@absolutejs/absolute 0.19.0-beta.987 → 0.19.0-beta.988

package/dist/build.js

@@ -10757,6 +10757,10 @@ var init_updateAssetPaths = __esm(() => {
 });
 
 // src/dev/buildHMRClient.ts
+var exports_buildHMRClient = {};
+__export(exports_buildHMRClient, {
+  buildHMRClient: () => buildHMRClient
+});
 import { existsSync as existsSync16 } from "fs";
 import { resolve as resolve12 } from "path";
 var {build: bunBuild } = globalThis.Bun;
@@ -11556,11 +11560,15 @@ var validateSafePath = (targetPath, baseDirectory) => {
 };
 var init_validateSafePath = () => {};
 
-// src/build/scanAngularHandlerCalls.ts
+// src/build/scanVueSsrOnlyPages.ts
+var exports_scanVueSsrOnlyPages = {};
+__export(exports_scanVueSsrOnlyPages, {
+  scanVueSsrOnlyPages: () => scanVueSsrOnlyPages
+});
 import { readdirSync as readdirSync2, readFileSync as readFileSync12 } from "fs";
 import { join as join22 } from "path";
 import ts6 from "typescript";
-var ELYSIA_ROUTE_METHODS2, SKIP_DIRS2, SOURCE_EXTENSIONS2, getScriptKind2 = (filePath) => {
+var SKIP_DIRS2, SOURCE_EXTENSIONS2, getScriptKind2 = (filePath) => {
   if (filePath.endsWith(".tsx"))
     return ts6.ScriptKind.TSX;
   return ts6.ScriptKind.TS;
@@ -11598,26 +11606,173 @@ var ELYSIA_ROUTE_METHODS2, SKIP_DIRS2, SOURCE_EXTENSIONS2, getScriptKind2 = (fil
     }
   }
   return out;
+}, fileMayContainVueHandler = (source) => source.includes("handleVuePageRequest"), isHandleVuePageRequestCallee = (expression) => {
+  if (ts6.isIdentifier(expression)) {
+    return expression.text === "handleVuePageRequest";
+  }
+  if (ts6.isPropertyAccessExpression(expression) && ts6.isIdentifier(expression.name)) {
+    return expression.name.text === "handleVuePageRequest";
+  }
+  return false;
+}, getPropertyName = (name) => {
+  if (ts6.isIdentifier(name) || ts6.isStringLiteral(name)) {
+    return name.text;
+  }
+  return null;
+}, readStringLiteralValue = (node) => {
+  if (ts6.isStringLiteral(node) || ts6.isNoSubstitutionTemplateLiteral(node)) {
+    return node.text;
+  }
+  return null;
+}, isAssetCall = (node) => {
+  if (!ts6.isCallExpression(node))
+    return false;
+  if (!ts6.isIdentifier(node.expression))
+    return false;
+  return node.expression.text === "asset";
+}, extractAssetLiteralKey = (call) => {
+  if (call.arguments.length < 2)
+    return null;
+  const keyArg = call.arguments[1];
+  if (!keyArg)
+    return null;
+  return readStringLiteralValue(keyArg);
+}, extractPagePathAssetKey = (initializer) => {
+  if (!isAssetCall(initializer))
+    return null;
+  if (!ts6.isCallExpression(initializer))
+    return null;
+  return extractAssetLiteralKey(initializer);
+}, extractSsrOnlyPageName = (objectLiteral) => {
+  let hasClientNone = false;
+  let pageAssetKey = null;
+  for (const property of objectLiteral.properties) {
+    if (!ts6.isPropertyAssignment(property))
+      continue;
+    const name = getPropertyName(property.name);
+    if (!name)
+      continue;
+    if (name === "client") {
+      const value = readStringLiteralValue(property.initializer);
+      if (value === "none")
+        hasClientNone = true;
+      continue;
+    }
+    if (name === "pagePath") {
+      pageAssetKey = extractPagePathAssetKey(property.initializer);
+    }
+  }
+  if (!hasClientNone)
+    return null;
+  return pageAssetKey;
+}, extractFromFile = (filePath, out) => {
+  let source;
+  try {
+    source = readFileSync12(filePath, "utf-8");
+  } catch {
+    return;
+  }
+  if (!fileMayContainVueHandler(source))
+    return;
+  const sourceFile = ts6.createSourceFile(filePath, source, ts6.ScriptTarget.Latest, true, getScriptKind2(filePath));
+  const visit = (node) => {
+    if (ts6.isCallExpression(node) && isHandleVuePageRequestCallee(node.expression)) {
+      const firstArg = node.arguments[0];
+      if (firstArg && ts6.isObjectLiteralExpression(firstArg)) {
+        const pageName = extractSsrOnlyPageName(firstArg);
+        if (pageName)
+          out.add(pageName);
+      }
+    }
+    ts6.forEachChild(node, visit);
+  };
+  ts6.forEachChild(sourceFile, visit);
+}, scanVueSsrOnlyPages = (projectRoot) => {
+  const files = collectSourceFiles2(projectRoot);
+  const ssrOnlyPageNames = new Set;
+  for (const file of files) {
+    extractFromFile(file, ssrOnlyPageNames);
+  }
+  return ssrOnlyPageNames;
+};
+var init_scanVueSsrOnlyPages = __esm(() => {
+  SKIP_DIRS2 = new Set([
+    ".absolutejs",
+    ".generated",
+    ".git",
+    ".next",
+    ".svelte-kit",
+    ".vercel",
+    "build",
+    "compiled",
+    "dist",
+    "node_modules"
+  ]);
+  SOURCE_EXTENSIONS2 = new Set([".ts", ".tsx", ".mts", ".cts"]);
+});
+
+// src/build/scanAngularHandlerCalls.ts
+import { readdirSync as readdirSync3, readFileSync as readFileSync13 } from "fs";
+import { join as join23 } from "path";
+import ts7 from "typescript";
+var ELYSIA_ROUTE_METHODS2, SKIP_DIRS3, SOURCE_EXTENSIONS3, getScriptKind3 = (filePath) => {
+  if (filePath.endsWith(".tsx"))
+    return ts7.ScriptKind.TSX;
+  return ts7.ScriptKind.TS;
+}, hasSourceExtension3 = (filePath) => {
+  const idx = filePath.lastIndexOf(".");
+  if (idx === -1)
+    return false;
+  return SOURCE_EXTENSIONS3.has(filePath.slice(idx));
+}, collectSourceFiles3 = (root) => {
+  const out = [];
+  const stack = [root];
+  while (stack.length > 0) {
+    const dir = stack.pop();
+    if (!dir)
+      continue;
+    let entries;
+    try {
+      entries = readdirSync3(dir, {
+        encoding: "utf-8",
+        withFileTypes: true
+      });
+    } catch {
+      continue;
+    }
+    for (const entry of entries) {
+      if (entry.isDirectory()) {
+        if (SKIP_DIRS3.has(entry.name))
+          continue;
+        if (entry.name.startsWith("."))
+          continue;
+        stack.push(join23(dir, entry.name));
+      } else if (entry.isFile() && hasSourceExtension3(entry.name)) {
+        out.push(join23(dir, entry.name));
+      }
+    }
+  }
+  return out;
 }, fileMayContainAngularHandler = (source) => source.includes("handleAngularPageRequest"), extractManifestKey = (pagePathValue) => {
-  if (!ts6.isCallExpression(pagePathValue))
+  if (!ts7.isCallExpression(pagePathValue))
     return null;
   const callee = pagePathValue.expression;
-  if (!ts6.isIdentifier(callee) || callee.text !== "asset")
+  if (!ts7.isIdentifier(callee) || callee.text !== "asset")
     return null;
   const [, second] = pagePathValue.arguments;
   if (!second)
     return null;
-  if (!ts6.isStringLiteral(second))
+  if (!ts7.isStringLiteral(second))
     return null;
   return second.text;
 }, findEnclosingMountPath = (node) => {
   let cursor = node.parent;
   while (cursor) {
-    if (ts6.isCallExpression(cursor)) {
+    if (ts7.isCallExpression(cursor)) {
       const callee = cursor.expression;
-      if (ts6.isPropertyAccessExpression(callee) && ts6.isIdentifier(callee.name) && ELYSIA_ROUTE_METHODS2.has(callee.name.text)) {
+      if (ts7.isPropertyAccessExpression(callee) && ts7.isIdentifier(callee.name) && ELYSIA_ROUTE_METHODS2.has(callee.name.text)) {
         const firstArg = cursor.arguments[0];
-        if (firstArg && ts6.isStringLiteral(firstArg) && firstArg.text.startsWith("/")) {
+        if (firstArg && ts7.isStringLiteral(firstArg) && firstArg.text.startsWith("/")) {
           return firstArg.text;
         }
       }
@@ -11628,33 +11783,33 @@ var ELYSIA_ROUTE_METHODS2, SKIP_DIRS2, SOURCE_EXTENSIONS2, getScriptKind2 = (fil
 }, extractCallsFromFile = (filePath, out) => {
   let source;
   try {
-    source = readFileSync12(filePath, "utf-8");
+    source = readFileSync13(filePath, "utf-8");
   } catch {
     return;
   }
   if (!fileMayContainAngularHandler(source))
     return;
-  const sf = ts6.createSourceFile(filePath, source, ts6.ScriptTarget.Latest, true, getScriptKind2(filePath));
+  const sf = ts7.createSourceFile(filePath, source, ts7.ScriptTarget.Latest, true, getScriptKind3(filePath));
   const visit = (node) => {
-    if (ts6.isCallExpression(node) && ts6.isIdentifier(node.expression) && node.expression.text === "handleAngularPageRequest") {
+    if (ts7.isCallExpression(node) && ts7.isIdentifier(node.expression) && node.expression.text === "handleAngularPageRequest") {
       const [arg] = node.arguments;
-      if (arg && ts6.isObjectLiteralExpression(arg)) {
+      if (arg && ts7.isObjectLiteralExpression(arg)) {
         let manifestKey = null;
         for (const prop of arg.properties) {
-          if (ts6.isPropertyAssignment(prop)) {
+          if (ts7.isPropertyAssignment(prop)) {
             if (!prop.name)
               continue;
-            const name = ts6.isIdentifier(prop.name) ? prop.name.text : ts6.isStringLiteral(prop.name) ? prop.name.text : null;
+            const name = ts7.isIdentifier(prop.name) ? prop.name.text : ts7.isStringLiteral(prop.name) ? prop.name.text : null;
             if (name === "pagePath") {
               manifestKey = extractManifestKey(prop.initializer);
             }
-          } else if (ts6.isSpreadAssignment(prop)) {
+          } else if (ts7.isSpreadAssignment(prop)) {
             if (manifestKey)
               continue;
             const spreadExpr = prop.expression;
-            if (ts6.isCallExpression(spreadExpr) && spreadExpr.arguments.length > 0) {
+            if (ts7.isCallExpression(spreadExpr) && spreadExpr.arguments.length > 0) {
               const [firstArg] = spreadExpr.arguments;
-              if (firstArg && ts6.isStringLiteral(firstArg)) {
+              if (firstArg && ts7.isStringLiteral(firstArg)) {
                 manifestKey = firstArg.text;
               }
             }
@@ -11669,11 +11824,11 @@ var ELYSIA_ROUTE_METHODS2, SKIP_DIRS2, SOURCE_EXTENSIONS2, getScriptKind2 = (fil
         }
       }
     }
-    ts6.forEachChild(node, visit);
+    ts7.forEachChild(node, visit);
   };
-  ts6.forEachChild(sf, visit);
+  ts7.forEachChild(sf, visit);
 }, scanAngularHandlerCalls = (projectRoot) => {
-  const files = collectSourceFiles2(projectRoot);
+  const files = collectSourceFiles3(projectRoot);
   const collected = [];
   for (const file of files) {
     extractCallsFromFile(file, collected);
@@ -11691,7 +11846,7 @@ var init_scanAngularHandlerCalls = __esm(() => {
     "post",
     "put"
   ]);
-  SKIP_DIRS2 = new Set([
+  SKIP_DIRS3 = new Set([
     ".absolutejs",
     ".generated",
     ".git",
@@ -11703,20 +11858,20 @@ var init_scanAngularHandlerCalls = __esm(() => {
     "dist",
     "node_modules"
   ]);
-  SOURCE_EXTENSIONS2 = new Set([".ts", ".tsx", ".mts", ".cts"]);
+  SOURCE_EXTENSIONS3 = new Set([".ts", ".tsx", ".mts", ".cts"]);
 });
 
 // src/build/scanAngularPageRoutes.ts
-import { readdirSync as readdirSync3, readFileSync as readFileSync13 } from "fs";
-import { basename as basename5, join as join23 } from "path";
-import ts7 from "typescript";
-var SOURCE_EXTENSIONS3, SKIP_DIRS3, hasSourceExtension3 = (filePath) => {
+import { readdirSync as readdirSync4, readFileSync as readFileSync14 } from "fs";
+import { basename as basename5, join as join24 } from "path";
+import ts8 from "typescript";
+var SOURCE_EXTENSIONS4, SKIP_DIRS4, hasSourceExtension4 = (filePath) => {
   const idx = filePath.lastIndexOf(".");
   if (idx === -1)
     return false;
-  return SOURCE_EXTENSIONS3.has(filePath.slice(idx));
+  return SOURCE_EXTENSIONS4.has(filePath.slice(idx));
 }, isPageFile = (filePath) => {
-  if (!hasSourceExtension3(filePath))
+  if (!hasSourceExtension4(filePath))
     return false;
   const base = basename5(filePath);
   if (base.endsWith(".d.ts"))
@@ -11735,7 +11890,7 @@ var SOURCE_EXTENSIONS3, SKIP_DIRS3, hasSourceExtension3 = (filePath) => {
       continue;
     let entries;
     try {
-      entries = readdirSync3(dir, {
+      entries = readdirSync4(dir, {
         encoding: "utf-8",
         withFileTypes: true
       });
@@ -11744,13 +11899,13 @@ var SOURCE_EXTENSIONS3, SKIP_DIRS3, hasSourceExtension3 = (filePath) => {
     }
     for (const entry of entries) {
       if (entry.isDirectory()) {
-        if (SKIP_DIRS3.has(entry.name))
+        if (SKIP_DIRS4.has(entry.name))
           continue;
         if (entry.name.startsWith("."))
           continue;
-        stack.push(join23(dir, entry.name));
+        stack.push(join24(dir, entry.name));
       } else if (entry.isFile() && isPageFile(entry.name)) {
-        out.push(join23(dir, entry.name));
+        out.push(join24(dir, entry.name));
       }
     }
   }
@@ -11758,15 +11913,15 @@ var SOURCE_EXTENSIONS3, SKIP_DIRS3, hasSourceExtension3 = (filePath) => {
 }, hasTopLevelRoutesExport = (source, filePath) => {
   if (!source.includes("routes"))
     return false;
-  const sf = ts7.createSourceFile(filePath, source, ts7.ScriptTarget.Latest, true, ts7.ScriptKind.TS);
+  const sf = ts8.createSourceFile(filePath, source, ts8.ScriptTarget.Latest, true, ts8.ScriptKind.TS);
   for (const statement of sf.statements) {
-    if (!ts7.isVariableStatement(statement))
+    if (!ts8.isVariableStatement(statement))
       continue;
-    const isExported = statement.modifiers?.some((modifier) => modifier.kind === ts7.SyntaxKind.ExportKeyword);
+    const isExported = statement.modifiers?.some((modifier) => modifier.kind === ts8.SyntaxKind.ExportKeyword);
     if (!isExported)
       continue;
     for (const declaration of statement.declarationList.declarations) {
-      if (!ts7.isIdentifier(declaration.name))
+      if (!ts8.isIdentifier(declaration.name))
         continue;
       if (declaration.name.text === "routes")
         return true;
@@ -11779,7 +11934,7 @@ var SOURCE_EXTENSIONS3, SKIP_DIRS3, hasSourceExtension3 = (filePath) => {
   for (const file of files) {
     let source;
     try {
-      source = readFileSync13(file, "utf-8");
+      source = readFileSync14(file, "utf-8");
     } catch {
       continue;
     }
@@ -11795,8 +11950,8 @@ var SOURCE_EXTENSIONS3, SKIP_DIRS3, hasSourceExtension3 = (filePath) => {
   return out;
 };
 var init_scanAngularPageRoutes = __esm(() => {
-  SOURCE_EXTENSIONS3 = new Set([".ts", ".tsx", ".mts", ".cts"]);
-  SKIP_DIRS3 = new Set([
+  SOURCE_EXTENSIONS4 = new Set([".ts", ".tsx", ".mts", ".cts"]);
+  SKIP_DIRS4 = new Set([
     ".absolutejs",
     ".generated",
     ".git",
@@ -11826,46 +11981,46 @@ var exports_parseAngularConfigImports = {};
 __export(exports_parseAngularConfigImports, {
   parseAngularProvidersImport: () => parseAngularProvidersImport
 });
-import { existsSync as existsSync19, readFileSync as readFileSync14 } from "fs";
-import { dirname as dirname11, isAbsolute as isAbsolute3, join as join24 } from "path";
-import ts8 from "typescript";
+import { existsSync as existsSync19, readFileSync as readFileSync15 } from "fs";
+import { dirname as dirname11, isAbsolute as isAbsolute3, join as join25 } from "path";
+import ts9 from "typescript";
 var findDefineConfigCall = (sf) => {
   let result = null;
   const visit = (node) => {
     if (result)
       return;
-    if (ts8.isCallExpression(node) && ts8.isIdentifier(node.expression) && node.expression.text === "defineConfig") {
+    if (ts9.isCallExpression(node) && ts9.isIdentifier(node.expression) && node.expression.text === "defineConfig") {
       const [arg] = node.arguments;
-      if (arg && ts8.isObjectLiteralExpression(arg)) {
+      if (arg && ts9.isObjectLiteralExpression(arg)) {
         result = arg;
         return;
       }
     }
-    ts8.forEachChild(node, visit);
+    ts9.forEachChild(node, visit);
   };
-  ts8.forEachChild(sf, visit);
+  ts9.forEachChild(sf, visit);
   return result;
 }, findPropertyInitializer = (object, name) => {
   for (const prop of object.properties) {
-    if (!ts8.isPropertyAssignment(prop))
+    if (!ts9.isPropertyAssignment(prop))
       continue;
     if (!prop.name)
       continue;
-    const key = ts8.isIdentifier(prop.name) ? prop.name.text : ts8.isStringLiteral(prop.name) ? prop.name.text : null;
+    const key = ts9.isIdentifier(prop.name) ? prop.name.text : ts9.isStringLiteral(prop.name) ? prop.name.text : null;
     if (key === name)
       return prop.initializer;
   }
   return null;
 }, findImportForBinding = (sf, binding) => {
   for (const statement of sf.statements) {
-    if (!ts8.isImportDeclaration(statement))
+    if (!ts9.isImportDeclaration(statement))
       continue;
-    if (!ts8.isStringLiteral(statement.moduleSpecifier))
+    if (!ts9.isStringLiteral(statement.moduleSpecifier))
       continue;
     if (statement.importClause?.isTypeOnly)
       continue;
     const named = statement.importClause?.namedBindings;
-    if (!named || !ts8.isNamedImports(named))
+    if (!named || !ts9.isNamedImports(named))
       continue;
     for (const element of named.elements) {
       if (element.isTypeOnly)
@@ -11882,15 +12037,15 @@ var findDefineConfigCall = (sf) => {
 }, resolveConfigPath = (projectRoot) => {
   const envOverride = process.env.ABSOLUTE_CONFIG;
   if (envOverride) {
-    const resolved = isAbsolute3(envOverride) ? envOverride : join24(projectRoot, envOverride);
+    const resolved = isAbsolute3(envOverride) ? envOverride : join25(projectRoot, envOverride);
     if (existsSync19(resolved))
       return resolved;
   }
   const candidates = [
-    join24(projectRoot, "absolute.config.ts"),
-    join24(projectRoot, "absolute.config.mts"),
-    join24(projectRoot, "absolute.config.js"),
-    join24(projectRoot, "absolute.config.mjs")
+    join25(projectRoot, "absolute.config.ts"),
+    join25(projectRoot, "absolute.config.mts"),
+    join25(projectRoot, "absolute.config.js"),
+    join25(projectRoot, "absolute.config.mjs")
   ];
   for (const candidate of candidates) {
     if (existsSync19(candidate))
@@ -11901,29 +12056,29 @@ var findDefineConfigCall = (sf) => {
   const configPath2 = resolveConfigPath(projectRoot);
   if (!configPath2)
     return null;
-  const source = readFileSync14(configPath2, "utf-8");
+  const source = readFileSync15(configPath2, "utf-8");
   if (!source.includes("angular"))
     return null;
   if (!source.includes("providers"))
     return null;
-  const sf = ts8.createSourceFile(configPath2, source, ts8.ScriptTarget.Latest, true, ts8.ScriptKind.TS);
+  const sf = ts9.createSourceFile(configPath2, source, ts9.ScriptTarget.Latest, true, ts9.ScriptKind.TS);
   const configObject = findDefineConfigCall(sf);
   if (!configObject)
     return null;
   const angularField = findPropertyInitializer(configObject, "angular");
-  if (!angularField || !ts8.isObjectLiteralExpression(angularField))
+  if (!angularField || !ts9.isObjectLiteralExpression(angularField))
     return null;
   const providersField = findPropertyInitializer(angularField, "providers");
   if (!providersField)
     return null;
-  if (!ts8.isIdentifier(providersField))
+  if (!ts9.isIdentifier(providersField))
     return null;
   const binding = providersField.text;
   const importInfo = findImportForBinding(sf, binding);
   if (!importInfo)
     return null;
   const configDir2 = dirname11(configPath2);
-  const absolutePath = importInfo.source.startsWith(".") ? join24(configDir2, importInfo.source).replace(/\.[cm]?[tj]sx?$/, "") : isAbsolute3(importInfo.source) ? importInfo.source.replace(/\.[cm]?[tj]sx?$/, "") : importInfo.source;
+  const absolutePath = importInfo.source.startsWith(".") ? join25(configDir2, importInfo.source).replace(/\.[cm]?[tj]sx?$/, "") : isAbsolute3(importInfo.source) ? importInfo.source.replace(/\.[cm]?[tj]sx?$/, "") : importInfo.source;
   return {
     absolutePath,
     bindingName: binding,
@@ -12075,7 +12230,7 @@ import { existsSync as existsSync20 } from "fs";
 import { mkdir as mkdir4, stat as stat2 } from "fs/promises";
 import {
   dirname as dirname12,
-  join as join25,
+  join as join26,
   basename as basename6,
   extname as extname5,
   resolve as resolve19,
@@ -12134,14 +12289,14 @@ var resolveDevClientDir2 = () => {
     `${basePath}.svelte`,
     `${basePath}.svelte.ts`,
     `${basePath}.svelte.js`,
-    join25(basePath, "index.ts"),
-    join25(basePath, "index.js"),
-    join25(basePath, "index.mjs"),
-    join25(basePath, "index.cjs"),
-    join25(basePath, "index.json"),
-    join25(basePath, "index.svelte"),
-    join25(basePath, "index.svelte.ts"),
-    join25(basePath, "index.svelte.js")
+    join26(basePath, "index.ts"),
+    join26(basePath, "index.js"),
+    join26(basePath, "index.mjs"),
+    join26(basePath, "index.cjs"),
+    join26(basePath, "index.json"),
+    join26(basePath, "index.svelte"),
+    join26(basePath, "index.svelte.ts"),
+    join26(basePath, "index.svelte.js")
   ];
   const checks = await Promise.all(candidates.map(exists));
   return candidates.find((_2, index) => checks[index]) ?? null;
@@ -12180,9 +12335,9 @@ 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 = join25(generatedDir, "client");
-  const indexDir = join25(generatedDir, "indexes");
-  const serverDir = join25(generatedDir, "server");
+  const clientDir = join26(generatedDir, "client");
+  const indexDir = join26(generatedDir, "indexes");
+  const serverDir = join26(generatedDir, "server");
   await Promise.all([clientDir, indexDir, serverDir].map((dir) => mkdir4(dir, { recursive: true })));
   const dev = env.NODE_ENV !== "production";
   const build = async (src) => {
@@ -12220,8 +12375,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 = dirname12(join25(serverDir, relDir, `${baseName}.js`));
-    const clientOutputDir = dirname12(join25(clientDir, relDir, `${baseName}.js`));
+    const ssrOutputDir = dirname12(join26(serverDir, relDir, `${baseName}.js`));
+    const clientOutputDir = dirname12(join26(clientDir, relDir, `${baseName}.js`));
     for (let idx = 0;idx < importPaths.length; idx++) {
       const rawSpec = importPaths[idx];
       if (!rawSpec)
@@ -12286,8 +12441,8 @@ var resolveDevClientDir2 = () => {
       code += islandMetadataExports;
       return { code, map: compiledJs.map };
     };
-    const ssrPath = join25(serverDir, relDir, `${baseName}.js`);
-    const clientPath = join25(clientDir, relDir, `${baseName}.js`);
+    const ssrPath = join26(serverDir, relDir, `${baseName}.js`);
+    const clientPath = join26(clientDir, relDir, `${baseName}.js`);
     await Promise.all([
       mkdir4(dirname12(ssrPath), { recursive: true }),
       mkdir4(dirname12(clientPath), { recursive: true })
@@ -12325,7 +12480,7 @@ var resolveDevClientDir2 = () => {
   await Promise.all(roots.map(async ({ client, hasAwaitSlot }) => {
     const relClientDir = dirname12(relative9(clientDir, client));
     const name = basename6(client, extname5(client));
-    const indexPath = join25(indexDir, relClientDir, `${name}.js`);
+    const indexPath = join26(indexDir, relClientDir, `${name}.js`);
     const importRaw = relative9(dirname12(indexPath), client).split(sep2).join("/");
     const importPath = importRaw.startsWith(".") || importRaw.startsWith("/") ? importRaw : `./${importRaw}`;
     const hmrImports = isDev ? `window.__HMR_FRAMEWORK__ = "svelte";
@@ -12404,7 +12559,7 @@ if (typeof window !== "undefined") {
     svelteClientPaths: roots.map(({ client }) => client),
     svelteIndexPaths: roots.map(({ client }) => {
       const rel = dirname12(relative9(clientDir, client));
-      return join25(indexDir, rel, basename6(client));
+      return join26(indexDir, rel, basename6(client));
     }),
     svelteServerPaths: roots.map(({ ssr }) => ssr)
   };
@@ -12419,7 +12574,7 @@ var init_compileSvelte = __esm(() => {
   init_lowerAwaitSlotSyntax();
   init_renderToReadableStream();
   devClientDir2 = resolveDevClientDir2();
-  hmrClientPath3 = join25(devClientDir2, "hmrClient.ts").replace(/\\/g, "/");
+  hmrClientPath3 = join26(devClientDir2, "hmrClient.ts").replace(/\\/g, "/");
   persistentCache = new Map;
   sourceHashCache = new Map;
   transpiler3 = new Transpiler2({ loader: "ts", target: "browser" });
@@ -12434,7 +12589,7 @@ __export(exports_chainInlineSourcemaps, {
   chainBundleInlineSourcemap: () => chainBundleInlineSourcemap,
   buildLineRemap: () => buildLineRemap
 });
-import { readFileSync as readFileSync15, writeFileSync as writeFileSync7 } from "fs";
+import { readFileSync as readFileSync16, writeFileSync as writeFileSync7 } from "fs";
 var BASE64_CHARS = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/", BASE64_TO_INT, decodeVlq = (str, startPos) => {
   let result = 0;
   let shift = 0;
@@ -12725,7 +12880,7 @@ var BASE64_CHARS = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz01234567
     version: 3
   };
 }, chainBundleInlineSourcemap = (bundleFilePath) => {
-  const text = readFileSync15(bundleFilePath, "utf-8");
+  const text = readFileSync16(bundleFilePath, "utf-8");
   const outerMap = extractInlineMap(text);
   if (!outerMap)
     return;
@@ -12817,7 +12972,7 @@ import {
   basename as basename7,
   dirname as dirname13,
   isAbsolute as isAbsolute4,
-  join as join26,
+  join as join27,
   relative as relative10,
   resolve as resolve20
 } from "path";
@@ -12995,7 +13150,7 @@ var resolveDevClientDir3 = () => {
   ];
   let cssOutputPaths = [];
   if (isEntryPoint && allCss.length) {
-    const cssOutputFile = join26(outputDirs.css, `${toKebab(fileBaseName)}-compiled.css`);
+    const cssOutputFile = join27(outputDirs.css, `${toKebab(fileBaseName)}-compiled.css`);
     await mkdir5(dirname13(cssOutputFile), { recursive: true });
     await write3(cssOutputFile, allCss.join(`
 `));
@@ -13026,8 +13181,8 @@ if (typeof __VUE_HMR_RUNTIME__ !== 'undefined') {
   };
   const clientCode = assembleModule(generateRenderFunction(false), "render", true) + islandMetadataExports;
   const serverCode = assembleModule(generateRenderFunction(true), "ssrRender", false) + islandMetadataExports;
-  const clientOutputPath = join26(outputDirs.client, `${relativeWithoutExtension}.js`);
-  const serverOutputPath = join26(outputDirs.server, `${relativeWithoutExtension}.js`);
+  const clientOutputPath = join27(outputDirs.client, `${relativeWithoutExtension}.js`);
+  const serverOutputPath = join27(outputDirs.server, `${relativeWithoutExtension}.js`);
   const relDir = dirname13(relativeFilePath);
   const relDepth = relDir === "." ? 0 : relDir.split("/").length;
   const adjustImports = (code) => code.replace(/(from\s+['"])(\.\.\/(?:\.\.\/)*)/g, (_2, prefix, dots) => {
@@ -13077,13 +13232,13 @@ if (typeof __VUE_HMR_RUNTIME__ !== 'undefined') {
   cacheMap.set(sourceFilePath, result);
   persistentBuildCache.set(sourceFilePath, result);
   return result;
-}, compileVue = async (entryPoints, vueRootDir, isDev = false, stylePreprocessors) => {
+}, compileVue = async (entryPoints, vueRootDir, isDev = false, stylePreprocessors, ssrOnlyEntries) => {
   const compiler = await import("@vue/compiler-sfc");
   const generatedDir = getFrameworkGeneratedDir("vue");
-  const clientOutputDir = join26(generatedDir, "client");
-  const indexOutputDir = join26(generatedDir, "indexes");
-  const serverOutputDir = join26(generatedDir, "server");
-  const cssOutputDir = join26(generatedDir, "compiled");
+  const clientOutputDir = join27(generatedDir, "client");
+  const indexOutputDir = join27(generatedDir, "indexes");
+  const serverOutputDir = join27(generatedDir, "server");
+  const cssOutputDir = join27(generatedDir, "compiled");
   await Promise.all([
     mkdir5(clientOutputDir, { recursive: true }),
     mkdir5(indexOutputDir, { recursive: true }),
@@ -13093,15 +13248,24 @@ if (typeof __VUE_HMR_RUNTIME__ !== 'undefined') {
   const buildCache = new Map;
   const allTsHelperPaths = new Set;
   const compiledPages = await Promise.all(entryPoints.map(async (entryPath) => {
-    const result = await compileVueFile(resolve20(entryPath), {
+    const resolvedEntryPath = resolve20(entryPath);
+    const result = await compileVueFile(resolvedEntryPath, {
       client: clientOutputDir,
       css: cssOutputDir,
       server: serverOutputDir
     }, buildCache, true, vueRootDir, compiler, stylePreprocessors);
     result.tsHelperPaths.forEach((path) => allTsHelperPaths.add(path));
+    if (ssrOnlyEntries?.has(resolvedEntryPath)) {
+      return {
+        clientPath: null,
+        cssPaths: result.cssPaths,
+        indexPath: null,
+        serverPath: result.serverPath
+      };
+    }
     const entryBaseName = basename7(entryPath, ".vue");
-    const indexOutputFile = join26(indexOutputDir, `${entryBaseName}.js`);
-    const clientOutputFile = join26(clientOutputDir, relative10(vueRootDir, entryPath).replace(/\\/g, "/").replace(/\.vue$/, ".js"));
+    const indexOutputFile = join27(indexOutputDir, `${entryBaseName}.js`);
+    const clientOutputFile = join27(clientOutputDir, relative10(vueRootDir, entryPath).replace(/\\/g, "/").replace(/\.vue$/, ".js"));
     await mkdir5(dirname13(indexOutputFile), { recursive: true });
     const vueHmrImports = isDev ? [
       `window.__HMR_FRAMEWORK__ = "vue";`,
@@ -13254,18 +13418,19 @@ if (typeof __VUE_HMR_RUNTIME__ !== 'undefined') {
     const sourceCode = await file2(tsPath).text();
     const transpiledCode = transpiler4.transformSync(sourceCode);
     const relativeJsPath = relative10(vueRootDir, tsPath).replace(/\.ts$/, ".js");
-    const outClientPath = join26(clientOutputDir, relativeJsPath);
-    const outServerPath = join26(serverOutputDir, relativeJsPath);
+    const outClientPath = join27(clientOutputDir, relativeJsPath);
+    const outServerPath = join27(serverOutputDir, relativeJsPath);
     await mkdir5(dirname13(outClientPath), { recursive: true });
     await mkdir5(dirname13(outServerPath), { recursive: true });
     await write3(outClientPath, transpiledCode);
     await write3(outServerPath, transpiledCode);
   }));
+  const isString = (value) => value !== null;
   return {
     hmrMetadata: new Map(vueHmrMetadata),
-    vueClientPaths: compiledPages.map((result) => result.clientPath),
+    vueClientPaths: compiledPages.map((p2) => p2.clientPath).filter(isString),
     vueCssPaths: compiledPages.flatMap((result) => result.cssPaths),
-    vueIndexPaths: compiledPages.map((result) => result.indexPath),
+    vueIndexPaths: compiledPages.map((p2) => p2.indexPath).filter(isString),
     vueServerPaths: compiledPages.map((result) => result.serverPath)
   };
 };
@@ -13278,7 +13443,7 @@ var init_compileVue = __esm(() => {
   init_vueAutoRouterTransform();
   init_stylePreprocessor();
   devClientDir3 = resolveDevClientDir3();
-  hmrClientPath4 = join26(devClientDir3, "hmrClient.ts").replace(/\\/g, "/");
+  hmrClientPath4 = join27(devClientDir3, "hmrClient.ts").replace(/\\/g, "/");
   transpiler4 = new Transpiler3({ loader: "ts", target: "browser" });
   scriptCache = new Map;
   scriptSetupCache = new Map;
@@ -13759,17 +13924,17 @@ __export(exports_compileAngular, {
   compileAngularFile: () => compileAngularFile,
   compileAngular: () => compileAngular
 });
-import { existsSync as existsSync22, readFileSync as readFileSync16, promises as fs5 } from "fs";
-import { join as join27, basename as basename8, sep as sep3, dirname as dirname14, resolve as resolve21, relative as relative11 } from "path";
+import { existsSync as existsSync22, readFileSync as readFileSync17, promises as fs5 } from "fs";
+import { join as join28, basename as basename8, sep as sep3, dirname as dirname14, resolve as resolve21, relative as relative11 } from "path";
 var {Glob: Glob6 } = globalThis.Bun;
-import ts9 from "typescript";
+import ts10 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 = resolve21(process.cwd(), "tsconfig.json");
-    const config = ts9.readConfigFile(configPath2, ts9.sys.readFile).config;
+    const config = ts10.readConfigFile(configPath2, ts10.sys.readFile).config;
     const compilerOptions = config?.compilerOptions ?? {};
     const baseUrl = resolve21(process.cwd(), compilerOptions.baseUrl ?? ".");
     const aliases = Object.entries(compilerOptions.paths ?? {}).map(([pattern, replacements]) => ({ pattern, replacements }));
@@ -13803,10 +13968,10 @@ var traceAngularPhase = async (name, fn2, metadata) => {
     `${candidate}.tsx`,
     `${candidate}.js`,
     `${candidate}.jsx`,
-    join27(candidate, "index.ts"),
-    join27(candidate, "index.tsx"),
-    join27(candidate, "index.js"),
-    join27(candidate, "index.jsx")
+    join28(candidate, "index.ts"),
+    join28(candidate, "index.tsx"),
+    join28(candidate, "index.js"),
+    join28(candidate, "index.jsx")
   ];
   return candidates.find((file3) => existsSync22(file3));
 }, createLegacyAngularAnimationUsageResolver = (rootDir) => {
@@ -13898,7 +14063,7 @@ var traceAngularPhase = async (name, fn2, metadata) => {
   return resolve21(import.meta.dir, "./dev/client");
 }, devClientDir4, hmrClientPath5, formatDiagnosticMessage = (diagnostic) => {
   try {
-    return ts9.flattenDiagnosticMessageText(diagnostic.messageText, `
+    return ts10.flattenDiagnosticMessageText(diagnostic.messageText, `
 `);
   } catch {
     return String(diagnostic.messageText || "Unknown error");
@@ -13906,7 +14071,7 @@ var traceAngularPhase = async (name, fn2, metadata) => {
 }, throwOnCompilationErrors = (diagnostics) => {
   if (!diagnostics?.length)
     return;
-  const errors = diagnostics.filter((diag) => diag.category === ts9.DiagnosticCategory.Error);
+  const errors = diagnostics.filter((diag) => diag.category === ts10.DiagnosticCategory.Error);
   if (!errors.length)
     return;
   const fullMessage = errors.map(formatDiagnosticMessage).join(`
@@ -13948,22 +14113,22 @@ var traceAngularPhase = async (name, fn2, metadata) => {
   }
   return `${path}.js${query}`;
 }, isRelativeModuleSpecifier = (specifier) => specifier.startsWith("./") || specifier.startsWith("../"), extractLocalImportSpecifiers = (source, fileName) => {
-  const sourceFile = ts9.createSourceFile(fileName, source, ts9.ScriptTarget.Latest, true, ts9.ScriptKind.TS);
+  const sourceFile = ts10.createSourceFile(fileName, source, ts10.ScriptTarget.Latest, true, ts10.ScriptKind.TS);
   const specifiers = [];
   const addSpecifier = (node) => {
-    if (!node || !ts9.isStringLiteralLike(node))
+    if (!node || !ts10.isStringLiteralLike(node))
       return;
     const specifier = node.text;
     if (isRelativeModuleSpecifier(specifier))
       specifiers.push(specifier);
   };
   const visit = (node) => {
-    if (ts9.isImportDeclaration(node) || ts9.isExportDeclaration(node)) {
+    if (ts10.isImportDeclaration(node) || ts10.isExportDeclaration(node)) {
       addSpecifier(node.moduleSpecifier);
-    } else if (ts9.isCallExpression(node) && node.expression.kind === ts9.SyntaxKind.ImportKeyword) {
+    } else if (ts10.isCallExpression(node) && node.expression.kind === ts10.SyntaxKind.ImportKeyword) {
       addSpecifier(node.arguments[0]);
     }
-    ts9.forEachChild(node, visit);
+    ts10.forEachChild(node, visit);
   };
   visit(sourceFile);
   return specifiers;
@@ -13976,10 +14141,10 @@ var traceAngularPhase = async (name, fn2, metadata) => {
     `${basePath}.tsx`,
     `${basePath}.mts`,
     `${basePath}.cts`,
-    join27(basePath, "index.ts"),
-    join27(basePath, "index.tsx"),
-    join27(basePath, "index.mts"),
-    join27(basePath, "index.cts")
+    join28(basePath, "index.ts"),
+    join28(basePath, "index.tsx"),
+    join28(basePath, "index.mts"),
+    join28(basePath, "index.cts")
   ];
   return candidates.map((candidate) => resolve21(candidate)).find((candidate) => existsSync22(candidate) && !candidate.endsWith(".d.ts")) ?? null;
 }, readFileForAotTransform = async (fileName, readFile6) => {
@@ -14005,15 +14170,15 @@ var traceAngularPhase = async (name, fn2, metadata) => {
   const paths = [];
   const templateUrlMatch = findUncommentedMatch(source, /templateUrl\s*:\s*['"]([^'"]+)['"]/);
   if (templateUrlMatch?.[1])
-    paths.push(join27(fileDir, templateUrlMatch[1]));
+    paths.push(join28(fileDir, templateUrlMatch[1]));
   const styleUrlMatch = findUncommentedMatch(source, /styleUrl\s*:\s*['"]([^'"]+)['"]/);
   if (styleUrlMatch?.[1])
-    paths.push(join27(fileDir, styleUrlMatch[1]));
+    paths.push(join28(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(join27(fileDir, urlMatch.replace(/['"]/g, "")));
+      paths.push(join28(fileDir, urlMatch.replace(/['"]/g, "")));
     }
   }
   return paths.map((path) => resolve21(path));
@@ -14047,7 +14212,7 @@ var traceAngularPhase = async (name, fn2, metadata) => {
     safeStableStringify(stylePreprocessors ?? null)
   ].join("\x00");
   const cacheKey2 = Bun.hash(cacheInput).toString(BASE_36_RADIX);
-  return join27(process.cwd(), ".absolutejs", "cache", "angular-resources", `${cacheKey2}.json`);
+  return join28(process.cwd(), ".absolutejs", "cache", "angular-resources", `${cacheKey2}.json`);
 }, precomputeAotResourceTransforms = async (inputPaths, readFile6, stylePreprocessors) => {
   const transformedSources = new Map;
   const visited = new Set;
@@ -14093,10 +14258,10 @@ 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 = resolve21(join27(outDir, relative11(process.cwd(), resolve21(inputPath)).replace(/\.[cm]?[tj]sx?$/, ".js")));
+    const outputPath = resolve21(join28(outDir, relative11(process.cwd(), resolve21(inputPath)).replace(/\.[cm]?[tj]sx?$/, ".js")));
     return [
       outputPath,
-      buildIslandMetadataExports(readFileSync16(inputPath, "utf-8"))
+      buildIslandMetadataExports(readFileSync17(inputPath, "utf-8"))
     ];
   })), { entries: inputPaths.length });
   await traceAngularPhase("aot/preload-compiler", () => import("@angular/compiler"));
@@ -14111,25 +14276,25 @@ var traceAngularPhase = async (name, fn2, metadata) => {
     emitDecoratorMetadata: true,
     esModuleInterop: true,
     experimentalDecorators: true,
-    module: ts9.ModuleKind.ESNext,
-    moduleResolution: ts9.ModuleResolutionKind.Bundler,
-    newLine: ts9.NewLineKind.LineFeed,
+    module: ts10.ModuleKind.ESNext,
+    moduleResolution: ts10.ModuleResolutionKind.Bundler,
+    newLine: ts10.NewLineKind.LineFeed,
     noLib: false,
     outDir,
     skipLibCheck: true,
-    target: ts9.ScriptTarget.ES2022,
+    target: ts10.ScriptTarget.ES2022,
     ...config.options
   };
-  options.target = ts9.ScriptTarget.ES2022;
+  options.target = ts10.ScriptTarget.ES2022;
   options.experimentalDecorators = true;
   options.emitDecoratorMetadata = true;
-  options.newLine = ts9.NewLineKind.LineFeed;
+  options.newLine = ts10.NewLineKind.LineFeed;
   options.outDir = outDir;
   options.noEmit = false;
   options.incremental = false;
   options.tsBuildInfoFile = undefined;
   options.rootDir = process.cwd();
-  const host = await traceAngularPhase("aot/create-compiler-host", () => ts9.createCompilerHost(options));
+  const host = await traceAngularPhase("aot/create-compiler-host", () => ts10.createCompilerHost(options));
   const originalGetDefaultLibLocation = host.getDefaultLibLocation;
   host.getDefaultLibLocation = () => tsLibDir || (originalGetDefaultLibLocation ? originalGetDefaultLibLocation() : "");
   const originalGetDefaultLibFileName = host.getDefaultLibFileName;
@@ -14140,7 +14305,7 @@ 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 = join27(tsLibDir, fileName);
+      const resolvedPath = join28(tsLibDir, fileName);
       return originalGetSourceFile?.call(host, resolvedPath, languageVersion, onError);
     }
     return originalGetSourceFile?.call(host, fileName, languageVersion, onError);
@@ -14175,7 +14340,7 @@ var traceAngularPhase = async (name, fn2, metadata) => {
   host.getSourceFile = (fileName, languageVersion, onError) => {
     const source = transformedSources.get(resolve21(fileName));
     if (source) {
-      return ts9.createSourceFile(fileName, source, languageVersion, true);
+      return ts10.createSourceFile(fileName, source, languageVersion, true);
     }
     return originalGetSourceFileForCompile?.call(host, fileName, languageVersion, onError);
   };
@@ -14195,7 +14360,7 @@ 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: join27(outDir, fileName)
+      target: join28(outDir, fileName)
     }));
     const outputFiles = new Set(rawEntries.map(({ target }) => resolve21(target)));
     return rawEntries.map(({ content, target }) => {
@@ -14372,7 +14537,7 @@ ${fields}
 }, inlineTemplateAndLowerDefer = async (source, fileDir) => {
   const templateUrlMatch = findUncommentedMatch(source, /templateUrl\s*:\s*['"]([^'"]+)['"]/);
   if (templateUrlMatch?.[1]) {
-    const templatePath = join27(fileDir, templateUrlMatch[1]);
+    const templatePath = join28(fileDir, templateUrlMatch[1]);
     if (!existsSync22(templatePath)) {
       throw new Error(`Unable to inline Angular templateUrl "${templateUrlMatch[1]}": file not found at ${templatePath}`);
     }
@@ -14403,11 +14568,11 @@ ${fields}
 }, inlineTemplateAndLowerDeferSync = (source, fileDir) => {
   const templateUrlMatch = findUncommentedMatch(source, /templateUrl\s*:\s*['"]([^'"]+)['"]/);
   if (templateUrlMatch?.[1]) {
-    const templatePath = join27(fileDir, templateUrlMatch[1]);
+    const templatePath = join28(fileDir, templateUrlMatch[1]);
     if (!existsSync22(templatePath)) {
       throw new Error(`Unable to inline Angular templateUrl "${templateUrlMatch[1]}": file not found at ${templatePath}`);
     }
-    const templateRaw2 = readFileSync16(templatePath, "utf-8");
+    const templateRaw2 = readFileSync17(templatePath, "utf-8");
     const lowered2 = lowerAngularDeferSyntax(templateRaw2);
     const escaped2 = escapeTemplateContent(lowered2.template);
     const replacedSource2 = source.slice(0, templateUrlMatch.index) + `template: \`${escaped2}\`` + source.slice(templateUrlMatch.index + templateUrlMatch[0].length);
@@ -14440,7 +14605,7 @@ ${fields}
     return source;
   const stylePromises = urlMatches.map((urlMatch) => {
     const styleUrl = urlMatch.replace(/['"]/g, "");
-    return readAndEscapeFile(join27(fileDir, styleUrl), stylePreprocessors);
+    return readAndEscapeFile(join28(fileDir, styleUrl), stylePreprocessors);
   });
   const results = await Promise.all(stylePromises);
   const inlinedStyles = results.filter(Boolean).map((escaped) => `\`${escaped}\``);
@@ -14451,7 +14616,7 @@ ${fields}
   const styleUrlMatch = findUncommentedMatch(source, /styleUrl\s*:\s*['"]([^'"]+)['"]/);
   if (!styleUrlMatch?.[1])
     return source;
-  const escaped = await readAndEscapeFile(join27(fileDir, styleUrlMatch[1]), stylePreprocessors);
+  const escaped = await readAndEscapeFile(join28(fileDir, styleUrlMatch[1]), stylePreprocessors);
   if (!escaped)
     return source;
   return source.slice(0, styleUrlMatch.index) + `styles: [\`${escaped}\`]` + source.slice(styleUrlMatch.index + styleUrlMatch[0].length);
@@ -14487,10 +14652,10 @@ ${fields}
       `${candidate}.js`,
       `${candidate}.jsx`,
       `${candidate}.json`,
-      join27(candidate, "index.ts"),
-      join27(candidate, "index.tsx"),
-      join27(candidate, "index.js"),
-      join27(candidate, "index.jsx")
+      join28(candidate, "index.ts"),
+      join28(candidate, "index.tsx"),
+      join28(candidate, "index.js"),
+      join28(candidate, "index.jsx")
     ];
     return candidates.find((file3) => existsSync22(file3));
   };
@@ -14517,10 +14682,10 @@ ${fields}
     const inputDir = dirname14(sourcePath);
     const fileBase = basename8(sourcePath).replace(/\.[cm]?[tj]sx?$/, ".js");
     if (inputDir === outDir || inputDir.startsWith(`${outDir}${sep3}`)) {
-      return join27(inputDir, fileBase);
+      return join28(inputDir, fileBase);
     }
     const relativeDir = inputDir.startsWith(baseDir) ? inputDir.substring(baseDir.length + 1) : inputDir;
-    return join27(outDir, relativeDir, fileBase);
+    return join28(outDir, relativeDir, fileBase);
   };
   const withCacheBuster = (specifier) => {
     if (!cacheBuster)
@@ -14570,8 +14735,8 @@ ${fields}
     if (resolved.endsWith(".json") && existsSync22(resolved)) {
       const inputDir2 = dirname14(resolved);
       const relativeDir2 = inputDir2.startsWith(baseDir) ? inputDir2.substring(baseDir.length + 1) : inputDir2;
-      const targetDir2 = join27(outDir, relativeDir2);
-      const targetPath2 = join27(targetDir2, basename8(resolved));
+      const targetDir2 = join28(outDir, relativeDir2);
+      const targetPath2 = join28(targetDir2, basename8(resolved));
       await fs5.mkdir(targetDir2, { recursive: true });
       await fs5.copyFile(resolved, targetPath2);
       allOutputs.push(targetPath2);
@@ -14649,7 +14814,7 @@ export const __ABSOLUTE_PAGE_USES_LEGACY_ANIMATIONS__ = true;
     return { clientPaths: [...emptyPaths], serverPaths: [...emptyPaths] };
   }
   const compiledRoot = compiledParent;
-  const indexesDir = join27(compiledParent, "indexes");
+  const indexesDir = join28(compiledParent, "indexes");
   await traceAngularPhase("setup/create-indexes-dir", () => fs5.mkdir(indexesDir, { recursive: true }));
   const aotOutputs = hmr ? [] : await traceAngularPhase("aot/compile-files", () => compileAngularFiles(entryPoints.map((entry) => resolve21(entry)), compiledRoot, stylePreprocessors), { entries: entryPoints.length });
   if (!hmr) {
@@ -14663,9 +14828,9 @@ export const __ABSOLUTE_PAGE_USES_LEGACY_ANIMATIONS__ = true;
         absolute: false,
         cwd: angularSrcDir
       })) {
-        const sourcePath = join27(angularSrcDir, rel);
+        const sourcePath = join28(angularSrcDir, rel);
         const cwdRel = relative11(cwd, sourcePath);
-        const targetPath = join27(compiledRoot, cwdRel);
+        const targetPath = join28(compiledRoot, cwdRel);
         await fs5.mkdir(dirname14(targetPath), { recursive: true });
         await fs5.copyFile(sourcePath, targetPath);
       }
@@ -14682,9 +14847,9 @@ export const __ABSOLUTE_PAGE_USES_LEGACY_ANIMATIONS__ = true;
     const fileBase = basename8(resolvedEntry).replace(/\.[tj]s$/, "");
     const jsName = `${fileBase}.js`;
     const compiledFallbackPaths = [
-      join27(compiledRoot, relativeEntry),
-      join27(compiledRoot, "pages", jsName),
-      join27(compiledRoot, jsName)
+      join28(compiledRoot, relativeEntry),
+      join28(compiledRoot, "pages", jsName),
+      join28(compiledRoot, jsName)
     ].map((file3) => resolve21(file3));
     const resolveRawServerFile = (candidatePaths) => {
       const normalizedCandidates = [
@@ -14734,7 +14899,7 @@ export const __ABSOLUTE_PAGE_USES_LEGACY_ANIMATIONS__ = true;
     const providersHashInput = providersInjection ? (() => {
       let providersSourceContent = "";
       try {
-        providersSourceContent = readFileSync16(providersInjection.appProvidersSource, "utf-8");
+        providersSourceContent = readFileSync17(providersInjection.appProvidersSource, "utf-8");
       } catch {}
       return JSON.stringify({
         basePath: pageInjectionForHash?.basePath ?? null,
@@ -14744,7 +14909,7 @@ export const __ABSOLUTE_PAGE_USES_LEGACY_ANIMATIONS__ = true;
     })() : "no-providers";
     const serverContentHash = `${Bun.hash(original).toString(BASE_36_RADIX)}.${Bun.hash(providersHashInput).toString(BASE_36_RADIX)}`;
     const cachedWrapper = wrapperOutputCache.get(resolvedEntry);
-    const clientFile = join27(indexesDir, jsName);
+    const clientFile = join28(indexesDir, jsName);
     if (hmr && cachedWrapper && cachedWrapper.serverHash === serverContentHash && existsSync22(clientFile) && (usesLegacyAnimations || !original.includes("__ABSOLUTE_PAGE_USES_LEGACY_ANIMATIONS__")) && (!usesLegacyAnimations || original.includes("__ABSOLUTE_PAGE_USES_LEGACY_ANIMATIONS__"))) {
       return {
         clientPath: clientFile,
@@ -14776,7 +14941,7 @@ export const __ABSOLUTE_PAGE_USES_LEGACY_ANIMATIONS__ = true;
         const angularDirAbs = resolve21(outRoot);
         const appSourceAbs = resolve21(providersInjection.appProvidersSource);
         const rel = relative11(angularDirAbs, appSourceAbs).replace(/\\/g, "/");
-        return join27(compiledParent, rel).replace(/\.[cm]?[tj]sx?$/, ".js");
+        return join28(compiledParent, rel).replace(/\.[cm]?[tj]sx?$/, ".js");
       })();
       const appProvidersSpec = (() => {
         const rel = relative11(dirname14(rawServerFile), compiledAppProvidersPath).replace(/\\/g, "/");
@@ -14999,24 +15164,24 @@ var init_compileAngular = __esm(() => {
   init_stylePreprocessor();
   init_generatedDir();
   devClientDir4 = resolveDevClientDir4();
-  hmrClientPath5 = join27(devClientDir4, "hmrClient.ts").replace(/\\/g, "/");
+  hmrClientPath5 = join28(devClientDir4, "hmrClient.ts").replace(/\\/g, "/");
   jitContentCache = new Map;
   wrapperOutputCache = new Map;
 });
 
 // src/dev/angular/hmrImportGenerator.ts
-import ts10 from "typescript";
+import ts11 from "typescript";
 var createHmrImportGenerator = (namespaceMap) => ({
   addImport(request) {
     const ns = namespaceMap.get(request.exportModuleSpecifier);
     if (!ns) {
       throw new Error(`HMR import generator has no namespace mapping for ${request.exportModuleSpecifier}. ` + `Add it to namespaceDependencies before calling compileHmrUpdateCallback.`);
     }
-    const namespaceId = ts10.factory.createIdentifier(ns);
+    const namespaceId = ts11.factory.createIdentifier(ns);
     if (request.exportSymbolName === null) {
       return namespaceId;
     }
-    return ts10.factory.createPropertyAccessExpression(namespaceId, ts10.factory.createIdentifier(request.exportSymbolName));
+    return ts11.factory.createPropertyAccessExpression(namespaceId, ts11.factory.createIdentifier(request.exportSymbolName));
   }
 });
 var init_hmrImportGenerator = () => {};
@@ -15389,13 +15554,13 @@ var init_translator = __esm(() => {
 });
 
 // src/dev/angular/vendor/translator/ts_util.ts
-import ts11 from "typescript";
+import ts12 from "typescript";
 function tsNumericExpression(value) {
   if (value < 0) {
-    const operand = ts11.factory.createNumericLiteral(Math.abs(value));
-    return ts11.factory.createPrefixUnaryExpression(ts11.SyntaxKind.MinusToken, operand);
+    const operand = ts12.factory.createNumericLiteral(Math.abs(value));
+    return ts12.factory.createPrefixUnaryExpression(ts12.SyntaxKind.MinusToken, operand);
   }
-  return ts11.factory.createNumericLiteral(value);
+  return ts12.factory.createNumericLiteral(value);
 }
 var init_ts_util = __esm(() => {
   /*!
@@ -15408,142 +15573,142 @@ var init_ts_util = __esm(() => {
 });
 
 // src/dev/angular/vendor/translator/typescript_ast_factory.ts
-import ts12 from "typescript";
+import ts13 from "typescript";
 
 class TypeScriptAstFactory {
   annotateForClosureCompiler;
   externalSourceFiles = new Map;
   UNARY_OPERATORS = /* @__PURE__ */ (() => ({
-    "+": ts12.SyntaxKind.PlusToken,
-    "-": ts12.SyntaxKind.MinusToken,
-    "!": ts12.SyntaxKind.ExclamationToken
+    "+": ts13.SyntaxKind.PlusToken,
+    "-": ts13.SyntaxKind.MinusToken,
+    "!": ts13.SyntaxKind.ExclamationToken
   }))();
   BINARY_OPERATORS = /* @__PURE__ */ (() => ({
-    "&&": ts12.SyntaxKind.AmpersandAmpersandToken,
-    ">": ts12.SyntaxKind.GreaterThanToken,
-    ">=": ts12.SyntaxKind.GreaterThanEqualsToken,
-    "&": ts12.SyntaxKind.AmpersandToken,
-    "|": ts12.SyntaxKind.BarToken,
-    "/": ts12.SyntaxKind.SlashToken,
-    "==": ts12.SyntaxKind.EqualsEqualsToken,
-    "===": ts12.SyntaxKind.EqualsEqualsEqualsToken,
-    "<": ts12.SyntaxKind.LessThanToken,
-    "<=": ts12.SyntaxKind.LessThanEqualsToken,
-    "-": ts12.SyntaxKind.MinusToken,
-    "%": ts12.SyntaxKind.PercentToken,
-    "*": ts12.SyntaxKind.AsteriskToken,
-    "**": ts12.SyntaxKind.AsteriskAsteriskToken,
-    "!=": ts12.SyntaxKind.ExclamationEqualsToken,
-    "!==": ts12.SyntaxKind.ExclamationEqualsEqualsToken,
-    "||": ts12.SyntaxKind.BarBarToken,
-    "+": ts12.SyntaxKind.PlusToken,
-    "??": ts12.SyntaxKind.QuestionQuestionToken,
-    "=": ts12.SyntaxKind.EqualsToken,
-    "+=": ts12.SyntaxKind.PlusEqualsToken,
-    "-=": ts12.SyntaxKind.MinusEqualsToken,
-    "*=": ts12.SyntaxKind.AsteriskEqualsToken,
-    "/=": ts12.SyntaxKind.SlashEqualsToken,
-    "%=": ts12.SyntaxKind.PercentEqualsToken,
-    "**=": ts12.SyntaxKind.AsteriskAsteriskEqualsToken,
-    "&&=": ts12.SyntaxKind.AmpersandAmpersandEqualsToken,
-    "||=": ts12.SyntaxKind.BarBarEqualsToken,
-    "??=": ts12.SyntaxKind.QuestionQuestionEqualsToken,
-    in: ts12.SyntaxKind.InKeyword,
-    instanceof: ts12.SyntaxKind.InstanceOfKeyword
+    "&&": ts13.SyntaxKind.AmpersandAmpersandToken,
+    ">": ts13.SyntaxKind.GreaterThanToken,
+    ">=": ts13.SyntaxKind.GreaterThanEqualsToken,
+    "&": ts13.SyntaxKind.AmpersandToken,
+    "|": ts13.SyntaxKind.BarToken,
+    "/": ts13.SyntaxKind.SlashToken,
+    "==": ts13.SyntaxKind.EqualsEqualsToken,
+    "===": ts13.SyntaxKind.EqualsEqualsEqualsToken,
+    "<": ts13.SyntaxKind.LessThanToken,
+    "<=": ts13.SyntaxKind.LessThanEqualsToken,
+    "-": ts13.SyntaxKind.MinusToken,
+    "%": ts13.SyntaxKind.PercentToken,
+    "*": ts13.SyntaxKind.AsteriskToken,
+    "**": ts13.SyntaxKind.AsteriskAsteriskToken,
+    "!=": ts13.SyntaxKind.ExclamationEqualsToken,
+    "!==": ts13.SyntaxKind.ExclamationEqualsEqualsToken,
+    "||": ts13.SyntaxKind.BarBarToken,
+    "+": ts13.SyntaxKind.PlusToken,
+    "??": ts13.SyntaxKind.QuestionQuestionToken,
+    "=": ts13.SyntaxKind.EqualsToken,
+    "+=": ts13.SyntaxKind.PlusEqualsToken,
+    "-=": ts13.SyntaxKind.MinusEqualsToken,
+    "*=": ts13.SyntaxKind.AsteriskEqualsToken,
+    "/=": ts13.SyntaxKind.SlashEqualsToken,
+    "%=": ts13.SyntaxKind.PercentEqualsToken,
+    "**=": ts13.SyntaxKind.AsteriskAsteriskEqualsToken,
+    "&&=": ts13.SyntaxKind.AmpersandAmpersandEqualsToken,
+    "||=": ts13.SyntaxKind.BarBarEqualsToken,
+    "??=": ts13.SyntaxKind.QuestionQuestionEqualsToken,
+    in: ts13.SyntaxKind.InKeyword,
+    instanceof: ts13.SyntaxKind.InstanceOfKeyword
   }))();
   VAR_TYPES = /* @__PURE__ */ (() => ({
-    const: ts12.NodeFlags.Const,
-    let: ts12.NodeFlags.Let,
-    var: ts12.NodeFlags.None
+    const: ts13.NodeFlags.Const,
+    let: ts13.NodeFlags.Let,
+    var: ts13.NodeFlags.None
   }))();
   constructor(annotateForClosureCompiler) {
     this.annotateForClosureCompiler = annotateForClosureCompiler;
   }
   attachComments = attachComments;
-  createArrayLiteral = ts12.factory.createArrayLiteralExpression;
+  createArrayLiteral = ts13.factory.createArrayLiteralExpression;
   createAssignment(target, operator, value) {
-    return ts12.factory.createBinaryExpression(target, this.BINARY_OPERATORS[operator], value);
+    return ts13.factory.createBinaryExpression(target, this.BINARY_OPERATORS[operator], value);
   }
   createBinaryExpression(leftOperand, operator, rightOperand) {
-    return ts12.factory.createBinaryExpression(leftOperand, this.BINARY_OPERATORS[operator], rightOperand);
+    return ts13.factory.createBinaryExpression(leftOperand, this.BINARY_OPERATORS[operator], rightOperand);
   }
   createBlock(body) {
-    return ts12.factory.createBlock(body);
+    return ts13.factory.createBlock(body);
   }
   createCallExpression(callee, args, pure) {
-    const call = ts12.factory.createCallExpression(callee, undefined, args);
+    const call = ts13.factory.createCallExpression(callee, undefined, args);
     if (pure) {
-      ts12.addSyntheticLeadingComment(call, ts12.SyntaxKind.MultiLineCommentTrivia, this.annotateForClosureCompiler ? "* @pureOrBreakMyCode " /* CLOSURE */ : "@__PURE__" /* TERSER */, false);
+      ts13.addSyntheticLeadingComment(call, ts13.SyntaxKind.MultiLineCommentTrivia, this.annotateForClosureCompiler ? "* @pureOrBreakMyCode " /* CLOSURE */ : "@__PURE__" /* TERSER */, false);
     }
     return call;
   }
   createConditional(condition, whenTrue, whenFalse) {
-    return ts12.factory.createConditionalExpression(condition, undefined, whenTrue, undefined, whenFalse);
+    return ts13.factory.createConditionalExpression(condition, undefined, whenTrue, undefined, whenFalse);
   }
-  createElementAccess = ts12.factory.createElementAccessExpression;
-  createExpressionStatement = ts12.factory.createExpressionStatement;
+  createElementAccess = ts13.factory.createElementAccessExpression;
+  createExpressionStatement = ts13.factory.createExpressionStatement;
   createDynamicImport(url) {
-    return ts12.factory.createCallExpression(ts12.factory.createToken(ts12.SyntaxKind.ImportKeyword), undefined, [
-      typeof url === "string" ? ts12.factory.createStringLiteral(url) : url
+    return ts13.factory.createCallExpression(ts13.factory.createToken(ts13.SyntaxKind.ImportKeyword), undefined, [
+      typeof url === "string" ? ts13.factory.createStringLiteral(url) : url
     ]);
   }
   createFunctionDeclaration(functionName, parameters, body) {
-    if (!ts12.isBlock(body)) {
-      throw new Error(`Invalid syntax, expected a block, but got ${ts12.SyntaxKind[body.kind]}.`);
+    if (!ts13.isBlock(body)) {
+      throw new Error(`Invalid syntax, expected a block, but got ${ts13.SyntaxKind[body.kind]}.`);
     }
-    return ts12.factory.createFunctionDeclaration(undefined, undefined, functionName, undefined, parameters.map((param) => this.createParameter(param)), undefined, body);
+    return ts13.factory.createFunctionDeclaration(undefined, undefined, functionName, undefined, parameters.map((param) => this.createParameter(param)), undefined, body);
   }
   createFunctionExpression(functionName, parameters, body) {
-    if (!ts12.isBlock(body)) {
-      throw new Error(`Invalid syntax, expected a block, but got ${ts12.SyntaxKind[body.kind]}.`);
+    if (!ts13.isBlock(body)) {
+      throw new Error(`Invalid syntax, expected a block, but got ${ts13.SyntaxKind[body.kind]}.`);
     }
-    return ts12.factory.createFunctionExpression(undefined, undefined, functionName ?? undefined, undefined, parameters.map((param) => this.createParameter(param)), undefined, body);
+    return ts13.factory.createFunctionExpression(undefined, undefined, functionName ?? undefined, undefined, parameters.map((param) => this.createParameter(param)), undefined, body);
   }
   createArrowFunctionExpression(parameters, body) {
-    if (ts12.isStatement(body) && !ts12.isBlock(body)) {
-      throw new Error(`Invalid syntax, expected a block, but got ${ts12.SyntaxKind[body.kind]}.`);
+    if (ts13.isStatement(body) && !ts13.isBlock(body)) {
+      throw new Error(`Invalid syntax, expected a block, but got ${ts13.SyntaxKind[body.kind]}.`);
     }
-    return ts12.factory.createArrowFunction(undefined, undefined, parameters.map((param) => this.createParameter(param)), undefined, undefined, body);
+    return ts13.factory.createArrowFunction(undefined, undefined, parameters.map((param) => this.createParameter(param)), undefined, undefined, body);
   }
   createParameter(param) {
-    return ts12.factory.createParameterDeclaration(undefined, undefined, param.name, undefined, param.type ?? undefined);
+    return ts13.factory.createParameterDeclaration(undefined, undefined, param.name, undefined, param.type ?? undefined);
   }
-  createIdentifier = ts12.factory.createIdentifier;
+  createIdentifier = ts13.factory.createIdentifier;
   createIfStatement(condition, thenStatement, elseStatement) {
-    return ts12.factory.createIfStatement(condition, thenStatement, elseStatement ?? undefined);
+    return ts13.factory.createIfStatement(condition, thenStatement, elseStatement ?? undefined);
   }
   createLiteral(value) {
     if (value === undefined) {
-      return ts12.factory.createIdentifier("undefined");
+      return ts13.factory.createIdentifier("undefined");
     } else if (value === null) {
-      return ts12.factory.createNull();
+      return ts13.factory.createNull();
     } else if (typeof value === "boolean") {
-      return value ? ts12.factory.createTrue() : ts12.factory.createFalse();
+      return value ? ts13.factory.createTrue() : ts13.factory.createFalse();
     } else if (typeof value === "number") {
       return tsNumericExpression(value);
     } else {
-      return ts12.factory.createStringLiteral(value);
+      return ts13.factory.createStringLiteral(value);
     }
   }
   createNewExpression(expression, args) {
-    return ts12.factory.createNewExpression(expression, undefined, args);
+    return ts13.factory.createNewExpression(expression, undefined, args);
   }
   createObjectLiteral(properties) {
-    return ts12.factory.createObjectLiteralExpression(properties.map((prop) => {
+    return ts13.factory.createObjectLiteralExpression(properties.map((prop) => {
       if (prop.kind === "spread") {
-        return ts12.factory.createSpreadAssignment(prop.expression);
+        return ts13.factory.createSpreadAssignment(prop.expression);
       }
-      return ts12.factory.createPropertyAssignment(prop.quoted ? ts12.factory.createStringLiteral(prop.propertyName) : ts12.factory.createIdentifier(prop.propertyName), prop.value);
+      return ts13.factory.createPropertyAssignment(prop.quoted ? ts13.factory.createStringLiteral(prop.propertyName) : ts13.factory.createIdentifier(prop.propertyName), prop.value);
     }));
   }
-  createParenthesizedExpression = ts12.factory.createParenthesizedExpression;
-  createPropertyAccess = ts12.factory.createPropertyAccessExpression;
-  createSpreadElement = ts12.factory.createSpreadElement;
+  createParenthesizedExpression = ts13.factory.createParenthesizedExpression;
+  createPropertyAccess = ts13.factory.createPropertyAccessExpression;
+  createSpreadElement = ts13.factory.createSpreadElement;
   createReturnStatement(expression) {
-    return ts12.factory.createReturnStatement(expression ?? undefined);
+    return ts13.factory.createReturnStatement(expression ?? undefined);
   }
   createTaggedTemplate(tag, template) {
-    return ts12.factory.createTaggedTemplateExpression(tag, undefined, this.createTemplateLiteral(template));
+    return ts13.factory.createTaggedTemplateExpression(tag, undefined, this.createTemplateLiteral(template));
   }
   createTemplateLiteral(template) {
     let templateLiteral;
@@ -15553,7 +15718,7 @@ class TypeScriptAstFactory {
       throw new Error("createTemplateLiteral: template has no elements");
     }
     if (length === 1) {
-      templateLiteral = ts12.factory.createNoSubstitutionTemplateLiteral(head.cooked, head.raw);
+      templateLiteral = ts13.factory.createNoSubstitutionTemplateLiteral(head.cooked, head.raw);
     } else {
       const spans = [];
       for (let i = 1;i < length - 1; i++) {
@@ -15567,7 +15732,7 @@ class TypeScriptAstFactory {
         if (range !== null) {
           this.setSourceMapRange(middle, range);
         }
-        spans.push(ts12.factory.createTemplateSpan(expression, middle));
+        spans.push(ts13.factory.createTemplateSpan(expression, middle));
       }
       const resolvedExpression = template.expressions[length - 2];
       const templatePart = template.elements[length - 1];
@@ -15578,27 +15743,27 @@ class TypeScriptAstFactory {
       if (templatePart.range !== null) {
         this.setSourceMapRange(templateTail, templatePart.range);
       }
-      spans.push(ts12.factory.createTemplateSpan(resolvedExpression, templateTail));
-      templateLiteral = ts12.factory.createTemplateExpression(ts12.factory.createTemplateHead(head.cooked, head.raw), spans);
+      spans.push(ts13.factory.createTemplateSpan(resolvedExpression, templateTail));
+      templateLiteral = ts13.factory.createTemplateExpression(ts13.factory.createTemplateHead(head.cooked, head.raw), spans);
     }
     if (head.range !== null) {
       this.setSourceMapRange(templateLiteral, head.range);
     }
     return templateLiteral;
   }
-  createThrowStatement = ts12.factory.createThrowStatement;
-  createTypeOfExpression = ts12.factory.createTypeOfExpression;
-  createVoidExpression = ts12.factory.createVoidExpression;
+  createThrowStatement = ts13.factory.createThrowStatement;
+  createTypeOfExpression = ts13.factory.createTypeOfExpression;
+  createVoidExpression = ts13.factory.createVoidExpression;
   createUnaryExpression(operator, operand) {
-    return ts12.factory.createPrefixUnaryExpression(this.UNARY_OPERATORS[operator], operand);
+    return ts13.factory.createPrefixUnaryExpression(this.UNARY_OPERATORS[operator], operand);
   }
   createVariableDeclaration(variableName, initializer, variableType, type) {
-    return ts12.factory.createVariableStatement(undefined, ts12.factory.createVariableDeclarationList([
-      ts12.factory.createVariableDeclaration(variableName, undefined, type ?? undefined, initializer ?? undefined)
+    return ts13.factory.createVariableStatement(undefined, ts13.factory.createVariableDeclarationList([
+      ts13.factory.createVariableDeclaration(variableName, undefined, type ?? undefined, initializer ?? undefined)
     ], this.VAR_TYPES[variableType]));
   }
   createRegularExpressionLiteral(body, flags) {
-    return ts12.factory.createRegularExpressionLiteral(`/${body}/${flags ?? ""}`);
+    return ts13.factory.createRegularExpressionLiteral(`/${body}/${flags ?? ""}`);
   }
   setSourceMapRange(node, sourceMapRange) {
     if (sourceMapRange === null) {
@@ -15606,10 +15771,10 @@ class TypeScriptAstFactory {
     }
     const url = sourceMapRange.url;
     if (!this.externalSourceFiles.has(url)) {
-      this.externalSourceFiles.set(url, ts12.createSourceMapSource(url, sourceMapRange.content, (pos) => pos));
+      this.externalSourceFiles.set(url, ts13.createSourceMapSource(url, sourceMapRange.content, (pos) => pos));
     }
     const source = this.externalSourceFiles.get(url);
-    ts12.setSourceMapRange(node, {
+    ts13.setSourceMapRange(node, {
       pos: sourceMapRange.start.offset,
       end: sourceMapRange.end.offset,
       source
@@ -15619,77 +15784,77 @@ class TypeScriptAstFactory {
   createBuiltInType(type) {
     switch (type) {
       case "any":
-        return ts12.factory.createKeywordTypeNode(ts12.SyntaxKind.AnyKeyword);
+        return ts13.factory.createKeywordTypeNode(ts13.SyntaxKind.AnyKeyword);
       case "boolean":
-        return ts12.factory.createKeywordTypeNode(ts12.SyntaxKind.BooleanKeyword);
+        return ts13.factory.createKeywordTypeNode(ts13.SyntaxKind.BooleanKeyword);
       case "number":
-        return ts12.factory.createKeywordTypeNode(ts12.SyntaxKind.NumberKeyword);
+        return ts13.factory.createKeywordTypeNode(ts13.SyntaxKind.NumberKeyword);
       case "string":
-        return ts12.factory.createKeywordTypeNode(ts12.SyntaxKind.StringKeyword);
+        return ts13.factory.createKeywordTypeNode(ts13.SyntaxKind.StringKeyword);
       case "function":
-        return ts12.factory.createTypeReferenceNode(ts12.factory.createIdentifier("Function"));
+        return ts13.factory.createTypeReferenceNode(ts13.factory.createIdentifier("Function"));
       case "never":
-        return ts12.factory.createKeywordTypeNode(ts12.SyntaxKind.NeverKeyword);
+        return ts13.factory.createKeywordTypeNode(ts13.SyntaxKind.NeverKeyword);
       case "unknown":
-        return ts12.factory.createKeywordTypeNode(ts12.SyntaxKind.UnknownKeyword);
+        return ts13.factory.createKeywordTypeNode(ts13.SyntaxKind.UnknownKeyword);
     }
   }
   createExpressionType(expression, typeParams) {
     const typeName = getEntityTypeFromExpression(expression);
-    return ts12.factory.createTypeReferenceNode(typeName, typeParams ?? undefined);
+    return ts13.factory.createTypeReferenceNode(typeName, typeParams ?? undefined);
   }
   createArrayType(elementType) {
-    return ts12.factory.createArrayTypeNode(elementType);
+    return ts13.factory.createArrayTypeNode(elementType);
   }
   createMapType(valueType) {
-    return ts12.factory.createTypeLiteralNode([
-      ts12.factory.createIndexSignature(undefined, [
-        ts12.factory.createParameterDeclaration(undefined, undefined, "key", undefined, ts12.factory.createKeywordTypeNode(ts12.SyntaxKind.StringKeyword))
+    return ts13.factory.createTypeLiteralNode([
+      ts13.factory.createIndexSignature(undefined, [
+        ts13.factory.createParameterDeclaration(undefined, undefined, "key", undefined, ts13.factory.createKeywordTypeNode(ts13.SyntaxKind.StringKeyword))
       ], valueType)
     ]);
   }
   transplantType(type) {
-    if (typeof type.kind === "number" && typeof type.getSourceFile === "function" && ts12.isTypeNode(type)) {
+    if (typeof type.kind === "number" && typeof type.getSourceFile === "function" && ts13.isTypeNode(type)) {
       return type;
     }
     throw new Error("Attempting to transplant a type node from a non-TypeScript AST: " + type);
   }
 }
 function createTemplateMiddle(cooked, raw) {
-  const node = ts12.factory.createTemplateHead(cooked, raw);
-  node.kind = ts12.SyntaxKind.TemplateMiddle;
+  const node = ts13.factory.createTemplateHead(cooked, raw);
+  node.kind = ts13.SyntaxKind.TemplateMiddle;
   return node;
 }
 function createTemplateTail(cooked, raw) {
-  const node = ts12.factory.createTemplateHead(cooked, raw);
-  node.kind = ts12.SyntaxKind.TemplateTail;
+  const node = ts13.factory.createTemplateHead(cooked, raw);
+  node.kind = ts13.SyntaxKind.TemplateTail;
   return node;
 }
 function attachComments(statement, leadingComments) {
   for (const comment of leadingComments) {
-    const commentKind = comment.multiline ? ts12.SyntaxKind.MultiLineCommentTrivia : ts12.SyntaxKind.SingleLineCommentTrivia;
+    const commentKind = comment.multiline ? ts13.SyntaxKind.MultiLineCommentTrivia : ts13.SyntaxKind.SingleLineCommentTrivia;
     if (comment.multiline) {
-      ts12.addSyntheticLeadingComment(statement, commentKind, comment.toString(), comment.trailingNewline);
+      ts13.addSyntheticLeadingComment(statement, commentKind, comment.toString(), comment.trailingNewline);
     } else {
       for (const line of comment.toString().split(`
 `)) {
-        ts12.addSyntheticLeadingComment(statement, commentKind, line, comment.trailingNewline);
+        ts13.addSyntheticLeadingComment(statement, commentKind, line, comment.trailingNewline);
       }
     }
   }
 }
 function getEntityTypeFromExpression(expression) {
-  if (ts12.isIdentifier(expression)) {
+  if (ts13.isIdentifier(expression)) {
     return expression;
   }
-  if (ts12.isPropertyAccessExpression(expression)) {
+  if (ts13.isPropertyAccessExpression(expression)) {
     const left = getEntityTypeFromExpression(expression.expression);
-    if (!ts12.isIdentifier(expression.name)) {
+    if (!ts13.isIdentifier(expression.name)) {
       throw new Error(`Unsupported property access for type reference: ${expression.name.text}`);
     }
-    return ts12.factory.createQualifiedName(left, expression.name);
+    return ts13.factory.createQualifiedName(left, expression.name);
   }
-  throw new Error(`Unsupported expression for type reference: ${ts12.SyntaxKind[expression.kind]}`);
+  throw new Error(`Unsupported expression for type reference: ${ts13.SyntaxKind[expression.kind]}`);
 }
 var init_typescript_ast_factory = __esm(() => {
   init_ts_util();
@@ -15722,9 +15887,9 @@ __export(exports_fastHmrCompiler, {
   primeComponentFingerprint: () => primeComponentFingerprint,
   invalidateFingerprintCache: () => invalidateFingerprintCache
 });
-import { existsSync as existsSync23, readFileSync as readFileSync17, statSync as statSync2 } from "fs";
+import { existsSync as existsSync23, readFileSync as readFileSync18, statSync as statSync2 } from "fs";
 import { dirname as dirname15, extname as extname6, relative as relative12, resolve as resolve22 } from "path";
-import ts13 from "typescript";
+import ts14 from "typescript";
 var fail = (reason, detail, location) => ({
   ok: false,
   reason,
@@ -15808,23 +15973,23 @@ var fail = (reason, detail, location) => ({
   }
   let sourceFile;
   try {
-    sourceFile = ts13.createSourceFile(componentFilePath, source, ts13.ScriptTarget.Latest, true, ts13.ScriptKind.TS);
+    sourceFile = ts14.createSourceFile(componentFilePath, source, ts14.ScriptTarget.Latest, true, ts14.ScriptKind.TS);
   } catch {
     return;
   }
   for (const stmt of sourceFile.statements) {
-    if (!ts13.isClassDeclaration(stmt))
+    if (!ts14.isClassDeclaration(stmt))
       continue;
     const className = stmt.name?.text;
     if (!className)
       continue;
-    const decorators = ts13.getDecorators(stmt) ?? [];
+    const decorators = ts14.getDecorators(stmt) ?? [];
     const decoratorName = (() => {
       for (const d2 of decorators) {
-        if (!ts13.isCallExpression(d2.expression))
+        if (!ts14.isCallExpression(d2.expression))
           continue;
         const expr = d2.expression.expression;
-        if (!ts13.isIdentifier(expr))
+        if (!ts14.isIdentifier(expr))
           continue;
         if (expr.text === "Component" || expr.text === "Directive" || expr.text === "Pipe" || expr.text === "Injectable") {
           return expr.text;
@@ -15838,16 +16003,16 @@ var fail = (reason, detail, location) => ({
     const id = encodeURIComponent(`${projectRel}@${className}`);
     if (decoratorName === "Component") {
       const componentDecorator = decorators.find((d2) => {
-        if (!ts13.isCallExpression(d2.expression))
+        if (!ts14.isCallExpression(d2.expression))
           return false;
         const expr = d2.expression.expression;
-        return ts13.isIdentifier(expr) && expr.text === "Component";
+        return ts14.isIdentifier(expr) && expr.text === "Component";
       });
       if (!componentDecorator)
         continue;
       const decoratorCall = componentDecorator.expression;
       const args = decoratorCall.arguments[0];
-      if (!args || !ts13.isObjectLiteralExpression(args))
+      if (!args || !ts14.isObjectLiteralExpression(args))
         continue;
       const decoratorMeta = readDecoratorMeta(args);
       const { inputs, outputs } = extractInputsAndOutputs(stmt, null);
@@ -15881,11 +16046,11 @@ var fail = (reason, detail, location) => ({
     return false;
   return true;
 }, ENTITY_DECORATOR_NAMES, findEntityDecorator = (cls) => {
-  for (const dec of ts13.getDecorators(cls) ?? []) {
+  for (const dec of ts14.getDecorators(cls) ?? []) {
     const expr = dec.expression;
-    if (!ts13.isCallExpression(expr))
+    if (!ts14.isCallExpression(expr))
       continue;
-    if (!ts13.isIdentifier(expr.expression))
+    if (!ts14.isIdentifier(expr.expression))
       continue;
     if (ENTITY_DECORATOR_NAMES.has(expr.expression.text))
       return dec;
@@ -15903,18 +16068,18 @@ var fail = (reason, detail, location) => ({
   }
   const ctorParamTypes = [];
   for (const member of cls.members) {
-    if (!ts13.isConstructorDeclaration(member))
+    if (!ts14.isConstructorDeclaration(member))
       continue;
     for (const param of member.parameters) {
       const typeText = param.type ? param.type.getText() : "";
-      const decorators = ts13.getDecorators(param) ?? [];
+      const decorators = ts14.getDecorators(param) ?? [];
       const decoratorSig = decorators.length === 0 ? "" : decorators.map((d2) => {
         const e = d2.expression;
-        if (ts13.isCallExpression(e) && ts13.isIdentifier(e.expression)) {
+        if (ts14.isCallExpression(e) && ts14.isIdentifier(e.expression)) {
           const args = e.arguments.map((a) => a.getText()).join(",");
           return `@${e.expression.text}(${args})`;
         }
-        if (ts13.isIdentifier(e))
+        if (ts14.isIdentifier(e))
           return `@${e.text}`;
         return "@<unknown>";
       }).join("");
@@ -15936,23 +16101,23 @@ var fail = (reason, detail, location) => ({
   const walk = (node) => {
     if (found)
       return;
-    if (ts13.isClassDeclaration(node) && node.name?.text === className) {
+    if (ts14.isClassDeclaration(node) && node.name?.text === className) {
       found = node;
       return;
     }
-    ts13.forEachChild(node, walk);
+    ts14.forEachChild(node, walk);
   };
   walk(sourceFile);
   return found;
 }, getClassDecorators = (cls) => {
-  const modifiers = ts13.getDecorators(cls) ?? [];
+  const modifiers = ts14.getDecorators(cls) ?? [];
   return [...modifiers];
 }, findComponentDecorator = (cls) => {
   for (const decorator of getClassDecorators(cls)) {
     const expr = decorator.expression;
-    if (ts13.isCallExpression(expr)) {
+    if (ts14.isCallExpression(expr)) {
       const fn2 = expr.expression;
-      if (ts13.isIdentifier(fn2) && fn2.text === "Component") {
+      if (ts14.isIdentifier(fn2) && fn2.text === "Component") {
         return decorator;
       }
     }
@@ -15960,15 +16125,15 @@ var fail = (reason, detail, location) => ({
   return null;
 }, getDecoratorArgsObject = (decorator) => {
   const call = decorator.expression;
-  if (!ts13.isCallExpression(call))
+  if (!ts14.isCallExpression(call))
     return null;
   const arg = call.arguments[0];
-  if (!arg || !ts13.isObjectLiteralExpression(arg))
+  if (!arg || !ts14.isObjectLiteralExpression(arg))
     return null;
   return arg;
 }, getProperty = (obj, name) => {
   for (const prop of obj.properties) {
-    if (ts13.isPropertyAssignment(prop) && (ts13.isIdentifier(prop.name) && prop.name.text === name || ts13.isStringLiteral(prop.name) && prop.name.text === name)) {
+    if (ts14.isPropertyAssignment(prop) && (ts14.isIdentifier(prop.name) && prop.name.text === name || ts14.isStringLiteral(prop.name) && prop.name.text === name)) {
       return prop.initializer;
     }
   }
@@ -15977,7 +16142,7 @@ var fail = (reason, detail, location) => ({
   const expr = getProperty(obj, name);
   if (!expr)
     return null;
-  if (ts13.isStringLiteral(expr) || ts13.isNoSubstitutionTemplateLiteral(expr)) {
+  if (ts14.isStringLiteral(expr) || ts14.isNoSubstitutionTemplateLiteral(expr)) {
     return expr.text;
   }
   return null;
@@ -15985,22 +16150,22 @@ var fail = (reason, detail, location) => ({
   const expr = getProperty(obj, name);
   if (!expr)
     return null;
-  if (expr.kind === ts13.SyntaxKind.TrueKeyword)
+  if (expr.kind === ts14.SyntaxKind.TrueKeyword)
     return true;
-  if (expr.kind === ts13.SyntaxKind.FalseKeyword)
+  if (expr.kind === ts14.SyntaxKind.FalseKeyword)
     return false;
   return null;
 }, isAngularDecoratorIdentifier = (name) => name === "Component" || name === "Directive" || name === "Pipe" || name === "Injectable", classHasAngularDecorator = (cls) => {
-  for (const dec of ts13.getDecorators(cls) ?? []) {
+  for (const dec of ts14.getDecorators(cls) ?? []) {
     const expr = dec.expression;
-    if (ts13.isCallExpression(expr) && ts13.isIdentifier(expr.expression) && isAngularDecoratorIdentifier(expr.expression.text)) {
+    if (ts14.isCallExpression(expr) && ts14.isIdentifier(expr.expression) && isAngularDecoratorIdentifier(expr.expression.text)) {
       return true;
     }
   }
   return false;
 }, findClassInSourceFile = (sf, className) => {
   for (const stmt of sf.statements) {
-    if (ts13.isClassDeclaration(stmt) && stmt.name?.text === className) {
+    if (ts14.isClassDeclaration(stmt) && stmt.name?.text === className) {
       return stmt;
     }
   }
@@ -16010,15 +16175,15 @@ var fail = (reason, detail, location) => ({
   if (sameFile)
     return classHasAngularDecorator(sameFile);
   for (const stmt of sourceFile.statements) {
-    if (!ts13.isImportDeclaration(stmt))
+    if (!ts14.isImportDeclaration(stmt))
       continue;
-    if (!ts13.isStringLiteral(stmt.moduleSpecifier))
+    if (!ts14.isStringLiteral(stmt.moduleSpecifier))
       continue;
     const clause = stmt.importClause;
     if (!clause || clause.isTypeOnly)
       continue;
     const named = clause.namedBindings;
-    if (!named || !ts13.isNamedImports(named))
+    if (!named || !ts14.isNamedImports(named))
       continue;
     const found = named.elements.find((el) => el.name.text === parentClassName);
     if (!found)
@@ -16039,11 +16204,11 @@ var fail = (reason, detail, location) => ({
         continue;
       let content;
       try {
-        content = readFileSync17(candidate, "utf-8");
+        content = readFileSync18(candidate, "utf-8");
       } catch {
         continue;
       }
-      const parentSf = ts13.createSourceFile(candidate, content, ts13.ScriptTarget.Latest, true);
+      const parentSf = ts14.createSourceFile(candidate, content, ts14.ScriptTarget.Latest, true);
       const parentCls = findClassInSourceFile(parentSf, parentClassName);
       if (!parentCls)
         continue;
@@ -16055,11 +16220,11 @@ var fail = (reason, detail, location) => ({
 }, inheritsDecoratedClass = (cls, sourceFile, componentDir, projectRoot) => {
   const heritage = cls.heritageClauses ?? [];
   for (const clause of heritage) {
-    if (clause.token !== ts13.SyntaxKind.ExtendsKeyword)
+    if (clause.token !== ts14.SyntaxKind.ExtendsKeyword)
       continue;
     for (const typeNode of clause.types) {
       const expr = typeNode.expression;
-      if (!ts13.isIdentifier(expr)) {
+      if (!ts14.isIdentifier(expr)) {
         return true;
       }
       if (parentHasAngularDecoratorAcrossFiles(expr.text, sourceFile, componentDir, projectRoot)) {
@@ -16070,18 +16235,18 @@ var fail = (reason, detail, location) => ({
   return false;
 }, CONTROL_CREATE_METHOD_NAME = "\u0275ngControlCreate", extractControlCreate = (cls) => {
   for (const member of cls.members) {
-    if (!ts13.isMethodDeclaration(member))
+    if (!ts14.isMethodDeclaration(member))
       continue;
-    if (member.modifiers?.some((m) => m.kind === ts13.SyntaxKind.StaticKeyword))
+    if (member.modifiers?.some((m) => m.kind === ts14.SyntaxKind.StaticKeyword))
       continue;
     const name = member.name;
     if (name === undefined)
       continue;
-    const nameText = ts13.isIdentifier(name) ? name.text : name.getText();
+    const nameText = ts14.isIdentifier(name) ? name.text : name.getText();
     if (nameText !== CONTROL_CREATE_METHOD_NAME)
       continue;
     const firstParam = member.parameters[0];
-    if (firstParam === undefined || firstParam.type === undefined || !ts13.isTypeReferenceNode(firstParam.type)) {
+    if (firstParam === undefined || firstParam.type === undefined || !ts14.isTypeReferenceNode(firstParam.type)) {
       return { passThroughInput: null };
     }
     const typeArgs = firstParam.type.typeArguments;
@@ -16089,16 +16254,16 @@ var fail = (reason, detail, location) => ({
       return { passThroughInput: null };
     }
     const arg = typeArgs[0];
-    if (arg === undefined || !ts13.isLiteralTypeNode(arg) || !ts13.isStringLiteral(arg.literal)) {
+    if (arg === undefined || !ts14.isLiteralTypeNode(arg) || !ts14.isStringLiteral(arg.literal)) {
       return { passThroughInput: null };
     }
     return { passThroughInput: arg.literal.text };
   }
   return null;
 }, resolveEnumPropertyAccess = (expr, enumName, values) => {
-  if (!ts13.isPropertyAccessExpression(expr))
+  if (!ts14.isPropertyAccessExpression(expr))
     return null;
-  if (!ts13.isIdentifier(expr.expression))
+  if (!ts14.isIdentifier(expr.expression))
     return null;
   if (expr.expression.text !== enumName)
     return null;
@@ -16117,21 +16282,21 @@ var fail = (reason, detail, location) => ({
   const hostExpr = getProperty(args, "host");
   const schemasExpr = getProperty(args, "schemas");
   const styleUrls = [];
-  if (styleUrlsExpr && ts13.isArrayLiteralExpression(styleUrlsExpr)) {
+  if (styleUrlsExpr && ts14.isArrayLiteralExpression(styleUrlsExpr)) {
     for (const el of styleUrlsExpr.elements) {
-      if (ts13.isStringLiteral(el))
+      if (ts14.isStringLiteral(el))
         styleUrls.push(el.text);
     }
   }
   const styles = [];
   if (stylesExpr) {
-    if (ts13.isArrayLiteralExpression(stylesExpr)) {
+    if (ts14.isArrayLiteralExpression(stylesExpr)) {
       for (const el of stylesExpr.elements) {
-        if (ts13.isStringLiteral(el) || ts13.isNoSubstitutionTemplateLiteral(el)) {
+        if (ts14.isStringLiteral(el) || ts14.isNoSubstitutionTemplateLiteral(el)) {
           styles.push(el.text);
         }
       }
-    } else if (ts13.isStringLiteral(stylesExpr) || ts13.isNoSubstitutionTemplateLiteral(stylesExpr)) {
+    } else if (ts14.isStringLiteral(stylesExpr) || ts14.isNoSubstitutionTemplateLiteral(stylesExpr)) {
       styles.push(stylesExpr.text);
     }
   }
@@ -16144,15 +16309,15 @@ var fail = (reason, detail, location) => ({
     encapsulation,
     hasProviders: getProperty(args, "providers") !== null,
     hasViewProviders: getProperty(args, "viewProviders") !== null,
-    importsExpr: importsExpr && ts13.isArrayLiteralExpression(importsExpr) ? importsExpr : null,
-    hostDirectivesExpr: hostDirectivesExpr && ts13.isArrayLiteralExpression(hostDirectivesExpr) ? hostDirectivesExpr : null,
-    animationsExpr: animationsExpr && ts13.isArrayLiteralExpression(animationsExpr) ? animationsExpr : null,
-    providersExpr: providersExpr && ts13.isArrayLiteralExpression(providersExpr) ? providersExpr : null,
-    viewProvidersExpr: viewProvidersExpr && ts13.isArrayLiteralExpression(viewProvidersExpr) ? viewProvidersExpr : null,
-    inputsArrayExpr: inputsArrayExpr && ts13.isArrayLiteralExpression(inputsArrayExpr) ? inputsArrayExpr : null,
-    outputsArrayExpr: outputsArrayExpr && ts13.isArrayLiteralExpression(outputsArrayExpr) ? outputsArrayExpr : null,
-    hostExpr: hostExpr && ts13.isObjectLiteralExpression(hostExpr) ? hostExpr : null,
-    schemasExpr: schemasExpr && ts13.isArrayLiteralExpression(schemasExpr) ? schemasExpr : null,
+    importsExpr: importsExpr && ts14.isArrayLiteralExpression(importsExpr) ? importsExpr : null,
+    hostDirectivesExpr: hostDirectivesExpr && ts14.isArrayLiteralExpression(hostDirectivesExpr) ? hostDirectivesExpr : null,
+    animationsExpr: animationsExpr && ts14.isArrayLiteralExpression(animationsExpr) ? animationsExpr : null,
+    providersExpr: providersExpr && ts14.isArrayLiteralExpression(providersExpr) ? providersExpr : null,
+    viewProvidersExpr: viewProvidersExpr && ts14.isArrayLiteralExpression(viewProvidersExpr) ? viewProvidersExpr : null,
+    inputsArrayExpr: inputsArrayExpr && ts14.isArrayLiteralExpression(inputsArrayExpr) ? inputsArrayExpr : null,
+    outputsArrayExpr: outputsArrayExpr && ts14.isArrayLiteralExpression(outputsArrayExpr) ? outputsArrayExpr : null,
+    hostExpr: hostExpr && ts14.isObjectLiteralExpression(hostExpr) ? hostExpr : null,
+    schemasExpr: schemasExpr && ts14.isArrayLiteralExpression(schemasExpr) ? schemasExpr : null,
     preserveWhitespaces: getBooleanProperty(args, "preserveWhitespaces") ?? projectDefaults.preserveWhitespaces ?? false,
     selector: getStringProperty(args, "selector"),
     standalone: getBooleanProperty(args, "standalone") ?? true,
@@ -16163,13 +16328,13 @@ var fail = (reason, detail, location) => ({
     templateUrl: getStringProperty(args, "templateUrl")
   };
 }, extractDecoratorInput = (prop, compiler) => {
-  const decorators = ts13.getDecorators(prop) ?? [];
+  const decorators = ts14.getDecorators(prop) ?? [];
   for (const decorator of decorators) {
     const expr = decorator.expression;
-    if (!ts13.isCallExpression(expr))
+    if (!ts14.isCallExpression(expr))
       continue;
     const fn2 = expr.expression;
-    if (!ts13.isIdentifier(fn2) || fn2.text !== "Input")
+    if (!ts14.isIdentifier(fn2) || fn2.text !== "Input")
       continue;
     const classPropertyName = prop.name.getText();
     let bindingPropertyName = classPropertyName;
@@ -16177,9 +16342,9 @@ var fail = (reason, detail, location) => ({
     let transformFunction = null;
     const arg = expr.arguments[0];
     if (arg) {
-      if (ts13.isStringLiteral(arg)) {
+      if (ts14.isStringLiteral(arg)) {
         bindingPropertyName = arg.text;
-      } else if (ts13.isObjectLiteralExpression(arg)) {
+      } else if (ts14.isObjectLiteralExpression(arg)) {
         const aliasNode = getStringProperty(arg, "alias");
         if (aliasNode !== null)
           bindingPropertyName = aliasNode;
@@ -16203,11 +16368,11 @@ var fail = (reason, detail, location) => ({
   }
   return null;
 }, isInputSignalCall = (init) => {
-  if (ts13.isCallExpression(init)) {
+  if (ts14.isCallExpression(init)) {
     const fn2 = init.expression;
-    if (ts13.isIdentifier(fn2) && fn2.text === "input")
+    if (ts14.isIdentifier(fn2) && fn2.text === "input")
       return true;
-    if (ts13.isPropertyAccessExpression(fn2) && ts13.isIdentifier(fn2.expression) && fn2.expression.text === "input") {
+    if (ts14.isPropertyAccessExpression(fn2) && ts14.isIdentifier(fn2.expression) && fn2.expression.text === "input") {
       return true;
     }
   }
@@ -16218,13 +16383,13 @@ var fail = (reason, detail, location) => ({
   const classPropertyName = prop.name.getText();
   const call = prop.initializer;
   let required = false;
-  if (ts13.isPropertyAccessExpression(call.expression) && ts13.isIdentifier(call.expression.name) && call.expression.name.text === "required") {
+  if (ts14.isPropertyAccessExpression(call.expression) && ts14.isIdentifier(call.expression.name) && call.expression.name.text === "required") {
     required = true;
   }
   let bindingPropertyName = classPropertyName;
   let transformFunction = null;
   const optsArg = call.arguments[required ? 0 : 1];
-  if (optsArg && ts13.isObjectLiteralExpression(optsArg)) {
+  if (optsArg && ts14.isObjectLiteralExpression(optsArg)) {
     const aliasNode = getStringProperty(optsArg, "alias");
     if (aliasNode !== null)
       bindingPropertyName = aliasNode;
@@ -16244,28 +16409,28 @@ var fail = (reason, detail, location) => ({
     }
   };
 }, extractDecoratorOutput = (prop) => {
-  const decorators = ts13.getDecorators(prop) ?? [];
+  const decorators = ts14.getDecorators(prop) ?? [];
   for (const decorator of decorators) {
     const expr = decorator.expression;
-    if (!ts13.isCallExpression(expr))
+    if (!ts14.isCallExpression(expr))
       continue;
     const fn2 = expr.expression;
-    if (!ts13.isIdentifier(fn2) || fn2.text !== "Output")
+    if (!ts14.isIdentifier(fn2) || fn2.text !== "Output")
       continue;
     const classPropertyName = prop.name.getText();
     let bindingName = classPropertyName;
     const arg = expr.arguments[0];
-    if (arg && ts13.isStringLiteral(arg))
+    if (arg && ts14.isStringLiteral(arg))
       bindingName = arg.text;
     return { classPropertyName, bindingName };
   }
   return null;
 }, isOutputSignalCall = (init) => {
-  if (ts13.isCallExpression(init)) {
+  if (ts14.isCallExpression(init)) {
     const fn2 = init.expression;
-    if (ts13.isIdentifier(fn2) && fn2.text === "output")
+    if (ts14.isIdentifier(fn2) && fn2.text === "output")
       return true;
-    if (ts13.isPropertyAccessExpression(fn2) && ts13.isIdentifier(fn2.expression) && fn2.expression.text === "output") {
+    if (ts14.isPropertyAccessExpression(fn2) && ts14.isIdentifier(fn2.expression) && fn2.expression.text === "output") {
       return true;
     }
   }
@@ -16277,7 +16442,7 @@ var fail = (reason, detail, location) => ({
   const call = prop.initializer;
   let bindingName = classPropertyName;
   const optsArg = call.arguments[0];
-  if (optsArg && ts13.isObjectLiteralExpression(optsArg)) {
+  if (optsArg && ts14.isObjectLiteralExpression(optsArg)) {
     const aliasNode = getStringProperty(optsArg, "alias");
     if (aliasNode !== null)
       bindingName = aliasNode;
@@ -16289,7 +16454,7 @@ var fail = (reason, detail, location) => ({
   let hasDecoratorIO = false;
   let hasSignalIO = false;
   for (const member of cls.members) {
-    if (!ts13.isPropertyDeclaration(member))
+    if (!ts14.isPropertyDeclaration(member))
       continue;
     const decoratorIn = extractDecoratorInput(member, compiler);
     if (decoratorIn) {
@@ -16323,21 +16488,21 @@ var fail = (reason, detail, location) => ({
   specialAttributes: {}
 }), parseHostObjectInto = (host, args, hostExprNode, compiler) => {
   const hostNode = getProperty(args, "host");
-  if (!hostNode || !ts13.isObjectLiteralExpression(hostNode)) {
+  if (!hostNode || !ts14.isObjectLiteralExpression(hostNode)) {
     if (!hostExprNode)
       return;
   }
-  const obj = hostNode && ts13.isObjectLiteralExpression(hostNode) ? hostNode : hostExprNode;
+  const obj = hostNode && ts14.isObjectLiteralExpression(hostNode) ? hostNode : hostExprNode;
   if (!obj)
     return;
   for (const prop of obj.properties) {
-    if (!ts13.isPropertyAssignment(prop))
+    if (!ts14.isPropertyAssignment(prop))
       continue;
     const keyNode = prop.name;
     let key;
-    if (ts13.isStringLiteral(keyNode) || ts13.isNoSubstitutionTemplateLiteral(keyNode)) {
+    if (ts14.isStringLiteral(keyNode) || ts14.isNoSubstitutionTemplateLiteral(keyNode)) {
       key = keyNode.text;
-    } else if (ts13.isIdentifier(keyNode)) {
+    } else if (ts14.isIdentifier(keyNode)) {
       key = keyNode.text;
     } else {
       continue;
@@ -16354,36 +16519,36 @@ var fail = (reason, detail, location) => ({
   }
 }, mergeMemberHostDecorators = (host, cls) => {
   for (const member of cls.members) {
-    if (!ts13.canHaveDecorators(member))
+    if (!ts14.canHaveDecorators(member))
       continue;
-    const decorators = ts13.getDecorators(member) ?? [];
+    const decorators = ts14.getDecorators(member) ?? [];
     for (const dec of decorators) {
       const expr = dec.expression;
-      if (!ts13.isCallExpression(expr))
+      if (!ts14.isCallExpression(expr))
         continue;
       const fn2 = expr.expression;
-      if (!ts13.isIdentifier(fn2))
+      if (!ts14.isIdentifier(fn2))
         continue;
       if (fn2.text === "HostBinding") {
-        if (!ts13.isPropertyDeclaration(member) && !ts13.isGetAccessor(member))
+        if (!ts14.isPropertyDeclaration(member) && !ts14.isGetAccessor(member))
           continue;
         const propertyName = member.name.text;
         const target = expr.arguments[0];
-        const key = target && ts13.isStringLiteral(target) ? target.text : propertyName;
+        const key = target && ts14.isStringLiteral(target) ? target.text : propertyName;
         host.properties[key] = propertyName;
       } else if (fn2.text === "HostListener") {
-        if (!ts13.isMethodDeclaration(member))
+        if (!ts14.isMethodDeclaration(member))
           continue;
         const methodName = member.name.text;
         const eventArg = expr.arguments[0];
-        if (!eventArg || !ts13.isStringLiteral(eventArg))
+        if (!eventArg || !ts14.isStringLiteral(eventArg))
           continue;
         const event = eventArg.text;
         const argsArg = expr.arguments[1];
         let argsList = [];
-        if (argsArg && ts13.isArrayLiteralExpression(argsArg)) {
+        if (argsArg && ts14.isArrayLiteralExpression(argsArg)) {
           for (const el of argsArg.elements) {
-            if (ts13.isStringLiteral(el))
+            if (ts14.isStringLiteral(el))
               argsList.push(el.text);
           }
         }
@@ -16396,14 +16561,14 @@ var fail = (reason, detail, location) => ({
   let descendants = true;
   let emitDistinctChangesOnly = true;
   const opts = args[1];
-  if (opts && ts13.isObjectLiteralExpression(opts)) {
+  if (opts && ts14.isObjectLiteralExpression(opts)) {
     static_ = getBooleanProperty(opts, "static") ?? false;
     descendants = getBooleanProperty(opts, "descendants") ?? true;
     emitDistinctChangesOnly = getBooleanProperty(opts, "emitDistinctChangesOnly") ?? true;
   }
   return { static_, descendants, emitDistinctChangesOnly };
 }, queryPredicateFromArg = (arg, compiler) => {
-  if (ts13.isStringLiteral(arg)) {
+  if (ts14.isStringLiteral(arg)) {
     return arg.text.split(",").map((s2) => s2.trim()).filter(Boolean);
   }
   return {
@@ -16414,15 +16579,15 @@ var fail = (reason, detail, location) => ({
   const contentQueries = [];
   const viewQueries = [];
   for (const member of cls.members) {
-    if (!ts13.isPropertyDeclaration(member))
+    if (!ts14.isPropertyDeclaration(member))
       continue;
-    const decorators = ts13.getDecorators(member) ?? [];
+    const decorators = ts14.getDecorators(member) ?? [];
     for (const dec of decorators) {
       const expr = dec.expression;
-      if (!ts13.isCallExpression(expr))
+      if (!ts14.isCallExpression(expr))
         continue;
       const fn2 = expr.expression;
-      if (!ts13.isIdentifier(fn2) || !QUERY_DECORATORS.has(fn2.text))
+      if (!ts14.isIdentifier(fn2) || !QUERY_DECORATORS.has(fn2.text))
         continue;
       const propertyName = member.name.text;
       const tokenArg = expr.arguments[0];
@@ -16434,7 +16599,7 @@ var fail = (reason, detail, location) => ({
       const { static_, descendants, emitDistinctChangesOnly } = parseQueryDecoratorOptions(expr.arguments);
       const opts = expr.arguments[1];
       let read = null;
-      if (opts && ts13.isObjectLiteralExpression(opts)) {
+      if (opts && ts14.isObjectLiteralExpression(opts)) {
         const readNode = getProperty(opts, "read");
         if (readNode) {
           read = new compiler.WrappedNodeExpr(readNode);
@@ -16462,15 +16627,15 @@ var fail = (reason, detail, location) => ({
   const contentQueries = [];
   const viewQueries = [];
   for (const member of cls.members) {
-    if (!ts13.isPropertyDeclaration(member) || !member.initializer)
+    if (!ts14.isPropertyDeclaration(member) || !member.initializer)
       continue;
     let init = member.initializer;
-    if (!ts13.isCallExpression(init))
+    if (!ts14.isCallExpression(init))
       continue;
     let queryName;
-    if (ts13.isIdentifier(init.expression)) {
+    if (ts14.isIdentifier(init.expression)) {
       queryName = init.expression.text;
-    } else if (ts13.isPropertyAccessExpression(init.expression) && ts13.isIdentifier(init.expression.expression) && init.expression.name.text === "required") {
+    } else if (ts14.isPropertyAccessExpression(init.expression) && ts14.isIdentifier(init.expression.expression) && init.expression.name.text === "required") {
       queryName = init.expression.expression.text;
     } else {
       continue;
@@ -16488,7 +16653,7 @@ var fail = (reason, detail, location) => ({
     let descendants = true;
     let read = null;
     const opts = init.arguments[1];
-    if (opts && ts13.isObjectLiteralExpression(opts)) {
+    if (opts && ts14.isObjectLiteralExpression(opts)) {
       descendants = getBooleanProperty(opts, "descendants") ?? true;
       const readNode = getProperty(opts, "read");
       if (readNode)
@@ -16514,13 +16679,13 @@ var fail = (reason, detail, location) => ({
   const node = getProperty(args, "exportAs");
   if (!node)
     return null;
-  if (ts13.isStringLiteral(node)) {
+  if (ts14.isStringLiteral(node)) {
     return node.text.split(",").map((s2) => s2.trim()).filter(Boolean);
   }
-  if (ts13.isArrayLiteralExpression(node)) {
+  if (ts14.isArrayLiteralExpression(node)) {
     const out = [];
     for (const el of node.elements) {
-      if (ts13.isStringLiteral(el))
+      if (ts14.isStringLiteral(el))
         out.push(el.text);
     }
     return out.length > 0 ? out : null;
@@ -16528,11 +16693,11 @@ var fail = (reason, detail, location) => ({
   return null;
 }, extractHostDirectives = (args, compiler) => {
   const node = getProperty(args, "hostDirectives");
-  if (!node || !ts13.isArrayLiteralExpression(node))
+  if (!node || !ts14.isArrayLiteralExpression(node))
     return null;
   const out = [];
   for (const el of node.elements) {
-    if (ts13.isIdentifier(el)) {
+    if (ts14.isIdentifier(el)) {
       out.push({
         directive: {
           value: new compiler.WrappedNodeExpr(el),
@@ -16544,7 +16709,7 @@ var fail = (reason, detail, location) => ({
       });
       continue;
     }
-    if (!ts13.isObjectLiteralExpression(el))
+    if (!ts14.isObjectLiteralExpression(el))
       continue;
     const directiveNode = getProperty(el, "directive");
     if (!directiveNode)
@@ -16552,11 +16717,11 @@ var fail = (reason, detail, location) => ({
     const inputsNode = getProperty(el, "inputs");
     const outputsNode = getProperty(el, "outputs");
     const collectMap = (n) => {
-      if (!n || !ts13.isArrayLiteralExpression(n))
+      if (!n || !ts14.isArrayLiteralExpression(n))
         return null;
       const map = {};
       for (const item of n.elements) {
-        if (!ts13.isStringLiteral(item))
+        if (!ts14.isStringLiteral(item))
           continue;
         const [name, alias] = item.text.split(":").map((s2) => s2.trim());
         if (name)
@@ -16618,7 +16783,7 @@ var fail = (reason, detail, location) => ({
     return cached.info;
   let source;
   try {
-    source = readFileSync17(filePath, "utf-8");
+    source = readFileSync18(filePath, "utf-8");
   } catch {
     childComponentInfoCache.set(cacheKey2, {
       info: null,
@@ -16626,10 +16791,10 @@ var fail = (reason, detail, location) => ({
     });
     return null;
   }
-  const sf = ts13.createSourceFile(filePath, source, ts13.ScriptTarget.Latest, true);
+  const sf = ts14.createSourceFile(filePath, source, ts14.ScriptTarget.Latest, true);
   let info = null;
   for (const stmt of sf.statements) {
-    if (!ts13.isClassDeclaration(stmt))
+    if (!ts14.isClassDeclaration(stmt))
       continue;
     if (!stmt.name || stmt.name.text !== className)
       continue;
@@ -16672,7 +16837,7 @@ var fail = (reason, detail, location) => ({
     return cached.info;
   let content;
   try {
-    content = readFileSync17(dtsPath, "utf-8");
+    content = readFileSync18(dtsPath, "utf-8");
   } catch {
     childComponentInfoCache.set(cacheKey2, {
       info: null,
@@ -16764,9 +16929,9 @@ var fail = (reason, detail, location) => ({
 }, buildClassToSpecMap = (sourceFile) => {
   const result = new Map;
   for (const stmt of sourceFile.statements) {
-    if (!ts13.isImportDeclaration(stmt))
+    if (!ts14.isImportDeclaration(stmt))
       continue;
-    if (!ts13.isStringLiteral(stmt.moduleSpecifier))
+    if (!ts14.isStringLiteral(stmt.moduleSpecifier))
       continue;
     const spec = stmt.moduleSpecifier.text;
     const clause = stmt.importClause;
@@ -16775,7 +16940,7 @@ var fail = (reason, detail, location) => ({
     if (clause.name)
       result.set(clause.name.text, spec);
     const named = clause.namedBindings;
-    if (named && ts13.isNamedImports(named)) {
+    if (named && ts14.isNamedImports(named)) {
       for (const el of named.elements) {
         if (el.isTypeOnly)
           continue;
@@ -16792,7 +16957,7 @@ var fail = (reason, detail, location) => ({
     return null;
   let content;
   try {
-    content = readFileSync17(startDtsPath, "utf-8");
+    content = readFileSync18(startDtsPath, "utf-8");
   } catch {
     return null;
   }
@@ -16888,7 +17053,7 @@ var fail = (reason, detail, location) => ({
     return result;
   const classToSpec = buildClassToSpecMap(sourceFile);
   for (const el of importsExpr.elements) {
-    if (!ts13.isIdentifier(el))
+    if (!ts14.isIdentifier(el))
       continue;
     const className = el.text;
     const spec = classToSpec.get(className);
@@ -16907,35 +17072,35 @@ var fail = (reason, detail, location) => ({
   }
   return (h2 >>> 0).toString(36);
 }, initializerShapeIsStructural = (node) => {
-  if (ts13.isArrowFunction(node) || ts13.isFunctionExpression(node) || ts13.isCallExpression(node) || ts13.isNewExpression(node)) {
+  if (ts14.isArrowFunction(node) || ts14.isFunctionExpression(node) || ts14.isCallExpression(node) || ts14.isNewExpression(node)) {
     return true;
   }
-  if (ts13.isConditionalExpression(node)) {
+  if (ts14.isConditionalExpression(node)) {
     return initializerShapeIsStructural(node.whenTrue) || initializerShapeIsStructural(node.whenFalse);
   }
-  if (ts13.isParenthesizedExpression(node)) {
+  if (ts14.isParenthesizedExpression(node)) {
     return initializerShapeIsStructural(node.expression);
   }
-  if (ts13.isAsExpression(node) || ts13.isTypeAssertionExpression(node)) {
+  if (ts14.isAsExpression(node) || ts14.isTypeAssertionExpression(node)) {
     return initializerShapeIsStructural(node.expression);
   }
-  if (ts13.isNonNullExpression(node)) {
+  if (ts14.isNonNullExpression(node)) {
     return initializerShapeIsStructural(node.expression);
   }
-  if (ts13.isObjectLiteralExpression(node)) {
+  if (ts14.isObjectLiteralExpression(node)) {
     for (const prop of node.properties) {
-      if (ts13.isPropertyAssignment(prop) && initializerShapeIsStructural(prop.initializer)) {
+      if (ts14.isPropertyAssignment(prop) && initializerShapeIsStructural(prop.initializer)) {
         return true;
       }
-      if (ts13.isShorthandPropertyAssignment(prop))
+      if (ts14.isShorthandPropertyAssignment(prop))
         continue;
-      if (ts13.isSpreadAssignment(prop) && initializerShapeIsStructural(prop.expression)) {
+      if (ts14.isSpreadAssignment(prop) && initializerShapeIsStructural(prop.expression)) {
         return true;
       }
     }
     return false;
   }
-  if (ts13.isArrayLiteralExpression(node)) {
+  if (ts14.isArrayLiteralExpression(node)) {
     for (const el of node.elements) {
       if (initializerShapeIsStructural(el))
         return true;
@@ -16946,7 +17111,7 @@ var fail = (reason, detail, location) => ({
 }, extractArrowFieldSig = (cls) => {
   const entries = [];
   for (const member of cls.members) {
-    if (!ts13.isPropertyDeclaration(member))
+    if (!ts14.isPropertyDeclaration(member))
       continue;
     const init = member.initializer;
     if (!init)
@@ -16956,12 +17121,12 @@ var fail = (reason, detail, location) => ({
     const name = member.name.getText();
     let bodyText;
     try {
-      const printer = ts13.createPrinter({
-        newLine: ts13.NewLineKind.LineFeed,
+      const printer = ts14.createPrinter({
+        newLine: ts14.NewLineKind.LineFeed,
         omitTrailingSemicolon: true,
         removeComments: true
       });
-      bodyText = printer.printNode(ts13.EmitHint.Unspecified, init, cls.getSourceFile());
+      bodyText = printer.printNode(ts14.EmitHint.Unspecified, init, cls.getSourceFile());
     } catch {
       bodyText = init.getText();
     }
@@ -16972,9 +17137,9 @@ var fail = (reason, detail, location) => ({
 }, INPUT_OUTPUT_DECORATORS, extractMemberDecoratorSig = (cls) => {
   const entries = [];
   for (const member of cls.members) {
-    if (!ts13.canHaveDecorators(member))
+    if (!ts14.canHaveDecorators(member))
       continue;
-    const decorators = ts13.getDecorators(member) ?? [];
+    const decorators = ts14.getDecorators(member) ?? [];
     if (decorators.length === 0)
       continue;
     const memberName = member.name?.getText() ?? "<anon>";
@@ -16982,14 +17147,14 @@ var fail = (reason, detail, location) => ({
       const expr = decorator.expression;
       let decName = "<unknown>";
       let argText = "";
-      if (ts13.isCallExpression(expr)) {
-        if (ts13.isIdentifier(expr.expression)) {
+      if (ts14.isCallExpression(expr)) {
+        if (ts14.isIdentifier(expr.expression)) {
           decName = expr.expression.text;
         }
         if (expr.arguments.length > 0) {
           argText = expr.arguments.map((a) => a.getText()).join(",");
         }
-      } else if (ts13.isIdentifier(expr)) {
+      } else if (ts14.isIdentifier(expr)) {
         decName = expr.text;
       }
       if (INPUT_OUTPUT_DECORATORS.has(decName))
@@ -17010,22 +17175,22 @@ var fail = (reason, detail, location) => ({
     return cached.hasProviders;
   let source;
   try {
-    source = readFileSync17(filePath, "utf8");
+    source = readFileSync18(filePath, "utf8");
   } catch {
     return true;
   }
-  const sf = ts13.createSourceFile(filePath, source, ts13.ScriptTarget.ES2022, true, ts13.ScriptKind.TS);
+  const sf = ts14.createSourceFile(filePath, source, ts14.ScriptTarget.ES2022, true, ts14.ScriptKind.TS);
   let hasProviders = false;
   const visit = (node) => {
     if (hasProviders)
       return;
-    if (ts13.isClassDeclaration(node)) {
-      for (const decorator of ts13.getDecorators(node) ?? []) {
+    if (ts14.isClassDeclaration(node)) {
+      for (const decorator of ts14.getDecorators(node) ?? []) {
         const expr = decorator.expression;
-        if (!ts13.isCallExpression(expr))
+        if (!ts14.isCallExpression(expr))
           continue;
         const arg = expr.arguments[0];
-        if (!arg || !ts13.isObjectLiteralExpression(arg))
+        if (!arg || !ts14.isObjectLiteralExpression(arg))
           continue;
         if (getProperty(arg, "providers") !== null) {
           hasProviders = true;
@@ -17033,7 +17198,7 @@ var fail = (reason, detail, location) => ({
         }
       }
     }
-    ts13.forEachChild(node, visit);
+    ts14.forEachChild(node, visit);
   };
   visit(sf);
   providerProbeCache.set(filePath, {
@@ -17043,10 +17208,10 @@ var fail = (reason, detail, location) => ({
   return hasProviders;
 }, TS_EXTENSIONS, resolveImportSource = (identifierName, sourceFile, componentDir) => {
   for (const stmt of sourceFile.statements) {
-    if (!ts13.isImportDeclaration(stmt))
+    if (!ts14.isImportDeclaration(stmt))
       continue;
     const moduleSpec = stmt.moduleSpecifier;
-    if (!ts13.isStringLiteral(moduleSpec))
+    if (!ts14.isStringLiteral(moduleSpec))
       continue;
     const spec = moduleSpec.text;
     if (!spec.startsWith(".") && !spec.startsWith("/"))
@@ -17060,7 +17225,7 @@ var fail = (reason, detail, location) => ({
     }
     if (importClause.namedBindings) {
       const nb = importClause.namedBindings;
-      if (ts13.isNamespaceImport(nb)) {
+      if (ts14.isNamespaceImport(nb)) {
         if (nb.name.text === identifierName)
           matches = true;
       } else {
@@ -17090,7 +17255,7 @@ var fail = (reason, detail, location) => ({
     return [];
   const sig = [];
   for (const entry of importsExpr.elements) {
-    if (ts13.isIdentifier(entry)) {
+    if (ts14.isIdentifier(entry)) {
       const importPath = resolveImportSource(entry.text, sourceFile, componentDir);
       if (importPath) {
         if (fileHasModuleProviders(importPath)) {
@@ -17109,13 +17274,13 @@ var fail = (reason, detail, location) => ({
 }, extractPropertyFieldNames = (cls) => {
   const names = [];
   for (const member of cls.members) {
-    if (!ts13.isPropertyDeclaration(member) && !ts13.isMethodDeclaration(member) && !ts13.isGetAccessorDeclaration(member) && !ts13.isSetAccessorDeclaration(member)) {
+    if (!ts14.isPropertyDeclaration(member) && !ts14.isMethodDeclaration(member) && !ts14.isGetAccessorDeclaration(member) && !ts14.isSetAccessorDeclaration(member)) {
       continue;
     }
     const name = member.name;
     if (name === undefined)
       continue;
-    const text = ts13.isIdentifier(name) ? name.text : ts13.isStringLiteral(name) || ts13.isNoSubstitutionTemplateLiteral(name) ? name.text : name.getText();
+    const text = ts14.isIdentifier(name) ? name.text : ts14.isStringLiteral(name) || ts14.isNoSubstitutionTemplateLiteral(name) ? name.text : name.getText();
     if (text.length > 0)
       names.push(text);
   }
@@ -17123,7 +17288,7 @@ var fail = (reason, detail, location) => ({
 }, extractTopLevelImports = (sourceFile) => {
   const names = new Set;
   for (const stmt of sourceFile.statements) {
-    if (!ts13.isImportDeclaration(stmt))
+    if (!ts14.isImportDeclaration(stmt))
       continue;
     const clause = stmt.importClause;
     if (!clause)
@@ -17135,9 +17300,9 @@ var fail = (reason, detail, location) => ({
     const bindings = clause.namedBindings;
     if (!bindings)
       continue;
-    if (ts13.isNamespaceImport(bindings)) {
+    if (ts14.isNamespaceImport(bindings)) {
       names.add(bindings.name.text);
-    } else if (ts13.isNamedImports(bindings)) {
+    } else if (ts14.isNamedImports(bindings)) {
       for (const el of bindings.elements) {
         if (el.isTypeOnly)
           continue;
@@ -17149,18 +17314,18 @@ var fail = (reason, detail, location) => ({
 }, extractFingerprint = (cls, className, decoratorMeta, inputs, outputs, sourceFile, componentDir) => {
   const ctorParamTypes = [];
   for (const member of cls.members) {
-    if (!ts13.isConstructorDeclaration(member))
+    if (!ts14.isConstructorDeclaration(member))
       continue;
     for (const param of member.parameters) {
       const typeText = param.type ? param.type.getText() : "";
-      const decorators = ts13.getDecorators(param) ?? [];
+      const decorators = ts14.getDecorators(param) ?? [];
       const decoratorSig = decorators.length === 0 ? "" : decorators.map((d2) => {
         const expr = d2.expression;
-        if (ts13.isCallExpression(expr) && ts13.isIdentifier(expr.expression)) {
+        if (ts14.isCallExpression(expr) && ts14.isIdentifier(expr.expression)) {
           const args = expr.arguments.map((a) => a.getText()).join(",");
           return `@${expr.expression.text}(${args})`;
         }
-        if (ts13.isIdentifier(expr)) {
+        if (ts14.isIdentifier(expr)) {
           return `@${expr.text}`;
         }
         return "@<unknown>";
@@ -17176,12 +17341,12 @@ var fail = (reason, detail, location) => ({
   const providerImportSig = extractProviderImportSig(decoratorMeta.importsExpr, sourceFile, componentDir);
   const topLevelImports = extractTopLevelImports(sourceFile);
   const propertyFieldNames = extractPropertyFieldNames(cls);
-  const printer = ts13.createPrinter({
-    newLine: ts13.NewLineKind.LineFeed,
+  const printer = ts14.createPrinter({
+    newLine: ts14.NewLineKind.LineFeed,
     omitTrailingSemicolon: true,
     removeComments: true
   });
-  const canonicalText = (node) => printer.printNode(ts13.EmitHint.Unspecified, node, sourceFile);
+  const canonicalText = (node) => printer.printNode(ts14.EmitHint.Unspecified, node, sourceFile);
   const importsArraySig = decoratorMeta.importsExpr ? djb2Hash(canonicalText(decoratorMeta.importsExpr)) : "";
   const hostDirectivesSig = decoratorMeta.hostDirectivesExpr ? djb2Hash(canonicalText(decoratorMeta.hostDirectivesExpr)) : "";
   const animationsArraySig = decoratorMeta.animationsExpr ? djb2Hash(canonicalText(decoratorMeta.animationsExpr)) : "";
@@ -17194,13 +17359,13 @@ var fail = (reason, detail, location) => ({
   const PAGE_EXPORT_NAMES = new Set(["providers", "routes"]);
   const pageExportEntries = [];
   for (const stmt of sourceFile.statements) {
-    if (!ts13.isVariableStatement(stmt))
+    if (!ts14.isVariableStatement(stmt))
       continue;
-    const isExported = stmt.modifiers?.some((m) => m.kind === ts13.SyntaxKind.ExportKeyword);
+    const isExported = stmt.modifiers?.some((m) => m.kind === ts14.SyntaxKind.ExportKeyword);
     if (!isExported)
       continue;
     for (const decl of stmt.declarationList.declarations) {
-      if (!ts13.isIdentifier(decl.name))
+      if (!ts14.isIdentifier(decl.name))
         continue;
       if (!PAGE_EXPORT_NAMES.has(decl.name.text))
         continue;
@@ -17241,35 +17406,35 @@ var fail = (reason, detail, location) => ({
 }, buildFreshClassMethodsBlock = (classNode, className) => {
   const memberSources = [];
   let hasStatic = false;
-  const printer = ts13.createPrinter({ removeComments: true });
+  const printer = ts14.createPrinter({ removeComments: true });
   for (const member of classNode.members) {
-    if (ts13.isPropertyDeclaration(member)) {
-      const modifiers = (ts13.getModifiers(member) ?? []).filter((m) => m.kind !== ts13.SyntaxKind.PrivateKeyword && m.kind !== ts13.SyntaxKind.PublicKeyword && m.kind !== ts13.SyntaxKind.ProtectedKeyword && m.kind !== ts13.SyntaxKind.ReadonlyKeyword && m.kind !== ts13.SyntaxKind.OverrideKeyword);
-      const cleaned = ts13.factory.createPropertyDeclaration(modifiers, member.name, undefined, undefined, member.initializer);
-      memberSources.push(printer.printNode(ts13.EmitHint.Unspecified, cleaned, classNode.getSourceFile()));
+    if (ts14.isPropertyDeclaration(member)) {
+      const modifiers = (ts14.getModifiers(member) ?? []).filter((m) => m.kind !== ts14.SyntaxKind.PrivateKeyword && m.kind !== ts14.SyntaxKind.PublicKeyword && m.kind !== ts14.SyntaxKind.ProtectedKeyword && m.kind !== ts14.SyntaxKind.ReadonlyKeyword && m.kind !== ts14.SyntaxKind.OverrideKeyword);
+      const cleaned = ts14.factory.createPropertyDeclaration(modifiers, member.name, undefined, undefined, member.initializer);
+      memberSources.push(printer.printNode(ts14.EmitHint.Unspecified, cleaned, classNode.getSourceFile()));
       continue;
     }
-    if (ts13.isConstructorDeclaration(member)) {
-      const cleanedParams = member.parameters.map((param) => ts13.factory.updateParameterDeclaration(param, (ts13.getModifiers(param) ?? []).filter((m) => m.kind !== ts13.SyntaxKind.PrivateKeyword && m.kind !== ts13.SyntaxKind.PublicKeyword && m.kind !== ts13.SyntaxKind.ProtectedKeyword && m.kind !== ts13.SyntaxKind.ReadonlyKeyword && m.kind !== ts13.SyntaxKind.OverrideKeyword), param.dotDotDotToken, param.name, param.questionToken, param.type, param.initializer));
-      const cleaned = ts13.factory.createConstructorDeclaration([], cleanedParams, member.body);
-      memberSources.push(printer.printNode(ts13.EmitHint.Unspecified, cleaned, classNode.getSourceFile()));
+    if (ts14.isConstructorDeclaration(member)) {
+      const cleanedParams = member.parameters.map((param) => ts14.factory.updateParameterDeclaration(param, (ts14.getModifiers(param) ?? []).filter((m) => m.kind !== ts14.SyntaxKind.PrivateKeyword && m.kind !== ts14.SyntaxKind.PublicKeyword && m.kind !== ts14.SyntaxKind.ProtectedKeyword && m.kind !== ts14.SyntaxKind.ReadonlyKeyword && m.kind !== ts14.SyntaxKind.OverrideKeyword), param.dotDotDotToken, param.name, param.questionToken, param.type, param.initializer));
+      const cleaned = ts14.factory.createConstructorDeclaration([], cleanedParams, member.body);
+      memberSources.push(printer.printNode(ts14.EmitHint.Unspecified, cleaned, classNode.getSourceFile()));
       continue;
     }
-    if (ts13.isMethodDeclaration(member) || ts13.isGetAccessorDeclaration(member) || ts13.isSetAccessorDeclaration(member)) {
-      const modifiers = ts13.getModifiers(member) ?? [];
-      const isStatic = modifiers.some((m) => m.kind === ts13.SyntaxKind.StaticKeyword);
+    if (ts14.isMethodDeclaration(member) || ts14.isGetAccessorDeclaration(member) || ts14.isSetAccessorDeclaration(member)) {
+      const modifiers = ts14.getModifiers(member) ?? [];
+      const isStatic = modifiers.some((m) => m.kind === ts14.SyntaxKind.StaticKeyword);
       if (isStatic)
         hasStatic = true;
-      const cleanedParams = member.parameters.map((param) => ts13.factory.updateParameterDeclaration(param, ts13.getModifiers(param) ?? [], param.dotDotDotToken, param.name, param.questionToken, param.type, param.initializer));
+      const cleanedParams = member.parameters.map((param) => ts14.factory.updateParameterDeclaration(param, ts14.getModifiers(param) ?? [], param.dotDotDotToken, param.name, param.questionToken, param.type, param.initializer));
       let cleaned;
-      if (ts13.isMethodDeclaration(member)) {
-        cleaned = ts13.factory.createMethodDeclaration(modifiers, member.asteriskToken, member.name, member.questionToken, member.typeParameters, cleanedParams, member.type, member.body);
-      } else if (ts13.isGetAccessorDeclaration(member)) {
-        cleaned = ts13.factory.createGetAccessorDeclaration(modifiers, member.name, cleanedParams, member.type, member.body);
+      if (ts14.isMethodDeclaration(member)) {
+        cleaned = ts14.factory.createMethodDeclaration(modifiers, member.asteriskToken, member.name, member.questionToken, member.typeParameters, cleanedParams, member.type, member.body);
+      } else if (ts14.isGetAccessorDeclaration(member)) {
+        cleaned = ts14.factory.createGetAccessorDeclaration(modifiers, member.name, cleanedParams, member.type, member.body);
       } else {
-        cleaned = ts13.factory.createSetAccessorDeclaration(modifiers, member.name, cleanedParams, member.body);
+        cleaned = ts14.factory.createSetAccessorDeclaration(modifiers, member.name, cleanedParams, member.body);
       }
-      const printed = printer.printNode(ts13.EmitHint.Unspecified, cleaned, classNode.getSourceFile());
+      const printed = printer.printNode(ts14.EmitHint.Unspecified, cleaned, classNode.getSourceFile());
       memberSources.push(printed);
     }
   }
@@ -17281,10 +17446,10 @@ ${memberSources.join(`
 }`;
   let transpiled;
   try {
-    transpiled = ts13.transpileModule(wrappedSource, {
+    transpiled = ts14.transpileModule(wrappedSource, {
       compilerOptions: {
-        module: ts13.ModuleKind.ES2022,
-        target: ts13.ScriptTarget.ES2022
+        module: ts14.ModuleKind.ES2022,
+        target: ts14.ScriptTarget.ES2022
       },
       reportDiagnostics: false
     }).outputText;
@@ -17318,7 +17483,7 @@ ${transpiled}
     return null;
   const ext = extname6(abs).toLowerCase();
   if (!STYLE_PREPROCESSED_EXT.has(ext) || ext === ".css") {
-    return readFileSync17(abs, "utf8");
+    return readFileSync18(abs, "utf8");
   }
   try {
     const { compileStyleFileIfNeededSync: compileStyleFileIfNeededSync2 } = (init_stylePreprocessor(), __toCommonJS(exports_stylePreprocessor));
@@ -17357,8 +17522,8 @@ ${block}
   const opts = {};
   if (existsSync23(tsconfigPath)) {
     try {
-      const text = readFileSync17(tsconfigPath, "utf8");
-      const parsed = ts13.parseConfigFileTextToJson(tsconfigPath, text);
+      const text = readFileSync18(tsconfigPath, "utf8");
+      const parsed = ts14.parseConfigFileTextToJson(tsconfigPath, text);
       if (!parsed.error && parsed.config) {
         const cfg = parsed.config;
         const ang = cfg.angularCompilerOptions ?? {};
@@ -17391,8 +17556,8 @@ ${block}
   } catch (err) {
     return fail("unexpected-error", `import @angular/compiler: ${err}`);
   }
-  const tsSource = readFileSync17(componentFilePath, "utf8");
-  const sourceFile = ts13.createSourceFile(componentFilePath, tsSource, ts13.ScriptTarget.ES2022, true, ts13.ScriptKind.TS);
+  const tsSource = readFileSync18(componentFilePath, "utf8");
+  const sourceFile = ts14.createSourceFile(componentFilePath, tsSource, ts14.ScriptTarget.ES2022, true, ts14.ScriptKind.TS);
   const classNode = findClassDeclaration(sourceFile, className);
   if (!classNode) {
     return fail("class-not-found", `${className} in ${componentFilePath}`);
@@ -17441,7 +17606,7 @@ ${block}
     if (!existsSync23(tplAbs)) {
       return fail("template-resource-not-found", `Template file not found: ${tplAbs}`, { file: componentFilePath });
     }
-    templateText = readFileSync17(tplAbs, "utf8");
+    templateText = readFileSync18(tplAbs, "utf8");
     templatePath = tplAbs;
   } else {
     return fail("unsupported-decorator-args", "missing template/templateUrl");
@@ -17512,7 +17677,7 @@ ${block}
     viewQueries: advancedMetadata.viewQueries,
     host: advancedMetadata.host,
     lifecycle: {
-      usesOnChanges: classNode.members.some((m) => ts13.isMethodDeclaration(m) && m.name !== undefined && ts13.isIdentifier(m.name) && m.name.text === "ngOnChanges")
+      usesOnChanges: classNode.members.some((m) => ts14.isMethodDeclaration(m) && m.name !== undefined && ts14.isIdentifier(m.name) && m.name.text === "ngOnChanges")
     },
     inputs,
     outputs,
@@ -17568,15 +17733,15 @@ ${block}
     }
     const importGenerator = createHmrImportGenerator(namespaceMap);
     const tsFunctionDecl = translateStatement(sourceFile, callback, importGenerator);
-    const exportedDecl = ts13.factory.updateFunctionDeclaration(tsFunctionDecl, [
-      ts13.factory.createToken(ts13.SyntaxKind.ExportKeyword),
-      ts13.factory.createToken(ts13.SyntaxKind.DefaultKeyword)
+    const exportedDecl = ts14.factory.updateFunctionDeclaration(tsFunctionDecl, [
+      ts14.factory.createToken(ts14.SyntaxKind.ExportKeyword),
+      ts14.factory.createToken(ts14.SyntaxKind.DefaultKeyword)
     ], tsFunctionDecl.asteriskToken, tsFunctionDecl.name, tsFunctionDecl.typeParameters, tsFunctionDecl.parameters, tsFunctionDecl.type, tsFunctionDecl.body);
-    const printer = ts13.createPrinter({
-      newLine: ts13.NewLineKind.LineFeed,
+    const printer = ts14.createPrinter({
+      newLine: ts14.NewLineKind.LineFeed,
       removeComments: false
     });
-    const fnText = printer.printNode(ts13.EmitHint.Unspecified, exportedDecl, sourceFile);
+    const fnText = printer.printNode(ts14.EmitHint.Unspecified, exportedDecl, sourceFile);
     const provisionalMethodsBlock = buildFreshClassMethodsBlock(classNode, className) ?? "";
     const referencedNames = new Set;
     const identRe = /[A-Za-z_$][A-Za-z0-9_$]*/g;
@@ -17586,33 +17751,33 @@ ${block}
     }
     const sourceScopeNames = new Set;
     for (const stmt of sourceFile.statements) {
-      if (ts13.isImportDeclaration(stmt)) {
-        if (!ts13.isStringLiteral(stmt.moduleSpecifier))
+      if (ts14.isImportDeclaration(stmt)) {
+        if (!ts14.isStringLiteral(stmt.moduleSpecifier))
           continue;
         const clause = stmt.importClause;
         if (clause?.name)
           sourceScopeNames.add(clause.name.text);
-        if (clause?.namedBindings && ts13.isNamedImports(clause.namedBindings)) {
+        if (clause?.namedBindings && ts14.isNamedImports(clause.namedBindings)) {
           for (const el of clause.namedBindings.elements) {
             if (el.isTypeOnly)
               continue;
             sourceScopeNames.add(el.name.text);
           }
-        } else if (clause?.namedBindings && ts13.isNamespaceImport(clause.namedBindings)) {
+        } else if (clause?.namedBindings && ts14.isNamespaceImport(clause.namedBindings)) {
           sourceScopeNames.add(clause.namedBindings.name.text);
         }
         continue;
       }
-      if (ts13.isVariableStatement(stmt) || stmt.kind === ts13.SyntaxKind.VariableStatement) {
+      if (ts14.isVariableStatement(stmt) || stmt.kind === ts14.SyntaxKind.VariableStatement) {
         const varStmt = stmt;
         for (const decl of varStmt.declarationList.declarations) {
-          if (ts13.isIdentifier(decl.name)) {
+          if (ts14.isIdentifier(decl.name)) {
             sourceScopeNames.add(decl.name.text);
           }
         }
         continue;
       }
-      if (ts13.isFunctionDeclaration(stmt) || ts13.isClassDeclaration(stmt)) {
+      if (ts14.isFunctionDeclaration(stmt) || ts14.isClassDeclaration(stmt)) {
         if (stmt.name)
           sourceScopeNames.add(stmt.name.text);
       }
@@ -17623,7 +17788,7 @@ ${block}
     }
     const allImportedNames = new Set;
     for (const stmt of sourceFile.statements) {
-      if (!ts13.isImportDeclaration(stmt))
+      if (!ts14.isImportDeclaration(stmt))
         continue;
       const clause = stmt.importClause;
       if (!clause || clause.isTypeOnly)
@@ -17633,7 +17798,7 @@ ${block}
       const bindings = clause.namedBindings;
       if (!bindings)
         continue;
-      if (ts13.isNamespaceImport(bindings)) {
+      if (ts14.isNamespaceImport(bindings)) {
         allImportedNames.add(bindings.name.text);
       } else {
         for (const el of bindings.elements) {
@@ -17645,10 +17810,10 @@ ${block}
     }
     const depsToDestructure = [...sourceScopeNames].filter((n) => referencedNames.has(n) || allImportedNames.has(n));
     const tsSourceText = fnText;
-    const transpiled = ts13.transpileModule(tsSourceText, {
+    const transpiled = ts14.transpileModule(tsSourceText, {
       compilerOptions: {
-        module: ts13.ModuleKind.ES2022,
-        target: ts13.ScriptTarget.ES2022
+        module: ts14.ModuleKind.ES2022,
+        target: ts14.ScriptTarget.ES2022
       },
       fileName: componentFilePath,
       reportDiagnostics: false
@@ -18200,7 +18365,7 @@ __export(exports_compileEmber, {
 });
 import { existsSync as existsSync24 } from "fs";
 import { mkdir as mkdir6, rm as rm4 } from "fs/promises";
-import { basename as basename9, dirname as dirname16, extname as extname7, join as join28, resolve as resolve23 } from "path";
+import { basename as basename9, dirname as dirname16, extname as extname7, join as join29, resolve as resolve23 } from "path";
 var {build: bunBuild2, Transpiler: Transpiler4, write: write4, file: file3 } = globalThis.Bun;
 var cachedPreprocessor = null, getPreprocessor = async () => {
   if (cachedPreprocessor)
@@ -18319,7 +18484,7 @@ export const importSync = (specifier) => {
     build.onResolve({ filter: /^@(?:ember|glimmer|simple-dom)\// }, (args) => {
       if (standalonePackages.has(args.path))
         return;
-      const internal = join28(cwd, "node_modules/ember-source/dist/packages", args.path, "index.js");
+      const internal = join29(cwd, "node_modules/ember-source/dist/packages", args.path, "index.js");
       if (existsSync24(internal))
         return { path: internal };
       return;
@@ -18367,16 +18532,16 @@ export default PageComponent;
   }
   const transpiled = transpiler5.transformSync(preprocessed);
   const baseName = basename9(resolvedEntry).replace(/\.(gjs|gts|ts|js)$/, "");
-  const tmpDir = join28(compiledRoot, "_tmp");
-  const serverDir = join28(compiledRoot, "server");
-  const clientDir = join28(compiledRoot, "client");
+  const tmpDir = join29(compiledRoot, "_tmp");
+  const serverDir = join29(compiledRoot, "server");
+  const clientDir = join29(compiledRoot, "client");
   await Promise.all([
     mkdir6(tmpDir, { recursive: true }),
     mkdir6(serverDir, { recursive: true }),
     mkdir6(clientDir, { recursive: true })
   ]);
-  const tmpPagePath = resolve23(join28(tmpDir, `${baseName}.module.js`));
-  const tmpHarnessPath = resolve23(join28(tmpDir, `${baseName}.harness.js`));
+  const tmpPagePath = resolve23(join29(tmpDir, `${baseName}.module.js`));
+  const tmpHarnessPath = resolve23(join29(tmpDir, `${baseName}.harness.js`));
   await Promise.all([
     write4(tmpPagePath, transpiled),
     write4(tmpHarnessPath, generateServerHarness(tmpPagePath))
@@ -18384,7 +18549,7 @@ export default PageComponent;
   const stagedSourceMap = new Map([
     [tmpPagePath, resolvedEntry]
   ]);
-  const serverPath = join28(serverDir, `${baseName}.js`);
+  const serverPath = join29(serverDir, `${baseName}.js`);
   const buildResult = await bunBuild2({
     entrypoints: [tmpHarnessPath],
     format: "esm",
@@ -18401,7 +18566,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 = join28(clientDir, `${baseName}.js`);
+  const clientPath = join29(clientDir, `${baseName}.js`);
   await write4(clientPath, transpiled);
   return { clientPath, serverPath };
 }, compileEmber = async (entries, emberDir, cwd = process.cwd(), _hmr = false) => {
@@ -18429,7 +18594,7 @@ export default PageComponent;
     preprocessed = rewriteTemplateEvalToScope(result.code);
   }
   return transpiler5.transformSync(preprocessed);
-}, clearEmberCompilerCache = () => {}, getEmberCompiledRoot = (_emberDir) => getFrameworkGeneratedDir("ember"), getEmberServerCompiledDir = (emberDir) => join28(getEmberCompiledRoot(emberDir), "server"), getEmberClientCompiledDir = (emberDir) => join28(getEmberCompiledRoot(emberDir), "client");
+}, clearEmberCompilerCache = () => {}, getEmberCompiledRoot = (_emberDir) => getFrameworkGeneratedDir("ember"), getEmberServerCompiledDir = (emberDir) => join29(getEmberCompiledRoot(emberDir), "server"), getEmberClientCompiledDir = (emberDir) => join29(getEmberCompiledRoot(emberDir), "client");
 var init_compileEmber = __esm(() => {
   init_generatedDir();
   transpiler5 = new Transpiler4({
@@ -18451,7 +18616,7 @@ __export(exports_buildReactVendor, {
   buildReactVendor: () => buildReactVendor
 });
 import { existsSync as existsSync25, mkdirSync as mkdirSync8 } from "fs";
-import { join as join29, resolve as resolve24 } from "path";
+import { join as join30, resolve as resolve24 } from "path";
 import { rm as rm5 } from "fs/promises";
 var {build: bunBuild3 } = globalThis.Bun;
 var resolveJsxDevRuntimeCompatPath = () => {
@@ -18505,14 +18670,14 @@ var resolveJsxDevRuntimeCompatPath = () => {
 `)}
 `;
 }, buildReactVendor = async (buildDir) => {
-  const vendorDir = join29(buildDir, "react", "vendor");
+  const vendorDir = join30(buildDir, "react", "vendor");
   mkdirSync8(vendorDir, { recursive: true });
-  const tmpDir = join29(buildDir, "_vendor_tmp");
+  const tmpDir = join30(buildDir, "_vendor_tmp");
   mkdirSync8(tmpDir, { recursive: true });
   const specifiers = resolveVendorSpecifiers();
   const entrypoints = await Promise.all(specifiers.map(async (specifier) => {
     const safeName = toSafeFileName(specifier);
-    const entryPath = join29(tmpDir, `${safeName}.ts`);
+    const entryPath = join30(tmpDir, `${safeName}.ts`);
     const source = await generateEntrySource(specifier);
     await Bun.write(entryPath, source);
     return entryPath;
@@ -18577,7 +18742,7 @@ __export(exports_buildAngularVendor, {
   buildAngularServerVendor: () => buildAngularServerVendor
 });
 import { mkdirSync as mkdirSync9 } from "fs";
-import { join as join30 } from "path";
+import { join as join31 } from "path";
 import { rm as rm6 } from "fs/promises";
 var {build: bunBuild4, Glob: Glob7 } = globalThis.Bun;
 var REQUIRED_ANGULAR_SPECIFIERS_BASE, requiredAngularSpecifiers = (jitMode) => jitMode ? [...REQUIRED_ANGULAR_SPECIFIERS_BASE, "@angular/compiler"] : REQUIRED_ANGULAR_SPECIFIERS_BASE, SERVER_ONLY_ANGULAR_SPECIFIERS, BUILD_ONLY_ANGULAR_SPECIFIER_PREFIXES, isBuildOnlyAngularSpecifier = (spec) => BUILD_ONLY_ANGULAR_SPECIFIER_PREFIXES.some((prefix) => spec === prefix || spec.startsWith(`${prefix}/`)), SCAN_SKIP_DIRS, isResolvable2 = (specifier) => {
@@ -18614,7 +18779,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: readFileSync18 } = await import("fs");
+  const { readFileSync: readFileSync19 } = await import("fs");
   const transpiler6 = new Bun.Transpiler({ loader: "js" });
   const visited = new Set;
   const frontier = [];
@@ -18635,7 +18800,7 @@ var REQUIRED_ANGULAR_SPECIFIERS_BASE, requiredAngularSpecifiers = (jitMode) => j
       }
       let content;
       try {
-        content = readFileSync18(resolved, "utf-8");
+        content = readFileSync19(resolved, "utf-8");
       } catch {
         continue;
       }
@@ -18674,14 +18839,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 = join30(buildDir, "angular", "vendor");
+  const vendorDir = join31(buildDir, "angular", "vendor");
   mkdirSync9(vendorDir, { recursive: true });
-  const tmpDir = join30(buildDir, "_angular_vendor_tmp");
+  const tmpDir = join31(buildDir, "_angular_vendor_tmp");
   mkdirSync9(tmpDir, { recursive: true });
   const specifiers = await resolveAngularSpecifiers(directories, linkerJitMode);
   const entrypoints = await Promise.all(specifiers.map(async (specifier) => {
     const safeName = toSafeFileName2(specifier);
-    const entryPath = join30(tmpDir, `${safeName}.ts`);
+    const entryPath = join31(tmpDir, `${safeName}.ts`);
     await Bun.write(entryPath, await generateVendorEntrySource(specifier));
     return entryPath;
   }));
@@ -18712,9 +18877,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 = join30(buildDir, "angular", "vendor", "server");
+  const vendorDir = join31(buildDir, "angular", "vendor", "server");
   mkdirSync9(vendorDir, { recursive: true });
-  const tmpDir = join30(buildDir, "_angular_server_vendor_tmp");
+  const tmpDir = join31(buildDir, "_angular_server_vendor_tmp");
   mkdirSync9(tmpDir, { recursive: true });
   const browserSpecs = await resolveAngularSpecifiers(directories, linkerJitMode);
   const allSpecs = new Set(browserSpecs);
@@ -18725,7 +18890,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 = join30(tmpDir, `${safeName}.ts`);
+    const entryPath = join31(tmpDir, `${safeName}.ts`);
     await Bun.write(entryPath, await generateVendorEntrySource(specifier));
     return entryPath;
   }));
@@ -18747,9 +18912,9 @@ var REQUIRED_ANGULAR_SPECIFIERS_BASE, requiredAngularSpecifiers = (jitMode) => j
   return specifiers;
 }, computeAngularServerVendorPaths = (buildDir, specifiers) => {
   const paths = {};
-  const vendorDir = join30(buildDir, "angular", "vendor", "server");
+  const vendorDir = join31(buildDir, "angular", "vendor", "server");
   for (const specifier of specifiers) {
-    paths[specifier] = join30(vendorDir, `${toSafeFileName2(specifier)}.js`);
+    paths[specifier] = join31(vendorDir, `${toSafeFileName2(specifier)}.js`);
   }
   return paths;
 }, computeAngularServerVendorPathsAsync = async (buildDir, directories = [], linkerJitMode = true) => {
@@ -18805,17 +18970,17 @@ __export(exports_buildVueVendor, {
   buildVueVendor: () => buildVueVendor
 });
 import { mkdirSync as mkdirSync10 } from "fs";
-import { join as join31 } from "path";
+import { join as join32 } 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 = join31(buildDir, "vue", "vendor");
+  const vendorDir = join32(buildDir, "vue", "vendor");
   mkdirSync10(vendorDir, { recursive: true });
-  const tmpDir = join31(buildDir, "_vue_vendor_tmp");
+  const tmpDir = join32(buildDir, "_vue_vendor_tmp");
   mkdirSync10(tmpDir, { recursive: true });
   const entrypoints = await Promise.all(vueSpecifiers.map(async (specifier) => {
     const safeName = toSafeFileName3(specifier);
-    const entryPath = join31(tmpDir, `${safeName}.ts`);
+    const entryPath = join32(tmpDir, `${safeName}.ts`);
     await Bun.write(entryPath, `export * from '${specifier}';
 `);
     return entryPath;
@@ -18840,11 +19005,11 @@ var vueSpecifiers, toSafeFileName3 = (specifier) => specifier.replace(/\//g, "_"
     console.warn("\u26A0\uFE0F Vue vendor build had errors:", result.logs);
     return;
   }
-  const { readFileSync: readFileSync18, writeFileSync: writeFileSync8, readdirSync: readdirSync4 } = await import("fs");
-  const files = readdirSync4(vendorDir).filter((f2) => f2.endsWith(".js"));
+  const { readFileSync: readFileSync19, writeFileSync: writeFileSync8, readdirSync: readdirSync5 } = await import("fs");
+  const files = readdirSync5(vendorDir).filter((f2) => f2.endsWith(".js"));
   for (const file4 of files) {
-    const filePath = join31(vendorDir, file4);
-    const content = readFileSync18(filePath, "utf-8");
+    const filePath = join32(vendorDir, file4);
+    const content = readFileSync19(filePath, "utf-8");
     if (!content.includes("__VUE_HMR_RUNTIME__"))
       continue;
     const patched = content.replace(/getGlobalThis\(\)\.__VUE_HMR_RUNTIME__\s*=\s*\{/, "getGlobalThis().__VUE_HMR_RUNTIME__ = getGlobalThis().__VUE_HMR_RUNTIME__ || {");
@@ -18870,7 +19035,7 @@ __export(exports_buildSvelteVendor, {
   buildSvelteVendor: () => buildSvelteVendor
 });
 import { mkdirSync as mkdirSync11 } from "fs";
-import { join as join32 } from "path";
+import { join as join33 } from "path";
 import { rm as rm8 } from "fs/promises";
 var {build: bunBuild6 } = globalThis.Bun;
 var svelteSpecifiers, isResolvable3 = (specifier) => {
@@ -18884,13 +19049,13 @@ var svelteSpecifiers, isResolvable3 = (specifier) => {
   const specifiers = resolveVendorSpecifiers2();
   if (specifiers.length === 0)
     return;
-  const vendorDir = join32(buildDir, "svelte", "vendor");
+  const vendorDir = join33(buildDir, "svelte", "vendor");
   mkdirSync11(vendorDir, { recursive: true });
-  const tmpDir = join32(buildDir, "_svelte_vendor_tmp");
+  const tmpDir = join33(buildDir, "_svelte_vendor_tmp");
   mkdirSync11(tmpDir, { recursive: true });
   const entrypoints = await Promise.all(specifiers.map(async (specifier) => {
     const safeName = toSafeFileName4(specifier);
-    const entryPath = join32(tmpDir, `${safeName}.ts`);
+    const entryPath = join33(tmpDir, `${safeName}.ts`);
     await Bun.write(entryPath, `export * from '${specifier}';
 `);
     return entryPath;
@@ -18940,7 +19105,7 @@ __export(exports_rewriteImportsPlugin, {
   buildWithImportRewrite: () => buildWithImportRewrite
 });
 import { readdir as readdir3 } from "fs/promises";
-import { join as join33 } from "path";
+import { join as join34 } from "path";
 var escapeRegex2 = (str) => str.replace(/[.*+?^${}()|[\]\\]/g, "\\$&"), jsRewriteImports = (content, replacements) => {
   let result = content;
   for (const [specifier, webPath] of replacements) {
@@ -19069,7 +19234,7 @@ ${content}`;
       const entries = await readdir3(dir);
       for (const entry of entries) {
         if (entry.endsWith(".js"))
-          allFiles.push(join33(dir, entry));
+          allFiles.push(join34(dir, entry));
       }
     } catch {}
   }
@@ -19113,12 +19278,12 @@ import {
   cpSync,
   existsSync as existsSync26,
   mkdirSync as mkdirSync12,
-  readFileSync as readFileSync18,
+  readFileSync as readFileSync19,
   rmSync as rmSync2,
   statSync as statSync3,
   writeFileSync as writeFileSync8
 } from "fs";
-import { basename as basename10, dirname as dirname17, extname as extname8, join as join34, relative as relative13, resolve as resolve25 } from "path";
+import { basename as basename10, dirname as dirname17, extname as extname8, join as join35, relative as relative13, resolve as resolve25 } from "path";
 import { cwd, env as env2, exit } from "process";
 var {build: bunBuild7, Glob: Glob8 } = globalThis.Bun;
 var isDev, isBuildTraceEnabled = () => {
@@ -19196,8 +19361,8 @@ var isDev, isBuildTraceEnabled = () => {
   mkdirSync12(htmxDestDir, { recursive: true });
   const glob = new Glob8("htmx*.min.js");
   for (const relPath of glob.scanSync({ cwd: htmxDir })) {
-    const src = join34(htmxDir, relPath);
-    const dest = join34(htmxDestDir, "htmx.min.js");
+    const src = join35(htmxDir, relPath);
+    const dest = join35(htmxDestDir, "htmx.min.js");
     copyFileSync2(src, dest);
     return;
   }
@@ -19225,7 +19390,7 @@ var isDev, isBuildTraceEnabled = () => {
     globalThis.__absoluteVersion = pkg.version;
   };
   await resolveCandidate(candidates);
-}, SKIP_DIRS4, addWorkerPathIfExists = (file4, relPath, workerPaths) => {
+}, SKIP_DIRS5, addWorkerPathIfExists = (file4, relPath, workerPaths) => {
   const absPath = resolve25(file4, "..", relPath);
   try {
     statSync3(absPath);
@@ -19241,7 +19406,7 @@ var isDev, isBuildTraceEnabled = () => {
     addWorkerPathIfExists(file4, relPath, workerPaths);
   }
 }, collectWorkerPathsFromFile = (file4, patterns, workerPaths) => {
-  const content = readFileSync18(file4, "utf-8");
+  const content = readFileSync19(file4, "utf-8");
   for (const pattern of patterns) {
     collectWorkerPathsFromContent(content, pattern, file4, workerPaths);
   }
@@ -19250,7 +19415,7 @@ var isDev, isBuildTraceEnabled = () => {
   for await (const file4 of glob.scan({ absolute: true, cwd: dir })) {
     const relToDir = file4.slice(dir.length + 1);
     const [firstSegment] = relToDir.split("/");
-    if (firstSegment && SKIP_DIRS4.has(firstSegment))
+    if (firstSegment && SKIP_DIRS5.has(firstSegment))
       continue;
     collectWorkerPathsFromFile(file4, patterns, workerPaths);
   }
@@ -19272,7 +19437,7 @@ var isDev, isBuildTraceEnabled = () => {
   vuePagesPath
 }) => {
   const { readdirSync: readDir } = await import("fs");
-  const devIndexDir = join34(buildPath, "_src_indexes");
+  const devIndexDir = join35(buildPath, "_src_indexes");
   mkdirSync12(devIndexDir, { recursive: true });
   if (reactIndexesPath && reactPagesPath) {
     copyReactDevIndexes(reactIndexesPath, reactPagesPath, devIndexDir, readDir);
@@ -19290,35 +19455,35 @@ var isDev, isBuildTraceEnabled = () => {
   const indexFiles = readDir(reactIndexesPath).filter((file4) => file4.endsWith(".tsx"));
   const pagesRel = relative13(process.cwd(), resolve25(reactPagesPath)).replace(/\\/g, "/");
   for (const file4 of indexFiles) {
-    let content = readFileSync18(join34(reactIndexesPath, file4), "utf-8");
+    let content = readFileSync19(join35(reactIndexesPath, file4), "utf-8");
     content = content.replace(/from\s*['"]([^'"]*\/pages\/([^'"]+))['"]/g, (_match, _fullPath, componentName) => `from '/@src/${pagesRel}/${componentName}'`);
-    writeFileSync8(join34(devIndexDir, file4), content);
+    writeFileSync8(join35(devIndexDir, file4), content);
   }
 }, copySvelteDevIndexes = (svelteDir, sveltePagesPath, svelteEntries, devIndexDir) => {
-  const svelteIndexDir = join34(getFrameworkGeneratedDir("svelte"), "indexes");
+  const svelteIndexDir = join35(getFrameworkGeneratedDir("svelte"), "indexes");
   const sveltePageEntries = svelteEntries.filter((file4) => resolve25(file4).startsWith(resolve25(sveltePagesPath)));
   for (const entry of sveltePageEntries) {
     const name = basename10(entry).replace(/\.svelte(\.(ts|js))?$/, "");
-    const indexFile = join34(svelteIndexDir, "pages", `${name}.js`);
+    const indexFile = join35(svelteIndexDir, "pages", `${name}.js`);
     if (!existsSync26(indexFile))
       continue;
-    let content = readFileSync18(indexFile, "utf-8");
+    let content = readFileSync19(indexFile, "utf-8");
     const srcRel = relative13(process.cwd(), resolve25(entry)).replace(/\\/g, "/");
     content = content.replace(/import\s+Component\s+from\s+['"]([^'"]+)['"]/, `import Component from "/@src/${srcRel}"`);
-    writeFileSync8(join34(devIndexDir, `${name}.svelte.js`), content);
+    writeFileSync8(join35(devIndexDir, `${name}.svelte.js`), content);
   }
 }, copyVueDevIndexes = (vueDir, vuePagesPath, vueEntries, devIndexDir) => {
-  const vueIndexDir = join34(getFrameworkGeneratedDir("vue"), "indexes");
+  const vueIndexDir = join35(getFrameworkGeneratedDir("vue"), "indexes");
   const vuePageEntries = vueEntries.filter((file4) => resolve25(file4).startsWith(resolve25(vuePagesPath)));
   for (const entry of vuePageEntries) {
     const name = basename10(entry, ".vue");
-    const indexFile = join34(vueIndexDir, `${name}.js`);
+    const indexFile = join35(vueIndexDir, `${name}.js`);
     if (!existsSync26(indexFile))
       continue;
-    let content = readFileSync18(indexFile, "utf-8");
+    let content = readFileSync19(indexFile, "utf-8");
     const srcRel = relative13(process.cwd(), resolve25(entry)).replace(/\\/g, "/");
     content = content.replace(/import\s+Comp(?:\s*,\s*\*\s+as\s+\w+)?\s+from\s+['"]([^'"]+)['"]/, (match) => match.replace(/from\s+['"][^'"]+['"]/, `from "/@src/${srcRel}"`));
-    writeFileSync8(join34(devIndexDir, `${name}.vue.js`), content);
+    writeFileSync8(join35(devIndexDir, `${name}.vue.js`), content);
   }
 }, resolveVueRuntimeId = (content, firstUseName, outputPath, projectRoot) => {
   const varIdx = content.indexOf(`var ${firstUseName} =`);
@@ -19366,7 +19531,7 @@ var isDev, isBuildTraceEnabled = () => {
   }
   return result;
 }, VUE_HMR_RUNTIME, injectVueComposableTracking = (outputPath, projectRoot) => {
-  let content = readFileSync18(outputPath, "utf-8");
+  let content = readFileSync19(outputPath, "utf-8");
   const usePattern = /^var\s+(use[A-Z]\w*)\s*=/gm;
   const useNames = [];
   let match;
@@ -19416,7 +19581,7 @@ ${content.slice(firstUseIdx)}`;
 }, rewriteUrlReferences = (outputPaths, urlFileMap) => {
   const urlPattern = /new\s+URL\(\s*["'](\.\.?\/[^"']+)["']\s*,\s*import\.meta\.url\s*\)/g;
   for (const outputPath of outputPaths) {
-    let content = readFileSync18(outputPath, "utf-8");
+    let content = readFileSync19(outputPath, "utf-8");
     let changed = false;
     content = content.replace(urlPattern, (_match, relPath) => {
       const targetName = basename10(relPath);
@@ -19541,10 +19706,10 @@ ${content.slice(firstUseIdx)}`;
       restoreTracePhase();
       return;
     }
-    const traceDir = join34(buildPath2, ".absolute-trace");
+    const traceDir = join35(buildPath2, ".absolute-trace");
     const timestamp = new Date().toISOString().replace(/[:.]/g, "-");
     mkdirSync12(traceDir, { recursive: true });
-    writeFileSync8(join34(traceDir, `build-trace-${timestamp}.json`), JSON.stringify({
+    writeFileSync8(join35(traceDir, `build-trace-${timestamp}.json`), JSON.stringify({
       events: traceEvents,
       frameworks: traceFrameworkNames,
       generatedAt: new Date().toISOString(),
@@ -19575,15 +19740,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 && join34(getFrameworkGeneratedDir("react"), "indexes");
-  const reactPagesPath = reactDir && join34(reactDir, "pages");
-  const htmlPagesPath = htmlDir && join34(htmlDir, "pages");
-  const htmlScriptsPath = htmlDir && join34(htmlDir, "scripts");
-  const sveltePagesPath = svelteDir && join34(svelteDir, "pages");
-  const vuePagesPath = vueDir && join34(vueDir, "pages");
-  const htmxPagesPath = htmxDir && join34(htmxDir, "pages");
-  const angularPagesPath = angularDir && join34(angularDir, "pages");
-  const emberPagesPath = emberDir && join34(emberDir, "pages");
+  const reactIndexesPath = reactDir && join35(getFrameworkGeneratedDir("react"), "indexes");
+  const reactPagesPath = reactDir && join35(reactDir, "pages");
+  const htmlPagesPath = htmlDir && join35(htmlDir, "pages");
+  const htmlScriptsPath = htmlDir && join35(htmlDir, "scripts");
+  const sveltePagesPath = svelteDir && join35(svelteDir, "pages");
+  const vuePagesPath = vueDir && join35(vueDir, "pages");
+  const htmxPagesPath = htmxDir && join35(htmxDir, "pages");
+  const angularPagesPath = angularDir && join35(angularDir, "pages");
+  const emberPagesPath = emberDir && join35(emberDir, "pages");
   const frontends = [
     reactDir,
     htmlDir,
@@ -19642,8 +19807,8 @@ ${content.slice(firstUseIdx)}`;
     const [firstEntry] = serverDirMap;
     if (!firstEntry)
       throw new Error("Expected at least one server directory entry");
-    serverRoot = join34(firstEntry.dir, firstEntry.subdir);
-    serverOutDir = join34(buildPath, basename10(firstEntry.dir));
+    serverRoot = join35(firstEntry.dir, firstEntry.subdir);
+    serverOutDir = join35(buildPath, basename10(firstEntry.dir));
   } else if (serverDirMap.length > 1) {
     serverRoot = commonAncestor(serverDirMap.map((entry) => entry.dir), projectRoot);
     serverOutDir = buildPath;
@@ -19671,7 +19836,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, join34(buildPath, "assets"), {
+    await tracePhase("assets/copy", () => cpSync(assetsPath, join35(buildPath, "assets"), {
       force: true,
       recursive: true
     }));
@@ -19781,11 +19946,11 @@ ${content.slice(firstUseIdx)}`;
     }
   }
   if (htmlDefaults.error || htmlDefaults.notFound || htmlDefaults.loading || Object.keys(htmlPages).length > 0) {
-    const htmlConventionsOutDir = join34(buildPath, "conventions", "html");
+    const htmlConventionsOutDir = join35(buildPath, "conventions", "html");
     mkdirSync12(htmlConventionsOutDir, { recursive: true });
     const htmlPathRemap = new Map;
     for (const sourcePath of htmlConventionSources) {
-      const dest = join34(htmlConventionsOutDir, basename10(sourcePath));
+      const dest = join35(htmlConventionsOutDir, basename10(sourcePath));
       cpSync(sourcePath, dest, { force: true });
       htmlPathRemap.set(sourcePath, dest);
     }
@@ -19828,7 +19993,7 @@ ${content.slice(firstUseIdx)}`;
   const reactEntries = isIncremental && reactIndexesPath && reactPagesPath ? filterToIncrementalEntries(allReactEntries, (entry) => {
     if (entry.startsWith(resolve25(reactIndexesPath))) {
       const pageName = basename10(entry, ".tsx");
-      return join34(reactPagesPath, `${pageName}.tsx`);
+      return join35(reactPagesPath, `${pageName}.tsx`);
     }
     return null;
   }) : allReactEntries;
@@ -19851,6 +20016,20 @@ ${content.slice(firstUseIdx)}`;
   const shouldCompileSvelte = svelteDir && svelteEntries.length > 0;
   const shouldCompileVue = vueDir && vueEntries.length > 0;
   const shouldCompileAngular = angularDir && angularEntries.length > 0;
+  const ssrOnlyVueEntries = shouldCompileVue ? await tracePhase("scan/vue-ssr-only", async () => {
+    const { scanVueSsrOnlyPages: scanVueSsrOnlyPages2 } = await Promise.resolve().then(() => (init_scanVueSsrOnlyPages(), exports_scanVueSsrOnlyPages));
+    const ssrOnlyPageNames = scanVueSsrOnlyPages2(projectRoot);
+    if (ssrOnlyPageNames.size === 0)
+      return new Set;
+    const resolved = new Set;
+    for (const entry of vueEntries) {
+      const name = basename10(entry, ".vue");
+      if (ssrOnlyPageNames.has(name)) {
+        resolved.add(resolve25(entry));
+      }
+    }
+    return resolved;
+  }) : new Set;
   const shouldCompileEmber = emberDir && emberEntries.length > 0;
   const emptyStringArray = [];
   const islandBuildInfo = islandRegistryPath ? await tracePhase("islands/registry", () => loadIslandRegistryBuildInfo(islandRegistryPath)) : null;
@@ -19913,7 +20092,7 @@ ${content.slice(firstUseIdx)}`;
       svelteIndexPaths: [...emptyStringArray],
       svelteServerPaths: [...emptyStringArray]
     },
-    shouldCompileVue ? tracePhase("compile/vue", () => Promise.resolve().then(() => (init_compileVue(), exports_compileVue)).then((mod) => mod.compileVue(vueEntries, vueDir, hmr, styleTransformConfig))) : {
+    shouldCompileVue ? tracePhase("compile/vue", () => Promise.resolve().then(() => (init_compileVue(), exports_compileVue)).then((mod) => mod.compileVue(vueEntries, vueDir, hmr, styleTransformConfig, ssrOnlyVueEntries))) : {
       vueClientPaths: [...emptyStringArray],
       vueCssPaths: [...emptyStringArray],
       vueIndexPaths: [...emptyStringArray],
@@ -19931,14 +20110,14 @@ ${content.slice(firstUseIdx)}`;
         try {
           const { primeComponentFingerprint: primeComponentFingerprint2 } = await Promise.resolve().then(() => (init_fastHmrCompiler(), exports_fastHmrCompiler));
           const { readdir: readdir4 } = await import("fs/promises");
-          const { join: join35 } = await import("path");
+          const { join: join36 } = await import("path");
           const walk = async (dir) => {
             const entries = await readdir4(dir, {
               withFileTypes: true
             });
             const out = [];
             for (const entry of entries) {
-              const full = join35(dir, entry.name);
+              const full = join36(dir, entry.name);
               if (entry.isDirectory()) {
                 out.push(...await walk(full));
               } else if (entry.isFile() && entry.name.endsWith(".ts") && !entry.name.endsWith(".d.ts")) {
@@ -20003,7 +20182,7 @@ ${content.slice(firstUseIdx)}`;
     const compileReactConventions = async () => {
       if (reactConventionSources.length === 0)
         return emptyStringArray;
-      const destDir = join34(buildPath, "conventions", "react");
+      const destDir = join35(buildPath, "conventions", "react");
       rmSync2(destDir, { force: true, recursive: true });
       mkdirSync12(destDir, { recursive: true });
       const destPaths = [];
@@ -20047,7 +20226,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 = join34(buildPath, "conventions", framework);
+      const destDir = join35(buildPath, "conventions", framework);
       rmSync2(destDir, { force: true, recursive: true });
       mkdirSync12(destDir, { recursive: true });
       const destPaths = [];
@@ -20121,7 +20300,7 @@ ${content.slice(firstUseIdx)}`;
     }
   })) : {
     entries: [],
-    generatedRoot: join34(buildPath, "_island_entries")
+    generatedRoot: join35(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) {
@@ -20157,7 +20336,7 @@ ${content.slice(firstUseIdx)}`;
     return {};
   }
   if (hmr && reactIndexesPath && reactClientEntryPoints.length > 0) {
-    const refreshEntry = join34(reactIndexesPath, "_refresh.tsx");
+    const refreshEntry = join35(reactIndexesPath, "_refresh.tsx");
     if (!reactClientEntryPoints.includes(refreshEntry))
       reactClientEntryPoints.push(refreshEntry);
   }
@@ -20259,19 +20438,19 @@ ${content.slice(firstUseIdx)}`;
     throw: false
   }, resolveBunBuildOverride(bunBuildConfig, "reactClient")) : undefined;
   if (reactDir && reactClientEntryPoints.length > 0) {
-    rmSync2(join34(buildPath, "react", "generated", "indexes"), {
+    rmSync2(join35(buildPath, "react", "generated", "indexes"), {
       force: true,
       recursive: true
     });
   }
   if (angularDir && angularClientPaths.length > 0) {
-    rmSync2(join34(buildPath, "angular", "indexes"), {
+    rmSync2(join35(buildPath, "angular", "indexes"), {
       force: true,
       recursive: true
     });
   }
   if (islandClientEntryPoints.length > 0) {
-    rmSync2(join34(buildPath, "islands"), {
+    rmSync2(join35(buildPath, "islands"), {
       force: true,
       recursive: true
     });
@@ -20360,7 +20539,7 @@ ${content.slice(firstUseIdx)}`;
     globalCssEntries.length > 0 ? tracePhase("bun/global-css", () => bunBuild7(mergeBunBuildConfig({
       entrypoints: globalCssEntries,
       naming: `[dir]/[name].[hash].[ext]`,
-      outdir: stylesDir ? join34(buildPath, basename10(stylesDir)) : buildPath,
+      outdir: stylesDir ? join35(buildPath, basename10(stylesDir)) : buildPath,
       plugins: [stylePreprocessorPlugin2],
       root: stylesDir || clientRoot,
       target: "browser",
@@ -20369,7 +20548,7 @@ ${content.slice(firstUseIdx)}`;
     vueCssPaths.length > 0 ? tracePhase("bun/vue-css", () => bunBuild7(mergeBunBuildConfig({
       entrypoints: vueCssPaths,
       naming: `[name].[hash].[ext]`,
-      outdir: join34(buildPath, assetsPath ? basename10(assetsPath) : "assets", "css"),
+      outdir: join35(buildPath, assetsPath ? basename10(assetsPath) : "assets", "css"),
       target: "browser",
       throw: false
     }, resolveBunBuildOverride(bunBuildConfig, "vueCss")))) : undefined
@@ -20529,7 +20708,7 @@ ${content.slice(firstUseIdx)}`;
   const injectHMRIntoHTMLFile = (filePath, framework) => {
     if (!hmrClientBundle)
       return;
-    let html = readFileSync18(filePath, "utf-8");
+    let html = readFileSync19(filePath, "utf-8");
     if (html.includes("data-hmr-client"))
       return;
     const tag = `<script>window.__HMR_FRAMEWORK__="${framework}";</script><script data-hmr-client>${hmrClientBundle}</script>`;
@@ -20540,7 +20719,7 @@ ${content.slice(firstUseIdx)}`;
   const processHtmlPages = async () => {
     if (!(htmlDir && htmlPagesPath))
       return;
-    const outputHtmlPages = isSingle ? join34(buildPath, "pages") : join34(buildPath, basename10(htmlDir), "pages");
+    const outputHtmlPages = isSingle ? join35(buildPath, "pages") : join35(buildPath, basename10(htmlDir), "pages");
     mkdirSync12(outputHtmlPages, { recursive: true });
     cpSync(htmlPagesPath, outputHtmlPages, {
       force: true,
@@ -20565,14 +20744,14 @@ ${content.slice(firstUseIdx)}`;
   const processHtmxPages = async () => {
     if (!(htmxDir && htmxPagesPath))
       return;
-    const outputHtmxPages = isSingle ? join34(buildPath, "pages") : join34(buildPath, basename10(htmxDir), "pages");
+    const outputHtmxPages = isSingle ? join35(buildPath, "pages") : join35(buildPath, basename10(htmxDir), "pages");
     mkdirSync12(outputHtmxPages, { recursive: true });
     cpSync(htmxPagesPath, outputHtmxPages, {
       force: true,
       recursive: true
     });
     if (shouldCopyHtmx) {
-      const htmxDestDir = isSingle ? buildPath : join34(buildPath, basename10(htmxDir));
+      const htmxDestDir = isSingle ? buildPath : join35(buildPath, basename10(htmxDir));
       copyHtmxVendor(htmxDir, htmxDestDir);
     }
     if (shouldUpdateHtmxAssetPaths) {
@@ -20637,9 +20816,9 @@ ${content.slice(firstUseIdx)}`;
     writeBuildTrace(buildPath);
     return { conventions: conventionsMap, manifest };
   }
-  writeFileSync8(join34(buildPath, "manifest.json"), JSON.stringify(manifest, null, "\t"));
+  writeFileSync8(join35(buildPath, "manifest.json"), JSON.stringify(manifest, null, "\t"));
   if (Object.keys(conventionsMap).length > 0) {
-    writeFileSync8(join34(buildPath, "conventions.json"), JSON.stringify(conventionsMap, null, "\t"));
+    writeFileSync8(join35(buildPath, "conventions.json"), JSON.stringify(conventionsMap, null, "\t"));
   }
   writeBuildTrace(buildPath);
   if (mode === "production") {
@@ -20702,7 +20881,7 @@ var init_build = __esm(() => {
   init_logger();
   init_validateSafePath();
   isDev = env2.NODE_ENV === "development";
-  SKIP_DIRS4 = new Set([
+  SKIP_DIRS5 = new Set([
     "build",
     "node_modules",
     ".absolutejs",
@@ -20761,7 +20940,7 @@ var init_build = __esm(() => {
 
 // src/build/buildEmberVendor.ts
 import { mkdirSync as mkdirSync13, existsSync as existsSync27 } from "fs";
-import { join as join35 } from "path";
+import { join as join36 } 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
@@ -20813,7 +20992,7 @@ export const importSync = (specifier) => {
   if (standaloneSpecifiers.has(specifier)) {
     return { resolveTo: specifier, specifier };
   }
-  const emberInternalPath = join35(cwd2, "node_modules/ember-source/dist/packages", specifier, "index.js");
+  const emberInternalPath = join36(cwd2, "node_modules/ember-source/dist/packages", specifier, "index.js");
   if (!existsSync27(emberInternalPath)) {
     throw new Error(`Ember vendor build: cannot find ${specifier} at ${emberInternalPath}. ` + `Is ember-source installed and at least 6.12?`);
   }
@@ -20845,7 +21024,7 @@ export const importSync = (specifier) => {
       if (standalonePackages.has(args.path)) {
         return;
       }
-      const internal = join35(cwd2, "node_modules/ember-source/dist/packages", args.path, "index.js");
+      const internal = join36(cwd2, "node_modules/ember-source/dist/packages", args.path, "index.js");
       if (existsSync27(internal)) {
         return { path: internal };
       }
@@ -20853,16 +21032,16 @@ export const importSync = (specifier) => {
     });
   }
 }), buildEmberVendor = async (buildDir, cwd2 = process.cwd()) => {
-  const vendorDir = join35(buildDir, "ember", "vendor");
+  const vendorDir = join36(buildDir, "ember", "vendor");
   mkdirSync13(vendorDir, { recursive: true });
-  const tmpDir = join35(buildDir, "_ember_vendor_tmp");
+  const tmpDir = join36(buildDir, "_ember_vendor_tmp");
   mkdirSync13(tmpDir, { recursive: true });
-  const macrosShimPath = join35(tmpDir, "embroider_macros_shim.js");
+  const macrosShimPath = join36(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 = join35(tmpDir, `${safeName}.js`);
+    const entryPath = join36(tmpDir, `${safeName}.js`);
     const source = resolution.specifier === "@embroider/macros" ? `export * from ${JSON.stringify(macrosShimPath)};
 ` : generateVendorEntrySource2(resolution);
     await Bun.write(entryPath, source);
@@ -20915,7 +21094,7 @@ __export(exports_dependencyGraph, {
   buildInitialDependencyGraph: () => buildInitialDependencyGraph,
   addFileToGraph: () => addFileToGraph
 });
-import { existsSync as existsSync28, readFileSync as readFileSync19 } from "fs";
+import { existsSync as existsSync28, readFileSync as readFileSync20 } from "fs";
 var {Glob: Glob9 } = globalThis.Bun;
 import { resolve as resolve26 } from "path";
 var emptyDependencyGraph, tsTranspiler, jsTranspiler, loaderForFile = (filePath) => {
@@ -21086,15 +21265,15 @@ var emptyDependencyGraph, tsTranspiler, jsTranspiler, loaderForFile = (filePath)
   const lowerPath = filePath.toLowerCase();
   const isSvelteOrVue = lowerPath.endsWith(".svelte") || lowerPath.endsWith(".vue");
   if (loader === "html") {
-    const content = readFileSync19(filePath, "utf-8");
+    const content = readFileSync20(filePath, "utf-8");
     return extractHtmlDependencies(filePath, content);
   }
   if (loader === "tsx" || loader === "js") {
-    const content = readFileSync19(filePath, "utf-8");
+    const content = readFileSync20(filePath, "utf-8");
     return extractJsDependencies(filePath, content, loader);
   }
   if (isSvelteOrVue) {
-    const content = readFileSync19(filePath, "utf-8");
+    const content = readFileSync20(filePath, "utf-8");
     return extractSvelteVueDependencies(filePath, content);
   }
   return [];
@@ -21237,7 +21416,7 @@ var init_clientManager = __esm(() => {
 });
 
 // src/dev/pathUtils.ts
-import { existsSync as existsSync29, readdirSync as readdirSync4, readFileSync as readFileSync20 } from "fs";
+import { existsSync as existsSync29, readdirSync as readdirSync5, readFileSync as readFileSync21 } from "fs";
 import { dirname as dirname18, resolve as resolve28 } from "path";
 var STYLE_EXTENSION_PATTERN2, detectFramework = (filePath, resolved) => {
   if (shouldIgnorePath(filePath, resolved)) {
@@ -21319,7 +21498,7 @@ var STYLE_EXTENSION_PATTERN2, detectFramework = (filePath, resolved) => {
   const walk = (dir) => {
     let entries;
     try {
-      entries = readdirSync4(dir, { withFileTypes: true });
+      entries = readdirSync5(dir, { withFileTypes: true });
     } catch {
       return;
     }
@@ -21337,7 +21516,7 @@ var STYLE_EXTENSION_PATTERN2, detectFramework = (filePath, resolved) => {
       }
       let source;
       try {
-        source = readFileSync20(full, "utf8");
+        source = readFileSync21(full, "utf8");
       } catch {
         continue;
       }
@@ -21415,8 +21594,8 @@ var STYLE_EXTENSION_PATTERN2, detectFramework = (filePath, resolved) => {
       roots.push(abs);
   }
   try {
-    const { readdirSync: readdirSync5 } = __require("fs");
-    const entries = readdirSync5(cwd2, { withFileTypes: true });
+    const { readdirSync: readdirSync6 } = __require("fs");
+    const entries = readdirSync6(cwd2, { withFileTypes: true });
     for (const entry of entries) {
       if (!entry.isDirectory())
         continue;
@@ -21496,8 +21675,8 @@ var init_pathUtils = __esm(() => {
 
 // src/dev/fileWatcher.ts
 import { watch } from "fs";
-import { existsSync as existsSync30, readdirSync as readdirSync5, statSync as statSync4 } from "fs";
-import { dirname as dirname19, join as join36, resolve as resolve29 } from "path";
+import { existsSync as existsSync30, readdirSync as readdirSync6, statSync as statSync4 } from "fs";
+import { dirname as dirname19, join as join37, resolve as resolve29 } from "path";
 var safeRemoveFromGraph = (graph, fullPath) => {
   try {
     removeFileFromGraph(graph, fullPath);
@@ -21522,7 +21701,7 @@ var safeRemoveFromGraph = (graph, fullPath) => {
   const atomicRecoveryScan = (eventDir) => {
     let entries;
     try {
-      entries = readdirSync5(eventDir);
+      entries = readdirSync6(eventDir);
     } catch {
       return;
     }
@@ -21530,7 +21709,7 @@ var safeRemoveFromGraph = (graph, fullPath) => {
     for (const name of entries) {
       if (shouldSkipFilename(name, isStylesDir))
         continue;
-      const child = join36(eventDir, name).replace(/\\/g, "/");
+      const child = join37(eventDir, name).replace(/\\/g, "/");
       let st2;
       try {
         st2 = statSync4(child);
@@ -21555,12 +21734,12 @@ var safeRemoveFromGraph = (graph, fullPath) => {
       return;
     if (shouldSkipFilename(filename, isStylesDir)) {
       if (event === "rename") {
-        const eventDir = dirname19(join36(absolutePath, filename)).replace(/\\/g, "/");
+        const eventDir = dirname19(join37(absolutePath, filename)).replace(/\\/g, "/");
         atomicRecoveryScan(eventDir);
       }
       return;
     }
-    const fullPath = join36(absolutePath, filename).replace(/\\/g, "/");
+    const fullPath = join37(absolutePath, filename).replace(/\\/g, "/");
     if (shouldIgnorePath(fullPath, state.resolvedPaths)) {
       return;
     }
@@ -21712,7 +21891,7 @@ var init_assetStore = __esm(() => {
 });
 
 // src/islands/pageMetadata.ts
-import { readFileSync as readFileSync21 } from "fs";
+import { readFileSync as readFileSync22 } from "fs";
 import { dirname as dirname20, resolve as resolve31 } from "path";
 var pagePatterns, getPageDirs = (config) => [
   { dir: config.angularDirectory, framework: "angular" },
@@ -21755,7 +21934,7 @@ var pagePatterns, getPageDirs = (config) => [
     return;
   const files = await scanEntryPoints(resolve31(entry.dir), pattern);
   for (const filePath of files) {
-    const source = readFileSync21(filePath, "utf-8");
+    const source = readFileSync22(filePath, "utf-8");
     const islands = extractIslandUsagesFromSource(source);
     pageMetadata.set(resolve31(filePath), {
       islands: resolveIslandUsages(islands, islandSourceLookup),
@@ -21786,10 +21965,10 @@ var init_pageMetadata = __esm(() => {
 });
 
 // src/dev/fileHashTracker.ts
-import { readFileSync as readFileSync22 } from "fs";
+import { readFileSync as readFileSync23 } from "fs";
 var computeFileHash = (filePath) => {
   try {
-    const fileContent = readFileSync22(filePath);
+    const fileContent = readFileSync23(filePath);
     return Number(Bun.hash(fileContent));
   } catch {
     return UNFOUND_INDEX;
@@ -22003,15 +22182,15 @@ __export(exports_resolveOwningComponents, {
   resolveDescendantsOfParent: () => resolveDescendantsOfParent,
   invalidateResourceIndex: () => invalidateResourceIndex
 });
-import { readdirSync as readdirSync6, readFileSync as readFileSync23, statSync as statSync5 } from "fs";
-import { dirname as dirname21, extname as extname9, join as join37, resolve as resolve34 } from "path";
-import ts14 from "typescript";
+import { readdirSync as readdirSync7, readFileSync as readFileSync24, statSync as statSync5 } from "fs";
+import { dirname as dirname21, extname as extname9, join as join38, resolve as resolve34 } from "path";
+import ts15 from "typescript";
 var ENTITY_DECORATORS, isAngularSourceFile = (file4) => file4.endsWith(".ts") || file4.endsWith(".tsx"), walkAngularSourceFiles = (root) => {
   const out = [];
   const visit = (dir) => {
     let entries;
     try {
-      entries = readdirSync6(dir, { withFileTypes: true });
+      entries = readdirSync7(dir, { withFileTypes: true });
     } catch {
       return;
     }
@@ -22019,7 +22198,7 @@ var ENTITY_DECORATORS, isAngularSourceFile = (file4) => file4.endsWith(".ts") ||
       if (entry.name.startsWith(".") || entry.name === "node_modules") {
         continue;
       }
-      const full = join37(dir, entry.name);
+      const full = join38(dir, entry.name);
       if (entry.isDirectory()) {
         visit(full);
       } else if (entry.isFile() && isAngularSourceFile(entry.name)) {
@@ -22031,13 +22210,13 @@ var ENTITY_DECORATORS, isAngularSourceFile = (file4) => file4.endsWith(".ts") ||
   return out;
 }, getStringPropertyValue = (obj, name) => {
   for (const prop of obj.properties) {
-    if (!ts14.isPropertyAssignment(prop))
+    if (!ts15.isPropertyAssignment(prop))
       continue;
-    const propName = ts14.isIdentifier(prop.name) ? prop.name.text : ts14.isStringLiteral(prop.name) ? prop.name.text : null;
+    const propName = ts15.isIdentifier(prop.name) ? prop.name.text : ts15.isStringLiteral(prop.name) ? prop.name.text : null;
     if (propName !== name)
       continue;
     const init = prop.initializer;
-    if (ts14.isStringLiteral(init) || ts14.isNoSubstitutionTemplateLiteral(init)) {
+    if (ts15.isStringLiteral(init) || ts15.isNoSubstitutionTemplateLiteral(init)) {
       return init.text;
     }
   }
@@ -22045,16 +22224,16 @@ var ENTITY_DECORATORS, isAngularSourceFile = (file4) => file4.endsWith(".ts") ||
 }, getStringArrayProperty = (obj, name) => {
   const out = [];
   for (const prop of obj.properties) {
-    if (!ts14.isPropertyAssignment(prop))
+    if (!ts15.isPropertyAssignment(prop))
       continue;
-    const propName = ts14.isIdentifier(prop.name) ? prop.name.text : ts14.isStringLiteral(prop.name) ? prop.name.text : null;
+    const propName = ts15.isIdentifier(prop.name) ? prop.name.text : ts15.isStringLiteral(prop.name) ? prop.name.text : null;
     if (propName !== name)
       continue;
     const init = prop.initializer;
-    if (!ts14.isArrayLiteralExpression(init))
+    if (!ts15.isArrayLiteralExpression(init))
       continue;
     for (const element of init.elements) {
-      if (ts14.isStringLiteral(element) || ts14.isNoSubstitutionTemplateLiteral(element)) {
+      if (ts15.isStringLiteral(element) || ts15.isNoSubstitutionTemplateLiteral(element)) {
         out.push(element.text);
       }
     }
@@ -22063,31 +22242,31 @@ var ENTITY_DECORATORS, isAngularSourceFile = (file4) => file4.endsWith(".ts") ||
 }, parseDecoratedClasses = (filePath) => {
   let source;
   try {
-    source = readFileSync23(filePath, "utf8");
+    source = readFileSync24(filePath, "utf8");
   } catch {
     return [];
   }
-  const sourceFile = ts14.createSourceFile(filePath, source, ts14.ScriptTarget.ES2022, true, ts14.ScriptKind.TS);
+  const sourceFile = ts15.createSourceFile(filePath, source, ts15.ScriptTarget.ES2022, true, ts15.ScriptKind.TS);
   const out = [];
   const visit = (node) => {
-    if (ts14.isClassDeclaration(node) && node.name) {
-      for (const decorator of ts14.getDecorators(node) ?? []) {
+    if (ts15.isClassDeclaration(node) && node.name) {
+      for (const decorator of ts15.getDecorators(node) ?? []) {
         const expr = decorator.expression;
-        if (!ts14.isCallExpression(expr))
+        if (!ts15.isCallExpression(expr))
           continue;
         const fn2 = expr.expression;
-        if (!ts14.isIdentifier(fn2))
+        if (!ts15.isIdentifier(fn2))
           continue;
         const kind = ENTITY_DECORATORS[fn2.text];
         if (!kind)
           continue;
         let extendsName = null;
         for (const heritage of node.heritageClauses ?? []) {
-          if (heritage.token !== ts14.SyntaxKind.ExtendsKeyword) {
+          if (heritage.token !== ts15.SyntaxKind.ExtendsKeyword) {
             continue;
           }
           const first = heritage.types[0];
-          if (first && ts14.isIdentifier(first.expression)) {
+          if (first && ts15.isIdentifier(first.expression)) {
             extendsName = first.expression.text;
           }
           break;
@@ -22100,7 +22279,7 @@ var ENTITY_DECORATORS, isAngularSourceFile = (file4) => file4.endsWith(".ts") ||
           extendsName
         };
         const arg = expr.arguments[0];
-        if (arg && ts14.isObjectLiteralExpression(arg) && kind === "component") {
+        if (arg && ts15.isObjectLiteralExpression(arg) && kind === "component") {
           const tplUrl = getStringPropertyValue(arg, "templateUrl");
           if (tplUrl)
             entry.templateUrls.push(tplUrl);
@@ -22113,7 +22292,7 @@ var ENTITY_DECORATORS, isAngularSourceFile = (file4) => file4.endsWith(".ts") ||
         break;
       }
     }
-    ts14.forEachChild(node, visit);
+    ts15.forEachChild(node, visit);
   };
   visit(sourceFile);
   return out;
@@ -22153,16 +22332,16 @@ var ENTITY_DECORATORS, isAngularSourceFile = (file4) => file4.endsWith(".ts") ||
 }, indexByRoot, resolveParentClassFile = (parentName, childFilePath, angularRoot) => {
   let source;
   try {
-    source = readFileSync23(childFilePath, "utf8");
+    source = readFileSync24(childFilePath, "utf8");
   } catch {
     return null;
   }
-  const sf = ts14.createSourceFile(childFilePath, source, ts14.ScriptTarget.ES2022, true, ts14.ScriptKind.TS);
+  const sf = ts15.createSourceFile(childFilePath, source, ts15.ScriptTarget.ES2022, true, ts15.ScriptKind.TS);
   const childDir = dirname21(childFilePath);
   for (const stmt of sf.statements) {
-    if (!ts14.isImportDeclaration(stmt))
+    if (!ts15.isImportDeclaration(stmt))
       continue;
-    if (!ts14.isStringLiteral(stmt.moduleSpecifier))
+    if (!ts15.isStringLiteral(stmt.moduleSpecifier))
       continue;
     const clause = stmt.importClause;
     if (!clause || clause.isTypeOnly)
@@ -22170,7 +22349,7 @@ var ENTITY_DECORATORS, isAngularSourceFile = (file4) => file4.endsWith(".ts") ||
     let matchesName = false;
     if (clause.name && clause.name.text === parentName)
       matchesName = true;
-    if (!matchesName && clause.namedBindings && ts14.isNamedImports(clause.namedBindings)) {
+    if (!matchesName && clause.namedBindings && ts15.isNamedImports(clause.namedBindings)) {
       for (const el of clause.namedBindings.elements) {
         if (el.isTypeOnly)
           continue;
@@ -22520,8 +22699,8 @@ __export(exports_moduleServer, {
   createModuleServer: () => createModuleServer,
   SRC_URL_PREFIX: () => SRC_URL_PREFIX
 });
-import { existsSync as existsSync31, readFileSync as readFileSync24, statSync as statSync6 } from "fs";
-import { basename as basename12, dirname as dirname22, extname as extname10, join as join38, resolve as resolve36, relative as relative14 } from "path";
+import { existsSync as existsSync31, readFileSync as readFileSync25, statSync as statSync6 } from "fs";
+import { basename as basename12, dirname as dirname22, extname as extname10, join as join39, resolve as resolve36, relative as relative14 } 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 = [];
@@ -22593,9 +22772,9 @@ ${stubs}
       const subpath = isScoped ? parts.slice(2).join("/") : parts.slice(1).join("/");
       if (!subpath) {
         const pkgDir = resolve36(projectRoot, "node_modules", packageName ?? "");
-        const pkgJsonPath = join38(pkgDir, "package.json");
+        const pkgJsonPath = join39(pkgDir, "package.json");
         if (existsSync31(pkgJsonPath)) {
-          const pkg = JSON.parse(readFileSync24(pkgJsonPath, "utf-8"));
+          const pkg = JSON.parse(readFileSync25(pkgJsonPath, "utf-8"));
           const esmEntry = typeof pkg.module === "string" && pkg.module || typeof pkg.browser === "string" && pkg.browser;
           if (esmEntry) {
             const resolved = resolve36(pkgDir, esmEntry);
@@ -22696,7 +22875,7 @@ ${code}`;
   reactFastRefreshWarningEmitted = true;
   logWarn("React HMR is blocked: this Bun build ignores " + "`reactFastRefresh` on Bun.Transpiler, so component state " + "cannot be preserved across edits. Tracking " + "https://github.com/oven-sh/bun/pull/28312 \u2014 if it still has " + "not merged, leave a \uD83D\uDC4D on the PR so the Bun team knows it " + "is blocking you. Until then, React edits trigger a full " + "reload instead of a fast refresh.");
 }, transformReactFile = (filePath, projectRoot, rewriter) => {
-  const raw = readFileSync24(filePath, "utf-8");
+  const raw = readFileSync25(filePath, "utf-8");
   const valueExports = tsxTranspiler.scan(raw).exports;
   let transpiled = reactTranspiler.transformSync(raw);
   transpiled = preserveTypeExports(raw, transpiled, valueExports);
@@ -22712,7 +22891,7 @@ ${transpiled}`;
   transpiled += buildIslandMetadataExports(raw);
   return rewriteImports(transpiled, filePath, projectRoot, rewriter);
 }, transformPlainFile = (filePath, projectRoot, rewriter, vueDir) => {
-  const raw = readFileSync24(filePath, "utf-8");
+  const raw = readFileSync25(filePath, "utf-8");
   const ext = extname10(filePath);
   const isTS = ext === ".ts" || ext === ".tsx";
   const isTSX = ext === ".tsx" || ext === ".jsx";
@@ -22878,7 +23057,7 @@ ${code}`;
 ` + `  var __hmr_accept = function(cb) { window.__SVELTE_HMR_ACCEPT__[${JSON.stringify(moduleUrl)}] = cb; };`);
   return code.replace(/import\.meta\.hot\.accept\(/g, "__hmr_accept(");
 }, transformSvelteFile = async (filePath, projectRoot, rewriter, stylePreprocessors) => {
-  const raw = readFileSync24(filePath, "utf-8");
+  const raw = readFileSync25(filePath, "utf-8");
   if (!svelteCompiler) {
     svelteCompiler = await import("svelte/compiler");
   }
@@ -22940,7 +23119,7 @@ export default __script__;`;
   return `${cssInjection}
 ${code}`;
 }, transformVueFile = async (filePath, projectRoot, rewriter, vueDir, stylePreprocessors) => {
-  const rawSource = readFileSync24(filePath, "utf-8");
+  const rawSource = readFileSync25(filePath, "utf-8");
   const raw = addAutoRouterSetupApp(rawSource);
   if (!vueCompiler) {
     vueCompiler = await import("@vue/compiler-sfc");
@@ -22995,7 +23174,7 @@ ${code}`;
     }
   });
 }, handleCssRequest = (filePath) => {
-  const raw = readFileSync24(filePath, "utf-8");
+  const raw = readFileSync25(filePath, "utf-8");
   const escaped = raw.replace(/\\/g, "\\\\").replace(/`/g, "\\`").replace(/\$/g, "\\$");
   return [
     `const style = document.createElement('style');`,
@@ -23654,7 +23833,7 @@ var init_simpleHTMXHMR = () => {};
 
 // src/dev/rebuildTrigger.ts
 import { existsSync as existsSync32, rmSync as rmSync3 } from "fs";
-import { basename as basename13, dirname as dirname24, join as join39, relative as relative16, resolve as resolve40, sep as sep4 } from "path";
+import { basename as basename13, dirname as dirname24, join as join40, relative as relative16, resolve as resolve40, 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;
@@ -23771,8 +23950,8 @@ var moduleServerPromise, getModuleServer = () => moduleServerPromise, runSequent
     const relJs = `${rel.slice(0, -ext[0].length)}.js`;
     const generatedDir = getFrameworkGeneratedDir(framework, cwd2);
     for (const candidate of [
-      join39(generatedDir, relJs),
-      `${join39(generatedDir, relJs)}.map`
+      join40(generatedDir, relJs),
+      `${join40(generatedDir, relJs)}.map`
     ]) {
       try {
         rmSync3(candidate, { force: true });
@@ -24634,12 +24813,12 @@ var moduleServerPromise, getModuleServer = () => moduleServerPromise, runSequent
     try {
       const { primeComponentFingerprint: primeComponentFingerprint2 } = await Promise.resolve().then(() => (init_fastHmrCompiler(), exports_fastHmrCompiler));
       const { readdir: readdir5 } = await import("fs/promises");
-      const { join: join40 } = await import("path");
+      const { join: join41 } = await import("path");
       const walk = async (dir) => {
         const entries = await readdir5(dir, { withFileTypes: true });
         const files = [];
         for (const entry of entries) {
-          const full = join40(dir, entry.name);
+          const full = join41(dir, entry.name);
           if (entry.isDirectory()) {
             files.push(...await walk(full));
           } else if (entry.isFile() && entry.name.endsWith(".ts") && !entry.name.endsWith(".d.ts")) {
@@ -24692,9 +24871,9 @@ var moduleServerPromise, getModuleServer = () => moduleServerPromise, runSequent
   const editedProvidersChain = providersImport && angularFiles.some((file4) => resolve40(file4) === resolve40(providersImport.absolutePath) || resolve40(file4).startsWith(`${resolve40(angularDir)}/`));
   const pageEntries = editedProvidersChain && initialPageEntries.length === 0 ? (() => {
     const allPages = [];
-    const { readdirSync: readdirSync7 } = __require("fs");
+    const { readdirSync: readdirSync8 } = __require("fs");
     const walk = (dir) => {
-      for (const entry of readdirSync7(dir, {
+      for (const entry of readdirSync8(dir, {
         withFileTypes: true
       })) {
         const full = resolve40(dir, entry.name);
@@ -25105,7 +25284,7 @@ var moduleServerPromise, getModuleServer = () => moduleServerPromise, runSequent
   const { vueServerPaths, vueIndexPaths, vueClientPaths, vueCssPaths } = await compileVue2(vueFiles, vueDir, true, getStyleTransformConfig(state.config));
   const serverEntries = [...vueServerPaths];
   const clientEntries = [...vueIndexPaths, ...vueClientPaths];
-  const cssOutDir = join39(buildDir, state.resolvedPaths.assetsDir ? basename13(state.resolvedPaths.assetsDir) : "assets", "css");
+  const cssOutDir = join40(buildDir, state.resolvedPaths.assetsDir ? basename13(state.resolvedPaths.assetsDir) : "assets", "css");
   const { serverRoot, serverOutDir } = await computeServerOutPaths(state.resolvedPaths, "vue");
   const [serverResult, clientResult, cssResult] = await Promise.all([
     serverEntries.length > 0 ? bunBuild9({
@@ -26120,7 +26299,7 @@ __export(exports_buildDepVendor, {
   buildDepVendor: () => buildDepVendor
 });
 import { mkdirSync as mkdirSync14 } from "fs";
-import { join as join40 } from "path";
+import { join as join41 } from "path";
 import { rm as rm10 } from "fs/promises";
 var {build: bunBuild9, Glob: Glob10 } = globalThis.Bun;
 var toSafeFileName6 = (specifier) => {
@@ -26174,7 +26353,7 @@ var toSafeFileName6 = (specifier) => {
     framework: Array.from(framework).filter(isResolvable4)
   };
 }, collectTransitiveImports = async (specs, alreadyVendored, alreadyScanned) => {
-  const { readFileSync: readFileSync25 } = await import("fs");
+  const { readFileSync: readFileSync26 } = await import("fs");
   const transpiler6 = new Bun.Transpiler({ loader: "js" });
   const newSpecs = new Set;
   for (const spec of specs) {
@@ -26189,7 +26368,7 @@ var toSafeFileName6 = (specifier) => {
     }
     let content;
     try {
-      content = readFileSync25(resolved, "utf-8");
+      content = readFileSync26(resolved, "utf-8");
     } catch {
       continue;
     }
@@ -26231,7 +26410,7 @@ var toSafeFileName6 = (specifier) => {
 }), buildDepVendorPass = async (specifiers, vendorDir, tmpDir) => {
   const entries = await Promise.all(specifiers.map(async (specifier) => {
     const safeName = toSafeFileName6(specifier);
-    const entryPath = join40(tmpDir, `${safeName}.ts`);
+    const entryPath = join41(tmpDir, `${safeName}.ts`);
     await Bun.write(entryPath, await generateVendorEntrySource(specifier));
     return { entryPath, specifier };
   }));
@@ -26292,9 +26471,9 @@ var toSafeFileName6 = (specifier) => {
   const { dep: initialSpecs, framework: frameworkRoots } = await scanBareImports(directories);
   if (initialSpecs.length === 0 && frameworkRoots.length === 0)
     return {};
-  const vendorDir = join40(buildDir, "vendor");
+  const vendorDir = join41(buildDir, "vendor");
   mkdirSync14(vendorDir, { recursive: true });
-  const tmpDir = join40(buildDir, "_dep_vendor_tmp");
+  const tmpDir = join41(buildDir, "_dep_vendor_tmp");
   mkdirSync14(tmpDir, { recursive: true });
   const allSpecs = new Set(initialSpecs);
   const alreadyScanned = new Set;
@@ -26806,5 +26985,5 @@ export {
   build
 };
 
-//# debugId=4F18A2DD76FF7F8064756E2164756E21
+//# debugId=71A611117C6D2CDE64756E2164756E21
 //# sourceMappingURL=build.js.map