A channel's message slots are named from the client, on every backend

The IR called them react-message and django-message, so a FastAPI channel had
to declare a DjangoMessage. They are client-message and server-message now,
and the direction words hold wherever a channel is declared: Params /
ClientMessage / ServerMessage, with mizan-core deriving <Pascal>Params and
friends so no backend names a type itself. Django's ReactChannel and
FastAPI's ReactChannel are both Channel.

mizan-fastapi never registered a channels extension, so build_ir() emitted no
channel at all and every payload type was invisible to codegen. It registers
one now. RegistryExtension is an ABC requiring all(), which is what the IR
reads — an extension that cannot enumerate its registrations no longer exists.

The gate that should have caught the rename could not: tests/afi registered no
channel because mizan-rust had no channel registry to register one in, so a
five-package rename of the wire contract passed byte-parity without a channel
byte crossing it. mizan-rust grows ChannelSlotKind, a CHANNELS slice, a
#[mizan::channel] macro, and KDL emission whose wire_to_pascal matches Python's
split; the AFI fixture now carries a channel with every slot and one with a
single slot, so all three backends prove the contract byte for byte.

MizanChannel held three Option<String> beside three has_*() predicates and
unwrapped them with defaults; it holds an ordered slot vector, so an absent
slot is absent rather than defaulted. The channels target emitted a React
hooks file that a stage1-only consumer could not compile — react emits that
now. The codegen's parity tests byte-compared emitted source against baselines
without ever compiling it: they compile the generated crate and run its tests,
import the generated Python package and call every method, and typecheck each
TypeScript target against a consumer.

Also fixed at source: app_visitor printed its import diagnostic to stdout, the
stream export_mizan_ir writes KDL to, so a failed import silently corrupted the
IR; the apps root was hardcoded to "apps"; _default_literal crashed build_ir on
any non-JSON-serializable field default; Django and mizan-core derived Pascal
names two different ways, disagreeing on every dotted channel name.

ir.py builds a document and renders templates/ir/document.kdl.j2 rather than
appending KDL strings with hand-tracked indentation, and named types resolve to
a fixed point — a model reachable only through a union branch was referenced by
a ref that no type block ever defined.

The rest is the write-gate's own classifiers run over the standing tree:
relative imports, silent swallows, Protocol contracts that should be ABCs,
emitters hand-rendering target source, catch-all arms over closed enums, and
comments narrating the project rather than the code.

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>

protocol/mizan-codegen/tests/ir_deserialization.rs

@@ -1,15 +1,11 @@
-//! IR deserialization tests against the AFI fixture (KDL).
-//!
-//! The fixture is captured from `cores/mizan-python/src/mizan_core/ir.py::build_ir()`
-//! against `tests/afi/fixture.py`. Each test exercises a different facet
-//! of the IR — function set, per-function field decoding, context-param
-//! elevation, and named-type presence — to confirm the typed Rust structs
-//! match the KDL shape the backend emits.
+//! Decodes the AFI fixture into the typed IR structs. Each test reads back a
+//! different facet of the KDL — the function set, per-function field decoding,
+//! context-param elevation, and the named-type table.
 
 use std::path::PathBuf;
 
 use mizan_codegen::fetch::parse_ir_from_str;
-use mizan_codegen::ir::{AffectKind, IsContext, NamedType, Primitive, Transport};
+use mizan_codegen::ir::{AffectKind, CallInput, IsContext, Primitive, Transport};
 
 
 fn load_fixture() -> mizan_codegen::ir::MizanIR {
@@ -43,15 +39,14 @@ fn afi_fixture_function_field_decode() {
     let ir = load_fixture();
     let echo = ir.functions.iter().find(|f| f.name == "echo").unwrap();
     assert_eq!(echo.camel_name, "echo");
-    assert!(echo.has_input);
-    assert_eq!(echo.input_type.as_deref(), Some("echoInput"));
+    assert_eq!(echo.input, CallInput::Typed("echoInput".to_string()));
     assert_eq!(echo.output_type, "echoOutput");
     assert!(!echo.output_nullable);
     assert_eq!(echo.transport, Transport::Http);
     assert_eq!(echo.is_context, IsContext::No);
 
     let whoami = ir.functions.iter().find(|f| f.name == "whoami").unwrap();
-    assert!(!whoami.has_input);
+    assert_eq!(whoami.input, CallInput::Absent);
 
     // `find_user` returns `ProfileOutput | None` — outputNullable must be true.
     let find_user = ir.functions.iter().find(|f| f.name == "find_user").unwrap();
@@ -73,6 +68,38 @@ fn afi_fixture_function_field_decode() {
 }
 
 
+/// `has-input` and `input` are two spellings of one fact; a document that
+/// spells them against each other is rejected at the KDL crossing rather than
+/// silently reaching a target as a no-argument call.
+#[test]
+fn contradictory_input_spellings_are_rejected() {
+    let declared_without_flag = r#"
+function "echo" {
+    camel "echo"
+    has-input #false
+    input "echoInput"
+    output "echoOutput"
+}
+"#;
+    let err = parse_ir_from_str(declared_without_flag)
+        .expect_err("`input` with `has-input #false` must not parse")
+        .to_string();
+    assert!(err.contains("echoInput"), "fault must name the declared input type: {err}");
+
+    let flag_without_type = r#"
+function "echo" {
+    camel "echo"
+    has-input #true
+    output "echoOutput"
+}
+"#;
+    let err = parse_ir_from_str(flag_without_type)
+        .expect_err("`has-input #true` with no `input` must not parse")
+        .to_string();
+    assert!(err.contains("has-input"), "fault must name `has-input`: {err}");
+}
+
+
 #[test]
 fn afi_fixture_context_param_elevation() {
     let ir = load_fixture();
@@ -90,9 +117,8 @@ fn afi_fixture_context_param_elevation() {
 #[test]
 fn afi_fixture_named_types_present() {
     let ir = load_fixture();
-    // Every IR function references its <camelName>Input / <camelName>Output
-    // type by name; the IR's `type` section must declare each as a named
-    // type (struct, alias to a list, etc.).
+    // Every function names its `<camelName>Input` / `<camelName>Output` type,
+    // so the IR's type table must declare each one.
     for expected in [
         "echoInput", "echoOutput",
         "whoamiOutput",
@@ -102,12 +128,6 @@ fn afi_fixture_named_types_present() {
         "findUserInput", "findUserOutput",
         "renameUserInput", "renameUserOutput",
     ] {
-        let ty = ir.types.get(expected)
-            .unwrap_or_else(|| panic!("missing type {expected:?}"));
-        // Each named type is one of the four KDL shapes — sanity-check
-        // we round-tripped a non-trivial declaration.
-        match ty {
-            NamedType::Struct(_) | NamedType::List(_) | NamedType::Enum(_) | NamedType::Alias(_) => {}
-        }
+        assert!(ir.types.contains_key(expected), "missing type {expected:?}");
     }
 }