@edgeone/opennextjs-pages 0.1.6 → 0.1.7

package/dist/build/functions/middleware/compiler.js

@@ -3539,28 +3539,61 @@ function matchesPath(pathname, matcher) {
           continue;
         }
       } else {
-        // \u8DEF\u5F84\u6A21\u5F0F\uFF0C\u9700\u8981\u8F6C\u6362
-        let regexPattern = pattern;
-        regexPattern = regexPattern.split('/').join('\\\\/');
-        
-        const parts = regexPattern.split(':');
-        regexPattern = parts[0];
-        for (let i = 1; i < parts.length; i++) {
-          const part = parts[i];
-          let j = 0;
-          while (j < part.length && /[a-zA-Z0-9_]/.test(part[j])) {
-            j++;
-          }
-          if (j < part.length && part[j] === '*') {
-            regexPattern += '.*' + part.slice(j + 1);
+        // \u8DEF\u5F84\u6A21\u5F0F\uFF0C\u9700\u8981\u8F6C\u6362\u4E3A\u6B63\u5219\u8868\u8FBE\u5F0F
+        // Next.js middleware matcher \u4F7F\u7528\u7C7B\u4F3C path-to-regexp \u7684\u8BED\u6CD5:
+        //   /dashboard/:path*  -> \u5339\u914D /dashboard \u548C /dashboard/xxx\uFF08\u96F6\u4E2A\u6216\u591A\u4E2A\u8DEF\u5F84\u6BB5\uFF09
+        //   /api/:path         -> \u5339\u914D /api/xxx\uFF08\u4E00\u4E2A\u8DEF\u5F84\u6BB5\uFF09
+        //   /api/:path+        -> \u5339\u914D /api/xxx/yyy\uFF08\u4E00\u4E2A\u6216\u591A\u4E2A\u8DEF\u5F84\u6BB5\uFF09
+        let regexPattern = '';
+        let ci = 0;
+        const p = pattern;
+        while (ci < p.length) {
+          if (p[ci] === ':') {
+            // \u89E3\u6790\u53C2\u6570\u540D
+            ci++;
+            while (ci < p.length && /[a-zA-Z0-9_]/.test(p[ci])) {
+              ci++;
+            }
+            // \u68C0\u67E5\u4FEE\u9970\u7B26
+            if (ci < p.length && p[ci] === '*') {
+              // :param* -> \u96F6\u4E2A\u6216\u591A\u4E2A\u8DEF\u5F84\u6BB5\uFF0C\u524D\u9762\u7684 / \u4E5F\u53D8\u4E3A\u53EF\u9009
+              if (regexPattern.endsWith('\\\\/')) {
+                regexPattern = regexPattern.slice(0, -2);
+              }
+              regexPattern += '(?:\\\\/.*)?';
+              ci++;
+            } else if (ci < p.length && p[ci] === '+') {
+              // :param+ -> \u4E00\u4E2A\u6216\u591A\u4E2A\u8DEF\u5F84\u6BB5
+              regexPattern += '.+';
+              ci++;
+            } else {
+              // :param -> \u5339\u914D\u4E00\u4E2A\u8DEF\u5F84\u6BB5
+              regexPattern += '[^/]+';
+            }
+          } else if (p[ci] === '/') {
+            regexPattern += '\\\\/';
+            ci++;
+          } else if (p[ci] === '*') {
+            if (ci + 1 < p.length && p[ci + 1] === '*') {
+              regexPattern += '.*';
+              ci += 2;
+            } else {
+              regexPattern += '[^/]*';
+              ci++;
+            }
           } else {
-            regexPattern += '[^/]+' + part.slice(j);
+            // \u8F6C\u4E49\u6B63\u5219\u7279\u6B8A\u5B57\u7B26
+            const ch = p[ci];
+            const specialChars = '.+?^$|(){}[]\\\\';
+            if (specialChars.indexOf(ch) !== -1) {
+              regexPattern += '\\\\' + ch;
+            } else {
+              regexPattern += ch;
+            }
+            ci++;
           }
         }
         
-        regexPattern = regexPattern.split('**').join('.*');
-        regexPattern = regexPattern.split('\\\\*').join('[^/]*');
-        
         regex = new RegExp('^' + regexPattern + '$');
       }
       

package/dist/build/functions/middleware/wrapper.js

@@ -258,42 +258,61 @@ function matchesPath(pathname, matcher) {
           continue;
         }
       } else {
-        // \u8DEF\u5F84\u6A21\u5F0F\uFF0C\u9700\u8981\u8F6C\u6362
-        // /dashboard/:path* -> /dashboard/.*
-        // /api/:path -> /api/[^/]+
-        // \u4F7F\u7528 split/join \u66FF\u4EE3\u6B63\u5219\uFF0C\u907F\u514D\u8F6C\u4E49\u95EE\u9898
-        let regexPattern = pattern;
-        
-        // \u8F6C\u4E49\u659C\u6760: / -> /
-        regexPattern = regexPattern.split('/').join('\\/');
-        
-        // :path* -> .*
-        // :path -> [^/]+
-        // \u5148\u5904\u7406 :xxx* \u518D\u5904\u7406 :xxx
-        const parts = regexPattern.split(':');
-        regexPattern = parts[0];
-        for (let i = 1; i < parts.length; i++) {
-          const part = parts[i];
-          // \u627E\u5230\u53C2\u6570\u540D\u7ED3\u675F\u4F4D\u7F6E
-          let j = 0;
-          while (j < part.length && /[a-zA-Z0-9_]/.test(part[j])) {
-            j++;
-          }
-          if (j < part.length && part[j] === '*') {
-            // :path* -> .*
-            regexPattern += '.*' + part.slice(j + 1);
+        // \u8DEF\u5F84\u6A21\u5F0F\uFF0C\u9700\u8981\u8F6C\u6362\u4E3A\u6B63\u5219\u8868\u8FBE\u5F0F
+        // Next.js middleware matcher \u4F7F\u7528\u7C7B\u4F3C path-to-regexp \u7684\u8BED\u6CD5:
+        //   /dashboard/:path*  -> \u5339\u914D /dashboard \u548C /dashboard/xxx\uFF08\u96F6\u4E2A\u6216\u591A\u4E2A\u8DEF\u5F84\u6BB5\uFF09
+        //   /api/:path         -> \u5339\u914D /api/xxx\uFF08\u4E00\u4E2A\u8DEF\u5F84\u6BB5\uFF09
+        //   /api/:path+        -> \u5339\u914D /api/xxx/yyy\uFF08\u4E00\u4E2A\u6216\u591A\u4E2A\u8DEF\u5F84\u6BB5\uFF09
+        let regexPattern = '';
+        let ci = 0;
+        const p = pattern;
+        while (ci < p.length) {
+          if (p[ci] === ':') {
+            // \u89E3\u6790\u53C2\u6570\u540D
+            ci++;
+            while (ci < p.length && /[a-zA-Z0-9_]/.test(p[ci])) {
+              ci++;
+            }
+            // \u68C0\u67E5\u4FEE\u9970\u7B26
+            if (ci < p.length && p[ci] === '*') {
+              // :param* -> \u96F6\u4E2A\u6216\u591A\u4E2A\u8DEF\u5F84\u6BB5\uFF0C\u524D\u9762\u7684 / \u4E5F\u53D8\u4E3A\u53EF\u9009
+              if (regexPattern.endsWith('\\/')) {
+                regexPattern = regexPattern.slice(0, -2);
+              }
+              regexPattern += '(?:\\/.*)?';
+              ci++;
+            } else if (ci < p.length && p[ci] === '+') {
+              // :param+ -> \u4E00\u4E2A\u6216\u591A\u4E2A\u8DEF\u5F84\u6BB5
+              regexPattern += '.+';
+              ci++;
+            } else {
+              // :param -> \u5339\u914D\u4E00\u4E2A\u8DEF\u5F84\u6BB5
+              regexPattern += '[^/]+';
+            }
+          } else if (p[ci] === '/') {
+            regexPattern += '\\/';
+            ci++;
+          } else if (p[ci] === '*') {
+            if (ci + 1 < p.length && p[ci + 1] === '*') {
+              regexPattern += '.*';
+              ci += 2;
+            } else {
+              regexPattern += '[^/]*';
+              ci++;
+            }
           } else {
-            // :path -> [^/]+
-            regexPattern += '[^/]+' + part.slice(j);
+            // \u8F6C\u4E49\u6B63\u5219\u7279\u6B8A\u5B57\u7B26
+            const ch = p[ci];
+            const specialChars = '.+?^$|(){}[]\\\\';
+            if (specialChars.indexOf(ch) !== -1) {
+              regexPattern += '\\' + ch;
+            } else {
+              regexPattern += ch;
+            }
+            ci++;
           }
         }
         
-        // ** -> .*
-        regexPattern = regexPattern.split('**').join('.*');
-        // * -> [^/]* (\u4F46\u4E0D\u5F71\u54CD\u5DF2\u7ECF\u8F6C\u6362\u7684 .*)
-        // \u7B80\u5355\u5904\u7406\uFF1A\u53EA\u66FF\u6362\u72EC\u7ACB\u7684 *
-        regexPattern = regexPattern.split('\\*').join('[^/]*');
-        
         regex = new RegExp('^' + regexPattern + '$');
       }
       

package/dist/build/plugin-context.js

@@ -22,7 +22,7 @@ import { fileURLToPath } from "node:url";
 var MODULE_DIR = fileURLToPath(new URL(".", import.meta.url));
 var PLUGIN_DIR = join(MODULE_DIR, "../..");
 var DEFAULT_PUBLISH_DIR = ".next";
-var SERVER_HANDLER_NAME = "server-handler";
+var SERVER_HANDLER_NAME = "cloud-functions/ssr-node";
 var EDGE_HANDLER_NAME = "edgeone-edge-handler";
 var PluginContext = class {
   edgeoneConfig;

package/dist/build/route-utils.js

@@ -0,0 +1,699 @@
+
+      var require = await (async () => {
+        var { createRequire } = await import("node:module");
+        return createRequire(import.meta.url);
+      })();
+    
+import {
+  __commonJS,
+  __toESM
+} from "../esm-chunks/chunk-6BT4RYQJ.js";
+
+// node_modules/path-to-regexp/dist/index.js
+var require_dist = __commonJS({
+  "node_modules/path-to-regexp/dist/index.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.pathToRegexp = exports.tokensToRegexp = exports.regexpToFunction = exports.match = exports.tokensToFunction = exports.compile = exports.parse = void 0;
+    function lexer(str) {
+      var tokens = [];
+      var i = 0;
+      while (i < str.length) {
+        var char = str[i];
+        if (char === "*" || char === "+" || char === "?") {
+          tokens.push({ type: "MODIFIER", index: i, value: str[i++] });
+          continue;
+        }
+        if (char === "\\") {
+          tokens.push({ type: "ESCAPED_CHAR", index: i++, value: str[i++] });
+          continue;
+        }
+        if (char === "{") {
+          tokens.push({ type: "OPEN", index: i, value: str[i++] });
+          continue;
+        }
+        if (char === "}") {
+          tokens.push({ type: "CLOSE", index: i, value: str[i++] });
+          continue;
+        }
+        if (char === ":") {
+          var name = "";
+          var j = i + 1;
+          while (j < str.length) {
+            var code = str.charCodeAt(j);
+            if (
+              // `0-9`
+              code >= 48 && code <= 57 || // `A-Z`
+              code >= 65 && code <= 90 || // `a-z`
+              code >= 97 && code <= 122 || // `_`
+              code === 95
+            ) {
+              name += str[j++];
+              continue;
+            }
+            break;
+          }
+          if (!name)
+            throw new TypeError("Missing parameter name at ".concat(i));
+          tokens.push({ type: "NAME", index: i, value: name });
+          i = j;
+          continue;
+        }
+        if (char === "(") {
+          var count = 1;
+          var pattern = "";
+          var j = i + 1;
+          if (str[j] === "?") {
+            throw new TypeError('Pattern cannot start with "?" at '.concat(j));
+          }
+          while (j < str.length) {
+            if (str[j] === "\\") {
+              pattern += str[j++] + str[j++];
+              continue;
+            }
+            if (str[j] === ")") {
+              count--;
+              if (count === 0) {
+                j++;
+                break;
+              }
+            } else if (str[j] === "(") {
+              count++;
+              if (str[j + 1] !== "?") {
+                throw new TypeError("Capturing groups are not allowed at ".concat(j));
+              }
+            }
+            pattern += str[j++];
+          }
+          if (count)
+            throw new TypeError("Unbalanced pattern at ".concat(i));
+          if (!pattern)
+            throw new TypeError("Missing pattern at ".concat(i));
+          tokens.push({ type: "PATTERN", index: i, value: pattern });
+          i = j;
+          continue;
+        }
+        tokens.push({ type: "CHAR", index: i, value: str[i++] });
+      }
+      tokens.push({ type: "END", index: i, value: "" });
+      return tokens;
+    }
+    function parse(str, options) {
+      if (options === void 0) {
+        options = {};
+      }
+      var tokens = lexer(str);
+      var _a = options.prefixes, prefixes = _a === void 0 ? "./" : _a, _b = options.delimiter, delimiter = _b === void 0 ? "/#?" : _b;
+      var result = [];
+      var key = 0;
+      var i = 0;
+      var path = "";
+      var tryConsume = function(type) {
+        if (i < tokens.length && tokens[i].type === type)
+          return tokens[i++].value;
+      };
+      var mustConsume = function(type) {
+        var value2 = tryConsume(type);
+        if (value2 !== void 0)
+          return value2;
+        var _a2 = tokens[i], nextType = _a2.type, index = _a2.index;
+        throw new TypeError("Unexpected ".concat(nextType, " at ").concat(index, ", expected ").concat(type));
+      };
+      var consumeText = function() {
+        var result2 = "";
+        var value2;
+        while (value2 = tryConsume("CHAR") || tryConsume("ESCAPED_CHAR")) {
+          result2 += value2;
+        }
+        return result2;
+      };
+      var isSafe = function(value2) {
+        for (var _i = 0, delimiter_1 = delimiter; _i < delimiter_1.length; _i++) {
+          var char2 = delimiter_1[_i];
+          if (value2.indexOf(char2) > -1)
+            return true;
+        }
+        return false;
+      };
+      var safePattern = function(prefix2) {
+        var prev = result[result.length - 1];
+        var prevText = prefix2 || (prev && typeof prev === "string" ? prev : "");
+        if (prev && !prevText) {
+          throw new TypeError('Must have text between two parameters, missing text after "'.concat(prev.name, '"'));
+        }
+        if (!prevText || isSafe(prevText))
+          return "[^".concat(escapeString(delimiter), "]+?");
+        return "(?:(?!".concat(escapeString(prevText), ")[^").concat(escapeString(delimiter), "])+?");
+      };
+      while (i < tokens.length) {
+        var char = tryConsume("CHAR");
+        var name = tryConsume("NAME");
+        var pattern = tryConsume("PATTERN");
+        if (name || pattern) {
+          var prefix = char || "";
+          if (prefixes.indexOf(prefix) === -1) {
+            path += prefix;
+            prefix = "";
+          }
+          if (path) {
+            result.push(path);
+            path = "";
+          }
+          result.push({
+            name: name || key++,
+            prefix,
+            suffix: "",
+            pattern: pattern || safePattern(prefix),
+            modifier: tryConsume("MODIFIER") || ""
+          });
+          continue;
+        }
+        var value = char || tryConsume("ESCAPED_CHAR");
+        if (value) {
+          path += value;
+          continue;
+        }
+        if (path) {
+          result.push(path);
+          path = "";
+        }
+        var open = tryConsume("OPEN");
+        if (open) {
+          var prefix = consumeText();
+          var name_1 = tryConsume("NAME") || "";
+          var pattern_1 = tryConsume("PATTERN") || "";
+          var suffix = consumeText();
+          mustConsume("CLOSE");
+          result.push({
+            name: name_1 || (pattern_1 ? key++ : ""),
+            pattern: name_1 && !pattern_1 ? safePattern(prefix) : pattern_1,
+            prefix,
+            suffix,
+            modifier: tryConsume("MODIFIER") || ""
+          });
+          continue;
+        }
+        mustConsume("END");
+      }
+      return result;
+    }
+    exports.parse = parse;
+    function compile2(str, options) {
+      return tokensToFunction(parse(str, options), options);
+    }
+    exports.compile = compile2;
+    function tokensToFunction(tokens, options) {
+      if (options === void 0) {
+        options = {};
+      }
+      var reFlags = flags(options);
+      var _a = options.encode, encode = _a === void 0 ? function(x) {
+        return x;
+      } : _a, _b = options.validate, validate = _b === void 0 ? true : _b;
+      var matches = tokens.map(function(token) {
+        if (typeof token === "object") {
+          return new RegExp("^(?:".concat(token.pattern, ")$"), reFlags);
+        }
+      });
+      return function(data) {
+        var path = "";
+        for (var i = 0; i < tokens.length; i++) {
+          var token = tokens[i];
+          if (typeof token === "string") {
+            path += token;
+            continue;
+          }
+          var value = data ? data[token.name] : void 0;
+          var optional = token.modifier === "?" || token.modifier === "*";
+          var repeat = token.modifier === "*" || token.modifier === "+";
+          if (Array.isArray(value)) {
+            if (!repeat) {
+              throw new TypeError('Expected "'.concat(token.name, '" to not repeat, but got an array'));
+            }
+            if (value.length === 0) {
+              if (optional)
+                continue;
+              throw new TypeError('Expected "'.concat(token.name, '" to not be empty'));
+            }
+            for (var j = 0; j < value.length; j++) {
+              var segment = encode(value[j], token);
+              if (validate && !matches[i].test(segment)) {
+                throw new TypeError('Expected all "'.concat(token.name, '" to match "').concat(token.pattern, '", but got "').concat(segment, '"'));
+              }
+              path += token.prefix + segment + token.suffix;
+            }
+            continue;
+          }
+          if (typeof value === "string" || typeof value === "number") {
+            var segment = encode(String(value), token);
+            if (validate && !matches[i].test(segment)) {
+              throw new TypeError('Expected "'.concat(token.name, '" to match "').concat(token.pattern, '", but got "').concat(segment, '"'));
+            }
+            path += token.prefix + segment + token.suffix;
+            continue;
+          }
+          if (optional)
+            continue;
+          var typeOfMessage = repeat ? "an array" : "a string";
+          throw new TypeError('Expected "'.concat(token.name, '" to be ').concat(typeOfMessage));
+        }
+        return path;
+      };
+    }
+    exports.tokensToFunction = tokensToFunction;
+    function match(str, options) {
+      var keys = [];
+      var re = pathToRegexp2(str, keys, options);
+      return regexpToFunction(re, keys, options);
+    }
+    exports.match = match;
+    function regexpToFunction(re, keys, options) {
+      if (options === void 0) {
+        options = {};
+      }
+      var _a = options.decode, decode = _a === void 0 ? function(x) {
+        return x;
+      } : _a;
+      return function(pathname) {
+        var m = re.exec(pathname);
+        if (!m)
+          return false;
+        var path = m[0], index = m.index;
+        var params = /* @__PURE__ */ Object.create(null);
+        var _loop_1 = function(i2) {
+          if (m[i2] === void 0)
+            return "continue";
+          var key = keys[i2 - 1];
+          if (key.modifier === "*" || key.modifier === "+") {
+            params[key.name] = m[i2].split(key.prefix + key.suffix).map(function(value) {
+              return decode(value, key);
+            });
+          } else {
+            params[key.name] = decode(m[i2], key);
+          }
+        };
+        for (var i = 1; i < m.length; i++) {
+          _loop_1(i);
+        }
+        return { path, index, params };
+      };
+    }
+    exports.regexpToFunction = regexpToFunction;
+    function escapeString(str) {
+      return str.replace(/([.+*?=^!:${}()[\]|/\\])/g, "\\$1");
+    }
+    function flags(options) {
+      return options && options.sensitive ? "" : "i";
+    }
+    function regexpToRegexp(path, keys) {
+      if (!keys)
+        return path;
+      var groupsRegex = /\((?:\?<(.*?)>)?(?!\?)/g;
+      var index = 0;
+      var execResult = groupsRegex.exec(path.source);
+      while (execResult) {
+        keys.push({
+          // Use parenthesized substring match if available, index otherwise
+          name: execResult[1] || index++,
+          prefix: "",
+          suffix: "",
+          modifier: "",
+          pattern: ""
+        });
+        execResult = groupsRegex.exec(path.source);
+      }
+      return path;
+    }
+    function arrayToRegexp(paths, keys, options) {
+      var parts = paths.map(function(path) {
+        return pathToRegexp2(path, keys, options).source;
+      });
+      return new RegExp("(?:".concat(parts.join("|"), ")"), flags(options));
+    }
+    function stringToRegexp(path, keys, options) {
+      return tokensToRegexp(parse(path, options), keys, options);
+    }
+    function tokensToRegexp(tokens, keys, options) {
+      if (options === void 0) {
+        options = {};
+      }
+      var _a = options.strict, strict = _a === void 0 ? false : _a, _b = options.start, start = _b === void 0 ? true : _b, _c = options.end, end = _c === void 0 ? true : _c, _d = options.encode, encode = _d === void 0 ? function(x) {
+        return x;
+      } : _d, _e = options.delimiter, delimiter = _e === void 0 ? "/#?" : _e, _f = options.endsWith, endsWith = _f === void 0 ? "" : _f;
+      var endsWithRe = "[".concat(escapeString(endsWith), "]|$");
+      var delimiterRe = "[".concat(escapeString(delimiter), "]");
+      var route = start ? "^" : "";
+      for (var _i = 0, tokens_1 = tokens; _i < tokens_1.length; _i++) {
+        var token = tokens_1[_i];
+        if (typeof token === "string") {
+          route += escapeString(encode(token));
+        } else {
+          var prefix = escapeString(encode(token.prefix));
+          var suffix = escapeString(encode(token.suffix));
+          if (token.pattern) {
+            if (keys)
+              keys.push(token);
+            if (prefix || suffix) {
+              if (token.modifier === "+" || token.modifier === "*") {
+                var mod = token.modifier === "*" ? "?" : "";
+                route += "(?:".concat(prefix, "((?:").concat(token.pattern, ")(?:").concat(suffix).concat(prefix, "(?:").concat(token.pattern, "))*)").concat(suffix, ")").concat(mod);
+              } else {
+                route += "(?:".concat(prefix, "(").concat(token.pattern, ")").concat(suffix, ")").concat(token.modifier);
+              }
+            } else {
+              if (token.modifier === "+" || token.modifier === "*") {
+                throw new TypeError('Can not repeat "'.concat(token.name, '" without a prefix and suffix'));
+              }
+              route += "(".concat(token.pattern, ")").concat(token.modifier);
+            }
+          } else {
+            route += "(?:".concat(prefix).concat(suffix, ")").concat(token.modifier);
+          }
+        }
+      }
+      if (end) {
+        if (!strict)
+          route += "".concat(delimiterRe, "?");
+        route += !options.endsWith ? "$" : "(?=".concat(endsWithRe, ")");
+      } else {
+        var endToken = tokens[tokens.length - 1];
+        var isEndDelimited = typeof endToken === "string" ? delimiterRe.indexOf(endToken[endToken.length - 1]) > -1 : endToken === void 0;
+        if (!strict) {
+          route += "(?:".concat(delimiterRe, "(?=").concat(endsWithRe, "))?");
+        }
+        if (!isEndDelimited) {
+          route += "(?=".concat(delimiterRe, "|").concat(endsWithRe, ")");
+        }
+      }
+      return new RegExp(route, flags(options));
+    }
+    exports.tokensToRegexp = tokensToRegexp;
+    function pathToRegexp2(path, keys, options) {
+      if (path instanceof RegExp)
+        return regexpToRegexp(path, keys);
+      if (Array.isArray(path))
+        return arrayToRegexp(path, keys, options);
+      return stringToRegexp(path, keys, options);
+    }
+    exports.pathToRegexp = pathToRegexp2;
+  }
+});
+
+// src/build/route-utils.ts
+var import_path_to_regexp = __toESM(require_dist(), 1);
+import { parse as parseUrl, format as formatUrl } from "url";
+var UN_NAMED_SEGMENT = "__UN_NAMED_SEGMENT__";
+function sourceToRegex(source) {
+  const keys = [];
+  const r = (0, import_path_to_regexp.pathToRegexp)(source, keys, {
+    strict: true,
+    sensitive: true,
+    delimiter: "/"
+  });
+  const segments = keys.map((k) => k.name).map((name) => {
+    if (typeof name !== "string") {
+      return UN_NAMED_SEGMENT;
+    }
+    return name;
+  });
+  return { src: r.source, segments };
+}
+var namedGroupsRegex = /\(\?<([a-zA-Z][a-zA-Z0-9_]*)>/g;
+function normalizeHasKeys(hasItems = []) {
+  for (const hasItem of hasItems) {
+    if ("key" in hasItem && hasItem.type === "header") {
+      hasItem.key = hasItem.key.toLowerCase();
+    }
+  }
+  return hasItems;
+}
+function collectHasSegments(has) {
+  const hasSegments = /* @__PURE__ */ new Set();
+  for (const hasItem of has || []) {
+    if (!hasItem.value && "key" in hasItem) {
+      hasSegments.add(hasItem.key);
+    }
+    if (typeof hasItem.value === "string") {
+      for (const match of hasItem.value.matchAll(namedGroupsRegex)) {
+        if (match[1]) {
+          hasSegments.add(match[1]);
+        }
+      }
+      if (hasItem.type === "host") {
+        hasSegments.add("host");
+      }
+    }
+  }
+  return [...hasSegments];
+}
+function toSegmentDest(index) {
+  return "$" + (index + 1).toString();
+}
+var escapeSegment = (str, segmentName) => str.replace(
+  new RegExp(`:${segmentName}`, "g"),
+  `__ESC_COLON_${segmentName}`
+);
+var unescapeSegments = (str) => str.replace(/__ESC_COLON_/gi, ":");
+function safelyCompile(value, indexes, attemptDirectCompile) {
+  if (!value) {
+    return value;
+  }
+  if (attemptDirectCompile) {
+    try {
+      return (0, import_path_to_regexp.compile)(value, { validate: false })(indexes);
+    } catch (_) {
+    }
+  }
+  for (const key of Object.keys(indexes)) {
+    if (value.includes(`:${key}`)) {
+      value = value.replace(
+        new RegExp(`:${key}\\*`, "g"),
+        `:${key}--ESCAPED_PARAM_ASTERISK`
+      ).replace(
+        new RegExp(`:${key}\\?`, "g"),
+        `:${key}--ESCAPED_PARAM_QUESTION`
+      ).replace(
+        new RegExp(`:${key}\\+`, "g"),
+        `:${key}--ESCAPED_PARAM_PLUS`
+      ).replace(
+        new RegExp(`:${key}(?!\\w)`, "g"),
+        `--ESCAPED_PARAM_COLON${key}`
+      );
+    }
+  }
+  value = value.replace(/(:|\\*|\\?|\\+|\\(|\\)|\\{|\\})/g, "\\$1").replace(/--ESCAPED_PARAM_PLUS/g, "+").replace(/--ESCAPED_PARAM_COLON/g, ":").replace(/--ESCAPED_PARAM_QUESTION/g, "?").replace(/--ESCAPED_PARAM_ASTERISK/g, "*");
+  return (0, import_path_to_regexp.compile)(`/${value}`, { validate: false })(indexes).slice(1);
+}
+function replaceSegments(segments, hasItemSegments, destination, isRedirect, internalParamNames) {
+  const namedSegments = segments.filter((name) => name !== UN_NAMED_SEGMENT);
+  const canNeedReplacing = destination.includes(":") && namedSegments.length > 0 || hasItemSegments.length > 0 || !isRedirect;
+  if (!canNeedReplacing) {
+    return destination;
+  }
+  let escapedDestination = destination;
+  const indexes = {};
+  segments.forEach((name, index) => {
+    indexes[name] = toSegmentDest(index);
+    escapedDestination = escapeSegment(escapedDestination, name);
+  });
+  hasItemSegments.forEach((name) => {
+    indexes[name] = "$" + name;
+    escapedDestination = escapeSegment(escapedDestination, name);
+  });
+  const parsedDestination = parseUrl(escapedDestination, true);
+  delete parsedDestination.href;
+  delete parsedDestination.path;
+  delete parsedDestination.search;
+  delete parsedDestination.host;
+  let { pathname, hash, query, hostname, ...rest } = parsedDestination;
+  pathname = unescapeSegments(pathname || "");
+  hash = unescapeSegments(hash || "");
+  hostname = unescapeSegments(hostname || "");
+  let destParams = /* @__PURE__ */ new Set();
+  const pathnameKeys = [];
+  const hashKeys = [];
+  const hostnameKeys = [];
+  try {
+    (0, import_path_to_regexp.pathToRegexp)(pathname, pathnameKeys);
+    (0, import_path_to_regexp.pathToRegexp)(hash || "", hashKeys);
+    (0, import_path_to_regexp.pathToRegexp)(hostname || "", hostnameKeys);
+  } catch (_) {
+  }
+  destParams = new Set(
+    [...pathnameKeys, ...hashKeys, ...hostnameKeys].map((key) => key.name).filter((val) => typeof val === "string")
+  );
+  pathname = safelyCompile(pathname, indexes, true);
+  hash = hash ? safelyCompile(hash, indexes, true) : null;
+  hostname = hostname ? safelyCompile(hostname, indexes, true) : null;
+  for (const [key, strOrArray] of Object.entries(query)) {
+    if (Array.isArray(strOrArray)) {
+      query[key] = strOrArray.map(
+        (str) => safelyCompile(unescapeSegments(str), indexes, true)
+      );
+    } else {
+      query[key] = safelyCompile(
+        unescapeSegments(strOrArray),
+        indexes,
+        true
+      );
+    }
+  }
+  const paramKeys = Object.keys(indexes);
+  const needsQueryUpdating = !isRedirect && !paramKeys.some(
+    (param) => !(internalParamNames && internalParamNames.includes(param)) && destParams.has(param)
+  );
+  if (needsQueryUpdating) {
+    for (const param of paramKeys) {
+      if (!(param in query) && param !== UN_NAMED_SEGMENT) {
+        query[param] = indexes[param];
+      }
+    }
+  }
+  destination = formatUrl({
+    ...rest,
+    hostname,
+    pathname,
+    query,
+    hash
+  });
+  return destination.replace(/%24/g, "$");
+}
+function convertRedirects(redirects, defaultStatus = 308) {
+  return redirects.map((r) => {
+    const { src, segments } = sourceToRegex(r.source);
+    const hasSegments = collectHasSegments(r.has);
+    normalizeHasKeys(r.has);
+    normalizeHasKeys(r.missing);
+    try {
+      const loc = replaceSegments(segments, hasSegments, r.destination, true);
+      let status;
+      if (typeof r.permanent === "boolean") {
+        status = r.permanent ? 308 : 307;
+      } else if (r.statusCode) {
+        status = r.statusCode;
+      } else {
+        status = defaultStatus;
+      }
+      const route = {
+        src,
+        headers: { Location: loc },
+        status
+      };
+      if (r.has) {
+        route.has = r.has;
+      }
+      if (r.missing) {
+        route.missing = r.missing;
+      }
+      return route;
+    } catch (e) {
+      throw new Error(`Failed to parse redirect: ${JSON.stringify(r)}`);
+    }
+  });
+}
+function convertRewrites(rewrites, internalParamNames) {
+  return rewrites.map((r) => {
+    const { src, segments } = sourceToRegex(r.source);
+    const hasSegments = collectHasSegments(r.has);
+    normalizeHasKeys(r.has);
+    normalizeHasKeys(r.missing);
+    try {
+      const dest = replaceSegments(
+        segments,
+        hasSegments,
+        r.destination,
+        false,
+        internalParamNames
+      );
+      const route = { src, dest, check: true };
+      if (r.has) {
+        route.has = r.has;
+      }
+      if (r.missing) {
+        route.missing = r.missing;
+      }
+      if (r.statusCode) {
+        route.status = r.statusCode;
+      }
+      return route;
+    } catch (e) {
+      throw new Error(`Failed to parse rewrite: ${JSON.stringify(r)}`);
+    }
+  });
+}
+function convertHeaders(headers) {
+  return headers.map((h) => {
+    const obj = {};
+    const { src, segments } = sourceToRegex(h.source);
+    const hasSegments = collectHasSegments(h.has);
+    normalizeHasKeys(h.has);
+    normalizeHasKeys(h.missing);
+    const namedSegments = segments.filter((name) => name !== UN_NAMED_SEGMENT);
+    const indexes = {};
+    segments.forEach((name, index) => {
+      indexes[name] = toSegmentDest(index);
+    });
+    hasSegments.forEach((name) => {
+      indexes[name] = "$" + name;
+    });
+    h.headers.forEach(({ key, value }) => {
+      if (namedSegments.length > 0 || hasSegments.length > 0) {
+        if (key.includes(":")) {
+          key = safelyCompile(key, indexes);
+        }
+        if (value.includes(":")) {
+          value = safelyCompile(value, indexes);
+        }
+      }
+      obj[key] = value;
+    });
+    const route = {
+      src,
+      headers: obj,
+      continue: true
+    };
+    if (h.has) {
+      route.has = h.has;
+    }
+    if (h.missing) {
+      route.missing = h.missing;
+    }
+    return route;
+  });
+}
+function convertTrailingSlash(enable, status = 308) {
+  const routes = [];
+  if (enable) {
+    routes.push({
+      src: "^\\/\\.well-known(?:\\/.*)?$"
+    });
+    routes.push({
+      src: "^/((?:[^/]+/)*[^/\\.]+)$",
+      has: [{ type: "header", key: "x-nextjs-data" }],
+      headers: { Location: "/$1/" },
+      status
+    });
+    routes.push({
+      src: "^/((?:[^/]+/)*[^/]+\\.\\w+)/$",
+      headers: { Location: "/$1" },
+      status
+    });
+  } else {
+    routes.push({
+      src: "^/(.*)\\/$",
+      headers: { Location: "/$1" },
+      status
+    });
+  }
+  return routes;
+}
+export {
+  collectHasSegments,
+  convertHeaders,
+  convertRedirects,
+  convertRewrites,
+  convertTrailingSlash,
+  normalizeHasKeys,
+  safelyCompile,
+  sourceToRegex
+};

package/dist/build/routes.js

@@ -9,18 +9,130 @@ import "../esm-chunks/chunk-6BT4RYQJ.js";
 // src/build/routes.ts
 import * as fs from "fs";
 import * as path from "path";
-function isRE2Compatible(regexSource) {
-  const unsupported = [
-    /\(\?[=!<]/,
-    // 断言（前瞻、后顾）
-    /\(\?>/,
-    // 原子组
-    /\\(\d+)/,
-    // 反向引用 \1 \2
-    /\(\?\(/
-    // 条件表达式
-  ];
-  return !unsupported.some((r) => r.test(regexSource));
+import {
+  convertRedirects,
+  convertRewrites,
+  convertHeaders,
+  convertTrailingSlash
+} from "./route-utils.js";
+function hasAppRouter(appPathRoutesManifest) {
+  return appPathRoutesManifest && Object.keys(appPathRoutesManifest).length > 0;
+}
+function getBuildId(ctx) {
+  try {
+    const buildIdPath = path.join(ctx.publishDir, "BUILD_ID");
+    if (fs.existsSync(buildIdPath)) {
+      return fs.readFileSync(buildIdPath, "utf-8").trim();
+    }
+  } catch {
+  }
+  return null;
+}
+function isRE2Compatible(regex) {
+  if (/\(\?[=!<]/.test(regex)) {
+    return false;
+  }
+  if (/\\[1-9]/.test(regex)) {
+    return false;
+  }
+  return true;
+}
+function convertNamedRegexToSrc(namedRegex, basePath = "") {
+  const regexWithoutNamedGroups = namedRegex.replace(/\(\?<[a-zA-Z][a-zA-Z0-9_]*>/g, "(");
+  if (!isRE2Compatible(regexWithoutNamedGroups)) {
+    console.warn(`[opennext] Warning: Regex not RE2 compatible, skipping: ${namedRegex}`);
+    return null;
+  }
+  let src = namedRegex.replace(/\(\?<[a-zA-Z][a-zA-Z0-9_]*>/g, "(");
+  if (basePath && !src.startsWith(`^${basePath}`)) {
+    src = src.replace(/^\^/, `^${basePath}`);
+  }
+  return src;
+}
+function getDynamicRoutes(dynamicRoutes, basePath = "") {
+  const routes = [];
+  for (const route of dynamicRoutes) {
+    if (route.namedRegex) {
+      const src = convertNamedRegexToSrc(route.namedRegex, basePath);
+      if (src) {
+        routes.push({ src });
+      }
+    } else if (route.regex) {
+      if (isRE2Compatible(route.regex)) {
+        let src = route.regex;
+        if (basePath && !src.startsWith(`^${basePath}`)) {
+          src = src.replace(/^\^/, `^${basePath}`);
+        }
+        routes.push({ src });
+      }
+    }
+  }
+  return routes;
+}
+function getDataRoutes(dataRoutes, basePath = "") {
+  const routes = [];
+  for (const route of dataRoutes) {
+    if (route.namedDataRouteRegex) {
+      const src = convertNamedRegexToSrc(route.namedDataRouteRegex, basePath);
+      if (src) {
+        routes.push({ src });
+      }
+    } else if (route.dataRouteRegex) {
+      if (isRE2Compatible(route.dataRouteRegex)) {
+        let src = route.dataRouteRegex;
+        if (basePath && !src.startsWith(`^${basePath}`)) {
+          src = src.replace(/^\^/, `^${basePath}`);
+        }
+        routes.push({ src });
+      }
+    }
+  }
+  return routes;
+}
+function getServerRoutes(staticRoutes, prerenderManifest, basePath = "") {
+  const routes = [];
+  const prerenderRoutes = prerenderManifest?.routes || {};
+  for (const route of staticRoutes) {
+    if (route.page.startsWith("/_")) {
+      continue;
+    }
+    const prerenderInfo = prerenderRoutes[route.page];
+    if (prerenderInfo && prerenderInfo.initialRevalidateSeconds === false) {
+      continue;
+    }
+    if (route.namedRegex) {
+      let src = convertNamedRegexToSrc(route.namedRegex, basePath);
+      if (src) {
+        src = src.replace(/\(\?:\/\)\?\$$/, "$");
+        routes.push({ src });
+      }
+    } else if (route.regex) {
+      if (isRE2Compatible(route.regex)) {
+        let src = route.regex;
+        if (basePath && !src.startsWith(`^${basePath}`)) {
+          src = src.replace(/^\^/, `^${basePath}`);
+        }
+        src = src.replace(/\(\?:\/\)\?\$$/, "$");
+        routes.push({ src });
+      }
+    }
+  }
+  return routes;
+}
+function getApiRoutes(appPathsManifest, basePath = "") {
+  if (!appPathsManifest) {
+    return [];
+  }
+  const routes = [];
+  for (const routePath of Object.keys(appPathsManifest)) {
+    if (routePath.includes("/api/") && routePath.endsWith("/route")) {
+      const apiPath = routePath.replace(/\/route$/, "");
+      const escapedPath = apiPath.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+      const src = `^${basePath}${escapedPath}$`;
+      routes.push({ src });
+    }
+  }
+  return routes;
 }
 async function getMiddlewareConfig(ctx) {
   try {
@@ -91,8 +203,8 @@ async function getMiddlewareConfig(ctx) {
     return null;
   }
 }
-function updateEdgeFunctionsMetaJson(middlewareConfig) {
-  const metaJsonPath = path.join(process.cwd(), ".edgeone/edge-functions/meta.json");
+function updateEdgeFunctionsConfigJson(middlewareConfig) {
+  const metaJsonPath = path.join(process.cwd(), ".edgeone/edge-functions/config.json");
   let meta = { routes: [] };
   if (fs.existsSync(metaJsonPath)) {
     try {
@@ -110,101 +222,139 @@ function updateEdgeFunctionsMetaJson(middlewareConfig) {
   }
   fs.writeFileSync(metaJsonPath, JSON.stringify(meta, null, 2), "utf-8");
 }
-var convertNextRoutePattern = (path2) => {
-  if (!path2.includes("[")) {
-    return path2;
-  }
-  let convertedPath = path2;
-  const optionalCatchAllMatch = path2.match(/\[\[\.\.\.([^\]]+)\]\]/);
-  if (optionalCatchAllMatch) {
-    const paramName = optionalCatchAllMatch[1];
-    convertedPath = convertedPath.replace(/\[\[\.\.\.([^\]]+)\]\]/g, `:${paramName}*`);
-  }
-  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}`);
-  }
-  return convertedPath;
-};
 var createRouteMeta = async (ctx) => {
-  const routeMap = {};
-  const manifest = await ctx.getPrerenderManifest();
-  if (manifest?.routes) {
-    for (const [route, routeInfo] of Object.entries(manifest.routes)) {
-      routeMap[route] = {
-        // 提取关键信息到routeMap
-        isStatic: routeInfo.initialRevalidateSeconds === false,
-        initialRevalidateSeconds: routeInfo.initialRevalidateSeconds || void 0,
-        srcRoute: routeInfo.srcRoute || void 0,
-        dataRoute: routeInfo.dataRoute || void 0
-      };
-    }
+  const routes = [];
+  const routesManifest = await ctx.getRoutesManifest();
+  const appPathRoutesManifest = await ctx.getAppPathRoutesManifest();
+  const isAppRouter = hasAppRouter(appPathRoutesManifest);
+  const basePath = routesManifest?.basePath || "";
+  const trailingSlash = ctx.requiredServerFiles?.config?.trailingSlash ?? false;
+  const redirects = routesManifest?.redirects || [];
+  const headers = routesManifest?.headers || [];
+  const rewrites = routesManifest?.rewrites || { beforeFiles: [], afterFiles: [], fallback: [] };
+  let beforeFilesRewrites = [];
+  let afterFilesRewrites = [];
+  let fallbackRewrites = [];
+  if (Array.isArray(rewrites)) {
+    afterFilesRewrites = rewrites;
+  } else {
+    beforeFilesRewrites = rewrites.beforeFiles || [];
+    afterFilesRewrites = rewrites.afterFiles || [];
+    fallbackRewrites = rewrites.fallback || [];
   }
-  const pagesManifest = await ctx.getPagesManifest();
-  if (pagesManifest) {
-    for (const [route, filePath] of Object.entries(pagesManifest)) {
-      if (!routeMap[route]) {
-        routeMap[route] = {};
-      }
-      if (filePath.startsWith("pages") && filePath.endsWith(".html")) {
-        routeMap[route].isStatic = true;
-      }
+  const dynamicRoutes = routesManifest?.dynamicRoutes || [];
+  const dataRoutes = routesManifest?.dataRoutes || [];
+  const staticRoutes = routesManifest?.staticRoutes || [];
+  const appPathsManifest = await ctx.getAppPathsManifest?.() || null;
+  const prerenderManifest = await ctx.getPrerenderManifest?.() || null;
+  const buildId = getBuildId(ctx);
+  const staticCacheRegex = buildId ? `^${basePath}/_next/static/(?:[^/]+/pages|pages|chunks|runtime|css|image|media|${buildId.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")})/.+` : `^${basePath}/_next/static/(?:[^/]+/pages|pages|chunks|runtime|css|image|media)/.+`;
+  routes.push({
+    src: staticCacheRegex,
+    headers: {
+      "cache-control": "public,max-age=31536000,immutable"
+    },
+    continue: true
+  });
+  if (trailingSlash) {
+    routes.push(...convertTrailingSlash(true));
+  } else {
+    routes.push(...convertTrailingSlash(false));
+  }
+  if (headers.length > 0) {
+    try {
+      routes.push(...convertHeaders(headers));
+    } catch (e) {
+      console.warn("[opennext] Warning: Failed to convert some headers:", e);
     }
   }
-  const appPathRoutesManifest = await ctx.getAppPathRoutesManifest();
-  if (appPathRoutesManifest) {
-    for (const [route, actualRoute] of Object.entries(appPathRoutesManifest)) {
-      if (!routeMap[actualRoute]) {
-        routeMap[actualRoute] = {};
-      }
+  const userRedirects = redirects.filter((r) => !r.internal);
+  if (userRedirects.length > 0) {
+    try {
+      routes.push(...convertRedirects(userRedirects));
+    } catch (e) {
+      console.warn("[opennext] Warning: Failed to convert some redirects:", e);
     }
   }
-  const routesManifest = await ctx.getRoutesManifest();
-  if (routesManifest) {
-    const dataRoutes = routesManifest.dataRoutes;
-    if (dataRoutes) {
-      for (const { page, dataRouteRegex } of dataRoutes) {
-        routeMap[dataRouteRegex] = {
-          isStatic: routeMap[page]?.isStatic || false
-        };
-      }
+  if (beforeFilesRewrites.length > 0) {
+    try {
+      routes.push(...convertRewrites(beforeFilesRewrites));
+    } catch (e) {
+      console.warn("[opennext] Warning: Failed to convert beforeFiles rewrites:", e);
     }
   }
-  const imagesManifest = await ctx.getImagesManifest();
-  if (imagesManifest) {
-    if (imagesManifest.images) {
-      const imageConfig = imagesManifest.images;
-      routeMap[imageConfig.path] = {};
+  if (isAppRouter) {
+    const rscVary = "RSC, Next-Router-State-Tree, Next-Router-Prefetch, Next-Router-Segment-Prefetch";
+    const rscContentType = "text/x-component";
+    routes.push({
+      src: `^${basePath}/?$`,
+      has: [{ type: "header", key: "rsc", value: "1" }],
+      dest: `${basePath}/index.rsc`,
+      headers: { vary: rscVary, "content-type": rscContentType },
+      continue: true
+    });
+    routes.push({
+      src: `^${basePath}/(.+?)(?:/)?$`,
+      exclude: "\\.rsc/?$",
+      has: [{ type: "header", key: "rsc", value: "1" }],
+      dest: `${basePath}/$1.rsc`,
+      headers: { vary: rscVary, "content-type": rscContentType },
+      continue: true
+    });
+  }
+  routes.push({
+    src: `^${basePath}/404/?$`,
+    status: 404,
+    continue: true,
+    missing: [{ type: "header", key: "x-prerender-revalidate" }]
+  });
+  routes.push({
+    src: `^${basePath}/500$`,
+    status: 500,
+    continue: true
+  });
+  routes.push({
+    src: `^${basePath}/((?:[^/]+/)*[^/.]+)/$`,
+    dest: `${basePath}/$1`,
+    continue: true
+  });
+  routes.push({ handle: "filesystem" });
+  if (afterFilesRewrites.length > 0) {
+    try {
+      routes.push(...convertRewrites(afterFilesRewrites));
+    } catch (e) {
+      console.warn("[opennext] Warning: Failed to convert afterFiles rewrites:", e);
     }
   }
-  const convertedRouteMap = {};
-  const pathsToDelete = [];
-  for (const [routePath, routeConfig] of Object.entries(routeMap)) {
-    const convertedPath = convertNextRoutePattern(routePath);
-    if (convertedPath !== routePath) {
-      pathsToDelete.push(routePath);
-      convertedRouteMap[convertedPath] = routeConfig;
+  if (fallbackRewrites.length > 0) {
+    try {
+      routes.push(...convertRewrites(fallbackRewrites));
+    } catch (e) {
+      console.warn("[opennext] Warning: Failed to convert fallback rewrites:", e);
     }
   }
-  for (const pathToDelete of pathsToDelete) {
-    delete routeMap[pathToDelete];
+  if (staticRoutes.length > 0) {
+    routes.push(...getServerRoutes(staticRoutes, prerenderManifest, basePath));
+  }
+  if (dynamicRoutes.length > 0) {
+    routes.push(...getDynamicRoutes(dynamicRoutes, basePath));
   }
-  Object.assign(routeMap, convertedRouteMap);
-  const routesArray = Object.entries(routeMap).map(([path2, config]) => ({
-    path: path2,
-    ...config
-  }));
+  if (dataRoutes.length > 0) {
+    routes.push(...getDataRoutes(dataRoutes, basePath));
+  }
+  const apiRoutes = getApiRoutes(appPathsManifest, basePath);
+  if (apiRoutes.length > 0) {
+    routes.push(...apiRoutes);
+  }
+  routes.push({
+    src: `^${basePath}/.*$`
+  });
   const serverHandlerDir = ctx.serverHandlerRootDir;
   if (!fs.existsSync(serverHandlerDir)) {
     fs.mkdirSync(serverHandlerDir, { recursive: true });
   }
-  const metaFilePath = path.join(serverHandlerDir, "meta.json");
+  const nextVersion = ctx.nextVersion || null;
+  const imagesManifest = await ctx.getImagesManifest();
   const updatedRedirects = [];
   if (imagesManifest?.images?.path) {
     const imagePath = imagesManifest.images.path;
@@ -215,21 +365,24 @@ var createRouteMeta = async (ctx) => {
     };
     updatedRedirects.push(nextImageRedirect);
   }
-  const metaData = {
+  const config = {
+    version: 3,
+    routes,
     conf: {
       redirects: updatedRedirects
     },
-    nextRoutes: routesArray
+    ...nextVersion ? { framework: { version: nextVersion } } : {}
   };
+  const configFilePath = path.join(serverHandlerDir, "config.json");
   fs.writeFileSync(
-    metaFilePath,
-    JSON.stringify(metaData, null, 2),
+    configFilePath,
+    JSON.stringify(config, null, 2),
     "utf-8"
   );
+  console.log(`[opennext] Generated ${configFilePath} with ${routes.length} routes`);
   const middlewareConfig = await getMiddlewareConfig(ctx);
-  updateEdgeFunctionsMetaJson(middlewareConfig);
+  updateEdgeFunctionsConfigJson(middlewareConfig);
 };
 export {
-  convertNextRoutePattern,
   createRouteMeta
 };

package/dist/run/handlers/tags-handler.cjs

@@ -28,7 +28,7 @@ module.exports = __toCommonJS(tags_handler_exports);
 
 // package.json
 var name = "@edgeone/opennextjs-pages";
-var version = "0.1.6";
+var version = "0.1.7";
 
 // src/run/handlers/tags-handler.cts
 var import_request_context = require("./request-context.cjs");

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@edgeone/opennextjs-pages",
-  "version": "0.1.6",
+  "version": "0.1.7",
   "description": "",
   "main": "./dist/index.js",
   "type": "module",