@absolutejs/absolute 0.19.0-beta.953 → 0.19.0-beta.955

package/dist/index.js

@@ -11996,24 +11996,6 @@ var init_compileVue = __esm(() => {
   vueHmrMetadata = new Map;
 });
 
-// src/build/rewriteProvideRouter.ts
-var ROUTER_IMPORT_PATTERN, PROVIDE_ROUTER_CALL_PATTERN, CAPTURE_IMPORT_STATEMENT = `import { __abs_provideRouter } from '@absolutejs/absolute/angular';
-`, SHIM_MARKER = "__abs_provideRouter", rewriteAngularProvideRouter = (source) => {
-  if (source.includes(SHIM_MARKER))
-    return source;
-  if (!ROUTER_IMPORT_PATTERN.test(source))
-    return source;
-  if (!PROVIDE_ROUTER_CALL_PATTERN.test(source))
-    return source;
-  PROVIDE_ROUTER_CALL_PATTERN.lastIndex = 0;
-  const rewritten = source.replace(PROVIDE_ROUTER_CALL_PATTERN, "__abs_provideRouter(");
-  return `${CAPTURE_IMPORT_STATEMENT}${rewritten}`;
-};
-var init_rewriteProvideRouter = __esm(() => {
-  ROUTER_IMPORT_PATTERN = /import\s*(?:type\s+)?\{[^}]*\bprovideRouter\b[^}]*\}\s*from\s*['"]@angular\/router['"]/;
-  PROVIDE_ROUTER_CALL_PATTERN = /\bprovideRouter\s*\(/g;
-});
-
 // src/angular/lowerDeferSyntax.ts
 var isInterpolatedExpressionStart = (value, index) => value[index] === "{" && value[index + 1] === "{", skipInterpolatedExpression = (value, start) => {
   const cursor = start + 2;
@@ -12709,11 +12691,9 @@ var traceAngularPhase = async (name, fn2, metadata2) => {
   return candidates.map((candidate) => resolve24(candidate)).find((candidate) => existsSync18(candidate) && !candidate.endsWith(".d.ts")) ?? null;
 }, readFileForAotTransform = async (fileName, readFile6) => {
   const hostSource = readFile6?.(fileName);
-  if (typeof hostSource === "string") {
-    return rewriteAngularProvideRouter(hostSource);
-  }
-  const raw = await fs.readFile(fileName, "utf-8");
-  return rewriteAngularProvideRouter(raw);
+  if (typeof hostSource === "string")
+    return hostSource;
+  return fs.readFile(fileName, "utf-8");
 }, safeStableStringify = (value) => {
   const seen = new WeakSet;
   return JSON.stringify(value, (_key, entry) => {
@@ -13307,7 +13287,6 @@ ${fields}
     if (!existsSync18(actualPath))
       return;
     let sourceCode = await fs.readFile(actualPath, "utf-8");
-    sourceCode = rewriteAngularProvideRouter(sourceCode);
     const inlined = await inlineResources(sourceCode, dirname15(actualPath), stylePreprocessors);
     sourceCode = inlineTemplateAndLowerDeferSync(inlined.source, dirname15(actualPath)).source;
     const inputDir = dirname15(actualPath);
@@ -13681,7 +13660,6 @@ if (pageHasRawStreamingSlots) {
   };
 };
 var init_compileAngular = __esm(() => {
-  init_rewriteProvideRouter();
   init_constants();
   init_sourceMetadata();
   init_lowerDeferSyntax();
@@ -25620,27 +25598,782 @@ var init_imageOptimizer = __esm(() => {
   avifInProgress = new Set;
 });
 
-// src/utils/spaRouteEnumeration.ts
-import { AsyncLocalStorage as AsyncLocalStorage2 } from "async_hooks";
-var STORAGE_KEY, isObjectRecord4 = (value) => Boolean(value) && typeof value === "object", isStorage = (value) => isObjectRecord4(value) && typeof value.getStore === "function" && typeof value.run === "function", getStorage = () => {
-  const existing = Reflect.get(globalThis, STORAGE_KEY);
-  if (isStorage(existing))
-    return existing;
-  const fresh = new AsyncLocalStorage2;
-  Reflect.set(globalThis, STORAGE_KEY, fresh);
-  return fresh;
-}, isCollectingSpaRoutes = () => getStorage().getStore() !== undefined, recordSpaRoutes = (entries) => {
-  const store = getStorage().getStore();
-  if (!store)
+// src/angular/staticAnalyzeSpaRoutes.ts
+import { existsSync as existsSync31, promises as fs2 } from "fs";
+import { join as join35 } from "path";
+import ts8 from "typescript";
+var DYNAMIC_SEGMENT_PATTERN, pathHasDynamic = (path) => path.split("/").some((seg) => DYNAMIC_SEGMENT_PATTERN.test(seg) || seg === "**"), importsSymbolFrom = (sf, localName, moduleSpecifier) => {
+  for (const statement of sf.statements) {
+    if (!ts8.isImportDeclaration(statement))
+      continue;
+    if (!ts8.isStringLiteral(statement.moduleSpecifier))
+      continue;
+    if (statement.moduleSpecifier.text !== moduleSpecifier)
+      continue;
+    const named = statement.importClause?.namedBindings;
+    if (!named || !ts8.isNamedImports(named))
+      continue;
+    for (const element of named.elements) {
+      if (element.name.text === localName)
+        return true;
+    }
+  }
+  return false;
+}, readStringLiteral = (expression) => {
+  if (ts8.isStringLiteral(expression) || ts8.isNoSubstitutionTemplateLiteral(expression)) {
+    return expression.text;
+  }
+  return null;
+}, readPropertyKey = (property) => {
+  if (ts8.isPropertyAssignment(property)) {
+    const name = property.name;
+    if (ts8.isIdentifier(name) || ts8.isStringLiteral(name))
+      return name.text;
+  }
+  if (ts8.isShorthandPropertyAssignment(property)) {
+    return property.name.text;
+  }
+  return null;
+}, findRoutesArrayDeclaration = (sf, identifierName) => {
+  let found = null;
+  const visit = (node) => {
+    if (found)
+      return;
+    if (ts8.isVariableDeclaration(node) && ts8.isIdentifier(node.name) && node.name.text === identifierName && node.initializer && ts8.isArrayLiteralExpression(node.initializer)) {
+      found = node.initializer;
+      return;
+    }
+    ts8.forEachChild(node, visit);
+  };
+  ts8.forEachChild(sf, visit);
+  return found;
+}, extractSitemapData = (dataLiteral) => {
+  for (const prop of dataLiteral.properties) {
+    const key = readPropertyKey(prop);
+    if (key !== "sitemap")
+      continue;
+    if (!ts8.isPropertyAssignment(prop))
+      continue;
+    const value = readStringLiteral(prop.initializer);
+    if (value === "exclude")
+      return true;
+  }
+  return false;
+}, joinSegments = (parent, child) => {
+  if (!child)
+    return parent;
+  if (!parent)
+    return child;
+  return `${parent.replace(/\/+$/, "")}/${child.replace(/^\/+/, "")}`;
+}, extractRoutePaths = (arr, parentPath, parentExcluded, out) => {
+  for (const element of arr.elements) {
+    if (!ts8.isObjectLiteralExpression(element))
+      continue;
+    let pathSegment = null;
+    let redirected = false;
+    let sitemapExcluded = parentExcluded;
+    let childrenLiteral = null;
+    for (const property of element.properties) {
+      const key = readPropertyKey(property);
+      if (!key)
+        continue;
+      if (!ts8.isPropertyAssignment(property))
+        continue;
+      if (key === "path") {
+        pathSegment = readStringLiteral(property.initializer);
+      } else if (key === "redirectTo") {
+        redirected = true;
+      } else if (key === "data" && ts8.isObjectLiteralExpression(property.initializer)) {
+        if (extractSitemapData(property.initializer))
+          sitemapExcluded = true;
+      } else if (key === "children" && ts8.isArrayLiteralExpression(property.initializer)) {
+        childrenLiteral = property.initializer;
+      }
+    }
+    if (pathSegment === null)
+      continue;
+    const joined = joinSegments(parentPath, pathSegment);
+    if (childrenLiteral) {
+      extractRoutePaths(childrenLiteral, joined, sitemapExcluded, out);
+      continue;
+    }
+    if (redirected)
+      continue;
+    if (joined === "")
+      continue;
+    out.push({
+      dynamic: pathHasDynamic(joined),
+      path: joined,
+      redirected,
+      sitemapExcluded
+    });
+  }
+}, findProvideRouterFirstArg = (sf) => {
+  let found = null;
+  const visit = (node) => {
+    if (found)
+      return;
+    if (ts8.isCallExpression(node) && ts8.isIdentifier(node.expression) && node.expression.text === "provideRouter") {
+      found = node.arguments[0] ?? null;
+      return;
+    }
+    ts8.forEachChild(node, visit);
+  };
+  ts8.forEachChild(sf, visit);
+  return found;
+}, findAppBaseHrefValue = (sf) => {
+  let found = null;
+  const visit = (node) => {
+    if (found)
+      return;
+    if (ts8.isObjectLiteralExpression(node)) {
+      let isAppBaseHref = false;
+      let value = null;
+      for (const property of node.properties) {
+        const key = readPropertyKey(property);
+        if (!key)
+          continue;
+        if (!ts8.isPropertyAssignment(property))
+          continue;
+        if (key === "provide" && ts8.isIdentifier(property.initializer) && property.initializer.text === "APP_BASE_HREF") {
+          isAppBaseHref = true;
+        } else if (key === "useValue") {
+          value = readStringLiteral(property.initializer);
+        }
+      }
+      if (isAppBaseHref && value !== null) {
+        found = value;
+        return;
+      }
+    }
+    ts8.forEachChild(node, visit);
+  };
+  ts8.forEachChild(sf, visit);
+  return found;
+}, analyzeFile = async (filePath) => {
+  let source;
+  try {
+    source = await fs2.readFile(filePath, "utf-8");
+  } catch {
+    return null;
+  }
+  if (!source.includes("APP_BASE_HREF") || !source.includes("provideRouter")) {
+    return null;
+  }
+  const sf = ts8.createSourceFile(filePath, source, ts8.ScriptTarget.Latest, true, ts8.ScriptKind.TS);
+  if (!importsSymbolFrom(sf, "APP_BASE_HREF", "@angular/common"))
+    return null;
+  if (!importsSymbolFrom(sf, "provideRouter", "@angular/router"))
+    return null;
+  const baseHref = findAppBaseHrefValue(sf);
+  if (!baseHref)
+    return null;
+  const firstArg = findProvideRouterFirstArg(sf);
+  if (!firstArg)
+    return null;
+  let routesArray = null;
+  if (ts8.isIdentifier(firstArg)) {
+    routesArray = findRoutesArrayDeclaration(sf, firstArg.text);
+  } else if (ts8.isArrayLiteralExpression(firstArg)) {
+    routesArray = firstArg;
+  }
+  if (!routesArray)
+    return null;
+  const routes = [];
+  extractRoutePaths(routesArray, "", false, routes);
+  return {
+    baseHref,
+    routes,
+    sourceFile: filePath
+  };
+}, walkTsFiles = async (dir, out) => {
+  let items;
+  try {
+    items = await fs2.readdir(dir, { withFileTypes: true });
+  } catch {
+    return;
+  }
+  for (const item of items) {
+    if (item.name === "node_modules")
+      continue;
+    if (item.name.startsWith("."))
+      continue;
+    const full = join35(dir, item.name);
+    if (item.isDirectory()) {
+      await walkTsFiles(full, out);
+    } else if (item.isFile() && item.name.endsWith(".ts") && !item.name.endsWith(".d.ts")) {
+      out.push(full);
+    }
+  }
+}, analyzeAngularSpaRoutes = async (angularDirectory) => {
+  if (!existsSync31(angularDirectory))
+    return [];
+  const tsFiles = [];
+  await walkTsFiles(angularDirectory, tsFiles);
+  const pages = [];
+  await Promise.all(tsFiles.map(async (file5) => {
+    try {
+      const page = await analyzeFile(file5);
+      if (page)
+        pages.push(page);
+    } catch (err) {
+      console.warn(`[sitemap] Angular SPA analysis failed for ${file5}:`, err);
+    }
+  }));
+  return pages;
+};
+var init_staticAnalyzeSpaRoutes = __esm(() => {
+  DYNAMIC_SEGMENT_PATTERN = /^[:*]/;
+});
+
+// src/react/staticAnalyzeSpaRoutes.ts
+import { existsSync as existsSync32, promises as fs3 } from "fs";
+import { join as join36 } from "path";
+import ts9 from "typescript";
+var DYNAMIC_SEGMENT_PATTERN2, pathHasDynamic2 = (path) => path.split("/").some((seg) => DYNAMIC_SEGMENT_PATTERN2.test(seg) || seg === "**"), readStringLiteral2 = (expression) => {
+  if (ts9.isStringLiteral(expression) || ts9.isNoSubstitutionTemplateLiteral(expression)) {
+    return expression.text;
+  }
+  return null;
+}, readPropertyKey2 = (property) => {
+  if (ts9.isPropertyAssignment(property)) {
+    const name = property.name;
+    if (ts9.isIdentifier(name) || ts9.isStringLiteral(name))
+      return name.text;
+  }
+  if (ts9.isShorthandPropertyAssignment(property)) {
+    return property.name.text;
+  }
+  return null;
+}, importsSymbolFromAny = (sf, localName, moduleSpecifiers) => {
+  for (const statement of sf.statements) {
+    if (!ts9.isImportDeclaration(statement))
+      continue;
+    if (!ts9.isStringLiteral(statement.moduleSpecifier))
+      continue;
+    if (!moduleSpecifiers.includes(statement.moduleSpecifier.text))
+      continue;
+    const named = statement.importClause?.namedBindings;
+    if (!named || !ts9.isNamedImports(named))
+      continue;
+    for (const element of named.elements) {
+      if (element.name.text === localName)
+        return true;
+    }
+  }
+  return false;
+}, findVariableArrayDeclaration = (sf, identifierName) => {
+  let found = null;
+  const visit = (node) => {
+    if (found)
+      return;
+    if (ts9.isVariableDeclaration(node) && ts9.isIdentifier(node.name) && node.name.text === identifierName && node.initializer && ts9.isArrayLiteralExpression(node.initializer)) {
+      found = node.initializer;
+      return;
+    }
+    ts9.forEachChild(node, visit);
+  };
+  ts9.forEachChild(sf, visit);
+  return found;
+}, joinSegments2 = (parent, child) => {
+  if (!child)
+    return parent;
+  if (!parent)
+    return child;
+  return `${parent.replace(/\/+$/, "")}/${child.replace(/^\/+/, "")}`;
+}, extractRouteEntries = (arr, parentPath, out) => {
+  for (const element of arr.elements) {
+    if (!ts9.isObjectLiteralExpression(element))
+      continue;
+    let pathSegment = null;
+    let redirected = false;
+    let sitemapExcluded = false;
+    let childrenLiteral = null;
+    let isIndex = false;
+    for (const property of element.properties) {
+      const key = readPropertyKey2(property);
+      if (!key)
+        continue;
+      if (!ts9.isPropertyAssignment(property))
+        continue;
+      if (key === "path") {
+        pathSegment = readStringLiteral2(property.initializer);
+      } else if (key === "index") {
+        isIndex = true;
+      } else if (key === "loader" || key === "lazy") {} else if (key === "children" && ts9.isArrayLiteralExpression(property.initializer)) {
+        childrenLiteral = property.initializer;
+      } else if (key === "redirectTo") {
+        redirected = true;
+      } else if (key === "handle" && ts9.isObjectLiteralExpression(property.initializer)) {
+        for (const handleProp of property.initializer.properties) {
+          const handleKey = readPropertyKey2(handleProp);
+          if (handleKey !== "sitemap")
+            continue;
+          if (!ts9.isPropertyAssignment(handleProp))
+            continue;
+          const value = readStringLiteral2(handleProp.initializer);
+          if (value === "exclude")
+            sitemapExcluded = true;
+        }
+      }
+    }
+    const segment = pathSegment ?? "";
+    const joined = joinSegments2(parentPath, segment);
+    if (childrenLiteral) {
+      extractRouteEntries(childrenLiteral, joined, out);
+      continue;
+    }
+    if (redirected)
+      continue;
+    if (!isIndex && pathSegment === null)
+      continue;
+    if (joined === "")
+      continue;
+    out.push({
+      dynamic: pathHasDynamic2(joined),
+      path: joined,
+      redirected,
+      sitemapExcluded
+    });
+  }
+}, findCreateBrowserRouterCall = (sf) => {
+  let found = null;
+  const visit = (node) => {
+    if (found)
+      return;
+    if (ts9.isCallExpression(node) && ts9.isIdentifier(node.expression) && node.expression.text === "createBrowserRouter") {
+      found = node;
+      return;
+    }
+    ts9.forEachChild(node, visit);
+  };
+  ts9.forEachChild(sf, visit);
+  return found;
+}, readBasenameFromOptions = (expression) => {
+  if (!expression || !ts9.isObjectLiteralExpression(expression))
+    return null;
+  for (const property of expression.properties) {
+    const key = readPropertyKey2(property);
+    if (key !== "basename")
+      continue;
+    if (!ts9.isPropertyAssignment(property))
+      continue;
+    const value = readStringLiteral2(property.initializer);
+    if (value !== null)
+      return value;
+  }
+  return null;
+}, analyzeFile2 = async (filePath) => {
+  let source;
+  try {
+    source = await fs3.readFile(filePath, "utf-8");
+  } catch {
+    return null;
+  }
+  if (!source.includes("createBrowserRouter"))
+    return null;
+  const sf = ts9.createSourceFile(filePath, source, ts9.ScriptTarget.Latest, true, filePath.endsWith(".tsx") ? ts9.ScriptKind.TSX : ts9.ScriptKind.TS);
+  if (!importsSymbolFromAny(sf, "createBrowserRouter", [
+    "react-router-dom",
+    "react-router"
+  ])) {
+    return null;
+  }
+  const call = findCreateBrowserRouterCall(sf);
+  if (!call)
+    return null;
+  const routesArg = call.arguments[0];
+  if (!routesArg)
+    return null;
+  let routesArray = null;
+  if (ts9.isArrayLiteralExpression(routesArg)) {
+    routesArray = routesArg;
+  } else if (ts9.isIdentifier(routesArg)) {
+    routesArray = findVariableArrayDeclaration(sf, routesArg.text);
+  }
+  if (!routesArray)
+    return null;
+  const basename14 = readBasenameFromOptions(call.arguments[1]);
+  const baseHref = basename14 ? `${basename14.replace(/\/+$/, "")}/` : "/";
+  const routes = [];
+  extractRouteEntries(routesArray, "", routes);
+  return { baseHref, routes, sourceFile: filePath };
+}, walkSourceFiles = async (dir, out) => {
+  let items;
+  try {
+    items = await fs3.readdir(dir, { withFileTypes: true });
+  } catch {
     return;
-  store.entries.push(...entries);
-}, collectSpaRoutes = async (task) => {
-  const store = { entries: [] };
-  await getStorage().run(store, task);
-  return store.entries;
+  }
+  for (const item of items) {
+    if (item.name === "node_modules" || item.name.startsWith("."))
+      continue;
+    const full = join36(dir, item.name);
+    if (item.isDirectory()) {
+      await walkSourceFiles(full, out);
+    } else if (item.isFile() && (item.name.endsWith(".tsx") || item.name.endsWith(".ts") || item.name.endsWith(".jsx") || item.name.endsWith(".js")) && !item.name.endsWith(".d.ts")) {
+      out.push(full);
+    }
+  }
+}, analyzeReactSpaRoutes = async (reactDirectory) => {
+  if (!existsSync32(reactDirectory))
+    return [];
+  const files = [];
+  await walkSourceFiles(reactDirectory, files);
+  const hosts = [];
+  await Promise.all(files.map(async (file5) => {
+    try {
+      const host = await analyzeFile2(file5);
+      if (host)
+        hosts.push(host);
+    } catch (err) {
+      console.warn(`[sitemap] React SPA analysis failed for ${file5}:`, err);
+    }
+  }));
+  return hosts;
 };
-var init_spaRouteEnumeration = __esm(() => {
-  STORAGE_KEY = Symbol.for("absolutejs.spaRouteEnumerationStorage");
+var init_staticAnalyzeSpaRoutes2 = __esm(() => {
+  DYNAMIC_SEGMENT_PATTERN2 = /^[:*]/;
+});
+
+// src/svelte/staticAnalyzeSpaRoutes.ts
+import { existsSync as existsSync33, promises as fs4 } from "fs";
+import { join as join37 } from "path";
+var DYNAMIC_SEGMENT_PATTERN3, pathHasDynamic3 = (path) => path.split("/").some((seg) => DYNAMIC_SEGMENT_PATTERN3.test(seg) || seg === "**"), joinSegments3 = (parent, child) => {
+  if (!child)
+    return parent;
+  if (!parent)
+    return child;
+  return `${parent.replace(/\/+$/, "")}/${child.replace(/^\/+/, "")}`;
+}, readAttribute = (tag, name) => {
+  const re2 = new RegExp(`${name}\\s*=\\s*(?:"([^"]*)"|'([^']*)'|\\{?["']([^"']+)["']\\}?)`);
+  const match = re2.exec(tag);
+  return match ? match[1] ?? match[2] ?? match[3] ?? null : null;
+}, ROUTER_OPEN_TAG_PATTERN, ROUTE_TAG_PATTERN, findRouterBlock = (source) => {
+  const openMatch = ROUTER_OPEN_TAG_PATTERN.exec(source);
+  ROUTER_OPEN_TAG_PATTERN.lastIndex = 0;
+  if (!openMatch)
+    return null;
+  const attrs = openMatch[1] ?? "";
+  const basepathRaw = readAttribute(`<Router ${attrs}>`, "basepath");
+  const basepath = basepathRaw ?? "/";
+  const closeIndex = source.indexOf("</Router>", openMatch.index);
+  if (closeIndex === -1)
+    return null;
+  const body = source.slice(openMatch.index + openMatch[0].length, closeIndex);
+  return { basepath, body };
+}, extractRoutesFromBody = (body) => {
+  const out = [];
+  let match;
+  ROUTE_TAG_PATTERN.lastIndex = 0;
+  while ((match = ROUTE_TAG_PATTERN.exec(body)) !== null) {
+    const attrs = match[1] ?? "";
+    const path = readAttribute(`<Route ${attrs}/>`, "path");
+    if (!path)
+      continue;
+    out.push({
+      dynamic: pathHasDynamic3(path),
+      path,
+      redirected: false,
+      sitemapExcluded: false
+    });
+  }
+  return out;
+}, analyzeFile3 = async (filePath) => {
+  let source;
+  try {
+    source = await fs4.readFile(filePath, "utf-8");
+  } catch {
+    return null;
+  }
+  if (!source.includes("<Router"))
+    return null;
+  const block = findRouterBlock(source);
+  if (!block)
+    return null;
+  const routes = extractRoutesFromBody(block.body);
+  if (routes.length === 0)
+    return null;
+  const baseHref = block.basepath.endsWith("/") ? block.basepath : `${block.basepath}/`;
+  const joinedRoutes = routes.map((r) => ({
+    ...r,
+    path: joinSegments3("", r.path)
+  }));
+  return { baseHref, routes: joinedRoutes, sourceFile: filePath };
+}, walkSvelteFiles = async (dir, out) => {
+  let items;
+  try {
+    items = await fs4.readdir(dir, { withFileTypes: true });
+  } catch {
+    return;
+  }
+  for (const item of items) {
+    if (item.name === "node_modules" || item.name.startsWith("."))
+      continue;
+    const full = join37(dir, item.name);
+    if (item.isDirectory()) {
+      await walkSvelteFiles(full, out);
+    } else if (item.isFile() && item.name.endsWith(".svelte")) {
+      out.push(full);
+    }
+  }
+}, analyzeSvelteSpaRoutes = async (svelteDirectory) => {
+  if (!existsSync33(svelteDirectory))
+    return [];
+  const files = [];
+  await walkSvelteFiles(svelteDirectory, files);
+  const hosts = [];
+  await Promise.all(files.map(async (file5) => {
+    try {
+      const host = await analyzeFile3(file5);
+      if (host)
+        hosts.push(host);
+    } catch (err) {
+      console.warn(`[sitemap] Svelte SPA analysis failed for ${file5}:`, err);
+    }
+  }));
+  return hosts;
+};
+var init_staticAnalyzeSpaRoutes3 = __esm(() => {
+  DYNAMIC_SEGMENT_PATTERN3 = /^[:*]/;
+  ROUTER_OPEN_TAG_PATTERN = /<Router\b([^>]*)>/g;
+  ROUTE_TAG_PATTERN = /<Route\b([^>]*)\/?>/g;
+});
+
+// src/vue/staticAnalyzeSpaRoutes.ts
+import { existsSync as existsSync34, promises as fs5 } from "fs";
+import { join as join38 } from "path";
+import ts10 from "typescript";
+var DYNAMIC_SEGMENT_PATTERN4, pathHasDynamic4 = (path) => path.split("/").some((seg) => DYNAMIC_SEGMENT_PATTERN4.test(seg) || seg === "**"), readStringLiteral3 = (expression) => {
+  if (ts10.isStringLiteral(expression) || ts10.isNoSubstitutionTemplateLiteral(expression)) {
+    return expression.text;
+  }
+  return null;
+}, readPropertyKey3 = (property) => {
+  if (ts10.isPropertyAssignment(property)) {
+    const name = property.name;
+    if (ts10.isIdentifier(name) || ts10.isStringLiteral(name))
+      return name.text;
+  }
+  if (ts10.isShorthandPropertyAssignment(property)) {
+    return property.name.text;
+  }
+  return null;
+}, importsSymbolFrom2 = (sf, localName, moduleSpecifier) => {
+  for (const statement of sf.statements) {
+    if (!ts10.isImportDeclaration(statement))
+      continue;
+    if (!ts10.isStringLiteral(statement.moduleSpecifier))
+      continue;
+    if (statement.moduleSpecifier.text !== moduleSpecifier)
+      continue;
+    const named = statement.importClause?.namedBindings;
+    if (!named || !ts10.isNamedImports(named))
+      continue;
+    for (const element of named.elements) {
+      if (element.name.text === localName)
+        return true;
+    }
+  }
+  return false;
+}, findVariableArrayDeclaration2 = (sf, identifierName) => {
+  let found = null;
+  const visit = (node) => {
+    if (found)
+      return;
+    if (ts10.isVariableDeclaration(node) && ts10.isIdentifier(node.name) && node.name.text === identifierName && node.initializer && ts10.isArrayLiteralExpression(node.initializer)) {
+      found = node.initializer;
+      return;
+    }
+    ts10.forEachChild(node, visit);
+  };
+  ts10.forEachChild(sf, visit);
+  return found;
+}, joinSegments4 = (parent, child) => {
+  if (!child)
+    return parent;
+  if (!parent)
+    return child;
+  return `${parent.replace(/\/+$/, "")}/${child.replace(/^\/+/, "")}`;
+}, extractRouteEntries2 = (arr, parentPath, out) => {
+  for (const element of arr.elements) {
+    if (!ts10.isObjectLiteralExpression(element))
+      continue;
+    let pathSegment = null;
+    let redirected = false;
+    let sitemapExcluded = false;
+    let childrenLiteral = null;
+    for (const property of element.properties) {
+      const key = readPropertyKey3(property);
+      if (!key)
+        continue;
+      if (!ts10.isPropertyAssignment(property))
+        continue;
+      if (key === "path") {
+        pathSegment = readStringLiteral3(property.initializer);
+      } else if (key === "redirect") {
+        redirected = true;
+      } else if (key === "children" && ts10.isArrayLiteralExpression(property.initializer)) {
+        childrenLiteral = property.initializer;
+      } else if (key === "meta" && ts10.isObjectLiteralExpression(property.initializer)) {
+        for (const metaProp of property.initializer.properties) {
+          const metaKey = readPropertyKey3(metaProp);
+          if (metaKey !== "sitemap")
+            continue;
+          if (!ts10.isPropertyAssignment(metaProp))
+            continue;
+          const value = readStringLiteral3(metaProp.initializer);
+          if (value === "exclude")
+            sitemapExcluded = true;
+        }
+      }
+    }
+    if (pathSegment === null)
+      continue;
+    const joined = joinSegments4(parentPath, pathSegment);
+    if (childrenLiteral) {
+      extractRouteEntries2(childrenLiteral, joined, out);
+      continue;
+    }
+    if (redirected)
+      continue;
+    if (joined === "")
+      continue;
+    out.push({
+      dynamic: pathHasDynamic4(joined),
+      path: joined,
+      redirected,
+      sitemapExcluded
+    });
+  }
+}, findCreateRouterCall = (sf) => {
+  let found = null;
+  const visit = (node) => {
+    if (found)
+      return;
+    if (ts10.isCallExpression(node) && ts10.isIdentifier(node.expression) && node.expression.text === "createRouter") {
+      found = node;
+      return;
+    }
+    ts10.forEachChild(node, visit);
+  };
+  ts10.forEachChild(sf, visit);
+  return found;
+}, findCreateWebHistoryBase = (sf) => {
+  let found = null;
+  const visit = (node) => {
+    if (found)
+      return;
+    if (ts10.isCallExpression(node) && ts10.isIdentifier(node.expression) && (node.expression.text === "createWebHistory" || node.expression.text === "createWebHashHistory")) {
+      const baseArg = node.arguments[0];
+      if (baseArg) {
+        const text = readStringLiteral3(baseArg);
+        if (text !== null) {
+          found = text;
+          return;
+        }
+      } else {
+        found = "/";
+        return;
+      }
+    }
+    ts10.forEachChild(node, visit);
+  };
+  ts10.forEachChild(sf, visit);
+  return found;
+}, readRoutesFromCreateRouterOptions = (sf, optionsExpr) => {
+  if (!ts10.isObjectLiteralExpression(optionsExpr))
+    return null;
+  for (const property of optionsExpr.properties) {
+    const key = readPropertyKey3(property);
+    if (key !== "routes")
+      continue;
+    if (ts10.isShorthandPropertyAssignment(property)) {
+      return findVariableArrayDeclaration2(sf, property.name.text);
+    }
+    if (!ts10.isPropertyAssignment(property))
+      continue;
+    if (ts10.isArrayLiteralExpression(property.initializer)) {
+      return property.initializer;
+    }
+    if (ts10.isIdentifier(property.initializer)) {
+      return findVariableArrayDeclaration2(sf, property.initializer.text);
+    }
+  }
+  return null;
+}, extractScriptBlockFromVueSfc = (source) => {
+  const scriptRe = /<script\b[^>]*?(?:setup)?[^>]*>([\s\S]*?)<\/script>/i;
+  const match = scriptRe.exec(source);
+  return match ? match[1] ?? null : null;
+}, analyzeFile4 = async (filePath) => {
+  let source;
+  try {
+    source = await fs5.readFile(filePath, "utf-8");
+  } catch {
+    return null;
+  }
+  let analysisSource = source;
+  if (filePath.endsWith(".vue")) {
+    const script = extractScriptBlockFromVueSfc(source);
+    if (script === null)
+      return null;
+    analysisSource = script;
+  }
+  if (!analysisSource.includes("createRouter"))
+    return null;
+  const sf = ts10.createSourceFile(filePath, analysisSource, ts10.ScriptTarget.Latest, true, ts10.ScriptKind.TS);
+  if (!importsSymbolFrom2(sf, "createRouter", "vue-router"))
+    return null;
+  const call = findCreateRouterCall(sf);
+  if (!call)
+    return null;
+  const optionsArg = call.arguments[0];
+  if (!optionsArg)
+    return null;
+  const routesArray = readRoutesFromCreateRouterOptions(sf, optionsArg);
+  if (!routesArray)
+    return null;
+  const base = findCreateWebHistoryBase(sf) ?? "/";
+  const baseHref = base.endsWith("/") ? base : `${base}/`;
+  const routes = [];
+  extractRouteEntries2(routesArray, "", routes);
+  return { baseHref, routes, sourceFile: filePath };
+}, walkSourceFiles2 = async (dir, out) => {
+  let items;
+  try {
+    items = await fs5.readdir(dir, { withFileTypes: true });
+  } catch {
+    return;
+  }
+  for (const item of items) {
+    if (item.name === "node_modules" || item.name.startsWith("."))
+      continue;
+    const full = join38(dir, item.name);
+    if (item.isDirectory()) {
+      await walkSourceFiles2(full, out);
+    } else if (item.isFile() && (item.name.endsWith(".ts") || item.name.endsWith(".js") || item.name.endsWith(".vue")) && !item.name.endsWith(".d.ts")) {
+      out.push(full);
+    }
+  }
+}, analyzeVueSpaRoutes = async (vueDirectory) => {
+  if (!existsSync34(vueDirectory))
+    return [];
+  const files = [];
+  await walkSourceFiles2(vueDirectory, files);
+  const hosts = [];
+  await Promise.all(files.map(async (file5) => {
+    try {
+      const host = await analyzeFile4(file5);
+      if (host)
+        hosts.push(host);
+    } catch (err) {
+      console.warn(`[sitemap] Vue SPA analysis failed for ${file5}:`, err);
+    }
+  }));
+  return hosts;
+};
+var init_staticAnalyzeSpaRoutes4 = __esm(() => {
+  DYNAMIC_SEGMENT_PATTERN4 = /^[:*]/;
 });
 
 // src/utils/generateSitemap.ts
@@ -25657,22 +26390,31 @@ var DEFAULT_PRIORITY = 0.8, escapeXml = (str) => str.replace(/&/g, "&amp;").repl
       return true;
   }
   return false;
-}, discoverPageRoutes = (routes, exclude) => {
+}, stripTrailingWildcard = (path) => path.replace(/\/\*+$/, ""), isWildcardPagePath = (path) => path.endsWith("/*") || path.endsWith("*"), discoverPageRoutes = (routes, exclude) => {
   const seen = new Set;
-  return routes.filter((route) => {
+  const out = [];
+  for (const route of routes) {
     if (route.method !== "GET")
-      return false;
-    if (route.path.includes("*") || route.path.includes(":"))
-      return false;
-    if (seen.has(route.path))
-      return false;
-    if (isExcluded(route.path, exclude))
-      return false;
+      continue;
+    if (route.path.includes(":"))
+      continue;
+    const mountPath = stripTrailingWildcard(route.path);
+    if (mountPath.includes("*"))
+      continue;
     if (!isPageHandler(route.handler))
-      return false;
-    seen.add(route.path);
-    return true;
-  });
+      continue;
+    if (seen.has(mountPath))
+      continue;
+    if (isExcluded(mountPath, exclude))
+      continue;
+    seen.add(mountPath);
+    out.push({
+      emitTopLevel: !isWildcardPagePath(route.path),
+      mountPath,
+      rawPath: route.path
+    });
+  }
+  return out;
 }, joinMountAndSubPath = (mount, sub) => {
   const trimmedMount = mount.replace(/\/+$/, "");
   const trimmedSub = sub.replace(/^\/+/, "");
@@ -25681,27 +26423,30 @@ var DEFAULT_PRIORITY = 0.8, escapeXml = (str) => str.replace(/&/g, "&amp;").repl
   if (!trimmedMount)
     return `/${trimmedSub}`;
   return `${trimmedMount}/${trimmedSub}`;
+}, normalizeMountFromBaseHref = (baseHref) => {
+  const stripped = baseHref.replace(/\/+$/, "");
+  return stripped === "" ? "/" : stripped;
 }, buildSitemapXml = (entries, baseUrl, config) => {
   const normalizedBase = baseUrl.replace(/\/$/, "");
   const xml = [];
   for (const entry of entries) {
     const override = config.overrides?.[entry.path];
-    const changefreq = override?.changefreq ?? entry.changefreq ?? config.defaultChangefreq ?? "weekly";
-    const priority = override?.priority ?? entry.priority ?? config.defaultPriority ?? DEFAULT_PRIORITY;
-    const lastmod = override?.lastmod ?? entry.lastmod;
+    const changefreq = override?.changefreq ?? config.defaultChangefreq ?? "weekly";
+    const priority = override?.priority ?? config.defaultPriority ?? DEFAULT_PRIORITY;
+    const lastmod = override?.lastmod;
     const url = escapeXml(`${normalizedBase}${entry.path}`);
-    let urlBlock = `  <url>
+    let block = `  <url>
     <loc>${url}</loc>`;
     if (lastmod)
-      urlBlock += `
+      block += `
     <lastmod>${lastmod}</lastmod>`;
-    urlBlock += `
+    block += `
     <changefreq>${changefreq}</changefreq>`;
-    urlBlock += `
+    block += `
     <priority>${priority}</priority>`;
-    urlBlock += `
+    block += `
   </url>`;
-    xml.push(urlBlock);
+    xml.push(block);
   }
   return [
     '<?xml version="1.0" encoding="UTF-8"?>',
@@ -25710,59 +26455,74 @@ var DEFAULT_PRIORITY = 0.8, escapeXml = (str) => str.replace(/&/g, "&amp;").repl
     "</urlset>"
   ].join(`
 `);
-}, resolveSpaEntryMetadata = (entry) => {
-  if (!entry.sitemap || typeof entry.sitemap !== "object")
-    return {};
-  return {
-    changefreq: entry.sitemap.changefreq,
-    lastmod: entry.sitemap.lastmod,
-    priority: entry.sitemap.priority
-  };
-}, collectPageSubRoutes = async (app, route, serverUrl) => {
-  const request = new Request(`${serverUrl}${route.path}`, {
-    headers: { "x-absolutejs-enumeration": "1" },
-    method: "GET"
-  });
-  return collectSpaRoutes(async () => {
-    try {
-      await app.handle(request);
-    } catch (err) {
-      console.warn(`[sitemap] enumeration request failed for ${route.path}:`, err);
-    }
-  });
-}, generateSitemap = async (app, serverUrl, outDir, config = {}) => {
-  const exclude = config.exclude ?? [];
-  const pageRoutes = discoverPageRoutes(app.routes, exclude);
-  const entries = [];
-  const seenPaths = new Set;
-  for (const route of pageRoutes) {
-    if (!seenPaths.has(route.path)) {
-      entries.push({ path: route.path });
-      seenPaths.add(route.path);
-    }
-    const subRoutes = await collectPageSubRoutes(app, route, serverUrl);
-    for (const sub of subRoutes) {
-      if (sub.dynamic)
+}, collectFrameworkSpaEntries = (hosts, wildcardMounts, exclude, seenPaths) => {
+  const out = [];
+  for (const host of hosts) {
+    const mount = normalizeMountFromBaseHref(host.baseHref);
+    if (!wildcardMounts.has(mount))
+      continue;
+    for (const route of host.routes) {
+      if (route.dynamic)
+        continue;
+      if (route.redirected)
         continue;
-      if (sub.sitemap === "exclude")
+      if (route.sitemapExcluded)
         continue;
-      const fullPath = joinMountAndSubPath(route.path, sub.path);
+      const fullPath = joinMountAndSubPath(mount, route.path);
       if (seenPaths.has(fullPath))
         continue;
       if (isExcluded(fullPath, exclude))
         continue;
-      entries.push({ path: fullPath, ...resolveSpaEntryMetadata(sub) });
       seenPaths.add(fullPath);
+      out.push({ path: fullPath });
     }
   }
-  const dynamicConfigRoutes = config.routes ? await config.routes() : [];
-  for (const path of dynamicConfigRoutes) {
+  return out;
+}, runAnalyzer = async (label, analyzer) => {
+  try {
+    return await analyzer();
+  } catch (err) {
+    console.warn(`[sitemap] ${label} SPA analysis failed:`, err);
+    return [];
+  }
+}, generateSitemap = async (routes, serverUrl, outDir, config = {}, pipelineConfig = {}) => {
+  const exclude = config.exclude ?? [];
+  const discoveredPages = discoverPageRoutes(routes, exclude);
+  const seenPaths = new Set;
+  const entries = [];
+  for (const page of discoveredPages) {
+    if (!page.emitTopLevel)
+      continue;
+    if (seenPaths.has(page.mountPath))
+      continue;
+    seenPaths.add(page.mountPath);
+    entries.push({ path: page.mountPath });
+  }
+  const wildcardMounts = new Set(discoveredPages.filter((page) => !page.emitTopLevel).map((page) => page.mountPath));
+  const analyzerJobs = [];
+  if (pipelineConfig.angularDirectory) {
+    analyzerJobs.push(runAnalyzer("Angular", () => analyzeAngularSpaRoutes(pipelineConfig.angularDirectory)));
+  }
+  if (pipelineConfig.reactDirectory) {
+    analyzerJobs.push(runAnalyzer("React", () => analyzeReactSpaRoutes(pipelineConfig.reactDirectory)));
+  }
+  if (pipelineConfig.svelteDirectory) {
+    analyzerJobs.push(runAnalyzer("Svelte", () => analyzeSvelteSpaRoutes(pipelineConfig.svelteDirectory)));
+  }
+  if (pipelineConfig.vueDirectory) {
+    analyzerJobs.push(runAnalyzer("Vue", () => analyzeVueSpaRoutes(pipelineConfig.vueDirectory)));
+  }
+  const allHosts = (await Promise.all(analyzerJobs)).flat();
+  const spaEntries = collectFrameworkSpaEntries(allHosts, wildcardMounts, exclude, seenPaths);
+  entries.push(...spaEntries);
+  const dynamicRoutes = config.routes ? await config.routes() : [];
+  for (const path of dynamicRoutes) {
     if (seenPaths.has(path))
       continue;
     if (isExcluded(path, exclude))
       continue;
-    entries.push({ path });
     seenPaths.add(path);
+    entries.push({ path });
   }
   const baseUrl = config.baseUrl ?? serverUrl;
   const xml = buildSitemapXml(entries, baseUrl, config);
@@ -25770,7 +26530,10 @@ var DEFAULT_PRIORITY = 0.8, escapeXml = (str) => str.replace(/&/g, "&amp;").repl
 };
 var init_generateSitemap = __esm(() => {
   init_devRouteRegistrationCallsite();
-  init_spaRouteEnumeration();
+  init_staticAnalyzeSpaRoutes();
+  init_staticAnalyzeSpaRoutes2();
+  init_staticAnalyzeSpaRoutes3();
+  init_staticAnalyzeSpaRoutes4();
 });
 
 // src/core/prerender.ts
@@ -25784,7 +26547,7 @@ __export(exports_prerender, {
   PRERENDER_BYPASS_HEADER: () => PRERENDER_BYPASS_HEADER
 });
 import { mkdirSync as mkdirSync16, readFileSync as readFileSync23 } from "fs";
-import { join as join35 } from "path";
+import { join as join39 } from "path";
 var SERVER_OUTPUT_LIMIT = 4000, STARTUP_POLL_INTERVAL_MS = 100, DEFAULT_STARTUP_TIMEOUT_MS = 30000, PRERENDER_BYPASS_HEADER = "X-Absolute-Prerender-Bypass", routeToFilename = (route) => route === "/" ? "index.html" : `${route.slice(1).replace(/\//g, "-")}.html`, writeTimestamp = async (htmlPath) => {
   const metaPath = htmlPath.replace(/\.html$/, ".meta");
   await Bun.write(metaPath, String(Date.now()));
@@ -25850,7 +26613,7 @@ var SERVER_OUTPUT_LIMIT = 4000, STARTUP_POLL_INTERVAL_MS = 100, DEFAULT_STARTUP_
       return false;
     const html = await res.text();
     const fileName = routeToFilename(route);
-    const filePath = join35(prerenderDir, fileName);
+    const filePath = join39(prerenderDir, fileName);
     await Bun.write(filePath, html);
     await writeTimestamp(filePath);
     return true;
@@ -25876,13 +26639,13 @@ var SERVER_OUTPUT_LIMIT = 4000, STARTUP_POLL_INTERVAL_MS = 100, DEFAULT_STARTUP_
   }
   const html = await res.text();
   const fileName = routeToFilename(route);
-  const filePath = join35(prerenderDir, fileName);
+  const filePath = join39(prerenderDir, fileName);
   await Bun.write(filePath, html);
   await writeTimestamp(filePath);
   result.routes.set(route, filePath);
   log2?.(`  Pre-rendered ${route} \u2192 ${fileName} (${html.length} bytes)`);
 }, prerender = async (port, outDir, staticConfig, log2) => {
-  const prerenderDir = join35(outDir, "_prerendered");
+  const prerenderDir = join39(outDir, "_prerendered");
   mkdirSync16(prerenderDir, { recursive: true });
   const baseUrl = `http://localhost:${port}`;
   let routes;
@@ -25982,14 +26745,14 @@ __export(exports_serverEntryWatcher, {
   startServerEntryWatcher: () => startServerEntryWatcher,
   isAtomicWriteTemp: () => isAtomicWriteTemp
 });
-import { existsSync as existsSync33, statSync as statSync8, watch as watch2 } from "fs";
+import { existsSync as existsSync37, statSync as statSync8, watch as watch2 } from "fs";
 import { createRequire as createRequire2 } from "module";
-import { dirname as dirname26, join as join38, resolve as resolve46 } from "path";
+import { dirname as dirname26, join as join42, resolve as resolve46 } from "path";
 var ATOMIC_RECOVERY_WINDOW_MS = 1000, RELOAD_DEBOUNCE_MS = 80, ATOMIC_WRITE_TEMP_PATTERNS2, isAtomicWriteTemp = (filename) => filename.endsWith(".tmp") || filename.includes(".tmp.") || filename.endsWith("~") || filename.startsWith(".#") || ATOMIC_WRITE_TEMP_PATTERNS2.some((re2) => re2.test(filename)), startServerEntryWatcher = () => {
   if (globalThis.__absoluteEntryWatcherStarted)
     return;
   const main = Bun.main;
-  if (!main || !existsSync33(main))
+  if (!main || !existsSync37(main))
     return;
   globalThis.__absoluteEntryWatcherStarted = true;
   const entryPath = resolve46(main);
@@ -26087,7 +26850,7 @@ var ATOMIC_RECOVERY_WINDOW_MS = 1000, RELOAD_DEBOUNCE_MS = 80, ATOMIC_WRITE_TEMP
         continue;
       let st2;
       try {
-        st2 = statSync8(join38(dir, entry.name));
+        st2 = statSync8(join42(dir, entry.name));
       } catch {
         continue;
       }
@@ -26642,8 +27405,8 @@ var handleHTMXPageRequest = async (pagePath) => {
 };
 // src/core/prepare.ts
 init_loadConfig();
-import { existsSync as existsSync31, readdirSync as readdirSync4, readFileSync as readFileSync24 } from "fs";
-import { basename as basename14, join as join36, relative as relative17, resolve as resolve45 } from "path";
+import { existsSync as existsSync35, readdirSync as readdirSync4, readFileSync as readFileSync24 } from "fs";
+import { basename as basename14, join as join40, relative as relative17, resolve as resolve45 } from "path";
 import { Elysia as Elysia5 } from "elysia";
 
 // src/core/loadIslandRegistry.ts
@@ -27042,7 +27805,7 @@ var patchManifestIndexes = (manifest, devIndexDir, SRC_URL_PREFIX2) => {
     if (!fileName)
       continue;
     const srcPath = resolve45(devIndexDir, fileName);
-    if (!existsSync31(srcPath))
+    if (!existsSync35(srcPath))
       continue;
     const rel = relative17(process.cwd(), srcPath).replace(/\\/g, "/");
     manifest[key] = `${SRC_URL_PREFIX2}${rel}`;
@@ -27140,7 +27903,12 @@ var prepareDev = async (config, buildDir) => {
     maxAge: null,
     prefix: "",
     staticLimit: MAX_STATIC_ROUTE_COUNT
-  })).use(hmrPlugin).use(createSitemapPlugin(buildDir, config.sitemap)).use(createBuildErrorRecoveryPlugin()).use(createNotFoundPlugin());
+  })).use(hmrPlugin).use(createSitemapPlugin(buildDir, config.sitemap, {
+    angularDirectory: config.angularDirectory,
+    reactDirectory: config.reactDirectory,
+    svelteDirectory: config.svelteDirectory,
+    vueDirectory: config.vueDirectory
+  })).use(createBuildErrorRecoveryPlugin()).use(createNotFoundPlugin());
   recordStep("assemble dev runtime", stepStartedAt);
   logStartupTimingBlock("AbsoluteJS prepareDev timing", startupSteps);
   return {
@@ -27150,7 +27918,7 @@ var prepareDev = async (config, buildDir) => {
 };
 var loadPrerenderMap = (prerenderDir) => {
   const map = new Map;
-  if (!existsSync31(prerenderDir))
+  if (!existsSync35(prerenderDir))
     return map;
   let entries;
   try {
@@ -27163,15 +27931,15 @@ var loadPrerenderMap = (prerenderDir) => {
       continue;
     const name = basename14(entry, ".html");
     const route = name === "index" ? "/" : `/${name}`;
-    map.set(route, join36(prerenderDir, entry));
+    map.set(route, join40(prerenderDir, entry));
   }
   return map;
 };
-var createSitemapPlugin = (buildDir, sitemapConfig) => new Elysia5({ name: "absolutejs-sitemap" }).onStart((started) => {
+var createSitemapPlugin = (buildDir, sitemapConfig, pipelineConfig) => new Elysia5({ name: "absolutejs-sitemap" }).onStart((started) => {
   const { server } = started;
   if (!server)
     return;
-  Promise.resolve().then(() => (init_generateSitemap(), exports_generateSitemap)).then(({ generateSitemap: generateSitemap2 }) => generateSitemap2(started, server.url.origin, buildDir, sitemapConfig)).catch((err) => console.error("[sitemap] Generation failed:", err));
+  Promise.resolve().then(() => (init_generateSitemap(), exports_generateSitemap)).then(({ generateSitemap: generateSitemap2 }) => generateSitemap2(started.routes, server.url.origin, buildDir, sitemapConfig, pipelineConfig)).catch((err) => console.error("[sitemap] Generation failed:", err));
 });
 var createNotFoundPlugin = () => new Elysia5({ name: "absolutejs-not-found" }).onError({ as: "global" }, async ({ code }) => {
   if (code !== "NOT_FOUND")
@@ -27229,8 +27997,8 @@ var prepare = async (configOrPath) => {
   setCurrentPageIslandMetadata(await loadPageIslandMetadata(config));
   recordStep("load production manifest and island metadata", stepStartedAt);
   stepStartedAt = performance.now();
-  const conventionsPath = join36(buildDir, "conventions.json");
-  if (existsSync31(conventionsPath)) {
+  const conventionsPath = join40(buildDir, "conventions.json");
+  if (existsSync35(conventionsPath)) {
     const conventions2 = JSON.parse(readFileSync24(conventionsPath, "utf-8"));
     setConventions(conventions2);
   }
@@ -27245,7 +28013,7 @@ var prepare = async (configOrPath) => {
   });
   recordStep("create static plugin", stepStartedAt);
   stepStartedAt = performance.now();
-  const prerenderDir = join36(buildDir, "_prerendered");
+  const prerenderDir = join40(buildDir, "_prerendered");
   const prerenderMap = loadPrerenderMap(prerenderDir);
   recordStep("load prerender map", stepStartedAt);
   if (prerenderMap.size > 0) {
@@ -27276,14 +28044,24 @@ var prepare = async (configOrPath) => {
     });
     stepStartedAt = performance.now();
     const { imageOptimizer: imageOptimizer3 } = await Promise.resolve().then(() => (init_imageOptimizer(), exports_imageOptimizer));
-    const absolutejs2 = new Elysia5({ name: "absolutejs-runtime" }).use(imageOptimizer3(config.images, buildDir)).use(prerenderPlugin).use(staticFiles).use(createSitemapPlugin(buildDir, config.sitemap)).use(createNotFoundPlugin());
+    const absolutejs2 = new Elysia5({ name: "absolutejs-runtime" }).use(imageOptimizer3(config.images, buildDir)).use(prerenderPlugin).use(staticFiles).use(createSitemapPlugin(buildDir, config.sitemap, {
+      angularDirectory: config.angularDirectory,
+      reactDirectory: config.reactDirectory,
+      svelteDirectory: config.svelteDirectory,
+      vueDirectory: config.vueDirectory
+    })).use(createNotFoundPlugin());
     recordStep("assemble production runtime", stepStartedAt);
     logStartupTimingBlock("AbsoluteJS prepare timing", startupSteps);
     return { absolutejs: absolutejs2, manifest };
   }
   stepStartedAt = performance.now();
   const { imageOptimizer: imageOptimizer2 } = await Promise.resolve().then(() => (init_imageOptimizer(), exports_imageOptimizer));
-  const absolutejs = new Elysia5({ name: "absolutejs-runtime" }).use(imageOptimizer2(config.images, buildDir)).use(staticFiles).use(createSitemapPlugin(buildDir, config.sitemap)).use(createNotFoundPlugin());
+  const absolutejs = new Elysia5({ name: "absolutejs-runtime" }).use(imageOptimizer2(config.images, buildDir)).use(staticFiles).use(createSitemapPlugin(buildDir, config.sitemap, {
+    angularDirectory: config.angularDirectory,
+    reactDirectory: config.reactDirectory,
+    svelteDirectory: config.svelteDirectory,
+    vueDirectory: config.vueDirectory
+  })).use(createNotFoundPlugin());
   recordStep("assemble production runtime", stepStartedAt);
   logStartupTimingBlock("AbsoluteJS prepare timing", startupSteps);
   return { absolutejs, manifest };
@@ -27303,15 +28081,15 @@ import { argv } from "process";
 var {env: env4 } = globalThis.Bun;
 
 // src/dev/devCert.ts
-import { existsSync as existsSync32, mkdirSync as mkdirSync17, readFileSync as readFileSync25, rmSync as rmSync4 } from "fs";
-import { join as join37 } from "path";
-var CERT_DIR = join37(process.cwd(), ".absolutejs");
-var CERT_PATH = join37(CERT_DIR, "cert.pem");
-var KEY_PATH = join37(CERT_DIR, "key.pem");
+import { existsSync as existsSync36, mkdirSync as mkdirSync17, readFileSync as readFileSync25, rmSync as rmSync4 } from "fs";
+import { join as join41 } from "path";
+var CERT_DIR = join41(process.cwd(), ".absolutejs");
+var CERT_PATH = join41(CERT_DIR, "cert.pem");
+var KEY_PATH = join41(CERT_DIR, "key.pem");
 var CERT_VALIDITY_DAYS = 365;
 var devLog = (msg) => console.log(`\x1B[2m${new Date().toLocaleTimeString()}\x1B[0m \x1B[36m[dev]\x1B[0m ${msg}`);
 var devWarn = (msg) => console.log(`\x1B[2m${new Date().toLocaleTimeString()}\x1B[0m \x1B[33m[dev]\x1B[0m \x1B[33m${msg}\x1B[0m`);
-var certFilesExist = () => existsSync32(CERT_PATH) && existsSync32(KEY_PATH);
+var certFilesExist = () => existsSync36(CERT_PATH) && existsSync36(KEY_PATH);
 var isCertExpired = () => {
   try {
     const certPem = readFileSync25(CERT_PATH, "utf-8");
@@ -27686,7 +28464,7 @@ var generateHeadElement = ({
 };
 // src/utils/defineEnv.ts
 var {env: bunEnv } = globalThis.Bun;
-import { existsSync as existsSync34, readFileSync as readFileSync26 } from "fs";
+import { existsSync as existsSync38, readFileSync as readFileSync26 } from "fs";
 import { resolve as resolve47 } from "path";
 
 // node_modules/@sinclair/typebox/build/esm/type/guard/value.mjs
@@ -33723,7 +34501,7 @@ ${lines.join(`
 var checkEnvFileSecurity = (properties) => {
   const cwd2 = process.cwd();
   const envPath = resolve47(cwd2, ".env");
-  if (!existsSync34(envPath))
+  if (!existsSync38(envPath))
     return;
   const sensitiveKeys = Object.keys(properties).filter(isSensitive);
   if (sensitiveKeys.length === 0)
@@ -33733,7 +34511,7 @@ var checkEnvFileSecurity = (properties) => {
   if (presentKeys.length === 0)
     return;
   const gitignorePath = resolve47(cwd2, ".gitignore");
-  if (existsSync34(gitignorePath)) {
+  if (existsSync38(gitignorePath)) {
     const gitignore = readFileSync26(gitignorePath, "utf-8");
     if (gitignore.split(`
 `).some((line) => line.trim() === ".env"))
@@ -33975,5 +34753,5 @@ export {
   ANGULAR_INIT_TIMEOUT_MS
 };
 
-//# debugId=27DB5119E1E545AE64756E2164756E21
+//# debugId=8CC7B20D34E950DD64756E2164756E21
 //# sourceMappingURL=index.js.map