@netlify/plugin-nextjs 4.41.3 → 5.0.0-beta.0

package/dist/run/next.cjs

@@ -0,0 +1,1055 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __commonJS = (cb, mod) => function __require() {
+  return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// node_modules/fs-monkey/lib/util/lists.js
+var require_lists = __commonJS({
+  "node_modules/fs-monkey/lib/util/lists.js"(exports2) {
+    "use strict";
+    Object.defineProperty(exports2, "__esModule", {
+      value: true
+    });
+    exports2.fsSyncMethods = exports2.fsProps = exports2.fsAsyncMethods = void 0;
+    var fsProps = ["constants", "F_OK", "R_OK", "W_OK", "X_OK", "Stats"];
+    exports2.fsProps = fsProps;
+    var fsSyncMethods = ["renameSync", "ftruncateSync", "truncateSync", "chownSync", "fchownSync", "lchownSync", "chmodSync", "fchmodSync", "lchmodSync", "statSync", "lstatSync", "fstatSync", "linkSync", "symlinkSync", "readlinkSync", "realpathSync", "unlinkSync", "rmdirSync", "mkdirSync", "mkdirpSync", "readdirSync", "closeSync", "openSync", "utimesSync", "futimesSync", "fsyncSync", "writeSync", "readSync", "readFileSync", "writeFileSync", "appendFileSync", "existsSync", "accessSync", "fdatasyncSync", "mkdtempSync", "copyFileSync", "rmSync", "createReadStream", "createWriteStream"];
+    exports2.fsSyncMethods = fsSyncMethods;
+    var fsAsyncMethods = ["rename", "ftruncate", "truncate", "chown", "fchown", "lchown", "chmod", "fchmod", "lchmod", "stat", "lstat", "fstat", "link", "symlink", "readlink", "realpath", "unlink", "rmdir", "mkdir", "mkdirp", "readdir", "close", "open", "utimes", "futimes", "fsync", "write", "read", "readFile", "writeFile", "appendFile", "exists", "access", "fdatasync", "mkdtemp", "copyFile", "rm", "watchFile", "unwatchFile", "watch"];
+    exports2.fsAsyncMethods = fsAsyncMethods;
+  }
+});
+
+// node_modules/fs-monkey/lib/patchFs.js
+var require_patchFs = __commonJS({
+  "node_modules/fs-monkey/lib/patchFs.js"(exports2) {
+    "use strict";
+    Object.defineProperty(exports2, "__esModule", {
+      value: true
+    });
+    exports2["default"] = patchFs2;
+    var _lists = require_lists();
+    function _createForOfIteratorHelper(o, allowArrayLike) {
+      var it = typeof Symbol !== "undefined" && o[Symbol.iterator] || o["@@iterator"];
+      if (!it) {
+        if (Array.isArray(o) || (it = _unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === "number") {
+          if (it)
+            o = it;
+          var i = 0;
+          var F = function F2() {
+          };
+          return { s: F, n: function n() {
+            if (i >= o.length)
+              return { done: true };
+            return { done: false, value: o[i++] };
+          }, e: function e(_e) {
+            throw _e;
+          }, f: F };
+        }
+        throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
+      }
+      var normalCompletion = true, didErr = false, err;
+      return { s: function s() {
+        it = it.call(o);
+      }, n: function n() {
+        var step = it.next();
+        normalCompletion = step.done;
+        return step;
+      }, e: function e(_e2) {
+        didErr = true;
+        err = _e2;
+      }, f: function f() {
+        try {
+          if (!normalCompletion && it["return"] != null)
+            it["return"]();
+        } finally {
+          if (didErr)
+            throw err;
+        }
+      } };
+    }
+    function _unsupportedIterableToArray(o, minLen) {
+      if (!o)
+        return;
+      if (typeof o === "string")
+        return _arrayLikeToArray(o, minLen);
+      var n = Object.prototype.toString.call(o).slice(8, -1);
+      if (n === "Object" && o.constructor)
+        n = o.constructor.name;
+      if (n === "Map" || n === "Set")
+        return Array.from(o);
+      if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n))
+        return _arrayLikeToArray(o, minLen);
+    }
+    function _arrayLikeToArray(arr, len) {
+      if (len == null || len > arr.length)
+        len = arr.length;
+      for (var i = 0, arr2 = new Array(len); i < len; i++)
+        arr2[i] = arr[i];
+      return arr2;
+    }
+    function patchFs2(vol) {
+      var fs2 = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : require("fs");
+      var bkp = {};
+      var patch = function patch2(key, newValue) {
+        bkp[key] = fs2[key];
+        fs2[key] = newValue;
+      };
+      var patchMethod = function patchMethod2(key) {
+        return patch(key, vol[key].bind(vol));
+      };
+      var _iterator = _createForOfIteratorHelper(_lists.fsProps), _step;
+      try {
+        for (_iterator.s(); !(_step = _iterator.n()).done; ) {
+          var prop = _step.value;
+          if (typeof vol[prop] !== "undefined")
+            patch(prop, vol[prop]);
+        }
+      } catch (err) {
+        _iterator.e(err);
+      } finally {
+        _iterator.f();
+      }
+      if (typeof vol.StatWatcher === "function") {
+        patch("StatWatcher", vol.FSWatcher.bind(null, vol));
+      }
+      if (typeof vol.FSWatcher === "function") {
+        patch("FSWatcher", vol.StatWatcher.bind(null, vol));
+      }
+      if (typeof vol.ReadStream === "function") {
+        patch("ReadStream", vol.ReadStream.bind(null, vol));
+      }
+      if (typeof vol.WriteStream === "function") {
+        patch("WriteStream", vol.WriteStream.bind(null, vol));
+      }
+      if (typeof vol._toUnixTimestamp === "function")
+        patchMethod("_toUnixTimestamp");
+      var _iterator2 = _createForOfIteratorHelper(_lists.fsAsyncMethods), _step2;
+      try {
+        for (_iterator2.s(); !(_step2 = _iterator2.n()).done; ) {
+          var method = _step2.value;
+          if (typeof vol[method] === "function")
+            patchMethod(method);
+        }
+      } catch (err) {
+        _iterator2.e(err);
+      } finally {
+        _iterator2.f();
+      }
+      var _iterator3 = _createForOfIteratorHelper(_lists.fsSyncMethods), _step3;
+      try {
+        for (_iterator3.s(); !(_step3 = _iterator3.n()).done; ) {
+          var _method = _step3.value;
+          if (typeof vol[_method] === "function")
+            patchMethod(_method);
+        }
+      } catch (err) {
+        _iterator3.e(err);
+      } finally {
+        _iterator3.f();
+      }
+      return function unpatch() {
+        for (var key in bkp)
+          fs2[key] = bkp[key];
+      };
+    }
+  }
+});
+
+// node_modules/fs-monkey/lib/correctPath.js
+var require_correctPath = __commonJS({
+  "node_modules/fs-monkey/lib/correctPath.js"(exports2) {
+    "use strict";
+    Object.defineProperty(exports2, "__esModule", {
+      value: true
+    });
+    exports2.correctPath = correctPath;
+    exports2.unixify = unixify;
+    var isWin = process.platform === "win32";
+    function removeTrailingSeparator(str) {
+      var i = str.length - 1;
+      if (i < 2) {
+        return str;
+      }
+      while (isSeparator(str, i)) {
+        i--;
+      }
+      return str.substr(0, i + 1);
+    }
+    function isSeparator(str, i) {
+      var _char = str[i];
+      return i > 0 && (_char === "/" || isWin && _char === "\\");
+    }
+    function normalizePath(str, stripTrailing) {
+      if (typeof str !== "string") {
+        throw new TypeError("expected a string");
+      }
+      str = str.replace(/[\\\/]+/g, "/");
+      if (stripTrailing !== false) {
+        str = removeTrailingSeparator(str);
+      }
+      return str;
+    }
+    function unixify(filepath) {
+      var stripTrailing = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : true;
+      if (isWin) {
+        filepath = normalizePath(filepath, stripTrailing);
+        return filepath.replace(/^([a-zA-Z]+:|\.\/)/, "");
+      }
+      return filepath;
+    }
+    function correctPath(filepath) {
+      return unixify(filepath.replace(/^\\\\\?\\.:\\/, "\\"));
+    }
+  }
+});
+
+// node_modules/fs-monkey/lib/patchRequire.js
+var require_patchRequire = __commonJS({
+  "node_modules/fs-monkey/lib/patchRequire.js"(exports2) {
+    "use strict";
+    function _typeof(obj) {
+      "@babel/helpers - typeof";
+      return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function(obj2) {
+        return typeof obj2;
+      } : function(obj2) {
+        return obj2 && "function" == typeof Symbol && obj2.constructor === Symbol && obj2 !== Symbol.prototype ? "symbol" : typeof obj2;
+      }, _typeof(obj);
+    }
+    Object.defineProperty(exports2, "__esModule", {
+      value: true
+    });
+    exports2["default"] = patchRequire;
+    var path = _interopRequireWildcard(require("path"));
+    function _getRequireWildcardCache(nodeInterop) {
+      if (typeof WeakMap !== "function")
+        return null;
+      var cacheBabelInterop = /* @__PURE__ */ new WeakMap();
+      var cacheNodeInterop = /* @__PURE__ */ new WeakMap();
+      return (_getRequireWildcardCache = function _getRequireWildcardCache2(nodeInterop2) {
+        return nodeInterop2 ? cacheNodeInterop : cacheBabelInterop;
+      })(nodeInterop);
+    }
+    function _interopRequireWildcard(obj, nodeInterop) {
+      if (!nodeInterop && obj && obj.__esModule) {
+        return obj;
+      }
+      if (obj === null || _typeof(obj) !== "object" && typeof obj !== "function") {
+        return { "default": obj };
+      }
+      var cache = _getRequireWildcardCache(nodeInterop);
+      if (cache && cache.has(obj)) {
+        return cache.get(obj);
+      }
+      var newObj = {};
+      var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor;
+      for (var key in obj) {
+        if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) {
+          var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null;
+          if (desc && (desc.get || desc.set)) {
+            Object.defineProperty(newObj, key, desc);
+          } else {
+            newObj[key] = obj[key];
+          }
+        }
+      }
+      newObj["default"] = obj;
+      if (cache) {
+        cache.set(obj, newObj);
+      }
+      return newObj;
+    }
+    var isWin32 = process.platform === "win32";
+    var correctPath = isWin32 ? require_correctPath().correctPath : function(p) {
+      return p;
+    };
+    function stripBOM(content) {
+      if (content.charCodeAt(0) === 65279) {
+        content = content.slice(1);
+      }
+      return content;
+    }
+    function patchRequire(vol) {
+      var unixifyPaths = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : false;
+      var Module = arguments.length > 2 && arguments[2] !== void 0 ? arguments[2] : require("module");
+      if (isWin32 && unixifyPaths) {
+        var original = vol;
+        vol = {
+          readFileSync: function readFileSync(path2, options) {
+            return original.readFileSync(correctPath(path2), options);
+          },
+          realpathSync: function realpathSync(path2) {
+            return original.realpathSync(correctPath(path2));
+          },
+          statSync: function statSync(path2) {
+            return original.statSync(correctPath(path2));
+          }
+        };
+      }
+      function internalModuleReadFile(path2) {
+        try {
+          return vol.readFileSync(path2, "utf8");
+        } catch (err) {
+        }
+      }
+      function internalModuleStat(filename) {
+        try {
+          return vol.statSync(filename).isDirectory() ? 1 : 0;
+        } catch (err) {
+          return -2;
+        }
+      }
+      function stat(filename) {
+        filename = path._makeLong(filename);
+        var cache = stat.cache;
+        if (cache !== null) {
+          var _result = cache.get(filename);
+          if (_result !== void 0)
+            return _result;
+        }
+        var result = internalModuleStat(filename);
+        if (cache !== null)
+          cache.set(filename, result);
+        return result;
+      }
+      stat.cache = null;
+      var preserveSymlinks = false;
+      function toRealPath(requestPath) {
+        return vol.realpathSync(requestPath);
+      }
+      var packageMainCache = /* @__PURE__ */ Object.create(null);
+      function readPackage(requestPath) {
+        var entry = packageMainCache[requestPath];
+        if (entry)
+          return entry;
+        var jsonPath = path.resolve(requestPath, "package.json");
+        var json = internalModuleReadFile(path._makeLong(jsonPath));
+        if (json === void 0) {
+          return false;
+        }
+        var pkg;
+        try {
+          var pkgJson = JSON.parse(json);
+          pkg = packageMainCache[requestPath] = pkgJson.exports && pkgJson.exports.require || pkgJson.main;
+        } catch (e) {
+          e.path = jsonPath;
+          e.message = "Error parsing " + jsonPath + ": " + e.message;
+          throw e;
+        }
+        return pkg;
+      }
+      function tryFile(requestPath, isMain) {
+        var rc = stat(requestPath);
+        if (preserveSymlinks && !isMain) {
+          return rc === 0 && path.resolve(requestPath);
+        }
+        return rc === 0 && toRealPath(requestPath);
+      }
+      function tryExtensions(p, exts, isMain) {
+        for (var i = 0; i < exts.length; i++) {
+          var filename = tryFile(p + exts[i], isMain);
+          if (filename) {
+            return filename;
+          }
+        }
+        return false;
+      }
+      function tryPackage(requestPath, exts, isMain) {
+        var pkg = readPackage(requestPath);
+        if (!pkg)
+          return false;
+        var filename = path.resolve(requestPath, pkg);
+        return tryFile(filename, isMain) || tryExtensions(filename, exts, isMain) || tryExtensions(path.resolve(filename, "index"), exts, isMain);
+      }
+      Module._extensions[".js"] = function(module3, filename) {
+        var content = vol.readFileSync(filename, "utf8");
+        module3._compile(stripBOM(content), filename);
+      };
+      Module._extensions[".json"] = function(module3, filename) {
+        var content = vol.readFileSync(filename, "utf8");
+        try {
+          module3.exports = JSON.parse(stripBOM(content));
+        } catch (err) {
+          err.message = filename + ": " + err.message;
+          throw err;
+        }
+      };
+      var warned = true;
+      Module._findPath = function(request, paths, isMain) {
+        if (path.isAbsolute(request)) {
+          paths = [""];
+        } else if (!paths || paths.length === 0) {
+          return false;
+        }
+        var cacheKey = request + "\0" + (paths.length === 1 ? paths[0] : paths.join("\0"));
+        var entry = Module._pathCache[cacheKey];
+        if (entry)
+          return entry;
+        var exts;
+        var trailingSlash = request.length > 0 && request.charCodeAt(request.length - 1) === 47;
+        for (var i = 0; i < paths.length; i++) {
+          var curPath = paths[i];
+          if (curPath && stat(curPath) < 1)
+            continue;
+          var basePath = correctPath(path.resolve(curPath, request));
+          var filename;
+          var rc = stat(basePath);
+          if (!trailingSlash) {
+            if (rc === 0) {
+              if (preserveSymlinks && !isMain) {
+                filename = path.resolve(basePath);
+              } else {
+                filename = toRealPath(basePath);
+              }
+            } else if (rc === 1) {
+              if (exts === void 0)
+                exts = Object.keys(Module._extensions);
+              filename = tryPackage(basePath, exts, isMain);
+            }
+            if (!filename) {
+              if (exts === void 0)
+                exts = Object.keys(Module._extensions);
+              filename = tryExtensions(basePath, exts, isMain);
+            }
+          }
+          if (!filename && rc === 1) {
+            if (exts === void 0)
+              exts = Object.keys(Module._extensions);
+            filename = tryPackage(basePath, exts, isMain);
+          }
+          if (!filename && rc === 1) {
+            if (exts === void 0)
+              exts = Object.keys(Module._extensions);
+            filename = tryExtensions(path.resolve(basePath, "index"), exts, isMain);
+          }
+          if (filename) {
+            if (request === "." && i > 0) {
+              if (!warned) {
+                warned = true;
+                process.emitWarning("warning: require('.') resolved outside the package directory. This functionality is deprecated and will be removed soon.", "DeprecationWarning", "DEP0019");
+              }
+            }
+            Module._pathCache[cacheKey] = filename;
+            return filename;
+          }
+        }
+        return false;
+      };
+    }
+  }
+});
+
+// node_modules/fs-monkey/lib/index.js
+var require_lib = __commonJS({
+  "node_modules/fs-monkey/lib/index.js"(exports2) {
+    "use strict";
+    function _typeof(obj) {
+      "@babel/helpers - typeof";
+      return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function(obj2) {
+        return typeof obj2;
+      } : function(obj2) {
+        return obj2 && "function" == typeof Symbol && obj2.constructor === Symbol && obj2 !== Symbol.prototype ? "symbol" : typeof obj2;
+      }, _typeof(obj);
+    }
+    Object.defineProperty(exports2, "__esModule", {
+      value: true
+    });
+    Object.defineProperty(exports2, "patchFs", {
+      enumerable: true,
+      get: function get() {
+        return _patchFs["default"];
+      }
+    });
+    Object.defineProperty(exports2, "patchRequire", {
+      enumerable: true,
+      get: function get() {
+        return _patchRequire["default"];
+      }
+    });
+    Object.defineProperty(exports2, "unixify", {
+      enumerable: true,
+      get: function get() {
+        return _correctPath.unixify;
+      }
+    });
+    exports2.util = void 0;
+    var _patchFs = _interopRequireDefault(require_patchFs());
+    var _patchRequire = _interopRequireDefault(require_patchRequire());
+    var _correctPath = require_correctPath();
+    var util = _interopRequireWildcard(require_lists());
+    exports2.util = util;
+    function _getRequireWildcardCache(nodeInterop) {
+      if (typeof WeakMap !== "function")
+        return null;
+      var cacheBabelInterop = /* @__PURE__ */ new WeakMap();
+      var cacheNodeInterop = /* @__PURE__ */ new WeakMap();
+      return (_getRequireWildcardCache = function _getRequireWildcardCache2(nodeInterop2) {
+        return nodeInterop2 ? cacheNodeInterop : cacheBabelInterop;
+      })(nodeInterop);
+    }
+    function _interopRequireWildcard(obj, nodeInterop) {
+      if (!nodeInterop && obj && obj.__esModule) {
+        return obj;
+      }
+      if (obj === null || _typeof(obj) !== "object" && typeof obj !== "function") {
+        return { "default": obj };
+      }
+      var cache = _getRequireWildcardCache(nodeInterop);
+      if (cache && cache.has(obj)) {
+        return cache.get(obj);
+      }
+      var newObj = {};
+      var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor;
+      for (var key in obj) {
+        if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) {
+          var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null;
+          if (desc && (desc.get || desc.set)) {
+            Object.defineProperty(newObj, key, desc);
+          } else {
+            newObj[key] = obj[key];
+          }
+        }
+      }
+      newObj["default"] = obj;
+      if (cache) {
+        cache.set(obj, newObj);
+      }
+      return newObj;
+    }
+    function _interopRequireDefault(obj) {
+      return obj && obj.__esModule ? obj : { "default": obj };
+    }
+  }
+});
+
+// src/run/next.cts
+var next_exports = {};
+__export(next_exports, {
+  getMockedRequestHandlers: () => getMockedRequestHandlers
+});
+module.exports = __toCommonJS(next_exports);
+var import_promises = __toESM(require("fs/promises"));
+var import_node_buffer = require("node:buffer");
+var import_path = require("path");
+
+// node_modules/@netlify/blobs/dist/main.js
+var import_buffer = require("buffer");
+var import_process = require("process");
+var import_buffer2 = require("buffer");
+var import_buffer3 = require("buffer");
+var getEnvironmentContext = () => {
+  const context = globalThis.netlifyBlobsContext || import_process.env.NETLIFY_BLOBS_CONTEXT;
+  if (typeof context !== "string" || !context) {
+    return {};
+  }
+  const data = import_buffer.Buffer.from(context, "base64").toString();
+  try {
+    return JSON.parse(data);
+  } catch {
+  }
+  return {};
+};
+var MissingBlobsEnvironmentError = class extends Error {
+  constructor(requiredProperties) {
+    super(
+      `The environment has not been configured to use Netlify Blobs. To use it manually, supply the following properties when creating a store: ${requiredProperties.join(
+        ", "
+      )}`
+    );
+    this.name = "MissingBlobsEnvironmentError";
+  }
+};
+var BASE64_PREFIX = "b64;";
+var METADATA_HEADER_INTERNAL = "x-amz-meta-user";
+var METADATA_HEADER_EXTERNAL = "netlify-blobs-metadata";
+var METADATA_MAX_SIZE = 2 * 1024;
+var encodeMetadata = (metadata) => {
+  if (!metadata) {
+    return null;
+  }
+  const encodedObject = import_buffer2.Buffer.from(JSON.stringify(metadata)).toString("base64");
+  const payload = `b64;${encodedObject}`;
+  if (METADATA_HEADER_EXTERNAL.length + payload.length > METADATA_MAX_SIZE) {
+    throw new Error("Metadata object exceeds the maximum size");
+  }
+  return payload;
+};
+var decodeMetadata = (header) => {
+  if (!header || !header.startsWith(BASE64_PREFIX)) {
+    return {};
+  }
+  const encodedData = header.slice(BASE64_PREFIX.length);
+  const decodedData = import_buffer2.Buffer.from(encodedData, "base64").toString();
+  const metadata = JSON.parse(decodedData);
+  return metadata;
+};
+var getMetadataFromResponse = (response) => {
+  if (!response.headers) {
+    return {};
+  }
+  const value = response.headers.get(METADATA_HEADER_EXTERNAL) || response.headers.get(METADATA_HEADER_INTERNAL);
+  try {
+    return decodeMetadata(value);
+  } catch {
+    throw new Error(
+      "An internal error occurred while trying to retrieve the metadata for an entry. Please try updating to the latest version of the Netlify Blobs client."
+    );
+  }
+};
+var DEFAULT_RETRY_DELAY = 5e3;
+var MIN_RETRY_DELAY = 1e3;
+var MAX_RETRY = 5;
+var RATE_LIMIT_HEADER = "X-RateLimit-Reset";
+var fetchAndRetry = async (fetch, url, options, attemptsLeft = MAX_RETRY) => {
+  try {
+    const res = await fetch(url, options);
+    if (attemptsLeft > 0 && (res.status === 429 || res.status >= 500)) {
+      const delay = getDelay(res.headers.get(RATE_LIMIT_HEADER));
+      await sleep(delay);
+      return fetchAndRetry(fetch, url, options, attemptsLeft - 1);
+    }
+    return res;
+  } catch (error) {
+    if (attemptsLeft === 0) {
+      throw error;
+    }
+    const delay = getDelay();
+    await sleep(delay);
+    return fetchAndRetry(fetch, url, options, attemptsLeft - 1);
+  }
+};
+var getDelay = (rateLimitReset) => {
+  if (!rateLimitReset) {
+    return DEFAULT_RETRY_DELAY;
+  }
+  return Math.max(Number(rateLimitReset) * 1e3 - Date.now(), MIN_RETRY_DELAY);
+};
+var sleep = (ms) => new Promise((resolve2) => {
+  setTimeout(resolve2, ms);
+});
+var Client = class {
+  constructor({ apiURL, edgeURL, fetch, siteID, token }) {
+    this.apiURL = apiURL;
+    this.edgeURL = edgeURL;
+    this.fetch = fetch ?? globalThis.fetch;
+    this.siteID = siteID;
+    this.token = token;
+    if (!this.fetch) {
+      throw new Error(
+        "Netlify Blobs could not find a `fetch` client in the global scope. You can either update your runtime to a version that includes `fetch` (like Node.js 18.0.0 or above), or you can supply your own implementation using the `fetch` property."
+      );
+    }
+  }
+  async getFinalRequest({ key, metadata, method, parameters = {}, storeName }) {
+    const encodedMetadata = encodeMetadata(metadata);
+    if (this.edgeURL) {
+      const headers = {
+        authorization: `Bearer ${this.token}`
+      };
+      if (encodedMetadata) {
+        headers[METADATA_HEADER_INTERNAL] = encodedMetadata;
+      }
+      const path = key ? `/${this.siteID}/${storeName}/${key}` : `/${this.siteID}/${storeName}`;
+      const url2 = new URL(path, this.edgeURL);
+      for (const key2 in parameters) {
+        url2.searchParams.set(key2, parameters[key2]);
+      }
+      return {
+        headers,
+        url: url2.toString()
+      };
+    }
+    const apiHeaders = { authorization: `Bearer ${this.token}` };
+    const url = new URL(`/api/v1/sites/${this.siteID}/blobs`, this.apiURL ?? "https://api.netlify.com");
+    for (const key2 in parameters) {
+      url.searchParams.set(key2, parameters[key2]);
+    }
+    url.searchParams.set("context", storeName);
+    if (key === void 0) {
+      return {
+        headers: apiHeaders,
+        url: url.toString()
+      };
+    }
+    url.pathname += `/${key}`;
+    if (encodedMetadata) {
+      apiHeaders[METADATA_HEADER_EXTERNAL] = encodedMetadata;
+    }
+    if (method === "head") {
+      return {
+        headers: apiHeaders,
+        url: url.toString()
+      };
+    }
+    const res = await this.fetch(url.toString(), { headers: apiHeaders, method });
+    if (res.status !== 200) {
+      throw new Error(`Netlify Blobs has generated an internal error: ${res.status} response`);
+    }
+    const { url: signedURL } = await res.json();
+    const userHeaders = encodedMetadata ? { [METADATA_HEADER_INTERNAL]: encodedMetadata } : void 0;
+    return {
+      headers: userHeaders,
+      url: signedURL
+    };
+  }
+  async makeRequest({
+    body,
+    headers: extraHeaders,
+    key,
+    metadata,
+    method,
+    parameters,
+    storeName
+  }) {
+    const { headers: baseHeaders = {}, url } = await this.getFinalRequest({
+      key,
+      metadata,
+      method,
+      parameters,
+      storeName
+    });
+    const headers = {
+      ...baseHeaders,
+      ...extraHeaders
+    };
+    if (method === "put") {
+      headers["cache-control"] = "max-age=0, stale-while-revalidate=60";
+    }
+    const options = {
+      body,
+      headers,
+      method
+    };
+    if (body instanceof ReadableStream) {
+      options.duplex = "half";
+    }
+    return fetchAndRetry(this.fetch, url, options);
+  }
+};
+var getClientOptions = (options, contextOverride) => {
+  const context = contextOverride ?? getEnvironmentContext();
+  const siteID = context.siteID ?? options.siteID;
+  const token = context.token ?? options.token;
+  if (!siteID || !token) {
+    throw new MissingBlobsEnvironmentError(["siteID", "token"]);
+  }
+  const clientOptions = {
+    apiURL: context.apiURL ?? options.apiURL,
+    edgeURL: context.edgeURL ?? options.edgeURL,
+    fetch: options.fetch,
+    siteID,
+    token
+  };
+  return clientOptions;
+};
+var BlobsInternalError = class extends Error {
+  constructor(statusCode) {
+    super(`Netlify Blobs has generated an internal error: ${statusCode} response`);
+    this.name = "BlobsInternalError";
+  }
+};
+var collectIterator = async (iterator) => {
+  const result = [];
+  for await (const item of iterator) {
+    result.push(item);
+  }
+  return result;
+};
+var Store = class _Store {
+  constructor(options) {
+    this.client = options.client;
+    if ("deployID" in options) {
+      _Store.validateDeployID(options.deployID);
+      this.name = `deploy:${options.deployID}`;
+    } else {
+      _Store.validateStoreName(options.name);
+      this.name = options.name;
+    }
+  }
+  async delete(key) {
+    const res = await this.client.makeRequest({ key, method: "delete", storeName: this.name });
+    if (![200, 204, 404].includes(res.status)) {
+      throw new BlobsInternalError(res.status);
+    }
+  }
+  async get(key, options) {
+    const { type } = options ?? {};
+    const res = await this.client.makeRequest({ key, method: "get", storeName: this.name });
+    if (res.status === 404) {
+      return null;
+    }
+    if (res.status !== 200) {
+      throw new BlobsInternalError(res.status);
+    }
+    if (type === void 0 || type === "text") {
+      return res.text();
+    }
+    if (type === "arrayBuffer") {
+      return res.arrayBuffer();
+    }
+    if (type === "blob") {
+      return res.blob();
+    }
+    if (type === "json") {
+      return res.json();
+    }
+    if (type === "stream") {
+      return res.body;
+    }
+    throw new BlobsInternalError(res.status);
+  }
+  async getMetadata(key) {
+    const res = await this.client.makeRequest({ key, method: "head", storeName: this.name });
+    if (res.status === 404) {
+      return null;
+    }
+    if (res.status !== 200 && res.status !== 304) {
+      throw new BlobsInternalError(res.status);
+    }
+    const etag = res?.headers.get("etag") ?? void 0;
+    const metadata = getMetadataFromResponse(res);
+    const result = {
+      etag,
+      metadata
+    };
+    return result;
+  }
+  async getWithMetadata(key, options) {
+    const { etag: requestETag, type } = options ?? {};
+    const headers = requestETag ? { "if-none-match": requestETag } : void 0;
+    const res = await this.client.makeRequest({ headers, key, method: "get", storeName: this.name });
+    if (res.status === 404) {
+      return null;
+    }
+    if (res.status !== 200 && res.status !== 304) {
+      throw new BlobsInternalError(res.status);
+    }
+    const responseETag = res?.headers.get("etag") ?? void 0;
+    const metadata = getMetadataFromResponse(res);
+    const result = {
+      etag: responseETag,
+      metadata
+    };
+    if (res.status === 304 && requestETag) {
+      return { data: null, ...result };
+    }
+    if (type === void 0 || type === "text") {
+      return { data: await res.text(), ...result };
+    }
+    if (type === "arrayBuffer") {
+      return { data: await res.arrayBuffer(), ...result };
+    }
+    if (type === "blob") {
+      return { data: await res.blob(), ...result };
+    }
+    if (type === "json") {
+      return { data: await res.json(), ...result };
+    }
+    if (type === "stream") {
+      return { data: res.body, ...result };
+    }
+    throw new Error(`Invalid 'type' property: ${type}. Expected: arrayBuffer, blob, json, stream, or text.`);
+  }
+  list(options = {}) {
+    const iterator = this.getListIterator(options);
+    if (options.paginate) {
+      return iterator;
+    }
+    return collectIterator(iterator).then(
+      (items) => items.reduce(
+        (acc, item) => ({
+          blobs: [...acc.blobs, ...item.blobs],
+          directories: [...acc.directories, ...item.directories]
+        }),
+        { blobs: [], directories: [] }
+      )
+    );
+  }
+  async set(key, data, { metadata } = {}) {
+    _Store.validateKey(key);
+    const res = await this.client.makeRequest({
+      body: data,
+      key,
+      metadata,
+      method: "put",
+      storeName: this.name
+    });
+    if (res.status !== 200) {
+      throw new BlobsInternalError(res.status);
+    }
+  }
+  async setJSON(key, data, { metadata } = {}) {
+    _Store.validateKey(key);
+    const payload = JSON.stringify(data);
+    const headers = {
+      "content-type": "application/json"
+    };
+    const res = await this.client.makeRequest({
+      body: payload,
+      headers,
+      key,
+      metadata,
+      method: "put",
+      storeName: this.name
+    });
+    if (res.status !== 200) {
+      throw new BlobsInternalError(res.status);
+    }
+  }
+  static formatListResultBlob(result) {
+    if (!result.key) {
+      return null;
+    }
+    return {
+      etag: result.etag,
+      key: result.key
+    };
+  }
+  static validateKey(key) {
+    if (key.startsWith("/") || key.startsWith("%2F")) {
+      throw new Error("Blob key must not start with forward slash (/).");
+    }
+    if (import_buffer3.Buffer.byteLength(key, "utf8") > 600) {
+      throw new Error(
+        "Blob key must be a sequence of Unicode characters whose UTF-8 encoding is at most 600 bytes long."
+      );
+    }
+  }
+  static validateDeployID(deployID) {
+    if (!/^\w{1,24}$/.test(deployID)) {
+      throw new Error(`'${deployID}' is not a valid Netlify deploy ID.`);
+    }
+  }
+  static validateStoreName(name) {
+    if (name.startsWith("deploy:") || name.startsWith("deploy%3A1")) {
+      throw new Error("Store name must not start with the `deploy:` reserved keyword.");
+    }
+    if (name.includes("/") || name.includes("%2F")) {
+      throw new Error("Store name must not contain forward slashes (/).");
+    }
+    if (import_buffer3.Buffer.byteLength(name, "utf8") > 64) {
+      throw new Error(
+        "Store name must be a sequence of Unicode characters whose UTF-8 encoding is at most 64 bytes long."
+      );
+    }
+  }
+  getListIterator(options) {
+    const { client, name: storeName } = this;
+    const parameters = {};
+    if (options?.prefix) {
+      parameters.prefix = options.prefix;
+    }
+    if (options?.directories) {
+      parameters.directories = "true";
+    }
+    return {
+      [Symbol.asyncIterator]() {
+        let currentCursor = null;
+        let done = false;
+        return {
+          async next() {
+            if (done) {
+              return { done: true, value: void 0 };
+            }
+            const nextParameters = { ...parameters };
+            if (currentCursor !== null) {
+              nextParameters.cursor = currentCursor;
+            }
+            const res = await client.makeRequest({
+              method: "get",
+              parameters: nextParameters,
+              storeName
+            });
+            const page = await res.json();
+            if (page.next_cursor) {
+              currentCursor = page.next_cursor;
+            } else {
+              done = true;
+            }
+            const blobs = (page.blobs ?? []).map(_Store.formatListResultBlob).filter(Boolean);
+            return {
+              done: false,
+              value: {
+                blobs,
+                directories: page.directories ?? []
+              }
+            };
+          }
+        };
+      }
+    };
+  }
+};
+var getDeployStore = (options = {}) => {
+  const context = getEnvironmentContext();
+  const deployID = options.deployID ?? context.deployID;
+  if (!deployID) {
+    throw new MissingBlobsEnvironmentError(["deployID"]);
+  }
+  const clientOptions = getClientOptions(options, context);
+  const client = new Client(clientOptions);
+  return new Store({ client, deployID });
+};
+
+// src/run/next.cts
+var import_fs_monkey = __toESM(require_lib());
+async function getMockedRequestHandlers(...args) {
+  const store = getDeployStore();
+  const ofs = { ...import_promises.default };
+  async function readFileFallbackBlobStore(...fsargs) {
+    const [path, options] = fsargs;
+    try {
+      return await ofs.readFile(path, options);
+    } catch (error) {
+      if (typeof path === "string" && path.endsWith(".html")) {
+        const relPath = (0, import_path.relative)((0, import_path.resolve)(".next/server/pages"), path);
+        const blobKey = import_node_buffer.Buffer.from(relPath).toString("base64");
+        const file = await store.get(blobKey);
+        if (file !== null) {
+          return file;
+        }
+      }
+      throw error;
+    }
+  }
+  (0, import_fs_monkey.patchFs)(
+    {
+      readFile: readFileFallbackBlobStore
+    },
+    // eslint-disable-next-line n/global-require
+    require("fs").promises
+  );
+  const { getRequestHandlers } = await import("next/dist/server/lib/start-server.js");
+  return getRequestHandlers(...args);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  getMockedRequestHandlers
+});