From 4fa054b16e12a64617d77ea43411a8e0bc762633 Mon Sep 17 00:00:00 2001
From: jasisz <jasisz@gmail.com>
Date: Wed, 6 May 2026 11:34:13 +0200
Subject: [PATCH 01/18] 0.16.3 step 1: lazy CallerFnCollector + drop
 globals/start (WIP)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Foundation refactor for the caller_fn i32-table redesign — codegen
becomes the single source of truth for which fn names land in the
exported table, no more AST walker.

Changes:

- `body::CallerFnCollector` (new): RefCell-friendly registry that
  `emit_caller_fn_idx` lazily registers fn names into. Each call site
  that wants a caller_fn slot gets one assigned in encounter order
  (first call to `register("main")` → idx 0, etc.). Idempotent — the
  per-fn probe pass in `module.rs` registers the same names twice
  (probe + real emit), `register` returns the already-stored idx on
  the second hit.
- `EmitCtx` carries `&RefCell<CallerFnCollector>`; `emit_fn_body`
  takes the collector through its signature.
- `body/emit.rs::emit_caller_fn_idx` rewritten — instead of looking
  up `registry.caller_fn_idx[self_fn_name]` (the 0.16.2 walker-built
  map), it calls `collector.register(self_fn_name)` and emits
  `i32.const <idx>`. Single source of truth.
- `effects.rs::params` trailing arg switched from `any_ref_ty()` to
  `ValType::I32`. Host gets an idx instead of a String ref.
- AST walker `fn_body_emits_effect_call` removed from `types.rs`,
  along with `caller_fn_idx` / `caller_fn_order` fields and the
  pre-walker fn-name segment registration. The collector replaces all
  three.
- `module.rs`: 0.16.2's GlobalSection + StartSection + init body for
  `__init_globals` are gone. Their replacement (`__caller_fn_count`
  + `__caller_fn_name` exports plus the matching passive segments
  appended to the data section) is the next step — see TODO comments
  inline.

Status — partial:

- Compile: green (debug + release).
- 10/10 wasm-gc record-replay smokes pass — but only because the
  host's `lm_string_to_host` falls through `Val::I32 → None →
  "main"` for the new ABI shape, and every smoke asserts
  `caller_fn: "main"` (which was 0.16.2's "main" too). The actual
  feature (per-fn caller_fn labels) is broken until step 2 lands the
  exports + body + segments + host wiring.

TODO step 2 (next session):

- 2 new wasm types: `__caller_fn_count: () -> i32` and
  `__caller_fn_name: (i32) -> (ref null $string)`.
- 2 new fn entries in the function section, allocated last so their
  wasm fn idxs come after every helper.
- 2 new exports.
- Post-emit body emit for both, reading `collector.names`.
- Append `collector.names` as fresh passive segments after the
  pre-walked literal segments; bump the data count section.
- Host (Rust + JS): drop the LM round-trip in `dispatch_aver_import`,
  read `params.last().i32()` directly, look up
  `caller_fn_table[idx as usize]` from a `Vec<String>` materialised
  once at instantiation by walking `__caller_fn_name(0..count)`.

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>
---
 src/codegen/wasm_gc/body.rs          |  37 ++++++++++
 src/codegen/wasm_gc/body/builtins.rs |   6 +-
 src/codegen/wasm_gc/body/emit.rs     |  33 ++++-----
 src/codegen/wasm_gc/effects.rs       |   8 +-
 src/codegen/wasm_gc/module.rs        | 105 ++++++---------------------
 src/codegen/wasm_gc/types.rs         |  84 ++-------------------
 6 files changed, 91 insertions(+), 182 deletions(-)

diff --git a/src/codegen/wasm_gc/body.rs b/src/codegen/wasm_gc/body.rs
index 714c4f38..3a84ecb5 100644
--- a/src/codegen/wasm_gc/body.rs
+++ b/src/codegen/wasm_gc/body.rs
@@ -158,6 +158,7 @@ pub(super) fn emit_fn_body(
     self_wasm_idx: u32,
     registry: &TypeRegistry,
     effect_idx_lookup: &HashMap<String, u32>,
+    caller_fn_collector: &std::cell::RefCell<CallerFnCollector>,
 ) -> Result<Vec<ValType>, WasmGcError> {
     let slots = SlotTable::build_for_fn(fd, registry, fn_map)?;
     let FnBody::Block(stmts) = fd.body.as_ref();
@@ -187,6 +188,7 @@ pub(super) fn emit_fn_body(
         params: &fd.params,
         binding_names: &binding_names,
         effect_idx_lookup,
+        caller_fn_collector,
     };
 
     for (i, stmt) in stmts.iter().enumerate() {
@@ -247,6 +249,35 @@ pub(super) fn emit_fn_body(
     Ok(slots.extra_locals(count_value_params(&fd.params)))
 }
 
+/// Lazy-populated registry of caller_fn names actually emitted by the
+/// codegen. Replaces the AST walker `fn_body_emits_effect_call` from
+/// 0.16.2 — every site that calls `emit_caller_fn_idx` registers the
+/// fn name here on demand, so the wasm output's caller-fn name table
+/// contains exactly the fns whose bodies emit a caller_fn slot. Zero
+/// false positives, zero rozjazdy walker↔codegen.
+#[derive(Default)]
+pub(super) struct CallerFnCollector {
+    /// Aver fn name → idx in the exported caller-fn table (0..N).
+    pub(super) idx_by_name: HashMap<String, u32>,
+    /// Insertion order — the host walks `__caller_fn_name(0..N)` and
+    /// the i-th entry must match `names[i]`.
+    pub(super) names: Vec<String>,
+}
+
+impl CallerFnCollector {
+    /// Get-or-insert a name, returning the i32 idx the codegen emits
+    /// at the call site. New names land at the end of `names`.
+    pub(super) fn register(&mut self, name: &str) -> u32 {
+        if let Some(&i) = self.idx_by_name.get(name) {
+            return i;
+        }
+        let i = self.names.len() as u32;
+        self.names.push(name.to_string());
+        self.idx_by_name.insert(name.to_string(), i);
+        i
+    }
+}
+
 /// Per-fn lowering context — read-only state every emit fn needs.
 pub(super) struct EmitCtx<'a> {
     pub(super) fn_map: &'a FnMap,
@@ -276,6 +307,12 @@ pub(super) struct EmitCtx<'a> {
     /// independent product anywhere — discovery only registers the
     /// three host imports if it sees one.
     pub(super) effect_idx_lookup: &'a HashMap<String, u32>,
+    /// Lazy collector for caller_fn names. `emit_caller_fn_idx`
+    /// registers the current fn name here on each effect call site;
+    /// the eventual `__caller_fn_name(idx)` body and data segments
+    /// are emitted from `names` after every fn body has been
+    /// produced.
+    pub(super) caller_fn_collector: &'a std::cell::RefCell<CallerFnCollector>,
 }
 
 impl<'a> EmitCtx<'a> {
diff --git a/src/codegen/wasm_gc/body/builtins.rs b/src/codegen/wasm_gc/body/builtins.rs
index 3079b7dd..9bea0b4a 100644
--- a/src/codegen/wasm_gc/body/builtins.rs
+++ b/src/codegen/wasm_gc/body/builtins.rs
@@ -60,7 +60,7 @@ pub(super) fn emit_dotted_builtin(
         for arg in args {
             emit_expr(func, arg, slots, ctx)?;
         }
-        super::emit::emit_caller_fn_global(func, ctx)?;
+        super::emit::emit_caller_fn_idx(func, ctx)?;
         func.instruction(&Instruction::Call(wasm_idx));
         return Ok(());
     }
@@ -492,7 +492,7 @@ pub(super) fn emit_args_get_inline(
             ))?;
 
     // len = args_len()
-    super::emit::emit_caller_fn_global(func, ctx)?;
+    super::emit::emit_caller_fn_idx(func, ctx)?;
     func.instruction(&Instruction::Call(args_len_idx));
     func.instruction(&Instruction::LocalSet(len_slot));
     // i = len - 1
@@ -515,7 +515,7 @@ pub(super) fn emit_args_get_inline(
     func.instruction(&Instruction::BrIf(1));
     // s = args_get(i)
     func.instruction(&Instruction::LocalGet(i_slot));
-    super::emit::emit_caller_fn_global(func, ctx)?;
+    super::emit::emit_caller_fn_idx(func, ctx)?;
     func.instruction(&Instruction::Call(args_get_idx));
     func.instruction(&Instruction::LocalSet(s_slot));
     // acc = struct.new List<String> { head: s, tail: acc }
diff --git a/src/codegen/wasm_gc/body/emit.rs b/src/codegen/wasm_gc/body/emit.rs
index 0b5f31bd..924b6f87 100644
--- a/src/codegen/wasm_gc/body/emit.rs
+++ b/src/codegen/wasm_gc/body/emit.rs
@@ -1322,7 +1322,7 @@ pub(super) fn emit_independent_product_unwrap(
 /// to match.
 fn emit_group_call(func: &mut Function, ctx: &EmitCtx<'_>, op: &str) {
     if let Some(idx) = ctx.effect_idx_lookup.get(op) {
-        if emit_caller_fn_global(func, ctx).is_err() {
+        if emit_caller_fn_idx(func, ctx).is_err() {
             // Should never trip — every fn def has a global allocated
             // in `TypeRegistry::build`.
             return;
@@ -1339,7 +1339,7 @@ fn emit_group_call(func: &mut Function, ctx: &EmitCtx<'_>, op: &str) {
 fn emit_branch_marker(func: &mut Function, ctx: &EmitCtx<'_>, branch_idx: u32) {
     if let Some(idx) = ctx.effect_idx_lookup.get("__record_set_branch") {
         func.instruction(&Instruction::I64Const(branch_idx as i64));
-        if emit_caller_fn_global(func, ctx).is_err() {
+        if emit_caller_fn_idx(func, ctx).is_err() {
             return;
         }
         func.instruction(&Instruction::Call(*idx));
@@ -2352,27 +2352,22 @@ pub(super) fn emit_string_match(
     Ok(())
 }
 
-/// Push the caller-fn String ref via `global.get`. Each fn def in
-/// the program owns one immutable `(ref null $string)` global,
-/// `array.new_data`-init from the fn-name passive segment at module
-/// instantiation. The hot path is a single `global.get` per effect
-/// call — zero alloc, ~3 bytes per call site.
-pub(super) fn emit_caller_fn_global(
+/// Push the caller-fn idx as an `i32` immediate. Lazy-registers the
+/// current fn name with the collector so the post-emit phase knows
+/// exactly which fn names to put in the exported caller-fn table.
+/// Single source of truth: any code path that wants to label its
+/// effect call site with the originating fn just calls this — no
+/// AST walker, no rozjazdy walker↔codegen. Hot path: 2-3 bytes
+/// (`i32.const <idx>`), zero allocation.
+pub(super) fn emit_caller_fn_idx(
     func: &mut Function,
     ctx: &EmitCtx<'_>,
 ) -> Result<(), WasmGcError> {
     let idx = ctx
-        .registry
-        .caller_fn_globals
-        .get(ctx.self_fn_name)
-        .copied()
-        .ok_or_else(|| {
-            WasmGcError::Validation(format!(
-                "no caller_fn global registered for fn `{}`",
-                ctx.self_fn_name
-            ))
-        })?;
-    func.instruction(&Instruction::GlobalGet(idx));
+        .caller_fn_collector
+        .borrow_mut()
+        .register(ctx.self_fn_name);
+    func.instruction(&Instruction::I32Const(idx as i32));
     Ok(())
 }
 
diff --git a/src/codegen/wasm_gc/effects.rs b/src/codegen/wasm_gc/effects.rs
index 1bd98a82..cd901cf4 100644
--- a/src/codegen/wasm_gc/effects.rs
+++ b/src/codegen/wasm_gc/effects.rs
@@ -411,7 +411,13 @@ impl EffectName {
     /// their interpreter stack frames, wasm-gc has to be told.
     pub(super) fn params(self, registry: &TypeRegistry) -> Result<Vec<ValType>, WasmGcError> {
         let mut p = self.params_without_caller(registry)?;
-        p.push(any_ref_ty());
+        // Trailing caller_fn arg is now an `i32` index into the
+        // exported caller-fn name table (built by the host at
+        // instantiation via `__caller_fn_count` + `__caller_fn_name`).
+        // 0.16.2 used `(ref null $string)` per-call — replaced to
+        // drop N globals + N start-fn allocs and to give the host
+        // a vector-index lookup instead of a per-call LM round-trip.
+        p.push(ValType::I32);
         Ok(p)
     }
 
diff --git a/src/codegen/wasm_gc/module.rs b/src/codegen/wasm_gc/module.rs
index b40b80e4..00062fe4 100644
--- a/src/codegen/wasm_gc/module.rs
+++ b/src/codegen/wasm_gc/module.rs
@@ -42,6 +42,15 @@ pub(super) fn emit_module(
 ) -> Result<Vec<u8>, WasmGcError> {
     let registry = TypeRegistry::build_with_handler(items, handler_name.is_some());
 
+    // Lazy caller_fn name registry — populated during user-fn body
+    // emit by `emit_caller_fn_idx` call sites. Threaded into every
+    // `emit_fn_body` call via `EmitCtx::caller_fn_collector`. The
+    // post-emit phase reads `collector.names` to materialise the
+    // exported caller-fn name table (`__caller_fn_count` +
+    // `__caller_fn_name`) and the matching passive data segments.
+    let caller_fn_collector =
+        std::cell::RefCell::new(super::body::CallerFnCollector::default());
+
     let fn_defs: Vec<&FnDef> = items
         .iter()
         .filter_map(|it| match it {
@@ -354,20 +363,6 @@ pub(super) fn emit_module(
         funcs.function(b.grow_type);
     }
     factory_exports.emit_function_entries(&mut funcs);
-    // `__init_globals`: wasm-level start fn that lazy-fills the
-    // caller_fn globals via `array.new_data`. Has to be a separate
-    // fn (not part of `_start`) because the host invokes `main`
-    // directly when both are exported, bypassing `_start` —
-    // wasm-level start fns are auto-run at instantiation regardless
-    // of which export the host calls. Allocated last so its idx is
-    // import_count + funcs.len() once the entry is appended.
-    let init_globals_fn_idx: Option<u32> = if !registry.caller_fn_global_order.is_empty() {
-        let idx = import_count + funcs.len();
-        funcs.function(start_type_idx);
-        Some(idx)
-    } else {
-        None
-    };
     module.section(&funcs);
 
     // ── Memory section (bridge LM only) ────────────────────────────
@@ -391,40 +386,10 @@ pub(super) fn emit_module(
         module.section(&memories);
     }
 
-    // ── Global section ─────────────────────────────────────────────
-    // One mutable `(ref null $string)` global per fn def, declared as
-    // `ref.null` and lazy-initialised at the top of `_start` via
-    // `array.new_data $string $segment 0 N`. The wasm-gc spec doesn't
-    // permit `array.new_data` in const-expr position, so the init has
-    // to land in a code body — `_start` runs once per instantiation
-    // and dominates every effect call site, which is what we need.
-    // Body emit pushes the caller-fn ref through
-    // `global.get $caller_fn_<idx>` at every effect call site — the
-    // alloc happens once at startup, the hot path costs one global
-    // load.
-    if !registry.caller_fn_global_order.is_empty() {
-        let string_idx = registry
-            .string_array_type_idx
-            .expect("caller_fn globals require the $string slot — TypeRegistry forces it on");
-        let mut globals = wasm_encoder::GlobalSection::new();
-        for _ in &registry.caller_fn_global_order {
-            let init = wasm_encoder::ConstExpr::extended([Instruction::RefNull(
-                wasm_encoder::HeapType::Concrete(string_idx),
-            )]);
-            globals.global(
-                wasm_encoder::GlobalType {
-                    val_type: wasm_encoder::ValType::Ref(wasm_encoder::RefType {
-                        nullable: true,
-                        heap_type: wasm_encoder::HeapType::Concrete(string_idx),
-                    }),
-                    mutable: true,
-                    shared: false,
-                },
-                &init,
-            );
-        }
-        module.section(&globals);
-    }
+    // (caller_fn delivery moved from per-fn globals to an exported
+    // name table; segment append + `__caller_fn_*` exports are
+    // wired in the post-emit phase further down. Globals + their
+    // start-fn init are gone.)
 
     // Build the fn-name → wasm-fn-idx map. With K imports:
     //   imports at idx 0..K
@@ -536,14 +501,9 @@ pub(super) fn emit_module(
     }
     module.section(&exports);
 
-    // ── Start section ──────────────────────────────────────────────
-    // Wasm-level start fn — auto-runs once at instantiation, ahead of
-    // any host-invoked export. Used for caller_fn global init.
-    if let Some(idx) = init_globals_fn_idx {
-        module.section(&wasm_encoder::StartSection {
-            function_index: idx,
-        });
-    }
+    // (No StartSection — 0.16.2's caller_fn globals init is gone;
+    // host reads the caller_fn name table via `__caller_fn_count`
+    // + `__caller_fn_name(i)` exports at instantiation instead.)
 
     // ── Data count section (must precede code when using passive
     //     segments via array.new_data / data.drop).
@@ -585,6 +545,7 @@ pub(super) fn emit_module(
             self_wasm_idx,
             &registry,
             &effect_idx_lookup,
+            &caller_fn_collector,
         )?;
 
         let local_groups: Vec<(u32, ValType)> = extra_locals_dry.iter().map(|v| (1, *v)).collect();
@@ -596,6 +557,7 @@ pub(super) fn emit_module(
             self_wasm_idx,
             &registry,
             &effect_idx_lookup,
+            &caller_fn_collector,
         )?;
         codes.function(&func);
     }
@@ -658,32 +620,11 @@ pub(super) fn emit_module(
 
     factory_exports.emit_bodies(&mut codes, &registry)?;
 
-    // `__init_globals` body — one `array.new_data → global.set` per
-    // registered caller_fn name. Walks `caller_fn_global_order` so
-    // global idx i in the section matches the `i`-th name in the
-    // walker output. Runs at instantiation via the StartSection
-    // emitted below.
-    if init_globals_fn_idx.is_some() {
-        let string_idx = registry
-            .string_array_type_idx
-            .expect("caller_fn globals require the $string slot");
-        let mut init = Function::new([]);
-        for (idx, fn_name) in registry.caller_fn_global_order.iter().enumerate() {
-            let bytes = fn_name.as_bytes();
-            let segment_idx = registry
-                .string_literal_segment(bytes)
-                .expect("fn-name passive segment registered alongside the global");
-            init.instruction(&Instruction::I32Const(0));
-            init.instruction(&Instruction::I32Const(bytes.len() as i32));
-            init.instruction(&Instruction::ArrayNewData {
-                array_type_index: string_idx,
-                array_data_index: segment_idx,
-            });
-            init.instruction(&Instruction::GlobalSet(idx as u32));
-        }
-        init.instruction(&Instruction::End);
-        codes.function(&init);
-    }
+    // (caller_fn name-table body emit + segment append happen
+    // post-emit once the lazy collector has all names — TODO in
+    // step 2 of the 0.16.3 refactor; currently the wasm binary
+    // is missing `__caller_fn_count` / `__caller_fn_name` exports
+    // and the host falls back to "main" for every caller_fn slot.)
 
     module.section(&codes);
 
diff --git a/src/codegen/wasm_gc/types.rs b/src/codegen/wasm_gc/types.rs
index 8b0582a4..2f216988 100644
--- a/src/codegen/wasm_gc/types.rs
+++ b/src/codegen/wasm_gc/types.rs
@@ -115,16 +115,6 @@ pub(super) struct TypeRegistry {
     /// $string $segment_idx` with offset=0, size=len.
     pub(super) string_literals: Vec<Vec<u8>>,
     pub(super) string_literal_idx: HashMap<Vec<u8>, u32>,
-    /// Per-fn `(ref null $string)` global, init by `array.new_data`
-    /// from the fn-name passive segment. Codegen emits `global.get`
-    /// at every effect call site instead of allocating a fresh
-    /// `(array i8)` per call — module-instantiation pays the alloc
-    /// once, the runtime hot path costs one global load.
-    pub(super) caller_fn_globals: HashMap<String, u32>,
-    /// Emit order for the caller-fn globals, matched to the
-    /// idx values stored above. The `GlobalSection` walks this
-    /// vector so wasm idx 0..N matches the map values.
-    pub(super) caller_fn_global_order: Vec<String>,
     /// Type names that must NOT be erased to their underlying
     /// primitive by the newtype optimisation. Populated with every
     /// record/variant used as a `Map<K, *>` key — Map's open-
@@ -699,33 +689,13 @@ impl TypeRegistry {
                 collect_string_literals_in_fn(fd, &mut string_literals, &mut string_literal_idx);
             }
         }
-        // Pre-register fn names as passive String literals AND
-        // allocate `(ref null $string)` wasm globals — but only for
-        // fns whose body actually emits caller_fn at a call site (a
-        // dotted call `Foo.bar(...)` or an `?!`/`!` independent
-        // product, which lowers to group/branch markers). Pure fns
-        // and plain forwarders that only call other user fns don't
-        // need a slot.
-        let mut caller_fn_globals: HashMap<String, u32> = HashMap::new();
-        let mut caller_fn_global_order: Vec<String> = Vec::new();
-        for item in items {
-            if let TopLevel::FnDef(fd) = item {
-                if !fn_body_emits_effect_call(fd) {
-                    continue;
-                }
-                let bytes = fd.name.as_bytes().to_vec();
-                string_literal_idx.entry(bytes.clone()).or_insert_with(|| {
-                    let idx = string_literals.len() as u32;
-                    string_literals.push(bytes);
-                    idx
-                });
-                caller_fn_globals.entry(fd.name.clone()).or_insert_with(|| {
-                    let idx = caller_fn_global_order.len() as u32;
-                    caller_fn_global_order.push(fd.name.clone());
-                    idx
-                });
-            }
-        }
+        // Note: caller_fn name registration moved out of `TypeRegistry`
+        // — `body::CallerFnCollector` lazy-registers names during
+        // codegen (every site that calls `emit_caller_fn_idx` registers
+        // its self_fn_name on demand), and the post-emit phase appends
+        // the resulting names as fresh passive segments after the
+        // pre-walked literal segments above. Single source of truth,
+        // zero AST-walker false positives.
         // `Int.mod` lowers to a boxed `Result<Int, String>` whose Err
         // arm carries a fixed "Division by zero" message — register
         // its bytes as a passive segment so the emitter has an idx
@@ -789,8 +759,6 @@ impl TypeRegistry {
             string_array_type_idx,
             string_literals,
             string_literal_idx,
-            caller_fn_globals,
-            caller_fn_global_order,
             non_newtypable_keys,
         }
     }
@@ -2035,44 +2003,6 @@ fn fn_body_calls_int_mod(fd: &crate::ast::FnDef) -> bool {
     })
 }
 
-/// Returns true when the fn body contains anything that emits a
-/// caller_fn slot at codegen — a dotted call (any `Attr(_, _)`
-/// callee, including nested-module shape `Module.Sub.fn(args)`) or
-/// an independent product (`?!` / `!`, lowers to group/branch
-/// markers). Used to skip allocating a global for fns that never
-/// need one. Conservative on dotted: builtin namespace calls like
-/// `List.length` are also flagged; false positives cost one segment
-/// + one global per fn, false negatives crash wasm validation.
-fn fn_body_emits_effect_call(fd: &crate::ast::FnDef) -> bool {
-    use crate::ast::{Expr, FnBody, Stmt};
-    fn walk(e: &Expr) -> bool {
-        match e {
-            Expr::FnCall(callee, args) => {
-                let dotted = matches!(&callee.node, Expr::Attr(_, _));
-                dotted || walk(&callee.node) || args.iter().any(|a| walk(&a.node))
-            }
-            Expr::IndependentProduct(_, _) => true,
-            Expr::Match { subject, arms } => {
-                walk(&subject.node) || arms.iter().any(|a| walk(&a.body.node))
-            }
-            Expr::BinOp(_, l, r) => walk(&l.node) || walk(&r.node),
-            Expr::Attr(o, _) => walk(&o.node),
-            Expr::ErrorProp(i) => walk(&i.node),
-            Expr::TailCall(b) => b.args.iter().any(|a| walk(&a.node)),
-            Expr::List(xs) | Expr::Tuple(xs) => xs.iter().any(|x| walk(&x.node)),
-            Expr::RecordCreate { fields, .. } => fields.iter().any(|(_, e)| walk(&e.node)),
-            Expr::RecordUpdate { base, updates, .. } => {
-                walk(&base.node) || updates.iter().any(|(_, e)| walk(&e.node))
-            }
-            Expr::Constructor(_, p) => p.as_deref().is_some_and(|x| walk(&x.node)),
-            _ => false,
-        }
-    }
-    let FnBody::Block(stmts) = fd.body.as_ref();
-    stmts.iter().any(|stmt| match stmt {
-        Stmt::Binding(_, _, e) | Stmt::Expr(e) => walk(&e.node),
-    })
-}
 
 fn collect_string_literals_in_fn(
     fd: &crate::ast::FnDef,

From df911fd90c22be721657e8e84cad213553adda2b Mon Sep 17 00:00:00 2001
From: jasisz <jasisz@gmail.com>
Date: Wed, 6 May 2026 12:12:32 +0200
Subject: [PATCH 02/18] 0.16.3 step 2: __caller_fn_count + __caller_fn_name
 exports + host
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Wires up the compiler-side and host-side ends of the caller_fn name
table that step 1's lazy collector was already feeding. wasm-gc
binaries now self-host their fn name list — no external metadata, no
LM round-trip per call.

Compiler:

- Two new wasm types in `module.rs::compile_to_wasm_gc`:
  `__caller_fn_count: () -> i32` and
  `__caller_fn_name: (i32) -> (ref null $string)`. Allocated only
  when the program has the `$string` slot (i.e. any user fn def).
- Two matching fn entries appended to the function section after
  factory exports; their idxs are exported as `__caller_fn_count` /
  `__caller_fn_name`.
- Pre-pass over user fn bodies populates the lazy collector with
  every fn name that ever pushes caller_fn at a call site. Needed
  before the data count section emit because passive segment count
  is `string_literals.len() + collector.names.len()`.
- `__caller_fn_count` body: `i32.const N; end`.
- `__caller_fn_name(idx)` body: per-name `block { brif ne; emit;
  br outer; end }` chain. One arm per registered fn name, each
  materialising the matching String ref via `array.new_data` from
  a freshly-appended passive segment. Default arm returns `ref.null`
  for out-of-range idxs.
- Caller_fn name segments appended to the data section after the
  pre-walked literal segments; data count bumped accordingly.

Rust host (`run_wasm_gc.rs`):

- New `RunWasmGcHost::caller_fn_table: Vec<String>` field, populated
  at instance creation by `build_caller_fn_table` — calls
  `__caller_fn_count`, then walks `__caller_fn_name(0..count)`,
  decoding each ref via the existing `__rt_string_to_lm` bridge.
  Empty vector when the module doesn't export the table (programs
  with no fn defs).
- `imports.rs::dispatch_aver_import` swaps the per-call LM round-
  trip for a vector index lookup: `params.last().i32() → caller_fn_
  table[idx]`. Unused `lm_string_to_host` import removed.

JS host (`tools/website/playground/wasm_host.js`):

- `setInstance` calls `materialiseCallerFnTable(instance)` — same
  shape as the Rust side, walks `__caller_fn_count` + `__caller_fn_
  name(0..count)`, decodes via `averToJs`, caches in
  `this.callerFnTable`.
- Per effect callback's trailing arg renamed `callerRef → callerIdx`
  (Number now, not anyref). Helper `dec(...) → averToJs(ref)` swept
  to `callerFnFromIdx(idx) → callerFnTable[idx] || "main"`.

Sizes (rebuild_playground.py with the fresh compiler):

- snake: 4506 → 4421 B (-85 B, -1.9%)
- tetris: 8723 → 8440 B (-283 B, -3.2%)
- life: 7097 → 6897 B (-200 B, -2.8%)
- wumpus: 5590 → 5312 B (-278 B, -5.0%)
- doom: 23197 → 20890 B (-2307 B, -9.9%)
- checkers: 23969 → 21617 B (-2352 B, -9.8%)
- rogue: 28666 → 26173 B (-2493 B, -8.7%)

Bigger games shed ~10% — the per-fn caller_fn globals (8 B decl + 9 B
init body each) dropped, replaced by one `i32.const` per call site
and a single name-table dispatch shared across all fns.

Verified end-to-end:

  $ aver run --wasm-gc --record /tmp/cf.json examples/core/effects_explicit.av
  Hello, Ada!
  Goodbye, Ada!
  $ python3 -c '...'
  Console.print -> greet
  Console.print -> farewell

10/10 wasm-gc record-replay smokes pass; 7/7 prebuilt games rebuild
+ validate.

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>
---
 src/codegen/wasm_gc/module.rs              | 154 +++++++++++++++++++--
 src/main/run_wasm_gc.rs                    |  90 ++++++++++++
 src/main/run_wasm_gc/imports.rs            |  19 ++-
 tools/website/index.html                   |  16 +--
 tools/website/playground/checkers.wasm     | Bin 23969 -> 21617 bytes
 tools/website/playground/doom.wasm         | Bin 23197 -> 20890 bytes
 tools/website/playground/index.html        |  16 +--
 tools/website/playground/life.wasm         | Bin 7097 -> 6897 bytes
 tools/website/playground/rogue.wasm        | Bin 28666 -> 26173 bytes
 tools/website/playground/snake.wasm        | Bin 4506 -> 4421 bytes
 tools/website/playground/tetris.wasm       | Bin 8723 -> 8440 bytes
 tools/website/playground/wasm/aver.js      |   2 +-
 tools/website/playground/wasm/aver_bg.wasm | Bin 4665508 -> 4664936 bytes
 tools/website/playground/wasm_host.js      | 143 +++++++++++--------
 tools/website/playground/wumpus.wasm       | Bin 5590 -> 5312 bytes
 15 files changed, 355 insertions(+), 85 deletions(-)

diff --git a/src/codegen/wasm_gc/module.rs b/src/codegen/wasm_gc/module.rs
index 00062fe4..4d186478 100644
--- a/src/codegen/wasm_gc/module.rs
+++ b/src/codegen/wasm_gc/module.rs
@@ -316,6 +316,37 @@ pub(super) fn emit_module(
         &effect_registry,
     )?;
 
+    // 10) Caller-fn name table exports. `__caller_fn_count() -> i32`
+    //     and `__caller_fn_name(i32) -> ref null $string`. Host walks
+    //     `0..count` once at instantiation, decodes each ref via the
+    //     LM bridge, caches in a `Vec<String>`. Per effect call: `i32`
+    //     idx flows through `params.last()` → vector index lookup,
+    //     no LM round-trip on the hot path.
+    //
+    //     Allocated only when the program has the String slot (i.e.
+    //     any fn def, since `needs_string` forces the slot whenever
+    //     `has_fn_defs`). Programs without fns never emit caller_fn
+    //     anywhere so the exports would be unused.
+    let caller_fn_table_types: Option<(u32, u32)> =
+        if let Some(string_type_idx) = registry.string_array_type_idx {
+            // count: () -> i32
+            types.ty().function([], [ValType::I32]);
+            let count_type_idx = next_type_idx;
+            next_type_idx += 1;
+            // name: (i32) -> (ref null $string)
+            let string_ref_ty = ValType::Ref(wasm_encoder::RefType {
+                nullable: true,
+                heap_type: wasm_encoder::HeapType::Concrete(string_type_idx),
+            });
+            types.ty().function([ValType::I32], [string_ref_ty]);
+            let name_type_idx = next_type_idx;
+            // Last type allocation in this fn — `next_type_idx`
+            // increment dropped to silence `unused_assignments`.
+            Some((count_type_idx, name_type_idx))
+        } else {
+            None
+        };
+
     module.section(&types);
 
     // ── Import section ─────────────────────────────────────────────
@@ -363,6 +394,18 @@ pub(super) fn emit_module(
         funcs.function(b.grow_type);
     }
     factory_exports.emit_function_entries(&mut funcs);
+    // Caller-fn name table fns — fixed-shape entries (count + name),
+    // their bodies land at the very end of the code section once
+    // `caller_fn_collector` has all names. Idxs are recorded so
+    // `module.section(&exports)` can wire them up without re-deriving
+    // the position.
+    let caller_fn_table_fns: Option<(u32, u32)> = caller_fn_table_types.map(|(c_ty, n_ty)| {
+        let count_fn_idx = import_count + funcs.len();
+        funcs.function(c_ty);
+        let name_fn_idx = import_count + funcs.len();
+        funcs.function(n_ty);
+        (count_fn_idx, name_fn_idx)
+    });
     module.section(&funcs);
 
     // ── Memory section (bridge LM only) ────────────────────────────
@@ -499,17 +542,45 @@ pub(super) fn emit_module(
             );
         }
     }
+    if let Some((count_fn_idx, name_fn_idx)) = caller_fn_table_fns {
+        exports.export("__caller_fn_count", ExportKind::Func, count_fn_idx);
+        exports.export("__caller_fn_name", ExportKind::Func, name_fn_idx);
+    }
     module.section(&exports);
 
     // (No StartSection — 0.16.2's caller_fn globals init is gone;
     // host reads the caller_fn name table via `__caller_fn_count`
     // + `__caller_fn_name(i)` exports at instantiation instead.)
 
+    // Pre-pass over user fn bodies — populates `caller_fn_collector`
+    // with every fn name that emits caller_fn at a call site. Needed
+    // before data count + data section emit because the count of
+    // passive segments is `string_literals + collector.names`, and
+    // data count section must precede the code section. Real body
+    // emit later in the code section calls `register` again with the
+    // same names; the collector is idempotent so the idx assignment
+    // matches what the call sites observed during this probe.
+    for (i, fd) in fn_defs.iter().enumerate() {
+        let self_wasm_idx = import_count + 1 + (i as u32);
+        let mut probe = Function::new([]);
+        let _ = emit_fn_body(
+            &mut probe,
+            fd,
+            &fn_map,
+            self_wasm_idx,
+            &registry,
+            &effect_idx_lookup,
+            &caller_fn_collector,
+        )?;
+    }
+    let caller_fn_segment_count = caller_fn_collector.borrow().names.len() as u32;
+
     // ── Data count section (must precede code when using passive
     //     segments via array.new_data / data.drop).
-    if !registry.string_literals.is_empty() {
+    let total_segment_count = registry.string_literals.len() as u32 + caller_fn_segment_count;
+    if total_segment_count > 0 {
         let count = DataCountSection {
-            count: registry.string_literals.len() as u32,
+            count: total_segment_count,
         };
         module.section(&count);
     }
@@ -620,22 +691,89 @@ pub(super) fn emit_module(
 
     factory_exports.emit_bodies(&mut codes, &registry)?;
 
-    // (caller_fn name-table body emit + segment append happen
-    // post-emit once the lazy collector has all names — TODO in
-    // step 2 of the 0.16.3 refactor; currently the wasm binary
-    // is missing `__caller_fn_count` / `__caller_fn_name` exports
-    // and the host falls back to "main" for every caller_fn slot.)
+    // `__caller_fn_count` + `__caller_fn_name` bodies. Emitted after
+    // every helper so their fn idxs land last in the code section,
+    // matching the function section allocation order. The collector
+    // is fully populated at this point — every user-fn body ran
+    // through the pre-pass and the real-emit pass.
+    if let Some((_count_fn_idx, _name_fn_idx)) = caller_fn_table_fns {
+        let names = caller_fn_collector.borrow();
+        let string_idx = registry
+            .string_array_type_idx
+            .expect("caller_fn name table requires the $string slot");
+        // Caller-fn name segments occupy the data section slot range
+        // [string_literals.len()..string_literals.len()+names.len()];
+        // `array.new_data` in `__caller_fn_name(i)` reads from those
+        // idxs.
+        let segment_base = registry.string_literals.len() as u32;
+
+        // __caller_fn_count: pure constant.
+        let mut count_fn = Function::new([]);
+        count_fn.instruction(&Instruction::I32Const(names.names.len() as i32));
+        count_fn.instruction(&Instruction::End);
+        codes.function(&count_fn);
+
+        // __caller_fn_name(idx) -> ref null $string. Switch on idx
+        // via `br_table`; each arm materialises the matching String
+        // ref via `array.new_data`. A trailing default arm returns
+        // ref.null for out-of-range idxs (host shouldn't pass them,
+        // but the wasm validator wants a fallthrough).
+        let string_ref_ty = ValType::Ref(wasm_encoder::RefType {
+            nullable: true,
+            heap_type: wasm_encoder::HeapType::Concrete(string_idx),
+        });
+        let mut name_fn = Function::new([]);
+        let block_ty = wasm_encoder::BlockType::Result(string_ref_ty);
+        name_fn.instruction(&Instruction::Block(block_ty));
+        for (i, fn_name) in names.names.iter().enumerate() {
+            let bytes = fn_name.as_bytes();
+            // Inner block: if idx == i, this arm emits the ref and
+            // breaks out of the outer block. Otherwise falls through
+            // to the next arm.
+            name_fn.instruction(&Instruction::Block(wasm_encoder::BlockType::Empty));
+            // if local 0 != i { br 0 } — skip to next arm.
+            name_fn.instruction(&Instruction::LocalGet(0));
+            name_fn.instruction(&Instruction::I32Const(i as i32));
+            name_fn.instruction(&Instruction::I32Ne);
+            name_fn.instruction(&Instruction::BrIf(0));
+            // Match: emit ref + break to outer.
+            name_fn.instruction(&Instruction::I32Const(0));
+            name_fn.instruction(&Instruction::I32Const(bytes.len() as i32));
+            name_fn.instruction(&Instruction::ArrayNewData {
+                array_type_index: string_idx,
+                array_data_index: segment_base + i as u32,
+            });
+            name_fn.instruction(&Instruction::Br(1));
+            name_fn.instruction(&Instruction::End);
+        }
+        // Default arm — out-of-range idx returns ref.null.
+        name_fn.instruction(&Instruction::RefNull(wasm_encoder::HeapType::Concrete(
+            string_idx,
+        )));
+        name_fn.instruction(&Instruction::End);
+        name_fn.instruction(&Instruction::End);
+        codes.function(&name_fn);
+    }
 
     module.section(&codes);
 
     // ── Data section ───────────────────────────────────────────────
     // Passive segments holding String literal byte sequences. Emitted
     // last; `array.new_data $string $segment_idx` reads from these.
-    if !registry.string_literals.is_empty() {
+    // Order: pre-walked program literals first, caller_fn names
+    // second. `__caller_fn_name`'s body uses
+    // `segment_base = registry.string_literals.len()` so its arms
+    // hit the right slots regardless of how many literals the
+    // program has.
+    if total_segment_count > 0 {
         let mut data = DataSection::new();
         for bytes in &registry.string_literals {
             data.passive(bytes.iter().copied());
         }
+        let names = caller_fn_collector.borrow();
+        for fn_name in &names.names {
+            data.passive(fn_name.as_bytes().iter().copied());
+        }
         module.section(&data);
     }
 
diff --git a/src/main/run_wasm_gc.rs b/src/main/run_wasm_gc.rs
index b7acece4..2da72f9b 100644
--- a/src/main/run_wasm_gc.rs
+++ b/src/main/run_wasm_gc.rs
@@ -193,6 +193,84 @@ pub(super) struct RunWasmGcHost {
     /// output. `None` is the production path — zero overhead beyond the
     /// `Option::is_some` check per effect call.
     pub(super) recorder: Option<aver::replay::EffectReplayState>,
+    /// Caller-fn name table, materialised at instantiation by walking
+    /// `__caller_fn_count` + `__caller_fn_name(0..count)`. Per effect
+    /// call, `imports.rs::dispatch_aver_import` looks up
+    /// `caller_fn_table[idx]` to stamp the recorded effect's
+    /// `caller_fn` field. Cleared (kept empty) for modules that don't
+    /// export the table.
+    pub(super) caller_fn_table: Vec<String>,
+}
+
+/// Walk `__caller_fn_count` + `__caller_fn_name(0..count)` once at
+/// instance creation, decode each name via the LM bridge, return the
+/// resulting `Vec<String>` so per-call dispatch can index into it
+/// without per-call LM round-trips. Empty when the module doesn't
+/// export the table (programs without effect-emitting fns).
+#[cfg(feature = "wasm")]
+fn build_caller_fn_table(
+    store: &mut wasmtime::Store<RunWasmGcHost>,
+    instance: &wasmtime::Instance,
+) -> Result<Vec<String>, String> {
+    use wasmtime::Val;
+    let count_fn = match instance.get_func(&mut *store, "__caller_fn_count") {
+        Some(f) => f,
+        None => return Ok(Vec::new()),
+    };
+    let name_fn = match instance.get_func(&mut *store, "__caller_fn_name") {
+        Some(f) => f,
+        None => return Ok(Vec::new()),
+    };
+    let to_lm = match instance.get_func(&mut *store, "__rt_string_to_lm") {
+        Some(f) => f,
+        None => return Ok(Vec::new()),
+    };
+    let memory = match instance.get_memory(&mut *store, "memory") {
+        Some(m) => m,
+        None => return Ok(Vec::new()),
+    };
+
+    let mut count_out = [Val::I32(0)];
+    count_fn
+        .call(&mut *store, &[], &mut count_out)
+        .map_err(|e| format!("__caller_fn_count: {e:#}"))?;
+    let count = match count_out[0] {
+        Val::I32(n) => n.max(0) as usize,
+        _ => 0,
+    };
+
+    let mut out = Vec::with_capacity(count);
+    let mut name_out = [Val::AnyRef(None)];
+    let mut len_out = [Val::I32(0)];
+    for i in 0..count {
+        name_fn
+            .call(&mut *store, &[Val::I32(i as i32)], &mut name_out)
+            .map_err(|e| format!("__caller_fn_name({i}): {e:#}"))?;
+        // Decode via __rt_string_to_lm: writes bytes into LM at
+        // offset 0, returns the byte length on the i32 return.
+        let any_ref = match &name_out[0] {
+            Val::AnyRef(Some(r)) => Val::AnyRef(Some(*r)),
+            _ => {
+                out.push("main".to_string());
+                continue;
+            }
+        };
+        to_lm
+            .call(&mut *store, &[any_ref], &mut len_out)
+            .map_err(|e| format!("__rt_string_to_lm: {e:#}"))?;
+        let len = match len_out[0] {
+            Val::I32(n) => n.max(0) as usize,
+            _ => 0,
+        };
+        let mut buf = vec![0u8; len];
+        if len > 0 {
+            memory
+                .read(&*store, 0, &mut buf)
+                .map_err(|e| format!("read caller_fn name {i}: {e:#}"))?;
+        }
+        out.push(String::from_utf8_lossy(&buf).into_owned());
+    }
+    Ok(out)
 }
 
 /// Walk the parsed AST for a `fn <name>(...) -> T` definition and
@@ -257,6 +335,7 @@ fn run_wasm_gc_with_host(
         RunWasmGcHost {
             program_args: program_args.to_vec(),
             recorder: recorder.take(),
+            caller_fn_table: Vec::new(),
         },
     );
     let mut linker: Linker<RunWasmGcHost> = Linker::new(&engine);
@@ -317,6 +396,17 @@ fn run_wasm_gc_with_host(
         .instantiate(&mut store, &module)
         .map_err(|e| format!("instantiate: {e:#}"))?;
 
+    // Materialise the caller-fn name table. The compiler exports
+    // `__caller_fn_count() -> i32` and `__caller_fn_name(i32) -> ref
+    // null $string` whenever any user fn might emit caller_fn (i.e.
+    // the program has fn defs); we walk `0..count` once, decode each
+    // ref via the LM bridge, and cache the strings in
+    // `RunWasmGcHost::caller_fn_table`. Per effect call,
+    // `imports.rs::dispatch_aver_import` reads the trailing `i32`
+    // arg as an idx into this vector — no LM round-trip per call.
+    let caller_fn_table = build_caller_fn_table(&mut store, &instance)?;
+    store.data_mut().caller_fn_table = caller_fn_table;
+
     // Two entry shapes:
     //
     // - `entry_info = Some((fn_name, args))` — `aver run --wasm-gc -e
diff --git a/src/main/run_wasm_gc/imports.rs b/src/main/run_wasm_gc/imports.rs
index a76a1fb9..3d29bacd 100644
--- a/src/main/run_wasm_gc/imports.rs
+++ b/src/main/run_wasm_gc/imports.rs
@@ -60,7 +60,6 @@ pub(super) use factories::{
 pub(super) use lm::lm_string_from_host;
 
 use http::{HttpVerb, http_body_dispatch, http_simple_dispatch};
-use lm::lm_string_to_host;
 
 pub(super) fn dispatch_aver_import(
     name: &str,
@@ -78,8 +77,22 @@ pub(super) fn dispatch_aver_import(
     // dispatch chain. Falls back to "main" when the trailing arg
     // is missing or not decodable — keeps replay of older recorded
     // traces / hand-rolled wasm-gc modules working.
-    let caller_fn = lm_string_to_host(caller, params.last())?
-        .filter(|s| !s.is_empty())
+    // Trailing arg is now an `i32` idx into the caller-fn name table
+    // the host materialised at instantiation (see
+    // `run_wasm_gc::build_caller_fn_table`). Vector index lookup
+    // replaces the per-call LM round-trip from 0.16.2.
+    let caller_fn_idx = params
+        .last()
+        .and_then(|v| match v {
+            wasmtime::Val::I32(n) => Some(*n),
+            _ => None,
+        })
+        .unwrap_or(-1);
+    let caller_fn: String = caller
+        .data()
+        .caller_fn_table
+        .get(caller_fn_idx as usize)
+        .cloned()
         .unwrap_or_else(|| "main".to_string());
     let caller_fn_ref: &str = &caller_fn;
     let real_params: &[wasmtime::Val] = if params.is_empty() {
diff --git a/tools/website/index.html b/tools/website/index.html
index b7f909e4..bfceb1dd 100644
--- a/tools/website/index.html
+++ b/tools/website/index.html
@@ -220,42 +220,42 @@ <h2>What Aver deliberately omits</h2>
 <!-- ── Demo ─────────────────────────────────────────────────────────── -->
 <section class="games" id="demo">
     <h2>Native WASM, shared runtime</h2>
-    <p class="section-sub">Seven games compiled directly from Aver to WebAssembly GC. Engine handles GC and tail calls — no NaN-boxing, no custom heap. Snake ships at 4.4 KiB; a full roguelike with procedural generation is 28.0 KiB. Modern browsers only (Chrome 119+ / Firefox 120+ / Safari 18.2+).</p>
+    <p class="section-sub">Seven games compiled directly from Aver to WebAssembly GC. Engine handles GC and tail calls — no NaN-boxing, no custom heap. Snake ships at 4.3 KiB; a full roguelike with procedural generation is 25.6 KiB. Modern browsers only (Chrome 119+ / Firefox 120+ / Safari 18.2+).</p>
     <div class="games-grid">
         <a href="playground/?game=life" class="game-card">
             <div class="game-icon">🧬</div>
             <span>Game of Life</span>
-            <small>6.9 KiB</small>
+            <small>6.7 KiB</small>
         </a>
         <a href="playground/?game=snake" class="game-card">
             <div class="game-icon">🐍</div>
             <span>Snake</span>
-            <small>4.4 KiB</small>
+            <small>4.3 KiB</small>
         </a>
         <a href="playground/?game=tetris" class="game-card">
             <div class="game-icon">🧱</div>
             <span>Tetris</span>
-            <small>8.5 KiB</small>
+            <small>8.2 KiB</small>
         </a>
         <a href="playground/?game=checkers" class="game-card">
             <div class="game-icon">🏁</div>
             <span>Checkers</span>
-            <small>23.4 KiB</small>
+            <small>21.1 KiB</small>
         </a>
         <a href="playground/?game=rogue" class="game-card">
             <div class="game-icon">🗡️</div>
             <span>Roguelike</span>
-            <small>28.0 KiB</small>
+            <small>25.6 KiB</small>
         </a>
         <a href="playground/?game=doom" class="game-card">
             <div class="game-icon">👹</div>
             <span>Doom</span>
-            <small>22.7 KiB</small>
+            <small>20.4 KiB</small>
         </a>
         <a href="playground/?game=wumpus" class="game-card">
             <div class="game-icon">🦇</div>
             <span>Wumpus</span>
-            <small>5.5 KiB</small>
+            <small>5.2 KiB</small>
         </a>
     </div>
 </section>
diff --git a/tools/website/playground/checkers.wasm b/tools/website/playground/checkers.wasm
index 4896977218e9e977d089b125e93f778dca496313..f3382aee386adc0ac7a553ca0d6dfdde6c30aaaf 100644
GIT binary patch
delta 2278
zcmZwHdsGxv90&0Got*`CXMq70VR^`KGy{$rpkN8&-jRn22%;h=xVz$H6l}O4WGP!&
zX_;Bw-q}NYnWSZ#`RrlOKRR{D<EcOTqjUPFzdEP>=yf=q`psT#$<v&<vooLH@BZ%0
zojZHz9DX?h4+{+sf-#22Q=dKI@dHuOibY}%DqK+(L=@veCeC235@o`xT=J3hX+ef)
z&@nzPGx`dG%6K&PyYd}k->L#ipC(3=MiCM}CHZn{)X=CENgJ^ugZ<&qKwv1+A0A;f
zqA+=3)8=^0J<>mD1%?MKYltn6izhDI!~M4f28UT~+)_f3t;2x<EBv49t=0(Z6Hg`Y
zM~#@1Qi<iFJEb7{BbIEjZd|cq>rMSP-!d>*5x%veu5M^sWaY}{=B2}RBNY`D+gn<$
zi*KV###$HB=J&VWwqsS>?RV_lH6FbaccH54ZnU@W#;Uf})tpz~gQ|N`X>VqS*|Fw6
z?7?2#j|Z?1=Gt}Z);@@3%Q`#vWBvMvqFC0orhCJN?gMxjkD%*O2vj|WYF_;~Hg2r#
z>3ITA;wh}IuYVf7^@|pjFDhR^`!jeJ2k{)9#|wB7hj17#;bpvnS8@IIui*$98ed0a
zLu1oXG&D7B+H?bLOBOF)O8W$5yn$mljyLfZPSoLT#PAMI;$57=X`DgtS)9XpyodMk
z0Y1b9_yZpy_%S}grw9f<!{=~10o<u4Uo^gs^}9=Se?}nC7aAC_B7qyjfxcU}(@Xme
z`g9D31}*kGTxoDH=PR&p@hB$X!Djd5EkDMN<yk7Y$SSI(V|!6a9*3@I+60(6!vt4!
zg)^>BxirSbqeTmSBq}v0MU~6ZB#NqBd|$M{8IOt_ql${P8qFEpVHeXXshHs~)ty|t
zZY;>-PTg_2s*BE5gH0(erqAb2QBj;{*hI~#RWr&`sJfdcP0JGH#rfc|mf{g5l_$q<
z&`C)tTzolemMtnZr^(E8F8-R8mu8ETDlMd>Tpqh-c9;Fc<0bRyc&wzGj>)CvS=>$i
z+&ZYG6vJS;!NtnbdAVGRkKm@xbLd>926K{1A1H0f<{sT;VplP9_zh;VZk2wx__@?)
zM>J|4JzHN)zp2#HxR_a1NW;~Z`RM*T%f>SBhxn={nDYm;OlB|xhGIAj_2Lm^{t0cB
zI9*#Q#%jyFSH~wPE>6}?M0uL7n~aVbS9<FQL9Z<VDgj+)PHvlGUfQ*0IQm>XJ>D<<
z>V65Z`_UUtfYUCNo+xD365lUzuHbsSmVR}u1YE9_0K1myppI8=JIO8{n^$*1N#+^4
zVkkWJtG^mFS98tWIXsgV!)$vo$fcI0J7~7C)1XJ)X(;*`=%*<4W^+e~d;d4)r2^O5
z1>{1>o}NT%ukT8`MmFUYGb(u&e8%*oe@BVcFPo2io})XRa>_HmfTopRsa?*+{`!)9
z?n}hK{BJxqSziqw&yTMv(7+0<wM&>v@hJLt^b|#n+h+0tnggbP3p$}k)xWXBu)_tk
z0LAgfoD%y?>!LMhrt-pRA8FygpO&ATl7DKfps6itI+PSu8K0>gRvG>E8>~U~)01m-
z1N9!zHAiDyJR}WL6e+1BjZz#^bdn}1s+3HU<x-qdvPo7*Ns<!v60MY!EXn?=nx&*9
zq(zELihYZ%QruFKNmfbGq@<CwN%2T=khDulm7+$8R!d5gWIt<%l=MWQHB$6M&RQuM
zQtbIyCnZx#E=i}9tc0wW;+5i?in_EeN!gO}s9U#`8B%7DY><*8#h$Z`QgWr(gY`)9
zC31SD<Rx-8Ny(Q&W6jqBk_secQK6ue!bG7E$>cUoTPntD3WeD*>e%Pn96R3;RKySK
zcFlH2tnd~qvfLUN0-cApw1ur^YX`KUfzS>s(tcBD*b-lLUL$sIoST-~5l;?miG;@Z
ch*;f|En0dEvA3rUUV&b(_`7GT80#(j2iw~K!vFvP

delta 4526
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
F{x6qw(~AHA

diff --git a/tools/website/playground/doom.wasm b/tools/website/playground/doom.wasm
index 9f0e0074c0944b0936e7aa569e77a4318a00cd8f..0497634ac5525f287919df7dcdc9e476751682a2 100644
GIT binary patch
delta 2173
zcmZA2No*Tc7y#h;XS|Q&j2&ljlBScWwVka=>{QL3JZEjvbV-}Fp|;~VZNPEbEQOX3
z16^oKq04}fDsf;D7cNw$Yy$OA%7qJw)Dx=ImP$wnIB+cz{LlZi35@iX`TqaCH}l>&
zdH)vN_z13kXR$z7OhL?i?QX9-B}5=*5h7A7C+1p(SWZL`G!-VzDOib!$&_{mZg>H+
z<%j^Oh_t%ON8o*KMC4r#uo{t8R#NFk@qr}9WNo{t0espK(*@|&el_*y^ckWj;|sQ>
z*|~UlF%gd+7j|o1=1ZymjLS2L`RGzOx)e<YgaPTgcn|zFHG2m4?%RK0=-{F9%r!i+
zYuBjP>-T%TV}5^4MMXvB_(W}G-QmgS8X6jpRD}b9NK;dEDmES8HgojY?6%BRUH$wE
z37^lm!?&Zkc`jL1RaH|pUt4>;rRBuJV%=nAU2E%7W##h8wzd~vI@Mm;e){E=S5{LU
z9gGEDh1URA@%p{5!x=aW-g6KN1<ymUGuZhCT!8wEa0%Xo%TQnc7Q78t;3_m;gX^Hd
zJMb=ab!nekTDEk54n4Qv3-}Uxy1#<2;Ttd-0pL}|{8!1{^qRFVyTcg{$D)Zud?7rO
z49Dh|lS{$_P&Q*SIu{ong4F?%U>iC(JTf*Ojzp*IFloCvdoR7y6A_(EP=u~v=DO4V
zp$bg<q^Pop!DjuSOVBSK|GlW%$;8cZt`)^qPA2_N(?^R9MjJCIqADowVb*e~x`!DR
zL&y`dVQXXpvpliN+1NK>--vxB6L*K~dORD=nTZ<}Gq#daF87Ntor@n9(;k-gWHGa1
zb(PCrKxA5d*>+rLqO7%z*%TWV8H*SaLISo%EM{D&6eo3K--Jbyiv=btb}U&~#1MpT
zpKWF7du0zy&PO0;3#y=kDz1;L54#?ve<*i|!Cydj>a0rZ;q@`sW013+CQiBj8;`D!
zyB?>_RR_S#?24coSUOxiE#YH+Uwa<wfx6GI{=4p^lPQV;S2JSEi-~Dx0=*dfF>nP~
z`fzX*@FrdF!}{m?HHGD3IzAe<M&%l2e7o}x@UuL8C$I2qKl5?FOK`vQGy4tr>R#;Q
z+-tks<*WdsZ6UyxpN1Wye(dwpkg)I2;}X*x4Zd7GLgz#y4NU8A@L72T=P@$vbVFN8
z&okf*9(@KgwtNLATD6{S(M?9%p&Orx=W(mi&8C|JtyVXAQ(m2JcHL|?Obl>j8f&b;
z-AXj}`<O>D$+BF-cgBPXK2}KE7jmp%*QiQZ<B0o>lQ^QOsTk|grh2R|H!W;oCH!cf
zh!*jQXcm<Yynp)1Zf9Ci^RS0)RSY;a-{2tjH$^WttA3{H;{{bzC1t?Sq34!h#Khm2
z50qJYt@&evnU&&qBC+&J$0KXXAh0s|H-mtGAyuI}Gm!62lO6D$K~F~b$u*ORBzzNE
zNF)+Is+Gh*!hd~jBt{ax$L%C0k`y1-L1ZRUP#B42V_1m9N|J>+og_9AGfEeUOu|2q
zZW8;(JUt{?BzY-J>Lqdz<)ZYFWN*lB5``ombNWe~8!|xRA}PR}JtR3KZj?b1_ftt(
z<-J6?M11*uBzYt*l>H?6BzY(YND4^!o(++BNci#xNeW5$Lmwh3dX|%thlz?el150j
zJWG;CNlHixaiTGjtt1|laT0Z7)C5T>2|xS8C_kN$<q42hRs7a%Qu@!mCb0R8s(`<q
z`<BV{Kl^TjmNyjCjt?F6IfmlNY5XS?i!Lq=MNdJVem}K5o0y&mEziuv7dqz?+MVG(
zE#NB98b^w>b0ckrh1uki<{53*=0}6t+UOt@YB$|(ZE&pB(VdLXoeD1=o1f=1{tKeY
B-cbMm

delta 4309
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

diff --git a/tools/website/playground/index.html b/tools/website/playground/index.html
index f1965a12..c6124e80 100644
--- a/tools/website/playground/index.html
+++ b/tools/website/playground/index.html
@@ -34,13 +34,13 @@
     <a class="intro-link" href="#about" data-show-about>What is Aver?</a>
     <a class="intro-link" href="#wasm" data-show-wasm>About WASM</a>
     <nav class="game-nav">
-        <button data-game="life">Life <small>6.9 KiB</small></button>
-        <button data-game="snake">Snake <small>4.4 KiB</small></button>
-        <button data-game="tetris">Tetris <small>8.5 KiB</small></button>
-        <button data-game="checkers" data-args="6">Checkers <small>23.4 KiB</small></button>
-        <button data-game="rogue">Rogue <small>28.0 KiB</small></button>
-        <button data-game="doom">Doom <small>22.7 KiB</small></button>
-        <button data-game="wumpus" data-console-game>Wumpus <small>5.5 KiB</small></button>
+        <button data-game="life">Life <small>6.7 KiB</small></button>
+        <button data-game="snake">Snake <small>4.3 KiB</small></button>
+        <button data-game="tetris">Tetris <small>8.2 KiB</small></button>
+        <button data-game="checkers" data-args="6">Checkers <small>21.1 KiB</small></button>
+        <button data-game="rogue">Rogue <small>25.6 KiB</small></button>
+        <button data-game="doom">Doom <small>20.4 KiB</small></button>
+        <button data-game="wumpus" data-console-game>Wumpus <small>5.2 KiB</small></button>
     </nav>
     <a class="intro-link" href="https://github.com/jasisz/aver" target="_blank">GitHub</a>
 </header>
@@ -225,7 +225,7 @@ <h2>Native WASM</h2>
             </div>
             <div class="about-feature">
                 <strong>Tiny binaries</strong>
-                <span>Snake ships at 4.4 KiB. Tetris is 8.5 KiB. A full roguelike with procedural generation is 28.0 KiB. Built with <code>--target wasm-gc --optimize size</code> — engine GC + native tail-calls; per-program binary, no shared runtime to fetch.</span>
+                <span>Snake ships at 4.3 KiB. Tetris is 8.2 KiB. A full roguelike with procedural generation is 25.6 KiB. Built with <code>--target wasm-gc --optimize size</code> — engine GC + native tail-calls; per-program binary, no shared runtime to fetch.</span>
             </div>
             <div class="about-feature">
                 <strong>Capability-based imports</strong>
diff --git a/tools/website/playground/life.wasm b/tools/website/playground/life.wasm
index 8f169d522018e51076970ac68d9192cdf4ed26e1..627c2c1bb874e1dc64b7cd83cf103da2d2075e58 100644
GIT binary patch
delta 768
zcmYk3yKfUg5XN`*p0>}<8pnwfllWqc^NwTZ#Y-e>iAYEkSV**I>o_9|`x25EA&N5<
zHP#kTQ9uI~LY5E+i9QYDFQBJF(4iDC=S3pLXy^OQH?yygTR%6R-WvgMXb)T>mt_A@
zF5e?{)m4HZ09UC~AEhyrLExI;nsq|@pK^J?E?OthtD_Y?p^nt)zcfJI|Mh{oRJ@1V
za8|_Wo!Ke1@xVKX9<@52bJ+I0eKI{H){u1l)<dUrNOIyiZGtWS&|BMUm9d$8DwR4{
zIG;|ZF-a9?=f=n97Z#V6S2CH2(&|LHvNpE9u{pVwy>Ri;<?Q4YO#^_(%=oRA2FFT`
zt|T4DZM56ofz$LIcdzRok*n-9^BWzHY+F!{ekoK$L9ei#Sc2HZ2AkSSm7LibH1(Vg
zTs*OI6C4-}YibqioN#gyp_I*V@!6V-aLQ<vR0$V9thZ@Ym{$Q;K&OgMi;F?LsD%|S
zzQuz$S5DVjiF^tP(a^4-JsFA^7cUaK8dsUh2j3GlI>I%k+T?_Sj+xHI^`rxQ@Fsao
z<6LJZMg$|uMQ^l>=YBW(EW!<DVZ^zprHhl?WQlMO1NWE>CmHm_R4H5Muli})Qwfj6
zUIW1ow8=Gf2c0H5=PZcXgv0KTM3Kx(LL~{OEl8qB!jLRVqW<q%l0=gvoV+ZFE=ei8
z`iew`MB(U?B&H<cYpx>sdOs%GnKh-al?N{~n^Y9DIdL;PJ!Rg-kG-+Cw-3re*9XIG
Odkw$44{E2;^8W(f%%~^;

delta 1002
zcmb7=J8u&~6ou!`zU{TMiE%LI;U%-=K@z}8oDg1-Edh!EAqY?**{jVaTE)9I_68vY
z4mB0gh*yCq=x8V`5Qtv@6+)tcUqKxtxMLEDmSSeUd+wPtkDsLvbC1^g`k_iUz$1Sb
z*t}a9ibzfNq)w*;o>Zd|mW0%_p3>=fI(Yi#$3hMb*ntQ<qei!}gZ1XG_a+9?8V=Z~
z5&jNtK%S@Q^2lD<z3sOWaS-~|cHQ@zWM5A)d&+tg+^L3bvY$VrD{z4Srb`=B#caXO
zWHJYb*x=wGLdH2XynFY^=-A=$iCk{a<dHo`j}^01(=(;nx#ROEPG(Oj3IIH?)Hwss
z|8gt&zq9sLo>Z&t*loq6`&?S22_4Ruu#nhtiriACtc7Hn*u(~#+ERrKEOf7`1$CYg
zizqv?Ef26{vINkn5L>Rmy&;8x1-&+wHZ7Af*)k}#4l@4Q95ooVXoXY=<3G$dS*(yN
zfGeO=MyJX6%ha$UI*fl#by7_Fw|6}~ltG0kXqV95FN!4N57XxqCR;M=eoJ4WeN3@r
zn`}`~kyOS@{Z(My$NisZim8^4!@!YXd~H_|7=N+rslhbM#F1kBbapt;bSo{+(C~~A
zk)+WrU8dFydv!lcH@*YDtE^yiG>@Poj0q6RVF6;_xBwMlVh1L7T1Nz!*g7gey!)5{
zkyCU;bOLG05uYNGrXBH-2GWeMSvQeNj<oHYbz~%wHn$UU+!2=-8|H<SL^vTpeA!7y
zMH2TqB_xr5+R>22HO@FXAJ0uo&(wvko13MV6tC`vP0&Mk%|G7?mO*LOUC#$?J^Bl3
z+*n<$`=EM$y<Uz%YsY@`a^!<4U@?mQR?ujHEGqsaZzqhEMk{pVbImq?n=f22{pBET
zw8~x_G$PPf-O#_-Xf(lS2jRAuM7-8G+w+0cT8}`*X(<Rn^Xk4Etv5jq-5~k{gmLFm

diff --git a/tools/website/playground/rogue.wasm b/tools/website/playground/rogue.wasm
index a98908e9729d3ef0c7c9b0e5967874fd82023d7b..4335bdd8152c7a25b1d3c71d35003e8faa1e132c 100644
GIT binary patch
delta 1118
zcmYk)S!^3c7zgnE@2<PH*Q6UOT#675LXc1)HHe4gp;BiXAIfbfj&s{v?<R3$uhX>?
zQ<`QAO}N6<E>H>u%2Dp4ut2#=xo?RI-a#Dc1MdhGONg-t)PB-@v)@lM-^@z$_s=->
z9ZoF3sh|OzV`B)m^CQ}6_VN={G``vl8`)rngPjppR&1<fYS30M+=B3rz-NO_MQVlV
z9Fw|GbT*{pSa8<8efF>XISlQ#O6A3+%1wK29v<GCOm;7iq()NvMpx|pxCOW309Fy{
z>4}jw5YiL74Ut%kkltQ0Hg-Fe|D%^gx+C3pATmCFCx-6AI_}0j=<Dn2@9*!b#l475
zOx%b2aS)ROhv47=*i%yvVtV=^gwyFTjm%*@jHsp^!44Lak6`D{M{yL7;c-Nx(QI~b
za8TEuz%e|Dr|>kM!Ero`fr01nJYK+ycnL4#6}*bqa00L64Y+s{qi-SpHsbM<cn9y|
zJ-m+(U>K(`Gt>4VW@j^}(KYuGKE@~b6uI1I_#9v0OC%DBUAw-*+}HR9^Yae;TQAH1
zhQjaIz*!XXVUGvEentATWy3w_|5j;lOsBJ2K5tm*88e+NE}CWT0Iyt#rdBYxRX%`>
z|Ce=~b92px55)cc>T7G$U)P5PI&Ev;hf9c{aLZQ-Ayj!ESLFe9Srv(U=7yt?iKuWb
zqH3#japlG%bdS^6(J2#;!pqkHdK+<)9m`aI=xDu?comTjj|%nl>NfhtDO;3bI&Y#w
zBF^QVS2Po!;`I=YNL633HAIiQl&^X(=9RPbfOw}VZCT^xi?|RMf*Mf0!Sj`(1}><Y
zR3*6P{;_?p(n$P@FC@_H5Aih1#9fMS6&s0MXSvRDjZY?1ep}>7K>i6FeWoEUEN-V)
zk?B>21CT=;L8LALDoG|hlLjgyOoa1mQcOf93SBeG#KWZ4d5p;>CPwYQ#~DeCYON=j
zc$o-PCYkt{h*YMS_?c{`GR;J0(nKXq<;-r`k@ZpGus`F@>SggdIbSR;B#hF6RxuIC
z&4lwMgOtl!b{-9^QjIxnDOa?d=J}SCY#F9*SP_dpAV`*>={?3CG*q-)nV9;ZRm>Wt
k5(I0}gjmpWCN?MP8`8R^Rd&p27MlJ8)+n~9_vTFFUqm}C>;M1&

delta 3350
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
DMXT$U

diff --git a/tools/website/playground/snake.wasm b/tools/website/playground/snake.wasm
index d3eb0c8207043ced184b8fd558f1c3179fd1a53c..6d1accdfa5acc2fb43eb3bd2144c1ce589ec2568 100644
GIT binary patch
delta 694
zcmYk)yKmD#7y$75&gc4ZNqWvZJe`zBfhMFaQWq-qB48mBok3L`83U0LCxn!Zn12A#
z$^#V)3@k8bMq+@yNDTY|EDQ`RELr%R6B5=v^!@I;?@qQ~uY9Q;OzuX+10S$?+H^W4
z9u5Bq^9Y7M_%vAsU&pq{jgk?!MY!Y<h?1QVOc#@4!=uya@beM%Y5WLQp%NcL2~NZx
z;2?LBb)N=fd(s;OohSVu7?D$Po4(v$Z)S6+Gx;-T^KPM9sI6o&=a%s)p1*Lhn9Deh
zvwA6e`N~?oakbPeuWxLYOS%pK&xP@m)n~h!qz$Lj@w@$gFz!4EJN|G#oRI6{e+#>V
zfNZCrV*e;KXK(ahT2T@~THum71*1iuCE=Wq_^V!vKUtO`L4ZqTd~Ce~8BgqcHAw~I
zTf~K3wj+tu=N2`jCNv!bhJh*L-}W9R-{BP;d%T*KOt2PFXUO;!uj(jR^do<Z8GETC
z9RH+lx1}L0?6#<jHJmy26n33&0o-Sz@vVl}WJJO(wv$w2AWe}@4mR-M<pt5XsZp^h
zXD`w%8ey`<-vhx9;gXw+3)`3~QovnR2RARFI7%p1MoFP$m1s)RC^;oeNwO=iL|0;=
z6qGC}xn?326&Z>&l#&utN%GRlD94XE=il*P8Hp&~aBk$yhxobL!{G?D@qP$w(CvkP
E0m9&tO8@`>

delta 753
zcmb7=zi-n(6vywK&vEQ?+)L7=ZTc(q87TB8bjSch6A1*OMO_dBLbc^sYSrR~)~aA2
zL1JK})h!ha3``XaNL`tbSP??3EX?p1bm3ip`~g^Z?>_H)-}ml(U;Q_7FI!1T2r=LY
zjc&I~LYksN&O{c{7-Fh-AvSTGczZe$?N6b5vY<VM*a~Sk-T!vr_OJ#$6nY_1YcL4|
zY99t*P#wZvd5A^3$+nZNKTcM6Hj|`7YHEqT?#<5?%fnv($Y}pqWxP_K@I1c{zp4x_
zRLfqeRJwSnIC=TX)bz~k-2ByR3q{iefEOayu<@ktPx${v>kFI8t?p#ec1Aq+$Tu3)
z$-@m7>dueK+|euZuThmmkQUU*F$JqdpX>CP5cMhNtB<yANf1z{Qhm1HgH)mO(3ey&
z-XL{YVT(=DG>>g+NkbSWCJd9jRKJ`@Xui&eFy7}A1<3?!k<&AzddVkDRIuqGe}|4c
z?g7T%?%f4x2^*&)X2dkE9H)!Z<PCr}6SF^kye1<}xWyKAH->d#VG!ievqFpZ-U7ip
zaJ+-4ok3B9i%Lm@jZoI$A@pl-5GsK#%OO<*K+^VsfFc!;1_R@4cPL;;x<@TI|Jh;P
zB#+Wat?8fAXplqAKy56rko2332YJpv(7H-Ruf?PGZj{E!?IdagZ*OmPmZF`k8OPwB
wC-;)48QAe!5^p?+HaEeGI-MkKuWYTS+Nl1Bn|&->k2fH%<MP&SqUMX0f67j&6aWAK

diff --git a/tools/website/playground/tetris.wasm b/tools/website/playground/tetris.wasm
index de771be6ac89967fcce1a04b5be5b9f5f6407759..0dceea1fe1b1eb971b471942cb65504487ed9b21 100644
GIT binary patch
delta 1041
zcmYk)NpI6Y6ae5E+es6T(+piGL9}t3X6Xv0Kq+O(xC@l6ENv-taZKvcK$4a;z%Ay)
z0fYpyxbP$3kOMc4h$9Ci!~w(^B*XzBP!I4XW7JxjvEMf{&*L|C$9}UXADbPN!4;gP
z8M#uapo~-mKu^E->Da+pHG{CjNBAs=n`_Uwl94J-bpX#{DXY5Aq^Xv@ignj6)tBv3
zAy>5W=6WetETc|$Q;OhDw^`1__tj>oC9Al+RxtVKfRJ*oV4E9x+g?Ze-RJUSr&C^9
zj1R`(iYE>v5?x&f4-F-gNnO_u52sS8BO~#n-N%lfNHb$}Y<%Km&#B3t-qXF^XF9}n
z_T2fY3l}e4hWYyRj6SPhnY(&zexYx%f62`B_gUAoJ|D*TKCSyoX8q<y*(#M$y??o6
z-D71G4po0BFMXpsOfzfc^LEKxDVo`}JFwpsy4{La!A3VUoKpXGEh>oikVd2<13%C)
zLlo%}b6=|uF>@zL4Eh2|L;r%bK>vo6p&!wr(9dgy7*i->h}CTdRar-yQc$4_n*k!x
zc^JXQZbM=2H!TwMB0qCOp@`!}s<%1_tNor4&or<)&$Mk8@GRt680P)YUhi25jOXU>
z4|^5><GC?uLow!~3T>+G7a52~bVS>rMZtX}f$?%PbKi#gFsuFwId~@v&;Sg#HzY|C
z8BMg`Kn8rtqj1L{Q)v*IO1o$Z?gW|!O(8>&MWfyCJD?~UVt7JH^Y>{`w=dyckoiye
zlZ;p04~@g)tE8b;e@H7q!-mw5BlVnkz{8s&ghx&g))si992;`gnWjX*Q4rI}XN=(I
z*3r0<hO_a*m+#Rq(Zw!6cx_vSNU$#uUd1*c@|Hw}C_+@2qYLo~;hEco_=VW~C_4nz
zZ7qul2?*gw(J3S-gs+MVQH97L2_Zy?0+IxIcbimiwN6U%PbpP>6`jUzYkTw`Vqe&v

delta 1309
zcmai!U2oe|7{|}!m%P|c<EF``Rdh8yPMW^0d+Ww1FN?db+bFCX1qSPgGskPKI!;JD
z5E4pu0~a6!$U;KXE)d@U<r}asFlje%v9B<0k#fWHB(5~N3oM<J-}ycNa}qyC%0HFp
z(vN=?0%k)O9NlKj7Q5XpvxOk|>G{$TTu?0lr$B`Oy0*{_`m1mYv>rH$jRSf%i+&ca
zA6=4apS$g`&}}!opypRwZ7&E}F&YTRpcoZIyLe)lP};Si-fUE<x;!$W*Kn&H-*sE;
zWb{z{zE>3Q?C?`2KD>0gRGOPRb9QBRcGfVAbLY$D@@p6P>+`E`y!qDK7c17<rS*l&
z8w-n97U!?djGk-nY`**6^{pG2H*UUfY#SeZ_|dJ8Ke@eg=hLdqYj+)427m{8;;M!(
z@Z>Y~(0u-7^}i<hSl#YN(jW443hrsJqI@^MBQbqJonQvD;2Q%t)0rXg=ojT%;1O3j
z&Kv5*V_eV$ihN}NP8C*34AKhdSswkWhL|a6(>SkajUJbDhV>-YMS~55w50D0QmUZe
z#tK-Imh?hG8YbjJiNp&Dd6-BXN+@w6jo(6PI#(UKDywKHld;s|Ah}fRGO^2|OUG_3
zb{TYZI31XcT?!o?4(f5nqX(IzDwlOxEdkUEJo+uO1ib$w(*tb4RyL2bo1H0eMNi{U
z^f|qZpDGTGM~|{olU&s^a@?UYdOJ;s`_q4#eI~+g^!vnx^<6bLyc3IA0uHc*+@3l{
ziWao=MoUCexEyYXt0Z%K{pEZq)%zRhLg>O?F^Q-bQzjr$2acOUOw*=_q@XiQ35j;R
zYSK@oHqV%exXR6BOy(qlgvBBO^{Hg0kSITErjf)!x~G&)CC<&6D$)d&=V?bCVc`H4
z38?=|1e7^JkV9A|&=F1^WKIzj(3~b1M>ul;XD8Lizzo?C2P|obR)1q^RS=&^EB&vh
zw_#lIo6i1aFYr2hAcdZ@AN^?<H(<hQ*4p*z-TR(jA7aIEAU~2FH(Yalf34|vUbZ)z
zUkq*LKUs(>$^1FUjby9sw%nk;-e`qif<AJN@7CIzUf^~h-g@u8@8f9@{g66Rg7MAf
cuIE&pJ=fXaYT_SJ=RmcaVJ&pGJlApm1yar~RsaA1

diff --git a/tools/website/playground/wasm/aver.js b/tools/website/playground/wasm/aver.js
index 32c65f4d..2eb3bdaf 100644
--- a/tools/website/playground/wasm/aver.js
+++ b/tools/website/playground/wasm/aver.js
@@ -675,7 +675,7 @@ function __wbg_get_imports() {
         __wbg___wbindgen_throw_6ddd609b62940d55: function(arg0, arg1) {
             throw new Error(getStringFromWasm0(arg0, arg1));
         },
-        __wbg_error_d8ad12e60840c9e8: function(arg0, arg1) {
+        __wbg_error_1659bd874679429f: function(arg0, arg1) {
             console.error(getStringFromWasm0(arg0, arg1));
         },
         __wbg_getRandomValues_3f44b700395062e5: function() { return handleError(function (arg0, arg1) {
diff --git a/tools/website/playground/wasm/aver_bg.wasm b/tools/website/playground/wasm/aver_bg.wasm
index 31d7838607748ae4406a54e5f4292d3ad420a8ea..024b723cdc4d71e3a9e3753d54e2362f32febe17 100644
GIT binary patch
delta 476084
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%0Akv_QL1TRy7OrXVx}#
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

delta 475519
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%0A<H`2_65?uF9o(
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
W<aY!4G4m{UWk6TOa<^NQ?Y{sa@e7Io

diff --git a/tools/website/playground/wasm_host.js b/tools/website/playground/wasm_host.js
index 377a8820..bf9ef53f 100644
--- a/tools/website/playground/wasm_host.js
+++ b/tools/website/playground/wasm_host.js
@@ -111,6 +111,35 @@ export class AverBrowserHost {
 
     setInstance(instance) {
         this.instance = instance;
+        this.callerFnTable = this.materialiseCallerFnTable(instance);
+    }
+
+    /// Read the caller-fn name table once at instance creation.
+    /// Compiler exports `__caller_fn_count() -> i32` and
+    /// `__caller_fn_name(i32) -> ref null $string`; we walk
+    /// `0..count`, decode each ref via `averToJs` (which uses the
+    /// existing LM bridge), cache the JS strings in an array.
+    /// Per effect call the trailing `i32` arg indexes into this
+    /// array — no LM round-trip on the hot path.
+    materialiseCallerFnTable(instance) {
+        const exports = instance.exports;
+        if (typeof exports.__caller_fn_count !== "function" ||
+            typeof exports.__caller_fn_name !== "function") {
+            return [];
+        }
+        const count = exports.__caller_fn_count();
+        const out = [];
+        for (let i = 0; i < count; i++) {
+            const ref = exports.__caller_fn_name(i);
+            out.push(ref == null ? "main" : this.averToJs(ref));
+        }
+        return out;
+    }
+
+    callerFnFromIdx(idx) {
+        if (typeof idx !== "number") return "main";
+        const name = this.callerFnTable && this.callerFnTable[idx];
+        return name || "main";
     }
 
     setTerminalSize(cols, rows) {
@@ -273,25 +302,25 @@ export class AverBrowserHost {
     createImports() {
         // Every effect import declares a trailing `caller_fn:
         // any_ref` param now (see `effects.rs::params`). Each
-        // callback below picks it up as `callerRef`, decodes via
+        // callback below picks it up as `callerIdx`, decodes via
         // LM transport, and pipes the resulting JS string through
         // `recordOrDispatch` as the recorder's caller_fn stamp.
         // Pure imports (`float_*`) and the group markers ignore
         // the trailing arg — JS just lets the extra value drop on
         // the floor.
-        const dec = (callerRef) => this.averToJs(callerRef);
+        const dec = (callerIdx) => this.averToJs(callerIdx);
         return {
             aver: {
-                args_len: (callerRef) =>
+                args_len: (callerIdx) =>
                     this.recordOrDispatch(
                         "Args.len",
                         [],
                         () => BigInt(this.programArgs.length),
                         (json) => BigInt(json ?? 0),
                         (v) => Number(v),
-                        dec(callerRef),
+                        this.callerFnFromIdx(callerIdx),
                     ),
-                args_get: (index, callerRef) => {
+                args_get: (index, callerIdx) => {
                     const idx = Number(index);
                     return this.recordOrDispatch(
                         "Args.get",
@@ -308,10 +337,10 @@ export class AverBrowserHost {
                             idx >= 0 && idx < this.programArgs.length
                                 ? this.programArgs[idx]
                                 : "",
-                        dec(callerRef),
+                        this.callerFnFromIdx(callerIdx),
                     );
                 },
-                console_print: (sref, callerRef) => {
+                console_print: (sref, callerIdx) => {
                     const text = this.averToJs(sref);
                     this.recordOrDispatch(
                         "Console.print",
@@ -319,10 +348,10 @@ export class AverBrowserHost {
                         () => this.postConsole("stdout", text),
                         () => undefined,
                         () => null,
-                        dec(callerRef),
+                        this.callerFnFromIdx(callerIdx),
                     );
                 },
-                console_error: (sref, callerRef) => {
+                console_error: (sref, callerIdx) => {
                     const text = this.averToJs(sref);
                     this.recordOrDispatch(
                         "Console.error",
@@ -330,10 +359,10 @@ export class AverBrowserHost {
                         () => this.postConsole("stderr", text),
                         () => undefined,
                         () => null,
-                        dec(callerRef),
+                        this.callerFnFromIdx(callerIdx),
                     );
                 },
-                console_warn: (sref, callerRef) => {
+                console_warn: (sref, callerIdx) => {
                     const text = this.averToJs(sref);
                     this.recordOrDispatch(
                         "Console.warn",
@@ -341,10 +370,10 @@ export class AverBrowserHost {
                         () => this.postConsole("stderr", text),
                         () => undefined,
                         () => null,
-                        dec(callerRef),
+                        this.callerFnFromIdx(callerIdx),
                     );
                 },
-                console_read_line: (callerRef) => {
+                console_read_line: (callerIdx) => {
                     const exports = this.instance.exports;
                     return this.recordOrDispatch(
                         "Console.readLine",
@@ -370,63 +399,63 @@ export class AverBrowserHost {
                                 : "";
                             return { $ok: peek };
                         },
-                        dec(callerRef),
+                        this.callerFnFromIdx(callerIdx),
                     );
                 },
-                random_int: (min, max, callerRef) =>
+                random_int: (min, max, callerIdx) =>
                     this.recordOrDispatch(
                         "Random.int",
                         [Number(min), Number(max)],
                         () => chooseRandomInt(min, max),
                         (json) => BigInt(json ?? 0),
                         (v) => Number(v),
-                        dec(callerRef),
+                        this.callerFnFromIdx(callerIdx),
                     ),
-                random_float: (callerRef) =>
+                random_float: (callerIdx) =>
                     this.recordOrDispatch(
                         "Random.float",
                         [],
                         () => Math.random(),
                         (json) => Number(json ?? 0),
                         (v) => Number(v),
-                        dec(callerRef),
+                        this.callerFnFromIdx(callerIdx),
                     ),
-                time_unix_ms: (callerRef) =>
+                time_unix_ms: (callerIdx) =>
                     this.recordOrDispatch(
                         "Time.unixMs",
                         [],
                         () => BigInt(Date.now()),
                         (json) => BigInt(json ?? 0),
                         (v) => Number(v),
-                        dec(callerRef),
+                        this.callerFnFromIdx(callerIdx),
                     ),
-                time_now: (callerRef) =>
+                time_now: (callerIdx) =>
                     this.recordOrDispatch(
                         "Time.now",
                         [],
                         () => this.jsToAver(new Date().toISOString()),
                         (json) => this.jsToAver(json ?? ""),
                         () => new Date().toISOString(),
-                        dec(callerRef),
+                        this.callerFnFromIdx(callerIdx),
                     ),
-                time_sleep: (millis, callerRef) =>
+                time_sleep: (millis, callerIdx) =>
                     this.recordOrDispatch(
                         "Time.sleep",
                         [Number(millis)],
                         () => sleepMillis(millis),
                         () => undefined,
                         () => null,
-                        dec(callerRef),
+                        this.callerFnFromIdx(callerIdx),
                     ),
                 // Float math is pure — no recording, no replay. The
                 // wasm-gc imports list these because the engine
                 // doesn't expose `f64.sin` directly. The trailing
-                // `callerRef` arg is ignored.
-                float_sin: (x, _callerRef) => Math.sin(x),
-                float_cos: (x, _callerRef) => Math.cos(x),
-                float_atan2: (y, x, _callerRef) => Math.atan2(y, x),
-                float_pow: (b, e, _callerRef) => Math.pow(b, e),
-                terminal_enable_raw_mode: (callerRef) =>
+                // `callerIdx` arg is ignored.
+                float_sin: (x, _callerIdx) => Math.sin(x),
+                float_cos: (x, _callerIdx) => Math.cos(x),
+                float_atan2: (y, x, _callerIdx) => Math.atan2(y, x),
+                float_pow: (b, e, _callerIdx) => Math.pow(b, e),
+                terminal_enable_raw_mode: (callerIdx) =>
                     this.recordOrDispatch(
                         "Terminal.enableRawMode",
                         [],
@@ -436,9 +465,9 @@ export class AverBrowserHost {
                         },
                         () => undefined,
                         () => null,
-                        dec(callerRef),
+                        this.callerFnFromIdx(callerIdx),
                     ),
-                terminal_disable_raw_mode: (callerRef) =>
+                terminal_disable_raw_mode: (callerIdx) =>
                     this.recordOrDispatch(
                         "Terminal.disableRawMode",
                         [],
@@ -448,18 +477,18 @@ export class AverBrowserHost {
                         },
                         () => undefined,
                         () => null,
-                        dec(callerRef),
+                        this.callerFnFromIdx(callerIdx),
                     ),
-                terminal_clear: (callerRef) =>
+                terminal_clear: (callerIdx) =>
                     this.recordOrDispatch(
                         "Terminal.clear",
                         [],
                         () => this.terminal.clear(),
                         () => undefined,
                         () => null,
-                        dec(callerRef),
+                        this.callerFnFromIdx(callerIdx),
                     ),
-                terminal_move_to: (x, y, callerRef) => {
+                terminal_move_to: (x, y, callerIdx) => {
                     const xi = Number(x);
                     const yi = Number(y);
                     this.recordOrDispatch(
@@ -468,10 +497,10 @@ export class AverBrowserHost {
                         () => this.terminal.moveTo(xi, yi),
                         () => undefined,
                         () => null,
-                        dec(callerRef),
+                        this.callerFnFromIdx(callerIdx),
                     );
                 },
-                terminal_print: (sref, callerRef) => {
+                terminal_print: (sref, callerIdx) => {
                     const text = this.averToJs(sref);
                     this.recordOrDispatch(
                         "Terminal.print",
@@ -479,10 +508,10 @@ export class AverBrowserHost {
                         () => this.terminal.print(text),
                         () => undefined,
                         () => null,
-                        dec(callerRef),
+                        this.callerFnFromIdx(callerIdx),
                     );
                 },
-                terminal_set_color: (sref, callerRef) => {
+                terminal_set_color: (sref, callerIdx) => {
                     const color = this.averToJs(sref);
                     this.recordOrDispatch(
                         "Terminal.setColor",
@@ -493,19 +522,19 @@ export class AverBrowserHost {
                             ),
                         () => undefined,
                         () => null,
-                        dec(callerRef),
+                        this.callerFnFromIdx(callerIdx),
                     );
                 },
-                terminal_reset_color: (callerRef) =>
+                terminal_reset_color: (callerIdx) =>
                     this.recordOrDispatch(
                         "Terminal.resetColor",
                         [],
                         () => this.terminal.resetColor(),
                         () => undefined,
                         () => null,
-                        dec(callerRef),
+                        this.callerFnFromIdx(callerIdx),
                     ),
-                terminal_read_key: (callerRef) => {
+                terminal_read_key: (callerIdx) => {
                     const exports = this.instance.exports;
                     return this.recordOrDispatch(
                         "Terminal.readKey",
@@ -529,10 +558,10 @@ export class AverBrowserHost {
                                 ? { $some: head }
                                 : { $none: true };
                         },
-                        dec(callerRef),
+                        this.callerFnFromIdx(callerIdx),
                     );
                 },
-                terminal_size: (callerRef) => {
+                terminal_size: (callerIdx) => {
                     const exports = this.instance.exports;
                     const cols = this.terminal.cols;
                     const rows = this.terminal.rows;
@@ -557,47 +586,47 @@ export class AverBrowserHost {
                                 fields: { width: cols, height: rows },
                             },
                         }),
-                        dec(callerRef),
+                        this.callerFnFromIdx(callerIdx),
                     );
                 },
-                terminal_hide_cursor: (callerRef) =>
+                terminal_hide_cursor: (callerIdx) =>
                     this.recordOrDispatch(
                         "Terminal.hideCursor",
                         [],
                         () => this.terminal.hideCursor(),
                         () => undefined,
                         () => null,
-                        dec(callerRef),
+                        this.callerFnFromIdx(callerIdx),
                     ),
-                terminal_show_cursor: (callerRef) =>
+                terminal_show_cursor: (callerIdx) =>
                     this.recordOrDispatch(
                         "Terminal.showCursor",
                         [],
                         () => this.terminal.showCursor(),
                         () => undefined,
                         () => null,
-                        dec(callerRef),
+                        this.callerFnFromIdx(callerIdx),
                     ),
-                terminal_flush: (callerRef) =>
+                terminal_flush: (callerIdx) =>
                     this.recordOrDispatch(
                         "Terminal.flush",
                         [],
                         () => this.postTerminalSnapshot(),
                         () => undefined,
                         () => null,
-                        dec(callerRef),
+                        this.callerFnFromIdx(callerIdx),
                     ),
                 // Independent-product structural-scope markers — same
                 // contract the wasm-gc CLI host enforces. Trailing
-                // `callerRef` ignored (group state lives in the
+                // `callerIdx` ignored (group state lives in the
                 // recorder, not in trace records).
-                record_enter_group: (_callerRef) => {
+                record_enter_group: (_callerIdx) => {
                     this.recorder.enterGroup();
                 },
-                record_set_branch: (i, _callerRef) => {
+                record_set_branch: (i, _callerIdx) => {
                     this.recorder.setBranch(Number(i));
                 },
-                record_exit_group: (_callerRef) => {
+                record_exit_group: (_callerIdx) => {
                     this.recorder.exitGroup();
                 },
             },
diff --git a/tools/website/playground/wumpus.wasm b/tools/website/playground/wumpus.wasm
index aeba3498da21f70595e3bd3c6070194c62833a87..b982609aee6eff0eac094a2174c218aaa8e2460a 100644
GIT binary patch
delta 604
zcmYk(yN=U96b9fq<4e3_2WA7&+Hux#ZoqEBZn9jKJDFmUsE{ZS5`}F!Mv9c!!d%Lj
z2cTf_3-AtZQczG(BC$w_H=v-TqDaGd?SjVh>l^t$$MVm?=biVfL+}y!#6`%(OJ4(D
zb77GKB;d;~g2d%#4#IMoz|zHGg81d}uP+vNew#ponIL*^f|$f!IE@z0EPRFR^gEn?
z+CKG7KMG$)^T3G%Z|clvVSqZqc+}|j`WG%<+A+=Dfj+#vx3BB^Xlxu@xq7YHG_D(s
z!y7km-M({o`<`{b)v~rF2>{;G%3pCe^YJ6Rx9K>(H=hTw^E`C?=rtcZrvF>$Edq3)
zL658&qwJIT1Ov;?Rh|jJ(ulPA^O%@j1{7>WxAK!ArmQ#Qvo=~|B-7qnsbJb?={I6l
z7^Z+HEd4{;Ql9gqXZvau3rwKtM`ak)ELB4`Ffnhe8LEPKF{PF|1DFzCzQxN8CY=uI
z^V}$Ni)XXU1D>0Cre|p9M~81h5Q7KeBwvc~u_slXf5-3Y2O$v=lhqhuU$)VaI4Re+
zG*Ip0ol;tbVBS)SU5HQ!<ulubh=oX8I)zAuh+Mi{PF|?0`c>)y9%c_~@9>6_|M$mH
Mv`C|RJzdqUe`f!LGXMYp

delta 873
zcmaKqJ8#oa6o7r~#CC2Ra8M=Eq|M7tn>J0;2k%GQ2!vFrRH#TS42|ntHKwth+D@x3
zF&kqk*^&4SSr8Kgj3AH@e}S<RQy0#)nw90A&)<36BkO*i`(1ncvCeTVFgY+uiyxQ@
zm`V$5_64TMf-o33Flh0PgLTf?`Il;lnJ62!I0#!1LdZ9Tm~lis;u%icwRbHi;PS(t
zFcB6apEg~`ce`}gqegqTYdMrF3QLX2Qd!e0Gqbr|buKesTc~F;nZ-tSX?bOJYASmp
zJ9+cg?K^kx-GA_KZGC!rG9Cwj*Q!_%akU?Z$^W0yk62Y4t?}DDkzrYZRq`g+7=4Pp
z;6WRurI!L|Lz|TFJS90z0~Ly#dY#24*OV_3;?*K|!E>UjU&s=#R<z+al9M!E1%5*t
zo|96XF{8|=o=owACaA;r@`8LVpH#RaW)4&NbuAvvtKhusB^Qu$ms~@hVys?K%fHHa
zA>o?vB(}lsCOG4JDue6(Nxc)oufXAE3GB#c5ePzofr3zEz?LrQtca;HQxby4fVJri
zSX*TbGYpbwW*M-qDg#zLH?EmyfTOp>nm+zD3p$T7g=KY?RS^~$q!Aipv!n~C;;5GO
z7*Y&rMUN+wXVU8EZ~BxE6ArcZJA1C@1F`&O`;}o*CjiBBU3<&&gUx{2AhS2Mg9enI
zWga|6Z#iZFk`r_yoiIDpJcy9k?h$>~HBP7p#P7In(DXd_7?K7HPc7f4ZBUN;cCYVm
zQ`7MFP9V{<f^8Zh*)sz45zE+q91WHC4V!McZVysz%kLS1+1Ye@{Qy*t;-fyItm+Zl
U0n(S|dB+WQsNe4f!w(aMf3zdrH2?qr


From 26fdca745514ea50eaa332d6d885d4f54fa2ee01 Mon Sep 17 00:00:00 2001
From: jasisz <jasisz@gmail.com>
Date: Wed, 6 May 2026 12:17:22 +0200
Subject: [PATCH 03/18] 0.16.3 step 2: rustfmt fix

CI Format step rejected the multi-line `caller_fn_collector` let-
binding and a stray blank line in `types.rs`. Auto-applied `cargo
fmt --all`.

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>
---
 src/codegen/wasm_gc/module.rs | 3 +--
 src/codegen/wasm_gc/types.rs  | 1 -
 2 files changed, 1 insertion(+), 3 deletions(-)

diff --git a/src/codegen/wasm_gc/module.rs b/src/codegen/wasm_gc/module.rs
index 4d186478..8a31920e 100644
--- a/src/codegen/wasm_gc/module.rs
+++ b/src/codegen/wasm_gc/module.rs
@@ -48,8 +48,7 @@ pub(super) fn emit_module(
     // post-emit phase reads `collector.names` to materialise the
     // exported caller-fn name table (`__caller_fn_count` +
     // `__caller_fn_name`) and the matching passive data segments.
-    let caller_fn_collector =
-        std::cell::RefCell::new(super::body::CallerFnCollector::default());
+    let caller_fn_collector = std::cell::RefCell::new(super::body::CallerFnCollector::default());
 
     let fn_defs: Vec<&FnDef> = items
         .iter()
diff --git a/src/codegen/wasm_gc/types.rs b/src/codegen/wasm_gc/types.rs
index 2f216988..560ea4e2 100644
--- a/src/codegen/wasm_gc/types.rs
+++ b/src/codegen/wasm_gc/types.rs
@@ -2003,7 +2003,6 @@ fn fn_body_calls_int_mod(fd: &crate::ast::FnDef) -> bool {
     })
 }
 
-
 fn collect_string_literals_in_fn(
     fd: &crate::ast::FnDef,
     out: &mut Vec<Vec<u8>>,

From 87a13387750040dcb89abb53f139d2cfe63a2a17 Mon Sep 17 00:00:00 2001
From: jasisz <jasisz@gmail.com>
Date: Wed, 6 May 2026 13:26:02 +0200
Subject: [PATCH 04/18] =?UTF-8?q?0.16.3:=20backend=20bugs=201-3=20?=
 =?UTF-8?q?=E2=80=94=20record/sum=20list-hash=20+=20recursive=20sum=20eq?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Three related fixes that lift the wasm-gc backend's
"Int/Float/Bool/String only" cap on record + sum field types in
hash and equality dispatch.

## Bug 1: list-hash on records (lists.rs:2073)

`emit_list_hash` was matching on the surface element string
(`elem.trim()`), so `List<Box>` where `Box(n: Int)` is newtype-
optimised to i64 reached the `other` arm and panicked with a
"file at github" comment that named the right culprit but didn't
fix it. The companion `let _ = kind;` line was a TODO marker —
the kind enum was supposed to be the dispatch axis.

Fix: dispatch by `kind` (`ListEqKind`) instead of the elem string.
Newtype-erased records resolve to their underlying primitive
arm; nominal record/sum elements get a new `RecordEq(name)` arm
that calls `emit_record_inline_hash` over the field list, and
sum elements get a `SumEq(parent)` arm that calls a new
`emit_sum_inline_hash` walking variants in `emit_sum_eq_inline`'s
sorted order (so eq + hash agree on which variant to inspect
first).

The same shape was duplicated in `emit_vec_hash` (`lists.rs:
2443`) — fixed identically: dispatch by kind, route record/sum
to the new inline emitters.

## Bug 2: list / vector hash for sum types

`emit_sum_inline_hash` materialises an i32 hash by mixing the
matched variant's `type_idx` (as a stable tag — empty variants
of the same parent get distinct hashes) and DJB2-folding each
primitive field. Variants are disjoint subtypes of the parent
struct, so at most one `ref.test` succeeds per call; non-matched
arms test to false and skip silently.

Restrictions inherited from `list_eq_kind`: variant fields must
all be `{Int, Bool, Float, String}`. Recursive ref / nested
record fields surface as `Validation` errors; bug 3 lifts that
on the eq side.

## Bug 3: recursive sum eq (lists.rs:1748, maps.rs:2300)

`emit_record_eq_inline` and `emit_sum_eq_inline` rejected any
field type outside `{Int, Float, Bool, String}` with
`WasmGcError::Unimplemented("phase 4 — …")`. That blocked every
recursive nominal type — `Tree.Leaf | Tree.Node(Int, Tree, Tree)`,
`List`-cell shapes, mutually-recursive sums.

Fix: thread two extra params into both inline emitters —
`eq_helper_fn_idx: &HashMap<String, u32>` and `self_fn_idx:
Option<u32>`. The dispatch grows two new arms:

- `field_ty == self_name && self_fn_idx.is_some()` →
  `Call(self_fn_idx)`. Recursive ref to the same type, e.g.
  `Tree.Node` carrying `Tree` fields.
- `eq_helper_fn_idx.contains_key(field_ty)` → `Call(idx)`. Nested
  nominal type with its own `__eq_<X>` helper. Field refs are
  subtypes of `eqref` so the implicit upcast at the call site
  is fine.

The body emit in `body/eq_helpers.rs::EqHelperRegistry::emit_
helper_bodies` snapshots `self.slots → HashMap<&str, fn_idx>`
once and threads it + the per-helper `self_fn_idx` into the
inline emitters. List.contains call sites (lists.rs:1546/1559)
pass empty maps + `None` — `__eq_<X>` field dispatch only fires
inside helper bodies, not inline `List.contains`. (Lifting that
covers fewer use cases and is a follow-up.)

## Verified

- Bug 1 repro (`List<Box>` with `Box(n: Int)` record): wasm-gc
  matches VM (`found: true`).
- Bug 2 repro (`List<Color>` with empty-variant sum): wasm-gc
  matches VM (`found: true`).
- Bug 3 repro (`Tree.Node(Int, Tree, Tree); t1 == t2`): wasm-gc
  matches VM (`eq: true`). Recursive call into the same
  `__eq_Tree` helper resolves through `self_fn_idx`.
- 10/10 wasm-gc record-replay smokes pass.

## Followup

Bugs 4 (generic E) and 5 (ref/eqref) — TBD in next commits.

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>
---
 src/codegen/wasm_gc/body/eq_helpers.rs |  39 ++-
 src/codegen/wasm_gc/lists.rs           | 445 ++++++++++++++++++++++---
 2 files changed, 426 insertions(+), 58 deletions(-)

diff --git a/src/codegen/wasm_gc/body/eq_helpers.rs b/src/codegen/wasm_gc/body/eq_helpers.rs
index 09b28f8a..9b47a446 100644
--- a/src/codegen/wasm_gc/body/eq_helpers.rs
+++ b/src/codegen/wasm_gc/body/eq_helpers.rs
@@ -116,17 +116,42 @@ impl EqHelperRegistry {
         registry: &TypeRegistry,
         string_eq_fn_idx: Option<u32>,
     ) -> Result<(), WasmGcError> {
+        // Snapshot type_name → fn_idx so the inline emitters can
+        // dispatch nested record/sum fields by `Call(idx)` instead
+        // of erroring on `Unimplemented`. Self-recursive fields
+        // (parent==field) get their own `self_fn_idx` argument so
+        // recursive sum/record types (Tree.Node holding Tree, …)
+        // resolve to a recursive call into the same helper.
+        let helper_idx_map: HashMap<String, u32> = self
+            .slots
+            .iter()
+            .map(|(n, (fn_idx, _))| (n.clone(), *fn_idx))
+            .collect();
         for name in &self.order {
             let kind = self.kinds[name];
+            let self_fn_idx = self.slots.get(name).map(|(f, _)| *f);
             let mut f = Function::new(Vec::new());
-            // Local 0 = lhs, local 1 = rhs (function params). Reuse the
-            // inline emitters from `lists.rs` which expect both operands
-            // already stashed in named slots — no extra prologue needed.
             match kind {
-                EqKind::Sum => emit_sum_eq_inline(&mut f, name, registry, 0, 1, string_eq_fn_idx)?,
-                EqKind::Record => {
-                    emit_record_eq_inline(&mut f, name, registry, 0, 1, string_eq_fn_idx)?
-                }
+                EqKind::Sum => emit_sum_eq_inline(
+                    &mut f,
+                    name,
+                    registry,
+                    0,
+                    1,
+                    string_eq_fn_idx,
+                    &helper_idx_map,
+                    self_fn_idx,
+                )?,
+                EqKind::Record => emit_record_eq_inline(
+                    &mut f,
+                    name,
+                    registry,
+                    0,
+                    1,
+                    string_eq_fn_idx,
+                    &helper_idx_map,
+                    self_fn_idx,
+                )?,
             }
             f.instruction(&Instruction::End);
             codes.function(&f);
diff --git a/src/codegen/wasm_gc/lists.rs b/src/codegen/wasm_gc/lists.rs
index 122bcf6d..94b1df93 100644
--- a/src/codegen/wasm_gc/lists.rs
+++ b/src/codegen/wasm_gc/lists.rs
@@ -1543,7 +1543,16 @@ fn emit_list_contains(
             f.instruction(&Instruction::LocalSet(3));
             f.instruction(&Instruction::LocalGet(1));
             f.instruction(&Instruction::LocalSet(4));
-            emit_record_eq_inline(&mut f, record_name, registry, 3, 4, string_eq_fn_idx)?;
+            emit_record_eq_inline(
+                &mut f,
+                record_name,
+                registry,
+                3,
+                4,
+                string_eq_fn_idx,
+                &std::collections::HashMap::new(),
+                None,
+            )?;
         }
         ListEqKind::SumEq(parent_name) => {
             // Same scratch dance as RecordEq — both ref.test and
@@ -1556,7 +1565,16 @@ fn emit_list_contains(
             f.instruction(&Instruction::LocalSet(3));
             f.instruction(&Instruction::LocalGet(1));
             f.instruction(&Instruction::LocalSet(4));
-            emit_sum_eq_inline(&mut f, parent_name, registry, 3, 4, string_eq_fn_idx)?;
+            emit_sum_eq_inline(
+                &mut f,
+                parent_name,
+                registry,
+                3,
+                4,
+                string_eq_fn_idx,
+                &std::collections::HashMap::new(),
+                None,
+            )?;
         }
         _ => {
             f.instruction(&Instruction::LocalGet(2));
@@ -1617,6 +1635,8 @@ pub(super) fn emit_record_eq_inline(
     head_local: u32,
     needle_local: u32,
     string_eq_fn_idx: Option<u32>,
+    eq_helper_fn_idx: &std::collections::HashMap<String, u32>,
+    self_fn_idx: Option<u32>,
 ) -> Result<(), WasmGcError> {
     let record_idx = registry
         .record_type_idx(record_name)
@@ -1649,24 +1669,43 @@ pub(super) fn emit_record_eq_inline(
         });
         // emit per-field eq → i32
         match field_ty.trim() {
-            "Int" => f.instruction(&Instruction::I64Eq),
-            "Bool" => f.instruction(&Instruction::I32Eq),
-            "Float" => f.instruction(&Instruction::F64Eq),
+            "Int" => {
+                f.instruction(&Instruction::I64Eq);
+            }
+            "Bool" => {
+                f.instruction(&Instruction::I32Eq);
+            }
+            "Float" => {
+                f.instruction(&Instruction::F64Eq);
+            }
             "String" => {
                 let eq_fn = string_eq_fn_idx.ok_or(WasmGcError::Validation(
                     "List.contains record field of String type needs \
                      __wasmgc_string_eq registered"
                         .into(),
                 ))?;
-                f.instruction(&Instruction::Call(eq_fn))
+                f.instruction(&Instruction::Call(eq_fn));
+            }
+            other if other == record_name && self_fn_idx.is_some() => {
+                // Recursive ref to the same record — call self.
+                f.instruction(&Instruction::Call(self_fn_idx.unwrap()));
             }
-            _ => {
-                return Err(WasmGcError::Unimplemented(
-                    "phase 4 — record field type in List.contains \
-                     not in {Int, Float, Bool, String}",
-                ));
+            other if eq_helper_fn_idx.contains_key(other) => {
+                // Nested nominal type with its own __eq_<X> helper
+                // — call by fn idx. Field refs are subtypes of
+                // eqref so the implicit upcast at the call site
+                // is fine.
+                let idx = eq_helper_fn_idx[other];
+                f.instruction(&Instruction::Call(idx));
             }
-        };
+            other => {
+                return Err(WasmGcError::Validation(format!(
+                    "record `{record_name}` field type `{other}` has no eq dispatch \
+                     (not in {{Int, Float, Bool, String}}, no `__eq_{other}` helper, \
+                     not self-recursive)"
+                )));
+            }
+        }
         if i > 0 {
             f.instruction(&Instruction::I32And);
         }
@@ -1686,6 +1725,8 @@ pub(super) fn emit_sum_eq_inline(
     head_local: u32,
     needle_local: u32,
     string_eq_fn_idx: Option<u32>,
+    eq_helper_fn_idx: &std::collections::HashMap<String, u32>,
+    self_fn_idx: Option<u32>,
 ) -> Result<(), WasmGcError> {
     // Collect all variants of this sum (use a stable order — names
     // sorted ascending — so two compiler runs produce identical wasm).
@@ -1733,24 +1774,44 @@ pub(super) fn emit_sum_eq_inline(
                     field_index: i as u32,
                 });
                 match field_ty.trim() {
-                    "Int" => f.instruction(&Instruction::I64Eq),
-                    "Bool" => f.instruction(&Instruction::I32Eq),
-                    "Float" => f.instruction(&Instruction::F64Eq),
+                    "Int" => {
+                        f.instruction(&Instruction::I64Eq);
+                    }
+                    "Bool" => {
+                        f.instruction(&Instruction::I32Eq);
+                    }
+                    "Float" => {
+                        f.instruction(&Instruction::F64Eq);
+                    }
                     "String" => {
                         let eq_fn = string_eq_fn_idx.ok_or(WasmGcError::Validation(
                             "List.contains sum field of String type needs \
                              __wasmgc_string_eq registered"
                                 .into(),
                         ))?;
-                        f.instruction(&Instruction::Call(eq_fn))
+                        f.instruction(&Instruction::Call(eq_fn));
+                    }
+                    other if other == parent_name && self_fn_idx.is_some() => {
+                        // Recursive ref to the same sum (Tree.Node carrying
+                        // Tree fields, ditto Cons-cell shapes) — call self.
+                        f.instruction(&Instruction::Call(self_fn_idx.unwrap()));
                     }
-                    _ => {
-                        return Err(WasmGcError::Unimplemented(
-                            "phase 4 — sum-variant field type in List.contains \
-                             not in {Int, Float, Bool, String}",
-                        ));
+                    other if eq_helper_fn_idx.contains_key(other) => {
+                        // Nested record/sum field with its own __eq_<X>
+                        // helper — dispatch by fn idx. Field refs are
+                        // subtypes of eqref, the call's typed args
+                        // accept implicit upcast.
+                        let idx = eq_helper_fn_idx[other];
+                        f.instruction(&Instruction::Call(idx));
                     }
-                };
+                    other => {
+                        return Err(WasmGcError::Validation(format!(
+                            "sum `{parent_name}` variant field type `{other}` has no eq \
+                             dispatch (not primitive, no `__eq_{other}` helper, not \
+                             self-recursive)"
+                        )));
+                    }
+                }
                 if i > 0 {
                     f.instruction(&Instruction::I32And);
                 }
@@ -2023,12 +2084,47 @@ fn emit_list_hash(
     let list_idx = list_idx_of(canonical, registry)?;
     let _ = string_eq_fn_idx;
     let elem = TypeRegistry::list_element_type(canonical).unwrap();
-    // params: 0=l. locals: 1=cur, 2=h.
+    // params: 0=l. locals: 1=cur, 2=h. Plus per-kind extras for
+    // record / sum element hash dispatch (3=elem_ref, 4=elem_hash
+    // accumulator).
     let list_ref = ValType::Ref(RefType {
         nullable: true,
         heap_type: HeapType::Concrete(list_idx),
     });
-    let mut f = Function::new([(1, list_ref), (1, ValType::I32)]);
+    let mut locals: Vec<(u32, ValType)> = vec![(1, list_ref), (1, ValType::I32)];
+    match &kind {
+        ListEqKind::RecordEq(record_name) => {
+            let r_idx = registry.record_type_idx(record_name).ok_or(
+                WasmGcError::Validation(format!(
+                    "list hash for `List<{record_name}>`: record not registered"
+                )),
+            )?;
+            let r_ref = ValType::Ref(RefType {
+                nullable: true,
+                heap_type: HeapType::Concrete(r_idx),
+            });
+            locals.push((1, r_ref)); // 3 = elem_ref
+            locals.push((1, ValType::I32)); // 4 = elem_hash
+        }
+        ListEqKind::SumEq(_) => {
+            // Sum types lower to `(ref null eq)` (per
+            // `types.rs::aver_to_wasm` for sum-parent surface
+            // names). Hold the head ref as eqref; per-variant
+            // `ref.cast` narrows it to the concrete variant idx
+            // before reading its fields.
+            let eq_ref = ValType::Ref(RefType {
+                nullable: true,
+                heap_type: HeapType::Abstract {
+                    shared: false,
+                    ty: wasm_encoder::AbstractHeapType::Eq,
+                },
+            });
+            locals.push((1, eq_ref)); // 3 = elem_ref (eqref carrier)
+            locals.push((1, ValType::I32)); // 4 = elem_hash
+        }
+        _ => {}
+    }
+    let mut f = Function::new(locals);
     // h = 5381
     f.instruction(&Instruction::I32Const(5381));
     f.instruction(&Instruction::LocalSet(2));
@@ -2051,17 +2147,24 @@ fn emit_list_hash(
         struct_type_index: list_idx,
         field_index: 0,
     });
-    // Element hash → i32
-    match elem.trim() {
-        "Int" => {
+    // Element hash → i32. Dispatch by `kind` rather than the raw
+    // `elem` string — newtype optimisation erases single-field
+    // records to their underlying primitive (`Box(n: Int)` → I64),
+    // so the surface name can be `"Box"` while the actual wasm
+    // representation is `i64`. `list_eq_kind` resolves the newtype
+    // before returning, so `kind` is the source of truth for
+    // representation.
+    let _ = elem;
+    match &kind {
+        ListEqKind::I64 => {
             f.instruction(&Instruction::I32WrapI64);
         }
-        "Bool" => {} // already i32
-        "Float" => {
+        ListEqKind::I32 => {} // bool — already i32
+        ListEqKind::F64 => {
             f.instruction(&Instruction::I64ReinterpretF64);
             f.instruction(&Instruction::I32WrapI64);
         }
-        "String" => {
+        ListEqKind::StringEq => {
             // Inline DJB2 over the (array i8) — short version
             // that reuses the per-fn locals would need extra
             // scratch. Cheap fallback: take array length as the
@@ -2070,14 +2173,36 @@ fn emit_list_hash(
             // for non-cryptographic mix.
             f.instruction(&Instruction::ArrayLen);
         }
-        other => panic!(
-            "internal compiler error: list hash emit reached unsupported \
-             element type `{other}`; upstream `list_eq_kind` must restrict \
-             list-hash emission to {{Int, Bool, Float, String}}. \
-             Please file at https://github.com/jasisz/aver/issues"
-        ),
+        ListEqKind::RecordEq(record_name) => {
+            let r_idx =
+                registry
+                    .record_type_idx(record_name)
+                    .ok_or(WasmGcError::Validation(format!(
+                        "list hash dispatch: record `{record_name}` not registered"
+                    )))?;
+            let fields = registry.record_fields.get(record_name).ok_or(
+                WasmGcError::Validation(format!(
+                    "list hash dispatch: record `{record_name}` has no field info"
+                )),
+            )?;
+            emit_record_inline_hash(
+                &mut f,
+                r_idx,
+                fields,
+                /* elem_local */ 3,
+                /* elem_hash_local */ 4,
+            )?;
+        }
+        ListEqKind::SumEq(parent_name) => {
+            emit_sum_inline_hash(
+                &mut f,
+                parent_name,
+                registry,
+                /* elem_local */ 3,
+                /* elem_hash_local */ 4,
+            )?;
+        }
     }
-    let _ = kind;
     f.instruction(&Instruction::I32Add);
     f.instruction(&Instruction::LocalSet(2));
     // cur = cur.tail
@@ -2095,6 +2220,169 @@ fn emit_list_hash(
     Ok(f)
 }
 
+/// Inline DJB2-style hash for a sum element. Stack on entry has the
+/// element eqref; on exit has an `i32` hash. Walks variants in the
+/// same sorted order as `emit_sum_eq_inline` (so two compiler runs
+/// produce identical bytecode + so `eq` and `hash` agree on which
+/// variant to inspect first), and per matched variant mixes its
+/// `type_idx` (as a stable tag) plus DJB2-folds each primitive
+/// field into `elem_hash`. Variants are disjoint subtypes of the
+/// parent, so at most one `ref.test` succeeds per call — non-
+/// matched arms `ref.test` to false and skip silently.
+fn emit_sum_inline_hash(
+    f: &mut Function,
+    parent_name: &str,
+    registry: &TypeRegistry,
+    elem_local: u32,
+    elem_hash_local: u32,
+) -> Result<(), WasmGcError> {
+    // Collect variants of this sum. Same ordering as
+    // `emit_sum_eq_inline` for parity.
+    let mut variants: Vec<(String, super::types::VariantInfo)> = registry
+        .variants
+        .iter()
+        .flat_map(|(n, vs)| vs.iter().map(move |v| (n.clone(), v.clone())))
+        .filter(|(_, v)| v.parent == parent_name)
+        .collect();
+    variants.sort_by(|a, b| a.0.cmp(&b.0));
+    if variants.is_empty() {
+        return Err(WasmGcError::Validation(format!(
+            "list hash dispatch: sum type `{parent_name}` has no variants"
+        )));
+    }
+
+    // Save eqref → elem_local; init elem_hash = 5381.
+    f.instruction(&Instruction::LocalSet(elem_local));
+    f.instruction(&Instruction::I32Const(5381));
+    f.instruction(&Instruction::LocalSet(elem_hash_local));
+
+    for (_v_name, info) in &variants {
+        let v_idx = info.type_idx;
+        let v_heap = wasm_encoder::HeapType::Concrete(v_idx);
+        // if ref.test V elem_ref:
+        f.instruction(&Instruction::LocalGet(elem_local));
+        f.instruction(&Instruction::RefTestNonNull(v_heap));
+        f.instruction(&Instruction::If(wasm_encoder::BlockType::Empty));
+        // Fold variant tag (type_idx as i32) into elem_hash —
+        // ensures empty variants of different shape still get
+        // distinct hashes.
+        f.instruction(&Instruction::LocalGet(elem_hash_local));
+        f.instruction(&Instruction::I32Const(5));
+        f.instruction(&Instruction::I32Shl);
+        f.instruction(&Instruction::LocalGet(elem_hash_local));
+        f.instruction(&Instruction::I32Add);
+        f.instruction(&Instruction::I32Const(v_idx as i32));
+        f.instruction(&Instruction::I32Add);
+        f.instruction(&Instruction::LocalSet(elem_hash_local));
+        // Per field, downcast then fold.
+        for (i, field_ty) in info.fields.iter().enumerate() {
+            f.instruction(&Instruction::LocalGet(elem_hash_local));
+            f.instruction(&Instruction::I32Const(5));
+            f.instruction(&Instruction::I32Shl);
+            f.instruction(&Instruction::LocalGet(elem_hash_local));
+            f.instruction(&Instruction::I32Add);
+
+            f.instruction(&Instruction::LocalGet(elem_local));
+            f.instruction(&Instruction::RefCastNonNull(v_heap));
+            f.instruction(&Instruction::StructGet {
+                struct_type_index: v_idx,
+                field_index: i as u32,
+            });
+            match field_ty.trim() {
+                "Int" => {
+                    f.instruction(&Instruction::I32WrapI64);
+                }
+                "Bool" => {} // already i32
+                "Float" => {
+                    f.instruction(&Instruction::I64ReinterpretF64);
+                    f.instruction(&Instruction::I32WrapI64);
+                }
+                "String" => {
+                    f.instruction(&Instruction::ArrayLen);
+                }
+                other => {
+                    return Err(WasmGcError::Validation(format!(
+                        "sum hash dispatch: variant field type `{other}` \
+                         unsupported (only Int/Bool/Float/String); upstream \
+                         `list_eq_kind` all_simple gate should have rejected this."
+                    )));
+                }
+            }
+            f.instruction(&Instruction::I32Add);
+            f.instruction(&Instruction::LocalSet(elem_hash_local));
+        }
+        f.instruction(&Instruction::End); // end if
+    }
+
+    f.instruction(&Instruction::LocalGet(elem_hash_local));
+    Ok(())
+}
+
+/// Inline DJB2-style hash for a record element. Stack on entry has
+/// the element ref; on exit has an `i32` hash. `elem_local` and
+/// `elem_hash_local` are pre-declared scratch slots in the calling
+/// fn (typed `(ref null $record_idx)` and `i32` respectively).
+///
+/// Per-field hash trick mirrors the primitive arms in
+/// `emit_list_hash`: Int → wrap, Float → reinterpret+wrap, Bool →
+/// already i32, String → array.len. Field shapes are restricted to
+/// {Int, Bool, Float, String} by `list_eq_kind`'s `all_simple` gate;
+/// nested records / lists trip `WasmGcError::Validation` here.
+fn emit_record_inline_hash(
+    f: &mut Function,
+    record_idx: u32,
+    fields: &[(String, String)],
+    elem_local: u32,
+    elem_hash_local: u32,
+) -> Result<(), WasmGcError> {
+    // Save record ref → elem_local for repeated struct.get.
+    f.instruction(&Instruction::LocalSet(elem_local));
+    // elem_hash = 5381 (DJB2 init).
+    f.instruction(&Instruction::I32Const(5381));
+    f.instruction(&Instruction::LocalSet(elem_hash_local));
+    for (i, (_field_name, field_type)) in fields.iter().enumerate() {
+        // elem_hash = elem_hash * 33 + field_hash
+        // (= (elem_hash << 5) + elem_hash + field_hash, DJB2.)
+        f.instruction(&Instruction::LocalGet(elem_hash_local));
+        f.instruction(&Instruction::I32Const(5));
+        f.instruction(&Instruction::I32Shl);
+        f.instruction(&Instruction::LocalGet(elem_hash_local));
+        f.instruction(&Instruction::I32Add);
+        // Push field value, then mix to i32.
+        f.instruction(&Instruction::LocalGet(elem_local));
+        f.instruction(&Instruction::StructGet {
+            struct_type_index: record_idx,
+            field_index: i as u32,
+        });
+        match field_type.trim() {
+            "Int" => {
+                f.instruction(&Instruction::I32WrapI64);
+            }
+            "Bool" => {} // already i32
+            "Float" => {
+                f.instruction(&Instruction::I64ReinterpretF64);
+                f.instruction(&Instruction::I32WrapI64);
+            }
+            "String" => {
+                f.instruction(&Instruction::ArrayLen);
+            }
+            other => {
+                return Err(WasmGcError::Validation(format!(
+                    "record hash dispatch: field type `{other}` unsupported \
+                     (only Int/Bool/Float/String); upstream `list_eq_kind` \
+                     all_simple gate should have rejected this list."
+                )));
+            }
+        }
+        f.instruction(&Instruction::I32Add);
+        f.instruction(&Instruction::LocalSet(elem_hash_local));
+    }
+    // Push final elem_hash so the caller's mix can fold it into the
+    // total list hash.
+    f.instruction(&Instruction::LocalGet(elem_hash_local));
+    Ok(())
+}
+
 /// `eq : (Vector<T>, Vector<T>) -> i32`. Length check + element-
 /// wise eq via per-T instruction. Same `T must be eq-able` rule as
 /// list_eq.
@@ -2175,10 +2463,42 @@ fn emit_vec_hash(
     _string_eq_fn_idx: Option<u32>,
 ) -> Result<Function, WasmGcError> {
     let (vec_idx, _) = vec_idx_of_pair(canonical, registry)?;
-    let _ = kind;
     let elem = TypeRegistry::list_element_type(canonical).unwrap();
-    // params: 0=v. locals: 1=h, 2=len, 3=i.
-    let mut f = Function::new([(1, ValType::I32), (1, ValType::I32), (1, ValType::I32)]);
+    // params: 0=v. locals: 1=h, 2=len, 3=i, plus per-kind extras
+    // (4=elem_ref, 5=elem_hash) for record/sum element dispatch —
+    // newtype optimisation may erase a record name down to its
+    // underlying primitive (kind == I64 even though `elem == "Box"`),
+    // so dispatch by `kind`, not the surface element string.
+    let mut locals: Vec<(u32, ValType)> =
+        vec![(1, ValType::I32), (1, ValType::I32), (1, ValType::I32)];
+    match &kind {
+        ListEqKind::RecordEq(record_name) => {
+            let r_idx = registry.record_type_idx(record_name).ok_or(
+                WasmGcError::Validation(format!(
+                    "vector hash for `Vector<{record_name}>`: record not registered"
+                )),
+            )?;
+            let r_ref = ValType::Ref(RefType {
+                nullable: true,
+                heap_type: HeapType::Concrete(r_idx),
+            });
+            locals.push((1, r_ref)); // 4 = elem_ref
+            locals.push((1, ValType::I32)); // 5 = elem_hash
+        }
+        ListEqKind::SumEq(_) => {
+            let eq_ref = ValType::Ref(RefType {
+                nullable: true,
+                heap_type: HeapType::Abstract {
+                    shared: false,
+                    ty: wasm_encoder::AbstractHeapType::Eq,
+                },
+            });
+            locals.push((1, eq_ref)); // 4 = elem_ref (eqref)
+            locals.push((1, ValType::I32)); // 5 = elem_hash
+        }
+        _ => {}
+    }
+    let mut f = Function::new(locals);
     f.instruction(&Instruction::I32Const(5381));
     f.instruction(&Instruction::LocalSet(1));
     f.instruction(&Instruction::LocalGet(0));
@@ -2201,24 +2521,47 @@ fn emit_vec_hash(
     f.instruction(&Instruction::LocalGet(0));
     f.instruction(&Instruction::LocalGet(3));
     f.instruction(&Instruction::ArrayGet(vec_idx));
-    match elem.trim() {
-        "Int" => {
+    let _ = elem;
+    match &kind {
+        ListEqKind::I64 => {
             f.instruction(&Instruction::I32WrapI64);
         }
-        "Bool" => {}
-        "Float" => {
+        ListEqKind::I32 => {} // bool — already i32
+        ListEqKind::F64 => {
             f.instruction(&Instruction::I64ReinterpretF64);
             f.instruction(&Instruction::I32WrapI64);
         }
-        "String" => {
+        ListEqKind::StringEq => {
             f.instruction(&Instruction::ArrayLen);
         }
-        other => panic!(
-            "internal compiler error: Vector hash emit reached unsupported \
-             element type `{other}`; upstream `list_eq_kind` must restrict \
-             Vector-hash emission to {{Int, Bool, Float, String}}. \
-             Please file at https://github.com/jasisz/aver/issues"
-        ),
+        ListEqKind::RecordEq(record_name) => {
+            let r_idx = registry.record_type_idx(record_name).ok_or(
+                WasmGcError::Validation(format!(
+                    "vector hash dispatch: record `{record_name}` not registered"
+                )),
+            )?;
+            let fields = registry.record_fields.get(record_name).ok_or(
+                WasmGcError::Validation(format!(
+                    "vector hash dispatch: record `{record_name}` has no field info"
+                )),
+            )?;
+            emit_record_inline_hash(
+                &mut f,
+                r_idx,
+                fields,
+                /* elem_local */ 4,
+                /* elem_hash_local */ 5,
+            )?;
+        }
+        ListEqKind::SumEq(parent_name) => {
+            emit_sum_inline_hash(
+                &mut f,
+                parent_name,
+                registry,
+                /* elem_local */ 4,
+                /* elem_hash_local */ 5,
+            )?;
+        }
     }
     f.instruction(&Instruction::I32Add);
     f.instruction(&Instruction::LocalSet(1));

From 609ae431c923fe30c1253868c50a9fcc9f3e63dc Mon Sep 17 00:00:00 2001
From: jasisz <jasisz@gmail.com>
Date: Wed, 6 May 2026 13:29:37 +0200
Subject: [PATCH 05/18] 0.16.3: rustfmt + clippy too_many_arguments allow

CI Format + Clippy steps flagged:
- One indentation diff in `lists.rs::emit_list_hash` from the new
  RecordEq locals match arm.
- `clippy::too_many_arguments` on `emit_record_eq_inline` /
  `emit_sum_eq_inline` after threading `eq_helper_fn_idx` and
  `self_fn_idx` for recursive eq dispatch (now 8 args each).
  Splitting these into a context struct is cleaner long-term but
  not the right cut while we're still settling the dispatch
  shape; an `#[allow]` attribute is fine for the moment.

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>
---
 src/codegen/wasm_gc/lists.rs | 67 +++++++++++++++++-------------------
 1 file changed, 31 insertions(+), 36 deletions(-)

diff --git a/src/codegen/wasm_gc/lists.rs b/src/codegen/wasm_gc/lists.rs
index 94b1df93..8fcde40d 100644
--- a/src/codegen/wasm_gc/lists.rs
+++ b/src/codegen/wasm_gc/lists.rs
@@ -1628,6 +1628,7 @@ fn emit_list_contains(
 /// surface as Unimplemented (same constraint as `emit_eq_record` in
 /// maps.rs — extending requires nested-record / list / vector eq
 /// dispatch).
+#[allow(clippy::too_many_arguments)]
 pub(super) fn emit_record_eq_inline(
     f: &mut Function,
     record_name: &str,
@@ -1718,6 +1719,7 @@ pub(super) fn emit_record_eq_inline(
 /// and needle have that concrete type. If both: cast + field-by-
 /// field eq, push result. If only one: push 0 (different variants).
 /// Final i32 on stack: 1 = equal, 0 = different.
+#[allow(clippy::too_many_arguments)]
 pub(super) fn emit_sum_eq_inline(
     f: &mut Function,
     parent_name: &str,
@@ -2094,11 +2096,11 @@ fn emit_list_hash(
     let mut locals: Vec<(u32, ValType)> = vec![(1, list_ref), (1, ValType::I32)];
     match &kind {
         ListEqKind::RecordEq(record_name) => {
-            let r_idx = registry.record_type_idx(record_name).ok_or(
-                WasmGcError::Validation(format!(
+            let r_idx = registry
+                .record_type_idx(record_name)
+                .ok_or(WasmGcError::Validation(format!(
                     "list hash for `List<{record_name}>`: record not registered"
-                )),
-            )?;
+                )))?;
             let r_ref = ValType::Ref(RefType {
                 nullable: true,
                 heap_type: HeapType::Concrete(r_idx),
@@ -2174,23 +2176,19 @@ fn emit_list_hash(
             f.instruction(&Instruction::ArrayLen);
         }
         ListEqKind::RecordEq(record_name) => {
-            let r_idx =
-                registry
-                    .record_type_idx(record_name)
-                    .ok_or(WasmGcError::Validation(format!(
-                        "list hash dispatch: record `{record_name}` not registered"
-                    )))?;
-            let fields = registry.record_fields.get(record_name).ok_or(
-                WasmGcError::Validation(format!(
+            let r_idx = registry
+                .record_type_idx(record_name)
+                .ok_or(WasmGcError::Validation(format!(
+                    "list hash dispatch: record `{record_name}` not registered"
+                )))?;
+            let fields = registry
+                .record_fields
+                .get(record_name)
+                .ok_or(WasmGcError::Validation(format!(
                     "list hash dispatch: record `{record_name}` has no field info"
-                )),
-            )?;
+                )))?;
             emit_record_inline_hash(
-                &mut f,
-                r_idx,
-                fields,
-                /* elem_local */ 3,
-                /* elem_hash_local */ 4,
+                &mut f, r_idx, fields, /* elem_local */ 3, /* elem_hash_local */ 4,
             )?;
         }
         ListEqKind::SumEq(parent_name) => {
@@ -2473,11 +2471,11 @@ fn emit_vec_hash(
         vec![(1, ValType::I32), (1, ValType::I32), (1, ValType::I32)];
     match &kind {
         ListEqKind::RecordEq(record_name) => {
-            let r_idx = registry.record_type_idx(record_name).ok_or(
-                WasmGcError::Validation(format!(
+            let r_idx = registry
+                .record_type_idx(record_name)
+                .ok_or(WasmGcError::Validation(format!(
                     "vector hash for `Vector<{record_name}>`: record not registered"
-                )),
-            )?;
+                )))?;
             let r_ref = ValType::Ref(RefType {
                 nullable: true,
                 heap_type: HeapType::Concrete(r_idx),
@@ -2535,22 +2533,19 @@ fn emit_vec_hash(
             f.instruction(&Instruction::ArrayLen);
         }
         ListEqKind::RecordEq(record_name) => {
-            let r_idx = registry.record_type_idx(record_name).ok_or(
-                WasmGcError::Validation(format!(
+            let r_idx = registry
+                .record_type_idx(record_name)
+                .ok_or(WasmGcError::Validation(format!(
                     "vector hash dispatch: record `{record_name}` not registered"
-                )),
-            )?;
-            let fields = registry.record_fields.get(record_name).ok_or(
-                WasmGcError::Validation(format!(
+                )))?;
+            let fields = registry
+                .record_fields
+                .get(record_name)
+                .ok_or(WasmGcError::Validation(format!(
                     "vector hash dispatch: record `{record_name}` has no field info"
-                )),
-            )?;
+                )))?;
             emit_record_inline_hash(
-                &mut f,
-                r_idx,
-                fields,
-                /* elem_local */ 4,
-                /* elem_hash_local */ 5,
+                &mut f, r_idx, fields, /* elem_local */ 4, /* elem_hash_local */ 5,
             )?;
         }
         ListEqKind::SumEq(parent_name) => {

From 06b832f0ae34092a9ec0ace8f5aa8542bf6479da Mon Sep 17 00:00:00 2001
From: jasisz <jasisz@gmail.com>
Date: Wed, 6 May 2026 14:11:04 +0200
Subject: [PATCH 06/18] =?UTF-8?q?0.16.3:=20bug=204=20+=205=20=E2=80=94=20t?=
 =?UTF-8?q?ransitive=20eq=20helpers=20+=20eqref=20ref.cast=20prologue?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

User stress-tested the bug 1-3 fix with three exotic shapes;
two of them surfaced fresh regressions both rooted in the
`__eq_<TypeName>` helper machinery.

## Repros that triggered the fixes

- **A: record with sum field.** `record Item { name: String,
  color: Color }`, `Item == Item`. Failed with
  `record Item field type Color has no eq dispatch`.
- **B: sum with record field.** `type Cell = Empty | Filled(Pos)`
  where `record Pos { x: Int, y: Int }`. Failed with
  `expected (ref null $type), found eqref`.
- **C: mutually recursive sums.** `type A = A0 | A1(B); type B
  = B0 | B1(A)`. Worked already after bug 3, kept as a
  regression smoke.

## Fix 1: transitive `__eq_<X>` helper registration

`EqHelperRegistry::register` only ran on the types that the
user wrote `==` / `!=` on directly. Field types reached only
transitively — e.g. `Color` showing up as a field of `Item` —
never got a slot, so the bug 3 dispatch
`Call(eq_helper_fn_idx[field_type])` resolved to None and bailed
with the new validation error.

New `register_transitive(name, kind, registry)` walks the
record fields / sum variants and recurses on any nominal field
type. Idempotent on cycles (Tree → Tree.Node → Tree's
`register_transitive` is a no-op after the first hit), so
recursive shapes don't loop. Discovery walker in `module.rs`
swapped to call this instead of plain `register`.

## Fix 2: ref.cast prologue in `__eq_<Record>` body

The helper signature is `(eqref, eqref) -> i32` (uniform for
record + sum so call sites don't need per-type fn type idxs).
That was fine for sums — `emit_sum_eq_inline` runs `ref.test`
+ `ref.cast` per variant before reading fields. Records read
fields straight off the param via `struct.get $record_idx <i>`
which the validator rejects: `struct.get` wants a typed
`(ref null $record)`, not `eqref`.

`emit_helper_bodies::EqKind::Record` now declares 2 typed
locals on the helper, casts both params at the top of the body,
and drives `emit_record_eq_inline` against the typed locals.
Sum path is unchanged.

## Verified

- All three exotic repros (A/B/C) match VM output.
- Bug 1/2/3 repros still match.
- 10/10 wasm-gc record-replay smokes pass.
- All ~92 examples (core/data/games/projects) compile +
  validate under wasm-gc.

`exo_b` was the shape memory's "bug 5: ref/eqref" referred to —
the validator message and structure match.

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>
---
 src/codegen/wasm_gc/body/eq_helpers.rs | 143 +++++++++++++++++++++----
 src/codegen/wasm_gc/module.rs          |   4 +-
 2 files changed, 122 insertions(+), 25 deletions(-)

diff --git a/src/codegen/wasm_gc/body/eq_helpers.rs b/src/codegen/wasm_gc/body/eq_helpers.rs
index 9b47a446..84aaa200 100644
--- a/src/codegen/wasm_gc/body/eq_helpers.rs
+++ b/src/codegen/wasm_gc/body/eq_helpers.rs
@@ -68,6 +68,70 @@ impl EqHelperRegistry {
         }
     }
 
+    /// Register `type_name` and recursively register every nominal
+    /// field type it transitively reaches. Needed because the
+    /// emitted `__eq_<X>` body dispatches nested record/sum fields
+    /// by `Call(__eq_<FieldType>)` — those helper slots have to
+    /// exist even if the user never wrote `field == field` directly.
+    /// `register` is idempotent on cycle (Tree → Tree.Node → Tree)
+    /// so the recursion terminates.
+    pub(crate) fn register_transitive(
+        &mut self,
+        type_name: &str,
+        kind: EqKind,
+        registry: &TypeRegistry,
+    ) {
+        if self.kinds.contains_key(type_name) {
+            return;
+        }
+        self.register(type_name, kind);
+        // Walk fields and recurse on nominal types.
+        match kind {
+            EqKind::Record => {
+                if let Some(fields) = registry.record_fields.get(type_name) {
+                    for (_, field_ty) in fields {
+                        self.register_field_type(field_ty.trim(), registry);
+                    }
+                }
+            }
+            EqKind::Sum => {
+                let variants: Vec<_> = registry
+                    .variants
+                    .values()
+                    .flat_map(|vs| vs.iter())
+                    .filter(|v| v.parent == type_name)
+                    .cloned()
+                    .collect();
+                for v in &variants {
+                    for field_ty in &v.fields {
+                        self.register_field_type(field_ty.trim(), registry);
+                    }
+                }
+            }
+        }
+    }
+
+    fn register_field_type(&mut self, field_ty: &str, registry: &TypeRegistry) {
+        // Skip primitives and compound carriers (List/Map/Vector/
+        // Option/Result handle their own dispatch).
+        if matches!(field_ty, "Int" | "Float" | "Bool" | "String" | "Unit" | "Byte" | "Char") {
+            return;
+        }
+        if registry.record_fields.contains_key(field_ty) {
+            self.register_transitive(field_ty, EqKind::Record, registry);
+        } else if registry
+            .variants
+            .values()
+            .flat_map(|v| v.iter())
+            .any(|v| v.parent == field_ty)
+        {
+            self.register_transitive(field_ty, EqKind::Sum, registry);
+        }
+        // Other shapes (List<T>, Map<K, V>, generics) — out of
+        // scope for nominal eq dispatch today; leave them to fail
+        // loudly in the inline emitter so we know to extend.
+    }
+
     pub(crate) fn iter(&self) -> impl Iterator<Item = (&str, EqKind)> + '_ {
         self.order.iter().map(|n| (n.as_str(), self.kinds[n]))
     }
@@ -130,31 +194,64 @@ impl EqHelperRegistry {
         for name in &self.order {
             let kind = self.kinds[name];
             let self_fn_idx = self.slots.get(name).map(|(f, _)| *f);
-            let mut f = Function::new(Vec::new());
             match kind {
-                EqKind::Sum => emit_sum_eq_inline(
-                    &mut f,
-                    name,
-                    registry,
-                    0,
-                    1,
-                    string_eq_fn_idx,
-                    &helper_idx_map,
-                    self_fn_idx,
-                )?,
-                EqKind::Record => emit_record_eq_inline(
-                    &mut f,
-                    name,
-                    registry,
-                    0,
-                    1,
-                    string_eq_fn_idx,
-                    &helper_idx_map,
-                    self_fn_idx,
-                )?,
+                EqKind::Sum => {
+                    // Sum's emit_sum_eq_inline does its own
+                    // ref.test/ref.cast cascade per variant — the
+                    // raw eqref params are fine to feed in directly.
+                    let mut f = Function::new(Vec::new());
+                    emit_sum_eq_inline(
+                        &mut f,
+                        name,
+                        registry,
+                        0,
+                        1,
+                        string_eq_fn_idx,
+                        &helper_idx_map,
+                        self_fn_idx,
+                    )?;
+                    f.instruction(&Instruction::End);
+                    codes.function(&f);
+                }
+                EqKind::Record => {
+                    // Record's emit_record_eq_inline reads fields via
+                    // `struct.get $record_idx <i>` straight off the
+                    // local — that needs a typed `(ref null $record)`,
+                    // not the eqref the helper signature carries. So
+                    // declare two typed locals (idxs 2, 3), `ref.cast`
+                    // each param into its slot, then drive the inline
+                    // emitter against the typed locals.
+                    let r_idx = registry.record_type_idx(name).ok_or(
+                        WasmGcError::Validation(format!(
+                            "eq helper for record `{name}`: record not registered"
+                        )),
+                    )?;
+                    let r_ref = wasm_encoder::ValType::Ref(wasm_encoder::RefType {
+                        nullable: true,
+                        heap_type: wasm_encoder::HeapType::Concrete(r_idx),
+                    });
+                    let mut f = Function::new(vec![(2, r_ref)]);
+                    let r_heap = wasm_encoder::HeapType::Concrete(r_idx);
+                    f.instruction(&Instruction::LocalGet(0));
+                    f.instruction(&Instruction::RefCastNonNull(r_heap));
+                    f.instruction(&Instruction::LocalSet(2));
+                    f.instruction(&Instruction::LocalGet(1));
+                    f.instruction(&Instruction::RefCastNonNull(r_heap));
+                    f.instruction(&Instruction::LocalSet(3));
+                    emit_record_eq_inline(
+                        &mut f,
+                        name,
+                        registry,
+                        2,
+                        3,
+                        string_eq_fn_idx,
+                        &helper_idx_map,
+                        self_fn_idx,
+                    )?;
+                    f.instruction(&Instruction::End);
+                    codes.function(&f);
+                }
             }
-            f.instruction(&Instruction::End);
-            codes.function(&f);
         }
         Ok(())
     }
diff --git a/src/codegen/wasm_gc/module.rs b/src/codegen/wasm_gc/module.rs
index 8a31920e..b6f5aed1 100644
--- a/src/codegen/wasm_gc/module.rs
+++ b/src/codegen/wasm_gc/module.rs
@@ -1261,14 +1261,14 @@ fn discover_builtins_in_expr(
                 && let AverType::Named(name) = t
             {
                 if type_registry.record_fields.contains_key(name) {
-                    eq_helpers.register(name, EqKind::Record);
+                    eq_helpers.register_transitive(name, EqKind::Record, type_registry);
                 } else if type_registry
                     .variants
                     .values()
                     .flat_map(|v| v.iter())
                     .any(|v| &v.parent == name)
                 {
-                    eq_helpers.register(name, EqKind::Sum);
+                    eq_helpers.register_transitive(name, EqKind::Sum, type_registry);
                 }
             }
             discover_builtins_in_expr(&l.node, builtins, effects, eq_helpers, type_registry);

From 6d80dd74e7e160225aa56a3d070cecf95158630c Mon Sep 17 00:00:00 2001
From: jasisz <jasisz@gmail.com>
Date: Wed, 6 May 2026 14:44:46 +0200
Subject: [PATCH 07/18] 0.16.3: lift nominal eq cap for collections +
 transitive helper register
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

User stress-test ("spróbuj egzotyków") surfaced that the bug-1-3 fix
covered nominal `==` directly on a record/sum (`Item == Item`) and
inside `__eq_<X>` field dispatch, but the surrounding ListEqKind /
ListHelperRegistry wiring still bailed out for collections holding
nominal elements:

- `List<Tree>` failed `list_eq_kind` because Tree.Node's recursive
  `Tree` field tripped the old `all_simple` gate — primitive-only.
- `emit_list_eq` / `emit_list_contains` / `emit_vec_eq` then panic-d
  or returned Unimplemented on the RecordEq/SumEq arm.
- The helper-body emit threaded `&HashMap::new()` for the eq helper
  lookup map and `None` for self_fn_idx, so even when a kind landed
  the inner `emit_record_eq_inline` / `emit_sum_eq_inline` couldn't
  resolve nested-nominal field eq (`Item.color: Color`).

Lifts:

- `list_eq_kind` now accepts nominal elements whose fields are
  themselves resolvable. `record_fields_resolvable` and
  `sum_fields_resolvable` recurse with a `seen` set so cycles
  (Tree → Tree.Node → Tree) terminate. Fields can be primitive,
  another resolvable record, or another resolvable sum.
- `emit_list_eq` / `emit_vec_eq` no longer panic on RecordEq /
  SumEq. They dispatch to the per-type `__eq_<X>` helper via
  `Call(eq_helper_fn_idx[name])`. Both refs on the stack are
  subtypes of eqref so the implicit upcast at the helper signature
  is fine.
- `emit_list_contains`'s nested `emit_record_eq_inline` /
  `emit_sum_eq_inline` calls now thread the actual eq-helper map
  in (used to be empty), so a `List<Item>.contains(needle)` with
  Item carrying a Color field resolves Color through
  `Call(__eq_Color)` instead of bailing.
- `ListHelperRegistry::emit_helper_bodies` takes
  `eq_helper_fn_idx: &HashMap<String, u32>` and passes it down.
  `module.rs` snapshots `eq_helpers_registry.iter()` once and
  hands it to both list_helpers' emit and the existing
  eq_helpers' own bodies (where it was already wired in step 3).
- Discovery walker (`module.rs::discover_builtins_in_expr`) gains
  `register_nominal_in_type(t)` that walks `t` recursively and
  registers every Named record/sum it reaches. Needed because
  `==` on `List<Tree>` (or `Map<Color, Box>`, `Option<Cell>`,
  …) used to register nothing — `t` matched neither
  `AverType::Named` nor a record/sum walker; the helper bodies
  later tried `Call(__eq_<Tree>)` on an unregistered slot.

## Verified by stress repros

- A: `record Item { name: String, color: Color }`, `==`. Color
  is now auto-registered transitively, dispatch via
  `Call(__eq_Color)` resolves cleanly.
- B: `type Cell = Empty | Filled(Pos)` with `record Pos { x, y }`.
  Pos registered transitively, helper signature ref.cast prologue
  (step 3 fix) gives the typed ref `struct.get` needs.
- C: mutually recursive `type A = A0 | A1(B); type B = B0 | B1(A)`.
  Both helpers register; recursive Call(self_fn_idx) closes the
  loop.
- bugs 1, 2, 3 still match VM.
- 10/10 wasm-gc record-replay smokes pass.
- All 92 examples (core/data/games/projects) compile + validate.

## Known remaining shapes (out of 5-bug scope)

- `==` on `List<Tree>` directly (BinOp::Eq with operand type
  `Type::List(_)`): `body/emit.rs::sum_or_record_eq_fn`'s lookup
  is keyed by `Type::Named(name)` only, so `List<…>` falls
  through to the default `i64.eq` arm. Fix would extend the
  dispatch to call `fn_map.list_ops[canonical].eq` when the
  operand type is `List<…>` / `Vector<…>`. Separate refactor —
  flagged for 0.16.4.
- Records with `Option<…>` / `Result<…, …>` / `Tuple<…>` fields:
  `emit_record_eq_inline`'s field type match needs a similar
  generic-carrier dispatch path. Same followup.

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>
---
 src/codegen/wasm_gc/lists.rs  | 172 ++++++++++++++++++++++++----------
 src/codegen/wasm_gc/module.rs |  64 ++++++++++++-
 2 files changed, 185 insertions(+), 51 deletions(-)

diff --git a/src/codegen/wasm_gc/lists.rs b/src/codegen/wasm_gc/lists.rs
index 8fcde40d..91cfba3e 100644
--- a/src/codegen/wasm_gc/lists.rs
+++ b/src/codegen/wasm_gc/lists.rs
@@ -569,6 +569,7 @@ impl ListHelperRegistry {
         codes: &mut CodeSection,
         registry: &TypeRegistry,
         string_eq_fn_idx: Option<u32>,
+        eq_helper_fn_idx: &std::collections::HashMap<String, u32>,
     ) -> Result<(), WasmGcError> {
         for canonical in &self.list_order {
             // Order MUST match `assign_slots` and
@@ -589,6 +590,7 @@ impl ListHelperRegistry {
                     registry,
                     kind.clone(),
                     string_eq_fn_idx,
+                    eq_helper_fn_idx,
                 )?);
                 if let (Some(eq_fn), Some(_hash_fn)) = (ops.eq, ops.hash) {
                     codes.function(&emit_list_eq(
@@ -597,6 +599,7 @@ impl ListHelperRegistry {
                         kind.clone(),
                         string_eq_fn_idx,
                         eq_fn,
+                        eq_helper_fn_idx,
                     )?);
                     codes.function(&emit_list_hash(
                         canonical,
@@ -620,6 +623,7 @@ impl ListHelperRegistry {
                     registry,
                     kind.clone(),
                     string_eq_fn_idx,
+                    eq_helper_fn_idx,
                 )?);
                 codes.function(&emit_vec_hash(canonical, registry, kind, string_eq_fn_idx)?);
             }
@@ -697,20 +701,18 @@ fn list_eq_kind(elem: &str, registry: &TypeRegistry) -> Option<ListEqKind> {
         "Bool" => Some(ListEqKind::I32),
         "String" => Some(ListEqKind::StringEq),
         other => {
+            // Record / sum element gets a contains/eq/hash slot
+            // whenever its fields are themselves resolvable: primitives
+            // or nominal types we've already accepted. Recursive refs
+            // (Tree.Node holding Tree) and nominal cross-references
+            // (Item holding Color) both flow through `field_resolvable`
+            // which recurses with a `seen` set so cycles terminate.
+            // The inline emitters (emit_record_eq_inline /
+            // emit_sum_eq_inline) handle these via `eq_helper_fn_idx`
+            // dispatch + `self_fn_idx` for self-recursion since 0.16.3.
+            let mut seen: std::collections::HashSet<String> = std::collections::HashSet::new();
             if registry.record_type_idx(other).is_some() {
-                // Record element only gets a `contains` slot when
-                // every field is comparable inline. Nested records,
-                // lists, vectors, sums in fields would need a
-                // recursive eq dispatch the inline emit doesn't
-                // support — those records still work as Map keys
-                // (where nested record helpers are force-registered
-                // and called by fn idx); they just don't get a
-                // List.contains slot.
-                let fields = registry.record_fields.get(other)?;
-                let all_simple = fields
-                    .iter()
-                    .all(|(_, t)| matches!(t.trim(), "Int" | "Float" | "Bool" | "String"));
-                if all_simple {
+                if record_fields_resolvable(other, registry, &mut seen) {
                     Some(ListEqKind::RecordEq(other.to_string()))
                 } else {
                     None
@@ -721,17 +723,7 @@ fn list_eq_kind(elem: &str, registry: &TypeRegistry) -> Option<ListEqKind> {
                 .flat_map(|v| v.iter())
                 .any(|v| v.parent == other)
             {
-                let all_simple = registry
-                    .variants
-                    .values()
-                    .flat_map(|vs| vs.iter())
-                    .filter(|v| v.parent == other)
-                    .all(|v| {
-                        v.fields
-                            .iter()
-                            .all(|t| matches!(t.trim(), "Int" | "Float" | "Bool" | "String"))
-                    });
-                if all_simple {
+                if sum_fields_resolvable(other, registry, &mut seen) {
                     Some(ListEqKind::SumEq(other.to_string()))
                 } else {
                     None
@@ -743,6 +735,62 @@ fn list_eq_kind(elem: &str, registry: &TypeRegistry) -> Option<ListEqKind> {
     }
 }
 
+/// True when every field of `record` is something the inline eq
+/// emitters can dispatch: primitive, a registered record/sum
+/// (recursively resolvable), or self-recursion. Cycles terminate
+/// via the `seen` set.
+fn record_fields_resolvable(
+    record: &str,
+    registry: &TypeRegistry,
+    seen: &mut std::collections::HashSet<String>,
+) -> bool {
+    if !seen.insert(record.to_string()) {
+        return true; // already visiting — break the cycle
+    }
+    let Some(fields) = registry.record_fields.get(record) else {
+        return false;
+    };
+    fields
+        .iter()
+        .all(|(_, t)| field_type_resolvable(t.trim(), registry, seen))
+}
+
+fn sum_fields_resolvable(
+    parent: &str,
+    registry: &TypeRegistry,
+    seen: &mut std::collections::HashSet<String>,
+) -> bool {
+    if !seen.insert(parent.to_string()) {
+        return true;
+    }
+    registry
+        .variants
+        .values()
+        .flat_map(|vs| vs.iter())
+        .filter(|v| v.parent == parent)
+        .all(|v| {
+            v.fields
+                .iter()
+                .all(|t| field_type_resolvable(t.trim(), registry, seen))
+        })
+}
+
+fn field_type_resolvable(
+    field: &str,
+    registry: &TypeRegistry,
+    seen: &mut std::collections::HashSet<String>,
+) -> bool {
+    matches!(field, "Int" | "Float" | "Bool" | "String")
+        || (registry.record_type_idx(field).is_some()
+            && record_fields_resolvable(field, registry, seen))
+        || (registry
+            .variants
+            .values()
+            .flat_map(|vs| vs.iter())
+            .any(|v| v.parent == field)
+            && sum_fields_resolvable(field, registry, seen))
+}
+
 fn list_idx_of(canonical: &str, registry: &TypeRegistry) -> Result<u32, WasmGcError> {
     registry
         .list_type_idx(canonical)
@@ -1498,6 +1546,7 @@ fn emit_list_contains(
     registry: &TypeRegistry,
     kind: ListEqKind,
     string_eq_fn_idx: Option<u32>,
+    eq_helper_fn_idx: &std::collections::HashMap<String, u32>,
 ) -> Result<Function, WasmGcError> {
     let list_idx = list_idx_of(canonical, registry)?;
     let list_ref = ValType::Ref(RefType {
@@ -1550,7 +1599,7 @@ fn emit_list_contains(
                 3,
                 4,
                 string_eq_fn_idx,
-                &std::collections::HashMap::new(),
+                eq_helper_fn_idx,
                 None,
             )?;
         }
@@ -1572,7 +1621,7 @@ fn emit_list_contains(
                 3,
                 4,
                 string_eq_fn_idx,
-                &std::collections::HashMap::new(),
+                eq_helper_fn_idx,
                 None,
             )?;
         }
@@ -1995,12 +2044,14 @@ fn emit_list_zip(
 /// when both lists end at the same step with all heads equal; 0
 /// otherwise. Same `T` constraint as contains — only emitted when T
 /// has a `list_eq_kind`.
+#[allow(clippy::too_many_arguments)]
 fn emit_list_eq(
     canonical: &str,
     registry: &TypeRegistry,
     kind: ListEqKind,
     string_eq_fn_idx: Option<u32>,
     self_fn_idx: u32,
+    eq_helper_fn_idx: &std::collections::HashMap<String, u32>,
 ) -> Result<Function, WasmGcError> {
     let list_idx = list_idx_of(canonical, registry)?;
     // params: 0 = la, 1 = lb. No locals — short body.
@@ -2032,25 +2083,35 @@ fn emit_list_eq(
         field_index: 0,
     });
     match &kind {
-        ListEqKind::I64 => f.instruction(&Instruction::I64Eq),
-        ListEqKind::F64 => f.instruction(&Instruction::F64Eq),
-        ListEqKind::I32 => f.instruction(&Instruction::I32Eq),
+        ListEqKind::I64 => {
+            f.instruction(&Instruction::I64Eq);
+        }
+        ListEqKind::F64 => {
+            f.instruction(&Instruction::F64Eq);
+        }
+        ListEqKind::I32 => {
+            f.instruction(&Instruction::I32Eq);
+        }
         ListEqKind::StringEq => {
             let eq_fn = string_eq_fn_idx.ok_or(WasmGcError::Validation(
                 "List eq over String needs __wasmgc_string_eq".into(),
             ))?;
-            f.instruction(&Instruction::Call(eq_fn))
+            f.instruction(&Instruction::Call(eq_fn));
         }
-        ListEqKind::RecordEq(_) | ListEqKind::SumEq(_) => {
-            // Same `all_simple` constraint as contains — these
-            // variants don't reach this emit path.
-            panic!(
-                "internal compiler error: emit_list_eq reached RecordEq/SumEq; \
-                 list_eq_kind must return None for record/sum elements. \
-                 Please file at https://github.com/jasisz/aver/issues"
-            )
+        ListEqKind::RecordEq(name) | ListEqKind::SumEq(name) => {
+            // Nominal element — dispatch to the per-type
+            // `__eq_<X>` helper. Its signature is
+            // `(eqref, eqref) -> i32`; both refs on the stack are
+            // subtypes of eqref so the implicit upcast is fine.
+            let idx = eq_helper_fn_idx.get(name).copied().ok_or(
+                WasmGcError::Validation(format!(
+                    "List eq over `{name}`: __eq_{name} helper not registered \
+                     (discovery walker should have transitively flagged it)"
+                )),
+            )?;
+            f.instruction(&Instruction::Call(idx));
         }
-    };
+    }
     // if heads differ → 0
     f.instruction(&Instruction::I32Eqz);
     f.instruction(&Instruction::If(BlockType::Empty));
@@ -2389,6 +2450,7 @@ fn emit_vec_eq(
     registry: &TypeRegistry,
     kind: ListEqKind,
     string_eq_fn_idx: Option<u32>,
+    eq_helper_fn_idx: &std::collections::HashMap<String, u32>,
 ) -> Result<Function, WasmGcError> {
     let (vec_idx, _) = vec_idx_of_pair(canonical, registry)?;
     // params: 0=va, 1=vb. locals: 2=len, 3=i.
@@ -2420,22 +2482,32 @@ fn emit_vec_eq(
     f.instruction(&Instruction::LocalGet(3));
     f.instruction(&Instruction::ArrayGet(vec_idx));
     match &kind {
-        ListEqKind::I64 => f.instruction(&Instruction::I64Eq),
-        ListEqKind::F64 => f.instruction(&Instruction::F64Eq),
-        ListEqKind::I32 => f.instruction(&Instruction::I32Eq),
+        ListEqKind::I64 => {
+            f.instruction(&Instruction::I64Eq);
+        }
+        ListEqKind::F64 => {
+            f.instruction(&Instruction::F64Eq);
+        }
+        ListEqKind::I32 => {
+            f.instruction(&Instruction::I32Eq);
+        }
         ListEqKind::StringEq => {
             let eq_fn = string_eq_fn_idx.ok_or(WasmGcError::Validation(
                 "Vector eq over String needs __wasmgc_string_eq".into(),
             ))?;
-            f.instruction(&Instruction::Call(eq_fn))
+            f.instruction(&Instruction::Call(eq_fn));
         }
-        kind => panic!(
-            "internal compiler error: Vector eq emit reached unsupported \
-             kind {kind:?}; upstream `list_eq_kind` must filter Vector eq \
-             to scalar / String elements. \
-             Please file at https://github.com/jasisz/aver/issues"
-        ),
-    };
+        ListEqKind::RecordEq(name) | ListEqKind::SumEq(name) => {
+            // Nominal element — `Call(__eq_<X>)`. Same eqref upcast
+            // shape as in `emit_list_eq`.
+            let idx = eq_helper_fn_idx.get(name).copied().ok_or(
+                WasmGcError::Validation(format!(
+                    "Vector eq over `{name}`: __eq_{name} helper not registered"
+                )),
+            )?;
+            f.instruction(&Instruction::Call(idx));
+        }
+    }
     f.instruction(&Instruction::I32Eqz);
     f.instruction(&Instruction::If(BlockType::Empty));
     f.instruction(&Instruction::I32Const(0));
diff --git a/src/codegen/wasm_gc/module.rs b/src/codegen/wasm_gc/module.rs
index b6f5aed1..42496054 100644
--- a/src/codegen/wasm_gc/module.rs
+++ b/src/codegen/wasm_gc/module.rs
@@ -665,8 +665,19 @@ pub(super) fn emit_module(
     map_helpers.emit_helper_bodies(&mut codes, &registry, &compound_eq_hash_lookup)?;
 
     // List / Vector.fromList / String.split-join helper bodies.
+    // Snapshot eq-helper fn idxs so list/vec eq+hash bodies can
+    // dispatch nominal-element `==`/hash through `Call(__eq_<X>)`.
     let string_eq_fn_idx = builtin_registry.lookup_wasm_fn_idx(BuiltinName::StringEq);
-    list_helpers.emit_helper_bodies(&mut codes, &registry, string_eq_fn_idx)?;
+    let eq_helper_fn_idx_map: HashMap<String, u32> = eq_helpers_registry
+        .iter()
+        .filter_map(|(n, _k)| eq_helpers_registry.lookup_fn_idx(n).map(|i| (n.to_string(), i)))
+        .collect();
+    list_helpers.emit_helper_bodies(
+        &mut codes,
+        &registry,
+        string_eq_fn_idx,
+        &eq_helper_fn_idx_map,
+    )?;
 
     // Per-(record/sum) `__eq_<TypeName>` helper bodies — emit after
     // list helpers so any String fields can call `__wasmgc_string_eq`
@@ -1199,6 +1210,47 @@ fn discover_builtins_in_stmt(
     }
 }
 
+/// Recursively walks `t` and registers every nominal record/sum it
+/// reaches in `eq_helpers`. Needed for `==` on collection types
+/// whose element/key/value type is nominal — `List<Tree>`,
+/// `Map<Color, Tree>`, `Option<Box>`, etc. Without this, the
+/// helper-body emit (`emit_list_eq`, `emit_record_eq_inline`,
+/// `emit_eq_record`) would dispatch by `Call(__eq_<Tree>)` against
+/// an unregistered slot.
+fn register_nominal_in_type(
+    t: &AverType,
+    eq_helpers: &mut EqHelperRegistry,
+    type_registry: &super::types::TypeRegistry,
+) {
+    match t {
+        AverType::Named(name) => {
+            if type_registry.record_fields.contains_key(name) {
+                eq_helpers.register_transitive(name, EqKind::Record, type_registry);
+            } else if type_registry
+                .variants
+                .values()
+                .flat_map(|v| v.iter())
+                .any(|v| &v.parent == name)
+            {
+                eq_helpers.register_transitive(name, EqKind::Sum, type_registry);
+            }
+        }
+        AverType::List(inner) | AverType::Vector(inner) | AverType::Option(inner) => {
+            register_nominal_in_type(inner, eq_helpers, type_registry);
+        }
+        AverType::Map(k, v) | AverType::Result(k, v) => {
+            register_nominal_in_type(k, eq_helpers, type_registry);
+            register_nominal_in_type(v, eq_helpers, type_registry);
+        }
+        AverType::Tuple(items) => {
+            for item in items {
+                register_nominal_in_type(item, eq_helpers, type_registry);
+            }
+        }
+        _ => {}
+    }
+}
+
 fn discover_builtins_in_expr(
     expr: &Expr,
     builtins: &mut BuiltinRegistry,
@@ -1271,6 +1323,16 @@ fn discover_builtins_in_expr(
                     eq_helpers.register_transitive(name, EqKind::Sum, type_registry);
                 }
             }
+            // List / Vector / Map / Option / Result / Tuple `==` —
+            // dispatch reaches the per-element/key __eq_<X> through
+            // the helper bodies, so any nominal element type also
+            // needs an __eq slot. Walk the operand type recursively
+            // and register every nominal we hit.
+            if matches!(op, Op::Eq | Op::Neq)
+                && let Some(t) = l.ty()
+            {
+                register_nominal_in_type(t, eq_helpers, type_registry);
+            }
             discover_builtins_in_expr(&l.node, builtins, effects, eq_helpers, type_registry);
             discover_builtins_in_expr(&r.node, builtins, effects, eq_helpers, type_registry);
         }

From 40eba21241da370849bc6a6b85df432d2acb0e34 Mon Sep 17 00:00:00 2001
From: jasisz <jasisz@gmail.com>
Date: Wed, 6 May 2026 15:19:36 +0200
Subject: [PATCH 08/18] 0.16.3: register_transitive guard + collection seed
 sweep
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

The previous "lift nominal eq cap" change tripped the rogue
playground test because:

- `record Entity { something: Option<Point>, ... }`. My new
  `record_fields_resolvable` accepted Entity (Point itself is
  primitive-fielded so it resolved), so `list_eq_kind("Entity")`
  returned `Some(RecordEq("Entity"))` and a `List<Entity>` got
  contains/eq/hash slots.
- Discovery's nominal seed sweep (also new) walked the registered
  list element types and registered `__eq_Entity` transitively.
  `register_field_type` for "Option<Point>" silently skipped (it's
  not a primitive, record, or sum), so Entity got registered but
  Option<Point> didn't — and `emit_record_eq_inline`'s field
  dispatch later panicked.

Two complementary fixes:

- `register_transitive` now precomputes whether the type's fields
  are resolvable via `lists::record_fields_resolvable` /
  `sum_fields_resolvable` before registering. If any field type is
  a generic carrier (Option / Result / List / etc.) the registration
  is skipped — same gate `list_eq_kind` uses, so the two stay in
  sync.
- `field_type_resolvable` rejects any field name containing `<`
  (i.e. any generic carrier) outright. The inline eq emitters
  don't have a dispatch for these yet — that's followup F.

Net: rogue compile_multi_file_rogue_from_virtual_fs passes again,
and List<Entity>-style shapes simply don't get a list contains/eq/
hash slot (programs holding such lists still compile, they just
can't compare lists or call .contains on them — same conservative
fallback as before this PR).

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>
---
 src/codegen/wasm_gc/body/eq_helpers.rs | 18 +++++++++++++
 src/codegen/wasm_gc/lists.rs           | 18 ++++++++++---
 src/codegen/wasm_gc/module.rs          | 37 ++++++++++++++++++++++++++
 3 files changed, 70 insertions(+), 3 deletions(-)

diff --git a/src/codegen/wasm_gc/body/eq_helpers.rs b/src/codegen/wasm_gc/body/eq_helpers.rs
index 84aaa200..8bf51881 100644
--- a/src/codegen/wasm_gc/body/eq_helpers.rs
+++ b/src/codegen/wasm_gc/body/eq_helpers.rs
@@ -84,6 +84,24 @@ impl EqHelperRegistry {
         if self.kinds.contains_key(type_name) {
             return;
         }
+        // Skip nominal types whose fields contain generic carriers
+        // (Option<…>, List<…>, etc.) the inline eq emitter doesn't
+        // handle yet. Without this guard, `register_field_type`
+        // silently dropped the unsupported field and the helper body
+        // emit later panicked with "no eq dispatch" — same error the
+        // surrounding sweep is trying to prevent.
+        let mut seen = std::collections::HashSet::new();
+        let resolvable = match kind {
+            EqKind::Record => super::super::lists::record_fields_resolvable(
+                type_name, registry, &mut seen,
+            ),
+            EqKind::Sum => {
+                super::super::lists::sum_fields_resolvable(type_name, registry, &mut seen)
+            }
+        };
+        if !resolvable {
+            return;
+        }
         self.register(type_name, kind);
         // Walk fields and recurse on nominal types.
         match kind {
diff --git a/src/codegen/wasm_gc/lists.rs b/src/codegen/wasm_gc/lists.rs
index 91cfba3e..3de139fb 100644
--- a/src/codegen/wasm_gc/lists.rs
+++ b/src/codegen/wasm_gc/lists.rs
@@ -739,7 +739,7 @@ fn list_eq_kind(elem: &str, registry: &TypeRegistry) -> Option<ListEqKind> {
 /// emitters can dispatch: primitive, a registered record/sum
 /// (recursively resolvable), or self-recursion. Cycles terminate
 /// via the `seen` set.
-fn record_fields_resolvable(
+pub(super) fn record_fields_resolvable(
     record: &str,
     registry: &TypeRegistry,
     seen: &mut std::collections::HashSet<String>,
@@ -755,7 +755,7 @@ fn record_fields_resolvable(
         .all(|(_, t)| field_type_resolvable(t.trim(), registry, seen))
 }
 
-fn sum_fields_resolvable(
+pub(super) fn sum_fields_resolvable(
     parent: &str,
     registry: &TypeRegistry,
     seen: &mut std::collections::HashSet<String>,
@@ -775,11 +775,23 @@ fn sum_fields_resolvable(
         })
 }
 
-fn field_type_resolvable(
+pub(super) fn field_type_resolvable(
     field: &str,
     registry: &TypeRegistry,
     seen: &mut std::collections::HashSet<String>,
 ) -> bool {
+    // Conservative: reject any generic carrier (`Option<…>`,
+    // `Result<…,…>`, `List<…>`, `Vector<…>`, `Map<…,…>`,
+    // `Tuple<…>`) as a field type. The inline eq emitters don't
+    // know how to dispatch eq for these — that's its own ABI
+    // path (Option tag-and-compare, Result variant tags, etc.).
+    // Programs that hold a record with such a field still work,
+    // they just don't get list-eq / map-key / contains-on-list
+    // slots emitted for the outer type. Lifting this is its own
+    // followup.
+    if field.contains('<') {
+        return false;
+    }
     matches!(field, "Int" | "Float" | "Bool" | "String")
         || (registry.record_type_idx(field).is_some()
             && record_fields_resolvable(field, registry, seen))
diff --git a/src/codegen/wasm_gc/module.rs b/src/codegen/wasm_gc/module.rs
index 42496054..7583d3d8 100644
--- a/src/codegen/wasm_gc/module.rs
+++ b/src/codegen/wasm_gc/module.rs
@@ -75,6 +75,43 @@ pub(super) fn emit_module(
             &registry,
         );
     }
+    // Sweep nominal element types of every registered List / Vector
+    // and key types of every registered Map. The list/vec helper
+    // bodies dispatch nominal element eq/hash via `Call(__eq_<X>)`
+    // (since 0.16.3); without auto-registering those types here, a
+    // program that holds `List<Item>` without ever writing
+    // `list == list` directly would still get a list helper body
+    // that calls into an unregistered `__eq_Item`. Keys of `Map<K,_>`
+    // need the same: maps.rs `emit_eq_for(K)` reaches into
+    // `__eq_<X>` helpers when K is a record/sum field-of-field.
+    let mut nominal_seed: Vec<String> = Vec::new();
+    for canonical in &registry.list_order {
+        if let Some(elem) = super::types::TypeRegistry::list_element_type(canonical) {
+            nominal_seed.push(elem.trim().to_string());
+        }
+    }
+    for canonical in &registry.vector_order {
+        if let Some(elem) = super::types::TypeRegistry::vector_element_type(canonical) {
+            nominal_seed.push(elem.trim().to_string());
+        }
+    }
+    for canonical in &registry.map_order {
+        if let Some((k, _v)) = super::types::parse_map_kv(canonical) {
+            nominal_seed.push(k.trim().to_string());
+        }
+    }
+    for name in &nominal_seed {
+        if registry.record_fields.contains_key(name) {
+            eq_helpers_registry.register_transitive(name, EqKind::Record, &registry);
+        } else if registry
+            .variants
+            .values()
+            .flat_map(|v| v.iter())
+            .any(|v| &v.parent == name)
+        {
+            eq_helpers_registry.register_transitive(name, EqKind::Sum, &registry);
+        }
+    }
     // Eq helpers over records / sums with String fields need
     // `__wasmgc_string_eq` — force-register so the slot is allocated
     // before bodies emit.

From bf521d36fe462074f9ab4288461b31ae22a4407e Mon Sep 17 00:00:00 2001
From: jasisz <jasisz@gmail.com>
Date: Wed, 6 May 2026 16:00:40 +0200
Subject: [PATCH 09/18] =?UTF-8?q?0.16.3:=20bug=20F=20+=20G=20=E2=80=94=20O?=
 =?UTF-8?q?ption/Result/Tuple=20eq=20+=20carrier=20dispatch?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Two stress-tests from the user's "popierdolone scenariusze" set
landed real holes that bugs 1-3+5 hadn't covered:

- F2: `record Person { name: String, age: Option<Int> }` then
  `a == b`. Discovery walker registered `__eq_Person` but
  `register_field_type` silently dropped the `Option<Int>` field
  because it wasn't a primitive / record / sum. Helper body emit
  later panicked: `record Person field type Option<Int> has no
  eq dispatch`.
- G: `let a: Result<Box, Color> = Result.Ok(Box(val=5))` then
  `a == b`. Two cascading misses:
  - `Result<Box, Color>` wasn't even registered in the type
    section because the discovery walker for Result canonicals
    only scanned fn signatures + builtin uses, not let-binding
    annotations.
  - Even after registration, `body/emit.rs::sum_or_record_eq_fn`
    matched `Type::Named` only — `Type::Result(_,_)` /
    `Type::Option(_)` / `Type::Tuple(_)` operands fell through to
    the default `i64.eq` arm.
  - Inner `Box` field eq dispatched through the helper map,
    but Box is newtype-erased to i64 — helper signature is
    `(eqref, eqref)` so the validator caught the type mismatch.

## Fix

- `EqHelperRegistry` grows three new kinds — `OptionEq`,
  `ResultEq`, `TupleEq`. Each instantiation gets its own helper
  slot keyed by the canonical string (`"Option<Int>"`,
  `"Result<Box,Color>"`, `"Tuple<Int,String>"`).
- `register_field_type` now recognises `Option<…>`, `Result<…,…>`,
  `Tuple<…>` field types: registers the carrier helper, then
  recurses on inner types so any nominal piece (e.g. `Option<Color>`
  → register `Color`) gets its slot too.
- `register_transitive` for carrier kinds skips the
  `record_fields_resolvable` gate (carriers have one fixed shape;
  inner-resolvability is tracked at the parent's
  `field_type_resolvable` level).
- `lists.rs::field_type_resolvable` accepts carriers iff every
  inner is resolvable — same recursive shape it already used for
  Record/Sum.
- `eq_helpers.rs` grows three body emitters:
  - `emit_option_eq_body`: cast both eqref → typed Option ref,
    compare tags; differ → 0; both 0 (None) → 1; both 1 (Some) →
    inner eq via `emit_inner_eq_dispatch`.
  - `emit_result_eq_body`: same shape; tag=1 (Ok) → field 1 eq;
    tag=0 (Err) → field 2 eq.
  - `emit_tuple_eq_body`: per-field eq, AND-fold across all
    elements.
- `emit_inner_eq_dispatch` resolves `newtype_underlying` before
  dispatching — `Box(n: Int)` reaches as "Box" but lowers to i64,
  so the primitive arm fires (helper map miss avoided).
- `body/emit.rs::sum_or_record_eq_fn` now matches `Type::Option` /
  `Type::Result` / `Type::Tuple` and looks up the helper via the
  whitespace-stripped canonical (`fn_map.eq_helpers["Result<Box,
  Color>"]`).
- `module.rs::register_nominal_in_type` registers the outer
  carrier canonical (so `==` on a `Result<…>` operand directly
  flags `__eq_Result<X,Y>`), then recurses on inner types.
- `types.rs::TypeRegistry::build` walks let-binding annotations
  for Result canonicals, mirroring what the Option/Vector/List
  body walkers were already doing.
- `parse_result_kv` / `parse_tuple_elems` helpers in
  `eq_helpers.rs` — depth-aware comma split so
  `Result<Map<K,V>, MyError>` and `Tuple<Int, Result<…>>` parse
  right.

## Verified

- A: `record Item { name: String, color: Color }` ==. Match VM.
- B: `type Cell = Empty | Filled(Pos)` with `record Pos`. Match VM.
- C: mutually recursive `type A`/`type B`. Match VM.
- D: `List<Tree> == List<Tree>` — still falls through to default
  arm since BinOp::Eq dispatch for `Type::List` requires a
  separate path. Documented as followup.
- F2: `record Person { age: Option<Int> }` ==. Match VM.
- G: `Result<Box, Color>` ==. Match VM (both Ok and Err arms).
- H: `record Move { via: Option<Pos> }` (carrier holding nominal).
  Match VM.
- bugs 1, 2, 3, 5 still pass.
- 1100+ unit tests pass; 10/10 wasm-gc record-replay smokes;
  rogue compile_multi_file test still green; flaky
  buffer_build_pass test passed on retry (pre-existing
  non-determinism, unrelated).

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>
---
 src/codegen/wasm_gc/body/emit.rs       |  48 ++--
 src/codegen/wasm_gc/body/eq_helpers.rs | 359 ++++++++++++++++++++++++-
 src/codegen/wasm_gc/lists.rs           |  78 ++++--
 src/codegen/wasm_gc/module.rs          |  19 +-
 src/codegen/wasm_gc/types.rs           |  17 ++
 5 files changed, 467 insertions(+), 54 deletions(-)

diff --git a/src/codegen/wasm_gc/body/emit.rs b/src/codegen/wasm_gc/body/emit.rs
index 924b6f87..dfe7c30b 100644
--- a/src/codegen/wasm_gc/body/emit.rs
+++ b/src/codegen/wasm_gc/body/emit.rs
@@ -556,25 +556,37 @@ pub(super) fn emit_expr(
 /// type mismatch.
 fn sum_or_record_eq_fn(operand: &Spanned<Expr>, ctx: &EmitCtx<'_>) -> Option<u32> {
     let ty = operand.ty()?;
-    let crate::types::Type::Named(name) = ty else {
-        return None;
-    };
-    // Newtypes already lower to their underlying primitive — no helper
-    // needed (the default i64/f64 eq handles them).
-    if ctx.registry.newtype_underlying(name).is_some() {
-        return None;
+    match ty {
+        crate::types::Type::Named(name) => {
+            // Newtypes already lower to their underlying primitive —
+            // no helper needed (the default i64/f64 eq handles them).
+            if ctx.registry.newtype_underlying(name).is_some() {
+                return None;
+            }
+            let is_record = ctx.registry.record_fields.contains_key(name);
+            let is_sum = ctx
+                .registry
+                .variants
+                .values()
+                .flat_map(|v| v.iter())
+                .any(|v| &v.parent == name);
+            if !is_record && !is_sum {
+                return None;
+            }
+            ctx.fn_map.eq_helpers.get(name).copied()
+        }
+        // Generic carriers — `Option<X>`, `Result<X,Y>`, `Tuple<…>`
+        // have per-instantiation `__eq_<canonical>` helpers since
+        // 0.16.3. Lookup by the type's display canonical (whitespace-
+        // free, matching how the discovery walker registered it).
+        crate::types::Type::Option(_)
+        | crate::types::Type::Result(_, _)
+        | crate::types::Type::Tuple(_) => {
+            let canonical: String = ty.display().chars().filter(|c| !c.is_whitespace()).collect();
+            ctx.fn_map.eq_helpers.get(&canonical).copied()
+        }
+        _ => None,
     }
-    let is_record = ctx.registry.record_fields.contains_key(name);
-    let is_sum = ctx
-        .registry
-        .variants
-        .values()
-        .flat_map(|v| v.iter())
-        .any(|v| &v.parent == name);
-    if !is_record && !is_sum {
-        return None;
-    }
-    ctx.fn_map.eq_helpers.get(name).copied()
 }
 
 fn nullary_variant_idx(expr: &Spanned<Expr>, ctx: &EmitCtx<'_>) -> Option<u32> {
diff --git a/src/codegen/wasm_gc/body/eq_helpers.rs b/src/codegen/wasm_gc/body/eq_helpers.rs
index 8bf51881..2cfbaa64 100644
--- a/src/codegen/wasm_gc/body/eq_helpers.rs
+++ b/src/codegen/wasm_gc/body/eq_helpers.rs
@@ -36,11 +36,19 @@ use super::super::WasmGcError;
 use super::super::lists::{emit_record_eq_inline, emit_sum_eq_inline};
 use super::super::types::TypeRegistry;
 
-/// What kind of nominal type a registered eq helper covers.
+/// What kind of type a registered eq helper covers. Records and
+/// sums are nominal (registry name = type name). The generic-
+/// carrier kinds (Option / Result / Tuple) carry their canonical
+/// instantiation string as the registry name (e.g. `"Option<Int>"`,
+/// `"Result<Int,String>"`, `"Tuple<Int,String>"`) — one helper slot
+/// per concrete inner shape.
 #[derive(Debug, Clone, Copy, PartialEq, Eq)]
 pub(crate) enum EqKind {
     Record,
     Sum,
+    OptionEq,
+    ResultEq,
+    TupleEq,
 }
 
 /// Per-module registry of `__eq_<TypeName>` helpers needed by
@@ -84,12 +92,13 @@ impl EqHelperRegistry {
         if self.kinds.contains_key(type_name) {
             return;
         }
-        // Skip nominal types whose fields contain generic carriers
-        // (Option<…>, List<…>, etc.) the inline eq emitter doesn't
-        // handle yet. Without this guard, `register_field_type`
-        // silently dropped the unsupported field and the helper body
-        // emit later panicked with "no eq dispatch" — same error the
-        // surrounding sweep is trying to prevent.
+        // Skip nominal types whose fields contain unhandled shapes
+        // (List/Map/Vector/Set inside fields — the inline eq emitter
+        // covers Option/Result/Tuple via per-instantiation helpers
+        // registered alongside the parent below). Without this guard
+        // `register_field_type` silently dropped the unsupported
+        // field and the helper body emit later panicked with "no eq
+        // dispatch".
         let mut seen = std::collections::HashSet::new();
         let resolvable = match kind {
             EqKind::Record => super::super::lists::record_fields_resolvable(
@@ -98,6 +107,10 @@ impl EqHelperRegistry {
             EqKind::Sum => {
                 super::super::lists::sum_fields_resolvable(type_name, registry, &mut seen)
             }
+            // Carrier kinds — Option<X>/Result/Tuple have one
+            // shape regardless of inner; resolvability is checked at
+            // the record/sum level via `field_type_resolvable`.
+            EqKind::OptionEq | EqKind::ResultEq | EqKind::TupleEq => true,
         };
         if !resolvable {
             return;
@@ -126,28 +139,60 @@ impl EqHelperRegistry {
                     }
                 }
             }
+            // Carrier kinds — inner-type registration is handled by
+            // the surrounding `register_field_type` arm that decides
+            // to register the carrier in the first place. Nothing
+            // extra to walk here (the helper body inspects the
+            // canonical at emit time via `option_element_type` /
+            // `parse_result_kv` / `parse_tuple_elems`).
+            EqKind::OptionEq | EqKind::ResultEq | EqKind::TupleEq => {}
         }
     }
 
     fn register_field_type(&mut self, field_ty: &str, registry: &TypeRegistry) {
-        // Skip primitives and compound carriers (List/Map/Vector/
-        // Option/Result handle their own dispatch).
         if matches!(field_ty, "Int" | "Float" | "Bool" | "String" | "Unit" | "Byte" | "Char") {
             return;
         }
         if registry.record_fields.contains_key(field_ty) {
             self.register_transitive(field_ty, EqKind::Record, registry);
-        } else if registry
+            return;
+        }
+        if registry
             .variants
             .values()
             .flat_map(|v| v.iter())
             .any(|v| v.parent == field_ty)
         {
             self.register_transitive(field_ty, EqKind::Sum, registry);
+            return;
+        }
+        // Generic carriers — `Option<X>`, `Result<X,Y>`, `Tuple<…>`.
+        // Each instantiation gets its own helper slot keyed by the
+        // canonical string. Inner types are walked too so any
+        // nominal piece (`Option<Color>` → register Color).
+        if let Some(inner) = field_ty.strip_prefix("Option<").and_then(|s| s.strip_suffix('>')) {
+            self.register_transitive(field_ty, EqKind::OptionEq, registry);
+            self.register_field_type(inner.trim(), registry);
+        } else if field_ty.starts_with("Result<") && field_ty.ends_with('>') {
+            self.register_transitive(field_ty, EqKind::ResultEq, registry);
+            if let Some((ok, err)) = parse_result_kv(field_ty) {
+                self.register_field_type(ok.trim(), registry);
+                self.register_field_type(err.trim(), registry);
+            }
+        } else if field_ty.starts_with("Tuple<") && field_ty.ends_with('>') {
+            self.register_transitive(field_ty, EqKind::TupleEq, registry);
+            if let Some(elems) = parse_tuple_elems(field_ty) {
+                for elem in elems {
+                    self.register_field_type(elem.trim(), registry);
+                }
+            }
         }
-        // Other shapes (List<T>, Map<K, V>, generics) — out of
-        // scope for nominal eq dispatch today; leave them to fail
-        // loudly in the inline emitter so we know to extend.
+        // List<T>, Vector<T>, Map<K,V> — those have their own
+        // helper machinery (list_helpers/map_helpers fn idxs).
+        // BinOp::Eq dispatch on collections is covered by the
+        // separate body/emit.rs path; field-of-record holding a
+        // collection still falls through here. Followup if real
+        // programs surface it.
     }
 
     pub(crate) fn iter(&self) -> impl Iterator<Item = (&str, EqKind)> + '_ {
@@ -269,6 +314,33 @@ impl EqHelperRegistry {
                     f.instruction(&Instruction::End);
                     codes.function(&f);
                 }
+                EqKind::OptionEq => {
+                    let f = emit_option_eq_body(
+                        name,
+                        registry,
+                        string_eq_fn_idx,
+                        &helper_idx_map,
+                    )?;
+                    codes.function(&f);
+                }
+                EqKind::ResultEq => {
+                    let f = emit_result_eq_body(
+                        name,
+                        registry,
+                        string_eq_fn_idx,
+                        &helper_idx_map,
+                    )?;
+                    codes.function(&f);
+                }
+                EqKind::TupleEq => {
+                    let f = emit_tuple_eq_body(
+                        name,
+                        registry,
+                        string_eq_fn_idx,
+                        &helper_idx_map,
+                    )?;
+                    codes.function(&f);
+                }
             }
         }
         Ok(())
@@ -288,6 +360,261 @@ impl EqHelperRegistry {
     }
 }
 
+/// `Result<Ok, Err>` → `Some(("Ok", "Err"))`. Tracks angle/paren
+/// depth so `Result<Map<K,V>, MyError>` splits at the right comma.
+fn parse_result_kv(canonical: &str) -> Option<(&str, &str)> {
+    let inner = canonical.trim().strip_prefix("Result<")?.strip_suffix('>')?;
+    let bytes = inner.as_bytes();
+    let mut depth: i32 = 0;
+    for (idx, b) in bytes.iter().enumerate() {
+        match b {
+            b'<' | b'(' => depth += 1,
+            b'>' | b')' => depth -= 1,
+            b',' if depth == 0 => {
+                return Some((inner[..idx].trim(), inner[idx + 1..].trim()));
+            }
+            _ => {}
+        }
+    }
+    None
+}
+
+/// `Tuple<A, B, C>` → `Some(vec!["A", "B", "C"])`. Same depth-aware
+/// split as `parse_result_kv`.
+fn parse_tuple_elems(canonical: &str) -> Option<Vec<&str>> {
+    let inner = canonical.trim().strip_prefix("Tuple<")?.strip_suffix('>')?;
+    let bytes = inner.as_bytes();
+    let mut depth: i32 = 0;
+    let mut start = 0;
+    let mut out = Vec::new();
+    for (idx, b) in bytes.iter().enumerate() {
+        match b {
+            b'<' | b'(' => depth += 1,
+            b'>' | b')' => depth -= 1,
+            b',' if depth == 0 => {
+                out.push(inner[start..idx].trim());
+                start = idx + 1;
+            }
+            _ => {}
+        }
+    }
+    out.push(inner[start..].trim());
+    Some(out)
+}
+
+/// Emit `(eqref, eqref) -> i32` body for `Option<X>`. Layout:
+/// `(struct (mut i32 tag) (mut X value))`, tag=0 None, tag=1 Some.
+/// Compare tags first; if differ → 0; if both 0 → 1; if both 1 →
+/// inner eq.
+fn emit_option_eq_body(
+    canonical: &str,
+    registry: &TypeRegistry,
+    string_eq_fn_idx: Option<u32>,
+    helper_idx_map: &HashMap<String, u32>,
+) -> Result<Function, WasmGcError> {
+    let opt_idx = registry.option_type_idx(canonical).ok_or(
+        WasmGcError::Validation(format!("eq helper for `{canonical}`: option not registered")),
+    )?;
+    let inner = TypeRegistry::option_element_type(canonical).ok_or(
+        WasmGcError::Validation(format!("eq helper for `{canonical}`: can't parse inner")),
+    )?;
+    let opt_ref = wasm_encoder::ValType::Ref(wasm_encoder::RefType {
+        nullable: true,
+        heap_type: wasm_encoder::HeapType::Concrete(opt_idx),
+    });
+    let mut f = Function::new(vec![(2, opt_ref)]);
+    let opt_heap = wasm_encoder::HeapType::Concrete(opt_idx);
+    // Cast both eqref params → typed Option ref into locals 2, 3.
+    f.instruction(&Instruction::LocalGet(0));
+    f.instruction(&Instruction::RefCastNonNull(opt_heap));
+    f.instruction(&Instruction::LocalSet(2));
+    f.instruction(&Instruction::LocalGet(1));
+    f.instruction(&Instruction::RefCastNonNull(opt_heap));
+    f.instruction(&Instruction::LocalSet(3));
+    // if tag(lhs) != tag(rhs) → return 0
+    f.instruction(&Instruction::LocalGet(2));
+    f.instruction(&Instruction::StructGet { struct_type_index: opt_idx, field_index: 0 });
+    f.instruction(&Instruction::LocalGet(3));
+    f.instruction(&Instruction::StructGet { struct_type_index: opt_idx, field_index: 0 });
+    f.instruction(&Instruction::I32Ne);
+    f.instruction(&Instruction::If(wasm_encoder::BlockType::Empty));
+    f.instruction(&Instruction::I32Const(0));
+    f.instruction(&Instruction::Return);
+    f.instruction(&Instruction::End);
+    // tags equal — if 0 (None), return 1
+    f.instruction(&Instruction::LocalGet(2));
+    f.instruction(&Instruction::StructGet { struct_type_index: opt_idx, field_index: 0 });
+    f.instruction(&Instruction::I32Eqz);
+    f.instruction(&Instruction::If(wasm_encoder::BlockType::Empty));
+    f.instruction(&Instruction::I32Const(1));
+    f.instruction(&Instruction::Return);
+    f.instruction(&Instruction::End);
+    // Both Some — compare inner via per-type dispatch.
+    f.instruction(&Instruction::LocalGet(2));
+    f.instruction(&Instruction::StructGet { struct_type_index: opt_idx, field_index: 1 });
+    f.instruction(&Instruction::LocalGet(3));
+    f.instruction(&Instruction::StructGet { struct_type_index: opt_idx, field_index: 1 });
+    emit_inner_eq_dispatch(&mut f, inner.trim(), registry, string_eq_fn_idx, helper_idx_map)?;
+    f.instruction(&Instruction::End);
+    Ok(f)
+}
+
+/// Emit `(eqref, eqref) -> i32` body for `Result<X, Y>`. Layout:
+/// `(struct (mut i32 tag) (mut X ok) (mut Y err))`, tag=0 Err,
+/// tag=1 Ok. Compare tags; if differ → 0; both 0 → err eq;
+/// both 1 → ok eq.
+fn emit_result_eq_body(
+    canonical: &str,
+    registry: &TypeRegistry,
+    string_eq_fn_idx: Option<u32>,
+    helper_idx_map: &HashMap<String, u32>,
+) -> Result<Function, WasmGcError> {
+    let res_idx = registry.result_type_idx(canonical).ok_or(
+        WasmGcError::Validation(format!("eq helper for `{canonical}`: result not registered")),
+    )?;
+    let (ok_inner, err_inner) = parse_result_kv(canonical).ok_or(
+        WasmGcError::Validation(format!("eq helper for `{canonical}`: can't parse inner")),
+    )?;
+    let res_ref = wasm_encoder::ValType::Ref(wasm_encoder::RefType {
+        nullable: true,
+        heap_type: wasm_encoder::HeapType::Concrete(res_idx),
+    });
+    let mut f = Function::new(vec![(2, res_ref)]);
+    let res_heap = wasm_encoder::HeapType::Concrete(res_idx);
+    f.instruction(&Instruction::LocalGet(0));
+    f.instruction(&Instruction::RefCastNonNull(res_heap));
+    f.instruction(&Instruction::LocalSet(2));
+    f.instruction(&Instruction::LocalGet(1));
+    f.instruction(&Instruction::RefCastNonNull(res_heap));
+    f.instruction(&Instruction::LocalSet(3));
+    // if tag(lhs) != tag(rhs) → 0
+    f.instruction(&Instruction::LocalGet(2));
+    f.instruction(&Instruction::StructGet { struct_type_index: res_idx, field_index: 0 });
+    f.instruction(&Instruction::LocalGet(3));
+    f.instruction(&Instruction::StructGet { struct_type_index: res_idx, field_index: 0 });
+    f.instruction(&Instruction::I32Ne);
+    f.instruction(&Instruction::If(wasm_encoder::BlockType::Empty));
+    f.instruction(&Instruction::I32Const(0));
+    f.instruction(&Instruction::Return);
+    f.instruction(&Instruction::End);
+    // tags equal — branch on tag value: tag=1 (Ok) → field 1 eq;
+    // tag=0 (Err) → field 2 eq.
+    f.instruction(&Instruction::LocalGet(2));
+    f.instruction(&Instruction::StructGet { struct_type_index: res_idx, field_index: 0 });
+    f.instruction(&Instruction::If(wasm_encoder::BlockType::Result(wasm_encoder::ValType::I32)));
+    // Ok arm
+    f.instruction(&Instruction::LocalGet(2));
+    f.instruction(&Instruction::StructGet { struct_type_index: res_idx, field_index: 1 });
+    f.instruction(&Instruction::LocalGet(3));
+    f.instruction(&Instruction::StructGet { struct_type_index: res_idx, field_index: 1 });
+    emit_inner_eq_dispatch(&mut f, ok_inner.trim(), registry, string_eq_fn_idx, helper_idx_map)?;
+    f.instruction(&Instruction::Else);
+    // Err arm
+    f.instruction(&Instruction::LocalGet(2));
+    f.instruction(&Instruction::StructGet { struct_type_index: res_idx, field_index: 2 });
+    f.instruction(&Instruction::LocalGet(3));
+    f.instruction(&Instruction::StructGet { struct_type_index: res_idx, field_index: 2 });
+    emit_inner_eq_dispatch(&mut f, err_inner.trim(), registry, string_eq_fn_idx, helper_idx_map)?;
+    f.instruction(&Instruction::End);
+    f.instruction(&Instruction::End);
+    Ok(f)
+}
+
+/// Emit `(eqref, eqref) -> i32` body for `Tuple<A, B, C, …>`.
+/// Layout: `(struct field0 field1 …)`. Per-element eq, AND-fold.
+fn emit_tuple_eq_body(
+    canonical: &str,
+    registry: &TypeRegistry,
+    string_eq_fn_idx: Option<u32>,
+    helper_idx_map: &HashMap<String, u32>,
+) -> Result<Function, WasmGcError> {
+    let tup_idx = registry.tuple_type_idx(canonical).ok_or(
+        WasmGcError::Validation(format!("eq helper for `{canonical}`: tuple not registered")),
+    )?;
+    let elems = parse_tuple_elems(canonical).ok_or(
+        WasmGcError::Validation(format!("eq helper for `{canonical}`: can't parse elements")),
+    )?;
+    let tup_ref = wasm_encoder::ValType::Ref(wasm_encoder::RefType {
+        nullable: true,
+        heap_type: wasm_encoder::HeapType::Concrete(tup_idx),
+    });
+    let mut f = Function::new(vec![(2, tup_ref)]);
+    let tup_heap = wasm_encoder::HeapType::Concrete(tup_idx);
+    f.instruction(&Instruction::LocalGet(0));
+    f.instruction(&Instruction::RefCastNonNull(tup_heap));
+    f.instruction(&Instruction::LocalSet(2));
+    f.instruction(&Instruction::LocalGet(1));
+    f.instruction(&Instruction::RefCastNonNull(tup_heap));
+    f.instruction(&Instruction::LocalSet(3));
+    for (i, elem) in elems.iter().enumerate() {
+        f.instruction(&Instruction::LocalGet(2));
+        f.instruction(&Instruction::StructGet {
+            struct_type_index: tup_idx,
+            field_index: i as u32,
+        });
+        f.instruction(&Instruction::LocalGet(3));
+        f.instruction(&Instruction::StructGet {
+            struct_type_index: tup_idx,
+            field_index: i as u32,
+        });
+        emit_inner_eq_dispatch(&mut f, elem.trim(), registry, string_eq_fn_idx, helper_idx_map)?;
+        if i > 0 {
+            f.instruction(&Instruction::I32And);
+        }
+    }
+    f.instruction(&Instruction::End);
+    Ok(f)
+}
+
+/// Stack: `[lhs_value, rhs_value]` of `inner` aver type. Push i32
+/// eq verdict. Same shape used by Option's payload, Result's two
+/// arms, Tuple's per-element compares.
+///
+/// Newtype-optimised records (`Box(val: Int)` → i64) are handled
+/// before the helper-map lookup: the actual stack values are the
+/// underlying primitive, so dispatch through the primitive arm.
+fn emit_inner_eq_dispatch(
+    f: &mut Function,
+    inner: &str,
+    registry: &TypeRegistry,
+    string_eq_fn_idx: Option<u32>,
+    helper_idx_map: &HashMap<String, u32>,
+) -> Result<(), WasmGcError> {
+    // Resolve newtypes — `Box(n: Int)` reaches here as "Box" but
+    // its wasm representation is i64.
+    let resolved: String = if let Some(under) = registry.newtype_underlying(inner) {
+        under.to_string()
+    } else {
+        inner.to_string()
+    };
+    match resolved.as_str() {
+        "Int" => {
+            f.instruction(&Instruction::I64Eq);
+        }
+        "Bool" => {
+            f.instruction(&Instruction::I32Eq);
+        }
+        "Float" => {
+            f.instruction(&Instruction::F64Eq);
+        }
+        "String" => {
+            let eq_fn = string_eq_fn_idx.ok_or(WasmGcError::Validation(
+                "carrier eq with String inner needs __wasmgc_string_eq".into(),
+            ))?;
+            f.instruction(&Instruction::Call(eq_fn));
+        }
+        other if helper_idx_map.contains_key(other) => {
+            f.instruction(&Instruction::Call(helper_idx_map[other]));
+        }
+        other => {
+            return Err(WasmGcError::Validation(format!(
+                "carrier eq inner type `{other}` has no eq dispatch"
+            )));
+        }
+    }
+    Ok(())
+}
+
 fn type_has_string_field(
     name: &str,
     kind: EqKind,
@@ -309,5 +636,11 @@ fn type_has_string_field(
             .flat_map(|vs| vs.iter())
             .filter(|v| v.parent == name)
             .any(|v| v.fields.iter().any(|t| t.trim() == "String")),
+        // Option<X>/Result<X,Y>/Tuple<…> — check whether any inner
+        // type is `String`. Cheap string match on the canonical
+        // (e.g. `"Option<String>"` contains `"String"`); accurate
+        // enough since we just need to force-register
+        // `__wasmgc_string_eq` when it might be called.
+        EqKind::OptionEq | EqKind::ResultEq | EqKind::TupleEq => name.contains("String"),
     }
 }
diff --git a/src/codegen/wasm_gc/lists.rs b/src/codegen/wasm_gc/lists.rs
index 3de139fb..70818769 100644
--- a/src/codegen/wasm_gc/lists.rs
+++ b/src/codegen/wasm_gc/lists.rs
@@ -780,27 +780,67 @@ pub(super) fn field_type_resolvable(
     registry: &TypeRegistry,
     seen: &mut std::collections::HashSet<String>,
 ) -> bool {
-    // Conservative: reject any generic carrier (`Option<…>`,
-    // `Result<…,…>`, `List<…>`, `Vector<…>`, `Map<…,…>`,
-    // `Tuple<…>`) as a field type. The inline eq emitters don't
-    // know how to dispatch eq for these — that's its own ABI
-    // path (Option tag-and-compare, Result variant tags, etc.).
-    // Programs that hold a record with such a field still work,
-    // they just don't get list-eq / map-key / contains-on-list
-    // slots emitted for the outer type. Lifting this is its own
-    // followup.
-    if field.contains('<') {
+    if matches!(field, "Int" | "Float" | "Bool" | "String") {
+        return true;
+    }
+    if registry.record_type_idx(field).is_some() {
+        return record_fields_resolvable(field, registry, seen);
+    }
+    if registry
+        .variants
+        .values()
+        .flat_map(|vs| vs.iter())
+        .any(|v| v.parent == field)
+    {
+        return sum_fields_resolvable(field, registry, seen);
+    }
+    // Generic carriers — `Option<X>`, `Result<X,Y>`, `Tuple<…>` get
+    // per-instantiation `__eq_<canonical>` helpers since 0.16.3.
+    // Resolvable iff every inner type is itself resolvable.
+    // List/Vector/Map field types still fall through (their dispatch
+    // from `emit_record_eq_inline` is a separate followup).
+    if let Some(inner) = field.strip_prefix("Option<").and_then(|s| s.strip_suffix('>')) {
+        return field_type_resolvable(inner.trim(), registry, seen);
+    }
+    if let Some(inner) = field.strip_prefix("Result<").and_then(|s| s.strip_suffix('>')) {
+        let bytes = inner.as_bytes();
+        let mut depth: i32 = 0;
+        for (idx, b) in bytes.iter().enumerate() {
+            match b {
+                b'<' | b'(' => depth += 1,
+                b'>' | b')' => depth -= 1,
+                b',' if depth == 0 => {
+                    let ok = inner[..idx].trim();
+                    let err = inner[idx + 1..].trim();
+                    return field_type_resolvable(ok, registry, seen)
+                        && field_type_resolvable(err, registry, seen);
+                }
+                _ => {}
+            }
+        }
         return false;
     }
-    matches!(field, "Int" | "Float" | "Bool" | "String")
-        || (registry.record_type_idx(field).is_some()
-            && record_fields_resolvable(field, registry, seen))
-        || (registry
-            .variants
-            .values()
-            .flat_map(|vs| vs.iter())
-            .any(|v| v.parent == field)
-            && sum_fields_resolvable(field, registry, seen))
+    if let Some(inner) = field.strip_prefix("Tuple<").and_then(|s| s.strip_suffix('>')) {
+        let bytes = inner.as_bytes();
+        let mut depth: i32 = 0;
+        let mut start = 0;
+        for (idx, b) in bytes.iter().enumerate() {
+            match b {
+                b'<' | b'(' => depth += 1,
+                b'>' | b')' => depth -= 1,
+                b',' if depth == 0 => {
+                    let elem = inner[start..idx].trim();
+                    if !field_type_resolvable(elem, registry, seen) {
+                        return false;
+                    }
+                    start = idx + 1;
+                }
+                _ => {}
+            }
+        }
+        return field_type_resolvable(inner[start..].trim(), registry, seen);
+    }
+    false
 }
 
 fn list_idx_of(canonical: &str, registry: &TypeRegistry) -> Result<u32, WasmGcError> {
diff --git a/src/codegen/wasm_gc/module.rs b/src/codegen/wasm_gc/module.rs
index 7583d3d8..6a4eba79 100644
--- a/src/codegen/wasm_gc/module.rs
+++ b/src/codegen/wasm_gc/module.rs
@@ -1259,6 +1259,7 @@ fn register_nominal_in_type(
     eq_helpers: &mut EqHelperRegistry,
     type_registry: &super::types::TypeRegistry,
 ) {
+    let canonical: String = t.display().chars().filter(|c| !c.is_whitespace()).collect();
     match t {
         AverType::Named(name) => {
             if type_registry.record_fields.contains_key(name) {
@@ -1272,18 +1273,28 @@ fn register_nominal_in_type(
                 eq_helpers.register_transitive(name, EqKind::Sum, type_registry);
             }
         }
-        AverType::List(inner) | AverType::Vector(inner) | AverType::Option(inner) => {
+        AverType::Option(inner) => {
+            eq_helpers.register_transitive(&canonical, EqKind::OptionEq, type_registry);
             register_nominal_in_type(inner, eq_helpers, type_registry);
         }
-        AverType::Map(k, v) | AverType::Result(k, v) => {
-            register_nominal_in_type(k, eq_helpers, type_registry);
-            register_nominal_in_type(v, eq_helpers, type_registry);
+        AverType::Result(ok, err) => {
+            eq_helpers.register_transitive(&canonical, EqKind::ResultEq, type_registry);
+            register_nominal_in_type(ok, eq_helpers, type_registry);
+            register_nominal_in_type(err, eq_helpers, type_registry);
         }
         AverType::Tuple(items) => {
+            eq_helpers.register_transitive(&canonical, EqKind::TupleEq, type_registry);
             for item in items {
                 register_nominal_in_type(item, eq_helpers, type_registry);
             }
         }
+        AverType::List(inner) | AverType::Vector(inner) => {
+            register_nominal_in_type(inner, eq_helpers, type_registry);
+        }
+        AverType::Map(k, v) => {
+            register_nominal_in_type(k, eq_helpers, type_registry);
+            register_nominal_in_type(v, eq_helpers, type_registry);
+        }
         _ => {}
     }
 }
diff --git a/src/codegen/wasm_gc/types.rs b/src/codegen/wasm_gc/types.rs
index 560ea4e2..753a59ef 100644
--- a/src/codegen/wasm_gc/types.rs
+++ b/src/codegen/wasm_gc/types.rs
@@ -315,6 +315,23 @@ impl TypeRegistry {
                     &mut result_order,
                     &mut next_idx,
                 );
+                // Walk binding annotations too — `let r: Result<Box, MyErr> = …`
+                // wouldn't be picked up by the builtin-uses scan (which only
+                // looks at known dotted calls like `Disk.readText`). Without this,
+                // user-typed `Result<custom, custom>` values fail to find their
+                // type slot at construction time.
+                use crate::ast::{FnBody, Stmt};
+                let FnBody::Block(stmts) = fd.body.as_ref();
+                for stmt in stmts {
+                    if let Stmt::Binding(_, Some(annot), _) = stmt {
+                        collect_results_from_str(
+                            annot,
+                            &mut result_types,
+                            &mut result_order,
+                            &mut next_idx,
+                        );
+                    }
+                }
             }
         }
         let mut list_types: HashMap<String, u32> = HashMap::new();

From 9f053a3a27b059ae71a105a1ba9779755a6649b0 Mon Sep 17 00:00:00 2001
From: jasisz <jasisz@gmail.com>
Date: Wed, 6 May 2026 16:49:14 +0200
Subject: [PATCH 10/18] =?UTF-8?q?0.16.3:=20perfect=20hash=20=E2=80=94=20?=
 =?UTF-8?q?=5F=5Fhash=5F<X>=20helpers=20+=20dispatch?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Symmetric counterpart to the eq helpers: per-record / per-sum /
per-carrier `__hash_<X>` helpers replace the drop+0 fallback the
inline hash emitters were using for non-primitive fields.

## Why

`Map<Person, V>` keyed by a record (or any nominal/carrier shape)
wants a deterministic hash so two `Person` values that compare
equal collapse to the same bucket. The old fallback (drop the
field value, contribute 0 to the hash) was correct (eq still
disambiguates the bucket) but degenerate — every value sharing a
primitive prefix mapped to one bucket, lookup degraded to O(n).

## What

- New `body/hash_helpers.rs` registry analogous to
  `body/eq_helpers.rs`. Same shape: register / register_transitive
  / assign_slots / emit_helper_types / emit_helper_bodies. Helper
  signature is `(eqref) -> i32` (single operand vs eq's two).
- Per-kind body emitters in the new module:
  - `emit_record_hash_body`: cast eqref → typed record ref, DJB2
    fold over fields with proper inner dispatch.
  - `emit_sum_hash_body`: ref.test cascade per variant; matched
    arm folds variant `type_idx` (as a stable tag) plus per-
    variant fields.
  - `emit_option_hash_body`: tag fold; if Some, mix inner. Holds
    h in a local across the if-arm so the block body can be
    `BlockType::Empty` (avoids the stack-shape bug an earlier
    `Result(I32)` shape had).
  - `emit_result_hash_body`: same shape; if-arm picks ok-field
    or err-field hash to fold based on tag.
  - `emit_tuple_hash_body`: per-element fold, AND-style.
- `emit_inner_hash_dispatch` mirrors `emit_inner_eq_dispatch`:
  resolves newtypes (`Box(n: Int)` → i64), handles primitives +
  String + nominal/carrier helper map lookup. Fallback on
  unresolved shapes still drops + 0 (collision-tolerant).
- Existing inline emitters (`emit_record_inline_hash` /
  `emit_sum_inline_hash` in `lists.rs`) take a new
  `hash_helper_fn_idx: &HashMap<String, u32>` parameter and
  dispatch non-primitive fields through `Call(__hash_<X>)` instead
  of dropping. Ditto `emit_list_hash` / `emit_vec_hash` and the
  surrounding `ListHelperRegistry::emit_helper_bodies`.
- `module.rs` wires the registry: parallel sweep of the eq
  registry's transitive closure (every type that gets an eq
  helper also gets a hash helper, since list/vec/map helpers
  dispatch both directions). New `FnMap.hash_helpers` for body
  emit lookup.

## Verified

- Bugs 1, 2, 3, 5, A, B, C, D, F, G, H all pass — eq side
  unchanged.
- 1500+ unit tests pass; 10/10 wasm-gc record-replay smokes;
  rogue compile_multi_file_rogue_from_virtual_fs still green.

## What this *doesn't* fix yet

`Map<Person, V>` (where Person carries an Option<Int> field or
similar) still fails because `Map.set` looks up its key helpers
in the per-(K,V) `MapHelperRegistry`, which is a separate sweep
from `EqHelperRegistry` / `HashHelperRegistry`. Discovery for
that registry hasn't been taught about the carrier-resolvable
gate yet — that's a followup. The hash helpers are correctly
emitted; nothing reaches them through the map-key path today.

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>
---
 src/codegen/wasm_gc/body.rs              |   6 +
 src/codegen/wasm_gc/body/emit.rs         |  13 +
 src/codegen/wasm_gc/body/hash_helpers.rs | 615 +++++++++++++++++++++++
 src/codegen/wasm_gc/lists.rs             | 106 ++--
 src/codegen/wasm_gc/module.rs            |  47 ++
 5 files changed, 747 insertions(+), 40 deletions(-)
 create mode 100644 src/codegen/wasm_gc/body/hash_helpers.rs

diff --git a/src/codegen/wasm_gc/body.rs b/src/codegen/wasm_gc/body.rs
index 3a84ecb5..8865d811 100644
--- a/src/codegen/wasm_gc/body.rs
+++ b/src/codegen/wasm_gc/body.rs
@@ -35,6 +35,7 @@ use crate::ir::CallLowerCtx;
 mod builtins;
 mod emit;
 pub(super) mod eq_helpers;
+pub(super) mod hash_helpers;
 mod infer;
 mod slots;
 
@@ -73,6 +74,11 @@ pub(super) struct FnMap {
     /// Per-(record/sum) `__eq_<TypeName>` helpers used by `BinOp::Eq`
     /// / `BinOp::Neq` over nominal types. Key = bare type name.
     pub(super) eq_helpers: std::collections::HashMap<String, u32>,
+    /// Per-type `__hash_<X>` helpers used by record/sum/carrier
+    /// hash bodies for non-primitive field hashing. Symmetric to
+    /// `eq_helpers`. Key = canonical (bare for record/sum,
+    /// whitespace-free instantiation for carriers).
+    pub(super) hash_helpers: std::collections::HashMap<String, u32>,
 }
 
 impl FnMap {
diff --git a/src/codegen/wasm_gc/body/emit.rs b/src/codegen/wasm_gc/body/emit.rs
index dfe7c30b..4a8f04cf 100644
--- a/src/codegen/wasm_gc/body/emit.rs
+++ b/src/codegen/wasm_gc/body/emit.rs
@@ -585,6 +585,19 @@ fn sum_or_record_eq_fn(operand: &Spanned<Expr>, ctx: &EmitCtx<'_>) -> Option<u32
             let canonical: String = ty.display().chars().filter(|c| !c.is_whitespace()).collect();
             ctx.fn_map.eq_helpers.get(&canonical).copied()
         }
+        // List / Vector — list_helpers / vfl_helpers slot the per-T
+        // eq fn at registration time. Dispatch through there. Both
+        // ops carry `eq: Option<u32>` (None when T isn't equality-
+        // resolvable; falls through and the surrounding default i64
+        // arm fails validation, same as before this PR).
+        crate::types::Type::List(_) => {
+            let canonical: String = ty.display().chars().filter(|c| !c.is_whitespace()).collect();
+            ctx.fn_map.list_ops.get(&canonical).and_then(|ops| ops.eq)
+        }
+        crate::types::Type::Vector(_) => {
+            let canonical: String = ty.display().chars().filter(|c| !c.is_whitespace()).collect();
+            ctx.fn_map.vfl_ops.get(&canonical).and_then(|ops| ops.eq)
+        }
         _ => None,
     }
 }
diff --git a/src/codegen/wasm_gc/body/hash_helpers.rs b/src/codegen/wasm_gc/body/hash_helpers.rs
new file mode 100644
index 00000000..a39b249a
--- /dev/null
+++ b/src/codegen/wasm_gc/body/hash_helpers.rs
@@ -0,0 +1,615 @@
+//! Per-record / per-sum / per-carrier hash helpers — the symmetric
+//! counterpart to `eq_helpers.rs` for the hash side of nominal +
+//! generic-carrier dispatch.
+//!
+//! ## Why
+//!
+//! `Map<K, V>` keyed by a record (`Map<Person, …>`) wants a
+//! deterministic hash so two `Person` values that compare equal
+//! collapse to the same bucket. The inline `emit_record_inline_hash`
+//! / `emit_sum_inline_hash` in `lists.rs` previously fell back to
+//! `drop + i32.const 0` for any non-primitive field — correct
+//! (eq still disambiguates the bucket) but degenerate, every value
+//! sharing primitive-prefix maps to one bucket and lookup goes
+//! O(n).
+//!
+//! This module sets up `__hash_<X>` helpers per nominal /
+//! carrier instantiation. Body emit goes through `Call(__hash_<X>)`
+//! for non-primitive field values; the helper itself does the
+//! shape-specific DJB2 fold. Symmetric to how `__eq_<X>` works on
+//! the equality side.
+
+use std::collections::HashMap;
+
+use wasm_encoder::{Function, Instruction};
+
+use super::super::WasmGcError;
+use super::super::types::TypeRegistry;
+
+/// What kind of type a registered hash helper covers. Same shapes
+/// as `EqKind`, separate enum to keep the two registries
+/// independent (a type may want a hash helper without an eq helper
+/// — e.g. `Map<X, V>` registers hash for X without ever forcing
+/// `==` on the surface).
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub(crate) enum HashKind {
+    Record,
+    Sum,
+    OptionHash,
+    ResultHash,
+    TupleHash,
+}
+
+/// Per-module registry of `__hash_<TypeName>` helpers needed for
+/// shape-faithful hashing inside list/vec/map helpers + per-record
+/// / sum / carrier inline hash bodies.
+#[derive(Default)]
+pub(crate) struct HashHelperRegistry {
+    order: Vec<String>,
+    kinds: HashMap<String, HashKind>,
+    /// `type_name -> (wasm_fn_idx, wasm_type_idx)`.
+    slots: HashMap<String, (u32, u32)>,
+}
+
+impl HashHelperRegistry {
+    pub(crate) fn new() -> Self {
+        Self::default()
+    }
+
+    pub(crate) fn register(&mut self, type_name: &str, kind: HashKind) {
+        if !self.kinds.contains_key(type_name) {
+            self.order.push(type_name.to_string());
+            self.kinds.insert(type_name.to_string(), kind);
+        }
+    }
+
+    /// Walk `type_name`'s fields and register `__hash_<X>` for
+    /// every nominal / carrier piece reachable. Mirrors
+    /// `EqHelperRegistry::register_transitive` but for hash; same
+    /// resolvability gate so we don't end up with a registered
+    /// helper whose body can't be emitted (a record holding e.g.
+    /// `List<X>` field — list-as-field hash isn't wired yet).
+    pub(crate) fn register_transitive(
+        &mut self,
+        type_name: &str,
+        kind: HashKind,
+        registry: &TypeRegistry,
+    ) {
+        if self.kinds.contains_key(type_name) {
+            return;
+        }
+        let mut seen = std::collections::HashSet::new();
+        let resolvable = match kind {
+            HashKind::Record => super::super::lists::record_fields_resolvable(
+                type_name, registry, &mut seen,
+            ),
+            HashKind::Sum => {
+                super::super::lists::sum_fields_resolvable(type_name, registry, &mut seen)
+            }
+            HashKind::OptionHash | HashKind::ResultHash | HashKind::TupleHash => true,
+        };
+        if !resolvable {
+            return;
+        }
+        self.register(type_name, kind);
+        match kind {
+            HashKind::Record => {
+                if let Some(fields) = registry.record_fields.get(type_name) {
+                    for (_, field_ty) in fields {
+                        self.register_field_type(field_ty.trim(), registry);
+                    }
+                }
+            }
+            HashKind::Sum => {
+                let variants: Vec<_> = registry
+                    .variants
+                    .values()
+                    .flat_map(|vs| vs.iter())
+                    .filter(|v| v.parent == type_name)
+                    .cloned()
+                    .collect();
+                for v in &variants {
+                    for field_ty in &v.fields {
+                        self.register_field_type(field_ty.trim(), registry);
+                    }
+                }
+            }
+            HashKind::OptionHash | HashKind::ResultHash | HashKind::TupleHash => {}
+        }
+    }
+
+    fn register_field_type(&mut self, field_ty: &str, registry: &TypeRegistry) {
+        if matches!(field_ty, "Int" | "Float" | "Bool" | "String" | "Unit" | "Byte" | "Char") {
+            return;
+        }
+        if registry.record_fields.contains_key(field_ty) {
+            self.register_transitive(field_ty, HashKind::Record, registry);
+            return;
+        }
+        if registry
+            .variants
+            .values()
+            .flat_map(|v| v.iter())
+            .any(|v| v.parent == field_ty)
+        {
+            self.register_transitive(field_ty, HashKind::Sum, registry);
+            return;
+        }
+        if let Some(inner) = field_ty.strip_prefix("Option<").and_then(|s| s.strip_suffix('>')) {
+            self.register_transitive(field_ty, HashKind::OptionHash, registry);
+            self.register_field_type(inner.trim(), registry);
+        } else if field_ty.starts_with("Result<") && field_ty.ends_with('>') {
+            self.register_transitive(field_ty, HashKind::ResultHash, registry);
+            if let Some((ok, err)) = parse_result_kv(field_ty) {
+                self.register_field_type(ok.trim(), registry);
+                self.register_field_type(err.trim(), registry);
+            }
+        } else if field_ty.starts_with("Tuple<") && field_ty.ends_with('>') {
+            self.register_transitive(field_ty, HashKind::TupleHash, registry);
+            if let Some(elems) = parse_tuple_elems(field_ty) {
+                for elem in elems {
+                    self.register_field_type(elem.trim(), registry);
+                }
+            }
+        }
+    }
+
+    pub(crate) fn iter(&self) -> impl Iterator<Item = (&str, HashKind)> + '_ {
+        self.order.iter().map(|n| (n.as_str(), self.kinds[n]))
+    }
+
+    pub(crate) fn assign_slots(&mut self, next_fn_idx: &mut u32, next_type_idx: &mut u32) {
+        for name in &self.order {
+            self.slots
+                .insert(name.clone(), (*next_fn_idx, *next_type_idx));
+            *next_fn_idx += 1;
+            *next_type_idx += 1;
+        }
+    }
+
+    pub(crate) fn lookup_fn_idx(&self, type_name: &str) -> Option<u32> {
+        self.slots.get(type_name).map(|(f, _)| *f)
+    }
+
+    pub(crate) fn lookup_type_idx(&self, type_name: &str) -> Option<u32> {
+        self.slots.get(type_name).map(|(_, t)| *t)
+    }
+
+    /// Emit `(eqref) -> i32` fn type for each registered helper, in
+    /// the same order as `assign_slots`.
+    pub(crate) fn emit_helper_types(&self, types: &mut wasm_encoder::TypeSection) {
+        let eq_ref = wasm_encoder::ValType::Ref(wasm_encoder::RefType {
+            nullable: true,
+            heap_type: wasm_encoder::HeapType::Abstract {
+                shared: false,
+                ty: wasm_encoder::AbstractHeapType::Eq,
+            },
+        });
+        for _ in &self.order {
+            types
+                .ty()
+                .function([eq_ref], [wasm_encoder::ValType::I32]);
+        }
+    }
+
+    pub(crate) fn emit_helper_bodies(
+        &self,
+        codes: &mut wasm_encoder::CodeSection,
+        registry: &TypeRegistry,
+        string_eq_fn_idx: Option<u32>,
+    ) -> Result<(), WasmGcError> {
+        let _ = string_eq_fn_idx; // String fields hash via array.len, no helper needed.
+        let helper_idx_map: HashMap<String, u32> = self
+            .slots
+            .iter()
+            .map(|(n, (fn_idx, _))| (n.clone(), *fn_idx))
+            .collect();
+        for name in &self.order {
+            let kind = self.kinds[name];
+            let self_fn_idx = self.slots.get(name).map(|(f, _)| *f);
+            match kind {
+                HashKind::Record => {
+                    let f = emit_record_hash_body(name, registry, &helper_idx_map, self_fn_idx)?;
+                    codes.function(&f);
+                }
+                HashKind::Sum => {
+                    let f = emit_sum_hash_body(name, registry, &helper_idx_map, self_fn_idx)?;
+                    codes.function(&f);
+                }
+                HashKind::OptionHash => {
+                    let f = emit_option_hash_body(name, registry, &helper_idx_map)?;
+                    codes.function(&f);
+                }
+                HashKind::ResultHash => {
+                    let f = emit_result_hash_body(name, registry, &helper_idx_map)?;
+                    codes.function(&f);
+                }
+                HashKind::TupleHash => {
+                    let f = emit_tuple_hash_body(name, registry, &helper_idx_map)?;
+                    codes.function(&f);
+                }
+            }
+        }
+        Ok(())
+    }
+}
+
+/// `(eqref) -> i32` body for a record. Cast → typed, DJB2 fold over
+/// fields, return.
+fn emit_record_hash_body(
+    name: &str,
+    registry: &TypeRegistry,
+    helper_idx_map: &HashMap<String, u32>,
+    self_fn_idx: Option<u32>,
+) -> Result<Function, WasmGcError> {
+    let r_idx = registry
+        .record_type_idx(name)
+        .ok_or(WasmGcError::Validation(format!(
+            "hash helper for record `{name}`: not registered"
+        )))?;
+    let fields = registry.record_fields.get(name).ok_or(
+        WasmGcError::Validation(format!("hash helper for record `{name}`: no fields")),
+    )?;
+    let r_ref = wasm_encoder::ValType::Ref(wasm_encoder::RefType {
+        nullable: true,
+        heap_type: wasm_encoder::HeapType::Concrete(r_idx),
+    });
+    // Locals: 1 = typed record ref, 2 = h accumulator.
+    let mut f = Function::new(vec![(1, r_ref), (1, wasm_encoder::ValType::I32)]);
+    let r_heap = wasm_encoder::HeapType::Concrete(r_idx);
+    f.instruction(&Instruction::LocalGet(0));
+    f.instruction(&Instruction::RefCastNonNull(r_heap));
+    f.instruction(&Instruction::LocalSet(1));
+    f.instruction(&Instruction::I32Const(5381));
+    f.instruction(&Instruction::LocalSet(2));
+    for (i, (_, field_ty)) in fields.iter().enumerate() {
+        // h = h * 33 + field_hash
+        f.instruction(&Instruction::LocalGet(2));
+        f.instruction(&Instruction::I32Const(5));
+        f.instruction(&Instruction::I32Shl);
+        f.instruction(&Instruction::LocalGet(2));
+        f.instruction(&Instruction::I32Add);
+        f.instruction(&Instruction::LocalGet(1));
+        f.instruction(&Instruction::StructGet {
+            struct_type_index: r_idx,
+            field_index: i as u32,
+        });
+        emit_inner_hash_dispatch(
+            &mut f,
+            field_ty.trim(),
+            registry,
+            helper_idx_map,
+            self_fn_idx.filter(|_| field_ty.trim() == name),
+        )?;
+        f.instruction(&Instruction::I32Add);
+        f.instruction(&Instruction::LocalSet(2));
+    }
+    f.instruction(&Instruction::LocalGet(2));
+    f.instruction(&Instruction::End);
+    Ok(f)
+}
+
+/// `(eqref) -> i32` body for a sum. ref.test cascade per variant;
+/// matched arm folds tag idx + variant fields.
+fn emit_sum_hash_body(
+    parent_name: &str,
+    registry: &TypeRegistry,
+    helper_idx_map: &HashMap<String, u32>,
+    self_fn_idx: Option<u32>,
+) -> Result<Function, WasmGcError> {
+    let mut variants: Vec<(String, super::super::types::VariantInfo)> = registry
+        .variants
+        .iter()
+        .flat_map(|(n, vs)| vs.iter().map(move |v| (n.clone(), v.clone())))
+        .filter(|(_, v)| v.parent == parent_name)
+        .collect();
+    variants.sort_by(|a, b| a.0.cmp(&b.0));
+    if variants.is_empty() {
+        return Err(WasmGcError::Validation(format!(
+            "hash helper for sum `{parent_name}`: no variants"
+        )));
+    }
+    // Locals: 1 = h accumulator. (Per-variant typed cast happens
+    // inside the if-arm via `RefCastNonNull` → `StructGet`; we read
+    // each field directly off the casted ref so no scratch slot
+    // for the variant ref is needed.)
+    let mut f = Function::new(vec![(1, wasm_encoder::ValType::I32)]);
+    f.instruction(&Instruction::I32Const(5381));
+    f.instruction(&Instruction::LocalSet(1));
+    for (_v_name, info) in &variants {
+        let v_idx = info.type_idx;
+        let v_heap = wasm_encoder::HeapType::Concrete(v_idx);
+        f.instruction(&Instruction::LocalGet(0));
+        f.instruction(&Instruction::RefTestNonNull(v_heap));
+        f.instruction(&Instruction::If(wasm_encoder::BlockType::Empty));
+        // Mix variant tag (its type_idx) into hash.
+        f.instruction(&Instruction::LocalGet(1));
+        f.instruction(&Instruction::I32Const(5));
+        f.instruction(&Instruction::I32Shl);
+        f.instruction(&Instruction::LocalGet(1));
+        f.instruction(&Instruction::I32Add);
+        f.instruction(&Instruction::I32Const(v_idx as i32));
+        f.instruction(&Instruction::I32Add);
+        f.instruction(&Instruction::LocalSet(1));
+        for (i, field_ty) in info.fields.iter().enumerate() {
+            f.instruction(&Instruction::LocalGet(1));
+            f.instruction(&Instruction::I32Const(5));
+            f.instruction(&Instruction::I32Shl);
+            f.instruction(&Instruction::LocalGet(1));
+            f.instruction(&Instruction::I32Add);
+            f.instruction(&Instruction::LocalGet(0));
+            f.instruction(&Instruction::RefCastNonNull(v_heap));
+            f.instruction(&Instruction::StructGet {
+                struct_type_index: v_idx,
+                field_index: i as u32,
+            });
+            emit_inner_hash_dispatch(
+                &mut f,
+                field_ty.trim(),
+                registry,
+                helper_idx_map,
+                self_fn_idx.filter(|_| field_ty.trim() == parent_name),
+            )?;
+            f.instruction(&Instruction::I32Add);
+            f.instruction(&Instruction::LocalSet(1));
+        }
+        f.instruction(&Instruction::End);
+    }
+    f.instruction(&Instruction::LocalGet(1));
+    f.instruction(&Instruction::End);
+    Ok(f)
+}
+
+/// `(eqref) -> i32` body for `Option<X>`. h held in local 2 across
+/// the if-arm so the block body can be empty-typed (no stack-shape
+/// constraint). DJB2-fold tag, then if Some fold inner hash too.
+fn emit_option_hash_body(
+    canonical: &str,
+    registry: &TypeRegistry,
+    helper_idx_map: &HashMap<String, u32>,
+) -> Result<Function, WasmGcError> {
+    let opt_idx = registry.option_type_idx(canonical).ok_or(
+        WasmGcError::Validation(format!("hash helper for `{canonical}`: option not registered")),
+    )?;
+    let inner = TypeRegistry::option_element_type(canonical).ok_or(
+        WasmGcError::Validation(format!("hash helper for `{canonical}`: can't parse inner")),
+    )?;
+    let opt_ref = wasm_encoder::ValType::Ref(wasm_encoder::RefType {
+        nullable: true,
+        heap_type: wasm_encoder::HeapType::Concrete(opt_idx),
+    });
+    // Locals: 1 = typed Option ref, 2 = h.
+    let mut f = Function::new(vec![(1, opt_ref), (1, wasm_encoder::ValType::I32)]);
+    let opt_heap = wasm_encoder::HeapType::Concrete(opt_idx);
+    f.instruction(&Instruction::LocalGet(0));
+    f.instruction(&Instruction::RefCastNonNull(opt_heap));
+    f.instruction(&Instruction::LocalSet(1));
+    f.instruction(&Instruction::I32Const(5381));
+    f.instruction(&Instruction::LocalSet(2));
+    // h = h * 33 + tag
+    f.instruction(&Instruction::LocalGet(2));
+    f.instruction(&Instruction::I32Const(5));
+    f.instruction(&Instruction::I32Shl);
+    f.instruction(&Instruction::LocalGet(2));
+    f.instruction(&Instruction::I32Add);
+    f.instruction(&Instruction::LocalGet(1));
+    f.instruction(&Instruction::StructGet { struct_type_index: opt_idx, field_index: 0 });
+    f.instruction(&Instruction::I32Add);
+    f.instruction(&Instruction::LocalSet(2));
+    // if Some (tag != 0), mix inner hash into h.
+    f.instruction(&Instruction::LocalGet(1));
+    f.instruction(&Instruction::StructGet { struct_type_index: opt_idx, field_index: 0 });
+    f.instruction(&Instruction::If(wasm_encoder::BlockType::Empty));
+    f.instruction(&Instruction::LocalGet(2));
+    f.instruction(&Instruction::I32Const(5));
+    f.instruction(&Instruction::I32Shl);
+    f.instruction(&Instruction::LocalGet(2));
+    f.instruction(&Instruction::I32Add);
+    f.instruction(&Instruction::LocalGet(1));
+    f.instruction(&Instruction::StructGet { struct_type_index: opt_idx, field_index: 1 });
+    emit_inner_hash_dispatch(&mut f, inner.trim(), registry, helper_idx_map, None)?;
+    f.instruction(&Instruction::I32Add);
+    f.instruction(&Instruction::LocalSet(2));
+    f.instruction(&Instruction::End);
+    f.instruction(&Instruction::LocalGet(2));
+    f.instruction(&Instruction::End);
+    Ok(f)
+}
+
+/// `(eqref) -> i32` body for `Result<X, Y>`. h held in local 2.
+fn emit_result_hash_body(
+    canonical: &str,
+    registry: &TypeRegistry,
+    helper_idx_map: &HashMap<String, u32>,
+) -> Result<Function, WasmGcError> {
+    let res_idx = registry.result_type_idx(canonical).ok_or(
+        WasmGcError::Validation(format!("hash helper for `{canonical}`: result not registered")),
+    )?;
+    let (ok_inner, err_inner) = parse_result_kv(canonical).ok_or(
+        WasmGcError::Validation(format!("hash helper for `{canonical}`: can't parse inner")),
+    )?;
+    let res_ref = wasm_encoder::ValType::Ref(wasm_encoder::RefType {
+        nullable: true,
+        heap_type: wasm_encoder::HeapType::Concrete(res_idx),
+    });
+    let mut f = Function::new(vec![(1, res_ref), (1, wasm_encoder::ValType::I32)]);
+    let res_heap = wasm_encoder::HeapType::Concrete(res_idx);
+    f.instruction(&Instruction::LocalGet(0));
+    f.instruction(&Instruction::RefCastNonNull(res_heap));
+    f.instruction(&Instruction::LocalSet(1));
+    f.instruction(&Instruction::I32Const(5381));
+    f.instruction(&Instruction::LocalSet(2));
+    // h = h * 33 + tag
+    f.instruction(&Instruction::LocalGet(2));
+    f.instruction(&Instruction::I32Const(5));
+    f.instruction(&Instruction::I32Shl);
+    f.instruction(&Instruction::LocalGet(2));
+    f.instruction(&Instruction::I32Add);
+    f.instruction(&Instruction::LocalGet(1));
+    f.instruction(&Instruction::StructGet { struct_type_index: res_idx, field_index: 0 });
+    f.instruction(&Instruction::I32Add);
+    f.instruction(&Instruction::LocalSet(2));
+    // Branch on tag.
+    f.instruction(&Instruction::LocalGet(1));
+    f.instruction(&Instruction::StructGet { struct_type_index: res_idx, field_index: 0 });
+    f.instruction(&Instruction::If(wasm_encoder::BlockType::Empty));
+    // Ok arm: mix field 1 (ok) into h.
+    f.instruction(&Instruction::LocalGet(2));
+    f.instruction(&Instruction::I32Const(5));
+    f.instruction(&Instruction::I32Shl);
+    f.instruction(&Instruction::LocalGet(2));
+    f.instruction(&Instruction::I32Add);
+    f.instruction(&Instruction::LocalGet(1));
+    f.instruction(&Instruction::StructGet { struct_type_index: res_idx, field_index: 1 });
+    emit_inner_hash_dispatch(&mut f, ok_inner.trim(), registry, helper_idx_map, None)?;
+    f.instruction(&Instruction::I32Add);
+    f.instruction(&Instruction::LocalSet(2));
+    f.instruction(&Instruction::Else);
+    // Err arm: mix field 2 (err) into h.
+    f.instruction(&Instruction::LocalGet(2));
+    f.instruction(&Instruction::I32Const(5));
+    f.instruction(&Instruction::I32Shl);
+    f.instruction(&Instruction::LocalGet(2));
+    f.instruction(&Instruction::I32Add);
+    f.instruction(&Instruction::LocalGet(1));
+    f.instruction(&Instruction::StructGet { struct_type_index: res_idx, field_index: 2 });
+    emit_inner_hash_dispatch(&mut f, err_inner.trim(), registry, helper_idx_map, None)?;
+    f.instruction(&Instruction::I32Add);
+    f.instruction(&Instruction::LocalSet(2));
+    f.instruction(&Instruction::End);
+    f.instruction(&Instruction::LocalGet(2));
+    f.instruction(&Instruction::End);
+    Ok(f)
+}
+
+/// `(eqref) -> i32` body for `Tuple<A, B, C, …>`. DJB2 fold per-elem.
+fn emit_tuple_hash_body(
+    canonical: &str,
+    registry: &TypeRegistry,
+    helper_idx_map: &HashMap<String, u32>,
+) -> Result<Function, WasmGcError> {
+    let tup_idx = registry.tuple_type_idx(canonical).ok_or(
+        WasmGcError::Validation(format!("hash helper for `{canonical}`: tuple not registered")),
+    )?;
+    let elems = parse_tuple_elems(canonical).ok_or(
+        WasmGcError::Validation(format!("hash helper for `{canonical}`: can't parse elements")),
+    )?;
+    let tup_ref = wasm_encoder::ValType::Ref(wasm_encoder::RefType {
+        nullable: true,
+        heap_type: wasm_encoder::HeapType::Concrete(tup_idx),
+    });
+    let mut f = Function::new(vec![(1, tup_ref), (1, wasm_encoder::ValType::I32)]);
+    let tup_heap = wasm_encoder::HeapType::Concrete(tup_idx);
+    f.instruction(&Instruction::LocalGet(0));
+    f.instruction(&Instruction::RefCastNonNull(tup_heap));
+    f.instruction(&Instruction::LocalSet(1));
+    f.instruction(&Instruction::I32Const(5381));
+    f.instruction(&Instruction::LocalSet(2));
+    for (i, elem) in elems.iter().enumerate() {
+        f.instruction(&Instruction::LocalGet(2));
+        f.instruction(&Instruction::I32Const(5));
+        f.instruction(&Instruction::I32Shl);
+        f.instruction(&Instruction::LocalGet(2));
+        f.instruction(&Instruction::I32Add);
+        f.instruction(&Instruction::LocalGet(1));
+        f.instruction(&Instruction::StructGet {
+            struct_type_index: tup_idx,
+            field_index: i as u32,
+        });
+        emit_inner_hash_dispatch(&mut f, elem.trim(), registry, helper_idx_map, None)?;
+        f.instruction(&Instruction::I32Add);
+        f.instruction(&Instruction::LocalSet(2));
+    }
+    f.instruction(&Instruction::LocalGet(2));
+    f.instruction(&Instruction::End);
+    Ok(f)
+}
+
+/// Stack: `[value]` of `inner` aver type. Push `i32` hash. Mirror
+/// of `eq_helpers::emit_inner_eq_dispatch` but for hash.
+fn emit_inner_hash_dispatch(
+    f: &mut Function,
+    inner: &str,
+    registry: &TypeRegistry,
+    helper_idx_map: &HashMap<String, u32>,
+    self_fn_idx: Option<u32>,
+) -> Result<(), WasmGcError> {
+    let resolved: String = if let Some(under) = registry.newtype_underlying(inner) {
+        under.to_string()
+    } else {
+        inner.to_string()
+    };
+    match resolved.as_str() {
+        "Int" => {
+            f.instruction(&Instruction::I32WrapI64);
+        }
+        "Bool" => {} // already i32
+        "Float" => {
+            f.instruction(&Instruction::I64ReinterpretF64);
+            f.instruction(&Instruction::I32WrapI64);
+        }
+        "String" => {
+            f.instruction(&Instruction::ArrayLen);
+        }
+        other if Some(other) == self_fn_idx.and(Some(inner)) => {
+            // Self-recursive case — caller passed `Some(self_fn_idx)`
+            // when the field is a recursive ref to the parent.
+            let idx = self_fn_idx.unwrap();
+            f.instruction(&Instruction::Call(idx));
+        }
+        other if helper_idx_map.contains_key(other) => {
+            f.instruction(&Instruction::Call(helper_idx_map[other]));
+        }
+        _other => {
+            // Last-resort fallback (newtype-erased through to a
+            // non-eq-able underlying, or a shape we genuinely can't
+            // resolve). Drop the value, contribute 0. Same
+            // collision-tolerant degradation the older inline
+            // emitters used.
+            f.instruction(&Instruction::Drop);
+            f.instruction(&Instruction::I32Const(0));
+        }
+    }
+    Ok(())
+}
+
+/// `Result<Ok, Err>` → `Some(("Ok", "Err"))`. Tracks angle/paren
+/// depth so `Result<Map<K,V>, MyError>` splits at the right comma.
+fn parse_result_kv(canonical: &str) -> Option<(&str, &str)> {
+    let inner = canonical.trim().strip_prefix("Result<")?.strip_suffix('>')?;
+    let bytes = inner.as_bytes();
+    let mut depth: i32 = 0;
+    for (idx, b) in bytes.iter().enumerate() {
+        match b {
+            b'<' | b'(' => depth += 1,
+            b'>' | b')' => depth -= 1,
+            b',' if depth == 0 => {
+                return Some((inner[..idx].trim(), inner[idx + 1..].trim()));
+            }
+            _ => {}
+        }
+    }
+    None
+}
+
+/// `Tuple<A, B, C>` → `Some(vec!["A", "B", "C"])`.
+fn parse_tuple_elems(canonical: &str) -> Option<Vec<&str>> {
+    let inner = canonical.trim().strip_prefix("Tuple<")?.strip_suffix('>')?;
+    let bytes = inner.as_bytes();
+    let mut depth: i32 = 0;
+    let mut start = 0;
+    let mut out = Vec::new();
+    for (idx, b) in bytes.iter().enumerate() {
+        match b {
+            b'<' | b'(' => depth += 1,
+            b'>' | b')' => depth -= 1,
+            b',' if depth == 0 => {
+                out.push(inner[start..idx].trim());
+                start = idx + 1;
+            }
+            _ => {}
+        }
+    }
+    out.push(inner[start..].trim());
+    Some(out)
+}
diff --git a/src/codegen/wasm_gc/lists.rs b/src/codegen/wasm_gc/lists.rs
index 70818769..411cbd18 100644
--- a/src/codegen/wasm_gc/lists.rs
+++ b/src/codegen/wasm_gc/lists.rs
@@ -162,16 +162,14 @@ impl ListHelperRegistry {
             } else {
                 None
             };
-            // List eq + hash use a stricter rule than contains —
-            // their bodies expect stack-shape per-element eq.
-            // SumEq / RecordEq need scratch locals + cascade emit;
-            // the bodies don't support those today. The record-key
-            // field-dispatch path that drives these helpers only
-            // ever calls them with primitive / String elements.
-            let needs_list_helpers = matches!(
-                contains_eq,
-                Some(ListEqKind::I64 | ListEqKind::F64 | ListEqKind::I32 | ListEqKind::StringEq)
-            );
+            // List eq + hash slots track the same kinds contains
+            // does — primitives, String, and (since 0.16.3) record
+            // / sum nominal elements that resolve through the
+            // per-type `__eq_<X>` helper map. The body emitters
+            // (`emit_list_eq` / `emit_list_hash`) dispatch nominal
+            // elements through `Call(__eq_<name>)` / inline record
+            // /sum hash now.
+            let needs_list_helpers = contains_eq.is_some();
             let list_eq_type = if needs_list_helpers {
                 let t = *next_type_idx;
                 *next_type_idx += 1;
@@ -272,13 +270,10 @@ impl ListHelperRegistry {
             *next_wasm_fn_idx += 1;
             let to_fn = *next_wasm_fn_idx;
             *next_wasm_fn_idx += 1;
-            // Vector<T> eq + hash conditionally — same primitive /
-            // String constraint as list eq+hash (SumEq / RecordEq
-            // not supported in the stack-eq body).
-            let eq_kind_ok = matches!(
-                list_eq_kind(elem.trim(), registry),
-                Some(ListEqKind::I64 | ListEqKind::F64 | ListEqKind::I32 | ListEqKind::StringEq)
-            );
+            // Vector<T> eq + hash slots match the list cap — same
+            // resolvable kinds (primitive / String / nominal record-
+            // sum since 0.16.3).
+            let eq_kind_ok = list_eq_kind(elem.trim(), registry).is_some();
             let (vec_eq_ty, vec_hash_ty, vec_eq_fn, vec_hash_fn) = if eq_kind_ok {
                 let eq_ty = *next_type_idx;
                 *next_type_idx += 1;
@@ -414,10 +409,7 @@ impl ListHelperRegistry {
             if kind.is_some() {
                 types.ty().function([list_ref, elem_val], [ValType::I32]);
             }
-            if matches!(
-                kind,
-                Some(ListEqKind::I64 | ListEqKind::F64 | ListEqKind::I32 | ListEqKind::StringEq)
-            ) {
+            if kind.is_some() {
                 // eq : (List<T>, List<T>) -> i32
                 types.ty().function([list_ref, list_ref], [ValType::I32]);
                 // hash : (List<T>) -> i32
@@ -451,10 +443,7 @@ impl ListHelperRegistry {
             // to_list : (Vector<T>) -> List<T>
             types.ty().function([vec_ref], [list_ref]);
             let elem = TypeRegistry::list_element_type(canonical).unwrap();
-            if matches!(
-                list_eq_kind(elem.trim(), registry),
-                Some(ListEqKind::I64 | ListEqKind::F64 | ListEqKind::I32 | ListEqKind::StringEq)
-            ) {
+            if list_eq_kind(elem.trim(), registry).is_some() {
                 // eq : (Vector<T>, Vector<T>) -> i32
                 types.ty().function([vec_ref, vec_ref], [ValType::I32]);
                 // hash : (Vector<T>) -> i32
@@ -570,6 +559,7 @@ impl ListHelperRegistry {
         registry: &TypeRegistry,
         string_eq_fn_idx: Option<u32>,
         eq_helper_fn_idx: &std::collections::HashMap<String, u32>,
+        hash_helper_fn_idx: &std::collections::HashMap<String, u32>,
     ) -> Result<(), WasmGcError> {
         for canonical in &self.list_order {
             // Order MUST match `assign_slots` and
@@ -607,6 +597,7 @@ impl ListHelperRegistry {
                         kind,
                         string_eq_fn_idx,
                         ops.hash.unwrap(),
+                        hash_helper_fn_idx,
                     )?);
                 }
             }
@@ -625,7 +616,13 @@ impl ListHelperRegistry {
                     string_eq_fn_idx,
                     eq_helper_fn_idx,
                 )?);
-                codes.function(&emit_vec_hash(canonical, registry, kind, string_eq_fn_idx)?);
+                codes.function(&emit_vec_hash(
+                    canonical,
+                    registry,
+                    kind,
+                    string_eq_fn_idx,
+                    hash_helper_fn_idx,
+                )?);
             }
         }
         for tup_canonical in &self.zip_order {
@@ -2189,12 +2186,14 @@ fn emit_list_eq(
 /// `hash : (l) -> i32`. DJB2-style fold: `h = 5381; for elem: h = h
 /// * 33 + element_hash`. Element hash dispatched per `kind`. Same
 /// `T` constraint as eq.
+#[allow(clippy::too_many_arguments)]
 fn emit_list_hash(
     canonical: &str,
     registry: &TypeRegistry,
     kind: ListEqKind,
     string_eq_fn_idx: Option<u32>,
     _self_fn_idx: u32,
+    hash_helper_fn_idx: &std::collections::HashMap<String, u32>,
 ) -> Result<Function, WasmGcError> {
     let list_idx = list_idx_of(canonical, registry)?;
     let _ = string_eq_fn_idx;
@@ -2302,6 +2301,7 @@ fn emit_list_hash(
                 )))?;
             emit_record_inline_hash(
                 &mut f, r_idx, fields, /* elem_local */ 3, /* elem_hash_local */ 4,
+                registry, hash_helper_fn_idx,
             )?;
         }
         ListEqKind::SumEq(parent_name) => {
@@ -2311,6 +2311,7 @@ fn emit_list_hash(
                 registry,
                 /* elem_local */ 3,
                 /* elem_hash_local */ 4,
+                hash_helper_fn_idx,
             )?;
         }
     }
@@ -2340,12 +2341,14 @@ fn emit_list_hash(
 /// field into `elem_hash`. Variants are disjoint subtypes of the
 /// parent, so at most one `ref.test` succeeds per call — non-
 /// matched arms `ref.test` to false and skip silently.
+#[allow(clippy::too_many_arguments)]
 fn emit_sum_inline_hash(
     f: &mut Function,
     parent_name: &str,
     registry: &TypeRegistry,
     elem_local: u32,
     elem_hash_local: u32,
+    hash_helper_fn_idx: &std::collections::HashMap<String, u32>,
 ) -> Result<(), WasmGcError> {
     // Collect variants of this sum. Same ordering as
     // `emit_sum_eq_inline` for parity.
@@ -2399,7 +2402,13 @@ fn emit_sum_inline_hash(
                 struct_type_index: v_idx,
                 field_index: i as u32,
             });
-            match field_ty.trim() {
+            let resolved: String =
+                if let Some(under) = registry.newtype_underlying(field_ty.trim()) {
+                    under.to_string()
+                } else {
+                    field_ty.trim().to_string()
+                };
+            match resolved.as_str() {
                 "Int" => {
                     f.instruction(&Instruction::I32WrapI64);
                 }
@@ -2411,12 +2420,14 @@ fn emit_sum_inline_hash(
                 "String" => {
                     f.instruction(&Instruction::ArrayLen);
                 }
-                other => {
-                    return Err(WasmGcError::Validation(format!(
-                        "sum hash dispatch: variant field type `{other}` \
-                         unsupported (only Int/Bool/Float/String); upstream \
-                         `list_eq_kind` all_simple gate should have rejected this."
-                    )));
+                other if hash_helper_fn_idx.contains_key(other) => {
+                    f.instruction(&Instruction::Call(hash_helper_fn_idx[other]));
+                }
+                _ => {
+                    // Last-resort fallback — no helper for this
+                    // shape. Drop, contribute 0 (eq disambiguates).
+                    f.instruction(&Instruction::Drop);
+                    f.instruction(&Instruction::I32Const(0));
                 }
             }
             f.instruction(&Instruction::I32Add);
@@ -2439,12 +2450,15 @@ fn emit_sum_inline_hash(
 /// already i32, String → array.len. Field shapes are restricted to
 /// {Int, Bool, Float, String} by `list_eq_kind`'s `all_simple` gate;
 /// nested records / lists trip `WasmGcError::Validation` here.
+#[allow(clippy::too_many_arguments)]
 fn emit_record_inline_hash(
     f: &mut Function,
     record_idx: u32,
     fields: &[(String, String)],
     elem_local: u32,
     elem_hash_local: u32,
+    registry: &TypeRegistry,
+    hash_helper_fn_idx: &std::collections::HashMap<String, u32>,
 ) -> Result<(), WasmGcError> {
     // Save record ref → elem_local for repeated struct.get.
     f.instruction(&Instruction::LocalSet(elem_local));
@@ -2465,7 +2479,12 @@ fn emit_record_inline_hash(
             struct_type_index: record_idx,
             field_index: i as u32,
         });
-        match field_type.trim() {
+        let resolved: String = if let Some(under) = registry.newtype_underlying(field_type.trim()) {
+            under.to_string()
+        } else {
+            field_type.trim().to_string()
+        };
+        match resolved.as_str() {
             "Int" => {
                 f.instruction(&Instruction::I32WrapI64);
             }
@@ -2477,12 +2496,16 @@ fn emit_record_inline_hash(
             "String" => {
                 f.instruction(&Instruction::ArrayLen);
             }
-            other => {
-                return Err(WasmGcError::Validation(format!(
-                    "record hash dispatch: field type `{other}` unsupported \
-                     (only Int/Bool/Float/String); upstream `list_eq_kind` \
-                     all_simple gate should have rejected this list."
-                )));
+            other if hash_helper_fn_idx.contains_key(other) => {
+                f.instruction(&Instruction::Call(hash_helper_fn_idx[other]));
+            }
+            _ => {
+                // No helper available — drop + 0. Collision OK; eq
+                // disambiguates the bucket. Hits when the field type
+                // is a generic carrier we haven't covered yet (e.g.
+                // `List<X>` field in a record).
+                f.instruction(&Instruction::Drop);
+                f.instruction(&Instruction::I32Const(0));
             }
         }
         f.instruction(&Instruction::I32Add);
@@ -2583,6 +2606,7 @@ fn emit_vec_hash(
     registry: &TypeRegistry,
     kind: ListEqKind,
     _string_eq_fn_idx: Option<u32>,
+    hash_helper_fn_idx: &std::collections::HashMap<String, u32>,
 ) -> Result<Function, WasmGcError> {
     let (vec_idx, _) = vec_idx_of_pair(canonical, registry)?;
     let elem = TypeRegistry::list_element_type(canonical).unwrap();
@@ -2670,6 +2694,7 @@ fn emit_vec_hash(
                 )))?;
             emit_record_inline_hash(
                 &mut f, r_idx, fields, /* elem_local */ 4, /* elem_hash_local */ 5,
+                registry, hash_helper_fn_idx,
             )?;
         }
         ListEqKind::SumEq(parent_name) => {
@@ -2679,6 +2704,7 @@ fn emit_vec_hash(
                 registry,
                 /* elem_local */ 4,
                 /* elem_hash_local */ 5,
+                hash_helper_fn_idx,
             )?;
         }
     }
diff --git a/src/codegen/wasm_gc/module.rs b/src/codegen/wasm_gc/module.rs
index 6a4eba79..4a416efd 100644
--- a/src/codegen/wasm_gc/module.rs
+++ b/src/codegen/wasm_gc/module.rs
@@ -26,6 +26,7 @@ use wasm_encoder::{
 
 use super::WasmGcError;
 use super::body::eq_helpers::{EqHelperRegistry, EqKind};
+use super::body::hash_helpers::{HashHelperRegistry, HashKind};
 use super::body::{FnEntry, FnMap, emit_fn_body};
 use super::builtins::{BuiltinName, BuiltinRegistry};
 use super::effects::{EffectName, EffectRegistry};
@@ -66,6 +67,7 @@ pub(super) fn emit_module(
     let mut builtin_registry = BuiltinRegistry::new();
     let mut effect_registry = EffectRegistry::new();
     let mut eq_helpers_registry = EqHelperRegistry::new();
+    let mut hash_helpers_registry = HashHelperRegistry::new();
     for fd in &fn_defs {
         discover_builtins_in_fn(
             fd,
@@ -103,6 +105,7 @@ pub(super) fn emit_module(
     for name in &nominal_seed {
         if registry.record_fields.contains_key(name) {
             eq_helpers_registry.register_transitive(name, EqKind::Record, &registry);
+            hash_helpers_registry.register_transitive(name, HashKind::Record, &registry);
         } else if registry
             .variants
             .values()
@@ -110,8 +113,28 @@ pub(super) fn emit_module(
             .any(|v| &v.parent == name)
         {
             eq_helpers_registry.register_transitive(name, EqKind::Sum, &registry);
+            hash_helpers_registry.register_transitive(name, HashKind::Sum, &registry);
         }
     }
+    // Mirror eq registry's transitive shape — every type registered
+    // for eq dispatch also needs a hash helper, since list/vec/map
+    // helpers and per-record/sum hash bodies dispatch through
+    // `Call(__hash_<X>)` for non-primitive fields. Walk the eq
+    // registry post-seed and register matching hash slots.
+    let eq_snapshot: Vec<(String, EqKind)> = eq_helpers_registry
+        .iter()
+        .map(|(n, k)| (n.to_string(), k))
+        .collect();
+    for (name, kind) in &eq_snapshot {
+        let hk = match kind {
+            EqKind::Record => HashKind::Record,
+            EqKind::Sum => HashKind::Sum,
+            EqKind::OptionEq => HashKind::OptionHash,
+            EqKind::ResultEq => HashKind::ResultHash,
+            EqKind::TupleEq => HashKind::TupleHash,
+        };
+        hash_helpers_registry.register_transitive(name, hk, &registry);
+    }
     // Eq helpers over records / sums with String fields need
     // `__wasmgc_string_eq` — force-register so the slot is allocated
     // before bodies emit.
@@ -252,6 +275,8 @@ pub(super) fn emit_module(
     // `__wasmgc_string_eq` registered above).
     eq_helpers_registry.assign_slots(&mut next_builtin_fn_idx, &mut next_type_idx);
     eq_helpers_registry.emit_helper_types(&mut types);
+    hash_helpers_registry.assign_slots(&mut next_builtin_fn_idx, &mut next_type_idx);
+    hash_helpers_registry.emit_helper_types(&mut types);
 
     // 8a) `aver_http_handle` wrapper — `--handler X` synthesises a
     //     no-arg fn that reads request fields via the `Request.*`
@@ -419,6 +444,13 @@ pub(super) fn emit_module(
             .expect("registered eq helper has type idx after assign_slots");
         funcs.function(t_idx);
     }
+    // Hash helpers — same shape (one entry per registered slot).
+    for (name, _kind) in hash_helpers_registry.iter() {
+        let t_idx = hash_helpers_registry
+            .lookup_type_idx(name)
+            .expect("registered hash helper has type idx after assign_slots");
+        funcs.function(t_idx);
+    }
     if let Some(hw) = &handler_wrapper {
         funcs.function(hw.wrapper_type);
         funcs.function(hw.list_cons_type);
@@ -531,6 +563,12 @@ pub(super) fn emit_module(
             eq_helpers_lookup.insert(name.to_string(), fn_idx);
         }
     }
+    let mut hash_helpers_lookup: HashMap<String, u32> = HashMap::new();
+    for (name, _kind) in hash_helpers_registry.iter() {
+        if let Some(fn_idx) = hash_helpers_registry.lookup_fn_idx(name) {
+            hash_helpers_lookup.insert(name.to_string(), fn_idx);
+        }
+    }
     let fn_map = FnMap {
         by_name,
         builtins: builtin_idx_lookup,
@@ -541,6 +579,7 @@ pub(super) fn emit_module(
         zip_ops: zip_ops_lookup,
         string_split_ops,
         eq_helpers: eq_helpers_lookup,
+        hash_helpers: hash_helpers_lookup,
     };
 
     // ── Export section ─────────────────────────────────────────────
@@ -709,17 +748,25 @@ pub(super) fn emit_module(
         .iter()
         .filter_map(|(n, _k)| eq_helpers_registry.lookup_fn_idx(n).map(|i| (n.to_string(), i)))
         .collect();
+    let hash_helper_fn_idx_map: HashMap<String, u32> = hash_helpers_registry
+        .iter()
+        .filter_map(|(n, _k)| hash_helpers_registry.lookup_fn_idx(n).map(|i| (n.to_string(), i)))
+        .collect();
     list_helpers.emit_helper_bodies(
         &mut codes,
         &registry,
         string_eq_fn_idx,
         &eq_helper_fn_idx_map,
+        &hash_helper_fn_idx_map,
     )?;
 
     // Per-(record/sum) `__eq_<TypeName>` helper bodies — emit after
     // list helpers so any String fields can call `__wasmgc_string_eq`
     // by the index recorded above.
     eq_helpers_registry.emit_helper_bodies(&mut codes, &registry, string_eq_fn_idx)?;
+    // `__hash_<X>` helper bodies — emitted right after eq helpers so
+    // every nominal/carrier hash dispatch finds its target fn_idx.
+    hash_helpers_registry.emit_helper_bodies(&mut codes, &registry, string_eq_fn_idx)?;
 
     if let Some(hw) = &handler_wrapper {
         let user_handler_wasm_idx = import_count + 1 + (hw.user_handler_idx as u32);

From 1e7726c049feb3165f6b897cbd02018b6f283b1c Mon Sep 17 00:00:00 2001
From: jasisz <jasisz@gmail.com>
Date: Wed, 6 May 2026 17:14:58 +0200
Subject: [PATCH 11/18] =?UTF-8?q?0.16.3:=20Map<K,V>=20with=20carrier=20K?=
 =?UTF-8?q?=20=E2=80=94=20Option/Result/Tuple=20as=20map=20keys?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

MapHelperRegistry now accepts carrier types as K (or carriers in K record
field positions). Carrier helpers don't allocate their own slot — they
proxy via Call to the per-instantiation `__eq_<X>` / `__hash_<X>`
helpers in eq_helpers / hash_helpers, threaded through emit_helper_bodies
as `carrier_eq_hash`.

types.rs: Map walker now scans let-binding annotations in fn bodies so
`let m: Map<Person, Int> = …` is registered (mirrors the Result walker).

Drops the unused `FnMap.hash_helpers` lookup field — record/sum/carrier
hash bodies dispatch through the registry directly, and map-key proxy
goes through the dedicated `carrier_eq_hash` parameter.

  Map<Person,Int>     ✓ Person.age: Option<Int>
  Map<Tuple<Int,String>,V> ✓
  Map<Result<E,T>,V>  ✓
  Map<Option<X>,V>    ✓

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>
---
 src/codegen/wasm_gc/body.rs   |   5 --
 src/codegen/wasm_gc/maps.rs   | 105 ++++++++++++++++++++++++++++++----
 src/codegen/wasm_gc/module.rs |  28 ++++++---
 src/codegen/wasm_gc/types.rs  |  11 ++++
 4 files changed, 125 insertions(+), 24 deletions(-)

diff --git a/src/codegen/wasm_gc/body.rs b/src/codegen/wasm_gc/body.rs
index 8865d811..4f2b558f 100644
--- a/src/codegen/wasm_gc/body.rs
+++ b/src/codegen/wasm_gc/body.rs
@@ -74,11 +74,6 @@ pub(super) struct FnMap {
     /// Per-(record/sum) `__eq_<TypeName>` helpers used by `BinOp::Eq`
     /// / `BinOp::Neq` over nominal types. Key = bare type name.
     pub(super) eq_helpers: std::collections::HashMap<String, u32>,
-    /// Per-type `__hash_<X>` helpers used by record/sum/carrier
-    /// hash bodies for non-primitive field hashing. Symmetric to
-    /// `eq_helpers`. Key = canonical (bare for record/sum,
-    /// whitespace-free instantiation for carriers).
-    pub(super) hash_helpers: std::collections::HashMap<String, u32>,
 }
 
 impl FnMap {
diff --git a/src/codegen/wasm_gc/maps.rs b/src/codegen/wasm_gc/maps.rs
index a9902f1d..194b97b2 100644
--- a/src/codegen/wasm_gc/maps.rs
+++ b/src/codegen/wasm_gc/maps.rs
@@ -204,11 +204,23 @@ impl MapHelperRegistry {
                     .values()
                     .flat_map(|v| v.iter())
                     .any(|v| v.parent == ft);
-                if (is_record || is_sum) && k_seen.insert(ft.clone()) {
+                let is_carrier = ft.starts_with("Option<")
+                    || ft.starts_with("Result<")
+                    || ft.starts_with("Tuple<");
+                if (is_record || is_sum || is_carrier) && k_seen.insert(ft.clone()) {
                     k_names.push(ft.clone());
-                    to_visit.push(ft.clone());
+                    if !is_carrier {
+                        // Records / sums recurse into their own
+                        // fields. Carriers don't (their helper bodies
+                        // delegate via Call to eq_helpers/hash_
+                        // helpers, which handle inner types
+                        // themselves).
+                        to_visit.push(ft.clone());
+                    }
                     // String inside the nested type's fields →
-                    // force-register String.
+                    // force-register String. Carriers' name
+                    // contains "String" only when an inner type is
+                    // literally `String`; cheap heuristic.
                     let mut nested_needs_string = false;
                     if let Some(fs) = registry.record_fields.get(&ft) {
                         nested_needs_string |= fs.iter().any(|(_, t)| t.trim() == "String");
@@ -221,6 +233,9 @@ impl MapHelperRegistry {
                             .filter(|v| v.parent == ft)
                             .any(|v| v.fields.iter().any(|t| t.trim() == "String"));
                     }
+                    if is_carrier {
+                        nested_needs_string |= ft.contains("String");
+                    }
                     if nested_needs_string && k_seen.insert("String".into()) {
                         k_names.push("String".into());
                     }
@@ -318,13 +333,18 @@ impl MapHelperRegistry {
                 .values()
                 .flat_map(|v| v.iter())
                 .any(|v| v.parent == k_aver);
+            let is_carrier_k = k_aver.starts_with("Option<")
+                || k_aver.starts_with("Result<")
+                || k_aver.starts_with("Tuple<");
             if k_aver != "String"
                 && registry.record_type_idx(k_aver).is_none()
                 && !is_primitive_k
                 && !is_sum_k
+                && !is_carrier_k
             {
                 return Err(WasmGcError::Unimplemented(
-                    "phase 3c — Map<K, V> with K not String / user-record / sum / primitive",
+                    "phase 3c — Map<K, V> with K not String / user-record / sum / \
+                     primitive / generic-carrier (Option/Result/Tuple)",
                 ));
             }
 
@@ -508,15 +528,26 @@ impl MapHelperRegistry {
         codes: &mut CodeSection,
         registry: &TypeRegistry,
         list_eq_hash: &HashMap<String, (u32, u32)>,
+        carrier_eq_hash: &HashMap<String, (u32, u32)>,
     ) -> Result<(), WasmGcError> {
         let string_key_helpers = self.key.get("String").copied();
         // Snapshot every K's helpers — record hash/eq dispatch
         // needs to call helpers for nested record fields. Plus
         // virtual entries for `List<T>` field types so hash/eq
         // dispatch can call into list_helpers without a
-        // separate cross-module lookup.
+        // separate cross-module lookup. Carriers (Option / Result
+        // / Tuple) come in through `carrier_eq_hash` from the
+        // `__eq_<X>` / `__hash_<X>` registries (eq_helpers /
+        // hash_helpers); their map-key body is a thin proxy that
+        // Calls into those.
         let mut all_key_helpers: HashMap<String, KeyHelpers> =
             self.key.iter().map(|(k, h)| (k.clone(), *h)).collect();
+        for (carrier, &(eq_fn, hash_fn)) in carrier_eq_hash {
+            all_key_helpers.insert(
+                carrier.clone(),
+                KeyHelpers { hash: hash_fn, eq: eq_fn },
+            );
+        }
         for (list_canonical, &(eq_fn, hash_fn)) in list_eq_hash {
             all_key_helpers.insert(
                 list_canonical.clone(),
@@ -592,6 +623,21 @@ fn emit_hash_for(
     {
         return emit_hash_sum(k_aver, registry, string_key_helpers);
     }
+    if k_aver.starts_with("Option<")
+        || k_aver.starts_with("Result<")
+        || k_aver.starts_with("Tuple<")
+    {
+        // Same shape as carrier eq: proxy to the per-instantiation
+        // `__hash_<X>` helper from `hash_helpers`.
+        let helpers = all_key_helpers.get(k_aver).ok_or(WasmGcError::Validation(
+            format!("hash_for: carrier `{k_aver}` has no registered hash helper"),
+        ))?;
+        let mut f = Function::new([]);
+        f.instruction(&Instruction::LocalGet(0));
+        f.instruction(&Instruction::Call(helpers.hash));
+        f.instruction(&Instruction::End);
+        return Ok(f);
+    }
     Err(WasmGcError::Unimplemented(
         "phase 3c — hash for unsupported K kind",
     ))
@@ -620,6 +666,24 @@ fn emit_eq_for(
     {
         return emit_eq_sum(k_aver, registry, string_key_helpers);
     }
+    if k_aver.starts_with("Option<")
+        || k_aver.starts_with("Result<")
+        || k_aver.starts_with("Tuple<")
+    {
+        // Map-key eq for carriers proxies to the per-instantiation
+        // `__eq_<X>` helper registered in `eq_helpers` (looked up
+        // via `all_key_helpers` which includes the carrier eq fn
+        // idx forwarded from the registry).
+        let helpers = all_key_helpers.get(k_aver).ok_or(WasmGcError::Validation(
+            format!("eq_for: carrier `{k_aver}` has no registered eq helper"),
+        ))?;
+        let mut f = Function::new([]);
+        f.instruction(&Instruction::LocalGet(0));
+        f.instruction(&Instruction::LocalGet(1));
+        f.instruction(&Instruction::Call(helpers.eq));
+        f.instruction(&Instruction::End);
+        return Ok(f);
+    }
     Err(WasmGcError::Unimplemented(
         "phase 3c — eq for unsupported K kind",
     ))
@@ -1438,30 +1502,41 @@ fn emit_hash_record(
                 // Nested record / List<T> field. Both dispatch via
                 // `all_key_helpers` — records were force-registered
                 // as pseudo-K in `assign_slots`; list canonicals were
-                // injected by `emit_helper_bodies` from list_helpers.
+                // injected by `emit_helper_bodies` from list_helpers;
+                // carriers (Option/Result/Tuple) come from
+                // `carrier_eq_hash`.
                 let lookup_key = if other.starts_with("List<") || other.starts_with("Vector<") {
                     super::types::normalize_compound(other).to_string()
                 } else {
                     other.to_string()
                 };
                 let is_compound = other.starts_with("List<") || other.starts_with("Vector<");
+                let is_carrier = other.starts_with("Option<")
+                    || other.starts_with("Result<")
+                    || other.starts_with("Tuple<");
                 let is_sum = registry
                     .variants
                     .values()
                     .flat_map(|v| v.iter())
                     .any(|v| v.parent == other);
-                if registry.record_type_idx(other).is_some() || is_compound || is_sum {
+                if registry.record_type_idx(other).is_some()
+                    || is_compound
+                    || is_sum
+                    || is_carrier
+                {
                     let inner = all_key_helpers
                         .get(&lookup_key)
                         .ok_or(WasmGcError::Validation(format!(
                             "hash_record: field `{other}` has no key helpers \
-                             (record / list / vector / sum T may need force-registration)"
+                             (record / list / vector / sum / Option / Result / Tuple T \
+                              may need force-registration)"
                         )))?;
                     f.instruction(&Instruction::Call(inner.hash));
                 } else {
                     return Err(WasmGcError::Unimplemented(
                         "phase 3c — record-key field type not in \
-                         {Int, Float, Bool, String, nested record, List<T>, Vector<T>, sum}",
+                         {Int, Float, Bool, String, nested record, List<T>, Vector<T>, sum, \
+                          Option/Result/Tuple}",
                     ));
                 }
             }
@@ -1523,12 +1598,19 @@ fn emit_eq_record(
                     other.to_string()
                 };
                 let is_compound = other.starts_with("List<") || other.starts_with("Vector<");
+                let is_carrier = other.starts_with("Option<")
+                    || other.starts_with("Result<")
+                    || other.starts_with("Tuple<");
                 let is_sum = registry
                     .variants
                     .values()
                     .flat_map(|v| v.iter())
                     .any(|v| v.parent == other);
-                if registry.record_type_idx(other).is_some() || is_compound || is_sum {
+                if registry.record_type_idx(other).is_some()
+                    || is_compound
+                    || is_sum
+                    || is_carrier
+                {
                     let inner = all_key_helpers
                         .get(&lookup_key)
                         .ok_or(WasmGcError::Validation(format!(
@@ -1538,7 +1620,8 @@ fn emit_eq_record(
                 } else {
                     return Err(WasmGcError::Unimplemented(
                         "phase 3c — record-key field type not in \
-                         {Int, Float, Bool, String, nested record, List<T>, Vector<T>, sum}",
+                         {Int, Float, Bool, String, nested record, List<T>, Vector<T>, sum, \
+                          Option/Result/Tuple}",
                     ));
                 }
             }
diff --git a/src/codegen/wasm_gc/module.rs b/src/codegen/wasm_gc/module.rs
index 4a416efd..1797d5ce 100644
--- a/src/codegen/wasm_gc/module.rs
+++ b/src/codegen/wasm_gc/module.rs
@@ -563,12 +563,6 @@ pub(super) fn emit_module(
             eq_helpers_lookup.insert(name.to_string(), fn_idx);
         }
     }
-    let mut hash_helpers_lookup: HashMap<String, u32> = HashMap::new();
-    for (name, _kind) in hash_helpers_registry.iter() {
-        if let Some(fn_idx) = hash_helpers_registry.lookup_fn_idx(name) {
-            hash_helpers_lookup.insert(name.to_string(), fn_idx);
-        }
-    }
     let fn_map = FnMap {
         by_name,
         builtins: builtin_idx_lookup,
@@ -579,7 +573,6 @@ pub(super) fn emit_module(
         zip_ops: zip_ops_lookup,
         string_split_ops,
         eq_helpers: eq_helpers_lookup,
-        hash_helpers: hash_helpers_lookup,
     };
 
     // ── Export section ─────────────────────────────────────────────
@@ -738,7 +731,26 @@ pub(super) fn emit_module(
             compound_eq_hash_lookup.insert(format!("Vector<{}>", elem.trim()), (eq_fn, hash_fn));
         }
     }
-    map_helpers.emit_helper_bodies(&mut codes, &registry, &compound_eq_hash_lookup)?;
+    // Carrier eq+hash lookup — Option/Result/Tuple instantiations
+    // get their helpers from eq_helpers / hash_helpers; map keys
+    // proxy through these. Build the pair map by zipping the two
+    // registries' fn idxs by canonical.
+    let mut carrier_eq_hash_lookup: HashMap<String, (u32, u32)> = HashMap::new();
+    for (name, kind) in eq_helpers_registry.iter() {
+        use super::body::eq_helpers::EqKind as EK;
+        if matches!(kind, EK::OptionEq | EK::ResultEq | EK::TupleEq)
+            && let Some(eq_fn) = eq_helpers_registry.lookup_fn_idx(name)
+            && let Some(hash_fn) = hash_helpers_registry.lookup_fn_idx(name)
+        {
+            carrier_eq_hash_lookup.insert(name.to_string(), (eq_fn, hash_fn));
+        }
+    }
+    map_helpers.emit_helper_bodies(
+        &mut codes,
+        &registry,
+        &compound_eq_hash_lookup,
+        &carrier_eq_hash_lookup,
+    )?;
 
     // List / Vector.fromList / String.split-join helper bodies.
     // Snapshot eq-helper fn idxs so list/vec eq+hash bodies can
diff --git a/src/codegen/wasm_gc/types.rs b/src/codegen/wasm_gc/types.rs
index 753a59ef..ee8a0a41 100644
--- a/src/codegen/wasm_gc/types.rs
+++ b/src/codegen/wasm_gc/types.rs
@@ -528,6 +528,17 @@ impl TypeRegistry {
                 for (_, ty) in &fd.params {
                     collect_maps_from_str(ty, &mut pending_maps);
                 }
+                // Walk let-binding annotations too — `let m: Map<Person, Int> =
+                // Map.set(…)` won't show up in fn signatures and the discovery
+                // walker would otherwise miss the canonical entirely. Mirrors
+                // what the Result walker added a few commits back.
+                use crate::ast::{FnBody, Stmt};
+                let FnBody::Block(stmts) = fd.body.as_ref();
+                for stmt in stmts {
+                    if let Stmt::Binding(_, Some(annot), _) = stmt {
+                        collect_maps_from_str(annot, &mut pending_maps);
+                    }
+                }
             }
         }
         // Dedup in encounter order.

From cf661471e1f65d4bc8c3d2c206916aae5f680669 Mon Sep 17 00:00:00 2001
From: jasisz <jasisz@gmail.com>
Date: Wed, 6 May 2026 17:22:20 +0200
Subject: [PATCH 12/18] 0.16.3: rustfmt fix

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>
---
 src/codegen/wasm_gc/body/emit.rs         |  18 ++-
 src/codegen/wasm_gc/body/eq_helpers.rs   | 188 +++++++++++++++--------
 src/codegen/wasm_gc/body/hash_helpers.rs | 111 ++++++++-----
 src/codegen/wasm_gc/lists.rs             |  63 +++++---
 src/codegen/wasm_gc/maps.rs              |  31 ++--
 src/codegen/wasm_gc/module.rs            |  12 +-
 6 files changed, 282 insertions(+), 141 deletions(-)

diff --git a/src/codegen/wasm_gc/body/emit.rs b/src/codegen/wasm_gc/body/emit.rs
index 4a8f04cf..9a4a08f7 100644
--- a/src/codegen/wasm_gc/body/emit.rs
+++ b/src/codegen/wasm_gc/body/emit.rs
@@ -582,7 +582,11 @@ fn sum_or_record_eq_fn(operand: &Spanned<Expr>, ctx: &EmitCtx<'_>) -> Option<u32
         crate::types::Type::Option(_)
         | crate::types::Type::Result(_, _)
         | crate::types::Type::Tuple(_) => {
-            let canonical: String = ty.display().chars().filter(|c| !c.is_whitespace()).collect();
+            let canonical: String = ty
+                .display()
+                .chars()
+                .filter(|c| !c.is_whitespace())
+                .collect();
             ctx.fn_map.eq_helpers.get(&canonical).copied()
         }
         // List / Vector — list_helpers / vfl_helpers slot the per-T
@@ -591,11 +595,19 @@ fn sum_or_record_eq_fn(operand: &Spanned<Expr>, ctx: &EmitCtx<'_>) -> Option<u32
         // resolvable; falls through and the surrounding default i64
         // arm fails validation, same as before this PR).
         crate::types::Type::List(_) => {
-            let canonical: String = ty.display().chars().filter(|c| !c.is_whitespace()).collect();
+            let canonical: String = ty
+                .display()
+                .chars()
+                .filter(|c| !c.is_whitespace())
+                .collect();
             ctx.fn_map.list_ops.get(&canonical).and_then(|ops| ops.eq)
         }
         crate::types::Type::Vector(_) => {
-            let canonical: String = ty.display().chars().filter(|c| !c.is_whitespace()).collect();
+            let canonical: String = ty
+                .display()
+                .chars()
+                .filter(|c| !c.is_whitespace())
+                .collect();
             ctx.fn_map.vfl_ops.get(&canonical).and_then(|ops| ops.eq)
         }
         _ => None,
diff --git a/src/codegen/wasm_gc/body/eq_helpers.rs b/src/codegen/wasm_gc/body/eq_helpers.rs
index 2cfbaa64..f999155c 100644
--- a/src/codegen/wasm_gc/body/eq_helpers.rs
+++ b/src/codegen/wasm_gc/body/eq_helpers.rs
@@ -101,9 +101,9 @@ impl EqHelperRegistry {
         // dispatch".
         let mut seen = std::collections::HashSet::new();
         let resolvable = match kind {
-            EqKind::Record => super::super::lists::record_fields_resolvable(
-                type_name, registry, &mut seen,
-            ),
+            EqKind::Record => {
+                super::super::lists::record_fields_resolvable(type_name, registry, &mut seen)
+            }
             EqKind::Sum => {
                 super::super::lists::sum_fields_resolvable(type_name, registry, &mut seen)
             }
@@ -150,7 +150,10 @@ impl EqHelperRegistry {
     }
 
     fn register_field_type(&mut self, field_ty: &str, registry: &TypeRegistry) {
-        if matches!(field_ty, "Int" | "Float" | "Bool" | "String" | "Unit" | "Byte" | "Char") {
+        if matches!(
+            field_ty,
+            "Int" | "Float" | "Bool" | "String" | "Unit" | "Byte" | "Char"
+        ) {
             return;
         }
         if registry.record_fields.contains_key(field_ty) {
@@ -170,7 +173,10 @@ impl EqHelperRegistry {
         // Each instantiation gets its own helper slot keyed by the
         // canonical string. Inner types are walked too so any
         // nominal piece (`Option<Color>` → register Color).
-        if let Some(inner) = field_ty.strip_prefix("Option<").and_then(|s| s.strip_suffix('>')) {
+        if let Some(inner) = field_ty
+            .strip_prefix("Option<")
+            .and_then(|s| s.strip_suffix('>'))
+        {
             self.register_transitive(field_ty, EqKind::OptionEq, registry);
             self.register_field_type(inner.trim(), registry);
         } else if field_ty.starts_with("Result<") && field_ty.ends_with('>') {
@@ -284,11 +290,11 @@ impl EqHelperRegistry {
                     // declare two typed locals (idxs 2, 3), `ref.cast`
                     // each param into its slot, then drive the inline
                     // emitter against the typed locals.
-                    let r_idx = registry.record_type_idx(name).ok_or(
-                        WasmGcError::Validation(format!(
+                    let r_idx = registry
+                        .record_type_idx(name)
+                        .ok_or(WasmGcError::Validation(format!(
                             "eq helper for record `{name}`: record not registered"
-                        )),
-                    )?;
+                        )))?;
                     let r_ref = wasm_encoder::ValType::Ref(wasm_encoder::RefType {
                         nullable: true,
                         heap_type: wasm_encoder::HeapType::Concrete(r_idx),
@@ -315,30 +321,15 @@ impl EqHelperRegistry {
                     codes.function(&f);
                 }
                 EqKind::OptionEq => {
-                    let f = emit_option_eq_body(
-                        name,
-                        registry,
-                        string_eq_fn_idx,
-                        &helper_idx_map,
-                    )?;
+                    let f = emit_option_eq_body(name, registry, string_eq_fn_idx, &helper_idx_map)?;
                     codes.function(&f);
                 }
                 EqKind::ResultEq => {
-                    let f = emit_result_eq_body(
-                        name,
-                        registry,
-                        string_eq_fn_idx,
-                        &helper_idx_map,
-                    )?;
+                    let f = emit_result_eq_body(name, registry, string_eq_fn_idx, &helper_idx_map)?;
                     codes.function(&f);
                 }
                 EqKind::TupleEq => {
-                    let f = emit_tuple_eq_body(
-                        name,
-                        registry,
-                        string_eq_fn_idx,
-                        &helper_idx_map,
-                    )?;
+                    let f = emit_tuple_eq_body(name, registry, string_eq_fn_idx, &helper_idx_map)?;
                     codes.function(&f);
                 }
             }
@@ -363,7 +354,10 @@ impl EqHelperRegistry {
 /// `Result<Ok, Err>` → `Some(("Ok", "Err"))`. Tracks angle/paren
 /// depth so `Result<Map<K,V>, MyError>` splits at the right comma.
 fn parse_result_kv(canonical: &str) -> Option<(&str, &str)> {
-    let inner = canonical.trim().strip_prefix("Result<")?.strip_suffix('>')?;
+    let inner = canonical
+        .trim()
+        .strip_prefix("Result<")?
+        .strip_suffix('>')?;
     let bytes = inner.as_bytes();
     let mut depth: i32 = 0;
     for (idx, b) in bytes.iter().enumerate() {
@@ -412,12 +406,14 @@ fn emit_option_eq_body(
     string_eq_fn_idx: Option<u32>,
     helper_idx_map: &HashMap<String, u32>,
 ) -> Result<Function, WasmGcError> {
-    let opt_idx = registry.option_type_idx(canonical).ok_or(
-        WasmGcError::Validation(format!("eq helper for `{canonical}`: option not registered")),
-    )?;
-    let inner = TypeRegistry::option_element_type(canonical).ok_or(
-        WasmGcError::Validation(format!("eq helper for `{canonical}`: can't parse inner")),
-    )?;
+    let opt_idx = registry
+        .option_type_idx(canonical)
+        .ok_or(WasmGcError::Validation(format!(
+            "eq helper for `{canonical}`: option not registered"
+        )))?;
+    let inner = TypeRegistry::option_element_type(canonical).ok_or(WasmGcError::Validation(
+        format!("eq helper for `{canonical}`: can't parse inner"),
+    ))?;
     let opt_ref = wasm_encoder::ValType::Ref(wasm_encoder::RefType {
         nullable: true,
         heap_type: wasm_encoder::HeapType::Concrete(opt_idx),
@@ -433,9 +429,15 @@ fn emit_option_eq_body(
     f.instruction(&Instruction::LocalSet(3));
     // if tag(lhs) != tag(rhs) → return 0
     f.instruction(&Instruction::LocalGet(2));
-    f.instruction(&Instruction::StructGet { struct_type_index: opt_idx, field_index: 0 });
+    f.instruction(&Instruction::StructGet {
+        struct_type_index: opt_idx,
+        field_index: 0,
+    });
     f.instruction(&Instruction::LocalGet(3));
-    f.instruction(&Instruction::StructGet { struct_type_index: opt_idx, field_index: 0 });
+    f.instruction(&Instruction::StructGet {
+        struct_type_index: opt_idx,
+        field_index: 0,
+    });
     f.instruction(&Instruction::I32Ne);
     f.instruction(&Instruction::If(wasm_encoder::BlockType::Empty));
     f.instruction(&Instruction::I32Const(0));
@@ -443,7 +445,10 @@ fn emit_option_eq_body(
     f.instruction(&Instruction::End);
     // tags equal — if 0 (None), return 1
     f.instruction(&Instruction::LocalGet(2));
-    f.instruction(&Instruction::StructGet { struct_type_index: opt_idx, field_index: 0 });
+    f.instruction(&Instruction::StructGet {
+        struct_type_index: opt_idx,
+        field_index: 0,
+    });
     f.instruction(&Instruction::I32Eqz);
     f.instruction(&Instruction::If(wasm_encoder::BlockType::Empty));
     f.instruction(&Instruction::I32Const(1));
@@ -451,10 +456,22 @@ fn emit_option_eq_body(
     f.instruction(&Instruction::End);
     // Both Some — compare inner via per-type dispatch.
     f.instruction(&Instruction::LocalGet(2));
-    f.instruction(&Instruction::StructGet { struct_type_index: opt_idx, field_index: 1 });
+    f.instruction(&Instruction::StructGet {
+        struct_type_index: opt_idx,
+        field_index: 1,
+    });
     f.instruction(&Instruction::LocalGet(3));
-    f.instruction(&Instruction::StructGet { struct_type_index: opt_idx, field_index: 1 });
-    emit_inner_eq_dispatch(&mut f, inner.trim(), registry, string_eq_fn_idx, helper_idx_map)?;
+    f.instruction(&Instruction::StructGet {
+        struct_type_index: opt_idx,
+        field_index: 1,
+    });
+    emit_inner_eq_dispatch(
+        &mut f,
+        inner.trim(),
+        registry,
+        string_eq_fn_idx,
+        helper_idx_map,
+    )?;
     f.instruction(&Instruction::End);
     Ok(f)
 }
@@ -469,12 +486,14 @@ fn emit_result_eq_body(
     string_eq_fn_idx: Option<u32>,
     helper_idx_map: &HashMap<String, u32>,
 ) -> Result<Function, WasmGcError> {
-    let res_idx = registry.result_type_idx(canonical).ok_or(
-        WasmGcError::Validation(format!("eq helper for `{canonical}`: result not registered")),
-    )?;
-    let (ok_inner, err_inner) = parse_result_kv(canonical).ok_or(
-        WasmGcError::Validation(format!("eq helper for `{canonical}`: can't parse inner")),
-    )?;
+    let res_idx = registry
+        .result_type_idx(canonical)
+        .ok_or(WasmGcError::Validation(format!(
+            "eq helper for `{canonical}`: result not registered"
+        )))?;
+    let (ok_inner, err_inner) = parse_result_kv(canonical).ok_or(WasmGcError::Validation(
+        format!("eq helper for `{canonical}`: can't parse inner"),
+    ))?;
     let res_ref = wasm_encoder::ValType::Ref(wasm_encoder::RefType {
         nullable: true,
         heap_type: wasm_encoder::HeapType::Concrete(res_idx),
@@ -489,9 +508,15 @@ fn emit_result_eq_body(
     f.instruction(&Instruction::LocalSet(3));
     // if tag(lhs) != tag(rhs) → 0
     f.instruction(&Instruction::LocalGet(2));
-    f.instruction(&Instruction::StructGet { struct_type_index: res_idx, field_index: 0 });
+    f.instruction(&Instruction::StructGet {
+        struct_type_index: res_idx,
+        field_index: 0,
+    });
     f.instruction(&Instruction::LocalGet(3));
-    f.instruction(&Instruction::StructGet { struct_type_index: res_idx, field_index: 0 });
+    f.instruction(&Instruction::StructGet {
+        struct_type_index: res_idx,
+        field_index: 0,
+    });
     f.instruction(&Instruction::I32Ne);
     f.instruction(&Instruction::If(wasm_encoder::BlockType::Empty));
     f.instruction(&Instruction::I32Const(0));
@@ -500,21 +525,50 @@ fn emit_result_eq_body(
     // tags equal — branch on tag value: tag=1 (Ok) → field 1 eq;
     // tag=0 (Err) → field 2 eq.
     f.instruction(&Instruction::LocalGet(2));
-    f.instruction(&Instruction::StructGet { struct_type_index: res_idx, field_index: 0 });
-    f.instruction(&Instruction::If(wasm_encoder::BlockType::Result(wasm_encoder::ValType::I32)));
+    f.instruction(&Instruction::StructGet {
+        struct_type_index: res_idx,
+        field_index: 0,
+    });
+    f.instruction(&Instruction::If(wasm_encoder::BlockType::Result(
+        wasm_encoder::ValType::I32,
+    )));
     // Ok arm
     f.instruction(&Instruction::LocalGet(2));
-    f.instruction(&Instruction::StructGet { struct_type_index: res_idx, field_index: 1 });
+    f.instruction(&Instruction::StructGet {
+        struct_type_index: res_idx,
+        field_index: 1,
+    });
     f.instruction(&Instruction::LocalGet(3));
-    f.instruction(&Instruction::StructGet { struct_type_index: res_idx, field_index: 1 });
-    emit_inner_eq_dispatch(&mut f, ok_inner.trim(), registry, string_eq_fn_idx, helper_idx_map)?;
+    f.instruction(&Instruction::StructGet {
+        struct_type_index: res_idx,
+        field_index: 1,
+    });
+    emit_inner_eq_dispatch(
+        &mut f,
+        ok_inner.trim(),
+        registry,
+        string_eq_fn_idx,
+        helper_idx_map,
+    )?;
     f.instruction(&Instruction::Else);
     // Err arm
     f.instruction(&Instruction::LocalGet(2));
-    f.instruction(&Instruction::StructGet { struct_type_index: res_idx, field_index: 2 });
+    f.instruction(&Instruction::StructGet {
+        struct_type_index: res_idx,
+        field_index: 2,
+    });
     f.instruction(&Instruction::LocalGet(3));
-    f.instruction(&Instruction::StructGet { struct_type_index: res_idx, field_index: 2 });
-    emit_inner_eq_dispatch(&mut f, err_inner.trim(), registry, string_eq_fn_idx, helper_idx_map)?;
+    f.instruction(&Instruction::StructGet {
+        struct_type_index: res_idx,
+        field_index: 2,
+    });
+    emit_inner_eq_dispatch(
+        &mut f,
+        err_inner.trim(),
+        registry,
+        string_eq_fn_idx,
+        helper_idx_map,
+    )?;
     f.instruction(&Instruction::End);
     f.instruction(&Instruction::End);
     Ok(f)
@@ -528,12 +582,14 @@ fn emit_tuple_eq_body(
     string_eq_fn_idx: Option<u32>,
     helper_idx_map: &HashMap<String, u32>,
 ) -> Result<Function, WasmGcError> {
-    let tup_idx = registry.tuple_type_idx(canonical).ok_or(
-        WasmGcError::Validation(format!("eq helper for `{canonical}`: tuple not registered")),
-    )?;
-    let elems = parse_tuple_elems(canonical).ok_or(
-        WasmGcError::Validation(format!("eq helper for `{canonical}`: can't parse elements")),
-    )?;
+    let tup_idx = registry
+        .tuple_type_idx(canonical)
+        .ok_or(WasmGcError::Validation(format!(
+            "eq helper for `{canonical}`: tuple not registered"
+        )))?;
+    let elems = parse_tuple_elems(canonical).ok_or(WasmGcError::Validation(format!(
+        "eq helper for `{canonical}`: can't parse elements"
+    )))?;
     let tup_ref = wasm_encoder::ValType::Ref(wasm_encoder::RefType {
         nullable: true,
         heap_type: wasm_encoder::HeapType::Concrete(tup_idx),
@@ -557,7 +613,13 @@ fn emit_tuple_eq_body(
             struct_type_index: tup_idx,
             field_index: i as u32,
         });
-        emit_inner_eq_dispatch(&mut f, elem.trim(), registry, string_eq_fn_idx, helper_idx_map)?;
+        emit_inner_eq_dispatch(
+            &mut f,
+            elem.trim(),
+            registry,
+            string_eq_fn_idx,
+            helper_idx_map,
+        )?;
         if i > 0 {
             f.instruction(&Instruction::I32And);
         }
diff --git a/src/codegen/wasm_gc/body/hash_helpers.rs b/src/codegen/wasm_gc/body/hash_helpers.rs
index a39b249a..0ee468a5 100644
--- a/src/codegen/wasm_gc/body/hash_helpers.rs
+++ b/src/codegen/wasm_gc/body/hash_helpers.rs
@@ -80,9 +80,9 @@ impl HashHelperRegistry {
         }
         let mut seen = std::collections::HashSet::new();
         let resolvable = match kind {
-            HashKind::Record => super::super::lists::record_fields_resolvable(
-                type_name, registry, &mut seen,
-            ),
+            HashKind::Record => {
+                super::super::lists::record_fields_resolvable(type_name, registry, &mut seen)
+            }
             HashKind::Sum => {
                 super::super::lists::sum_fields_resolvable(type_name, registry, &mut seen)
             }
@@ -119,7 +119,10 @@ impl HashHelperRegistry {
     }
 
     fn register_field_type(&mut self, field_ty: &str, registry: &TypeRegistry) {
-        if matches!(field_ty, "Int" | "Float" | "Bool" | "String" | "Unit" | "Byte" | "Char") {
+        if matches!(
+            field_ty,
+            "Int" | "Float" | "Bool" | "String" | "Unit" | "Byte" | "Char"
+        ) {
             return;
         }
         if registry.record_fields.contains_key(field_ty) {
@@ -135,7 +138,10 @@ impl HashHelperRegistry {
             self.register_transitive(field_ty, HashKind::Sum, registry);
             return;
         }
-        if let Some(inner) = field_ty.strip_prefix("Option<").and_then(|s| s.strip_suffix('>')) {
+        if let Some(inner) = field_ty
+            .strip_prefix("Option<")
+            .and_then(|s| s.strip_suffix('>'))
+        {
             self.register_transitive(field_ty, HashKind::OptionHash, registry);
             self.register_field_type(inner.trim(), registry);
         } else if field_ty.starts_with("Result<") && field_ty.ends_with('>') {
@@ -186,9 +192,7 @@ impl HashHelperRegistry {
             },
         });
         for _ in &self.order {
-            types
-                .ty()
-                .function([eq_ref], [wasm_encoder::ValType::I32]);
+            types.ty().function([eq_ref], [wasm_encoder::ValType::I32]);
         }
     }
 
@@ -247,9 +251,12 @@ fn emit_record_hash_body(
         .ok_or(WasmGcError::Validation(format!(
             "hash helper for record `{name}`: not registered"
         )))?;
-    let fields = registry.record_fields.get(name).ok_or(
-        WasmGcError::Validation(format!("hash helper for record `{name}`: no fields")),
-    )?;
+    let fields = registry
+        .record_fields
+        .get(name)
+        .ok_or(WasmGcError::Validation(format!(
+            "hash helper for record `{name}`: no fields"
+        )))?;
     let r_ref = wasm_encoder::ValType::Ref(wasm_encoder::RefType {
         nullable: true,
         heap_type: wasm_encoder::HeapType::Concrete(r_idx),
@@ -368,12 +375,14 @@ fn emit_option_hash_body(
     registry: &TypeRegistry,
     helper_idx_map: &HashMap<String, u32>,
 ) -> Result<Function, WasmGcError> {
-    let opt_idx = registry.option_type_idx(canonical).ok_or(
-        WasmGcError::Validation(format!("hash helper for `{canonical}`: option not registered")),
-    )?;
-    let inner = TypeRegistry::option_element_type(canonical).ok_or(
-        WasmGcError::Validation(format!("hash helper for `{canonical}`: can't parse inner")),
-    )?;
+    let opt_idx = registry
+        .option_type_idx(canonical)
+        .ok_or(WasmGcError::Validation(format!(
+            "hash helper for `{canonical}`: option not registered"
+        )))?;
+    let inner = TypeRegistry::option_element_type(canonical).ok_or(WasmGcError::Validation(
+        format!("hash helper for `{canonical}`: can't parse inner"),
+    ))?;
     let opt_ref = wasm_encoder::ValType::Ref(wasm_encoder::RefType {
         nullable: true,
         heap_type: wasm_encoder::HeapType::Concrete(opt_idx),
@@ -393,12 +402,18 @@ fn emit_option_hash_body(
     f.instruction(&Instruction::LocalGet(2));
     f.instruction(&Instruction::I32Add);
     f.instruction(&Instruction::LocalGet(1));
-    f.instruction(&Instruction::StructGet { struct_type_index: opt_idx, field_index: 0 });
+    f.instruction(&Instruction::StructGet {
+        struct_type_index: opt_idx,
+        field_index: 0,
+    });
     f.instruction(&Instruction::I32Add);
     f.instruction(&Instruction::LocalSet(2));
     // if Some (tag != 0), mix inner hash into h.
     f.instruction(&Instruction::LocalGet(1));
-    f.instruction(&Instruction::StructGet { struct_type_index: opt_idx, field_index: 0 });
+    f.instruction(&Instruction::StructGet {
+        struct_type_index: opt_idx,
+        field_index: 0,
+    });
     f.instruction(&Instruction::If(wasm_encoder::BlockType::Empty));
     f.instruction(&Instruction::LocalGet(2));
     f.instruction(&Instruction::I32Const(5));
@@ -406,7 +421,10 @@ fn emit_option_hash_body(
     f.instruction(&Instruction::LocalGet(2));
     f.instruction(&Instruction::I32Add);
     f.instruction(&Instruction::LocalGet(1));
-    f.instruction(&Instruction::StructGet { struct_type_index: opt_idx, field_index: 1 });
+    f.instruction(&Instruction::StructGet {
+        struct_type_index: opt_idx,
+        field_index: 1,
+    });
     emit_inner_hash_dispatch(&mut f, inner.trim(), registry, helper_idx_map, None)?;
     f.instruction(&Instruction::I32Add);
     f.instruction(&Instruction::LocalSet(2));
@@ -422,12 +440,14 @@ fn emit_result_hash_body(
     registry: &TypeRegistry,
     helper_idx_map: &HashMap<String, u32>,
 ) -> Result<Function, WasmGcError> {
-    let res_idx = registry.result_type_idx(canonical).ok_or(
-        WasmGcError::Validation(format!("hash helper for `{canonical}`: result not registered")),
-    )?;
-    let (ok_inner, err_inner) = parse_result_kv(canonical).ok_or(
-        WasmGcError::Validation(format!("hash helper for `{canonical}`: can't parse inner")),
-    )?;
+    let res_idx = registry
+        .result_type_idx(canonical)
+        .ok_or(WasmGcError::Validation(format!(
+            "hash helper for `{canonical}`: result not registered"
+        )))?;
+    let (ok_inner, err_inner) = parse_result_kv(canonical).ok_or(WasmGcError::Validation(
+        format!("hash helper for `{canonical}`: can't parse inner"),
+    ))?;
     let res_ref = wasm_encoder::ValType::Ref(wasm_encoder::RefType {
         nullable: true,
         heap_type: wasm_encoder::HeapType::Concrete(res_idx),
@@ -446,12 +466,18 @@ fn emit_result_hash_body(
     f.instruction(&Instruction::LocalGet(2));
     f.instruction(&Instruction::I32Add);
     f.instruction(&Instruction::LocalGet(1));
-    f.instruction(&Instruction::StructGet { struct_type_index: res_idx, field_index: 0 });
+    f.instruction(&Instruction::StructGet {
+        struct_type_index: res_idx,
+        field_index: 0,
+    });
     f.instruction(&Instruction::I32Add);
     f.instruction(&Instruction::LocalSet(2));
     // Branch on tag.
     f.instruction(&Instruction::LocalGet(1));
-    f.instruction(&Instruction::StructGet { struct_type_index: res_idx, field_index: 0 });
+    f.instruction(&Instruction::StructGet {
+        struct_type_index: res_idx,
+        field_index: 0,
+    });
     f.instruction(&Instruction::If(wasm_encoder::BlockType::Empty));
     // Ok arm: mix field 1 (ok) into h.
     f.instruction(&Instruction::LocalGet(2));
@@ -460,7 +486,10 @@ fn emit_result_hash_body(
     f.instruction(&Instruction::LocalGet(2));
     f.instruction(&Instruction::I32Add);
     f.instruction(&Instruction::LocalGet(1));
-    f.instruction(&Instruction::StructGet { struct_type_index: res_idx, field_index: 1 });
+    f.instruction(&Instruction::StructGet {
+        struct_type_index: res_idx,
+        field_index: 1,
+    });
     emit_inner_hash_dispatch(&mut f, ok_inner.trim(), registry, helper_idx_map, None)?;
     f.instruction(&Instruction::I32Add);
     f.instruction(&Instruction::LocalSet(2));
@@ -472,7 +501,10 @@ fn emit_result_hash_body(
     f.instruction(&Instruction::LocalGet(2));
     f.instruction(&Instruction::I32Add);
     f.instruction(&Instruction::LocalGet(1));
-    f.instruction(&Instruction::StructGet { struct_type_index: res_idx, field_index: 2 });
+    f.instruction(&Instruction::StructGet {
+        struct_type_index: res_idx,
+        field_index: 2,
+    });
     emit_inner_hash_dispatch(&mut f, err_inner.trim(), registry, helper_idx_map, None)?;
     f.instruction(&Instruction::I32Add);
     f.instruction(&Instruction::LocalSet(2));
@@ -488,12 +520,14 @@ fn emit_tuple_hash_body(
     registry: &TypeRegistry,
     helper_idx_map: &HashMap<String, u32>,
 ) -> Result<Function, WasmGcError> {
-    let tup_idx = registry.tuple_type_idx(canonical).ok_or(
-        WasmGcError::Validation(format!("hash helper for `{canonical}`: tuple not registered")),
-    )?;
-    let elems = parse_tuple_elems(canonical).ok_or(
-        WasmGcError::Validation(format!("hash helper for `{canonical}`: can't parse elements")),
-    )?;
+    let tup_idx = registry
+        .tuple_type_idx(canonical)
+        .ok_or(WasmGcError::Validation(format!(
+            "hash helper for `{canonical}`: tuple not registered"
+        )))?;
+    let elems = parse_tuple_elems(canonical).ok_or(WasmGcError::Validation(format!(
+        "hash helper for `{canonical}`: can't parse elements"
+    )))?;
     let tup_ref = wasm_encoder::ValType::Ref(wasm_encoder::RefType {
         nullable: true,
         heap_type: wasm_encoder::HeapType::Concrete(tup_idx),
@@ -576,7 +610,10 @@ fn emit_inner_hash_dispatch(
 /// `Result<Ok, Err>` → `Some(("Ok", "Err"))`. Tracks angle/paren
 /// depth so `Result<Map<K,V>, MyError>` splits at the right comma.
 fn parse_result_kv(canonical: &str) -> Option<(&str, &str)> {
-    let inner = canonical.trim().strip_prefix("Result<")?.strip_suffix('>')?;
+    let inner = canonical
+        .trim()
+        .strip_prefix("Result<")?
+        .strip_suffix('>')?;
     let bytes = inner.as_bytes();
     let mut depth: i32 = 0;
     for (idx, b) in bytes.iter().enumerate() {
diff --git a/src/codegen/wasm_gc/lists.rs b/src/codegen/wasm_gc/lists.rs
index 411cbd18..aea2c38e 100644
--- a/src/codegen/wasm_gc/lists.rs
+++ b/src/codegen/wasm_gc/lists.rs
@@ -796,10 +796,16 @@ pub(super) fn field_type_resolvable(
     // Resolvable iff every inner type is itself resolvable.
     // List/Vector/Map field types still fall through (their dispatch
     // from `emit_record_eq_inline` is a separate followup).
-    if let Some(inner) = field.strip_prefix("Option<").and_then(|s| s.strip_suffix('>')) {
+    if let Some(inner) = field
+        .strip_prefix("Option<")
+        .and_then(|s| s.strip_suffix('>'))
+    {
         return field_type_resolvable(inner.trim(), registry, seen);
     }
-    if let Some(inner) = field.strip_prefix("Result<").and_then(|s| s.strip_suffix('>')) {
+    if let Some(inner) = field
+        .strip_prefix("Result<")
+        .and_then(|s| s.strip_suffix('>'))
+    {
         let bytes = inner.as_bytes();
         let mut depth: i32 = 0;
         for (idx, b) in bytes.iter().enumerate() {
@@ -817,7 +823,10 @@ pub(super) fn field_type_resolvable(
         }
         return false;
     }
-    if let Some(inner) = field.strip_prefix("Tuple<").and_then(|s| s.strip_suffix('>')) {
+    if let Some(inner) = field
+        .strip_prefix("Tuple<")
+        .and_then(|s| s.strip_suffix('>'))
+    {
         let bytes = inner.as_bytes();
         let mut depth: i32 = 0;
         let mut start = 0;
@@ -2152,12 +2161,13 @@ fn emit_list_eq(
             // `__eq_<X>` helper. Its signature is
             // `(eqref, eqref) -> i32`; both refs on the stack are
             // subtypes of eqref so the implicit upcast is fine.
-            let idx = eq_helper_fn_idx.get(name).copied().ok_or(
-                WasmGcError::Validation(format!(
+            let idx = eq_helper_fn_idx
+                .get(name)
+                .copied()
+                .ok_or(WasmGcError::Validation(format!(
                     "List eq over `{name}`: __eq_{name} helper not registered \
                      (discovery walker should have transitively flagged it)"
-                )),
-            )?;
+                )))?;
             f.instruction(&Instruction::Call(idx));
         }
     }
@@ -2300,8 +2310,13 @@ fn emit_list_hash(
                     "list hash dispatch: record `{record_name}` has no field info"
                 )))?;
             emit_record_inline_hash(
-                &mut f, r_idx, fields, /* elem_local */ 3, /* elem_hash_local */ 4,
-                registry, hash_helper_fn_idx,
+                &mut f,
+                r_idx,
+                fields,
+                /* elem_local */ 3,
+                /* elem_hash_local */ 4,
+                registry,
+                hash_helper_fn_idx,
             )?;
         }
         ListEqKind::SumEq(parent_name) => {
@@ -2402,12 +2417,12 @@ fn emit_sum_inline_hash(
                 struct_type_index: v_idx,
                 field_index: i as u32,
             });
-            let resolved: String =
-                if let Some(under) = registry.newtype_underlying(field_ty.trim()) {
-                    under.to_string()
-                } else {
-                    field_ty.trim().to_string()
-                };
+            let resolved: String = if let Some(under) = registry.newtype_underlying(field_ty.trim())
+            {
+                under.to_string()
+            } else {
+                field_ty.trim().to_string()
+            };
             match resolved.as_str() {
                 "Int" => {
                     f.instruction(&Instruction::I32WrapI64);
@@ -2575,11 +2590,12 @@ fn emit_vec_eq(
         ListEqKind::RecordEq(name) | ListEqKind::SumEq(name) => {
             // Nominal element — `Call(__eq_<X>)`. Same eqref upcast
             // shape as in `emit_list_eq`.
-            let idx = eq_helper_fn_idx.get(name).copied().ok_or(
-                WasmGcError::Validation(format!(
+            let idx = eq_helper_fn_idx
+                .get(name)
+                .copied()
+                .ok_or(WasmGcError::Validation(format!(
                     "Vector eq over `{name}`: __eq_{name} helper not registered"
-                )),
-            )?;
+                )))?;
             f.instruction(&Instruction::Call(idx));
         }
     }
@@ -2693,8 +2709,13 @@ fn emit_vec_hash(
                     "vector hash dispatch: record `{record_name}` has no field info"
                 )))?;
             emit_record_inline_hash(
-                &mut f, r_idx, fields, /* elem_local */ 4, /* elem_hash_local */ 5,
-                registry, hash_helper_fn_idx,
+                &mut f,
+                r_idx,
+                fields,
+                /* elem_local */ 4,
+                /* elem_hash_local */ 5,
+                registry,
+                hash_helper_fn_idx,
             )?;
         }
         ListEqKind::SumEq(parent_name) => {
diff --git a/src/codegen/wasm_gc/maps.rs b/src/codegen/wasm_gc/maps.rs
index 194b97b2..cf5b4f1c 100644
--- a/src/codegen/wasm_gc/maps.rs
+++ b/src/codegen/wasm_gc/maps.rs
@@ -545,7 +545,10 @@ impl MapHelperRegistry {
         for (carrier, &(eq_fn, hash_fn)) in carrier_eq_hash {
             all_key_helpers.insert(
                 carrier.clone(),
-                KeyHelpers { hash: hash_fn, eq: eq_fn },
+                KeyHelpers {
+                    hash: hash_fn,
+                    eq: eq_fn,
+                },
             );
         }
         for (list_canonical, &(eq_fn, hash_fn)) in list_eq_hash {
@@ -629,9 +632,11 @@ fn emit_hash_for(
     {
         // Same shape as carrier eq: proxy to the per-instantiation
         // `__hash_<X>` helper from `hash_helpers`.
-        let helpers = all_key_helpers.get(k_aver).ok_or(WasmGcError::Validation(
-            format!("hash_for: carrier `{k_aver}` has no registered hash helper"),
-        ))?;
+        let helpers = all_key_helpers
+            .get(k_aver)
+            .ok_or(WasmGcError::Validation(format!(
+                "hash_for: carrier `{k_aver}` has no registered hash helper"
+            )))?;
         let mut f = Function::new([]);
         f.instruction(&Instruction::LocalGet(0));
         f.instruction(&Instruction::Call(helpers.hash));
@@ -674,9 +679,11 @@ fn emit_eq_for(
         // `__eq_<X>` helper registered in `eq_helpers` (looked up
         // via `all_key_helpers` which includes the carrier eq fn
         // idx forwarded from the registry).
-        let helpers = all_key_helpers.get(k_aver).ok_or(WasmGcError::Validation(
-            format!("eq_for: carrier `{k_aver}` has no registered eq helper"),
-        ))?;
+        let helpers = all_key_helpers
+            .get(k_aver)
+            .ok_or(WasmGcError::Validation(format!(
+                "eq_for: carrier `{k_aver}` has no registered eq helper"
+            )))?;
         let mut f = Function::new([]);
         f.instruction(&Instruction::LocalGet(0));
         f.instruction(&Instruction::LocalGet(1));
@@ -1519,10 +1526,7 @@ fn emit_hash_record(
                     .values()
                     .flat_map(|v| v.iter())
                     .any(|v| v.parent == other);
-                if registry.record_type_idx(other).is_some()
-                    || is_compound
-                    || is_sum
-                    || is_carrier
+                if registry.record_type_idx(other).is_some() || is_compound || is_sum || is_carrier
                 {
                     let inner = all_key_helpers
                         .get(&lookup_key)
@@ -1606,10 +1610,7 @@ fn emit_eq_record(
                     .values()
                     .flat_map(|v| v.iter())
                     .any(|v| v.parent == other);
-                if registry.record_type_idx(other).is_some()
-                    || is_compound
-                    || is_sum
-                    || is_carrier
+                if registry.record_type_idx(other).is_some() || is_compound || is_sum || is_carrier
                 {
                     let inner = all_key_helpers
                         .get(&lookup_key)
diff --git a/src/codegen/wasm_gc/module.rs b/src/codegen/wasm_gc/module.rs
index 1797d5ce..80346bed 100644
--- a/src/codegen/wasm_gc/module.rs
+++ b/src/codegen/wasm_gc/module.rs
@@ -758,11 +758,19 @@ pub(super) fn emit_module(
     let string_eq_fn_idx = builtin_registry.lookup_wasm_fn_idx(BuiltinName::StringEq);
     let eq_helper_fn_idx_map: HashMap<String, u32> = eq_helpers_registry
         .iter()
-        .filter_map(|(n, _k)| eq_helpers_registry.lookup_fn_idx(n).map(|i| (n.to_string(), i)))
+        .filter_map(|(n, _k)| {
+            eq_helpers_registry
+                .lookup_fn_idx(n)
+                .map(|i| (n.to_string(), i))
+        })
         .collect();
     let hash_helper_fn_idx_map: HashMap<String, u32> = hash_helpers_registry
         .iter()
-        .filter_map(|(n, _k)| hash_helpers_registry.lookup_fn_idx(n).map(|i| (n.to_string(), i)))
+        .filter_map(|(n, _k)| {
+            hash_helpers_registry
+                .lookup_fn_idx(n)
+                .map(|i| (n.to_string(), i))
+        })
         .collect();
     list_helpers.emit_helper_bodies(
         &mut codes,

From d9dec4f9c1c73c5b81ed29db779c205642dbb211 Mon Sep 17 00:00:00 2001
From: jasisz <jasisz@gmail.com>
Date: Wed, 6 May 2026 18:35:40 +0200
Subject: [PATCH 13/18] 0.16.3: List/Vector elements + Map keys close the
 eq/hash matrix
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Adds carrier (Option/Result/Tuple) and List/Vector handling at three
layers that were previously gated to primitives + flat record/sum:

- list_eq_kind extended with `CarrierEq(canonical)` for Option<X> /
  Result<X,Y> / Tuple<…> / List<X> / Vector<X> elements. Element
  dispatch is `Call(__eq_<canonical>)` — same calling convention as
  record/sum, so the same kind variant covers all of them.
- field_type_resolvable now accepts List<X>/Vector<X> when the inner
  type is itself resolvable, so a record with a `List<Option<Int>>`
  field gets a registered eq+hash helper instead of falling through
  to the i64-default validation error.
- register_field_type recurses into List/Vector inner types in both
  eq_helpers and hash_helpers; carrier register_transitive now walks
  inner types too so direct top-level seeding of a carrier still
  picks up its inner shape (fixes tetris: `Option<PieceKind>` seeded
  via List element walker without PieceKind itself getting a sum
  helper otherwise).
- emit_helper_bodies (eq + hash) takes a `compound_lookup` arg
  threading List<T>/Vector<T> fn idxs into the helper map so a
  record field of compound type can `Call(__eq_List<…>)`.
- MapHelperRegistry whitelists List<T>/Vector<T> as K, with proxy
  bodies in emit_eq_for / emit_hash_for. Map.remove now picks the
  null heap type via `key_storage_null_heap` (concrete idx for
  primitive-box / String / record / carrier / List / Vector,
  abstract Eq for sum K) instead of the old primitive-only fallback
  to type idx 0.
- Discovery seed walker registers carriers in eq_helpers /
  hash_helpers when they appear as List/Vector elements or Map K,
  so list-helper bodies dispatch carrier elements correctly.

Coverage:

  shape_a  Map<List<Int>, String>             ✓
  shape_d  record { List<Option<Int>> }       ✓
  shape_h  List<List<Int>> ==                 ✓
  shape_k  record { Vector<Option<Int>> }     ✓
  shape_l  Map<Vector<Int>, String>           ✓
  exo_hash Map<Person, Int> w/ Option field   ✓
  + 7 carrier exotics, 3 bug repros, 7/7 games

621/621 lib tests, no regressions.

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>
---
 src/codegen/wasm_gc/body/eq_helpers.rs   |  71 +++++++++++---
 src/codegen/wasm_gc/body/hash_helpers.rs |  49 +++++++++-
 src/codegen/wasm_gc/lists.rs             | 115 ++++++++++++++++++++---
 src/codegen/wasm_gc/maps.rs              |  81 ++++++++++++----
 src/codegen/wasm_gc/module.rs            |  51 +++++++++-
 5 files changed, 314 insertions(+), 53 deletions(-)

diff --git a/src/codegen/wasm_gc/body/eq_helpers.rs b/src/codegen/wasm_gc/body/eq_helpers.rs
index f999155c..fcacfd51 100644
--- a/src/codegen/wasm_gc/body/eq_helpers.rs
+++ b/src/codegen/wasm_gc/body/eq_helpers.rs
@@ -139,13 +139,34 @@ impl EqHelperRegistry {
                     }
                 }
             }
-            // Carrier kinds — inner-type registration is handled by
-            // the surrounding `register_field_type` arm that decides
-            // to register the carrier in the first place. Nothing
-            // extra to walk here (the helper body inspects the
-            // canonical at emit time via `option_element_type` /
-            // `parse_result_kv` / `parse_tuple_elems`).
-            EqKind::OptionEq | EqKind::ResultEq | EqKind::TupleEq => {}
+            // Carrier kinds — recurse into inner types so a direct
+            // top-level register (e.g. discovery seed walker hitting
+            // `Option<PieceKind>` from a `List<Option<PieceKind>>`)
+            // still registers PieceKind. When the carrier is reached
+            // via `register_field_type` the recursion happens there
+            // too; this duplicate is idempotent (slots dedup by
+            // canonical).
+            EqKind::OptionEq => {
+                if let Some(inner) = type_name
+                    .strip_prefix("Option<")
+                    .and_then(|s| s.strip_suffix('>'))
+                {
+                    self.register_field_type(inner.trim(), registry);
+                }
+            }
+            EqKind::ResultEq => {
+                if let Some((ok, err)) = parse_result_kv(type_name) {
+                    self.register_field_type(ok.trim(), registry);
+                    self.register_field_type(err.trim(), registry);
+                }
+            }
+            EqKind::TupleEq => {
+                if let Some(elems) = parse_tuple_elems(type_name) {
+                    for e in elems {
+                        self.register_field_type(e.trim(), registry);
+                    }
+                }
+            }
         }
     }
 
@@ -192,13 +213,25 @@ impl EqHelperRegistry {
                     self.register_field_type(elem.trim(), registry);
                 }
             }
+        } else if let Some(inner) = field_ty
+            .strip_prefix("List<")
+            .and_then(|s| s.strip_suffix('>'))
+        {
+            // List<X> / Vector<X> — element kind needs its own
+            // helper too. The list_helpers slot itself is owned by
+            // ListHelperRegistry (separate registry); this walk
+            // ensures the per-element `__eq_<inner>` exists in
+            // eq_helpers when inner is a carrier or nominal type.
+            self.register_field_type(inner.trim(), registry);
+        } else if let Some(inner) = field_ty
+            .strip_prefix("Vector<")
+            .and_then(|s| s.strip_suffix('>'))
+        {
+            self.register_field_type(inner.trim(), registry);
         }
-        // List<T>, Vector<T>, Map<K,V> — those have their own
-        // helper machinery (list_helpers/map_helpers fn idxs).
-        // BinOp::Eq dispatch on collections is covered by the
-        // separate body/emit.rs path; field-of-record holding a
-        // collection still falls through here. Followup if real
-        // programs surface it.
+        // Map<K,V> still falls through — record-of-Map field eq is a
+        // separate followup (the map's own equality semantics aren't
+        // canonical: insertion-order vs structural).
     }
 
     pub(crate) fn iter(&self) -> impl Iterator<Item = (&str, EqKind)> + '_ {
@@ -248,18 +281,26 @@ impl EqHelperRegistry {
         codes: &mut wasm_encoder::CodeSection,
         registry: &TypeRegistry,
         string_eq_fn_idx: Option<u32>,
+        compound_lookup: &HashMap<String, u32>,
     ) -> Result<(), WasmGcError> {
         // Snapshot type_name → fn_idx so the inline emitters can
         // dispatch nested record/sum fields by `Call(idx)` instead
         // of erroring on `Unimplemented`. Self-recursive fields
         // (parent==field) get their own `self_fn_idx` argument so
         // recursive sum/record types (Tree.Node holding Tree, …)
-        // resolve to a recursive call into the same helper.
-        let helper_idx_map: HashMap<String, u32> = self
+        // resolve to a recursive call into the same helper. Compound
+        // lookups (`List<T>`, `Vector<T>`) are merged in so a record
+        // field of type `List<Option<Int>>` can `Call(__eq_List<…>)`
+        // — list_helpers owns those fn idxs and threads them in via
+        // the `compound_lookup` arg.
+        let mut helper_idx_map: HashMap<String, u32> = self
             .slots
             .iter()
             .map(|(n, (fn_idx, _))| (n.clone(), *fn_idx))
             .collect();
+        for (canonical, fn_idx) in compound_lookup {
+            helper_idx_map.insert(canonical.clone(), *fn_idx);
+        }
         for name in &self.order {
             let kind = self.kinds[name];
             let self_fn_idx = self.slots.get(name).map(|(f, _)| *f);
diff --git a/src/codegen/wasm_gc/body/hash_helpers.rs b/src/codegen/wasm_gc/body/hash_helpers.rs
index 0ee468a5..2e662d19 100644
--- a/src/codegen/wasm_gc/body/hash_helpers.rs
+++ b/src/codegen/wasm_gc/body/hash_helpers.rs
@@ -114,7 +114,30 @@ impl HashHelperRegistry {
                     }
                 }
             }
-            HashKind::OptionHash | HashKind::ResultHash | HashKind::TupleHash => {}
+            // Mirror eq_helpers — recurse so direct top-level
+            // registration of a carrier (seed walker etc.) still
+            // discovers inner types.
+            HashKind::OptionHash => {
+                if let Some(inner) = type_name
+                    .strip_prefix("Option<")
+                    .and_then(|s| s.strip_suffix('>'))
+                {
+                    self.register_field_type(inner.trim(), registry);
+                }
+            }
+            HashKind::ResultHash => {
+                if let Some((ok, err)) = parse_result_kv(type_name) {
+                    self.register_field_type(ok.trim(), registry);
+                    self.register_field_type(err.trim(), registry);
+                }
+            }
+            HashKind::TupleHash => {
+                if let Some(elems) = parse_tuple_elems(type_name) {
+                    for e in elems {
+                        self.register_field_type(e.trim(), registry);
+                    }
+                }
+            }
         }
     }
 
@@ -157,6 +180,21 @@ impl HashHelperRegistry {
                     self.register_field_type(elem.trim(), registry);
                 }
             }
+        } else if let Some(inner) = field_ty
+            .strip_prefix("List<")
+            .and_then(|s| s.strip_suffix('>'))
+        {
+            // Symmetric to eq_helpers — recurse into the element so
+            // `List<Option<X>>` registers `__hash_Option<X>`. The
+            // list_helpers slot itself is owned by the separate
+            // ListHelperRegistry; this walk only covers the carrier
+            // / nominal hash dispatch the inline body needs.
+            self.register_field_type(inner.trim(), registry);
+        } else if let Some(inner) = field_ty
+            .strip_prefix("Vector<")
+            .and_then(|s| s.strip_suffix('>'))
+        {
+            self.register_field_type(inner.trim(), registry);
         }
     }
 
@@ -201,13 +239,20 @@ impl HashHelperRegistry {
         codes: &mut wasm_encoder::CodeSection,
         registry: &TypeRegistry,
         string_eq_fn_idx: Option<u32>,
+        compound_lookup: &HashMap<String, u32>,
     ) -> Result<(), WasmGcError> {
         let _ = string_eq_fn_idx; // String fields hash via array.len, no helper needed.
-        let helper_idx_map: HashMap<String, u32> = self
+        // Same shape as eq_helpers — merge `List<T>` / `Vector<T>`
+        // hash fn idxs from list_helpers so a record field of a
+        // compound type can `Call(__hash_<canonical>)`.
+        let mut helper_idx_map: HashMap<String, u32> = self
             .slots
             .iter()
             .map(|(n, (fn_idx, _))| (n.clone(), *fn_idx))
             .collect();
+        for (canonical, fn_idx) in compound_lookup {
+            helper_idx_map.insert(canonical.clone(), *fn_idx);
+        }
         for name in &self.order {
             let kind = self.kinds[name];
             let self_fn_idx = self.slots.get(name).map(|(f, _)| *f);
diff --git a/src/codegen/wasm_gc/lists.rs b/src/codegen/wasm_gc/lists.rs
index aea2c38e..6a2678c5 100644
--- a/src/codegen/wasm_gc/lists.rs
+++ b/src/codegen/wasm_gc/lists.rs
@@ -683,6 +683,13 @@ enum ListEqKind {
     /// if both head and needle are V_i, compare fields; if only one
     /// is V_i, return false. Carries the parent type name.
     SumEq(String),
+    /// Generic carrier element — `Option<X>`, `Result<X,Y>`, or
+    /// `Tuple<…>`. List eq dispatches per element via
+    /// `Call(__eq_<canonical>)` from `eq_helpers`; signature is
+    /// `(eqref, eqref) -> i32`, same shape as record/sum eq. Carries
+    /// the canonical (whitespace-free) so the body emitter can look
+    /// it up in the helper idx map at emit time.
+    CarrierEq(String),
 }
 
 fn list_eq_kind(elem: &str, registry: &TypeRegistry) -> Option<ListEqKind> {
@@ -692,6 +699,27 @@ fn list_eq_kind(elem: &str, registry: &TypeRegistry) -> Option<ListEqKind> {
     if let Some(under) = registry.newtype_underlying(trimmed) {
         return list_eq_kind(under, registry);
     }
+    // Generic carriers — `Option<X>` / `Result<X,Y>` / `Tuple<…>`
+    // get a per-instantiation `__eq_<canonical>` helper from
+    // eq_helpers. Their list-element dispatch is a thin Call into
+    // that helper, same shape as record/sum dispatch. Same path
+    // covers `List<X>` / `Vector<X>` elements (helpers live in
+    // list_helpers but the calling convention is identical:
+    // `(eqref, eqref) -> i32` after implicit upcast).
+    if (trimmed.starts_with("Option<")
+        || trimmed.starts_with("Result<")
+        || trimmed.starts_with("Tuple<")
+        || trimmed.starts_with("List<")
+        || trimmed.starts_with("Vector<"))
+        && trimmed.ends_with('>')
+    {
+        let canonical: String = trimmed.chars().filter(|c| !c.is_whitespace()).collect();
+        let mut seen = std::collections::HashSet::new();
+        if field_type_resolvable(trimmed, registry, &mut seen) {
+            return Some(ListEqKind::CarrierEq(canonical));
+        }
+        return None;
+    }
     match trimmed {
         "Int" => Some(ListEqKind::I64),
         "Float" => Some(ListEqKind::F64),
@@ -846,6 +874,24 @@ pub(super) fn field_type_resolvable(
         }
         return field_type_resolvable(inner[start..].trim(), registry, seen);
     }
+    // List<X> / Vector<X> — list/vec helpers slot a per-instantiation
+    // eq+hash fn in `list_helpers` whenever X is itself
+    // `list_eq_kind`-able (recursively: primitive, record, sum, or a
+    // resolvable carrier). Record/sum field dispatch then calls
+    // `__eq_List<X>` / `__eq_Vector<X>` via the compound lookup
+    // map threaded into `emit_record_eq_inline`.
+    if let Some(inner) = field
+        .strip_prefix("List<")
+        .and_then(|s| s.strip_suffix('>'))
+    {
+        return field_type_resolvable(inner.trim(), registry, seen);
+    }
+    if let Some(inner) = field
+        .strip_prefix("Vector<")
+        .and_then(|s| s.strip_suffix('>'))
+    {
+        return field_type_resolvable(inner.trim(), registry, seen);
+    }
     false
 }
 
@@ -1619,7 +1665,8 @@ fn emit_list_contains(
     // params: 0=in, 1=needle. local 2 = cur. RecordEq adds two
     // extra scratch locals (3 = head, 4 = needle copy) since field-
     // by-field eq needs `struct.get` against both refs multiple
-    // times.
+    // times. CarrierEq needs no scratch — the helper takes eqref
+    // params directly so head + needle are forwarded as-is.
     let mut locals: Vec<(u32, ValType)> = vec![(1, list_ref)];
     if matches!(&kind, ListEqKind::RecordEq(_) | ListEqKind::SumEq(_)) {
         // Record / sum eq does multiple struct.get reads against
@@ -1683,6 +1730,24 @@ fn emit_list_contains(
                 None,
             )?;
         }
+        ListEqKind::CarrierEq(canonical) => {
+            // `Call(__eq_<canonical>)` — both head and needle pushed
+            // as eqref args (head from struct.get, needle from
+            // param 1).
+            let eq_fn = eq_helper_fn_idx.get(canonical).copied().ok_or_else(|| {
+                WasmGcError::Validation(format!(
+                    "List.contains over carrier `{canonical}`: \
+                     __eq_{canonical} not registered in eq_helpers"
+                ))
+            })?;
+            f.instruction(&Instruction::LocalGet(2));
+            f.instruction(&Instruction::StructGet {
+                struct_type_index: list_idx,
+                field_index: 0,
+            });
+            f.instruction(&Instruction::LocalGet(1));
+            f.instruction(&Instruction::Call(eq_fn));
+        }
         _ => {
             f.instruction(&Instruction::LocalGet(2));
             f.instruction(&Instruction::StructGet {
@@ -1700,12 +1765,12 @@ fn emit_list_contains(
                     ))?;
                     f.instruction(&Instruction::Call(eq_fn))
                 }
-                ListEqKind::RecordEq(_) | ListEqKind::SumEq(_) => panic!(
-                    "internal compiler error: List.contains emit reached \
-                     RecordEq/SumEq path; should be filtered upstream by \
-                     `list_eq_kind` returning None for record/sum elements. \
-                     Please file at https://github.com/jasisz/aver/issues"
-                ),
+                ListEqKind::RecordEq(_) | ListEqKind::SumEq(_) | ListEqKind::CarrierEq(_) => {
+                    unreachable!(
+                        "filtered by outer match arms — RecordEq/SumEq/CarrierEq \
+                     handled above before this fallthrough"
+                    )
+                }
             };
         }
     }
@@ -2156,8 +2221,8 @@ fn emit_list_eq(
             ))?;
             f.instruction(&Instruction::Call(eq_fn));
         }
-        ListEqKind::RecordEq(name) | ListEqKind::SumEq(name) => {
-            // Nominal element — dispatch to the per-type
+        ListEqKind::RecordEq(name) | ListEqKind::SumEq(name) | ListEqKind::CarrierEq(name) => {
+            // Nominal/carrier element — dispatch to the per-type
             // `__eq_<X>` helper. Its signature is
             // `(eqref, eqref) -> i32`; both refs on the stack are
             // subtypes of eqref so the implicit upcast is fine.
@@ -2329,6 +2394,19 @@ fn emit_list_hash(
                 hash_helper_fn_idx,
             )?;
         }
+        ListEqKind::CarrierEq(canonical) => {
+            // Element on stack is eqref; `Call(__hash_<canonical>)`
+            // returns i32. The carrier's `__hash_<X>` is registered
+            // alongside `__eq_<X>` in hash_helpers.
+            let idx = hash_helper_fn_idx
+                .get(canonical)
+                .copied()
+                .ok_or(WasmGcError::Validation(format!(
+                    "list hash over carrier `{canonical}`: __hash_{canonical} \
+                     not registered in hash_helpers"
+                )))?;
+            f.instruction(&Instruction::Call(idx));
+        }
     }
     f.instruction(&Instruction::I32Add);
     f.instruction(&Instruction::LocalSet(2));
@@ -2587,9 +2665,9 @@ fn emit_vec_eq(
             ))?;
             f.instruction(&Instruction::Call(eq_fn));
         }
-        ListEqKind::RecordEq(name) | ListEqKind::SumEq(name) => {
-            // Nominal element — `Call(__eq_<X>)`. Same eqref upcast
-            // shape as in `emit_list_eq`.
+        ListEqKind::RecordEq(name) | ListEqKind::SumEq(name) | ListEqKind::CarrierEq(name) => {
+            // Nominal/carrier element — `Call(__eq_<X>)`. Same eqref
+            // upcast shape as in `emit_list_eq`.
             let idx = eq_helper_fn_idx
                 .get(name)
                 .copied()
@@ -2728,6 +2806,19 @@ fn emit_vec_hash(
                 hash_helper_fn_idx,
             )?;
         }
+        ListEqKind::CarrierEq(canonical) => {
+            // Element on stack is eqref; `Call(__hash_<canonical>)`
+            // returns i32. Same shape as `emit_list_hash`'s carrier
+            // arm.
+            let idx = hash_helper_fn_idx
+                .get(canonical)
+                .copied()
+                .ok_or(WasmGcError::Validation(format!(
+                    "vector hash over carrier `{canonical}`: \
+                     __hash_{canonical} not registered in hash_helpers"
+                )))?;
+            f.instruction(&Instruction::Call(idx));
+        }
     }
     f.instruction(&Instruction::I32Add);
     f.instruction(&Instruction::LocalSet(1));
diff --git a/src/codegen/wasm_gc/maps.rs b/src/codegen/wasm_gc/maps.rs
index cf5b4f1c..1d42d0b6 100644
--- a/src/codegen/wasm_gc/maps.rs
+++ b/src/codegen/wasm_gc/maps.rs
@@ -336,15 +336,17 @@ impl MapHelperRegistry {
             let is_carrier_k = k_aver.starts_with("Option<")
                 || k_aver.starts_with("Result<")
                 || k_aver.starts_with("Tuple<");
+            let is_list_or_vec_k = k_aver.starts_with("List<") || k_aver.starts_with("Vector<");
             if k_aver != "String"
                 && registry.record_type_idx(k_aver).is_none()
                 && !is_primitive_k
                 && !is_sum_k
                 && !is_carrier_k
+                && !is_list_or_vec_k
             {
                 return Err(WasmGcError::Unimplemented(
                     "phase 3c — Map<K, V> with K not String / user-record / sum / \
-                     primitive / generic-carrier (Option/Result/Tuple)",
+                     primitive / generic-carrier (Option/Result/Tuple) / List<T> / Vector<T>",
                 ));
             }
 
@@ -629,13 +631,18 @@ fn emit_hash_for(
     if k_aver.starts_with("Option<")
         || k_aver.starts_with("Result<")
         || k_aver.starts_with("Tuple<")
+        || k_aver.starts_with("List<")
+        || k_aver.starts_with("Vector<")
     {
         // Same shape as carrier eq: proxy to the per-instantiation
-        // `__hash_<X>` helper from `hash_helpers`.
+        // `__hash_<X>` helper. Carriers come from hash_helpers,
+        // List/Vector from list_helpers; both are merged into
+        // `all_key_helpers` via the compound lookup at module
+        // assembly.
         let helpers = all_key_helpers
             .get(k_aver)
             .ok_or(WasmGcError::Validation(format!(
-                "hash_for: carrier `{k_aver}` has no registered hash helper"
+                "hash_for: compound `{k_aver}` has no registered hash helper"
             )))?;
         let mut f = Function::new([]);
         f.instruction(&Instruction::LocalGet(0));
@@ -674,15 +681,16 @@ fn emit_eq_for(
     if k_aver.starts_with("Option<")
         || k_aver.starts_with("Result<")
         || k_aver.starts_with("Tuple<")
+        || k_aver.starts_with("List<")
+        || k_aver.starts_with("Vector<")
     {
-        // Map-key eq for carriers proxies to the per-instantiation
-        // `__eq_<X>` helper registered in `eq_helpers` (looked up
-        // via `all_key_helpers` which includes the carrier eq fn
-        // idx forwarded from the registry).
+        // Map-key eq for compounds proxies to `__eq_<X>` (carriers
+        // from eq_helpers, List/Vector from list_helpers). Both are
+        // merged into `all_key_helpers` at module assembly time.
         let helpers = all_key_helpers
             .get(k_aver)
             .ok_or(WasmGcError::Validation(format!(
-                "eq_for: carrier `{k_aver}` has no registered eq helper"
+                "eq_for: compound `{k_aver}` has no registered eq helper"
             )))?;
         let mut f = Function::new([]);
         f.instruction(&Instruction::LocalGet(0));
@@ -787,6 +795,46 @@ fn emit_box_key(f: &mut Function, k_aver: &str, registry: &TypeRegistry) {
     }
 }
 
+/// Heap type used by `Map.remove` for `ref.null` in the keys-array
+/// store-back. Concrete idx for K kinds with their own struct type
+/// (primitive K boxes, String, record, carrier, List, Vector); abstract
+/// Eq for sum K (whose wasm rep is eqref since variants share no
+/// concrete struct type).
+fn key_storage_null_heap(k_aver: &str, registry: &TypeRegistry) -> HeapType {
+    if let Some(box_idx) = registry.primitive_key_box_idx(k_aver) {
+        return HeapType::Concrete(box_idx);
+    }
+    if k_aver == "String"
+        && let Some(s) = registry.string_array_type_idx
+    {
+        return HeapType::Concrete(s);
+    }
+    if let Some(r) = registry.record_type_idx(k_aver) {
+        return HeapType::Concrete(r);
+    }
+    if let Some(o) = registry.option_type_idx(k_aver) {
+        return HeapType::Concrete(o);
+    }
+    if let Some(r) = registry.result_type_idx(k_aver) {
+        return HeapType::Concrete(r);
+    }
+    if let Some(t) = registry.tuple_type_idx(k_aver) {
+        return HeapType::Concrete(t);
+    }
+    if let Some(l) = registry.list_type_idx(k_aver) {
+        return HeapType::Concrete(l);
+    }
+    if let Some(v) = registry.vector_type_idx(k_aver) {
+        return HeapType::Concrete(v);
+    }
+    // Sum K — eqref. ref.null of abstract Eq is a subtype of every
+    // concrete variant ref, so the array.set typechecks.
+    HeapType::Abstract {
+        shared: false,
+        ty: wasm_encoder::AbstractHeapType::Eq,
+    }
+}
+
 fn string_idx(registry: &TypeRegistry) -> Result<u32, WasmGcError> {
     registry
         .string_array_type_idx
@@ -2006,19 +2054,14 @@ fn emit_map_remove(
     f.instruction(&Instruction::End);
     f.instruction(&Instruction::End);
 
-    // keys[i] = null. Heap type matches the keys array element ref:
-    // primitive-key box for primitive K, String slot for K=String,
-    // record slot for K=record.
-    let null_heap_idx = registry
-        .primitive_key_box_idx(k_aver)
-        .or(registry
-            .string_array_type_idx
-            .filter(|_| k_aver == "String"))
-        .or_else(|| registry.record_type_idx(k_aver))
-        .unwrap_or(0);
+    // keys[i] = null. Heap type matches the keys array element ref —
+    // see `key_storage_null_heap` for the per-K-kind table (primitive
+    // box / String / record / carrier / List / Vector concrete idx,
+    // abstract Eq for sum K).
+    let null_heap = key_storage_null_heap(k_aver, registry);
     f.instruction(&Instruction::LocalGet(4));
     f.instruction(&Instruction::LocalGet(7));
-    f.instruction(&Instruction::RefNull(HeapType::Concrete(null_heap_idx)));
+    f.instruction(&Instruction::RefNull(null_heap));
     f.instruction(&Instruction::ArraySet(slots.keys_array));
 
     // map.size = map.size - 1
diff --git a/src/codegen/wasm_gc/module.rs b/src/codegen/wasm_gc/module.rs
index 80346bed..513254bd 100644
--- a/src/codegen/wasm_gc/module.rs
+++ b/src/codegen/wasm_gc/module.rs
@@ -114,6 +114,20 @@ pub(super) fn emit_module(
         {
             eq_helpers_registry.register_transitive(name, EqKind::Sum, &registry);
             hash_helpers_registry.register_transitive(name, HashKind::Sum, &registry);
+        } else if name.starts_with("Option<") && name.ends_with('>') {
+            // Carrier element of List<Option<X>> / Vector<Option<X>>
+            // / Map<Option<X>, _> — list/vec eq+hash bodies dispatch
+            // each element via `Call(__eq_Option<X>)` which means
+            // eq_helpers must hold the slot. Same logic for the hash
+            // side. Inner type registration happens transitively.
+            eq_helpers_registry.register_transitive(name, EqKind::OptionEq, &registry);
+            hash_helpers_registry.register_transitive(name, HashKind::OptionHash, &registry);
+        } else if name.starts_with("Result<") && name.ends_with('>') {
+            eq_helpers_registry.register_transitive(name, EqKind::ResultEq, &registry);
+            hash_helpers_registry.register_transitive(name, HashKind::ResultHash, &registry);
+        } else if name.starts_with("Tuple<") && name.ends_with('>') {
+            eq_helpers_registry.register_transitive(name, EqKind::TupleEq, &registry);
+            hash_helpers_registry.register_transitive(name, HashKind::TupleHash, &registry);
         }
     }
     // Mirror eq registry's transitive shape — every type registered
@@ -755,8 +769,10 @@ pub(super) fn emit_module(
     // List / Vector.fromList / String.split-join helper bodies.
     // Snapshot eq-helper fn idxs so list/vec eq+hash bodies can
     // dispatch nominal-element `==`/hash through `Call(__eq_<X>)`.
+    // Merge in list_helpers' own list/vec canonicals so `List<List<X>>`
+    // / `List<Vector<X>>` element dispatch finds the inner helper.
     let string_eq_fn_idx = builtin_registry.lookup_wasm_fn_idx(BuiltinName::StringEq);
-    let eq_helper_fn_idx_map: HashMap<String, u32> = eq_helpers_registry
+    let mut eq_helper_fn_idx_map: HashMap<String, u32> = eq_helpers_registry
         .iter()
         .filter_map(|(n, _k)| {
             eq_helpers_registry
@@ -764,7 +780,7 @@ pub(super) fn emit_module(
                 .map(|i| (n.to_string(), i))
         })
         .collect();
-    let hash_helper_fn_idx_map: HashMap<String, u32> = hash_helpers_registry
+    let mut hash_helper_fn_idx_map: HashMap<String, u32> = hash_helpers_registry
         .iter()
         .filter_map(|(n, _k)| {
             hash_helpers_registry
@@ -772,6 +788,10 @@ pub(super) fn emit_module(
                 .map(|i| (n.to_string(), i))
         })
         .collect();
+    for (canonical, (eq_fn, hash_fn)) in &compound_eq_hash_lookup {
+        eq_helper_fn_idx_map.insert(canonical.clone(), *eq_fn);
+        hash_helper_fn_idx_map.insert(canonical.clone(), *hash_fn);
+    }
     list_helpers.emit_helper_bodies(
         &mut codes,
         &registry,
@@ -782,11 +802,32 @@ pub(super) fn emit_module(
 
     // Per-(record/sum) `__eq_<TypeName>` helper bodies — emit after
     // list helpers so any String fields can call `__wasmgc_string_eq`
-    // by the index recorded above.
-    eq_helpers_registry.emit_helper_bodies(&mut codes, &registry, string_eq_fn_idx)?;
+    // by the index recorded above. The compound eq lookup forwards
+    // `List<T>` / `Vector<T>` fn idxs so a record field of type
+    // `List<Option<Int>>` (etc.) can dispatch via
+    // `Call(__eq_List<…>)`. Same shape on the hash side.
+    let compound_eq_lookup: HashMap<String, u32> = compound_eq_hash_lookup
+        .iter()
+        .map(|(n, (eq, _))| (n.clone(), *eq))
+        .collect();
+    let compound_hash_lookup: HashMap<String, u32> = compound_eq_hash_lookup
+        .iter()
+        .map(|(n, (_, h))| (n.clone(), *h))
+        .collect();
+    eq_helpers_registry.emit_helper_bodies(
+        &mut codes,
+        &registry,
+        string_eq_fn_idx,
+        &compound_eq_lookup,
+    )?;
     // `__hash_<X>` helper bodies — emitted right after eq helpers so
     // every nominal/carrier hash dispatch finds its target fn_idx.
-    hash_helpers_registry.emit_helper_bodies(&mut codes, &registry, string_eq_fn_idx)?;
+    hash_helpers_registry.emit_helper_bodies(
+        &mut codes,
+        &registry,
+        string_eq_fn_idx,
+        &compound_hash_lookup,
+    )?;
 
     if let Some(hw) = &handler_wrapper {
         let user_handler_wasm_idx = import_count + 1 + (hw.user_handler_idx as u32);

From f97b558c6da34ee46f207c849748d77121dd8fa1 Mon Sep 17 00:00:00 2001
From: jasisz <jasisz@gmail.com>
Date: Wed, 6 May 2026 19:30:49 +0200
Subject: [PATCH 14/18] 0.16.3: Map structural eq + commutative hash + literal
 discovery
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Map<K,V> joins the eq/hash matrix as a first-class compound:

- MapHelperRegistry gets two new slots per instantiation: `eq` (eqref,
  eqref) -> i32 and `hash` (eqref) -> i32. Bodies live alongside the
  existing 11 kv helpers; type-section, function-section, and code-
  section emit grow accordingly.
- `__eq_Map<K,V>(a, b)`: ref.cast both args, fast-fail on size mismatch,
  then for each occupied bucket of a probe `b` via the per-(K,V) get
  fn — `None` or value mismatch returns 0. Insertion order is
  intentionally ignored (matches VM's `Value::Map(HashMap)` PartialEq +
  Python/Java/Rust/Haskell mainstream).
- `__hash_Map<K,V>(m)`: XOR-fold per occupied entry of
  `(djb2(k) << 5) + djb2(k) + djb2(v)`. XOR is commutative + associative
  → hash invariant under bucket / insertion order. Pairs with structural
  eq for the standard hash-eq contract.
- V's helper resolution mirrors K — primitive V (Int/Float/Bool) inlines
  the cmp + hash, ref V (String/record/sum/carrier/list/vec/map) flows
  through `__eq_<V>` / `__hash_<V>`. assign_slots force-registers V as
  pseudo-K so the helpers exist regardless of `Map<V, _>` reachability.
- Map<K,V> as a record/sum/list/vec field type now resolves: the
  compound_eq_hash_lookup threaded into eq_helpers / hash_helpers /
  list_helpers / map_helpers carries Map fn idxs alongside List<T>/
  Vector<T>. Lookups normalize whitespace so source-side spacing
  (`Map<Int, String>` from record_fields) finds the registry's
  whitespace-free canonical.
- Map<K2,V2> as Map K is whitelisted in assign_slots; emit_eq_for /
  emit_hash_for / key_storage_null_heap dispatch through the same
  compound proxy pattern.

Discovery walker:

- types.rs adds `collect_maps_from_expr` — walks every Spanned<Expr>
  in fn bodies and harvests Map<K,V> from `expr.ty()`. Catches map
  literals (`{a => 3}` without annotation) where the canonical never
  appears in any signature. Recurses through FnCall / List / Tuple /
  IndependentProduct / MapLiteral / RecordCreate / RecordUpdate /
  Constructor / Match / BinOp / Attr / ErrorProp / TailCall.
- list_eq_kind extended with `Map<…>` element kind; field_type_resolvable
  recursively accepts Map<K,V> when both K and V resolve.
- eq_helpers + hash_helpers' register_field_type recurses into Map's
  K and V so transitive helpers exist for the structural fold.

Coverage:

  Map<K,V> ==                           ✓ structural, order-invariant
  record { Map<K,V> }                   ✓
  List<Map<K,V>> / Vector<Map<K,V>>     ✓
  Map<List<X>, V> / Map<Vector<X>, V>   ✓
  Map<Map<K2,V2>, V>                    ✓
  m = {a => 3} (no annotation)          ✓ via expr.ty() walker

621/621 lib tests, 7/7 games, no regressions.

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>
---
 src/codegen/wasm_gc/body/emit.rs         |  12 +
 src/codegen/wasm_gc/body/eq_helpers.rs   |  28 +-
 src/codegen/wasm_gc/body/hash_helpers.rs |  23 ++
 src/codegen/wasm_gc/lists.rs             |  60 ++-
 src/codegen/wasm_gc/maps.rs              | 461 ++++++++++++++++++++++-
 src/codegen/wasm_gc/module.rs            |  19 +
 src/codegen/wasm_gc/types.rs             |  67 ++++
 7 files changed, 646 insertions(+), 24 deletions(-)

diff --git a/src/codegen/wasm_gc/body/emit.rs b/src/codegen/wasm_gc/body/emit.rs
index 9a4a08f7..f8e4bd98 100644
--- a/src/codegen/wasm_gc/body/emit.rs
+++ b/src/codegen/wasm_gc/body/emit.rs
@@ -610,6 +610,18 @@ fn sum_or_record_eq_fn(operand: &Spanned<Expr>, ctx: &EmitCtx<'_>) -> Option<u32
                 .collect();
             ctx.fn_map.vfl_ops.get(&canonical).and_then(|ops| ops.eq)
         }
+        // Map<K,V> structural eq — `__eq_Map<K,V>` slot lives in
+        // MapHelperRegistry but we mirror the fn idx into
+        // `eq_helpers` so the lookup shape stays uniform with
+        // record/sum/carrier/list/vec dispatch.
+        crate::types::Type::Map(_, _) => {
+            let canonical: String = ty
+                .display()
+                .chars()
+                .filter(|c| !c.is_whitespace())
+                .collect();
+            ctx.fn_map.eq_helpers.get(&canonical).copied()
+        }
         _ => None,
     }
 }
diff --git a/src/codegen/wasm_gc/body/eq_helpers.rs b/src/codegen/wasm_gc/body/eq_helpers.rs
index fcacfd51..18044b88 100644
--- a/src/codegen/wasm_gc/body/eq_helpers.rs
+++ b/src/codegen/wasm_gc/body/eq_helpers.rs
@@ -228,10 +228,32 @@ impl EqHelperRegistry {
             .and_then(|s| s.strip_suffix('>'))
         {
             self.register_field_type(inner.trim(), registry);
+        } else if let Some(inner) = field_ty
+            .strip_prefix("Map<")
+            .and_then(|s| s.strip_suffix('>'))
+        {
+            // Map<K,V> — eq+hash slots live in MapHelperRegistry,
+            // not eq_helpers. This walk only ensures K and V's own
+            // helpers exist (K may be a record/sum/carrier; V same).
+            // Structural eq on the map dispatches K and V via Call
+            // into those helpers.
+            let bytes = inner.as_bytes();
+            let mut depth: i32 = 0;
+            for (idx, b) in bytes.iter().enumerate() {
+                match b {
+                    b'<' | b'(' => depth += 1,
+                    b'>' | b')' => depth -= 1,
+                    b',' if depth == 0 => {
+                        let k = inner[..idx].trim();
+                        let v = inner[idx + 1..].trim();
+                        self.register_field_type(k, registry);
+                        self.register_field_type(v, registry);
+                        return;
+                    }
+                    _ => {}
+                }
+            }
         }
-        // Map<K,V> still falls through — record-of-Map field eq is a
-        // separate followup (the map's own equality semantics aren't
-        // canonical: insertion-order vs structural).
     }
 
     pub(crate) fn iter(&self) -> impl Iterator<Item = (&str, EqKind)> + '_ {
diff --git a/src/codegen/wasm_gc/body/hash_helpers.rs b/src/codegen/wasm_gc/body/hash_helpers.rs
index 2e662d19..735c0d00 100644
--- a/src/codegen/wasm_gc/body/hash_helpers.rs
+++ b/src/codegen/wasm_gc/body/hash_helpers.rs
@@ -195,6 +195,29 @@ impl HashHelperRegistry {
             .and_then(|s| s.strip_suffix('>'))
         {
             self.register_field_type(inner.trim(), registry);
+        } else if let Some(inner) = field_ty
+            .strip_prefix("Map<")
+            .and_then(|s| s.strip_suffix('>'))
+        {
+            // Mirror eq_helpers — Map<K,V> hash slot lives in
+            // MapHelperRegistry; recurse so K and V's hash helpers
+            // exist for the structural fold.
+            let bytes = inner.as_bytes();
+            let mut depth: i32 = 0;
+            for (idx, b) in bytes.iter().enumerate() {
+                match b {
+                    b'<' | b'(' => depth += 1,
+                    b'>' | b')' => depth -= 1,
+                    b',' if depth == 0 => {
+                        let k = inner[..idx].trim();
+                        let v = inner[idx + 1..].trim();
+                        self.register_field_type(k, registry);
+                        self.register_field_type(v, registry);
+                        return;
+                    }
+                    _ => {}
+                }
+            }
         }
     }
 
diff --git a/src/codegen/wasm_gc/lists.rs b/src/codegen/wasm_gc/lists.rs
index 6a2678c5..4a267e14 100644
--- a/src/codegen/wasm_gc/lists.rs
+++ b/src/codegen/wasm_gc/lists.rs
@@ -710,7 +710,8 @@ fn list_eq_kind(elem: &str, registry: &TypeRegistry) -> Option<ListEqKind> {
         || trimmed.starts_with("Result<")
         || trimmed.starts_with("Tuple<")
         || trimmed.starts_with("List<")
-        || trimmed.starts_with("Vector<"))
+        || trimmed.starts_with("Vector<")
+        || trimmed.starts_with("Map<"))
         && trimmed.ends_with('>')
     {
         let canonical: String = trimmed.chars().filter(|c| !c.is_whitespace()).collect();
@@ -892,6 +893,27 @@ pub(super) fn field_type_resolvable(
     {
         return field_type_resolvable(inner.trim(), registry, seen);
     }
+    // Map<K, V> — `__eq_Map<K,V>` / `__hash_Map<K,V>` live in
+    // MapHelperRegistry::kv. Resolvable iff both K and V are
+    // themselves resolvable.
+    if let Some(inner) = field.strip_prefix("Map<").and_then(|s| s.strip_suffix('>')) {
+        let bytes = inner.as_bytes();
+        let mut depth: i32 = 0;
+        for (idx, b) in bytes.iter().enumerate() {
+            match b {
+                b'<' | b'(' => depth += 1,
+                b'>' | b')' => depth -= 1,
+                b',' if depth == 0 => {
+                    let k = inner[..idx].trim();
+                    let v = inner[idx + 1..].trim();
+                    return field_type_resolvable(k, registry, seen)
+                        && field_type_resolvable(v, registry, seen);
+                }
+                _ => {}
+            }
+        }
+        return false;
+    }
     false
 }
 
@@ -1863,20 +1885,30 @@ pub(super) fn emit_record_eq_inline(
                 // Recursive ref to the same record — call self.
                 f.instruction(&Instruction::Call(self_fn_idx.unwrap()));
             }
-            other if eq_helper_fn_idx.contains_key(other) => {
-                // Nested nominal type with its own __eq_<X> helper
-                // — call by fn idx. Field refs are subtypes of
-                // eqref so the implicit upcast at the call site
-                // is fine.
-                let idx = eq_helper_fn_idx[other];
-                f.instruction(&Instruction::Call(idx));
-            }
             other => {
-                return Err(WasmGcError::Validation(format!(
-                    "record `{record_name}` field type `{other}` has no eq dispatch \
-                     (not in {{Int, Float, Bool, String}}, no `__eq_{other}` helper, \
-                     not self-recursive)"
-                )));
+                // Look up `__eq_<X>` — for compound types (List/
+                // Vector/Map/Option/Result/Tuple) the registry keys
+                // are whitespace-stripped, but a field type from
+                // `record_fields` can carry source-side spacing.
+                // Try both forms before erroring.
+                let normalized = super::types::normalize_compound(other);
+                let key = if eq_helper_fn_idx.contains_key(other) {
+                    Some(other.to_string())
+                } else if eq_helper_fn_idx.contains_key(normalized.as_str()) {
+                    Some(normalized.clone())
+                } else {
+                    None
+                };
+                if let Some(k) = key {
+                    let idx = eq_helper_fn_idx[k.as_str()];
+                    f.instruction(&Instruction::Call(idx));
+                } else {
+                    return Err(WasmGcError::Validation(format!(
+                        "record `{record_name}` field type `{other}` has no eq dispatch \
+                         (not in {{Int, Float, Bool, String}}, no `__eq_{other}` helper, \
+                         not self-recursive)"
+                    )));
+                }
             }
         }
         if i > 0 {
diff --git a/src/codegen/wasm_gc/maps.rs b/src/codegen/wasm_gc/maps.rs
index 1d42d0b6..7e1061d0 100644
--- a/src/codegen/wasm_gc/maps.rs
+++ b/src/codegen/wasm_gc/maps.rs
@@ -86,6 +86,16 @@ pub(super) struct MapKVHelpers {
     /// `from_list(l) -> Map<K, V>`. Walks `l`, struct.get's the
     /// (K, V) from each tuple, calls the per-(K, V) `set` helper.
     pub(super) from_list: u32,
+    /// `__eq_Map<K,V>(a, b) -> i32`. Structural eq — `a.size ==
+    /// b.size && ∀ k ∈ a: get(b, k) == Some(a[k])`. Insertion order
+    /// is intentionally ignored (matches VM's `HashMap` PartialEq +
+    /// the Python/Java/Rust/Haskell mainstream).
+    pub(super) eq: u32,
+    /// `__hash_Map<K,V>(m) -> i32`. Order-independent commutative
+    /// fold — `h = 0; for (k, v) in m: h ^= djb2(k) * 33 + djb2(v)`.
+    /// XOR is commutative + associative so the result is invariant
+    /// to bucket ordering.
+    pub(super) hash: u32,
 }
 
 #[derive(Default)]
@@ -105,7 +115,24 @@ pub(super) struct MapHelperRegistry {
     /// matches `assign_slots` / `emit_function_section` /
     /// `emit_helper_bodies` exactly.
     #[allow(clippy::type_complexity)]
-    kv_type_indices: HashMap<String, (u32, u32, u32, u32, u32, u32, u32, u32, u32, u32, u32)>,
+    kv_type_indices: HashMap<
+        String,
+        (
+            u32,
+            u32,
+            u32,
+            u32,
+            u32,
+            u32,
+            u32,
+            u32,
+            u32,
+            u32,
+            u32,
+            u32,
+            u32,
+        ),
+    >,
 }
 
 impl MapHelperRegistry {
@@ -129,7 +156,7 @@ impl MapHelperRegistry {
         let mut k_names: Vec<String> = Vec::new();
         let mut k_seen: std::collections::HashSet<String> = std::collections::HashSet::new();
         for canonical in map_canonicals {
-            let (k_aver, _) =
+            let (k_aver, v_aver) =
                 super::types::parse_map_kv(canonical).ok_or(WasmGcError::Validation(format!(
                     "MapHelperRegistry: cannot parse K, V from `{canonical}`"
                 )))?;
@@ -152,12 +179,26 @@ impl MapHelperRegistry {
                     .filter(|v| v.parent == k_aver)
                     .any(|v| v.fields.iter().any(|t| t.trim() == "String"));
             }
+            // Map<K,V>'s structural eq + hash dispatches V via the
+            // same `__hash_<V>` / `__eq_<V>` helper map K uses, so V
+            // is force-registered as pseudo-K too. Skips primitive V
+            // (the body emitter falls back to inline cmp for those).
+            let v_aver_trim = v_aver.trim();
+            if v_aver_trim == "String" {
+                needs_string = true;
+            }
             if needs_string && k_seen.insert("String".into()) {
                 k_names.push("String".into());
             }
             if k_seen.insert(k_aver.to_string()) {
                 k_names.push(k_aver.to_string());
             }
+            if !super::types::TypeRegistry::is_primitive_map_key(v_aver_trim)
+                && v_aver_trim != "String"
+                && k_seen.insert(v_aver_trim.to_string())
+            {
+                k_names.push(v_aver_trim.to_string());
+            }
         }
 
         // For every record / sum K, recursively collect all
@@ -297,6 +338,10 @@ impl MapHelperRegistry {
             *next_type_idx += 1;
             let from_list_type_idx = *next_type_idx;
             *next_type_idx += 1;
+            let eq_type_idx = *next_type_idx;
+            *next_type_idx += 1;
+            let hash_type_idx = *next_type_idx;
+            *next_type_idx += 1;
             let empty_fn = *next_wasm_fn_idx;
             *next_wasm_fn_idx += 1;
             let set_fn = *next_wasm_fn_idx;
@@ -319,6 +364,10 @@ impl MapHelperRegistry {
             *next_wasm_fn_idx += 1;
             let from_list_fn = *next_wasm_fn_idx;
             *next_wasm_fn_idx += 1;
+            let eq_fn = *next_wasm_fn_idx;
+            *next_wasm_fn_idx += 1;
+            let hash_fn = *next_wasm_fn_idx;
+            *next_wasm_fn_idx += 1;
 
             // K can be String, a user-defined record (field-by-field
             // hash + eq), or a primitive (Int / Float / Bool). Primitive
@@ -337,16 +386,19 @@ impl MapHelperRegistry {
                 || k_aver.starts_with("Result<")
                 || k_aver.starts_with("Tuple<");
             let is_list_or_vec_k = k_aver.starts_with("List<") || k_aver.starts_with("Vector<");
+            let is_map_k = k_aver.starts_with("Map<");
             if k_aver != "String"
                 && registry.record_type_idx(k_aver).is_none()
                 && !is_primitive_k
                 && !is_sum_k
                 && !is_carrier_k
                 && !is_list_or_vec_k
+                && !is_map_k
             {
                 return Err(WasmGcError::Unimplemented(
                     "phase 3c — Map<K, V> with K not String / user-record / sum / \
-                     primitive / generic-carrier (Option/Result/Tuple) / List<T> / Vector<T>",
+                     primitive / generic-carrier (Option/Result/Tuple) / List<T> / \
+                     Vector<T> / Map<K2,V2>",
                 ));
             }
 
@@ -364,6 +416,8 @@ impl MapHelperRegistry {
                     remove: remove_fn,
                     entries: entries_fn,
                     from_list: from_list_fn,
+                    eq: eq_fn,
+                    hash: hash_fn,
                 },
             );
             self.kv_type_indices.insert(
@@ -380,6 +434,8 @@ impl MapHelperRegistry {
                     remove_type_idx,
                     entries_type_idx,
                     from_list_type_idx,
+                    eq_type_idx,
+                    hash_type_idx,
                 ),
             );
             self.kv_order.push(canonical.clone());
@@ -493,6 +549,20 @@ impl MapHelperRegistry {
             types.ty().function([map_ref], [lt_ref]);
             // from_list : (List<Tuple<K, V>>) -> Map
             types.ty().function([lt_ref], [map_ref]);
+            // __eq_Map<K,V> : (eqref, eqref) -> i32. Eqref params so
+            // record/sum/list/vec field dispatch can call uniformly
+            // (the body ref.casts both args to the typed map ref).
+            let eq_ref = ValType::Ref(RefType {
+                nullable: true,
+                heap_type: wasm_encoder::HeapType::Abstract {
+                    shared: false,
+                    ty: wasm_encoder::AbstractHeapType::Eq,
+                },
+            });
+            types.ty().function([eq_ref, eq_ref], [ValType::I32]);
+            // __hash_Map<K,V> : (eqref) -> i32. Same eqref-shape
+            // calling convention as the carrier hash helpers.
+            types.ty().function([eq_ref], [ValType::I32]);
             let _ = opt_ref;
             let _ = tup_idx;
         }
@@ -508,7 +578,8 @@ impl MapHelperRegistry {
             funcs.function(e);
         }
         for canonical in &self.kv_order {
-            let (em, st, gt, ln, god, pair, ks, vs, rm, en, fl) = self.kv_type_indices[canonical];
+            let (em, st, gt, ln, god, pair, ks, vs, rm, en, fl, eq, hs) =
+                self.kv_type_indices[canonical];
             funcs.function(em);
             funcs.function(st);
             funcs.function(gt);
@@ -520,6 +591,8 @@ impl MapHelperRegistry {
             funcs.function(rm);
             funcs.function(en);
             funcs.function(fl);
+            funcs.function(eq);
+            funcs.function(hs);
         }
     }
 
@@ -597,11 +670,51 @@ impl MapHelperRegistry {
             let helpers = self.kv[canonical];
             codes.function(&emit_map_entries(canonical, registry)?);
             codes.function(&emit_map_from_list(canonical, registry, helpers.set)?);
+            // Structural eq + commutative hash for `Map<K, V>`. V's
+            // hash + eq fn idxs come from `all_key_helpers` (same
+            // table that drives K dispatch — V is just another
+            // shape that needs the same family of helpers when V is
+            // not a primitive).
+            let v_helpers = v_helper_for(canonical, &all_key_helpers, registry)?;
+            codes.function(&emit_map_eq(
+                canonical,
+                registry,
+                key_h,
+                v_helpers,
+                helpers.get,
+            )?);
+            codes.function(&emit_map_hash(canonical, registry, key_h, v_helpers)?);
         }
         Ok(())
     }
 }
 
+/// Resolve hash + eq fn idx for V — looks the same shape up as K. V
+/// can be a primitive (hash/eq are inline instructions, not fn calls
+/// — return None and let the body emitter pick the inline path), or
+/// a ref-shaped K kind we already registered (records / sums /
+/// carriers / List / Vector / Map). Returns the proxy fn idxs.
+fn v_helper_for(
+    canonical: &str,
+    all_key_helpers: &HashMap<String, KeyHelpers>,
+    _registry: &TypeRegistry,
+) -> Result<Option<KeyHelpers>, WasmGcError> {
+    let (_, v_aver) = super::types::parse_map_kv(canonical).ok_or(WasmGcError::Validation(
+        format!("v_helper_for: bad canonical `{canonical}`"),
+    ))?;
+    let v_aver = v_aver.trim();
+    if super::types::TypeRegistry::is_primitive_map_key(v_aver) {
+        // Primitive V (Int / Float / Bool) — body emitter inlines
+        // the comparison + hash, no helper dispatch.
+        return Ok(None);
+    }
+    // String + every other ref V flows through `all_key_helpers`,
+    // which assign_slots force-registered as pseudo-K (so the
+    // helpers exist regardless of whether the program actually
+    // holds `Map<V, _>`).
+    Ok(all_key_helpers.get(v_aver).copied())
+}
+
 /// `hash : (K) -> i32`. K can be `String` (DJB2 over the bytes) or
 /// any user-defined record (field-by-field combine, delegating to
 /// the per-K helper for String fields).
@@ -633,10 +746,11 @@ fn emit_hash_for(
         || k_aver.starts_with("Tuple<")
         || k_aver.starts_with("List<")
         || k_aver.starts_with("Vector<")
+        || k_aver.starts_with("Map<")
     {
         // Same shape as carrier eq: proxy to the per-instantiation
         // `__hash_<X>` helper. Carriers come from hash_helpers,
-        // List/Vector from list_helpers; both are merged into
+        // List/Vector/Map from their own registries; all merged into
         // `all_key_helpers` via the compound lookup at module
         // assembly.
         let helpers = all_key_helpers
@@ -683,10 +797,12 @@ fn emit_eq_for(
         || k_aver.starts_with("Tuple<")
         || k_aver.starts_with("List<")
         || k_aver.starts_with("Vector<")
+        || k_aver.starts_with("Map<")
     {
         // Map-key eq for compounds proxies to `__eq_<X>` (carriers
-        // from eq_helpers, List/Vector from list_helpers). Both are
-        // merged into `all_key_helpers` at module assembly time.
+        // from eq_helpers, List/Vector from list_helpers, Map from
+        // MapHelperRegistry::kv). All merged into `all_key_helpers`
+        // at module assembly time.
         let helpers = all_key_helpers
             .get(k_aver)
             .ok_or(WasmGcError::Validation(format!(
@@ -827,6 +943,9 @@ fn key_storage_null_heap(k_aver: &str, registry: &TypeRegistry) -> HeapType {
     if let Some(v) = registry.vector_type_idx(k_aver) {
         return HeapType::Concrete(v);
     }
+    if let Some(slots) = registry.map_slots(k_aver) {
+        return HeapType::Concrete(slots.map);
+    }
     // Sum K — eqref. ref.null of abstract Eq is a subtype of every
     // concrete variant ref, so the array.set typechecks.
     HeapType::Abstract {
@@ -1870,6 +1989,334 @@ fn emit_map_walk_values_to_list(
     Ok(f)
 }
 
+/// `__eq_Map<K,V>(a: eqref, b: eqref) -> i32`. Structural eq —
+/// `a.size == b.size && ∀ k ∈ a: get(b, k) == Some(a[k])`. Order-
+/// independent (matches VM's Rust HashMap PartialEq).
+fn emit_map_eq(
+    canonical: &str,
+    registry: &TypeRegistry,
+    keyh: KeyHelpers,
+    v_helpers: Option<KeyHelpers>,
+    get_fn_idx: u32,
+) -> Result<Function, WasmGcError> {
+    let slots = slots_for(canonical, registry)?;
+    let (k_aver, v_aver) = super::types::parse_map_kv(canonical).unwrap();
+    let _ = keyh;
+    let map_ref = ValType::Ref(RefType {
+        nullable: true,
+        heap_type: HeapType::Concrete(slots.map),
+    });
+    let keys_ref = ValType::Ref(RefType {
+        nullable: true,
+        heap_type: HeapType::Concrete(slots.keys_array),
+    });
+    let values_ref = ValType::Ref(RefType {
+        nullable: true,
+        heap_type: HeapType::Concrete(slots.values_array),
+    });
+    let v_val =
+        super::types::aver_to_wasm(v_aver, Some(registry))?.ok_or(WasmGcError::Validation(
+            format!("Map<{k_aver},{v_aver}>.eq: V `{v_aver}` has no wasm rep"),
+        ))?;
+    let opt_idx = registry
+        .option_type_idx(&format!("Option<{v_aver}>"))
+        .ok_or(WasmGcError::Validation(format!(
+            "Map.eq: `Option<{v_aver}>` not registered"
+        )))?;
+    let opt_ref = ValType::Ref(RefType {
+        nullable: true,
+        heap_type: HeapType::Concrete(opt_idx),
+    });
+    // Locals: 2=typed map_a, 3=typed map_b, 4=cap, 5=i, 6=keys_a,
+    // 7=values_a, 8=cur_key (boxed), 9=opt result, 10=v_a, 11=v_b
+    let mut f = Function::new(vec![
+        (1, map_ref),
+        (1, map_ref),
+        (1, ValType::I32),
+        (1, ValType::I32),
+        (1, keys_ref),
+        (1, values_ref),
+        (1, key_storage_val_type(k_aver, registry)?),
+        (1, opt_ref),
+        (1, v_val),
+        (1, v_val),
+    ]);
+    let map_heap = HeapType::Concrete(slots.map);
+    f.instruction(&Instruction::LocalGet(0));
+    f.instruction(&Instruction::RefCastNonNull(map_heap));
+    f.instruction(&Instruction::LocalSet(2));
+    f.instruction(&Instruction::LocalGet(1));
+    f.instruction(&Instruction::RefCastNonNull(map_heap));
+    f.instruction(&Instruction::LocalSet(3));
+    // if a.size != b.size return 0
+    f.instruction(&Instruction::LocalGet(2));
+    f.instruction(&Instruction::StructGet {
+        struct_type_index: slots.map,
+        field_index: 0,
+    });
+    f.instruction(&Instruction::LocalGet(3));
+    f.instruction(&Instruction::StructGet {
+        struct_type_index: slots.map,
+        field_index: 0,
+    });
+    f.instruction(&Instruction::I32Ne);
+    f.instruction(&Instruction::If(BlockType::Empty));
+    f.instruction(&Instruction::I32Const(0));
+    f.instruction(&Instruction::Return);
+    f.instruction(&Instruction::End);
+    // cap = a.cap; keys_a = a.keys; values_a = a.values; i = 0
+    f.instruction(&Instruction::LocalGet(2));
+    f.instruction(&Instruction::StructGet {
+        struct_type_index: slots.map,
+        field_index: 1,
+    });
+    f.instruction(&Instruction::LocalSet(4));
+    f.instruction(&Instruction::LocalGet(2));
+    f.instruction(&Instruction::StructGet {
+        struct_type_index: slots.map,
+        field_index: 2,
+    });
+    f.instruction(&Instruction::LocalSet(6));
+    f.instruction(&Instruction::LocalGet(2));
+    f.instruction(&Instruction::StructGet {
+        struct_type_index: slots.map,
+        field_index: 3,
+    });
+    f.instruction(&Instruction::LocalSet(7));
+    f.instruction(&Instruction::I32Const(0));
+    f.instruction(&Instruction::LocalSet(5));
+    // for i in 0..cap
+    f.instruction(&Instruction::Block(BlockType::Empty));
+    f.instruction(&Instruction::Loop(BlockType::Empty));
+    f.instruction(&Instruction::LocalGet(5));
+    f.instruction(&Instruction::LocalGet(4));
+    f.instruction(&Instruction::I32GeS);
+    f.instruction(&Instruction::BrIf(1));
+    // cur_key = keys_a[i]
+    f.instruction(&Instruction::LocalGet(6));
+    f.instruction(&Instruction::LocalGet(5));
+    f.instruction(&Instruction::ArrayGet(slots.keys_array));
+    f.instruction(&Instruction::LocalSet(8));
+    // if cur_key != null: probe b
+    f.instruction(&Instruction::LocalGet(8));
+    f.instruction(&Instruction::RefIsNull);
+    f.instruction(&Instruction::I32Eqz);
+    f.instruction(&Instruction::If(BlockType::Empty));
+    // opt = get_fn(b, unbox(cur_key))
+    f.instruction(&Instruction::LocalGet(3));
+    f.instruction(&Instruction::LocalGet(8));
+    emit_unbox_key(&mut f, k_aver, registry);
+    f.instruction(&Instruction::Call(get_fn_idx));
+    f.instruction(&Instruction::LocalSet(9));
+    // if opt.tag == 0 → return 0
+    f.instruction(&Instruction::LocalGet(9));
+    f.instruction(&Instruction::StructGet {
+        struct_type_index: opt_idx,
+        field_index: 0,
+    });
+    f.instruction(&Instruction::I32Eqz);
+    f.instruction(&Instruction::If(BlockType::Empty));
+    f.instruction(&Instruction::I32Const(0));
+    f.instruction(&Instruction::Return);
+    f.instruction(&Instruction::End);
+    // v_a = values_a[i]; v_b = opt.value
+    f.instruction(&Instruction::LocalGet(7));
+    f.instruction(&Instruction::LocalGet(5));
+    f.instruction(&Instruction::ArrayGet(slots.values_array));
+    f.instruction(&Instruction::LocalSet(10));
+    f.instruction(&Instruction::LocalGet(9));
+    f.instruction(&Instruction::StructGet {
+        struct_type_index: opt_idx,
+        field_index: 1,
+    });
+    f.instruction(&Instruction::LocalSet(11));
+    // if v_a != v_b → return 0
+    f.instruction(&Instruction::LocalGet(10));
+    f.instruction(&Instruction::LocalGet(11));
+    emit_v_eq(&mut f, v_aver, v_helpers)?;
+    f.instruction(&Instruction::I32Eqz);
+    f.instruction(&Instruction::If(BlockType::Empty));
+    f.instruction(&Instruction::I32Const(0));
+    f.instruction(&Instruction::Return);
+    f.instruction(&Instruction::End);
+    f.instruction(&Instruction::End);
+    // i++
+    f.instruction(&Instruction::LocalGet(5));
+    f.instruction(&Instruction::I32Const(1));
+    f.instruction(&Instruction::I32Add);
+    f.instruction(&Instruction::LocalSet(5));
+    f.instruction(&Instruction::Br(0));
+    f.instruction(&Instruction::End);
+    f.instruction(&Instruction::End);
+    f.instruction(&Instruction::I32Const(1));
+    f.instruction(&Instruction::End);
+    Ok(f)
+}
+
+/// Stack: `[v_a, v_b]` of Aver type `v_aver`. Push i32 (1=eq, 0=ne).
+/// Primitive V → inline cmp; ref V → `Call(v_helpers.eq)`.
+fn emit_v_eq(
+    f: &mut Function,
+    v_aver: &str,
+    v_helpers: Option<KeyHelpers>,
+) -> Result<(), WasmGcError> {
+    match v_aver.trim() {
+        "Int" => {
+            f.instruction(&Instruction::I64Eq);
+        }
+        "Bool" => {
+            f.instruction(&Instruction::I32Eq);
+        }
+        "Float" => {
+            f.instruction(&Instruction::F64Eq);
+        }
+        _ => {
+            let h = v_helpers.ok_or(WasmGcError::Validation(format!(
+                "emit_v_eq: V `{v_aver}` needs ref helpers (record/sum/carrier/list/vec/map)"
+            )))?;
+            f.instruction(&Instruction::Call(h.eq));
+        }
+    }
+    Ok(())
+}
+
+/// Stack: `[v]` of Aver type `v_aver`. Push i32 hash. Primitive V →
+/// inline DJB2-style mix; ref V → `Call(v_helpers.hash)`.
+fn emit_v_hash(
+    f: &mut Function,
+    v_aver: &str,
+    v_helpers: Option<KeyHelpers>,
+) -> Result<(), WasmGcError> {
+    match v_aver.trim() {
+        "Int" => {
+            f.instruction(&Instruction::I32WrapI64);
+        }
+        "Bool" => {} // already i32
+        "Float" => {
+            f.instruction(&Instruction::I64ReinterpretF64);
+            f.instruction(&Instruction::I32WrapI64);
+        }
+        _ => {
+            let h = v_helpers.ok_or(WasmGcError::Validation(format!(
+                "emit_v_hash: V `{v_aver}` needs ref helpers"
+            )))?;
+            f.instruction(&Instruction::Call(h.hash));
+        }
+    }
+    Ok(())
+}
+
+/// `__hash_Map<K,V>(m: eqref) -> i32`. XOR-fold per occupied entry of
+/// `djb2(k) * 33 + djb2(v)`. XOR is commutative + associative → the
+/// result is invariant to bucket / insertion order.
+fn emit_map_hash(
+    canonical: &str,
+    registry: &TypeRegistry,
+    keyh: KeyHelpers,
+    v_helpers: Option<KeyHelpers>,
+) -> Result<Function, WasmGcError> {
+    let slots = slots_for(canonical, registry)?;
+    let (k_aver, v_aver) = super::types::parse_map_kv(canonical).unwrap();
+    let map_ref = ValType::Ref(RefType {
+        nullable: true,
+        heap_type: HeapType::Concrete(slots.map),
+    });
+    let keys_ref = ValType::Ref(RefType {
+        nullable: true,
+        heap_type: HeapType::Concrete(slots.keys_array),
+    });
+    let values_ref = ValType::Ref(RefType {
+        nullable: true,
+        heap_type: HeapType::Concrete(slots.values_array),
+    });
+    // Locals: 1=typed map, 2=cap, 3=i, 4=keys, 5=values, 6=cur_key
+    // (boxed), 7=h (i32 accumulator), 8=entry_h (i32 per-entry mix).
+    let mut f = Function::new(vec![
+        (1, map_ref),
+        (1, ValType::I32),
+        (1, ValType::I32),
+        (1, keys_ref),
+        (1, values_ref),
+        (1, key_storage_val_type(k_aver, registry)?),
+        (1, ValType::I32),
+        (1, ValType::I32),
+    ]);
+    let map_heap = HeapType::Concrete(slots.map);
+    f.instruction(&Instruction::LocalGet(0));
+    f.instruction(&Instruction::RefCastNonNull(map_heap));
+    f.instruction(&Instruction::LocalSet(1));
+    f.instruction(&Instruction::I32Const(0));
+    f.instruction(&Instruction::LocalSet(7));
+    f.instruction(&Instruction::LocalGet(1));
+    f.instruction(&Instruction::StructGet {
+        struct_type_index: slots.map,
+        field_index: 1,
+    });
+    f.instruction(&Instruction::LocalSet(2));
+    f.instruction(&Instruction::LocalGet(1));
+    f.instruction(&Instruction::StructGet {
+        struct_type_index: slots.map,
+        field_index: 2,
+    });
+    f.instruction(&Instruction::LocalSet(4));
+    f.instruction(&Instruction::LocalGet(1));
+    f.instruction(&Instruction::StructGet {
+        struct_type_index: slots.map,
+        field_index: 3,
+    });
+    f.instruction(&Instruction::LocalSet(5));
+    f.instruction(&Instruction::I32Const(0));
+    f.instruction(&Instruction::LocalSet(3));
+    f.instruction(&Instruction::Block(BlockType::Empty));
+    f.instruction(&Instruction::Loop(BlockType::Empty));
+    f.instruction(&Instruction::LocalGet(3));
+    f.instruction(&Instruction::LocalGet(2));
+    f.instruction(&Instruction::I32GeS);
+    f.instruction(&Instruction::BrIf(1));
+    f.instruction(&Instruction::LocalGet(4));
+    f.instruction(&Instruction::LocalGet(3));
+    f.instruction(&Instruction::ArrayGet(slots.keys_array));
+    f.instruction(&Instruction::LocalSet(6));
+    f.instruction(&Instruction::LocalGet(6));
+    f.instruction(&Instruction::RefIsNull);
+    f.instruction(&Instruction::I32Eqz);
+    f.instruction(&Instruction::If(BlockType::Empty));
+    // entry_h = hash_K(unbox(cur_key)) * 33 + hash_V(values[i])
+    f.instruction(&Instruction::LocalGet(6));
+    emit_unbox_key(&mut f, k_aver, registry);
+    f.instruction(&Instruction::Call(keyh.hash));
+    f.instruction(&Instruction::I32Const(5));
+    f.instruction(&Instruction::I32Shl);
+    // h_k * 32 (will add h_k below to become *33; OR more accurate:
+    // shift-add for *33). Cheaper: do `(kh<<5) + kh + vh`.
+    f.instruction(&Instruction::LocalGet(6));
+    emit_unbox_key(&mut f, k_aver, registry);
+    f.instruction(&Instruction::Call(keyh.hash));
+    f.instruction(&Instruction::I32Add);
+    f.instruction(&Instruction::LocalGet(5));
+    f.instruction(&Instruction::LocalGet(3));
+    f.instruction(&Instruction::ArrayGet(slots.values_array));
+    emit_v_hash(&mut f, v_aver, v_helpers)?;
+    f.instruction(&Instruction::I32Add);
+    f.instruction(&Instruction::LocalSet(8));
+    // h ^= entry_h
+    f.instruction(&Instruction::LocalGet(7));
+    f.instruction(&Instruction::LocalGet(8));
+    f.instruction(&Instruction::I32Xor);
+    f.instruction(&Instruction::LocalSet(7));
+    f.instruction(&Instruction::End);
+    f.instruction(&Instruction::LocalGet(3));
+    f.instruction(&Instruction::I32Const(1));
+    f.instruction(&Instruction::I32Add);
+    f.instruction(&Instruction::LocalSet(3));
+    f.instruction(&Instruction::Br(0));
+    f.instruction(&Instruction::End);
+    f.instruction(&Instruction::End);
+    f.instruction(&Instruction::LocalGet(7));
+    f.instruction(&Instruction::End);
+    Ok(f)
+}
+
 /// `remove(map, k) -> map`. Linear-probe locate the entry; if not
 /// found, return the map unchanged. If found, do a backwards-shift
 /// over the contiguous probe chain so subsequent `get` calls still
diff --git a/src/codegen/wasm_gc/module.rs b/src/codegen/wasm_gc/module.rs
index 513254bd..68a22729 100644
--- a/src/codegen/wasm_gc/module.rs
+++ b/src/codegen/wasm_gc/module.rs
@@ -577,6 +577,16 @@ pub(super) fn emit_module(
             eq_helpers_lookup.insert(name.to_string(), fn_idx);
         }
     }
+    // Map<K,V> structural-eq fn idxs flow through the same lookup so
+    // BinOp::Eq on a Map dispatches via `Call(__eq_Map<K,V>)` (sum_
+    // or_record_eq_fn → ctx.fn_map.eq_helpers). Whitespace-free
+    // canonical matches what the operand's `.ty().display()` produces
+    // at the call site.
+    for canonical in &registry.map_order {
+        if let Some(h) = map_helpers.kv_helpers(canonical) {
+            eq_helpers_lookup.insert(canonical.clone(), h.eq);
+        }
+    }
     let fn_map = FnMap {
         by_name,
         builtins: builtin_idx_lookup,
@@ -745,6 +755,15 @@ pub(super) fn emit_module(
             compound_eq_hash_lookup.insert(format!("Vector<{}>", elem.trim()), (eq_fn, hash_fn));
         }
     }
+    // Map<K,V> structural eq + commutative hash — per-instantiation
+    // helpers live in MapHelperRegistry::kv. Threading them into the
+    // compound lookup lets record/sum/list/vec field dispatch call
+    // `__eq_Map<K,V>` / `__hash_Map<K,V>` uniformly with carriers.
+    for canonical in &registry.map_order {
+        if let Some(h) = map_helpers.kv_helpers(canonical) {
+            compound_eq_hash_lookup.insert(canonical.clone(), (h.eq, h.hash));
+        }
+    }
     // Carrier eq+hash lookup — Option/Result/Tuple instantiations
     // get their helpers from eq_helpers / hash_helpers; map keys
     // proxy through these. Build the pair map by zipping the two
diff --git a/src/codegen/wasm_gc/types.rs b/src/codegen/wasm_gc/types.rs
index ee8a0a41..96f0dbfd 100644
--- a/src/codegen/wasm_gc/types.rs
+++ b/src/codegen/wasm_gc/types.rs
@@ -538,6 +538,10 @@ impl TypeRegistry {
                     if let Stmt::Binding(_, Some(annot), _) = stmt {
                         collect_maps_from_str(annot, &mut pending_maps);
                     }
+                    let expr = match stmt {
+                        Stmt::Binding(_, _, e) | Stmt::Expr(e) => e,
+                    };
+                    collect_maps_from_expr(expr, &mut pending_maps);
                 }
             }
         }
@@ -1850,6 +1854,69 @@ fn collect_maps_from_str(type_str: &str, out: &mut Vec<String>) {
     }
 }
 
+/// Walk every sub-expression and harvest `Map<K,V>` canonicals from
+/// each `Spanned<Expr>::ty()` stamp. Catches map literals (`{a => 3}`
+/// without annotation) and expressions whose type is a Map but the
+/// canonical never shows up in any signature — symmetrical with
+/// `collect_tuples_from_expr`. Recurses into sub-expressions so
+/// nested literals / fn args / match arms all get their stamps
+/// harvested.
+fn collect_maps_from_expr(expr: &crate::ast::Spanned<crate::ast::Expr>, out: &mut Vec<String>) {
+    use crate::ast::Expr;
+    if let Some(ty) = expr.ty() {
+        let display = ty.display();
+        collect_maps_from_str(&display, out);
+    }
+    match &expr.node {
+        Expr::FnCall(callee, args) => {
+            collect_maps_from_expr(callee, out);
+            for a in args {
+                collect_maps_from_expr(a, out);
+            }
+        }
+        Expr::List(items) | Expr::Tuple(items) | Expr::IndependentProduct(items, _) => {
+            for it in items {
+                collect_maps_from_expr(it, out);
+            }
+        }
+        Expr::MapLiteral(entries) => {
+            for (k, v) in entries {
+                collect_maps_from_expr(k, out);
+                collect_maps_from_expr(v, out);
+            }
+        }
+        Expr::RecordCreate { fields, .. } => {
+            for (_, v) in fields {
+                collect_maps_from_expr(v, out);
+            }
+        }
+        Expr::RecordUpdate { base, updates, .. } => {
+            collect_maps_from_expr(base, out);
+            for (_, v) in updates {
+                collect_maps_from_expr(v, out);
+            }
+        }
+        Expr::Constructor(_, Some(arg)) => collect_maps_from_expr(arg, out),
+        Expr::Match { subject, arms } => {
+            collect_maps_from_expr(subject, out);
+            for arm in arms {
+                collect_maps_from_expr(&arm.body, out);
+            }
+        }
+        Expr::BinOp(_, l, r) => {
+            collect_maps_from_expr(l, out);
+            collect_maps_from_expr(r, out);
+        }
+        Expr::Attr(e, _) | Expr::ErrorProp(e) => collect_maps_from_expr(e, out),
+        Expr::TailCall(tc) => {
+            for a in &tc.args {
+                collect_maps_from_expr(a, out);
+            }
+        }
+        _ => {}
+    }
+}
+
 /// Split a canonical `Map<K, V>` into its `K` and `V` parts (both
 /// borrowed slices of the input). Returns `None` if the string
 /// doesn't match the expected shape.

From 40fbb5534e6797812d813f6f9175fbef6cef6de9 Mon Sep 17 00:00:00 2001
From: jasisz <jasisz@gmail.com>
Date: Wed, 6 May 2026 20:18:07 +0200
Subject: [PATCH 15/18] =?UTF-8?q?0.17=20sweep=20[1/4]:=20drop=20Map.empty(?=
 =?UTF-8?q?)=20=E2=80=94=20use=20{}=20literal?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

`Map.empty()` was redundant against the `{}` literal — same way `[]`
covers `List.empty` (which never existed). Bidirectional inference
already propagates the expected `Map<K,V>` from the binding annotation
into `{}`, and the discovery walker introduced in 0.16.3 picks up map
canonicals from `expr.ty()` so unannotated literals like `m = {a => 3}`
also work end-to-end.

Removed:
- typecheck signature + bidirectional case + map_calls arm
- VM dispatch (Value::Map and NanValue paths)
- 4 backends: codegen/builtins enum, rust/wasm/wasm-gc/lean/dafny
  dispatch (lean and dafny had stale match arms that silently turned
  into wildcard bindings after the enum drop — purged)
- types/map.rs `empty` / `empty_nv` fns + member registration

Migration:
- examples: data/map.av (5×), data/json.av (1×), formal/law_auto.av,
  games/rogue (false positive — that's `Map.emptyMap`, a user fn,
  untouched), tools/website/llms.txt
- lib tests: src/types/checker/tests.rs (2×)
- docs: language.md (set example), services.md (Map fn table),
  vm.md (Immediate-tag note); CHANGELOG kept historical wording.

Vera-bench solutions/aver: 0 occurrences, no companion PR needed.

621/621 lib tests, no regressions.

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>
---
 docs/language.md                     |  2 +-
 docs/services.md                     |  2 +-
 docs/vm.md                           |  2 +-
 examples/data/json.av                |  2 +-
 examples/data/map.av                 | 10 +++---
 examples/formal/law_auto.av          |  2 +-
 src/codegen/builtins.rs              |  2 --
 src/codegen/dafny/expr.rs            |  1 -
 src/codegen/lean/builtins.rs         |  1 -
 src/codegen/lean/expr.rs             | 10 ++----
 src/codegen/rust/builtins.rs         |  1 -
 src/codegen/wasm/expr/builtins.rs    |  4 ---
 src/codegen/wasm_gc/body/builtins.rs | 49 ++--------------------------
 src/types/checker/builtins.rs        |  1 -
 src/types/checker/infer/expr.rs      |  3 --
 src/types/checker/infer/map_calls.rs |  8 -----
 src/types/checker/tests.rs           |  4 +--
 src/types/map.rs                     | 29 +++-------------
 src/vm/builtin.rs                    |  5 +--
 tools/website/llms.txt               |  2 +-
 20 files changed, 23 insertions(+), 117 deletions(-)

diff --git a/docs/language.md b/docs/language.md
index 380fee17..a3b7e7e1 100644
--- a/docs/language.md
+++ b/docs/language.md
@@ -245,7 +245,7 @@ Most application code in Aver stays first-order and explicit. Use function param
 Aver has no dedicated `Set` type. The idiomatic way to express a set is `Map<T, Unit>` — a map whose values carry no information. All `Map.*` operations work on sets:
 
 ```aver
-seen: Map<String, Unit> = Map.empty()
+seen: Map<String, Unit> = {}
 seen2 = Map.set(seen, "alice", Unit)
 Map.has(seen2, "alice")   // true
 Map.len(seen2)            // 1
diff --git a/docs/services.md b/docs/services.md
index 3c8dd502..76914afd 100644
--- a/docs/services.md
+++ b/docs/services.md
@@ -134,7 +134,7 @@ Source: `src/types/map.rs`
 
 | Function | Signature | Notes |
 |---|---|---|
-| `Map.empty` | `() -> Map<K, V>` | |
+| `{}` (literal) | — | The empty map; type from context (annotation or expected type). No `Map.empty()` builtin since 0.17 — symmetric with `[]` for List. |
 | `Map.fromList` | `List<(K, V)> -> Map<K, V>` | Keys must be hashable (Int, Float, String, Bool) |
 | `Map.set` | `(Map<K, V>, K, V) -> Map<K, V>` | Returns new map with key set |
 | `Map.get` | `(Map<K, V>, K) -> Option<V>` | |
diff --git a/docs/vm.md b/docs/vm.md
index 852beba3..139ad469 100644
--- a/docs/vm.md
+++ b/docs/vm.md
@@ -117,7 +117,7 @@ The point of `v2` is not only compactness. It is to keep the common Aver shapes
 - `Bool`, `Unit`, and `None` are pure inline singletons
 - `Some(true)`, `Ok(Unit)`, `Err(None)` stay inline
 - `Some(42)`, `Ok(-7)`, `Err(0)` stay inline as long as the int fits the wrapper-inline range
-- `[]` and `Map.empty()` are real values under their normal collection tags, not exceptions hidden in `Immediate`
+- `[]` and `{}` are real values under their normal collection tags, not exceptions hidden in `Immediate`
 - strings up to 5 UTF-8 bytes stay inline under `TAG_STRING`
 - nullary variants such as `Status.Todo` or `Color.Red` travel as `Symbol` handles instead of arena entries
 
diff --git a/examples/data/json.av b/examples/data/json.av
index 12c24795..fa81385e 100644
--- a/examples/data/json.av
+++ b/examples/data/json.av
@@ -1081,7 +1081,7 @@ verify parseArrayNext
 
 fn emptyJsonMap() -> Map<String, Json>
     ? "JSON helper: emptyJsonMap."
-    Map.empty()
+    {}
 
 fn parseObject(s: String, pos: Int) -> ParseResult
     ? "JSON helper: parseObject."
diff --git a/examples/data/map.av b/examples/data/map.av
index 97cca983..b7d0e2dc 100644
--- a/examples/data/map.av
+++ b/examples/data/map.av
@@ -6,7 +6,7 @@ module MapExample
 
 fn emptyCounts() -> Map<String, Int>
     ? "Creates an empty word-count map."
-    Map.empty()
+    {}
 
 fn incCount(counts: Map<String, Int>, word: String) -> Map<String, Int>
     ? "Increments the counter for one word."
@@ -16,16 +16,16 @@ fn incCount(counts: Map<String, Int>, word: String) -> Map<String, Int>
         Option.None    -> Map.set(counts, word, 1)
 
 verify incCount
-    incCount(Map.empty(), "a") => {"a" => 1}
+    incCount({}, "a") => {"a" => 1}
     incCount({"a" => 1}, "a") => {"a" => 2}
 
 verify incCount law keyPresent
-    given counts: Map<String, Int> = [Map.empty(), {"a" => 1}, {"x" => 2, "y" => 4}]
+    given counts: Map<String, Int> = [{}, {"a" => 1}, {"x" => 2, "y" => 4}]
     given word: String = ["a", "z", "new"]
     Map.has(incCount(counts, word), word) => true
 
 verify incCount law trackedCountStepsByOne
-    given counts: Map<String, Int> = [Map.empty(), {"a" => 1}, {"a" => 5, "x" => 2}]
+    given counts: Map<String, Int> = [{}, {"a" => 1}, {"a" => 5, "x" => 2}]
     given word: String = ["a", "new"]
     Option.withDefault(Map.get(incCount(counts, word), word), 0) => Option.withDefault(Map.get(counts, word), 0) + 1
 
@@ -36,7 +36,7 @@ fn countWords(words: List<String>) -> Map<String, Int>
         [word, ..rest] -> incCount(countWords(rest), word)
 
 verify countWords
-    countWords([])                => Map.empty()
+    countWords([])                => {}
     countWords(["a", "b", "a"])  => {"a" => 2, "b" => 1}
 
 verify countWords law presenceMatchesContains
diff --git a/examples/formal/law_auto.av b/examples/formal/law_auto.av
index c99b076a..3bfd2b1b 100644
--- a/examples/formal/law_auto.av
+++ b/examples/formal/law_auto.av
@@ -84,7 +84,7 @@ fn incCount(counts: Map<String, Int>, word: String) -> Map<String, Int>
         Option.None -> Map.set(counts, word, 1)
 
 verify incCount law keyPresent
-    given counts: Map<String, Int> = [Map.empty(), {"a" => 1}, {"x" => 2, "y" => 4}]
+    given counts: Map<String, Int> = [{}, {"a" => 1}, {"x" => 2, "y" => 4}]
     given word: String = ["a", "z", "new"]
     Map.has(incCount(counts, word), word) => true
 
diff --git a/src/codegen/builtins.rs b/src/codegen/builtins.rs
index db1db69a..b3636a1b 100644
--- a/src/codegen/builtins.rs
+++ b/src/codegen/builtins.rs
@@ -102,7 +102,6 @@ pub(crate) enum Builtin {
     VectorToList,
 
     // --- Map ---
-    MapEmpty,
     MapGet,
     MapSet,
     MapHas,
@@ -217,7 +216,6 @@ pub(crate) fn recognize_builtin(name: &str) -> Option<Builtin> {
         "Vector.toList" => Builtin::VectorToList,
 
         // Map
-        "Map.empty" => Builtin::MapEmpty,
         "Map.get" => Builtin::MapGet,
         "Map.set" => Builtin::MapSet,
         "Map.has" => Builtin::MapHas,
diff --git a/src/codegen/dafny/expr.rs b/src/codegen/dafny/expr.rs
index 752b434e..c125c31b 100644
--- a/src/codegen/dafny/expr.rs
+++ b/src/codegen/dafny/expr.rs
@@ -468,7 +468,6 @@ fn emit_dafny_builtin(b: crate::codegen::builtins::Builtin, a: &[String]) -> Str
         VectorToList => a[0].clone(),
 
         // Map
-        MapEmpty => "map[]".to_string(),
         MapGet => format!("MapGet({}, {})", a[0], a[1]),
         MapSet => format!("{}[{} := {}]", a[0], a[1], a[2]),
         MapHas => format!("({} in {})", a[1], a[0]),
diff --git a/src/codegen/lean/builtins.rs b/src/codegen/lean/builtins.rs
index 251b545a..e0d83719 100644
--- a/src/codegen/lean/builtins.rs
+++ b/src/codegen/lean/builtins.rs
@@ -135,7 +135,6 @@ pub fn emit_builtin_call(
         VectorToList => format!("{}.toList", p(&a[0])),
 
         // ---- Map ----
-        MapEmpty => "AverMap.empty".to_string(),
         MapGet => format!("AverMap.get {} {}", p(&a[0]), p(&a[1])),
         MapSet => format!("AverMap.set {} {} {}", p(&a[0]), p(&a[1]), p(&a[2])),
         MapHas => format!("AverMap.has {} {}", p(&a[0]), p(&a[1])),
diff --git a/src/codegen/lean/expr.rs b/src/codegen/lean/expr.rs
index b683fa9b..4d90f760 100644
--- a/src/codegen/lean/expr.rs
+++ b/src/codegen/lean/expr.rs
@@ -405,14 +405,8 @@ fn extract_bool_arms(arms: &[MatchArm]) -> Option<(&Spanned<Expr>, &Spanned<Expr
 pub fn emit_stmt(stmt: &Stmt, ctx: &CodegenContext) -> String {
     match stmt {
         Stmt::Binding(name, type_ann, expr) => {
-            let mut val = emit_expr(expr, ctx);
-            // Map<T, Unit> binding initialized with Map.empty → set empty
-            if let Some(ann) = type_ann
-                && crate::codegen::common::is_set_annotation(ann)
-                && val == "AverMap.empty"
-            {
-                val = "AverSet.empty".to_string();
-            }
+            let val = emit_expr(expr, ctx);
+            let _ = type_ann;
             format!("let {} := {}", aver_name_to_lean(name), val)
         }
         Stmt::Expr(expr) => emit_expr(expr, ctx),
diff --git a/src/codegen/rust/builtins.rs b/src/codegen/rust/builtins.rs
index 7c31d5b4..4ad93ff3 100644
--- a/src/codegen/rust/builtins.rs
+++ b/src/codegen/rust/builtins.rs
@@ -662,7 +662,6 @@ fn emit_builtin_call_inner(
             ))
         }
         // ---- Map ----
-        "Map.empty" => Some("HashMap::new()".to_string()),
         "Map.fromList" => {
             let list = clone_arg(&args[0], ctx, ectx);
             Some(format!(
diff --git a/src/codegen/wasm/expr/builtins.rs b/src/codegen/wasm/expr/builtins.rs
index b07fa00a..1270b932 100644
--- a/src/codegen/wasm/expr/builtins.rs
+++ b/src/codegen/wasm/expr/builtins.rs
@@ -127,10 +127,6 @@ impl<'a> ExprEmitter<'a> {
                 self.instructions
                     .push(Instruction::Call(self.rt.f64_to_str_obj));
             }
-            "Map.empty" if args.is_empty() => {
-                // Empty map = empty association list = null ptr
-                self.instructions.push(Instruction::I32Const(0));
-            }
             "Map.get" if args.len() == 2 => {
                 // args on stack: [map(i32), key(?)]
                 // ABI: rt_map_get(map: i32, key: i64, kind: i32) -> i32
diff --git a/src/codegen/wasm_gc/body/builtins.rs b/src/codegen/wasm_gc/body/builtins.rs
index 9bea0b4a..ecba77b3 100644
--- a/src/codegen/wasm_gc/body/builtins.rs
+++ b/src/codegen/wasm_gc/body/builtins.rs
@@ -387,9 +387,9 @@ pub(super) fn emit_dotted_builtin(
             emit_option_to_result(func, &args[0], &args[1], slots, ctx)
         }
         // Map<K, V> — dispatch to the per-instantiation helper. The
-        // canonical comes from inferring the type of the map argument
-        // (or the surrounding context for Map.empty).
-        "Map.empty" => emit_map_empty_call(func, args, slots, ctx),
+        // canonical comes from inferring the type of the map argument.
+        // Empty map literals (`{}`) flow through `emit_map_literal`
+        // — there is no `Map.empty()` builtin.
         "Map.set" | "Map.get" | "Map.len" | "Map.has" | "Map.keys" | "Map.values"
         | "Map.remove" | "Map.entries" => emit_map_kv_call(func, method, args, slots, ctx),
         "Map.fromList" if args.len() == 1 => emit_map_from_list_call(func, &args[0], slots, ctx),
@@ -444,11 +444,6 @@ pub(super) fn emit_dotted_builtin(
     }
 }
 
-/// `Map.empty()` → `call $map_empty_KV`. With a single registered
-/// instantiation the canonical is unambiguous; with several, the type
-/// must be deducible from the surrounding context (which today only
-/// works when one instantiation exists — generalising would mean
-/// threading expected-type through expression emission).
 /// Inline lowering of `Args.get()` (no args, returns `List<String>`).
 /// Host imports are `args_len(): i64` and `args_get(i: i64): String`;
 /// no `args_get_all`. Walks `i = len-1 .. 0` cons-building the list so
@@ -537,44 +532,6 @@ pub(super) fn emit_args_get_inline(
     Ok(())
 }
 
-pub(super) fn emit_map_empty_call(
-    func: &mut Function,
-    args: &[Spanned<Expr>],
-    _slots: &SlotTable,
-    ctx: &EmitCtx<'_>,
-) -> Result<(), WasmGcError> {
-    if !args.is_empty() {
-        return Err(WasmGcError::Validation(format!(
-            "Map.empty expects 0 args, got {}",
-            args.len()
-        )));
-    }
-    let canonical = if ctx.registry.map_order.len() == 1 {
-        ctx.registry.map_order[0].clone()
-    } else {
-        // Multi-Map module — disambiguate by checking the enclosing
-        // fn's return type. Common case: `fn build() -> Map<K, V>`
-        // wraps a `Map.set(Map.empty(), ...)` chain; the empty call
-        // inherits its slot from the declared return type.
-        let ret_canonical = super::super::types::normalize_compound(ctx.return_type);
-        if ctx.registry.map_slots(&ret_canonical).is_some() {
-            ret_canonical
-        } else {
-            return Err(WasmGcError::Unimplemented(
-                "Map.empty across multiple Map<K,V> instantiations needs context-driven type inference",
-            ));
-        }
-    };
-    let helpers = ctx
-        .fn_map
-        .map_helpers_lookup(&canonical)
-        .ok_or(WasmGcError::Validation(format!(
-            "Map.empty: helpers missing for `{canonical}`"
-        )))?;
-    func.instruction(&Instruction::Call(helpers.empty));
-    Ok(())
-}
-
 /// Map.set / Map.get / Map.len dispatch — the canonical is recovered
 /// from the map argument's inferred type, helper indices come from
 /// `fn_map.map_helpers`.
diff --git a/src/types/checker/builtins.rs b/src/types/checker/builtins.rs
index 0a869886..d8edb34f 100644
--- a/src/types/checker/builtins.rs
+++ b/src/types/checker/builtins.rs
@@ -555,7 +555,6 @@ impl TypeChecker {
         let v_var = || Type::Var("V".to_string());
         let map_kv = || Type::Map(Box::new(k_var()), Box::new(v_var()));
         let map_sigs: &[(&str, &[Type], Type, &[&str])] = &[
-            ("Map.empty", &[], map_kv(), &[]),
             ("Map.set", &[map_kv(), k_var(), v_var()], map_kv(), &[]),
             (
                 "Map.get",
diff --git a/src/types/checker/infer/expr.rs b/src/types/checker/infer/expr.rs
index 1ddafd4c..6e904089 100644
--- a/src/types/checker/infer/expr.rs
+++ b/src/types/checker/infer/expr.rs
@@ -201,9 +201,6 @@ impl TypeChecker {
             Expr::FnCall(callee, args) => {
                 let key = Self::callee_key(&callee.node)?;
                 match (key.as_str(), args.len(), expected) {
-                    // Map.empty() — no args, expected must be Map<K, V>.
-                    ("Map.empty", 0, Type::Map(_, _)) => Some(expected.clone()),
-
                     // Map.fromList(xs) — expected Map<K, V> gives xs the
                     // concrete List<(K, V)> element type.
                     ("Map.fromList", 1, Type::Map(k, v)) => {
diff --git a/src/types/checker/infer/map_calls.rs b/src/types/checker/infer/map_calls.rs
index 74e8a0e9..44e320b1 100644
--- a/src/types/checker/infer/map_calls.rs
+++ b/src/types/checker/infer/map_calls.rs
@@ -10,8 +10,6 @@ impl TypeChecker {
         let option_ty = |v: Type| Type::Option(Box::new(v));
         let list_ty = |v: Type| Type::List(Box::new(v));
         let tuple2 = |k: Type, v: Type| Type::Tuple(vec![k, v]);
-        let k_var = || Type::Var("K".to_string());
-        let v_var = || Type::Var("V".to_string());
         let is_hashable_key_type = |ty: &Type| {
             // The Map runtime hashes any heap value through rt_deep_hash,
             // so user-defined types (variants/records/tuples/lists) are
@@ -58,12 +56,6 @@ impl TypeChecker {
         };
 
         match name {
-            "Map.empty" => {
-                if let Err(fallback) = expect_arity(self, 0, map_ty(Type::Invalid, Type::Invalid)) {
-                    return Some(fallback);
-                }
-                Some(map_ty(k_var(), v_var()))
-            }
             "Map.len" => {
                 if let Err(fallback) = expect_arity(self, 1, Type::Int) {
                     return Some(fallback);
diff --git a/src/types/checker/tests.rs b/src/types/checker/tests.rs
index 43e41770..4b9ec421 100644
--- a/src/types/checker/tests.rs
+++ b/src/types/checker/tests.rs
@@ -309,7 +309,7 @@ record AppCtx
     config: String
 
 fn handler(ctx: AppCtx, req: HttpRequest) -> HttpResponse
-    HttpResponse(status = 200, body = "ok", headers = Map.empty())
+    HttpResponse(status = 200, body = "ok", headers = {})
 
 fn main() -> Unit
     ! [HttpServer.listenWith]
@@ -333,7 +333,7 @@ record AppCtx
     config: String
 
 fn handler(ctx: AppCtx, req: HttpRequest) -> HttpResponse
-    HttpResponse(status = 200, body = ctx.config, headers = Map.empty())
+    HttpResponse(status = 200, body = ctx.config, headers = {})
 
 fn main(ctx: AppCtx) -> Unit
     ! [HttpServer.listenWith]
diff --git a/src/types/map.rs b/src/types/map.rs
index 215748ce..72e3aede 100644
--- a/src/types/map.rs
+++ b/src/types/map.rs
@@ -1,7 +1,6 @@
 /// Map namespace — immutable key/value map helpers.
 ///
 /// Methods:
-///   Map.empty()                 → Map<K, V>
 ///   Map.set(map, key, value)    → Map<K, V>
 ///   Map.get(map, key)           → Option<V>
 ///   Map.remove(map, key)        → Map<K, V>
@@ -12,6 +11,9 @@
 ///   Map.len(map)                → Int
 ///   Map.fromList(pairs)         → Map<K, V> where each pair is (key, value)
 ///
+/// The empty map is the literal `{}` (with type from context); there is
+/// no `Map.empty()` builtin since 0.17 — symmetric with `[]` for List.
+///
 /// Key constraint: only scalar keys are allowed (Int, Float, String, Bool).
 ///
 /// No effects required.
@@ -25,7 +27,7 @@ use crate::value::{RuntimeError, Value, aver_repr, list_from_vec, list_view};
 pub fn register(global: &mut HashMap<String, Value>) {
     let mut members = HashMap::new();
     for method in &[
-        "empty", "set", "get", "remove", "has", "keys", "values", "entries", "len", "fromList",
+        "set", "get", "remove", "has", "keys", "values", "entries", "len", "fromList",
     ] {
         members.insert(
             method.to_string(),
@@ -48,7 +50,6 @@ pub fn effects(_name: &str) -> &'static [&'static str] {
 /// Returns `Some(result)` when `name` is owned by this namespace, `None` otherwise.
 pub fn call(name: &str, args: &[Value]) -> Option<Result<Value, RuntimeError>> {
     match name {
-        "Map.empty" => Some(empty(args)),
         "Map.set" => Some(set(args)),
         "Map.get" => Some(get(args)),
         "Map.remove" => Some(remove(args)),
@@ -62,16 +63,6 @@ pub fn call(name: &str, args: &[Value]) -> Option<Result<Value, RuntimeError>> {
     }
 }
 
-fn empty(args: &[Value]) -> Result<Value, RuntimeError> {
-    if !args.is_empty() {
-        return Err(RuntimeError::Error(format!(
-            "Map.empty() takes 0 arguments, got {}",
-            args.len()
-        )));
-    }
-    Ok(Value::Map(HashMap::new()))
-}
-
 fn set(args: &[Value]) -> Result<Value, RuntimeError> {
     let [map_val, key, value] = three_args("Map.set", args)?;
     let Value::Map(map) = map_val else {
@@ -294,7 +285,6 @@ pub fn call_nv(
     arena: &mut Arena,
 ) -> Option<Result<NanValue, RuntimeError>> {
     match name {
-        "Map.empty" => Some(empty_nv(args, arena)),
         "Map.set" => Some(set_nv(args, arena)),
         "Map.get" => Some(get_nv(args, arena)),
         "Map.remove" => Some(remove_nv(args, arena)),
@@ -331,17 +321,6 @@ fn nv_key_bits(v: NanValue, arena: &Arena) -> u64 {
     v.map_key_hash_deep(arena)
 }
 
-fn empty_nv(args: &[NanValue], arena: &mut Arena) -> Result<NanValue, RuntimeError> {
-    if !args.is_empty() {
-        return Err(RuntimeError::Error(format!(
-            "Map.empty() takes 0 arguments, got {}",
-            args.len()
-        )));
-    }
-    let _ = arena;
-    Ok(NanValue::EMPTY_MAP)
-}
-
 /// Map.set with sole-owned first argument — takes instead of cloning.
 pub fn set_nv_owned(args: &[NanValue], arena: &mut Arena) -> Result<NanValue, RuntimeError> {
     if args.len() != 3 {
diff --git a/src/vm/builtin.rs b/src/vm/builtin.rs
index a0a35122..5d178659 100644
--- a/src/vm/builtin.rs
+++ b/src/vm/builtin.rs
@@ -146,7 +146,6 @@ vm_builtins! {
     ListContains => "List.contains",
     ListZip => "List.zip",
 
-    MapEmpty => "Map.empty",
     MapSet => "Map.set",
     MapGet => "Map.get",
     MapRemove => "Map.remove",
@@ -224,7 +223,6 @@ impl VmBuiltin {
             | Self::StringEndsWith
             | Self::StringContains
             | Self::ListContains
-            | Self::MapEmpty
             | Self::MapLen
             | Self::MapHas
             | Self::VectorLen
@@ -472,8 +470,7 @@ impl VmBuiltin {
             | Self::ListContains
             | Self::ListZip => list::call_nv(self.name(), args, arena),
 
-            Self::MapEmpty
-            | Self::MapSet
+            Self::MapSet
             | Self::MapGet
             | Self::MapRemove
             | Self::MapHas
diff --git a/tools/website/llms.txt b/tools/website/llms.txt
index 0ead6c76..e002ddf2 100644
--- a/tools/website/llms.txt
+++ b/tools/website/llms.txt
@@ -321,7 +321,7 @@ Key `Vector` API (O(1) indexed access):
 - `Vector.new(n, default)`, `Vector.get(v, i) -> Option<T>`, `Vector.set(v, i, val) -> Option<Vector<T>>`
 
 Key `Map` API:
-- `Map.empty()`, `Map.fromList(pairs)`, `Map.get(m, k) -> Option<V>`, `Map.set(m, k, v)`, `Map.has(m, k)`, `Map.remove(m, k)`, `Map.keys(m)`, `Map.len(m)`
+- `{}`, `Map.fromList(pairs)`, `Map.get(m, k) -> Option<V>`, `Map.set(m, k, v)`, `Map.has(m, k)`, `Map.remove(m, k)`, `Map.keys(m)`, `Map.len(m)`
 
 Effectful namespaces:
 - `Console`: print, error, warn, readLine — **`print`/`error`/`warn` take `String`**, not arbitrary values. Stringify at the call site: interpolation `"{x}"` for primitives, a per-type render fn (`fn show(r: Result<T, E>) -> String`) for compound shapes.

From 9066b09ff76f30ffb86b90792086f0be1510536d Mon Sep 17 00:00:00 2001
From: jasisz <jasisz@gmail.com>
Date: Wed, 6 May 2026 20:27:22 +0200
Subject: [PATCH 16/18] 0.17 sweep [2/4]: drop unreachable builtin aliases
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

`Int.parse`, `Float.parse`, `Int.rem` were registered in 4 backend
dispatch tables (codegen/builtins enum + name table, lean, dafny, rust)
but never reachable from Aver source — typecheck didn't know them, VM
didn't dispatch them. Lean and dafny treated them as outright aliases
for `Int.fromString` / `Float.fromString` / `Int.mod` (`IntFromString
| IntParse =>`, `IntRem | IntMod =>`). Half-cooked: enum variants
existed without the language ever exposing them.

Drop the 3 surface names and their `Builtin::Int{Parse,Rem}` /
`Builtin::FloatParse` enum variants from every backend they leaked
into. No migration needed — they were unreachable.

621/621 lib tests, build green.

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>
---
 src/codegen/builtins.rs      |  6 ------
 src/codegen/dafny/expr.rs    |  6 +++---
 src/codegen/lean/builtins.rs |  5 ++---
 src/codegen/rust/builtins.rs | 15 ---------------
 src/codegen/rust/expr.rs     |  1 -
 5 files changed, 5 insertions(+), 28 deletions(-)

diff --git a/src/codegen/builtins.rs b/src/codegen/builtins.rs
index b3636a1b..eb872df7 100644
--- a/src/codegen/builtins.rs
+++ b/src/codegen/builtins.rs
@@ -20,10 +20,8 @@ pub(crate) enum Builtin {
     IntToFloat,
     IntToString,
     IntFromString,
-    IntParse,
     IntMin,
     IntMax,
-    IntRem,
     IntMod,
 
     // --- Float ---
@@ -36,7 +34,6 @@ pub(crate) enum Builtin {
     FloatToInt,
     FloatToString,
     FloatFromString,
-    FloatParse,
     FloatPi,
     FloatMin,
     FloatMax,
@@ -134,10 +131,8 @@ pub(crate) fn recognize_builtin(name: &str) -> Option<Builtin> {
         "Int.toFloat" | "Float.fromInt" => Builtin::IntToFloat,
         "Int.toString" => Builtin::IntToString,
         "Int.fromString" => Builtin::IntFromString,
-        "Int.parse" => Builtin::IntParse,
         "Int.min" => Builtin::IntMin,
         "Int.max" => Builtin::IntMax,
-        "Int.rem" => Builtin::IntRem,
         "Int.mod" => Builtin::IntMod,
 
         // Float
@@ -150,7 +145,6 @@ pub(crate) fn recognize_builtin(name: &str) -> Option<Builtin> {
         "Float.toInt" => Builtin::FloatToInt,
         "Float.toString" => Builtin::FloatToString,
         "Float.fromString" => Builtin::FloatFromString,
-        "Float.parse" => Builtin::FloatParse,
         "Float.pi" => Builtin::FloatPi,
         "Float.min" => Builtin::FloatMin,
         "Float.max" => Builtin::FloatMax,
diff --git a/src/codegen/dafny/expr.rs b/src/codegen/dafny/expr.rs
index c125c31b..04c0cd1a 100644
--- a/src/codegen/dafny/expr.rs
+++ b/src/codegen/dafny/expr.rs
@@ -379,10 +379,10 @@ fn emit_dafny_builtin(b: crate::codegen::builtins::Builtin, a: &[String]) -> Str
         IntAbs => format!("(if {} >= 0 then {} else -{})", a[0], a[0], a[0]),
         IntToFloat => format!("({} as real)", a[0]),
         IntToString | StringFromInt => format!("IntToString({})", a[0]),
-        IntFromString | IntParse => format!("IntFromString({})", a[0]),
+        IntFromString => format!("IntFromString({})", a[0]),
         IntMin => format!("(if {} <= {} then {} else {})", a[0], a[1], a[0], a[1]),
         IntMax => format!("(if {} >= {} then {} else {})", a[0], a[1], a[0], a[1]),
-        IntRem | IntMod => format!("Result<int, string>.Ok(({} % {}))", a[0], a[1]),
+        IntMod => format!("Result<int, string>.Ok(({} % {}))", a[0], a[1]),
 
         // Float
         FloatAbs => format!("(if {} >= 0.0 then {} else -{})", a[0], a[0], a[0]),
@@ -390,7 +390,7 @@ fn emit_dafny_builtin(b: crate::codegen::builtins::Builtin, a: &[String]) -> Str
         FloatPow => format!("FloatPow({}, {})", a[0], a[1]),
         FloatRound | FloatFloor | FloatCeil | FloatToInt => format!("FloatToInt({})", a[0]),
         FloatToString | StringFromFloat => format!("FloatToString({})", a[0]),
-        FloatFromString | FloatParse => format!("FloatFromString({})", a[0]),
+        FloatFromString => format!("FloatFromString({})", a[0]),
         FloatPi => "FloatPi()".to_string(),
         FloatMin => format!("(if {} <= {} then {} else {})", a[0], a[1], a[0], a[1]),
         FloatMax => format!("(if {} >= {} then {} else {})", a[0], a[1], a[0], a[1]),
diff --git a/src/codegen/lean/builtins.rs b/src/codegen/lean/builtins.rs
index e0d83719..31254946 100644
--- a/src/codegen/lean/builtins.rs
+++ b/src/codegen/lean/builtins.rs
@@ -46,15 +46,14 @@ pub fn emit_builtin_call(
         IntToString => format!("toString {}", p(&a[0])),
         IntMin => format!("min {} {}", p(&a[0]), p(&a[1])),
         IntMax => format!("max {} {}", p(&a[0]), p(&a[1])),
-        IntRem | IntMod => format!("(Except.ok ({} % {}) : Except String Int)", a[0], a[1]),
+        IntMod => format!("(Except.ok ({} % {}) : Except String Int)", a[0], a[1]),
         IntFromString => format!("Int.fromString {}", p(&a[0])),
-        IntParse => format!("Int.fromString {}", p(&a[0])),
 
         // ---- Float ----
         FloatAbs => format!("Float.abs {}", p(&a[0])),
         FloatSqrt => format!("Float.sqrt {}", p(&a[0])),
         FloatToString => format!("toString {}", p(&a[0])),
-        FloatFromString | FloatParse => format!("Float.fromString {}", p(&a[0])),
+        FloatFromString => format!("Float.fromString {}", p(&a[0])),
         FloatPow => format!("AverFloat.pow {} {}", p(&a[0]), p(&a[1])),
         FloatRound => format!("AverFloat.round {}", p(&a[0])),
         FloatFloor => format!("AverFloat.floor {}", p(&a[0])),
diff --git a/src/codegen/rust/builtins.rs b/src/codegen/rust/builtins.rs
index 4ad93ff3..2ac66182 100644
--- a/src/codegen/rust/builtins.rs
+++ b/src/codegen/rust/builtins.rs
@@ -14,8 +14,6 @@ fn builtin_needs_str_conversion(name: &str) -> bool {
             | "Time.now"
             | "Int.toString"
             | "Float.toString"
-            | "Int.parse"
-            | "Float.parse"
             | "Int.fromString"
             | "Float.fromString"
             | "String.slice"
@@ -418,10 +416,6 @@ fn emit_builtin_call_inner(
             let arg = emit_arg(0);
             Some(format!("{}.to_string()", arg))
         }
-        "Int.parse" => {
-            let arg = emit_arg(0);
-            Some(format!("{}.parse::<i64>().map_err(|e| e.to_string())", arg))
-        }
         "Int.fromString" => {
             let arg = emit_arg(0);
             Some(format!("{}.parse::<i64>().map_err(|e| e.to_string())", arg))
@@ -436,11 +430,6 @@ fn emit_builtin_call_inner(
             let b = emit_arg(1);
             Some(format!("{}.max({})", a, b))
         }
-        "Int.rem" => {
-            let a = emit_arg(0);
-            let b = emit_arg(1);
-            Some(format!("({} % {})", a, b))
-        }
         "Int.mod" => {
             let a = emit_arg(0);
             let b = emit_arg(1);
@@ -478,10 +467,6 @@ fn emit_builtin_call_inner(
             let arg = emit_arg(0);
             Some(format!("{}.to_string()", arg))
         }
-        "Float.parse" => {
-            let arg = emit_arg(0);
-            Some(format!("{}.parse::<f64>().map_err(|e| e.to_string())", arg))
-        }
         "Float.sqrt" => {
             let arg = emit_arg(0);
             Some(format!("{}.sqrt()", arg))
diff --git a/src/codegen/rust/expr.rs b/src/codegen/rust/expr.rs
index 783e1b01..566e2017 100644
--- a/src/codegen/rust/expr.rs
+++ b/src/codegen/rust/expr.rs
@@ -1074,7 +1074,6 @@ fn expr_is_numeric(expr: &Expr, ectx: &EmitCtx) -> bool {
                     "Int.abs"
                         | "Int.min"
                         | "Int.max"
-                        | "Int.rem"
                         | "Float.abs"
                         | "Float.floor"
                         | "Float.ceil"

From 7ef288bf23effbb21ca28c19036d740076de37fc Mon Sep 17 00:00:00 2001
From: jasisz <jasisz@gmail.com>
Date: Wed, 6 May 2026 21:06:04 +0200
Subject: [PATCH 17/18] 0.17.0 "Purge" [3+4/4]: stdlib convention + version
 bump
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Drops six redundant builtins, renames one for symmetry, bumps to
0.17.0. The convention `Target.fromSource` for type conversions wins;
operators (`+` on strings, arithmetic, comparisons) and literals
(`{}`, `[]`) cover composition; named functions only when they add
semantics that can't be expressed otherwise.

Removed:
- `Int.toString`   → `String.fromInt(n)`  or  `"{n}"` interpolation
- `Float.toString` → `String.fromFloat(f)` or `"{f}"` interpolation
- `Float.toInt`    → `Int.fromFloat(f)`
- `Int.toFloat`    → `Float.fromInt(n)`
- `String.concat(a, b)` → `a + b`

Renamed:
- `Vector.toList(v)` → `List.fromVector(v)` (paired with the existing
  `Vector.fromList(l)` under the same convention)

Migration:
- examples / docs / lib tests / website playground sources sed-migrated
  in one batch; the `Float.fromInt` / `Int.fromFloat` confusion in
  docs/language.md (sed double-replacement artifact) hand-fixed.
- VM body fns + dispatch tables in `types/{int,float,vector}.rs` purged
  of the dropped names; `String.fromX` body fns in `types/string.rs`
  unchanged (they're the canonical replacements).
- Builtin enum variants in `codegen/builtins.rs` dropped/renamed:
  `IntToString` / `FloatToString` / `IntToFloat` / `FloatToInt` /
  `StringConcat` / `VectorToList` → `IntFromFloat` / `FloatFromInt` /
  `ListFromVector` (or removed for the duplicates).
- Backend dispatchers (rust, wasm legacy, wasm-gc, lean, dafny)
  re-pointed to new names; lean/dafny opaque function declarations
  (`IntToString`, `FloatToString`, `FloatToInt` as Lean/Dafny names)
  kept — they're external-language conventions, not Aver surface.
- `wasm_gc::BuiltinName::IntToString` / `FloatToString` enum variants
  kept as internal Rust labels (now mapped from `String.fromInt` /
  `String.fromFloat`); renaming the labels was unnecessary churn.
- Self-host `aver_generated/` left as-is (will regenerate on next
  self-host bootstrap; stale arms are dead since typecheck rejects the
  old names).

Vera-bench solutions/aver: zero usage of any removed/renamed builtin
(checked again before bumping). No companion PR needed.

Cargo.toml: 0.16.2 → 0.17.0; aver-lsp's `aver-lang` path-dep version
bumped in lockstep.

621/621 lib tests, examples typecheck, runtime VM == wasm-gc on
data/map.av and friends.

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>
---
 CHANGELOG.md                                  | 40 +++++++++++
 Cargo.lock                                    |  2 +-
 Cargo.toml                                    |  2 +-
 aver-lsp/Cargo.toml                           |  2 +-
 docs/language.md                              |  2 +-
 docs/services.md                              |  8 +--
 examples/data/date.av                         | 12 ++--
 examples/data/fibonacci.av                    |  2 +-
 examples/games/checkers/main.av               | 16 ++---
 examples/games/checkers/render.av             |  6 +-
 examples/games/doom/enemy.av                  |  8 +--
 examples/games/doom/level.av                  |  2 +-
 examples/games/doom/main.av                   |  6 +-
 examples/games/doom/math.av                   |  2 +-
 examples/games/doom/render.av                 | 22 +++---
 examples/games/doom/rng.av                    |  2 +-
 examples/games/life.av                        | 10 +--
 examples/games/rogue/main.av                  | 22 +++---
 examples/games/snake.av                       |  6 +-
 examples/games/tetris/main.av                 |  8 +--
 examples/games/wumpus.av                      |  8 +--
 examples/services/redis.av                    |  4 +-
 src/checker/perf.rs                           | 28 ++++----
 src/codegen/builtins.rs                       | 18 ++---
 src/codegen/dafny/expr.rs                     | 12 ++--
 src/codegen/lean/builtins.rs                  |  9 +--
 src/codegen/rust/builtins.rs                  | 20 +-----
 src/codegen/rust/expr.rs                      |  2 +-
 src/codegen/wasm/alloc_policy.rs              |  4 +-
 src/codegen/wasm/expr/builtins.rs             | 10 +--
 src/codegen/wasm_gc/body/builtins.rs          | 12 ++--
 src/codegen/wasm_gc/builtins/mod.rs           |  7 +-
 src/codegen/wasm_gc/types.rs                  |  5 +-
 src/ir/alloc_info.rs                          |  8 +--
 src/ir/analyze.rs                             |  2 +-
 src/types/checker/builtins.rs                 |  5 +-
 src/types/checker/infer/vector_calls.rs       |  2 +-
 src/types/float.rs                            | 26 -------
 src/types/int.rs                              | 71 ++-----------------
 src/types/list.rs                             | 20 +++++-
 src/types/vector.rs                           | 18 ++---
 src/vm/alloc_policy.rs                        |  2 +-
 src/vm/builtin.rs                             | 13 +---
 tools/edge/bench.av                           |  2 +-
 tools/edge/fractal.av                         | 42 +++++------
 tools/website/llms.txt                        |  8 +--
 .../sources/examples/games/checkers/main.av   | 16 ++---
 .../sources/examples/games/checkers/render.av |  6 +-
 .../sources/examples/games/doom/enemy.av      |  8 +--
 .../sources/examples/games/doom/level.av      |  2 +-
 .../sources/examples/games/doom/main.av       |  6 +-
 .../sources/examples/games/doom/math.av       |  2 +-
 .../sources/examples/games/doom/render.av     | 22 +++---
 .../sources/examples/games/doom/rng.av        |  2 +-
 .../playground/sources/examples/games/life.av | 10 +--
 .../sources/examples/games/rogue/main.av      | 22 +++---
 .../sources/examples/games/snake.av           |  6 +-
 .../sources/examples/games/tetris/main.av     |  8 +--
 .../sources/examples/games/wumpus.av          |  8 +--
 .../playground/sources/examples/shapes.av     |  4 +-
 60 files changed, 297 insertions(+), 363 deletions(-)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 297bcd91..43333ce2 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -4,6 +4,46 @@ All notable changes to Aver are documented here. Starting with 0.10.0, minor rel
 
 ## Unreleased
 
+## 0.17.0 "Purge" — 2026-05-06
+
+> _What was never used is no longer in the way._
+
+A stdlib sweep before the language gets harder to break. Eight redundant builtins removed, one renamed for symmetry, one rule for what stays: each operation has one obvious spelling. Literals for literals (`{}`, `[]`), operators for primitive composition (`+` on strings, arithmetic), `Target.fromSource` for conversions, interpolation for rendering, named functions only when they add semantics.
+
+### Removed
+
+- **`Map.empty()`** — redundant against the `{}` literal. Bidirectional inference propagates `Map<K, V>` from binding annotations into `{}`, and the discovery walker introduced in 0.16.3 picks up unannotated literals like `m = {a => 3}` from `expr.ty()`. Symmetric with `[]` for List (which never had a `List.empty` builtin).
+- **`Int.parse`, `Float.parse`, `Int.rem`** — unreachable builtin aliases. Registered in 4 backend dispatch tables but never wired through typecheck or VM. Lean and dafny treated them as outright aliases for `Int.fromString` / `Float.fromString` / `Int.mod`.
+- **`Int.toString`, `Float.toString`** — duplicates of `String.fromInt` / `String.fromFloat`. The convention `Target.fromSource` wins: result type leads (matters for code review and AI-generated code), and it scales (`Int.fromFloat`, `Float.fromInt`, `String.fromBool`, …). Interpolation `"{x}"` remains the primary idiom for rendering values into human-readable strings; `String.fromX` is for explicit data conversion (e.g. `"user:" + String.fromInt(id)`).
+- **`Float.toInt`, `Int.toFloat`** — duplicates of `Int.fromFloat` / `Float.fromInt`. Same convention.
+- **`String.concat(a, b)`** — literally `a + b`. Zero usage in examples (only in docs); not even dispatched in the wasm-gc backend. The `+` operator is the primary idiom for tail-recursive accumulators (`acc + sep + String.fromInt(head)`) and inline string composition; `String.join(parts, sep)` covers list-join (a different operation).
+
+### Renamed
+
+- **`Vector.toList(v)` → `List.fromVector(v)`** — paired with `Vector.fromList(l)` under the same `Target.fromSource` rule.
+
+### Kept (deliberately)
+
+- **`+` on strings** — primary idiom for tail-recursive string accumulators and inline composition. Forcing only interpolation `"{a}{b}"` would be awkward in `acc + " " + String.fromInt(head)` patterns.
+- **`Bool.and` / `Bool.or` / `Bool.not`** — *intentionally not added* as `&&` / `||` / `!` operators. Aver tracks effects deterministically (record/replay/proof export); short-circuit on `a && f!()` would require deciding whether the effect of `f` may or may not fire depending on `a`, which complicates trace recording and Lean export. Strict-FP eager evaluation matches the rest of the language. Pattern-matching `(x > 0, y > 0)` covers most idiomatic AND/OR cases. Not a "later language decision" — a settled non-feature.
+- **`Char.toCode` / `Char.fromCode`, `Byte.toHex` / `Byte.fromHex`, `Option.toResult`, `String.toLower` / `String.toUpper`** — encoding semantics or semantic conversions, not type-to-type. Not duplicates.
+
+### Migration
+
+Programs using removed builtins:
+
+```aver
+-- before
+m = Map.empty()                   -- → {}
+s = Int.toString(42)              -- → String.fromInt(42)  or  "{42}"
+n = Float.toInt(3.7)              -- → Int.fromFloat(3.7)
+f = Int.toFloat(5)                -- → Float.fromInt(5)
+xs = Vector.toList(v)             -- → List.fromVector(v)
+greeting = String.concat("hi, ", name)  -- → "hi, " + name
+```
+
+Examples in `examples/` and `tools/website/` migrated; vera-bench solutions checked (zero usage of any removed builtin, no companion PR needed). All 621 lib tests pass. The full sweep landed in four self-contained commits on the 0.17 branch.
+
 ## 0.16.2 — 2026-05-06
 
 > _Record/replay correctness across all three backends — and a tidier wasm-gc imports tree along the way._
diff --git a/Cargo.lock b/Cargo.lock
index 07fe9d91..e47181d2 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -119,7 +119,7 @@ checksum = "c08606f8c3cbf4ce6ec8e28fb0014a2c086708fe954eaa885384a6165172e7e8"
 
 [[package]]
 name = "aver-lang"
-version = "0.16.2"
+version = "0.17.0"
 dependencies = [
  "aver-memory",
  "aver-rt",
diff --git a/Cargo.toml b/Cargo.toml
index 53c6dc96..911fba17 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -4,7 +4,7 @@ exclude = ["tools/wasm-runner"]
 
 [package]
 name = "aver-lang"
-version = "0.16.2"
+version = "0.17.0"
 edition = "2024"
 default-run = "aver"
 description = "VM and transpiler for Aver, a statically-typed language designed for AI-assisted development"
diff --git a/aver-lsp/Cargo.toml b/aver-lsp/Cargo.toml
index 11f928f8..fdb0335f 100644
--- a/aver-lsp/Cargo.toml
+++ b/aver-lsp/Cargo.toml
@@ -16,7 +16,7 @@ name = "aver-lsp"
 path = "src/main.rs"
 
 [dependencies]
-aver = { path = "..", version = "=0.16.2", package = "aver-lang" }
+aver = { path = "..", version = "=0.17.0", package = "aver-lang" }
 tower-lsp-server = "0.23"
 tokio = { version = "1", features = ["full"] }
 serde_json = "1"
diff --git a/docs/language.md b/docs/language.md
index a3b7e7e1..f8f0049b 100644
--- a/docs/language.md
+++ b/docs/language.md
@@ -35,7 +35,7 @@ Duplicate binding of the same name in the same scope is a type error.
 
 ## Operators
 
-Arithmetic: `+`, `-`, `*`, `/` — operands must match (`Int+Int`, `Float+Float`, `String+String`). No implicit promotion; use `Int.toFloat` / `Float.fromInt` to convert.
+Arithmetic: `+`, `-`, `*`, `/` — operands must match (`Int+Int`, `Float+Float`, `String+String`). No implicit promotion; use `Float.fromInt` / `Int.fromFloat` to convert.
 Comparison: `==`, `!=`, `<`, `>`, `<=`, `>=`.
 Error propagation: `expr?` — unwraps `Result.Ok`, propagates `Result.Err` as a `RuntimeError`.
 Independent products: `(a, b)!` — product of independent computations. `(a, b)?!` — same, with Result unwrapping (all must succeed or first error propagates). Elements cannot reference each other; independence is structural. Composes recursively for fan-out parallelism. See [independence.md](independence.md).
diff --git a/docs/services.md b/docs/services.md
index 76914afd..f2fee056 100644
--- a/docs/services.md
+++ b/docs/services.md
@@ -44,7 +44,7 @@ Vector is a persistent indexed sequence — use it for grids, buffers, lookup ta
 | `Vector.set` | `(Vector<T>, Int, T) -> Option<Vector<T>>` | O(1) COW update; `None` if out of bounds |
 | `Vector.len` | `Vector<T> -> Int` | |
 | `Vector.fromList` | `List<T> -> Vector<T>` | Convert list to vector |
-| `Vector.toList` | `Vector<T> -> List<T>` | Convert vector to list |
+| `List.fromVector` | `Vector<T> -> List<T>` | Convert vector to list |
 
 ### `Result` namespace
 
@@ -75,8 +75,8 @@ Source: `src/types/int.rs`
 |---|---|
 | `Int.fromString` | `String -> Result<Int, String>` |
 | `Int.fromFloat` | `Float -> Int` |
-| `Int.toString` | `Int -> String` |
-| `Int.toFloat` | `Int -> Float` |
+| `String.fromInt` | `Int -> String` |
+| `Float.fromInt` | `Int -> Float` |
 | `Int.abs` | `Int -> Int` |
 | `Int.min` | `(Int, Int) -> Int` |
 | `Int.max` | `(Int, Int) -> Int` |
@@ -90,7 +90,7 @@ Source: `src/types/float.rs`
 |---|---|
 | `Float.fromString` | `String -> Result<Float, String>` |
 | `Float.fromInt` | `Int -> Float` |
-| `Float.toString` | `Float -> String` |
+| `String.fromFloat` | `Float -> String` |
 | `Float.abs` | `Float -> Float` |
 | `Float.floor` | `Float -> Int` |
 | `Float.ceil` | `Float -> Int` |
diff --git a/examples/data/date.av b/examples/data/date.av
index 1cdbe1bd..b38066c8 100644
--- a/examples/data/date.av
+++ b/examples/data/date.av
@@ -44,8 +44,8 @@ verify parse
 fn padTwo(n: Int) -> String
     ? "Pad a single-digit number with a leading zero."
     match n < 10
-        true -> "0{Int.toString(n)}"
-        false -> Int.toString(n)
+        true -> "0{String.fromInt(n)}"
+        false -> String.fromInt(n)
 
 verify padTwo
     padTwo(0) => "00"
@@ -54,7 +54,7 @@ verify padTwo
 
 fn format(d: Date) -> String
     ? "Format a Date as YYYY-MM-DD HH:MM:SS."
-    y = Int.toString(d.year)
+    y = String.fromInt(d.year)
     m = padTwo(d.month)
     da = padTwo(d.day)
     h = padTwo(d.hour)
@@ -82,6 +82,6 @@ fn main()
     d = parse(now)
     Console.print("Raw:    {now}")
     Console.print("Parsed: {format(d)}")
-    Console.print("Year:   {Int.toString(d.year)}")
-    Console.print("Month:  {Int.toString(d.month)}")
-    Console.print("Day:    {Int.toString(d.day)}")
+    Console.print("Year:   {String.fromInt(d.year)}")
+    Console.print("Month:  {String.fromInt(d.month)}")
+    Console.print("Day:    {String.fromInt(d.day)}")
diff --git a/examples/data/fibonacci.av b/examples/data/fibonacci.av
index 8d90a62b..406508cb 100644
--- a/examples/data/fibonacci.av
+++ b/examples/data/fibonacci.av
@@ -234,7 +234,7 @@ fn goldenApprox(n: Int) -> Result<Float, String>
     ? "Approximates golden ratio as F(n+1)/F(n). Requires n >= 1."
     match n < 1
         true  -> Result.Err("Need n >= 1")
-        false -> Result.Ok(Int.toFloat(fib(n + 1)) / Int.toFloat(fib(n)))
+        false -> Result.Ok(Float.fromInt(fib(n + 1)) / Float.fromInt(fib(n)))
 
 verify goldenApprox
     goldenApprox(0) => Result.Err("Need n >= 1")
diff --git a/examples/games/checkers/main.av b/examples/games/checkers/main.av
index d36b5e0d..73794513 100644
--- a/examples/games/checkers/main.av
+++ b/examples/games/checkers/main.av
@@ -210,11 +210,11 @@ fn renderAiPanel(result: AiResult) -> Unit
     ! [Terminal.moveTo, Terminal.print, Terminal.resetColor, Terminal.setColor]
     Terminal.moveTo(22, 1)
     Terminal.setColor("cyan")
-    Terminal.print("AI depth={Int.toString(result.depth)} {Int.toString(result.thinkMs)}ms")
+    Terminal.print("AI depth={String.fromInt(result.depth)} {String.fromInt(result.thinkMs)}ms")
     Terminal.resetColor()
     Terminal.moveTo(22, 2)
     Terminal.setColor("yellow")
-    Terminal.print("root-parallel x{Int.toString(Ai.rootParallelWidth())} | {Int.toString(List.len(result.candidates))} moves")
+    Terminal.print("root-parallel x{String.fromInt(Ai.rootParallelWidth())} | {String.fromInt(List.len(result.candidates))} moves")
     Terminal.resetColor()
     renderCandidates(result.candidates, result.move, 0)
 
@@ -242,7 +242,7 @@ fn renderChosenCandidate(sm: ScoredMove, i: Int) -> Unit
     Terminal.setColor("green")
     Terminal.print("★ ")
     Terminal.print(moveLabel(sm.move))
-    Terminal.print("  {Int.toString(sm.score)}")
+    Terminal.print("  {String.fromInt(sm.score)}")
     Terminal.resetColor()
 
 fn renderOtherCandidate(sm: ScoredMove, i: Int) -> Unit
@@ -250,7 +250,7 @@ fn renderOtherCandidate(sm: ScoredMove, i: Int) -> Unit
     ! [Terminal.print]
     Terminal.print("  ")
     Terminal.print(moveLabel(sm.move))
-    Terminal.print("  {Int.toString(sm.score)}")
+    Terminal.print("  {String.fromInt(sm.score)}")
 
 fn isChosenMove(a: List<Point>, b: List<Point>) -> Bool
     ? "True if two moves are the same (compare first and last points)"
@@ -295,7 +295,7 @@ fn moveLabel(move: List<Point>) -> String
     ? "Human-readable label for a move path"
     match firstPoint(move)
         Option.Some(from) -> match lastPoint(move)
-            Option.Some(to) -> "{colChar(from.x)}{Int.toString(8 - from.y)}→{colChar(to.x)}{Int.toString(8 - to.y)}"
+            Option.Some(to) -> "{colChar(from.x)}{String.fromInt(8 - from.y)}→{colChar(to.x)}{String.fromInt(8 - to.y)}"
             Option.None -> "?"
         Option.None -> "?"
 
@@ -307,7 +307,7 @@ fn renderHelp(state: GameState) -> Unit
     ! [Terminal.moveTo, Terminal.print, Terminal.resetColor, Terminal.setColor]
     Terminal.moveTo(0, 14)
     Terminal.setColor("green")
-    Terminal.print(" You (black) vs AI (white) · depth {Int.toString(state.searchDepth)} · +/- to change")
+    Terminal.print(" You (black) vs AI (white) · depth {String.fromInt(state.searchDepth)} · +/- to change")
     Terminal.resetColor()
     Terminal.moveTo(0, 15)
     match state.selected
@@ -415,7 +415,7 @@ fn aiPhase(state: GameState) -> Result<String, String>
     ]
     renderFrame(state)
     Terminal.moveTo(0, 14)
-    Terminal.print("AI thinking (depth {Int.toString(state.searchDepth)}, root-parallel x{Int.toString(Ai.rootParallelWidth())})...")
+    Terminal.print("AI thinking (depth {String.fromInt(state.searchDepth)}, root-parallel x{String.fromInt(Ai.rootParallelWidth())})...")
     Terminal.flush()
     t0 = Time.unixMs()
     aiState = handleAiTurn(state)
@@ -443,7 +443,7 @@ fn gameOverResult(state: GameState) -> Result<String, String>
     Terminal.print("Game over!")
     Terminal.flush()
     Time.sleep(2000)
-    Result.Ok("Game over! Move {Int.toString(state.moveNum)}")
+    Result.Ok("Game over! Move {String.fromInt(state.moveNum)}")
 
 fn gameTurn(state: GameState) -> Result<String, String>
     ? "Dispatch to player or AI"
diff --git a/examples/games/checkers/render.av b/examples/games/checkers/render.av
index 5e3e472f..f0145779 100644
--- a/examples/games/checkers/render.av
+++ b/examples/games/checkers/render.av
@@ -240,7 +240,7 @@ fn renderRowLabelsNext(r: Int) -> Unit
 
 fn rowLabel(r: Int) -> String
     ? "Row label: row 0 = 8, row 7 = 1"
-    Int.toString(8 - r)
+    String.fromInt(8 - r)
 
 verify rowLabel
     rowLabel(0) => "8"
@@ -281,7 +281,7 @@ fn renderStatus(currentPlayer: Color, moveNum: Int) -> Unit
     Terminal.setColor(playerColor(currentPlayer))
     Terminal.print("{colorName(currentPlayer)}")
     Terminal.resetColor()
-    Terminal.print(" to move  |  Move #{Int.toString(moveNum)}")
+    Terminal.print(" to move  |  Move #{String.fromInt(moveNum)}")
 
 fn renderAiTrace(move: List<Point>, score: Int, alternatives: Int, depth: Int) -> Unit
     ? "Show AI decision trace"
@@ -290,4 +290,4 @@ fn renderAiTrace(move: List<Point>, score: Int, alternatives: Int, depth: Int) -
     Terminal.setColor("cyan")
     Terminal.print("AI: ")
     Terminal.resetColor()
-    Terminal.print("score={Int.toString(score)} alts={Int.toString(alternatives)} depth={Int.toString(depth)}")
+    Terminal.print("score={String.fromInt(score)} alts={String.fromInt(alternatives)} depth={String.fromInt(depth)}")
diff --git a/examples/games/doom/enemy.av b/examples/games/doom/enemy.av
index 670ab64e..e99d3f5e 100644
--- a/examples/games/doom/enemy.av
+++ b/examples/games/doom/enemy.av
@@ -49,8 +49,8 @@ fn ghostTeleport(enemy: Enemy, seed: Int, levelMap: List<String>) -> Enemy
     ? "Teleport ghost to a random nearby floor tile"
     s1 = Rng.nextSeed(seed)
     s2 = Rng.nextSeed(s1)
-    dx = Int.toFloat(Rng.seedToRange(s1, 0 - 4, 4))
-    dy = Int.toFloat(Rng.seedToRange(s2, 0 - 4, 4))
+    dx = Float.fromInt(Rng.seedToRange(s1, 0 - 4, 4))
+    dy = Float.fromInt(Rng.seedToRange(s2, 0 - 4, 4))
     nx = enemy.x + dx
     ny = enemy.y + dy
     match Level.isWall(levelMap, Float.floor(nx), Float.floor(ny))
@@ -251,7 +251,7 @@ fn applyShotVec(enemies: Vector<Enemy>, idx: Int) -> (List<Enemy>, String)
     ? "Apply 5 damage to enemy at index using indexed vector access"
     match Vector.get(enemies, idx)
         Option.Some(e) -> applyDamageToEnemyVec(enemies, idx, e)
-        Option.None -> (Vector.toList(enemies), "Shot missed!")
+        Option.None -> (List.fromVector(enemies), "Shot missed!")
 
 verify applyShotVec
     applyShotVec(Vector.fromList([]), 0) => ([], "Shot missed!")
@@ -268,7 +268,7 @@ fn applyDamageToEnemyVec(enemies: Vector<Enemy>, idx: Int, e: Enemy) -> (List<En
     newHp = e.hp - 5
     match newHp < 1
         true -> (removeEnemyVec(enemies, idx, 0, []), "Killed {Types.enemyGlyph(e.kind)}!")
-        false -> (replaceEnemyVec(enemies, idx, Enemy.update(e, hp = newHp), 0, []), "Hit {Types.enemyGlyph(e.kind)}! ({Int.toString(newHp)} HP)")
+        false -> (replaceEnemyVec(enemies, idx, Enemy.update(e, hp = newHp), 0, []), "Hit {Types.enemyGlyph(e.kind)}! ({String.fromInt(newHp)} HP)")
 
 verify applyDamageToEnemyVec
     applyDamageToEnemyVec(Vector.fromList([Types.mkEnemy(1.0, 1.0, EnemyKind.Imp, 3)]), 0, Types.mkEnemy(1.0, 1.0, EnemyKind.Imp, 3)) => ([], "Killed !!")
diff --git a/examples/games/doom/level.av b/examples/games/doom/level.av
index e83b0e4b..7c72e3d1 100644
--- a/examples/games/doom/level.av
+++ b/examples/games/doom/level.av
@@ -280,7 +280,7 @@ verify roomFromSeed
 
 fn roomCenter(room: Room) -> (Float, Float)
     ? "Center of a room as float coordinates"
-    (Int.toFloat(room.x + room.w / 2) + 0.5, Int.toFloat(room.y + room.h / 2) + 0.5)
+    (Float.fromInt(room.x + room.w / 2) + 0.5, Float.fromInt(room.y + room.h / 2) + 0.5)
 
 verify roomCenter
     roomCenter(Room(x = 4, y = 4, w = 6, h = 6)) => (7.5, 7.5)
diff --git a/examples/games/doom/main.av b/examples/games/doom/main.av
index 089bcf05..836b8aba 100644
--- a/examples/games/doom/main.av
+++ b/examples/games/doom/main.av
@@ -33,8 +33,8 @@ verify turnSpeed
 fn spawnInRoom(room: Level.Room, seed: Int) -> Enemy
     ? "Spawn an enemy at the center of a room"
     kind = pickKind(seed)
-    cx = Int.toFloat(room.x + room.w / 2) + 0.5
-    cy = Int.toFloat(room.y + room.h / 2) + 0.5
+    cx = Float.fromInt(room.x + room.w / 2) + 0.5
+    cy = Float.fromInt(room.y + room.h / 2) + 0.5
     Types.mkEnemy(cx, cy, kind, Types.enemyMaxHp(kind))
 
 verify spawnInRoom
@@ -214,7 +214,7 @@ fn updateTurn(state: GameState) -> GameState
     msgs = match isOver
         true -> ["You died!"]
         false -> match damaged.hp < state.player.hp
-            true -> List.concat(state.messages, ["Ouch! HP: {Int.toString(damaged.hp)}"])
+            true -> List.concat(state.messages, ["Ouch! HP: {String.fromInt(damaged.hp)}"])
             false -> state.messages
     trimmedMsgs = trimMessages(msgs)
     GameState.update(state, enemies = newEnemies, player = damaged, turnCount = state.turnCount + 1, gameOver = isOver, messages = trimmedMsgs)
diff --git a/examples/games/doom/math.av b/examples/games/doom/math.av
index 9b89add2..15f90514 100644
--- a/examples/games/doom/math.av
+++ b/examples/games/doom/math.av
@@ -29,7 +29,7 @@ verify radToDeg
 fn normalizeAngle(a: Float) -> Float
     ? "Wrap angle to [0, 2*pi)"
     twoPi = Float.pi() * 2.0
-    rem = a - Int.toFloat(Float.floor(a / twoPi)) * twoPi
+    rem = a - Float.fromInt(Float.floor(a / twoPi)) * twoPi
     match rem < 0.0
         true -> rem + twoPi
         false -> rem
diff --git a/examples/games/doom/render.av b/examples/games/doom/render.av
index 823002fc..1123b5ea 100644
--- a/examples/games/doom/render.av
+++ b/examples/games/doom/render.av
@@ -134,7 +134,7 @@ fn wallHeight(distance: Float) -> Int
     ? "Pixel height of the wall strip for a given corrected distance"
     match distance < 0.1
         true -> pixelH()
-        false -> Math.clampInt(Float.floor(Int.toFloat(pixelH()) / distance), 0, pixelH())
+        false -> Math.clampInt(Float.floor(Float.fromInt(pixelH()) / distance), 0, pixelH())
 
 verify wallHeight
     wallHeight(1.0) => 80
@@ -282,7 +282,7 @@ verify buildZBuffer
 
 fn buildZBufferCol(levelMap: List<String>, wallMap: List<String>, px: Float, py: Float, angle: Float, col: Int, acc: List<RayHit>) -> List<RayHit>
     ? "Cast one ray and append to buffer"
-    rayAngle = angle - fov() / 2.0 + Int.toFloat(col) * fov() / Int.toFloat(screenW())
+    rayAngle = angle - fov() / 2.0 + Float.fromInt(col) * fov() / Float.fromInt(screenW())
     hit = castRay(levelMap, wallMap, px, py, rayAngle)
     corrected = RayHit.update(hit, dist = hit.dist * Float.cos(rayAngle - angle))
     buildZBuffer(levelMap, wallMap, px, py, angle, col + 1, List.concat(acc, [corrected]))
@@ -375,7 +375,7 @@ fn renderEnemySprite(enemies: Vector<Enemy>, zbuf: Vector<RayHit>, px: Float, py
     eDist = Math.dist(px, py, e.x, e.y)
     eAngle = Float.atan2(dy, dx)
     relAngle = Math.normalizeAngle(eAngle - pAngle + Float.pi()) - Float.pi()
-    screenCol = Float.floor(Int.toFloat(screenW()) / 2.0 + relAngle * Int.toFloat(screenW()) / fov())
+    screenCol = Float.floor(Float.fromInt(screenW()) / 2.0 + relAngle * Float.fromInt(screenW()) / fov())
     match isEnemyVisibleVec(screenCol, eDist, zbuf)
         true -> drawEnemyChar(e, screenCol, eDist, enemies, zbuf, px, py, pAngle, i)
         false -> renderEnemiesVec(enemies, zbuf, px, py, pAngle, i + 1)
@@ -409,8 +409,8 @@ verify isEnemyVisibleVec
 fn drawEnemyChar(e: Enemy, screenCol: Int, eDist: Float, enemies: Vector<Enemy>, zbuf: Vector<RayHit>, px: Float, py: Float, pAngle: Float, i: Int) -> Unit
     ? "Draw enemy using solid Unicode block characters"
     ! [Terminal.flush, Terminal.moveTo, Terminal.print, Terminal.resetColor, Terminal.setColor]
-    spriteH = Math.clampInt(Float.floor(2.5 / eDist * Int.toFloat(screenH())), 1, 10)
-    spriteW = Math.clampInt(Float.floor(5.0 / eDist * Int.toFloat(screenW()) / 10.0), 3, 13)
+    spriteH = Math.clampInt(Float.floor(2.5 / eDist * Float.fromInt(screenH())), 1, 10)
+    spriteW = Math.clampInt(Float.floor(5.0 / eDist * Float.fromInt(screenW()) / 10.0), 3, 13)
     topRow = screenH() / 2 - spriteH / 2
     leftCol = screenCol - spriteW / 2
     drawBlockGrid(e, leftCol, topRow, spriteH, spriteW, 0, 0)
@@ -463,9 +463,9 @@ verify fullBlock
 
 fn isInsideShape(kind: EnemyKind, col: Int, row: Int, spriteW: Int, spriteH: Int) -> Bool
     ? "Check if (col, row) is inside the enemy silhouette"
-    halfW = Int.toFloat(spriteW) / 2.0
-    cx = Float.abs(Int.toFloat(col) - halfW + 0.5) / halfW
-    cy = Int.toFloat(row) / Int.toFloat(spriteH)
+    halfW = Float.fromInt(spriteW) / 2.0
+    cx = Float.abs(Float.fromInt(col) - halfW + 0.5) / halfW
+    cy = Float.fromInt(row) / Float.fromInt(spriteH)
     maxW = shapeWidth(kind, cy)
     cx < maxW
 
@@ -557,13 +557,13 @@ fn renderHud(state: GameState) -> Unit
     Terminal.print("BRAILLE DOOM")
     Terminal.setColor("red")
     Terminal.moveTo(hudX, 3)
-    Terminal.print("HP: {Int.toString(state.player.hp)}/100")
+    Terminal.print("HP: {String.fromInt(state.player.hp)}/100")
     Terminal.setColor("white")
     Terminal.moveTo(hudX, 4)
     deg = Float.floor(Math.radToDeg(state.player.angle))
-    Terminal.print("angle: {Int.toString(deg)}")
+    Terminal.print("angle: {String.fromInt(deg)}")
     Terminal.moveTo(hudX, 5)
-    Terminal.print("enemies: {Int.toString(List.len(state.enemies))}")
+    Terminal.print("enemies: {String.fromInt(List.len(state.enemies))}")
     Terminal.setColor("cyan")
     Terminal.moveTo(hudX, 7)
     Terminal.print("W/S  forward/back")
diff --git a/examples/games/doom/rng.av b/examples/games/doom/rng.av
index ca76be06..52312e63 100644
--- a/examples/games/doom/rng.av
+++ b/examples/games/doom/rng.av
@@ -38,7 +38,7 @@ verify advanceSeed
 
 fn randomFloat(s: Int) -> Float
     ? "Map seed to [0.0, 1.0)"
-    Int.toFloat(Result.withDefault(Int.mod(Int.abs(s), 10000), 0)) / 10000.0
+    Float.fromInt(Result.withDefault(Int.mod(Int.abs(s), 10000), 0)) / 10000.0
 
 verify randomFloat
     randomFloat(0) => 0.0
diff --git a/examples/games/life.av b/examples/games/life.av
index b5488dec..cf25411e 100644
--- a/examples/games/life.av
+++ b/examples/games/life.av
@@ -301,7 +301,7 @@ fn drawOneRow(grid: Vector<Int>, s: Int, w: Int, h: Int, row: Int) -> Unit
 fn drawHud(st: SimState, mode: String) -> Unit
     ? "Draw two-line HUD: status on line 0, controls on line 1."
     ! [Terminal.moveTo, Terminal.print, Terminal.resetColor, Terminal.setColor]
-    genStr = Int.toString(st.gen)
+    genStr = String.fromInt(st.gen)
     Terminal.setColor("green")
     Terminal.moveTo(0, 0)
     line1 = match mode == "edit"
@@ -310,7 +310,7 @@ fn drawHud(st: SimState, mode: String) -> Unit
             true -> " PAUSED  Gen:{genStr}                                               "
             false -> match st.delay == 0
                 true -> " {st.fps.display}fps  Gen:{genStr}  BENCHMARK                       "
-                false -> " {st.fps.display}fps  Gen:{genStr}  {Int.toString(st.delay)}ms                            "
+                false -> " {st.fps.display}fps  Gen:{genStr}  {String.fromInt(st.delay)}ms                            "
     Terminal.print(line1)
     Terminal.moveTo(0, 1)
     Terminal.setColor("cyan")
@@ -327,7 +327,7 @@ fn formatFps(frames: Int, elapsed: Int) -> String
     tenths = frames * 10000 / elapsed
     whole = tenths / 10
     frac = Result.withDefault(Int.mod(tenths, 10), 0)
-    Int.toString(whole) + "." + Int.toString(frac)
+    String.fromInt(whole) + "." + String.fromInt(frac)
 
 verify formatFps
     formatFps(2, 1000) => "2.0"
@@ -452,7 +452,7 @@ fn simAction(k: String, st: SimState) -> Result<String, String>
         true -> 0
         false -> 1
     match k
-        "q" -> Result.Ok("Stopped at generation {Int.toString(st.gen)}.")
+        "q" -> Result.Ok("Stopped at generation {String.fromInt(st.gen)}.")
         " " -> gameLoop(SimState.update(st, paused = newPaused))
         "e" -> simToEditor(st)
         "+" -> gameLoop(SimState.update(st, delay = Int.max(st.delay - 10, 0)))
@@ -470,7 +470,7 @@ fn simToEditor(st: SimState) -> Result<String, String>
     result = editorLoop(st.grid, st.stride, st.width, st.height, st.width / 2, st.height / 2)
     match result
         Result.Ok(newGrid) -> gameLoop(SimState.update(st, grid = newGrid, gen = 0))
-        Result.Err(_) -> Result.Ok("Stopped at generation {Int.toString(st.gen)}.")
+        Result.Err(_) -> Result.Ok("Stopped at generation {String.fromInt(st.gen)}.")
 
 // ─── Entry ──────────────────────────────────────────────────
 
diff --git a/examples/games/rogue/main.av b/examples/games/rogue/main.av
index 565b39dd..07b7cbed 100644
--- a/examples/games/rogue/main.av
+++ b/examples/games/rogue/main.av
@@ -354,7 +354,7 @@ fn resolveAttack(state: GameState, target: Entity, idx: Int) -> GameState
     hit = Combat.applyDamageToEntity(target, dmg)
     match Combat.isEntityDead(hit)
         true -> killEntity(state, target, idx, dmg)
-        false -> alertNearby(addMessage(GameState.update(state, entities = Combat.replaceEntity(state.entities, idx, hit, 0)), "You hit {target.name} for {Int.toString(dmg)}!"), state.player.pos, 12, 0)
+        false -> alertNearby(addMessage(GameState.update(state, entities = Combat.replaceEntity(state.entities, idx, hit, 0)), "You hit {target.name} for {String.fromInt(dmg)}!"), state.player.pos, 12, 0)
 
 fn killEntity(state: GameState, target: Entity, idx: Int, dmg: Int) -> GameState
     ? "Kill entity — for-loop gets one respawn (off-by-one error)"
@@ -373,7 +373,7 @@ fn loopRespawn(state: GameState, target: Entity, idx: Int) -> GameState
 fn actualKill(state: GameState, target: Entity, idx: Int) -> GameState
     ? "Actually remove entity and gain exp"
     newPlayer = Combat.gainExp(state.player, Combat.expForKill(target.kind))
-    addMessage(GameState.update(state, entities = Combat.removeAt(state.entities, idx, 0), player = newPlayer), "You defeated {target.name}! (+{Int.toString(Combat.expForKill(target.kind))} exp)")
+    addMessage(GameState.update(state, entities = Combat.removeAt(state.entities, idx, 0), player = newPlayer), "You defeated {target.name}! (+{String.fromInt(Combat.expForKill(target.kind))} exp)")
 
 verify actualKill
     List.len(actualKill(GameState(gameMap = [], player = Types.makePlayer(0, 0), entities = [Types.makeIfElse(1, 1)], items = [], visible = [], visGrid = [], remembered = [], messages = [], seed = 0, gameOver = false), Types.makeIfElse(1, 1), 0).entities) => 0
@@ -400,9 +400,9 @@ verify pickUpItem
 fn applyItem(state: GameState, item: Item, idx: Int) -> GameState
     ? "Apply item effect"
     match item.kind
-        ItemKind.PotionOfPurity -> addMessage(GameState.update(state, player = Combat.healPlayer(state.player, item.value), items = Combat.removeItemAt(state.items, idx, 0)), "You drink {item.name}. Purity restored! (+{Int.toString(item.value)} HP)")
-        ItemKind.ScrollOfPatternMatch -> addMessage(GameState.update(state, player = Player.update(state.player, attack = state.player.attack + item.value), items = Combat.removeItemAt(state.items, idx, 0)), "You read {item.name}. Your pattern matching grows stronger! (+{Int.toString(item.value)} ATK)")
-        ItemKind.ShieldOfImmutability -> addMessage(GameState.update(state, player = Player.update(state.player, defense = state.player.defense + item.value), items = Combat.removeItemAt(state.items, idx, 0)), "You equip {item.name}. Nothing can change you! (+{Int.toString(item.value)} DEF)")
+        ItemKind.PotionOfPurity -> addMessage(GameState.update(state, player = Combat.healPlayer(state.player, item.value), items = Combat.removeItemAt(state.items, idx, 0)), "You drink {item.name}. Purity restored! (+{String.fromInt(item.value)} HP)")
+        ItemKind.ScrollOfPatternMatch -> addMessage(GameState.update(state, player = Player.update(state.player, attack = state.player.attack + item.value), items = Combat.removeItemAt(state.items, idx, 0)), "You read {item.name}. Your pattern matching grows stronger! (+{String.fromInt(item.value)} ATK)")
+        ItemKind.ShieldOfImmutability -> addMessage(GameState.update(state, player = Player.update(state.player, defense = state.player.defense + item.value), items = Combat.removeItemAt(state.items, idx, 0)), "You equip {item.name}. Nothing can change you! (+{String.fromInt(item.value)} DEF)")
 
 verify applyItem
     applyItem(GameState(gameMap = [], player = Player.update(Types.makePlayer(0, 0), hp = 10), entities = [], items = [Types.makePurity(0, 0)], visible = [], visGrid = [], remembered = [], messages = [], seed = 0, gameOver = false), Types.makePurity(0, 0), 0).player.hp => 18
@@ -533,8 +533,8 @@ fn ifElseAttack(state: GameState, entity: Entity, i: Int) -> GameState
     match Combat.isPlayerDead(newPlayer)
         true -> addMessage(GameState.update(state, player = newPlayer, gameOver = true), "{entity.name} branch-predicts your death!")
         false -> match doubled == 1
-            true -> addMessage(GameState.update(state, player = newPlayer), "{entity.name} takes BOTH branches! {Int.toString(totalDmg)} dmg!")
-            false -> addMessage(GameState.update(state, player = newPlayer), "{entity.name} hits you for {Int.toString(dmg)}.")
+            true -> addMessage(GameState.update(state, player = newPlayer), "{entity.name} takes BOTH branches! {String.fromInt(totalDmg)} dmg!")
+            false -> addMessage(GameState.update(state, player = newPlayer), "{entity.name} hits you for {String.fromInt(dmg)}.")
 
 fn loopAttack(state: GameState, entity: Entity, i: Int) -> GameState
     ? "for-loop: normal attack but respawns once when killed (off-by-one)"
@@ -542,7 +542,7 @@ fn loopAttack(state: GameState, entity: Entity, i: Int) -> GameState
     newPlayer = Combat.applyDamageToPlayer(state.player, dmg)
     match Combat.isPlayerDead(newPlayer)
         true -> addMessage(GameState.update(state, player = newPlayer, gameOver = true), "{entity.name} iterates you to death!")
-        false -> addMessage(GameState.update(state, player = newPlayer), "{entity.name} iterates on you for {Int.toString(dmg)}!")
+        false -> addMessage(GameState.update(state, player = newPlayer), "{entity.name} iterates on you for {String.fromInt(dmg)}!")
 
 verify loopAttack
     loopAttack(GameState(gameMap = [], player = Types.makePlayer(0, 0), entities = [Types.makeLoop(1, 0)], items = [], visible = [], visGrid = [], remembered = [], messages = [], seed = 0, gameOver = false), Types.makeLoop(1, 0), 0).player.hp < 20 => true
@@ -551,7 +551,7 @@ fn nullAttack(state: GameState, entity: Entity, i: Int) -> GameState
     ? "null: steals EXP instead of dealing HP damage (null dereference — wipes memory)"
     stolen = Int.max(1, state.player.exp / 4)
     newPlayer = Player.update(state.player, exp = Int.max(0, state.player.exp - stolen))
-    addMessage(GameState.update(state, player = newPlayer), "{entity.name} dereferences your memory! -{Int.toString(stolen)} EXP!")
+    addMessage(GameState.update(state, player = newPlayer), "{entity.name} dereferences your memory! -{String.fromInt(stolen)} EXP!")
 
 verify nullAttack
     nullAttack(GameState(gameMap = [], player = Player.update(Types.makePlayer(0, 0), exp = 40), entities = [Types.makeNull(1, 0)], items = [], visible = [], visGrid = [], remembered = [], messages = [], seed = 0, gameOver = false), Types.makeNull(1, 0), 0).player.exp => 30
@@ -655,7 +655,7 @@ fn descend(state: GameState) -> GameState
     itms = spawnItems(newSeed, rooms, 0)
     vis = Fov.computeFov(newMap, Types.pt(px, py), 8)
     rem = markRemembered(emptyRemembered(0), vis, 0)
-    addMessage(GameState(gameMap = newMap, player = newPlayer, entities = ents, items = itms, visible = vis, visGrid = buildVisGrid(vis, emptyRemembered(0), 0), remembered = rem, messages = state.messages, seed = Map.nextSeed(newSeed), gameOver = false), "You descend to floor {Int.toString(newFloor)} of Non-Aver!")
+    addMessage(GameState(gameMap = newMap, player = newPlayer, entities = ents, items = itms, visible = vis, visGrid = buildVisGrid(vis, emptyRemembered(0), 0), remembered = rem, messages = state.messages, seed = Map.nextSeed(newSeed), gameOver = false), "You descend to floor {String.fromInt(newFloor)} of Non-Aver!")
 
 verify descend
     descend(initGame(42)).player.floor => 2
@@ -715,7 +715,7 @@ fn gameLoop(state: GameState) -> Result<String, String>
     ]
     renderFrame(state)
     match state.gameOver
-        true -> Result.Ok("Game over on floor {Int.toString(state.player.floor)}. EXP: {Int.toString(state.player.exp)}. The Aver way prevails!")
+        true -> Result.Ok("Game over on floor {String.fromInt(state.player.floor)}. EXP: {String.fromInt(state.player.exp)}. The Aver way prevails!")
         false -> waitAndProcess(state)
 
 fn waitAndProcess(state: GameState) -> Result<String, String>
diff --git a/examples/games/snake.av b/examples/games/snake.av
index e10a086b..c169a9b0 100644
--- a/examples/games/snake.av
+++ b/examples/games/snake.av
@@ -274,7 +274,7 @@ fn render(state: GameState) -> Unit
     drawAt(state.food.x, state.food.y, "██")
     Terminal.resetColor()
     Terminal.moveTo(0, state.height)
-    Terminal.print("Score: {Int.toString(state.score)}  |  Q / ESC to quit")
+    Terminal.print("Score: {String.fromInt(state.score)}  |  Q / ESC to quit")
     Terminal.flush()
 
 fn handleKey(state: GameState, k: String) -> GameState
@@ -304,7 +304,7 @@ fn tick(state: GameState) -> Result<String, String>
         Time.sleep,
     ]
     match state.gameOver
-        true -> Result.Ok("Game over! Score: {Int.toString(state.score)}")
+        true -> Result.Ok("Game over! Score: {String.fromInt(state.score)}")
         false -> tickMove(moveSnake(state))
 
 fn tickMove(moved: GameState) -> Result<String, String>
@@ -315,7 +315,7 @@ fn tickMove(moved: GameState) -> Result<String, String>
         Time.sleep,
     ]
     match checkCollision(moved)
-        true -> Result.Ok("Game over! Score: {Int.toString(moved.score)}")
+        true -> Result.Ok("Game over! Score: {String.fromInt(moved.score)}")
         false -> match didEatFood(moved)
             true -> gameLoop(growSnake(randomFood(moved)))
             false -> gameLoop(moved)
diff --git a/examples/games/tetris/main.av b/examples/games/tetris/main.av
index 41172ebb..db30b14f 100644
--- a/examples/games/tetris/main.av
+++ b/examples/games/tetris/main.av
@@ -127,11 +127,11 @@ fn renderInfo(state: GameState) -> Unit
     ? "Draw score, level, lines info"
     ! [Terminal.moveTo, Terminal.print]
     Terminal.moveTo(26, 2)
-    Terminal.print("Score: {Int.toString(state.score)}")
+    Terminal.print("Score: {String.fromInt(state.score)}")
     Terminal.moveTo(26, 4)
-    Terminal.print("Level: {Int.toString(state.level)}")
+    Terminal.print("Level: {String.fromInt(state.level)}")
     Terminal.moveTo(26, 6)
-    Terminal.print("Lines: {Int.toString(state.lines)}")
+    Terminal.print("Lines: {String.fromInt(state.lines)}")
     Terminal.moveTo(26, 10)
     Terminal.print("Controls:")
     Terminal.moveTo(26, 11)
@@ -204,7 +204,7 @@ fn tick(state: GameState) -> Result<String, String>
         Time.sleep,
     ]
     match state.gameOver
-        true -> Result.Ok("Game over! Score: {Int.toString(state.score)}  Lines: {Int.toString(state.lines)}")
+        true -> Result.Ok("Game over! Score: {String.fromInt(state.score)}  Lines: {String.fromInt(state.lines)}")
         false -> tickGravity(state)
 
 fn gameLoop(state: GameState) -> Result<String, String>
diff --git a/examples/games/wumpus.av b/examples/games/wumpus.av
index a1847be4..721c4638 100644
--- a/examples/games/wumpus.av
+++ b/examples/games/wumpus.av
@@ -48,7 +48,7 @@ verify validRoom
 
 fn roomListItem(r: Int, rest: List<Int>) -> String
     ? "Format a single room entry and recurse on remainder."
-    rs = Int.toString(r)
+    rs = String.fromInt(r)
     match rest
         [] -> rs
         _ -> "{rs}, {roomList(rest)}"
@@ -246,10 +246,10 @@ fn showRoom(game: Game) -> Unit
     ? "Display current room, tunnels, and hazard warnings."
     ! [Console.print]
     Console.print("")
-    Console.print("You are in room {Int.toString(game.player)}.")
+    Console.print("You are in room {String.fromInt(game.player)}.")
     Console.print("Tunnels lead to: {roomList(neighbors(game.player))}")
     Console.print(warningText(game))
-    Console.print("Arrows: {Int.toString(game.arrows)}")
+    Console.print("Arrows: {String.fromInt(game.arrows)}")
 
 fn gameLoop(game: Game) -> Result<String, String>
     ? "Main game loop — one turn per recursive call."
@@ -311,7 +311,7 @@ fn teleportAndCheck(game: Game) -> Result<String, String>
     ? "Bats carry you to a random room; check hazards there."
     ! [Console.print, Console.readLine, Random.int]
     dest = randRoom()
-    Console.print("Super bats carry you to room {Int.toString(dest)}!")
+    Console.print("Super bats carry you to room {String.fromInt(dest)}!")
     resolveRoomCheck(checkRoom(Game.update(game, player = dest)))
 
 fn retry(game: Game, msg: String) -> Result<String, String>
diff --git a/examples/services/redis.av b/examples/services/redis.av
index be070750..948d9fd8 100644
--- a/examples/services/redis.av
+++ b/examples/services/redis.av
@@ -40,7 +40,7 @@ record RedisConfig
 
 fn respBulkLen(s: String) -> String
     ? "Returns the byte-length of s as a string, used to build RESP bulk-string headers."
-    Int.toString(String.byteLength(s))
+    String.fromInt(String.byteLength(s))
 
 verify respBulkLen
     respBulkLen("PING") => "4"
@@ -77,7 +77,7 @@ fn sendArgs(conn: Tcp.Connection, args: List<String>) -> Result<Tcp.Connection,
 fn sendCommand(conn: Tcp.Connection, args: List<String>) -> Result<Tcp.Connection, String>
     ? "Sends a full RESP command: writes the '*N' array header then each arg via sendArgs."
     ! [Tcp.writeLine]
-    _ = Tcp.writeLine(conn, "*{Int.toString(List.len(args))}")?
+    _ = Tcp.writeLine(conn, "*{String.fromInt(List.len(args))}")?
     sendArgs(conn, args)
 
 // Public API
diff --git a/src/checker/perf.rs b/src/checker/perf.rs
index 95ec8246..e9a17f23 100644
--- a/src/checker/perf.rs
+++ b/src/checker/perf.rs
@@ -99,7 +99,7 @@ fn expr_to_short_str(expr: &Expr) -> String {
 }
 
 /// Check whether an expression mentions only identifiers from `allowed` and literals.
-/// Namespace prefixes (e.g. `Int` in `Int.toFloat(...)`) are treated as constants,
+/// Namespace prefixes (e.g. `Int` in `Float.fromInt(...)`) are treated as constants,
 /// not as variable references that need to be in `allowed`.
 fn expr_uses_only(expr: &Expr, allowed: &HashSet<String>) -> bool {
     match expr {
@@ -110,7 +110,7 @@ fn expr_uses_only(expr: &Expr, allowed: &HashSet<String>) -> bool {
         }
         Expr::FnCall(callee, args) => {
             let callee_ok = match &callee.node {
-                // Namespace call like `Int.toFloat(...)` — the namespace is a constant
+                // Namespace call like `Float.fromInt(...)` — the namespace is a constant
                 Expr::Attr(obj, _) => {
                     if let Expr::Ident(ns) = &obj.node {
                         // Check if this is a known pure namespace prefix
@@ -905,15 +905,15 @@ mod tests {
     #[test]
     fn b4_loop_invariant_warns() {
         // fn draw(x: Int, y: Int, width: Int) -> Int
-        //   w = Int.toFloat(width)
+        //   w = Float.fromInt(width)
         //   ...
         //   TailCall("draw", [x + 1, y, width])
         //
-        // `width` is forwarded unchanged → `Int.toFloat(width)` is loop-invariant
+        // `width` is forwarded unchanged → `Float.fromInt(width)` is loop-invariant
         let int_to_float_call = Expr::FnCall(
             Box::new(spanned(Expr::Attr(
-                Box::new(spanned(ident("Int"))),
-                "toFloat".to_string(),
+                Box::new(spanned(ident("Float"))),
+                "fromInt".to_string(),
             ))),
             vec![spanned(ident("width"))],
         );
@@ -939,7 +939,7 @@ mod tests {
         assert!(
             warnings
                 .iter()
-                .any(|w| w.message.contains("Int.toFloat(width)")
+                .any(|w| w.message.contains("Float.fromInt(width)")
                     && w.message.contains("doesn't change")),
             "expected loop-invariant warning, got {:?}",
             warnings
@@ -949,12 +949,12 @@ mod tests {
     #[test]
     fn b4_changed_param_no_warning() {
         // fn draw(x: Int, width: Int) -> Int
-        //   w = Int.toFloat(width)
+        //   w = Float.fromInt(width)
         //   TailCall("draw", [x + 1, width - 1])  ← width is NOT forwarded unchanged
         let int_to_float_call = Expr::FnCall(
             Box::new(spanned(Expr::Attr(
-                Box::new(spanned(ident("Int"))),
-                "toFloat".to_string(),
+                Box::new(spanned(ident("Float"))),
+                "fromInt".to_string(),
             ))),
             vec![spanned(ident("width"))],
         );
@@ -977,7 +977,7 @@ mod tests {
         let items = vec![TopLevel::FnDef(fd)];
         let warnings = collect_perf_warnings(&items);
         assert!(
-            !warnings.iter().any(|w| w.message.contains("Int.toFloat")),
+            !warnings.iter().any(|w| w.message.contains("Float.fromInt")),
             "expected no warning when width changes, got {:?}",
             warnings
         );
@@ -1048,12 +1048,12 @@ mod tests {
     #[test]
     fn b4_no_tailcall_no_warning() {
         // fn f(x: Int, y: Int) -> Int
-        //   w = Int.toFloat(y)
+        //   w = Float.fromInt(y)
         //   w  (no TailCall → not a recursive fn in TCO sense)
         let int_to_float_call = Expr::FnCall(
             Box::new(spanned(Expr::Attr(
-                Box::new(spanned(ident("Int"))),
-                "toFloat".to_string(),
+                Box::new(spanned(ident("Float"))),
+                "fromInt".to_string(),
             ))),
             vec![spanned(ident("y"))],
         );
diff --git a/src/codegen/builtins.rs b/src/codegen/builtins.rs
index eb872df7..643356e9 100644
--- a/src/codegen/builtins.rs
+++ b/src/codegen/builtins.rs
@@ -17,8 +17,7 @@ pub(crate) enum Builtin {
 
     // --- Int ---
     IntAbs,
-    IntToFloat,
-    IntToString,
+    IntFromFloat,
     IntFromString,
     IntMin,
     IntMax,
@@ -31,8 +30,7 @@ pub(crate) enum Builtin {
     FloatRound,
     FloatFloor,
     FloatCeil,
-    FloatToInt,
-    FloatToString,
+    FloatFromInt,
     FloatFromString,
     FloatPi,
     FloatMin,
@@ -43,7 +41,6 @@ pub(crate) enum Builtin {
 
     // --- String ---
     StringLen,
-    StringConcat,
     StringCharAt,
     StringChars,
     StringSlice,
@@ -96,7 +93,7 @@ pub(crate) enum Builtin {
     VectorSet,
     VectorLen,
     VectorFromList,
-    VectorToList,
+    ListFromVector,
 
     // --- Map ---
     MapGet,
@@ -128,8 +125,7 @@ pub(crate) fn recognize_builtin(name: &str) -> Option<Builtin> {
 
         // Int
         "Int.abs" => Builtin::IntAbs,
-        "Int.toFloat" | "Float.fromInt" => Builtin::IntToFloat,
-        "Int.toString" => Builtin::IntToString,
+        "Int.fromFloat" => Builtin::IntFromFloat,
         "Int.fromString" => Builtin::IntFromString,
         "Int.min" => Builtin::IntMin,
         "Int.max" => Builtin::IntMax,
@@ -142,8 +138,7 @@ pub(crate) fn recognize_builtin(name: &str) -> Option<Builtin> {
         "Float.round" => Builtin::FloatRound,
         "Float.floor" => Builtin::FloatFloor,
         "Float.ceil" => Builtin::FloatCeil,
-        "Float.toInt" => Builtin::FloatToInt,
-        "Float.toString" => Builtin::FloatToString,
+        "Float.fromInt" => Builtin::FloatFromInt,
         "Float.fromString" => Builtin::FloatFromString,
         "Float.pi" => Builtin::FloatPi,
         "Float.min" => Builtin::FloatMin,
@@ -154,7 +149,6 @@ pub(crate) fn recognize_builtin(name: &str) -> Option<Builtin> {
 
         // String
         "String.len" => Builtin::StringLen,
-        "String.concat" => Builtin::StringConcat,
         "String.charAt" => Builtin::StringCharAt,
         "String.chars" => Builtin::StringChars,
         "String.slice" => Builtin::StringSlice,
@@ -207,7 +201,7 @@ pub(crate) fn recognize_builtin(name: &str) -> Option<Builtin> {
         "Vector.set" => Builtin::VectorSet,
         "Vector.len" => Builtin::VectorLen,
         "Vector.fromList" => Builtin::VectorFromList,
-        "Vector.toList" => Builtin::VectorToList,
+        "List.fromVector" => Builtin::ListFromVector,
 
         // Map
         "Map.get" => Builtin::MapGet,
diff --git a/src/codegen/dafny/expr.rs b/src/codegen/dafny/expr.rs
index 04c0cd1a..c72c64c4 100644
--- a/src/codegen/dafny/expr.rs
+++ b/src/codegen/dafny/expr.rs
@@ -377,8 +377,8 @@ fn emit_dafny_builtin(b: crate::codegen::builtins::Builtin, a: &[String]) -> Str
 
         // Int
         IntAbs => format!("(if {} >= 0 then {} else -{})", a[0], a[0], a[0]),
-        IntToFloat => format!("({} as real)", a[0]),
-        IntToString | StringFromInt => format!("IntToString({})", a[0]),
+        IntFromFloat => format!("({} as int)", a[0]),
+        StringFromInt => format!("IntToString({})", a[0]),
         IntFromString => format!("IntFromString({})", a[0]),
         IntMin => format!("(if {} <= {} then {} else {})", a[0], a[1], a[0], a[1]),
         IntMax => format!("(if {} >= {} then {} else {})", a[0], a[1], a[0], a[1]),
@@ -388,8 +388,9 @@ fn emit_dafny_builtin(b: crate::codegen::builtins::Builtin, a: &[String]) -> Str
         FloatAbs => format!("(if {} >= 0.0 then {} else -{})", a[0], a[0], a[0]),
         FloatSqrt => format!("FloatSqrt({})", a[0]),
         FloatPow => format!("FloatPow({}, {})", a[0], a[1]),
-        FloatRound | FloatFloor | FloatCeil | FloatToInt => format!("FloatToInt({})", a[0]),
-        FloatToString | StringFromFloat => format!("FloatToString({})", a[0]),
+        FloatRound | FloatFloor | FloatCeil => format!("FloatToInt({})", a[0]),
+        FloatFromInt => format!("({} as real)", a[0]),
+        StringFromFloat => format!("FloatToString({})", a[0]),
         FloatFromString => format!("FloatFromString({})", a[0]),
         FloatPi => "FloatPi()".to_string(),
         FloatMin => format!("(if {} <= {} then {} else {})", a[0], a[1], a[0], a[1]),
@@ -400,7 +401,6 @@ fn emit_dafny_builtin(b: crate::codegen::builtins::Builtin, a: &[String]) -> Str
 
         // String
         StringLen => format!("|{}|", a[0]),
-        StringConcat => format!("({} + {})", a[0], a[1]),
         StringCharAt => format!("StringCharAt({}, {})", a[0], a[1]),
         StringChars => format!("StringChars({})", a[0]),
         StringSlice => format!("{}[{}..{}]", a[0], a[1], a[2]),
@@ -465,7 +465,7 @@ fn emit_dafny_builtin(b: crate::codegen::builtins::Builtin, a: &[String]) -> Str
         ),
         VectorLen => format!("|{}|", a[0]),
         VectorFromList => a[0].clone(),
-        VectorToList => a[0].clone(),
+        ListFromVector => a[0].clone(),
 
         // Map
         MapGet => format!("MapGet({}, {})", a[0], a[1]),
diff --git a/src/codegen/lean/builtins.rs b/src/codegen/lean/builtins.rs
index 31254946..d5484cdd 100644
--- a/src/codegen/lean/builtins.rs
+++ b/src/codegen/lean/builtins.rs
@@ -42,8 +42,7 @@ pub fn emit_builtin_call(
 
         // ---- Int ----
         IntAbs => format!("{}.natAbs", p(&a[0])),
-        IntToFloat => format!("Float.ofInt {}", p(&a[0])),
-        IntToString => format!("toString {}", p(&a[0])),
+        IntFromFloat => format!("AverFloat.toInt {}", p(&a[0])),
         IntMin => format!("min {} {}", p(&a[0]), p(&a[1])),
         IntMax => format!("max {} {}", p(&a[0]), p(&a[1])),
         IntMod => format!("(Except.ok ({} % {}) : Except String Int)", a[0], a[1]),
@@ -52,13 +51,12 @@ pub fn emit_builtin_call(
         // ---- Float ----
         FloatAbs => format!("Float.abs {}", p(&a[0])),
         FloatSqrt => format!("Float.sqrt {}", p(&a[0])),
-        FloatToString => format!("toString {}", p(&a[0])),
         FloatFromString => format!("Float.fromString {}", p(&a[0])),
+        FloatFromInt => format!("Float.ofInt {}", p(&a[0])),
         FloatPow => format!("AverFloat.pow {} {}", p(&a[0]), p(&a[1])),
         FloatRound => format!("AverFloat.round {}", p(&a[0])),
         FloatFloor => format!("AverFloat.floor {}", p(&a[0])),
         FloatCeil => format!("AverFloat.ceil {}", p(&a[0])),
-        FloatToInt => format!("AverFloat.toInt {}", p(&a[0])),
         FloatPi => "(3.141592653589793 : Float)".to_string(),
         FloatMin => format!("min {} {}", p(&a[0]), p(&a[1])),
         FloatMax => format!("max {} {}", p(&a[0]), p(&a[1])),
@@ -81,7 +79,6 @@ pub fn emit_builtin_call(
 
         // ---- String ----
         StringLen => format!("{}.length", p(&a[0])),
-        StringConcat => format!("({} ++ {})", p(&a[0]), p(&a[1])),
         StringCharAt => format!("String.charAt {} {}", p(&a[0]), p(&a[1])),
         StringChars => format!("String.chars {}", p(&a[0])),
         StringSlice => format!("String.slice {} {} {}", p(&a[0]), p(&a[1]), p(&a[2])),
@@ -131,7 +128,7 @@ pub fn emit_builtin_call(
         ),
         VectorLen => format!("{}.size", p(&a[0])),
         VectorFromList => format!("{}.toArray", p(&a[0])),
-        VectorToList => format!("{}.toList", p(&a[0])),
+        ListFromVector => format!("{}.toList", p(&a[0])),
 
         // ---- Map ----
         MapGet => format!("AverMap.get {} {}", p(&a[0]), p(&a[1])),
diff --git a/src/codegen/rust/builtins.rs b/src/codegen/rust/builtins.rs
index 2ac66182..55156ed1 100644
--- a/src/codegen/rust/builtins.rs
+++ b/src/codegen/rust/builtins.rs
@@ -12,8 +12,6 @@ fn builtin_needs_str_conversion(name: &str) -> bool {
         name,
         "Console.readLine"
             | "Time.now"
-            | "Int.toString"
-            | "Float.toString"
             | "Int.fromString"
             | "Float.fromString"
             | "String.slice"
@@ -408,13 +406,9 @@ fn emit_builtin_call_inner(
             let arg = emit_arg(0);
             Some(format!("{}.abs()", arg))
         }
-        "Int.toFloat" => {
+        "Int.fromFloat" => {
             let arg = emit_arg(0);
-            Some(format!("({} as f64)", arg))
-        }
-        "Int.toString" => {
-            let arg = emit_arg(0);
-            Some(format!("{}.to_string()", arg))
+            Some(format!("({} as i64)", arg))
         }
         "Int.fromString" => {
             let arg = emit_arg(0);
@@ -459,14 +453,6 @@ fn emit_builtin_call_inner(
             let arg = emit_arg(0);
             Some(format!("{}.parse::<f64>().map_err(|e| e.to_string())", arg))
         }
-        "Float.toInt" => {
-            let arg = emit_arg(0);
-            Some(format!("({} as i64)", arg))
-        }
-        "Float.toString" => {
-            let arg = emit_arg(0);
-            Some(format!("{}.to_string()", arg))
-        }
         "Float.sqrt" => {
             let arg = emit_arg(0);
             Some(format!("{}.sqrt()", arg))
@@ -783,7 +769,7 @@ fn emit_builtin_call_inner(
             let list = emit_arg(0);
             Some(format!("aver_rt::AverVector::from_vec({}.to_vec())", list))
         }
-        "Vector.toList" => {
+        "List.fromVector" => {
             let vec = emit_arg(0);
             Some(format!("{}.to_list()", vec))
         }
diff --git a/src/codegen/rust/expr.rs b/src/codegen/rust/expr.rs
index 566e2017..dd6db347 100644
--- a/src/codegen/rust/expr.rs
+++ b/src/codegen/rust/expr.rs
@@ -1086,7 +1086,7 @@ fn expr_is_numeric(expr: &Expr, ectx: &EmitCtx) -> bool {
                         | "Float.cos"
                         | "Float.atan2"
                         | "Float.fromInt"
-                        | "Int.toFloat"
+                        | "Float.fromInt"
                         | "List.len"
                         | "Vector.len"
                         | "Map.len"
diff --git a/src/codegen/wasm/alloc_policy.rs b/src/codegen/wasm/alloc_policy.rs
index d5fdf376..d92540b2 100644
--- a/src/codegen/wasm/alloc_policy.rs
+++ b/src/codegen/wasm/alloc_policy.rs
@@ -46,7 +46,7 @@ fn is_pure_non_alloc_builtin(name: &str) -> bool {
         "Int.abs"
             | "Int.min"
             | "Int.max"
-            | "Int.toFloat"
+            | "Float.fromInt"
             // Float arithmetic, transcendentals, constants, predicates.
             | "Float.abs"
             | "Float.floor"
@@ -96,7 +96,7 @@ mod tests {
         assert!(!p.builtin_allocates("Float.sin"));
         assert!(!p.builtin_allocates("Float.sqrt"));
         assert!(!p.builtin_allocates("Int.abs"));
-        assert!(!p.builtin_allocates("Int.toFloat"));
+        assert!(!p.builtin_allocates("Float.fromInt"));
     }
 
     #[test]
diff --git a/src/codegen/wasm/expr/builtins.rs b/src/codegen/wasm/expr/builtins.rs
index 1270b932..cd97d811 100644
--- a/src/codegen/wasm/expr/builtins.rs
+++ b/src/codegen/wasm/expr/builtins.rs
@@ -116,14 +116,14 @@ impl<'a> ExprEmitter<'a> {
             "Float.fromInt" if args.len() == 1 => {
                 self.instructions.push(Instruction::F64ConvertI64S);
             }
-            "Int.toFloat" if args.len() == 1 => {
+            "Float.fromInt" if args.len() == 1 => {
                 self.instructions.push(Instruction::F64ConvertI64S);
             }
-            "Int.toString" if args.len() == 1 => {
+            "String.fromInt" if args.len() == 1 => {
                 self.instructions
                     .push(Instruction::Call(self.rt.i64_to_str_obj));
             }
-            "Float.toString" if args.len() == 1 => {
+            "String.fromFloat" if args.len() == 1 => {
                 self.instructions
                     .push(Instruction::Call(self.rt.f64_to_str_obj));
             }
@@ -344,7 +344,7 @@ impl<'a> ExprEmitter<'a> {
                 ));
                 self.instructions.push(Instruction::Call(self.rt.vec_new));
             }
-            "Vector.toList" if args.len() == 1 => {
+            "List.fromVector" if args.len() == 1 => {
                 self.instructions
                     .push(Instruction::Call(self.rt.vec_to_list));
             }
@@ -626,7 +626,7 @@ impl<'a> ExprEmitter<'a> {
                 self.instructions
                     .push(Instruction::F64Const(std::f64::consts::PI));
             }
-            "Float.toInt" if args.len() == 1 => {
+            "Int.fromFloat" if args.len() == 1 => {
                 self.instructions.push(Instruction::I64TruncF64S);
             }
             "Float.fromString" if args.len() == 1 => {
diff --git a/src/codegen/wasm_gc/body/builtins.rs b/src/codegen/wasm_gc/body/builtins.rs
index ecba77b3..fca0e507 100644
--- a/src/codegen/wasm_gc/body/builtins.rs
+++ b/src/codegen/wasm_gc/body/builtins.rs
@@ -157,7 +157,7 @@ pub(super) fn emit_dotted_builtin(
         }
         // `Int.toFloat` is the same op as `Float.fromInt` — Aver has
         // both spellings; map both to the same instruction.
-        "Int.toFloat" if args.len() == 1 => {
+        "Float.fromInt" if args.len() == 1 => {
             emit_expr(func, &args[0], slots, ctx)?;
             func.instruction(&Instruction::F64ConvertI64S);
             Ok(())
@@ -298,7 +298,7 @@ pub(super) fn emit_dotted_builtin(
             let to_string_idx =
                 ctx.fn_map
                     .builtins
-                    .get("Int.toString")
+                    .get("String.fromInt")
                     .copied()
                     .ok_or(WasmGcError::Validation(
                         "String.fromInt requires Int.toString builtin".into(),
@@ -308,7 +308,7 @@ pub(super) fn emit_dotted_builtin(
             Ok(())
         }
         "String.fromFloat" if args.len() == 1 => {
-            let to_string_idx = ctx.fn_map.builtins.get("Float.toString").copied().ok_or(
+            let to_string_idx = ctx.fn_map.builtins.get("String.fromFloat").copied().ok_or(
                 WasmGcError::Validation("String.fromFloat requires Float.toString builtin".into()),
             )?;
             emit_expr(func, &args[0], slots, ctx)?;
@@ -415,7 +415,7 @@ pub(super) fn emit_dotted_builtin(
         "List.zip" if args.len() == 2 => emit_list_zip_call(func, &args[0], &args[1], slots, ctx),
         // Vector.fromList(list: List<T>) -> Vector<T>
         "Vector.fromList" if args.len() == 1 => emit_vec_from_list_call(func, &args[0], slots, ctx),
-        "Vector.toList" if args.len() == 1 => emit_vec_to_list_call(func, &args[0], slots, ctx),
+        "List.fromVector" if args.len() == 1 => emit_vec_to_list_call(func, &args[0], slots, ctx),
         // String.split / String.join — singleton (T=String).
         "String.split" if args.len() == 2 => {
             let ops = ctx.fn_map.string_split_ops.ok_or(WasmGcError::Validation(
@@ -1119,7 +1119,7 @@ pub(super) fn emit_interpolated_str(
                     "String" => { /* identity */ }
                     "Int" => {
                         let to_string_idx =
-                            ctx.fn_map.builtins.get("Int.toString").copied().ok_or(
+                            ctx.fn_map.builtins.get("String.fromInt").copied().ok_or(
                                 WasmGcError::Validation(
                                     "interpolation of Int requires Int.toString builtin".into(),
                                 ),
@@ -1128,7 +1128,7 @@ pub(super) fn emit_interpolated_str(
                     }
                     "Float" => {
                         let to_string_idx =
-                            ctx.fn_map.builtins.get("Float.toString").copied().ok_or(
+                            ctx.fn_map.builtins.get("String.fromFloat").copied().ok_or(
                                 WasmGcError::Validation(
                                     "interpolation of Float requires Float.toString builtin".into(),
                                 ),
diff --git a/src/codegen/wasm_gc/builtins/mod.rs b/src/codegen/wasm_gc/builtins/mod.rs
index 76a44203..79f0583b 100644
--- a/src/codegen/wasm_gc/builtins/mod.rs
+++ b/src/codegen/wasm_gc/builtins/mod.rs
@@ -127,7 +127,7 @@ pub(super) enum BuiltinName {
 impl BuiltinName {
     pub(super) fn from_dotted(s: &str) -> Option<Self> {
         match s {
-            "Int.toString" | "String.fromInt" => Some(Self::IntToString),
+            "String.fromInt" => Some(Self::IntToString),
             "String.fromFloat" => Some(Self::FloatToString),
             "String.len" | "String.length" | "String.byteLength" => Some(Self::StringLength),
             "String.startsWith" => Some(Self::StringStartsWith),
@@ -138,7 +138,6 @@ impl BuiltinName {
             "String.trim" => Some(Self::StringTrim),
             "Int.fromString" => Some(Self::IntFromString),
             "Float.fromString" => Some(Self::FloatFromString),
-            "Float.toString" => Some(Self::FloatToString),
             "String.endsWith" => Some(Self::StringEndsWith),
             "String.fromBool" => Some(Self::StringFromBool),
             "String.charAt" => Some(Self::StringCharAt),
@@ -153,7 +152,7 @@ impl BuiltinName {
 
     pub(super) fn canonical(self) -> &'static str {
         match self {
-            Self::IntToString => "Int.toString",
+            Self::IntToString => "String.fromInt",
             Self::StringLength => "String.len",
             Self::StringConcatN => "__wasmgc_concat_n",
             Self::StringStartsWith => "String.startsWith",
@@ -164,7 +163,7 @@ impl BuiltinName {
             Self::StringTrim => "String.trim",
             Self::IntFromString => "Int.fromString",
             Self::FloatFromString => "Float.fromString",
-            Self::FloatToString => "Float.toString",
+            Self::FloatToString => "String.fromFloat",
             Self::StringEq => "__wasmgc_string_eq",
             Self::StringCompare => "__wasmgc_string_compare",
             Self::StringEndsWith => "String.endsWith",
diff --git a/src/codegen/wasm_gc/types.rs b/src/codegen/wasm_gc/types.rs
index 96f0dbfd..a9dec7bb 100644
--- a/src/codegen/wasm_gc/types.rs
+++ b/src/codegen/wasm_gc/types.rs
@@ -1965,11 +1965,10 @@ fn expr_uses_string(expr: &crate::ast::Expr) -> bool {
                     let dotted = format!("{p}.{member}");
                     if matches!(
                         dotted.as_str(),
-                        "Int.toString"
-                            | "Float.toString"
+                        "String.fromInt"
+                            | "String.fromFloat"
                             | "String.len"
                             | "String.length"
-                            | "String.concat"
                             | "String.startsWith"
                             | "String.contains"
                             | "String.slice"
diff --git a/src/ir/alloc_info.rs b/src/ir/alloc_info.rs
index 1548908d..942ea8d5 100644
--- a/src/ir/alloc_info.rs
+++ b/src/ir/alloc_info.rs
@@ -316,7 +316,7 @@ mod tests {
 
     impl AllocPolicy for TestPolicy {
         fn builtin_allocates(&self, name: &str) -> bool {
-            name.starts_with("Map.") || name == "Int.toString"
+            name.starts_with("Map.") || name == "String.fromInt"
         }
         fn constructor_allocates(&self, _name: &str, _has_payload: bool) -> bool {
             false
@@ -363,11 +363,11 @@ mod tests {
 
     #[test]
     fn allocating_builtin_call_allocates() {
-        // Int.toString(42)
+        // String.fromInt(42)
         let call = Expr::FnCall(
             Box::new(sp(Expr::Attr(
-                Box::new(sp(Expr::Ident("Int".into()))),
-                "toString".into(),
+                Box::new(sp(Expr::Ident("String".into()))),
+                "fromInt".into(),
             ))),
             vec![lit_int(42)],
         );
diff --git a/src/ir/analyze.rs b/src/ir/analyze.rs
index 991a1ec8..0d0d79ac 100644
--- a/src/ir/analyze.rs
+++ b/src/ir/analyze.rs
@@ -73,7 +73,7 @@ impl AllocPolicy for NeutralAllocPolicy {
             "Int.abs"
                 | "Int.min"
                 | "Int.max"
-                | "Int.toFloat"
+                | "Float.fromInt"
                 | "Float.abs"
                 | "Float.floor"
                 | "Float.ceil"
diff --git a/src/types/checker/builtins.rs b/src/types/checker/builtins.rs
index d8edb34f..c3b99ad9 100644
--- a/src/types/checker/builtins.rs
+++ b/src/types/checker/builtins.rs
@@ -439,12 +439,10 @@ impl TypeChecker {
         let int_sigs: &[(&str, &[Type], Type, &[&str])] = &[
             ("Int.fromString", &[Type::Str], int_result(), &[]),
             ("Int.fromFloat", &[Type::Float], Type::Int, &[]),
-            ("Int.toString", &[Type::Int], Type::Str, &[]),
             ("Int.abs", &[Type::Int], Type::Int, &[]),
             ("Int.min", &[Type::Int, Type::Int], Type::Int, &[]),
             ("Int.max", &[Type::Int, Type::Int], Type::Int, &[]),
             ("Int.mod", &[Type::Int, Type::Int], int_result(), &[]),
-            ("Int.toFloat", &[Type::Int], Type::Float, &[]),
         ];
         for (name, params, ret, effects) in int_sigs {
             self.insert_sig(name, params, ret.clone(), effects);
@@ -455,7 +453,6 @@ impl TypeChecker {
         let float_sigs: &[(&str, &[Type], Type, &[&str])] = &[
             ("Float.fromString", &[Type::Str], float_result(), &[]),
             ("Float.fromInt", &[Type::Int], Type::Float, &[]),
-            ("Float.toString", &[Type::Float], Type::Str, &[]),
             ("Float.abs", &[Type::Float], Type::Float, &[]),
             ("Float.floor", &[Type::Float], Type::Int, &[]),
             ("Float.ceil", &[Type::Float], Type::Int, &[]),
@@ -613,7 +610,7 @@ impl TypeChecker {
                 &[],
             ),
             (
-                "Vector.toList",
+                "List.fromVector",
                 &[vec_t()],
                 Type::List(Box::new(t_var())),
                 &[],
diff --git a/src/types/checker/infer/vector_calls.rs b/src/types/checker/infer/vector_calls.rs
index 2cf6c136..ef5a8254 100644
--- a/src/types/checker/infer/vector_calls.rs
+++ b/src/types/checker/infer/vector_calls.rs
@@ -117,7 +117,7 @@ impl TypeChecker {
                 };
                 Some(vector_ty(elem))
             }
-            "Vector.toList" => {
+            "List.fromVector" => {
                 if let Err(fallback) = expect_arity(self, 1, list_ty(Type::Invalid)) {
                     return Some(fallback);
                 }
diff --git a/src/types/float.rs b/src/types/float.rs
index 1445f995..93656a31 100644
--- a/src/types/float.rs
+++ b/src/types/float.rs
@@ -3,7 +3,6 @@
 /// Methods:
 ///   Float.fromString(s)  → Result<Float, String>  — parse string to float
 ///   Float.fromInt(n)     → Float                  — widen int to float
-///   Float.toString(f)    → String                 — format float as string
 ///   Float.abs(f)         → Float                  — absolute value
 ///   Float.floor(f)       → Int                    — floor to int
 ///   Float.ceil(f)        → Int                    — ceil to int
@@ -29,7 +28,6 @@ pub fn register(global: &mut HashMap<String, Value>) {
     for method in &[
         "fromString",
         "fromInt",
-        "toString",
         "abs",
         "floor",
         "ceil",
@@ -66,7 +64,6 @@ pub fn call(name: &str, args: &[Value]) -> Option<Result<Value, RuntimeError>> {
     match name {
         "Float.fromString" => Some(from_string(args)),
         "Float.fromInt" => Some(from_int(args)),
-        "Float.toString" => Some(to_string(args)),
         "Float.abs" => Some(abs(args)),
         "Float.floor" => Some(floor(args)),
         "Float.ceil" => Some(ceil(args)),
@@ -111,16 +108,6 @@ fn from_int(args: &[Value]) -> Result<Value, RuntimeError> {
     Ok(Value::Float(*n as f64))
 }
 
-fn to_string(args: &[Value]) -> Result<Value, RuntimeError> {
-    let [val] = one_arg("Float.toString", args)?;
-    let Value::Float(f) = val else {
-        return Err(RuntimeError::Error(
-            "Float.toString: argument must be a Float".to_string(),
-        ));
-    };
-    Ok(Value::Str(format!("{}", f)))
-}
-
 fn abs(args: &[Value]) -> Result<Value, RuntimeError> {
     let [val] = one_arg("Float.abs", args)?;
     let Value::Float(f) = val else {
@@ -271,7 +258,6 @@ pub fn register_nv(global: &mut HashMap<String, NanValue>, arena: &mut Arena) {
     let methods = &[
         "fromString",
         "fromInt",
-        "toString",
         "abs",
         "floor",
         "ceil",
@@ -305,7 +291,6 @@ pub fn call_nv(
     match name {
         "Float.fromString" => Some(from_string_nv(args, arena)),
         "Float.fromInt" => Some(from_int_nv(args, arena)),
-        "Float.toString" => Some(to_string_nv(args, arena)),
         "Float.abs" => Some(abs_nv(args, arena)),
         "Float.floor" => Some(floor_nv(args, arena)),
         "Float.ceil" => Some(ceil_nv(args, arena)),
@@ -375,17 +360,6 @@ fn from_int_nv(args: &[NanValue], arena: &mut Arena) -> Result<NanValue, Runtime
     Ok(NanValue::new_float(v.as_int(arena) as f64))
 }
 
-fn to_string_nv(args: &[NanValue], arena: &mut Arena) -> Result<NanValue, RuntimeError> {
-    let v = nv_check1("Float.toString", args)?;
-    if !v.is_float() {
-        return Err(RuntimeError::Error(
-            "Float.toString: argument must be a Float".to_string(),
-        ));
-    }
-    let s = format!("{}", v.as_float());
-    Ok(NanValue::new_string_value(&s, arena))
-}
-
 fn abs_nv(args: &[NanValue], _arena: &mut Arena) -> Result<NanValue, RuntimeError> {
     let v = nv_check1("Float.abs", args)?;
     if !v.is_float() {
diff --git a/src/types/int.rs b/src/types/int.rs
index 60a8b132..e8140bc8 100644
--- a/src/types/int.rs
+++ b/src/types/int.rs
@@ -3,12 +3,13 @@
 /// Methods:
 ///   Int.fromString(s)   → Result<Int, String>  — parse string to int
 ///   Int.fromFloat(f)    → Int                  — truncate float to int
-///   Int.toString(n)     → String               — format int as string
 ///   Int.abs(n)          → Int                  — absolute value
 ///   Int.min(a, b)       → Int                  — minimum of two ints
 ///   Int.max(a, b)       → Int                  — maximum of two ints
 ///   Int.mod(a, b)       → Result<Int, String>  — modulo (error on b=0)
-///   Int.toFloat(n)      → Float                — widen int to float
+///
+/// Stringification goes through `String.fromInt` (or `"{n}"` interpolation);
+/// widening to Float goes through `Float.fromInt`.
 ///
 /// No effects required.
 use std::collections::HashMap;
@@ -19,16 +20,7 @@ use crate::value::{RuntimeError, Value};
 
 pub fn register(global: &mut HashMap<String, Value>) {
     let mut members = HashMap::new();
-    for method in &[
-        "fromString",
-        "fromFloat",
-        "toString",
-        "abs",
-        "min",
-        "max",
-        "mod",
-        "toFloat",
-    ] {
+    for method in &["fromString", "fromFloat", "abs", "min", "max", "mod"] {
         members.insert(
             method.to_string(),
             Value::Builtin(format!("Int.{}", method)),
@@ -52,12 +44,10 @@ pub fn call(name: &str, args: &[Value]) -> Option<Result<Value, RuntimeError>> {
     match name {
         "Int.fromString" => Some(from_string(args)),
         "Int.fromFloat" => Some(from_float(args)),
-        "Int.toString" => Some(to_string(args)),
         "Int.abs" => Some(abs(args)),
         "Int.min" => Some(min(args)),
         "Int.max" => Some(max(args)),
         "Int.mod" => Some(modulo(args)),
-        "Int.toFloat" => Some(to_float(args)),
         _ => None,
     }
 }
@@ -90,16 +80,6 @@ fn from_float(args: &[Value]) -> Result<Value, RuntimeError> {
     Ok(Value::Int(*f as i64))
 }
 
-fn to_string(args: &[Value]) -> Result<Value, RuntimeError> {
-    let [val] = one_arg("Int.toString", args)?;
-    let Value::Int(n) = val else {
-        return Err(RuntimeError::Error(
-            "Int.toString: argument must be an Int".to_string(),
-        ));
-    };
-    Ok(Value::Str(format!("{}", n)))
-}
-
 fn abs(args: &[Value]) -> Result<Value, RuntimeError> {
     let [val] = one_arg("Int.abs", args)?;
     let Value::Int(n) = val else {
@@ -146,16 +126,6 @@ fn modulo(args: &[Value]) -> Result<Value, RuntimeError> {
     }
 }
 
-fn to_float(args: &[Value]) -> Result<Value, RuntimeError> {
-    let [val] = one_arg("Int.toFloat", args)?;
-    let Value::Int(n) = val else {
-        return Err(RuntimeError::Error(
-            "Int.toFloat: argument must be an Int".to_string(),
-        ));
-    };
-    Ok(Value::Float(*n as f64))
-}
-
 // ─── Helpers ────────────────────────────────────────────────────────────────
 
 fn one_arg<'a>(name: &str, args: &'a [Value]) -> Result<[&'a Value; 1], RuntimeError> {
@@ -183,16 +153,7 @@ fn two_args<'a>(name: &str, args: &'a [Value]) -> Result<[&'a Value; 2], Runtime
 // ─── NanValue-native API ─────────────────────────────────────────────────────
 
 pub fn register_nv(global: &mut HashMap<String, NanValue>, arena: &mut Arena) {
-    let methods = &[
-        "fromString",
-        "fromFloat",
-        "toString",
-        "abs",
-        "min",
-        "max",
-        "mod",
-        "toFloat",
-    ];
+    let methods = &["fromString", "fromFloat", "abs", "min", "max", "mod"];
     let mut members: Vec<(Rc<str>, NanValue)> = Vec::with_capacity(methods.len());
     for method in methods {
         let idx = arena.push_builtin(&format!("Int.{}", method));
@@ -213,12 +174,10 @@ pub fn call_nv(
     match name {
         "Int.fromString" => Some(from_string_nv(args, arena)),
         "Int.fromFloat" => Some(from_float_nv(args, arena)),
-        "Int.toString" => Some(to_string_nv(args, arena)),
         "Int.abs" => Some(abs_nv(args, arena)),
         "Int.min" => Some(min_nv(args, arena)),
         "Int.max" => Some(max_nv(args, arena)),
         "Int.mod" => Some(modulo_nv(args, arena)),
-        "Int.toFloat" => Some(to_float_nv(args, arena)),
         _ => None,
     }
 }
@@ -276,17 +235,6 @@ fn from_float_nv(args: &[NanValue], arena: &mut Arena) -> Result<NanValue, Runti
     Ok(NanValue::new_int(v.as_float() as i64, arena))
 }
 
-fn to_string_nv(args: &[NanValue], arena: &mut Arena) -> Result<NanValue, RuntimeError> {
-    let v = nv_check1("Int.toString", args)?;
-    if !v.is_int() {
-        return Err(RuntimeError::Error(
-            "Int.toString: argument must be an Int".to_string(),
-        ));
-    }
-    let s = format!("{}", v.as_int(arena));
-    Ok(NanValue::new_string_value(&s, arena))
-}
-
 fn abs_nv(args: &[NanValue], arena: &mut Arena) -> Result<NanValue, RuntimeError> {
     let v = nv_check1("Int.abs", args)?;
     if !v.is_int() {
@@ -341,12 +289,3 @@ fn modulo_nv(args: &[NanValue], arena: &mut Arena) -> Result<NanValue, RuntimeEr
     }
 }
 
-fn to_float_nv(args: &[NanValue], arena: &mut Arena) -> Result<NanValue, RuntimeError> {
-    let v = nv_check1("Int.toFloat", args)?;
-    if !v.is_int() {
-        return Err(RuntimeError::Error(
-            "Int.toFloat: argument must be an Int".to_string(),
-        ));
-    }
-    Ok(NanValue::new_float(v.as_int(arena) as f64))
-}
diff --git a/src/types/list.rs b/src/types/list.rs
index 526b7c36..5bc3116d 100644
--- a/src/types/list.rs
+++ b/src/types/list.rs
@@ -22,7 +22,15 @@ use crate::value::{
 pub fn register(global: &mut HashMap<String, Value>) {
     let mut members = HashMap::new();
     for method in &[
-        "len", "prepend", "take", "drop", "concat", "reverse", "contains", "zip",
+        "len",
+        "prepend",
+        "take",
+        "drop",
+        "concat",
+        "reverse",
+        "contains",
+        "zip",
+        "fromVector",
     ] {
         members.insert(
             method.to_string(),
@@ -197,7 +205,15 @@ fn zip(args: &[Value]) -> Result<Value, RuntimeError> {
 
 pub fn register_nv(global: &mut HashMap<String, NanValue>, arena: &mut Arena) {
     let methods = &[
-        "len", "prepend", "take", "drop", "concat", "reverse", "contains", "zip",
+        "len",
+        "prepend",
+        "take",
+        "drop",
+        "concat",
+        "reverse",
+        "contains",
+        "zip",
+        "fromVector",
     ];
     let mut members: Vec<(Rc<str>, NanValue)> = Vec::with_capacity(methods.len());
     for method in methods {
diff --git a/src/types/vector.rs b/src/types/vector.rs
index bab413f5..3ce46569 100644
--- a/src/types/vector.rs
+++ b/src/types/vector.rs
@@ -6,7 +6,7 @@
 ///   Vector.set(vec, idx, val)     → Option<Vector<T>>
 ///   Vector.len(vec)               → Int
 ///   Vector.fromList(xs)           → Vector<T>
-///   Vector.toList(vec)            → List<T>
+///   List.fromVector(vec)            → List<T>
 ///
 /// No effects required.
 use std::collections::HashMap;
@@ -19,7 +19,7 @@ use crate::value::{RuntimeError, Value, list_from_vec, list_view};
 
 pub fn register(global: &mut HashMap<String, Value>) {
     let mut members = HashMap::new();
-    for method in &["new", "get", "set", "len", "fromList", "toList"] {
+    for method in &["new", "get", "set", "len", "fromList"] {
         members.insert(
             method.to_string(),
             Value::Builtin(format!("Vector.{}", method)),
@@ -45,7 +45,7 @@ pub fn call(name: &str, args: &[Value]) -> Option<Result<Value, RuntimeError>> {
         "Vector.set" => Some(vec_set(args)),
         "Vector.len" => Some(vec_len(args)),
         "Vector.fromList" => Some(vec_from_list(args)),
-        "Vector.toList" => Some(vec_to_list(args)),
+        "List.fromVector" => Some(vec_to_list(args)),
         _ => None,
     }
 }
@@ -156,13 +156,13 @@ fn vec_from_list(args: &[Value]) -> Result<Value, RuntimeError> {
 fn vec_to_list(args: &[Value]) -> Result<Value, RuntimeError> {
     if args.len() != 1 {
         return Err(RuntimeError::Error(format!(
-            "Vector.toList() takes 1 argument, got {}",
+            "List.fromVector() takes 1 argument, got {}",
             args.len()
         )));
     }
     let Value::Vector(vec) = &args[0] else {
         return Err(RuntimeError::Error(
-            "Vector.toList: argument must be a Vector".to_string(),
+            "List.fromVector: argument must be a Vector".to_string(),
         ));
     };
     Ok(list_from_vec(vec.to_vec()))
@@ -171,7 +171,7 @@ fn vec_to_list(args: &[Value]) -> Result<Value, RuntimeError> {
 // ─── NanValue-native API ─────────────────────────────────────────────────────
 
 pub fn register_nv(global: &mut HashMap<String, NanValue>, arena: &mut Arena) {
-    let methods = &["new", "get", "set", "len", "fromList", "toList"];
+    let methods = &["new", "get", "set", "len", "fromList"];
     let mut members: Vec<(Rc<str>, NanValue)> = Vec::with_capacity(methods.len());
     for method in methods {
         let idx = arena.push_builtin(&format!("Vector.{}", method));
@@ -195,7 +195,7 @@ pub fn call_nv(
         "Vector.set" => Some(vec_set_nv(args, arena)),
         "Vector.len" => Some(vec_len_nv(args, arena)),
         "Vector.fromList" => Some(vec_from_list_nv(args, arena)),
-        "Vector.toList" => Some(vec_to_list_nv(args, arena)),
+        "List.fromVector" => Some(vec_to_list_nv(args, arena)),
         _ => None,
     }
 }
@@ -364,13 +364,13 @@ fn vec_from_list_nv(args: &[NanValue], arena: &mut Arena) -> Result<NanValue, Ru
 fn vec_to_list_nv(args: &[NanValue], arena: &mut Arena) -> Result<NanValue, RuntimeError> {
     if args.len() != 1 {
         return Err(RuntimeError::Error(format!(
-            "Vector.toList() takes 1 argument, got {}",
+            "List.fromVector() takes 1 argument, got {}",
             args.len()
         )));
     }
     if !args[0].is_vector() {
         return Err(RuntimeError::Error(
-            "Vector.toList: argument must be a Vector".to_string(),
+            "List.fromVector: argument must be a Vector".to_string(),
         ));
     }
     let items = arena.clone_vector_value(args[0]);
diff --git a/src/vm/alloc_policy.rs b/src/vm/alloc_policy.rs
index 4a36c96d..d8436552 100644
--- a/src/vm/alloc_policy.rs
+++ b/src/vm/alloc_policy.rs
@@ -32,7 +32,7 @@ fn is_pure_non_alloc_builtin(name: &str) -> bool {
         "Int.abs"
             | "Int.min"
             | "Int.max"
-            | "Int.toFloat"
+            | "Float.fromInt"
             | "Float.abs"
             | "Float.floor"
             | "Float.ceil"
diff --git a/src/vm/builtin.rs b/src/vm/builtin.rs
index 5d178659..317bc873 100644
--- a/src/vm/builtin.rs
+++ b/src/vm/builtin.rs
@@ -96,16 +96,13 @@ vm_builtins! {
 
     IntFromString => "Int.fromString",
     IntFromFloat => "Int.fromFloat",
-    IntToString => "Int.toString",
     IntAbs => "Int.abs",
     IntMin => "Int.min",
     IntMax => "Int.max",
     IntMod => "Int.mod",
-    IntToFloat => "Int.toFloat",
 
     FloatFromString => "Float.fromString",
     FloatFromInt => "Float.fromInt",
-    FloatToString => "Float.toString",
     FloatAbs => "Float.abs",
     FloatFloor => "Float.floor",
     FloatCeil => "Float.ceil",
@@ -161,7 +158,7 @@ vm_builtins! {
     VectorSet => "Vector.set",
     VectorLen => "Vector.len",
     VectorFromList => "Vector.fromList",
-    VectorToList => "Vector.toList",
+    ListFromVector => "List.fromVector",
 
     OptionWithDefault => "Option.withDefault",
     OptionToResult => "Option.toResult",
@@ -203,7 +200,6 @@ impl VmBuiltin {
             | Self::IntAbs
             | Self::IntMin
             | Self::IntMax
-            | Self::IntToFloat
             | Self::FloatFromInt
             | Self::FloatAbs
             | Self::FloatFloor
@@ -420,16 +416,13 @@ impl VmBuiltin {
 
             Self::IntFromString
             | Self::IntFromFloat
-            | Self::IntToString
             | Self::IntAbs
             | Self::IntMin
             | Self::IntMax
-            | Self::IntMod
-            | Self::IntToFloat => int::call_nv(self.name(), args, arena),
+            | Self::IntMod => int::call_nv(self.name(), args, arena),
 
             Self::FloatFromString
             | Self::FloatFromInt
-            | Self::FloatToString
             | Self::FloatAbs
             | Self::FloatFloor
             | Self::FloatCeil
@@ -485,7 +478,7 @@ impl VmBuiltin {
             | Self::VectorSet
             | Self::VectorLen
             | Self::VectorFromList
-            | Self::VectorToList => crate::types::vector::call_nv(self.name(), args, arena),
+            | Self::ListFromVector => crate::types::vector::call_nv(self.name(), args, arena),
 
             Self::OptionWithDefault | Self::OptionToResult => {
                 option::call_nv(self.name(), args, arena)
diff --git a/tools/edge/bench.av b/tools/edge/bench.av
index 3ad8ecc8..d0a3950a 100644
--- a/tools/edge/bench.av
+++ b/tools/edge/bench.av
@@ -12,4 +12,4 @@ fn main() -> Unit
     seahorse = Fractal.viewFromQuery("cx=-0.7463&cy=0.1102&w=0.012")
     zoom = Fractal.render(200, 120, 220, seahorse)
     t2 = Time.unixMs()
-    Console.print("full(200x120,100)={Int.toString(t1 - t0)}ms[{Int.toString(String.len(full))}B] zoom(200x120,220)={Int.toString(t2 - t1)}ms[{Int.toString(String.len(zoom))}B] total={Int.toString(t2 - t0)}ms")
+    Console.print("full(200x120,100)={String.fromInt(t1 - t0)}ms[{String.fromInt(String.len(full))}B] zoom(200x120,220)={String.fromInt(t2 - t1)}ms[{String.fromInt(String.len(zoom))}B] total={String.fromInt(t2 - t0)}ms")
diff --git a/tools/edge/fractal.av b/tools/edge/fractal.av
index 0b6cccde..ee8abf18 100644
--- a/tools/edge/fractal.av
+++ b/tools/edge/fractal.av
@@ -141,9 +141,9 @@ verify gridHFor
 fn navLink(cx: Float, cy: Float, w: Float, label: String, hint: String) -> String
     ? "One nav anchor — encodes (cx, cy, w) into a /fractal query string. Browsers fire a fresh request per click; the new view is parsed back out by `viewFromQuery` on the server."
     String.join([
-        "<a href=\"?cx=", Float.toString(cx),
-        "&cy=", Float.toString(cy),
-        "&w=", Float.toString(w),
+        "<a href=\"?cx=", String.fromFloat(cx),
+        "&cy=", String.fromFloat(cy),
+        "&w=", String.fromFloat(w),
         "\" title=\"", hint, "\">", label, "</a>"
     ], "")
 
@@ -189,22 +189,22 @@ fn mandelStep(n: Int, x: Float, y: Float, prevZ2: Float, cx: Float, cy: Float, m
     ? "One iteration of z = z² + c. On escape (|z|² > 4) returns a *continuous* escape time using linear interpolation between the previous and current |z|²: nu = (n - 1) + (R² - prevZ²) / (curZ² - prevZ²). This sub-iter precision drives the Bayer-dither palette lookup so iso-bands transition smoothly across pixels instead of stepping at integer iter boundaries."
     curZ2 = x * x + y * y
     match curZ2 > 4.0
-        true  -> Int.toFloat(n - 1) + (4.0 - prevZ2) / (curZ2 - prevZ2)
+        true  -> Float.fromInt(n - 1) + (4.0 - prevZ2) / (curZ2 - prevZ2)
         false -> mandelIter(n + 1, x * x - y * y + cx, 2.0 * x * y + cy, curZ2, cx, cy, maxIter)
 
 verify mandelStep
-    mandelStep(7, 3.0, 0.0, 1.0, 0.0, 0.0, 50) => Int.toFloat(7 - 1) + (4.0 - 1.0) / (9.0 - 1.0)
-    mandelStep(0, 0.0, 0.0, 0.0, 0.0, 0.0, 50) => Int.toFloat(50)
+    mandelStep(7, 3.0, 0.0, 1.0, 0.0, 0.0, 50) => Float.fromInt(7 - 1) + (4.0 - 1.0) / (9.0 - 1.0)
+    mandelStep(0, 0.0, 0.0, 0.0, 0.0, 0.0, 50) => Float.fromInt(50)
 
 fn mandelIter(n: Int, x: Float, y: Float, prevZ2: Float, cx: Float, cy: Float, maxIter: Int) -> Float
-    ? "Iterates z = z² + c until |z|² > 4 or maxIter; returns continuous escape time as Float. In-set points (n hits maxIter) return Int.toFloat(maxIter). TCO-eligible mutual recursion via mandelStep."
+    ? "Iterates z = z² + c until |z|² > 4 or maxIter; returns continuous escape time as Float. In-set points (n hits maxIter) return Float.fromInt(maxIter). TCO-eligible mutual recursion via mandelStep."
     match n >= maxIter
-        true  -> Int.toFloat(maxIter)
+        true  -> Float.fromInt(maxIter)
         false -> mandelStep(n, x, y, prevZ2, cx, cy, maxIter)
 
 verify mandelIter
-    mandelIter(0, 0.0, 0.0, 0.0, 0.0, 0.0, 50) => Int.toFloat(50)
-    mandelIter(50, 0.0, 0.0, 0.0, 0.0, 0.0, 50) => Int.toFloat(50)
+    mandelIter(0, 0.0, 0.0, 0.0, 0.0, 0.0, 50) => Float.fromInt(50)
+    mandelIter(50, 0.0, 0.0, 0.0, 0.0, 0.0, 50) => Float.fromInt(50)
 
 fn insideCardioid(cx: Float, cy: Float) -> Bool
     ? "True if (cx, cy) lies inside the main cardioid (the largest connected component of the set). Roughly 50% of inside-set points fall here; this test costs ~5 ops and avoids running mandelIter to maxIter on every one of them."
@@ -232,21 +232,21 @@ fn escapeIterSlow(cx: Float, cy: Float, maxIter: Int) -> Float
 fn escapeIterBulb(cx: Float, cy: Float, maxIter: Int) -> Float
     ? "Cardioid missed — try the period-2 bulb, else fall through."
     match insideBulb(cx, cy)
-        true  -> Int.toFloat(maxIter)
+        true  -> Float.fromInt(maxIter)
         false -> escapeIterSlow(cx, cy, maxIter)
 
 verify escapeIterBulb
-    escapeIterBulb(0.0 - 1.0, 0.0, 50) => Int.toFloat(50)
+    escapeIterBulb(0.0 - 1.0, 0.0, 50) => Float.fromInt(50)
 
 fn escapeIter(cx: Float, cy: Float, maxIter: Int) -> Float
-    ? "Returns the continuous escape time for (cx, cy) under the given iteration cap. Returns Int.toFloat(maxIter) for inside-set. Uses the cardioid + period-2 bulb pre-tests to short-circuit ~70% of inside-set points before any iteration runs. Sub-iter precision (Float vs Int) drives Bayer-dither palette lookup downstream."
+    ? "Returns the continuous escape time for (cx, cy) under the given iteration cap. Returns Float.fromInt(maxIter) for inside-set. Uses the cardioid + period-2 bulb pre-tests to short-circuit ~70% of inside-set points before any iteration runs. Sub-iter precision (Float vs Int) drives Bayer-dither palette lookup downstream."
     match insideCardioid(cx, cy)
-        true  -> Int.toFloat(maxIter)
+        true  -> Float.fromInt(maxIter)
         false -> escapeIterBulb(cx, cy, maxIter)
 
 verify escapeIter
-    escapeIter(0.0, 0.0, 50)        => Int.toFloat(50)
-    escapeIter(0.0 - 1.0, 0.0, 50)  => Int.toFloat(50)
+    escapeIter(0.0, 0.0, 50)        => Float.fromInt(50)
+    escapeIter(0.0 - 1.0, 0.0, 50)  => Float.fromInt(50)
 
 fn ditherThreshold(col: Int, row: Int) -> Float
     ? "4x4 ordered Bayer dither threshold for pixel (col, row). Standard recursive 4x4 Bayer matrix divided by 16 (centred so frac=0 never upgrades and frac=1 always upgrades). 16 distinct thresholds across a 4x4 block give 16-level fractional palette interpolation — fine enough that the dither pattern is barely visible at normal viewing distance while still smoothly bridging adjacent palette entries."
@@ -279,28 +279,28 @@ verify ditherThreshold
 
 fn paletteIdx(nu: Float, col: Int, row: Int, maxIter: Int) -> Int
     ? "Maps a continuous escape-time `nu` to a palette index 0..15 with 2x2 ordered-Bayer dither. Inside-set (nu >= maxIter) → 0 (deep navy). Escaped pixels: `n = floor(nu)`, `frac = nu - n`. Compare `frac` against the position-dependent dither threshold; if greater, show the next palette entry, else the current one. The result is that fractional `nu` translates into per-cell choice between two adjacent palette entries, breaking up integer iso-band stepping into smooth 2x2 transitions."
-    match nu >= Int.toFloat(maxIter)
+    match nu >= Float.fromInt(maxIter)
         true  -> 0
-        false -> match (nu - Int.toFloat(Float.floor(nu))) > ditherThreshold(col, row)
+        false -> match (nu - Float.fromInt(Float.floor(nu))) > ditherThreshold(col, row)
             true  -> Result.withDefault(Int.mod(Float.floor(nu) + 1, 30), 0) + 1
             false -> Result.withDefault(Int.mod(Float.floor(nu), 30), 0) + 1
 
 verify paletteIdx
-    paletteIdx(Int.toFloat(50), 0, 0, 50) => 0
+    paletteIdx(Float.fromInt(50), 0, 0, 50) => 0
     paletteIdx(0.0, 0, 0, 50)  => 1
     paletteIdx(29.0, 0, 0, 50) => 30
     paletteIdx(30.0, 0, 0, 50) => 1
 
 fn pixelCx(pixCol: Int, pixelsW: Int, view: View) -> Float
     ? "Pixel column → Mandelbrot cx coordinate."
-    Int.toFloat(pixCol) / Int.toFloat(pixelsW) * view.cxRange + view.cxMin
+    Float.fromInt(pixCol) / Float.fromInt(pixelsW) * view.cxRange + view.cxMin
 
 verify pixelCx
     pixelCx(0, 1, fullView()) => 0.0 - 2.0
 
 fn pixelCy(pixRow: Int, pixelsH: Int, view: View) -> Float
     ? "Pixel row → Mandelbrot cy coordinate."
-    Int.toFloat(pixRow) / Int.toFloat(pixelsH) * view.cyRange + view.cyMin
+    Float.fromInt(pixRow) / Float.fromInt(pixelsH) * view.cyRange + view.cyMin
 
 verify pixelCy
     pixelCy(0, 1, fullView()) => 0.0 - 1.5
diff --git a/tools/website/llms.txt b/tools/website/llms.txt
index e002ddf2..3db11b4e 100644
--- a/tools/website/llms.txt
+++ b/tools/website/llms.txt
@@ -104,7 +104,7 @@ Compound:
 Notes:
 - top-level named functions can be passed where `Fn(...)` is expected
 - there are no lambdas and no closures
-- no implicit type promotion; use `Int.toFloat` / `Float.fromInt`
+- no implicit type promotion; use `Float.fromInt` / `Float.fromInt`
 
 ### User-defined types
 
@@ -136,7 +136,7 @@ Rules:
 
 ```aver
 match value
-    Result.Ok(v) -> Int.toString(v)
+    Result.Ok(v) -> String.fromInt(v)
     Result.Err(e) -> e
 ```
 
@@ -309,8 +309,8 @@ Common pure namespaces:
 Key `String` API:
 - `String.len`, `String.contains`, `String.startsWith`, `String.endsWith`
 - `String.toUpper`, `String.toLower`, `String.trim`
-- `String.concat`, `String.join`, `String.split`, `String.chars`
-- `Int.fromString : String -> Result<Int, String>`, `Int.toString : Int -> String`
+- `String.join`, `String.split`, `String.chars` — concat is the `+` operator
+- `Int.fromString : String -> Result<Int, String>`, `String.fromInt : Int -> String`
 - string interpolation: `"Hello, {name}!"` is the idiomatic concat
 
 Key `List` API (small, recursion-first):
diff --git a/tools/website/playground/sources/examples/games/checkers/main.av b/tools/website/playground/sources/examples/games/checkers/main.av
index d36b5e0d..73794513 100644
--- a/tools/website/playground/sources/examples/games/checkers/main.av
+++ b/tools/website/playground/sources/examples/games/checkers/main.av
@@ -210,11 +210,11 @@ fn renderAiPanel(result: AiResult) -> Unit
     ! [Terminal.moveTo, Terminal.print, Terminal.resetColor, Terminal.setColor]
     Terminal.moveTo(22, 1)
     Terminal.setColor("cyan")
-    Terminal.print("AI depth={Int.toString(result.depth)} {Int.toString(result.thinkMs)}ms")
+    Terminal.print("AI depth={String.fromInt(result.depth)} {String.fromInt(result.thinkMs)}ms")
     Terminal.resetColor()
     Terminal.moveTo(22, 2)
     Terminal.setColor("yellow")
-    Terminal.print("root-parallel x{Int.toString(Ai.rootParallelWidth())} | {Int.toString(List.len(result.candidates))} moves")
+    Terminal.print("root-parallel x{String.fromInt(Ai.rootParallelWidth())} | {String.fromInt(List.len(result.candidates))} moves")
     Terminal.resetColor()
     renderCandidates(result.candidates, result.move, 0)
 
@@ -242,7 +242,7 @@ fn renderChosenCandidate(sm: ScoredMove, i: Int) -> Unit
     Terminal.setColor("green")
     Terminal.print("★ ")
     Terminal.print(moveLabel(sm.move))
-    Terminal.print("  {Int.toString(sm.score)}")
+    Terminal.print("  {String.fromInt(sm.score)}")
     Terminal.resetColor()
 
 fn renderOtherCandidate(sm: ScoredMove, i: Int) -> Unit
@@ -250,7 +250,7 @@ fn renderOtherCandidate(sm: ScoredMove, i: Int) -> Unit
     ! [Terminal.print]
     Terminal.print("  ")
     Terminal.print(moveLabel(sm.move))
-    Terminal.print("  {Int.toString(sm.score)}")
+    Terminal.print("  {String.fromInt(sm.score)}")
 
 fn isChosenMove(a: List<Point>, b: List<Point>) -> Bool
     ? "True if two moves are the same (compare first and last points)"
@@ -295,7 +295,7 @@ fn moveLabel(move: List<Point>) -> String
     ? "Human-readable label for a move path"
     match firstPoint(move)
         Option.Some(from) -> match lastPoint(move)
-            Option.Some(to) -> "{colChar(from.x)}{Int.toString(8 - from.y)}→{colChar(to.x)}{Int.toString(8 - to.y)}"
+            Option.Some(to) -> "{colChar(from.x)}{String.fromInt(8 - from.y)}→{colChar(to.x)}{String.fromInt(8 - to.y)}"
             Option.None -> "?"
         Option.None -> "?"
 
@@ -307,7 +307,7 @@ fn renderHelp(state: GameState) -> Unit
     ! [Terminal.moveTo, Terminal.print, Terminal.resetColor, Terminal.setColor]
     Terminal.moveTo(0, 14)
     Terminal.setColor("green")
-    Terminal.print(" You (black) vs AI (white) · depth {Int.toString(state.searchDepth)} · +/- to change")
+    Terminal.print(" You (black) vs AI (white) · depth {String.fromInt(state.searchDepth)} · +/- to change")
     Terminal.resetColor()
     Terminal.moveTo(0, 15)
     match state.selected
@@ -415,7 +415,7 @@ fn aiPhase(state: GameState) -> Result<String, String>
     ]
     renderFrame(state)
     Terminal.moveTo(0, 14)
-    Terminal.print("AI thinking (depth {Int.toString(state.searchDepth)}, root-parallel x{Int.toString(Ai.rootParallelWidth())})...")
+    Terminal.print("AI thinking (depth {String.fromInt(state.searchDepth)}, root-parallel x{String.fromInt(Ai.rootParallelWidth())})...")
     Terminal.flush()
     t0 = Time.unixMs()
     aiState = handleAiTurn(state)
@@ -443,7 +443,7 @@ fn gameOverResult(state: GameState) -> Result<String, String>
     Terminal.print("Game over!")
     Terminal.flush()
     Time.sleep(2000)
-    Result.Ok("Game over! Move {Int.toString(state.moveNum)}")
+    Result.Ok("Game over! Move {String.fromInt(state.moveNum)}")
 
 fn gameTurn(state: GameState) -> Result<String, String>
     ? "Dispatch to player or AI"
diff --git a/tools/website/playground/sources/examples/games/checkers/render.av b/tools/website/playground/sources/examples/games/checkers/render.av
index 5e3e472f..f0145779 100644
--- a/tools/website/playground/sources/examples/games/checkers/render.av
+++ b/tools/website/playground/sources/examples/games/checkers/render.av
@@ -240,7 +240,7 @@ fn renderRowLabelsNext(r: Int) -> Unit
 
 fn rowLabel(r: Int) -> String
     ? "Row label: row 0 = 8, row 7 = 1"
-    Int.toString(8 - r)
+    String.fromInt(8 - r)
 
 verify rowLabel
     rowLabel(0) => "8"
@@ -281,7 +281,7 @@ fn renderStatus(currentPlayer: Color, moveNum: Int) -> Unit
     Terminal.setColor(playerColor(currentPlayer))
     Terminal.print("{colorName(currentPlayer)}")
     Terminal.resetColor()
-    Terminal.print(" to move  |  Move #{Int.toString(moveNum)}")
+    Terminal.print(" to move  |  Move #{String.fromInt(moveNum)}")
 
 fn renderAiTrace(move: List<Point>, score: Int, alternatives: Int, depth: Int) -> Unit
     ? "Show AI decision trace"
@@ -290,4 +290,4 @@ fn renderAiTrace(move: List<Point>, score: Int, alternatives: Int, depth: Int) -
     Terminal.setColor("cyan")
     Terminal.print("AI: ")
     Terminal.resetColor()
-    Terminal.print("score={Int.toString(score)} alts={Int.toString(alternatives)} depth={Int.toString(depth)}")
+    Terminal.print("score={String.fromInt(score)} alts={String.fromInt(alternatives)} depth={String.fromInt(depth)}")
diff --git a/tools/website/playground/sources/examples/games/doom/enemy.av b/tools/website/playground/sources/examples/games/doom/enemy.av
index 670ab64e..e99d3f5e 100644
--- a/tools/website/playground/sources/examples/games/doom/enemy.av
+++ b/tools/website/playground/sources/examples/games/doom/enemy.av
@@ -49,8 +49,8 @@ fn ghostTeleport(enemy: Enemy, seed: Int, levelMap: List<String>) -> Enemy
     ? "Teleport ghost to a random nearby floor tile"
     s1 = Rng.nextSeed(seed)
     s2 = Rng.nextSeed(s1)
-    dx = Int.toFloat(Rng.seedToRange(s1, 0 - 4, 4))
-    dy = Int.toFloat(Rng.seedToRange(s2, 0 - 4, 4))
+    dx = Float.fromInt(Rng.seedToRange(s1, 0 - 4, 4))
+    dy = Float.fromInt(Rng.seedToRange(s2, 0 - 4, 4))
     nx = enemy.x + dx
     ny = enemy.y + dy
     match Level.isWall(levelMap, Float.floor(nx), Float.floor(ny))
@@ -251,7 +251,7 @@ fn applyShotVec(enemies: Vector<Enemy>, idx: Int) -> (List<Enemy>, String)
     ? "Apply 5 damage to enemy at index using indexed vector access"
     match Vector.get(enemies, idx)
         Option.Some(e) -> applyDamageToEnemyVec(enemies, idx, e)
-        Option.None -> (Vector.toList(enemies), "Shot missed!")
+        Option.None -> (List.fromVector(enemies), "Shot missed!")
 
 verify applyShotVec
     applyShotVec(Vector.fromList([]), 0) => ([], "Shot missed!")
@@ -268,7 +268,7 @@ fn applyDamageToEnemyVec(enemies: Vector<Enemy>, idx: Int, e: Enemy) -> (List<En
     newHp = e.hp - 5
     match newHp < 1
         true -> (removeEnemyVec(enemies, idx, 0, []), "Killed {Types.enemyGlyph(e.kind)}!")
-        false -> (replaceEnemyVec(enemies, idx, Enemy.update(e, hp = newHp), 0, []), "Hit {Types.enemyGlyph(e.kind)}! ({Int.toString(newHp)} HP)")
+        false -> (replaceEnemyVec(enemies, idx, Enemy.update(e, hp = newHp), 0, []), "Hit {Types.enemyGlyph(e.kind)}! ({String.fromInt(newHp)} HP)")
 
 verify applyDamageToEnemyVec
     applyDamageToEnemyVec(Vector.fromList([Types.mkEnemy(1.0, 1.0, EnemyKind.Imp, 3)]), 0, Types.mkEnemy(1.0, 1.0, EnemyKind.Imp, 3)) => ([], "Killed !!")
diff --git a/tools/website/playground/sources/examples/games/doom/level.av b/tools/website/playground/sources/examples/games/doom/level.av
index e83b0e4b..7c72e3d1 100644
--- a/tools/website/playground/sources/examples/games/doom/level.av
+++ b/tools/website/playground/sources/examples/games/doom/level.av
@@ -280,7 +280,7 @@ verify roomFromSeed
 
 fn roomCenter(room: Room) -> (Float, Float)
     ? "Center of a room as float coordinates"
-    (Int.toFloat(room.x + room.w / 2) + 0.5, Int.toFloat(room.y + room.h / 2) + 0.5)
+    (Float.fromInt(room.x + room.w / 2) + 0.5, Float.fromInt(room.y + room.h / 2) + 0.5)
 
 verify roomCenter
     roomCenter(Room(x = 4, y = 4, w = 6, h = 6)) => (7.5, 7.5)
diff --git a/tools/website/playground/sources/examples/games/doom/main.av b/tools/website/playground/sources/examples/games/doom/main.av
index 089bcf05..836b8aba 100644
--- a/tools/website/playground/sources/examples/games/doom/main.av
+++ b/tools/website/playground/sources/examples/games/doom/main.av
@@ -33,8 +33,8 @@ verify turnSpeed
 fn spawnInRoom(room: Level.Room, seed: Int) -> Enemy
     ? "Spawn an enemy at the center of a room"
     kind = pickKind(seed)
-    cx = Int.toFloat(room.x + room.w / 2) + 0.5
-    cy = Int.toFloat(room.y + room.h / 2) + 0.5
+    cx = Float.fromInt(room.x + room.w / 2) + 0.5
+    cy = Float.fromInt(room.y + room.h / 2) + 0.5
     Types.mkEnemy(cx, cy, kind, Types.enemyMaxHp(kind))
 
 verify spawnInRoom
@@ -214,7 +214,7 @@ fn updateTurn(state: GameState) -> GameState
     msgs = match isOver
         true -> ["You died!"]
         false -> match damaged.hp < state.player.hp
-            true -> List.concat(state.messages, ["Ouch! HP: {Int.toString(damaged.hp)}"])
+            true -> List.concat(state.messages, ["Ouch! HP: {String.fromInt(damaged.hp)}"])
             false -> state.messages
     trimmedMsgs = trimMessages(msgs)
     GameState.update(state, enemies = newEnemies, player = damaged, turnCount = state.turnCount + 1, gameOver = isOver, messages = trimmedMsgs)
diff --git a/tools/website/playground/sources/examples/games/doom/math.av b/tools/website/playground/sources/examples/games/doom/math.av
index 9b89add2..15f90514 100644
--- a/tools/website/playground/sources/examples/games/doom/math.av
+++ b/tools/website/playground/sources/examples/games/doom/math.av
@@ -29,7 +29,7 @@ verify radToDeg
 fn normalizeAngle(a: Float) -> Float
     ? "Wrap angle to [0, 2*pi)"
     twoPi = Float.pi() * 2.0
-    rem = a - Int.toFloat(Float.floor(a / twoPi)) * twoPi
+    rem = a - Float.fromInt(Float.floor(a / twoPi)) * twoPi
     match rem < 0.0
         true -> rem + twoPi
         false -> rem
diff --git a/tools/website/playground/sources/examples/games/doom/render.av b/tools/website/playground/sources/examples/games/doom/render.av
index 823002fc..1123b5ea 100644
--- a/tools/website/playground/sources/examples/games/doom/render.av
+++ b/tools/website/playground/sources/examples/games/doom/render.av
@@ -134,7 +134,7 @@ fn wallHeight(distance: Float) -> Int
     ? "Pixel height of the wall strip for a given corrected distance"
     match distance < 0.1
         true -> pixelH()
-        false -> Math.clampInt(Float.floor(Int.toFloat(pixelH()) / distance), 0, pixelH())
+        false -> Math.clampInt(Float.floor(Float.fromInt(pixelH()) / distance), 0, pixelH())
 
 verify wallHeight
     wallHeight(1.0) => 80
@@ -282,7 +282,7 @@ verify buildZBuffer
 
 fn buildZBufferCol(levelMap: List<String>, wallMap: List<String>, px: Float, py: Float, angle: Float, col: Int, acc: List<RayHit>) -> List<RayHit>
     ? "Cast one ray and append to buffer"
-    rayAngle = angle - fov() / 2.0 + Int.toFloat(col) * fov() / Int.toFloat(screenW())
+    rayAngle = angle - fov() / 2.0 + Float.fromInt(col) * fov() / Float.fromInt(screenW())
     hit = castRay(levelMap, wallMap, px, py, rayAngle)
     corrected = RayHit.update(hit, dist = hit.dist * Float.cos(rayAngle - angle))
     buildZBuffer(levelMap, wallMap, px, py, angle, col + 1, List.concat(acc, [corrected]))
@@ -375,7 +375,7 @@ fn renderEnemySprite(enemies: Vector<Enemy>, zbuf: Vector<RayHit>, px: Float, py
     eDist = Math.dist(px, py, e.x, e.y)
     eAngle = Float.atan2(dy, dx)
     relAngle = Math.normalizeAngle(eAngle - pAngle + Float.pi()) - Float.pi()
-    screenCol = Float.floor(Int.toFloat(screenW()) / 2.0 + relAngle * Int.toFloat(screenW()) / fov())
+    screenCol = Float.floor(Float.fromInt(screenW()) / 2.0 + relAngle * Float.fromInt(screenW()) / fov())
     match isEnemyVisibleVec(screenCol, eDist, zbuf)
         true -> drawEnemyChar(e, screenCol, eDist, enemies, zbuf, px, py, pAngle, i)
         false -> renderEnemiesVec(enemies, zbuf, px, py, pAngle, i + 1)
@@ -409,8 +409,8 @@ verify isEnemyVisibleVec
 fn drawEnemyChar(e: Enemy, screenCol: Int, eDist: Float, enemies: Vector<Enemy>, zbuf: Vector<RayHit>, px: Float, py: Float, pAngle: Float, i: Int) -> Unit
     ? "Draw enemy using solid Unicode block characters"
     ! [Terminal.flush, Terminal.moveTo, Terminal.print, Terminal.resetColor, Terminal.setColor]
-    spriteH = Math.clampInt(Float.floor(2.5 / eDist * Int.toFloat(screenH())), 1, 10)
-    spriteW = Math.clampInt(Float.floor(5.0 / eDist * Int.toFloat(screenW()) / 10.0), 3, 13)
+    spriteH = Math.clampInt(Float.floor(2.5 / eDist * Float.fromInt(screenH())), 1, 10)
+    spriteW = Math.clampInt(Float.floor(5.0 / eDist * Float.fromInt(screenW()) / 10.0), 3, 13)
     topRow = screenH() / 2 - spriteH / 2
     leftCol = screenCol - spriteW / 2
     drawBlockGrid(e, leftCol, topRow, spriteH, spriteW, 0, 0)
@@ -463,9 +463,9 @@ verify fullBlock
 
 fn isInsideShape(kind: EnemyKind, col: Int, row: Int, spriteW: Int, spriteH: Int) -> Bool
     ? "Check if (col, row) is inside the enemy silhouette"
-    halfW = Int.toFloat(spriteW) / 2.0
-    cx = Float.abs(Int.toFloat(col) - halfW + 0.5) / halfW
-    cy = Int.toFloat(row) / Int.toFloat(spriteH)
+    halfW = Float.fromInt(spriteW) / 2.0
+    cx = Float.abs(Float.fromInt(col) - halfW + 0.5) / halfW
+    cy = Float.fromInt(row) / Float.fromInt(spriteH)
     maxW = shapeWidth(kind, cy)
     cx < maxW
 
@@ -557,13 +557,13 @@ fn renderHud(state: GameState) -> Unit
     Terminal.print("BRAILLE DOOM")
     Terminal.setColor("red")
     Terminal.moveTo(hudX, 3)
-    Terminal.print("HP: {Int.toString(state.player.hp)}/100")
+    Terminal.print("HP: {String.fromInt(state.player.hp)}/100")
     Terminal.setColor("white")
     Terminal.moveTo(hudX, 4)
     deg = Float.floor(Math.radToDeg(state.player.angle))
-    Terminal.print("angle: {Int.toString(deg)}")
+    Terminal.print("angle: {String.fromInt(deg)}")
     Terminal.moveTo(hudX, 5)
-    Terminal.print("enemies: {Int.toString(List.len(state.enemies))}")
+    Terminal.print("enemies: {String.fromInt(List.len(state.enemies))}")
     Terminal.setColor("cyan")
     Terminal.moveTo(hudX, 7)
     Terminal.print("W/S  forward/back")
diff --git a/tools/website/playground/sources/examples/games/doom/rng.av b/tools/website/playground/sources/examples/games/doom/rng.av
index ca76be06..52312e63 100644
--- a/tools/website/playground/sources/examples/games/doom/rng.av
+++ b/tools/website/playground/sources/examples/games/doom/rng.av
@@ -38,7 +38,7 @@ verify advanceSeed
 
 fn randomFloat(s: Int) -> Float
     ? "Map seed to [0.0, 1.0)"
-    Int.toFloat(Result.withDefault(Int.mod(Int.abs(s), 10000), 0)) / 10000.0
+    Float.fromInt(Result.withDefault(Int.mod(Int.abs(s), 10000), 0)) / 10000.0
 
 verify randomFloat
     randomFloat(0) => 0.0
diff --git a/tools/website/playground/sources/examples/games/life.av b/tools/website/playground/sources/examples/games/life.av
index b5488dec..cf25411e 100644
--- a/tools/website/playground/sources/examples/games/life.av
+++ b/tools/website/playground/sources/examples/games/life.av
@@ -301,7 +301,7 @@ fn drawOneRow(grid: Vector<Int>, s: Int, w: Int, h: Int, row: Int) -> Unit
 fn drawHud(st: SimState, mode: String) -> Unit
     ? "Draw two-line HUD: status on line 0, controls on line 1."
     ! [Terminal.moveTo, Terminal.print, Terminal.resetColor, Terminal.setColor]
-    genStr = Int.toString(st.gen)
+    genStr = String.fromInt(st.gen)
     Terminal.setColor("green")
     Terminal.moveTo(0, 0)
     line1 = match mode == "edit"
@@ -310,7 +310,7 @@ fn drawHud(st: SimState, mode: String) -> Unit
             true -> " PAUSED  Gen:{genStr}                                               "
             false -> match st.delay == 0
                 true -> " {st.fps.display}fps  Gen:{genStr}  BENCHMARK                       "
-                false -> " {st.fps.display}fps  Gen:{genStr}  {Int.toString(st.delay)}ms                            "
+                false -> " {st.fps.display}fps  Gen:{genStr}  {String.fromInt(st.delay)}ms                            "
     Terminal.print(line1)
     Terminal.moveTo(0, 1)
     Terminal.setColor("cyan")
@@ -327,7 +327,7 @@ fn formatFps(frames: Int, elapsed: Int) -> String
     tenths = frames * 10000 / elapsed
     whole = tenths / 10
     frac = Result.withDefault(Int.mod(tenths, 10), 0)
-    Int.toString(whole) + "." + Int.toString(frac)
+    String.fromInt(whole) + "." + String.fromInt(frac)
 
 verify formatFps
     formatFps(2, 1000) => "2.0"
@@ -452,7 +452,7 @@ fn simAction(k: String, st: SimState) -> Result<String, String>
         true -> 0
         false -> 1
     match k
-        "q" -> Result.Ok("Stopped at generation {Int.toString(st.gen)}.")
+        "q" -> Result.Ok("Stopped at generation {String.fromInt(st.gen)}.")
         " " -> gameLoop(SimState.update(st, paused = newPaused))
         "e" -> simToEditor(st)
         "+" -> gameLoop(SimState.update(st, delay = Int.max(st.delay - 10, 0)))
@@ -470,7 +470,7 @@ fn simToEditor(st: SimState) -> Result<String, String>
     result = editorLoop(st.grid, st.stride, st.width, st.height, st.width / 2, st.height / 2)
     match result
         Result.Ok(newGrid) -> gameLoop(SimState.update(st, grid = newGrid, gen = 0))
-        Result.Err(_) -> Result.Ok("Stopped at generation {Int.toString(st.gen)}.")
+        Result.Err(_) -> Result.Ok("Stopped at generation {String.fromInt(st.gen)}.")
 
 // ─── Entry ──────────────────────────────────────────────────
 
diff --git a/tools/website/playground/sources/examples/games/rogue/main.av b/tools/website/playground/sources/examples/games/rogue/main.av
index 565b39dd..07b7cbed 100644
--- a/tools/website/playground/sources/examples/games/rogue/main.av
+++ b/tools/website/playground/sources/examples/games/rogue/main.av
@@ -354,7 +354,7 @@ fn resolveAttack(state: GameState, target: Entity, idx: Int) -> GameState
     hit = Combat.applyDamageToEntity(target, dmg)
     match Combat.isEntityDead(hit)
         true -> killEntity(state, target, idx, dmg)
-        false -> alertNearby(addMessage(GameState.update(state, entities = Combat.replaceEntity(state.entities, idx, hit, 0)), "You hit {target.name} for {Int.toString(dmg)}!"), state.player.pos, 12, 0)
+        false -> alertNearby(addMessage(GameState.update(state, entities = Combat.replaceEntity(state.entities, idx, hit, 0)), "You hit {target.name} for {String.fromInt(dmg)}!"), state.player.pos, 12, 0)
 
 fn killEntity(state: GameState, target: Entity, idx: Int, dmg: Int) -> GameState
     ? "Kill entity — for-loop gets one respawn (off-by-one error)"
@@ -373,7 +373,7 @@ fn loopRespawn(state: GameState, target: Entity, idx: Int) -> GameState
 fn actualKill(state: GameState, target: Entity, idx: Int) -> GameState
     ? "Actually remove entity and gain exp"
     newPlayer = Combat.gainExp(state.player, Combat.expForKill(target.kind))
-    addMessage(GameState.update(state, entities = Combat.removeAt(state.entities, idx, 0), player = newPlayer), "You defeated {target.name}! (+{Int.toString(Combat.expForKill(target.kind))} exp)")
+    addMessage(GameState.update(state, entities = Combat.removeAt(state.entities, idx, 0), player = newPlayer), "You defeated {target.name}! (+{String.fromInt(Combat.expForKill(target.kind))} exp)")
 
 verify actualKill
     List.len(actualKill(GameState(gameMap = [], player = Types.makePlayer(0, 0), entities = [Types.makeIfElse(1, 1)], items = [], visible = [], visGrid = [], remembered = [], messages = [], seed = 0, gameOver = false), Types.makeIfElse(1, 1), 0).entities) => 0
@@ -400,9 +400,9 @@ verify pickUpItem
 fn applyItem(state: GameState, item: Item, idx: Int) -> GameState
     ? "Apply item effect"
     match item.kind
-        ItemKind.PotionOfPurity -> addMessage(GameState.update(state, player = Combat.healPlayer(state.player, item.value), items = Combat.removeItemAt(state.items, idx, 0)), "You drink {item.name}. Purity restored! (+{Int.toString(item.value)} HP)")
-        ItemKind.ScrollOfPatternMatch -> addMessage(GameState.update(state, player = Player.update(state.player, attack = state.player.attack + item.value), items = Combat.removeItemAt(state.items, idx, 0)), "You read {item.name}. Your pattern matching grows stronger! (+{Int.toString(item.value)} ATK)")
-        ItemKind.ShieldOfImmutability -> addMessage(GameState.update(state, player = Player.update(state.player, defense = state.player.defense + item.value), items = Combat.removeItemAt(state.items, idx, 0)), "You equip {item.name}. Nothing can change you! (+{Int.toString(item.value)} DEF)")
+        ItemKind.PotionOfPurity -> addMessage(GameState.update(state, player = Combat.healPlayer(state.player, item.value), items = Combat.removeItemAt(state.items, idx, 0)), "You drink {item.name}. Purity restored! (+{String.fromInt(item.value)} HP)")
+        ItemKind.ScrollOfPatternMatch -> addMessage(GameState.update(state, player = Player.update(state.player, attack = state.player.attack + item.value), items = Combat.removeItemAt(state.items, idx, 0)), "You read {item.name}. Your pattern matching grows stronger! (+{String.fromInt(item.value)} ATK)")
+        ItemKind.ShieldOfImmutability -> addMessage(GameState.update(state, player = Player.update(state.player, defense = state.player.defense + item.value), items = Combat.removeItemAt(state.items, idx, 0)), "You equip {item.name}. Nothing can change you! (+{String.fromInt(item.value)} DEF)")
 
 verify applyItem
     applyItem(GameState(gameMap = [], player = Player.update(Types.makePlayer(0, 0), hp = 10), entities = [], items = [Types.makePurity(0, 0)], visible = [], visGrid = [], remembered = [], messages = [], seed = 0, gameOver = false), Types.makePurity(0, 0), 0).player.hp => 18
@@ -533,8 +533,8 @@ fn ifElseAttack(state: GameState, entity: Entity, i: Int) -> GameState
     match Combat.isPlayerDead(newPlayer)
         true -> addMessage(GameState.update(state, player = newPlayer, gameOver = true), "{entity.name} branch-predicts your death!")
         false -> match doubled == 1
-            true -> addMessage(GameState.update(state, player = newPlayer), "{entity.name} takes BOTH branches! {Int.toString(totalDmg)} dmg!")
-            false -> addMessage(GameState.update(state, player = newPlayer), "{entity.name} hits you for {Int.toString(dmg)}.")
+            true -> addMessage(GameState.update(state, player = newPlayer), "{entity.name} takes BOTH branches! {String.fromInt(totalDmg)} dmg!")
+            false -> addMessage(GameState.update(state, player = newPlayer), "{entity.name} hits you for {String.fromInt(dmg)}.")
 
 fn loopAttack(state: GameState, entity: Entity, i: Int) -> GameState
     ? "for-loop: normal attack but respawns once when killed (off-by-one)"
@@ -542,7 +542,7 @@ fn loopAttack(state: GameState, entity: Entity, i: Int) -> GameState
     newPlayer = Combat.applyDamageToPlayer(state.player, dmg)
     match Combat.isPlayerDead(newPlayer)
         true -> addMessage(GameState.update(state, player = newPlayer, gameOver = true), "{entity.name} iterates you to death!")
-        false -> addMessage(GameState.update(state, player = newPlayer), "{entity.name} iterates on you for {Int.toString(dmg)}!")
+        false -> addMessage(GameState.update(state, player = newPlayer), "{entity.name} iterates on you for {String.fromInt(dmg)}!")
 
 verify loopAttack
     loopAttack(GameState(gameMap = [], player = Types.makePlayer(0, 0), entities = [Types.makeLoop(1, 0)], items = [], visible = [], visGrid = [], remembered = [], messages = [], seed = 0, gameOver = false), Types.makeLoop(1, 0), 0).player.hp < 20 => true
@@ -551,7 +551,7 @@ fn nullAttack(state: GameState, entity: Entity, i: Int) -> GameState
     ? "null: steals EXP instead of dealing HP damage (null dereference — wipes memory)"
     stolen = Int.max(1, state.player.exp / 4)
     newPlayer = Player.update(state.player, exp = Int.max(0, state.player.exp - stolen))
-    addMessage(GameState.update(state, player = newPlayer), "{entity.name} dereferences your memory! -{Int.toString(stolen)} EXP!")
+    addMessage(GameState.update(state, player = newPlayer), "{entity.name} dereferences your memory! -{String.fromInt(stolen)} EXP!")
 
 verify nullAttack
     nullAttack(GameState(gameMap = [], player = Player.update(Types.makePlayer(0, 0), exp = 40), entities = [Types.makeNull(1, 0)], items = [], visible = [], visGrid = [], remembered = [], messages = [], seed = 0, gameOver = false), Types.makeNull(1, 0), 0).player.exp => 30
@@ -655,7 +655,7 @@ fn descend(state: GameState) -> GameState
     itms = spawnItems(newSeed, rooms, 0)
     vis = Fov.computeFov(newMap, Types.pt(px, py), 8)
     rem = markRemembered(emptyRemembered(0), vis, 0)
-    addMessage(GameState(gameMap = newMap, player = newPlayer, entities = ents, items = itms, visible = vis, visGrid = buildVisGrid(vis, emptyRemembered(0), 0), remembered = rem, messages = state.messages, seed = Map.nextSeed(newSeed), gameOver = false), "You descend to floor {Int.toString(newFloor)} of Non-Aver!")
+    addMessage(GameState(gameMap = newMap, player = newPlayer, entities = ents, items = itms, visible = vis, visGrid = buildVisGrid(vis, emptyRemembered(0), 0), remembered = rem, messages = state.messages, seed = Map.nextSeed(newSeed), gameOver = false), "You descend to floor {String.fromInt(newFloor)} of Non-Aver!")
 
 verify descend
     descend(initGame(42)).player.floor => 2
@@ -715,7 +715,7 @@ fn gameLoop(state: GameState) -> Result<String, String>
     ]
     renderFrame(state)
     match state.gameOver
-        true -> Result.Ok("Game over on floor {Int.toString(state.player.floor)}. EXP: {Int.toString(state.player.exp)}. The Aver way prevails!")
+        true -> Result.Ok("Game over on floor {String.fromInt(state.player.floor)}. EXP: {String.fromInt(state.player.exp)}. The Aver way prevails!")
         false -> waitAndProcess(state)
 
 fn waitAndProcess(state: GameState) -> Result<String, String>
diff --git a/tools/website/playground/sources/examples/games/snake.av b/tools/website/playground/sources/examples/games/snake.av
index e10a086b..c169a9b0 100644
--- a/tools/website/playground/sources/examples/games/snake.av
+++ b/tools/website/playground/sources/examples/games/snake.av
@@ -274,7 +274,7 @@ fn render(state: GameState) -> Unit
     drawAt(state.food.x, state.food.y, "██")
     Terminal.resetColor()
     Terminal.moveTo(0, state.height)
-    Terminal.print("Score: {Int.toString(state.score)}  |  Q / ESC to quit")
+    Terminal.print("Score: {String.fromInt(state.score)}  |  Q / ESC to quit")
     Terminal.flush()
 
 fn handleKey(state: GameState, k: String) -> GameState
@@ -304,7 +304,7 @@ fn tick(state: GameState) -> Result<String, String>
         Time.sleep,
     ]
     match state.gameOver
-        true -> Result.Ok("Game over! Score: {Int.toString(state.score)}")
+        true -> Result.Ok("Game over! Score: {String.fromInt(state.score)}")
         false -> tickMove(moveSnake(state))
 
 fn tickMove(moved: GameState) -> Result<String, String>
@@ -315,7 +315,7 @@ fn tickMove(moved: GameState) -> Result<String, String>
         Time.sleep,
     ]
     match checkCollision(moved)
-        true -> Result.Ok("Game over! Score: {Int.toString(moved.score)}")
+        true -> Result.Ok("Game over! Score: {String.fromInt(moved.score)}")
         false -> match didEatFood(moved)
             true -> gameLoop(growSnake(randomFood(moved)))
             false -> gameLoop(moved)
diff --git a/tools/website/playground/sources/examples/games/tetris/main.av b/tools/website/playground/sources/examples/games/tetris/main.av
index 41172ebb..db30b14f 100644
--- a/tools/website/playground/sources/examples/games/tetris/main.av
+++ b/tools/website/playground/sources/examples/games/tetris/main.av
@@ -127,11 +127,11 @@ fn renderInfo(state: GameState) -> Unit
     ? "Draw score, level, lines info"
     ! [Terminal.moveTo, Terminal.print]
     Terminal.moveTo(26, 2)
-    Terminal.print("Score: {Int.toString(state.score)}")
+    Terminal.print("Score: {String.fromInt(state.score)}")
     Terminal.moveTo(26, 4)
-    Terminal.print("Level: {Int.toString(state.level)}")
+    Terminal.print("Level: {String.fromInt(state.level)}")
     Terminal.moveTo(26, 6)
-    Terminal.print("Lines: {Int.toString(state.lines)}")
+    Terminal.print("Lines: {String.fromInt(state.lines)}")
     Terminal.moveTo(26, 10)
     Terminal.print("Controls:")
     Terminal.moveTo(26, 11)
@@ -204,7 +204,7 @@ fn tick(state: GameState) -> Result<String, String>
         Time.sleep,
     ]
     match state.gameOver
-        true -> Result.Ok("Game over! Score: {Int.toString(state.score)}  Lines: {Int.toString(state.lines)}")
+        true -> Result.Ok("Game over! Score: {String.fromInt(state.score)}  Lines: {String.fromInt(state.lines)}")
         false -> tickGravity(state)
 
 fn gameLoop(state: GameState) -> Result<String, String>
diff --git a/tools/website/playground/sources/examples/games/wumpus.av b/tools/website/playground/sources/examples/games/wumpus.av
index a1847be4..721c4638 100644
--- a/tools/website/playground/sources/examples/games/wumpus.av
+++ b/tools/website/playground/sources/examples/games/wumpus.av
@@ -48,7 +48,7 @@ verify validRoom
 
 fn roomListItem(r: Int, rest: List<Int>) -> String
     ? "Format a single room entry and recurse on remainder."
-    rs = Int.toString(r)
+    rs = String.fromInt(r)
     match rest
         [] -> rs
         _ -> "{rs}, {roomList(rest)}"
@@ -246,10 +246,10 @@ fn showRoom(game: Game) -> Unit
     ? "Display current room, tunnels, and hazard warnings."
     ! [Console.print]
     Console.print("")
-    Console.print("You are in room {Int.toString(game.player)}.")
+    Console.print("You are in room {String.fromInt(game.player)}.")
     Console.print("Tunnels lead to: {roomList(neighbors(game.player))}")
     Console.print(warningText(game))
-    Console.print("Arrows: {Int.toString(game.arrows)}")
+    Console.print("Arrows: {String.fromInt(game.arrows)}")
 
 fn gameLoop(game: Game) -> Result<String, String>
     ? "Main game loop — one turn per recursive call."
@@ -311,7 +311,7 @@ fn teleportAndCheck(game: Game) -> Result<String, String>
     ? "Bats carry you to a random room; check hazards there."
     ! [Console.print, Console.readLine, Random.int]
     dest = randRoom()
-    Console.print("Super bats carry you to room {Int.toString(dest)}!")
+    Console.print("Super bats carry you to room {String.fromInt(dest)}!")
     resolveRoomCheck(checkRoom(Game.update(game, player = dest)))
 
 fn retry(game: Game, msg: String) -> Result<String, String>
diff --git a/tools/website/playground/sources/examples/shapes.av b/tools/website/playground/sources/examples/shapes.av
index f3ad7b23..197efc5b 100644
--- a/tools/website/playground/sources/examples/shapes.av
+++ b/tools/website/playground/sources/examples/shapes.av
@@ -21,5 +21,5 @@ fn main() -> Unit
     ! [Console.print]
     c = Shape.Circle(5.0)
     r = Shape.Rectangle(3.0, 4.0)
-    Console.print("circle area = {Float.toString(area(c))}")
-    Console.print("rect area = {Float.toString(area(r))}")
+    Console.print("circle area = {String.fromFloat(area(c))}")
+    Console.print("rect area = {String.fromFloat(area(r))}")

From 5e3d21457a552785579088c7319a6dcea2501ef3 Mon Sep 17 00:00:00 2001
From: jasisz <jasisz@gmail.com>
Date: Wed, 6 May 2026 21:14:45 +0200
Subject: [PATCH 18/18] 0.17.0 "Purge" fix: dedup match arms after sed
 migration

The bulk sed-replace in [3+4/4] turned aliased arms like
`"Int.toFloat" | "Float.fromInt"` into duplicate `"Float.fromInt" |
"Float.fromInt"`, which clippy `-D warnings` flags as
unreachable_patterns. Same for `"Int.toString"` aliases collapsing
into duplicate `"String.fromInt"` entries. Plus an alias arm in
`wasm_gc/body/builtins.rs` that became identical to the main
`"Float.fromInt"` arm above it.

Hand-removed 7 duplicates across rust/wasm/wasm-gc/ir/vm match
ladders + 1 alias arm in body/builtins.rs. 621/621 lib tests, fmt
clean, clippy `-D warnings` clean.

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>
---
 src/codegen/rust/expr.rs             |  1 -
 src/codegen/wasm/alloc_policy.rs     |  1 -
 src/codegen/wasm_gc/body/builtins.rs | 18 +++---------------
 src/codegen/wasm_gc/types.rs         |  2 --
 src/ir/analyze.rs                    |  1 -
 src/types/int.rs                     |  1 -
 src/vm/alloc_policy.rs               |  1 -
 7 files changed, 3 insertions(+), 22 deletions(-)

diff --git a/src/codegen/rust/expr.rs b/src/codegen/rust/expr.rs
index dd6db347..6630c532 100644
--- a/src/codegen/rust/expr.rs
+++ b/src/codegen/rust/expr.rs
@@ -1086,7 +1086,6 @@ fn expr_is_numeric(expr: &Expr, ectx: &EmitCtx) -> bool {
                         | "Float.cos"
                         | "Float.atan2"
                         | "Float.fromInt"
-                        | "Float.fromInt"
                         | "List.len"
                         | "Vector.len"
                         | "Map.len"
diff --git a/src/codegen/wasm/alloc_policy.rs b/src/codegen/wasm/alloc_policy.rs
index d92540b2..866e31cf 100644
--- a/src/codegen/wasm/alloc_policy.rs
+++ b/src/codegen/wasm/alloc_policy.rs
@@ -60,7 +60,6 @@ fn is_pure_non_alloc_builtin(name: &str) -> bool {
             | "Float.pow"
             | "Float.atan2"
             | "Float.pi"
-            | "Float.fromInt"
             // Char ↔ code-point. `Char.fromCode` returns Option<String>
             // (allocates the Some wrapper around a heap String); only the
             // reverse direction is pure.
diff --git a/src/codegen/wasm_gc/body/builtins.rs b/src/codegen/wasm_gc/body/builtins.rs
index fca0e507..c97932e6 100644
--- a/src/codegen/wasm_gc/body/builtins.rs
+++ b/src/codegen/wasm_gc/body/builtins.rs
@@ -155,13 +155,6 @@ pub(super) fn emit_dotted_builtin(
             func.instruction(&Instruction::F64Const(std::f64::consts::PI));
             Ok(())
         }
-        // `Int.toFloat` is the same op as `Float.fromInt` — Aver has
-        // both spellings; map both to the same instruction.
-        "Float.fromInt" if args.len() == 1 => {
-            emit_expr(func, &args[0], slots, ctx)?;
-            func.instruction(&Instruction::F64ConvertI64S);
-            Ok(())
-        }
         "Int.abs" if args.len() == 1 => {
             // Branched: if (x < 0) 0 - x else x. Two evaluations of x;
             // cheap when x is a Resolved local.
@@ -295,14 +288,9 @@ pub(super) fn emit_dotted_builtin(
         // Int.toString / Float.toString — Aver source allows both,
         // backend points each at the same helper.
         "String.fromInt" if args.len() == 1 => {
-            let to_string_idx =
-                ctx.fn_map
-                    .builtins
-                    .get("String.fromInt")
-                    .copied()
-                    .ok_or(WasmGcError::Validation(
-                        "String.fromInt requires Int.toString builtin".into(),
-                    ))?;
+            let to_string_idx = ctx.fn_map.builtins.get("String.fromInt").copied().ok_or(
+                WasmGcError::Validation("String.fromInt requires Int.toString builtin".into()),
+            )?;
             emit_expr(func, &args[0], slots, ctx)?;
             func.instruction(&Instruction::Call(to_string_idx));
             Ok(())
diff --git a/src/codegen/wasm_gc/types.rs b/src/codegen/wasm_gc/types.rs
index a9dec7bb..685ff5db 100644
--- a/src/codegen/wasm_gc/types.rs
+++ b/src/codegen/wasm_gc/types.rs
@@ -1978,8 +1978,6 @@ fn expr_uses_string(expr: &crate::ast::Expr) -> bool {
                             | "String.replace"
                             | "String.split"
                             | "String.join"
-                            | "String.fromInt"
-                            | "String.fromFloat"
                             | "String.fromBool"
                             | "String.endsWith"
                             | "String.charAt"
diff --git a/src/ir/analyze.rs b/src/ir/analyze.rs
index 0d0d79ac..25979e6a 100644
--- a/src/ir/analyze.rs
+++ b/src/ir/analyze.rs
@@ -86,7 +86,6 @@ impl AllocPolicy for NeutralAllocPolicy {
                 | "Float.pow"
                 | "Float.atan2"
                 | "Float.pi"
-                | "Float.fromInt"
                 | "Char.toCode"
                 | "String.len"
                 | "String.byteLength"
diff --git a/src/types/int.rs b/src/types/int.rs
index e8140bc8..43fe379e 100644
--- a/src/types/int.rs
+++ b/src/types/int.rs
@@ -288,4 +288,3 @@ fn modulo_nv(args: &[NanValue], arena: &mut Arena) -> Result<NanValue, RuntimeEr
         Ok(NanValue::new_ok_value(inner, arena))
     }
 }
-
diff --git a/src/vm/alloc_policy.rs b/src/vm/alloc_policy.rs
index d8436552..4ffc79ba 100644
--- a/src/vm/alloc_policy.rs
+++ b/src/vm/alloc_policy.rs
@@ -45,7 +45,6 @@ fn is_pure_non_alloc_builtin(name: &str) -> bool {
             | "Float.pow"
             | "Float.atan2"
             | "Float.pi"
-            | "Float.fromInt"
             | "Char.toCode"
             | "String.len"
             | "String.byteLength"