@tishlang/tish-format 3.9.1 → 3.10.2

package/Cargo.toml

@@ -22,8 +22,6 @@ members = [
     "crates/tish_vm",
     "crates/tish_llvm",
     "crates/tish_ffi",
-    "examples/ffi/mathext",
-
     "crates/tish_native",
     "crates/tish_wasm",
     "crates/tish",

package/crates/tish_compile/src/resolve.rs

@@ -756,31 +756,60 @@ pub fn compute_native_build_artifacts(
     })
 }
 
+/// Names a directory may declare and still satisfy `package_name`.
+///
+/// A `tish:foo` import asks for the package `tish-foo`, which is what the in-repo crate
+/// directories under `tish-apple/crates/` are called. The SAME code is published to npm under the
+/// scoped name `@tishlang/tish-foo`, so a project that depends on the published package has it at
+/// `node_modules/@tishlang/tish-foo` declaring that scoped name. Treat the two as one identity,
+/// or a pinned published dependency is silently ignored in favour of a sibling checkout.
+fn acceptable_package_names(package_name: &str) -> Vec<String> {
+    let mut names = vec![package_name.to_string()];
+    if !package_name.starts_with('@') {
+        names.push(format!("@tishlang/{package_name}"));
+    }
+    names
+}
+
+fn declares_one_of(pkg_dir: &Path, names: &[String]) -> bool {
+    let pkg_json = pkg_dir.join("package.json");
+    if !pkg_json.exists() {
+        return false;
+    }
+    match read_package_name(&pkg_json) {
+        Some(found) => names.iter().any(|n| *n == found),
+        None => false,
+    }
+}
+
 fn find_package_dir(package_name: &str, project_root: &Path) -> Result<PathBuf, String> {
+    let names = acceptable_package_names(package_name);
     let mut search = project_root.to_path_buf();
     loop {
+        // node_modules first, and the scoped published name before the sibling checkout: an
+        // explicit dependency pin must beat a directory that merely happens to sit alongside.
         let node_mod = search.join("node_modules").join(package_name);
-        if node_mod.join("package.json").exists()
-            && read_package_name(&node_mod.join("package.json")) == Some(package_name.to_string())
-        {
+        if declares_one_of(&node_mod, &names) {
             return Ok(node_mod);
         }
+        if !package_name.starts_with('@') {
+            let scoped = search
+                .join("node_modules")
+                .join("@tishlang")
+                .join(package_name);
+            if declares_one_of(&scoped, &names) {
+                return Ok(scoped);
+            }
+        }
         let apple_crate = search.join("tish-apple").join("crates").join(package_name);
-        if apple_crate.join("package.json").exists()
-            && read_package_name(&apple_crate.join("package.json"))
-                == Some(package_name.to_string())
-        {
+        if declares_one_of(&apple_crate, &names) {
             return Ok(apple_crate);
         }
         let sibling = search.join(package_name);
-        if sibling.join("package.json").exists()
-            && read_package_name(&sibling.join("package.json")) == Some(package_name.to_string())
-        {
+        if declares_one_of(&sibling, &names) {
             return Ok(sibling);
         }
-        if search.join("package.json").exists()
-            && read_package_name(&search.join("package.json")) == Some(package_name.to_string())
-        {
+        if declares_one_of(&search, &names) {
             return Ok(search);
         }
         if let Some(parent) = search.parent() {
@@ -2385,4 +2414,53 @@ mod find_package_dir_tests {
         let hit = find_package_dir("tish-macos", &project).expect("resolve");
         assert_eq!(hit.canonicalize().unwrap(), apple.canonicalize().unwrap());
     }
+
+    /// The published npm package for `tish:macos` is named `@tishlang/tish-macos`, so a bare
+    /// name-equality check rejects it and silently falls through to a sibling checkout --
+    /// pulling that checkout's path-dep copy of tishlang_core in beside the registry one and
+    /// failing the build on mismatched `Value` types. An explicit dependency must win.
+    #[test]
+    fn prefers_scoped_node_modules_over_tish_apple_crates() {
+        let dir = tempfile::tempdir().expect("tempdir");
+        let root = dir.path();
+        let apple = root.join("tish-apple").join("crates").join("tish-macos");
+        std::fs::create_dir_all(&apple).unwrap();
+        std::fs::write(
+            apple.join("package.json"),
+            r#"{"name":"tish-macos","tish":{"module":true,"crate":"tishlang_macos","export":"macos_object"}}"#,
+        )
+        .unwrap();
+        let project = root.join("app");
+        let scoped = project
+            .join("node_modules")
+            .join("@tishlang")
+            .join("tish-macos");
+        std::fs::create_dir_all(&scoped).unwrap();
+        std::fs::write(
+            scoped.join("package.json"),
+            r#"{"name":"@tishlang/tish-macos","tish":{"module":true,"crate":"tishlang_macos","export":"macos_object"}}"#,
+        )
+        .unwrap();
+        let hit = find_package_dir("tish-macos", &project).expect("resolve");
+        assert_eq!(hit.canonicalize().unwrap(), scoped.canonicalize().unwrap());
+    }
+
+    /// npm alias installs (`"tish-macos": "npm:@tishlang/tish-macos@1.2.0"`) put the scoped
+    /// package at the UNSCOPED directory, so the directory name matches but the declared name
+    /// does not. That must resolve too.
+    #[test]
+    fn accepts_scoped_name_at_unscoped_node_modules_dir() {
+        let dir = tempfile::tempdir().expect("tempdir");
+        let root = dir.path();
+        let project = root.join("app");
+        let aliased = project.join("node_modules").join("tish-macos");
+        std::fs::create_dir_all(&aliased).unwrap();
+        std::fs::write(
+            aliased.join("package.json"),
+            r#"{"name":"@tishlang/tish-macos","tish":{"module":true,"crate":"tishlang_macos","export":"macos_object"}}"#,
+        )
+        .unwrap();
+        let hit = find_package_dir("tish-macos", &project).expect("resolve");
+        assert_eq!(hit.canonicalize().unwrap(), aliased.canonicalize().unwrap());
+    }
 }

package/crates/tish_fmt/Cargo.toml

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

package/crates/tish_native/src/build.rs

@@ -224,18 +224,7 @@ pub fn build_via_cargo_with_config(
         rust_main
     };
 
-    let tish_ui_path = std::path::Path::new(&runtime_path)
-        .parent()
-        .ok_or_else(|| "invalid tishlang_runtime path (no parent)".to_string())?
-        .join("tish_ui");
-    let ui_dep = if rust_code.contains("tishlang_ui") {
-        format!(
-            "\ntishlang_ui = {{ path = {:?}, default-features = false, features = [\"runtime\"] }}\n",
-            tish_ui_path.display().to_string().replace('\\', "/")
-        )
-    } else {
-        String::new()
-    };
+    let ui_dep = ui_dep_toml(&runtime_path, rust_code);
 
     let profile = nested_release_profile_toml();
     let src_file = if build_config.artifact == NativeArtifact::StaticLib {
@@ -271,9 +260,18 @@ edition = "2021"
 
 {}{}
 [dependencies]
-tishlang_runtime = {{ path = {:?}{} }}
-{}{}"#,
-        crate_section, profile, runtime_path, features_str, more_deps, ui_dep
+{}
+{}{}{}"#,
+        crate_section,
+        profile,
+        runtime_dep_toml(&runtime_path, &features_str),
+        more_deps,
+        ui_dep,
+        if released_compiler_version().is_some() {
+            String::new()
+        } else {
+            tishlang_patch_section(&runtime_path, &more_deps)
+        }
     );
 
     fs::write(build_dir.join("Cargo.toml"), cargo_toml)
@@ -452,6 +450,141 @@ opt-level = 3
 }
 
 /// Read `version = "…"` from the `[package]` section of a crate's `Cargo.toml`.
+/// The `tishlang_runtime` dependency line: registry version for a released compiler,
+/// local path tree for dev builds.
+fn runtime_dep_toml(runtime_path: &str, features_str: &str) -> String {
+    if let Some(v) = released_compiler_version() {
+        format!("tishlang_runtime = {{ version = {:?}{} }}", v, features_str)
+    } else {
+        format!("tishlang_runtime = {{ path = {:?}{} }}", runtime_path, features_str)
+    }
+}
+
+/// The optional `tishlang_ui` dependency line (same source policy as the runtime).
+fn ui_dep_toml(runtime_path: &str, rust_code: &str) -> String {
+    if !rust_code.contains("tishlang_ui") {
+        return String::new();
+    }
+    if let Some(v) = released_compiler_version() {
+        return format!(
+            "\ntishlang_ui = {{ version = {:?}, default-features = false, features = [\"runtime\"] }}\n",
+            v
+        );
+    }
+    let tish_ui_path = std::path::Path::new(runtime_path)
+        .parent()
+        .map(|p| p.join("tish_ui"))
+        .unwrap_or_default();
+    format!(
+        "\ntishlang_ui = {{ path = {:?}, default-features = false, features = [\"runtime\"] }}\n",
+        tish_ui_path.display().to_string().replace('\\', "/")
+    )
+}
+
+/// The compiler's own RELEASED version, or None for a dev/workspace build.
+///
+/// A released compiler is published together with the whole tishlang_* crate family at the
+/// SAME version, so generated crates can depend on the runtime from crates.io — one source
+/// for every tishlang crate, unified with any published native crate (tishlang_ios,
+/// tishlang_desktop, user `cargo:` deps). Dev builds (workspace version 0.x / -dev) keep
+/// the local path tree + the [patch.crates-io] pin instead.
+fn released_compiler_version() -> Option<&'static str> {
+    let v = env!("CARGO_PKG_VERSION");
+    if v.starts_with("0.") || v.contains("dev") {
+        None
+    } else {
+        Some(v)
+    }
+}
+
+/// `[package] name` from a crate dir's Cargo.toml (first table only, like read_crate_version).
+fn read_crate_package_name(crate_dir: &Path) -> Option<String> {
+    let toml = fs::read_to_string(crate_dir.join("Cargo.toml")).ok()?;
+    for line in toml.lines() {
+        let line = line.trim();
+        if let Some(rest) = line.strip_prefix("name") {
+            let rest = rest.trim_start();
+            if let Some(rest) = rest.strip_prefix('=') {
+                return Some(rest.trim().trim_matches('"').to_string());
+            }
+        }
+        if line.starts_with('[') && !line.starts_with("[package]") {
+            break;
+        }
+    }
+    None
+}
+
+/// `[patch.crates-io]` section pinning every `tishlang_*` crate in the local runtime tree
+/// (the siblings of `runtime_path`) to that tree.
+///
+/// Why: the generated program depends on `tishlang_runtime` BY PATH, but registry-sourced
+/// native crates (`cargo:` deps with a version, published hosts like `tishlang_ios` /
+/// `tishlang_desktop`) declare `tishlang_core` / `tishlang_runtime` / `tishlang_ui` BY
+/// VERSION. Cargo never unifies a path crate with a registry crate, so the build died with
+/// "multiple different versions of crate `tishlang_core`" the moment a published native
+/// crate entered the graph — publishing runtimes was pointless. The patch makes the
+/// compiler's own tree the single source for every tishlang crate, whatever requested it.
+///
+/// Emitted whenever the program has ANY extra native dependency: even a path dep (an npm-
+/// shipped crate like `@tishlang/tish-ios`) reaches the registry TRANSITIVELY through its own
+/// `tishlang_core = "x"` version requirements. Builds with no native deps skip the section so
+/// plain programs don't carry "unused patch" warnings.
+fn tishlang_patch_section(runtime_path: &str, more_deps: &str) -> String {
+    let has_extra_dep = more_deps.lines().any(|l| {
+        let l = l.trim();
+        !l.is_empty() && l.contains('=') && !l.starts_with('#')
+    });
+    if !has_extra_dep {
+        return String::new();
+    }
+    // A patch entry only ever applies when the patched source's version SATISFIES the
+    // registry requirement it replaces. Dev/workspace trees carry 0.x placeholder
+    // versions that can never satisfy a released "3.x" requirement — emitting the
+    // patch there does nothing useful and destabilizes resolution for path-dep
+    // setups that already work. Only patch from a release-stamped tree.
+    let core_dir = Path::new(runtime_path)
+        .parent()
+        .map(|p| p.join("tish_core"));
+    let tree_is_released = core_dir
+        .as_deref()
+        .and_then(read_crate_version)
+        .map(|v| !v.starts_with("0."))
+        .unwrap_or(false);
+    if !tree_is_released {
+        return String::new();
+    }
+    let Some(crates_dir) = Path::new(runtime_path).parent() else {
+        return String::new();
+    };
+    let Ok(read) = fs::read_dir(crates_dir) else {
+        return String::new();
+    };
+    let mut entries: Vec<(String, String)> = Vec::new();
+    for e in read.flatten() {
+        let dir = e.path();
+        if !dir.join("Cargo.toml").exists() {
+            continue;
+        }
+        let Some(name) = read_crate_package_name(&dir) else {
+            continue;
+        };
+        if !name.starts_with("tishlang_") {
+            continue;
+        }
+        entries.push((name, dir.display().to_string().replace('\\', "/")));
+    }
+    if entries.is_empty() {
+        return String::new();
+    }
+    entries.sort();
+    let mut out = String::from("\n[patch.crates-io]\n");
+    for (name, path) in entries {
+        out.push_str(&format!("{} = {{ path = {:?} }}\n", name, path));
+    }
+    out
+}
+
 fn read_crate_version(crate_dir: &Path) -> Option<String> {
     let toml = fs::read_to_string(crate_dir.join("Cargo.toml")).ok()?;
     for line in toml.lines() {
@@ -925,15 +1058,8 @@ pub(crate) fn build_many_via_cargo(
         more_deps.push_str("\nmimalloc = \"0.1\"\n");
     }
 
-    let tish_ui_path = std::path::Path::new(&runtime_path)
-        .parent()
-        .ok_or_else(|| "invalid tishlang_runtime path (no parent)".to_string())?
-        .join("tish_ui");
     let ui_dep = if needs_ui {
-        format!(
-            "\ntishlang_ui = {{ path = {:?}, default-features = false, features = [\"runtime\"] }}\n",
-            tish_ui_path.display().to_string().replace('\\', "/")
-        )
+        ui_dep_toml(&runtime_path, "tishlang_ui")
     } else {
         String::new()
     };
@@ -979,9 +1105,18 @@ edition = "2021"
 
 {}{}
 [dependencies]
-tishlang_runtime = {{ path = {:?}{} }}
-{}{}"#,
-        bin_tables, profile, runtime_path, features_str, more_deps, ui_dep
+{}
+{}{}{}"#,
+        bin_tables,
+        profile,
+        runtime_dep_toml(&runtime_path, &features_str),
+        more_deps,
+        ui_dep,
+        if released_compiler_version().is_some() {
+            String::new()
+        } else {
+            tishlang_patch_section(&runtime_path, &more_deps)
+        }
     );
 
     fs::write(build_dir.join("Cargo.toml"), cargo_toml)

package/crates/tish_runtime_gba/Cargo.toml

@@ -3,6 +3,14 @@ name = "tishlang_runtime_gba"
 version = "0.1.0"
 edition = "2021"
 description = "no_std runtime facade for Tish compiled output on the Game Boy Advance (agb)"
+# Spelled out, NOT `{ workspace = true }`: this crate is in the workspace `exclude` list, so it has
+# no workspace root to inherit from. Without these, `cargo publish` refuses the crate outright,
+# which is why it is the one tishlang_* crate that never shipped.
+#
+# The LICENSE is a COPY, not the root one: cargo requires license-file to resolve inside the
+# package directory, and `../../LICENSE` is not packaged.
+license-file = "LICENSE"
+repository = "https://github.com/tishlang/tish"
 
 # The GBA `Gba` emit mode declares the generated crate's dependency as
 #   tishlang_runtime = { package = "tishlang_runtime_gba", path = ... }
@@ -11,6 +19,6 @@ description = "no_std runtime facade for Tish compiled output on the Game Boy Ad
 # tishlang_core / tishlang_builtins and adds the GBA `gba::{init, halt, hooks}`.
 
 [dependencies]
-tishlang_core = { path = "../tish_core", default-features = false, features = ["portable"] }
-tishlang_builtins = { path = "../tish_builtins", default-features = false, features = ["portable"] }
+tishlang_core = { path = "../tish_core", version = ">=0.1", default-features = false, features = ["portable"] }
+tishlang_builtins = { path = "../tish_builtins", version = ">=0.1", default-features = false, features = ["portable"] }
 agb = "0.25.0"

package/crates/tish_runtime_gba/LICENSE

@@ -0,0 +1,13 @@
+Pay It Forward License (PIF)
+
+Copyright (c) 2025-present The Tish Project Authors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+
+This license includes a perpetual, worldwide, non-exclusive, royalty-free, irrevocable (except as stated below) grant for patent claims necessarily infringed by the use of the Software or any contributions submitted to it; terminating automatically when an entity initiates patent litigation (including a cross-claim or counterclaim) alleging that the Software or any portion thereof infringes a patent.
+
+The software is provided "as is," without warranty of any kind, express or implied, including but not limited to the warranties of merchantability, fitness for a particular purpose, and non-infringement. In no event shall the authors or copyright holders be liable for any claim, damages, or other liability, whether in an action of contract, tort, or otherwise, arising from, out of, or in connection with the software or the use or other dealings in the software.
+
+Recipients of the Software should pay it forward by contributing to the open-source community through actions including but not limited to providing code, documentation, tutorials, guides, support, feedback, or promoting open-source projects through advocacy or related efforts that advance innovation and community growth.

package/crates/tish_ui/src/jsx.rs

@@ -1,6 +1,7 @@
 //! Shared JSX lowering: emit `h(tag, props, children)` as JavaScript or Rust (`Value`) source.
 
 use std::collections::HashSet;
+use std::sync::Arc;
 
 use tishlang_ast::{
     ArrayElement, ArrowBody, CallArg, ExportDeclaration, Expr, JsxAttrValue, JsxChild, JsxProp,
@@ -401,6 +402,7 @@ where
     match expr {
         Expr::JsxElement {
             tag,
+            tag_span,
             props,
             children,
             ..
@@ -412,7 +414,16 @@ where
                 .unwrap_or(false);
             let tag_rust = if is_component {
                 if fun_decls.contains(tag.as_ref()) {
-                    escape_ident_rust(tag.as_ref())
+                    // Lower the component reference through the caller's own identifier path
+                    // rather than writing the bare name. A module-scope function is promoted to a
+                    // `__TISH_GF_<name>` static, and there is no local of the original name to
+                    // reference — emitting it verbatim produced
+                    // `error[E0425]: cannot find value \`Comp\` in this scope` for every imported
+                    // component. `emit_expr` already resolves statics, locals and captures.
+                    emit_expr(&Expr::Ident {
+                        name: Arc::clone(tag),
+                        span: *tag_span,
+                    })?
                 } else {
                     format!("Value::String({:?}.into())", tag.as_ref())
                 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tishlang/tish-format",
-  "version": "3.9.1",
+  "version": "3.10.2",
   "description": "Tish code formatter",
   "license": "PIF",
   "repository": {
@@ -14,7 +14,9 @@
     "tish-format": "./bin/tish-format"
   },
   "scripts": {
-    "postinstall": "node scripts/install-bin.js"
+    "postinstall": "node scripts/install-bin.js",
+    "prepack": "node scripts/prepack.js",
+    "postpack": "node scripts/postpack.js"
   },
   "files": [
     "bin",