Always pass --experimental-wasm-exnref when emitting WASM

Node 24 still ships V8 12.x where wasm-exnref is gated behind --experimental-wasm-exnref; the flag only flips to default in V8 13.x (Node 25+). The previous nodeMajorVersion < 24 guard therefore left Node 24 (the version pinned in CI) without the flag, which made any Scala.js WASM code using exception bytecodes, runtime throws, JS interop or Scala 3 @main fail at runtime. Same reasoning applies to Deno (Deno 2.x = V8 12.x).

Until V8 13.x is the default everywhere, just always set the flag, there is no any overhead

Author: lostflydev

modules/build/src/main/scala/scala/build/internal/Runner.scala

@@ -210,24 +210,26 @@ object Runner {
       case _: Exception => None
     }
 
-  // Node 24+ (V8 13+) has wasm-exnref enabled by default; older versions need --experimental-wasm-exnref.
-  private def nodeNeedsWasmFlag: Boolean =
-    nodeMajorVersion.forall(_ < 24) // true if unknown or < 24
-
-  // Detects the major version of Deno on PATH; cached for the JVM lifetime (lazy val).
-  // Returns None if deno is not found or version cannot be parsed.
-  private lazy val denoMajorVersion: Option[Int] =
+  // Pre-V8 13.x runtimes need --experimental-wasm-exnref for the Scala.js WASM exception model.
+  // V8 13.x ships in Node 25+ (Node 24 is still on V8 12.x where exnref is gated behind the flag),
+  // so until the default flips we always pass the flag when emitWasm is true.
+  private def nodeNeedsWasmFlag: Boolean = true
+
+  // Deno 2.x bundles V8 12.x where wasm-exnref is gated behind a flag; symmetrical reasoning to Node.
+  // We always set DENO_V8_FLAGS=--experimental-wasm-exnref on emitWasm until V8 13.x lands in Deno.
+  private def denoNeedsWasmFlag: Boolean = true
+
+  // Detects the major version of Bun on PATH; cached for the JVM lifetime (lazy val).
+  // Returns None if bun is not found or version cannot be parsed.
+  private lazy val bunMajorVersion: Option[Int] =
     try {
-      val process = new ProcessBuilder("deno", "--version")
+      val process = new ProcessBuilder("bun", "--version")
         .redirectErrorStream(true)
         .start()
       val output = new String(process.getInputStream.readAllBytes()).trim
       process.waitFor()
-      // Deno version format: "deno 2.1.0 (release, aarch64-apple-darwin)\nv8 13.x\ntypescript 5.x"
-      // Extract major from first line
-      val firstLine  = output.linesIterator.nextOption().getOrElse("")
-      val versionStr = firstLine.stripPrefix("deno ").takeWhile(c => c.isDigit || c == '.')
-      versionStr.takeWhile(_.isDigit) match {
+      // Bun version format: "1.1.30" -> extract 1
+      output.takeWhile(_.isDigit) match {
         case s if s.nonEmpty => Some(s.toInt)
         case _               => None
       }
@@ -236,10 +238,6 @@ object Runner {
       case _: Exception => None
     }
 
-  // Deno 2.x+ bundles V8 13+ which has wasm-exnref enabled by default; no flag needed.
-  private def denoNeedsWasmFlag: Boolean =
-    denoMajorVersion.forall(_ < 2) // true if unknown or < 2
-
   private def endsWithCaseInsensitive(s: String, suffix: String): Boolean =
     s.length >= suffix.length &&
     s.regionMatches(true, s.length - suffix.length, suffix, 0, suffix.length)
@@ -302,6 +300,10 @@ object Runner {
       value(findInPath("node")
         .map(_.toString)
         .toRight(NodeNotFoundError()))
+    if (emitWasm)
+      nodeMajorVersion.foreach { v =>
+        if (v < 22) value(Left(new NodeVersionTooOldForWasmError(v)))
+      }
     val nodeFlags = if (emitWasm && nodeNeedsWasmFlag) List("--experimental-wasm-exnref") else Nil
     if !jsDom && allowExecve && Execve.available() then {
       val command = Seq(nodePath) ++ nodeFlags ++ Seq(entrypoint.getAbsolutePath) ++ args
@@ -453,6 +455,9 @@ object Runner {
       value(findInPath("bun")
         .map(_.toString)
         .toRight(BunNotFoundError()))
+    bunMajorVersion.foreach { v =>
+      if (v < 1) value(Left(new BunVersionTooOldForWasmError(v)))
+    }
 
     val command = Seq(bunPath, "run", entrypoint.getAbsolutePath) ++ args
 

modules/cli/src/main/scala/scala/cli/commands/run/Run.scala

@@ -552,7 +552,9 @@ object Run extends ScalaCommand[RunOptions] with BuildCommandHelpers {
             build.options.platform.value match {
               case Platform.JS =>
                 val esModule =
-                  build.options.scalaJsOptions.moduleKindStr.exists(m => m == "es" || m == "esmodule")
+                  build.options.scalaJsOptions.moduleKindStr.exists(m =>
+                    m == "es" || m == "esmodule"
+                  )
 
                 val linkerConfig = build.options.scalaJsOptions.linkerConfig(logger)
                 val jsDest       = {

modules/core/src/main/scala/scala/build/errors/BunNotFoundError.scala

@@ -2,4 +2,4 @@ package scala.build.errors
 
 final class BunNotFoundError extends BuildException(
       "Bun was not found on the PATH. Install Bun from https://bun.sh/ or use --wasm-runtime node"
-    )
+    )

modules/core/src/main/scala/scala/build/errors/BunVersionTooOldForWasmError.scala

@@ -0,0 +1,7 @@
+package scala.build.errors
+
+final class BunVersionTooOldForWasmError(found: Int)
+    extends BuildException(
+      s"Scala.js WASM backend requires Bun >= 1, but found Bun $found. " +
+        "Upgrade Bun (https://bun.sh/) or switch runtime via --wasm-runtime node|deno."
+    )

modules/core/src/main/scala/scala/build/errors/NodeVersionTooOldForWasmError.scala

@@ -0,0 +1,7 @@
+package scala.build.errors
+
+final class NodeVersionTooOldForWasmError(found: Int)
+    extends BuildException(
+      s"Scala.js WASM backend requires Node.js >= 22, but found Node.js $found. " +
+        "Upgrade Node (https://nodejs.org/) or switch runtime via --wasm-runtime deno|bun."
+    )

project/deps/package.mill

@@ -13,15 +13,16 @@ object Cli {
 }
 
 object Scala {
-  def scala212         = "2.12.21"
-  def scala213         = "2.13.18"
-  def scala3LtsPrefix  = "3.3"                  // used for the LTS version tags
-  def scala3Lts        = s"$scala3LtsPrefix.7"  // the LTS version currently used in the build
-  def runnerScala3     = scala3Lts
-  def scala3NextPrefix = "3.8"
-  def scala3Next       = s"$scala3NextPrefix.3" // the newest/next version of Scala
-  def scala3NextAnnounced   = s"$scala3NextPrefix.2"  // the newest/next version of Scala that's been announced
-  def scala3NextRc          = "3.8.4-RC1" // the latest RC version of Scala Next
+  def scala212            = "2.12.21"
+  def scala213            = "2.13.18"
+  def scala3LtsPrefix     = "3.3"                  // used for the LTS version tags
+  def scala3Lts           = s"$scala3LtsPrefix.7"  // the LTS version currently used in the build
+  def runnerScala3        = scala3Lts
+  def scala3NextPrefix    = "3.8"
+  def scala3Next          = s"$scala3NextPrefix.3" // the newest/next version of Scala
+  def scala3NextAnnounced =
+    s"$scala3NextPrefix.2" // the newest/next version of Scala that's been announced
+  def scala3NextRc        = "3.8.4-RC1"            // the latest RC version of Scala Next
   def scala3NextRcAnnounced = "3.8.4-RC1" // the latest announced RC version of Scala Next
 
   // The Scala version used to build the CLI itself.