@netlify/plugin-nextjs 5.1.1 → 5.2.0

package/dist/{esm-chunks/chunk-PMRBBOBY.js → run/regional-blob-store.cjs}

@@ -1,17 +1,39 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
-      var require = await (async () => {
-        var { createRequire } = await import("node:module");
-        return createRequire(import.meta.url);
-      })();
-    
-import {
-  encodeBlobKey
-} from "./chunk-TYCYFZ22.js";
+// src/run/regional-blob-store.cts
+var regional_blob_store_exports = {};
+__export(regional_blob_store_exports, {
+  getRegionalBlobStore: () => getRegionalBlobStore
+});
+module.exports = __toCommonJS(regional_blob_store_exports);
 
-// node_modules/@netlify/blobs/dist/chunk-6TGYNZGH.js
+// node_modules/@netlify/blobs/dist/chunk-SGXOM2EY.js
+var NF_ERROR = "x-nf-error";
+var NF_REQUEST_ID = "x-nf-request-id";
 var BlobsInternalError = class extends Error {
-  constructor(statusCode) {
-    super(`Netlify Blobs has generated an internal error: ${statusCode} response`);
+  constructor(res) {
+    let details = res.headers.get(NF_ERROR) || `${res.status} status code`;
+    if (res.headers.has(NF_REQUEST_ID)) {
+      details += `, ID: ${res.headers.get(NF_REQUEST_ID)}`;
+    }
+    super(`Netlify Blobs has generated an internal error (${details})`);
     this.name = "BlobsInternalError";
   }
 };
@@ -23,19 +45,55 @@ var collectIterator = async (iterator) => {
   return result;
 };
 var base64Decode = (input) => {
-  const { Buffer } = globalThis;
-  if (Buffer) {
-    return Buffer.from(input, "base64").toString();
+  const { Buffer: Buffer2 } = globalThis;
+  if (Buffer2) {
+    return Buffer2.from(input, "base64").toString();
   }
   return atob(input);
 };
 var base64Encode = (input) => {
-  const { Buffer } = globalThis;
-  if (Buffer) {
-    return Buffer.from(input).toString("base64");
+  const { Buffer: Buffer2 } = globalThis;
+  if (Buffer2) {
+    return Buffer2.from(input).toString("base64");
   }
   return btoa(input);
 };
+var getEnvironment = () => {
+  const { Deno, Netlify, process: process2 } = globalThis;
+  return Netlify?.env ?? Deno?.env ?? {
+    delete: (key) => delete process2?.env[key],
+    get: (key) => process2?.env[key],
+    has: (key) => Boolean(process2?.env[key]),
+    set: (key, value) => {
+      if (process2?.env) {
+        process2.env[key] = value;
+      }
+    },
+    toObject: () => process2?.env ?? {}
+  };
+};
+var getEnvironmentContext = () => {
+  const context = globalThis.netlifyBlobsContext || getEnvironment().get("NETLIFY_BLOBS_CONTEXT");
+  if (typeof context !== "string" || !context) {
+    return {};
+  }
+  const data = base64Decode(context);
+  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";
@@ -81,42 +139,6 @@ var BlobsConsistencyError = class extends Error {
     this.name = "BlobsConsistencyError";
   }
 };
-var getEnvironment = () => {
-  const { Deno, Netlify, process } = globalThis;
-  return Netlify?.env ?? Deno?.env ?? {
-    delete: (key) => delete process?.env[key],
-    get: (key) => process?.env[key],
-    has: (key) => Boolean(process?.env[key]),
-    set: (key, value) => {
-      if (process?.env) {
-        process.env[key] = value;
-      }
-    },
-    toObject: () => process?.env ?? {}
-  };
-};
-var getEnvironmentContext = () => {
-  const context = globalThis.netlifyBlobsContext || getEnvironment().get("NETLIFY_BLOBS_CONTEXT");
-  if (typeof context !== "string" || !context) {
-    return {};
-  }
-  const data = base64Decode(context);
-  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 DEFAULT_RETRY_DELAY = getEnvironment().get("NODE_ENV") === "test" ? 1 : 5e3;
 var MIN_RETRY_DELAY = 1e3;
 var MAX_RETRY = 5;
@@ -150,11 +172,12 @@ var sleep = (ms) => new Promise((resolve) => {
 });
 var SIGNED_URL_ACCEPT_HEADER = "application/json;type=signed-url";
 var Client = class {
-  constructor({ apiURL, consistency, edgeURL, fetch, siteID, token, uncachedEdgeURL }) {
+  constructor({ apiURL, consistency, edgeURL, fetch, region, siteID, token, uncachedEdgeURL }) {
     this.apiURL = apiURL;
     this.consistency = consistency ?? "eventual";
     this.edgeURL = edgeURL;
     this.fetch = fetch ?? globalThis.fetch;
+    this.region = region;
     this.siteID = siteID;
     this.token = token;
     this.uncachedEdgeURL = uncachedEdgeURL;
@@ -191,6 +214,9 @@ var Client = class {
       if (encodedMetadata) {
         headers[METADATA_HEADER_INTERNAL] = encodedMetadata;
       }
+      if (this.region) {
+        urlPath = `/region:${this.region}${urlPath}`;
+      }
       const url2 = new URL(urlPath, consistency === "strong" ? this.uncachedEdgeURL : this.edgeURL);
       for (const key2 in parameters) {
         url2.searchParams.set(key2, parameters[key2]);
@@ -205,6 +231,9 @@ var Client = class {
     for (const key2 in parameters) {
       url.searchParams.set(key2, parameters[key2]);
     }
+    if (this.region) {
+      url.searchParams.set("region", this.region);
+    }
     if (storeName === void 0 || key === void 0) {
       return {
         headers: apiHeaders,
@@ -225,7 +254,7 @@ var Client = class {
       method
     });
     if (res.status !== 200) {
-      throw new Error(`Netlify Blobs has generated an internal error: ${res.status} response`);
+      throw new BlobsInternalError(res);
     }
     const { url: signedURL } = await res.json();
     const userHeaders = encodedMetadata ? { [METADATA_HEADER_INTERNAL]: encodedMetadata } : void 0;
@@ -282,6 +311,7 @@ var getClientOptions = (options, contextOverride) => {
     consistency: options.consistency,
     edgeURL: context.edgeURL ?? options.edgeURL,
     fetch: options.fetch,
+    region: options.region,
     siteID,
     token,
     uncachedEdgeURL: context.uncachedEdgeURL ?? options.uncachedEdgeURL
@@ -311,7 +341,7 @@ var Store = class _Store {
   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);
+      throw new BlobsInternalError(res);
     }
   }
   async get(key, options) {
@@ -321,7 +351,7 @@ var Store = class _Store {
       return null;
     }
     if (res.status !== 200) {
-      throw new BlobsInternalError(res.status);
+      throw new BlobsInternalError(res);
     }
     if (type === void 0 || type === "text") {
       return res.text();
@@ -338,7 +368,7 @@ var Store = class _Store {
     if (type === "stream") {
       return res.body;
     }
-    throw new BlobsInternalError(res.status);
+    throw new BlobsInternalError(res);
   }
   async getMetadata(key, { consistency } = {}) {
     const res = await this.client.makeRequest({ consistency, key, method: "head", storeName: this.name });
@@ -346,7 +376,7 @@ var Store = class _Store {
       return null;
     }
     if (res.status !== 200 && res.status !== 304) {
-      throw new BlobsInternalError(res.status);
+      throw new BlobsInternalError(res);
     }
     const etag = res?.headers.get("etag") ?? void 0;
     const metadata = getMetadataFromResponse(res);
@@ -370,7 +400,7 @@ var Store = class _Store {
       return null;
     }
     if (res.status !== 200 && res.status !== 304) {
-      throw new BlobsInternalError(res.status);
+      throw new BlobsInternalError(res);
     }
     const responseETag = res?.headers.get("etag") ?? void 0;
     const metadata = getMetadataFromResponse(res);
@@ -423,7 +453,7 @@ var Store = class _Store {
       storeName: this.name
     });
     if (res.status !== 200) {
-      throw new BlobsInternalError(res.status);
+      throw new BlobsInternalError(res);
     }
   }
   async setJSON(key, data, { metadata } = {}) {
@@ -441,7 +471,7 @@ var Store = class _Store {
       storeName: this.name
     });
     if (res.status !== 200) {
-      throw new BlobsInternalError(res.status);
+      throw new BlobsInternalError(res);
     }
   }
   static formatListResultBlob(result) {
@@ -535,211 +565,35 @@ var getDeployStore = (options = {}) => {
     throw new MissingBlobsEnvironmentError(["deployID"]);
   }
   const clientOptions = getClientOptions(options, context);
-  const client = new Client(clientOptions);
-  return new Store({ client, deployID });
-};
-
-// src/run/headers.ts
-var ALL_VARIATIONS = Symbol.for("ALL_VARIATIONS");
-var NetlifyVaryKeys = /* @__PURE__ */ new Set(["header", "language", "cookie", "query", "country"]);
-var isNetlifyVaryKey = (key) => NetlifyVaryKeys.has(key);
-var generateNetlifyVaryValues = ({
-  header,
-  language,
-  cookie,
-  query,
-  country
-}) => {
-  const values = [];
-  if (query.length !== 0) {
-    if (query.includes(ALL_VARIATIONS)) {
-      values.push(`query`);
-    } else {
-      values.push(`query=${query.join(`|`)}`);
+  if (options.experimentalRegion === "context") {
+    if (!context.primaryRegion) {
+      throw new Error(
+        'The Netlify Blobs client was initialized with `experimentalRegion: "context"` but there is no region configured in the environment'
+      );
     }
-  }
-  if (header.length !== 0) {
-    values.push(`header=${header.join(`|`)}`);
-  }
-  if (language.length !== 0) {
-    values.push(`language=${language.join(`|`)}`);
-  }
-  if (cookie.length !== 0) {
-    values.push(`cookie=${cookie.join(`|`)}`);
-  }
-  if (country.length !== 0) {
-    values.push(`country=${country.join(`|`)}`);
-  }
-  return values.join(",");
-};
-var getHeaderValueArray = (header) => {
-  return header.split(",").map((value) => value.trim());
-};
-var omitHeaderValues = (header, values) => {
-  const headerValues = getHeaderValueArray(header);
-  const filteredValues = headerValues.filter(
-    (value) => !values.some((val) => value.startsWith(val))
-  );
-  return filteredValues.join(", ");
-};
-var mapHeaderValues = (header, callback) => {
-  const headerValues = getHeaderValueArray(header);
-  const mappedValues = headerValues.map(callback);
-  return mappedValues.join(", ");
-};
-var setVaryHeaders = (headers, request, { basePath, i18n }) => {
-  const netlifyVaryValues = {
-    header: ["x-nextjs-data"],
-    language: [],
-    cookie: ["__prerender_bypass", "__next_preview_data"],
-    query: [],
-    country: []
-  };
-  const vary = headers.get("vary");
-  if (vary !== null) {
-    netlifyVaryValues.header.push(...getHeaderValueArray(vary));
-  }
-  const path = new URL(request.url).pathname;
-  const locales = i18n && i18n.localeDetection !== false ? i18n.locales : [];
-  if (locales.length > 1 && (path === "/" || path === basePath)) {
-    netlifyVaryValues.language.push(...locales);
-    netlifyVaryValues.cookie.push(`NEXT_LOCALE`);
-  }
-  const userNetlifyVary = headers.get("netlify-vary");
-  if (userNetlifyVary) {
-    const directives = getHeaderValueArray(userNetlifyVary);
-    for (const directive of directives) {
-      const [key, value] = directive.split("=");
-      if (key === "query" && !value) {
-        netlifyVaryValues.query.push(ALL_VARIATIONS);
-      } else if (value && isNetlifyVaryKey(key)) {
-        netlifyVaryValues[key].push(...value.split("|"));
-      }
+    clientOptions.region = context.primaryRegion;
+  } else if (options.experimentalRegion === "auto") {
+    if (clientOptions.edgeURL) {
+      throw new Error(
+        'The Netlify Blobs client was initialized with `experimentalRegion: "auto"` which is not compatible with the `edgeURL` property; consider using `apiURL` instead'
+      );
     }
+    clientOptions.region = options.experimentalRegion;
   }
-  headers.set(`netlify-vary`, generateNetlifyVaryValues(netlifyVaryValues));
+  const client = new Client(clientOptions);
+  return new Store({ client, deployID });
 };
+
+// src/run/regional-blob-store.cts
 var fetchBeforeNextPatchedIt = globalThis.fetch;
-var adjustDateHeader = async ({
-  headers,
-  request,
-  span,
-  tracer,
-  requestContext
-}) => {
-  const cacheState = headers.get("x-nextjs-cache");
-  const isServedFromCache = cacheState === "HIT" || cacheState === "STALE";
-  span.setAttributes({
-    "x-nextjs-cache": cacheState ?? void 0,
-    isServedFromCache
+var getRegionalBlobStore = (args = {}) => {
+  return getDeployStore({
+    ...args,
+    fetch: fetchBeforeNextPatchedIt,
+    experimentalRegion: process.env.USE_REGIONAL_BLOBS?.toUpperCase() === "TRUE" ? "context" : void 0
   });
-  if (!isServedFromCache) {
-    return;
-  }
-  const key = new URL(request.url).pathname;
-  let lastModified;
-  if (requestContext.responseCacheGetLastModified) {
-    lastModified = requestContext.responseCacheGetLastModified;
-  } else {
-    span.recordException(
-      new Error("lastModified not found in requestContext, falling back to trying blobs")
-    );
-    span.setAttributes({
-      severity: "alert",
-      warning: true
-    });
-    const blobKey = await encodeBlobKey(key);
-    const blobStore = getDeployStore({ fetch: fetchBeforeNextPatchedIt, consistency: "strong" });
-    lastModified = await tracer.withActiveSpan(
-      "get cache to calculate date header",
-      async (getBlobForDateSpan) => {
-        getBlobForDateSpan.setAttributes({
-          key,
-          blobKey
-        });
-        const blob = await blobStore.get(blobKey, { type: "json" }) ?? {};
-        getBlobForDateSpan.addEvent(blob ? "Cache hit" : "Cache miss");
-        return blob.lastModified;
-      }
-    );
-  }
-  if (!lastModified) {
-    span.recordException(
-      new Error(
-        "lastModified not found in either requestContext or blobs, date header for cached response is not set"
-      )
-    );
-    span.setAttributes({
-      severity: "alert",
-      warning: true
-    });
-    return;
-  }
-  const lastModifiedDate = new Date(lastModified);
-  headers.set("x-nextjs-date", headers.get("date") ?? lastModifiedDate.toUTCString());
-  headers.set("date", lastModifiedDate.toUTCString());
-};
-var setCacheControlHeaders = (headers, request, requestContext) => {
-  if (typeof requestContext.routeHandlerRevalidate !== "undefined" && ["GET", "HEAD"].includes(request.method) && !headers.has("cdn-cache-control") && !headers.has("netlify-cdn-cache-control")) {
-    const cdnCacheControl = (
-      // if we are serving already stale response, instruct edge to not attempt to cache that response
-      headers.get("x-nextjs-cache") === "STALE" ? "public, max-age=0, must-revalidate" : `s-maxage=${requestContext.routeHandlerRevalidate === false ? 31536e3 : requestContext.routeHandlerRevalidate}, stale-while-revalidate=31536000`
-    );
-    headers.set("netlify-cdn-cache-control", cdnCacheControl);
-    return;
-  }
-  const cacheControl = headers.get("cache-control");
-  if (cacheControl !== null && ["GET", "HEAD"].includes(request.method) && !headers.has("cdn-cache-control") && !headers.has("netlify-cdn-cache-control")) {
-    const browserCacheControl = omitHeaderValues(cacheControl, [
-      "s-maxage",
-      "stale-while-revalidate"
-    ]);
-    const cdnCacheControl = (
-      // if we are serving already stale response, instruct edge to not attempt to cache that response
-      headers.get("x-nextjs-cache") === "STALE" ? "public, max-age=0, must-revalidate" : mapHeaderValues(
-        cacheControl,
-        (value) => value === "stale-while-revalidate" ? "stale-while-revalidate=31536000" : value
-      )
-    );
-    headers.set("cache-control", browserCacheControl || "public, max-age=0, must-revalidate");
-    headers.set("netlify-cdn-cache-control", cdnCacheControl);
-    return;
-  }
-  if (cacheControl === null && !headers.has("cdn-cache-control") && !headers.has("netlify-cdn-cache-control") && requestContext.usedFsRead) {
-    headers.set("cache-control", "public, max-age=0, must-revalidate");
-    headers.set("netlify-cdn-cache-control", `max-age=31536000`);
-  }
-};
-function getCanonicalPathFromCacheKey(cacheKey) {
-  return cacheKey === "/index" ? "/" : cacheKey;
-}
-var setCacheTagsHeaders = (headers, request, manifest, requestContext) => {
-  const path = getCanonicalPathFromCacheKey(requestContext.responseCacheKey) ?? new URL(request.url).pathname;
-  const tags = manifest[path];
-  if (tags !== void 0) {
-    headers.set("netlify-cache-tag", tags);
-  }
-};
-var NEXT_CACHE_TO_CACHE_STATUS = {
-  HIT: `hit`,
-  MISS: `fwd=miss`,
-  STALE: `hit; fwd=stale`
-};
-var setCacheStatusHeader = (headers) => {
-  const nextCache = headers.get("x-nextjs-cache");
-  if (typeof nextCache === "string") {
-    if (nextCache in NEXT_CACHE_TO_CACHE_STATUS) {
-      const cacheStatus = NEXT_CACHE_TO_CACHE_STATUS[nextCache];
-      headers.set("cache-status", `"Next.js"; ${cacheStatus}`);
-    }
-    headers.delete("x-nextjs-cache");
-  }
-};
-
-export {
-  setVaryHeaders,
-  adjustDateHeader,
-  setCacheControlHeaders,
-  setCacheTagsHeaders,
-  setCacheStatusHeader
 };
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  getRegionalBlobStore
+});

package/dist/run/revalidate.js

@@ -4,10 +4,24 @@
         return createRequire(import.meta.url);
       })();
     
-import {
-  nextResponseProxy
-} from "../esm-chunks/chunk-RL4K4CVH.js";
 import "../esm-chunks/chunk-5JVNISGM.js";
+
+// src/run/revalidate.ts
+var nextResponseProxy = (res, requestContext) => {
+  return new Proxy(res, {
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    get(target, key) {
+      const originalValue = target[key];
+      if (key === "revalidate") {
+        return async function newRevalidate(...args) {
+          requestContext.didPagesRouterOnDemandRevalidate = true;
+          return originalValue?.apply(target, args);
+        };
+      }
+      return originalValue;
+    }
+  });
+};
 export {
   nextResponseProxy
 };

package/dist/run/systemlog.js

@@ -5,9 +5,100 @@
       })();
     
 import {
-  import_internal
-} from "../esm-chunks/chunk-HYBEXB2Z.js";
-import "../esm-chunks/chunk-5JVNISGM.js";
+  __commonJS,
+  __require,
+  __toESM
+} from "../esm-chunks/chunk-5JVNISGM.js";
+
+// node_modules/@netlify/functions/dist/lib/system_logger.js
+var require_system_logger = __commonJS({
+  "node_modules/@netlify/functions/dist/lib/system_logger.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.systemLogger = exports.LogLevel = void 0;
+    var process_1 = __require("process");
+    var systemLogTag = "__nfSystemLog";
+    var serializeError = (error) => {
+      const cause = error?.cause instanceof Error ? serializeError(error.cause) : error.cause;
+      return {
+        error: error.message,
+        error_cause: cause,
+        error_stack: error.stack
+      };
+    };
+    var LogLevel2;
+    (function(LogLevel3) {
+      LogLevel3[LogLevel3["Debug"] = 1] = "Debug";
+      LogLevel3[LogLevel3["Log"] = 2] = "Log";
+      LogLevel3[LogLevel3["Error"] = 3] = "Error";
+    })(LogLevel2 = exports.LogLevel || (exports.LogLevel = {}));
+    var SystemLogger = class _SystemLogger {
+      fields;
+      logLevel;
+      constructor(fields = {}, logLevel = LogLevel2.Log) {
+        this.fields = fields;
+        this.logLevel = logLevel;
+      }
+      doLog(logger, message) {
+        if (process_1.env.NETLIFY_DEV && !process_1.env.NETLIFY_ENABLE_SYSTEM_LOGGING) {
+          return;
+        }
+        logger(systemLogTag, JSON.stringify({ msg: message, fields: this.fields }));
+      }
+      log(message) {
+        if (this.logLevel > LogLevel2.Log) {
+          return;
+        }
+        this.doLog(console.log, message);
+      }
+      debug(message) {
+        if (this.logLevel > LogLevel2.Debug) {
+          return;
+        }
+        this.doLog(console.debug, message);
+      }
+      error(message) {
+        if (this.logLevel > LogLevel2.Error) {
+          return;
+        }
+        this.doLog(console.error, message);
+      }
+      withLogLevel(level) {
+        return new _SystemLogger(this.fields, level);
+      }
+      withFields(fields) {
+        return new _SystemLogger({
+          ...this.fields,
+          ...fields
+        }, this.logLevel);
+      }
+      withError(error) {
+        const fields = error instanceof Error ? serializeError(error) : { error };
+        return this.withFields(fields);
+      }
+    };
+    exports.systemLogger = new SystemLogger();
+  }
+});
+
+// node_modules/@netlify/functions/dist/internal.js
+var require_internal = __commonJS({
+  "node_modules/@netlify/functions/dist/internal.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.LogLevel = exports.systemLogger = void 0;
+    var system_logger_js_1 = require_system_logger();
+    Object.defineProperty(exports, "systemLogger", { enumerable: true, get: function() {
+      return system_logger_js_1.systemLogger;
+    } });
+    Object.defineProperty(exports, "LogLevel", { enumerable: true, get: function() {
+      return system_logger_js_1.LogLevel;
+    } });
+  }
+});
+
+// src/run/systemlog.ts
+var import_internal = __toESM(require_internal(), 1);
 var export_LogLevel = import_internal.LogLevel;
 var export_logger = import_internal.systemLogger;
 export {

package/dist/shared/blobkey.js

@@ -4,10 +4,22 @@
         return createRequire(import.meta.url);
       })();
     
-import {
-  encodeBlobKey
-} from "../esm-chunks/chunk-TYCYFZ22.js";
 import "../esm-chunks/chunk-5JVNISGM.js";
+
+// src/shared/blobkey.ts
+import { Buffer } from "node:buffer";
+import { webcrypto as crypto } from "node:crypto";
+var maxLength = 180;
+async function encodeBlobKey(key) {
+  const buffer = Buffer.from(key);
+  const base64 = buffer.toString("base64url");
+  if (base64.length <= maxLength) {
+    return base64;
+  }
+  const digest = await crypto.subtle.digest("SHA-256", buffer);
+  const hash = Buffer.from(digest).toString("base64url");
+  return `${base64.slice(0, maxLength - hash.length - 1)}-${hash}`;
+}
 export {
   encodeBlobKey
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@netlify/plugin-nextjs",
-  "version": "5.1.1",
+  "version": "5.2.0",
   "description": "Run Next.js seamlessly on Netlify",
   "main": "./dist/index.js",
   "type": "module",