Add WASM support: --wasm flag with Node.js and Deno runtimes #4176
+1,048
−247
There are no files selected for viewing
This file contains hidden or bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
This file contains hidden or bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
| Original file line number | Diff line number | Diff line change |
|---|---|---|
|
|
@@ -189,6 +189,37 @@ object Runner { | |
| run(command, logger, cwd = cwd, extraEnv = extraEnv) | ||
| } | ||
|
|
||
| // Detects the major version of Node.js on PATH; cached for the JVM lifetime (lazy val). | ||
| // Returns None if node is not found or version cannot be parsed. | ||
| private lazy val nodeMajorVersion: Option[Int] = | ||
| try { | ||
| val process = new ProcessBuilder("node", "--version") | ||
| .redirectErrorStream(true) | ||
| .start() | ||
| val output = new String(process.getInputStream.readAllBytes()).trim | ||
| process.waitFor() | ||
| // Node version format: "v22.5.0" -> extract 22 | ||
| if (output.startsWith("v")) | ||
| output.drop(1).takeWhile(_.isDigit) match { | ||
| case s if s.nonEmpty => Some(s.toInt) | ||
| case _ => None | ||
| } | ||
| else None | ||
| } | ||
| catch { | ||
| case _: Exception => None | ||
| } | ||
|
|
||
| // 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). | ||
| // In Node 26+, the flag may be removed from the CLI. Only pass it when Node < 25. | ||
| // None.forall(_ < 25) == true — safe fallback when version detection fails. | ||
| private def nodeNeedsWasmFlag: Boolean = nodeMajorVersion.forall(_ < 25) | ||
|
|
||
| // 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 Wasm output until V8 13.x lands in Deno. | ||
| private def denoNeedsWasmFlag: Boolean = true | ||
|
|
||
| private def endsWithCaseInsensitive(s: String, suffix: String): Boolean = | ||
| s.length >= suffix.length && | ||
| s.regionMatches(true, s.length - suffix.length, suffix, 0, suffix.length) | ||
|
|
@@ -221,11 +252,13 @@ object Runner { | |
| def jsCommand( | ||
| entrypoint: File, | ||
| args: Seq[String], | ||
| jsDom: Boolean = false, | ||
| emitWasm: Boolean = false | ||
| ): Seq[String] = { | ||
|
|
||
| val nodePath = findInPath("node").fold("node")(_.toString) | ||
| val nodeFlags = if (emitWasm && nodeNeedsWasmFlag) List("--experimental-wasm-exnref") else Nil | ||
| val command = Seq(nodePath) ++ nodeFlags ++ Seq(entrypoint.getAbsolutePath) ++ args | ||
|
|
||
| if (jsDom) | ||
| // FIXME We'd need to replicate what JSDOMNodeJSEnv does under-the-hood to get the command in that case. | ||
|
|
@@ -242,14 +275,20 @@ object Runner { | |
| allowExecve: Boolean = false, | ||
| jsDom: Boolean = false, | ||
| sourceMap: Boolean = false, | ||
| esModule: Boolean = false, | ||
| emitWasm: Boolean = false | ||
| ): Either[BuildException, Process] = either { | ||
| val nodePath: String = | ||
| value(findInPath("node") | ||
| .map(_.toString) | ||
| .toRight(NodeNotFoundError())) | ||
| val nodeFlags = if (emitWasm && nodeNeedsWasmFlag) List("--experimental-wasm-exnref") else Nil | ||
|
There was a problem hiding this comment. I don't think tools like in Node 26, options like
Author
There was a problem hiding this comment. Fixed. nodeNeedsWasmFlag is now version-aware: private def nodeNeedsWasmFlag: Boolean = nodeMajorVersion.forall(_ < 25) There was a problem hiding this comment. Ah sorry, Whether to detect the Node version and automatically add options should follow scala-cli's implementation policy. :) FYI @Gedochao I was thinking about passing Node options from the
Contributor
There was a problem hiding this comment. We can add some options as implicit if user doesn't specify them and we know they are necessary to run the Wasm build. Just make sure the implicit stuff is logged, so that the user knows what's happening. |
||
| if (emitWasm && nodeFlags.nonEmpty) | ||
| logger.log( | ||
| s"Wasm: adding ${nodeFlags.mkString(" ")} (required for Wasm exception handling on Node.js < 25)" | ||
| ) | ||
| if !jsDom && allowExecve && Execve.available() then { | ||
| val command = Seq(nodePath) ++ nodeFlags ++ Seq(entrypoint.getAbsolutePath) ++ args | ||
|
|
||
| logger.log( | ||
| s"Running ${command.mkString(" ")}", | ||
|
|
@@ -270,7 +309,7 @@ object Runner { | |
| // Scala.js runs apps by piping JS to node. | ||
| // If we need to pass arguments, we must first make the piped input explicit | ||
| // with "-", and we pass the user's arguments after that. | ||
| nodeFlags ++ (if args.isEmpty then Nil else "-" :: args.toList) | ||
| val envJs = | ||
| if jsDom then | ||
| new JSDOMNodeJSEnv( | ||
|
|
@@ -307,6 +346,123 @@ object Runner { | |
| } | ||
| } | ||
|
|
||
| def denoCommand( | ||
| entrypoint: File, | ||
| args: Seq[String] | ||
| ): Seq[String] = { | ||
| val denoPath = findInPath("deno").fold("deno")(_.toString) | ||
| val denoFlags = Seq("run", "--allow-read") | ||
| Seq(denoPath) ++ denoFlags ++ Seq(entrypoint.getAbsolutePath) ++ args | ||
| } | ||
|
|
||
| def runDeno( | ||
| entrypoint: File, | ||
| args: Seq[String], | ||
| logger: Logger, | ||
| allowExecve: Boolean = false, | ||
| emitWasm: Boolean = false | ||
| ): Either[BuildException, Process] = either { | ||
| val denoPath: String = | ||
| value(findInPath("deno") | ||
| .map(_.toString) | ||
| .toRight(DenoNotFoundError())) | ||
| val denoFlags = Seq("run", "--allow-read") | ||
| val wasmFlag = "--experimental-wasm-exnref" | ||
| val extraEnv = | ||
| if (emitWasm && denoNeedsWasmFlag) { | ||
| // Append to any existing DENO_V8_FLAGS rather than replacing them. | ||
| val existing = sys.env.get("DENO_V8_FLAGS").filter(_.nonEmpty) | ||
| val merged = existing.fold(wasmFlag)(f => s"$f $wasmFlag") | ||
| logger.log( | ||
| s"Wasm: setting DENO_V8_FLAGS=$merged (required for Wasm exception handling)" | ||
| ) | ||
| Map("DENO_V8_FLAGS" -> merged) | ||
| } | ||
| else Map.empty[String, String] | ||
|
|
||
| if (allowExecve && Execve.available()) { | ||
| val command = Seq(denoPath) ++ denoFlags ++ Seq(entrypoint.getAbsolutePath) ++ args | ||
|
|
||
| logger.log( | ||
| s"Running ${command.mkString(" ")}", | ||
| " Running" + System.lineSeparator() + | ||
| command.iterator.map(_ + System.lineSeparator()).mkString | ||
| ) | ||
|
|
||
| logger.debug("execve available") | ||
| Execve.execve( | ||
| command.head, | ||
| "deno" +: command.tail.toArray, | ||
| (sys.env ++ extraEnv).toArray.sorted.map { case (k, v) => s"$k=$v" } | ||
| ) | ||
| sys.error("should not happen") | ||
| } | ||
| else { | ||
| val command = Seq(denoPath) ++ denoFlags ++ Seq(entrypoint.getAbsolutePath) ++ args | ||
|
|
||
| logger.log( | ||
| s"Running ${command.mkString(" ")}", | ||
| " Running" + System.lineSeparator() + | ||
| command.iterator.map(_ + System.lineSeparator()).mkString | ||
| ) | ||
|
|
||
| val builder = new ProcessBuilder(command*) | ||
| .inheritIO() | ||
| val env = builder.environment() | ||
| for ((k, v) <- extraEnv) | ||
| env.put(k, v) | ||
| builder.start() | ||
| } | ||
| } | ||
|
|
||
| def bunCommand( | ||
| entrypoint: File, | ||
| args: Seq[String] | ||
| ): Seq[String] = { | ||
| val bunPath = findInPath("bun").fold("bun")(_.toString) | ||
| Seq(bunPath, "run", entrypoint.getAbsolutePath) ++ args | ||
| } | ||
|
|
||
| def runBun( | ||
| entrypoint: File, | ||
| args: Seq[String], | ||
| logger: Logger, | ||
| allowExecve: Boolean = false | ||
| ): Either[BuildException, Process] = either { | ||
| val bunPath: String = | ||
| value(findInPath("bun") | ||
| .map(_.toString) | ||
| .toRight(BunNotFoundError())) | ||
| val command = Seq(bunPath, "run", entrypoint.getAbsolutePath) ++ args | ||
|
|
||
| if (allowExecve && Execve.available()) { | ||
| logger.log( | ||
| s"Running ${command.mkString(" ")}", | ||
| " Running" + System.lineSeparator() + | ||
| command.iterator.map(_ + System.lineSeparator()).mkString | ||
| ) | ||
|
|
||
| logger.debug("execve available") | ||
| Execve.execve( | ||
| command.head, | ||
| "bun" +: command.tail.toArray, | ||
| sys.env.toArray.sorted.map { case (k, v) => s"$k=$v" } | ||
| ) | ||
| sys.error("should not happen") | ||
| } | ||
| else { | ||
| logger.log( | ||
| s"Running ${command.mkString(" ")}", | ||
| " Running" + System.lineSeparator() + | ||
| command.iterator.map(_ + System.lineSeparator()).mkString | ||
| ) | ||
|
|
||
| new ProcessBuilder(command*) | ||
| .inheritIO() | ||
| .start() | ||
| } | ||
| } | ||
|
|
||
| def runNative( | ||
| launcher: File, | ||
| args: Seq[String], | ||
|
|
||
This file contains hidden or bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
This file contains hidden or bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
Oops, something went wrong.
Oops, something went wrong.
Add this suggestion to a batch that can be applied as a single commit.
This suggestion is invalid because no changes were made to the code.
Suggestions cannot be applied while the pull request is closed.
Suggestions cannot be applied while viewing a subset of changes.
Only one suggestion per line can be applied in a batch.
Add this suggestion to a batch that can be applied as a single commit.
Applying suggestions on deleted lines is not supported.
You must change the existing code in this line in order to create a valid suggestion.
Outdated suggestions cannot be applied.
This suggestion has been applied or marked resolved.
Suggestions cannot be applied from pending reviews.
Suggestions cannot be applied on multi-line comments.
Suggestions cannot be applied while the pull request is queued to merge.
Suggestion cannot be applied right now. Please check back later.
There was a problem hiding this comment.
Choose a reason for hiding this comment
The reason will be displayed to describe this comment to others. Learn more.
I'm not sure about scala-cli policy, but I feel like detecting node version if it supports wasm or not is too much.
my 2 cents: scala-cli should loosely couple with the runtime environment, just try to run and let them fail if it's too old.
There was a problem hiding this comment.
Choose a reason for hiding this comment
The reason will be displayed to describe this comment to others. Learn more.
Removed it, so scala cli lets runtime fail if it is too old
There was a problem hiding this comment.
Choose a reason for hiding this comment
The reason will be displayed to describe this comment to others. Learn more.
I don't see it's removed, did you forget to push some commits?
There was a problem hiding this comment.
Choose a reason for hiding this comment
The reason will be displayed to describe this comment to others. Learn more.
likewise, unresolved?
There was a problem hiding this comment.
Choose a reason for hiding this comment
The reason will be displayed to describe this comment to others. Learn more.
Apologies for the earlier confusion — I said "removed" but hadn't actually pushed the change. In the end I kept the version detection, because @Gedochao's comment below explicitly approved the approach:
"We can add some options as implicit if user doesn't specify them and we know they are necessary to run the Wasm build. Just make sure the implicit stuff is logged."
The current state: nodeMajorVersion remains, --experimental-wasm-exnref is passed only on Node < 25 (where V8 12.x requires it), and when it is injected, Scala CLI now logs:
"Wasm: adding --experimental-wasm-exnref (required for Wasm exception handling on Node.js < 25)"
There was a problem hiding this comment.
Choose a reason for hiding this comment
The reason will be displayed to describe this comment to others. Learn more.
(While I personally don't like
scala-climanage options implicitly), if we do that, we should properly append all necessary flags for GC and EH across every version ofdenoandNode. Why don't we automatically append options for Node 22, 23, and 24? and how about every versions of Deno?Also, do I understand correctly that, we only manage the minimum required flags for execution (exnref, gc, function-references)? I mean, how about other features such as
js-string-builtins,JSPI, (and custom descriptor in future?) Are those flags are expected to be added by users manually throughNODE_OPTIONSandDENO_V8_FLAGS?There was a problem hiding this comment.
Choose a reason for hiding this comment
The reason will be displayed to describe this comment to others. Learn more.
that sounds like quite the headache to manage implicitly...
to chip in - doing some of this for the user is fine, as long as it is clear what needs to be passed manually, and what has been picked up implicitly.
the feature is meant to be experimental, so it's okay to require some knowledge from the user (although if we can provide a seamless UX, that's great)