@netlify/plugin-nextjs 5.1.2 → 5.2.1

package/dist/build/advanced-api-routes.js

@@ -5,10 +5,127 @@
       })();
     
 import {
-  ApiRouteType,
-  getAPIRoutesConfigs
-} from "../esm-chunks/chunk-BG455SFE.js";
-import "../esm-chunks/chunk-5JVNISGM.js";
+  __require
+} from "../esm-chunks/chunk-5JVNISGM.js";
+
+// src/build/advanced-api-routes.ts
+import { existsSync } from "node:fs";
+import { readFile } from "node:fs/promises";
+import { join } from "node:path";
+var ApiRouteType = /* @__PURE__ */ ((ApiRouteType2) => {
+  ApiRouteType2["SCHEDULED"] = "experimental-scheduled";
+  ApiRouteType2["BACKGROUND"] = "experimental-background";
+  return ApiRouteType2;
+})(ApiRouteType || {});
+async function getAPIRoutesConfigs(ctx) {
+  const functionsConfigManifestPath = join(
+    ctx.publishDir,
+    "server",
+    "functions-config-manifest.json"
+  );
+  if (!existsSync(functionsConfigManifestPath)) {
+    return [];
+  }
+  const functionsConfigManifest = JSON.parse(
+    await readFile(functionsConfigManifestPath, "utf-8")
+  );
+  const appDir = ctx.resolveFromSiteDir(".");
+  const pagesDir = join(appDir, "pages");
+  const srcPagesDir = join(appDir, "src", "pages");
+  const { pageExtensions } = ctx.requiredServerFiles.config;
+  return Promise.all(
+    Object.keys(functionsConfigManifest.functions).map(async (apiRoute) => {
+      const filePath = getSourceFileForPage(apiRoute, [pagesDir, srcPagesDir], pageExtensions);
+      const sharedFields = {
+        apiRoute,
+        filePath,
+        config: {}
+      };
+      if (filePath) {
+        const config = await extractConfigFromFile(filePath, appDir);
+        return {
+          ...sharedFields,
+          config
+        };
+      }
+      return sharedFields;
+    })
+  );
+}
+var SOURCE_FILE_EXTENSIONS = ["js", "jsx", "ts", "tsx"];
+var getSourceFileForPage = (page, roots, pageExtensions = SOURCE_FILE_EXTENSIONS) => {
+  for (const root of roots) {
+    for (const extension of pageExtensions) {
+      const file = join(root, `${page}.${extension}`);
+      if (existsSync(file)) {
+        return file;
+      }
+      const fileAtFolderIndex = join(root, page, `index.${extension}`);
+      if (existsSync(fileAtFolderIndex)) {
+        return fileAtFolderIndex;
+      }
+    }
+  }
+};
+var findModuleFromBase = ({
+  paths,
+  candidates
+}) => {
+  for (const candidate of candidates) {
+    try {
+      const modulePath = __require.resolve(candidate, { paths });
+      if (modulePath) {
+        return modulePath;
+      }
+    } catch {
+    }
+  }
+  for (const candidate of candidates) {
+    try {
+      const modulePath = __require.resolve(candidate);
+      if (modulePath) {
+        return modulePath;
+      }
+    } catch {
+    }
+  }
+  return null;
+};
+var extractConstValue;
+var parseModule;
+var extractConfigFromFile = async (apiFilePath, appDir) => {
+  if (!apiFilePath || !existsSync(apiFilePath)) {
+    return {};
+  }
+  const extractConstValueModulePath = findModuleFromBase({
+    paths: [appDir],
+    candidates: ["next/dist/build/analysis/extract-const-value"]
+  });
+  const parseModulePath = findModuleFromBase({
+    paths: [appDir],
+    candidates: ["next/dist/build/analysis/parse-module"]
+  });
+  if (!extractConstValueModulePath || !parseModulePath) {
+    return {};
+  }
+  if (!extractConstValue && extractConstValueModulePath) {
+    extractConstValue = __require(extractConstValueModulePath);
+  }
+  if (!parseModule && parseModulePath) {
+    parseModule = __require(parseModulePath).parseModule;
+  }
+  const { extractExportedConstValue } = extractConstValue;
+  const fileContent = await readFile(apiFilePath, "utf8");
+  if (!fileContent.includes("config")) {
+    return {};
+  }
+  const ast = await parseModule(apiFilePath, fileContent);
+  try {
+    return extractExportedConstValue(ast, "config");
+  } catch {
+    return {};
+  }
+};
 export {
   ApiRouteType,
   getAPIRoutesConfigs

package/dist/build/cache.js

@@ -4,11 +4,32 @@
         return createRequire(import.meta.url);
       })();
     
-import {
-  restoreBuildCache,
-  saveBuildCache
-} from "../esm-chunks/chunk-72ZI2IVI.js";
 import "../esm-chunks/chunk-5JVNISGM.js";
+
+// src/build/cache.ts
+import { existsSync } from "node:fs";
+import { rm } from "node:fs/promises";
+import { join } from "node:path";
+var saveBuildCache = async (ctx) => {
+  const { cache } = ctx.utils;
+  const cacheDir = join(ctx.publishDir, "cache");
+  if (existsSync(cacheDir)) {
+    await rm(join(cacheDir, "fetch-cache"), { recursive: true, force: true });
+    await cache.save(cacheDir);
+    console.log("Next.js cache saved");
+  } else {
+    console.log("No Next.js cache to save");
+  }
+};
+var restoreBuildCache = async (ctx) => {
+  const { cache } = ctx.utils;
+  const cacheDir = join(ctx.publishDir, "cache");
+  if (await cache.restore(cacheDir)) {
+    console.log("Next.js cache restored");
+  } else {
+    console.log("No Next.js cache to restore");
+  }
+};
 export {
   restoreBuildCache,
   saveBuildCache

package/dist/build/content/prerendered.js

@@ -5,14 +5,243 @@
       })();
     
 import {
-  copyFetchContent,
-  copyPrerenderedContent
-} from "../../esm-chunks/chunk-MRD3XSKD.js";
-import "../../esm-chunks/chunk-TYCYFZ22.js";
-import "../../esm-chunks/chunk-PDPDW32D.js";
-import "../../esm-chunks/chunk-Y3K5Q6FP.js";
-import "../../esm-chunks/chunk-VZNKO4OO.js";
-import "../../esm-chunks/chunk-5JVNISGM.js";
+  require_out
+} from "../../esm-chunks/chunk-VZNKO4OO.js";
+import {
+  wrapTracer
+} from "../../esm-chunks/chunk-PDPDW32D.js";
+import {
+  init_esm,
+  trace
+} from "../../esm-chunks/chunk-Y3K5Q6FP.js";
+import {
+  __toESM
+} from "../../esm-chunks/chunk-5JVNISGM.js";
+
+// src/build/content/prerendered.ts
+init_esm();
+import { existsSync } from "node:fs";
+import { mkdir, readFile, writeFile } from "node:fs/promises";
+import { join } from "node:path";
+var import_fast_glob = __toESM(require_out(), 1);
+
+// node_modules/yocto-queue/index.js
+var Node = class {
+  value;
+  next;
+  constructor(value) {
+    this.value = value;
+  }
+};
+var Queue = class {
+  #head;
+  #tail;
+  #size;
+  constructor() {
+    this.clear();
+  }
+  enqueue(value) {
+    const node = new Node(value);
+    if (this.#head) {
+      this.#tail.next = node;
+      this.#tail = node;
+    } else {
+      this.#head = node;
+      this.#tail = node;
+    }
+    this.#size++;
+  }
+  dequeue() {
+    const current = this.#head;
+    if (!current) {
+      return;
+    }
+    this.#head = this.#head.next;
+    this.#size--;
+    return current.value;
+  }
+  clear() {
+    this.#head = void 0;
+    this.#tail = void 0;
+    this.#size = 0;
+  }
+  get size() {
+    return this.#size;
+  }
+  *[Symbol.iterator]() {
+    let current = this.#head;
+    while (current) {
+      yield current.value;
+      current = current.next;
+    }
+  }
+};
+
+// node_modules/p-limit/index.js
+import { AsyncResource } from "async_hooks";
+function pLimit(concurrency) {
+  if (!((Number.isInteger(concurrency) || concurrency === Number.POSITIVE_INFINITY) && concurrency > 0)) {
+    throw new TypeError("Expected `concurrency` to be a number from 1 and up");
+  }
+  const queue = new Queue();
+  let activeCount = 0;
+  const next = () => {
+    activeCount--;
+    if (queue.size > 0) {
+      queue.dequeue()();
+    }
+  };
+  const run = async (function_, resolve, arguments_) => {
+    activeCount++;
+    const result = (async () => function_(...arguments_))();
+    resolve(result);
+    try {
+      await result;
+    } catch {
+    }
+    next();
+  };
+  const enqueue = (function_, resolve, arguments_) => {
+    queue.enqueue(
+      AsyncResource.bind(run.bind(void 0, function_, resolve, arguments_))
+    );
+    (async () => {
+      await Promise.resolve();
+      if (activeCount < concurrency && queue.size > 0) {
+        queue.dequeue()();
+      }
+    })();
+  };
+  const generator = (function_, ...arguments_) => new Promise((resolve) => {
+    enqueue(function_, resolve, arguments_);
+  });
+  Object.defineProperties(generator, {
+    activeCount: {
+      get: () => activeCount
+    },
+    pendingCount: {
+      get: () => queue.size
+    },
+    clearQueue: {
+      value() {
+        queue.clear();
+      }
+    }
+  });
+  return generator;
+}
+
+// src/build/content/prerendered.ts
+import { encodeBlobKey } from "../../shared/blobkey.js";
+var tracer = wrapTracer(trace.getTracer("Next runtime"));
+var writeCacheEntry = async (route, value, lastModified, ctx) => {
+  const path = join(ctx.blobDir, await encodeBlobKey(route));
+  const entry = JSON.stringify({
+    lastModified,
+    value
+  });
+  await writeFile(path, entry, "utf-8");
+};
+var routeToFilePath = (path) => path === "/" ? "/index" : path;
+var buildPagesCacheValue = async (path) => ({
+  kind: "PAGE",
+  html: await readFile(`${path}.html`, "utf-8"),
+  pageData: JSON.parse(await readFile(`${path}.json`, "utf-8")),
+  postponed: void 0,
+  headers: void 0,
+  status: void 0
+});
+var buildAppCacheValue = async (path) => {
+  const meta = JSON.parse(await readFile(`${path}.meta`, "utf-8"));
+  const rsc = await readFile(`${path}.rsc`, "utf-8").catch(
+    () => readFile(`${path}.prefetch.rsc`, "utf-8")
+  );
+  if (!meta.status && rsc.includes("NEXT_NOT_FOUND")) {
+    meta.status = 404;
+  }
+  return {
+    kind: "PAGE",
+    html: await readFile(`${path}.html`, "utf-8"),
+    pageData: rsc,
+    ...meta
+  };
+};
+var buildRouteCacheValue = async (path, initialRevalidateSeconds) => ({
+  kind: "ROUTE",
+  body: await readFile(`${path}.body`, "base64"),
+  ...JSON.parse(await readFile(`${path}.meta`, "utf-8")),
+  revalidate: initialRevalidateSeconds
+});
+var buildFetchCacheValue = async (path) => ({
+  kind: "FETCH",
+  ...JSON.parse(await readFile(path, "utf-8"))
+});
+var copyPrerenderedContent = async (ctx) => {
+  return tracer.withActiveSpan("copyPrerenderedContent", async () => {
+    try {
+      await mkdir(ctx.blobDir, { recursive: true });
+      const manifest = await ctx.getPrerenderManifest();
+      const limitConcurrentPrerenderContentHandling = pLimit(10);
+      await Promise.all(
+        Object.entries(manifest.routes).map(
+          ([route, meta]) => limitConcurrentPrerenderContentHandling(async () => {
+            const lastModified = meta.initialRevalidateSeconds ? Date.now() - 31536e6 : Date.now();
+            const key = routeToFilePath(route);
+            let value;
+            switch (true) {
+              case (meta.dataRoute?.endsWith("/default.rsc") && !existsSync(join(ctx.publishDir, "server/app", `${key}.html`))):
+                return;
+              case meta.dataRoute?.endsWith(".json"):
+                if (manifest.notFoundRoutes.includes(route)) {
+                  return;
+                }
+                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),
+                  meta.initialRevalidateSeconds
+                );
+                break;
+              default:
+                throw new Error(`Unrecognized content: ${route}`);
+            }
+            await writeCacheEntry(key, value, lastModified, ctx);
+          })
+        )
+      );
+      if (existsSync(join(ctx.publishDir, `server/app/_not-found.html`))) {
+        const lastModified = Date.now();
+        const key = "/404";
+        const value = await buildAppCacheValue(join(ctx.publishDir, "server/app/_not-found"));
+        await writeCacheEntry(key, value, lastModified, ctx);
+      }
+    } catch (error) {
+      ctx.failBuild("Failed assembling prerendered content for upload", error);
+    }
+  });
+};
+var copyFetchContent = async (ctx) => {
+  try {
+    const paths = await (0, import_fast_glob.glob)(["!(*.*)"], {
+      cwd: join(ctx.publishDir, "cache/fetch-cache"),
+      extglob: true
+    });
+    await Promise.all(
+      paths.map(async (key) => {
+        const lastModified = Date.now() - 31536e6;
+        const path = join(ctx.publishDir, "cache/fetch-cache", key);
+        const value = await buildFetchCacheValue(path);
+        await writeCacheEntry(key, value, lastModified, ctx);
+      })
+    );
+  } catch (error) {
+    ctx.failBuild("Failed assembling fetch content for upload", error);
+  }
+};
 export {
   copyFetchContent,
   copyPrerenderedContent

package/dist/build/content/server.js

@@ -5,20 +5,265 @@
       })();
     
 import {
-  copyNextDependencies,
-  copyNextServerCode,
-  getPatchesToApply,
-  verifyHandlerDirStructure,
-  writeTagsManifest
-} from "../../esm-chunks/chunk-4BNHE6TP.js";
-import "../../esm-chunks/chunk-PDPDW32D.js";
-import "../../esm-chunks/chunk-Y3K5Q6FP.js";
-import "../../esm-chunks/chunk-VZNKO4OO.js";
-import "../../esm-chunks/chunk-K7BTUM7O.js";
-import "../../esm-chunks/chunk-PJG75HGC.js";
-import "../../esm-chunks/chunk-BG455SFE.js";
-import "../../esm-chunks/chunk-UYKENJEU.js";
-import "../../esm-chunks/chunk-5JVNISGM.js";
+  require_out
+} from "../../esm-chunks/chunk-VZNKO4OO.js";
+import {
+  wrapTracer
+} from "../../esm-chunks/chunk-PDPDW32D.js";
+import {
+  init_esm,
+  trace
+} from "../../esm-chunks/chunk-Y3K5Q6FP.js";
+import {
+  require_semver
+} from "../../esm-chunks/chunk-PJG75HGC.js";
+import {
+  __toESM
+} from "../../esm-chunks/chunk-5JVNISGM.js";
+
+// src/build/content/server.ts
+init_esm();
+import { existsSync } from "node:fs";
+import {
+  cp,
+  mkdir,
+  readFile,
+  readdir,
+  readlink,
+  symlink,
+  writeFile,
+  access
+} from "node:fs/promises";
+import { createRequire } from "node:module";
+import { dirname, join, resolve, sep } from "node:path";
+import { sep as posixSep, join as posixJoin } from "node:path/posix";
+var import_fast_glob = __toESM(require_out(), 1);
+var import_semver = __toESM(require_semver(), 1);
+import { RUN_CONFIG } from "../../run/constants.js";
+import { verifyNextVersion } from "../verification.js";
+var tracer = wrapTracer(trace.getTracer("Next runtime"));
+var toPosixPath = (path) => path.split(sep).join(posixSep);
+function isError(error) {
+  return error instanceof Error;
+}
+var copyNextServerCode = async (ctx) => {
+  await tracer.withActiveSpan("copyNextServerCode", async () => {
+    const reqServerFilesPath = join(
+      ctx.standaloneRootDir,
+      ctx.relativeAppDir,
+      ctx.requiredServerFiles.config.distDir,
+      "required-server-files.json"
+    );
+    try {
+      await access(reqServerFilesPath);
+    } catch (error) {
+      if (isError(error) && error.code === "ENOENT") {
+        ctx.failBuild(
+          `Failed creating server handler. required-server-files.json file not found at expected location "${reqServerFilesPath}". Your repository setup is currently not yet supported.`
+        );
+      } else {
+        throw error;
+      }
+    }
+    const reqServerFiles = JSON.parse(await readFile(reqServerFilesPath, "utf-8"));
+    if (toPosixPath(ctx.distDir).replace(new RegExp(`^${ctx.relativeAppDir}/?`), "") !== reqServerFiles.config.distDir) {
+      reqServerFiles.config.distDir = ctx.nextDistDir;
+      await writeFile(reqServerFilesPath, JSON.stringify(reqServerFiles));
+    }
+    await mkdir(ctx.serverHandlerDir, { recursive: true });
+    await writeFile(
+      join(ctx.serverHandlerDir, RUN_CONFIG),
+      JSON.stringify(reqServerFiles.config),
+      "utf-8"
+    );
+    const srcDir = join(ctx.standaloneDir, ctx.nextDistDir);
+    const nextFolder = toPosixPath(ctx.distDir) === toPosixPath(ctx.buildConfig.distDir) ? ctx.distDir : ctx.nextDistDir;
+    const destDir = join(ctx.serverHandlerDir, nextFolder);
+    const paths = await (0, import_fast_glob.default)(
+      [`*`, `server/*`, `server/chunks/*`, `server/edge-chunks/*`, `server/+(app|pages)/**/*.js`],
+      {
+        cwd: srcDir,
+        extglob: true
+      }
+    );
+    await Promise.all(
+      paths.map(async (path) => {
+        const srcPath = join(srcDir, path);
+        const destPath = join(destDir, path);
+        if (path === "server/middleware-manifest.json") {
+          try {
+            await replaceMiddlewareManifest(srcPath, destPath);
+          } catch (error) {
+            throw new Error("Could not patch middleware manifest file", { cause: error });
+          }
+          return;
+        }
+        await cp(srcPath, destPath, { recursive: true, force: 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(symlinkTarget, symlinkSrc);
+        }
+      }
+    })
+  );
+}
+var nextInternalModuleReplacements = [
+  {
+    // standalone is loading expensive Telemetry module that is not actually used
+    // so this replace that module with lightweight no-op shim that doesn't load additional modules
+    // see https://github.com/vercel/next.js/pull/63574 that removed need for this shim
+    ongoing: false,
+    minVersion: "13.5.0-canary.0",
+    // perf released in https://github.com/vercel/next.js/releases/tag/v14.2.0-canary.43
+    maxVersion: "14.2.0-canary.42",
+    nextModule: "next/dist/telemetry/storage.js",
+    shimModule: "./next-shims/telemetry-storage.cjs"
+  }
+];
+function getPatchesToApply(nextVersion, patches = nextInternalModuleReplacements) {
+  return patches.filter((patch) => {
+    if ((0, import_semver.lt)(nextVersion, patch.minVersion)) {
+      return false;
+    }
+    if (patch.ongoing) {
+      if ((0, import_semver.prerelease)(nextVersion) || process.env.NETLIFY_NEXT_FORCE_APPLY_ONGOING_PATCHES) {
+        return true;
+      }
+      return (0, import_semver.lte)(nextVersion, patch.maxStableVersion);
+    }
+    return (0, import_semver.lte)(nextVersion, patch.maxVersion);
+  });
+}
+async function patchNextModules(ctx, nextVersion, serverHandlerRequireResolve) {
+  const moduleReplacementsToApply = getPatchesToApply(nextVersion);
+  if (moduleReplacementsToApply.length !== 0) {
+    await Promise.all(
+      moduleReplacementsToApply.map(async ({ nextModule, shimModule }) => {
+        try {
+          const nextModulePath = serverHandlerRequireResolve(nextModule);
+          const shimModulePath = posixJoin(ctx.pluginDir, "dist", "build", "content", shimModule);
+          await cp(shimModulePath, nextModulePath, { force: true });
+        } catch {
+        }
+      })
+    );
+  }
+}
+var copyNextDependencies = async (ctx) => {
+  await tracer.withActiveSpan("copyNextDependencies", async () => {
+    const entries = await readdir(ctx.standaloneDir);
+    const promises = entries.map(async (entry) => {
+      if (entry === "package.json" || entry === ctx.nextDistDir) {
+        return;
+      }
+      const src = join(ctx.standaloneDir, entry);
+      const dest = join(ctx.serverHandlerDir, entry);
+      await cp(src, dest, { recursive: true, verbatimSymlinks: true, force: true });
+      if (entry === "node_modules") {
+        await recreateNodeModuleSymlinks(ctx.resolveFromSiteDir("node_modules"), dest);
+      }
+    });
+    const rootSrcDir = join(ctx.standaloneRootDir, "node_modules");
+    const rootDestDir = join(ctx.serverHandlerRootDir, "node_modules");
+    if (existsSync(rootSrcDir) && ctx.standaloneRootDir !== ctx.standaloneDir) {
+      promises.push(
+        cp(rootSrcDir, rootDestDir, { recursive: true, verbatimSymlinks: true }).then(
+          () => recreateNodeModuleSymlinks(resolve("node_modules"), rootDestDir)
+        )
+      );
+    }
+    await Promise.all(promises);
+    const serverHandlerRequire = createRequire(posixJoin(ctx.serverHandlerDir, ":internal:"));
+    let nextVersion;
+    try {
+      const { version } = serverHandlerRequire("next/package.json");
+      if (version) {
+        nextVersion = version;
+      }
+    } catch {
+    }
+    if (nextVersion) {
+      verifyNextVersion(ctx, nextVersion);
+      await patchNextModules(ctx, nextVersion, serverHandlerRequire.resolve);
+    }
+    try {
+      const nextEntryAbsolutePath = serverHandlerRequire.resolve("next");
+      const nextRequire = createRequire(nextEntryAbsolutePath);
+      nextRequire.resolve("styled-jsx");
+    } catch {
+      throw new Error(
+        "node_modules are not installed correctly, if you are using pnpm please set the public hoist pattern to: `public-hoist-pattern[]=*`.\nRefer to your docs for more details: https://docs.netlify.com/integrations/frameworks/next-js/overview/#pnpm-support"
+      );
+    }
+  });
+};
+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 {
+        if (!definition.dataRoute?.endsWith("/default.rsc")) {
+          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 replaceMiddlewareManifest = async (sourcePath, destPath) => {
+  await mkdir(dirname(destPath), { recursive: true });
+  const data = await readFile(sourcePath, "utf8");
+  const manifest = JSON.parse(data);
+  const newManifest = {
+    ...manifest,
+    middleware: {}
+  };
+  const newData = JSON.stringify(newManifest);
+  await writeFile(destPath, newData);
+};
+var verifyHandlerDirStructure = async (ctx) => {
+  const runConfig = JSON.parse(await readFile(join(ctx.serverHandlerDir, RUN_CONFIG), "utf-8"));
+  const expectedBuildIDPath = join(ctx.serverHandlerDir, runConfig.distDir, "BUILD_ID");
+  if (!existsSync(expectedBuildIDPath)) {
+    ctx.failBuild(
+      `Failed creating server handler. BUILD_ID file not found at expected location "${expectedBuildIDPath}".`
+    );
+  }
+};
 export {
   copyNextDependencies,
   copyNextServerCode,