scripts/build-v8-bytecode.js

'use strict'

const fs = require('fs')
const path = require('path')
const { spawn } = require('child_process')
const bytenode = require('bytenode')

const FILES_TO_COMPILE = ['main.js']
const backups = new Map()
const generatedJsc = new Set()
let restoring = false

async function backupAndCompile() {
  for (const file of FILES_TO_COMPILE) {
    const absPath = path.join(process.cwd(), file)
    if (!fs.existsSync(absPath)) continue

    const backupPath = `${absPath}.backup`
    fs.copyFileSync(absPath, backupPath)
    backups.set(absPath, backupPath)

    const parsed = path.parse(absPath)
    const jscPath = path.join(parsed.dir, `${parsed.name}.jsc`)
    const existedBefore = fs.existsSync(jscPath)

    await bytenode.compileFile({
      filename: absPath,
      output: jscPath,
      electron: true,
      compileAsModule: true
    })

    if (!existedBefore) generatedJsc.add(jscPath)
    console.log(`[V8 Builder] Compiled ${file} -> ${path.basename(jscPath)}`)

    const relBase = parsed.name
    const requireLine = file === 'main.js'
      ? `module.exports = require('./${relBase}.jsc')`
      : `require('./${relBase}.jsc')`
    fs.writeFileSync(absPath, ["'use strict'", "require('bytenode')", requireLine, ''].join('\n'), 'utf8')
  }
}

function restoreFiles() {
  if (restoring) return
  restoring = true
  console.log('\n[V8 Builder] Restoring original source files...')
  for (const [absPath, backupPath] of backups) {
    try {
      if (fs.existsSync(backupPath)) {
        fs.copyFileSync(backupPath, absPath)
        fs.unlinkSync(backupPath)
        console.log(`[V8 Builder] Restored ${path.basename(absPath)}`)
      }
    } catch (err) {
      console.error(`[V8 Builder] restore failed for ${path.basename(absPath)}: ${err.message}`)
    }
  }
  for (const jscPath of generatedJsc) {
    try { if (fs.existsSync(jscPath)) fs.unlinkSync(jscPath) } catch {}
  }
}

process.on('SIGINT', () => { restoreFiles(); process.exit(1) })
process.on('uncaughtException', (err) => { console.error(err); restoreFiles(); process.exit(1) })

async function run() {
  try {
    console.log('=== Starting V8 Compilation and Build ===')
    await backupAndCompile()

    const builderCli = require.resolve('electron-builder/out/cli/cli.js')
    const extraArgs = process.argv.slice(2)
    const args = [builderCli, ...extraArgs]

    const child = spawn(process.execPath, args, { stdio: 'inherit', windowsHide: true, shell: false, env: { ...process.env } })
    child.on('exit', (code) => { restoreFiles(); process.exit(code ?? 1) })
    child.on('error', (err) => { console.error(`[V8 Builder] failed: ${err.message}`); restoreFiles(); process.exit(1) })
  } catch (err) {
    console.error(`[V8 Builder] prebuild failed: ${err.message}`)
    restoreFiles()
    process.exit(1)
  }
}

run()