fix: stabilize Vite 8/Rolldown beta and merge pending fixes

Fork release as @desirecore/electron-vite (v6.0.0-beta.2). Fixes a batch
of Vite 8 / Rolldown regressions and Electron 42 support, and merges
several long-pending upstream fixes.

- fix(esmShim): AST-based CJS shim injection at offset 0, no longer
  corrupts large Vite 8/Rolldown ESM bundles (alex8088#906)
- fix(swc): also set `oxc: false` to disable Vite 8 default transform (alex8088#916)
- fix(config): do not throw on non-plain objects when isolating config (alex8088#902)
- fix(renderer): re-root when HTML entry is outside root, avoid illegal
  `../` emit paths under Rolldown (alex8088#915)
- fix(bytecode): compile via vm.compileFunction in the consuming process
  type, fixing cachedDataRejected on Electron 42 / V8 14.8 (alex8088#911, alex8088#912)
- fix(bytecode): remove non-deterministic compile race (alex8088#910)
- fix(bytecode): correct renderer preset plugin name; locate the compiler
  script relative to this module so it survives package renames
- fix(modulePath): inject modulePathPlugin into the sub-build for nested
  `?modulePath` and re-exports (alex8088#860, alex8088#862)
- fix(dev): forward signals to the Electron child and escalate to SIGKILL
  on restart, fixing zombie processes (alex8088#899, alex8088#734, alex8088#353)
- feat: support Electron 42 targets and lazy electron install (alex8088#904)
- feat(bytecode): allow RegExp for chunkAlias; protect string concat (alex8088#885)
- feat(cli): add --noElectronStart (alex8088#578) and --electronPackage (alex8088#867)
- feat: export workerPlugin (alex8088#480)

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

Author: yi-ge

CHANGELOG.md

@@ -1,3 +1,25 @@
+### v6.0.0-beta.2 (_2026-06-27_)
+
+> Fork release published as `@desirecore/electron-vite` (CLI command stays `electron-vite`). Stabilizes the Vite 8 / Rolldown beta and merges a batch of long-pending upstream fixes. Issue links reference the upstream `alex8088/electron-vite` tracker.
+
+- fix(esmShim): inject the CommonJS shim via AST detection at offset 0 to stop corrupting large Vite 8/Rolldown ESM bundles ([#906](https://github.com/alex8088/electron-vite/issues/906))
+- fix(swc): also set `oxc: false` so `swcPlugin` disables Vite 8's default Oxc transform ([#916](https://github.com/alex8088/electron-vite/issues/916))
+- fix(config): no longer throw on non-plain objects (plugin/class instances) when isolating sub-build config ([#902](https://github.com/alex8088/electron-vite/issues/902))
+- fix(renderer): re-root renderer build when the HTML entry lives outside `root`, avoiding illegal `../` emit paths under Rolldown ([#915](https://github.com/alex8088/electron-vite/issues/915))
+- fix(bytecode): compile via `vm.compileFunction` inside the consuming process type to fix `cachedDataRejected` crashes on Electron 42 / V8 14.8 ([#911](https://github.com/alex8088/electron-vite/issues/911), [#912](https://github.com/alex8088/electron-vite/pull/912))
+- fix(bytecode): remove a non-deterministic compile race that intermittently produced bad bundles ([#910](https://github.com/alex8088/electron-vite/issues/910))
+- fix(bytecode): correct the renderer preset plugin name so the renderer guard actually applies
+- fix(modulePath): inject `modulePathPlugin` into the sub-build so nested `?modulePath` and re-exports resolve ([#860](https://github.com/alex8088/electron-vite/issues/860), [#862](https://github.com/alex8088/electron-vite/issues/862))
+- fix(dev): forward `SIGINT`/`SIGTERM`/`SIGHUP` to the Electron child and escalate to `SIGKILL` on restart, fixing zombie Electron processes ([#899](https://github.com/alex8088/electron-vite/issues/899), [#734](https://github.com/alex8088/electron-vite/issues/734), [#353](https://github.com/alex8088/electron-vite/issues/353))
+- feat: support Electron 42 build targets and lazily run `electron/install.js` when the binary is missing on Electron ≥ 42 ([#904](https://github.com/alex8088/electron-vite/issues/904))
+- feat(bytecode): allow `RegExp` (and mixed arrays) for the `chunkAlias` option ([#885](https://github.com/alex8088/electron-vite/pull/885))
+- feat(bytecode): protect static string-concatenation expressions
+- feat(cli): add `--noElectronStart` to run dev servers without launching Electron ([#578](https://github.com/alex8088/electron-vite/pull/578))
+- feat(cli): add `--electronPackage <name>` to support a custom Electron package name ([#867](https://github.com/alex8088/electron-vite/pull/867))
+- feat: export `workerPlugin` ([#480](https://github.com/alex8088/electron-vite/pull/480))
+
+> Note: with `build.bytecode`, compilation now launches a real Electron process. On Linux without a display, run under `xvfb-run`.
+
 ### v6.0.0-beta.0 (_2026-04-12_)
 
 - refactor!: simplify resolve config and isolate user config for sub-builds

README.md

@@ -41,8 +41,10 @@
 
 ### Install
 
+> This is a community fork published as [`@desirecore/electron-vite`](https://www.npmjs.com/package/@desirecore/electron-vite). The CLI command stays `electron-vite`.
+
 ```sh
-npm i electron-vite -D
+npm i @desirecore/electron-vite -D
 ```
 
 ### Development & Build

bin/electron-bytecode-preload.cjs

@@ -0,0 +1,24 @@
+// Bytecode compiler preload. Runs in a renderer process (sandbox:false) so the produced
+// V8 code cache matches the isolate (snapshot + flag hash) of the app's runtime preload,
+// which the browser/main process cache would not on Electron 42+ (V8 14.8). The compile
+// result (or error) is reported back over IPC. See bin/electron-bytecode.cjs.
+const fs = require('fs')
+const vm = require('vm')
+const v8 = require('v8')
+const { ipcRenderer } = require('electron')
+
+v8.setFlagsFromString('--no-lazy')
+v8.setFlagsFromString('--no-flush-bytecode')
+
+const COMPILE_PARAMS = ['exports', 'require', 'module', '__filename', '__dirname']
+
+let error = ''
+try {
+  const code = fs.readFileSync(process.env.ELECTRON_VITE_BYTECODE_IN, 'utf-8')
+  const fn = vm.compileFunction(code, COMPILE_PARAMS, { produceCachedData: true })
+  fs.writeFileSync(process.env.ELECTRON_VITE_BYTECODE_OUT, fn.cachedData)
+} catch (err) {
+  error = String(err && err.stack ? err.stack : err)
+}
+
+ipcRenderer.send('electron-vite:bytecode-done', error)

bin/electron-bytecode.cjs

@@ -1,32 +1,74 @@
+const { app } = require('electron')
 const vm = require('vm')
 const v8 = require('v8')
-const wrap = require('module').wrap
+const fs = require('fs')
+const path = require('path')
 
 v8.setFlagsFromString('--no-lazy')
 v8.setFlagsFromString('--no-flush-bytecode')
 
-let code = ''
+// Compile a chunk to a V8 code cache inside the SAME process type that will load it.
+// On Electron 42+ (V8 14.8) the cache is bound to a per-process-type snapshot/isolate
+// checksum (header @16) and a flag hash, so a cache produced in the wrong process type is
+// rejected (and force-patching the header corrupts execution). The compiler is therefore
+// launched as a real Electron app (never ELECTRON_RUN_AS_NODE, whose isolate matches
+// neither the main nor the renderer process):
+//   - main / node chunks -> compiled here, in the browser (main) process.
+//   - preload chunks      -> ELECTRON_VITE_BYTECODE_RENDERER=1: compiled in a renderer
+//                            isolate by the sandbox:false preload of a hidden window.
+// Input/output go through temp files (a GUI process has no usable stdio pipe).
+const COMPILE_PARAMS = ['exports', 'require', 'module', '__filename', '__dirname']
+const inFile = process.env.ELECTRON_VITE_BYTECODE_IN
+const outFile = process.env.ELECTRON_VITE_BYTECODE_OUT
 
-process.stdin.setEncoding('utf-8')
+const fail = error => {
+  process.stderr.write(`${error && error.stack ? error.stack : error}\n`)
+  process.exitCode = 1
+}
 
-process.stdin.on('readable', () => {
-  const data = process.stdin.read()
-  if (data !== null) {
-    code += data
-  }
-})
+// Headless: no GPU, no visible window.
+app.disableHardwareAcceleration()
 
-process.stdin.on('end', () => {
-  try {
-    if (typeof code !== 'string') {
-      throw new Error(`javascript code must be string. ${typeof code} was given.`)
+if (process.env.ELECTRON_VITE_BYTECODE_RENDERER) {
+  const { BrowserWindow, ipcMain } = require('electron')
+  app.whenReady().then(() => {
+    // Guard against a renderer that never reports back, so the build can't hang forever.
+    const timer = setTimeout(() => {
+      fail(new Error('bytecode compilation timed out'))
+      app.quit()
+    }, 60000)
+    ipcMain.once('electron-vite:bytecode-done', (_event, error) => {
+      clearTimeout(timer)
+      if (error) {
+        fail(error)
+      }
+      app.quit()
+    })
+    try {
+      const win = new BrowserWindow({
+        show: false,
+        webPreferences: {
+          preload: path.join(__dirname, 'electron-bytecode-preload.cjs'),
+          sandbox: false,
+          contextIsolation: true
+        }
+      })
+      win.loadURL('data:text/html,<!doctype html><html></html>')
+    } catch (error) {
+      clearTimeout(timer)
+      fail(error)
+      app.quit()
     }
-
-    const script = new vm.Script(wrap(code), { produceCachedData: true })
-    const bytecodeBuffer = script.createCachedData()
-
-    process.stdout.write(bytecodeBuffer)
-  } catch (error) {
-    console.error(error)
-  }
-})
+  })
+} else {
+  app.whenReady().then(() => {
+    try {
+      const code = fs.readFileSync(inFile, 'utf-8')
+      const fn = vm.compileFunction(code, COMPILE_PARAMS, { produceCachedData: true })
+      fs.writeFileSync(outFile, fn.cachedData)
+    } catch (error) {
+      fail(error)
+    }
+    app.quit()
+  })
+}

package.json

@@ -1,6 +1,6 @@
 {
-  "name": "electron-vite",
-  "version": "6.0.0-beta.1",
+  "name": "@desirecore/electron-vite",
+  "version": "6.0.0-beta.2",
   "description": "Electron build tooling based on Vite",
   "type": "module",
   "main": "./dist/index.js",
@@ -28,12 +28,15 @@
   "license": "MIT",
   "repository": {
     "type": "git",
-    "url": "git+https://github.com/alex8088/electron-vite.git"
+    "url": "git+https://github.com/desirecore/electron-vite.git"
   },
   "bugs": {
-    "url": "https://github.com/alex8088/electron-vite/issues"
+    "url": "https://github.com/desirecore/electron-vite/issues"
+  },
+  "homepage": "https://github.com/desirecore/electron-vite",
+  "publishConfig": {
+    "access": "public"
   },
-  "homepage": "https://electron-vite.org",
   "keywords": [
     "electron",
     "vite",

src/cli.ts

@@ -26,6 +26,7 @@ interface GlobalCLIOptions {
   watch?: boolean
   outDir?: string
   entry?: string
+  electronPackage?: string
 }
 
 interface DevCLIOptions {
@@ -34,6 +35,7 @@ interface DevCLIOptions {
   remoteDebuggingPort?: string
   noSandbox?: boolean
   rendererOnly?: boolean
+  noElectronStart?: boolean
 }
 
 interface PreviewCLIOptions {
@@ -68,6 +70,7 @@ cli
   .option('--sourcemap', `[boolean] output source maps for debug (default: false)`)
   .option('--outDir <dir>', `[string] output directory (default: out)`)
   .option('--entry <file>', `[string] specify electron entry file`)
+  .option('--electronPackage <name>', `[string] specify electron package name (default: electron)`)
 
 // dev
 cli
@@ -80,6 +83,7 @@ cli
   .option('--remoteDebuggingPort <port>', `[string] port for remote debugging`)
   .option('--noSandbox', `[boolean] forces renderer process to run un-sandboxed`)
   .option('--rendererOnly', `[boolean] only dev server for the renderer`)
+  .option('--noElectronStart', `[boolean] run dev servers without starting the electron app`)
   .action(async (root: string, options: DevCLIOptions & GlobalCLIOptions) => {
     if (options.remoteDebuggingPort) {
       process.env.REMOTE_DEBUGGING_PORT = options.remoteDebuggingPort
@@ -105,11 +109,18 @@ cli
       process.env.ELECTRON_ENTRY = options.entry
     }
 
+    if (options.electronPackage) {
+      process.env.ELECTRON_PKG_NAME = options.electronPackage
+    }
+
     const { createServer } = await import('./server')
     const inlineConfig = createInlineConfig(root, options)
 
     try {
-      await createServer(inlineConfig, { rendererOnly: options.rendererOnly })
+      await createServer(inlineConfig, {
+        rendererOnly: options.rendererOnly,
+        noElectronStart: options.noElectronStart
+      })
     } catch (e) {
       const error = e as Error
       createLogger(options.logLevel).error(
@@ -129,6 +140,10 @@ cli.command('build [root]', 'build for production').action(async (root: string,
     process.env.ELECTRON_ENTRY = options.entry
   }
 
+  if (options.electronPackage) {
+    process.env.ELECTRON_PKG_NAME = options.electronPackage
+  }
+
   try {
     await build(inlineConfig)
   } catch (e) {
@@ -155,6 +170,10 @@ cli
       process.env.ELECTRON_ENTRY = options.entry
     }
 
+    if (options.electronPackage) {
+      process.env.ELECTRON_PKG_NAME = options.electronPackage
+    }
+
     if (options['--']) {
       process.env.ELECTRON_CLI_ARGS = JSON.stringify(options['--'])
     }

src/electron.ts

@@ -1,11 +1,18 @@
 import path from 'node:path'
 import fs from 'node:fs'
 import { createRequire } from 'node:module'
-import { type ChildProcess, spawn } from 'node:child_process'
+import { type ChildProcess, spawn, spawnSync } from 'node:child_process'
+import colors from 'picocolors'
+import { createLogger } from 'vite'
 import { loadPackageData } from './utils'
 
 const _require = createRequire(import.meta.url)
 
+// The Electron package name, defaults to 'electron'. A custom build (e.g.
+// '@overwolf/ow-electron') can be selected via the ELECTRON_PKG_NAME env var,
+// which is set from the `--electronPackage` CLI option.
+const getElectronPackageName = (): string => process.env.ELECTRON_PKG_NAME || 'electron'
+
 const ensureElectronEntryFile = (root = process.cwd()): void => {
   if (process.env.ELECTRON_ENTRY) return
   const pkg = loadPackageData()
@@ -26,7 +33,7 @@ const ensureElectronEntryFile = (root = process.cwd()): void => {
 const getElectronMajorVer = (): string => {
   let majorVer = process.env.ELECTRON_MAJOR_VER || ''
   if (!majorVer) {
-    const pkg = _require.resolve('electron/package.json')
+    const pkg = _require.resolve(`${getElectronPackageName()}/package.json`)
     if (fs.existsSync(pkg)) {
       const version = _require(pkg).version
       majorVer = version.split('.')[0]
@@ -46,20 +53,41 @@ export function supportImportMetaPaths(): boolean {
   return parseInt(majorVer) >= 30
 }
 
+// Electron 42+ no longer downloads its binary via a `postinstall` script
+// (supply-chain hardening). Instead the binary is fetched on first launch by
+// running the package's own `install.js`, mirroring what `npx electron` does.
+function installElectronBinary(electronModulePath: string): void {
+  const installScript = path.join(electronModulePath, 'install.js')
+  if (!fs.existsSync(installScript)) {
+    throw new Error(`Electron install script not found at "${installScript}", please reinstall the electron package`)
+  }
+  createLogger().info(colors.green('Electron binary not found, downloading...'))
+  const result = spawnSync(process.execPath, [installScript], { stdio: 'inherit', cwd: electronModulePath })
+  if (result.status !== 0) {
+    throw new Error('Failed to download the Electron binary')
+  }
+}
+
 export function getElectronPath(): string {
   let electronExecPath = process.env.ELECTRON_EXEC_PATH || ''
   if (!electronExecPath) {
-    const electronModulePath = path.dirname(_require.resolve('electron'))
+    const electronPkgName = getElectronPackageName()
+    const electronModulePath = path.dirname(_require.resolve(electronPkgName))
     const pathFile = path.join(electronModulePath, 'path.txt')
-    let executablePath
-    if (fs.existsSync(pathFile)) {
-      executablePath = fs.readFileSync(pathFile, 'utf-8')
+    const readExecutablePath = (): string | undefined =>
+      fs.existsSync(pathFile) ? fs.readFileSync(pathFile, 'utf-8') : undefined
+    let executablePath = readExecutablePath()
+    if (!executablePath && parseInt(getElectronMajorVer()) >= 42) {
+      installElectronBinary(electronModulePath)
+      executablePath = readExecutablePath()
     }
     if (executablePath) {
       electronExecPath = path.join(electronModulePath, 'dist', executablePath)
       process.env.ELECTRON_EXEC_PATH = electronExecPath
     } else {
-      throw new Error('Electron uninstall')
+      throw new Error(
+        `The Electron package "${electronPkgName}" is not installed correctly, please reinstall it and try again`
+      )
     }
   }
   return electronExecPath
@@ -69,6 +97,7 @@ export function getElectronNodeTarget(): string {
   const electronVer = getElectronMajorVer()
 
   const nodeVer = {
+    '42': '24.15',
     '41': '24.14',
     '40': '24.14',
     '39': '22.20',
@@ -102,6 +131,7 @@ export function getElectronChromeTarget(): string {
   const electronVer = getElectronMajorVer()
 
   const chromeVer = {
+    '42': '148',
     '41': '146',
     '40': '144',
     '39': '142',
@@ -159,7 +189,41 @@ export function startElectron(root: string | undefined): ChildProcess {
   const entry = process.env.ELECTRON_ENTRY || '.'
 
   const ps = spawn(electronPath, [entry].concat(args), { stdio: 'inherit' })
-  ps.on('close', process.exit)
+
+  currentElectronPs = ps
+  installSignalForwarding()
+
+  ps.on('close', (code, signal) => {
+    // A hot reload replaces the child via a new startElectron call. Only the
+    // active child should terminate the parent; otherwise restarting would
+    // bring down the dev server.
+    if (currentElectronPs === ps) {
+      process.exit(code ?? (signal ? 1 : 0))
+    }
+  })
 
   return ps
 }
+
+// The currently running Electron child. Updated on every (re)start so a single
+// set of signal handlers always targets the live process.
+let currentElectronPs: ChildProcess | undefined
+let signalHandlersInstalled = false
+
+// Forward termination signals to the Electron child instead of letting the
+// parent die immediately, matching electron's own CLI wrapper (electron/cli.js).
+// This lets the app run its quit handlers and prevents orphaned/zombie Electron
+// processes on Ctrl-C or when a parent task runner stops us. Handlers are
+// installed once to avoid leaking across hot-reload restarts.
+function installSignalForwarding(): void {
+  if (signalHandlersInstalled) return
+  signalHandlersInstalled = true
+  for (const signal of ['SIGINT', 'SIGTERM', 'SIGHUP'] as const) {
+    process.on(signal, () => {
+      const ps = currentElectronPs
+      if (ps && ps.exitCode === null && !ps.killed) {
+        ps.kill(signal)
+      }
+    })
+  }
+}