Build: Address latest review feedback for robustness and CI stability

- Exit explicitly after one-off watch closes; set exit code on errors
- Guard os.cpus() with try/catch; default cpuCount to 1
- Leave one CPU core free by default for thread-loader workers
- Add fallback to  if  import fails
- Close webpack compiler after production run completes
- Version filesystem cache with env-affecting options (thread/worker/cache/prod)
- Harden zip creation with error handling and close event awaiting

These changes reduce chances of hung processes, stale/incorrect caches,
resource leaks, and unnoticed zip errors, improving reliability in local
and CI builds.

Author: PeterDaveHello

build.mjs

@@ -32,8 +32,14 @@ if (cacheCompressionEnv != null) {
     cacheCompressionOption = false
   }
 }
-const cpuCountRaw = os.cpus()?.length
-const cpuCount = Number.isInteger(cpuCountRaw) && cpuCountRaw > 0 ? cpuCountRaw : 1
+let cpuCount = 1
+try {
+  const cpuInfo = os.cpus && os.cpus()
+  const len = Array.isArray(cpuInfo) ? cpuInfo.length : 0
+  cpuCount = Number.isInteger(len) && len > 0 ? len : 1
+} catch {
+  cpuCount = 1
+}
 const rawWorkers = process.env.BUILD_THREAD_WORKERS
   ? parseInt(process.env.BUILD_THREAD_WORKERS, 10)
   : undefined
@@ -78,8 +84,16 @@ async function runWebpack(isWithoutKatex, isWithoutTiktoken, minimal, sourceBuil
   ]
   if (isWithoutKatex) shared.push('./src/components')
 
-  // Use the default export from sass-embedded; sass-loader expects the implementation object
-  const { default: sassImpl } = await import('sass-embedded')
+  // Use the default export from sass-embedded; sass-loader expects the implementation object.
+  // Fallback to `sass` if sass-embedded is unavailable.
+  let sassImpl
+  try {
+    const mod = await import('sass-embedded')
+    sassImpl = mod.default || mod
+  } catch (e) {
+    const mod = await import('sass')
+    sassImpl = mod.default || mod
+  }
 
   const variantId = [
     isWithoutKatex ? 'no-katex' : 'with-katex',
@@ -117,6 +131,12 @@ async function runWebpack(isWithoutKatex, isWithoutTiktoken, minimal, sourceBuil
     cache: {
       type: 'filesystem',
       name: `webpack-${variantId}`,
+      version: JSON.stringify({
+        THREAD: enableThread,
+        WORKERS: threadWorkers,
+        CACHE_COMP: cacheCompressionOption ?? false,
+        PROD: isProduction,
+      }),
       // default none; override via BUILD_CACHE_COMPRESSION=gzip|brotli
       compression: cacheCompressionOption ?? false,
       buildDependencies: {
@@ -341,27 +361,57 @@ async function runWebpack(isWithoutKatex, isWithoutTiktoken, minimal, sourceBuil
       ],
     },
   })
-  if (isProduction) compiler.run(callback)
-  else {
+  if (isProduction) {
+    // Ensure compiler is properly closed after production runs
+    compiler.run((err, stats) => {
+      const finishClose = () =>
+        compiler.close((closeErr) => {
+          if (closeErr) console.error('Error closing compiler:', closeErr)
+        })
+      try {
+        const ret = callback(err, stats)
+        if (ret && typeof ret.then === 'function') {
+          ret.then(finishClose, finishClose)
+        } else {
+          finishClose()
+        }
+      } catch (_) {
+        finishClose()
+      }
+    })
+  } else {
     const watching = compiler.watch({}, (err, stats) => {
+      const hasErrors = !!(
+        err ||
+        (stats && typeof stats.hasErrors === 'function' && stats.hasErrors())
+      )
       callback(err, stats)
       if (process.env.BUILD_WATCH_ONCE) {
         watching.close((closeErr) => {
           if (closeErr) console.error('Error closing watcher:', closeErr)
+          // Exit explicitly to prevent hanging processes in CI
+          // Use non-zero exit code when errors occurred
+          process.exit(hasErrors || closeErr ? 1 : 0)
         })
       }
     })
   }
 }
 
 async function zipFolder(dir) {
-  const output = fs.createWriteStream(`${dir}.zip`)
-  const archive = archiver('zip', {
-    zlib: { level: 9 },
+  const zipPath = `${dir}.zip`
+  await fs.ensureDir(path.dirname(zipPath))
+  await new Promise((resolve, reject) => {
+    const output = fs.createWriteStream(zipPath)
+    const archive = archiver('zip', { zlib: { level: 9 } })
+    const onError = (err) => reject(err)
+    output.on('error', onError)
+    archive.on('error', onError)
+    output.on('close', resolve)
+    archive.pipe(output)
+    archive.directory(dir, false)
+    archive.finalize().catch(onError)
   })
-  archive.pipe(output)
-  archive.directory(dir, false)
-  await archive.finalize()
 }
 
 async function copyFiles(entryPoints, targetDir) {