@mui/internal-babel-plugin-minify-errors 2.0.8-canary.2 → 2.0.8-canary.20

package/index.js

@@ -26,136 +26,203 @@ function pathToNodeImportSpecifier(importPath) {
 
 const COMMENT_OPT_IN_MARKER = 'minify-error';
 const COMMENT_OPT_OUT_MARKER = 'minify-error-disabled';
+const SUPPORTED_ERROR_CONSTRUCTORS = new Set(['Error', 'TypeError']);
 
 /**
  * @typedef {import('@babel/core')} babel
  */
 
 /**
- * @typedef {babel.PluginPass & {updatedErrorCodes?: boolean, formatErrorMessageIdentifier?: babel.types.Identifier}} PluginState
  * @typedef {'annotate' | 'throw' | 'write'} MissingError
+ * @typedef {babel.PluginPass & {formatErrorMessageIdentifier?: babel.types.Identifier, processedNodes?: WeakSet<babel.types.Node>}} PluginState
  * @typedef {{
- *   errorCodesPath: string,
- *   missingError: MissingError,
+ *   errorCodesPath?: string,
  *   runtimeModule?: string,
  *   detection?: 'opt-in' | 'opt-out',
- *   outExtension?: string
+ *   outExtension?: string,
+ *   collectErrors?: Set<string | Error>
  * }} Options
  */
 
 /**
- * Extracts the message and expressions from a node.
+ * `collectErrors` - When provided, the plugin collects error messages into this Set
+ * instead of transforming the code. The caller typically passes the same Set instance
+ * across multiple plugin invocations (e.g., when processing multiple files), and the
+ * plugin is expected to mutate the Set by adding entries during traversal.
+ */
+
+/**
+ * Checks if a node is `process.env.NODE_ENV` using Babel types.
  * @param {babel.types} t
  * @param {babel.types.Node} node
- * @returns {{ message: string, expressions: babel.types.Expression[] } | null}
+ * @returns {boolean}
+ */
+function isProcessEnvNodeEnv(t, node) {
+  return (
+    t.isMemberExpression(node) &&
+    t.isMemberExpression(node.object) &&
+    t.isIdentifier(node.object.object, { name: 'process' }) &&
+    t.isIdentifier(node.object.property, { name: 'env' }) &&
+    t.isIdentifier(node.property, { name: 'NODE_ENV' })
+  );
+}
+
+/**
+ * Checks if a binary expression compares `process.env.NODE_ENV` with a value using the given operator.
+ * Handles both `process.env.NODE_ENV op value` and `value op process.env.NODE_ENV`.
+ * @param {babel.types} t
+ * @param {babel.types.BinaryExpression} node
+ * @param {string} operator
+ * @param {string} value
+ * @returns {boolean}
+ */
+function isNodeEnvComparison(t, node, operator, value) {
+  if (node.operator !== operator) {
+    return false;
+  }
+  return (
+    (isProcessEnvNodeEnv(t, node.left) && t.isStringLiteral(node.right, { value })) ||
+    (t.isStringLiteral(node.left, { value }) && isProcessEnvNodeEnv(t, node.right))
+  );
+}
+
+/**
+ * Checks if the given path is inside a dev-only branch
+ * (e.g. `if (process.env.NODE_ENV !== 'production') { ... }`).
+ * Errors inside such branches are already stripped in production,
+ * so minification is unnecessary.
+ * @param {babel.types} t
+ * @param {babel.NodePath} path
+ * @returns {boolean}
+ */
+function isInsideDevOnlyBranch(t, path) {
+  let current = path;
+  while (current.parentPath) {
+    const parent = current.parentPath;
+    if (parent.isIfStatement()) {
+      const isInConsequent = current.key === 'consequent';
+      const isInAlternate = current.key === 'alternate';
+      if ((isInConsequent || isInAlternate) && t.isBinaryExpression(parent.node.test)) {
+        const operator = isInConsequent ? '!==' : '===';
+        if (isNodeEnvComparison(t, parent.node.test, operator, 'production')) {
+          return true;
+        }
+      }
+    }
+    current = current.parentPath;
+  }
+  return false;
+}
+
+/**
+ * @typedef {{ path: babel.NodePath<babel.types.Expression>, message: string, expressions: babel.types.Expression[] }} ExtractedMessage
+ */
+
+/**
+ * Extracts the message and expressions from a path.
+ * @param {babel.types} t
+ * @param {babel.NodePath<babel.types.ArgumentPlaceholder | babel.types.SpreadElement | babel.types.Expression>} path
+ * @returns {ExtractedMessage | null}
  */
-function extractMessage(t, node) {
-  if (t.isTemplateLiteral(node)) {
+function extractMessage(t, path) {
+  if (path.isSpreadElement() || path.isArgumentPlaceholder()) {
+    return null;
+  }
+  if (path.isTemplateLiteral()) {
     return {
-      message: node.quasis.map((quasi) => quasi.value.cooked).join('%s'),
-      expressions: node.expressions.map((expression) => {
+      path,
+      message: path.node.quasis.map((quasi) => quasi.value.cooked).join('%s'),
+      expressions: path.node.expressions.map((expression) => {
         if (t.isExpression(expression)) {
           return expression;
         }
-        throw new Error('Can only evaluate javascript template literals.');
+        throw path.buildCodeFrameError('Can only evaluate javascript template literals.');
       }),
     };
   }
-  if (t.isStringLiteral(node)) {
-    return { message: node.value, expressions: [] };
+  if (path.isStringLiteral()) {
+    return { path, message: path.node.value, expressions: [] };
   }
-  if (t.isBinaryExpression(node) && node.operator === '+') {
-    const left = extractMessage(t, node.left);
-    const right = extractMessage(t, node.right);
-    if (!left || !right) {
-      return null;
+  if (path.isBinaryExpression() && path.node.operator === '+') {
+    const leftPath = path.get('left');
+    if (leftPath.isExpression()) {
+      const left = extractMessage(t, leftPath);
+      const right = extractMessage(t, path.get('right'));
+      if (!left || !right) {
+        return null;
+      }
+      return {
+        path,
+        message: left.message + right.message,
+        expressions: [...left.expressions, ...right.expressions],
+      };
     }
-    return {
-      message: left.message + right.message,
-      expressions: [...left.expressions, ...right.expressions],
-    };
   }
   return null;
 }
 
 /**
- * Handles unminifyable errors based on the missingError option.
- * @param {MissingError} missingError
- * @param {babel.NodePath} path
+ * @param {babel.types} t
+ * @param {babel.NodePath<babel.types.NewExpression>} newExpressionPath
+ * @param {'opt-in' | 'opt-out'} detection
+ * @returns {null | babel.NodePath<babel.types.ArgumentPlaceholder | babel.types.SpreadElement | babel.types.Expression>}
  */
-function handleUnminifyableError(missingError, path) {
-  switch (missingError) {
-    case 'annotate':
-      path.addComment(
-        'leading',
-        ' FIXME (minify-errors-in-prod): Unminifyable error in production! ',
-      );
+function findMessageNode(t, newExpressionPath, detection) {
+  const callee = newExpressionPath.get('callee');
+  if (!callee.isIdentifier() || !SUPPORTED_ERROR_CONSTRUCTORS.has(callee.node.name)) {
+    return null;
+  }
+
+  if (isInsideDevOnlyBranch(t, newExpressionPath)) {
+    return null;
+  }
+
+  switch (detection) {
+    case 'opt-in': {
+      if (
+        !newExpressionPath.node.leadingComments?.some((comment) =>
+          comment.value.includes(COMMENT_OPT_IN_MARKER),
+        )
+      ) {
+        return null;
+      }
       break;
-    case 'throw':
-      throw new Error(
-        'Unminifyable error. You can only use literal strings and template strings as error messages.',
-      );
-    case 'write':
+    }
+    case 'opt-out': {
+      if (
+        newExpressionPath.node.leadingComments?.some((comment) =>
+          comment.value.includes(COMMENT_OPT_OUT_MARKER),
+        )
+      ) {
+        return null;
+      }
+
       break;
-    default:
-      throw new Error(`Unknown missingError option: ${missingError}`);
+    }
+    default: {
+      throw new Error(`Unknown detection option: ${detection}`);
+    }
   }
+
+  const messagePath = newExpressionPath.get('arguments')[0];
+
+  return messagePath ?? null;
 }
 
 /**
  * Transforms the error message node.
  * @param {babel.types} t
- * @param {babel.NodePath} path
- * @param {babel.types.Expression} messageNode
+ * @param {ExtractedMessage} extracted
+ * @param {number} errorCode
  * @param {PluginState} state
- * @param {Map<string, number>} errorCodesLookup
- * @param {MissingError} missingError
  * @param {string} runtimeModule
  * @param {string} outExtension
- * @returns {babel.types.Expression | null}
+ * @returns {babel.types.Expression}
  */
-function transformMessage(
-  t,
-  path,
-  messageNode,
-  state,
-  errorCodesLookup,
-  missingError,
-  runtimeModule,
-  outExtension,
-) {
-  const message = extractMessage(t, messageNode);
-  if (!message) {
-    handleUnminifyableError(missingError, path);
-    return null;
-  }
-
-  let errorCode = errorCodesLookup.get(message.message);
-  if (errorCode === undefined) {
-    switch (missingError) {
-      case 'annotate':
-        path.addComment(
-          'leading',
-          ' FIXME (minify-errors-in-prod): Unminified error message in production build! ',
-        );
-        return null;
-      case 'throw':
-        throw new Error(
-          `Missing error code for message '${message.message}'. Did you forget to run \`pnpm extract-error-codes\` first?`,
-        );
-      case 'write':
-        errorCode = errorCodesLookup.size + 1;
-        errorCodesLookup.set(message.message, errorCode);
-        state.updatedErrorCodes = true;
-        break;
-      default:
-        throw new Error(`Unknown missingError option: ${missingError}`);
-    }
-  }
-
+function transformMessage(t, extracted, errorCode, state, runtimeModule, outExtension) {
   if (!state.formatErrorMessageIdentifier) {
     state.formatErrorMessageIdentifier = helperModuleImports.addDefault(
-      path,
+      extracted.path,
       transformExtension(resolveRuntimeModule(runtimeModule, state), outExtension),
       { nameHint: '_formatErrorMessage' },
     );
@@ -170,10 +237,10 @@ function transformMessage(
       ),
       t.stringLiteral('production'),
     ),
-    messageNode,
+    extracted.path.node,
     t.callExpression(t.cloneNode(state.formatErrorMessageIdentifier, true), [
       t.numericLiteral(errorCode),
-      ...message.expressions,
+      ...extracted.expressions,
     ]),
   );
 }
@@ -240,99 +307,109 @@ module.exports = function plugin(
   { types: t },
   {
     errorCodesPath,
-    missingError = 'annotate',
     runtimeModule = '#formatErrorMessage',
     detection = 'opt-in',
     outExtension = '.js',
+    collectErrors,
   },
 ) {
-  if (!errorCodesPath) {
-    throw new Error('errorCodesPath is required.');
-  }
+  /** @type {Map<string, number>} */
+  let errorCodesLookup;
 
-  const errorCodesContent = fs.readFileSync(errorCodesPath, 'utf8');
-  const errorCodes = JSON.parse(errorCodesContent);
+  if (collectErrors) {
+    errorCodesLookup = new Map();
+  } else {
+    if (!errorCodesPath) {
+      throw new Error('errorCodesPath is required.');
+    }
 
-  const errorCodesLookup = new Map(
-    Object.entries(errorCodes).map(([key, value]) => [value, Number(key)]),
-  );
+    const errorCodesContent = fs.readFileSync(errorCodesPath, 'utf8');
+    const errorCodes = JSON.parse(errorCodesContent);
+
+    errorCodesLookup = new Map(
+      Object.entries(errorCodes).map(([key, value]) => [value, Number(key)]),
+    );
+  }
 
   return {
     name: '@mui/internal-babel-plugin-minify-errors',
     visitor: {
       NewExpression(newExpressionPath, state) {
-        if (!newExpressionPath.get('callee').isIdentifier({ name: 'Error' })) {
+        // Initialize the WeakSet lazily to track processed nodes
+        state.processedNodes ??= new WeakSet();
+
+        // Skip if we've already processed this node. This can happen when Babel
+        // visits the same node multiple times due to configuration or plugin
+        // interactions (e.g., @babel/preset-env with modules: 'commonjs' combined
+        // with React.forwardRef causes double visitation).
+        if (state.processedNodes.has(newExpressionPath.node)) {
+          return;
+        }
+
+        // Mark this node as processed before transforming
+        state.processedNodes.add(newExpressionPath.node);
+
+        const messagePath = findMessageNode(t, newExpressionPath, detection);
+
+        if (!messagePath) {
+          // Not an error, or not eligible for minification
           return;
         }
 
-        switch (detection) {
-          case 'opt-in': {
-            if (
-              !newExpressionPath.node.leadingComments?.some((comment) =>
-                comment.value.includes(COMMENT_OPT_IN_MARKER),
-              )
-            ) {
-              return;
-            }
-            newExpressionPath.node.leadingComments = newExpressionPath.node.leadingComments.filter(
-              (comment) => !comment.value.includes(COMMENT_OPT_IN_MARKER),
+        if (!collectErrors && newExpressionPath.node.leadingComments) {
+          newExpressionPath.node.leadingComments = newExpressionPath.node.leadingComments.filter(
+            (comment) =>
+              !comment.value.includes(COMMENT_OPT_IN_MARKER) &&
+              !comment.value.includes(COMMENT_OPT_OUT_MARKER),
+          );
+        }
+
+        const extracted = extractMessage(t, messagePath);
+
+        if (!extracted) {
+          if (collectErrors) {
+            // Mutates the caller's Set
+            collectErrors.add(
+              messagePath.buildCodeFrameError(
+                'Unminifyable error. You can only use literal strings and template strings as error messages.',
+              ),
+            );
+          } else {
+            newExpressionPath.addComment(
+              'leading',
+              ' FIXME (minify-errors-in-prod): Unminifyable error in production! ',
             );
-            break;
-          }
-          case 'opt-out': {
-            if (
-              newExpressionPath.node.leadingComments?.some((comment) =>
-                comment.value.includes(COMMENT_OPT_OUT_MARKER),
-              )
-            ) {
-              newExpressionPath.node.leadingComments =
-                newExpressionPath.node.leadingComments.filter(
-                  (comment) => !comment.value.includes(COMMENT_OPT_OUT_MARKER),
-                );
-              return;
-            }
-
-            break;
-          }
-          default: {
-            throw new Error(`Unknown detection option: ${detection}`);
           }
+          return;
         }
 
-        const messagePath = newExpressionPath.get('arguments')[0];
-        if (!messagePath) {
+        const errorCode = errorCodesLookup.get(extracted.message);
+
+        if (collectErrors) {
+          // Mutates the caller's Set
+          collectErrors.add(extracted.message);
           return;
         }
 
-        const messageNode = messagePath.node;
-        if (t.isSpreadElement(messageNode) || t.isArgumentPlaceholder(messageNode)) {
-          handleUnminifyableError(missingError, newExpressionPath);
+        if (errorCode === undefined) {
+          newExpressionPath.addComment(
+            'leading',
+            ' FIXME (minify-errors-in-prod): Unminified error message in production build! ',
+          );
           return;
         }
 
         const transformedMessage = transformMessage(
           t,
-          newExpressionPath,
-          messageNode,
+          extracted,
+          errorCode,
           state,
-          errorCodesLookup,
-          missingError,
           runtimeModule,
           outExtension,
         );
 
-        if (transformedMessage) {
-          messagePath.replaceWith(transformedMessage);
-        }
+        messagePath.replaceWith(transformedMessage);
       },
     },
-    post() {
-      if (missingError === 'write' && this.updatedErrorCodes) {
-        const invertedErrorCodes = Object.fromEntries(
-          Array.from(errorCodesLookup, ([key, value]) => [value, key]),
-        );
-        fs.writeFileSync(errorCodesPath, `${JSON.stringify(invertedErrorCodes, null, 2)}\n`);
-      }
-    },
   };
 };

package/index.test.js

@@ -1,11 +1,11 @@
 import * as fs from 'fs';
 import * as path from 'path';
-import * as os from 'os';
+import { transformSync } from '@babel/core';
 import { pluginTester } from 'babel-plugin-tester';
-import { expect } from 'chai';
+import { expect, describe, it } from 'vitest';
+import * as babel from '@babel/core';
 import plugin from './index';
 
-const temporaryErrorCodesPath = path.join(os.tmpdir(), 'error-codes.json');
 const fixturePath = path.resolve(__dirname, './__fixtures__');
 
 /**
@@ -35,6 +35,15 @@ pluginTester({
       fixture: path.join(fixturePath, 'literal', 'input.js'),
       output: readOutputFixtureSync('literal', 'output.js'),
     },
+    {
+      title: 'type-error',
+      pluginOptions: {
+        errorCodesPath: path.join(fixturePath, 'type-error', 'error-codes.json'),
+        runtimeModule: '@mui/utils/formatMuiErrorMessage',
+      },
+      fixture: path.join(fixturePath, 'type-error', 'input.js'),
+      output: readOutputFixtureSync('type-error', 'output.js'),
+    },
     {
       title: 'interpolation',
       pluginOptions: {
@@ -53,19 +62,6 @@ pluginTester({
       fixture: path.join(fixturePath, 'no-error-code-annotation', 'input.js'),
       output: readOutputFixtureSync('no-error-code-annotation', 'output.js'),
     },
-    {
-      title: 'can throw on missing error codes',
-      // babel prefixes with filename.
-      // We're only interested in the message.
-      error:
-        /: Missing error code for message 'missing'. Did you forget to run `pnpm extract-error-codes` first\?/,
-      fixture: path.join(fixturePath, 'no-error-code-throw', 'input.js'),
-      pluginOptions: {
-        errorCodesPath: path.join(fixturePath, 'no-error-code-throw', 'error-codes.json'),
-        missingError: 'throw',
-        runtimeModule: '@mui/utils/formatMuiErrorMessage',
-      },
-    },
     {
       title: 'annotates unminifyable errors',
       pluginOptions: {
@@ -76,50 +72,10 @@ pluginTester({
       output: readOutputFixtureSync('unminifyable-annotation', 'output.js'),
     },
     {
-      title: 'can throw on unminifyable errors',
-      // babel prefixes with filename.
-      // We're only interested in the message.
-      error:
-        /: Unminifyable error. You can only use literal strings and template strings as error messages./,
-      fixture: path.join(fixturePath, 'unminifyable-throw', 'input.js'),
-      pluginOptions: {
-        errorCodesPath: path.join(fixturePath, 'unminifyable-throw', 'error-codes.json'),
-        missingError: 'throw',
-        runtimeModule: '@mui/utils/formatMuiErrorMessage',
-      },
-    },
-    {
-      title: 'can extract errors',
-      fixture: path.join(fixturePath, 'error-code-extraction', 'input.js'),
+      title: 'collects unminifyable errors as Error objects without throwing',
+      fixture: path.join(fixturePath, 'unminifyable-collect', 'input.js'),
       pluginOptions: {
-        errorCodesPath: temporaryErrorCodesPath,
-        missingError: 'write',
-        runtimeModule: '@mui/utils/formatMuiErrorMessage',
-      },
-      output: readOutputFixtureSync('error-code-extraction', 'output.js'),
-      setup() {
-        fs.copyFileSync(
-          path.join(fixturePath, 'error-code-extraction', 'error-codes.before.json'),
-          temporaryErrorCodesPath,
-        );
-
-        return function teardown() {
-          try {
-            const actualErrorCodes = JSON.parse(
-              fs.readFileSync(temporaryErrorCodesPath, { encoding: 'utf8' }),
-            );
-            const expectedErrorCodes = JSON.parse(
-              fs.readFileSync(
-                path.join(fixturePath, 'error-code-extraction', 'error-codes.after.json'),
-                'utf-8',
-              ),
-            );
-
-            expect(actualErrorCodes).to.deep.equal(expectedErrorCodes);
-          } finally {
-            fs.unlinkSync(temporaryErrorCodesPath);
-          }
-        };
+        collectErrors: new Set(),
       },
     },
     {
@@ -166,5 +122,151 @@ pluginTester({
       fixture: path.join(fixturePath, 'custom-runtime-imports-recursive', 'input.js'),
       output: readOutputFixtureSync('custom-runtime-imports-recursive', 'output.js'),
     },
+    {
+      title: 'skips errors inside dev-only branches',
+      pluginOptions: {
+        errorCodesPath: path.join(fixturePath, 'dev-only-branch', 'error-codes.json'),
+        runtimeModule: '@mui/utils/formatMuiErrorMessage',
+        detection: 'opt-out',
+      },
+      fixture: path.join(fixturePath, 'dev-only-branch', 'input.js'),
+      output: readOutputFixtureSync('dev-only-branch', 'output.js'),
+    },
   ],
 });
+
+describe('collectErrors', () => {
+  it('collects error messages into the provided Set without transforming code', () => {
+    const errors = new Set();
+    const code = [
+      'throw /* minify-error */ new Error("first error");',
+      // eslint-disable-next-line no-template-curly-in-string
+      'throw /* minify-error */ new Error(`second ${x} error`);',
+    ].join('\n');
+
+    transformSync(code, {
+      filename: '/test/file.js',
+      plugins: [[plugin, { collectErrors: errors }]],
+      configFile: false,
+      babelrc: false,
+    });
+
+    expect(errors).toEqual(new Set(['first error', 'second %s error']));
+  });
+
+  it('collects Error objects for unminifyable errors', () => {
+    const errors = new Set();
+    const code = [
+      'throw /* minify-error */ new Error(foo);',
+      'throw /* minify-error */ new Error(...bar);',
+    ].join('\n');
+
+    transformSync(code, {
+      filename: '/test/file.js',
+      plugins: [[plugin, { collectErrors: errors }]],
+      configFile: false,
+      babelrc: false,
+    });
+
+    const collected = Array.from(errors);
+    expect(collected).toHaveLength(2);
+    expect(collected[0]).toBeInstanceOf(Error);
+    expect(collected[0].message).toMatch(
+      /Unminifyable error. You can only use literal strings and template strings as error messages./,
+    );
+    expect(collected[1]).toBeInstanceOf(Error);
+    expect(collected[1].message).toMatch(
+      /Unminifyable error. You can only use literal strings and template strings as error messages./,
+    );
+  });
+
+  it('continues collection past unminifyable errors', () => {
+    const errors = new Set();
+    const code = [
+      'throw /* minify-error */ new Error(foo);',
+      'throw /* minify-error */ new Error("valid error message");',
+    ].join('\n');
+
+    transformSync(code, {
+      filename: '/test/file.js',
+      plugins: [[plugin, { collectErrors: errors }]],
+      configFile: false,
+      babelrc: false,
+    });
+
+    const collected = Array.from(errors);
+    expect(collected).toHaveLength(2);
+    expect(collected[0]).toBeInstanceOf(Error);
+    expect(collected[1]).toBe('valid error message');
+  });
+
+  it('respects detection option when collecting errors', () => {
+    const errors = new Set();
+    const code = ['throw new Error("opted-in error");', 'throw new Error("not collected");'].join(
+      '\n',
+    );
+
+    transformSync(code, {
+      filename: '/test/file.js',
+      plugins: [[plugin, { collectErrors: errors, detection: 'opt-out' }]],
+      configFile: false,
+      babelrc: false,
+    });
+
+    expect(errors).toEqual(new Set(['opted-in error', 'not collected']));
+  });
+});
+
+describe('minify-errors double-visitation fix', () => {
+  // Separate test for the double-visitation bug fix
+  // This test uses @babel/core directly because it requires specific preset configuration
+  // that triggers the double-visitation issue (preset-env with modules: 'commonjs' + React.forwardRef)
+  it('handles double visitation with preset-env commonjs modules', () => {
+    // This pattern (React.forwardRef) combined with @babel/preset-env modules: 'commonjs'
+    // causes Babel to visit the same NewExpression node multiple times.
+    // Without the fix, this would result in both a FIXME annotation AND a minified error.
+    //
+    // NOTE: We use detection: 'opt-out' to properly trigger the bug, because with opt-in,
+    // the /* minify-error */ comment gets removed on the first pass, which masks the issue.
+    const input = `
+import * as React from 'react';
+
+export const Component = React.forwardRef(function Component(props, ref) {
+  if (!props.store) {
+    throw new Error('Component requires a store prop');
+  }
+  return <div ref={ref}>{props.children}</div>;
+});
+`;
+
+    const result = babel.transformSync(input, {
+      filename: path.join(fixturePath, 'commonjs-double-visit', 'test.js'),
+      configFile: false,
+      babelrc: false,
+      presets: [
+        ['@babel/preset-env', { modules: 'commonjs' }],
+        ['@babel/preset-react', { runtime: 'automatic' }],
+      ],
+      plugins: [
+        [
+          plugin,
+          {
+            errorCodesPath: path.join(fixturePath, 'commonjs-double-visit', 'error-codes.json'),
+            runtimeModule: '@mui/utils/formatMuiErrorMessage',
+            detection: 'opt-out', // Use opt-out to properly trigger the bug
+          },
+        ],
+      ],
+    });
+
+    // Key assertions:
+    // 1. Output should NOT contain FIXME annotation (which would indicate improper double processing)
+    expect(result?.code).not.toContain('FIXME');
+
+    // 2. Output should contain the properly minified error with NODE_ENV conditional
+    expect(result?.code).toContain('process.env.NODE_ENV !== "production"');
+
+    // 3. Output should contain the error code call (the import name varies based on babel helper)
+    expect(result?.code).toMatch(/_formatMuiErrorMessage.*\(1\)/);
+  });
+});

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mui/internal-babel-plugin-minify-errors",
-  "version": "2.0.8-canary.2",
+  "version": "2.0.8-canary.20",
   "author": "MUI Team",
   "description": "This is an internal package not meant for general use.",
   "repository": {
@@ -17,22 +17,22 @@
     "url": "https://opencollective.com/mui-org"
   },
   "dependencies": {
-    "@babel/helper-module-imports": "^7.27.1",
+    "@babel/helper-module-imports": "^7.28.6",
     "find-package-json": "^1.2.0"
   },
   "devDependencies": {
-    "@babel/core": "^7.22.0",
-    "@types/babel__core": "^7.20.5",
-    "@types/babel__helper-module-imports": "^7.18.3",
-    "@types/find-package-json": "^1.2.6",
-    "babel-plugin-tester": "^12.0.0",
-    "chai": "^4.5.0"
+    "@babel/core": "7.28.6",
+    "@types/babel__core": "7.20.5",
+    "@types/babel__helper-module-imports": "7.18.3",
+    "@types/find-package-json": "1.2.7",
+    "babel-plugin-tester": "12.0.0"
   },
   "peerDependencies": {
     "@babel/core": "7"
   },
   "sideEffects": false,
   "type": "commonjs",
+  "main": "./index.js",
   "exports": {
     ".": "./index.js"
   },
@@ -42,6 +42,6 @@
   "publishConfig": {
     "access": "public"
   },
-  "gitSha": "8391aed9c1a47151a520e3bfea6db8c730fdadd3",
+  "gitSha": "2836960cc7e128ab529942129c49aeffb8a0b76d",
   "scripts": {}
 }