@tishlang/tish-lsp 2.38.0 → 2.43.8

package/crates/tish_compile/src/infer.rs

@@ -229,7 +229,7 @@ pub fn infer_expr_type(expr: &Expr, ctx: &InferCtx) -> Option<TypeAnnotation> {
 /// Run inference over a program, returning a modified Program with additional
 /// type annotations filled in on `VarDecl` nodes.
 pub fn infer_program(program: &Program) -> Program {
-    // M4 (opt-in via TISH_PARAM_INFER) runs FIRST: give unannotated params used PURELY
+    // M4 (default-on via native_opts_enabled; TISH_NATIVE_OPT=0 opts out) runs FIRST: give unannotated params used PURELY
     // numerically a synthetic `: number`. Doing this *before* local/struct inference is what
     // lets derived numeric locals (`let x0 = (px / w) * 3`) be proven numeric off the now-known
     // param types — otherwise they fall back to boxed `Value` and the whole hot loop boxes with
@@ -245,7 +245,7 @@ pub fn infer_program(program: &Program) -> Program {
     let p = Program {
         statements: infer_statements(&p.statements, &mut ctx),
     };
-    // Automatic struct inference (opt-in via TISH_STRUCT_INFER until proven):
+    // Automatic struct inference (default-on via native_opts_enabled):
     // give unannotated object literals a concrete struct type so the Rust
     // backend emits unboxed structs with direct field access. Conservative —
     // only applies when every use of the binding is a literal-key field read,
@@ -255,17 +255,18 @@ pub fn infer_program(program: &Program) -> Program {
     } else {
         p
     };
-    // S-0..S-C aggregate (interprocedural monomorphic struct) inference — issue #177, opt-in via
-    // TISH_AGGREGATE_INFER, OFF by default. Front-end of the nbody unboxing lever: it
+    // S-0..S-F aggregate (interprocedural monomorphic struct) inference — issue #177, default-on
+    // via native_opts_enabled. Front-end of the nbody unboxing lever: it
     //   S-0: types params used ONLY as object-literal field values (`body(x,…)` → `: number`),
     //   S-A: registers the return-shape struct alias for an all-f64 object-literal-returning fn,
     //   S-B: propagates a call's return type to `let p = body(…)` / `let bs = makeBodies()`,
     //   S-C: types `[ident,…]` array literals from those struct-typed locals.
-    // The full lever also needs S-D (write-permitting param-shape) + S-E/S-F (the typed-fn ABI
-    // tier in codegen) before the annotations can be *consumed* without a boxed-edge miscompile;
-    // until those land this pass only emits the annotations the existing codegen backs SOUNDLY
-    // (the S-0 scalar `: number` params, identical to the M4 mechanism) plus the inert struct
-    // alias decls. See `aggregate_infer_program`.
+    // S-0 scalar params are always stamped. The S-A/S-B/S-C struct/array shapes are stamped only
+    // when the S-D whole-program candidacy predicate holds (`unbox_alias` — monomorphic all-f64
+    // shape, no `===`/escape/reshape), in which case codegen's S-E/S-F typed-fn ABI tier
+    // (`setup_aggregate_fns`) consumes them, de-virtualizing the group into native free fns over
+    // `Vec<TishStruct_alias>`; any unlowerable use disables the whole path (boxed fallback,
+    // byte-identical). See `aggregate_infer_program` / `stamp_aggregate`.
     if crate::native_opts_enabled() {
         aggregate_infer_program(p)
     } else {
@@ -274,7 +275,7 @@ pub fn infer_program(program: &Program) -> Program {
 }
 
 // ---------------------------------------------------------------------------
-// M4: parameter type inference (conservative, sound, opt-in)
+// M4: parameter type inference (conservative, sound, default-on)
 // ---------------------------------------------------------------------------
 
 fn param_infer_program(program: Program) -> Program {
@@ -1469,7 +1470,7 @@ pub(crate) fn pi_mentions(e: &Expr, name: &str) -> bool {
 }
 
 // ---------------------------------------------------------------------------
-// Automatic struct inference (conservative, sound, opt-in)
+// Automatic struct inference (conservative, sound, default-on)
 // ---------------------------------------------------------------------------
 
 /// One emitted `type` decl: alias name plus its field list.
@@ -2319,7 +2320,7 @@ fn inline_single_call_factories(stmts: Vec<Statement>) -> Vec<Statement> {
         // (`return [a, b]`), a call return, or a discarded `f()` is left intact — those are the #177
         // aggregate machinery's territory (nbody's `makeBodies` returns `[sun, jupiter, …]`, and
         // inlining it removes the function the aggregate ABI expects → nbody BUILD-FAIL under
-        // TISH_AGGREGATE_INFER). This keeps the inliner to exactly the Stage A/B bridge target.
+        // the aggregate path). This keeps the inliner to exactly the Stage A/B bridge target.
         let return_ident = match &ret_expr {
             Expr::Ident { name, .. } if leaked.iter().any(|l| l.as_ref() == name.as_ref()) => {
                 name.clone()
@@ -3987,8 +3988,8 @@ fn _uses_arrow_body(_: &ArrowBody) {}
 // S-0..S-C: aggregate (interprocedural monomorphic struct) inference — issue #177
 // ===========================================================================
 //
-// This is the front-end of the nbody-unboxing lever. It runs ONLY under
-// `TISH_AGGREGATE_INFER` (OFF by default). The four sub-passes are pure analysis
+// This is the front-end of the nbody-unboxing lever. It runs by default under
+// `native_opts_enabled()` (`TISH_NATIVE_OPT=0` opts out). The four sub-passes are pure analysis
 // over the (already base/param/struct-inferred) `Program`:
 //
 //   S-0  param-numeric-as-field-value: a param used ONLY as an object-literal
@@ -4004,27 +4005,22 @@ fn _uses_arrow_body(_: &ArrowBody) {}
 //
 // SOUNDNESS / WHAT IS ACTUALLY WRITTEN BACK
 // -----------------------------------------
-// The struct types S-A/S-B/S-C compute cannot yet be *consumed* by codegen
-// without the S-D write-permitting param predicate and the S-E/S-F typed-fn ABI
-// tier (a de-virtualized `fn advance(bodies: &VmRef<Vec<TishStruct_Body>>, …)`).
-// Until those land, writing a `Named`/`Array(Named)` annotation onto a fn param
-// or a call-initialised local would MISCOMPILE: `collect_annotated_types`
-// (codegen.rs) records the param/local as a native struct while the actual
-// binding is still a boxed `Value` (the call returns boxed `Value` — there is no
-// FnSigTable / struct-returning emission), so a `p.x` field read or `bodies[i].vx
-// = …` write would be lowered against a boxed value. The boxed-edge `===`/escape
-// hazards in the design's candidacy predicate are the same class of problem.
-//
-// Therefore `aggregate_infer_program` writes back ONLY the annotations the
-// EXISTING codegen backs soundly:
-//   * S-0's scalar `: number` params (identical to the M4 param-infer mechanism,
-//     already consumed soundly), and
-//   * the inert struct `type` alias decls (unreferenced aliases are dropped by
-//     codegen — they change nothing on their own).
-// The S-A/S-B/S-C struct *shapes* are computed and exposed via
-// `analyze_aggregate` for unit tests and for the future S-D..S-F consumers, but
-// are NOT yet stamped onto params / call-locals. This keeps the ON path free of
-// any checksum divergence while the inference logic is validated independently.
+// Stamping a struct/array annotation is only sound when codegen can back it end
+// to end — a `Named`/`Array(Named)` annotation on a param or call-initialised
+// local whose actual binding stays a boxed `Value` would MISCOMPILE (`p.x` /
+// `bodies[i].vx = …` lowered against a boxed value). So write-back is two-tier:
+//   * S-0's scalar `: number` params are ALWAYS stamped (identical to the M4
+//     param-infer mechanism, already consumed soundly), plus the struct `type`
+//     alias decls (inert on their own — unreferenced aliases are dropped).
+//   * The S-A/S-B/S-C struct/array shapes are stamped ONLY when the S-D
+//     whole-program candidacy predicate holds (`compute_unbox_candidacy` →
+//     `unbox_alias`: one monomorphic all-f64 shape, no `===`/escape/reshape).
+//     Codegen's S-E/S-F typed-fn ABI tier (`setup_aggregate_fns`) then consumes
+//     them, de-virtualizing the factory/array/operator fns into native free fns
+//     over `Vec<TishStruct_alias>` threaded by reference. All-or-nothing with
+//     scratch-buffer rollback: any unlowerable use disables the whole path and
+//     the boxed closures are emitted unchanged (byte-identical fallback).
+// `analyze_aggregate` stays exposed for unit tests over the raw analysis.
 
 /// The result of the aggregate analysis: the registered struct shapes plus, per
 /// function, the inferred return shape and the set of params S-0 typed numeric.
@@ -5003,12 +4999,12 @@ fn infer_aggregate_expr(
     }
 }
 
-/// Aggregate inference writeback. Runs the S-0..S-C analysis, then stamps onto the
-/// program ONLY the annotations the existing codegen backs soundly (see the module
-/// note above): the S-0 numeric `: number` params, plus the inert struct alias
-/// `type` decls. The S-A/S-B/S-C struct shapes are computed and available via
-/// `analyze_aggregate` but are NOT written onto params / call-locals until the
-/// S-D..S-F typed-fn ABI tier exists to consume them without a boxed-edge miscompile.
+/// Aggregate inference writeback (two-tier — see the module note above). Always
+/// stamps the S-0 numeric `: number` params plus the struct alias `type` decls;
+/// when the S-D candidacy predicate holds (`unbox_alias` is `Some`) it ALSO stamps
+/// the S-A/S-B/S-C struct/array shapes (factory returns, group-fn array params,
+/// top-level array locals), which codegen's S-E/S-F typed-fn ABI tier
+/// (`setup_aggregate_fns`) consumes with scratch-buffer rollback.
 fn aggregate_infer_program(program: Program) -> Program {
     let analysis = analyze_aggregate(&program);
 

package/crates/tish_compile/src/lib.rs

@@ -5,9 +5,13 @@
 mod check;
 mod codegen;
 mod infer;
+mod platform_resolve;
 mod resolve;
+mod schemes;
 mod types;
 
+pub use schemes::{set_active as set_scheme_registry, SchemeRegistry};
+
 pub use check::{check_program, TypeDiagnostic};
 
 /// The native typed-codegen optimizations — numeric param inference, struct/aggregate inference,
@@ -29,13 +33,16 @@ pub(crate) fn native_recur_guard_enabled() -> bool {
     std::env::var("TISH_NATIVE_RECUR_GUARD").map(|v| v != "0").unwrap_or(true)
 }
 
-/// How generated Rust is linked (desktop binary vs embedded iOS staticlib).
+/// How generated Rust is linked (desktop binary vs embedded iOS staticlib vs GBA ROM).
 #[derive(Debug, Clone, Copy, PartialEq, Eq, Default)]
 pub enum NativeEmitMode {
     #[default]
     DesktopBin,
     /// `[lib] crate-type = ["staticlib"]` — no `fn main()`, host calls `tish_ios_launch`.
     EmbeddedLib,
+    /// Game Boy Advance ROM: `#![no_std]`, `#[agb::entry] fn agb_main(gba)`, links the
+    /// `tishlang_runtime_gba` facade. Numbers/async lowering diverge; see codegen `emit_program`.
+    Gba,
 }
 
 pub use codegen::CompileError;
@@ -44,6 +51,11 @@ pub use codegen::{
     compile_with_features, compile_with_native_modules, compile_with_native_modules_emit,
     compile_with_project_root,
 };
+pub use platform_resolve::{
+    apply_resolve_env, parse_platform, parse_surface, platform_suffixes, platform_virtual_keys,
+    resolve_context, resolve_id_public, resolve_with_platform, set_resolve_context, Platform,
+    ResolveContext, Surface,
+};
 pub use resolve::{
     cargo_export_fn_name, compute_native_build_artifacts, detect_cycles, ensure_tish_canvas_module,
     export_name_to_rust_ident, extract_native_import_features, format_rust_dependencies_toml,

package/crates/tish_compile/src/platform_resolve.rs

@@ -0,0 +1,361 @@
+//! React Native–style platform/surface file resolution for `.tish` imports.
+//!
+//! See docs/LANGUAGE.md (platform extensions). Context is process-wide so existing
+//! `resolve_project` callers pick up `--platform` / `--surface` / env without signature churn.
+
+use std::path::{Path, PathBuf};
+use std::sync::{Mutex, OnceLock};
+
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Default)]
+pub enum Platform {
+    #[default]
+    Unknown,
+    Macos,
+    Ios,
+    Android,
+    Windows,
+    Linux,
+    Web,
+}
+
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Default)]
+pub enum Surface {
+    #[default]
+    Unknown,
+    Native,
+    Webview,
+    Web,
+}
+
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Default)]
+pub struct ResolveContext {
+    pub platform: Platform,
+    pub surface: Surface,
+}
+
+fn resolve_ctx_lock() -> &'static Mutex<ResolveContext> {
+    static RESOLVE_CTX: OnceLock<Mutex<ResolveContext>> = OnceLock::new();
+    RESOLVE_CTX.get_or_init(|| Mutex::new(ResolveContext::default()))
+}
+
+pub fn set_resolve_context(ctx: ResolveContext) {
+    *resolve_ctx_lock().lock().unwrap_or_else(|e| e.into_inner()) = ctx;
+}
+
+pub fn resolve_context() -> ResolveContext {
+    *resolve_ctx_lock().lock().unwrap_or_else(|e| e.into_inner())
+}
+
+pub fn parse_platform(s: &str) -> Option<Platform> {
+    match s.trim().to_ascii_lowercase().as_str() {
+        "macos" | "darwin" | "osx" => Some(Platform::Macos),
+        "ios" => Some(Platform::Ios),
+        "android" => Some(Platform::Android),
+        "windows" | "win32" | "win" => Some(Platform::Windows),
+        "linux" => Some(Platform::Linux),
+        "web" => Some(Platform::Web),
+        "" | "unknown" | "default" => Some(Platform::Unknown),
+        _ => None,
+    }
+}
+
+pub fn parse_surface(s: &str) -> Option<Surface> {
+    match s.trim().to_ascii_lowercase().as_str() {
+        "native" => Some(Surface::Native),
+        "webview" => Some(Surface::Webview),
+        "web" => Some(Surface::Web),
+        "" | "unknown" | "default" => Some(Surface::Unknown),
+        _ => None,
+    }
+}
+
+/// Apply CLI/env into the process resolve context.
+/// `TISH_PLATFORM` / `TISH_SURFACE` fill gaps when args are omitted.
+pub fn apply_resolve_env(platform: Option<&str>, surface: Option<&str>) -> Result<(), String> {
+    let mut ctx = resolve_context();
+    if let Some(p) = platform {
+        ctx.platform = parse_platform(p).ok_or_else(|| format!("unknown --platform '{p}'"))?;
+    } else if let Ok(p) = std::env::var("TISH_PLATFORM") {
+        if let Some(parsed) = parse_platform(&p) {
+            ctx.platform = parsed;
+        }
+    }
+    if let Some(s) = surface {
+        ctx.surface = parse_surface(s).ok_or_else(|| format!("unknown --surface '{s}'"))?;
+    } else if let Ok(s) = std::env::var("TISH_SURFACE") {
+        if let Some(parsed) = parse_surface(&s) {
+            ctx.surface = parsed;
+        }
+    }
+    // `--platform web` implies surface web when surface unset
+    if ctx.platform == Platform::Web && ctx.surface == Surface::Unknown {
+        ctx.surface = Surface::Web;
+    }
+    set_resolve_context(ctx);
+    Ok(())
+}
+
+/// Suffix tokens to try (before bare `.tish`), most specific first.
+pub fn platform_suffixes(ctx: ResolveContext) -> Vec<&'static str> {
+    let mut out = Vec::new();
+    match (ctx.platform, ctx.surface) {
+        (_, Surface::Web) | (Platform::Web, _) => {
+            out.push("web");
+        }
+        (Platform::Macos, Surface::Native) | (Platform::Macos, Surface::Unknown) => {
+            out.extend(["macos", "desktop", "native"]);
+        }
+        (Platform::Ios, Surface::Native) | (Platform::Ios, Surface::Unknown) => {
+            out.extend(["ios", "mobile", "native"]);
+        }
+        (Platform::Android, Surface::Native) | (Platform::Android, Surface::Unknown) => {
+            out.extend(["android", "mobile", "native"]);
+        }
+        (Platform::Windows, Surface::Native) | (Platform::Windows, Surface::Unknown) => {
+            out.extend(["windows", "desktop", "native"]);
+        }
+        (Platform::Linux, Surface::Native) | (Platform::Linux, Surface::Unknown) => {
+            out.extend(["linux", "desktop", "native"]);
+        }
+        (Platform::Macos, Surface::Webview)
+        | (Platform::Windows, Surface::Webview)
+        | (Platform::Linux, Surface::Webview)
+        | (Platform::Unknown, Surface::Webview) => {
+            out.extend(["webview", "web", "desktop"]);
+        }
+        (Platform::Ios, Surface::Webview) | (Platform::Android, Surface::Webview) => {
+            out.extend(["webview", "web", "mobile"]);
+        }
+        _ => {}
+    }
+    out
+}
+
+/// After normalizing a virtual path to a stem (no `.tish`), list cascade keys to probe.
+/// `normalized_stem` is e.g. `app/Button` (no extension).
+pub fn platform_virtual_keys(normalized_stem: &str, ctx: ResolveContext) -> Vec<String> {
+    let parent = Path::new(normalized_stem)
+        .parent()
+        .map(|p| p.to_string_lossy().to_string())
+        .filter(|p| !p.is_empty() && p != ".");
+    let file_stem = Path::new(normalized_stem)
+        .file_name()
+        .and_then(|s| s.to_str())
+        .unwrap_or("index");
+    let mut keys = Vec::new();
+    for suffix in platform_suffixes(ctx) {
+        keys.push(match &parent {
+            Some(p) => format!("{p}/{file_stem}.{suffix}.tish"),
+            None => format!("{file_stem}.{suffix}.tish"),
+        });
+    }
+    keys.push(match &parent {
+        Some(p) => format!("{p}/{file_stem}.tish"),
+        None => format!("{file_stem}.tish"),
+    });
+    keys
+}
+
+/// Resolve a relative import specifier to an on-disk path, trying platform variants.
+///
+/// `spec` is e.g. `./Button` or `./Button.tish`. Never picks native-only suffixes for web surface.
+pub fn resolve_with_platform(
+    spec: &str,
+    from_dir: &Path,
+    ctx: ResolveContext,
+) -> Option<PathBuf> {
+    let joined = from_dir.join(spec);
+    let (stem_path, had_tish_ext) = if joined.extension().and_then(|e| e.to_str()) == Some("tish")
+    {
+        (joined.with_extension(""), true)
+    } else if joined.extension().is_none() {
+        (joined, false)
+    } else {
+        // Other extensions (.js, .css): leave to caller / no platform remap
+        return if joined.exists() {
+            joined.canonicalize().ok()
+        } else {
+            None
+        };
+    };
+
+    let parent = stem_path.parent().unwrap_or(from_dir);
+    let file_stem = stem_path
+        .file_name()
+        .and_then(|s| s.to_str())
+        .unwrap_or("index");
+
+    for suffix in platform_suffixes(ctx) {
+        let candidate = parent.join(format!("{file_stem}.{suffix}.tish"));
+        if candidate.exists() {
+            return candidate.canonicalize().ok();
+        }
+    }
+
+    let base = parent.join(format!("{file_stem}.tish"));
+    if base.exists() {
+        return base.canonicalize().ok();
+    }
+
+    // Explicit path without remap that already exists (edge)
+    if had_tish_ext {
+        let explicit = from_dir.join(spec);
+        if explicit.exists() {
+            return explicit.canonicalize().ok();
+        }
+    }
+
+    None
+}
+
+/// Public one-shot for CLI / Vite: resolve `importer` + `source` → absolute path string.
+pub fn resolve_id_public(
+    source: &str,
+    importer: Option<&str>,
+    platform: Option<&str>,
+    surface: Option<&str>,
+) -> Result<String, String> {
+    apply_resolve_env(platform, surface)?;
+    let ctx = resolve_context();
+    let from_dir = if let Some(imp) = importer {
+        Path::new(imp)
+            .parent()
+            .map(Path::to_path_buf)
+            .unwrap_or_else(|| PathBuf::from("."))
+    } else {
+        std::env::current_dir().unwrap_or_else(|_| PathBuf::from("."))
+    };
+
+    if !source.starts_with("./") && !source.starts_with("../") {
+        return Err(format!(
+            "resolve-id only handles relative imports (got '{source}')"
+        ));
+    }
+
+    resolve_with_platform(source, &from_dir, ctx)
+        .map(|p| p.display().to_string())
+        .ok_or_else(|| {
+            let tried: Vec<_> = platform_suffixes(ctx)
+                .into_iter()
+                .map(|s| format!("*.{s}.tish"))
+                .collect();
+            format!(
+                "Cannot resolve '{source}' from {} (tried {} then *.tish)",
+                from_dir.display(),
+                if tried.is_empty() {
+                    "(no platform suffixes)".into()
+                } else {
+                    tried.join(", ")
+                }
+            )
+        })
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use std::fs;
+    use tempfile::tempdir;
+
+    #[test]
+    fn macos_native_prefers_macos_then_desktop() {
+        let dir = tempdir().unwrap();
+        let root = dir.path();
+        fs::write(root.join("Button.desktop.tish"), "").unwrap();
+        fs::write(root.join("Button.macos.tish"), "").unwrap();
+        fs::write(root.join("Button.tish"), "").unwrap();
+        let ctx = ResolveContext {
+            platform: Platform::Macos,
+            surface: Surface::Native,
+        };
+        let p = resolve_with_platform("./Button", root, ctx).unwrap();
+        assert!(p.ends_with("Button.macos.tish"));
+    }
+
+    #[test]
+    fn webview_reuses_web_not_macos() {
+        let dir = tempdir().unwrap();
+        let root = dir.path();
+        fs::write(root.join("Button.macos.tish"), "").unwrap();
+        fs::write(root.join("Button.web.tish"), "").unwrap();
+        let ctx = ResolveContext {
+            platform: Platform::Macos,
+            surface: Surface::Webview,
+        };
+        let p = resolve_with_platform("./Button", root, ctx).unwrap();
+        assert!(p.ends_with("Button.web.tish"));
+    }
+
+    #[test]
+    fn web_surface_only_web_and_base() {
+        let dir = tempdir().unwrap();
+        let root = dir.path();
+        fs::write(root.join("Button.macos.tish"), "").unwrap();
+        fs::write(root.join("Button.web.tish"), "").unwrap();
+        let ctx = ResolveContext {
+            platform: Platform::Web,
+            surface: Surface::Web,
+        };
+        let p = resolve_with_platform("./Button.tish", root, ctx).unwrap();
+        assert!(p.ends_with("Button.web.tish"));
+    }
+
+    #[test]
+    fn android_native_prefers_android_then_mobile() {
+        let dir = tempdir().unwrap();
+        let root = dir.path();
+        fs::write(root.join("Button.mobile.tish"), "").unwrap();
+        fs::write(root.join("Button.android.tish"), "").unwrap();
+        fs::write(root.join("Button.tish"), "").unwrap();
+        let ctx = ResolveContext {
+            platform: Platform::Android,
+            surface: Surface::Native,
+        };
+        let p = resolve_with_platform("./Button", root, ctx).unwrap();
+        assert!(p.ends_with("Button.android.tish"));
+    }
+
+    #[test]
+    fn ios_native_falls_back_to_mobile() {
+        let dir = tempdir().unwrap();
+        let root = dir.path();
+        fs::write(root.join("Button.mobile.tish"), "").unwrap();
+        fs::write(root.join("Button.tish"), "").unwrap();
+        let ctx = ResolveContext {
+            platform: Platform::Ios,
+            surface: Surface::Native,
+        };
+        let p = resolve_with_platform("./Button", root, ctx).unwrap();
+        assert!(p.ends_with("Button.mobile.tish"));
+    }
+
+    #[test]
+    fn virtual_keys_cascade_with_and_without_parent() {
+        // nested path keeps the parent dir; macos/native → macos, desktop, native, then base
+        let macos = platform_virtual_keys(
+            "app/Button",
+            ResolveContext {
+                platform: Platform::Macos,
+                surface: Surface::Native,
+            },
+        );
+        assert_eq!(
+            macos,
+            vec![
+                "app/Button.macos.tish",
+                "app/Button.desktop.tish",
+                "app/Button.native.tish",
+                "app/Button.tish",
+            ]
+        );
+        // bare stem (no parent) + web surface → web, then base
+        let web = platform_virtual_keys(
+            "Button",
+            ResolveContext {
+                platform: Platform::Web,
+                surface: Surface::Web,
+            },
+        );
+        assert_eq!(web, vec!["Button.web.tish", "Button.tish"]);
+    }
+}