fix(react-router): Preserve sourcemaps.disable when unstable_sentryVitePluginOptions is set

packages/react-router/src/vite/buildEnd/handleOnBuildEnd.ts

@@ -16,6 +16,20 @@ function getSentryConfig(viteConfig: unknown): SentryReactRouterBuildOptions {
   return (viteConfig as { sentryConfig: SentryReactRouterBuildOptions }).sentryConfig;
 }
 
+/**
+ * This hook is the only place that injects debug IDs and uploads source maps for React
+ * Router, so `disable` has to be honoured wherever the user set it. Reading it from the
+ * top-level config only would silently ignore `unstable_sentryVitePluginOptions`.
+ */
+function resolveSourceMapsDisable(sentryConfig: SentryReactRouterBuildOptions): boolean | 'disable-upload' | undefined {
+  // eslint-disable-next-line typescript/no-deprecated
+  if (sentryConfig.sourceMapsUploadOptions?.enabled === false) {
+    return true;
+  }
+
+  return sentryConfig.sourcemaps?.disable ?? sentryConfig.unstable_sentryVitePluginOptions?.sourcemaps?.disable;
+}
+
 /**
  * A build end hook that handles Sentry release creation and source map uploads.
  * It creates a new Sentry release if configured, uploads source maps to Sentry,
@@ -48,8 +62,7 @@ export const sentryOnBuildEnd: BuildEndHook = async ({ reactRouterConfig, viteCo
       ...unstableSentryVitePluginOptions?.sourcemaps,
       ...sentryConfig.sourcemaps,
       ...sourceMapsUploadOptions,
-      // eslint-disable-next-line typescript/no-deprecated
-      disable: sourceMapsUploadOptions?.enabled === false ? true : sentryConfig.sourcemaps?.disable,
+      disable: resolveSourceMapsDisable(sentryConfig),
     },
     release: {
       ...unstableSentryVitePluginOptions?.release,
@@ -80,7 +93,12 @@ export const sentryOnBuildEnd: BuildEndHook = async ({ reactRouterConfig, viteCo
     }
   }
 
-  if (!sourcemaps?.disable && viteConfig.build.sourcemap !== false) {
+  // `disable: 'disable-upload'` still injects debug IDs, so that source maps can be
+  // uploaded manually at a later point - only `true` turns source maps off entirely.
+  const sourceMapsFullyDisabled = sourcemaps?.disable === true;
+  const uploadDisabled = sourceMapsFullyDisabled || sourcemaps?.disable === 'disable-upload';
+
+  if (!sourceMapsFullyDisabled && viteConfig.build.sourcemap !== false) {
     // inject debugIds
     try {
       await cliInstance.execute(
@@ -92,21 +110,30 @@ export const sentryOnBuildEnd: BuildEndHook = async ({ reactRouterConfig, viteCo
       console.error('[Sentry] Could not inject debug ids', error);
     }
 
-    // upload sourcemaps
-    try {
-      await cliInstance.releases.uploadSourceMaps(release?.name || 'undefined', {
-        include: [
-          {
-            paths: [reactRouterConfig.buildDirectory],
-          },
-        ],
-        live: 'rejectOnError',
-      });
-    } catch (error) {
-      // eslint-disable-next-line no-console
-      console.error('[Sentry] Could not upload sourcemaps', error);
+    if (!uploadDisabled) {
+      // upload sourcemaps
+      try {
+        await cliInstance.releases.uploadSourceMaps(release?.name || 'undefined', {
+          include: [
+            {
+              paths: [reactRouterConfig.buildDirectory],
+            },
+          ],
+          live: 'rejectOnError',
+        });
+      } catch (error) {
+        // eslint-disable-next-line no-console
+        console.error('[Sentry] Could not upload sourcemaps', error);
+      }
     }
   }
+
+  // Only clean up source maps that were actually uploaded. Deleting them after skipping
+  // the upload would leave the user with neither, breaking a manual upload.
+  if (uploadDisabled) {
+    return;
+  }
+
   // delete sourcemaps after upload
   let updatedFilesToDeleteAfterUpload = await sourcemaps?.filesToDeleteAfterUpload;
 

packages/react-router/src/vite/makeCustomSentryVitePlugins.ts

@@ -19,6 +19,20 @@ export async function makeCustomSentryVitePlugins(options: SentryReactRouterBuil
     release,
   } = options;
 
+  const unstableSourcemapsDisable = unstable_sentryVitePluginOptions?.sourcemaps?.disable;
+
+  // Anything other than `true` would have the Vite plugin inject debug IDs on top of the
+  // ones `sentryOnBuildEnd` injects, which breaks source map resolution. The value still
+  // applies to the buildEnd hook - only the Vite plugin ignores it.
+  if (unstableSourcemapsDisable !== undefined && unstableSourcemapsDisable !== true) {
+    // eslint-disable-next-line no-console
+    console.warn(
+      `[Sentry] \`unstable_sentryVitePluginOptions.sourcemaps.disable: ${JSON.stringify(
+        unstableSourcemapsDisable,
+      )}\` does not apply to the Vite plugin. Debug ID injection and source map upload are handled by the \`sentryOnBuildEnd\` hook for React Router, so letting the Vite plugin do it as well would inject a second debug ID per chunk. The option still applies to \`sentryOnBuildEnd\`.`,
+    );
+  }
+
   const sentryVitePlugins = sentryVitePlugin({
     applicationKey,
     authToken: authToken ?? process.env.SENTRY_AUTH_TOKEN,
@@ -27,27 +41,38 @@ export async function makeCustomSentryVitePlugins(options: SentryReactRouterBuil
     org: org ?? process.env.SENTRY_ORG,
     project: project ?? process.env.SENTRY_PROJECT,
     telemetry: telemetry ?? true,
+    // Spread here so it can override the plain options above, but not the objects
+    // merged below - object spread replaces whole keys rather than deep-merging.
+    ...unstable_sentryVitePluginOptions,
     _metaOptions: {
+      ...unstable_sentryVitePluginOptions?._metaOptions,
       telemetry: {
+        ...unstable_sentryVitePluginOptions?._metaOptions?.telemetry,
         metaFramework: 'react-router',
       },
-      ...unstable_sentryVitePluginOptions?._metaOptions,
     },
     reactComponentAnnotation: {
-      enabled: reactComponentAnnotation?.enabled ?? undefined,
-      ignoredComponents: reactComponentAnnotation?.ignoredComponents ?? undefined,
+      // Only assign when set, as an explicit `undefined` would erase the unstable value
+      ...(reactComponentAnnotation?.enabled !== undefined && { enabled: reactComponentAnnotation.enabled }),
+      ...(reactComponentAnnotation?.ignoredComponents !== undefined && {
+        ignoredComponents: reactComponentAnnotation.ignoredComponents,
+      }),
       ...unstable_sentryVitePluginOptions?.reactComponentAnnotation,
     },
     release: {
       ...unstable_sentryVitePluginOptions?.release,
       ...release,
     },
-    // will be handled in buildEnd hook
     sourcemaps: {
-      disable: true,
       ...unstable_sentryVitePluginOptions?.sourcemaps,
+      // Injection and upload are handled in the buildEnd hook, so the Vite plugin must
+      // never do it too. This is deliberately not overridable - see the warning above.
+      disable: true,
+      // The plugin deletes these in a `finally` block that runs regardless of `disable`,
+      // which would remove the maps before `sentryOnBuildEnd` gets to upload them.
+      // Deletion is handled there instead, from the same option.
+      filesToDeleteAfterUpload: undefined,
     },
-    ...unstable_sentryVitePluginOptions,
   }) as Plugin[];
 
   return sentryVitePlugins;

packages/react-router/test/vite/buildEnd/handleOnBuildEnd.test.ts

@@ -178,6 +178,176 @@ describe('sentryOnBuildEnd', () => {
     expect(mockSentryCliInstance.releases.uploadSourceMaps).not.toHaveBeenCalled();
   });
 
+  it('should not upload source maps when disabled via top-level sourcemaps.disable', async () => {
+    const config = {
+      ...defaultConfig,
+      viteConfig: {
+        ...defaultConfig.viteConfig,
+        sentryConfig: {
+          ...defaultConfig.viteConfig.sentryConfig,
+          sourcemaps: { disable: true },
+        },
+      } as unknown as TestConfig,
+    };
+
+    // @ts-expect-error - mocking the React config
+    await sentryOnBuildEnd(config);
+
+    expect(mockSentryCliInstance.execute).not.toHaveBeenCalled();
+    expect(mockSentryCliInstance.releases.uploadSourceMaps).not.toHaveBeenCalled();
+  });
+
+  // `disable` used to be read from the top-level config only, so this opt-out was
+  // silently ignored while the Vite plugin honoured it - see #22929.
+  it('should not upload source maps when disabled via unstable_sentryVitePluginOptions', async () => {
+    const config = {
+      ...defaultConfig,
+      viteConfig: {
+        ...defaultConfig.viteConfig,
+        sentryConfig: {
+          ...defaultConfig.viteConfig.sentryConfig,
+          unstable_sentryVitePluginOptions: {
+            sourcemaps: { disable: true },
+          },
+        },
+      } as unknown as TestConfig,
+    };
+
+    // @ts-expect-error - mocking the React config
+    await sentryOnBuildEnd(config);
+
+    expect(mockSentryCliInstance.execute).not.toHaveBeenCalled();
+    expect(mockSentryCliInstance.releases.uploadSourceMaps).not.toHaveBeenCalled();
+  });
+
+  it('should let top-level sourcemaps.disable override unstable_sentryVitePluginOptions', async () => {
+    const config = {
+      ...defaultConfig,
+      viteConfig: {
+        ...defaultConfig.viteConfig,
+        sentryConfig: {
+          ...defaultConfig.viteConfig.sentryConfig,
+          sourcemaps: { disable: false },
+          unstable_sentryVitePluginOptions: {
+            sourcemaps: { disable: true },
+          },
+        },
+      } as unknown as TestConfig,
+    };
+
+    // @ts-expect-error - mocking the React config
+    await sentryOnBuildEnd(config);
+
+    expect(mockSentryCliInstance.releases.uploadSourceMaps).toHaveBeenCalled();
+  });
+
+  it('should still upload source maps when unstable_sentryVitePluginOptions only sets unrelated sourcemaps keys', async () => {
+    const config = {
+      ...defaultConfig,
+      viteConfig: {
+        ...defaultConfig.viteConfig,
+        sentryConfig: {
+          ...defaultConfig.viteConfig.sentryConfig,
+          unstable_sentryVitePluginOptions: {
+            sourcemaps: { filesToDeleteAfterUpload: ['./build/**/*.map'] },
+          },
+        },
+      } as unknown as TestConfig,
+    };
+
+    // @ts-expect-error - mocking the React config
+    await sentryOnBuildEnd(config);
+
+    expect(mockSentryCliInstance.execute).toHaveBeenCalledWith(['sourcemaps', 'inject', '/build'], false);
+    expect(mockSentryCliInstance.releases.uploadSourceMaps).toHaveBeenCalled();
+    expect(glob).toHaveBeenCalledWith(['./build/**/*.map'], {
+      absolute: true,
+      nodir: true,
+    });
+  });
+
+  // `'disable-upload'` means "inject debug IDs, but let me upload the maps myself", so
+  // injection must still run and the maps must survive.
+  it('should inject debug IDs but skip upload and deletion when disable is "disable-upload"', async () => {
+    const config = {
+      ...defaultConfig,
+      viteConfig: {
+        ...defaultConfig.viteConfig,
+        sentryConfig: {
+          ...defaultConfig.viteConfig.sentryConfig,
+          sourcemaps: { disable: 'disable-upload' },
+        },
+      } as unknown as TestConfig,
+    };
+
+    // @ts-expect-error - mocking the React config
+    await sentryOnBuildEnd(config);
+
+    expect(mockSentryCliInstance.execute).toHaveBeenCalledWith(['sourcemaps', 'inject', '/build'], false);
+    expect(mockSentryCliInstance.releases.uploadSourceMaps).not.toHaveBeenCalled();
+    expect(glob).not.toHaveBeenCalled();
+  });
+
+  it('should honour "disable-upload" set via unstable_sentryVitePluginOptions', async () => {
+    const config = {
+      ...defaultConfig,
+      viteConfig: {
+        ...defaultConfig.viteConfig,
+        sentryConfig: {
+          ...defaultConfig.viteConfig.sentryConfig,
+          unstable_sentryVitePluginOptions: {
+            sourcemaps: { disable: 'disable-upload' },
+          },
+        },
+      } as unknown as TestConfig,
+    };
+
+    // @ts-expect-error - mocking the React config
+    await sentryOnBuildEnd(config);
+
+    expect(mockSentryCliInstance.execute).toHaveBeenCalledWith(['sourcemaps', 'inject', '/build'], false);
+    expect(mockSentryCliInstance.releases.uploadSourceMaps).not.toHaveBeenCalled();
+    expect(glob).not.toHaveBeenCalled();
+  });
+
+  // Deleting maps that were never uploaded would leave the user with neither.
+  it('should not delete source maps when upload is disabled', async () => {
+    const config = {
+      ...defaultConfig,
+      viteConfig: {
+        ...defaultConfig.viteConfig,
+        sentryConfig: {
+          ...defaultConfig.viteConfig.sentryConfig,
+          sourcemaps: { disable: true },
+        },
+      } as unknown as TestConfig,
+    };
+
+    // @ts-expect-error - mocking the React config
+    await sentryOnBuildEnd(config);
+
+    expect(glob).not.toHaveBeenCalled();
+    expect(fs.promises.rm).not.toHaveBeenCalled();
+  });
+
+  it('should not delete source maps when disabled via the deprecated sourceMapsUploadOptions', async () => {
+    const config = {
+      ...defaultConfig,
+      viteConfig: {
+        ...defaultConfig.viteConfig,
+        sentryConfig: {
+          ...defaultConfig.viteConfig.sentryConfig,
+          sourceMapsUploadOptions: { enabled: false },
+        },
+      } as unknown as TestConfig,
+    };
+
+    // @ts-expect-error - mocking the React config
+    await sentryOnBuildEnd(config);
+
+    expect(glob).not.toHaveBeenCalled();
+  });
+
   it('should delete source maps after upload with default pattern', async () => {
     // @ts-expect-error - mocking the React config
     await sentryOnBuildEnd(defaultConfig);