perf(module-runner): skip cloning call sites that have no source map

[Cherry]

Discovered this while benchmarking a larger project internally.

wrapCallSite clones every stack frame, even when the frame has no source map and the clone prints exactly what the original would. This skips the clone in that case.

It mostly matters in Vitest browser mode with vi.mock, where every module request goes through a Playwright route and Playwright captures a stack per call. The repro below formats ~36k stacks per run:

time in prepareStackTrace	before	after
repro, 3 runs	3.3-3.4s	1.1s

Stack output is unchanged. The new test covers the one case where skipping the clone would print a different file name.

Reproduction

npm install && node gen.mjs && npx vitest run, timing is printed at the end.

package.json

{
  "name": "vite-stack-trace-repro",
  "private": true,
  "type": "module",
  "scripts": {
    "gen": "node gen.mjs",
    "test": "vitest run"
  },
  "devDependencies": {
    "@vitest/browser-playwright": "^4.1.11",
    "playwright": "^1.63.0",
    "vitest": "^4.1.11"
  }
}

vitest.config.ts

import { playwright } from '@vitest/browser-playwright'
import { defineConfig } from 'vitest/config'

export default defineConfig({
  test: {
    include: ['tests/**/*.test.ts'],
    setupFiles: ['./setup.ts'],
    globalSetup: ['./measure.ts'],
    browser: {
      enabled: true,
      headless: true,
      provider: playwright(),
      instances: [{ browser: 'chromium' }],
    },
  },
})

setup.ts

import { vi } from 'vitest'

// one mock in a setup file, as many browser-mode suites have for analytics or similar
vi.mock('./src/analytics', () => ({ track: vi.fn() }))

measure.ts

// Times Error.prepareStackTrace in the Vitest main process, where Vite's module runner installs it.
let stacks = 0
let frames = 0
let ms = 0

export function setup() {
  const original = Error.prepareStackTrace!
  Error.prepareStackTrace = function (error, callSites) {
    const start = performance.now()
    try {
      return original.call(this, error, callSites)
    } finally {
      stacks++
      frames += callSites.length
      ms += performance.now() - start
    }
  }
}

export function teardown() {
  console.log(`stacks formatted: ${stacks}, frames: ${frames}, time in prepareStackTrace: ${ms.toFixed(0)} ms`)
}

gen.mjs

// Writes 300 small modules and 30 test files that each import all of them.
import fs from 'node:fs'

fs.rmSync('src', { recursive: true, force: true })
fs.rmSync('tests', { recursive: true, force: true })
fs.mkdirSync('src')
fs.mkdirSync('tests')
const modules = 300
for (let i = 0; i < modules; i++) {
  fs.writeFileSync(
    `src/m${i}.ts`,
    `export interface Item${i} { id: number; label: string }\nexport function make${i}(id: number): Item${i} {\n  return { id, label: 'item ${i}' }\n}\n`,
  )
}
fs.writeFileSync('src/analytics.ts', `export function track(event: string): void {\n  console.log(event)\n}\n`)
fs.writeFileSync(
  'src/index.ts',
  Array.from({ length: modules }, (_, i) => `export * from './m${i}'`).join('\n') + '\n',
)
for (let t = 0; t < 30; t++) {
  fs.writeFileSync(
    `tests/t${t}.test.ts`,
    `import { expect, test } from 'vitest'\nimport * as all from '../src/index'\n\ntest('loads every module', () => {\n  expect(all.make${t}(${t}).id).toBe(${t})\n})\n`,
  )
}

AI disclosure: I used Claude Code to profile our test runs, write the benchmark harness and repro, and draft the change and test. I reviewed the diff line by line and had it check the remaining edge cases (eval, vm scripts with a sourceURL, async and native frames) for byte-identical stacks against unpatched Vite. I also had it confirm the win in a real suite rather than only a microbenchmark, which is how the vi.mock case came up.

[sapphi-red]

Thanks!