@tishlang/tish-lsp 2.38.0 → 2.43.8

package/crates/tish_lsp/src/main.rs

@@ -344,6 +344,8 @@ impl LanguageServer for Backend {
         }
 
         let mut src_root: Option<PathBuf> = None;
+        let mut init_platform: Option<String> = None;
+        let mut init_surface: Option<String> = None;
         if let Some(opts) = &params.initialization_options {
             if let Some(s) = opts
                 .get("tishlangSourceRoot")
@@ -354,7 +356,23 @@ impl LanguageServer for Backend {
                     src_root = Some(PathBuf::from(s));
                 }
             }
+            // Platform file cascade for imports (same as `tish resolve-id` / Vite).
+            // settings.json: "tish.platform" / "tish.surface", or env TISH_PLATFORM / TISH_SURFACE.
+            if let Some(p) = opts.get("platform").and_then(|v| v.as_str()) {
+                init_platform = Some(p.to_string());
+            } else if let Some(p) = opts.get("tishPlatform").and_then(|v| v.as_str()) {
+                init_platform = Some(p.to_string());
+            }
+            if let Some(s) = opts.get("surface").and_then(|v| v.as_str()) {
+                init_surface = Some(s.to_string());
+            } else if let Some(s) = opts.get("tishSurface").and_then(|v| v.as_str()) {
+                init_surface = Some(s.to_string());
+            }
         }
+        let _ = tishlang_compile::apply_resolve_env(
+            init_platform.as_deref(),
+            init_surface.as_deref(),
+        );
         if src_root.is_none() {
             if let Ok(s) = std::env::var("TISHLANG_SOURCE_ROOT") {
                 let t = s.trim();

package/crates/tish_native/src/build.rs

@@ -135,6 +135,17 @@ pub fn build_via_cargo_with_config(
     project_root: Option<&Path>,
     build_config: &NativeBuildConfig,
 ) -> Result<(), String> {
+    if build_config.artifact == NativeArtifact::GbaRom {
+        return build_gba_rom(
+            rust_code,
+            native_modules,
+            output_path,
+            extra_dependencies_toml,
+            generated_native_rs,
+            project_root,
+        );
+    }
+
     let out_stem = output_path
         .file_stem()
         .and_then(|s| s.to_str())
@@ -299,6 +310,241 @@ tishlang_runtime = {{ path = {:?}{} }}
     Ok(())
 }
 
+/// Read the agb version the facade pins, from `<facade>/Cargo.toml`. This keeps the generated ROM
+/// crate's agb in lockstep with the facade's (the single source of truth) — see [`build_gba_rom`].
+/// Matches an `agb = "X"` or `agb = { version = "X", … }` line; `None` if absent (caller falls back).
+fn read_facade_agb_version(facade_path: &Path) -> Option<String> {
+    let toml = fs::read_to_string(facade_path.join("Cargo.toml")).ok()?;
+    for line in toml.lines() {
+        // Require the key to be exactly `agb` (not `agb_foo`): after `agb`, the next non-space
+        // token must be `=`.
+        let Some(after_key) = line.trim_start().strip_prefix("agb") else {
+            continue;
+        };
+        let Some(after_eq) = after_key.trim_start().strip_prefix('=') else {
+            continue;
+        };
+        // Take the first double-quoted string (the version, in either the bare or table form).
+        let rest = after_eq.trim_start();
+        if let Some(start) = rest.find('"') {
+            if let Some(len) = rest[start + 1..].find('"') {
+                return Some(rest[start + 1..start + 1 + len].to_string());
+            }
+        }
+    }
+    None
+}
+
+/// Build a Game Boy Advance ROM from generated `#![no_std]` Rust.
+///
+/// Emits an agb-style cargo project (nightly + build-std + `thumbv4t-none-eabi` +
+/// `gba.ld`) that links the `tishlang_runtime_gba` facade under the `tishlang_runtime`
+/// name (the `package =` rename), builds it, then runs `agb-gbafix` on the ELF.
+///
+/// Runs its own `cargo build` (NOT `run_cargo_build`) so the `.cargo/config.toml`
+/// rustflags (`-Tgba.ld`, `-Ctarget-cpu=arm7tdmi`) apply — `run_cargo_build` sets a
+/// `RUSTFLAGS` env that would shadow them.
+fn build_gba_rom(
+    rust_code: &str,
+    native_modules: Vec<ResolvedNativeModule>,
+    output_path: &Path,
+    extra_dependencies_toml: &str,
+    generated_native_rs: Option<&str>,
+    project_root: Option<&Path>,
+) -> Result<(), String> {
+    use std::process::Command;
+
+    // Locate the facade crate (sibling of tishlang_runtime in the tish workspace).
+    let runtime_path = tishlang_build_utils::find_runtime_path_for_project(project_root)?;
+    let facade_path = Path::new(&runtime_path)
+        .parent()
+        .ok_or_else(|| "invalid tishlang_runtime path (no parent)".to_string())?
+        .join("tish_runtime_gba");
+    if !facade_path.exists() {
+        return Err(format!(
+            "GBA runtime facade not found at {} (expected the tishlang_runtime_gba crate)",
+            facade_path.display()
+        ));
+    }
+
+    // Single-source the agb version from the facade's own Cargo.toml — the facade is the one crate
+    // that actually links agb (its `Fixed`, entry-point, and asset arenas are agb types), so it is
+    // the source of truth. The generated ROM crate must depend on the SAME agb: a skew would pull in
+    // two agb crates and mismatch types at the sprite-registration boundary. Falls back to a known
+    // pin only if the line can't be read (never blocks the build on a parse miss).
+    let agb_version =
+        read_facade_agb_version(&facade_path).unwrap_or_else(|| "0.25.0".to_string());
+
+    let out_stem = output_path
+        .file_stem()
+        .and_then(|s| s.to_str())
+        .unwrap_or("tish_out");
+    let cargo_name = tishlang_build_utils::cargo_target_name(out_stem);
+
+    // Persistent build dir under the project so the (expensive) build-std recompile
+    // is cached across runs; the generated Rust stays inspectable.
+    let base = project_root
+        .map(|p| p.to_path_buf())
+        .unwrap_or_else(|| std::env::current_dir().unwrap_or_default());
+    let build_dir = base.join(".tish").join("gba").join(out_stem);
+    fs::create_dir_all(build_dir.join("src"))
+        .map_err(|e| format!("Cannot create GBA build dir: {}", e))?;
+    fs::create_dir_all(build_dir.join(".cargo"))
+        .map_err(|e| format!("Cannot create .cargo dir: {}", e))?;
+
+    // Path dependencies for any `cargo:` native modules the program imported.
+    let native_deps: String = native_modules
+        .iter()
+        .filter(|m| m.use_path_dependency)
+        .map(|m| {
+            let path = m.crate_path.display().to_string().replace('\\', "/");
+            format!("{} = {{ path = {:?} }}\n", m.package_name, path)
+        })
+        .collect();
+
+    // `cargo:` module path deps arrive via `extra_dependencies_toml`
+    // (`tish.rustDependencies`); `native_modules` covers any that use a path dep
+    // resolved another way. Both are appended to `[dependencies]`.
+    let mut more_deps = native_deps;
+    if !extra_dependencies_toml.trim().is_empty() {
+        more_deps.push('\n');
+        more_deps.push_str(extra_dependencies_toml);
+    }
+
+    let facade = facade_path.display().to_string().replace('\\', "/");
+    let cargo_toml = format!(
+        r#"[package]
+name = "tish_output"
+version = "0.1.0"
+edition = "2021"
+
+# Standalone workspace so a parent Cargo workspace (e.g. the tish-gba repo, when
+# the build dir lives under it) doesn't try to absorb this generated crate.
+[workspace]
+
+[[bin]]
+name = "{cargo_name}"
+path = "src/main.rs"
+
+[dependencies]
+tishlang_runtime = {{ package = "tishlang_runtime_gba", path = {facade:?} }}
+agb = "{agb_version}"
+{more_deps}
+[profile.dev]
+opt-level = 3
+debug = true
+
+[profile.dev.build-override]
+opt-level = 3
+
+[profile.release]
+opt-level = 3
+lto = "fat"
+debug = true
+
+[profile.release.build-override]
+opt-level = 3
+"#,
+    );
+    fs::write(build_dir.join("Cargo.toml"), cargo_toml)
+        .map_err(|e| format!("Cannot write Cargo.toml: {}", e))?;
+
+    fs::write(
+        build_dir.join("rust-toolchain.toml"),
+        "[toolchain]\nchannel = \"nightly\"\ncomponents = [\"rust-src\"]\n",
+    )
+    .map_err(|e| format!("Cannot write rust-toolchain.toml: {}", e))?;
+
+    // build-std + target + gba.ld rustflags (agb ships gba.ld via its build.rs).
+    fs::write(
+        build_dir.join(".cargo").join("config.toml"),
+        r#"[unstable]
+build-std = ["core", "alloc"]
+build-std-features = ["compiler-builtins-mem"]
+
+[build]
+target = "thumbv4t-none-eabi"
+
+[target.thumbv4t-none-eabi]
+runner = ["mgba-qt", "-C", "logToStdout=1", "-C", "logLevel.gba.debug=127"]
+"#,
+    )
+    .map_err(|e| format!("Cannot write .cargo/config.toml: {}", e))?;
+
+    let rust_main = if generated_native_rs.is_some() {
+        inject_generated_native_mod(rust_code)
+    } else {
+        rust_code.to_string()
+    };
+    if let Some(gen) = generated_native_rs {
+        // The `cargo:` wrapper emits the std header (`std::cell/rc/sync`); map it
+        // to the no_std facade equivalents (`alloc` is crate-wide via main.rs's
+        // `extern crate alloc`). The module body is otherwise Value-only.
+        let gen = gen
+            .replace("use std::cell::RefCell;", "use core::cell::RefCell;")
+            .replace("use std::rc::Rc;", "use alloc::rc::Rc;")
+            .replace("use std::sync::Arc;", "use tishlang_runtime::Arc;");
+        fs::write(build_dir.join("src").join("generated_native.rs"), gen)
+            .map_err(|e| format!("Cannot write generated_native.rs: {}", e))?;
+    }
+    fs::write(build_dir.join("src").join("main.rs"), rust_main)
+        .map_err(|e| format!("Cannot write main.rs: {}", e))?;
+
+    // Pass the GBA linker/target rustflags via the RUSTFLAGS env (which REPLACES,
+    // not joins, any `[target.*].rustflags` from config files). This matters when
+    // the build dir sits inside a project that already has a `.cargo/config.toml`
+    // with `-Tgba.ld` — cargo *joins* rustflags arrays across config files, so a
+    // config-file approach would pass `-Tgba.ld` twice ("region already defined").
+    // build-std still comes from the generated `[unstable]` config (not rustflags).
+    let status = Command::new("cargo")
+        .arg("build")
+        .arg("--release")
+        .current_dir(&build_dir)
+        .env(
+            "RUSTFLAGS",
+            "-Clink-arg=-Tgba.ld -Ctarget-cpu=arm7tdmi -Cforce-frame-pointers=yes",
+        )
+        .env("CARGO_TERM_COLOR", "always")
+        .status()
+        .map_err(|e| format!("Failed to run cargo for GBA build: {}", e))?;
+    if !status.success() {
+        return Err(format!(
+            "GBA cargo build failed (see output above). Build dir: {}",
+            build_dir.display()
+        ));
+    }
+
+    // ELF → .gba via agb-gbafix.
+    let elf = build_dir
+        .join("target")
+        .join("thumbv4t-none-eabi")
+        .join("release")
+        .join(&cargo_name);
+    if !elf.exists() {
+        return Err(format!("GBA ELF not found at {}", elf.display()));
+    }
+    let rom = if output_path.extension().is_some_and(|e| e == "gba") {
+        output_path.to_path_buf()
+    } else {
+        output_path.with_extension("gba")
+    };
+    let gbafix = Command::new("agb-gbafix")
+        .arg(&elf)
+        .arg("-o")
+        .arg(&rom)
+        .status()
+        .map_err(|e| {
+            format!(
+                "Failed to run agb-gbafix ({}). Install it with: cargo install agb-gbafix",
+                e
+            )
+        })?;
+    if !gbafix.success() {
+        return Err("agb-gbafix failed to produce the ROM".to_string());
+    }
+    Ok(())
+}
+
 /// Remove a finished build's per-PID source directory (#384). Called only on SUCCESS, after the
 /// binary is copied out — the dir is then disposable (it holds only the generated crate source;
 /// compiled artifacts live in the shared workspace `target/`). Left in place on any earlier error so a

package/crates/tish_native/src/config.rs

@@ -8,6 +8,9 @@ pub enum NativeArtifact {
     #[default]
     Bin,
     StaticLib,
+    /// A GBA ROM: cargo builds an ELF for `thumbv4t-none-eabi`, then `agb-gbafix`
+    /// converts it to a `.gba`.
+    GbaRom,
 }
 
 /// Options passed from the CLI into nested `cargo build`.
@@ -32,11 +35,28 @@ impl NativeBuildConfig {
         }
     }
 
+    /// Game Boy Advance ROM build (`tish build --target gba`): cross-compile to
+    /// `thumbv4t-none-eabi` with the `Gba` emit mode.
+    pub fn gba() -> Self {
+        Self {
+            artifact: NativeArtifact::GbaRom,
+            cargo_target: Some("thumbv4t-none-eabi".to_string()),
+            emit_mode: NativeEmitMode::Gba,
+        }
+    }
+
     pub fn is_cross_compile(&self) -> bool {
         self.cargo_target.is_some()
     }
 }
 
+/// Feature cap for GBA builds: no host-only runtime capabilities (http/fs/process/
+/// timers/ws/tty/pty). The facade `compile_error!`-stubs them, but capping keeps
+/// the emitted prelude from importing names that don't exist on GBA.
+pub fn gba_runtime_features(_features: &[String]) -> Vec<String> {
+    Vec::new()
+}
+
 /// Filter runtime features for iOS sandbox builds.
 pub fn ios_runtime_features(features: &[String]) -> Vec<String> {
     const ALLOW: &[&str] = &["http", "http-hyper", "regex", "timers"];

package/crates/tish_native/src/lib.rs

@@ -97,13 +97,23 @@ pub fn compile_to_native_with_config(
 
     match backend {
         Backend::Rust => {
-            let ios_cap = build_config.cargo_target.as_ref().map(|_| {
-                ios_runtime_features(features)
+            // Cross-target builds cap runtime features to what the target supports:
+            // GBA gets none (no OS), iOS gets its sandbox allow-list.
+            let is_gba = build_config.emit_mode == tishlang_compile::NativeEmitMode::Gba;
+            let cap = |f: &[String]| -> Vec<String> {
+                if is_gba {
+                    crate::config::gba_runtime_features(f)
+                } else {
+                    ios_runtime_features(f)
+                }
+            };
+            let cross_cap = build_config.cargo_target.as_ref().map(|_| {
+                cap(features)
                     .into_iter()
                     .collect::<std::collections::HashSet<_>>()
             });
-            let compile_features = if ios_cap.is_some() {
-                ios_runtime_features(features)
+            let compile_features = if cross_cap.is_some() {
+                cap(features)
             } else {
                 features.to_vec()
             };
@@ -114,14 +124,14 @@ pub fn compile_to_native_with_config(
                     &compile_features,
                     optimize,
                     build_config.emit_mode,
-                    ios_cap.as_ref(),
+                    cross_cap.as_ref(),
                 )
                 .map_err(|e| NativeError {
                     message: e.to_string(),
                 })?;
 
             let features_for_cargo = if build_config.cargo_target.is_some() {
-                ios_runtime_features(&effective_features)
+                cap(&effective_features)
             } else {
                 effective_features
             };

package/crates/tish_parser/src/lib.rs

@@ -101,6 +101,34 @@ mod tests {
         assert!(parse("let x = async 5").is_err());
     }
 
+    /// #428 (function-expression half): `async function (…) {…}` / named `async function f(…) {…}`
+    /// in expression position parse as async ArrowFunctions — anonymous, named, object-property,
+    /// and IIFE-operand forms. Non-async function expressions keep `async_: false` (#464).
+    #[test]
+    fn async_function_expressions_parse() {
+        use tishlang_ast::Expr;
+        let fn_expr_async = |src: &str| -> bool {
+            let p = parse(src).expect("parse");
+            let Some(Statement::VarDecl { init: Some(e), .. }) = p.statements.first() else {
+                panic!("expected `let x = <fn expr>`");
+            };
+            match e {
+                Expr::ArrowFunction { async_, .. } => *async_,
+                other => panic!("expected ArrowFunction, got {other:?}"),
+            }
+        };
+        assert!(fn_expr_async("let f = async function() { return 1 }"), "anonymous");
+        assert!(fn_expr_async("let f = async function named(n) { return n }"), "named");
+        assert!(!fn_expr_async("let f = function() { return 1 }"), "plain fn expr is not async");
+        // Object-property and IIFE-operand positions.
+        assert!(parse("let o = { m: async function() { return 1 } }").is_ok());
+        assert!(parse("let p = (async function() { return 1 })()").is_ok());
+        assert!(parse("let q = (async () => { return 1 })()").is_ok());
+        // `async fn => …` stays a single-param arrow with param `fn` (#55 ident-compat) —
+        // the function-expression branch requires `(` or an identifier after `function`.
+        assert!(parse("let r = async fn => fn").is_ok());
+    }
+
     #[test]
     fn test_async_fn_parse() {
         let program = parse("async fn foo() { }").expect("parse async fn");

package/crates/tish_parser/src/parser.rs

@@ -197,6 +197,11 @@ impl<'a> Parser<'a> {
         self.peek().map(|t| t.kind)
     }
 
+    /// Kind of the token `n` positions past the current one (`peek_ahead_kind(0)` == `peek_kind`).
+    fn peek_ahead_kind(&self, n: usize) -> Option<TokenKind> {
+        self.tokens.get(self.pos + n).map(|t| t.kind)
+    }
+
     fn advance(&mut self) -> Option<&Token> {
         let t = self.tokens.get(self.pos);
         if t.is_some() {
@@ -1060,7 +1065,8 @@ impl<'a> Parser<'a> {
 
     /// `interface Name { k: T, ... }` — desugared to `type Name = { ... }` so the checker
     /// (structural matching) and codegen (native `TishStruct_*`) treat it exactly like an
-    /// object-type alias. (`extends` is not yet supported.)
+    /// object-type alias. `interface Name extends P1, P2 { ... }` desugars to an intersection
+    /// of the parents with the body (see below), so inherited fields participate too.
     fn parse_interface(&mut self) -> Result<Statement, String> {
         let span_start = self.expect(TokenKind::Interface)?.span.start;
         let name_tok = self.expect(TokenKind::Ident)?;
@@ -2464,9 +2470,11 @@ impl<'a> Parser<'a> {
                 value: Literal::Null,
                 span,
             }),
-            // `async` in expression position (#428): an async arrow — `async () => …` or
-            // `async x => …`. The body runs in async context (`await` allowed). Async function
-            // expressions / method shorthand need function-expression support, which tish lacks.
+            // `async` in expression position (#428): an async arrow — `async () => …` /
+            // `async x => …` — or an async function EXPRESSION — `async function (…) {…}` /
+            // named `async function f(…) {…}` (desugars to an async ArrowFunction exactly like
+            // the non-async `function` expression form, #464). The body runs in async context
+            // (`await` allowed).
             TokenKind::Async => {
                 if matches!(self.peek_kind(), Some(TokenKind::LParen)) {
                     self.advance(); // consume `(`
@@ -2475,6 +2483,19 @@ impl<'a> Parser<'a> {
                     }
                     return Err("Expected an arrow function after `async (`".to_string());
                 }
+                // `async function (…) {…}` / `async function f(…) {…}`: `function` (`Fn`)
+                // followed by `(` or an identifier is a function expression, mirroring the
+                // non-async arm below. Checked BEFORE the single-param-arrow branch, which
+                // would otherwise consume `function` as a parameter name and demand `=>`.
+                if matches!(self.peek_kind(), Some(TokenKind::Fn))
+                    && matches!(
+                        self.peek_ahead_kind(1),
+                        Some(TokenKind::LParen | TokenKind::Ident)
+                    )
+                {
+                    self.advance(); // consume `function`
+                    return self.parse_function_expr_tail(&span, true);
+                }
                 if matches!(
                     self.peek_kind(),
                     Some(TokenKind::Ident | TokenKind::Fn | TokenKind::Type)

package/crates/tish_runtime/src/http_hyper.rs

@@ -289,6 +289,9 @@ fn worker_thread(
                     // headers slower than this instead of pinning the worker task.
                     .header_read_timeout(std::time::Duration::from_secs(30))
                     .serve_connection(io, svc)
+                    // Required for `hyper::upgrade::on` to hand off the socket after a 101 — without
+                    // this, a WebSocket upgrade sends the 101 but the upgrade future never resolves.
+                    .with_upgrades()
                     .await
                 {
                     // Chatty connection errors (resets, client timeouts) are
@@ -314,6 +317,13 @@ async fn handle_request(
         return Ok(static_route_response(route));
     }
 
+    // WebSocket upgrade: complete the handshake here and hand the socket to `ws.rs` — the VM handler
+    // never sees it. The program picks the connection up via `wsAccept`. (Single-port WS, issue #495.)
+    #[cfg(feature = "ws")]
+    if is_ws_upgrade(&req) {
+        return Ok(handle_ws_upgrade(req));
+    }
+
     // Slow path: cross the mpsc to the VM thread.
     let (method, url, path, query, headers, body_bytes) = extract_request(req).await;
     // Lossy UTF-8 decode to match the tiny_http path (`http.rs`): a body with invalid UTF-8 becomes
@@ -455,6 +465,66 @@ fn simple_error_response(status: StatusCode, msg: &str) -> Response<Full<Bytes>>
         .unwrap()
 }
 
+/// A well-formed WebSocket upgrade handshake request (RFC 6455): `Upgrade: websocket`,
+/// `Connection: Upgrade`, and a `Sec-WebSocket-Key`.
+#[cfg(feature = "ws")]
+fn is_ws_upgrade(req: &Request<hyper::body::Incoming>) -> bool {
+    let h = req.headers();
+    let upgrade_ws = h
+        .get(hyper::header::UPGRADE)
+        .and_then(|v| v.to_str().ok())
+        .map(|s| s.eq_ignore_ascii_case("websocket"))
+        .unwrap_or(false);
+    let conn_upgrade = h
+        .get(hyper::header::CONNECTION)
+        .and_then(|v| v.to_str().ok())
+        .map(|s| s.to_ascii_lowercase().split(',').any(|p| p.trim() == "upgrade"))
+        .unwrap_or(false);
+    upgrade_ws && conn_upgrade && h.contains_key(hyper::header::SEC_WEBSOCKET_KEY)
+}
+
+/// Complete a WebSocket handshake on the HTTP port: reply `101` with the derived accept key, then
+/// (after the response flushes) take over the connection, wrap it as a server-role WebSocket, and
+/// register it with `ws.rs` so the program can pick it up via `wsAccept`.
+#[cfg(feature = "ws")]
+fn handle_ws_upgrade(mut req: Request<hyper::body::Incoming>) -> Response<Full<Bytes>> {
+    use tokio_tungstenite::tungstenite::handshake::derive_accept_key;
+    use tokio_tungstenite::tungstenite::protocol::Role;
+
+    let accept = match req.headers().get(hyper::header::SEC_WEBSOCKET_KEY) {
+        Some(k) => derive_accept_key(k.as_bytes()),
+        None => return simple_error_response(StatusCode::BAD_REQUEST, "missing Sec-WebSocket-Key"),
+    };
+
+    let on_upgrade = hyper::upgrade::on(&mut req);
+    tokio::spawn(async move {
+        match on_upgrade.await {
+            Ok(upgraded) => {
+                let io = TokioIo::new(upgraded);
+                let ws = tokio_tungstenite::WebSocketStream::from_raw_socket(io, Role::Server, None)
+                    .await;
+                let id = crate::ws::register_ws_stream(ws);
+                crate::ws::enqueue_upgraded_conn(id);
+            }
+            Err(e) => {
+                if std::env::var_os("TISH_HTTP_DEBUG").is_some() {
+                    eprintln!("[tish http/hyper] ws upgrade failed: {}", e);
+                }
+            }
+        }
+    });
+
+    Response::builder()
+        .status(StatusCode::SWITCHING_PROTOCOLS)
+        .header(hyper::header::UPGRADE, "websocket")
+        .header(hyper::header::CONNECTION, "Upgrade")
+        .header(hyper::header::SEC_WEBSOCKET_ACCEPT, accept)
+        .body(Full::new(Bytes::new()))
+        .unwrap_or_else(|_| {
+            simple_error_response(StatusCode::INTERNAL_SERVER_ERROR, "ws upgrade build failed")
+        })
+}
+
 /// Marker used by external callers (like the bench) to gate the backend
 /// choice. Returns true when `TISH_HTTP_BACKEND=hyper` is in the env.
 pub fn is_enabled_via_env() -> bool {