cdk-nextjs 0.7.0 → 0.7.1

package/lib/runtime/lambda.mjs

@@ -40020,6 +40020,10 @@ function useNextFrom(projectDir) {
 function setupNodeEnvironment() {
   nextModule("next/dist/build/adapter/setup-node-env.external.js");
 }
+async function registerInstrumentation(projectDir, distDir) {
+  const { ensureInstrumentationRegistered } = nextModule("next/dist/server/lib/router-utils/instrumentation-globals.external.js");
+  await ensureInstrumentationRegistered(projectDir, distDir);
+}
 function loadEnvFiles(projectDir) {
   const nextEnvRequire = createRequire2(nextModuleResolve("next/package.json"));
   const { loadEnvConfig } = nextEnvRequire("@next/env");
@@ -41264,6 +41268,7 @@ async function loadRuntime(deploymentRoot) {
   useNextFrom(projectDir);
   loadEnvFiles(projectDir);
   setupNodeEnvironment();
+  await registerInstrumentation(projectDir, manifest.config.distDir);
   return new NextjsRuntime({
     deploymentRoot,
     manifest,

package/lib/runtime/next-modules.d.ts

@@ -33,6 +33,22 @@ export declare function useNextFrom(projectDir: string): void;
  * more than once is harmless.
  */
 export declare function setupNodeEnvironment(): void;
+/**
+ * Run the app's `instrumentation.register()` to completion, the way `next start`
+ * does in `NextNodeServer.prepareImpl()` before it loads any page or middleware.
+ *
+ * The built entrypoints and middleware do call this themselves, but only inside
+ * their `handler` — after the module, and everything it imports, has already
+ * been evaluated. So module-scope code (an auth client built from an env var
+ * `register()` fetches from Secrets Manager, say) would otherwise run first.
+ *
+ * Next memoizes the registration in this module, so the entrypoints' later
+ * calls await the same promise rather than registering again. That also makes
+ * this call's arguments the ones that count: `distDir` relative to `projectDir`,
+ * as `RouteModule.prepare()` passes it. An app with no instrumentation file is
+ * a no-op.
+ */
+export declare function registerInstrumentation(projectDir: string, distDir: string): Promise<void>;
 /**
  * Load the staged `.env` / `.env.production` into `process.env`, the way
  * `NextNodeServer` does when `next start` constructs it. Nothing else would:

package/lib/runtime/next-modules.js

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.useNextFrom = useNextFrom;
 exports.setupNodeEnvironment = setupNodeEnvironment;
+exports.registerInstrumentation = registerInstrumentation;
 exports.loadEnvFiles = loadEnvFiles;
 exports.nextModule = nextModule;
 /**
@@ -73,6 +74,25 @@ function useNextFrom(projectDir) {
 function setupNodeEnvironment() {
     nextModule("next/dist/build/adapter/setup-node-env.external.js");
 }
+/**
+ * Run the app's `instrumentation.register()` to completion, the way `next start`
+ * does in `NextNodeServer.prepareImpl()` before it loads any page or middleware.
+ *
+ * The built entrypoints and middleware do call this themselves, but only inside
+ * their `handler` — after the module, and everything it imports, has already
+ * been evaluated. So module-scope code (an auth client built from an env var
+ * `register()` fetches from Secrets Manager, say) would otherwise run first.
+ *
+ * Next memoizes the registration in this module, so the entrypoints' later
+ * calls await the same promise rather than registering again. That also makes
+ * this call's arguments the ones that count: `distDir` relative to `projectDir`,
+ * as `RouteModule.prepare()` passes it. An app with no instrumentation file is
+ * a no-op.
+ */
+async function registerInstrumentation(projectDir, distDir) {
+    const { ensureInstrumentationRegistered } = nextModule("next/dist/server/lib/router-utils/instrumentation-globals.external.js");
+    await ensureInstrumentationRegistered(projectDir, distDir);
+}
 /**
  * Load the staged `.env` / `.env.production` into `process.env`, the way
  * `NextNodeServer` does when `next start` constructs it. Nothing else would:
@@ -121,4 +141,4 @@ function nextModule(specifier) {
             `target that was not staged.`, { cause });
     }
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"next-modules.js","sourceRoot":"","sources":["../../src/runtime/next-modules.ts"],"names":[],"mappings":";;AAqCA,kCAIC;AA4BD,oDAEC;AAcD,oCAOC;AA0BD,gCAaC;AAnID;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,6CAA4C;AAC5C,yCAAiC;AAEjC,IAAI,WAAyD,CAAC;AAE9D;;;;;;GAMG;AACH,SAAgB,WAAW,CAAC,UAAkB;IAC5C,+EAA+E;IAC/E,yEAAyE;IACzE,WAAW,GAAG,IAAA,2BAAa,EAAC,IAAA,gBAAI,EAAC,UAAU,EAAE,8BAA8B,CAAC,CAAC,CAAC;AAChF,CAAC;AAED;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,SAAgB,oBAAoB;IAClC,UAAU,CAAC,oDAAoD,CAAC,CAAC;AACnE,CAAC;AAED;;;;;;;;;;;GAWG;AACH,SAAgB,YAAY,CAAC,UAAkB;IAC7C,MAAM,cAAc,GAAG,IAAA,2BAAa,EAAC,iBAAiB,CAAC,mBAAmB,CAAC,CAAC,CAAC;IAC7E,gFAAgF;IAChF,MAAM,EAAE,aAAa,EAAE,GAAG,cAAc,CAAC,WAAW,CAEnD,CAAC;IACF,aAAa,CAAC,UAAU,EAAE,KAAK,CAAC,CAAC;AACnC,CAAC;AAED,SAAS,iBAAiB,CAAC,SAAiB;IAC1C,OAAO,kBAAkB,CAAC,SAAS,CAAC,CAAC,OAAO,CAAC,SAAS,CAAC,CAAC;AAC1D,CAAC;AAED,SAAS,kBAAkB,CACzB,SAAiB;IAEjB,IAAI,CAAC,WAAW,EAAE,CAAC;QACjB,MAAM,IAAI,KAAK,CACb,gBAAgB,SAAS,iDAAiD;YACxE,uEAAuE;YACvE,qEAAqE;YACrE,SAAS,CACZ,CAAC;IACJ,CAAC;IACD,OAAO,WAAW,CAAC;AACrB,CAAC;AAED;;;;;GAKG;AACH,SAAgB,UAAU,CAAI,SAAiB;IAC7C,MAAM,IAAI,GAAG,kBAAkB,CAAC,SAAS,CAAC,CAAC;IAC3C,IAAI,CAAC;QACH,OAAO,IAAI,CAAC,SAAS,CAAM,CAAC;IAC9B,CAAC;IAAC,OAAO,KAAK,EAAE,CAAC;QACf,MAAM,IAAI,KAAK,CACb,sBAAsB,SAAS,2CAA2C;YACxE,kEAAkE;YAClE,wEAAwE;YACxE,6BAA6B,EAC/B,EAAE,KAAK,EAAE,CACV,CAAC;IACJ,CAAC;AACH,CAAC","sourcesContent":["/**\n * Resolving the handful of `next` internals the runtime itself needs, out of the\n * staged app rather than from next to the shell.\n *\n * `next` is deliberately external to both shell bundles: the deployment already\n * carries the traced `next` files every built entrypoint requires, and a second\n * bundled copy would be a different module instance — pinned to *cdk-nextjs's*\n * `next` version rather than the consumer's.\n *\n * Marking it external is not enough on its own. esbuild turns\n * `import { serveStatic } from \"next/dist/server/serve-static.js\"` into a real,\n * hoisted `import` inside `cdk-nextjs-runtime/lambda.mjs`, which Node resolves by\n * walking `cdk-nextjs-runtime/node_modules` and then `<deploymentRoot>/node_modules`\n * — and under pnpm neither holds `next`. The only `next` in the staged tree is the\n * relative symlink at `<projectDir>/node_modules/next` that the traced entrypoints\n * resolve through, one directory *below* the deployment root. A hoisted npm/yarn\n * monorepo puts it somewhere else again. Since those imports are hoisted, getting\n * this wrong is not a degraded image route: the shell fails to load at all.\n *\n * So every such module is required through a `createRequire` anchored inside the\n * staged project dir, which makes the runtime resolve `next` by the same walk the\n * entrypoints do, for any package manager and any layout. That also means they\n * cannot be imported at module scope; each caller resolves (and memoizes) on\n * first use, after {@link useNextFrom}.\n */\nimport { createRequire } from \"node:module\";\nimport { join } from \"node:path\";\n\nlet nextRequire: ReturnType<typeof createRequire> | undefined;\n\n/**\n * Point `next` resolution at the staged Next.js project. Called once by\n * `loadRuntime`, before anything can serve a request.\n *\n * @param projectDir absolute path to the staged project dir\n * (`join(deploymentRoot, manifest.relativeProjectDir)`).\n */\nexport function useNextFrom(projectDir: string): void {\n  // Anchored on a path *inside* `projectDir`, because `createRequire` starts its\n  // `node_modules` walk at the anchor's directory. The file needn't exist.\n  nextRequire = createRequire(join(projectDir, \"cdk-nextjs-next-resolver.cjs\"));\n}\n\n/**\n * The bootstrap Next.js exposes for adapters — \"can be used to ensure Node.js\n * APIs are setup as expected without requiring `next-server`\", in its own words.\n * It installs the globals, the `react`/`react-dom` require hook, and the\n * `console`/`Error`/`Date`/crypto extensions that `next start` installs before it\n * loads any route.\n *\n * Its most load-bearing effect is `globalThis.AsyncLocalStorage`, which\n * `next/dist/server/app-render/async-local-storage.js` reads *at module scope* —\n * whatever is loaded first wins, permanently.\n *\n * Without this, `next/dist/compiled/next-server/app-page-turbo.runtime.prod.js`\n * requires `work-async-storage.external.js` before its own\n * `route-module.js` gets to the bootstrap, and the app-render storage is created\n * as Next's `FakeAsyncLocalStorage`, which throws \"Invariant: AsyncLocalStorage\n * accessed in runtime where it is not available\" on the first dynamic render.\n *\n * It is easy to miss, because an app with middleware is accidentally fine:\n * `next/dist/build/templates/middleware.js` requires the same bootstrap, and the\n * runtime runs middleware before it loads a page entrypoint. Only an app with no\n * middleware — and only on a dynamic app-page render — reaches the invariant.\n *\n * `next/dist/build/adapter/setup-node-env.external.js` is side-effect-only and\n * idempotent (`node-environment.js` guards its own re-entry), so calling this\n * more than once is harmless.\n */\nexport function setupNodeEnvironment(): void {\n  nextModule(\"next/dist/build/adapter/setup-node-env.external.js\");\n}\n\n/**\n * Load the staged `.env` / `.env.production` into `process.env`, the way\n * `NextNodeServer` does when `next start` constructs it. Nothing else would:\n * the built entrypoints never call `loadEnvConfig`, and the runtime builds no\n * `NextNodeServer`.\n *\n * Same semantics as `next start` because it is the same function — variables\n * already in `process.env` (the Lambda or task environment) win over the files.\n * `@next/env` is a dependency of `next`, not of the app, so it is resolved from\n * `next`'s own directory; the adapter stages it on that basis\n * (`addRuntimeNextClosure`).\n */\nexport function loadEnvFiles(projectDir: string): void {\n  const nextEnvRequire = createRequire(nextModuleResolve(\"next/package.json\"));\n  // Typed locally: `@next/env` is `next`'s dependency, not a resolvable one here.\n  const { loadEnvConfig } = nextEnvRequire(\"@next/env\") as {\n    loadEnvConfig: (dir: string, dev?: boolean) => unknown;\n  };\n  loadEnvConfig(projectDir, false);\n}\n\nfunction nextModuleResolve(specifier: string): string {\n  return nextRequireOrThrow(specifier).resolve(specifier);\n}\n\nfunction nextRequireOrThrow(\n  specifier: string,\n): ReturnType<typeof createRequire> {\n  if (!nextRequire) {\n    throw new Error(\n      `Cannot load \"${specifier}\": \\`next\\` resolution has not been pointed at ` +\n        `the staged app yet. \\`useNextFrom\\` runs in \\`loadRuntime\\`, so this ` +\n        `means runtime code loaded a \\`next\\` module before the runtime was ` +\n        `loaded.`,\n    );\n  }\n  return nextRequire;\n}\n\n/**\n * `require` a `next` submodule from the staged app.\n *\n * Pass the module's own type — `nextModule<typeof import(\"next/dist/...\")>(...)` —\n * so the call is as type-checked as a static import would be.\n */\nexport function nextModule<T>(specifier: string): T {\n  const load = nextRequireOrThrow(specifier);\n  try {\n    return load(specifier) as T;\n  } catch (cause) {\n    throw new Error(\n      `Could not resolve \"${specifier}\" from the deployed Next.js project. The ` +\n        `deployment package is missing part of the \\`next\\` closure that ` +\n        `\\`next build\\` traced, or \\`node_modules/next\\` resolves to a symlink ` +\n        `target that was not staged.`,\n      { cause },\n    );\n  }\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"next-modules.js","sourceRoot":"","sources":["../../src/runtime/next-modules.ts"],"names":[],"mappings":";;AAqCA,kCAIC;AA4BD,oDAEC;AAiBD,0DAQC;AAcD,oCAOC;AA0BD,gCAaC;AA5JD;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,6CAA4C;AAC5C,yCAAiC;AAEjC,IAAI,WAAyD,CAAC;AAE9D;;;;;;GAMG;AACH,SAAgB,WAAW,CAAC,UAAkB;IAC5C,+EAA+E;IAC/E,yEAAyE;IACzE,WAAW,GAAG,IAAA,2BAAa,EAAC,IAAA,gBAAI,EAAC,UAAU,EAAE,8BAA8B,CAAC,CAAC,CAAC;AAChF,CAAC;AAED;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,SAAgB,oBAAoB;IAClC,UAAU,CAAC,oDAAoD,CAAC,CAAC;AACnE,CAAC;AAED;;;;;;;;;;;;;;GAcG;AACI,KAAK,UAAU,uBAAuB,CAC3C,UAAkB,EAClB,OAAe;IAEf,MAAM,EAAE,+BAA+B,EAAE,GAAG,UAAU,CAEpD,uEAAuE,CAAC,CAAC;IAC3E,MAAM,+BAA+B,CAAC,UAAU,EAAE,OAAO,CAAC,CAAC;AAC7D,CAAC;AAED;;;;;;;;;;;GAWG;AACH,SAAgB,YAAY,CAAC,UAAkB;IAC7C,MAAM,cAAc,GAAG,IAAA,2BAAa,EAAC,iBAAiB,CAAC,mBAAmB,CAAC,CAAC,CAAC;IAC7E,gFAAgF;IAChF,MAAM,EAAE,aAAa,EAAE,GAAG,cAAc,CAAC,WAAW,CAEnD,CAAC;IACF,aAAa,CAAC,UAAU,EAAE,KAAK,CAAC,CAAC;AACnC,CAAC;AAED,SAAS,iBAAiB,CAAC,SAAiB;IAC1C,OAAO,kBAAkB,CAAC,SAAS,CAAC,CAAC,OAAO,CAAC,SAAS,CAAC,CAAC;AAC1D,CAAC;AAED,SAAS,kBAAkB,CACzB,SAAiB;IAEjB,IAAI,CAAC,WAAW,EAAE,CAAC;QACjB,MAAM,IAAI,KAAK,CACb,gBAAgB,SAAS,iDAAiD;YACxE,uEAAuE;YACvE,qEAAqE;YACrE,SAAS,CACZ,CAAC;IACJ,CAAC;IACD,OAAO,WAAW,CAAC;AACrB,CAAC;AAED;;;;;GAKG;AACH,SAAgB,UAAU,CAAI,SAAiB;IAC7C,MAAM,IAAI,GAAG,kBAAkB,CAAC,SAAS,CAAC,CAAC;IAC3C,IAAI,CAAC;QACH,OAAO,IAAI,CAAC,SAAS,CAAM,CAAC;IAC9B,CAAC;IAAC,OAAO,KAAK,EAAE,CAAC;QACf,MAAM,IAAI,KAAK,CACb,sBAAsB,SAAS,2CAA2C;YACxE,kEAAkE;YAClE,wEAAwE;YACxE,6BAA6B,EAC/B,EAAE,KAAK,EAAE,CACV,CAAC;IACJ,CAAC;AACH,CAAC","sourcesContent":["/**\n * Resolving the handful of `next` internals the runtime itself needs, out of the\n * staged app rather than from next to the shell.\n *\n * `next` is deliberately external to both shell bundles: the deployment already\n * carries the traced `next` files every built entrypoint requires, and a second\n * bundled copy would be a different module instance — pinned to *cdk-nextjs's*\n * `next` version rather than the consumer's.\n *\n * Marking it external is not enough on its own. esbuild turns\n * `import { serveStatic } from \"next/dist/server/serve-static.js\"` into a real,\n * hoisted `import` inside `cdk-nextjs-runtime/lambda.mjs`, which Node resolves by\n * walking `cdk-nextjs-runtime/node_modules` and then `<deploymentRoot>/node_modules`\n * — and under pnpm neither holds `next`. The only `next` in the staged tree is the\n * relative symlink at `<projectDir>/node_modules/next` that the traced entrypoints\n * resolve through, one directory *below* the deployment root. A hoisted npm/yarn\n * monorepo puts it somewhere else again. Since those imports are hoisted, getting\n * this wrong is not a degraded image route: the shell fails to load at all.\n *\n * So every such module is required through a `createRequire` anchored inside the\n * staged project dir, which makes the runtime resolve `next` by the same walk the\n * entrypoints do, for any package manager and any layout. That also means they\n * cannot be imported at module scope; each caller resolves (and memoizes) on\n * first use, after {@link useNextFrom}.\n */\nimport { createRequire } from \"node:module\";\nimport { join } from \"node:path\";\n\nlet nextRequire: ReturnType<typeof createRequire> | undefined;\n\n/**\n * Point `next` resolution at the staged Next.js project. Called once by\n * `loadRuntime`, before anything can serve a request.\n *\n * @param projectDir absolute path to the staged project dir\n * (`join(deploymentRoot, manifest.relativeProjectDir)`).\n */\nexport function useNextFrom(projectDir: string): void {\n  // Anchored on a path *inside* `projectDir`, because `createRequire` starts its\n  // `node_modules` walk at the anchor's directory. The file needn't exist.\n  nextRequire = createRequire(join(projectDir, \"cdk-nextjs-next-resolver.cjs\"));\n}\n\n/**\n * The bootstrap Next.js exposes for adapters — \"can be used to ensure Node.js\n * APIs are setup as expected without requiring `next-server`\", in its own words.\n * It installs the globals, the `react`/`react-dom` require hook, and the\n * `console`/`Error`/`Date`/crypto extensions that `next start` installs before it\n * loads any route.\n *\n * Its most load-bearing effect is `globalThis.AsyncLocalStorage`, which\n * `next/dist/server/app-render/async-local-storage.js` reads *at module scope* —\n * whatever is loaded first wins, permanently.\n *\n * Without this, `next/dist/compiled/next-server/app-page-turbo.runtime.prod.js`\n * requires `work-async-storage.external.js` before its own\n * `route-module.js` gets to the bootstrap, and the app-render storage is created\n * as Next's `FakeAsyncLocalStorage`, which throws \"Invariant: AsyncLocalStorage\n * accessed in runtime where it is not available\" on the first dynamic render.\n *\n * It is easy to miss, because an app with middleware is accidentally fine:\n * `next/dist/build/templates/middleware.js` requires the same bootstrap, and the\n * runtime runs middleware before it loads a page entrypoint. Only an app with no\n * middleware — and only on a dynamic app-page render — reaches the invariant.\n *\n * `next/dist/build/adapter/setup-node-env.external.js` is side-effect-only and\n * idempotent (`node-environment.js` guards its own re-entry), so calling this\n * more than once is harmless.\n */\nexport function setupNodeEnvironment(): void {\n  nextModule(\"next/dist/build/adapter/setup-node-env.external.js\");\n}\n\n/**\n * Run the app's `instrumentation.register()` to completion, the way `next start`\n * does in `NextNodeServer.prepareImpl()` before it loads any page or middleware.\n *\n * The built entrypoints and middleware do call this themselves, but only inside\n * their `handler` — after the module, and everything it imports, has already\n * been evaluated. So module-scope code (an auth client built from an env var\n * `register()` fetches from Secrets Manager, say) would otherwise run first.\n *\n * Next memoizes the registration in this module, so the entrypoints' later\n * calls await the same promise rather than registering again. That also makes\n * this call's arguments the ones that count: `distDir` relative to `projectDir`,\n * as `RouteModule.prepare()` passes it. An app with no instrumentation file is\n * a no-op.\n */\nexport async function registerInstrumentation(\n  projectDir: string,\n  distDir: string,\n): Promise<void> {\n  const { ensureInstrumentationRegistered } = nextModule<\n    typeof import(\"next/dist/server/lib/router-utils/instrumentation-globals.external.js\")\n  >(\"next/dist/server/lib/router-utils/instrumentation-globals.external.js\");\n  await ensureInstrumentationRegistered(projectDir, distDir);\n}\n\n/**\n * Load the staged `.env` / `.env.production` into `process.env`, the way\n * `NextNodeServer` does when `next start` constructs it. Nothing else would:\n * the built entrypoints never call `loadEnvConfig`, and the runtime builds no\n * `NextNodeServer`.\n *\n * Same semantics as `next start` because it is the same function — variables\n * already in `process.env` (the Lambda or task environment) win over the files.\n * `@next/env` is a dependency of `next`, not of the app, so it is resolved from\n * `next`'s own directory; the adapter stages it on that basis\n * (`addRuntimeNextClosure`).\n */\nexport function loadEnvFiles(projectDir: string): void {\n  const nextEnvRequire = createRequire(nextModuleResolve(\"next/package.json\"));\n  // Typed locally: `@next/env` is `next`'s dependency, not a resolvable one here.\n  const { loadEnvConfig } = nextEnvRequire(\"@next/env\") as {\n    loadEnvConfig: (dir: string, dev?: boolean) => unknown;\n  };\n  loadEnvConfig(projectDir, false);\n}\n\nfunction nextModuleResolve(specifier: string): string {\n  return nextRequireOrThrow(specifier).resolve(specifier);\n}\n\nfunction nextRequireOrThrow(\n  specifier: string,\n): ReturnType<typeof createRequire> {\n  if (!nextRequire) {\n    throw new Error(\n      `Cannot load \"${specifier}\": \\`next\\` resolution has not been pointed at ` +\n        `the staged app yet. \\`useNextFrom\\` runs in \\`loadRuntime\\`, so this ` +\n        `means runtime code loaded a \\`next\\` module before the runtime was ` +\n        `loaded.`,\n    );\n  }\n  return nextRequire;\n}\n\n/**\n * `require` a `next` submodule from the staged app.\n *\n * Pass the module's own type — `nextModule<typeof import(\"next/dist/...\")>(...)` —\n * so the call is as type-checked as a static import would be.\n */\nexport function nextModule<T>(specifier: string): T {\n  const load = nextRequireOrThrow(specifier);\n  try {\n    return load(specifier) as T;\n  } catch (cause) {\n    throw new Error(\n      `Could not resolve \"${specifier}\" from the deployed Next.js project. The ` +\n        `deployment package is missing part of the \\`next\\` closure that ` +\n        `\\`next build\\` traced, or \\`node_modules/next\\` resolves to a symlink ` +\n        `target that was not staged.`,\n      { cause },\n    );\n  }\n}\n"]}

package/lib/runtime/server.mjs

@@ -40020,6 +40020,10 @@ function useNextFrom(projectDir) {
 function setupNodeEnvironment() {
   nextModule("next/dist/build/adapter/setup-node-env.external.js");
 }
+async function registerInstrumentation(projectDir, distDir) {
+  const { ensureInstrumentationRegistered } = nextModule("next/dist/server/lib/router-utils/instrumentation-globals.external.js");
+  await ensureInstrumentationRegistered(projectDir, distDir);
+}
 function loadEnvFiles(projectDir) {
   const nextEnvRequire = createRequire2(nextModuleResolve("next/package.json"));
   const { loadEnvConfig } = nextEnvRequire("@next/env");
@@ -41264,6 +41268,7 @@ async function loadRuntime(deploymentRoot) {
   useNextFrom(projectDir);
   loadEnvFiles(projectDir);
   setupNodeEnvironment();
+  await registerInstrumentation(projectDir, manifest.config.distDir);
   return new NextjsRuntime({
     deploymentRoot,
     manifest,

package/package.json

@@ -84,7 +84,7 @@
   "publishConfig": {
     "access": "public"
   },
-  "version": "0.7.0",
+  "version": "0.7.1",
   "jest": {
     "coverageProvider": "v8",
     "testPathIgnorePatterns": [