@tishlang/tish-format 3.11.0 → 3.12.1

package/crates/tish_fmt/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "tishlang_fmt"
-version = "3.11.0"
+version = "3.12.1"
 edition = "2021"
 description = "Opinionated formatter for Tish source (parse → pretty-print)"
 license-file = { workspace = true }

package/crates/tish_native/src/build.rs

@@ -45,6 +45,13 @@ fn runtime_features_for_cargo(features: &[String]) -> Vec<String> {
 }
 
 /// `[profile.release]` for nested `cargo build` of generated crates.
+///
+/// - default: fat LTO, one codegen unit — smallest and fastest binary, slowest to produce (the
+///   final link is single-threaded and dominates a warm build of a large app).
+/// - `TISH_FAST_NATIVE_BUILD=1`: iteration profile, no LTO, opt-level 1.
+/// - `TISH_NATIVE_THIN_LTO=1`: thin LTO over 8 codegen units — keeps most of fat's size/speed win
+///   while letting rustc parallelise the link. Same trade the GBA path offers via
+///   `TISH_GBA_THIN_LTO`; for desktop apps this is the CI-friendly shipping profile.
 fn nested_release_profile_toml() -> &'static str {
     if std::env::var("TISH_FAST_NATIVE_BUILD").as_deref() == Ok("1") {
         r#"[profile.release]
@@ -55,6 +62,13 @@ incremental = true
 strip = false
 debug = 0
 panic = "abort"
+"#
+    } else if std::env::var("TISH_NATIVE_THIN_LTO").as_deref() == Ok("1") {
+        r#"[profile.release]
+strip = true
+panic = "abort"
+codegen-units = 8
+lto = "thin"
 "#
     } else {
         r#"[profile.release]
@@ -1179,6 +1193,7 @@ edition = "2021"
 
 #[cfg(test)]
 mod tests {
+    use super::nested_release_profile_toml;
     use super::runtime_features_for_cargo;
 
     /// The generated ROM crate must inherit the project's pin, or GBA builds float against whatever
@@ -1219,6 +1234,27 @@ mod tests {
         let _ = fs::remove_dir_all(&base);
     }
 
+    /// `TISH_NATIVE_THIN_LTO=1` selects thin LTO for native release builds; fast wins over it.
+    #[test]
+    fn native_release_profile_follows_env() {
+        use std::sync::Mutex;
+        static ENV_LOCK: Mutex<()> = Mutex::new(());
+        let _g = ENV_LOCK.lock().unwrap_or_else(|e| e.into_inner());
+        std::env::remove_var("TISH_FAST_NATIVE_BUILD");
+        std::env::remove_var("TISH_NATIVE_THIN_LTO");
+        assert!(nested_release_profile_toml().contains("lto = \"fat\""));
+        std::env::set_var("TISH_NATIVE_THIN_LTO", "1");
+        let thin = nested_release_profile_toml();
+        assert!(thin.contains("lto = \"thin\"") && thin.contains("codegen-units = 8"));
+        std::env::set_var("TISH_FAST_NATIVE_BUILD", "1");
+        assert!(
+            nested_release_profile_toml().contains("lto = false"),
+            "fast wins over thin"
+        );
+        std::env::remove_var("TISH_FAST_NATIVE_BUILD");
+        std::env::remove_var("TISH_NATIVE_THIN_LTO");
+    }
+
     /// `TISH_NATIVE_TARGET_DIR`: unset/empty → None (temp-dir build); set → that dir, created.
     #[test]
     fn shared_native_target_dir_follows_env() {

package/crates/tish_runtime/src/fs_ext.rs

@@ -218,9 +218,25 @@ pub fn copy_file_core(args: &[Value]) -> Result<Value, Value> {
 }
 pub fn realpath_core(args: &[Value]) -> Result<Value, Value> {
     std::fs::canonicalize(path_arg(args, 0))
-        .map(|p| Value::String(p.to_string_lossy().into()))
+        .map(|p| Value::String(strip_verbatim_prefix(&p.to_string_lossy()).into()))
         .map_err(io_err)
 }
+
+/// `std::fs::canonicalize` on Windows returns the verbatim form — `\\?\C:\Users\…` for a drive
+/// path, `\\?\UNC\server\share\…` for a network one. Node's `fs.realpath` never does: it hands
+/// back `C:\Users\…` / `\\server\share\…`, and programs treat the result as a display / URL /
+/// comparison string, not just an OS handle (Dune showed `\\?\C:\…` as its workspace title, and a
+/// `?` inside a URL path starts the query string). Match Node. No-op on POSIX and for paths
+/// that carry no prefix.
+pub(crate) fn strip_verbatim_prefix(p: &str) -> String {
+    if let Some(rest) = p.strip_prefix("\\\\?\\UNC\\") {
+        format!("\\\\{rest}")
+    } else if let Some(rest) = p.strip_prefix("\\\\?\\") {
+        rest.to_string()
+    } else {
+        p.to_string()
+    }
+}
 pub fn readlink_core(args: &[Value]) -> Result<Value, Value> {
     std::fs::read_link(path_arg(args, 0))
         .map(|p| Value::String(p.to_string_lossy().into()))
@@ -393,3 +409,16 @@ pub fn constants() -> Value {
     m.insert("X_OK".into(), Value::Number(1.0));
     Value::object(m)
 }
+
+#[cfg(test)]
+mod verbatim_prefix_tests {
+    use super::strip_verbatim_prefix;
+
+    #[test]
+    fn strips_windows_verbatim_prefixes_like_node() {
+        assert_eq!(strip_verbatim_prefix("\\\\?\\C:\\Users\\x\\ui"), "C:\\Users\\x\\ui");
+        assert_eq!(strip_verbatim_prefix("\\\\?\\UNC\\srv\\share\\d"), "\\\\srv\\share\\d");
+        assert_eq!(strip_verbatim_prefix("C:\\Users\\x"), "C:\\Users\\x");
+        assert_eq!(strip_verbatim_prefix("/Users/x/ui"), "/Users/x/ui");
+    }
+}

package/crates/tish_runtime/src/http_prefork.rs

@@ -108,6 +108,7 @@ pub fn spawn_children(n: usize) -> io::Result<Vec<Child>> {
     let mut out = Vec::with_capacity(n - 1);
     for i in 1..n {
         let mut cmd = Command::new(&exe);
+        crate::no_console_window(&mut cmd);
         cmd.args(&args);
         cmd.env("TISH_WORKER_ID", i.to_string());
         cmd.env("TISH_HTTP_PREFORK", "child");

package/crates/tish_runtime/src/lib.rs

@@ -1013,6 +1013,20 @@ pub fn process_cwd(_args: &[Value]) -> Value {
 }
 
 #[cfg(feature = "process")]
+/// Windows: a child spawned from a GUI-subsystem parent (a desktop app) gets its own console
+/// window unless created with CREATE_NO_WINDOW — a packaged app spawning git / node / shell
+/// helpers at boot flashed a terminal window per child and stole focus. No-op elsewhere.
+#[cfg(windows)]
+pub fn no_console_window(cmd: &mut std::process::Command) -> &mut std::process::Command {
+    use std::os::windows::process::CommandExt;
+    const CREATE_NO_WINDOW: u32 = 0x0800_0000;
+    cmd.creation_flags(CREATE_NO_WINDOW)
+}
+#[cfg(not(windows))]
+pub fn no_console_window(cmd: &mut std::process::Command) -> &mut std::process::Command {
+    cmd
+}
+
 pub fn process_exec(args: &[Value]) -> Value {
     use std::process::Command;
     let cmd = args
@@ -1022,7 +1036,7 @@ pub fn process_exec(args: &[Value]) -> Value {
     if cmd.is_empty() {
         return Value::Number(0.0);
     }
-    match Command::new("sh").arg("-c").arg(&cmd).status() {
+    match no_console_window(Command::new("sh").arg("-c").arg(&cmd)).status() {
         Ok(status) => Value::Number(status.code().unwrap_or(1) as f64),
         Err(_) => Value::Number(1.0),
     }
@@ -1046,7 +1060,7 @@ pub fn process_exec_file(args: &[Value]) -> Value {
         Some(Value::Array(a)) => a.borrow().iter().map(|v| v.to_display_string()).collect(),
         _ => Vec::new(),
     };
-    match Command::new(&program).args(&argv).status() {
+    match no_console_window(Command::new(&program).args(&argv)).status() {
         Ok(status) => Value::Number(status.code().unwrap_or(1) as f64),
         Err(_) => Value::Number(1.0),
     }
@@ -1093,7 +1107,7 @@ pub fn process_exec_capture(args: &[Value]) -> Value {
     if cmd.is_empty() {
         return process_capture_obj(0, String::new(), String::new());
     }
-    process_capture_result(Command::new("sh").arg("-c").arg(&cmd).output())
+    process_capture_result(no_console_window(Command::new("sh").arg("-c").arg(&cmd)).output())
 }
 
 /// `process.execFileCapture(program, [args])` — run a program directly, WITHOUT a shell, capturing
@@ -1115,7 +1129,7 @@ pub fn process_exec_file_capture(args: &[Value]) -> Value {
         Some(Value::Array(a)) => a.borrow().iter().map(|v| v.to_display_string()).collect(),
         _ => Vec::new(),
     };
-    process_capture_result(Command::new(&program).args(&argv).output())
+    process_capture_result(no_console_window(Command::new(&program).args(&argv)).output())
 }
 
 #[cfg(all(test, feature = "process", unix))]

package/crates/tish_runtime/src/process_spawn.rs

@@ -198,6 +198,7 @@ pub fn process_spawn(args: &[Value]) -> Value {
     };
 
     let mut cmd = Command::new(program);
+    crate::no_console_window(&mut cmd);
     if let Some(Value::Array(a)) = obj_field(opts, "args") {
         for v in a.borrow().iter() {
             cmd.arg(v.to_display_string());

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tishlang/tish-format",
-  "version": "3.11.0",
+  "version": "3.12.1",
   "description": "Tish code formatter",
   "license": "PIF",
   "repository": {