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/harness/mod.rs

@@ -0,0 +1,125 @@
+//! Plumbing shared by the per-target tests: emit a target onto a clean scratch
+//! root, drop the consumer fixtures beside it, and run the language toolchain
+//! over the result. A toolchain that cannot be located panics with the search
+//! it performed rather than letting the test pass without checking anything.
+
+use std::fs;
+use std::path::{Path, PathBuf};
+use std::process::Command;
+
+use mizan_codegen::config::Config;
+use mizan_codegen::emit::EmittedFile;
+use mizan_codegen::fetch::parse_ir_from_str;
+use mizan_codegen::ir::MizanIR;
+
+
+pub fn manifest_dir() -> PathBuf {
+    PathBuf::from(env!("CARGO_MANIFEST_DIR"))
+}
+
+
+pub fn load_ir(fixture: &str) -> MizanIR {
+    let path = manifest_dir().join("tests/fixtures").join(fixture);
+    let raw = fs::read_to_string(&path)
+        .unwrap_or_else(|e| panic!("read {}: {e}", path.display()));
+    parse_ir_from_str(&raw)
+        .unwrap_or_else(|e| panic!("parse {}: {e}", path.display()))
+}
+
+
+/// Emitters read the target list and write relative to `output`; the scratch
+/// root is the process working directory for every toolchain run, so `.` is
+/// the whole of the path configuration these tests need.
+pub fn config_for(target: &str) -> Config {
+    Config {
+        output: PathBuf::from("."),
+        targets: vec![target.to_string()],
+        ..Config::default()
+    }
+}
+
+
+/// Wipes and recreates `target/toolchain/<name>`. A failing run leaves its
+/// sources there for inspection; the next run clears them.
+pub fn scratch_root(name: &str) -> PathBuf {
+    let root = manifest_dir().join("target/toolchain").join(name);
+    if root.exists() {
+        fs::remove_dir_all(&root)
+            .unwrap_or_else(|e| panic!("clear {}: {e}", root.display()));
+    }
+    fs::create_dir_all(&root)
+        .unwrap_or_else(|e| panic!("create {}: {e}", root.display()));
+    root
+}
+
+
+pub fn write_emitted(root: &Path, files: &[EmittedFile]) {
+    assert!(!files.is_empty(), "target emitted no files");
+    for file in files {
+        write_file(&root.join(&file.rel_path), &file.content);
+    }
+}
+
+
+pub fn copy_fixture(rel: &str, dest: &Path) {
+    let src = manifest_dir().join("tests/fixtures/toolchain").join(rel);
+    let contents = fs::read_to_string(&src)
+        .unwrap_or_else(|e| panic!("read fixture {}: {e}", src.display()));
+    write_file(dest, &contents);
+}
+
+
+fn write_file(dest: &Path, contents: &str) {
+    let parent = match dest.parent() {
+        Some(dir) => dir,
+        None => Path::new("."),
+    };
+    fs::create_dir_all(parent)
+        .unwrap_or_else(|e| panic!("create {}: {e}", parent.display()));
+    fs::write(dest, contents)
+        .unwrap_or_else(|e| panic!("write {}: {e}", dest.display()));
+}
+
+
+pub fn resolve_on_path(program: &str) -> PathBuf {
+    let path_var = std::env::var("PATH")
+        .unwrap_or_else(|e| panic!("PATH must be readable to locate `{program}`: {e}"));
+    for dir in std::env::split_paths(&path_var) {
+        let candidate = dir.join(program);
+        if candidate.is_file() {
+            return candidate;
+        }
+    }
+    panic!(
+        "`{program}` is required to check the emitted client and is not on PATH:\n  {path_var}"
+    );
+}
+
+
+pub fn run_tool(
+    program: &Path,
+    args: &[&str],
+    cwd: &Path,
+    env: &[(&str, &Path)],
+    what: &str,
+) {
+    let mut command = Command::new(program);
+    command.args(args).current_dir(cwd);
+    for (key, value) in env {
+        command.env(key, value);
+    }
+
+    let output = command.output()
+        .unwrap_or_else(|e| panic!("spawn {}: {e}", program.display()));
+    if output.status.success() {
+        return;
+    }
+
+    let stdout = String::from_utf8_lossy(&output.stdout);
+    let stderr = String::from_utf8_lossy(&output.stderr);
+    panic!(
+        "{what} (exit {:?}); sources left at {}\n--- stdout ---\n{stdout}\n--- stderr ---\n{stderr}",
+        output.status.code(),
+        cwd.display(),
+    );
+}