@tishlang/tish 2.2.0 → 2.2.4

package/crates/tish/Cargo.toml

@@ -1,11 +1,17 @@
 [package]
 name = "tishlang"
-version = "2.2.0"
+version = "2.2.4"
 edition = "2021"
 description = "Tish CLI - run, REPL, compile to native"
 license-file = { workspace = true }
 repository = { workspace = true }
 
+# tishlang_runtime has no direct source use here — it's required by the http/fs/process/
+# regex/ws/tty feature-forwards below (`tishlang_runtime/<feat>`). cargo-machete only scans
+# source, so it false-flags it; ignore it.
+[package.metadata.cargo-machete]
+ignored = ["tishlang_runtime"]
+
 [[bin]]
 name = "tish"
 path = "src/main.rs"
@@ -38,7 +44,6 @@ tty     = ["tishlang_eval/tty",     "tishlang_runtime/tty",     "tishlang_compil
 # GPU compute — Apple Silicon only
 [dependencies]
 rustyline = { version = "17", features = ["with-file-history"] }
-tishlang_lexer = { path = "../tish_lexer", version = ">=0.1" }
 tishlang_ast = { path = "../tish_ast", version = ">=0.1" }
 tishlang_parser = { path = "../tish_parser", version = ">=0.1" }
 tishlang_eval = { path = "../tish_eval", version = ">=0.1" }
@@ -49,7 +54,6 @@ tishlang_opt = { path = "../tish_opt", version = ">=0.1" }
 tishlang_vm = { path = "../tish_vm", version = ">=0.1" }
 tishlang_ffi = { path = "../tish_ffi", version = ">=0.1" }
 tishlang_native = { path = "../tish_native", version = ">=0.1" }
-tishlang_llvm = { path = "../tish_llvm", version = ">=0.1" }
 tishlang_wasm = { path = "../tish_wasm", version = ">=0.1" }
 tishlang_runtime = { path = "../tish_runtime", version = ">=0.1" }
 tishlang_core = { path = "../tish_core", version = ">=0.1" }

package/crates/tish/src/main.rs

@@ -56,15 +56,17 @@ fn vm_capabilities_for_cli_run(cli_features: &[String]) -> HashSet<String> {
 
 /// `--feature` list for `tish build --target native`: same default as `tish run` (all linked-in caps).
 fn native_build_features_from_cli(cli_features: &[String]) -> Vec<String> {
-    if cli_features.is_empty() {
-        let mut v: Vec<String> = tishlang_vm::all_compiled_capabilities()
-            .into_iter()
-            .collect();
-        v.sort();
-        v
+    let mut v: Vec<String> = if cli_features.is_empty() {
+        tishlang_vm::all_compiled_capabilities().into_iter().collect()
     } else {
-        cli_features.to_vec()
-    }
+        // Normalize exactly like `tish run`: split comma-separated values (`--feature http,timers`)
+        // and expand `full`. Without this, a value like "http,timers,process" was treated as one
+        // opaque feature name, so `has_feature("http")` was false and the http runtime imports were
+        // never emitted — async `fetch` then failed to compile (issue #209).
+        normalize_capability_flags(cli_features).into_iter().collect()
+    };
+    v.sort();
+    v
 }
 
 /// `tish script.tish` → insert `run` so it matches `tish run script.tish` (npx / npm UX).
@@ -829,6 +831,22 @@ mod cli_tests {
         }
     }
 
+    #[test]
+    fn native_build_features_split_commas_and_expand_full() {
+        use super::native_build_features_from_cli;
+        // Issue #209: a comma-joined value was treated as one opaque feature, so has_feature("http")
+        // was false and the native http imports were skipped (async `fetch` failed to compile).
+        let f = native_build_features_from_cli(&["http,timers,process".to_string()]);
+        for cap in ["http", "timers", "process"] {
+            assert!(f.iter().any(|s| s == cap), "missing `{cap}` in {f:?}");
+        }
+        // `full` expands to every capability, matching `tish run`.
+        let full = native_build_features_from_cli(&["full".to_string()]);
+        for cap in ["http", "timers", "fs", "process", "regex", "ws", "tty"] {
+            assert!(full.iter().any(|s| s == cap), "`full` missing `{cap}` in {full:?}");
+        }
+    }
+
     #[test]
     fn run_stdin_marker_parses_as_file() {
         let cli = Cli::try_parse_from(["tish", "run", "-"]).unwrap();

package/crates/tish_ast/src/ast.rs

@@ -436,6 +436,11 @@ pub enum Expr {
     /// JSX element: <Tag props>children</Tag>
     JsxElement {
         tag: Arc<str>,
+        /// Span of the tag name in the opening tag (`<`**`Foo`**`>`), for go-to-def / rename.
+        tag_span: Span,
+        /// Span of the tag name in the closing tag (`</`**`Foo`**`>`); `None` for self-closing
+        /// (`<Foo/>`). Renaming a component must update both, or `<Bar></Foo>` would be invalid.
+        close_tag_span: Option<Span>,
         props: Vec<JsxProp>,
         children: Vec<JsxChild>,
         span: Span,

package/crates/tish_build_utils/Cargo.toml

@@ -5,7 +5,3 @@ edition = "2021"
 description = "Shared build utilities for Tish (workspace discovery, path resolution)"
 license-file = { workspace = true }
 repository = { workspace = true }
-
-[dependencies]
-# Bundled `protoc` for nested `cargo build` (Lance / prost-build) when none is on PATH.
-protoc-bin-vendored = "3"

package/crates/tish_build_utils/src/lib.rs

@@ -355,35 +355,6 @@ pub fn create_build_dir(prefix: &str, out_name: &str) -> Result<PathBuf, String>
     Ok(build_dir)
 }
 
-/// `PROTOC` for prost-build in transitive crates (e.g. lance-encoding) during nested `cargo build`.
-/// Respects an existing `PROTOC`, then `protoc` on `PATH`, then `protoc-bin-vendored`.
-fn protoc_for_nested_cargo() -> Option<PathBuf> {
-    // Empty or non-file PROTOC must not short-circuit: prost-build treats "" like a missing binary.
-    if let Some(v) = std::env::var_os("PROTOC") {
-        if !v.is_empty() {
-            let p = PathBuf::from(&v);
-            if p.is_file() {
-                return None;
-            }
-        }
-    }
-    // Prefer vendored protoc over PATH: a broken or non-executable `protoc` on PATH still passes `is_file()`.
-    if let Ok(p) = protoc_bin_vendored::protoc_bin_path() {
-        return Some(p);
-    }
-    let ext = if cfg!(windows) { ".exe" } else { "" };
-    let name = format!("protoc{}", ext);
-    if let Some(paths) = std::env::var_os("PATH") {
-        for dir in std::env::split_paths(&paths) {
-            let candidate = dir.join(&name);
-            if candidate.is_file() {
-                return Some(candidate);
-            }
-        }
-    }
-    None
-}
-
 /// Run cargo build in the given directory.
 /// If `cross_target` is Some, passes `--target` and skips `-C target-cpu=native`.
 pub fn run_cargo_build(
@@ -433,9 +404,6 @@ pub fn run_cargo_build(
     } else {
         cmd.env_remove("CARGO_INCREMENTAL");
     }
-    if let Some(protoc) = protoc_for_nested_cargo() {
-        cmd.env("PROTOC", protoc);
-    }
     let output = cmd
         .output()
         .map_err(|e| format!("Failed to run cargo: {}", e))?;
@@ -460,15 +428,6 @@ mod protoc_tests {
         assert_eq!(cargo_target_name("hello-ios"), "hello_ios");
         assert_eq!(cargo_target_name("tish_out"), "tish_out");
     }
-
-    #[test]
-    fn protoc_for_nested_cargo_without_env_uses_vendored_or_path() {
-        let _lock = std::sync::Mutex::new(());
-        let _guard = _lock.lock().unwrap();
-        std::env::remove_var("PROTOC");
-        let p = protoc_for_nested_cargo().expect("expected vendored or PATH protoc");
-        assert!(p.exists(), "resolved protoc should exist: {}", p.display());
-    }
 }
 
 /// Find the built static library in target/release (or target/$TRIPLE/release).

package/crates/tish_bytecode/Cargo.toml

@@ -11,7 +11,6 @@ tishlang_ast = { path = "../tish_ast", version = ">=0.1" }
 tishlang_core = { path = "../tish_core", version = ">=0.1" }
 
 [dev-dependencies]
-tishlang_compile = { path = "../tish_compile", version = ">=0.1" }
 tishlang_parser = { path = "../tish_parser", version = ">=0.1" }
 tishlang_opt = { path = "../tish_opt", version = ">=0.1" }
 tishlang_vm = { path = "../tish_vm", version = ">=0.1" }

package/crates/tish_compile/src/codegen.rs

@@ -2674,6 +2674,8 @@ impl Codegen {
                     "Set",
                     "Map",
                     "Object",
+                    "Array",
+                    "Number",
                     "Float64Array",
                     "Float32Array",
                     "Int8Array",
@@ -2714,6 +2716,25 @@ impl Codegen {
                         self.writeln(&format!("let {} = {}.clone();", builtin, builtin));
                     }
                 }
+                // Feature-gated globals also move into the closure when referenced.
+                // Clone them only when their capability is actually linked, so we
+                // never emit `let h = h.clone();` for a binding that was never
+                // emitted (e.g. a fn-local named `h` in a program without JSX).
+                let mut gated: Vec<&str> = Vec::new();
+                if self.has_feature("http") {
+                    gated.extend(["fetch", "fetchAll"]);
+                }
+                if self.has_feature("fs") {
+                    gated.extend(["readFile", "writeFile", "fileExists", "isDir", "readDir", "mkdir"]);
+                }
+                if self.program_has_jsx && !self.has_native_ui_host {
+                    gated.extend(["Fragment", "h", "text", "useState", "createRoot"]);
+                }
+                for name in gated {
+                    if referenced.contains(name) {
+                        self.writeln(&format!("let {} = {}.clone();", name, name));
+                    }
+                }
                 self.writeln("Value::native(move |args: &[Value]| {");
                 self.value_fn_depth += 1;
                 self.indent += 1;

package/crates/tish_cranelift/Cargo.toml

@@ -9,11 +9,7 @@ repository = { workspace = true }
 [dependencies]
 tishlang_build_utils = { path = "../tish_build_utils", version = ">=0.1" }
 cranelift = "0.130"
-cranelift-codegen = "0.130"
-cranelift-frontend = "0.130"
 cranelift-module = "0.130"
 cranelift-native = "0.130"
 cranelift-object = "0.130"
-target-lexicon = "0.13"
 tishlang_bytecode = { path = "../tish_bytecode", version = ">=0.1" }
-tishlang_core = { path = "../tish_core", version = ">=0.1" }

package/crates/tish_cranelift_runtime/Cargo.toml

@@ -23,4 +23,3 @@ crate-type = ["staticlib", "rlib"]
 [dependencies]
 tishlang_bytecode = { path = "../tish_bytecode", version = ">=0.1" }
 tishlang_vm = { path = "../tish_vm", version = ">=0.1" }
-tishlang_core = { path = "../tish_core", version = ">=0.1" }

package/crates/tish_eval/Cargo.toml

@@ -13,8 +13,6 @@ timers = []
 http = [
     "timers",
     "tokio",
-    "reqwest",
-    "futures",
     "tiny_http",
     "tishlang_core/regex",
     "dep:tishlang_runtime",
@@ -27,7 +25,7 @@ http = [
 fs = []
 process = []
 tty = ["dep:tishlang_runtime", "tishlang_runtime/tty"]
-regex = ["dep:fancy-regex", "tishlang_core/regex"]
+regex = ["tishlang_core/regex"]
 tokio = ["dep:tokio"]
 ws = ["dep:tishlang_runtime", "tishlang_runtime/ws"]
 
@@ -43,9 +41,6 @@ tishlang_ast = { path = "../tish_ast", version = ">=0.1" }
 tishlang_builtins = { path = "../tish_builtins", version = ">=0.1" }
 tishlang_parser = { path = "../tish_parser", version = ">=0.1" }
 tishlang_core = { path = "../tish_core", version = ">=0.1" }
-reqwest = { version = "0.13.2", default-features = false, features = ["rustls", "json", "stream"], optional = true }
-futures = { version = "0.3.32", optional = true }
 tiny_http = { version = "0.12.0", optional = true }
-fancy-regex = { version = "0.17.0", optional = true }
 tokio = { version = "1.50.0", features = ["rt-multi-thread", "time", "sync"], optional = true }
 tishlang_runtime = { path = "../tish_runtime", version = ">=0.1", optional = true }

package/crates/tish_fmt/src/lib.rs

@@ -1124,11 +1124,41 @@ impl Printer {
         }
     }
 
+    /// Print JSX children inline and verbatim. JSX whitespace is significant in tish, so text is
+    /// emitted exactly as written and there is no reflow/indentation. A nested element/fragment is
+    /// printed bare (as a child element); any other expression child gets `{ }`.
+    fn jsx_children(&mut self, children: &[JsxChild]) {
+        for ch in children {
+            match ch {
+                JsxChild::Text(t) => self.buf.push_str(t.as_ref()),
+                JsxChild::Expr(e) => {
+                    if matches!(e, Expr::JsxElement { .. } | Expr::JsxFragment { .. }) {
+                        self.expr(e);
+                    } else {
+                        self.buf.push('{');
+                        self.expr(e);
+                        self.buf.push('}');
+                    }
+                }
+            }
+        }
+    }
+
     fn expr(&mut self, e: &Expr) {
         match e {
             Expr::Literal { value, .. } => match value {
                 Literal::Number(n) => {
-                    if n.fract() == 0.0 && n.abs() < 1e15 {
+                    if !n.is_finite() {
+                        // f64 overflow / NaN: emit the tish globals, not Rust's bare `inf`/`-inf`/`NaN`
+                        // (`inf` would re-parse as an undefined identifier).
+                        self.buf.push_str(if n.is_nan() {
+                            "NaN"
+                        } else if *n > 0.0 {
+                            "Infinity"
+                        } else {
+                            "-Infinity"
+                        });
+                    } else if n.fract() == 0.0 && n.abs() < 1e15 {
                         self.buf.push_str(&format!("{}", *n as i64));
                     } else {
                         self.buf.push_str(&format!("{}", n));
@@ -1169,7 +1199,18 @@ impl Printer {
             }
             Expr::New { callee, args, .. } => {
                 self.buf.push_str("new ");
-                self.child(callee, PREC_POSTFIX);
+                // `new` parses its callee as a member expression WITHOUT a trailing call, so any call
+                // in the callee's spine (`new (factory())()`, `new (factory().Cls)()`) must be
+                // parenthesized — otherwise the printed `()` rebinds as the constructor's argument
+                // list. child()'s precedence check can't catch this because a Call/Member already has
+                // postfix precedence.
+                if new_callee_has_call(callee) {
+                    self.buf.push('(');
+                    self.expr(callee);
+                    self.buf.push(')');
+                } else {
+                    self.child(callee, PREC_POSTFIX);
+                }
                 if !args.is_empty() {
                     self.emit_args(args);
                 }
@@ -1370,72 +1411,21 @@ impl Printer {
                 if children.is_empty() {
                     self.buf.push_str(" />");
                 } else {
-                    let compact = children.len() == 1
-                        && matches!(
-                            &children[0],
-                            JsxChild::Text(t) if !t.as_ref().contains('\n')
-                        );
-                    if compact {
-                        self.buf.push('>');
-                        if let JsxChild::Text(t) = &children[0] {
-                            self.buf.push_str(t.as_ref());
-                        }
-                        self.buf.push_str("</");
-                        self.buf.push_str(tag.as_ref());
-                        self.buf.push('>');
-                    } else {
-                        self.buf.push('>');
-                        self.buf.push('\n');
-                        for ch in children {
-                            self.buf.push_str("  ");
-                            match ch {
-                                JsxChild::Text(t) => self.buf.push_str(t.as_ref()),
-                                JsxChild::Expr(e) => {
-                                    self.buf.push('{');
-                                    self.expr(e);
-                                    self.buf.push('}');
-                                }
-                            }
-                            self.buf.push('\n');
-                        }
-                        self.buf.push_str("  </");
-                        self.buf.push_str(tag.as_ref());
-                        self.buf.push('>');
-                    }
+                    // JSX whitespace is significant in tish (the lexer keeps it verbatim and codegen
+                    // emits it as content), so children are printed inline and verbatim. Reflowing
+                    // them onto indented lines injected newlines/spaces as real text nodes, which
+                    // changed the rendered output and was non-idempotent.
+                    self.buf.push('>');
+                    self.jsx_children(children);
+                    self.buf.push_str("</");
+                    self.buf.push_str(tag.as_ref());
+                    self.buf.push('>');
                 }
             }
             Expr::JsxFragment { children, .. } => {
                 self.buf.push_str("<>");
-                if children.is_empty() {
-                    self.buf.push_str("</>");
-                } else {
-                    let compact = children.len() == 1
-                        && matches!(
-                            &children[0],
-                            JsxChild::Text(t) if !t.as_ref().contains('\n')
-                        );
-                    if compact {
-                        if let JsxChild::Text(t) = &children[0] {
-                            self.buf.push_str(t.as_ref());
-                        }
-                        self.buf.push_str("</>");
-                    } else {
-                        self.buf.push('\n');
-                        for ch in children {
-                            self.buf.push_str("  ");
-                            match ch {
-                                JsxChild::Text(t) => self.buf.push_str(t.as_ref()),
-                                JsxChild::Expr(e) => {
-                                    self.buf.push('{');
-                                    self.expr(e);
-                                    self.buf.push('}');
-                                }
-                            }
-                            self.buf.push('\n');
-                        }
-                        self.buf.push_str("</>");
-                    }
-                }
+                self.jsx_children(children);
+                self.buf.push_str("</>");
             }
             Expr::NativeModuleLoad {
                 spec, export_name, ..
@@ -1466,9 +1456,19 @@ impl Printer {
 }
 
 fn escape_template(s: &str) -> String {
-    s.replace('\\', "\\\\")
-        .replace('`', "\\`")
-        .replace('$', "\\$")
+    // In a template literal only backslash, backtick, and a `$` that begins an interpolation (`${`)
+    // need escaping. A bare `$` is literal, so escaping every `$` just adds spurious backslashes.
+    let mut out = String::with_capacity(s.len());
+    let mut chars = s.chars().peekable();
+    while let Some(c) = chars.next() {
+        match c {
+            '\\' => out.push_str("\\\\"),
+            '`' => out.push_str("\\`"),
+            '$' if chars.peek() == Some(&'{') => out.push_str("\\$"),
+            _ => out.push(c),
+        }
+    }
+    out
 }
 
 // Expression precedence levels (higher binds tighter), mirroring the parser's
@@ -1528,16 +1528,29 @@ fn expr_prec(e: &Expr) -> u8 {
         | Expr::PrefixInc { .. }
         | Expr::PrefixDec { .. } => 14,
         Expr::Call { .. }
-        | Expr::New { .. }
         | Expr::Member { .. }
         | Expr::Index { .. }
         | Expr::PostfixInc { .. }
         | Expr::PostfixDec { .. } => PREC_POSTFIX,
+        // `new X` binds looser than member/call, so a New used as the object of `.`/`[]`/`()`
+        // must be parenthesized (e.g. `(new Foo()).bar()`, not `new Foo().bar()`).
+        Expr::New { .. } => PREC_POSTFIX - 1,
         Expr::ArrowFunction { .. } => PREC_ATOM,
         _ => PREC_ATOM,
     }
 }
 
+/// True when a `new` callee contains a call in its member/index spine. Such a callee must be
+/// parenthesized, because `new` parses its callee without a trailing call and would otherwise bind
+/// the first `()` as the constructor's argument list (`new (f())()`, `new (f().C)()`).
+fn new_callee_has_call(e: &Expr) -> bool {
+    match e {
+        Expr::Call { .. } => true,
+        Expr::Member { object, .. } | Expr::Index { object, .. } => new_callee_has_call(object),
+        _ => false,
+    }
+}
+
 fn binop(op: BinOp) -> &'static str {
     match op {
         BinOp::Add => "+",
@@ -1813,15 +1826,83 @@ mod tests {
         let _ = tishlang_parser::parse(&out).unwrap();
     }
 
+    /// Debug-render the parsed AST with all `Span { … }` contents removed, so two programs compare
+    /// equal iff they are structurally identical (reformatting legitimately changes spans).
+    fn structure(src: &str) -> String {
+        let dbg = format!("{:#?}", tishlang_parser::parse(src).unwrap().statements);
+        let mut out = String::new();
+        let mut rest = dbg.as_str();
+        while let Some(i) = rest.find("Span {") {
+            out.push_str(&rest[..i]);
+            match rest[i..].find('}') {
+                Some(j) => rest = &rest[i + j + 1..],
+                None => {
+                    rest = "";
+                    break;
+                }
+            }
+        }
+        out.push_str(rest);
+        out
+    }
+
+    #[test]
+    fn new_expr_preserves_structure_and_is_idempotent() {
+        // Each input must format to a program with the SAME structure (modulo spans), and a second
+        // format pass must be a no-op. These previously corrupted into structurally different
+        // programs (Call<->New<->Member swaps) on format.
+        for src in [
+            "const d = (new Foo()).bar()\n",
+            "const b = new (factory().Cls)()\n",
+            "const x = new (getClass())(1)\n",
+            "const e = new Foo()\n",
+            "const f = new a.b.c()\n",
+            "const g = new Foo(1, 2).baz\n",
+        ] {
+            let out = format_source(src).unwrap();
+            let out2 = format_source(&out).unwrap();
+            assert_eq!(structure(src), structure(&out), "structure changed: {src:?} -> {out:?}");
+            assert_eq!(out, out2, "not idempotent: {src:?} -> {out:?} -> {out2:?}");
+        }
+    }
+
+    #[test]
+    fn jsx_preserves_structure_and_is_idempotent() {
+        // JSX whitespace is significant; formatting must not inject newlines/indentation as text
+        // (which changed rendered output and was non-idempotent). Structure must be preserved.
+        for src in [
+            "let x = <div>a{b}</div>\n",
+            "const e = <div>Hello {name}!</div>\n",
+            "const e2 = <div><span>a</span><span>b</span></div>\n",
+            "let y = <div>  spaced  text  </div>\n",
+            "let z = <>{a}{b}</>\n",
+            "let s = <div a={1} b=\"x\">{c}</div>\n",
+        ] {
+            let out = format_source(src).unwrap();
+            let out2 = format_source(&out).unwrap();
+            assert_eq!(structure(src), structure(&out), "JSX structure changed: {src:?} -> {out:?}");
+            assert_eq!(out, out2, "JSX not idempotent: {src:?} -> {out:?} -> {out2:?}");
+        }
+    }
+
     #[test]
-    fn jsx_multiline_when_mixed_children() {
-        let src = "let x = <div>a{b}</div>\n";
+    fn non_finite_number_literal_emits_valid_token() {
+        // 1e400 overflows f64 to infinity; it must format to the `Infinity` global, not Rust's bare
+        // `inf` (which would re-parse as an undefined identifier).
+        let src = "let x = 1e400\n";
         let out = format_source(src).unwrap();
-        assert!(
-            out.contains('\n'),
-            "expected line breaks in formatted JSX: {out:?}"
-        );
-        let _ = tishlang_parser::parse(&out).unwrap();
+        assert!(out.contains("Infinity"), "expected Infinity, got {out:?}");
+        tishlang_parser::parse(&out).expect("formatted output must parse");
+        assert_eq!(format_source(&out).unwrap(), out, "not idempotent: {out:?}");
+    }
+
+    #[test]
+    fn template_literal_escapes_only_interpolation_dollar() {
+        let src = "let p = `cost: $5 and ${x} done`\n";
+        let out = format_source(src).unwrap();
+        assert!(out.contains("cost: $5"), "a bare $ must not be escaped: {out:?}");
+        assert_eq!(structure(src), structure(&out), "structure changed: {src:?} -> {out:?}");
+        assert_eq!(format_source(&out).unwrap(), out, "not idempotent: {out:?}");
     }
 
     #[test]

package/crates/tish_lsp/src/import_goto.rs

@@ -450,6 +450,21 @@ fn resolve_relative_tish(from_dir: &Path, from_s: &str, imported: &str) -> Optio
     crate::find_export(&prog, imported, &u, &src)
 }
 
+/// Resolve a relative default import (`import X from "./m"`) to the `export default` in the source.
+fn resolve_relative_tish_default(from_dir: &Path, from_s: &str) -> Option<Location> {
+    let target = from_dir.join(from_s.trim_start_matches("./"));
+    let target = if target.extension().is_none() {
+        target.with_extension("tish")
+    } else {
+        target
+    };
+    let can = target.canonicalize().ok()?;
+    let u = Url::from_file_path(&can).ok()?;
+    let src = std::fs::read_to_string(&can).ok()?;
+    let prog = tishlang_parser::parse(&src).ok()?;
+    crate::find_default_export(&prog, &u, &src)
+}
+
 /// After same-file [`tishlang_resolve::definition_span`] misses, resolve import sites (Tish files,
 /// `node_modules` packages, and Rust `pub fn` for native / `cargo:` imports).
 pub fn definition_for_import(
@@ -474,12 +489,13 @@ pub fn definition_for_import(
         };
         let from_s = from.as_ref();
         for sp in specifiers {
-            let (imported, local) = match sp {
+            let (imported, local, is_default) = match sp {
                 ImportSpecifier::Named { name, alias, .. } => (
                     name.as_ref(),
                     alias.as_ref().map(|a| a.as_ref()).unwrap_or(name.as_ref()),
+                    false,
                 ),
-                ImportSpecifier::Default { name, .. } => (name.as_ref(), name.as_ref()),
+                ImportSpecifier::Default { name, .. } => (name.as_ref(), name.as_ref(), true),
                 ImportSpecifier::Namespace { .. } => continue,
             };
             if local != word {
@@ -487,7 +503,13 @@ pub fn definition_for_import(
             }
 
             if from_s.starts_with("./") || from_s.starts_with("../") {
-                return resolve_relative_tish(from_dir, from_s, imported);
+                // A default import binds the source module's `export default`, which has no name to
+                // match; resolve it directly. Named imports resolve by exported name.
+                return if is_default {
+                    resolve_relative_tish_default(from_dir, from_s)
+                } else {
+                    resolve_relative_tish(from_dir, from_s, imported)
+                };
             }
 
             if is_native_import(from_s) {