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

package/dist/esm-chunks/chunk-B6QMRLBH.js

@@ -0,0 +1,255 @@
+
+      const require = await (async () => {
+        const { createRequire } = await import("node:module");
+        return createRequire(import.meta.url);
+      })();
+    
+import {
+  __commonJS,
+  __require,
+  __toESM
+} from "./chunk-RSKIKBZH.js";
+
+// node_modules/is-promise/index.js
+var require_is_promise = __commonJS({
+  "node_modules/is-promise/index.js"(exports, module) {
+    module.exports = isPromise;
+    module.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"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.METADATA_VERSION = exports.HTTP_STATUS_OK = exports.HTTP_STATUS_METHOD_NOT_ALLOWED = exports.BUILDER_FUNCTIONS_FLAG = void 0;
+    var BUILDER_FUNCTIONS_FLAG = true;
+    exports.BUILDER_FUNCTIONS_FLAG = BUILDER_FUNCTIONS_FLAG;
+    var HTTP_STATUS_METHOD_NOT_ALLOWED = 405;
+    exports.HTTP_STATUS_METHOD_NOT_ALLOWED = HTTP_STATUS_METHOD_NOT_ALLOWED;
+    var HTTP_STATUS_OK = 200;
+    exports.HTTP_STATUS_OK = HTTP_STATUS_OK;
+    var METADATA_VERSION = 1;
+    exports.METADATA_VERSION = METADATA_VERSION;
+  }
+});
+
+// node_modules/@netlify/functions/dist/lib/builder.js
+var require_builder = __commonJS({
+  "node_modules/@netlify/functions/dist/lib/builder.js"(exports) {
+    "use strict";
+    var __importDefault = exports && exports.__importDefault || function(mod) {
+      return mod && mod.__esModule ? mod : { "default": mod };
+    };
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.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;
+      }
+    );
+    exports.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"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.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}`);
+      }
+    };
+    exports.purgeCache = purgeCache2;
+  }
+});
+
+// node_modules/@netlify/functions/dist/lib/schedule.js
+var require_schedule = __commonJS({
+  "node_modules/@netlify/functions/dist/lib/schedule.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.schedule = void 0;
+    var schedule = (cron, handler) => handler;
+    exports.schedule = schedule;
+  }
+});
+
+// node_modules/@netlify/functions/dist/lib/stream.js
+var require_stream = __commonJS({
+  "node_modules/@netlify/functions/dist/lib/stream.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.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);
+      }
+    });
+    exports.stream = stream;
+  }
+});
+
+// node_modules/@netlify/functions/dist/function/index.js
+var require_function = __commonJS({
+  "node_modules/@netlify/functions/dist/function/index.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+  }
+});
+
+// node_modules/@netlify/functions/dist/main.js
+var require_main = __commonJS({
+  "node_modules/@netlify/functions/dist/main.js"(exports) {
+    "use strict";
+    var __createBinding = exports && exports.__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 = exports && exports.__exportStar || function(m, exports2) {
+      for (var p in m)
+        if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports2, p))
+          __createBinding(exports2, m, p);
+    };
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.stream = exports.schedule = exports.purgeCache = exports.builder = void 0;
+    var builder_js_1 = require_builder();
+    Object.defineProperty(exports, "builder", { enumerable: true, get: function() {
+      return builder_js_1.builder;
+    } });
+    var purge_cache_js_1 = require_purge_cache();
+    Object.defineProperty(exports, "purgeCache", { enumerable: true, get: function() {
+      return purge_cache_js_1.purgeCache;
+    } });
+    var schedule_js_1 = require_schedule();
+    Object.defineProperty(exports, "schedule", { enumerable: true, get: function() {
+      return schedule_js_1.schedule;
+    } });
+    var stream_js_1 = require_stream();
+    Object.defineProperty(exports, "stream", { enumerable: true, get: function() {
+      return stream_js_1.stream;
+    } });
+    __exportStar(require_function(), exports);
+  }
+});
+
+// src/run/revalidate.ts
+var import_functions = __toESM(require_main(), 1);
+var nextResponseProxy = (res) => {
+  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) {
+          try {
+            console.debug("Purging cache for:", [args[0]]);
+            await (0, import_functions.purgeCache)({ tags: [`_N_T_${args[0]}`] });
+          } catch {
+            throw new Error(
+              `An internal error occurred while trying to purge cache for ${args[0]}}`
+            );
+          }
+          return originalValue?.apply(target, args);
+        };
+      }
+      return originalValue;
+    }
+  });
+};
+
+export {
+  nextResponseProxy
+};

package/dist/esm-chunks/chunk-G2VRYWGL.js

@@ -0,0 +1,107 @@
+
+      const require = await (async () => {
+        const { createRequire } = await import("node:module");
+        return createRequire(import.meta.url);
+      })();
+    
+import {
+  require_out
+} from "./chunk-AVWFCGVE.js";
+import {
+  __toESM
+} from "./chunk-RSKIKBZH.js";
+
+// src/build/content/server.ts
+var import_fast_glob = __toESM(require_out(), 1);
+import { existsSync } from "node:fs";
+import { cp, mkdir, readFile, readdir, readlink, symlink, writeFile } from "node:fs/promises";
+import { dirname, join } from "node:path";
+var copyNextServerCode = async (ctx) => {
+  const srcDir = join(ctx.publishDir, "standalone/.next");
+  const destDir = join(ctx.serverHandlerDir, ".next");
+  const paths = await (0, import_fast_glob.default)([`*`, `server/*`, `server/chunks/*`, `server/+(app|pages)/**/*.js`], {
+    cwd: srcDir,
+    extglob: true
+  });
+  await Promise.all(
+    paths.map(async (path) => {
+      const destPath = join(destDir, path);
+      if (path === "server/middleware-manifest.json") {
+        await mkdir(dirname(destPath), { recursive: true });
+        await writeFile(destPath, getEmptyMiddlewareManifest());
+        return;
+      }
+      await cp(join(srcDir, path), destPath, { recursive: true });
+    })
+  );
+};
+async function recreateNodeModuleSymlinks(src, dest, org) {
+  const dirents = await readdir(join(src, org || ""), { withFileTypes: true });
+  await Promise.all(
+    dirents.map(async (dirent) => {
+      if (dirent.name.startsWith("@")) {
+        return recreateNodeModuleSymlinks(src, dest, dirent.name);
+      }
+      if (dirent.isSymbolicLink()) {
+        const symlinkSrc = join(dest, org || "", dirent.name);
+        const symlinkTarget = await readlink(join(src, org || "", dirent.name));
+        const symlinkDest = join(dest, org || "", symlinkTarget);
+        if (existsSync(symlinkDest) && !existsSync(symlinkSrc)) {
+          if (org) {
+            await mkdir(join(dest, org), { recursive: true });
+          }
+          await symlink(symlinkDest, symlinkSrc);
+        }
+      }
+    })
+  );
+}
+var copyNextDependencies = async (ctx) => {
+  const srcDir = join(ctx.publishDir, "standalone/node_modules");
+  const destDir = join(ctx.serverHandlerDir, "node_modules");
+  await cp(srcDir, destDir, { recursive: true });
+  await recreateNodeModuleSymlinks(ctx.resolve("node_modules"), destDir);
+};
+var writeTagsManifest = async (ctx) => {
+  const manifest = await ctx.getPrerenderManifest();
+  const routes = Object.entries(manifest.routes).map(async ([route, definition]) => {
+    let tags;
+    if (definition.dataRoute?.endsWith(".rsc")) {
+      const path = join(ctx.publishDir, `server/app/${route === "/" ? "/index" : route}.meta`);
+      try {
+        const file = await readFile(path, "utf-8");
+        const meta = JSON.parse(file);
+        tags = meta.headers["x-next-cache-tags"];
+      } catch {
+        console.log(`Unable to read cache tags for: ${path}`);
+      }
+    }
+    if (definition.dataRoute?.endsWith(".json")) {
+      tags = `_N_T_${route}`;
+    }
+    if (definition.dataRoute === null) {
+      tags = definition.initialHeaders?.["x-next-cache-tags"];
+    }
+    return [route, tags];
+  });
+  await writeFile(
+    join(ctx.serverHandlerDir, ".netlify/tags-manifest.json"),
+    JSON.stringify(Object.fromEntries(await Promise.all(routes))),
+    "utf-8"
+  );
+};
+var getEmptyMiddlewareManifest = () => {
+  const manifest = {
+    sortedMiddleware: [],
+    middleware: {},
+    functions: {},
+    version: 2
+  };
+  return JSON.stringify(manifest);
+};
+
+export {
+  copyNextServerCode,
+  copyNextDependencies,
+  writeTagsManifest
+};

package/dist/esm-chunks/chunk-G3GM7JNF.js

@@ -0,0 +1,92 @@
+
+      const require = await (async () => {
+        const { createRequire } = await import("node:module");
+        return createRequire(import.meta.url);
+      })();
+    
+import {
+  require_out
+} from "./chunk-AVWFCGVE.js";
+import {
+  __toESM
+} from "./chunk-RSKIKBZH.js";
+
+// src/build/content/prerendered.ts
+var import_fast_glob = __toESM(require_out(), 1);
+import { existsSync } from "node:fs";
+import { readFile } from "node:fs/promises";
+import { join } from "node:path";
+var routeToFilePath = (path) => path.replace(/^\//, "") || "index";
+var buildPagesCacheValue = async (path) => ({
+  kind: "PAGE",
+  html: await readFile(`${path}.html`, "utf-8"),
+  pageData: JSON.parse(await readFile(`${path}.json`, "utf-8"))
+});
+var buildAppCacheValue = async (path) => ({
+  kind: "PAGE",
+  html: await readFile(`${path}.html`, "utf-8"),
+  pageData: await readFile(`${path}.rsc`, "utf-8"),
+  ...JSON.parse(await readFile(`${path}.meta`, "utf-8"))
+});
+var buildRouteCacheValue = async (path) => ({
+  kind: "ROUTE",
+  body: await readFile(`${path}.body`, "utf-8"),
+  ...JSON.parse(await readFile(`${path}.meta`, "utf-8"))
+});
+var buildFetchCacheValue = async (path) => ({
+  kind: "FETCH",
+  ...JSON.parse(await readFile(path, "utf-8"))
+});
+var copyPrerenderedContent = async (ctx) => {
+  try {
+    const manifest = await ctx.getPrerenderManifest();
+    await Promise.all(
+      Object.entries(manifest.routes).map(async ([route, meta]) => {
+        const key = routeToFilePath(route);
+        let value;
+        switch (true) {
+          case meta.dataRoute?.endsWith(".json"):
+            value = await buildPagesCacheValue(join(ctx.publishDir, "server/pages", key));
+            break;
+          case meta.dataRoute?.endsWith(".rsc"):
+            value = await buildAppCacheValue(join(ctx.publishDir, "server/app", key));
+            break;
+          case meta.dataRoute === null:
+            value = await buildRouteCacheValue(join(ctx.publishDir, "server/app", key));
+            break;
+          default:
+            throw new Error(`Unrecognized content: ${route}`);
+        }
+        await ctx.writeCacheEntry(key, value);
+      })
+    );
+    if (existsSync(join(ctx.publishDir, `server/app/_not-found.html`))) {
+      const key = "404";
+      const value = await buildAppCacheValue(join(ctx.publishDir, "server/app/_not-found"));
+      await ctx.writeCacheEntry(key, value);
+    }
+  } catch (error) {
+    ctx.failBuild("Failed assembling prerendered content for upload", error);
+  }
+};
+var copyFetchContent = async (ctx) => {
+  try {
+    const paths = await (0, import_fast_glob.default)(["!(*.*)"], {
+      cwd: join(ctx.publishDir, "cache/fetch-cache"),
+      extglob: true
+    });
+    await Promise.all(
+      paths.map(async (key) => {
+        const value = await buildFetchCacheValue(join(ctx.publishDir, "cache/fetch-cache", key));
+        await ctx.writeCacheEntry(key, value);
+      })
+    );
+  } catch (error) {
+    ctx.failBuild("Failed assembling fetch content for upload", error);
+  }
+};
+
+export {
+  copyPrerenderedContent,
+  copyFetchContent
+};

package/dist/esm-chunks/chunk-GGHAQM5D.js

@@ -0,0 +1,28 @@
+
+      const require = await (async () => {
+        const { createRequire } = await import("node:module");
+        return createRequire(import.meta.url);
+      })();
+    
+
+// src/build/cache.ts
+import { join } from "node:path";
+var saveBuildCache = async (ctx) => {
+  if (await ctx.utils.cache.save(join(ctx.publishDir, "cache"))) {
+    console.log("Next.js cache saved.");
+  } else {
+    console.log("No Next.js cache to save.");
+  }
+};
+var restoreBuildCache = async (ctx) => {
+  if (await ctx.utils.cache.restore(join(ctx.publishDir, "cache"))) {
+    console.log("Next.js cache restored.");
+  } else {
+    console.log("No Next.js cache to restore.");
+  }
+};
+
+export {
+  saveBuildCache,
+  restoreBuildCache
+};

package/dist/esm-chunks/chunk-HPGTYMVD.js

@@ -0,0 +1,113 @@
+
+      const require = await (async () => {
+        const { createRequire } = await import("node:module");
+        return createRequire(import.meta.url);
+      })();
+    
+
+// src/build/plugin-context.ts
+import { Buffer } from "node:buffer";
+import { readFileSync } from "node:fs";
+import { mkdir, readFile, writeFile } from "node:fs/promises";
+import { dirname, join, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+var MODULE_DIR = fileURLToPath(new URL(".", import.meta.url));
+var PLUGIN_DIR = join(MODULE_DIR, "../..");
+var SERVER_HANDLER_NAME = "___netlify-server-handler";
+var EDGE_HANDLER_NAME = "___netlify-edge-handler";
+var PluginContext = class {
+  utils;
+  pluginName;
+  pluginVersion;
+  constants;
+  packageJSON;
+  /** Absolute path of the next runtime plugin directory */
+  pluginDir = PLUGIN_DIR;
+  /** Absolute path of the publish directory */
+  get publishDir() {
+    return resolve(this.constants.PUBLISH_DIR);
+  }
+  /**
+   * Absolute path of the directory that is published and deployed to the Netlify CDN
+   * Will be swapped with the publish directory
+   * `.netlify/static`
+   */
+  get staticDir() {
+    return this.resolve(".netlify/static");
+  }
+  /**
+   * Absolute path of the directory that will be deployed to the blob store
+   * `.netlify/blobs/deploy`
+   */
+  get blobDir() {
+    return this.resolve(".netlify/blobs/deploy");
+  }
+  /**
+   * Absolute path of the directory containing the files for the serverless lambda function
+   * `.netlify/functions-internal`
+   */
+  get serverFunctionsDir() {
+    return this.resolve(".netlify/functions-internal");
+  }
+  /** Absolute path of the server handler */
+  get serverHandlerDir() {
+    return join(this.serverFunctionsDir, SERVER_HANDLER_NAME);
+  }
+  /**
+   * Absolute path of the directory containing the files for deno edge functions
+   * `.netlify/edge-functions`
+   */
+  get edgeFunctionsDir() {
+    return this.resolve(".netlify/edge-functions");
+  }
+  /** Absolute path of the edge handler */
+  get edgeHandlerDir() {
+    return join(this.edgeFunctionsDir, EDGE_HANDLER_NAME);
+  }
+  constructor(options) {
+    this.packageJSON = JSON.parse(readFileSync(join(PLUGIN_DIR, "package.json"), "utf-8"));
+    this.pluginName = this.packageJSON.name;
+    this.pluginVersion = this.packageJSON.version;
+    this.constants = options.constants;
+    this.utils = options.utils;
+  }
+  /** Resolves a path correctly with mono repository awareness  */
+  resolve(...args) {
+    return resolve(this.constants.PACKAGE_PATH || "", ...args);
+  }
+  /** Get the next prerender-manifest.json */
+  async getPrerenderManifest() {
+    return JSON.parse(await readFile(join(this.publishDir, "prerender-manifest.json"), "utf-8"));
+  }
+  /**
+   * Get Next.js middleware config from the build output
+   */
+  async getMiddlewareManifest() {
+    return JSON.parse(
+      await readFile(join(this.publishDir, "server/middleware-manifest.json"), "utf-8")
+    );
+  }
+  /**
+   * Write a cache entry to the blob upload directory using
+   * base64 keys to avoid collisions with directories
+   */
+  async writeCacheEntry(key, value) {
+    const path = join(this.blobDir, Buffer.from(key).toString("base64"));
+    const entry = JSON.stringify({
+      lastModified: Date.now(),
+      value
+    });
+    await mkdir(dirname(path), { recursive: true });
+    await writeFile(path, entry, "utf-8");
+  }
+  /** Fails a build with a message and an optional error */
+  failBuild(message, error) {
+    return this.utils.build.failBuild(message, error instanceof Error ? { error } : void 0);
+  }
+};
+
+export {
+  SERVER_HANDLER_NAME,
+  EDGE_HANDLER_NAME,
+  PluginContext
+};

package/dist/esm-chunks/chunk-PEBUKFKH.js

@@ -0,0 +1,89 @@
+
+      const require = await (async () => {
+        const { createRequire } = await import("node:module");
+        return createRequire(import.meta.url);
+      })();
+    
+import {
+  copyNextDependencies,
+  copyNextServerCode,
+  writeTagsManifest
+} from "./chunk-G2VRYWGL.js";
+import {
+  require_out
+} from "./chunk-AVWFCGVE.js";
+import {
+  SERVER_HANDLER_NAME
+} from "./chunk-HPGTYMVD.js";
+import {
+  __toESM
+} from "./chunk-RSKIKBZH.js";
+
+// src/build/functions/server.ts
+var import_fast_glob = __toESM(require_out(), 1);
+import { cp, mkdir, rm, writeFile } from "fs/promises";
+import { join } from "node:path";
+var copyHandlerDependencies = async (ctx) => {
+  const fileList = await (0, import_fast_glob.glob)("dist/**/*", { cwd: ctx.pluginDir });
+  await Promise.all(
+    [...fileList].map(
+      (path) => cp(join(ctx.pluginDir, path), join(ctx.serverHandlerDir, path), { recursive: true })
+    )
+  );
+};
+var writeHandlerManifest = async (ctx) => {
+  await writeFile(
+    join(ctx.serverHandlerDir, `${SERVER_HANDLER_NAME}.json`),
+    JSON.stringify({
+      config: {
+        name: "Next.js Server Handler",
+        generator: `${ctx.pluginName}@${ctx.pluginVersion}`,
+        nodeBundler: "none",
+        includedFiles: [
+          `${SERVER_HANDLER_NAME}*`,
+          "package.json",
+          "dist/**",
+          ".next/**",
+          ".netlify/**",
+          "node_modules/**"
+        ],
+        includedFilesBasePath: ctx.serverHandlerDir
+      },
+      version: 1
+    }),
+    "utf-8"
+  );
+};
+var writePackageMetadata = async (ctx) => {
+  await writeFile(join(ctx.serverHandlerDir, "package.json"), JSON.stringify({ type: "module" }));
+};
+var writeHandlerFile = async (ctx) => {
+  await writeFile(
+    join(ctx.serverHandlerDir, `${SERVER_HANDLER_NAME}.js`),
+    `
+    import handler from './dist/run/handlers/server.js';
+    export default handler;
+    export const config = {
+      path: '/*',
+      preferStatic: true
+    };
+    `
+  );
+};
+var createServerHandler = async (ctx) => {
+  await rm(ctx.serverFunctionsDir, { recursive: true, force: true });
+  await mkdir(join(ctx.serverHandlerDir, ".netlify"), { recursive: true });
+  await Promise.all([
+    copyNextServerCode(ctx),
+    copyNextDependencies(ctx),
+    writeTagsManifest(ctx),
+    copyHandlerDependencies(ctx),
+    writeHandlerManifest(ctx),
+    writePackageMetadata(ctx),
+    writeHandlerFile(ctx)
+  ]);
+};
+
+export {
+  createServerHandler
+};