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

package/dist/build.js

@@ -3381,6 +3381,100 @@ var init_svelteServerModule = __esm(() => {
   });
 });
 
+// src/core/vueServerModule.ts
+import { mkdir as mkdir2 } from "fs/promises";
+import { dirname as dirname4, join as join7, relative as relative5, resolve as resolve8 } from "path";
+var {Transpiler } = globalThis.Bun;
+var ISLAND_COMPONENT_ID_LENGTH = 8, serverCacheRoot2, compiledModuleCache2, transpiler2, ensureRelativeImportPath2 = (from, target) => {
+  const importPath = relative5(dirname4(from), target).replace(/\\/g, "/");
+  return importPath.startsWith(".") ? importPath : `./${importPath}`;
+}, getCachedModulePath2 = (sourcePath) => {
+  const relativeSourcePath = relative5(process.cwd(), sourcePath).replace(/\\/g, "/");
+  const normalizedSourcePath = relativeSourcePath.startsWith("..") ? sourcePath.replace(/[:\\/]/g, "_") : relativeSourcePath;
+  return join7(serverCacheRoot2, `${normalizedSourcePath}.server.js`);
+}, writeIfChanged2 = async (path, content) => {
+  const targetFile = Bun.file(path);
+  if (await targetFile.exists()) {
+    const currentContent = await targetFile.text();
+    if (currentContent === content)
+      return;
+  }
+  await Bun.write(path, content);
+}, stripExports = (code) => code.replace(/export\s+default/, "const script ="), mergeVueImports = (code) => {
+  const lines = code.split(`
+`);
+  const specifierSet = new Set;
+  const vueImportRegex = /^import\s+{([^}]+)}\s+from\s+['"]vue['"];?$/;
+  lines.forEach((line) => {
+    const match = line.match(vueImportRegex);
+    if (match?.[1])
+      match[1].split(",").forEach((importSpecifier) => specifierSet.add(importSpecifier.trim()));
+  });
+  const nonVueLines = lines.filter((line) => !vueImportRegex.test(line));
+  return specifierSet.size ? [
+    `import { ${[...specifierSet].join(", ")} } from "vue";`,
+    ...nonVueLines
+  ].join(`
+`) : nonVueLines.join(`
+`);
+}, extractRelativeVueImports = (sourceCode) => Array.from(sourceCode.matchAll(/import\s+[\s\S]+?['"]([^'"]+)['"]/g)).map((match) => match[1]).filter((importPath) => typeof importPath === "string" && importPath.startsWith(".") && importPath.endsWith(".vue")), compileVueServerModule = async (sourcePath) => {
+  const cachedModulePath = compiledModuleCache2.get(sourcePath);
+  if (cachedModulePath)
+    return cachedModulePath;
+  const compiler = await import("@vue/compiler-sfc");
+  const source = await Bun.file(sourcePath).text();
+  const { descriptor } = compiler.parse(source, { filename: sourcePath });
+  const componentId = Bun.hash(sourcePath).toString(BASE_36_RADIX).slice(0, ISLAND_COMPONENT_ID_LENGTH);
+  const hasScript = descriptor.script || descriptor.scriptSetup;
+  const compiledScript = hasScript ? compiler.compileScript(descriptor, {
+    id: componentId,
+    inlineTemplate: false
+  }) : { bindings: {}, content: "export default {};" };
+  const renderCode = descriptor.template ? compiler.compileTemplate({
+    compilerOptions: {
+      bindingMetadata: compiledScript.bindings,
+      expressionPlugins: ["typescript"],
+      prefixIdentifiers: true,
+      isCustomElement: (tag) => tag === "absolute-island"
+    },
+    filename: sourcePath,
+    id: componentId,
+    scoped: descriptor.styles.some((styleBlock) => styleBlock.scoped),
+    source: descriptor.template.content,
+    ssr: true,
+    ssrCssVars: descriptor.cssVars
+  }).code : "const ssrRender = () => {};";
+  const childImportPaths = extractRelativeVueImports(compiledScript.content);
+  const compiledChildren = await Promise.all(childImportPaths.map(async (relativeImport) => ({
+    compiledPath: await compileVueServerModule(resolve8(dirname4(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(dirname4(compiledModulePath), { recursive: true });
+  await writeIfChanged2(compiledModulePath, rewritten);
+  compiledModuleCache2.set(sourcePath, compiledModulePath);
+  return compiledModulePath;
+};
+var init_vueServerModule = __esm(() => {
+  init_constants();
+  serverCacheRoot2 = join7(process.cwd(), ".absolutejs", "islands", "vue");
+  compiledModuleCache2 = new Map;
+  transpiler2 = new Transpiler({ loader: "ts", target: "browser" });
+});
+
 // src/core/islandMarkupAttributes.ts
 var getIslandMarkerAttributes = (props, islandId) => ({
   "data-component": props.component,
@@ -3416,9 +3510,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];
@@ -3522,6 +3624,7 @@ var islandSequence = 0, resolvedServerComponentCache, resolvedServerBuildCompone
 var init_renderIslandMarkup = __esm(() => {
   init_islandSsr();
   init_svelteServerModule();
+  init_vueServerModule();
   init_islandMarkupAttributes();
   init_islands();
   resolvedServerComponentCache = new Map;
@@ -8752,7 +8855,7 @@ __export(exports_tailwindCompiler, {
 import { createHash as createHash2 } from "crypto";
 import { existsSync as existsSync8, readFileSync as readFileSync5 } from "fs";
 import { readFile as readFile2, stat } from "fs/promises";
-import { dirname as dirname4, isAbsolute as isAbsolute2, resolve as resolve8 } from "path";
+import { dirname as dirname5, isAbsolute as isAbsolute2, resolve as resolve9 } from "path";
 var compilerCache, cachedTailwindCompile = null, loadTailwindCompile = async () => {
   if (cachedTailwindCompile)
     return cachedTailwindCompile;
@@ -8783,7 +8886,7 @@ var compilerCache, cachedTailwindCompile = null, loadTailwindCompile = async ()
   } catch {
     return Bun.resolveSync(id, base);
   }
-  const pkgDir = dirname4(pkgJsonPath);
+  const pkgDir = dirname5(pkgJsonPath);
   let pkg = {};
   try {
     pkg = JSON.parse(readFileSync5(pkgJsonPath, "utf-8"));
@@ -8799,29 +8902,29 @@ var compilerCache, cachedTailwindCompile = null, loadTailwindCompile = async ()
     "dist/index.css"
   ].filter((entry) => typeof entry === "string");
   for (const candidate of candidates) {
-    const candidatePath = resolve8(pkgDir, candidate);
+    const candidatePath = resolve9(pkgDir, candidate);
     if (existsSync8(candidatePath))
       return candidatePath;
   }
   return Bun.resolveSync(id, base);
 }, createLoadStylesheet = (deps) => async (id, base) => {
-  const path = id.startsWith(".") || isAbsolute2(id) ? resolve8(base, id) : resolveBareCssImport(id, base);
+  const path = id.startsWith(".") || isAbsolute2(id) ? resolve9(base, id) : resolveBareCssImport(id, base);
   const content = await readFile2(path, "utf-8");
   await recordDependency(deps, path);
-  return { base: dirname4(path), content, path };
+  return { base: dirname5(path), content, path };
 }, loadModule = async (id, base, _kind) => {
-  const path = id.startsWith(".") || isAbsolute2(id) ? resolve8(base, id) : Bun.resolveSync(id, base);
+  const path = id.startsWith(".") || isAbsolute2(id) ? resolve9(base, id) : Bun.resolveSync(id, base);
   const module = await import(path);
-  return { base: dirname4(path), module, path };
+  return { base: dirname5(path), module, path };
 }, buildCompilerEntry = async (cssPath) => {
   const compile = await loadTailwindCompile();
-  const absPath = resolve8(cssPath);
+  const absPath = resolve9(cssPath);
   const css = await readFile2(absPath, "utf-8");
   const cssMtimeMs = (await stat(absPath)).mtimeMs;
   const cssDependencies = new Map;
   cssDependencies.set(absPath, cssMtimeMs);
   const compiler = await compile(css, {
-    base: dirname4(absPath),
+    base: dirname5(absPath),
     loadModule,
     loadStylesheet: createLoadStylesheet(cssDependencies)
   });
@@ -8844,11 +8947,11 @@ var compilerCache, cachedTailwindCompile = null, loadTailwindCompile = async ()
 }, hashCss = (css) => createHash2("sha1").update(css).digest("hex"), fileMatchesSources = (file, sources) => {
   if (sources.length === 0)
     return true;
-  const absFile = resolve8(file);
+  const absFile = resolve9(file);
   for (const source of sources) {
     if (source.negated)
       continue;
-    const absolutePattern = resolve8(source.base, source.pattern);
+    const absolutePattern = resolve9(source.base, source.pattern);
     if (!/[*?{[]/.test(absolutePattern)) {
       if (absolutePattern === absFile)
         return true;
@@ -8893,7 +8996,7 @@ var compilerCache, cachedTailwindCompile = null, loadTailwindCompile = async ()
   const seen = new Set;
   const collected = [];
   const scans = sources.filter((source) => !source.negated).map(async (source) => {
-    const absolutePattern = resolve8(source.base, source.pattern);
+    const absolutePattern = resolve9(source.base, source.pattern);
     const { glob: relativePattern, root } = splitGlobAtFirstMeta(absolutePattern);
     if (!relativePattern) {
       try {
@@ -8905,12 +9008,12 @@ var compilerCache, cachedTailwindCompile = null, loadTailwindCompile = async ()
     }
     const glob = new Bun.Glob(relativePattern);
     const matches = [];
-    for await (const relative5 of glob.scan({
+    for await (const relative6 of glob.scan({
       absolute: false,
       cwd: root,
       onlyFiles: true
     })) {
-      matches.push(resolve8(root, relative5));
+      matches.push(resolve9(root, relative6));
     }
     return matches;
   });
@@ -8942,7 +9045,7 @@ var compilerCache, cachedTailwindCompile = null, loadTailwindCompile = async ()
   const results = await Promise.all(checks);
   return results.some(Boolean);
 }, getCompilerEntry = async (cssPath) => {
-  const key = resolve8(cssPath);
+  const key = resolve9(cssPath);
   const cached = compilerCache.get(key);
   if (cached && !await isCompilerStale(cached))
     return cached;
@@ -8955,14 +9058,14 @@ var compilerCache, cachedTailwindCompile = null, loadTailwindCompile = async ()
     compilerCache.clear();
     return;
   }
-  compilerCache.delete(resolve8(cssPath));
+  compilerCache.delete(resolve9(cssPath));
 }, incrementalTailwindBuild = async (tailwind, buildPath, changedFiles, styleTransformConfig) => {
   const startedAt = performance.now();
   const entry = await getCompilerEntry(tailwind.input);
   const inputAbs = entry.cssPath;
   const filesToRescan = [];
   for (const file of changedFiles) {
-    const abs = resolve8(file);
+    const abs = resolve9(file);
     if (abs === inputAbs)
       continue;
     if (!fileMatchesSources(abs, entry.sources))
@@ -8971,7 +9074,7 @@ var compilerCache, cachedTailwindCompile = null, loadTailwindCompile = async ()
   }
   await Promise.all(filesToRescan.map((file) => ingestFile(entry, file)));
   const rawCss = entry.compiler.build([...entry.candidateCounts.keys()]);
-  const outputPath = resolve8(buildPath, tailwind.output);
+  const outputPath = resolve9(buildPath, tailwind.output);
   const finalCss = await compileStyleSource(outputPath, rawCss, "css", styleTransformConfig);
   const hash = hashCss(finalCss);
   const durationMs = performance.now() - startedAt;
@@ -8991,11 +9094,11 @@ var init_tailwindCompiler = __esm(() => {
 });
 
 // src/build/compileTailwind.ts
-import { mkdir as mkdir2 } from "fs/promises";
-import { dirname as dirname5, join as join7 } from "path";
+import { mkdir as mkdir3 } from "fs/promises";
+import { dirname as dirname6, join as join8 } from "path";
 var TAILWIND_CANDIDATE_EXTENSION_PATTERN, isTailwindCandidate = (filePath) => TAILWIND_CANDIDATE_EXTENSION_PATTERN.test(filePath), compileTailwind = async (input, output, buildPath, styleTransformConfig) => {
-  const outputPath = join7(buildPath, output);
-  await mkdir2(dirname5(outputPath), { recursive: true });
+  const outputPath = join8(buildPath, output);
+  await mkdir3(dirname6(outputPath), { recursive: true });
   await incrementalTailwindBuild({ input, output }, buildPath, [], styleTransformConfig);
 }, compileTailwindConfig = async (tailwind, buildPath, styleTransformConfig) => compileTailwind(tailwind.input, tailwind.output, buildPath, styleTransformConfig);
 var init_compileTailwind = __esm(() => {
@@ -9005,7 +9108,7 @@ var init_compileTailwind = __esm(() => {
 
 // src/utils/imageProcessing.ts
 import { existsSync as existsSync9, mkdirSync as mkdirSync3, readFileSync as readFileSync6, writeFileSync as writeFileSync3 } from "fs";
-import { join as join8, resolve as resolve9 } from "path";
+import { join as join9, resolve as resolve10 } from "path";
 var DEFAULT_DEVICE_SIZES, DEFAULT_IMAGE_SIZES, DEFAULT_QUALITY, OPTIMIZATION_ENDPOINT = "/_absolute/image", BLUR_DEVIATION = 20, sharpModule = undefined, sharpLoaded = false, sharpWarned = false, snapToSize = (target, sizes) => {
   for (const size of sizes) {
     if (size >= target)
@@ -9060,7 +9163,7 @@ var DEFAULT_DEVICE_SIZES, DEFAULT_IMAGE_SIZES, DEFAULT_QUALITY, OPTIMIZATION_END
   const image = config?.imageSizes ?? DEFAULT_IMAGE_SIZES;
   return [...device, ...image].sort((left, right) => left - right);
 }, getCacheDir = (buildDir) => {
-  const dir = join8(buildDir, ".cache", "images");
+  const dir = join9(buildDir, ".cache", "images");
   if (!existsSync9(dir))
     mkdirSync3(dir, { recursive: true });
   return dir;
@@ -9117,8 +9220,8 @@ var DEFAULT_DEVICE_SIZES, DEFAULT_IMAGE_SIZES, DEFAULT_QUALITY, OPTIMIZATION_END
       return toBuffer(buffer);
   }
 }, readFromCache = (cacheDir, cacheKey) => {
-  const metaPath = join8(cacheDir, `${cacheKey}.meta`);
-  const dataPath = join8(cacheDir, `${cacheKey}.data`);
+  const metaPath = join9(cacheDir, `${cacheKey}.meta`);
+  const dataPath = join9(cacheDir, `${cacheKey}.data`);
   if (!existsSync9(metaPath) || !existsSync9(dataPath))
     return null;
   try {
@@ -9133,7 +9236,7 @@ var DEFAULT_DEVICE_SIZES, DEFAULT_IMAGE_SIZES, DEFAULT_QUALITY, OPTIMIZATION_END
     return sharpModule;
   sharpLoaded = true;
   try {
-    const sharpPath = resolve9(process.cwd(), "node_modules/sharp");
+    const sharpPath = resolve10(process.cwd(), "node_modules/sharp");
     const mod = await import(sharpPath);
     sharpModule = mod.default ?? mod;
     return sharpModule;
@@ -9145,8 +9248,8 @@ var DEFAULT_DEVICE_SIZES, DEFAULT_IMAGE_SIZES, DEFAULT_QUALITY, OPTIMIZATION_END
     return null;
   }
 }, writeToCache = (cacheDir, cacheKey, buffer, meta) => {
-  const metaPath = join8(cacheDir, `${cacheKey}.meta`);
-  const dataPath = join8(cacheDir, `${cacheKey}.data`);
+  const metaPath = join9(cacheDir, `${cacheKey}.meta`);
+  const dataPath = join9(cacheDir, `${cacheKey}.data`);
   writeFileSync3(dataPath, buffer);
   writeFileSync3(metaPath, JSON.stringify(meta));
 };
@@ -9234,7 +9337,7 @@ var init_optimizeHtmlImages = __esm(() => {
 // src/cli/scripts/telemetry.ts
 import { existsSync as existsSync10, mkdirSync as mkdirSync4, readFileSync as readFileSync7, writeFileSync as writeFileSync4 } from "fs";
 import { homedir } from "os";
-import { join as join9 } from "path";
+import { join as join10 } from "path";
 var configDir, configPath, getTelemetryConfig = () => {
   try {
     if (!existsSync10(configPath))
@@ -9247,14 +9350,14 @@ var configDir, configPath, getTelemetryConfig = () => {
   }
 };
 var init_telemetry = __esm(() => {
-  configDir = join9(homedir(), ".absolutejs");
-  configPath = join9(configDir, "telemetry.json");
+  configDir = join10(homedir(), ".absolutejs");
+  configPath = join10(configDir, "telemetry.json");
 });
 
 // src/cli/telemetryEvent.ts
 import { existsSync as existsSync11, readFileSync as readFileSync8 } from "fs";
 import { arch, platform } from "os";
-import { dirname as dirname6, join as join10, parse } from "path";
+import { dirname as dirname7, join as join11, parse } from "path";
 var checkCandidate = (candidate) => {
   if (!existsSync11(candidate)) {
     return null;
@@ -9274,12 +9377,12 @@ var checkCandidate = (candidate) => {
 }, findPackageVersion = () => {
   let { dir } = import.meta;
   while (dir !== parse(dir).root) {
-    const candidate = join10(dir, "package.json");
+    const candidate = join11(dir, "package.json");
     const version = checkCandidate(candidate);
     if (version) {
       return version;
     }
-    dir = dirname6(dir);
+    dir = dirname7(dir);
   }
   return "unknown";
 }, sendTelemetryEvent = (event, payload) => {
@@ -9365,18 +9468,18 @@ var init_updateAssetPaths = __esm(() => {
 
 // src/dev/buildHMRClient.ts
 import { existsSync as existsSync12 } from "fs";
-import { resolve as resolve10 } from "path";
+import { resolve as resolve11 } from "path";
 var {build: bunBuild } = globalThis.Bun;
 var resolveHmrClientPath = () => {
   const projectRoot = process.cwd();
-  const fromSource = resolve10(import.meta.dir, "client/hmrClient.ts");
+  const fromSource = resolve11(import.meta.dir, "client/hmrClient.ts");
   if (existsSync12(fromSource) && fromSource.startsWith(projectRoot)) {
     return fromSource;
   }
-  const fromNodeModules = resolve10(projectRoot, "node_modules/@absolutejs/absolute/dist/dev/client/hmrClient.ts");
+  const fromNodeModules = resolve11(projectRoot, "node_modules/@absolutejs/absolute/dist/dev/client/hmrClient.ts");
   if (existsSync12(fromNodeModules))
     return fromNodeModules;
-  return resolve10(import.meta.dir, "dev/client/hmrClient.ts");
+  return resolve11(import.meta.dir, "dev/client/hmrClient.ts");
 }, hmrClientPath2, buildHMRClient = async () => {
   const entryPoint = hmrClientPath2;
   const result = await bunBuild({
@@ -9406,7 +9509,7 @@ var init_buildHMRClient = __esm(() => {
 // src/build/nativeRewrite.ts
 import { dlopen, FFIType, ptr } from "bun:ffi";
 import { platform as platform2, arch as arch2 } from "os";
-import { resolve as resolve11 } from "path";
+import { resolve as resolve12 } from "path";
 var ffiDefinition, nativeLib = null, loadNative = () => {
   if (nativeLib !== null)
     return nativeLib;
@@ -9424,7 +9527,7 @@ var ffiDefinition, nativeLib = null, loadNative = () => {
   if (!libPath)
     return null;
   try {
-    const fullPath = resolve11(import.meta.dir, "../../native/packages", libPath);
+    const fullPath = resolve12(import.meta.dir, "../../native/packages", libPath);
     const lib = dlopen(fullPath, ffiDefinition);
     nativeLib = lib.symbols;
     return nativeLib;
@@ -9570,7 +9673,7 @@ var devVendorPaths = null, getDevVendorPaths = () => devVendorPaths, setDevVendo
 
 // src/build/angularLinkerPlugin.ts
 import { existsSync as existsSync13, mkdirSync as mkdirSync5, readFileSync as readFileSync9, writeFileSync as writeFileSync5 } from "fs";
-import { dirname as dirname7, join as join11, relative as relative5, resolve as resolve12 } from "path";
+import { dirname as dirname8, join as join12, relative as relative6, resolve as resolve13 } from "path";
 import { createHash as createHash3 } from "crypto";
 var CACHE_ROOT, createAngularLinkerPlugin = (linkerJitMode) => ({
   name: "angular-linker",
@@ -9578,7 +9681,7 @@ var CACHE_ROOT, createAngularLinkerPlugin = (linkerJitMode) => ({
     let needsLinking;
     let babelTransform;
     let linkerPlugin;
-    const cacheDir = join11(CACHE_ROOT, linkerJitMode ? "jit" : "aot");
+    const cacheDir = join12(CACHE_ROOT, linkerJitMode ? "jit" : "aot");
     bld.onLoad({ filter: /[\\/]@angular[\\/].*\.m?js$/ }, async (args) => {
       const source = await Bun.file(args.path).text();
       if (!needsLinking) {
@@ -9591,7 +9694,7 @@ var CACHE_ROOT, createAngularLinkerPlugin = (linkerJitMode) => ({
         return;
       }
       const hash = createHash3("md5").update(source).digest("hex");
-      const cachePath = join11(cacheDir, `${hash}.js`);
+      const cachePath = join12(cacheDir, `${hash}.js`);
       if (existsSync13(cachePath)) {
         return {
           contents: readFileSync9(cachePath, "utf-8"),
@@ -9608,11 +9711,11 @@ var CACHE_ROOT, createAngularLinkerPlugin = (linkerJitMode) => ({
         const mod = await import(linkerSpecifier);
         linkerPlugin = mod.createEs2015LinkerPlugin({
           fileSystem: {
-            dirname: dirname7,
+            dirname: dirname8,
             exists: existsSync13,
             readFile: readFileSync9,
-            relative: relative5,
-            resolve: resolve12
+            relative: relative6,
+            resolve: resolve13
           },
           linkerJitMode,
           logger: {
@@ -9643,7 +9746,7 @@ var CACHE_ROOT, createAngularLinkerPlugin = (linkerJitMode) => ({
   }
 }), angularLinkerPlugin;
 var init_angularLinkerPlugin = __esm(() => {
-  CACHE_ROOT = resolve12(".absolutejs", "cache", "angular-linker");
+  CACHE_ROOT = resolve13(".absolutejs", "cache", "angular-linker");
   angularLinkerPlugin = createAngularLinkerPlugin(false);
 });
 
@@ -9654,7 +9757,7 @@ __export(exports_hmrInjectionPlugin, {
   applyAngularHmrInjection: () => applyAngularHmrInjection
 });
 import { readFile as readFile5 } from "fs/promises";
-import { relative as relative6, resolve as resolve13 } from "path";
+import { relative as relative7, resolve as resolve14 } from "path";
 var ENTITY_DECORATOR_RE, IMPORT_RE, TOP_LEVEL_DECL_RE, extractAllTopLevelNames = (jsSource) => {
   const names = new Set;
   IMPORT_RE.lastIndex = 0;
@@ -9817,7 +9920,7 @@ var ENTITY_DECORATOR_RE, IMPORT_RE, TOP_LEVEL_DECL_RE, extractAllTopLevelNames =
 }
 `, applyAngularHmrInjection = (jsSource, componentJsAbsPath, params) => {
   const { generatedAngularRoot, userAngularRoot, projectRoot } = params;
-  const normalizedGenRoot = resolve13(generatedAngularRoot).replace(/\\/g, "/");
+  const normalizedGenRoot = resolve14(generatedAngularRoot).replace(/\\/g, "/");
   const normalizedPath = componentJsAbsPath.replace(/\\/g, "/");
   if (!normalizedPath.startsWith(normalizedGenRoot + "/"))
     return;
@@ -9834,9 +9937,9 @@ var ENTITY_DECORATOR_RE, IMPORT_RE, TOP_LEVEL_DECL_RE, extractAllTopLevelNames =
   }
   if (classNames.length === 0)
     return;
-  const relFromGenRoot = relative6(generatedAngularRoot, componentJsAbsPath).replace(/\\/g, "/");
-  const userTsPath = resolve13(userAngularRoot, relFromGenRoot.replace(/\.js$/, ".ts"));
-  const projectRel = relative6(projectRoot, userTsPath).replace(/\\/g, "/");
+  const relFromGenRoot = relative7(generatedAngularRoot, componentJsAbsPath).replace(/\\/g, "/");
+  const userTsPath = resolve14(userAngularRoot, relFromGenRoot.replace(/\.js$/, ".ts"));
+  const projectRel = relative7(projectRoot, userTsPath).replace(/\\/g, "/");
   const tail = classNames.map((className) => {
     const id = `${projectRel}@${className}`;
     return buildHmrTail(className, JSON.stringify(id));
@@ -9870,17 +9973,17 @@ var init_hmrInjectionPlugin = __esm(() => {
 
 // src/utils/cleanStaleOutputs.ts
 import { rm as rm2 } from "fs/promises";
-import { resolve as resolve14 } from "path";
+import { resolve as resolve15 } from "path";
 var {Glob: Glob5 } = globalThis.Bun;
 var HASHED_FILE_PATTERN, cleanStaleOutputs = async (buildPath, currentOutputPaths) => {
-  const currentPaths = new Set(currentOutputPaths.map((path) => resolve14(path)));
+  const currentPaths = new Set(currentOutputPaths.map((path) => resolve15(path)));
   const glob = new Glob5("**/*");
   const removals = [];
-  for (const relative7 of glob.scanSync({ cwd: buildPath })) {
-    const absolute = resolve14(buildPath, relative7);
+  for (const relative8 of glob.scanSync({ cwd: buildPath })) {
+    const absolute = resolve15(buildPath, relative8);
     if (currentPaths.has(absolute))
       continue;
-    if (!HASHED_FILE_PATTERN.test(relative7))
+    if (!HASHED_FILE_PATTERN.test(relative8))
       continue;
     removals.push(rm2(absolute, { force: true }));
   }
@@ -9896,20 +9999,20 @@ __export(exports_generatedDir, {
   getGeneratedRoot: () => getGeneratedRoot,
   getFrameworkGeneratedDir: () => getFrameworkGeneratedDir
 });
-import { join as join12 } from "path";
-var GENERATED_DIR_NAME = "generated", ABSOLUTE_CACHE_DIR_NAME = ".absolutejs", getGeneratedRoot = (projectRoot = process.cwd()) => join12(projectRoot, ABSOLUTE_CACHE_DIR_NAME, GENERATED_DIR_NAME), getFrameworkGeneratedDir = (framework, projectRoot = process.cwd()) => join12(getGeneratedRoot(projectRoot), framework);
+import { join as join13 } from "path";
+var GENERATED_DIR_NAME = "generated", ABSOLUTE_CACHE_DIR_NAME = ".absolutejs", getGeneratedRoot = (projectRoot = process.cwd()) => join13(projectRoot, ABSOLUTE_CACHE_DIR_NAME, GENERATED_DIR_NAME), getFrameworkGeneratedDir = (framework, projectRoot = process.cwd()) => join13(getGeneratedRoot(projectRoot), framework);
 var init_generatedDir = () => {};
 
 // src/utils/cleanup.ts
 import { rm as rm3 } from "fs/promises";
-import { join as join13 } from "path";
+import { join as join14 } from "path";
 var removeIfExists = (path) => rm3(path, { force: true, recursive: true }), cleanFramework = (framework, frameworkDir, skipGenerated = false) => {
   const tasks = [];
   if (!skipGenerated) {
     tasks.push(removeIfExists(getFrameworkGeneratedDir(framework)));
   }
   if (frameworkDir)
-    tasks.push(removeIfExists(join13(frameworkDir, "generated")));
+    tasks.push(removeIfExists(join14(frameworkDir, "generated")));
   return Promise.all(tasks);
 }, cleanup = async ({
   angularDir,
@@ -9948,7 +10051,7 @@ var init_commonAncestor = () => {};
 
 // src/utils/buildDirectoryLock.ts
 import { mkdirSync as mkdirSync6, unlinkSync, writeFileSync as writeFileSync6, readFileSync as readFileSync10 } from "fs";
-import { dirname as dirname8, join as join14 } from "path";
+import { dirname as dirname9, join as join15 } from "path";
 var heldLocks, HELD_LOCKS_ENV = "ABSOLUTE_HELD_BUILD_DIRECTORY_LOCKS", exitHandlersRegistered = false, registerExitHandlersOnce = () => {
   if (exitHandlersRegistered)
     return;
@@ -9974,7 +10077,7 @@ var heldLocks, HELD_LOCKS_ENV = "ABSOLUTE_HELD_BUILD_DIRECTORY_LOCKS", exitHandl
     releaseAllSync();
     throw err;
   });
-}, isAlreadyExistsError = (error) => error instanceof Error && ("code" in error) && error.code === "EEXIST", lockPathForBuildDirectory = (buildDirectory) => join14(dirname8(buildDirectory), ".absolutejs", "build.lock"), readHeldLockEnv = () => new Set((process.env[HELD_LOCKS_ENV] ?? "").split(`
+}, isAlreadyExistsError = (error) => error instanceof Error && ("code" in error) && error.code === "EEXIST", lockPathForBuildDirectory = (buildDirectory) => join15(dirname9(buildDirectory), ".absolutejs", "build.lock"), readHeldLockEnv = () => new Set((process.env[HELD_LOCKS_ENV] ?? "").split(`
 `).filter((entry) => entry.length > 0)), writeHeldLockEnv = (locks) => {
   if (locks.size === 0) {
     delete process.env[HELD_LOCKS_ENV];
@@ -9991,7 +10094,7 @@ var heldLocks, HELD_LOCKS_ENV = "ABSOLUTE_HELD_BUILD_DIRECTORY_LOCKS", exitHandl
   locks.delete(buildDirectory);
   writeHeldLockEnv(locks);
 }, writeLockFileSync = (lockPath, metadata) => {
-  mkdirSync6(dirname8(lockPath), { recursive: true });
+  mkdirSync6(dirname9(lockPath), { recursive: true });
   writeFileSync6(lockPath, JSON.stringify(metadata, null, 2), { flag: "wx" });
 }, readLockMetadata = (lockPath) => {
   try {
@@ -10111,11 +10214,11 @@ var init_buildDirectoryLock = __esm(() => {
 });
 
 // src/utils/validateSafePath.ts
-import { resolve as resolve15, relative as relative7 } from "path";
+import { resolve as resolve16, relative as relative8 } from "path";
 var validateSafePath = (targetPath, baseDirectory) => {
-  const absoluteBase = resolve15(baseDirectory);
-  const absoluteTarget = resolve15(baseDirectory, targetPath);
-  const relativePath = normalizePath(relative7(absoluteBase, absoluteTarget));
+  const absoluteBase = resolve16(baseDirectory);
+  const absoluteTarget = resolve16(baseDirectory, targetPath);
+  const relativePath = normalizePath(relative8(absoluteBase, absoluteTarget));
   if (relativePath.startsWith("../") || relativePath === "..") {
     throw new Error(`Unsafe path: ${targetPath}`);
   }
@@ -10263,32 +10366,32 @@ __export(exports_compileSvelte, {
   clearSvelteCompilerCache: () => clearSvelteCompilerCache
 });
 import { existsSync as existsSync14 } from "fs";
-import { mkdir as mkdir3, stat as stat2 } from "fs/promises";
+import { mkdir as mkdir4, stat as stat2 } from "fs/promises";
 import {
-  dirname as dirname9,
-  join as join15,
+  dirname as dirname10,
+  join as join16,
   basename as basename4,
   extname as extname5,
-  resolve as resolve16,
-  relative as relative8,
+  resolve as resolve17,
+  relative as relative9,
   sep as sep2
 } from "path";
 import { env } from "process";
-var {write, file, Transpiler } = globalThis.Bun;
+var {write, file, Transpiler: Transpiler2 } = globalThis.Bun;
 var resolveDevClientDir2 = () => {
   const projectRoot = process.cwd();
-  const fromSource = resolve16(import.meta.dir, "../dev/client");
+  const fromSource = resolve17(import.meta.dir, "../dev/client");
   if (existsSync14(fromSource) && fromSource.startsWith(projectRoot)) {
     return fromSource;
   }
-  const fromNodeModules = resolve16(projectRoot, "node_modules/@absolutejs/absolute/dist/dev/client");
+  const fromNodeModules = resolve17(projectRoot, "node_modules/@absolutejs/absolute/dist/dev/client");
   if (existsSync14(fromNodeModules))
     return fromNodeModules;
-  return resolve16(import.meta.dir, "./dev/client");
+  return resolve17(import.meta.dir, "./dev/client");
 }, devClientDir2, hmrClientPath3, persistentCache, sourceHashCache, clearSvelteCompilerCache = () => {
   persistentCache.clear();
   sourceHashCache.clear();
-}, transpiler2, removeUnusedRequireHelper = (code) => {
+}, transpiler3, removeUnusedRequireHelper = (code) => {
   const helperStart = code.indexOf("var __require = /* @__PURE__ */");
   if (helperStart === -1) {
     return code;
@@ -10314,7 +10417,7 @@ var resolveDevClientDir2 = () => {
 }, resolveRelativeModule2 = async (spec, from) => {
   if (!spec.startsWith("."))
     return null;
-  const basePath = resolve16(dirname9(from), spec);
+  const basePath = resolve17(dirname10(from), spec);
   const candidates = [
     basePath,
     `${basePath}.ts`,
@@ -10325,14 +10428,14 @@ var resolveDevClientDir2 = () => {
     `${basePath}.svelte`,
     `${basePath}.svelte.ts`,
     `${basePath}.svelte.js`,
-    join15(basePath, "index.ts"),
-    join15(basePath, "index.js"),
-    join15(basePath, "index.mjs"),
-    join15(basePath, "index.cjs"),
-    join15(basePath, "index.json"),
-    join15(basePath, "index.svelte"),
-    join15(basePath, "index.svelte.ts"),
-    join15(basePath, "index.svelte.js")
+    join16(basePath, "index.ts"),
+    join16(basePath, "index.js"),
+    join16(basePath, "index.mjs"),
+    join16(basePath, "index.cjs"),
+    join16(basePath, "index.json"),
+    join16(basePath, "index.svelte"),
+    join16(basePath, "index.svelte.ts"),
+    join16(basePath, "index.svelte.js")
   ];
   const checks = await Promise.all(candidates.map(exists));
   return candidates.find((_2, index) => checks[index]) ?? null;
@@ -10341,7 +10444,7 @@ var resolveDevClientDir2 = () => {
     const resolved = resolvePackageImport(spec);
     return resolved && /\.svelte(\.(?:ts|js))?$/.test(resolved) ? resolved : null;
   }
-  const basePath = resolve16(dirname9(from), spec);
+  const basePath = resolve17(dirname10(from), spec);
   const explicit = /\.(svelte|svelte\.(?:ts|js))$/.test(basePath);
   if (!explicit) {
     const extensions = [".svelte", ".svelte.ts", ".svelte.js"];
@@ -10362,8 +10465,8 @@ var resolveDevClientDir2 = () => {
     return jsPath;
   return null;
 }, addModuleRewrite = (rewrites, rawSpec, resolvedModule, ssrOutputDir, clientOutputDir) => {
-  const toServer = relative8(ssrOutputDir, resolvedModule).replace(/\\/g, "/");
-  const toClient = relative8(clientOutputDir, resolvedModule).replace(/\\/g, "/");
+  const toServer = relative9(ssrOutputDir, resolvedModule).replace(/\\/g, "/");
+  const toClient = relative9(clientOutputDir, resolvedModule).replace(/\\/g, "/");
   rewrites.set(rawSpec, {
     client: toClient.startsWith(".") || toClient.startsWith("/") ? toClient : `./${toClient}`,
     server: toServer.startsWith(".") ? toServer : `./${toServer}`
@@ -10371,10 +10474,10 @@ var resolveDevClientDir2 = () => {
 }, compileSvelte = async (entryPoints, svelteRoot, cache = new Map, isDev = false, stylePreprocessors) => {
   const { compile, compileModule, preprocess } = await import("svelte/compiler");
   const generatedDir = getFrameworkGeneratedDir("svelte");
-  const clientDir = join15(generatedDir, "client");
-  const indexDir = join15(generatedDir, "indexes");
-  const serverDir = join15(generatedDir, "server");
-  await Promise.all([clientDir, indexDir, serverDir].map((dir) => mkdir3(dir, { recursive: true })));
+  const clientDir = join16(generatedDir, "client");
+  const indexDir = join16(generatedDir, "indexes");
+  const serverDir = join16(generatedDir, "server");
+  await Promise.all([clientDir, indexDir, serverDir].map((dir) => mkdir4(dir, { recursive: true })));
   const dev = env.NODE_ENV !== "production";
   const build = async (src) => {
     const memoized = cache.get(src);
@@ -10399,10 +10502,10 @@ var resolveDevClientDir2 = () => {
     const svelteStylePreprocessor = createSvelteStylePreprocessor(stylePreprocessors);
     const preprocessedServer = isModule ? loweredServerSource.code : (await preprocess(loweredServerSource.code, svelteStylePreprocessor)).code;
     const preprocessedClient = isModule ? loweredClientSource.code : (await preprocess(loweredClientSource.code, svelteStylePreprocessor)).code;
-    const transpiledServer = src.endsWith(".ts") || src.endsWith(".svelte.ts") ? transpiler2.transformSync(preprocessedServer) : preprocessedServer;
-    const transpiledClient = src.endsWith(".ts") || src.endsWith(".svelte.ts") ? transpiler2.transformSync(preprocessedClient) : preprocessedClient;
-    const rawRel = dirname9(relative8(svelteRoot, src)).replace(/\\/g, "/");
-    const relDir = rawRel.startsWith("..") ? `_ext/${relative8(process.cwd(), dirname9(src)).replace(/\\/g, "/")}` : rawRel;
+    const transpiledServer = src.endsWith(".ts") || src.endsWith(".svelte.ts") ? transpiler3.transformSync(preprocessedServer) : preprocessedServer;
+    const transpiledClient = src.endsWith(".ts") || src.endsWith(".svelte.ts") ? transpiler3.transformSync(preprocessedClient) : preprocessedClient;
+    const rawRel = dirname10(relative9(svelteRoot, src)).replace(/\\/g, "/");
+    const relDir = rawRel.startsWith("..") ? `_ext/${relative9(process.cwd(), dirname10(src)).replace(/\\/g, "/")}` : rawRel;
     const baseName = basename4(src).replace(/\.svelte(\.(ts|js))?$/, "");
     const importPaths = Array.from(transpiledServer.matchAll(/from\s+['"]([^'"]+)['"]/g)).map((match) => match[1]).filter((path) => path !== undefined);
     const resolvedModuleImports = await Promise.all(importPaths.map((importPath) => resolveRelativeModule2(importPath, src)));
@@ -10411,8 +10514,8 @@ var resolveDevClientDir2 = () => {
     const childBuilt = await Promise.all(childSources.map((child) => build(child)));
     const hasAwaitSlotFromChildren = childBuilt.some((child) => child.hasAwaitSlot);
     const externalRewrites = new Map;
-    const ssrOutputDir = dirname9(join15(serverDir, relDir, `${baseName}.js`));
-    const clientOutputDir = dirname9(join15(clientDir, relDir, `${baseName}.js`));
+    const ssrOutputDir = dirname10(join16(serverDir, relDir, `${baseName}.js`));
+    const clientOutputDir = dirname10(join16(clientDir, relDir, `${baseName}.js`));
     for (let idx = 0;idx < importPaths.length; idx++) {
       const rawSpec = importPaths[idx];
       if (!rawSpec)
@@ -10423,15 +10526,15 @@ var resolveDevClientDir2 = () => {
         addModuleRewrite(externalRewrites, rawSpec, resolvedModule, ssrOutputDir, clientOutputDir);
       if (!resolved)
         continue;
-      const childRel = relative8(svelteRoot, resolved).replace(/\\/g, "/");
+      const childRel = relative9(svelteRoot, resolved).replace(/\\/g, "/");
       if (!childRel.startsWith(".."))
         continue;
       const childBuilt2 = cache.get(resolved);
       if (!childBuilt2)
         continue;
       const origSpec = rawSpec.replace(/\.svelte(?:\.(?:ts|js))?$/, ".js");
-      const toServer = relative8(ssrOutputDir, childBuilt2.ssr).replace(/\\/g, "/");
-      const toClient = relative8(clientOutputDir, childBuilt2.client).replace(/\\/g, "/");
+      const toServer = relative9(ssrOutputDir, childBuilt2.ssr).replace(/\\/g, "/");
+      const toClient = relative9(clientOutputDir, childBuilt2.client).replace(/\\/g, "/");
       externalRewrites.set(origSpec, {
         client: toClient.startsWith(".") ? toClient : `./${toClient}`,
         server: toServer.startsWith(".") ? toServer : `./${toServer}`
@@ -10465,7 +10568,7 @@ var resolveDevClientDir2 = () => {
       }).js.code;
       let code = compiled.replace(/\.svelte(?:\.(?:ts|js))?(['"])/g, ".js$1");
       if (mode === "client" && isDev) {
-        const moduleKey = `/@src/${relative8(process.cwd(), src).replace(/\\/g, "/")}`;
+        const moduleKey = `/@src/${relative9(process.cwd(), src).replace(/\\/g, "/")}`;
         code = code.replace(/if\s*\(import\.meta\.hot\)\s*\{/, `if (typeof window !== "undefined") {
   if (!window.__SVELTE_HMR_ACCEPT__) window.__SVELTE_HMR_ACCEPT__ = {};
   var __hmr_accept = function(cb) { window.__SVELTE_HMR_ACCEPT__[${JSON.stringify(moduleKey)}] = cb; };`);
@@ -10477,11 +10580,11 @@ var resolveDevClientDir2 = () => {
       code += islandMetadataExports;
       return code;
     };
-    const ssrPath = join15(serverDir, relDir, `${baseName}.js`);
-    const clientPath = join15(clientDir, relDir, `${baseName}.js`);
+    const ssrPath = join16(serverDir, relDir, `${baseName}.js`);
+    const clientPath = join16(clientDir, relDir, `${baseName}.js`);
     await Promise.all([
-      mkdir3(dirname9(ssrPath), { recursive: true }),
-      mkdir3(dirname9(clientPath), { recursive: true })
+      mkdir4(dirname10(ssrPath), { recursive: true }),
+      mkdir4(dirname10(clientPath), { recursive: true })
     ]);
     if (isModule) {
       const bundle = rewriteExternalImports(generate("client"), "client");
@@ -10508,10 +10611,10 @@ var resolveDevClientDir2 = () => {
   };
   const roots = await Promise.all(entryPoints.map(build));
   await Promise.all(roots.map(async ({ client, hasAwaitSlot }) => {
-    const relClientDir = dirname9(relative8(clientDir, client));
+    const relClientDir = dirname10(relative9(clientDir, client));
     const name = basename4(client, extname5(client));
-    const indexPath = join15(indexDir, relClientDir, `${name}.js`);
-    const importRaw = relative8(dirname9(indexPath), client).split(sep2).join("/");
+    const indexPath = join16(indexDir, relClientDir, `${name}.js`);
+    const importRaw = relative9(dirname10(indexPath), client).split(sep2).join("/");
     const importPath = importRaw.startsWith(".") || importRaw.startsWith("/") ? importRaw : `./${importRaw}`;
     const hmrImports = isDev ? `window.__HMR_FRAMEWORK__ = "svelte";
 import "${hmrClientPath3}";
@@ -10582,14 +10685,14 @@ if (typeof window !== "undefined") {
     setTimeout(releaseStreamingSlots, 0);
   }
 }`;
-    await mkdir3(dirname9(indexPath), { recursive: true });
+    await mkdir4(dirname10(indexPath), { recursive: true });
     return write(indexPath, bootstrap);
   }));
   return {
     svelteClientPaths: roots.map(({ client }) => client),
     svelteIndexPaths: roots.map(({ client }) => {
-      const rel = dirname9(relative8(clientDir, client));
-      return join15(indexDir, rel, basename4(client));
+      const rel = dirname10(relative9(clientDir, client));
+      return join16(indexDir, rel, basename4(client));
     }),
     svelteServerPaths: roots.map(({ ssr }) => ssr)
   };
@@ -10604,10 +10707,10 @@ var init_compileSvelte = __esm(() => {
   init_lowerAwaitSlotSyntax();
   init_renderToReadableStream();
   devClientDir2 = resolveDevClientDir2();
-  hmrClientPath3 = join15(devClientDir2, "hmrClient.ts").replace(/\\/g, "/");
+  hmrClientPath3 = join16(devClientDir2, "hmrClient.ts").replace(/\\/g, "/");
   persistentCache = new Map;
   sourceHashCache = new Map;
-  transpiler2 = new Transpiler({ loader: "ts", target: "browser" });
+  transpiler3 = new Transpiler2({ loader: "ts", target: "browser" });
 });
 
 // src/build/vueAutoRouterTransform.ts
@@ -10671,27 +10774,27 @@ __export(exports_compileVue, {
   clearVueHmrCaches: () => clearVueHmrCaches
 });
 import { existsSync as existsSync15 } from "fs";
-import { mkdir as mkdir4 } from "fs/promises";
+import { mkdir as mkdir5 } from "fs/promises";
 import {
   basename as basename5,
-  dirname as dirname10,
+  dirname as dirname11,
   isAbsolute as isAbsolute3,
-  join as join16,
-  relative as relative9,
-  resolve as resolve17
+  join as join17,
+  relative as relative10,
+  resolve as resolve18
 } from "path";
-var {file: file2, write: write2, Transpiler: Transpiler2 } = globalThis.Bun;
+var {file: file2, write: write2, Transpiler: Transpiler3 } = globalThis.Bun;
 var resolveDevClientDir3 = () => {
   const projectRoot = process.cwd();
-  const fromSource = resolve17(import.meta.dir, "../dev/client");
+  const fromSource = resolve18(import.meta.dir, "../dev/client");
   if (existsSync15(fromSource) && fromSource.startsWith(projectRoot)) {
     return fromSource;
   }
-  const fromNodeModules = resolve17(projectRoot, "node_modules/@absolutejs/absolute/dist/dev/client");
+  const fromNodeModules = resolve18(projectRoot, "node_modules/@absolutejs/absolute/dist/dev/client");
   if (existsSync15(fromNodeModules))
     return fromNodeModules;
-  return resolve17(import.meta.dir, "./dev/client");
-}, devClientDir3, hmrClientPath4, transpiler3, scriptCache, scriptSetupCache, templateCache, styleCache, persistentBuildCache, vueSourceHashCache, vueHmrMetadata, clearVueHmrCaches = () => {
+  return resolve18(import.meta.dir, "./dev/client");
+}, devClientDir3, hmrClientPath4, transpiler4, scriptCache, scriptSetupCache, templateCache, styleCache, persistentBuildCache, vueSourceHashCache, vueHmrMetadata, clearVueHmrCaches = () => {
   scriptCache.clear();
   scriptSetupCache.clear();
   templateCache.clear();
@@ -10729,19 +10832,19 @@ var resolveDevClientDir3 = () => {
     return "template-only";
   }
   return "full";
-}, generateVueHmrId = (sourceFilePath, vueRootDir) => relative9(vueRootDir, sourceFilePath).replace(/\\/g, "/").replace(/\.vue$/, ""), extractImports = (sourceCode) => Array.from(sourceCode.matchAll(/import\s+[\s\S]+?['"]([^'"]+)['"]/g)).map((match) => match[1]).filter((importPath) => importPath !== undefined), toJs = (filePath, sourceDir) => {
+}, generateVueHmrId = (sourceFilePath, vueRootDir) => relative10(vueRootDir, sourceFilePath).replace(/\\/g, "/").replace(/\.vue$/, ""), extractImports = (sourceCode) => Array.from(sourceCode.matchAll(/import\s+[\s\S]+?['"]([^'"]+)['"]/g)).map((match) => match[1]).filter((importPath) => importPath !== undefined), toJs = (filePath, sourceDir) => {
   if (filePath.endsWith(".vue"))
     return filePath.replace(/\.vue$/, ".js");
   if (filePath.endsWith(".ts"))
     return filePath.replace(/\.ts$/, ".js");
   if (isStylePath(filePath)) {
     if (sourceDir && (filePath.startsWith("./") || filePath.startsWith("../"))) {
-      return resolve17(sourceDir, filePath);
+      return resolve18(sourceDir, filePath);
     }
     return filePath;
   }
   return `${filePath}.js`;
-}, stripExports = (code) => code.replace(/export\s+default/, "const script ="), mergeVueImports = (code) => {
+}, stripExports2 = (code) => code.replace(/export\s+default/, "const script ="), mergeVueImports2 = (code) => {
   const lines = code.split(`
 `);
   const specifierSet = new Set;
@@ -10762,7 +10865,7 @@ var resolveDevClientDir3 = () => {
   const cachedResult = cacheMap.get(sourceFilePath);
   if (cachedResult)
     return cachedResult;
-  const relativeFilePath = relative9(vueRootDir, sourceFilePath).replace(/\\/g, "/");
+  const relativeFilePath = relative10(vueRootDir, sourceFilePath).replace(/\\/g, "/");
   const relativeWithoutExtension = relativeFilePath.replace(/\.vue$/, "");
   const fileBaseName = basename5(sourceFilePath, ".vue");
   const componentId = toKebab(fileBaseName);
@@ -10800,12 +10903,12 @@ var resolveDevClientDir3 = () => {
   const childComponentPaths = importPaths.filter((path) => path.startsWith(".") && path.endsWith(".vue"));
   const packageComponentPaths = Array.from(resolvedPackageVueImports.entries());
   const helperModulePaths = importPaths.filter((path) => path.startsWith(".") && !path.endsWith(".vue") && !isStylePath(path));
-  const stylePathsImported = importPaths.filter((path) => (path.startsWith(".") || isAbsolute3(path)) && isStylePath(path)).map((path) => isAbsolute3(path) ? path : resolve17(dirname10(sourceFilePath), path));
+  const stylePathsImported = importPaths.filter((path) => (path.startsWith(".") || isAbsolute3(path)) && isStylePath(path)).map((path) => isAbsolute3(path) ? path : resolve18(dirname11(sourceFilePath), path));
   for (const stylePath of stylePathsImported) {
     addStyleImporter(sourceFilePath, stylePath);
   }
   const childBuildResults = await Promise.all([
-    ...childComponentPaths.map((relativeChildPath) => compileVueFile(resolve17(dirname10(sourceFilePath), relativeChildPath), outputDirs, cacheMap, false, vueRootDir, compiler, stylePreprocessors)),
+    ...childComponentPaths.map((relativeChildPath) => compileVueFile(resolve18(dirname11(sourceFilePath), relativeChildPath), outputDirs, cacheMap, false, vueRootDir, compiler, stylePreprocessors)),
     ...packageComponentPaths.map(([, absolutePath]) => compileVueFile(absolutePath, outputDirs, cacheMap, false, vueRootDir, compiler, stylePreprocessors))
   ]);
   const hasScript = descriptor.script || descriptor.scriptSetup;
@@ -10813,9 +10916,9 @@ var resolveDevClientDir3 = () => {
     id: componentId,
     inlineTemplate: false
   }) : { bindings: {}, content: "export default {};" };
-  const strippedScript = stripExports(compiledScript.content);
-  const sourceDir = dirname10(sourceFilePath);
-  const transpiledScript = transpiler3.transformSync(strippedScript).replace(/(['"])(\.{1,2}\/[^'"]+)(['"])/g, (_2, quoteStart, relativeImport, quoteEnd) => `${quoteStart}${toJs(relativeImport, sourceDir)}${quoteEnd}`);
+  const strippedScript = stripExports2(compiledScript.content);
+  const sourceDir = dirname11(sourceFilePath);
+  const transpiledScript = transpiler4.transformSync(strippedScript).replace(/(['"])(\.{1,2}\/[^'"]+)(['"])/g, (_2, quoteStart, relativeImport, quoteEnd) => `${quoteStart}${toJs(relativeImport, sourceDir)}${quoteEnd}`);
   const packageImportRewrites = new Map;
   for (const [bareImport, absolutePath] of packageComponentPaths) {
     const childResult = cacheMap.get(absolutePath);
@@ -10829,6 +10932,8 @@ var resolveDevClientDir3 = () => {
   const generateRenderFunction = (ssr) => compiler.compileTemplate({
     compilerOptions: {
       bindingMetadata: compiledScript.bindings,
+      expressionPlugins: ["typescript"],
+      isCustomElement: (tag) => tag === "absolute-island",
       prefixIdentifiers: true
     },
     filename: sourceFilePath,
@@ -10851,8 +10956,8 @@ var resolveDevClientDir3 = () => {
   ];
   let cssOutputPaths = [];
   if (isEntryPoint && allCss.length) {
-    const cssOutputFile = join16(outputDirs.css, `${toKebab(fileBaseName)}-compiled.css`);
-    await mkdir4(dirname10(cssOutputFile), { recursive: true });
+    const cssOutputFile = join17(outputDirs.css, `${toKebab(fileBaseName)}-compiled.css`);
+    await mkdir5(dirname11(cssOutputFile), { recursive: true });
     await write2(cssOutputFile, allCss.join(`
 `));
     cssOutputPaths = [cssOutputFile];
@@ -10870,7 +10975,7 @@ if (typeof __VUE_HMR_RUNTIME__ !== 'undefined') {
     window.__VUE_HMR_COMPONENTS__[script.__hmrId] = script;
   }
 }` : "";
-    return mergeVueImports([
+    return mergeVueImports2([
       transpiledScript,
       renderCode,
       `script.${renderFnName} = ${renderFnName};`,
@@ -10882,9 +10987,9 @@ if (typeof __VUE_HMR_RUNTIME__ !== 'undefined') {
   };
   const clientCode = assembleModule(generateRenderFunction(false), "render", true) + islandMetadataExports;
   const serverCode = assembleModule(generateRenderFunction(true), "ssrRender", false) + islandMetadataExports;
-  const clientOutputPath = join16(outputDirs.client, `${relativeWithoutExtension}.js`);
-  const serverOutputPath = join16(outputDirs.server, `${relativeWithoutExtension}.js`);
-  const relDir = dirname10(relativeFilePath);
+  const clientOutputPath = join17(outputDirs.client, `${relativeWithoutExtension}.js`);
+  const serverOutputPath = join17(outputDirs.server, `${relativeWithoutExtension}.js`);
+  const relDir = dirname11(relativeFilePath);
   const relDepth = relDir === "." ? 0 : relDir.split("/").length;
   const adjustImports = (code) => code.replace(/(from\s+['"])(\.\.\/(?:\.\.\/)*)/g, (_2, prefix, dots) => {
     const upCount = dots.split("/").length - 1;
@@ -10896,15 +11001,15 @@ if (typeof __VUE_HMR_RUNTIME__ !== 'undefined') {
     let result2 = code;
     for (const [bareImport, paths] of packageImportRewrites) {
       const targetPath = mode === "server" ? paths.server : paths.client;
-      let rel = relative9(dirname10(outputPath), targetPath).replace(/\\/g, "/");
+      let rel = relative10(dirname11(outputPath), targetPath).replace(/\\/g, "/");
       if (!rel.startsWith("."))
         rel = `./${rel}`;
       result2 = result2.replaceAll(bareImport, rel);
     }
     return result2;
   };
-  await mkdir4(dirname10(clientOutputPath), { recursive: true });
-  await mkdir4(dirname10(serverOutputPath), { recursive: true });
+  await mkdir5(dirname11(clientOutputPath), { recursive: true });
+  await mkdir5(dirname11(serverOutputPath), { recursive: true });
   await write2(clientOutputPath, rewritePackageImports(adjustImports(clientCode), clientOutputPath, "client"));
   await write2(serverOutputPath, rewritePackageImports(adjustImports(serverCode), serverOutputPath, "server"));
   const result = {
@@ -10914,7 +11019,7 @@ if (typeof __VUE_HMR_RUNTIME__ !== 'undefined') {
     hmrId,
     serverPath: serverOutputPath,
     tsHelperPaths: [
-      ...helperModulePaths.map((helper) => resolve17(dirname10(sourceFilePath), helper.endsWith(".ts") ? helper : `${helper}.ts`)),
+      ...helperModulePaths.map((helper) => resolve18(dirname11(sourceFilePath), helper.endsWith(".ts") ? helper : `${helper}.ts`)),
       ...childBuildResults.flatMap((child) => child.tsHelperPaths)
     ]
   };
@@ -10924,36 +11029,36 @@ if (typeof __VUE_HMR_RUNTIME__ !== 'undefined') {
 }, compileVue = async (entryPoints, vueRootDir, isDev = false, stylePreprocessors) => {
   const compiler = await import("@vue/compiler-sfc");
   const generatedDir = getFrameworkGeneratedDir("vue");
-  const clientOutputDir = join16(generatedDir, "client");
-  const indexOutputDir = join16(generatedDir, "indexes");
-  const serverOutputDir = join16(generatedDir, "server");
-  const cssOutputDir = join16(generatedDir, "compiled");
+  const clientOutputDir = join17(generatedDir, "client");
+  const indexOutputDir = join17(generatedDir, "indexes");
+  const serverOutputDir = join17(generatedDir, "server");
+  const cssOutputDir = join17(generatedDir, "compiled");
   await Promise.all([
-    mkdir4(clientOutputDir, { recursive: true }),
-    mkdir4(indexOutputDir, { recursive: true }),
-    mkdir4(serverOutputDir, { recursive: true }),
-    mkdir4(cssOutputDir, { recursive: true })
+    mkdir5(clientOutputDir, { recursive: true }),
+    mkdir5(indexOutputDir, { recursive: true }),
+    mkdir5(serverOutputDir, { recursive: true }),
+    mkdir5(cssOutputDir, { recursive: true })
   ]);
   const buildCache = new Map;
   const allTsHelperPaths = new Set;
   const compiledPages = await Promise.all(entryPoints.map(async (entryPath) => {
-    const result = await compileVueFile(resolve17(entryPath), {
+    const result = await compileVueFile(resolve18(entryPath), {
       client: clientOutputDir,
       css: cssOutputDir,
       server: serverOutputDir
     }, buildCache, true, vueRootDir, compiler, stylePreprocessors);
     result.tsHelperPaths.forEach((path) => allTsHelperPaths.add(path));
     const entryBaseName = basename5(entryPath, ".vue");
-    const indexOutputFile = join16(indexOutputDir, `${entryBaseName}.js`);
-    const clientOutputFile = join16(clientOutputDir, relative9(vueRootDir, entryPath).replace(/\\/g, "/").replace(/\.vue$/, ".js"));
-    await mkdir4(dirname10(indexOutputFile), { recursive: true });
+    const indexOutputFile = join17(indexOutputDir, `${entryBaseName}.js`);
+    const clientOutputFile = join17(clientOutputDir, relative10(vueRootDir, entryPath).replace(/\\/g, "/").replace(/\.vue$/, ".js"));
+    await mkdir5(dirname11(indexOutputFile), { recursive: true });
     const vueHmrImports = isDev ? [
       `window.__HMR_FRAMEWORK__ = "vue";`,
       `import "${hmrClientPath4}";`
     ] : [];
     await write2(indexOutputFile, [
       ...vueHmrImports,
-      `import Comp, * as PageModule from "${relative9(dirname10(indexOutputFile), clientOutputFile).replace(/\\/g, "/")}";`,
+      `import Comp, * as PageModule from "${relative10(dirname11(indexOutputFile), clientOutputFile).replace(/\\/g, "/")}";`,
       'import { createSSRApp, createApp } from "vue";',
       "",
       "// HMR State Preservation: Check for preserved state from HMR",
@@ -11096,12 +11201,12 @@ if (typeof __VUE_HMR_RUNTIME__ !== 'undefined') {
   }));
   await Promise.all(Array.from(allTsHelperPaths).map(async (tsPath) => {
     const sourceCode = await file2(tsPath).text();
-    const transpiledCode = transpiler3.transformSync(sourceCode);
-    const relativeJsPath = relative9(vueRootDir, tsPath).replace(/\.ts$/, ".js");
-    const outClientPath = join16(clientOutputDir, relativeJsPath);
-    const outServerPath = join16(serverOutputDir, relativeJsPath);
-    await mkdir4(dirname10(outClientPath), { recursive: true });
-    await mkdir4(dirname10(outServerPath), { recursive: true });
+    const transpiledCode = transpiler4.transformSync(sourceCode);
+    const relativeJsPath = relative10(vueRootDir, tsPath).replace(/\.ts$/, ".js");
+    const outClientPath = join17(clientOutputDir, relativeJsPath);
+    const outServerPath = join17(serverOutputDir, relativeJsPath);
+    await mkdir5(dirname11(outClientPath), { recursive: true });
+    await mkdir5(dirname11(outServerPath), { recursive: true });
     await write2(outClientPath, transpiledCode);
     await write2(outServerPath, transpiledCode);
   }));
@@ -11121,8 +11226,8 @@ var init_compileVue = __esm(() => {
   init_vueAutoRouterTransform();
   init_stylePreprocessor();
   devClientDir3 = resolveDevClientDir3();
-  hmrClientPath4 = join16(devClientDir3, "hmrClient.ts").replace(/\\/g, "/");
-  transpiler3 = new Transpiler2({ loader: "ts", target: "browser" });
+  hmrClientPath4 = join17(devClientDir3, "hmrClient.ts").replace(/\\/g, "/");
+  transpiler4 = new Transpiler3({ loader: "ts", target: "browser" });
   scriptCache = new Map;
   scriptSetupCache = new Map;
   templateCache = new Map;
@@ -11602,17 +11707,17 @@ __export(exports_compileAngular, {
   compileAngular: () => compileAngular
 });
 import { existsSync as existsSync16, readFileSync as readFileSync11, promises as fs } from "fs";
-import { join as join17, basename as basename6, sep as sep3, dirname as dirname11, resolve as resolve18, relative as relative10 } from "path";
+import { join as join18, basename as basename6, sep as sep3, dirname as dirname12, resolve as resolve19, relative as relative11 } from "path";
 import ts2 from "typescript";
 var traceAngularPhase = async (name, fn2, metadata) => {
   const tracePhase = globalThis.__absoluteBuildTracePhase;
   return tracePhase ? tracePhase(`compile/angular/${name}`, fn2, metadata) : await fn2();
 }, readTsconfigPathAliases = () => {
   try {
-    const configPath2 = resolve18(process.cwd(), "tsconfig.json");
+    const configPath2 = resolve19(process.cwd(), "tsconfig.json");
     const config = ts2.readConfigFile(configPath2, ts2.sys.readFile).config;
     const compilerOptions = config?.compilerOptions ?? {};
-    const baseUrl = resolve18(process.cwd(), compilerOptions.baseUrl ?? ".");
+    const baseUrl = resolve19(process.cwd(), compilerOptions.baseUrl ?? ".");
     const aliases = Object.entries(compilerOptions.paths ?? {}).map(([pattern, replacements]) => ({ pattern, replacements }));
     return { aliases, baseUrl };
   } catch {
@@ -11632,7 +11737,7 @@ var traceAngularPhase = async (name, fn2, metadata) => {
     const wildcardValue = exactMatch ? "" : specifier.slice(prefix.length, specifier.length - suffix.length);
     for (const replacement of alias.replacements) {
       const candidate = replacement.replace("*", wildcardValue);
-      const resolved = resolveSourceFile(resolve18(baseUrl, candidate));
+      const resolved = resolveSourceFile(resolve19(baseUrl, candidate));
       if (resolved)
         return resolved;
     }
@@ -11644,20 +11749,20 @@ var traceAngularPhase = async (name, fn2, metadata) => {
     `${candidate}.tsx`,
     `${candidate}.js`,
     `${candidate}.jsx`,
-    join17(candidate, "index.ts"),
-    join17(candidate, "index.tsx"),
-    join17(candidate, "index.js"),
-    join17(candidate, "index.jsx")
+    join18(candidate, "index.ts"),
+    join18(candidate, "index.tsx"),
+    join18(candidate, "index.js"),
+    join18(candidate, "index.jsx")
   ];
   return candidates.find((file3) => existsSync16(file3));
 }, createLegacyAngularAnimationUsageResolver = (rootDir) => {
-  const baseDir = resolve18(rootDir);
+  const baseDir = resolve19(rootDir);
   const tsconfigAliases = readTsconfigPathAliases();
-  const transpiler4 = new Bun.Transpiler({ loader: "tsx" });
+  const transpiler5 = new Bun.Transpiler({ loader: "tsx" });
   const scanCache = new Map;
   const resolveLocalImport = (specifier, fromDir) => {
     if (specifier.startsWith(".") || specifier.startsWith("/")) {
-      return resolveSourceFile(resolve18(fromDir, specifier));
+      return resolveSourceFile(resolve19(fromDir, specifier));
     }
     const aliased = matchTsconfigAlias(specifier, tsconfigAliases.aliases, tsconfigAliases.baseUrl, resolveSourceFile);
     if (aliased)
@@ -11666,7 +11771,7 @@ var traceAngularPhase = async (name, fn2, metadata) => {
       const resolved = Bun.resolveSync(specifier, fromDir);
       if (resolved.includes("/node_modules/"))
         return;
-      const absolute = resolve18(resolved);
+      const absolute = resolve19(resolved);
       if (!absolute.startsWith(baseDir))
         return;
       return resolveSourceFile(absolute);
@@ -11682,7 +11787,7 @@ var traceAngularPhase = async (name, fn2, metadata) => {
         usesLegacyAnimations: false
       });
     }
-    const resolved = resolve18(actualPath);
+    const resolved = resolve19(actualPath);
     const cached = scanCache.get(resolved);
     if (cached)
       return cached;
@@ -11695,7 +11800,7 @@ var traceAngularPhase = async (name, fn2, metadata) => {
       }
       let imports;
       try {
-        imports = transpiler4.scanImports(sourceCode);
+        imports = transpiler5.scanImports(sourceCode);
       } catch {
         return { imports: [], usesLegacyAnimations: false };
       }
@@ -11711,7 +11816,7 @@ var traceAngularPhase = async (name, fn2, metadata) => {
     const actualPath = resolveSourceFile(filePath);
     if (!actualPath)
       return false;
-    const resolved = resolve18(actualPath);
+    const resolved = resolve19(actualPath);
     if (visited.has(resolved))
       return false;
     visited.add(resolved);
@@ -11719,7 +11824,7 @@ var traceAngularPhase = async (name, fn2, metadata) => {
     if (scan.usesLegacyAnimations)
       return true;
     for (const specifier of scan.imports) {
-      const importedPath = resolveLocalImport(specifier, dirname11(resolved));
+      const importedPath = resolveLocalImport(specifier, dirname12(resolved));
       if (importedPath && await visit(importedPath, visited)) {
         return true;
       }
@@ -11729,14 +11834,14 @@ var traceAngularPhase = async (name, fn2, metadata) => {
   return (entryPath) => visit(entryPath);
 }, resolveDevClientDir4 = () => {
   const projectRoot = process.cwd();
-  const fromSource = resolve18(import.meta.dir, "../dev/client");
+  const fromSource = resolve19(import.meta.dir, "../dev/client");
   if (existsSync16(fromSource) && fromSource.startsWith(projectRoot)) {
     return fromSource;
   }
-  const fromNodeModules = resolve18(projectRoot, "node_modules/@absolutejs/absolute/dist/dev/client");
+  const fromNodeModules = resolve19(projectRoot, "node_modules/@absolutejs/absolute/dist/dev/client");
   if (existsSync16(fromNodeModules))
     return fromNodeModules;
-  return resolve18(import.meta.dir, "./dev/client");
+  return resolve19(import.meta.dir, "./dev/client");
 }, devClientDir4, hmrClientPath5, formatDiagnosticMessage = (diagnostic) => {
   try {
     return ts2.flattenDiagnosticMessageText(diagnostic.messageText, `
@@ -11778,12 +11883,12 @@ var traceAngularPhase = async (name, fn2, metadata) => {
     return `${path.replace(/\.ts$/, ".js")}${query}`;
   if (hasJsLikeExtension(path))
     return `${path}${query}`;
-  const importerDir = dirname11(importerOutputPath);
-  const fileCandidate = resolve18(importerDir, `${path}.js`);
+  const importerDir = dirname12(importerOutputPath);
+  const fileCandidate = resolve19(importerDir, `${path}.js`);
   if (outputFiles?.has(fileCandidate) || existsSync16(fileCandidate)) {
     return `${path}.js${query}`;
   }
-  const indexCandidate = resolve18(importerDir, path, "index.js");
+  const indexCandidate = resolve19(importerDir, path, "index.js");
   if (outputFiles?.has(indexCandidate) || existsSync16(indexCandidate)) {
     return `${path}/index.js${query}`;
   }
@@ -11811,18 +11916,18 @@ var traceAngularPhase = async (name, fn2, metadata) => {
 }, resolveLocalTsImport = (fromFile, specifier) => {
   if (!isRelativeModuleSpecifier(specifier))
     return null;
-  const basePath = resolve18(dirname11(fromFile), specifier);
+  const basePath = resolve19(dirname12(fromFile), specifier);
   const candidates = /\.[cm]?[tj]sx?$/.test(basePath) ? [basePath] : [
     `${basePath}.ts`,
     `${basePath}.tsx`,
     `${basePath}.mts`,
     `${basePath}.cts`,
-    join17(basePath, "index.ts"),
-    join17(basePath, "index.tsx"),
-    join17(basePath, "index.mts"),
-    join17(basePath, "index.cts")
+    join18(basePath, "index.ts"),
+    join18(basePath, "index.tsx"),
+    join18(basePath, "index.mts"),
+    join18(basePath, "index.cts")
   ];
-  return candidates.map((candidate) => resolve18(candidate)).find((candidate) => existsSync16(candidate) && !candidate.endsWith(".d.ts")) ?? null;
+  return candidates.map((candidate) => resolve19(candidate)).find((candidate) => existsSync16(candidate) && !candidate.endsWith(".d.ts")) ?? null;
 }, readFileForAotTransform = async (fileName, readFile6) => {
   const hostSource = readFile6?.(fileName);
   if (typeof hostSource === "string")
@@ -11846,18 +11951,18 @@ var traceAngularPhase = async (name, fn2, metadata) => {
   const paths = [];
   const templateUrlMatch = findUncommentedMatch(source, /templateUrl\s*:\s*['"]([^'"]+)['"]/);
   if (templateUrlMatch?.[1])
-    paths.push(join17(fileDir, templateUrlMatch[1]));
+    paths.push(join18(fileDir, templateUrlMatch[1]));
   const styleUrlMatch = findUncommentedMatch(source, /styleUrl\s*:\s*['"]([^'"]+)['"]/);
   if (styleUrlMatch?.[1])
-    paths.push(join17(fileDir, styleUrlMatch[1]));
+    paths.push(join18(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(join17(fileDir, urlMatch.replace(/['"]/g, "")));
+      paths.push(join18(fileDir, urlMatch.replace(/['"]/g, "")));
     }
   }
-  return paths.map((path) => resolve18(path));
+  return paths.map((path) => resolve19(path));
 }, readResourceCacheFile = async (cachePath) => {
   try {
     const entry = JSON.parse(await fs.readFile(cachePath, "utf-8"));
@@ -11869,13 +11974,13 @@ var traceAngularPhase = async (name, fn2, metadata) => {
     return null;
   }
 }, writeResourceCacheFile = async (cachePath, source) => {
-  await fs.mkdir(dirname11(cachePath), { recursive: true });
+  await fs.mkdir(dirname12(cachePath), { recursive: true });
   await fs.writeFile(cachePath, JSON.stringify({
     source,
     version: 1
   }), "utf-8");
 }, resolveResourceTransformCachePath = async (filePath, source, stylePreprocessors) => {
-  const resourcePaths = collectAngularResourcePaths(source, dirname11(filePath));
+  const resourcePaths = collectAngularResourcePaths(source, dirname12(filePath));
   const resourceContents = await Promise.all(resourcePaths.map(async (resourcePath) => {
     const content = await fs.readFile(resourcePath, "utf-8");
     return `${resourcePath}\x00${content}`;
@@ -11888,7 +11993,7 @@ var traceAngularPhase = async (name, fn2, metadata) => {
     safeStableStringify(stylePreprocessors ?? null)
   ].join("\x00");
   const cacheKey2 = Bun.hash(cacheInput).toString(BASE_36_RADIX);
-  return join17(process.cwd(), ".absolutejs", "cache", "angular-resources", `${cacheKey2}.json`);
+  return join18(process.cwd(), ".absolutejs", "cache", "angular-resources", `${cacheKey2}.json`);
 }, precomputeAotResourceTransforms = async (inputPaths, readFile6, stylePreprocessors) => {
   const transformedSources = new Map;
   const visited = new Set;
@@ -11899,7 +12004,7 @@ var traceAngularPhase = async (name, fn2, metadata) => {
     transformedFiles: 0
   };
   const transformFile = async (filePath) => {
-    const resolvedPath = resolve18(filePath);
+    const resolvedPath = resolve19(filePath);
     if (visited.has(resolvedPath))
       return;
     visited.add(resolvedPath);
@@ -11915,7 +12020,7 @@ var traceAngularPhase = async (name, fn2, metadata) => {
       transformedSource = cached.source;
     } else {
       stats.cacheMisses += 1;
-      const transformed = await inlineResources(source, dirname11(resolvedPath), stylePreprocessors);
+      const transformed = await inlineResources(source, dirname12(resolvedPath), stylePreprocessors);
       transformedSource = transformed.source;
       await writeResourceCacheFile(cachePath, transformedSource);
     }
@@ -11934,7 +12039,7 @@ var traceAngularPhase = async (name, fn2, metadata) => {
   return { stats, transformedSources };
 }, compileAngularFiles = async (inputPaths, outDir, stylePreprocessors) => {
   const islandMetadataByOutputPath = await traceAngularPhase("aot/island-metadata", () => new Map(inputPaths.map((inputPath) => {
-    const outputPath = resolve18(join17(outDir, relative10(process.cwd(), resolve18(inputPath)).replace(/\.[cm]?[tj]sx?$/, ".js")));
+    const outputPath = resolve19(join18(outDir, relative11(process.cwd(), resolve19(inputPath)).replace(/\.[cm]?[tj]sx?$/, ".js")));
     return [
       outputPath,
       buildIslandMetadataExports(readFileSync11(inputPath, "utf-8"))
@@ -11944,8 +12049,8 @@ var traceAngularPhase = async (name, fn2, metadata) => {
   const { readConfiguration, performCompilation, EmitFlags } = await traceAngularPhase("aot/import-compiler-cli", () => import("@angular/compiler-cli"));
   const tsLibDir = await traceAngularPhase("aot/resolve-typescript-lib", () => {
     const tsPath = __require.resolve("typescript");
-    const tsRootDir = dirname11(tsPath);
-    return tsRootDir.endsWith("lib") ? tsRootDir : resolve18(tsRootDir, "lib");
+    const tsRootDir = dirname12(tsPath);
+    return tsRootDir.endsWith("lib") ? tsRootDir : resolve19(tsRootDir, "lib");
   });
   const config = await traceAngularPhase("aot/read-configuration", () => readConfiguration("./tsconfig.json"));
   const options = {
@@ -11981,13 +12086,13 @@ var traceAngularPhase = async (name, fn2, metadata) => {
   const originalGetSourceFile = host.getSourceFile;
   host.getSourceFile = (fileName, languageVersion, onError) => {
     if (fileName.startsWith("lib.") && fileName.endsWith(".d.ts") && tsLibDir) {
-      const resolvedPath = join17(tsLibDir, fileName);
+      const resolvedPath = join18(tsLibDir, fileName);
       return originalGetSourceFile?.call(host, resolvedPath, languageVersion, onError);
     }
     return originalGetSourceFile?.call(host, fileName, languageVersion, onError);
   };
   const emitted = {};
-  const resolvedOutDir = resolve18(outDir);
+  const resolvedOutDir = resolve19(outDir);
   host.writeFile = (fileName, text) => {
     const relativePath = resolveRelativePath(fileName, resolvedOutDir, outDir);
     emitted[relativePath] = text;
@@ -12009,12 +12114,12 @@ var traceAngularPhase = async (name, fn2, metadata) => {
     if (!fileName.endsWith(".ts") || fileName.endsWith(".d.ts")) {
       return source;
     }
-    const resolvedPath = resolve18(fileName);
+    const resolvedPath = resolve19(fileName);
     return transformedSources.get(resolvedPath) ?? source;
   };
   const originalGetSourceFileForCompile = host.getSourceFile;
   host.getSourceFile = (fileName, languageVersion, onError) => {
-    const source = transformedSources.get(resolve18(fileName));
+    const source = transformedSources.get(resolve19(fileName));
     if (source) {
       return ts2.createSourceFile(fileName, source, languageVersion, true);
     }
@@ -12036,9 +12141,9 @@ var traceAngularPhase = async (name, fn2, metadata) => {
   const entries = await traceAngularPhase("aot/postprocess-emitted-js", () => {
     const rawEntries = Object.entries(emitted).filter(([fileName]) => fileName.endsWith(".js")).map(([fileName, content]) => ({
       content,
-      target: join17(outDir, fileName)
+      target: join18(outDir, fileName)
     }));
-    const outputFiles = new Set(rawEntries.map(({ target }) => resolve18(target)));
+    const outputFiles = new Set(rawEntries.map(({ target }) => resolve19(target)));
     return rawEntries.map(({ content, target }) => {
       let processedContent = content.replace(/from\s+(['"])(\.\.?\/[^'"]+)(\1)/g, (match, quote, path) => {
         const rewritten = rewriteRelativeJsSpecifier(target, path, outputFiles);
@@ -12053,12 +12158,12 @@ var traceAngularPhase = async (name, fn2, metadata) => {
         return cleaned ? `import { ${cleaned}, InternalInjectFlags } from '@angular/core'` : `import { InternalInjectFlags } from '@angular/core'`;
       });
       processedContent = processedContent.replace(/\b(?<!Internal)InjectFlags\b/g, "InternalInjectFlags");
-      processedContent += islandMetadataByOutputPath.get(resolve18(target)) ?? "";
+      processedContent += islandMetadataByOutputPath.get(resolve19(target)) ?? "";
       return { content: processedContent, target };
     });
   });
   await traceAngularPhase("aot/write-output", () => Promise.all(entries.map(async ({ target, content }) => {
-    await fs.mkdir(dirname11(target), { recursive: true });
+    await fs.mkdir(dirname12(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 });
@@ -12074,7 +12179,7 @@ var traceAngularPhase = async (name, fn2, metadata) => {
   }
   return null;
 }, resolveAngularDeferImportSpecifier = () => {
-  const sourceEntry = resolve18(import.meta.dir, "../angular/components/index.ts");
+  const sourceEntry = resolve19(import.meta.dir, "../angular/components/index.ts");
   if (existsSync16(sourceEntry)) {
     return sourceEntry.replace(/\\/g, "/");
   }
@@ -12211,7 +12316,7 @@ ${fields}
 }, inlineTemplateAndLowerDefer = async (source, fileDir) => {
   const templateUrlMatch = findUncommentedMatch(source, /templateUrl\s*:\s*['"]([^'"]+)['"]/);
   if (templateUrlMatch?.[1]) {
-    const templatePath = join17(fileDir, templateUrlMatch[1]);
+    const templatePath = join18(fileDir, templateUrlMatch[1]);
     if (!existsSync16(templatePath)) {
       throw new Error(`Unable to inline Angular templateUrl "${templateUrlMatch[1]}": file not found at ${templatePath}`);
     }
@@ -12242,7 +12347,7 @@ ${fields}
 }, inlineTemplateAndLowerDeferSync = (source, fileDir) => {
   const templateUrlMatch = findUncommentedMatch(source, /templateUrl\s*:\s*['"]([^'"]+)['"]/);
   if (templateUrlMatch?.[1]) {
-    const templatePath = join17(fileDir, templateUrlMatch[1]);
+    const templatePath = join18(fileDir, templateUrlMatch[1]);
     if (!existsSync16(templatePath)) {
       throw new Error(`Unable to inline Angular templateUrl "${templateUrlMatch[1]}": file not found at ${templatePath}`);
     }
@@ -12279,7 +12384,7 @@ ${fields}
     return source;
   const stylePromises = urlMatches.map((urlMatch) => {
     const styleUrl = urlMatch.replace(/['"]/g, "");
-    return readAndEscapeFile(join17(fileDir, styleUrl), stylePreprocessors);
+    return readAndEscapeFile(join18(fileDir, styleUrl), stylePreprocessors);
   });
   const results = await Promise.all(stylePromises);
   const inlinedStyles = results.filter(Boolean).map((escaped) => `\`${escaped}\``);
@@ -12290,7 +12395,7 @@ ${fields}
   const styleUrlMatch = findUncommentedMatch(source, /styleUrl\s*:\s*['"]([^'"]+)['"]/);
   if (!styleUrlMatch?.[1])
     return source;
-  const escaped = await readAndEscapeFile(join17(fileDir, styleUrlMatch[1]), stylePreprocessors);
+  const escaped = await readAndEscapeFile(join18(fileDir, styleUrlMatch[1]), stylePreprocessors);
   if (!escaped)
     return source;
   return source.slice(0, styleUrlMatch.index) + `styles: [\`${escaped}\`]` + source.slice(styleUrlMatch.index + styleUrlMatch[0].length);
@@ -12304,10 +12409,10 @@ ${fields}
     source: result
   };
 }, compileAngularFileJIT = async (inputPath, outDir, rootDir, stylePreprocessors, cacheBuster) => {
-  const entryPath = resolve18(inputPath);
+  const entryPath = resolve19(inputPath);
   const allOutputs = [];
   const visited = new Set;
-  const baseDir = resolve18(rootDir ?? process.cwd());
+  const baseDir = resolve19(rootDir ?? process.cwd());
   let usesLegacyAnimations = false;
   const angularTranspiler = new Bun.Transpiler({
     loader: "ts",
@@ -12325,16 +12430,16 @@ ${fields}
       `${candidate}.tsx`,
       `${candidate}.js`,
       `${candidate}.jsx`,
-      join17(candidate, "index.ts"),
-      join17(candidate, "index.tsx"),
-      join17(candidate, "index.js"),
-      join17(candidate, "index.jsx")
+      join18(candidate, "index.ts"),
+      join18(candidate, "index.tsx"),
+      join18(candidate, "index.js"),
+      join18(candidate, "index.jsx")
     ];
     return candidates.find((file3) => existsSync16(file3));
   };
   const resolveLocalImport = (specifier, fromDir) => {
     if (specifier.startsWith(".") || specifier.startsWith("/")) {
-      return resolveSourceFile2(resolve18(fromDir, specifier));
+      return resolveSourceFile2(resolve19(fromDir, specifier));
     }
     const aliased = matchTsconfigAlias(specifier, tsconfigAliases.aliases, tsconfigAliases.baseUrl, resolveSourceFile2);
     if (aliased)
@@ -12343,7 +12448,7 @@ ${fields}
       const resolved = Bun.resolveSync(specifier, fromDir);
       if (resolved.includes("/node_modules/"))
         return;
-      const absolute = resolve18(resolved);
+      const absolute = resolve19(resolved);
       if (!absolute.startsWith(baseDir))
         return;
       return resolveSourceFile2(absolute);
@@ -12352,10 +12457,10 @@ ${fields}
     }
   };
   const toOutputPath = (sourcePath) => {
-    const inputDir = dirname11(sourcePath);
+    const inputDir = dirname12(sourcePath);
     const relativeDir = inputDir.startsWith(baseDir) ? inputDir.substring(baseDir.length + 1) : inputDir;
     const fileBase = basename6(sourcePath).replace(/\.[cm]?[tj]sx?$/, ".js");
-    return join17(outDir, relativeDir, fileBase);
+    return join18(outDir, relativeDir, fileBase);
   };
   const withCacheBuster = (specifier) => {
     if (!cacheBuster)
@@ -12392,13 +12497,13 @@ ${fields}
         return `${prefix}${dots}`;
       return `${prefix}../${dots}`;
     });
-    if (resolve18(actualPath) === entryPath) {
+    if (resolve19(actualPath) === entryPath) {
       processedContent += buildIslandMetadataExports(sourceCode);
     }
     return processedContent;
   };
   const transpileFile = async (filePath) => {
-    const resolved = resolve18(filePath);
+    const resolved = resolve19(filePath);
     if (visited.has(resolved))
       return;
     visited.add(resolved);
@@ -12408,12 +12513,12 @@ ${fields}
     if (!existsSync16(actualPath))
       return;
     let sourceCode = await fs.readFile(actualPath, "utf-8");
-    const inlined = await inlineResources(sourceCode, dirname11(actualPath), stylePreprocessors);
-    sourceCode = inlineTemplateAndLowerDeferSync(inlined.source, dirname11(actualPath)).source;
-    const inputDir = dirname11(actualPath);
+    const inlined = await inlineResources(sourceCode, dirname12(actualPath), stylePreprocessors);
+    sourceCode = inlineTemplateAndLowerDeferSync(inlined.source, dirname12(actualPath)).source;
+    const inputDir = dirname12(actualPath);
     const relativeDir = inputDir.startsWith(baseDir) ? inputDir.substring(baseDir.length + 1) : inputDir;
     const fileBase = basename6(actualPath).replace(/\.[cm]?[tj]sx?$/, ".js");
-    const targetDir = join17(outDir, relativeDir);
+    const targetDir = join18(outDir, relativeDir);
     const targetPath = toOutputPath(actualPath);
     const localImports = [];
     const importRewrites = new Map;
@@ -12435,12 +12540,12 @@ ${fields}
       const resolved2 = resolveLocalImport(specifier, inputDir);
       if (!resolved2)
         return null;
-      const relativeImport = relative10(targetDir, toOutputPath(resolved2)).replace(/\\/g, "/").replace(/\.js$/, "");
+      const relativeImport = relative11(targetDir, toOutputPath(resolved2)).replace(/\\/g, "/").replace(/\.js$/, "");
       const relativeRewrite = relativeImport.startsWith(".") ? relativeImport : `./${relativeImport}`;
       importRewrites.set(specifier, relativeRewrite);
       return resolved2;
     }).filter((path) => Boolean(path));
-    const isEntry = resolve18(actualPath) === resolve18(entryPath);
+    const isEntry = resolve19(actualPath) === resolve19(entryPath);
     const contentHash = Bun.hash(sourceCode).toString(BASE_36_RADIX);
     const cacheKey2 = actualPath;
     const shouldWriteFile = cacheBuster && isEntry ? true : jitContentCache.get(cacheKey2) !== contentHash || !existsSync16(targetPath);
@@ -12474,13 +12579,13 @@ export const __ABSOLUTE_PAGE_USES_LEGACY_ANIMATIONS__ = true;
     return { clientPaths: [...emptyPaths], serverPaths: [...emptyPaths] };
   }
   const compiledRoot = compiledParent;
-  const indexesDir = join17(compiledParent, "indexes");
+  const indexesDir = join18(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) => resolve18(entry)), compiledRoot, stylePreprocessors), { entries: entryPoints.length });
+  const aotOutputs = hmr ? [] : await traceAngularPhase("aot/compile-files", () => compileAngularFiles(entryPoints.map((entry) => resolve19(entry)), compiledRoot, stylePreprocessors), { entries: entryPoints.length });
   const usesLegacyAngularAnimations = await traceAngularPhase("setup/legacy-animation-resolver", () => createLegacyAngularAnimationUsageResolver(outRoot));
   const compileTasks = entryPoints.map(async (entry) => {
-    const resolvedEntry = resolve18(entry);
-    const relativeEntry = relative10(outRoot, resolvedEntry).replace(/\.[tj]s$/, ".js");
+    const resolvedEntry = resolve19(entry);
+    const relativeEntry = relative11(outRoot, resolvedEntry).replace(/\.[tj]s$/, ".js");
     const compileEntry = () => compileAngularFileJIT(resolvedEntry, compiledRoot, outRoot, stylePreprocessors);
     let outputs = hmr ? await traceAngularPhase("jit/compile-entry", compileEntry, {
       entry: resolvedEntry
@@ -12488,13 +12593,13 @@ export const __ABSOLUTE_PAGE_USES_LEGACY_ANIMATIONS__ = true;
     const fileBase = basename6(resolvedEntry).replace(/\.[tj]s$/, "");
     const jsName = `${fileBase}.js`;
     const compiledFallbackPaths = [
-      join17(compiledRoot, relativeEntry),
-      join17(compiledRoot, "pages", jsName),
-      join17(compiledRoot, jsName)
-    ].map((file3) => resolve18(file3));
+      join18(compiledRoot, relativeEntry),
+      join18(compiledRoot, "pages", jsName),
+      join18(compiledRoot, jsName)
+    ].map((file3) => resolve19(file3));
     const resolveRawServerFile = (candidatePaths) => {
       const normalizedCandidates = [
-        ...candidatePaths.map((file3) => resolve18(file3)),
+        ...candidatePaths.map((file3) => resolve19(file3)),
         ...compiledFallbackPaths
       ];
       let candidate = normalizedCandidates.find((file3) => existsSync16(file3) && file3.endsWith(`${sep3}pages${sep3}${jsName}`));
@@ -12535,7 +12640,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 = join17(indexesDir, jsName);
+    const clientFile = join18(indexesDir, jsName);
     if (hmr && cachedWrapper && cachedWrapper.serverHash === serverContentHash && existsSync16(clientFile) && (usesLegacyAnimations || !original.includes("__ABSOLUTE_PAGE_USES_LEGACY_ANIMATIONS__")) && (!usesLegacyAnimations || original.includes("__ABSOLUTE_PAGE_USES_LEGACY_ANIMATIONS__"))) {
       return {
         clientPath: clientFile,
@@ -12562,7 +12667,7 @@ export const __ABSOLUTE_PAGE_USES_LEGACY_ANIMATIONS__ = true;
 `;
     }
     await traceAngularPhase("wrapper/write-server-output", () => fs.writeFile(rawServerFile, rewritten, "utf-8"), { entry: resolvedEntry });
-    const relativePath = relative10(indexesDir, rawServerFile).replace(/\\/g, "/");
+    const relativePath = relative11(indexesDir, rawServerFile).replace(/\\/g, "/");
     const normalizedImportPath = relativePath.startsWith(".") ? relativePath : `./${relativePath}`;
     const hmrPreamble = hmr ? `window.__HMR_FRAMEWORK__ = "angular";
 import "${hmrClientPath5}";
@@ -12766,14 +12871,14 @@ var init_compileAngular = __esm(() => {
   init_stylePreprocessor();
   init_generatedDir();
   devClientDir4 = resolveDevClientDir4();
-  hmrClientPath5 = join17(devClientDir4, "hmrClient.ts").replace(/\\/g, "/");
+  hmrClientPath5 = join18(devClientDir4, "hmrClient.ts").replace(/\\/g, "/");
   jitContentCache = new Map;
   wrapperOutputCache = new Map;
 });
 
 // node_modules/content-tag/pkg/node/content_tag.cjs
 var require_content_tag = __commonJS((exports, module) => {
-  var __dirname = "/tmp/absolutejs-clean/node_modules/content-tag/pkg/node";
+  var __dirname = "/home/alexkahn/abs/absolutejs/node_modules/content-tag/pkg/node";
   var imports = {};
   imports["__wbindgen_placeholder__"] = exports;
   var wasm;
@@ -13211,7 +13316,7 @@ __export(exports_compileEmber, {
   getEmberServerCompiledDir: () => getEmberServerCompiledDir,
   getEmberCompiledRoot: () => getEmberCompiledRoot,
   getEmberClientCompiledDir: () => getEmberClientCompiledDir,
-  dirname: () => dirname12,
+  dirname: () => dirname13,
   compileEmberFileSource: () => compileEmberFileSource,
   compileEmberFile: () => compileEmberFile,
   compileEmber: () => compileEmber,
@@ -13219,16 +13324,16 @@ __export(exports_compileEmber, {
   basename: () => basename7
 });
 import { existsSync as existsSync17 } from "fs";
-import { mkdir as mkdir5, rm as rm4 } from "fs/promises";
-import { basename as basename7, dirname as dirname12, extname as extname6, join as join18, resolve as resolve19 } from "path";
-var {build: bunBuild2, Transpiler: Transpiler3, write: write3, file: file3 } = globalThis.Bun;
+import { mkdir as mkdir6, rm as rm4 } from "fs/promises";
+import { basename as basename7, dirname as dirname13, extname as extname6, join as join19, resolve as resolve20 } from "path";
+var {build: bunBuild2, Transpiler: Transpiler4, write: write3, file: file3 } = globalThis.Bun;
 var cachedPreprocessor = null, getPreprocessor = async () => {
   if (cachedPreprocessor)
     return cachedPreprocessor;
   const module = await Promise.resolve().then(() => __toESM(require_node(), 1));
   cachedPreprocessor = new module.Preprocessor;
   return cachedPreprocessor;
-}, transpiler4, isTemplateTagFile = (entry) => {
+}, transpiler5, isTemplateTagFile = (entry) => {
   const ext = extname6(entry);
   return ext === ".gjs" || ext === ".gts";
 }, rewriteTemplateEvalToScope = (source) => {
@@ -13316,7 +13421,7 @@ export const importSync = (specifier) => {
         const originalImporter = stagedSourceMap.get(args.importer);
         if (!originalImporter)
           return;
-        const candidateBase = resolve19(dirname12(originalImporter), args.path);
+        const candidateBase = resolve20(dirname13(originalImporter), args.path);
         const extensionsToTry = ["", ".gts", ".gjs", ".ts", ".js"];
         for (const ext of extensionsToTry) {
           const candidate = candidateBase + ext;
@@ -13333,13 +13438,13 @@ export const importSync = (specifier) => {
         filename: args.path
       });
       const rewritten = rewriteTemplateEvalToScope(result.code);
-      const transpiled = transpiler4.transformSync(rewritten);
+      const transpiled = transpiler5.transformSync(rewritten);
       return { contents: transpiled, loader: "js" };
     });
     build.onResolve({ filter: /^@(?:ember|glimmer|simple-dom)\// }, (args) => {
       if (standalonePackages.has(args.path))
         return;
-      const internal = join18(cwd, "node_modules/ember-source/dist/packages", args.path, "index.js");
+      const internal = join19(cwd, "node_modules/ember-source/dist/packages", args.path, "index.js");
       if (existsSync17(internal))
         return { path: internal };
       return;
@@ -13375,7 +13480,7 @@ export const renderToHTML = (props = {}) => {
 export { PageComponent };
 export default PageComponent;
 `, compileEmberFile = async (entry, compiledRoot, cwd = process.cwd()) => {
-  const resolvedEntry = resolve19(entry);
+  const resolvedEntry = resolve20(entry);
   const source = await file3(resolvedEntry).text();
   let preprocessed = source;
   if (isTemplateTagFile(resolvedEntry)) {
@@ -13385,18 +13490,18 @@ export default PageComponent;
     });
     preprocessed = rewriteTemplateEvalToScope(result.code);
   }
-  const transpiled = transpiler4.transformSync(preprocessed);
+  const transpiled = transpiler5.transformSync(preprocessed);
   const baseName = basename7(resolvedEntry).replace(/\.(gjs|gts|ts|js)$/, "");
-  const tmpDir = join18(compiledRoot, "_tmp");
-  const serverDir = join18(compiledRoot, "server");
-  const clientDir = join18(compiledRoot, "client");
+  const tmpDir = join19(compiledRoot, "_tmp");
+  const serverDir = join19(compiledRoot, "server");
+  const clientDir = join19(compiledRoot, "client");
   await Promise.all([
-    mkdir5(tmpDir, { recursive: true }),
-    mkdir5(serverDir, { recursive: true }),
-    mkdir5(clientDir, { recursive: true })
+    mkdir6(tmpDir, { recursive: true }),
+    mkdir6(serverDir, { recursive: true }),
+    mkdir6(clientDir, { recursive: true })
   ]);
-  const tmpPagePath = resolve19(join18(tmpDir, `${baseName}.module.js`));
-  const tmpHarnessPath = resolve19(join18(tmpDir, `${baseName}.harness.js`));
+  const tmpPagePath = resolve20(join19(tmpDir, `${baseName}.module.js`));
+  const tmpHarnessPath = resolve20(join19(tmpDir, `${baseName}.harness.js`));
   await Promise.all([
     write3(tmpPagePath, transpiled),
     write3(tmpHarnessPath, generateServerHarness(tmpPagePath))
@@ -13404,7 +13509,7 @@ export default PageComponent;
   const stagedSourceMap = new Map([
     [tmpPagePath, resolvedEntry]
   ]);
-  const serverPath = join18(serverDir, `${baseName}.js`);
+  const serverPath = join19(serverDir, `${baseName}.js`);
   const buildResult = await bunBuild2({
     entrypoints: [tmpHarnessPath],
     format: "esm",
@@ -13421,7 +13526,7 @@ export default PageComponent;
     console.warn(`\u26A0\uFE0F Ember server build for ${baseName} had errors:`, buildResult.logs);
   }
   await rm4(tmpDir, { force: true, recursive: true });
-  const clientPath = join18(clientDir, `${baseName}.js`);
+  const clientPath = join19(clientDir, `${baseName}.js`);
   await write3(clientPath, transpiled);
   return { clientPath, serverPath };
 }, compileEmber = async (entries, emberDir, cwd = process.cwd(), _hmr = false) => {
@@ -13438,7 +13543,7 @@ export default PageComponent;
     serverPaths: outputs.map((o) => o.serverPath)
   };
 }, compileEmberFileSource = async (entry) => {
-  const resolvedEntry = resolve19(entry);
+  const resolvedEntry = resolve20(entry);
   const source = await file3(resolvedEntry).text();
   let preprocessed = source;
   if (isTemplateTagFile(resolvedEntry)) {
@@ -13448,11 +13553,11 @@ export default PageComponent;
     });
     preprocessed = rewriteTemplateEvalToScope(result.code);
   }
-  return transpiler4.transformSync(preprocessed);
-}, clearEmberCompilerCache = () => {}, getEmberCompiledRoot = (_emberDir) => getFrameworkGeneratedDir("ember"), getEmberServerCompiledDir = (emberDir) => join18(getEmberCompiledRoot(emberDir), "server"), getEmberClientCompiledDir = (emberDir) => join18(getEmberCompiledRoot(emberDir), "client");
+  return transpiler5.transformSync(preprocessed);
+}, clearEmberCompilerCache = () => {}, getEmberCompiledRoot = (_emberDir) => getFrameworkGeneratedDir("ember"), getEmberServerCompiledDir = (emberDir) => join19(getEmberCompiledRoot(emberDir), "server"), getEmberClientCompiledDir = (emberDir) => join19(getEmberCompiledRoot(emberDir), "client");
 var init_compileEmber = __esm(() => {
   init_generatedDir();
-  transpiler4 = new Transpiler3({
+  transpiler5 = new Transpiler4({
     loader: "ts",
     target: "browser",
     tsconfig: JSON.stringify({
@@ -13471,24 +13576,24 @@ __export(exports_buildReactVendor, {
   buildReactVendor: () => buildReactVendor
 });
 import { existsSync as existsSync18, mkdirSync as mkdirSync7 } from "fs";
-import { join as join19, resolve as resolve20 } from "path";
+import { join as join20, resolve as resolve21 } from "path";
 import { rm as rm5 } from "fs/promises";
 var {build: bunBuild3 } = globalThis.Bun;
 var resolveJsxDevRuntimeCompatPath = () => {
   const candidates = [
-    resolve20(import.meta.dir, "react", "jsxDevRuntimeCompat.js"),
-    resolve20(import.meta.dir, "src", "react", "jsxDevRuntimeCompat.ts"),
-    resolve20(import.meta.dir, "..", "react", "jsxDevRuntimeCompat.js"),
-    resolve20(import.meta.dir, "..", "src", "react", "jsxDevRuntimeCompat.ts"),
-    resolve20(import.meta.dir, "..", "..", "dist", "react", "jsxDevRuntimeCompat.js"),
-    resolve20(import.meta.dir, "..", "..", "src", "react", "jsxDevRuntimeCompat.ts")
+    resolve21(import.meta.dir, "react", "jsxDevRuntimeCompat.js"),
+    resolve21(import.meta.dir, "src", "react", "jsxDevRuntimeCompat.ts"),
+    resolve21(import.meta.dir, "..", "react", "jsxDevRuntimeCompat.js"),
+    resolve21(import.meta.dir, "..", "src", "react", "jsxDevRuntimeCompat.ts"),
+    resolve21(import.meta.dir, "..", "..", "dist", "react", "jsxDevRuntimeCompat.js"),
+    resolve21(import.meta.dir, "..", "..", "src", "react", "jsxDevRuntimeCompat.ts")
   ];
   for (const candidate of candidates) {
     if (existsSync18(candidate)) {
       return candidate.replace(/\\/g, "/");
     }
   }
-  return (candidates[0] ?? resolve20(import.meta.dir, "react", "jsxDevRuntimeCompat.js")).replace(/\\/g, "/");
+  return (candidates[0] ?? resolve21(import.meta.dir, "react", "jsxDevRuntimeCompat.js")).replace(/\\/g, "/");
 }, jsxDevRuntimeCompatPath, reactSpecifiers, isResolvable = (specifier) => {
   try {
     Bun.resolveSync(specifier, process.cwd());
@@ -13525,14 +13630,14 @@ var resolveJsxDevRuntimeCompatPath = () => {
 `)}
 `;
 }, buildReactVendor = async (buildDir) => {
-  const vendorDir = join19(buildDir, "react", "vendor");
+  const vendorDir = join20(buildDir, "react", "vendor");
   mkdirSync7(vendorDir, { recursive: true });
-  const tmpDir = join19(buildDir, "_vendor_tmp");
+  const tmpDir = join20(buildDir, "_vendor_tmp");
   mkdirSync7(tmpDir, { recursive: true });
   const specifiers = resolveVendorSpecifiers();
   const entrypoints = await Promise.all(specifiers.map(async (specifier) => {
     const safeName = toSafeFileName(specifier);
-    const entryPath = join19(tmpDir, `${safeName}.ts`);
+    const entryPath = join20(tmpDir, `${safeName}.ts`);
     const source = await generateEntrySource(specifier);
     await Bun.write(entryPath, source);
     return entryPath;
@@ -13597,7 +13702,7 @@ __export(exports_buildAngularVendor, {
   buildAngularServerVendor: () => buildAngularServerVendor
 });
 import { mkdirSync as mkdirSync8 } from "fs";
-import { join as join20 } from "path";
+import { join as join21 } from "path";
 import { rm as rm6 } from "fs/promises";
 var {build: bunBuild4, Glob: Glob6 } = globalThis.Bun;
 var REQUIRED_ANGULAR_SPECIFIERS_BASE, requiredAngularSpecifiers = (jitMode) => jitMode ? [...REQUIRED_ANGULAR_SPECIFIERS_BASE, "@angular/compiler"] : REQUIRED_ANGULAR_SPECIFIERS_BASE, SERVER_ONLY_ANGULAR_SPECIFIERS, BUILD_ONLY_ANGULAR_SPECIFIER_PREFIXES, isBuildOnlyAngularSpecifier = (spec) => BUILD_ONLY_ANGULAR_SPECIFIER_PREFIXES.some((prefix) => spec === prefix || spec.startsWith(`${prefix}/`)), SCAN_SKIP_DIRS, isResolvable2 = (specifier) => {
@@ -13610,7 +13715,7 @@ var REQUIRED_ANGULAR_SPECIFIERS_BASE, requiredAngularSpecifiers = (jitMode) => j
 }, isBareSpecifier = (spec) => !spec.startsWith(".") && !spec.startsWith("/") && !spec.startsWith("@src/"), isAngularBrowserSpecifier = (spec) => spec.startsWith("@angular/") && !SERVER_ONLY_ANGULAR_SPECIFIERS.has(spec) && !isBuildOnlyAngularSpecifier(spec), scanSourceImports = async (directories) => {
   const angular = new Set;
   const transitiveRoots = new Set;
-  const transpiler5 = new Bun.Transpiler({ loader: "tsx" });
+  const transpiler6 = new Bun.Transpiler({ loader: "tsx" });
   const glob = new Glob6("**/*.{ts,tsx,js,jsx}");
   for (const dir of directories) {
     try {
@@ -13621,7 +13726,7 @@ var REQUIRED_ANGULAR_SPECIFIERS_BASE, requiredAngularSpecifiers = (jitMode) => j
           continue;
         try {
           const content = await Bun.file(file4).text();
-          for (const imp of transpiler5.scanImports(content)) {
+          for (const imp of transpiler6.scanImports(content)) {
             if (isAngularBrowserSpecifier(imp.path)) {
               angular.add(imp.path);
             } else if (isBareSpecifier(imp.path)) {
@@ -13635,7 +13740,7 @@ var REQUIRED_ANGULAR_SPECIFIERS_BASE, requiredAngularSpecifiers = (jitMode) => j
   return { angular, transitiveRoots };
 }, PARTIAL_DECL_MARKERS, containsPartialDeclarations = (source) => PARTIAL_DECL_MARKERS.some((marker) => source.includes(marker)), collectTransitiveAngularSpecs = async (roots, angularFound) => {
   const { readFileSync: readFileSync12 } = await import("fs");
-  const transpiler5 = new Bun.Transpiler({ loader: "js" });
+  const transpiler6 = new Bun.Transpiler({ loader: "js" });
   const visited = new Set;
   const frontier = [];
   for (const r of roots)
@@ -13664,7 +13769,7 @@ var REQUIRED_ANGULAR_SPECIFIERS_BASE, requiredAngularSpecifiers = (jitMode) => j
       }
       let imports;
       try {
-        imports = transpiler5.scanImports(content);
+        imports = transpiler6.scanImports(content);
       } catch {
         continue;
       }
@@ -13694,14 +13799,14 @@ var REQUIRED_ANGULAR_SPECIFIERS_BASE, requiredAngularSpecifiers = (jitMode) => j
   await collectTransitiveAngularSpecs([...angular, ...transitiveRoots], angular);
   return Array.from(angular).filter(isResolvable2);
 }, buildAngularVendor = async (buildDir, directories = [], linkerJitMode = false, depVendorSpecifiers = []) => {
-  const vendorDir = join20(buildDir, "angular", "vendor");
+  const vendorDir = join21(buildDir, "angular", "vendor");
   mkdirSync8(vendorDir, { recursive: true });
-  const tmpDir = join20(buildDir, "_angular_vendor_tmp");
+  const tmpDir = join21(buildDir, "_angular_vendor_tmp");
   mkdirSync8(tmpDir, { recursive: true });
   const specifiers = await resolveAngularSpecifiers(directories, linkerJitMode);
   const entrypoints = await Promise.all(specifiers.map(async (specifier) => {
     const safeName = toSafeFileName2(specifier);
-    const entryPath = join20(tmpDir, `${safeName}.ts`);
+    const entryPath = join21(tmpDir, `${safeName}.ts`);
     await Bun.write(entryPath, await generateVendorEntrySource(specifier));
     return entryPath;
   }));
@@ -13732,9 +13837,9 @@ var REQUIRED_ANGULAR_SPECIFIERS_BASE, requiredAngularSpecifiers = (jitMode) => j
   const specifiers = await resolveAngularSpecifiers(directories, linkerJitMode);
   return computeAngularVendorPaths(specifiers);
 }, buildAngularServerVendor = async (buildDir, directories = [], linkerJitMode = false) => {
-  const vendorDir = join20(buildDir, "angular", "vendor", "server");
+  const vendorDir = join21(buildDir, "angular", "vendor", "server");
   mkdirSync8(vendorDir, { recursive: true });
-  const tmpDir = join20(buildDir, "_angular_server_vendor_tmp");
+  const tmpDir = join21(buildDir, "_angular_server_vendor_tmp");
   mkdirSync8(tmpDir, { recursive: true });
   const browserSpecs = await resolveAngularSpecifiers(directories, linkerJitMode);
   const allSpecs = new Set(browserSpecs);
@@ -13745,7 +13850,7 @@ var REQUIRED_ANGULAR_SPECIFIERS_BASE, requiredAngularSpecifiers = (jitMode) => j
   const specifiers = Array.from(allSpecs);
   const entrypoints = await Promise.all(specifiers.map(async (specifier) => {
     const safeName = toSafeFileName2(specifier);
-    const entryPath = join20(tmpDir, `${safeName}.ts`);
+    const entryPath = join21(tmpDir, `${safeName}.ts`);
     await Bun.write(entryPath, await generateVendorEntrySource(specifier));
     return entryPath;
   }));
@@ -13767,9 +13872,9 @@ var REQUIRED_ANGULAR_SPECIFIERS_BASE, requiredAngularSpecifiers = (jitMode) => j
   return specifiers;
 }, computeAngularServerVendorPaths = (buildDir, specifiers) => {
   const paths = {};
-  const vendorDir = join20(buildDir, "angular", "vendor", "server");
+  const vendorDir = join21(buildDir, "angular", "vendor", "server");
   for (const specifier of specifiers) {
-    paths[specifier] = join20(vendorDir, `${toSafeFileName2(specifier)}.js`);
+    paths[specifier] = join21(vendorDir, `${toSafeFileName2(specifier)}.js`);
   }
   return paths;
 }, computeAngularServerVendorPathsAsync = async (buildDir, directories = [], linkerJitMode = true) => {
@@ -13825,17 +13930,17 @@ __export(exports_buildVueVendor, {
   buildVueVendor: () => buildVueVendor
 });
 import { mkdirSync as mkdirSync9 } from "fs";
-import { join as join21 } from "path";
+import { join as join22 } from "path";
 import { rm as rm7 } from "fs/promises";
 var {build: bunBuild5 } = globalThis.Bun;
 var vueSpecifiers, toSafeFileName3 = (specifier) => specifier.replace(/\//g, "_"), buildVueVendor = async (buildDir) => {
-  const vendorDir = join21(buildDir, "vue", "vendor");
+  const vendorDir = join22(buildDir, "vue", "vendor");
   mkdirSync9(vendorDir, { recursive: true });
-  const tmpDir = join21(buildDir, "_vue_vendor_tmp");
+  const tmpDir = join22(buildDir, "_vue_vendor_tmp");
   mkdirSync9(tmpDir, { recursive: true });
   const entrypoints = await Promise.all(vueSpecifiers.map(async (specifier) => {
     const safeName = toSafeFileName3(specifier);
-    const entryPath = join21(tmpDir, `${safeName}.ts`);
+    const entryPath = join22(tmpDir, `${safeName}.ts`);
     await Bun.write(entryPath, `export * from '${specifier}';
 `);
     return entryPath;
@@ -13863,7 +13968,7 @@ var vueSpecifiers, toSafeFileName3 = (specifier) => specifier.replace(/\//g, "_"
   const { readFileSync: readFileSync12, writeFileSync: writeFileSync7, readdirSync } = await import("fs");
   const files = readdirSync(vendorDir).filter((f2) => f2.endsWith(".js"));
   for (const file4 of files) {
-    const filePath = join21(vendorDir, file4);
+    const filePath = join22(vendorDir, file4);
     const content = readFileSync12(filePath, "utf-8");
     if (!content.includes("__VUE_HMR_RUNTIME__"))
       continue;
@@ -13890,7 +13995,7 @@ __export(exports_buildSvelteVendor, {
   buildSvelteVendor: () => buildSvelteVendor
 });
 import { mkdirSync as mkdirSync10 } from "fs";
-import { join as join22 } from "path";
+import { join as join23 } from "path";
 import { rm as rm8 } from "fs/promises";
 var {build: bunBuild6 } = globalThis.Bun;
 var svelteSpecifiers, isResolvable3 = (specifier) => {
@@ -13904,13 +14009,13 @@ var svelteSpecifiers, isResolvable3 = (specifier) => {
   const specifiers = resolveVendorSpecifiers2();
   if (specifiers.length === 0)
     return;
-  const vendorDir = join22(buildDir, "svelte", "vendor");
+  const vendorDir = join23(buildDir, "svelte", "vendor");
   mkdirSync10(vendorDir, { recursive: true });
-  const tmpDir = join22(buildDir, "_svelte_vendor_tmp");
+  const tmpDir = join23(buildDir, "_svelte_vendor_tmp");
   mkdirSync10(tmpDir, { recursive: true });
   const entrypoints = await Promise.all(specifiers.map(async (specifier) => {
     const safeName = toSafeFileName4(specifier);
-    const entryPath = join22(tmpDir, `${safeName}.ts`);
+    const entryPath = join23(tmpDir, `${safeName}.ts`);
     await Bun.write(entryPath, `export * from '${specifier}';
 `);
     return entryPath;
@@ -13960,7 +14065,7 @@ __export(exports_rewriteImportsPlugin, {
   buildWithImportRewrite: () => buildWithImportRewrite
 });
 import { readdir as readdir3 } from "fs/promises";
-import { join as join23 } from "path";
+import { join as join24 } from "path";
 var escapeRegex2 = (str) => str.replace(/[.*+?^${}()|[\]\\]/g, "\\$&"), jsRewriteImports = (content, replacements) => {
   let result = content;
   for (const [specifier, webPath] of replacements) {
@@ -14089,7 +14194,7 @@ ${content}`;
       const entries = await readdir3(dir);
       for (const entry of entries) {
         if (entry.endsWith(".js"))
-          allFiles.push(join23(dir, entry));
+          allFiles.push(join24(dir, entry));
       }
     } catch {}
   }
@@ -14138,7 +14243,7 @@ import {
   statSync,
   writeFileSync as writeFileSync7
 } from "fs";
-import { basename as basename8, dirname as dirname13, extname as extname7, join as join24, relative as relative11, resolve as resolve21 } from "path";
+import { basename as basename8, dirname as dirname14, extname as extname7, join as join25, relative as relative12, resolve as resolve22 } from "path";
 import { cwd, env as env2, exit } from "process";
 var {build: bunBuild7, Glob: Glob7 } = globalThis.Bun;
 var isDev, isBuildTraceEnabled = () => {
@@ -14216,8 +14321,8 @@ var isDev, isBuildTraceEnabled = () => {
   mkdirSync11(htmxDestDir, { recursive: true });
   const glob = new Glob7("htmx*.min.js");
   for (const relPath of glob.scanSync({ cwd: htmxDir })) {
-    const src = join24(htmxDir, relPath);
-    const dest = join24(htmxDestDir, "htmx.min.js");
+    const src = join25(htmxDir, relPath);
+    const dest = join25(htmxDestDir, "htmx.min.js");
     copyFileSync(src, dest);
     return;
   }
@@ -14229,8 +14334,8 @@ var isDev, isBuildTraceEnabled = () => {
   }
 }, resolveAbsoluteVersion = async () => {
   const candidates = [
-    resolve21(import.meta.dir, "..", "..", "package.json"),
-    resolve21(import.meta.dir, "..", "package.json")
+    resolve22(import.meta.dir, "..", "..", "package.json"),
+    resolve22(import.meta.dir, "..", "package.json")
   ];
   const resolveCandidate = async (remaining) => {
     const [candidate, ...rest] = remaining;
@@ -14246,7 +14351,7 @@ var isDev, isBuildTraceEnabled = () => {
   };
   await resolveCandidate(candidates);
 }, SKIP_DIRS, addWorkerPathIfExists = (file4, relPath, workerPaths) => {
-  const absPath = resolve21(file4, "..", relPath);
+  const absPath = resolve22(file4, "..", relPath);
   try {
     statSync(absPath);
     workerPaths.add(absPath);
@@ -14292,7 +14397,7 @@ var isDev, isBuildTraceEnabled = () => {
   vuePagesPath
 }) => {
   const { readdirSync: readDir } = await import("fs");
-  const devIndexDir = join24(buildPath, "_src_indexes");
+  const devIndexDir = join25(buildPath, "_src_indexes");
   mkdirSync11(devIndexDir, { recursive: true });
   if (reactIndexesPath && reactPagesPath) {
     copyReactDevIndexes(reactIndexesPath, reactPagesPath, devIndexDir, readDir);
@@ -14308,37 +14413,37 @@ var isDev, isBuildTraceEnabled = () => {
     return;
   }
   const indexFiles = readDir(reactIndexesPath).filter((file4) => file4.endsWith(".tsx"));
-  const pagesRel = relative11(process.cwd(), resolve21(reactPagesPath)).replace(/\\/g, "/");
+  const pagesRel = relative12(process.cwd(), resolve22(reactPagesPath)).replace(/\\/g, "/");
   for (const file4 of indexFiles) {
-    let content = readFileSync12(join24(reactIndexesPath, file4), "utf-8");
+    let content = readFileSync12(join25(reactIndexesPath, file4), "utf-8");
     content = content.replace(/from\s*['"]([^'"]*\/pages\/([^'"]+))['"]/g, (_match, _fullPath, componentName) => `from '/@src/${pagesRel}/${componentName}'`);
-    writeFileSync7(join24(devIndexDir, file4), content);
+    writeFileSync7(join25(devIndexDir, file4), content);
   }
 }, copySvelteDevIndexes = (svelteDir, sveltePagesPath, svelteEntries, devIndexDir) => {
-  const svelteIndexDir = join24(getFrameworkGeneratedDir("svelte"), "indexes");
-  const sveltePageEntries = svelteEntries.filter((file4) => resolve21(file4).startsWith(resolve21(sveltePagesPath)));
+  const svelteIndexDir = join25(getFrameworkGeneratedDir("svelte"), "indexes");
+  const sveltePageEntries = svelteEntries.filter((file4) => resolve22(file4).startsWith(resolve22(sveltePagesPath)));
   for (const entry of sveltePageEntries) {
     const name = basename8(entry).replace(/\.svelte(\.(ts|js))?$/, "");
-    const indexFile = join24(svelteIndexDir, "pages", `${name}.js`);
+    const indexFile = join25(svelteIndexDir, "pages", `${name}.js`);
     if (!existsSync19(indexFile))
       continue;
     let content = readFileSync12(indexFile, "utf-8");
-    const srcRel = relative11(process.cwd(), resolve21(entry)).replace(/\\/g, "/");
+    const srcRel = relative12(process.cwd(), resolve22(entry)).replace(/\\/g, "/");
     content = content.replace(/import\s+Component\s+from\s+['"]([^'"]+)['"]/, `import Component from "/@src/${srcRel}"`);
-    writeFileSync7(join24(devIndexDir, `${name}.svelte.js`), content);
+    writeFileSync7(join25(devIndexDir, `${name}.svelte.js`), content);
   }
 }, copyVueDevIndexes = (vueDir, vuePagesPath, vueEntries, devIndexDir) => {
-  const vueIndexDir = join24(getFrameworkGeneratedDir("vue"), "indexes");
-  const vuePageEntries = vueEntries.filter((file4) => resolve21(file4).startsWith(resolve21(vuePagesPath)));
+  const vueIndexDir = join25(getFrameworkGeneratedDir("vue"), "indexes");
+  const vuePageEntries = vueEntries.filter((file4) => resolve22(file4).startsWith(resolve22(vuePagesPath)));
   for (const entry of vuePageEntries) {
     const name = basename8(entry, ".vue");
-    const indexFile = join24(vueIndexDir, `${name}.js`);
+    const indexFile = join25(vueIndexDir, `${name}.js`);
     if (!existsSync19(indexFile))
       continue;
     let content = readFileSync12(indexFile, "utf-8");
-    const srcRel = relative11(process.cwd(), resolve21(entry)).replace(/\\/g, "/");
+    const srcRel = relative12(process.cwd(), resolve22(entry)).replace(/\\/g, "/");
     content = content.replace(/import\s+Comp(?:\s*,\s*\*\s+as\s+\w+)?\s+from\s+['"]([^'"]+)['"]/, (match) => match.replace(/from\s+['"][^'"]+['"]/, `from "/@src/${srcRel}"`));
-    writeFileSync7(join24(devIndexDir, `${name}.vue.js`), content);
+    writeFileSync7(join25(devIndexDir, `${name}.vue.js`), content);
   }
 }, resolveVueRuntimeId = (content, firstUseName, outputPath, projectRoot) => {
   const varIdx = content.indexOf(`var ${firstUseName} =`);
@@ -14349,7 +14454,7 @@ var isDev, isBuildTraceEnabled = () => {
   const last = allComments[allComments.length - 1];
   if (!last?.[1])
     return JSON.stringify(outputPath);
-  const srcPath = resolve21(projectRoot, last[1].replace("/client/", "/").replace(/\.js$/, ".ts"));
+  const srcPath = resolve22(projectRoot, last[1].replace("/client/", "/").replace(/\.js$/, ".ts"));
   return JSON.stringify(srcPath);
 }, QUOTE_CHARS, OPEN_BRACES, CLOSE_BRACES, findFunctionExpressionEnd = (content, startPos) => {
   let depth = 0;
@@ -14411,7 +14516,7 @@ ${content.slice(firstUseIdx)}`;
 }, buildDevUrlFileMap = (urlReferencedFiles, projectRoot) => {
   const urlFileMap = new Map;
   for (const srcPath of urlReferencedFiles) {
-    const rel = relative11(projectRoot, srcPath).replace(/\\/g, "/");
+    const rel = relative12(projectRoot, srcPath).replace(/\\/g, "/");
     const name = basename8(srcPath);
     const mtime = Math.round(statSync(srcPath).mtimeMs);
     const url = `/@src/${rel}?v=${mtime}`;
@@ -14426,7 +14531,7 @@ ${content.slice(firstUseIdx)}`;
     const output = nonReactClientOutputs.find((artifact) => basename8(artifact.path).startsWith(`${srcBase}.`));
     if (!output)
       continue;
-    urlFileMap.set(basename8(srcPath), `/${relative11(buildPath, output.path).replace(/\\/g, "/")}`);
+    urlFileMap.set(basename8(srcPath), `/${relative12(buildPath, output.path).replace(/\\/g, "/")}`);
   }
   return urlFileMap;
 }, buildUrlFileMap = (urlReferencedFiles, hmr, projectRoot, buildPath, nonReactClientOutputs) => {
@@ -14560,10 +14665,10 @@ ${content.slice(firstUseIdx)}`;
       restoreTracePhase();
       return;
     }
-    const traceDir = join24(buildPath2, ".absolute-trace");
+    const traceDir = join25(buildPath2, ".absolute-trace");
     const timestamp = new Date().toISOString().replace(/[:.]/g, "-");
     mkdirSync11(traceDir, { recursive: true });
-    writeFileSync7(join24(traceDir, `build-trace-${timestamp}.json`), JSON.stringify({
+    writeFileSync7(join25(traceDir, `build-trace-${timestamp}.json`), JSON.stringify({
       events: traceEvents,
       frameworks: traceFrameworkNames,
       generatedAt: new Date().toISOString(),
@@ -14594,15 +14699,15 @@ ${content.slice(firstUseIdx)}`;
   const stylesPath = typeof stylesConfig === "string" ? stylesConfig : stylesConfig?.path;
   const stylesIgnore = typeof stylesConfig === "object" ? stylesConfig.ignore : undefined;
   const stylesDir = stylesPath && validateSafePath(stylesPath, projectRoot);
-  const reactIndexesPath = reactDir && join24(getFrameworkGeneratedDir("react"), "indexes");
-  const reactPagesPath = reactDir && join24(reactDir, "pages");
-  const htmlPagesPath = htmlDir && join24(htmlDir, "pages");
-  const htmlScriptsPath = htmlDir && join24(htmlDir, "scripts");
-  const sveltePagesPath = svelteDir && join24(svelteDir, "pages");
-  const vuePagesPath = vueDir && join24(vueDir, "pages");
-  const htmxPagesPath = htmxDir && join24(htmxDir, "pages");
-  const angularPagesPath = angularDir && join24(angularDir, "pages");
-  const emberPagesPath = emberDir && join24(emberDir, "pages");
+  const reactIndexesPath = reactDir && join25(getFrameworkGeneratedDir("react"), "indexes");
+  const reactPagesPath = reactDir && join25(reactDir, "pages");
+  const htmlPagesPath = htmlDir && join25(htmlDir, "pages");
+  const htmlScriptsPath = htmlDir && join25(htmlDir, "scripts");
+  const sveltePagesPath = svelteDir && join25(svelteDir, "pages");
+  const vuePagesPath = vueDir && join25(vueDir, "pages");
+  const htmxPagesPath = htmxDir && join25(htmxDir, "pages");
+  const angularPagesPath = angularDir && join25(angularDir, "pages");
+  const emberPagesPath = emberDir && join25(emberDir, "pages");
   const frontends = [
     reactDir,
     htmlDir,
@@ -14633,7 +14738,7 @@ ${content.slice(firstUseIdx)}`;
   const sourceClientRoots = [
     htmlDir,
     htmxDir,
-    islandBootstrapPath && dirname13(islandBootstrapPath)
+    islandBootstrapPath && dirname14(islandBootstrapPath)
   ].filter((dir) => Boolean(dir));
   const usesGenerated = Boolean(reactDir) || Boolean(svelteDir) || Boolean(vueDir) || Boolean(angularDir);
   if (usesGenerated)
@@ -14661,8 +14766,8 @@ ${content.slice(firstUseIdx)}`;
     const [firstEntry] = serverDirMap;
     if (!firstEntry)
       throw new Error("Expected at least one server directory entry");
-    serverRoot = join24(firstEntry.dir, firstEntry.subdir);
-    serverOutDir = join24(buildPath, basename8(firstEntry.dir));
+    serverRoot = join25(firstEntry.dir, firstEntry.subdir);
+    serverOutDir = join25(buildPath, basename8(firstEntry.dir));
   } else if (serverDirMap.length > 1) {
     serverRoot = commonAncestor(serverDirMap.map((entry) => entry.dir), projectRoot);
     serverOutDir = buildPath;
@@ -14674,13 +14779,13 @@ ${content.slice(firstUseIdx)}`;
   const filterToIncrementalEntries = (entryPoints, mapToSource) => {
     if (!isIncremental || !incrementalFiles)
       return entryPoints;
-    const normalizedIncremental = new Set(incrementalFiles.map((f2) => resolve21(f2)));
+    const normalizedIncremental = new Set(incrementalFiles.map((f2) => resolve22(f2)));
     const matchingEntries = [];
     for (const entry of entryPoints) {
       const sourceFile = mapToSource(entry);
       if (!sourceFile)
         continue;
-      if (!normalizedIncremental.has(resolve21(sourceFile)))
+      if (!normalizedIncremental.has(resolve22(sourceFile)))
         continue;
       matchingEntries.push(entry);
     }
@@ -14690,7 +14795,7 @@ ${content.slice(firstUseIdx)}`;
     await tracePhase("react/index-generation", () => generateReactIndexFiles(reactPagesPath, reactIndexesPath, hmr));
   }
   if (assetsPath && (!isIncremental || normalizedIncrementalFiles?.some((f2) => f2.includes("/assets/")))) {
-    await tracePhase("assets/copy", () => cpSync(assetsPath, join24(buildPath, "assets"), {
+    await tracePhase("assets/copy", () => cpSync(assetsPath, join25(buildPath, "assets"), {
       force: true,
       recursive: true
     }));
@@ -14700,6 +14805,15 @@ ${content.slice(firstUseIdx)}`;
     conventions: undefined,
     pageFiles: []
   };
+  const htmlConventionDirs = [
+    reactPagesPath,
+    sveltePagesPath,
+    vuePagesPath,
+    angularPagesPath,
+    emberPagesPath,
+    htmlPagesPath,
+    htmxPagesPath
+  ].filter((path) => Boolean(path));
   const [
     ,
     allReactEntries,
@@ -14709,6 +14823,7 @@ ${content.slice(firstUseIdx)}`;
     vueConventionResult,
     angularConventionResult,
     emberConventionResult,
+    htmlConventionResults,
     allGlobalCssEntries
   ] = await Promise.all([
     tailwindPromise,
@@ -14719,6 +14834,7 @@ ${content.slice(firstUseIdx)}`;
     vuePagesPath ? tracePhase("scan/vue-conventions", () => scanConventions(vuePagesPath, "*.vue")) : emptyConventionResult,
     angularPagesPath ? tracePhase("scan/angular-conventions", () => scanConventions(angularPagesPath, "*.ts")) : emptyConventionResult,
     emberPagesPath ? tracePhase("scan/ember-conventions", () => scanConventions(emberPagesPath, "*.{gjs,gts,ts}")) : emptyConventionResult,
+    tracePhase("scan/html-conventions", async () => Promise.all(htmlConventionDirs.map((dir) => scanConventions(dir, "*.html")))),
     stylesDir ? tracePhase("scan/css", () => scanCssEntryPoints(stylesDir, stylesIgnore)) : []
   ]);
   const allSvelteEntries = svelteConventionResult.pageFiles;
@@ -14736,15 +14852,99 @@ ${content.slice(firstUseIdx)}`;
     conventionsMap.angular = angularConventionResult.conventions;
   if (emberConventionResult.conventions)
     conventionsMap.ember = emberConventionResult.conventions;
-  const notFoundFrameworks = ["react", "svelte", "vue", "angular", "ember"].filter((framework) => conventionsMap[framework]?.defaults?.notFound);
+  const htmlDefaults = {};
+  const htmlPages = {};
+  const htmlConventionSources = [];
+  for (let idx = 0;idx < htmlConventionResults.length; idx++) {
+    const result = htmlConventionResults[idx];
+    if (!result?.conventions)
+      continue;
+    const dirLabel = htmlConventionDirs[idx] ?? "<unknown>";
+    const { defaults: scannedDefaults, pages: scannedPages } = result.conventions;
+    if (scannedDefaults?.error) {
+      if (htmlDefaults.error) {
+        logWarn(`Multiple error.html files found; using ${htmlDefaults.error} and ignoring ${scannedDefaults.error} (${dirLabel}).`);
+      } else {
+        htmlDefaults.error = scannedDefaults.error;
+        htmlConventionSources.push(scannedDefaults.error);
+      }
+    }
+    if (scannedDefaults?.notFound) {
+      if (htmlDefaults.notFound) {
+        logWarn(`Multiple not-found.html files found; using ${htmlDefaults.notFound} and ignoring ${scannedDefaults.notFound} (${dirLabel}).`);
+      } else {
+        htmlDefaults.notFound = scannedDefaults.notFound;
+        htmlConventionSources.push(scannedDefaults.notFound);
+      }
+    }
+    if (scannedDefaults?.loading && !htmlDefaults.loading) {
+      htmlDefaults.loading = scannedDefaults.loading;
+      htmlConventionSources.push(scannedDefaults.loading);
+    }
+    if (scannedPages) {
+      for (const [pageName, page] of Object.entries(scannedPages)) {
+        if (!htmlPages[pageName])
+          htmlPages[pageName] = {};
+        if (page.error && !htmlPages[pageName].error) {
+          htmlPages[pageName].error = page.error;
+          htmlConventionSources.push(page.error);
+        }
+        if (page.loading && !htmlPages[pageName].loading) {
+          htmlPages[pageName].loading = page.loading;
+          htmlConventionSources.push(page.loading);
+        }
+      }
+    }
+  }
+  if (htmlDefaults.error || htmlDefaults.notFound || htmlDefaults.loading || Object.keys(htmlPages).length > 0) {
+    const htmlConventionsOutDir = join25(buildPath, "conventions", "html");
+    mkdirSync11(htmlConventionsOutDir, { recursive: true });
+    const htmlPathRemap = new Map;
+    for (const sourcePath of htmlConventionSources) {
+      const dest = join25(htmlConventionsOutDir, basename8(sourcePath));
+      cpSync(sourcePath, dest, { force: true });
+      htmlPathRemap.set(sourcePath, dest);
+    }
+    const remap = (path) => path ? htmlPathRemap.get(path) ?? path : undefined;
+    const htmlConventions = {};
+    const remappedDefaults = {};
+    const errorRemap = remap(htmlDefaults.error);
+    if (errorRemap)
+      remappedDefaults.error = errorRemap;
+    const notFoundRemap = remap(htmlDefaults.notFound);
+    if (notFoundRemap)
+      remappedDefaults.notFound = notFoundRemap;
+    const loadingRemap = remap(htmlDefaults.loading);
+    if (loadingRemap)
+      remappedDefaults.loading = loadingRemap;
+    if (remappedDefaults.error || remappedDefaults.notFound || remappedDefaults.loading) {
+      htmlConventions.defaults = remappedDefaults;
+    }
+    if (Object.keys(htmlPages).length > 0) {
+      const remappedPages = {};
+      for (const [pageName, page] of Object.entries(htmlPages)) {
+        const entry = {};
+        const errorPath = remap(page.error);
+        if (errorPath)
+          entry.error = errorPath;
+        const loadingPath = remap(page.loading);
+        if (loadingPath)
+          entry.loading = loadingPath;
+        remappedPages[pageName] = entry;
+      }
+      htmlConventions.pages = remappedPages;
+    }
+    conventionsMap.html = htmlConventions;
+  }
+  const notFoundFrameworks = ["react", "svelte", "vue", "angular", "ember", "html"].filter((framework) => conventionsMap[framework]?.defaults?.notFound);
   if (notFoundFrameworks.length > 1) {
     logWarn(`Multiple frameworks define not-found convention files: ${notFoundFrameworks.join(", ")}. Only one will be used (priority: ${notFoundFrameworks[0]}). Remove not-found files from other frameworks to avoid ambiguity.`);
   }
   const shouldIncludeHtmlAssets = !isIncremental || normalizedIncrementalFiles?.some((f2) => f2.includes("/html/") && (f2.endsWith(".html") || isStylePath(f2)));
   const reactEntries = isIncremental && reactIndexesPath && reactPagesPath ? filterToIncrementalEntries(allReactEntries, (entry) => {
-    if (entry.startsWith(resolve21(reactIndexesPath))) {
+    if (entry.startsWith(resolve22(reactIndexesPath))) {
       const pageName = basename8(entry, ".tsx");
-      return join24(reactPagesPath, `${pageName}.tsx`);
+      return join25(reactPagesPath, `${pageName}.tsx`);
     }
     return null;
   }) : allReactEntries;
@@ -14821,7 +15021,7 @@ ${content.slice(firstUseIdx)}`;
     const clientPath = islandSvelteClientPaths[idx];
     if (!sourcePath || !clientPath)
       continue;
-    islandSvelteClientPathMap.set(resolve21(sourcePath), clientPath);
+    islandSvelteClientPathMap.set(resolve22(sourcePath), clientPath);
   }
   const islandVueClientPathMap = new Map;
   for (let idx = 0;idx < islandVueSources.length; idx++) {
@@ -14829,7 +15029,7 @@ ${content.slice(firstUseIdx)}`;
     const clientPath = islandVueClientPaths[idx];
     if (!sourcePath || !clientPath)
       continue;
-    islandVueClientPathMap.set(resolve21(sourcePath), clientPath);
+    islandVueClientPathMap.set(resolve22(sourcePath), clientPath);
   }
   const islandAngularClientPathMap = new Map;
   for (let idx = 0;idx < islandAngularSources.length; idx++) {
@@ -14837,7 +15037,7 @@ ${content.slice(firstUseIdx)}`;
     const clientPath = islandAngularClientPaths[idx];
     if (!sourcePath || !clientPath)
       continue;
-    islandAngularClientPathMap.set(resolve21(sourcePath), clientPath);
+    islandAngularClientPathMap.set(resolve22(sourcePath), clientPath);
   }
   const reactConventionSources = collectConventionSourceFiles(conventionsMap.react);
   const svelteConventionSources = collectConventionSourceFiles(conventionsMap.svelte);
@@ -14848,7 +15048,7 @@ ${content.slice(firstUseIdx)}`;
     const compileReactConventions = async () => {
       if (reactConventionSources.length === 0)
         return emptyStringArray;
-      const destDir = join24(buildPath, "conventions", "react");
+      const destDir = join25(buildPath, "conventions", "react");
       rmSync2(destDir, { force: true, recursive: true });
       mkdirSync11(destDir, { recursive: true });
       const destPaths = [];
@@ -14864,7 +15064,7 @@ ${content.slice(firstUseIdx)}`;
           naming: `${idx}-[name].[ext]`,
           outdir: destDir,
           plugins: [stylePreprocessorPlugin2],
-          root: dirname13(source),
+          root: dirname14(source),
           target: "bun",
           throw: false,
           tsconfig: "./tsconfig.json"
@@ -14892,7 +15092,7 @@ ${content.slice(firstUseIdx)}`;
       angularConventionSources.length > 0 && angularDir ? tracePhase("compile/convention-angular", () => Promise.resolve().then(() => (init_compileAngular(), exports_compileAngular)).then((mod) => mod.compileAngular(angularConventionSources, angularDir, hmr, styleTransformConfig))) : { serverPaths: emptyStringArray }
     ]);
     const bundleConventionFiles = async (framework, compiledPaths) => {
-      const destDir = join24(buildPath, "conventions", framework);
+      const destDir = join25(buildPath, "conventions", framework);
       rmSync2(destDir, { force: true, recursive: true });
       mkdirSync11(destDir, { recursive: true });
       const destPaths = [];
@@ -14966,7 +15166,7 @@ ${content.slice(firstUseIdx)}`;
     }
   })) : {
     entries: [],
-    generatedRoot: join24(buildPath, "_island_entries")
+    generatedRoot: join25(buildPath, "_island_entries")
   };
   const islandClientEntryPoints = islandEntryResult.entries.map((entry) => entry.entryPath);
   if (serverEntryPoints.length === 0 && reactClientEntryPoints.length === 0 && nonReactClientEntryPoints.length === 0 && islandClientEntryPoints.length === 0 && htmxDir === undefined && htmlDir === undefined) {
@@ -15002,7 +15202,7 @@ ${content.slice(firstUseIdx)}`;
     return {};
   }
   if (hmr && reactIndexesPath && reactClientEntryPoints.length > 0) {
-    const refreshEntry = join24(reactIndexesPath, "_refresh.tsx");
+    const refreshEntry = join25(reactIndexesPath, "_refresh.tsx");
     if (!reactClientEntryPoints.includes(refreshEntry))
       reactClientEntryPoints.push(refreshEntry);
   }
@@ -15101,19 +15301,19 @@ ${content.slice(firstUseIdx)}`;
     throw: false
   }, resolveBunBuildOverride(bunBuildConfig, "reactClient")) : undefined;
   if (reactDir && reactClientEntryPoints.length > 0) {
-    rmSync2(join24(buildPath, "react", "generated", "indexes"), {
+    rmSync2(join25(buildPath, "react", "generated", "indexes"), {
       force: true,
       recursive: true
     });
   }
   if (angularDir && angularClientPaths.length > 0) {
-    rmSync2(join24(buildPath, "angular", "indexes"), {
+    rmSync2(join25(buildPath, "angular", "indexes"), {
       force: true,
       recursive: true
     });
   }
   if (islandClientEntryPoints.length > 0) {
-    rmSync2(join24(buildPath, "islands"), {
+    rmSync2(join25(buildPath, "islands"), {
       force: true,
       recursive: true
     });
@@ -15196,7 +15396,7 @@ ${content.slice(firstUseIdx)}`;
     globalCssEntries.length > 0 ? tracePhase("bun/global-css", () => bunBuild7(mergeBunBuildConfig({
       entrypoints: globalCssEntries,
       naming: `[dir]/[name].[hash].[ext]`,
-      outdir: stylesDir ? join24(buildPath, basename8(stylesDir)) : buildPath,
+      outdir: stylesDir ? join25(buildPath, basename8(stylesDir)) : buildPath,
       plugins: [stylePreprocessorPlugin2],
       root: stylesDir || clientRoot,
       target: "browser",
@@ -15205,7 +15405,7 @@ ${content.slice(firstUseIdx)}`;
     vueCssPaths.length > 0 ? tracePhase("bun/vue-css", () => bunBuild7(mergeBunBuildConfig({
       entrypoints: vueCssPaths,
       naming: `[name].[hash].[ext]`,
-      outdir: join24(buildPath, assetsPath ? basename8(assetsPath) : "assets", "css"),
+      outdir: join25(buildPath, assetsPath ? basename8(assetsPath) : "assets", "css"),
       target: "browser",
       throw: false
     }, resolveBunBuildOverride(bunBuildConfig, "vueCss")))) : undefined
@@ -15272,10 +15472,10 @@ ${content.slice(firstUseIdx)}`;
   if (serverOutputs.length > 0 && angularServerVendorPaths2 && Object.keys(angularServerVendorPaths2).length > 0) {
     const { rewriteBuildOutputsWith: rewriteBuildOutputsWith2 } = await Promise.resolve().then(() => (init_rewriteImportsPlugin(), exports_rewriteImportsPlugin));
     await tracePhase("postprocess/server-angular-vendor-imports", () => rewriteBuildOutputsWith2(serverOutputs, (artifact) => {
-      const fileDir = dirname13(artifact.path);
+      const fileDir = dirname14(artifact.path);
       const relativePaths = {};
       for (const [specifier, absolute] of Object.entries(angularServerVendorPaths2)) {
-        const rel = relative11(fileDir, absolute);
+        const rel = relative12(fileDir, absolute);
         relativePaths[specifier] = rel.startsWith(".") ? rel : `./${rel}`;
       }
       return relativePaths;
@@ -15344,7 +15544,7 @@ ${content.slice(firstUseIdx)}`;
   if (skipAngularClientBundle) {
     for (const clientPath of angularClientPaths) {
       const fileBase = basename8(clientPath, ".js");
-      const relFromCwd = relative11(projectRoot, clientPath).replace(/\\/g, "/");
+      const relFromCwd = relative12(projectRoot, clientPath).replace(/\\/g, "/");
       manifest[`${toPascal(fileBase)}Index`] = `/@src/${relFromCwd}`;
     }
   }
@@ -15366,7 +15566,7 @@ ${content.slice(firstUseIdx)}`;
   const processHtmlPages = async () => {
     if (!(htmlDir && htmlPagesPath))
       return;
-    const outputHtmlPages = isSingle ? join24(buildPath, "pages") : join24(buildPath, basename8(htmlDir), "pages");
+    const outputHtmlPages = isSingle ? join25(buildPath, "pages") : join25(buildPath, basename8(htmlDir), "pages");
     mkdirSync11(outputHtmlPages, { recursive: true });
     cpSync(htmlPagesPath, outputHtmlPages, {
       force: true,
@@ -15388,14 +15588,14 @@ ${content.slice(firstUseIdx)}`;
   const processHtmxPages = async () => {
     if (!(htmxDir && htmxPagesPath))
       return;
-    const outputHtmxPages = isSingle ? join24(buildPath, "pages") : join24(buildPath, basename8(htmxDir), "pages");
+    const outputHtmxPages = isSingle ? join25(buildPath, "pages") : join25(buildPath, basename8(htmxDir), "pages");
     mkdirSync11(outputHtmxPages, { recursive: true });
     cpSync(htmxPagesPath, outputHtmxPages, {
       force: true,
       recursive: true
     });
     if (shouldCopyHtmx) {
-      const htmxDestDir = isSingle ? buildPath : join24(buildPath, basename8(htmxDir));
+      const htmxDestDir = isSingle ? buildPath : join25(buildPath, basename8(htmxDir));
       copyHtmxVendor(htmxDir, htmxDestDir);
     }
     if (shouldUpdateHtmxAssetPaths) {
@@ -15457,9 +15657,9 @@ ${content.slice(firstUseIdx)}`;
     writeBuildTrace(buildPath);
     return { conventions: conventionsMap, manifest };
   }
-  writeFileSync7(join24(buildPath, "manifest.json"), JSON.stringify(manifest, null, "\t"));
+  writeFileSync7(join25(buildPath, "manifest.json"), JSON.stringify(manifest, null, "\t"));
   if (Object.keys(conventionsMap).length > 0) {
-    writeFileSync7(join24(buildPath, "conventions.json"), JSON.stringify(conventionsMap, null, "\t"));
+    writeFileSync7(join25(buildPath, "conventions.json"), JSON.stringify(conventionsMap, null, "\t"));
   }
   writeBuildTrace(buildPath);
   if (tailwind && mode === "production") {
@@ -15560,7 +15760,7 @@ var init_build = __esm(() => {
 
 // src/build/buildEmberVendor.ts
 import { mkdirSync as mkdirSync12, existsSync as existsSync20 } from "fs";
-import { join as join25 } from "path";
+import { join as join26 } from "path";
 import { rm as rm9 } from "fs/promises";
 var {build: bunBuild8 } = globalThis.Bun;
 var toSafeFileName5 = (specifier) => specifier.replace(/^@/, "").replace(/\//g, "_"), generateMacrosShim = () => `// Generated shim for @embroider/macros \u2014 provides minimal runtime
@@ -15612,7 +15812,7 @@ export const importSync = (specifier) => {
   if (standaloneSpecifiers.has(specifier)) {
     return { resolveTo: specifier, specifier };
   }
-  const emberInternalPath = join25(cwd2, "node_modules/ember-source/dist/packages", specifier, "index.js");
+  const emberInternalPath = join26(cwd2, "node_modules/ember-source/dist/packages", specifier, "index.js");
   if (!existsSync20(emberInternalPath)) {
     throw new Error(`Ember vendor build: cannot find ${specifier} at ${emberInternalPath}. ` + `Is ember-source installed and at least 6.12?`);
   }
@@ -15644,7 +15844,7 @@ export const importSync = (specifier) => {
       if (standalonePackages.has(args.path)) {
         return;
       }
-      const internal = join25(cwd2, "node_modules/ember-source/dist/packages", args.path, "index.js");
+      const internal = join26(cwd2, "node_modules/ember-source/dist/packages", args.path, "index.js");
       if (existsSync20(internal)) {
         return { path: internal };
       }
@@ -15652,16 +15852,16 @@ export const importSync = (specifier) => {
     });
   }
 }), buildEmberVendor = async (buildDir, cwd2 = process.cwd()) => {
-  const vendorDir = join25(buildDir, "ember", "vendor");
+  const vendorDir = join26(buildDir, "ember", "vendor");
   mkdirSync12(vendorDir, { recursive: true });
-  const tmpDir = join25(buildDir, "_ember_vendor_tmp");
+  const tmpDir = join26(buildDir, "_ember_vendor_tmp");
   mkdirSync12(tmpDir, { recursive: true });
-  const macrosShimPath = join25(tmpDir, "embroider_macros_shim.js");
+  const macrosShimPath = join26(tmpDir, "embroider_macros_shim.js");
   await Bun.write(macrosShimPath, generateMacrosShim());
   const resolutions = REQUIRED_EMBER_SPECIFIERS.map((specifier) => resolveEmberSpecifier(specifier, cwd2));
   const entrypoints = await Promise.all(resolutions.map(async (resolution) => {
     const safeName = toSafeFileName5(resolution.specifier);
-    const entryPath = join25(tmpDir, `${safeName}.js`);
+    const entryPath = join26(tmpDir, `${safeName}.js`);
     const source = resolution.specifier === "@embroider/macros" ? `export * from ${JSON.stringify(macrosShimPath)};
 ` : generateVendorEntrySource2(resolution);
     await Bun.write(entryPath, source);
@@ -15707,7 +15907,7 @@ var init_buildEmberVendor = __esm(() => {
 // src/dev/dependencyGraph.ts
 import { existsSync as existsSync21, readFileSync as readFileSync13 } from "fs";
 var {Glob: Glob8 } = globalThis.Bun;
-import { resolve as resolve22 } from "path";
+import { resolve as resolve23 } from "path";
 var emptyDependencyGraph, tsTranspiler, jsTranspiler, loaderForFile = (filePath) => {
   const lower = filePath.toLowerCase();
   if (lower.endsWith(".ts") || lower.endsWith(".tsx") || lower.endsWith(".jsx"))
@@ -15721,8 +15921,8 @@ var emptyDependencyGraph, tsTranspiler, jsTranspiler, loaderForFile = (filePath)
   if (!importPath.startsWith(".") && !importPath.startsWith("/")) {
     return null;
   }
-  const fromDir = resolve22(fromFile, "..");
-  const normalized = resolve22(fromDir, importPath);
+  const fromDir = resolve23(fromFile, "..");
+  const normalized = resolve23(fromDir, importPath);
   const extensions = [
     ".ts",
     ".tsx",
@@ -15752,7 +15952,7 @@ var emptyDependencyGraph, tsTranspiler, jsTranspiler, loaderForFile = (filePath)
     dependents.delete(normalizedPath);
   }
 }, addFileToGraph = (graph, filePath) => {
-  const normalizedPath = resolve22(filePath);
+  const normalizedPath = resolve23(filePath);
   if (!existsSync21(normalizedPath))
     return;
   const dependencies = extractDependencies(normalizedPath);
@@ -15769,10 +15969,10 @@ var emptyDependencyGraph, tsTranspiler, jsTranspiler, loaderForFile = (filePath)
 }, IGNORED_SEGMENTS, buildInitialDependencyGraph = (graph, directories) => {
   const processedFiles = new Set;
   const glob = new Glob8("**/*.{ts,tsx,js,jsx,vue,svelte,html,htm}");
-  const resolvedDirs = directories.map((dir) => resolve22(dir)).filter((dir) => existsSync21(dir));
+  const resolvedDirs = directories.map((dir) => resolve23(dir)).filter((dir) => existsSync21(dir));
   const allFiles = resolvedDirs.flatMap((dir) => Array.from(glob.scanSync({ absolute: true, cwd: dir })));
   for (const file4 of allFiles) {
-    const fullPath = resolve22(file4);
+    const fullPath = resolve23(file4);
     if (IGNORED_SEGMENTS.some((seg) => fullPath.includes(seg)))
       continue;
     if (processedFiles.has(fullPath))
@@ -15827,8 +16027,8 @@ var emptyDependencyGraph, tsTranspiler, jsTranspiler, loaderForFile = (filePath)
   resolveRegexMatches(styleUrlSingularRegex, content, filePath, dependencies);
   extractStyleUrlsDependencies(content, filePath, dependencies);
 }, extractJsDependencies = (filePath, content, loader) => {
-  const transpiler5 = loader === "tsx" ? tsTranspiler : jsTranspiler;
-  const imports = transpiler5.scanImports(content);
+  const transpiler6 = loader === "tsx" ? tsTranspiler : jsTranspiler;
+  const imports = transpiler6.scanImports(content);
   const dependencies = [];
   for (const imp of imports) {
     const resolved = resolveImportPath2(imp.path, filePath);
@@ -15885,7 +16085,7 @@ var emptyDependencyGraph, tsTranspiler, jsTranspiler, loaderForFile = (filePath)
     return [];
   }
 }, getAffectedFiles = (graph, changedFile) => {
-  const normalizedPath = resolve22(changedFile);
+  const normalizedPath = resolve23(changedFile);
   const affected = new Set;
   const toProcess = [normalizedPath];
   const processNode = (current) => {
@@ -15925,7 +16125,7 @@ var emptyDependencyGraph, tsTranspiler, jsTranspiler, loaderForFile = (filePath)
   }
   graph.dependents.delete(normalizedPath);
 }, removeFileFromGraph = (graph, filePath) => {
-  const normalizedPath = resolve22(filePath);
+  const normalizedPath = resolve23(filePath);
   removeDepsForFile(graph, normalizedPath);
   removeDependentsForFile(graph, normalizedPath);
 };
@@ -15968,12 +16168,12 @@ var globalVersionCounter = 0, createModuleVersionTracker = () => new Map, getNex
 };
 
 // src/dev/configResolver.ts
-import { resolve as resolve23 } from "path";
+import { resolve as resolve24 } from "path";
 var resolveBuildPaths = (config) => {
   const cwd2 = process.cwd();
   const normalize = (path) => path.replace(/\\/g, "/");
-  const withDefault = (value, fallback) => normalize(resolve23(cwd2, value ?? fallback));
-  const optional = (value) => value ? normalize(resolve23(cwd2, value)) : undefined;
+  const withDefault = (value, fallback) => normalize(resolve24(cwd2, value ?? fallback));
+  const optional = (value) => value ? normalize(resolve24(cwd2, value)) : undefined;
   return {
     angularDir: optional(config.angularDirectory),
     assetsDir: optional(config.assetsDirectory),
@@ -16026,7 +16226,7 @@ var init_clientManager = __esm(() => {
 
 // src/dev/pathUtils.ts
 import { existsSync as existsSync22, readdirSync, readFileSync as readFileSync14 } from "fs";
-import { dirname as dirname14, resolve as resolve24 } from "path";
+import { dirname as dirname15, resolve as resolve25 } from "path";
 var STYLE_EXTENSION_PATTERN2, detectFramework = (filePath, resolved) => {
   if (shouldIgnorePath(filePath, resolved)) {
     return "ignored";
@@ -16102,7 +16302,7 @@ var STYLE_EXTENSION_PATTERN2, detectFramework = (filePath, resolved) => {
   return "unknown";
 }, collectAngularResourceDirs = (angularDir) => {
   const out = new Set;
-  const angularRoot = resolve24(angularDir);
+  const angularRoot = resolve25(angularDir);
   const angularRootNormalized = normalizePath(angularRoot);
   const walk = (dir) => {
     let entries;
@@ -16115,7 +16315,7 @@ var STYLE_EXTENSION_PATTERN2, detectFramework = (filePath, resolved) => {
       if (entry.name.startsWith(".") || entry.name === "node_modules") {
         continue;
       }
-      const full = resolve24(dir, entry.name);
+      const full = resolve25(dir, entry.name);
       if (entry.isDirectory()) {
         walk(full);
         continue;
@@ -16154,10 +16354,10 @@ var STYLE_EXTENSION_PATTERN2, detectFramework = (filePath, resolved) => {
             refs.push(strMatch[1]);
         }
       }
-      const componentDir = dirname14(full);
+      const componentDir = dirname15(full);
       for (const ref of refs) {
-        const refAbs = normalizePath(resolve24(componentDir, ref));
-        const refDir = normalizePath(dirname14(refAbs));
+        const refAbs = normalizePath(resolve25(componentDir, ref));
+        const refDir = normalizePath(dirname15(refAbs));
         if (refDir === angularRootNormalized || refDir.startsWith(angularRootNormalized + "/")) {
           continue;
         }
@@ -16173,7 +16373,7 @@ var STYLE_EXTENSION_PATTERN2, detectFramework = (filePath, resolved) => {
   const push = (path) => {
     if (!path)
       return;
-    const abs = normalizePath(resolve24(cwd2, path));
+    const abs = normalizePath(resolve25(cwd2, path));
     if (!roots.includes(abs))
       roots.push(abs);
   };
@@ -16198,7 +16398,7 @@ var STYLE_EXTENSION_PATTERN2, detectFramework = (filePath, resolved) => {
   push(cfg.assetsDir);
   push(cfg.stylesDir);
   for (const candidate of ["src", "db", "assets", "styles"]) {
-    const abs = normalizePath(resolve24(cwd2, candidate));
+    const abs = normalizePath(resolve25(cwd2, candidate));
     if (existsSync22(abs) && !roots.includes(abs))
       roots.push(abs);
   }
@@ -16269,7 +16469,7 @@ var init_pathUtils = __esm(() => {
 // src/dev/fileWatcher.ts
 import { watch } from "fs";
 import { existsSync as existsSync23 } from "fs";
-import { join as join26, resolve as resolve25 } from "path";
+import { join as join27, resolve as resolve26 } from "path";
 var safeRemoveFromGraph = (graph, fullPath) => {
   try {
     removeFileFromGraph(graph, fullPath);
@@ -16296,7 +16496,7 @@ var safeRemoveFromGraph = (graph, fullPath) => {
     if (shouldSkipFilename(filename, isStylesDir)) {
       return;
     }
-    const fullPath = join26(absolutePath, filename).replace(/\\/g, "/");
+    const fullPath = join27(absolutePath, filename).replace(/\\/g, "/");
     if (shouldIgnorePath(fullPath, state.resolvedPaths)) {
       return;
     }
@@ -16314,7 +16514,7 @@ var safeRemoveFromGraph = (graph, fullPath) => {
 }, addFileWatchers = (state, paths, onFileChange) => {
   const stylesDir = state.resolvedPaths?.stylesDir;
   paths.forEach((path) => {
-    const absolutePath = resolve25(path).replace(/\\/g, "/");
+    const absolutePath = resolve26(path).replace(/\\/g, "/");
     if (!existsSync23(absolutePath)) {
       return;
     }
@@ -16325,7 +16525,7 @@ var safeRemoveFromGraph = (graph, fullPath) => {
   const watchPaths = getWatchPaths(config, state.resolvedPaths);
   const stylesDir = state.resolvedPaths?.stylesDir;
   watchPaths.forEach((path) => {
-    const absolutePath = resolve25(path).replace(/\\/g, "/");
+    const absolutePath = resolve26(path).replace(/\\/g, "/");
     if (!existsSync23(absolutePath)) {
       return;
     }
@@ -16340,13 +16540,13 @@ var init_fileWatcher = __esm(() => {
 });
 
 // src/dev/assetStore.ts
-import { resolve as resolve26 } from "path";
+import { resolve as resolve27 } from "path";
 import { readdir as readdir4, unlink } from "fs/promises";
 var mimeTypes, getMimeType = (filePath) => {
   const ext = filePath.slice(filePath.lastIndexOf("."));
   return mimeTypes[ext] ?? "application/octet-stream";
 }, HASHED_FILE_RE, stripHash = (webPath) => webPath.replace(/\.[a-z0-9]{8}(\.(js|css|mjs))$/, "$1"), processWalkEntry = (entry, dir, liveByIdentity, walkAndClean) => {
-  const fullPath = resolve26(dir, entry.name);
+  const fullPath = resolve27(dir, entry.name);
   if (entry.isDirectory()) {
     return walkAndClean(fullPath);
   }
@@ -16362,10 +16562,10 @@ var mimeTypes, getMimeType = (filePath) => {
 }, cleanStaleAssets = async (store, manifest, buildDir) => {
   const liveByIdentity = new Map;
   for (const webPath of store.keys()) {
-    const diskPath = resolve26(buildDir, webPath.slice(1));
+    const diskPath = resolve27(buildDir, webPath.slice(1));
     liveByIdentity.set(stripHash(diskPath), diskPath);
   }
-  const absBuildDir = resolve26(buildDir);
+  const absBuildDir = resolve27(buildDir);
   Object.values(manifest).forEach((val) => {
     if (!HASHED_FILE_RE.test(val))
       return;
@@ -16383,7 +16583,7 @@ var mimeTypes, getMimeType = (filePath) => {
   } catch {}
 }, lookupAsset = (store, path) => store.get(path), processScanEntry = (entry, dir, prefix, store, scanDir) => {
   if (entry.isDirectory()) {
-    return scanDir(resolve26(dir, entry.name), `${prefix}${entry.name}/`);
+    return scanDir(resolve27(dir, entry.name), `${prefix}${entry.name}/`);
   }
   if (!entry.name.startsWith("chunk-")) {
     return null;
@@ -16392,7 +16592,7 @@ var mimeTypes, getMimeType = (filePath) => {
   if (store.has(webPath)) {
     return null;
   }
-  return Bun.file(resolve26(dir, entry.name)).bytes().then((bytes) => {
+  return Bun.file(resolve27(dir, entry.name)).bytes().then((bytes) => {
     store.set(webPath, bytes);
     return;
   }).catch(() => {});
@@ -16414,7 +16614,7 @@ var mimeTypes, getMimeType = (filePath) => {
   for (const webPath of newIdentities.values()) {
     if (store.has(webPath))
       continue;
-    loadPromises.push(Bun.file(resolve26(buildDir, webPath.slice(1))).bytes().then((bytes) => {
+    loadPromises.push(Bun.file(resolve27(buildDir, webPath.slice(1))).bytes().then((bytes) => {
       store.set(webPath, bytes);
       return;
     }).catch(() => {}));
@@ -16445,7 +16645,7 @@ var init_assetStore = __esm(() => {
 
 // src/islands/pageMetadata.ts
 import { readFileSync as readFileSync15 } from "fs";
-import { dirname as dirname15, resolve as resolve27 } from "path";
+import { dirname as dirname16, resolve as resolve28 } from "path";
 var pagePatterns, getPageDirs = (config) => [
   { dir: config.angularDirectory, framework: "angular" },
   { dir: config.emberDirectory, framework: "ember" },
@@ -16465,15 +16665,15 @@ var pagePatterns, getPageDirs = (config) => [
     const source = definition.buildReference?.source;
     if (!source)
       continue;
-    const resolvedSource = source.startsWith("file://") ? new URL(source).pathname : resolve27(dirname15(buildInfo.resolvedRegistryPath), source);
-    lookup.set(`${definition.framework}:${definition.component}`, resolve27(resolvedSource));
+    const resolvedSource = source.startsWith("file://") ? new URL(source).pathname : resolve28(dirname16(buildInfo.resolvedRegistryPath), source);
+    lookup.set(`${definition.framework}:${definition.component}`, resolve28(resolvedSource));
   }
   return lookup;
 }, getCurrentPageIslandMetadata = () => globalThis.__absolutePageIslandMetadata ?? new Map, metadataUsesSource = (metadata, target) => metadata.islands.some((usage) => {
   const candidate = usage.source;
-  return candidate ? resolve27(candidate) === target : false;
+  return candidate ? resolve28(candidate) === target : false;
 }), getPagesUsingIslandSource = (sourcePath) => {
-  const target = resolve27(sourcePath);
+  const target = resolve28(sourcePath);
   return [...getCurrentPageIslandMetadata().values()].filter((metadata) => metadataUsesSource(metadata, target)).map((metadata) => metadata.pagePath);
 }, resolveIslandUsages = (islands, islandSourceLookup) => islands.map((usage) => {
   const sourcePath = islandSourceLookup.get(`${usage.framework}:${usage.component}`);
@@ -16485,13 +16685,13 @@ var pagePatterns, getPageDirs = (config) => [
   const pattern = pagePatterns[entry.framework];
   if (!pattern)
     return;
-  const files = await scanEntryPoints(resolve27(entry.dir), pattern);
+  const files = await scanEntryPoints(resolve28(entry.dir), pattern);
   for (const filePath of files) {
     const source = readFileSync15(filePath, "utf-8");
     const islands = extractIslandUsagesFromSource(source);
-    pageMetadata.set(resolve27(filePath), {
+    pageMetadata.set(resolve28(filePath), {
       islands: resolveIslandUsages(islands, islandSourceLookup),
-      pagePath: resolve27(filePath)
+      pagePath: resolve28(filePath)
     });
   }
 }, loadPageIslandMetadata = async (config) => {
@@ -16614,9 +16814,9 @@ var init_transformCache = __esm(() => {
 });
 
 // src/dev/reactComponentClassifier.ts
-import { resolve as resolve28 } from "path";
+import { resolve as resolve29 } from "path";
 var classifyComponent = (filePath) => {
-  const normalizedPath = resolve28(filePath);
+  const normalizedPath = resolve29(filePath);
   if (normalizedPath.includes("/react/pages/")) {
     return "server";
   }
@@ -16628,7 +16828,7 @@ var classifyComponent = (filePath) => {
 var init_reactComponentClassifier = () => {};
 
 // src/dev/moduleMapper.ts
-import { basename as basename9, resolve as resolve29 } from "path";
+import { basename as basename9, resolve as resolve30 } from "path";
 var buildModulePaths = (moduleKeys, manifest) => {
   const modulePaths = {};
   moduleKeys.forEach((key) => {
@@ -16638,7 +16838,7 @@ var buildModulePaths = (moduleKeys, manifest) => {
   });
   return modulePaths;
 }, processChangedFile = (sourceFile, framework, manifest, resolvedPaths, processedFiles) => {
-  const normalizedFile = resolve29(sourceFile);
+  const normalizedFile = resolve30(sourceFile);
   const normalizedPath = normalizedFile.replace(/\\/g, "/");
   if (processedFiles.has(normalizedFile)) {
     return null;
@@ -16674,7 +16874,7 @@ var buildModulePaths = (moduleKeys, manifest) => {
   });
   return grouped;
 }, mapSourceFileToManifestKeys = (sourceFile, framework, resolvedPaths) => {
-  const normalizedFile = resolve29(sourceFile);
+  const normalizedFile = resolve30(sourceFile);
   const fileName = basename9(normalizedFile);
   const baseName = fileName.replace(/\.(tsx?|jsx?|vue|svelte|css|html)$/, "");
   const pascalName = toPascal(baseName);
@@ -16870,7 +17070,7 @@ __export(exports_moduleServer, {
   SRC_URL_PREFIX: () => SRC_URL_PREFIX
 });
 import { existsSync as existsSync24, readFileSync as readFileSync17, statSync as statSync2 } from "fs";
-import { basename as basename10, dirname as dirname16, extname as extname8, join as join27, resolve as resolve30, relative as relative12 } from "path";
+import { basename as basename10, dirname as dirname17, extname as extname8, join as join28, resolve as resolve31, relative as relative13 } from "path";
 var SRC_PREFIX = "/@src/", jsTranspiler2, tsTranspiler2, tsxTranspiler, TRANSPILABLE, ALL_EXPORTS_RE, STRING_CONTENTS_RE, preserveTypeExports = (originalSource, transpiled, valueExports) => {
   const codeOnly = originalSource.replace(STRING_CONTENTS_RE, '""');
   const allExports = [];
@@ -16890,7 +17090,7 @@ var SRC_PREFIX = "/@src/", jsTranspiler2, tsTranspiler2, tsxTranspiler, TRANSPIL
 ${stubs}
 `;
 }, resolveRelativeExtension = (srcPath, projectRoot, extensions) => {
-  const found = extensions.find((ext) => existsSync24(resolve30(projectRoot, srcPath + ext)));
+  const found = extensions.find((ext) => existsSync24(resolve31(projectRoot, srcPath + ext)));
   return found ? srcPath + found : srcPath;
 }, IMPORT_EXTENSIONS, SIDE_EFFECT_EXTENSIONS, MODULE_EXTENSIONS, RESOLVED_MODULE_EXTENSIONS, REACT_EXTENSIONS, escapeRegex3 = (str) => str.replace(/[.*+?^${}()|[\]\\]/g, "\\$&"), buildImportRewriter = (vendorPaths) => {
   const entries = Object.entries(vendorPaths).sort(([a], [b2]) => b2.length - a.length);
@@ -16905,7 +17105,7 @@ ${stubs}
   return invalidationVersion > 0 ? `${mtime}.${invalidationVersion}` : `${mtime}`;
 }, srcUrl = (relPath, projectRoot) => {
   const base = `${SRC_PREFIX}${relPath.replace(/\\/g, "/")}`;
-  const absPath = resolve30(projectRoot, relPath);
+  const absPath = resolve31(projectRoot, relPath);
   const cached = mtimeCache.get(absPath);
   if (cached !== undefined)
     return `${base}?v=${buildVersion(cached, absPath)}`;
@@ -16917,12 +17117,12 @@ ${stubs}
     return base;
   }
 }, resolveRelativeImport = (relPath, fileDir, projectRoot, extensions) => {
-  const absPath = resolve30(fileDir, relPath);
-  const rel = relative12(projectRoot, absPath);
+  const absPath = resolve31(fileDir, relPath);
+  const rel = relative13(projectRoot, absPath);
   const extension = extname8(rel);
   let srcPath = RESOLVED_MODULE_EXTENSIONS.has(extension) ? rel : resolveRelativeExtension(rel, projectRoot, extensions);
   if (extname8(srcPath) === ".svelte") {
-    srcPath = relative12(projectRoot, resolveSvelteModulePath(resolve30(projectRoot, srcPath)));
+    srcPath = relative13(projectRoot, resolveSvelteModulePath(resolve31(projectRoot, srcPath)));
   }
   return srcUrl(srcPath, projectRoot);
 }, NODE_BUILTIN_RE, resolveAbsoluteSpecifier = (specifier, projectRoot) => {
@@ -16934,27 +17134,27 @@ ${stubs}
       "import"
     ]);
     if (fromExports)
-      return relative12(projectRoot, fromExports);
+      return relative13(projectRoot, fromExports);
     try {
       const isScoped = specifier.startsWith("@");
       const parts = specifier.split("/");
       const packageName = isScoped ? `${parts[0]}/${parts[1]}` : parts[0];
       const subpath = isScoped ? parts.slice(2).join("/") : parts.slice(1).join("/");
       if (!subpath) {
-        const pkgDir = resolve30(projectRoot, "node_modules", packageName ?? "");
-        const pkgJsonPath = join27(pkgDir, "package.json");
+        const pkgDir = resolve31(projectRoot, "node_modules", packageName ?? "");
+        const pkgJsonPath = join28(pkgDir, "package.json");
         if (existsSync24(pkgJsonPath)) {
           const pkg = JSON.parse(readFileSync17(pkgJsonPath, "utf-8"));
           const esmEntry = typeof pkg.module === "string" && pkg.module || typeof pkg.browser === "string" && pkg.browser;
           if (esmEntry) {
-            const resolved = resolve30(pkgDir, esmEntry);
+            const resolved = resolve31(pkgDir, esmEntry);
             if (existsSync24(resolved))
-              return relative12(projectRoot, resolved);
+              return relative13(projectRoot, resolved);
           }
         }
       }
     } catch {}
-    return relative12(projectRoot, Bun.resolveSync(specifier, projectRoot));
+    return relative13(projectRoot, Bun.resolveSync(specifier, projectRoot));
   } catch {
     return;
   }
@@ -16979,28 +17179,28 @@ ${stubs}
   };
   result = result.replace(/^((?:import\s+[\s\S]+?\s+from|export\s+[\s\S]+?\s+from|import)\s*["'])([^"'./][^"']*)(["'])/gm, stubReplace);
   result = result.replace(/(import\s*\(\s*["'])([^"'./][^"']*)(["']\s*\))/g, stubReplace);
-  const fileDir = dirname16(filePath);
+  const fileDir = dirname17(filePath);
   result = result.replace(/(from\s*["'])(\.\.?\/[^"']+)(["'])/g, (_match, prefix, relPath, suffix) => `${prefix}${resolveRelativeImport(relPath, fileDir, projectRoot, IMPORT_EXTENSIONS)}${suffix}`);
   result = result.replace(/(import\s*\(\s*["'])(\.\.?\/[^"']+)(["']\s*\))/g, (_match, prefix, relPath, suffix) => `${prefix}${resolveRelativeImport(relPath, fileDir, projectRoot, IMPORT_EXTENSIONS)}${suffix}`);
   result = result.replace(/(import\s*["'])(\.\.?\/[^"']+)(["']\s*;?)/g, (_match, prefix, relPath, suffix) => `${prefix}${resolveRelativeImport(relPath, fileDir, projectRoot, SIDE_EFFECT_EXTENSIONS)}${suffix}`);
   const rewriteAbsoluteToSrc = (_match, prefix, absPath, _ext, suffix) => {
     if (absPath.startsWith(projectRoot)) {
-      const rel2 = relative12(projectRoot, absPath).replace(/\\/g, "/");
+      const rel2 = relative13(projectRoot, absPath).replace(/\\/g, "/");
       return `${prefix}${srcUrl(rel2, projectRoot)}${suffix}`;
     }
-    const rel = relative12(projectRoot, absPath).replace(/\\/g, "/");
+    const rel = relative13(projectRoot, absPath).replace(/\\/g, "/");
     return `${prefix}${srcUrl(rel, projectRoot)}${suffix}`;
   };
   result = result.replace(/((?:from|import)\s*["'])(\/[^"']+\.(tsx?|jsx?|ts))(["'])/g, rewriteAbsoluteToSrc);
   result = result.replace(/(import\s*\(\s*["'])(\/[^"']+\.(tsx?|jsx?|ts))(["']\s*\))/g, rewriteAbsoluteToSrc);
   result = result.replace(/new\s+URL\(\s*["'](\.\.?\/[^"']+)["']\s*,\s*import\.meta\.url\s*\)/g, (_match, relPath) => {
-    const absPath = resolve30(fileDir, relPath);
-    const rel = relative12(projectRoot, absPath);
+    const absPath = resolve31(fileDir, relPath);
+    const rel = relative13(projectRoot, absPath);
     return `new URL('${srcUrl(rel, projectRoot)}', import.meta.url)`;
   });
   result = result.replace(/import\.meta\.resolve\(\s*["'](\.\.?\/[^"']+)["']\s*\)/g, (_match, relPath) => {
-    const absPath = resolve30(fileDir, relPath);
-    const rel = relative12(projectRoot, absPath);
+    const absPath = resolve31(fileDir, relPath);
+    const rel = relative13(projectRoot, absPath);
     return `'${srcUrl(rel, projectRoot)}'`;
   });
   return result;
@@ -17056,7 +17256,7 @@ ${code}`;
   transpiled = `var $RefreshReg$ = window.$RefreshReg$ || function(){};
 ` + `var $RefreshSig$ = window.$RefreshSig$ || function(){ return function(t){ return t; }; };
 ${transpiled}`;
-  const relPath = relative12(projectRoot, filePath).replace(/\\/g, "/");
+  const relPath = relative13(projectRoot, filePath).replace(/\\/g, "/");
   transpiled = transpiled.replace(/\binput\.tsx:/g, `${relPath}:`);
   transpiled += buildIslandMetadataExports(raw);
   return rewriteImports(transpiled, filePath, projectRoot, rewriter);
@@ -17065,13 +17265,13 @@ ${transpiled}`;
   const ext = extname8(filePath);
   const isTS = ext === ".ts" || ext === ".tsx";
   const isTSX = ext === ".tsx" || ext === ".jsx";
-  let transpiler5 = jsTranspiler2;
+  let transpiler6 = jsTranspiler2;
   if (isTSX)
-    transpiler5 = tsxTranspiler;
+    transpiler6 = tsxTranspiler;
   else if (isTS)
-    transpiler5 = tsTranspiler2;
-  const valueExports = isTS ? transpiler5.scan(raw).exports : [];
-  let transpiled = transpiler5.transformSync(raw);
+    transpiler6 = tsTranspiler2;
+  const valueExports = isTS ? transpiler6.scan(raw).exports : [];
+  let transpiled = transpiler6.transformSync(raw);
   if (isTS) {
     transpiled = preserveTypeExports(raw, transpiled, valueExports);
   }
@@ -17217,11 +17417,11 @@ ${code}`;
   if (compiled.css?.code) {
     const cssPath = `${filePath}.css`;
     svelteExternalCss.set(cssPath, compiled.css.code);
-    const cssUrl = srcUrl(relative12(projectRoot, cssPath), projectRoot);
+    const cssUrl = srcUrl(relative13(projectRoot, cssPath), projectRoot);
     code = `import "${cssUrl}";
 ${code}`;
   }
-  const moduleUrl = `${SRC_PREFIX}${relative12(projectRoot, filePath).replace(/\\/g, "/")}`;
+  const moduleUrl = `${SRC_PREFIX}${relative13(projectRoot, filePath).replace(/\\/g, "/")}`;
   code = code.replace(/if\s*\(import\.meta\.hot\)\s*\{/, `if (typeof window !== "undefined") {
 ` + `  if (!window.__SVELTE_HMR_ACCEPT__) window.__SVELTE_HMR_ACCEPT__ = {};
 ` + `  var __hmr_accept = function(cb) { window.__SVELTE_HMR_ACCEPT__[${JSON.stringify(moduleUrl)}] = cb; };`);
@@ -17247,6 +17447,8 @@ ${code}`;
   const templateResult = compiler.compileTemplate({
     compilerOptions: {
       bindingMetadata: compiledScript.bindings,
+      expressionPlugins: ["typescript"],
+      isCustomElement: (tag) => tag === "absolute-island",
       prefixIdentifiers: true
     },
     filename: filePath,
@@ -17310,8 +17512,8 @@ ${code}`;
   code = injectVueHmr(code, filePath, projectRoot, vueDir);
   return rewriteImports(code, filePath, projectRoot, rewriter);
 }, injectVueHmr = (code, filePath, projectRoot, vueDir) => {
-  const hmrBase = vueDir ? resolve30(vueDir) : projectRoot;
-  const hmrId = relative12(hmrBase, filePath).replace(/\\/g, "/").replace(/\.vue$/, "");
+  const hmrBase = vueDir ? resolve31(vueDir) : projectRoot;
+  const hmrId = relative13(hmrBase, filePath).replace(/\\/g, "/").replace(/\.vue$/, "");
   let result = code.replace(/export\s+default\s+/, "var __hmr_comp__ = ");
   result += [
     "",
@@ -17474,7 +17676,7 @@ export default {};
   const escaped = virtualCss.replace(/\\/g, "\\\\").replace(/`/g, "\\`").replace(/\$/g, "\\$");
   return jsResponse(`var s=document.createElement('style');s.textContent=\`${escaped}\`;s.dataset.svelteHmr=${JSON.stringify(cssCheckPath)};var p=document.querySelector('style[data-svelte-hmr="${cssCheckPath}"]');if(p)p.remove();document.head.appendChild(s);`);
 }, resolveSourcePath = (relPath, projectRoot) => {
-  const filePath = resolve30(projectRoot, relPath);
+  const filePath = resolve31(projectRoot, relPath);
   const ext = extname8(filePath);
   if (ext === ".svelte")
     return { ext, filePath: resolveSvelteModulePath(filePath) };
@@ -17501,7 +17703,7 @@ export default {};
   if (!TRANSPILABLE.has(ext))
     return;
   const stat3 = statSync2(filePath);
-  const resolvedVueDir = vueDir ? resolve30(vueDir) : undefined;
+  const resolvedVueDir = vueDir ? resolve31(vueDir) : undefined;
   let content = REACT_EXTENSIONS.has(ext) ? transformReactFile(filePath, projectRoot, rewriter) : transformPlainFile(filePath, projectRoot, rewriter, resolvedVueDir);
   const isComponentJs = ext === ".js" && filePath.endsWith(".component.js") && filePath.replace(/\\/g, "/").includes("/.absolutejs/generated/angular/");
   if (isComponentJs) {
@@ -17560,7 +17762,7 @@ export default {};
     const relPath = pathname.slice(SRC_PREFIX.length);
     if (relPath === "bun:wrap" || relPath.startsWith("bun:wrap?"))
       return handleBunWrapRequest();
-    const virtualCssResponse = handleVirtualSvelteCss(resolve30(projectRoot, relPath));
+    const virtualCssResponse = handleVirtualSvelteCss(resolve31(projectRoot, relPath));
     if (virtualCssResponse)
       return virtualCssResponse;
     const { filePath, ext } = resolveSourcePath(relPath, projectRoot);
@@ -17576,11 +17778,11 @@ export default {};
   SRC_IMPORT_RE.lastIndex = 0;
   while ((match = SRC_IMPORT_RE.exec(content)) !== null) {
     if (match[1])
-      files.push(resolve30(projectRoot, match[1]));
+      files.push(resolve31(projectRoot, match[1]));
   }
   return files;
 }, invalidateModule = (filePath) => {
-  const resolved = resolve30(filePath);
+  const resolved = resolve31(filePath);
   invalidate(filePath);
   if (resolved !== filePath)
     invalidate(resolved);
@@ -17727,7 +17929,7 @@ __export(exports_resolveOwningComponents, {
   invalidateResourceIndex: () => invalidateResourceIndex
 });
 import { readdirSync as readdirSync2, readFileSync as readFileSync18, statSync as statSync3 } from "fs";
-import { dirname as dirname17, extname as extname9, join as join28, resolve as resolve31 } from "path";
+import { dirname as dirname18, extname as extname9, join as join29, resolve as resolve32 } from "path";
 import ts3 from "typescript";
 var ENTITY_DECORATORS, isAngularSourceFile = (file4) => file4.endsWith(".ts") || file4.endsWith(".tsx"), walkAngularSourceFiles = (root) => {
   const out = [];
@@ -17742,7 +17944,7 @@ var ENTITY_DECORATORS, isAngularSourceFile = (file4) => file4.endsWith(".ts") ||
       if (entry.name.startsWith(".") || entry.name === "node_modules") {
         continue;
       }
-      const full = join28(dir, entry.name);
+      const full = join29(dir, entry.name);
       if (entry.isDirectory()) {
         visit(full);
       } else if (entry.isFile() && isAngularSourceFile(entry.name)) {
@@ -17840,7 +18042,7 @@ var ENTITY_DECORATORS, isAngularSourceFile = (file4) => file4.endsWith(".ts") ||
   };
   visit(sourceFile);
   return out;
-}, safeNormalize = (path) => resolve31(path).replace(/\\/g, "/"), resolveOwningComponents = (params) => {
+}, safeNormalize = (path) => resolve32(path).replace(/\\/g, "/"), resolveOwningComponents = (params) => {
   const { changedFilePath, userAngularRoot } = params;
   const changedAbs = safeNormalize(changedFilePath);
   const out = [];
@@ -17881,7 +18083,7 @@ var ENTITY_DECORATORS, isAngularSourceFile = (file4) => file4.endsWith(".ts") ||
     return null;
   }
   const sf = ts3.createSourceFile(childFilePath, source, ts3.ScriptTarget.ES2022, true, ts3.ScriptKind.TS);
-  const childDir = dirname17(childFilePath);
+  const childDir = dirname18(childFilePath);
   for (const stmt of sf.statements) {
     if (!ts3.isImportDeclaration(stmt))
       continue;
@@ -17909,7 +18111,7 @@ var ENTITY_DECORATORS, isAngularSourceFile = (file4) => file4.endsWith(".ts") ||
     if (!spec.startsWith(".") && !spec.startsWith("/")) {
       return null;
     }
-    const base = resolve31(childDir, spec);
+    const base = resolve32(childDir, spec);
     const candidates = [
       `${base}.ts`,
       `${base}.tsx`,
@@ -17938,7 +18140,7 @@ var ENTITY_DECORATORS, isAngularSourceFile = (file4) => file4.endsWith(".ts") ||
   const parentFile = new Map;
   for (const tsPath of walkAngularSourceFiles(userAngularRoot)) {
     const classes = parseDecoratedClasses(tsPath);
-    const componentDir = dirname17(tsPath);
+    const componentDir = dirname18(tsPath);
     for (const cls of classes) {
       const entity = {
         className: cls.className,
@@ -17947,7 +18149,7 @@ var ENTITY_DECORATORS, isAngularSourceFile = (file4) => file4.endsWith(".ts") ||
       };
       if (cls.kind === "component") {
         for (const url of [...cls.templateUrls, ...cls.styleUrls]) {
-          const abs = safeNormalize(resolve31(componentDir, url));
+          const abs = safeNormalize(resolve32(componentDir, url));
           const existing = resource.get(abs);
           if (existing)
             existing.push(entity);
@@ -18027,8 +18229,6 @@ class Context {
 }
 
 // src/dev/angular/vendor/translator/translator.ts
-import * as o from "@angular/compiler";
-
 class ExpressionTranslatorVisitor {
   factory;
   imports;
@@ -18084,7 +18284,9 @@ class ExpressionTranslatorVisitor {
     return this.setSourceMapRange(this.factory.createRegularExpressionLiteral(ast.body, ast.flags), ast.sourceSpan);
   }
   visitLocalizedString(ast, context) {
-    const elements = [createTemplateElement(ast.serializeI18nHead())];
+    const elements = [
+      createTemplateElement(ast.serializeI18nHead())
+    ];
     const expressions = [];
     for (let i = 0;i < ast.expressions.length; i++) {
       const placeholder = this.setSourceMapRange(ast.expressions[i].visitExpression(this, context), ast.getPlaceholderSourceSpan(i));
@@ -18092,7 +18294,10 @@ class ExpressionTranslatorVisitor {
       elements.push(createTemplateElement(ast.serializeI18nTemplatePart(i + 1)));
     }
     const localizeTag = this.factory.createIdentifier("$localize");
-    return this.setSourceMapRange(this.createTaggedTemplateExpression(localizeTag, { elements, expressions }), ast.sourceSpan);
+    return this.setSourceMapRange(this.createTaggedTemplateExpression(localizeTag, {
+      elements,
+      expressions
+    }), ast.sourceSpan);
   }
   visitBuiltinType(ast) {
     let builtInType;
@@ -18149,7 +18354,10 @@ class ExpressionTranslatorVisitor {
       cooked.push(this.factory.setSourceMapRange(this.factory.createLiteral(element.cooked), element.range));
       raw.push(this.factory.setSourceMapRange(this.factory.createLiteral(element.raw), element.range));
     }
-    const templateHelperCall = this.factory.createCallExpression(__makeTemplateObjectHelper, [this.factory.createArrayLiteral(cooked), this.factory.createArrayLiteral(raw)], false);
+    const templateHelperCall = this.factory.createCallExpression(__makeTemplateObjectHelper, [
+      this.factory.createArrayLiteral(cooked),
+      this.factory.createArrayLiteral(raw)
+    ], false);
     return this.factory.createCallExpression(tagHandler, [templateHelperCall, ...expressions], false);
   }
   visitExternalExpr(ast, _context) {
@@ -18179,7 +18387,9 @@ class ExpressionTranslatorVisitor {
   visitDynamicImportExpr(ast, context) {
     const urlExpression = typeof ast.url === "string" ? this.factory.createLiteral(ast.url) : ast.url.visitExpression(this, context);
     if (ast.urlComment) {
-      this.factory.attachComments(urlExpression, [o.leadingComment(ast.urlComment, true)]);
+      this.factory.attachComments(urlExpression, [
+        o.leadingComment(ast.urlComment, true)
+      ]);
     }
     return this.factory.createDynamicImport(urlExpression);
   }
@@ -18319,8 +18529,16 @@ function createRange(span) {
     end: { offset: end.offset, line: end.line, column: end.col }
   };
 }
-var UNARY_OPERATORS, BINARY_OPERATORS;
+var o, UNARY_OPERATORS, BINARY_OPERATORS;
 var init_translator = __esm(() => {
+  o = (() => {
+    try {
+      return __require("@angular/compiler");
+    } catch {
+      const stub = new Proxy(function() {}, { apply: () => stub, construct: () => stub, get: () => stub });
+      return stub;
+    }
+  })();
   UNARY_OPERATORS = /* @__PURE__ */ new Map([
     [o.UnaryOperator.Minus, "-"],
     [o.UnaryOperator.Plus, "+"]
@@ -18455,7 +18673,9 @@ class TypeScriptAstFactory {
   createElementAccess = ts6.factory.createElementAccessExpression;
   createExpressionStatement = ts6.factory.createExpressionStatement;
   createDynamicImport(url) {
-    return ts6.factory.createCallExpression(ts6.factory.createToken(ts6.SyntaxKind.ImportKeyword), undefined, [typeof url === "string" ? ts6.factory.createStringLiteral(url) : url]);
+    return ts6.factory.createCallExpression(ts6.factory.createToken(ts6.SyntaxKind.ImportKeyword), undefined, [
+      typeof url === "string" ? ts6.factory.createStringLiteral(url) : url
+    ]);
   }
   createFunctionDeclaration(functionName, parameters, body) {
     if (!ts6.isBlock(body)) {
@@ -18658,9 +18878,18 @@ var init_typescript_ast_factory = __esm(() => {
 function translateStatement(contextFile, statement, imports, options = {}) {
   return statement.visitStatement(new ExpressionTranslatorVisitor(new TypeScriptAstFactory(options.annotateForClosureCompiler === true), imports, contextFile, options), new Context(true));
 }
+var o2;
 var init_typescript_translator = __esm(() => {
   init_translator();
   init_typescript_ast_factory();
+  o2 = (() => {
+    try {
+      return __require("@angular/compiler");
+    } catch {
+      const stub = new Proxy(function() {}, { apply: () => stub, construct: () => stub, get: () => stub });
+      return stub;
+    }
+  })();
 });
 
 // src/dev/angular/fastHmrCompiler.ts
@@ -18672,7 +18901,7 @@ __export(exports_fastHmrCompiler, {
   invalidateFingerprintCache: () => invalidateFingerprintCache
 });
 import { existsSync as existsSync25, readFileSync as readFileSync19, statSync as statSync4 } from "fs";
-import { dirname as dirname18, extname as extname10, relative as relative13, resolve as resolve32 } from "path";
+import { dirname as dirname19, extname as extname10, relative as relative14, resolve as resolve33 } from "path";
 import ts7 from "typescript";
 var fail = (reason, detail, location) => ({
   ok: false,
@@ -18894,7 +19123,7 @@ var fail = (reason, detail, location) => ({
     if (!spec.startsWith(".") && !spec.startsWith("/")) {
       return true;
     }
-    const base = resolve32(componentDir, spec);
+    const base = resolve33(componentDir, spec);
     const candidates = [
       `${base}.ts`,
       `${base}.tsx`,
@@ -19469,7 +19698,10 @@ var fail = (reason, detail, location) => ({
   try {
     source = readFileSync19(filePath, "utf-8");
   } catch {
-    childComponentInfoCache.set(cacheKey2, { info: null, mtimeMs: stat3.mtimeMs });
+    childComponentInfoCache.set(cacheKey2, {
+      info: null,
+      mtimeMs: stat3.mtimeMs
+    });
     return null;
   }
   const sf = ts7.createSourceFile(filePath, source, ts7.ScriptTarget.Latest, true);
@@ -19657,7 +19889,7 @@ var fail = (reason, detail, location) => ({
     });
     if (!names.includes(className))
       continue;
-    const nextDts = resolveDtsFromSpec(fromPath, dirname18(startDtsPath));
+    const nextDts = resolveDtsFromSpec(fromPath, dirname19(startDtsPath));
     if (!nextDts)
       continue;
     const found = findDtsContainingClass(nextDts, className, visited);
@@ -19667,7 +19899,7 @@ var fail = (reason, detail, location) => ({
   const starReExportRe = /export\s*\*\s*from\s*["']([^"']+)["']/g;
   while ((m = starReExportRe.exec(content)) !== null) {
     const fromPath = m[1] || "";
-    const nextDts = resolveDtsFromSpec(fromPath, dirname18(startDtsPath));
+    const nextDts = resolveDtsFromSpec(fromPath, dirname19(startDtsPath));
     if (!nextDts)
       continue;
     const found = findDtsContainingClass(nextDts, className, visited);
@@ -19677,7 +19909,7 @@ var fail = (reason, detail, location) => ({
   return null;
 }, resolveDtsFromSpec = (spec, fromDir) => {
   const stripped = spec.replace(/\.[mc]?js$/, "");
-  const base = resolve32(fromDir, stripped);
+  const base = resolve33(fromDir, stripped);
   const candidates = [
     `${base}.d.ts`,
     `${base}.d.mts`,
@@ -19701,7 +19933,7 @@ var fail = (reason, detail, location) => ({
   return null;
 }, resolveChildComponentInfo = (className, spec, componentDir, projectRoot) => {
   if (spec.startsWith(".") || spec.startsWith("/")) {
-    const base = resolve32(componentDir, spec);
+    const base = resolve33(componentDir, spec);
     const candidates = [
       `${base}.ts`,
       `${base}.tsx`,
@@ -19871,13 +20103,13 @@ var fail = (reason, detail, location) => ({
     }
     if (!matches)
       continue;
-    const resolved = resolve32(componentDir, spec);
+    const resolved = resolve33(componentDir, spec);
     for (const ext of TS_EXTENSIONS) {
       const candidate = resolved + ext;
       if (existsSync25(candidate))
         return candidate;
     }
-    const indexCandidate = resolve32(resolved, "index.ts");
+    const indexCandidate = resolve33(resolved, "index.ts");
     if (existsSync25(indexCandidate))
       return indexCandidate;
   }
@@ -20064,7 +20296,7 @@ ${transpiled}
     }
 }${staticPatch}`;
 }, STYLE_PREPROCESSED_EXT, resolveAndReadStyleResource = (componentDir, url) => {
-  const abs = resolve32(componentDir, url);
+  const abs = resolve33(componentDir, url);
   if (!existsSync25(abs))
     return null;
   const ext = extname10(abs).toLowerCase();
@@ -20104,7 +20336,7 @@ ${block}
   const cached = projectOptionsCache.get(projectRoot);
   if (cached !== undefined)
     return cached;
-  const tsconfigPath = resolve32(projectRoot, "tsconfig.json");
+  const tsconfigPath = resolve33(projectRoot, "tsconfig.json");
   const opts = {};
   if (existsSync25(tsconfigPath)) {
     try {
@@ -20150,7 +20382,7 @@ ${block}
   }
   const kind = params.kind ?? "component";
   if (kind !== "component") {
-    const entityId = encodeURIComponent(`${relative13(projectRoot, componentFilePath).replace(/\\/g, "/")}@${className}`);
+    const entityId = encodeURIComponent(`${relative14(projectRoot, componentFilePath).replace(/\\/g, "/")}@${className}`);
     const currentEntityFingerprint = extractEntityFingerprint(classNode, className, sourceFile);
     const cachedEntityFingerprint = entityFingerprintCache.get(entityId);
     if (cachedEntityFingerprint !== undefined && !entityFingerprintsEqual(cachedEntityFingerprint, currentEntityFingerprint)) {
@@ -20168,7 +20400,7 @@ ${block}
       ok: true
     };
   }
-  if (inheritsDecoratedClass(classNode, sourceFile, dirname18(componentFilePath), projectRoot)) {
+  if (inheritsDecoratedClass(classNode, sourceFile, dirname19(componentFilePath), projectRoot)) {
     return fail("inherits-decorated-class");
   }
   const decorator = findComponentDecorator(classNode);
@@ -20180,14 +20412,14 @@ ${block}
   const projectDefaults = readProjectAngularCompilerOptions(projectRoot);
   const decoratorMeta = readDecoratorMeta(decoratorArgs, projectDefaults);
   const advancedMetadata = extractAdvancedMetadata(classNode, decoratorArgs, compiler);
-  const componentDir = dirname18(componentFilePath);
+  const componentDir = dirname19(componentFilePath);
   let templateText;
   let templatePath;
   if (decoratorMeta.template !== null) {
     templateText = decoratorMeta.template;
     templatePath = componentFilePath;
   } else if (decoratorMeta.templateUrl) {
-    const tplAbs = resolve32(componentDir, decoratorMeta.templateUrl);
+    const tplAbs = resolve33(componentDir, decoratorMeta.templateUrl);
     if (!existsSync25(tplAbs)) {
       return fail("template-resource-not-found", `Template file not found: ${tplAbs}`, { file: componentFilePath });
     }
@@ -20232,13 +20464,8 @@ ${block}
   if (!className_)
     return fail("class-not-found", "anonymous class");
   const wrappedClass = new compiler.WrappedNodeExpr(className_);
-  const {
-    inputs,
-    outputs,
-    hasDecoratorIO,
-    hasSignalIO
-  } = extractInputsAndOutputs(classNode, compiler);
-  const projectRelPath = relative13(projectRoot, componentFilePath).replace(/\\/g, "/");
+  const { inputs, outputs, hasDecoratorIO, hasSignalIO } = extractInputsAndOutputs(classNode, compiler);
+  const projectRelPath = relative14(projectRoot, componentFilePath).replace(/\\/g, "/");
   const fingerprintId = encodeURIComponent(`${projectRelPath}@${className}`);
   const currentFingerprint = extractFingerprint(classNode, className, decoratorMeta, inputs, outputs, sourceFile, componentDir);
   const cachedFingerprint = fingerprintCache.get(fingerprintId);
@@ -20441,11 +20668,7 @@ var init_fastHmrCompiler = __esm(() => {
   fingerprintCache = new Map;
   pendingModuleCache = new Map;
   entityFingerprintCache = new Map;
-  ENTITY_DECORATOR_NAMES = new Set([
-    "Pipe",
-    "Directive",
-    "Injectable"
-  ]);
+  ENTITY_DECORATOR_NAMES = new Set(["Pipe", "Directive", "Injectable"]);
   VIEW_ENCAPSULATION_VALUES = {
     Emulated: 0,
     ExperimentalIsolatedShadowDom: 4,
@@ -20492,7 +20715,7 @@ __export(exports_hmrCompiler, {
   getApplyMetadataModule: () => getApplyMetadataModule,
   encodeHmrComponentId: () => encodeHmrComponentId
 });
-import { dirname as dirname19, relative as relative14, resolve as resolve33 } from "path";
+import { dirname as dirname20, relative as relative15, resolve as resolve34 } from "path";
 import { performance as performance2 } from "perf_hooks";
 var getApplyMetadataModule = async (encodedId) => {
   const decoded = decodeURIComponent(encodedId);
@@ -20501,8 +20724,8 @@ var getApplyMetadataModule = async (encodedId) => {
     return null;
   const filePathRel = decoded.slice(0, at2);
   const className = decoded.slice(at2 + 1);
-  const componentFilePath = resolve33(process.cwd(), filePathRel);
-  const projectRelPath = relative14(process.cwd(), componentFilePath).replace(/\\/g, "/");
+  const componentFilePath = resolve34(process.cwd(), filePathRel);
+  const projectRelPath = relative15(process.cwd(), componentFilePath).replace(/\\/g, "/");
   const cacheKey2 = encodeURIComponent(`${projectRelPath}@${className}`);
   const { takePendingModule: takePendingModule2 } = await Promise.resolve().then(() => (init_fastHmrCompiler(), exports_fastHmrCompiler));
   const cached = takePendingModule2(cacheKey2);
@@ -20512,9 +20735,9 @@ var getApplyMetadataModule = async (encodedId) => {
   const { resolveOwningComponents: resolveOwningComponents2 } = await Promise.resolve().then(() => (init_resolveOwningComponents(), exports_resolveOwningComponents));
   const owners = resolveOwningComponents2({
     changedFilePath: componentFilePath,
-    userAngularRoot: dirname19(componentFilePath)
+    userAngularRoot: dirname20(componentFilePath)
   });
-  const owner = owners.find((o2) => o2.className === className);
+  const owner = owners.find((o3) => o3.className === className);
   const kind = owner?.kind ?? "component";
   const fastStart = performance2.now();
   const fast = await tryFastHmr({ className, componentFilePath, kind });
@@ -20524,7 +20747,7 @@ var getApplyMetadataModule = async (encodedId) => {
   }
   return null;
 }, encodeHmrComponentId = (absoluteFilePath, className) => {
-  const projectRel = relative14(process.cwd(), absoluteFilePath).replace(/\\/g, "/");
+  const projectRel = relative15(process.cwd(), absoluteFilePath).replace(/\\/g, "/");
   return `${projectRel}@${className}`;
 };
 var init_hmrCompiler = __esm(() => {
@@ -20663,11 +20886,11 @@ var exports_simpleHTMLHMR = {};
 __export(exports_simpleHTMLHMR, {
   handleHTMLUpdate: () => handleHTMLUpdate
 });
-import { resolve as resolve34 } from "path";
+import { resolve as resolve35 } from "path";
 var handleHTMLUpdate = async (htmlFilePath) => {
   let htmlContent;
   try {
-    const resolvedPath = resolve34(htmlFilePath);
+    const resolvedPath = resolve35(htmlFilePath);
     const file4 = Bun.file(resolvedPath);
     if (!await file4.exists()) {
       return null;
@@ -20693,11 +20916,11 @@ var exports_simpleHTMXHMR = {};
 __export(exports_simpleHTMXHMR, {
   handleHTMXUpdate: () => handleHTMXUpdate
 });
-import { resolve as resolve35 } from "path";
+import { resolve as resolve36 } from "path";
 var handleHTMXUpdate = async (htmxFilePath) => {
   let htmlContent;
   try {
-    const resolvedPath = resolve35(htmxFilePath);
+    const resolvedPath = resolve36(htmxFilePath);
     const file4 = Bun.file(resolvedPath);
     if (!await file4.exists()) {
       return null;
@@ -20720,7 +20943,7 @@ var init_simpleHTMXHMR = () => {};
 
 // src/dev/rebuildTrigger.ts
 import { existsSync as existsSync26 } from "fs";
-import { basename as basename11, dirname as dirname20, relative as relative15, resolve as resolve36, sep as sep4 } from "path";
+import { basename as basename11, dirname as dirname21, relative as relative16, resolve as resolve37, sep as sep4 } from "path";
 var moduleServerPromise, getModuleServer = () => moduleServerPromise, runSequentially = (items, action) => items.reduce((chain, item) => chain.then(() => action(item)), Promise.resolve()), getStyleTransformConfig = (config) => createStyleTransformConfig(config.stylePreprocessors, config.postcss), recompileTailwindForFastPath = async (state, config, files) => {
   if (!config.tailwind)
     return;
@@ -20812,7 +21035,7 @@ var moduleServerPromise, getModuleServer = () => moduleServerPromise, runSequent
   state.fileHashes.delete(filePathInSet);
   try {
     const affectedFiles = getAffectedFiles(state.dependencyGraph, filePathInSet);
-    const deletedPathResolved = resolve36(filePathInSet);
+    const deletedPathResolved = resolve37(filePathInSet);
     affectedFiles.forEach((affectedFile) => {
       if (isValidDeletedAffectedFile(affectedFile, deletedPathResolved, processedFiles)) {
         validFiles.push(affectedFile);
@@ -20856,7 +21079,7 @@ var moduleServerPromise, getModuleServer = () => moduleServerPromise, runSequent
   if (storedHash !== undefined && storedHash === fileHash) {
     return;
   }
-  const normalizedFilePath = resolve36(filePathInSet);
+  const normalizedFilePath = resolve37(filePathInSet);
   if (!processedFiles.has(normalizedFilePath)) {
     validFiles.push(normalizedFilePath);
     processedFiles.add(normalizedFilePath);
@@ -20960,8 +21183,8 @@ var moduleServerPromise, getModuleServer = () => moduleServerPromise, runSequent
     return;
   }
   if (framework === "unknown") {
-    invalidate(resolve36(filePath));
-    const relPath = relative15(process.cwd(), filePath);
+    invalidate(resolve37(filePath));
+    const relPath = relative16(process.cwd(), filePath);
     logHmrUpdate(relPath);
     return;
   }
@@ -20987,7 +21210,7 @@ var moduleServerPromise, getModuleServer = () => moduleServerPromise, runSequent
     const userEditedFiles = new Set;
     state.fileChangeQueue.forEach((filePaths) => {
       for (const filePath2 of filePaths) {
-        userEditedFiles.add(resolve36(filePath2));
+        userEditedFiles.add(resolve37(filePath2));
       }
     });
     state.lastUserEditedFiles = userEditedFiles;
@@ -21016,7 +21239,7 @@ var moduleServerPromise, getModuleServer = () => moduleServerPromise, runSequent
   }
   if (!graph)
     return componentFile;
-  const dependents = graph.dependents.get(resolve36(componentFile));
+  const dependents = graph.dependents.get(resolve37(componentFile));
   if (!dependents)
     return componentFile;
   for (const dep of dependents) {
@@ -21025,7 +21248,7 @@ var moduleServerPromise, getModuleServer = () => moduleServerPromise, runSequent
   }
   return componentFile;
 }, resolveAngularPageEntries = (state, angularFiles, angularPagesPath) => {
-  const pageEntries = angularFiles.filter((file4) => file4.endsWith(".ts") && resolve36(file4).startsWith(angularPagesPath));
+  const pageEntries = angularFiles.filter((file4) => file4.endsWith(".ts") && resolve37(file4).startsWith(angularPagesPath));
   if (pageEntries.length > 0 || !state.dependencyGraph) {
     return pageEntries;
   }
@@ -21034,7 +21257,7 @@ var moduleServerPromise, getModuleServer = () => moduleServerPromise, runSequent
     const lookupFile = resolveComponentLookupFile(componentFile, state.dependencyGraph);
     const affected = getAffectedFiles(state.dependencyGraph, lookupFile);
     affected.forEach((file4) => {
-      if (file4.endsWith(".ts") && resolve36(file4).startsWith(angularPagesPath)) {
+      if (file4.endsWith(".ts") && resolve37(file4).startsWith(angularPagesPath)) {
         resolvedPages.add(file4);
       }
     });
@@ -21306,16 +21529,16 @@ var moduleServerPromise, getModuleServer = () => moduleServerPromise, runSequent
   };
   const fire = () => {
     ctx.debounceTimer = null;
-    const resolve37 = ctx.debouncedResolve;
+    const resolve38 = ctx.debouncedResolve;
     ctx.debouncedResolve = null;
     ctx.debouncedPromise = null;
     if (ctx.inFlight) {
       ctx.pending = true;
-      ctx.inFlight.finally(() => resolve37?.());
+      ctx.inFlight.finally(() => resolve38?.());
       return;
     }
     ctx.inFlight = drive();
-    ctx.inFlight.finally(() => resolve37?.());
+    ctx.inFlight.finally(() => resolve38?.());
   };
   return ({ immediate = false } = {}) => {
     if (!ctx.debouncedPromise) {
@@ -21342,9 +21565,9 @@ var moduleServerPromise, getModuleServer = () => moduleServerPromise, runSequent
   const diskRefreshPromise = (async () => {
     if (!angularDir || editedFiles.size === 0)
       return;
-    const angularDirAbs = resolve36(angularDir);
+    const angularDirAbs = resolve37(angularDir);
     const filesUnderAngular = Array.from(editedFiles).filter((file4) => {
-      const abs = resolve36(file4);
+      const abs = resolve37(file4);
       return abs === angularDirAbs || abs.startsWith(angularDirAbs + sep4);
     });
     if (filesUnderAngular.length === 0)
@@ -21366,7 +21589,7 @@ var moduleServerPromise, getModuleServer = () => moduleServerPromise, runSequent
         if (!ext)
           continue;
         if (ext === ".ts" || ext === ".tsx") {
-          tsFilesToRefresh.add(resolve36(file4));
+          tsFilesToRefresh.add(resolve37(file4));
           continue;
         }
         const owners = resolveOwningComponents2({
@@ -21374,7 +21597,7 @@ var moduleServerPromise, getModuleServer = () => moduleServerPromise, runSequent
           userAngularRoot: angularDirAbs
         });
         for (const owner of owners) {
-          tsFilesToRefresh.add(resolve36(owner.componentFilePath));
+          tsFilesToRefresh.add(resolve37(owner.componentFilePath));
         }
       }
       if (tsFilesToRefresh.size === 0)
@@ -21385,8 +21608,8 @@ var moduleServerPromise, getModuleServer = () => moduleServerPromise, runSequent
       try {
         const { invalidateModule: invalidateModule2 } = await Promise.resolve().then(() => (init_moduleServer(), exports_moduleServer));
         for (const tsFile of tsFilesToRefresh) {
-          const rel = relative15(angularDirAbs, tsFile).replace(/\\/g, "/").replace(/\.[tj]sx?$/, ".js");
-          const compiledFile = resolve36(compiledRoot, rel);
+          const rel = relative16(angularDirAbs, tsFile).replace(/\\/g, "/").replace(/\.[tj]sx?$/, ".js");
+          const compiledFile = resolve37(compiledRoot, rel);
           invalidateModule2(compiledFile);
         }
       } catch {}
@@ -21415,7 +21638,7 @@ var moduleServerPromise, getModuleServer = () => moduleServerPromise, runSequent
   serverPaths.forEach((serverPath, idx) => {
     const fileBase = basename11(serverPath, ".js");
     const ssrPath = ssrPaths[idx] ?? serverPath;
-    state.manifest[toPascal(fileBase)] = resolve36(ssrPath);
+    state.manifest[toPascal(fileBase)] = resolve37(ssrPath);
   });
   if (clientPaths.length > 0) {
     await bundleAngularClient(state, clientPaths, state.resolvedPaths.buildDir, angularDir);
@@ -21424,9 +21647,9 @@ var moduleServerPromise, getModuleServer = () => moduleServerPromise, runSequent
   const angularDir = config.angularDirectory ?? "";
   const angularFiles = filesToRebuild.filter((file4) => detectFramework(file4, state.resolvedPaths) === "angular");
   for (const file4 of angularFiles) {
-    state.fileHashes.set(resolve36(file4), computeFileHash(file4));
+    state.fileHashes.set(resolve37(file4), computeFileHash(file4));
   }
-  const angularPagesPath = resolve36(angularDir, "pages");
+  const angularPagesPath = resolve37(angularDir, "pages");
   const pageEntries = resolveAngularPageEntries(state, angularFiles, angularPagesPath);
   const tierStart = performance.now();
   const verdict = await decideAngularTier(state, angularDir);
@@ -21456,7 +21679,7 @@ var moduleServerPromise, getModuleServer = () => moduleServerPromise, runSequent
 }, getModuleUrl = async (pageFile) => {
   const { invalidateModule: invalidateModule2, warmCache: warmCache2, SRC_URL_PREFIX: SRC_URL_PREFIX2 } = await Promise.resolve().then(() => (init_moduleServer(), exports_moduleServer));
   invalidateModule2(pageFile);
-  const rel = relative15(process.cwd(), pageFile).replace(/\\/g, "/");
+  const rel = relative16(process.cwd(), pageFile).replace(/\\/g, "/");
   const url = `${SRC_URL_PREFIX2}${rel}`;
   warmCache2(url);
   return url;
@@ -21465,11 +21688,11 @@ var moduleServerPromise, getModuleServer = () => moduleServerPromise, runSequent
   if (isComponentFile2)
     return primaryFile;
   const { findNearestComponent: findNearestComponent2 } = await Promise.resolve().then(() => (init_transformCache(), exports_transformCache));
-  const nearest = findNearestComponent2(resolve36(primaryFile));
+  const nearest = findNearestComponent2(resolve37(primaryFile));
   return nearest ?? primaryFile;
 }, handleReactModuleServerPath = async (state, reactFiles, startTime, onRebuildComplete) => {
   for (const file4 of reactFiles) {
-    state.fileHashes.set(resolve36(file4), computeFileHash(file4));
+    state.fileHashes.set(resolve37(file4), computeFileHash(file4));
   }
   markSsrCacheDirty("react");
   const primaryFile = reactFiles.find((file4) => !file4.replace(/\\/g, "/").includes("/pages/")) ?? reactFiles[0];
@@ -21488,7 +21711,7 @@ var moduleServerPromise, getModuleServer = () => moduleServerPromise, runSequent
   const pageModuleUrl = await getReactModuleUrl(broadcastTarget);
   if (pageModuleUrl) {
     const serverDuration = Date.now() - startTime;
-    state.lastHmrPath = relative15(process.cwd(), primaryFile).replace(/\\/g, "/");
+    state.lastHmrPath = relative16(process.cwd(), primaryFile).replace(/\\/g, "/");
     state.lastHmrFramework = "react";
     broadcastToClients(state, {
       data: {
@@ -21551,7 +21774,7 @@ var moduleServerPromise, getModuleServer = () => moduleServerPromise, runSequent
   });
 }, handleSvelteModuleServerPath = async (state, svelteFiles, startTime, onRebuildComplete) => {
   for (const file4 of svelteFiles) {
-    state.fileHashes.set(resolve36(file4), computeFileHash(file4));
+    state.fileHashes.set(resolve37(file4), computeFileHash(file4));
   }
   markSsrCacheDirty("svelte");
   const serverDuration = Date.now() - startTime;
@@ -21576,8 +21799,8 @@ var moduleServerPromise, getModuleServer = () => moduleServerPromise, runSequent
     const serverEntries = [...svelteServerPaths];
     const clientEntries = [...svelteIndexPaths, ...svelteClientPaths];
     const { getFrameworkGeneratedDir: getFrameworkGeneratedDir2 } = await Promise.resolve().then(() => (init_generatedDir(), exports_generatedDir));
-    const serverRoot = resolve36(getFrameworkGeneratedDir2("svelte"), "server");
-    const serverOutDir = resolve36(buildDir, basename11(svelteDir));
+    const serverRoot = resolve37(getFrameworkGeneratedDir2("svelte"), "server");
+    const serverOutDir = resolve37(buildDir, basename11(svelteDir));
     const [serverResult, clientResult] = await Promise.all([
       serverEntries.length > 0 ? bunBuild9({
         entrypoints: serverEntries,
@@ -21674,7 +21897,7 @@ var moduleServerPromise, getModuleServer = () => moduleServerPromise, runSequent
   });
 }, handleVueModuleServerPath = async (state, vueFiles, nonVueFiles, startTime, onRebuildComplete) => {
   for (const file4 of [...vueFiles, ...nonVueFiles]) {
-    state.fileHashes.set(resolve36(file4), computeFileHash(file4));
+    state.fileHashes.set(resolve37(file4), computeFileHash(file4));
   }
   markSsrCacheDirty("vue");
   await invalidateNonVueModules(nonVueFiles);
@@ -21702,7 +21925,7 @@ var moduleServerPromise, getModuleServer = () => moduleServerPromise, runSequent
       recursive: true,
       withFileTypes: true
     });
-    return entries.filter((entry) => entry.isFile() && EMBER_PAGE_EXTENSIONS.some((ext) => entry.name.endsWith(ext))).map((entry) => resolve36(emberPagesPath, entry.name));
+    return entries.filter((entry) => entry.isFile() && EMBER_PAGE_EXTENSIONS.some((ext) => entry.name.endsWith(ext))).map((entry) => resolve37(emberPagesPath, entry.name));
   } catch {
     return [];
   }
@@ -21714,10 +21937,10 @@ var moduleServerPromise, getModuleServer = () => moduleServerPromise, runSequent
     return state.manifest;
   }
   for (const file4 of emberFiles) {
-    state.fileHashes.set(resolve36(file4), computeFileHash(file4));
+    state.fileHashes.set(resolve37(file4), computeFileHash(file4));
   }
-  const emberPagesPath = resolve36(emberDir, "pages");
-  const directPageEntries = emberFiles.filter((file4) => resolve36(file4).startsWith(emberPagesPath));
+  const emberPagesPath = resolve37(emberDir, "pages");
+  const directPageEntries = emberFiles.filter((file4) => resolve37(file4).startsWith(emberPagesPath));
   const allPageEntries = directPageEntries.length > 0 ? directPageEntries : await collectAllEmberPages(emberPagesPath);
   if (allPageEntries.length === 0) {
     onRebuildComplete({ hmrState: state, manifest: state.manifest });
@@ -21727,14 +21950,14 @@ var moduleServerPromise, getModuleServer = () => moduleServerPromise, runSequent
   const { serverPaths } = await compileEmber2(allPageEntries, emberDir, process.cwd(), true);
   for (const serverPath of serverPaths) {
     const fileBase = basename11(serverPath, ".js");
-    state.manifest[toPascal(fileBase)] = resolve36(serverPath);
+    state.manifest[toPascal(fileBase)] = resolve37(serverPath);
   }
   const { invalidateEmberSsrCache: invalidateEmberSsrCache2 } = await Promise.resolve().then(() => (init_ember(), exports_ember));
   invalidateEmberSsrCache2();
   const duration = Date.now() - startTime;
   const [primary] = emberFiles;
   if (primary) {
-    state.lastHmrPath = relative15(process.cwd(), primary).replace(/\\/g, "/");
+    state.lastHmrPath = relative16(process.cwd(), primary).replace(/\\/g, "/");
     state.lastHmrFramework = "ember";
     logHmrUpdate(primary, "ember", duration);
   }
@@ -21819,8 +22042,8 @@ var moduleServerPromise, getModuleServer = () => moduleServerPromise, runSequent
   if (!buildReference?.source) {
     return;
   }
-  const sourcePath = buildReference.source.startsWith("file://") ? new URL(buildReference.source).pathname : resolve36(dirname20(buildInfo.resolvedRegistryPath), buildReference.source);
-  islandFiles.add(resolve36(sourcePath));
+  const sourcePath = buildReference.source.startsWith("file://") ? new URL(buildReference.source).pathname : resolve37(dirname21(buildInfo.resolvedRegistryPath), buildReference.source);
+  islandFiles.add(resolve37(sourcePath));
 }, resolveIslandSourceFiles = async (config) => {
   const registryPath = config.islands?.registry;
   if (!registryPath) {
@@ -21828,7 +22051,7 @@ var moduleServerPromise, getModuleServer = () => moduleServerPromise, runSequent
   }
   const buildInfo = await loadIslandRegistryBuildInfo(registryPath);
   const islandFiles = new Set([
-    resolve36(buildInfo.resolvedRegistryPath)
+    resolve37(buildInfo.resolvedRegistryPath)
   ]);
   for (const definition of buildInfo.definitions) {
     resolveIslandDefinitionSource(definition, buildInfo, islandFiles);
@@ -21839,7 +22062,7 @@ var moduleServerPromise, getModuleServer = () => moduleServerPromise, runSequent
   if (islandFiles.size === 0) {
     return false;
   }
-  return filesToRebuild.some((file4) => islandFiles.has(resolve36(file4)));
+  return filesToRebuild.some((file4) => islandFiles.has(resolve37(file4)));
 }, handleIslandSourceReload = async (state, config, filesToRebuild, manifest) => {
   const shouldReload = await didStaticPagesNeedIslandRefresh(config, filesToRebuild);
   if (!shouldReload) {
@@ -21874,10 +22097,10 @@ var moduleServerPromise, getModuleServer = () => moduleServerPromise, runSequent
 }, computeOutputPagesDir = (state, config, framework) => {
   const isSingle = !config.reactDirectory && !config.svelteDirectory && !config.vueDirectory && (framework === "html" ? !config.htmxDirectory : !config.htmlDirectory);
   if (isSingle) {
-    return resolve36(state.resolvedPaths.buildDir, "pages");
+    return resolve37(state.resolvedPaths.buildDir, "pages");
   }
   const dirName = framework === "html" ? basename11(config.htmlDirectory ?? "html") : basename11(config.htmxDirectory ?? "htmx");
-  return resolve36(state.resolvedPaths.buildDir, dirName, "pages");
+  return resolve37(state.resolvedPaths.buildDir, dirName, "pages");
 }, processHtmlPageUpdate = async (state, pageFile, builtHtmlPagePath, manifest, duration) => {
   try {
     const { handleHTMLUpdate: handleHTMLUpdate2 } = await Promise.resolve().then(() => (init_simpleHTMLHMR(), exports_simpleHTMLHMR));
@@ -21916,7 +22139,7 @@ var moduleServerPromise, getModuleServer = () => moduleServerPromise, runSequent
   const pageFilesToUpdate = shouldRefreshAllPages ? await scanEntryPoints(outputHtmlPages, "*.html") : htmlPageFiles;
   await runSequentially(pageFilesToUpdate, async (pageFile) => {
     const htmlPageName = basename11(pageFile);
-    const builtHtmlPagePath = resolve36(outputHtmlPages, htmlPageName);
+    const builtHtmlPagePath = resolve37(outputHtmlPages, htmlPageName);
     await processHtmlPageUpdate(state, pageFile, builtHtmlPagePath, manifest, duration);
   });
 }, handleVueCssOnlyUpdate = (state, vueCssFiles, manifest, duration) => {
@@ -21977,11 +22200,11 @@ var moduleServerPromise, getModuleServer = () => moduleServerPromise, runSequent
   const baseName = fileName.replace(/\.vue$/, "");
   const pascalName = toPascal(baseName);
   const vueRoot = config.vueDirectory;
-  const hmrId = vueRoot ? relative15(vueRoot, vuePagePath).replace(/\\/g, "/").replace(/\.vue$/, "") : baseName;
+  const hmrId = vueRoot ? relative16(vueRoot, vuePagePath).replace(/\\/g, "/").replace(/\.vue$/, "") : baseName;
   const cssKey = `${pascalName}CSS`;
   const cssUrl = manifest[cssKey] || null;
   const { vueHmrMetadata: vueHmrMetadata2 } = await Promise.resolve().then(() => (init_compileVue(), exports_compileVue));
-  const hmrMeta = vueHmrMetadata2.get(resolve36(vuePagePath));
+  const hmrMeta = vueHmrMetadata2.get(resolve37(vuePagePath));
   const changeType = hmrMeta?.changeType ?? "full";
   if (changeType === "style-only") {
     broadcastVueStyleOnly(state, vuePagePath, baseName, cssUrl, hmrId, manifest, duration);
@@ -22166,7 +22389,7 @@ var moduleServerPromise, getModuleServer = () => moduleServerPromise, runSequent
   const pageFilesToUpdate = shouldRefreshAllPages ? await scanEntryPoints(outputHtmxPages, "*.html") : htmxPageFiles;
   await runSequentially(pageFilesToUpdate, async (htmxPageFile) => {
     const htmxPageName = basename11(htmxPageFile);
-    const builtHtmxPagePath = resolve36(outputHtmxPages, htmxPageName);
+    const builtHtmxPagePath = resolve37(outputHtmxPages, htmxPageName);
     await processHtmxPageUpdate(state, htmxPageFile, builtHtmxPagePath, manifest, duration);
   });
 }, collectUpdatedModulePaths = (allModuleUpdates) => {
@@ -22275,7 +22498,7 @@ var moduleServerPromise, getModuleServer = () => moduleServerPromise, runSequent
   html = html.slice(0, bodyClose.index) + hmrScript + html.slice(bodyClose.index);
   writeFs(destPath, html);
 }, processMarkupFileFastPath = async (state, sourceFile, outputDir, framework, startTime, updateAssetPaths2, handleUpdate, readFs, writeFs) => {
-  const destPath = resolve36(outputDir, basename11(sourceFile));
+  const destPath = resolve37(outputDir, basename11(sourceFile));
   const hmrScript = extractHmrScript(destPath, readFs);
   const source = await Bun.file(sourceFile).text();
   await Bun.write(destPath, source);
@@ -22585,7 +22808,7 @@ __export(exports_buildDepVendor, {
   buildDepVendor: () => buildDepVendor
 });
 import { mkdirSync as mkdirSync13 } from "fs";
-import { join as join29 } from "path";
+import { join as join30 } from "path";
 import { rm as rm10 } from "fs/promises";
 var {build: bunBuild9, Glob: Glob9 } = globalThis.Bun;
 var toSafeFileName6 = (specifier) => {
@@ -22598,12 +22821,12 @@ var toSafeFileName6 = (specifier) => {
   } catch {
     return false;
   }
-}, isBareSpecifier2 = (spec) => !spec.startsWith(".") && !spec.startsWith("/") && !spec.startsWith("@src/"), isAbsolutePackageSpecifier = (spec) => spec === "@absolutejs/absolute" || spec.startsWith("@absolutejs/absolute/"), FRAMEWORK_SPECIFIERS, FRAMEWORK_NAMESPACE_PREFIXES, isFrameworkSpecifier = (spec) => FRAMEWORK_SPECIFIERS.has(spec) || FRAMEWORK_NAMESPACE_PREFIXES.some((prefix) => spec.startsWith(prefix)), FRAMEWORK_EXTERNALS, isSkippedFile = (file4) => file4.includes("node_modules") || file4.includes("/build/") || file4.includes("/dist/") || file4.includes("/indexes/"), isDepSpecifier = (path) => isBareSpecifier2(path) && !isFrameworkSpecifier(path) && !isAbsolutePackageSpecifier(path), isFrameworkRootCandidate = (path) => isBareSpecifier2(path) && isFrameworkSpecifier(path) && !isAbsolutePackageSpecifier(path), readFileSpecifiers = async (file4, transpiler5) => {
+}, isBareSpecifier2 = (spec) => !spec.startsWith(".") && !spec.startsWith("/") && !spec.startsWith("@src/"), isAbsolutePackageSpecifier = (spec) => spec === "@absolutejs/absolute" || spec.startsWith("@absolutejs/absolute/"), FRAMEWORK_SPECIFIERS, FRAMEWORK_NAMESPACE_PREFIXES, isFrameworkSpecifier = (spec) => FRAMEWORK_SPECIFIERS.has(spec) || FRAMEWORK_NAMESPACE_PREFIXES.some((prefix) => spec.startsWith(prefix)), FRAMEWORK_EXTERNALS, isSkippedFile = (file4) => file4.includes("node_modules") || file4.includes("/build/") || file4.includes("/dist/") || file4.includes("/indexes/"), isDepSpecifier = (path) => isBareSpecifier2(path) && !isFrameworkSpecifier(path) && !isAbsolutePackageSpecifier(path), isFrameworkRootCandidate = (path) => isBareSpecifier2(path) && isFrameworkSpecifier(path) && !isAbsolutePackageSpecifier(path), readFileSpecifiers = async (file4, transpiler6) => {
   const dep = [];
   const framework = [];
   try {
     const content = await Bun.file(file4).text();
-    for (const imp of transpiler5.scanImports(content)) {
+    for (const imp of transpiler6.scanImports(content)) {
       if (isDepSpecifier(imp.path))
         dep.push(imp.path);
       else if (isFrameworkRootCandidate(imp.path))
@@ -22620,9 +22843,9 @@ var toSafeFileName6 = (specifier) => {
   } catch {
     return empty;
   }
-}, collectDirSpecifiers = async (dir, transpiler5, dep, framework) => {
+}, collectDirSpecifiers = async (dir, transpiler6, dep, framework) => {
   const files = await scanDirFiles(dir);
-  const results = await Promise.all(files.map((file4) => readFileSpecifiers(file4, transpiler5)));
+  const results = await Promise.all(files.map((file4) => readFileSpecifiers(file4, transpiler6)));
   for (const result of results) {
     for (const spec of result.dep)
       dep.add(spec);
@@ -22632,15 +22855,15 @@ var toSafeFileName6 = (specifier) => {
 }, scanBareImports = async (directories) => {
   const dep = new Set;
   const framework = new Set;
-  const transpiler5 = new Bun.Transpiler({ loader: "tsx" });
-  await Promise.all(directories.map((dir) => collectDirSpecifiers(dir, transpiler5, dep, framework)));
+  const transpiler6 = new Bun.Transpiler({ loader: "tsx" });
+  await Promise.all(directories.map((dir) => collectDirSpecifiers(dir, transpiler6, dep, framework)));
   return {
     dep: Array.from(dep).filter(isResolvable4),
     framework: Array.from(framework).filter(isResolvable4)
   };
 }, collectTransitiveImports = async (specs, alreadyVendored, alreadyScanned) => {
   const { readFileSync: readFileSync20 } = await import("fs");
-  const transpiler5 = new Bun.Transpiler({ loader: "js" });
+  const transpiler6 = new Bun.Transpiler({ loader: "js" });
   const newSpecs = new Set;
   for (const spec of specs) {
     if (alreadyScanned.has(spec))
@@ -22660,7 +22883,7 @@ var toSafeFileName6 = (specifier) => {
     }
     let imports;
     try {
-      imports = transpiler5.scanImports(content);
+      imports = transpiler6.scanImports(content);
     } catch {
       continue;
     }
@@ -22696,7 +22919,7 @@ var toSafeFileName6 = (specifier) => {
 }), buildDepVendorPass = async (specifiers, vendorDir, tmpDir) => {
   const entries = await Promise.all(specifiers.map(async (specifier) => {
     const safeName = toSafeFileName6(specifier);
-    const entryPath = join29(tmpDir, `${safeName}.ts`);
+    const entryPath = join30(tmpDir, `${safeName}.ts`);
     await Bun.write(entryPath, await generateVendorEntrySource(specifier));
     return { entryPath, specifier };
   }));
@@ -22757,9 +22980,9 @@ var toSafeFileName6 = (specifier) => {
   const { dep: initialSpecs, framework: frameworkRoots } = await scanBareImports(directories);
   if (initialSpecs.length === 0 && frameworkRoots.length === 0)
     return {};
-  const vendorDir = join29(buildDir, "vendor");
+  const vendorDir = join30(buildDir, "vendor");
   mkdirSync13(vendorDir, { recursive: true });
-  const tmpDir = join29(buildDir, "_dep_vendor_tmp");
+  const tmpDir = join30(buildDir, "_dep_vendor_tmp");
   mkdirSync13(tmpDir, { recursive: true });
   const allSpecs = new Set(initialSpecs);
   const alreadyScanned = new Set;
@@ -22842,7 +23065,7 @@ __export(exports_devBuild, {
 });
 import { readdir as readdir5 } from "fs/promises";
 import { statSync as statSync5 } from "fs";
-import { resolve as resolve37 } from "path";
+import { resolve as resolve38 } from "path";
 var FRAMEWORK_DIR_KEYS, collectDepVendorSourceDirs = (config) => {
   const configuredDirs = [
     config.reactDirectory,
@@ -22865,7 +23088,7 @@ var FRAMEWORK_DIR_KEYS, collectDepVendorSourceDirs = (config) => {
   return Object.keys(config).length > 0 ? config : null;
 }, reloadConfig = async () => {
   try {
-    const configPath2 = resolve37(process.env.ABSOLUTE_CONFIG ?? "absolute.config.ts");
+    const configPath2 = resolve38(process.env.ABSOLUTE_CONFIG ?? "absolute.config.ts");
     const source = await Bun.file(configPath2).text();
     return parseDirectoryConfig(source);
   } catch {
@@ -22950,7 +23173,7 @@ var FRAMEWORK_DIR_KEYS, collectDepVendorSourceDirs = (config) => {
     state.fileChangeQueue.clear();
   }
 }, handleCachedReload = async () => {
-  const serverMtime = statSync5(resolve37(Bun.main)).mtimeMs;
+  const serverMtime = statSync5(resolve38(Bun.main)).mtimeMs;
   const lastMtime = globalThis.__hmrServerMtime;
   globalThis.__hmrServerMtime = serverMtime;
   const cached = globalThis.__hmrDevResult;
@@ -22987,8 +23210,8 @@ var FRAMEWORK_DIR_KEYS, collectDepVendorSourceDirs = (config) => {
   return true;
 }, resolveAbsoluteVersion2 = async () => {
   const candidates = [
-    resolve37(import.meta.dir, "..", "..", "package.json"),
-    resolve37(import.meta.dir, "..", "package.json")
+    resolve38(import.meta.dir, "..", "..", "package.json"),
+    resolve38(import.meta.dir, "..", "package.json")
   ];
   const [candidate, ...remaining] = candidates;
   if (!candidate) {
@@ -23014,7 +23237,7 @@ var FRAMEWORK_DIR_KEYS, collectDepVendorSourceDirs = (config) => {
   const entries = await readdir5(vendorDir).catch(() => emptyStringArray);
   await Promise.all(entries.filter((entry) => entry.endsWith(".js")).map(async (entry) => {
     const webPath = `/${framework}/vendor/${entry}`;
-    const bytes = await Bun.file(resolve37(vendorDir, entry)).bytes();
+    const bytes = await Bun.file(resolve38(vendorDir, entry)).bytes();
     assetStore.set(webPath, bytes);
   }));
 }, devBuild = async (config) => {
@@ -23082,11 +23305,11 @@ var FRAMEWORK_DIR_KEYS, collectDepVendorSourceDirs = (config) => {
   cleanStaleAssets(state.assetStore, manifest, state.resolvedPaths.buildDir);
   recordStep("populate asset store", stepStartedAt);
   stepStartedAt = performance.now();
-  const reactVendorDir = resolve37(state.resolvedPaths.buildDir, "react", "vendor");
-  const angularVendorDir = resolve37(state.resolvedPaths.buildDir, "angular", "vendor");
-  const svelteVendorDir = resolve37(state.resolvedPaths.buildDir, "svelte", "vendor");
-  const vueVendorDir = resolve37(state.resolvedPaths.buildDir, "vue", "vendor");
-  const depVendorDir = resolve37(state.resolvedPaths.buildDir, "vendor");
+  const reactVendorDir = resolve38(state.resolvedPaths.buildDir, "react", "vendor");
+  const angularVendorDir = resolve38(state.resolvedPaths.buildDir, "angular", "vendor");
+  const svelteVendorDir = resolve38(state.resolvedPaths.buildDir, "svelte", "vendor");
+  const vueVendorDir = resolve38(state.resolvedPaths.buildDir, "vue", "vendor");
+  const depVendorDir = resolve38(state.resolvedPaths.buildDir, "vendor");
   const { buildDepVendor: buildDepVendor2 } = await Promise.resolve().then(() => (init_buildDepVendor(), exports_buildDepVendor));
   const [, angularSpecs, , , , , depPaths] = await Promise.all([
     config.reactDirectory ? buildReactVendor(state.resolvedPaths.buildDir) : Promise.resolve(undefined),
@@ -23164,7 +23387,7 @@ var FRAMEWORK_DIR_KEYS, collectDepVendorSourceDirs = (config) => {
     manifest
   };
   globalThis.__hmrDevResult = result;
-  globalThis.__hmrServerMtime = statSync5(resolve37(Bun.main)).mtimeMs;
+  globalThis.__hmrServerMtime = statSync5(resolve38(Bun.main)).mtimeMs;
   return result;
 };
 var init_devBuild = __esm(() => {
@@ -23201,5 +23424,5 @@ export {
   build
 };
 
-//# debugId=084BDA7430AC337364756E2164756E21
+//# debugId=3B26BE8AA231F38A64756E2164756E21
 //# sourceMappingURL=build.js.map