@netlify/plugin-nextjs 5.0.0-rc.5 → 5.0.0-rc.7

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

@@ -0,0 +1,110 @@
+
+      var require = await (async () => {
+        var { createRequire } = await import("node:module");
+        return createRequire(import.meta.url);
+      })();
+    
+import {
+  wrapTracer
+} from "./chunk-PDPDW32D.js";
+import {
+  init_esm,
+  trace
+} from "./chunk-Y3K5Q6FP.js";
+import {
+  require_out
+} from "./chunk-VZNKO4OO.js";
+import {
+  encodeBlobKey
+} from "./chunk-TYCYFZ22.js";
+import {
+  __toESM
+} from "./chunk-5JVNISGM.js";
+
+// src/build/content/static.ts
+init_esm();
+import { existsSync } from "node:fs";
+import { cp, mkdir, rename, rm } from "node:fs/promises";
+import { basename, join } from "node:path";
+var import_fast_glob = __toESM(require_out(), 1);
+var tracer = wrapTracer(trace.getTracer("Next runtime"));
+var copyStaticContent = async (ctx) => {
+  return tracer.withActiveSpan("copyStaticContent", async () => {
+    const srcDir = join(ctx.publishDir, "server/pages");
+    const destDir = ctx.blobDir;
+    const paths = await (0, import_fast_glob.default)("**/*.+(html|json)", {
+      cwd: srcDir,
+      extglob: true
+    });
+    try {
+      await Promise.all(
+        paths.filter((path) => !paths.includes(`${path.slice(0, -5)}.json`)).map(async (path) => {
+          await cp(join(srcDir, path), join(destDir, await encodeBlobKey(path)), {
+            recursive: true,
+            force: true
+          });
+        })
+      );
+    } catch (error) {
+      ctx.failBuild("Failed assembling static pages for upload", error);
+    }
+  });
+};
+var copyStaticAssets = async (ctx) => {
+  return tracer.withActiveSpan("copyStaticAssets", async (span) => {
+    try {
+      await rm(ctx.staticDir, { recursive: true, force: true });
+      const { basePath } = await ctx.getRoutesManifest();
+      if (existsSync(ctx.resolveFromSiteDir("public"))) {
+        await cp(ctx.resolveFromSiteDir("public"), join(ctx.staticDir, basePath), {
+          recursive: true
+        });
+      }
+      if (existsSync(join(ctx.publishDir, "static"))) {
+        await cp(join(ctx.publishDir, "static"), join(ctx.staticDir, basePath, "_next/static"), {
+          recursive: true
+        });
+      }
+    } catch (error) {
+      span.end();
+      ctx.failBuild("Failed copying static assets", error);
+    }
+  });
+};
+var copyStaticExport = async (ctx) => {
+  await tracer.withActiveSpan("copyStaticExport", async () => {
+    try {
+      await rm(ctx.staticDir, { recursive: true, force: true });
+      await cp(ctx.resolveFromSiteDir("out"), ctx.staticDir, { recursive: true });
+    } catch (error) {
+      ctx.failBuild("Failed copying static export", error);
+    }
+  });
+};
+var publishStaticDir = async (ctx) => {
+  try {
+    await rm(ctx.tempPublishDir, { recursive: true, force: true });
+    await mkdir(basename(ctx.tempPublishDir), { recursive: true });
+    await rename(ctx.publishDir, ctx.tempPublishDir);
+    await rename(ctx.staticDir, ctx.publishDir);
+  } catch (error) {
+    ctx.failBuild("Failed publishing static content", error instanceof Error ? { error } : {});
+  }
+};
+var unpublishStaticDir = async (ctx) => {
+  try {
+    if (existsSync(ctx.tempPublishDir)) {
+      await rename(ctx.publishDir, ctx.staticDir);
+      await rename(ctx.tempPublishDir, ctx.publishDir);
+    }
+  } catch {
+  }
+};
+
+export {
+  copyStaticContent,
+  copyStaticAssets,
+  copyStaticExport,
+  publishStaticDir,
+  unpublishStaticDir
+};

package/dist/esm-chunks/{chunk-637Y3P2U.js → chunk-M2ZKGJAI.js}

@@ -617,7 +617,7 @@ var adjustDateHeader = async ({
     });
     const blobKey = await encodeBlobKey(key);
     const blobStore = getDeployStore({ fetch: fetchBeforeNextPatchedIt, consistency: "strong" });
-    lastModified = await tracer.startActiveSpan(
+    lastModified = await tracer.withActiveSpan(
       "get cache to calculate date header",
       async (getBlobForDateSpan) => {
         getBlobForDateSpan.setAttributes({
@@ -626,7 +626,6 @@ var adjustDateHeader = async ({
         });
         const blob = await blobStore.get(blobKey, { type: "json" }) ?? {};
         getBlobForDateSpan.addEvent(blob ? "Cache hit" : "Cache miss");
-        getBlobForDateSpan.end();
         return blob.lastModified;
       }
     );

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

@@ -0,0 +1,89 @@
+
+      var require = await (async () => {
+        var { createRequire } = await import("node:module");
+        return createRequire(import.meta.url);
+      })();
+    
+import {
+  SpanStatusCode,
+  context,
+  init_esm
+} from "./chunk-Y3K5Q6FP.js";
+
+// node_modules/@opentelemetry/api/build/esm/experimental/trace/SugaredTracer.js
+init_esm();
+var defaultOnException = function(e, span) {
+  span.recordException(e);
+  span.setStatus({
+    code: SpanStatusCode.ERROR
+  });
+};
+function wrapTracer(tracer) {
+  return new SugaredTracer(tracer);
+}
+var SugaredTracer = (
+  /** @class */
+  function() {
+    function SugaredTracer2(tracer) {
+      this._tracer = tracer;
+      this.startSpan = tracer.startSpan.bind(this._tracer);
+      this.startActiveSpan = tracer.startActiveSpan.bind(this._tracer);
+    }
+    SugaredTracer2.prototype.withActiveSpan = function(name, arg2, arg3, arg4) {
+      var _a = massageParams(arg2, arg3, arg4), opts = _a.opts, ctx = _a.ctx, fn = _a.fn;
+      return this._tracer.startActiveSpan(name, opts, ctx, function(span) {
+        return handleFn(span, opts, fn);
+      });
+    };
+    SugaredTracer2.prototype.withSpan = function(name, arg2, arg3, arg4) {
+      var _a = massageParams(arg2, arg3, arg4), opts = _a.opts, ctx = _a.ctx, fn = _a.fn;
+      var span = this._tracer.startSpan(name, opts, ctx);
+      return handleFn(span, opts, fn);
+    };
+    return SugaredTracer2;
+  }()
+);
+function massageParams(arg, arg2, arg3) {
+  var opts;
+  var ctx;
+  var fn;
+  if (!arg2 && !arg3) {
+    fn = arg;
+  } else if (!arg3) {
+    opts = arg;
+    fn = arg2;
+  } else {
+    opts = arg;
+    ctx = arg2;
+    fn = arg3;
+  }
+  opts = opts !== null && opts !== void 0 ? opts : {};
+  ctx = ctx !== null && ctx !== void 0 ? ctx : context.active();
+  return { opts, ctx, fn };
+}
+function handleFn(span, opts, fn) {
+  var _a;
+  var onException = (_a = opts.onException) !== null && _a !== void 0 ? _a : defaultOnException;
+  var errorHandler = function(e) {
+    onException(e, span);
+    span.end();
+    throw e;
+  };
+  try {
+    var ret = fn(span);
+    if (typeof (ret === null || ret === void 0 ? void 0 : ret.then) === "function") {
+      return ret.then(function(val) {
+        span.end();
+        return val;
+      }, errorHandler);
+    }
+    span.end();
+    return ret;
+  } catch (e) {
+    throw errorHandler(e);
+  }
+}
+
+export {
+  wrapTracer
+};

package/dist/esm-chunks/{chunk-GQ6KIYPX.js → chunk-Y3K5Q6FP.js}

@@ -9,18 +9,6 @@ import {
   __export
 } from "./chunk-5JVNISGM.js";
 
-// node_modules/@opentelemetry/api/build/esm/trace/status.js
-var SpanStatusCode;
-var init_status = __esm({
-  "node_modules/@opentelemetry/api/build/esm/trace/status.js"() {
-    (function(SpanStatusCode2) {
-      SpanStatusCode2[SpanStatusCode2["UNSET"] = 0] = "UNSET";
-      SpanStatusCode2[SpanStatusCode2["OK"] = 1] = "OK";
-      SpanStatusCode2[SpanStatusCode2["ERROR"] = 2] = "ERROR";
-    })(SpanStatusCode || (SpanStatusCode = {}));
-  }
-});
-
 // node_modules/@opentelemetry/api/build/esm/platform/node/globalThis.js
 var _globalThis;
 var init_globalThis = __esm({
@@ -1295,6 +1283,18 @@ var init_span_kind = __esm({
   }
 });
 
+// node_modules/@opentelemetry/api/build/esm/trace/status.js
+var SpanStatusCode;
+var init_status = __esm({
+  "node_modules/@opentelemetry/api/build/esm/trace/status.js"() {
+    (function(SpanStatusCode2) {
+      SpanStatusCode2[SpanStatusCode2["UNSET"] = 0] = "UNSET";
+      SpanStatusCode2[SpanStatusCode2["OK"] = 1] = "OK";
+      SpanStatusCode2[SpanStatusCode2["ERROR"] = 2] = "ERROR";
+    })(SpanStatusCode || (SpanStatusCode = {}));
+  }
+});
+
 // node_modules/@opentelemetry/api/build/esm/trace/internal/tracestate-validators.js
 function validateKey(key) {
   return VALID_KEY_REGEX.test(key);
@@ -1652,6 +1652,7 @@ var init_esm = __esm({
 
 export {
   SpanStatusCode,
+  context,
   trace,
   esm_exports,
   init_esm

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

@@ -0,0 +1,278 @@
+
+      var require = await (async () => {
+        var { createRequire } = await import("node:module");
+        return createRequire(import.meta.url);
+      })();
+    
+import {
+  wrapTracer
+} from "./chunk-PDPDW32D.js";
+import {
+  init_esm,
+  trace
+} from "./chunk-Y3K5Q6FP.js";
+import {
+  require_out
+} from "./chunk-VZNKO4OO.js";
+import {
+  verifyNextVersion
+} from "./chunk-MGPEWDDD.js";
+import {
+  require_semver
+} from "./chunk-PJG75HGC.js";
+import {
+  RUN_CONFIG
+} from "./chunk-UYKENJEU.js";
+import {
+  __toESM
+} from "./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);
+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 {
+  copyNextServerCode,
+  getPatchesToApply,
+  copyNextDependencies,
+  writeTagsManifest,
+  verifyHandlerDirStructure
+};

package/dist/esm-chunks/{package-67C5TREY.js → package-NR7AMHPP.js}

@@ -8,7 +8,7 @@ import "./chunk-5JVNISGM.js";
 
 // package.json
 var name = "@netlify/plugin-nextjs";
-var version = "5.0.0-rc.5";
+var version = "5.0.0-rc.7";
 var description = "Run Next.js seamlessly on Netlify";
 var main = "./dist/index.js";
 var type = "module";
@@ -23,7 +23,7 @@ var engines = {
 var scripts = {
   prepack: "clean-package",
   postpack: "clean-package restore",
-  pretest: "node tests/prepare.mjs",
+  pretest: "npm run build && node tests/prepare.mjs",
   build: "node ./tools/build.js",
   "build:watch": "node ./tools/build.js --watch",
   lint: "eslint --cache --format=codeframe --max-warnings=0 --ext .ts,.cts,.js src",
@@ -60,7 +60,7 @@ var devDependencies = {
   "@netlify/functions": "^2.5.1",
   "@netlify/serverless-functions-api": "^1.10.1",
   "@netlify/zip-it-and-ship-it": "^9.30.0",
-  "@opentelemetry/api": "^1.7.0",
+  "@opentelemetry/api": "^1.8.0",
   "@opentelemetry/exporter-trace-otlp-http": "^0.49.0",
   "@opentelemetry/resources": "^1.21.0",
   "@opentelemetry/sdk-node": "^0.49.0",

package/dist/index.js

@@ -6,21 +6,28 @@
     
 import {
   copyPrerenderedContent
-} from "./esm-chunks/chunk-VSH4JS2L.js";
+} from "./esm-chunks/chunk-4635LKT6.js";
 import {
   copyStaticAssets,
   copyStaticContent,
   copyStaticExport,
   publishStaticDir,
   unpublishStaticDir
-} from "./esm-chunks/chunk-WFVNEURA.js";
+} from "./esm-chunks/chunk-GV3YIJ33.js";
 import {
   createEdgeHandlers
 } from "./esm-chunks/chunk-OBKVBMAL.js";
 import {
   createServerHandler
-} from "./esm-chunks/chunk-W7XTKMHH.js";
-import "./esm-chunks/chunk-CSTSA3JJ.js";
+} from "./esm-chunks/chunk-757FQQND.js";
+import "./esm-chunks/chunk-YSGPGDIG.js";
+import {
+  wrapTracer
+} from "./esm-chunks/chunk-PDPDW32D.js";
+import {
+  init_esm,
+  trace
+} from "./esm-chunks/chunk-Y3K5Q6FP.js";
 import "./esm-chunks/chunk-VZNKO4OO.js";
 import {
   restoreBuildCache,
@@ -42,43 +49,56 @@ import "./esm-chunks/chunk-TYCYFZ22.js";
 import "./esm-chunks/chunk-5JVNISGM.js";
 
 // src/index.ts
+init_esm();
+var tracer = wrapTracer(trace.getTracer("Next.js runtime"));
 var onPreBuild = async (options) => {
-  process.env.NEXT_PRIVATE_STANDALONE = "true";
-  if (!options.constants.IS_LOCAL) {
-    await restoreBuildCache(new PluginContext(options));
-  }
+  await tracer.withActiveSpan("onPreBuild", async () => {
+    process.env.NEXT_PRIVATE_STANDALONE = "true";
+    if (!options.constants.IS_LOCAL) {
+      await restoreBuildCache(new PluginContext(options));
+    }
+  });
 };
 var onBuild = async (options) => {
-  const ctx = new PluginContext(options);
-  verifyPublishDir(ctx);
-  verifyBuildConfig(ctx);
-  if (!options.constants.IS_LOCAL) {
-    await saveBuildCache(ctx);
-  }
-  if (ctx.buildConfig.output === "export") {
-    return copyStaticExport(ctx);
-  }
-  await Promise.all([
-    copyStaticAssets(ctx),
-    copyStaticContent(ctx),
-    copyPrerenderedContent(ctx),
-    createServerHandler(ctx),
-    createEdgeHandlers(ctx),
-    setImageConfig(ctx)
-  ]);
+  await tracer.withActiveSpan("onBuild", async (span) => {
+    const ctx = new PluginContext(options);
+    verifyPublishDir(ctx);
+    verifyBuildConfig(ctx);
+    span.setAttribute("next.buildConfig", JSON.stringify(ctx.buildConfig));
+    if (!options.constants.IS_LOCAL) {
+      await saveBuildCache(ctx);
+    }
+    if (ctx.buildConfig.output === "export") {
+      return copyStaticExport(ctx);
+    }
+    await Promise.all([
+      copyStaticAssets(ctx),
+      copyStaticContent(ctx),
+      copyPrerenderedContent(ctx),
+      createServerHandler(ctx),
+      createEdgeHandlers(ctx),
+      setImageConfig(ctx)
+    ]);
+  });
 };
 var onPostBuild = async (options) => {
-  await publishStaticDir(new PluginContext(options));
+  await tracer.withActiveSpan("onPostBuild", async () => {
+    await publishStaticDir(new PluginContext(options));
+  });
 };
 var onSuccess = async () => {
-  const prewarm = [process.env.DEPLOY_URL, process.env.DEPLOY_PRIME_URL, process.env.URL].filter(
-    // If running locally then the deploy ID is a placeholder value. Filtering for `https://0--` removes it.
-    (url) => Boolean(url && !url.startsWith("https://0--"))
-  );
-  await Promise.allSettled(prewarm.map((url) => fetch(url)));
+  await tracer.withActiveSpan("onSuccess", async () => {
+    const prewarm = [process.env.DEPLOY_URL, process.env.DEPLOY_PRIME_URL, process.env.URL].filter(
+      // If running locally then the deploy ID is a placeholder value. Filtering for `https://0--` removes it.
+      (url) => Boolean(url && !url.startsWith("https://0--"))
+    );
+    await Promise.allSettled(prewarm.map((url) => fetch(url)));
+  });
 };
 var onEnd = async (options) => {
-  await unpublishStaticDir(new PluginContext(options));
+  await tracer.withActiveSpan("onEnd", async () => {
+    await unpublishStaticDir(new PluginContext(options));
+  });
 };
 export {
   onBuild,