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

package/dist/run/handlers/cache.cjs

@@ -0,0 +1,849 @@
+"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/is-promise/index.js
+var require_is_promise = __commonJS({
+  "node_modules/is-promise/index.js"(exports2, module2) {
+    module2.exports = isPromise;
+    module2.exports.default = isPromise;
+    function isPromise(obj) {
+      return !!obj && (typeof obj === "object" || typeof obj === "function") && typeof obj.then === "function";
+    }
+  }
+});
+
+// node_modules/@netlify/functions/dist/lib/consts.js
+var require_consts = __commonJS({
+  "node_modules/@netlify/functions/dist/lib/consts.js"(exports2) {
+    "use strict";
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    exports2.METADATA_VERSION = exports2.HTTP_STATUS_OK = exports2.HTTP_STATUS_METHOD_NOT_ALLOWED = exports2.BUILDER_FUNCTIONS_FLAG = void 0;
+    var BUILDER_FUNCTIONS_FLAG = true;
+    exports2.BUILDER_FUNCTIONS_FLAG = BUILDER_FUNCTIONS_FLAG;
+    var HTTP_STATUS_METHOD_NOT_ALLOWED = 405;
+    exports2.HTTP_STATUS_METHOD_NOT_ALLOWED = HTTP_STATUS_METHOD_NOT_ALLOWED;
+    var HTTP_STATUS_OK = 200;
+    exports2.HTTP_STATUS_OK = HTTP_STATUS_OK;
+    var METADATA_VERSION = 1;
+    exports2.METADATA_VERSION = METADATA_VERSION;
+  }
+});
+
+// node_modules/@netlify/functions/dist/lib/builder.js
+var require_builder = __commonJS({
+  "node_modules/@netlify/functions/dist/lib/builder.js"(exports2) {
+    "use strict";
+    var __importDefault = exports2 && exports2.__importDefault || function(mod) {
+      return mod && mod.__esModule ? mod : { "default": mod };
+    };
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    exports2.builder = void 0;
+    var is_promise_1 = __importDefault(require_is_promise());
+    var consts_js_1 = require_consts();
+    var augmentResponse = (response) => {
+      if (!response) {
+        return response;
+      }
+      const metadata = { version: consts_js_1.METADATA_VERSION, builder_function: consts_js_1.BUILDER_FUNCTIONS_FLAG, ttl: response.ttl || 0 };
+      return {
+        ...response,
+        metadata
+      };
+    };
+    var wrapHandler = (handler) => (
+      // eslint-disable-next-line promise/prefer-await-to-callbacks
+      (event, context, callback) => {
+        if (event.httpMethod !== "GET" && event.httpMethod !== "HEAD") {
+          return Promise.resolve({
+            body: "Method Not Allowed",
+            statusCode: consts_js_1.HTTP_STATUS_METHOD_NOT_ALLOWED
+          });
+        }
+        const modifiedEvent = {
+          ...event,
+          multiValueQueryStringParameters: {},
+          queryStringParameters: {}
+        };
+        const wrappedCallback = (error, response) => (
+          // eslint-disable-next-line promise/prefer-await-to-callbacks
+          callback ? callback(error, augmentResponse(response)) : null
+        );
+        const execution = handler(modifiedEvent, context, wrappedCallback);
+        if ((0, is_promise_1.default)(execution)) {
+          return execution.then(augmentResponse);
+        }
+        return execution;
+      }
+    );
+    exports2.builder = wrapHandler;
+  }
+});
+
+// node_modules/@netlify/functions/dist/lib/purge_cache.js
+var require_purge_cache = __commonJS({
+  "node_modules/@netlify/functions/dist/lib/purge_cache.js"(exports2) {
+    "use strict";
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    exports2.purgeCache = void 0;
+    var process_1 = require("process");
+    var purgeCache2 = async (options = {}) => {
+      if (globalThis.fetch === void 0) {
+        throw new Error("`fetch` is not available. Please ensure you're using Node.js version 18.0.0 or above. Refer to https://ntl.fyi/functions-runtime for more information.");
+      }
+      const payload = {
+        cache_tags: options.tags,
+        deploy_alias: options.deployAlias
+      };
+      const token = process_1.env.NETLIFY_PURGE_API_TOKEN || options.token;
+      if ("siteSlug" in options) {
+        payload.site_slug = options.siteSlug;
+      } else if ("domain" in options) {
+        payload.domain = options.domain;
+      } else {
+        const siteID = options.siteID || process_1.env.SITE_ID;
+        if (!siteID) {
+          throw new Error("The Netlify site ID was not found in the execution environment. Please supply it manually using the `siteID` property.");
+        }
+        payload.site_id = siteID;
+      }
+      if (!token) {
+        throw new Error("The cache purge API token was not found in the execution environment. Please supply it manually using the `token` property.");
+      }
+      const apiURL = options.apiURL || "https://api.netlify.com";
+      const response = await fetch(`${apiURL}/api/v1/purge`, {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json; charset=utf8",
+          Authorization: `Bearer ${token}`
+        },
+        body: JSON.stringify(payload)
+      });
+      if (!response.ok) {
+        throw new Error(`Cache purge API call returned an unexpected status code: ${response.status}`);
+      }
+    };
+    exports2.purgeCache = purgeCache2;
+  }
+});
+
+// node_modules/@netlify/functions/dist/lib/schedule.js
+var require_schedule = __commonJS({
+  "node_modules/@netlify/functions/dist/lib/schedule.js"(exports2) {
+    "use strict";
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    exports2.schedule = void 0;
+    var schedule = (cron, handler) => handler;
+    exports2.schedule = schedule;
+  }
+});
+
+// node_modules/@netlify/functions/dist/lib/stream.js
+var require_stream = __commonJS({
+  "node_modules/@netlify/functions/dist/lib/stream.js"(exports2) {
+    "use strict";
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    exports2.stream = void 0;
+    var node_stream_1 = require("node:stream");
+    var node_util_1 = require("node:util");
+    var pipeline = (0, node_util_1.promisify)(node_stream_1.pipeline);
+    var stream = (handler) => awslambda.streamifyResponse(async (event, responseStream, context) => {
+      const { body, ...httpResponseMetadata } = await handler(event, context);
+      const responseBody = awslambda.HttpResponseStream.from(responseStream, httpResponseMetadata);
+      if (typeof body === "undefined") {
+        responseBody.end();
+      } else if (typeof body === "string") {
+        responseBody.write(body);
+        responseBody.end();
+      } else {
+        await pipeline(body, responseBody);
+      }
+    });
+    exports2.stream = stream;
+  }
+});
+
+// node_modules/@netlify/functions/dist/function/index.js
+var require_function = __commonJS({
+  "node_modules/@netlify/functions/dist/function/index.js"(exports2) {
+    "use strict";
+    Object.defineProperty(exports2, "__esModule", { value: true });
+  }
+});
+
+// node_modules/@netlify/functions/dist/main.js
+var require_main = __commonJS({
+  "node_modules/@netlify/functions/dist/main.js"(exports2) {
+    "use strict";
+    var __createBinding = exports2 && exports2.__createBinding || (Object.create ? function(o, m, k, k2) {
+      if (k2 === void 0)
+        k2 = k;
+      var desc = Object.getOwnPropertyDescriptor(m, k);
+      if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+        desc = { enumerable: true, get: function() {
+          return m[k];
+        } };
+      }
+      Object.defineProperty(o, k2, desc);
+    } : function(o, m, k, k2) {
+      if (k2 === void 0)
+        k2 = k;
+      o[k2] = m[k];
+    });
+    var __exportStar = exports2 && exports2.__exportStar || function(m, exports3) {
+      for (var p in m)
+        if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports3, p))
+          __createBinding(exports3, m, p);
+    };
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    exports2.stream = exports2.schedule = exports2.purgeCache = exports2.builder = void 0;
+    var builder_js_1 = require_builder();
+    Object.defineProperty(exports2, "builder", { enumerable: true, get: function() {
+      return builder_js_1.builder;
+    } });
+    var purge_cache_js_1 = require_purge_cache();
+    Object.defineProperty(exports2, "purgeCache", { enumerable: true, get: function() {
+      return purge_cache_js_1.purgeCache;
+    } });
+    var schedule_js_1 = require_schedule();
+    Object.defineProperty(exports2, "schedule", { enumerable: true, get: function() {
+      return schedule_js_1.schedule;
+    } });
+    var stream_js_1 = require_stream();
+    Object.defineProperty(exports2, "stream", { enumerable: true, get: function() {
+      return stream_js_1.stream;
+    } });
+    __exportStar(require_function(), exports2);
+  }
+});
+
+// src/run/handlers/cache.cts
+var cache_exports = {};
+__export(cache_exports, {
+  NetlifyCacheHandler: () => NetlifyCacheHandler,
+  blobStore: () => blobStore,
+  default: () => cache_default
+});
+module.exports = __toCommonJS(cache_exports);
+var import_node_buffer = require("node:buffer");
+var import_node_fs = require("node:fs");
+var import_posix = require("node:path/posix");
+
+// 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 (fetch2, url, options, attemptsLeft = MAX_RETRY) => {
+  try {
+    const res = await fetch2(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(fetch2, url, options, attemptsLeft - 1);
+    }
+    return res;
+  } catch (error) {
+    if (attemptsLeft === 0) {
+      throw error;
+    }
+    const delay = getDelay();
+    await sleep(delay);
+    return fetchAndRetry(fetch2, 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: fetch2, siteID, token }) {
+    this.apiURL = apiURL;
+    this.edgeURL = edgeURL;
+    this.fetch = fetch2 ?? 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/handlers/cache.cts
+var import_functions = __toESM(require_main());
+var import_constants = require("next/dist/lib/constants.js");
+var blobStore = getDeployStore();
+var prerenderManifest = JSON.parse(
+  (0, import_node_fs.readFileSync)((0, import_posix.join)(process.cwd(), ".next/prerender-manifest.json"), "utf-8")
+);
+function toRoute(cacheKey) {
+  return cacheKey.replace(/\/$/, "").replace(/\/index$/, "") || "/";
+}
+function encodeBlobKey(key) {
+  return import_node_buffer.Buffer.from(key.replace(/^\//, "")).toString("base64");
+}
+var NetlifyCacheHandler = class {
+  options;
+  revalidatedTags;
+  constructor(options) {
+    this.options = options;
+    this.revalidatedTags = options.revalidatedTags;
+  }
+  async get(...args) {
+    const [key, ctx = {}] = args;
+    console.debug(`[NetlifyCacheHandler.get]: ${key}`);
+    const blob = await blobStore.get(encodeBlobKey(key), {
+      type: "json"
+    });
+    if (!blob) {
+      return null;
+    }
+    const revalidateAfter = this.calculateRevalidate(key, blob.lastModified, ctx);
+    const isStale = revalidateAfter !== false && revalidateAfter < Date.now();
+    const staleByTags = await this.checkCacheEntryStaleByTags(blob, ctx.softTags);
+    if (staleByTags || isStale) {
+      return null;
+    }
+    switch (blob.value.kind) {
+      case "FETCH":
+        return {
+          lastModified: blob.lastModified,
+          value: {
+            kind: blob.value.kind,
+            data: blob.value.data,
+            revalidate: ctx.revalidate || 1
+          }
+        };
+      case "ROUTE":
+        return {
+          lastModified: blob.lastModified,
+          value: {
+            body: import_node_buffer.Buffer.from(blob.value.body),
+            kind: blob.value.kind,
+            status: blob.value.status,
+            headers: blob.value.headers
+          }
+        };
+      case "PAGE":
+        return {
+          lastModified: blob.lastModified,
+          value: blob.value
+        };
+      default:
+    }
+    return null;
+  }
+  async set(...args) {
+    const [key, data] = args;
+    console.debug(`[NetlifyCacheHandler.set]: ${key}`);
+    await blobStore.setJSON(encodeBlobKey(key), {
+      lastModified: Date.now(),
+      value: data
+    });
+  }
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  async revalidateTag(tag, ...args) {
+    console.debug("NetlifyCacheHandler.revalidateTag", tag, args);
+    const data = {
+      revalidatedAt: Date.now()
+    };
+    try {
+      await blobStore.setJSON(encodeBlobKey(tag), data);
+    } catch (error) {
+      console.warn(`Failed to update tag manifest for ${tag}`, error);
+    }
+    (0, import_functions.purgeCache)({ tags: [tag] }).catch((error) => {
+      console.error(`[NetlifyCacheHandler]: Purging the cache for tag ${tag} failed`, error);
+    });
+  }
+  /**
+   * Checks if a page is stale through on demand revalidated tags
+   */
+  async checkCacheEntryStaleByTags(cacheEntry, softTags = []) {
+    const tags = "headers" in cacheEntry.value ? cacheEntry.value.headers?.[import_constants.NEXT_CACHE_TAGS_HEADER]?.split(",") || [] : [];
+    const cacheTags = [...tags, ...softTags];
+    const allManifests = await Promise.all(
+      cacheTags.map(async (tag) => {
+        const res = await blobStore.get(encodeBlobKey(tag), { type: "json" }).then((value) => ({ [tag]: value })).catch(console.error);
+        return res || { [tag]: null };
+      })
+    );
+    const tagsManifest = Object.assign({}, ...allManifests);
+    const isStale = cacheTags.some((tag) => {
+      if (this.revalidatedTags?.includes(tag)) {
+        return true;
+      }
+      const { revalidatedAt } = tagsManifest[tag] || {};
+      return revalidatedAt && revalidatedAt >= (cacheEntry.lastModified || Date.now());
+    });
+    return isStale;
+  }
+  /**
+   * Retrieves the milliseconds since midnight, January 1, 1970 when it should revalidate for a path.
+   */
+  calculateRevalidate(cacheKey, fromTime, ctx, dev) {
+    if (dev)
+      return Date.now() - 1e3;
+    if (ctx?.revalidate && typeof ctx.revalidate === "number") {
+      return fromTime + ctx.revalidate * 1e3;
+    }
+    const { initialRevalidateSeconds } = prerenderManifest.routes[toRoute(cacheKey)] || {
+      initialRevalidateSeconds: 0
+    };
+    const revalidateAfter = typeof initialRevalidateSeconds === "number" ? initialRevalidateSeconds * 1e3 + fromTime : initialRevalidateSeconds;
+    return revalidateAfter;
+  }
+};
+var cache_default = NetlifyCacheHandler;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  NetlifyCacheHandler,
+  blobStore
+});