@edgeone/nuxt-pages 1.0.16 → 1.1.0-beta.1

package/dist/build/content/server.js

@@ -8,7 +8,7 @@ import {
   RUN_CONFIG_FILE,
   copyNuxtServerCode,
   verifyNuxtHandlerDirStructure
-} from "../../esm-chunks/chunk-NJ4SUJNF.js";
+} from "../../esm-chunks/chunk-TP3RAVPL.js";
 import "../../esm-chunks/chunk-V2LFVP3C.js";
 import "../../esm-chunks/chunk-6BT4RYQJ.js";
 export {

package/dist/build/content/static.js

@@ -7,8 +7,8 @@
 import {
   addNitroBuildOutputConfig,
   resetNitroConfig
-} from "../../esm-chunks/chunk-7X4RPD4I.js";
-import "../../esm-chunks/chunk-MONI3XWQ.js";
+} from "../../esm-chunks/chunk-7RNB5RB6.js";
+import "../../esm-chunks/chunk-5JK44IEA.js";
 import "../../esm-chunks/chunk-V2LFVP3C.js";
 import "../../esm-chunks/chunk-6BT4RYQJ.js";
 export {

package/dist/build/functions/server.js

@@ -7,8 +7,8 @@
 import {
   createServerHandler,
   patchNitroHandler
-} from "../../esm-chunks/chunk-RNEZUAPL.js";
-import "../../esm-chunks/chunk-NJ4SUJNF.js";
+} from "../../esm-chunks/chunk-L23O2KDO.js";
+import "../../esm-chunks/chunk-TP3RAVPL.js";
 import "../../esm-chunks/chunk-V2LFVP3C.js";
 import "../../esm-chunks/chunk-6BT4RYQJ.js";
 export {

package/dist/build/plugin-context.js

@@ -7,8 +7,8 @@
 import {
   PluginContext,
   SERVER_HANDLER_NAME
-} from "../esm-chunks/chunk-BZQMVWYQ.js";
-import "../esm-chunks/chunk-MONI3XWQ.js";
+} from "../esm-chunks/chunk-Y3YAV6NZ.js";
+import "../esm-chunks/chunk-5JK44IEA.js";
 import "../esm-chunks/chunk-6BT4RYQJ.js";
 export {
   PluginContext,

package/dist/build/routes.js

@@ -6,11 +6,13 @@
     
 import {
   createNuxtApiRoutesMeta,
-  createNuxtPagesRouteMeta
-} from "../esm-chunks/chunk-J25U56II.js";
-import "../esm-chunks/chunk-MONI3XWQ.js";
+  createNuxtPagesRouteMeta,
+  createNuxtRoutesMeta
+} from "../esm-chunks/chunk-FZBQIMQA.js";
+import "../esm-chunks/chunk-5JK44IEA.js";
 import "../esm-chunks/chunk-6BT4RYQJ.js";
 export {
   createNuxtApiRoutesMeta,
-  createNuxtPagesRouteMeta
+  createNuxtPagesRouteMeta,
+  createNuxtRoutesMeta
 };

package/dist/esm-chunks/{chunk-MONI3XWQ.js → chunk-5JK44IEA.js}

@@ -14823,7 +14823,7 @@ function addCodeToGenerateEdgeoneWithAST(code, insertCode) {
     const newOutputConfig = {
       dir: ".edgeone",
       publicDir: ".edgeone/assets",
-      serverDir: ".edgeone/server-handler"
+      serverDir: ".edgeone/cloud-functions/ssr-node"
     };
     if (!hasNitro) {
       oldOutputValue = null;
@@ -14832,7 +14832,7 @@ function addCodeToGenerateEdgeoneWithAST(code, insertCode) {
     output: {
       dir: '.edgeone',
       publicDir: '.edgeone/assets',
-      serverDir: '.edgeone/server-handler',
+      serverDir: '.edgeone/cloud-functions/ssr-node',
     },
   }`;
       if (existingConfigContent) {
@@ -14871,7 +14871,7 @@ ${nitroConfig}
       const outputConfigStr = `    output: {
       dir: '.edgeone',
       publicDir: '.edgeone/assets',
-      serverDir: '.edgeone/server-handler',
+      serverDir: '.edgeone/cloud-functions/ssr-node',
     }`;
       let newNitroContent;
       const properties = [];

package/dist/esm-chunks/{chunk-7X4RPD4I.js → chunk-7RNB5RB6.js}

@@ -7,7 +7,7 @@
 import {
   addCodeToGenerateEdgeoneWithAST,
   resetNitroConfigWithAST
-} from "./chunk-MONI3XWQ.js";
+} from "./chunk-5JK44IEA.js";
 import {
   trace,
   wrapTracer
@@ -35,7 +35,7 @@ var addNitroBuildOutputConfig = async (ctx) => {
               output: {
                 dir: '.edgeone',
                 publicDir: '.edgeone/assets',
-                serverDir: '.edgeone/server-handler',
+                serverDir: '.edgeone/cloud-functions/ssr-node',
               },
             },
             devtools: { enabled: true },
@@ -57,7 +57,7 @@ var addNitroBuildOutputConfig = async (ctx) => {
               output: {
                 dir: '.edgeone',
                 publicDir: '.edgeone/assets',
-                serverDir: '.edgeone/server-handler',
+                serverDir: '.edgeone/cloud-functions/ssr-node',
               },
             },
           `);

package/dist/esm-chunks/chunk-FZBQIMQA.js

@@ -0,0 +1,260 @@
+
+      var require = await (async () => {
+        var { createRequire } = await import("node:module");
+        return createRequire(import.meta.url);
+      })();
+    
+import {
+  getHandlersArrayWithAST,
+  getRouteRulesWithAST
+} from "./chunk-5JK44IEA.js";
+
+// src/build/routes.ts
+import * as fs from "fs";
+import * as path from "path";
+var CONFIG_VERSION = 3;
+var CONFIG_FILE_NAME = "config.json";
+function escapeRegExp(str) {
+  return str.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+function normalizeRoutePath(p) {
+  if (!p) return "/";
+  const clean = p.split("?")[0];
+  if (clean === "" || clean === "/") return "/";
+  return clean.startsWith("/") ? clean.replace(/\/+$/, "") : `/${clean.replace(/\/+$/, "")}`;
+}
+function ensureServerHandlerDir() {
+  const edgeOneDir = path.join(process.cwd(), ".edgeone");
+  const serverHandlerDir = path.join(edgeOneDir, "cloud-functions", "ssr-node");
+  if (!fs.existsSync(edgeOneDir)) fs.mkdirSync(edgeOneDir, { recursive: true });
+  if (!fs.existsSync(serverHandlerDir)) fs.mkdirSync(serverHandlerDir, { recursive: true });
+  return serverHandlerDir;
+}
+function getConfigPath() {
+  return path.join(ensureServerHandlerDir(), CONFIG_FILE_NAME);
+}
+function writeConfig(config) {
+  const configPath = getConfigPath();
+  fs.writeFileSync(configPath, JSON.stringify(config, null, 2), "utf-8");
+}
+function normalizeHeaders(headers) {
+  if (!headers || typeof headers !== "object") return null;
+  const out = {};
+  for (const [k, v] of Object.entries(headers)) {
+    if (typeof k !== "string" || !k) continue;
+    if (typeof v === "string") out[k] = v;
+    else if (typeof v === "number" || typeof v === "boolean") out[k] = String(v);
+  }
+  return Object.keys(out).length ? out : null;
+}
+function extractInlineRuntimeConfigFromNitroMjs(code) {
+  if (!code || typeof code !== "string") return null;
+  const idx = code.search(/\b_inlineRuntimeConfig\b\s*=\s*\{/);
+  if (idx === -1) return null;
+  const braceStart = code.indexOf("{", idx);
+  if (braceStart === -1) return null;
+  let depth = 0;
+  let inStr = false;
+  let quote = "";
+  let escaped = false;
+  let end = -1;
+  for (let i = braceStart; i < code.length; i++) {
+    const ch = code[i];
+    if (inStr) {
+      if (escaped) {
+        escaped = false;
+        continue;
+      }
+      if (ch === "\\") {
+        escaped = true;
+        continue;
+      }
+      if (ch === quote) {
+        inStr = false;
+        quote = "";
+      }
+      continue;
+    }
+    if (ch === '"' || ch === "'") {
+      inStr = true;
+      quote = ch;
+      continue;
+    }
+    if (ch === "{") {
+      depth++;
+      continue;
+    }
+    if (ch === "}") {
+      depth--;
+      if (depth === 0) {
+        end = i;
+        break;
+      }
+      continue;
+    }
+  }
+  if (end === -1) return null;
+  const objStr = code.slice(braceStart, end + 1);
+  try {
+    return JSON.parse(objStr);
+  } catch {
+    return null;
+  }
+}
+async function getRouteRulesFromNitroInlineRuntimeConfig(ctx) {
+  const nitroMjsPath = resolveNitroMjsPath();
+  if (!nitroMjsPath) return null;
+  try {
+    const nitroContent = fs.readFileSync(nitroMjsPath, "utf-8");
+    const inlineCfg = extractInlineRuntimeConfigFromNitroMjs(nitroContent);
+    const rr = inlineCfg?.nitro?.routeRules;
+    if (rr && typeof rr === "object") return rr;
+  } catch {
+  }
+  return null;
+}
+async function getRouteRulesFromBuildOutput(ctx) {
+  const fromNitroMjs = await getRouteRulesFromNitroInlineRuntimeConfig(ctx);
+  if (fromNitroMjs) return fromNitroMjs;
+  try {
+    if (typeof ctx?.getNuxtConfig === "function") {
+      const cfg = await ctx.getNuxtConfig();
+      const parsed = getRouteRulesWithAST(cfg || "");
+      if (parsed && typeof parsed === "object") return parsed;
+    }
+  } catch {
+  }
+  return null;
+}
+async function buildHeadersRoutes(ctx) {
+  const routeRules = await getRouteRulesFromBuildOutput(ctx);
+  if (!routeRules || typeof routeRules !== "object") return [];
+  const out = [];
+  for (const [srcRaw, rule] of Object.entries(routeRules)) {
+    const headers = normalizeHeaders(rule?.headers);
+    if (!headers) continue;
+    const src = typeof srcRaw === "string" && srcRaw.startsWith("^") ? srcRaw : normalizeRoutePath(String(srcRaw)).replace(/\*\*/g, "(.*)");
+    out.push({ src, headers });
+  }
+  return out;
+}
+async function buildStage1Routes(ctx) {
+  const routes = [];
+  routes.push({ src: "^/([^.]+[^/.])$", dest: "/$1/", continue: true });
+  routes.push(...await buildHeadersRoutes(ctx));
+  routes.push({ handle: "filesystem" });
+  return routes;
+}
+function resolveNitroMjsPath() {
+  const edgeOneDir = path.join(process.cwd(), ".edgeone");
+  const defaultNitroPath = path.join(edgeOneDir, "cloud-functions", "ssr-node", "chunks", "nitro", "nitro.mjs");
+  const fallbackNitroPath = path.join(edgeOneDir, "cloud-functions", "ssr-node", "chunks", "_", "nitro.mjs");
+  const nitroPath = fs.existsSync(defaultNitroPath) ? defaultNitroPath : fallbackNitroPath;
+  return fs.existsSync(nitroPath) ? nitroPath : null;
+}
+async function buildExplicitApiRoutes(_ctx) {
+  const nitroPath = resolveNitroMjsPath();
+  if (!nitroPath) {
+    console.error("Nitro entry(nitro.mjs) not found");
+    return [];
+  }
+  try {
+    const nitroContent = fs.readFileSync(nitroPath, "utf-8");
+    const handlersArray = getHandlersArrayWithAST(nitroContent);
+    if (!Array.isArray(handlersArray)) return [];
+    const seen = /* @__PURE__ */ new Set();
+    const out = [];
+    for (const h of handlersArray) {
+      const route = typeof h?.route === "string" ? String(h.route) : "";
+      if (!route) continue;
+      const normalized = normalizeRoutePath(route);
+      if (!normalized.startsWith("/api")) continue;
+      const rule = route.startsWith("^") ? { src: route } : nuxtRoutePathToRouteRule(normalized);
+      const src = rule?.src;
+      if (!src || seen.has(src)) continue;
+      seen.add(src);
+      out.push(rule);
+    }
+    out.sort((a, b) => String(b.src || "").length - String(a.src || "").length);
+    return out;
+  } catch (error) {
+    console.error("Error parsing nitro.mjs for API routes:", error);
+    return [];
+  }
+}
+function isCatchAllLikeRoutePath(p) {
+  const clean = normalizeRoutePath(p);
+  return clean.includes("(.*)") || clean.includes(".*") || clean.includes(":all");
+}
+function nuxtRoutePathToRouteRule(routePath) {
+  const p = normalizeRoutePath(routePath);
+  if (!p.startsWith("/")) return null;
+  if (p === "/") return { src: "^/$" };
+  const parts = p.split("/").filter(Boolean);
+  const srcParts = [];
+  for (const seg of parts) {
+    if (seg === "*" || seg === "**") {
+      srcParts.push("(.*)");
+      continue;
+    }
+    if (seg.startsWith(":")) {
+      const m = seg.match(/^:([A-Za-z_$][\w$]*)(?:\((.*)\))?(\*)?$/);
+      const inner = m ? m[2] : null;
+      const star = m ? m[3] : null;
+      if (star || inner === ".*") {
+        srcParts.push("(.*)");
+        continue;
+      }
+      if (!inner || inner.trim() === "") {
+        srcParts.push("([^/]+)");
+        continue;
+      }
+      srcParts.push(`((?:${inner}))`);
+      continue;
+    }
+    srcParts.push(escapeRegExp(seg));
+  }
+  const srcBody = srcParts.join("/");
+  return { src: `^/${srcBody}$` };
+}
+async function buildExplicitSsrAndSwrRoutes(ctx) {
+  const routesManifest = await ctx.getRoutesManifest();
+  const manifestRoutes = Array.isArray(routesManifest?.routes) ? routesManifest.routes : [];
+  const seen = /* @__PURE__ */ new Set();
+  const tmp = [];
+  for (const r of manifestRoutes) {
+    const p = typeof r?.path === "string" ? r.path : "";
+    if (!p) continue;
+    const normalized = normalizeRoutePath(p);
+    if (normalized.startsWith("/api")) continue;
+    const isSsr = r?.ssr === true;
+    const isSwr = r?.swr !== false && r?.swr !== void 0 && r?.swr !== null;
+    if (!isSsr && !isSwr) continue;
+    const rule = nuxtRoutePathToRouteRule(normalized);
+    const src = rule?.src;
+    if (!src || seen.has(src)) continue;
+    seen.add(src);
+    const score = (isCatchAllLikeRoutePath(normalized) ? -1e4 : 0) + normalized.split("/").length;
+    tmp.push({ score, rule });
+  }
+  tmp.sort((a, b) => b.score - a.score);
+  return tmp.map((x) => x.rule);
+}
+var createNuxtRoutesMeta = async (ctx) => {
+  const routes = await buildStage1Routes(ctx);
+  routes.push(...await buildExplicitApiRoutes(ctx));
+  routes.push(...await buildExplicitSsrAndSwrRoutes(ctx));
+  writeConfig({ version: CONFIG_VERSION, routes });
+};
+var createNuxtPagesRouteMeta = async (ctx) => {
+  await createNuxtRoutesMeta(ctx);
+};
+var createNuxtApiRoutesMeta = async (ctx) => {
+  await createNuxtRoutesMeta(ctx);
+};
+
+export {
+  createNuxtRoutesMeta,
+  createNuxtPagesRouteMeta,
+  createNuxtApiRoutesMeta
+};

package/dist/esm-chunks/{chunk-RNEZUAPL.js → chunk-L23O2KDO.js}

@@ -7,7 +7,7 @@
 import {
   require_out,
   verifyNuxtHandlerDirStructure
-} from "./chunk-NJ4SUJNF.js";
+} from "./chunk-TP3RAVPL.js";
 import {
   __require,
   __toESM
@@ -101,10 +101,10 @@ var createServerHandler = async (ctx) => {
 };
 async function patchNitroHandler(ctx) {
   const fs = __require("fs");
-  const defaultNitroMjsPath = ".edgeone/server-handler/chunks/nitro/nitro.mjs";
-  const fallbackNitroMjsPath = ".edgeone/server-handler/chunks/_/nitro.mjs";
+  const defaultNitroMjsPath = join(ctx.serverHandlerDir, "chunks", "nitro", "nitro.mjs");
+  const fallbackNitroMjsPath = join(ctx.serverHandlerDir, "chunks", "_", "nitro.mjs");
   const nitroMjsPath = fs.existsSync(defaultNitroMjsPath) ? defaultNitroMjsPath : fallbackNitroMjsPath;
-  const handlerTmplPath = ".edgeone/server-handler/handler.js";
+  const handlerTmplPath = join(ctx.serverHandlerRootDir, "handler.js");
   const nitroCode = fs.readFileSync(nitroMjsPath, "utf-8");
   const match = nitroCode.match(/export\s*\{[^}]*\buseNitroApp\s+as\s+([A-Za-z_$][\w$]*)/) ?? nitroCode.match(/\buseNitroApp\s+as\s+([A-Za-z_$][\w$]*)\b/);
   if (!match) throw new Error("Cannot find useNitroApp export symbol in nitro.mjs!");

package/dist/esm-chunks/{chunk-NJ4SUJNF.js → chunk-TP3RAVPL.js}

@@ -5520,7 +5520,7 @@ function isError(error) {
   return error instanceof Error;
 }
 var copyNuxtServerCode = async (ctx) => {
-  const nuxtServerDir = join(ctx.outputDir, "server-handler");
+  const nuxtServerDir = join(ctx.outputDir, "cloud-functions", "ssr-node");
   try {
     await access(nuxtServerDir);
   } catch (error) {

package/dist/esm-chunks/{chunk-BZQMVWYQ.js → chunk-Y3YAV6NZ.js}

@@ -9,7 +9,7 @@ import {
   getPrerenderRoutesWithAST,
   getRouteRulesWithAST,
   getRoutesArrayWithAST
-} from "./chunk-MONI3XWQ.js";
+} from "./chunk-5JK44IEA.js";
 
 // src/build/plugin-context.ts
 import { existsSync, readFileSync } from "node:fs";
@@ -21,7 +21,7 @@ var MODULE_DIR = fileURLToPath(new URL(".", import.meta.url));
 var PLUGIN_DIR = join(MODULE_DIR, "../..");
 var DEFAULT_BUILD_DIR = ".nuxt";
 var DEFAULT_OUTPUT_DIR = ".edgeone";
-var SERVER_HANDLER_NAME = "server-handler";
+var SERVER_HANDLER_NAME = "cloud-functions/ssr-node";
 var PluginContext = class {
   edgeoneConfig;
   pluginName;
@@ -240,7 +240,7 @@ var PluginContext = class {
   }
   /** Detect and locate server.mjs file */
   detectNuxtServerFile() {
-    const serverFilePath = this.resolveFromPackagePath(".edgeone", "server-handler", "chunks", "build", "server.mjs");
+    const serverFilePath = this.resolveFromPackagePath(".edgeone", "cloud-functions", "ssr-node", "chunks", "build", "server.mjs");
     if (existsSync(serverFilePath)) {
       return serverFilePath;
     }

package/dist/index.js

@@ -6,24 +6,23 @@
     
 import {
   PluginContext
-} from "./esm-chunks/chunk-BZQMVWYQ.js";
+} from "./esm-chunks/chunk-Y3YAV6NZ.js";
 import {
-  createNuxtApiRoutesMeta,
-  createNuxtPagesRouteMeta
-} from "./esm-chunks/chunk-J25U56II.js";
+  createNuxtRoutesMeta
+} from "./esm-chunks/chunk-FZBQIMQA.js";
 import {
   addNitroBuildOutputConfig,
   resetNitroConfig
-} from "./esm-chunks/chunk-7X4RPD4I.js";
+} from "./esm-chunks/chunk-7RNB5RB6.js";
 import {
   resetEdgeOneConfig,
   useStaticBuild
-} from "./esm-chunks/chunk-MONI3XWQ.js";
+} from "./esm-chunks/chunk-5JK44IEA.js";
 import {
   createServerHandler,
   patchNitroHandler
-} from "./esm-chunks/chunk-RNEZUAPL.js";
-import "./esm-chunks/chunk-NJ4SUJNF.js";
+} from "./esm-chunks/chunk-L23O2KDO.js";
+import "./esm-chunks/chunk-TP3RAVPL.js";
 import "./esm-chunks/chunk-V2LFVP3C.js";
 import "./esm-chunks/chunk-6BT4RYQJ.js";
 
@@ -47,6 +46,7 @@ var removeIndexMJS = async (ctx) => {
 var recordOldNitroConfig = null;
 var recordOldEdgeOneConfig = -1;
 var onPreBuild = async (options) => {
+  console.log("\u{1F62C}\u{1F62C}\u{1F62C}\u{1F62C}\u{1F62C}\u{1F62C}\u{1F62C}\u{1F62C}\u{1F62C}\u{1F62C} ======= new nuxt pages 1.1.0+ ============");
   try {
     const ctx = new PluginContext(options);
     recordOldNitroConfig = await addNitroBuildOutputConfig(ctx);
@@ -67,8 +67,7 @@ var onBuild = async (options) => {
     await removeServerHandler(ctx);
     return;
   }
-  await createServerHandler(ctx), await createNuxtPagesRouteMeta(ctx);
-  await createNuxtApiRoutesMeta(ctx);
+  await createServerHandler(ctx), await createNuxtRoutesMeta(ctx);
   await patchNitroHandler(ctx);
 };
 var onPostBuild = async (options) => {

package/dist/utils.js

@@ -14,7 +14,7 @@ import {
   resetEdgeOneConfig,
   resetNitroConfigWithAST,
   useStaticBuild
-} from "./esm-chunks/chunk-MONI3XWQ.js";
+} from "./esm-chunks/chunk-5JK44IEA.js";
 import "./esm-chunks/chunk-6BT4RYQJ.js";
 export {
   addCodeToGenerateEdgeoneWithAST,

package/package.json

@@ -1,9 +1,9 @@
 {
   "name": "@edgeone/nuxt-pages",
-  "version": "1.0.16",
+  "version": "1.1.0-beta.1",
   "main": "./dist/index.js",
   "scripts": {
-    "test": "ts-node src/test.ts",
+    "test": "vitest run --passWithNoTests",
     "build": "node ./tools/build.js",
     "build:watch": "node ./tools/build.js --watch",
     "start": "node dist/index.js",

package/dist/esm-chunks/chunk-J25U56II.js

@@ -1,213 +0,0 @@
-
-      var require = await (async () => {
-        var { createRequire } = await import("node:module");
-        return createRequire(import.meta.url);
-      })();
-    
-import {
-  getHandlersArrayWithAST
-} from "./chunk-MONI3XWQ.js";
-
-// src/build/routes.ts
-import * as fs from "fs";
-import * as path from "path";
-var convertNuxtRoutePattern = (path2) => {
-  if (!path2.includes("[") && !path2.includes("_")) {
-    return path2;
-  }
-  let convertedPath = path2;
-  const catchAllMatch = path2.match(/\[\.\.\.([^\]]+)\]/);
-  if (catchAllMatch) {
-    const paramName = catchAllMatch[1];
-    convertedPath = convertedPath.replace(/\[\.\.\.([^\]]+)\]/g, `:${paramName}*`);
-  }
-  const dynamicMatch = path2.match(/\[([^\]]+)\]/);
-  if (dynamicMatch) {
-    const paramName = dynamicMatch[1];
-    convertedPath = convertedPath.replace(/\[([^\]]+)\]/g, `:${paramName}`);
-  }
-  const underscoreMatch = path2.match(/_([^\/\.]+)/);
-  if (underscoreMatch) {
-    const paramName = underscoreMatch[1];
-    convertedPath = convertedPath.replace(/_([^\/\.]+)/g, `:${paramName}`);
-  }
-  return convertedPath;
-};
-var createNuxtPagesRouteMeta = async (ctx) => {
-  const routeMap = {};
-  const prerenderRoutes = await ctx.getPrerenderRoutes();
-  if (prerenderRoutes && Array.isArray(prerenderRoutes)) {
-    for (const route of prerenderRoutes) {
-      routeMap[route] = {
-        isStatic: true
-      };
-    }
-  }
-  const staticPages = await ctx.getStaticPages();
-  if (staticPages && Array.isArray(staticPages)) {
-    for (const page of staticPages) {
-      if (!routeMap[page]) {
-        routeMap[page] = {};
-      }
-      routeMap[page].isStatic = true;
-    }
-  }
-  const routesManifest = await ctx.getRoutesManifest();
-  if (routesManifest) {
-    if (routesManifest.routes) {
-      for (let [route, routeInfo] of Object.entries(routesManifest.routes)) {
-        route = routeInfo.path;
-        if (!routeMap[route]) {
-          routeMap[route] = {};
-        }
-        if (routeInfo.prerender !== void 0) {
-          routeMap[route].isStatic = routeInfo.prerender;
-        }
-        if (routeInfo.swr !== void 0 && routeInfo.swr) {
-          routeMap[route].isr = routeInfo.swr;
-        }
-        if (routeInfo.isr !== void 0 && routeInfo.isr) {
-          routeMap[route].isr = routeInfo.isr;
-        }
-      }
-    }
-  }
-  const convertedRouteMap = {};
-  const pathsToDelete = [];
-  for (const [routePath, routeConfig] of Object.entries(routeMap)) {
-    const convertedPath = convertNuxtRoutePattern(routePath);
-    if (convertedPath !== routePath) {
-      pathsToDelete.push(routePath);
-      convertedRouteMap[convertedPath] = routeConfig;
-    }
-  }
-  for (const pathToDelete of pathsToDelete) {
-    delete routeMap[pathToDelete];
-  }
-  Object.assign(routeMap, convertedRouteMap);
-  const routesArray = Object.entries(routeMap).map(([path2, config]) => ({
-    path: path2,
-    ...config
-  }));
-  const edgeOneDir = path.join(process.cwd(), ".edgeone");
-  if (!fs.existsSync(edgeOneDir)) {
-    fs.mkdirSync(edgeOneDir, { recursive: true });
-  }
-  const metaFilePath = path.join(edgeOneDir, "server-handler", "meta.json");
-  let existingMetaData = {};
-  if (fs.existsSync(metaFilePath)) {
-    try {
-      const existingContent = fs.readFileSync(metaFilePath, "utf-8");
-      existingMetaData = JSON.parse(existingContent);
-    } catch (error2) {
-      console.warn("Failed to parse existing meta.json:", error2);
-    }
-  }
-  const mergedMetaData = {
-    ...existingMetaData,
-    routes: routesArray
-  };
-  await fs.writeFileSync(
-    metaFilePath,
-    JSON.stringify(mergedMetaData, null, 2),
-    "utf-8"
-  );
-};
-var createNuxtApiRoutesMeta = async (ctx) => {
-  const edgeOneDir = path.join(process.cwd(), ".edgeone");
-  if (!fs.existsSync(edgeOneDir)) {
-    console.error("Failed to create .edgeone directory:", error);
-    return;
-  }
-  const metaFilePath = path.join(edgeOneDir, "server-handler", "meta.json");
-  if (!fs.existsSync(metaFilePath)) {
-    console.error("Failed to create meta.json file:", error);
-    return;
-  }
-  const existingContent = await fs.readFileSync(metaFilePath, "utf-8");
-  const existingMetaData = JSON.parse(existingContent);
-  const defaultNitroPath = path.join(edgeOneDir, "server-handler", "chunks", "nitro", "nitro.mjs");
-  const fallbackNitroPath = path.join(edgeOneDir, "server-handler", "chunks", "_", "nitro.mjs");
-  const nitroPath = fs.existsSync(defaultNitroPath) ? defaultNitroPath : fallbackNitroPath;
-  let apiRoutes = [];
-  if (fs.existsSync(nitroPath)) {
-    try {
-      const nitroContent = fs.readFileSync(nitroPath, "utf-8");
-      const handlersArray = getHandlersArrayWithAST(nitroContent);
-      if (Array.isArray(handlersArray)) {
-        for (const handler of handlersArray) {
-          if (handler && typeof handler === "object") {
-            let routePath = null;
-            if (handler.route && typeof handler.route === "string") {
-              routePath = handler.route;
-              if (existingMetaData.routes.some((route) => route.path === routePath)) {
-                continue;
-              }
-              apiRoutes.push({
-                path: routePath,
-                handler
-              });
-            }
-          }
-        }
-      }
-    } catch (error2) {
-      console.error("Error parsing nitro.mjs for API routes:", error2);
-    }
-  }
-  const mergedMetaData = {
-    frameworkRoutes: existingMetaData.routes.concat(apiRoutes.map((route) => ({ path: route.path })))
-  };
-  const excludeRoutes = ["/**"];
-  let processedRoutes = mergedMetaData.frameworkRoutes.filter((route) => !excludeRoutes.includes(route.path)).map((route) => {
-    if (!route.path || route.path === "/**") {
-      return {
-        ...route,
-        path: "/"
-      };
-    }
-    if (route.path && route.path.includes("**:")) {
-      route.path = route.path.replaceAll("**:", ":");
-    }
-    if (route.path && route.path.includes("**")) {
-      let regexPath = route.path.replace(/\*\*/g, ".*").replace(/\*/g, "[^/]*").replace(/\//g, "\\/");
-      regexPath = `^${regexPath}$`;
-      if (route.path.startsWith("/_ipx")) {
-        regexPath = `/_ipx/:path*`;
-      }
-      return {
-        ...route,
-        path: regexPath
-        // Keep original path
-      };
-    } else if (route.path && route.path.includes("(.*)*")) {
-      let regexPath = route.path.replace(/\(\.\*\)\*/g, "*");
-      regexPath = `${regexPath}`;
-      return {
-        ...route,
-        path: regexPath
-        // Keep original path
-      };
-    }
-    return route;
-  });
-  processedRoutes = processedRoutes.map((route) => {
-    if (route.hasOwnProperty("ssr")) {
-      Reflect.deleteProperty(route, "ssr");
-    }
-    route.path = route.path.replace(/\(/g, "").replace(/\)/g, "");
-    return route;
-  });
-  const finalMetaData = {
-    frameworkRoutes: processedRoutes,
-    conf: {
-      ssr404: true
-    }
-  };
-  await fs.writeFileSync(metaFilePath, JSON.stringify(finalMetaData, null, 2));
-};
-
-export {
-  createNuxtPagesRouteMeta,
-  createNuxtApiRoutesMeta
-};