@vercel/remix-builder 5.0.2 → 5.1.1

package/defaults/server-node.mjs

@@ -8,9 +8,13 @@ import * as build from '@remix-run/dev/server-build';
 
 installGlobals({
   nativeFetch:
+    // Explicit opt-in to native fetch via runtime env var
     (parseInt(process.versions.node, 10) >= 20 &&
       process.env.VERCEL_REMIX_NATIVE_FETCH === '1') ||
-    build.future.unstable_singleFetch,
+    // `unstable_singleFetch` future flag added in Remix v2.9.0
+    build.future.unstable_singleFetch ||
+    // `v3_singleFetch` future flag stabilized in Remix v2.13.0
+    build.future.v3_singleFetch,
 });
 
 const handleRequest = createRemixRequestHandler(

package/defaults/server-react-router.mjs

@@ -0,0 +1,3 @@
+import { createRequestHandler } from 'react-router';
+import * as build from 'ENTRYPOINT_PLACEHOLDER';
+export default createRequestHandler(build.default || build);

package/dist/index.js

@@ -2816,6 +2816,396 @@ var require_dist = __commonJS({
   }
 });
 
+// ../../node_modules/.pnpm/path-to-regexp@6.3.0/node_modules/path-to-regexp/dist/index.js
+var require_dist2 = __commonJS({
+  "../../node_modules/.pnpm/path-to-regexp@6.3.0/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 compile(str, options) {
+      return tokensToFunction(parse(str, options), options);
+    }
+    exports.compile = compile;
+    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/index.ts
 var src_exports = {};
 __export(src_exports, {
@@ -2837,9 +3227,40 @@ var import_semver = __toESM(require_semver2());
 var import_fs = require("fs");
 var import_path = require("path");
 var import_path_to_regexp = __toESM(require_dist());
+var import_path_to_regexp_updated = __toESM(require_dist2());
 var import_build_utils = require("@vercel/build-utils");
 var import_build_utils2 = require("@vercel/build-utils");
 var import_module = require("module");
+function pathToRegexp(callerId, path, keys, options) {
+  const currentRegExp = (0, import_path_to_regexp.pathToRegexp)(path, keys, options);
+  try {
+    const currentKeys = keys;
+    const newKeys = [];
+    const newRegExp = (0, import_path_to_regexp_updated.pathToRegexp)(path, newKeys, options);
+    const isDiffRegExp = currentRegExp.toString() !== newRegExp.toString();
+    if (process.env.FORCE_PATH_TO_REGEXP_LOG || isDiffRegExp) {
+      const message = JSON.stringify({
+        path,
+        currentRegExp: currentRegExp.toString(),
+        newRegExp: newRegExp.toString()
+      });
+      console.error(`[vc] PATH TO REGEXP PATH DIFF @ #${callerId}: ${message}`);
+    }
+    const isDiffKeys = keys?.toString() !== newKeys?.toString();
+    if (process.env.FORCE_PATH_TO_REGEXP_LOG || isDiffKeys) {
+      const message = JSON.stringify({
+        isDiffKeys,
+        currentKeys,
+        newKeys
+      });
+      console.error(`[vc] PATH TO REGEXP KEYS DIFF @ #${callerId}: ${message}`);
+    }
+  } catch (err) {
+    const error = err;
+    console.error(`[vc] PATH TO REGEXP ERROR @ #${callerId}: ${error.message}`);
+  }
+  return currentRegExp;
+}
 var require_ = (0, import_module.createRequire)(__filename);
 var SPLAT_PATH = "/:params*";
 var entryExts = [".js", ".jsx", ".ts", ".tsx"];
@@ -2950,7 +3371,7 @@ function getPathFromRoute(route, routes) {
 }
 function getRegExpFromPath(rePath) {
   const keys = [];
-  const re = (0, import_path_to_regexp.pathToRegexp)(rePath, keys);
+  const re = pathToRegexp("923", rePath, keys);
   return keys.length > 0 ? re : false;
 }
 async function chdirAndReadConfig(remixRunDevPath, dir, packageJsonPath) {
@@ -3066,17 +3487,15 @@ function hasScript(scriptName, pkg) {
   const scripts = pkg?.scripts || {};
   return typeof scripts[scriptName] === "string";
 }
-async function getRemixVersion(dir, base) {
-  const resolvedPath = require_.resolve("@remix-run/dev", { paths: [dir] });
+async function getPackageVersion(name, dir, base) {
+  const resolvedPath = require_.resolve(name, { paths: [dir] });
   const pkgPath = await (0, import_build_utils2.walkParentDirs)({
     base,
     start: (0, import_path.dirname)(resolvedPath),
     filename: "package.json"
   });
   if (!pkgPath) {
-    throw new Error(
-      `Failed to find \`package.json\` file for "@remix-run/dev"`
-    );
+    throw new Error(`Failed to find \`package.json\` file for "${name}"`);
   }
   const { version: version2 } = JSON.parse(
     await import_fs.promises.readFile(pkgPath, "utf8")
@@ -3137,6 +3556,80 @@ var nodeServerSrcPromise = import_fs2.promises.readFile(
   (0, import_path2.join)(DEFAULTS_PATH, "server-node.mjs"),
   "utf-8"
 );
+var reactRouterServerSrcPromise = import_fs2.promises.readFile(
+  (0, import_path2.join)(DEFAULTS_PATH, "server-react-router.mjs"),
+  "utf-8"
+);
+var REMIX_FRAMEWORK_SETTINGS = {
+  primaryPackageName: "@remix-run/dev",
+  buildCommand: "remix build",
+  buildResultFilePath: ".vercel/remix-build-result.json",
+  createRenderFunction({
+    nodeVersion,
+    entrypointDir,
+    rootDir,
+    serverBuildPath,
+    serverEntryPoint,
+    frameworkVersion,
+    config
+  }) {
+    if (config.runtime === "edge") {
+      return createRenderEdgeFunction(
+        entrypointDir,
+        rootDir,
+        serverBuildPath,
+        serverEntryPoint,
+        frameworkVersion,
+        config
+      );
+    }
+    return createRenderNodeFunction(
+      nodeVersion,
+      entrypointDir,
+      rootDir,
+      serverBuildPath,
+      serverEntryPoint,
+      frameworkVersion,
+      config
+    );
+  }
+};
+var REACT_ROUTER_FRAMEWORK_SETTINGS = {
+  primaryPackageName: "react-router",
+  buildCommand: "react-router build",
+  buildResultFilePath: ".vercel/react-router-build-result.json",
+  createRenderFunction({
+    nodeVersion,
+    entrypointDir,
+    rootDir,
+    serverBuildPath,
+    serverEntryPoint,
+    frameworkVersion,
+    config
+  }) {
+    return createRenderReactRouterFunction(
+      nodeVersion,
+      entrypointDir,
+      rootDir,
+      serverBuildPath,
+      serverEntryPoint,
+      frameworkVersion,
+      config
+    );
+  }
+};
+function determineFrameworkSettings(workPath) {
+  const isReactRouter = findConfig(workPath, "react-router.config", [
+    ".js",
+    ".ts",
+    ".mjs",
+    ".mts"
+  ]);
+  if (isReactRouter) {
+    return REACT_ROUTER_FRAMEWORK_SETTINGS;
+  }
+  return REMIX_FRAMEWORK_SETTINGS;
+}
 var build = async ({
   entrypoint,
   workPath,
@@ -3147,6 +3640,7 @@ var build = async ({
   const { installCommand, buildCommand } = config;
   const mountpoint = (0, import_path2.dirname)(entrypoint);
   const entrypointFsDirname = (0, import_path2.join)(workPath, mountpoint);
+  const frameworkSettings = determineFrameworkSettings(workPath);
   const nodeVersion = await (0, import_build_utils3.getNodeVersion)(
     entrypointFsDirname,
     void 0,
@@ -3185,7 +3679,11 @@ var build = async ({
   } else {
     await (0, import_build_utils3.runNpmInstall)(entrypointFsDirname, [], spawnOpts, meta, nodeVersion);
   }
-  const remixVersion = await getRemixVersion(entrypointFsDirname, repoRootPath);
+  const frameworkVersion = await getPackageVersion(
+    frameworkSettings.primaryPackageName,
+    entrypointFsDirname,
+    repoRootPath
+  );
   if (buildCommand) {
     (0, import_build_utils3.debug)(`Executing build command "${buildCommand}"`);
     await (0, import_build_utils3.execCommand)(buildCommand, {
@@ -3204,28 +3702,28 @@ var build = async ({
       (0, import_build_utils3.debug)(`Executing "build" script`);
       await (0, import_build_utils3.runPackageJsonScript)(entrypointFsDirname, "build", spawnOpts);
     } else {
-      await (0, import_build_utils3.execCommand)("remix build", {
+      await (0, import_build_utils3.execCommand)(frameworkSettings.buildCommand, {
         ...spawnOpts,
         cwd: entrypointFsDirname
       });
     }
   }
-  const remixBuildResultPath = (0, import_path2.join)(
+  const buildResultJsonPath = (0, import_path2.join)(
     entrypointFsDirname,
-    ".vercel/remix-build-result.json"
+    frameworkSettings.buildResultFilePath
   );
-  let remixBuildResult;
+  let buildResult;
   try {
-    const remixBuildResultContents = (0, import_fs2.readFileSync)(remixBuildResultPath, "utf8");
-    remixBuildResult = JSON.parse(remixBuildResultContents);
+    const buildResultContents = (0, import_fs2.readFileSync)(buildResultJsonPath, "utf8");
+    buildResult = JSON.parse(buildResultContents);
   } catch (err) {
     if (!(0, import_error_utils.isErrnoException)(err) || err.code !== "ENOENT") {
       throw err;
     }
-    const buildDirectory = (0, import_path2.join)(entrypointFsDirname, "build");
-    if ((0, import_fs2.statSync)(buildDirectory).isDirectory()) {
+    const buildDirectory2 = (0, import_path2.join)(entrypointFsDirname, "build");
+    if ((0, import_fs2.statSync)(buildDirectory2).isDirectory()) {
       console.warn("WARN: The `vercelPreset()` Preset was not detected.");
-      remixBuildResult = {
+      buildResult = {
         buildManifest: {
           routes: {
             root: {
@@ -3244,15 +3742,15 @@ var build = async ({
           }
         },
         remixConfig: {
-          buildDirectory
+          buildDirectory: buildDirectory2
         }
       };
       const serverPath = "build/server/index.js";
       if ((0, import_fs2.existsSync)((0, import_path2.join)(entrypointFsDirname, serverPath))) {
-        remixBuildResult.buildManifest.routeIdToServerBundleId = {
+        buildResult.buildManifest.routeIdToServerBundleId = {
           "routes/_index": ""
         };
-        remixBuildResult.buildManifest.serverBundles = {
+        buildResult.buildManifest.serverBundles = {
           "": {
             id: "",
             file: serverPath,
@@ -3262,36 +3760,27 @@ var build = async ({
       }
     }
   }
-  if (!remixBuildResult) {
+  if (!buildResult) {
     throw new Error(
       "Could not determine build output directory. Please configure the `vercelPreset()` Preset from the `@vercel/remix` npm package"
     );
   }
-  const { buildManifest, remixConfig, viteConfig } = remixBuildResult;
-  const staticDir = (0, import_path2.join)(remixConfig.buildDirectory, "client");
+  const { buildManifest, viteConfig } = buildResult;
+  const buildDirectory = "remixConfig" in buildResult ? buildResult.remixConfig.buildDirectory : buildResult.reactRouterConfig.buildDirectory;
+  const staticDir = (0, import_path2.join)(buildDirectory, "client");
   const serverBundles = Object.values(buildManifest.serverBundles ?? {});
   const [staticFiles, ...functions] = await Promise.all([
     (0, import_build_utils3.glob)("**", staticDir),
     ...serverBundles.map((bundle) => {
-      if (bundle.config.runtime === "edge") {
-        return createRenderEdgeFunction(
-          entrypointFsDirname,
-          repoRootPath,
-          (0, import_path2.join)(entrypointFsDirname, bundle.file),
-          void 0,
-          remixVersion,
-          bundle.config
-        );
-      }
-      return createRenderNodeFunction(
+      return frameworkSettings.createRenderFunction({
         nodeVersion,
-        entrypointFsDirname,
-        repoRootPath,
-        (0, import_path2.join)(entrypointFsDirname, bundle.file),
-        void 0,
-        remixVersion,
-        bundle.config
-      );
+        entrypointDir: entrypointFsDirname,
+        rootDir: repoRootPath,
+        serverBuildPath: (0, import_path2.join)(entrypointFsDirname, bundle.file),
+        serverEntryPoint: void 0,
+        frameworkVersion,
+        config: bundle.config
+      });
     })
   ]);
   const functionsMap = /* @__PURE__ */ new Map();
@@ -3335,9 +3824,98 @@ var build = async ({
     src: "/(.*)",
     dest: "/"
   });
-  return { routes, output, framework: { version: remixVersion } };
+  return { routes, output, framework: { version: frameworkVersion } };
 };
-async function createRenderNodeFunction(nodeVersion, entrypointDir, rootDir, serverBuildPath, serverEntryPoint, remixVersion, config) {
+async function createRenderReactRouterFunction(nodeVersion, entrypointDir, rootDir, serverBuildPath, serverEntryPoint, frameworkVersion, config) {
+  const isEdgeFunction = config.runtime === "edge";
+  const files = {};
+  let handler = (0, import_path2.relative)(rootDir, serverBuildPath);
+  let handlerPath = (0, import_path2.join)(rootDir, handler);
+  if (!serverEntryPoint) {
+    const baseServerBuildPath = (0, import_path2.basename)(serverBuildPath, ".js");
+    handler = (0, import_path2.join)((0, import_path2.dirname)(handler), `server-${baseServerBuildPath}.mjs`);
+    handlerPath = (0, import_path2.join)(rootDir, handler);
+    const reactRouterServerSrc = await reactRouterServerSrcPromise;
+    await import_fs2.promises.writeFile(
+      handlerPath,
+      reactRouterServerSrc.replace(
+        "ENTRYPOINT_PLACEHOLDER",
+        `./${baseServerBuildPath}.js`
+      )
+    );
+  }
+  let conditions;
+  let readFile;
+  if (isEdgeFunction) {
+    conditions = ["edge-light", "browser", "module", "import", "require"];
+    readFile = async (fsPath) => {
+      let source;
+      try {
+        source = await import_fs2.promises.readFile(fsPath);
+      } catch (err) {
+        if (err.code === "ENOENT" || err.code === "EISDIR") {
+          return null;
+        }
+        throw err;
+      }
+      if ((0, import_path2.basename)(fsPath) === "package.json") {
+        const pkgJson = JSON.parse(source.toString());
+        for (const prop of ["browser", "module"]) {
+          const val = pkgJson[prop];
+          if (typeof val === "string") {
+            pkgJson.main = val;
+            source = JSON.stringify(pkgJson);
+            break;
+          }
+        }
+      }
+      return source;
+    };
+  }
+  const trace = await (0, import_nft.nodeFileTrace)([handlerPath], {
+    base: rootDir,
+    processCwd: entrypointDir,
+    conditions,
+    readFile
+  });
+  logNftWarnings(trace.warnings, "react-router");
+  for (const file of trace.fileList) {
+    files[file] = await import_build_utils3.FileFsRef.fromFsPath({ fsPath: (0, import_path2.join)(rootDir, file) });
+  }
+  let fn;
+  if (isEdgeFunction) {
+    fn = new import_build_utils3.EdgeFunction({
+      files,
+      deploymentTarget: "v8-worker",
+      entrypoint: handler,
+      regions: config.regions,
+      framework: {
+        slug: "react-router",
+        version: frameworkVersion
+      }
+    });
+  } else {
+    fn = new import_build_utils3.NodejsLambda({
+      files,
+      handler,
+      runtime: nodeVersion.runtime,
+      shouldAddHelpers: false,
+      shouldAddSourcemapSupport: false,
+      operationType: "SSR",
+      supportsResponseStreaming: true,
+      useWebApi: true,
+      regions: config.regions,
+      memory: config.memory,
+      maxDuration: config.maxDuration,
+      framework: {
+        slug: "react-router",
+        version: frameworkVersion
+      }
+    });
+  }
+  return fn;
+}
+async function createRenderNodeFunction(nodeVersion, entrypointDir, rootDir, serverBuildPath, serverEntryPoint, frameworkVersion, config) {
   const files = {};
   let handler = (0, import_path2.relative)(rootDir, serverBuildPath);
   let handlerPath = (0, import_path2.join)(rootDir, handler);
@@ -3375,12 +3953,12 @@ async function createRenderNodeFunction(nodeVersion, entrypointDir, rootDir, ser
     maxDuration: config.maxDuration,
     framework: {
       slug: "remix",
-      version: remixVersion
+      version: frameworkVersion
     }
   });
   return fn;
 }
-async function createRenderEdgeFunction(entrypointDir, rootDir, serverBuildPath, serverEntryPoint, remixVersion, config) {
+async function createRenderEdgeFunction(entrypointDir, rootDir, serverBuildPath, serverEntryPoint, frameworkVersion, config) {
   const files = {};
   let handler = (0, import_path2.relative)(rootDir, serverBuildPath);
   let handlerPath = (0, import_path2.join)(rootDir, handler);
@@ -3441,7 +4019,7 @@ async function createRenderEdgeFunction(entrypointDir, rootDir, serverBuildPath,
     regions: config.regions,
     framework: {
       slug: "remix",
-      version: remixVersion
+      version: frameworkVersion
     }
   });
   return fn;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vercel/remix-builder",
-  "version": "5.0.2",
+  "version": "5.1.1",
   "license": "Apache-2.0",
   "main": "./dist/index.js",
   "homepage": "https://vercel.com/docs",
@@ -24,10 +24,11 @@
     "@types/jest": "27.5.1",
     "@types/node": "14.18.33",
     "@types/semver": "7.3.13",
-    "@vercel/build-utils": "9.0.1",
+    "@vercel/build-utils": "9.1.0",
     "glob": "10.3.16",
     "jest-junit": "16.0.0",
     "path-to-regexp": "6.2.1",
+    "path-to-regexp-updated": "npm:path-to-regexp@6.3.0",
     "semver": "7.5.2",
     "vitest": "2.0.1"
   },