ir: fix tuple literal element widths (construction was garbage)

A tuple_init's element values must match its field types exactly — LLVM
`insertvalue` does no implicit conversion. An inferred `pair := (40, 2)`
lowered its elements under the enclosing fn's `target_type` (e.g. main's
s32 return), producing i32 values, while the field types were inferred
independently as s64. The {i64,i64} aggregate was filled with i32
constants, so reading any element back returned garbage (40 + 2^32) and
tuple equality was always false.

lowerTupleLiteral now lowers each element under its resolved field type
(the contextual target tuple's fields when present, else per-element
inference) and coerces to it, so value width always matches field width.
Assignment to a tuple-typed field/element now also propagates the target
tuple type. Adds examples/190-tuple-values.sx as a regression test and
examples/probes/tuple-baseline.sx as the Step 0.4 audit artifact.

examples/190-tuple-values.sx

@@ -0,0 +1,49 @@
+// Tuple values: construction, element access, struct-field storage,
+// return, and operators. Regression for the tuple-construction bug where
+// an inferred `:=` tuple literal lowered its element values under the
+// enclosing fn's (narrower) return `target_type`, mismatching the
+// independently-inferred s64 field types and yielding garbage on read.
+
+#import "modules/std.sx";
+
+Box :: struct { xs: (s32, s32); }
+
+swap :: (a: s64, b: s64) -> (s64, s64) { (b, a); }
+fst  :: (t: (s64, s64)) -> s64 { t.0; }
+
+main :: () -> s32 {
+    // Inferred positional tuple + numeric field access.
+    pair := (40, 2);
+    print("pair {} {}\n", pair.0, pair.1);
+
+    // Named tuple: named + numeric access.
+    named := (x: 10, y: 20);
+    print("named {} {} {}\n", named.x, named.0, named.1);
+
+    // Element into a typed local (access path, not just print).
+    a : s64 = pair.0;
+    b : s64 = pair.1;
+    print("locals {} {}\n", a, b);
+
+    // Tuple-typed struct field: store a tuple value, read both elements.
+    box : Box = ---;
+    box.xs = (7, 9);
+    print("field {} {}\n", box.xs.0, box.xs.1);
+
+    // Return a tuple from a function.
+    s := swap(1, 2);
+    print("ret {} {}\n", s.0, s.1);
+
+    // Pass a tuple by value.
+    print("pass {}\n", fst((11, 22)));
+
+    // Operators: equality, concatenation, repetition, membership, lex.
+    print("eq {}\n", (1, 2) == (1, 2));
+    c := (1, 2) + (3, 4);
+    print("concat {} {}\n", c.0, c.3);
+    r := (1, 2) * 3;
+    print("rep {} {}\n", r.0, r.5);
+    print("mem {}\n", 3 in (1, 2, 3));
+    print("lex {}\n", (1, 2) < (1, 3));
+    0;
+}

examples/probes/tuple-baseline.sx

@@ -0,0 +1,62 @@
+// Feature 1 / Step 0.4 — tuple baseline probe (gate for Decision 2:
+// "tuples are first-class for pack storage").
+//
+// This file is the audit artifact: it exercises every tuple operation the
+// canonical `Combined`/`map` body relies on, EXCEPT the two pack/tuple
+// projection+spread sugars that are themselves Feature 1 work (documented
+// as gaps at the bottom). Everything here RUNS today.
+//
+// Run:  ./zig-out/bin/sx run examples/probes/tuple-baseline.sx
+
+#import "modules/std.sx";
+
+Listenable :: struct { value: s64; }      // stand-in element struct
+Combined   :: struct { sources: (s32, s32); }  // tuple-typed field (Decision 2)
+
+swap :: (a: s64, b: s64) -> (s64, s64) { (b, a); }
+fst  :: (t: (s64, s64)) -> s64 { t.0; }
+
+main :: () -> s32 {
+    // ── Block A — primitives (WORKS) ───────────────────────────────
+    pair := (40, 2);                       // inferred positional
+    print("A.idx     {} {}\n", pair.0, pair.1);
+    named := (x: 10, y: 20);               // named + numeric access
+    print("A.named   {} {} {}\n", named.x, named.0, named.1);
+    one := (42,);                          // 1-tuple
+    print("A.one     {}\n", one.0);
+    a : s64 = pair.0;                      // element into typed local
+    print("A.local   {}\n", a);
+
+    // ── Block B — storage in a struct field (WORKS; core of Decision 2)
+    c : Combined = ---;
+    c.sources = (7, 9);                    // assign tuple value to field
+    print("B.field   {} {}\n", c.sources.0, c.sources.1);
+
+    // ── Block C — return / pass / operators (WORKS) ────────────────
+    s := swap(1, 2);
+    print("C.ret     {} {}\n", s.0, s.1);
+    print("C.pass    {}\n", fst((11, 22)));
+    print("C.eq      {}\n", (1, 2) == (1, 2));
+    cc := (1, 2) + (3, 4);
+    print("C.concat  {} {}\n", cc.0, cc.3);
+    print("C.mem     {}\n", 3 in (1, 2, 3));
+    0;
+}
+
+// ── GAPS (Feature 1 work — intentionally NOT exercised above) ──────
+//
+//   G1. Tuple field projection across elements:
+//         t := (Listenable.{value=1}, Listenable.{value=2});
+//         v := t.value;        // expected: (1, 2)   — Decision 3 "tuple.field"
+//       Today: `error: field 'value' not found on type 'tuple'`.
+//       Needed by canonical `self.sources.value`.
+//
+//   G2. Tuple spread into call args:
+//         p := (10, 20);
+//         add(..p);            // expected: add(10, 20) — Decision 3 "..tuple"
+//       Today: lowers to one `undef` arg → LLVM arity verification failure.
+//       Needed by canonical `mapper(..sources.value)` and `(..sources)`.
+//
+// Both are already scheduled: parsing in Phase 1.2 (PackExpansion node covers
+// `(..pack)` / `..pack.field`), sema in Phase 2.3 ("tuple-spread parallels").
+// No separate Feature 1.5 needed — see Step 0.4 triage in CHECKPOINT-LANG.md.

src/ir/lower.zig

@@ -1729,7 +1729,7 @@ pub const Lowering = struct {
             // unchanged into method-call arg slots (`resolveCallParamTypes` can't
             // override target_type per-arg).
             const needs_target = switch (asgn.value.data) {
-                .enum_literal, .struct_literal, .if_expr, .match_expr, .block, .unary_op, .binary_op => true,
+                .enum_literal, .struct_literal, .tuple_literal, .if_expr, .match_expr, .block, .unary_op, .binary_op => true,
                 .call => |vc| vc.callee.data == .enum_literal,
                 else => false,
             };
@@ -4548,11 +4548,35 @@ pub const Lowering = struct {
         defer name_ids.deinit(self.alloc);
         var has_names = false;
 
-        for (tl.elements) |elem| {
+        // A tuple_init's element values must match its field types exactly
-            const val = self.lowerExpr(elem.value);
+        // (LLVM `insertvalue` does no implicit conversion). When a contextual
+        // target tuple of matching arity is in scope (annotation, assignment
+        // LHS, call/return slot), its field types drive element lowering so an
+        // ambient scalar `target_type` (e.g. the enclosing fn's int return
+        // type) can't narrow an element below its field width. Otherwise each
+        // element's type is inferred independently.
+        var target_fields: ?[]const TypeId = null;
+        if (self.target_type) |tt| {
+            if (!tt.isBuiltin()) {
+                const tinfo = self.module.types.get(tt);
+                if (tinfo == .tuple and tinfo.tuple.fields.len == tl.elements.len) {
+                    target_fields = tinfo.tuple.fields;
+                }
+            }
+        }
+
+        const saved_target = self.target_type;
+        for (tl.elements, 0..) |elem, i| {
+            const field_ty = if (target_fields) |tf| tf[i] else self.inferExprType(elem.value);
+            self.target_type = field_ty;
+            var val = self.lowerExpr(elem.value);
+            self.target_type = saved_target;
+            const val_ty = self.builder.getRefType(val);
+            if (val_ty != field_ty and val_ty != .void) {
+                val = self.coerceToType(val, val_ty, field_ty);
+            }
             elems.append(self.alloc, val) catch unreachable;
-            const ety = self.inferExprType(elem.value);
+            field_type_ids.append(self.alloc, field_ty) catch unreachable;
-            field_type_ids.append(self.alloc, ety) catch unreachable;
             if (elem.name) |name| {
                 name_ids.append(self.alloc, self.module.types.internString(name)) catch unreachable;
                 has_names = true;
@@ -4561,11 +4585,16 @@ pub const Lowering = struct {
             }
         }
 
-        // Create a tuple type
+        // Reuse the contextual target tuple type when it drove lowering so the
-        const tuple_ty = self.module.types.intern(.{ .tuple = .{
+        // value's type identity (incl. field names) matches the destination
-            .fields = self.alloc.dupe(TypeId, field_type_ids.items) catch unreachable,
+        // slot; otherwise build the tuple type from the inferred fields.
-            .names = if (has_names) self.alloc.dupe(types.StringId, name_ids.items) catch unreachable else null,
+        const tuple_ty = if (target_fields != null and self.target_type != null)
-        } });
+            self.target_type.?
+        else
+            self.module.types.intern(.{ .tuple = .{
+                .fields = self.alloc.dupe(TypeId, field_type_ids.items) catch unreachable,
+                .names = if (has_names) self.alloc.dupe(types.StringId, name_ids.items) catch unreachable else null,
+            } });
 
         const owned = self.alloc.dupe(Ref, elems.items) catch unreachable;
         return self.builder.emit(.{ .tuple_init = .{ .fields = owned } }, tuple_ty);

tests/expected/190-tuple-values.exit

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

tests/expected/190-tuple-values.txt

@@ -0,0 +1,11 @@
+pair 40 2
+named 10 10 20
+locals 40 2
+field 7 9
+ret 2 1
+pass 11
+eq true
+concat 1 4
+rep 1 2
+mem true
+lex true