fix: Prevent Metro serializer crash on non-standard serializer output (#6652)

* fix: Prevent Metro serializer crash on non-standard serializer output

The Metro serializer used `'map' in serializerResult` to detect a
`{ code, map }` bundle. For arrays that check is always true because of
`Array.prototype.map`, so an array result (e.g. Expo's static/EAS Update
export) yielded `{ code: undefined }` and crashed in
`determineDebugIdFromBundleSource` with "Cannot read properties of
undefined (reading 'match')".

Detect a bundle with a positive check (object, not array, string `code`)
and pass non-standard output through untouched instead of crashing.

Fixes #6650

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>

* docs: Point changelog entry to PR #6652

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>

---------

Co-authored-by: Claude Opus 4.8 <noreply@anthropic.com>

Author: antonis

CHANGELOG.md

@@ -15,6 +15,7 @@
 
 ### Fixes
 
+- Fix Metro bundler crash on Expo static/EAS Update exports ([#6652](https://github.com/getsentry/sentry-react-native/pull/6652))
 - No longer logs `NSNull cannot be converted` warnings on iOS with the New Architecture when clearing a scope context ([#6651](https://github.com/getsentry/sentry-react-native/pull/6651))
 - `time_to_initial_display`/`time_to_full_display` now measure the actual screen render for apps whose first navigation happens well after app start ([#6626](https://github.com/getsentry/sentry-react-native/pull/6626))
 

packages/core/src/js/tools/sentryMetroSerializer.ts

@@ -2,7 +2,7 @@ import type { MixedOutput, Module, ReadOnlyGraph } from 'metro';
 
 import * as crypto from 'crypto';
 
-import type { Bundle, MetroSerializer, MetroSerializerOutput, SerializedBundle, VirtualJSOutput } from './utils';
+import type { Bundle, MetroSerializer, SerializedBundle, VirtualJSOutput } from './utils';
 
 import {
   createDebugIdSnippet,
@@ -73,8 +73,18 @@ export const createSentryMetroSerializer = (customSerializer?: MetroSerializer):
     const modifiedPreModules = prependModule(preModules, debugIdModule);
 
     // Run wrapped serializer
-    const serializerResult = serializer(entryPoint, modifiedPreModules, graph, options);
-    const { code: bundleCode, map: bundleMapString } = await extractSerializerResult(serializerResult);
+    const serializerResult = await serializer(entryPoint, modifiedPreModules, graph, options);
+    const bundle = extractSerializerResult(serializerResult);
+    if (!bundle) {
+      // The wrapped serializer returned a non-standard output that is not a single
+      // `{ code, map }` bundle (for example Expo's static/EAS Update export, which returns an
+      // array of serial assets). We can't inject a Sentry Debug ID into such output here, so we
+      // return it untouched to avoid crashing the bundler. Debug IDs for these outputs are added
+      // by Expo's own serializer.
+      // https://github.com/getsentry/sentry-react-native/issues/6650
+      return serializerResult;
+    }
+    const { code: bundleCode, map: bundleMapString } = bundle;
 
     // Add debug id comment to the bundle
     let debugId = determineDebugIdFromBundleSource(bundleCode);
@@ -133,21 +143,31 @@ function createSentryBundleCallback(debugIdModule: Module<VirtualJSOutput> & { s
   };
 }
 
-async function extractSerializerResult(serializerResult: MetroSerializerOutput): Promise<SerializedBundle> {
+/**
+ * Normalizes an (already awaited) Metro serializer result into a `{ code, map }` bundle.
+ *
+ * Returns `null` when the result is not a standard single bundle (for example an array of serial
+ * assets produced by Expo's static export), so callers can skip Debug ID injection instead of
+ * crashing. We must not use `'map' in result` to detect a bundle: for arrays that is always `true`
+ * because of `Array.prototype.map`, which would yield `{ code: undefined }`.
+ * https://github.com/getsentry/sentry-react-native/issues/6650
+ */
+function extractSerializerResult(serializerResult: unknown): SerializedBundle | null {
   if (typeof serializerResult === 'string') {
     return { code: serializerResult, map: '{}' };
   }
 
-  if ('map' in serializerResult) {
-    return { code: serializerResult.code, map: serializerResult.map };
-  }
-
-  const awaitedResult = await serializerResult;
-  if (typeof awaitedResult === 'string') {
-    return { code: awaitedResult, map: '{}' };
+  if (
+    serializerResult !== null &&
+    typeof serializerResult === 'object' &&
+    !Array.isArray(serializerResult) &&
+    typeof (serializerResult as Partial<SerializedBundle>).code === 'string'
+  ) {
+    const { code, map } = serializerResult as SerializedBundle;
+    return { code, map: typeof map === 'string' ? map : '{}' };
   }
 
-  return { code: awaitedResult.code, map: awaitedResult.map };
+  return null;
 }
 
 function createDebugIdModule(debugId: string): Module<VirtualJSOutput> & { setSource: (code: string) => void } {

packages/core/test/tools/sentryMetroSerializer.test.ts

@@ -111,6 +111,32 @@ describe('Sentry Metro Serializer', () => {
     }
   });
 
+  test('does not crash when wrapped serializer returns an array (Expo static export)', async () => {
+    // Expo's Metro serializer returns a non-standard output (e.g. an array of serial assets)
+    // when doing a static/EAS Update export. The array must not be mistaken for a { code, map }
+    // bundle. Note `'map' in []` is `true` because of Array.prototype.map, which used to make the
+    // serializer return `{ code: undefined }` and crash in determineDebugIdFromBundleSource.
+    // https://github.com/getsentry/sentry-react-native/issues/6650
+    const serialAssets = [{ filename: 'index.js', source: 'console.log("a");' }];
+    const customSerializer = (() => serialAssets) as unknown as MetroSerializer;
+
+    const serializer = createSentryMetroSerializer(customSerializer);
+    const bundle = await serializer(...mockMinSerializerArgs());
+
+    // The original non-standard result is returned untouched (no debug ID injection, no crash).
+    expect(bundle).toBe(serialAssets);
+  });
+
+  test('does not crash when wrapped serializer returns a promise resolving to an array', async () => {
+    const serialAssets = [{ filename: 'index.js', source: 'console.log("a");' }];
+    const customSerializer = (() => Promise.resolve(serialAssets)) as unknown as MetroSerializer;
+
+    const serializer = createSentryMetroSerializer(customSerializer);
+    const bundle = await serializer(...mockMinSerializerArgs());
+
+    expect(bundle).toBe(serialAssets);
+  });
+
   describe('calculateDebugId', () => {
     // We need to access the private function for testing
     const crypto = require('crypto');