fix(module-runner): don't crash stack-trace source mapping when globalThis.Buffer is absent (#22945)

Teglgaard · cursoragent · web-flow · commit f8b38e316bce · 2026-07-16T13:52:24.000+09:00
Co-authored-by: Cursor &lt;cursoragent@cursor.com&gt;
diff --git a/packages/vite/src/module-runner/sourcemap/interceptor.ts b/packages/vite/src/module-runner/sourcemap/interceptor.ts
@@ -1,6 +1,6 @@
 import type { OriginalMapping } from '@jridgewell/trace-mapping'
 import type { ModuleRunner } from '../runner'
-import { posixDirname, posixResolve } from '../utils'
+import { decodeBase64, posixDirname, posixResolve } from '../utils'
 import type { EvaluatedModules } from '../evaluatedModules'
 import { slash } from '../../shared/utils'
 import { DecodedMap, getOriginalPosition } from './decoder'
@@ -154,7 +154,7 @@ function retrieveSourceMap(source: string) {
   if (reSourceMap.test(sourceMappingURL)) {
     // Support source map URL as a data url
     const rawData = sourceMappingURL.slice(sourceMappingURL.indexOf(',') + 1)
-    sourceMapData = Buffer.from(rawData, 'base64').toString()
+    sourceMapData = decodeBase64(rawData)
     sourceMappingURL = source
   } else {
     // Support source map URLs relative to the source URL
diff --git a/packages/vite/src/module-runner/utils.ts b/packages/vite/src/module-runner/utils.ts
@@ -4,8 +4,13 @@ import { isWindows } from '../shared/utils'
 const textDecoder = new TextDecoder()
 
 export const decodeBase64: (base64: string) => string = (() => {
-  if (typeof Buffer === 'function' && typeof Buffer.from === 'function') {
-    return (base64: string) => Buffer.from(base64, 'base64').toString('utf-8')
+  // Capture the binding at module load: realms may legitimately delete
+  // `globalThis.Buffer` afterwards (e.g. browser-parity tests), and this
+  // decoder runs lazily while preparing stack traces
+  const capturedBuffer = typeof Buffer === 'function' ? Buffer : undefined
+  if (capturedBuffer && typeof capturedBuffer.from === 'function') {
+    return (base64: string) =>
+      capturedBuffer.from(base64, 'base64').toString('utf-8')
   }
 
   return (base64: string) =>
diff --git a/packages/vite/src/node/ssr/runtime/__tests__/server-source-maps.spec.ts b/packages/vite/src/node/ssr/runtime/__tests__/server-source-maps.spec.ts
@@ -4,6 +4,7 @@ import { describe, expect } from 'vitest'
 import type { ViteDevServer } from '../../..'
 import type { ModuleRunnerContext } from '../../../../module-runner'
 import { ESModulesEvaluator } from '../../../../module-runner'
+import { SOURCEMAPPING_URL } from '../../../../shared/constants'
 import {
   createFixtureEditor,
   createModuleRunnerTester,
@@ -156,6 +157,29 @@ describe('module runner initialization', async () => {
       ]
     `)
   })
+
+  it('should not crash when preparing a stack trace while globalThis.Buffer is absent', async ({
+    runner,
+    server,
+  }) => {
+    const mod = await runner.import('/fixtures/throws-error-method.ts')
+    const methodError = await getError(() => mod.throwError())
+
+    // Realms may legitimately remove `Buffer` after modules were loaded
+    // (e.g. browser-parity tests). Preparing a stack in that window must not
+    // depend on the global still existing.
+    const bufferBackup = globalThis.Buffer
+    Reflect.deleteProperty(globalThis, 'Buffer')
+    try {
+      // `.stack` access lazily invokes `prepareStackTrace`, which decodes the
+      // inline source map of the runner module
+      expect(serializeStack(server, methodError)).toBe(
+        '    at Module.throwError (<root>/fixtures/throws-error-method.ts:6:9)',
+      )
+    } finally {
+      globalThis.Buffer = bufferBackup
+    }
+  })
 })
 
 describe('module runner with node:vm executor', async () => {
@@ -193,3 +217,68 @@ describe('module runner with node:vm executor', async () => {
     ).not.toThrow()
   })
 })
+
+describe('module runner interceptor with inline data: source map', async () => {
+  const syntheticFile = '/virtual-bufferless/inline-map.js'
+  // Minimal map pointing every generated position at line 1, column 0 of
+  // "inline-map-original.ts"
+  const syntheticSourceMap = {
+    version: 3,
+    sources: ['inline-map-original.ts'],
+    names: [],
+    mappings: 'AAAA',
+  }
+  // The comment token is composed from SOURCEMAPPING_URL so that this spec
+  // file itself never contains it (see shared/constants.ts)
+  const syntheticFileContent =
+    `throw new Error('example')\n` +
+    `//# ${SOURCEMAPPING_URL}=data:application/json;base64,${btoa(
+      JSON.stringify(syntheticSourceMap),
+    )}\n`
+
+  class Evaluator extends ESModulesEvaluator {
+    async runInlinedModule(_: ModuleRunnerContext, __: string) {
+      const initModule = runInThisContext(
+        '() => { throw new Error("example") }',
+        { filename: syntheticFile },
+      )
+
+      initModule()
+    }
+  }
+
+  const it = await createModuleRunnerTester(
+    {},
+    {
+      sourcemapInterceptor: {
+        // Serves a file that is not part of the runner module graph and
+        // carries an inline base64 source map, so mapping goes through
+        // `retrieveSourceMap` instead of the runner graph
+        retrieveFile(id) {
+          if (id === syntheticFile) {
+            return syntheticFileContent
+          }
+        },
+      },
+      evaluator: new Evaluator(),
+    },
+  )
+
+  it('should not crash when decoding an inline source map while globalThis.Buffer is absent', async ({
+    runner,
+  }) => {
+    const error: Error = await runner
+      .import('/fixtures/a.ts')
+      .catch((err) => err)
+
+    const bufferBackup = globalThis.Buffer
+    Reflect.deleteProperty(globalThis, 'Buffer')
+    try {
+      expect(error.stack).toContain(
+        '/virtual-bufferless/inline-map-original.ts:1:1',
+      )
+    } finally {
+      globalThis.Buffer = bufferBackup
+    }
+  })
+})
