fix(nuxt): Chain Nuxt 5 server source maps to the original sources

Nitro 3 bundles the output of Nuxt 5's ssr build (.nuxt/vite/services/ssr)
again, but loads it without the .map files next to it. So server stack
frames stop at that output instead of the .vue and .ts files.

Nuxt's own SourcemapPreserverPlugin does not chain the maps when Nitro
builds as a Vite environment. Until Nuxt fixes this, return each service
chunk together with its map from a load hook in the Nitro build.

Fixes #25323

Author: s1gr1d

dev-packages/e2e-tests/test-applications/nuxt-5-sourcemaps/assert-build.ts

@@ -12,6 +12,7 @@ import {
   getAssembleRequests,
   getChunkUploadPosts,
   getDebugIdPairs,
+  getSourcemapSources,
   getSourcemaps,
   loadMockServerResults,
   startNodeServer,
@@ -234,14 +235,18 @@ for (const outputDir of isStaticBuild ? [CLIENT_OUTPUT] : [CLIENT_OUTPUT, SERVER
 const conflictingDebugIds = findDebugIdsWithConflictingSourcemaps(sourcemaps);
 assert.deepEqual(conflictingDebugIds, [], 'Expected every uploaded debug ID to resolve to exactly one source map');
 
-// TODO: Nitro 3 bundles the SSR build's output again, but its maps stop at that output
-// (`.nuxt/vite/services/ssr/...`) and do not chain to the SSR build's own maps. So server frames do not reach
-// `.vue` files. Assert this when the server maps reach the original sources:
-// const serverDebugIds = new Set(findInjectedDebugIds({ outputDir: SERVER_OUTPUT }));
-// const serverSources = sourcemaps
-//   .filter(map => map.debugId && serverDebugIds.has(map.debugId))
-//   .flatMap(map => getSourcemapSources(map.sourcemap));
-// assert.ok(serverSources.some(source => source.endsWith('app/pages/index.vue')));
+if (!isStaticBuild) {
+  // Nitro bundles the output of the SSR build (`.nuxt/vite/services/ssr`) again, so server frames reach `.vue`
+  // files only through the maps of that build.
+  const serverDebugIds = new Set(findInjectedDebugIds({ outputDir: SERVER_OUTPUT }));
+  const serverSources = sourcemaps
+    .filter(map => map.debugId && serverDebugIds.has(map.debugId))
+    .flatMap(map => getSourcemapSources(map.sourcemap));
+  assert.ok(
+    serverSources.some(source => source.endsWith('app/pages/index.vue')),
+    `Expected the server source maps to resolve to app/pages/index.vue, got: ${serverSources.join(', ')}`,
+  );
+}
 console.log('');
 
 // --- What the build leaves behind in the client output ---

packages/nuxt/src/vite/serviceSourceMaps.ts

@@ -0,0 +1,29 @@
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import type { Plugin } from 'rollup';
+import { isInDirectory } from './utils';
+
+/**
+ * Nitro 3 bundles the output of its Vite services, like Nuxt 5's `ssr` build, again. It loads that output without the
+ * `.map` files next to it, so the server source maps stop at the output instead of the original source files.
+ * Returning the map from `load` lets the bundler chain both maps.
+ *
+ * Nuxt's own `SourcemapPreserverPlugin` does this only when Nitro does not build as a Vite environment.
+ */
+export function serviceSourceMapsPlugin(buildDir: string): Plugin {
+  const servicesDir = path.join(buildDir, 'vite', 'services');
+
+  return {
+    name: 'sentry-nuxt-service-source-maps',
+    async load(id) {
+      const mapFile = `${id}.map`;
+      // Rolldown emits no map for a chunk without mappable source.
+      if (!isInDirectory(id, servicesDir) || !fs.existsSync(mapFile)) {
+        return null;
+      }
+
+      const [code, map] = await Promise.all([fs.promises.readFile(id, 'utf8'), fs.promises.readFile(mapFile, 'utf8')]);
+      return { code, map };
+    },
+  };
+}

packages/nuxt/src/vite/sourceMapDeletion.ts

@@ -1,6 +1,6 @@
 import { createSentryBuildPluginManager, globFiles, type Options } from '@sentry/bundler-plugins/core';
 import * as fs from 'node:fs';
-import * as path from 'node:path';
+import { isInDirectory } from './utils';
 
 export function withoutSourceMapDeletion(options: Options): Options {
   return {
@@ -64,13 +64,3 @@ function logDebug(options: Options, ...messages: unknown[]): void {
     console.log('[Sentry]', ...messages);
   }
 }
-
-function isInDirectory(file: string, directory: string): boolean {
-  const relativePath = path.relative(directory, file);
-  return (
-    relativePath !== '' &&
-    relativePath !== '..' &&
-    !relativePath.startsWith(`..${path.sep}`) &&
-    !path.isAbsolute(relativePath)
-  );
-}

packages/nuxt/src/vite/sourceMaps.ts

@@ -7,6 +7,7 @@ import type { Plugin } from 'vite';
 import type { SentryNuxtModuleOptions } from '../common/types';
 import { deletePublicSourceMaps, deleteSourceMapsAfterBuild, withoutSourceMapDeletion } from './sourceMapDeletion';
 import { validateSourceMapsOptionsPlugin } from './sentryVitePlugin';
+import { serviceSourceMapsPlugin } from './serviceSourceMaps';
 
 /**
  * Whether the user enabled (true, 'hidden', 'inline') or disabled (false) source maps
@@ -107,6 +108,7 @@ export function setupSourceMaps(
       // Add Sentry plugin
       // Runs only on server-side (Nitro)
       nitroConfig.rollupConfig.plugins.push(
+        serviceSourceMapsPlugin(nuxt.options.buildDir),
         sentryRollupPlugin(withoutSourceMapDeletion(getPluginOptions(moduleOptions, shouldDeleteFilesFallback))),
       );
     }

packages/nuxt/src/vite/utils.ts

@@ -66,6 +66,17 @@ export function toImportSpecifier(fromDir: string, filePath: string): string {
   return `./${path.relative(fromDir, filePath).split(/[\\/]/).join('/')}`;
 }
 
+/** Whether `file` is inside `directory`. `directory` itself does not count. */
+export function isInDirectory(file: string, directory: string): boolean {
+  const relativePath = path.relative(directory, file);
+  return (
+    relativePath !== '' &&
+    relativePath !== '..' &&
+    !relativePath.startsWith(`..${path.sep}`) &&
+    !path.isAbsolute(relativePath)
+  );
+}
+
 /**
  *  Extracts the filename from a node command with a path.
  */

packages/nuxt/test/vite/serviceSourceMaps.test.ts

@@ -0,0 +1,55 @@
+import * as fs from 'fs';
+import * as os from 'os';
+import * as path from 'path';
+import type { PluginContext } from 'rollup';
+import { afterEach, beforeEach, describe, expect, it } from 'vitest';
+import { serviceSourceMapsPlugin } from '../../src/vite/serviceSourceMaps';
+
+const CODE = 'export default 1;\n';
+const MAP = '{"version":3,"sources":["../../../../app/pages/index.vue"],"mappings":"AAAA"}';
+
+let buildDir: string;
+
+function writeFile(file: string, content: string): string {
+  fs.mkdirSync(path.dirname(file), { recursive: true });
+  fs.writeFileSync(file, content);
+  return file;
+}
+
+function load(id: string): unknown {
+  const { load } = serviceSourceMapsPlugin(buildDir);
+  if (typeof load !== 'function') {
+    throw new Error('Expected `load` to be a function');
+  }
+  return load.call({} as PluginContext, id);
+}
+
+describe('serviceSourceMapsPlugin', () => {
+  beforeEach(() => {
+    buildDir = fs.mkdtempSync(path.join(os.tmpdir(), 'sentry-nuxt-service-source-maps-'));
+  });
+
+  afterEach(() => {
+    fs.rmSync(buildDir, { recursive: true, force: true });
+  });
+
+  it('loads a service chunk together with its source map', async () => {
+    const chunk = writeFile(path.join(buildDir, 'vite', 'services', 'ssr', '_nuxt', 'pages.js'), CODE);
+    writeFile(`${chunk}.map`, MAP);
+
+    expect(await load(chunk)).toEqual({ code: CODE, map: MAP });
+  });
+
+  it('leaves a service chunk without a source map to the default loader', async () => {
+    const chunk = writeFile(path.join(buildDir, 'vite', 'services', 'ssr', '_nuxt', 'export-helper.js'), CODE);
+
+    expect(await load(chunk)).toBeNull();
+  });
+
+  it('leaves files outside the service output to the default loader', async () => {
+    const file = writeFile(path.join(buildDir, 'sentry-runtime-flags.mjs'), CODE);
+    writeFile(`${file}.map`, MAP);
+
+    expect(await load(file)).toBeNull();
+  });
+});

packages/nuxt/test/vite/sourceMaps-nuxtHooks.test.ts

@@ -54,6 +54,7 @@ function createMockNuxt(options: {
       _prepare: options._prepare ?? false,
       dev: options.dev ?? false,
       sourcemap: options.sourcemap ?? { server: undefined, client: undefined },
+      buildDir: path.join(os.tmpdir(), '.nuxt'),
     },
     hook: (name: string, callback: HookCallback) => {
       hooks[name] = hooks[name] || [];
@@ -355,6 +356,22 @@ describe('setupSourceMaps hooks', () => {
       expect(nitroConfig.rollupConfig.plugins.length).toBeGreaterThan(0);
     });
 
+    it('loads the source maps of the Vite service output in the Nitro build', async () => {
+      const mockNuxt = createMockNuxt({ _prepare: false, dev: false });
+      const { mockAddVitePlugin } = createMockAddVitePlugin();
+
+      setupSourceMaps({}, mockNuxt as unknown as Nuxt, mockAddVitePlugin);
+      await mockNuxt.triggerHook('modules:done');
+
+      const nitroConfig = { rollupConfig: { plugins: [] as { name: string }[], output: {} }, dev: false };
+      await mockNuxt.triggerHook('nitro:config', nitroConfig);
+
+      expect(nitroConfig.rollupConfig.plugins.map(plugin => plugin.name)).toEqual([
+        'sentry-nuxt-service-source-maps',
+        'sentry-rollup-plugin',
+      ]);
+    });
+
     it.each([
       {
         label: 'prepare mode',

packages/nuxt/test/vite/utils.test.ts

@@ -9,6 +9,7 @@ import {
   extractFunctionReexportQueryParameters,
   findDefaultSdkInitFile,
   getFilenameFromNodeStartCommand,
+  isInDirectory,
   QUERY_END_INDICATOR,
   removeSentryQueryFromPath,
   SENTRY_REEXPORTED_FUNCTIONS,
@@ -203,6 +204,23 @@ describe('toImportSpecifier', () => {
   });
 });
 
+describe('isInDirectory', () => {
+  const directory = path.join('/my', 'app', '.nuxt', 'vite', 'services');
+
+  it.each([
+    { label: 'a file in a subdirectory', file: path.join(directory, 'ssr', 'index.mjs'), expected: true },
+    { label: 'the directory itself', file: directory, expected: false },
+    {
+      label: 'a sibling directory with the same prefix',
+      file: `${directory}-old${path.sep}index.mjs`,
+      expected: false,
+    },
+    { label: 'the parent directory', file: path.dirname(directory), expected: false },
+  ])('returns $expected for $label', ({ file, expected }) => {
+    expect(isInDirectory(file, directory)).toBe(expected);
+  });
+});
+
 describe('getFilenameFromPath', () => {
   it('should return the filename from a simple path', () => {
     const path = 'node ./server/index.mjs';