fix(0126): array args bind []$T generic params; uninferrable type params diagnose at the call

extractTypeParam's slice arm only extracted from slice-typed args, so
first(a) with a : [3]s64 at first :: (xs: []$T) -> T left T unbound
and the mono body reached LLVM emission carrying the .unresolved
sentinel (panic). The arm now also extracts from array args via the
array's element type — mirroring the array→slice promotion concrete
slice params already perform; the existing arg coercion handles the
rest.

lowerGenericCall additionally diagnoses any still-uninferrable TYPE
param at the call site instead of monomorphizing unbound — the
deliberate string-at-[]$T gap used to hit the same sentinel panic and
now errors with a source-located message. Comptime value params
($N: u32) and ..$Ts packs bind through their own dispatch and stay
exempt.

Regressions: examples/0212-generics-array-arg-slice-param.sx (scalar /
u8 / struct elements + the slice spelling) and
examples/1168-diagnostics-generic-param-uninferrable.sx (string arg
diagnostic) — both failed pre-fix.

examples/0212-generics-array-arg-slice-param.sx

@@ -0,0 +1,41 @@
+// An ARRAY argument at a generic slice param (`xs: []$T`) binds T from
+// the array's element type — the same array→slice promotion concrete
+// slice params perform — for scalar and struct elements, with the
+// return-position `T` resolving to the element type. The slice
+// spelling keeps working unchanged.
+//
+// Regression (issue 0126): the binding extractor only accepted slice
+// args, so `first(a)` left T unbound and the monomorphized body
+// reached LLVM emission with the `.unresolved` sentinel (panic).
+
+#import "modules/std.sx";
+
+P :: struct { x: s64; y: s64; }
+
+first :: (xs: []$T) -> T {
+    return xs[0];
+}
+
+last :: (xs: []$T) -> T {
+    return xs[xs.len - 1];
+}
+
+main :: () -> s32 {
+    a : [3]s64 = ---;
+    a[0] = 7; a[1] = 8; a[2] = 9;
+    print("{}\n", first(a));
+    print("{}\n", last(a));
+
+    bs : [4]u8 = ---;
+    bs[0] = 5; bs[1] = 6; bs[2] = 7; bs[3] = 8;
+    print("{}\n", last(bs));
+
+    ps : [2]P = ---;
+    ps[0] = .{ x = 1, y = 2 };
+    ps[1] = .{ x = 3, y = 4 };
+    print("{}\n", first(ps).y);
+
+    s : []s64 = a;
+    print("{}\n", first(s));
+    return 0;
+}

examples/1168-diagnostics-generic-param-uninferrable.sx

@@ -0,0 +1,19 @@
+// A direct call to a generic fn whose arguments cannot bind a TYPE
+// param diagnoses at the call site instead of monomorphizing with the
+// param unbound. A `string` arg at a `[]$T` param is the canonical
+// uninferrable shape (string deliberately does not bind `[]$T`); it
+// used to stamp `.unresolved` through the body and PANIC the compiler
+// at LLVM emission via the sentinel tripwire.
+//
+// Regression (issue 0126, diagnostic half).
+
+#import "modules/std.sx";
+
+first :: (xs: []$T) -> T {
+    return xs[0];
+}
+
+main :: () -> s32 {
+    print("{}\n", first("abc"));
+    return 0;
+}

examples/expected/0212-generics-array-arg-slice-param.exit

@@ -0,0 +1 @@
+0

examples/expected/0212-generics-array-arg-slice-param.stderr

@@ -0,0 +1 @@
+

examples/expected/0212-generics-array-arg-slice-param.stdout

@@ -0,0 +1,5 @@
+7
+9
+8
+2
+7

examples/expected/1168-diagnostics-generic-param-uninferrable.exit

@@ -0,0 +1 @@
+1

examples/expected/1168-diagnostics-generic-param-uninferrable.stderr

@@ -0,0 +1,5 @@
+error: cannot infer generic type parameter 'T' for 'first' from this call's arguments
+  --> examples/1168-diagnostics-generic-param-uninferrable.sx:17:19
+   |
+17 |     print("{}\n", first("abc"));
+   |                   ^^^^^

examples/expected/1168-diagnostics-generic-param-uninferrable.stdout

@@ -0,0 +1 @@
+

issues/0126-array-arg-slice-generic-param-unbound.md

@@ -1,4 +1,23 @@
-# 0126 — array arg at a `[]$T` param leaves T unbound → LLVM emission panic
+# RESOLVED — 0126: array arg at a `[]$T` param leaves T unbound → LLVM emission panic
+
+> **RESOLVED** (2026-06-12). Root cause: `extractTypeParam`'s
+> `.slice_type_expr` arm (src/ir/lower/generic.zig) only extracted from
+> `.slice`-typed args, so an array arg left `T` unbound and
+> `monomorphizeFunction` stamped `.unresolved` through the body — no
+> diagnostic before the emitter's sentinel panic. Fix: (1) the arm also
+> extracts from `.array` args via the array's element type, mirroring
+> the array→slice promotion concrete slice params perform (the existing
+> coercion then handles the lowered arg); (2) `lowerGenericCall`
+> (src/ir/lower/call.zig) diagnoses any still-uninferrable TYPE param
+> at the call site ("cannot infer generic type parameter ...") instead
+> of monomorphizing unbound — covers the deliberate string-at-`[]$T`
+> gap, which used to hit the same panic. Comptime value params and
+> `..$Ts` packs stay exempt. Regression tests:
+> `examples/0212-generics-array-arg-slice-param.sx` (scalar/u8/struct
+> elements + slice spelling; panicked or mis-typed pre-fix) and
+> `examples/1168-diagnostics-generic-param-uninferrable.sx` (string
+> arg; panicked pre-fix). Gates: zig build test 426/426, suite 594/594,
+> distribution repo 14/14.
 
 ## Symptom
 

src/ir/lower/call.zig

@@ -1323,6 +1323,25 @@ pub fn lowerGenericCall(self: *Lowering, fd: *const ast.FnDecl, base_name: []con
     var bindings = self.genericResolver().buildTypeBindings(fd, call_node.args);
     defer bindings.deinit();
 
+    // An uninferrable TYPE param must diagnose here: monomorphizing with
+    // it unbound stamps `.unresolved` through the body and trips the
+    // emitter's sentinel panic instead of surfacing a source error.
+    // Comptime VALUE params (`$N: u32`) and `..$Ts` packs bind through
+    // their own dispatch and are exempt.
+    for (fd.type_params) |tp| {
+        if (tp.is_variadic) continue;
+        if (tp.constraint.data != .type_expr) continue;
+        const cname = tp.constraint.data.type_expr.name;
+        const is_type_param = std.mem.eql(u8, cname, "Type") or
+            self.program_index.protocol_decl_map.contains(cname) or
+            self.program_index.protocol_ast_map.contains(cname);
+        if (is_type_param and !bindings.contains(tp.name)) {
+            if (self.diagnostics) |d|
+                d.addFmt(.err, call_node.callee.span, "cannot infer generic type parameter '{s}' for '{s}' from this call's arguments", .{ tp.name, base_name });
+            return Ref.none;
+        }
+    }
+
     const types_passed_explicitly = call_node.args.len == fd.params.len;
     const mangled_name = self.genericResolver().mangleGenericName(base_name, fd, &bindings);
 

src/ir/lower/generic.zig

@@ -554,11 +554,15 @@ pub fn extractTypeParam(self: *Lowering, type_node: *const Node, arg_ty: TypeId,
         .type_expr => |te| if (std.mem.eql(u8, te.name, tp_name)) arg_ty else null,
         .identifier => |id| if (std.mem.eql(u8, id.name, tp_name)) arg_ty else null,
         .slice_type_expr => |st| blk: {
-            // arg_ty should be a slice → extract element type
+            // arg_ty should be a slice → extract element type. An array
+            // arg coerces to a slice at a `[]T` param (the same promotion
+            // concrete slice params perform), so it binds from its
+            // element type too (issue 0126).
             if (arg_ty.isBuiltin()) break :blk null;
             const info = self.module.types.get(arg_ty);
             break :blk switch (info) {
                 .slice => |s| self.extractTypeParam(st.element_type, s.element, tp_name),
+                .array => |a| self.extractTypeParam(st.element_type, a.element, tp_name),
                 else => null,
             };
         },