feat(diag): report unknown types and fields in Xi terms; add web payload test

Extends the Xi-level diagnostics so more mistakes are caught before they reach
the C compiler and are worded against the source, not the generated C:

- constructing an unknown type — `Uzer { ... }` now reports
  `unknown type 'Uzer' — no type, event, or sum-type variant ...` instead of a
  cascading C `undeclared identifier` mess. A capitalized name before `{` in
  expression position is only ever a constructor, so this is unambiguous.
- unknown field in a constructor — `User { nam: ... }` reports
  `type 'User' has no field 'nam'`.
- reading an unknown field — `u.aeg` reports the same.

Field presence is tested by name against the declared field set (hasFieldC),
not the field's resolved xtype, so a valid field whose type is a sum type (which
resolves to "") is never mis-flagged — this was the one false positive found on
machine_phase_demo and is now covered. All checks are gated to declared compound
types and verified to have zero false positives across every example.

Also adds examples/web/web_payload_test.xi: a server-free test of the web
controller payload path (res.send / req.parse) — it binds JsonTransport and
round-trips a DTO through WebTransport over the auto-derived JSON codecs.

Author: code-by-sia

compiler/impl/codegen/expr.xi

@@ -27,6 +27,11 @@ mapper genTypeLiteral(toks: Token[], pos: Integer, ctx: GCtx) -> ExprRes {
     let first = true
     while toks.kindAt(p) != 103 and toks.kindAt(p) != 0 {
         let fname = toks.textAt(p)
+        // A field name the type doesn't declare is a typo — report it in Xi terms
+        // rather than emitting a C `field designator does not refer to any field`.
+        if (ctx.prog).isCompoundTypeC(typeName) and not (ctx.prog).hasFieldC(typeName, fname) {
+            diag_error(tokenArrGet(toks, p).line, "type '" + typeName + "' has no field '" + fname + "'")
+        }
         p = p + 1
         if toks.kindAt(p) == 108 { p = p + 1 }
         let e = genExpr(toks, p, ctx)
@@ -520,6 +525,14 @@ mapper genPrimary(toks: Token[], pos: Integer, ctx: GCtx) -> ExprRes {
                 diag_error(tokenArrGet(toks, pos).line, txt + "." + toks.textAt(pos + 2) + "(...) — the '" + txt + "' namespace isn't imported; add:  import \"" + nsImp + "\"")
             }
         }
+        // Constructor `Name { ... }` for a name that resolves to nothing: neither a
+        // sum-type variant (488) nor a type/event/class (492) matched, and it's not
+        // a local. A capitalized name before `{` in expression position is only ever
+        // a constructor, so report the unknown type in Xi terms instead of letting
+        // the bare name leak out as a cryptic C `undeclared identifier` cascade.
+        if toks.kindAt(pos + 1) == 102 and txt.startsUpper() and string_len(ctx.lookupVar(txt)) == 0 {
+            diag_error(tokenArrGet(toks, pos).line, "unknown type '" + txt + "' — no type, event, or sum-type variant with that name is declared or imported")
+        }
         return ExprRes { code: txt, pos: pos + 1, xtyp: ctx.lookupVar(txt) , owned: false }
     }
     return ExprRes { code: txt, pos: pos + 1, xtyp: "" , owned: false }

compiler/impl/codegen/postfix.xi

@@ -486,6 +486,14 @@ mapper genPostfix(toks: Token[], pos: Integer, ctx: GCtx) -> ExprRes {
                             typ = "Integer"
                         } else {
                             let ft = (ctx.prog).fieldTypeNameC(typ, fld)
+                            // Field access on a declared compound type whose field
+                            // set is fixed: a name that is not a declared field is a
+                            // typo. Report it in Xi terms instead of leaking a C
+                            // `no member named`. (Test name presence, not ft — a
+                            // valid field of sum-type resolves ft to "".)
+                            if (ctx.prog).isCompoundTypeC(typ) and not (ctx.prog).hasFieldC(typ, fld) {
+                                diag_error(tokenArrGet(toks, p + 1).line, "type '" + typ + "' has no field '" + fld + "'")
+                            }
                             code = code + "." + fld
                             typ = ft
                         }

compiler/impl/codegen/program_query.xi

@@ -245,6 +245,32 @@ mapper Program.fieldCheckFn(typeName: String, field: String) -> String {
     return ""
 }
 
+// Does the declared compound type `typeName` have a field literally named
+// `field`? Tests name presence only — unlike fieldTypeNameC, it does not depend
+// on the field's type resolving to a non-empty xtype (a field of sum-type or
+// otherwise unresolvable type still counts), so it is a sound basis for the
+// "type has no field" diagnostic.
+predicate Program.hasFieldC(typeName: String, field: String) {
+    if field == "ok" or field == "err" or field == "value" { return true }
+    let i = 0
+    let n = typeSpecLen(this.types)
+    while i < n {
+        let ts = typeSpecGet(this.types, i)
+        if ts.name == typeName {
+            let fi = 0
+            let fn2 = stringArrLen(ts.fields)
+            while fi < fn2 {
+                let fentry = stringArrGet(ts.fields, fi)
+                let colon = findChar(fentry, 58)
+                if string_slice(fentry, 0, colon) == field { return true }
+                fi = fi + 1
+            }
+        }
+        i = i + 1
+    }
+    return false
+}
+
 mapper Program.fieldTypeNameC(typeName: String, field: String) -> String {
     // Result<T> fields: .ok is Bool, .err is String, .value is T.
     if field == "ok"  { return "Bool" }

compiler/impl/strings.xi

@@ -18,6 +18,14 @@ predicate String.endsWith2(suffix: String) {
     return string_slice(this, n - sl, n) == suffix
 }
 
+// Does the name start with an ASCII uppercase letter? Type / event / variant
+// names are Capitalized by convention, so this gates type-shaped diagnostics.
+predicate String.startsUpper() {
+    if string_len(this) == 0 { return false }
+    let c = string_char_at(this, 0)
+    return c >= 65 and c <= 90
+}
+
 // Membership test over a String[] — `names.includes(x)`. Lets a long run of
 // `if x == "a" { return true } ...` collapse to a single set-style query.
 predicate String[].includes(s: String) {

docs/internals.md

@@ -113,6 +113,26 @@ not the transient `.gen.c` — and correctly across imports, so an error inside
 imported helper points at that helper. Directives are deduped and deterministic,
 so the self-hosting fixpoint is unaffected.
 
+### Semantic diagnostics (Xi errors, not C errors)
+
+Beyond `#line`, codegen catches the most common mistakes *before* they reach the
+C compiler and reports them in Xi terms at the source line. Each check is placed
+where a name legitimately fails to resolve and is gated so it never fires on
+valid code (verified: zero false positives across every example):
+
+| Mistake | Message |
+| --- | --- |
+| call to an un-imported std function | `int_to_string(...) is defined in std/convert.xi — add: import "std/convert.xi"` |
+| use of an un-imported std namespace | `json.foo(...) — the 'json' namespace isn't imported; add: import "std/json.xi"` |
+| constructing an unknown type | `unknown type 'Uzer' — no type, event, or sum-type variant with that name is declared or imported` |
+| unknown field in a constructor | `type 'User' has no field 'nam'` |
+| reading an unknown field | `type 'User' has no field 'aeg'` |
+
+The field checks test name presence against the type's declared field set
+(`hasFieldC`), not the field's resolved type, so a valid field of sum-type is
+never mis-flagged. Anything not caught here still compiles to C and, if it
+fails, is reported against the Xi source via `#line`.
+
 ## What runs at runtime
 
 DI resolution, overload dispatch tables, and refined-type layout are decided at

examples/web/web_payload_test.xi

@@ -0,0 +1,41 @@
+// Feature: web controller payload (de)serialization.
+//
+// A controller replies with `res.send(dto)` and reads a typed body with
+// `req.parse(T)`. Both route the payload through the DI-resolved `WebTransport`
+// over the compiler's auto-derived JSON codecs (`dto as Json` / `json as T`).
+// This test exercises that exact path without standing up a server: bind the
+// default `JsonTransport`, then serialize a DTO to the wire and parse it back.
+import "std/web.xi"
+
+// The kind of payload a controller sends back (res.send) ...
+event  Created = { id: Integer, name: String, active: Bool }
+// ... and the kind it accepts in a request body (req.parse).
+type   NewUser = { name: String, age: Integer }
+
+module WebPayload { bind WebTransport -> JsonTransport as singleton }
+
+test "serialize a controller response payload (res.send path)" {
+    let tx  = WebPayload.resolve(WebTransport)
+    let dto = Created { id: 7, name: "John Doe", active: true }
+    // res.send(dto) === transport.serialize(dto as Json)
+    let wire = tx.serialize(dto as Json)
+    assertEq(wire, "{\"id\":7,\"name\":\"John Doe\",\"active\":true}")
+}
+
+test "deserialize a request body payload (req.parse path)" {
+    let tx   = WebPayload.resolve(WebTransport)
+    let body = "{\"name\":\"John Doe\",\"age\":44}"
+    // req.parse(NewUser) === transport.deserialize(body) as NewUser
+    let u = (tx.deserialize(body)) as NewUser
+    assertEq(u.name, "John Doe")
+    assertEq(u.age, 44)
+}
+
+test "round-trip a payload through the transport" {
+    let tx   = WebPayload.resolve(WebTransport)
+    let sent = Created { id: 3, name: "Ada", active: false }
+    let back = (tx.deserialize(tx.serialize(sent as Json))) as Created
+    assertEq(back.id, 3)
+    assertEq(back.name, "Ada")
+    assertEq(back.active, false)
+}