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>

cores/mizan-rust/tests/afi_parity.rs

@@ -1,11 +1,8 @@
-//! Byte-equivalence: the Rust KDL emitter (driven by the proc macros)
-//! against `protocol/mizan-codegen/tests/fixtures/afi_ir.kdl` (canonical
-//! Python-emitted reference).
-//!
-//! This is the Phase-2 verifier — the AFI fixture is authored against the
-//! real consumer surface (`#[derive(Mizan)] / #[mizan::context] /
-//! #[mizan::client]`), not hand-built static specs.
+//! `build_ir()` renders the proc-macro-populated registries; the emitted KDL
+//! is parsed by the `kdl` crate and then compared byte for byte with
+//! `protocol/mizan-codegen/tests/fixtures/afi_ir.kdl`.
 
+use kdl::{KdlDocument, KdlNode};
 use mizan_core as mizan;
 use mizan_core::prelude::*;
 use mizan_core::RequestHandle;
@@ -46,7 +43,17 @@ pub struct StatusOutput {
 #[mizan::context("user")]
 pub struct UserCtx;
 
-// ─── Fixture functions (mirroring tests/afi/fixture.py) ────────────────────
+// ─── Fixture handlers ───────────────────────────────────────────────────────
+
+/// `(order id, owning user id, total)` — the store the order handlers read.
+const ORDERS: &[(i64, i64, i64)] = &[(10, 1, 4200), (11, 1, 1750), (12, 2, 990)];
+
+fn profile_of(user_id: i64) -> ProfileOutput {
+    ProfileOutput {
+        user_id,
+        name: format!("user-{user_id}"),
+    }
+}
 
 #[mizan::client]
 pub async fn echo(_req: &RequestHandle<'_>, text: String) -> EchoOutput {
@@ -65,29 +72,39 @@ pub async fn whoami(_req: &RequestHandle<'_>) -> WhoamiOutput {
 
 #[mizan::client(context = UserCtx)]
 pub async fn user_profile(_req: &RequestHandle<'_>, user_id: i64) -> ProfileOutput {
-    ProfileOutput {
-        user_id,
-        name: "placeholder".into(),
-    }
+    profile_of(user_id)
 }
 
 #[mizan::client(context = UserCtx)]
-pub async fn user_orders(_req: &RequestHandle<'_>, _user_id: i64) -> Vec<OrderOutput> {
-    vec![]
+pub async fn user_orders(_req: &RequestHandle<'_>, user_id: i64) -> Vec<OrderOutput> {
+    ORDERS
+        .iter()
+        .filter(|(_, owner, _)| *owner == user_id)
+        .map(|(id, owner, total)| OrderOutput {
+            id: *id,
+            user_id: *owner,
+            total: *total,
+        })
+        .collect()
 }
 
 #[mizan::client(affects = UserCtx)]
 pub async fn update_profile(
     _req: &RequestHandle<'_>,
-    _user_id: i64,
-    _name: String,
+    user_id: i64,
+    name: String,
 ) -> StatusOutput {
-    StatusOutput { ok: true }
+    StatusOutput {
+        ok: user_id > 0 && !name.trim().is_empty(),
+    }
 }
 
 #[mizan::client]
-pub async fn find_user(_req: &RequestHandle<'_>, _user_id: i64) -> Option<ProfileOutput> {
-    None
+pub async fn find_user(_req: &RequestHandle<'_>, user_id: i64) -> Option<ProfileOutput> {
+    ORDERS
+        .iter()
+        .any(|(_, owner, _)| *owner == user_id)
+        .then(|| profile_of(user_id))
 }
 
 #[mizan::client(merge = UserCtx)]
@@ -99,20 +116,96 @@ pub async fn rename_user(
     ProfileOutput { user_id, name }
 }
 
-// ─── The byte-equivalence test ──────────────────────────────────────────────
+// ─── Reading the parsed document ────────────────────────────────────────────
 
 fn canonical_kdl_path() -> PathBuf {
     PathBuf::from(env!("CARGO_MANIFEST_DIR"))
         .join("../../protocol/mizan-codegen/tests/fixtures/afi_ir.kdl")
 }
 
+/// The node's first string argument, or the empty string when it has none.
+fn label(node: &KdlNode) -> String {
+    for entry in node.entries() {
+        if let Some(s) = entry.value().as_string() {
+            return s.to_string();
+        }
+    }
+    String::new()
+}
+
+/// `(node name, first string argument)` for every node at one level.
+fn index(nodes: &[KdlNode]) -> Vec<(String, String)> {
+    nodes
+        .iter()
+        .map(|node| (node.name().value().to_string(), label(node)))
+        .collect()
+}
+
+/// The child nodes of the first `kind "name"` node in `doc`, or an empty slice
+/// when the document has no such node or it carries no child block.
+fn children_of<'a>(doc: &'a KdlDocument, kind: &str, name: &str) -> &'a [KdlNode] {
+    for node in doc.nodes() {
+        if node.name().value() == kind && label(node) == name {
+            return match node.children() {
+                Some(block) => block.nodes(),
+                None => &[],
+            };
+        }
+    }
+    &[]
+}
+
 #[test]
 fn build_ir_matches_canonical_afi_kdl() {
-    let expected = std::fs::read_to_string(canonical_kdl_path()).expect("read canonical KDL");
-    let actual = mizan_core::build_ir();
+    let emitted = mizan_core::build_ir();
 
-    if actual != expected {
-        for (lineno, (a, b)) in actual.lines().zip(expected.lines()).enumerate() {
+    // Parsing before comparing means a malformed emission fails here rather
+    // than as a confusing textual diff.
+    let parsed: KdlDocument = emitted
+        .parse()
+        .expect("build_ir() output is a well-formed KDL document");
+    let top = index(parsed.nodes());
+
+    assert!(
+        top.contains(&("function".to_string(), "user_orders".to_string())),
+        "parsed document is missing the user_orders function node: {top:?}",
+    );
+    assert!(
+        top.contains(&("context".to_string(), "user".to_string())),
+        "parsed document is missing the user context node: {top:?}",
+    );
+    assert_eq!(
+        index(children_of(&parsed, "function", "user_orders")),
+        vec![
+            ("camel".to_string(), "userOrders".to_string()),
+            ("has-input".to_string(), String::new()),
+            ("input".to_string(), "userOrdersInput".to_string()),
+            ("output".to_string(), "userOrdersOutput".to_string()),
+            ("transport".to_string(), "http".to_string()),
+            ("context".to_string(), "user".to_string()),
+        ],
+    );
+    assert_eq!(
+        index(children_of(&parsed, "context", "user")),
+        vec![
+            ("function".to_string(), "user_orders".to_string()),
+            ("function".to_string(), "user_profile".to_string()),
+            ("param".to_string(), "user_id".to_string()),
+        ],
+    );
+
+    let expected = std::fs::read_to_string(canonical_kdl_path()).expect("read canonical KDL");
+    let canonical: KdlDocument = expected
+        .parse()
+        .expect("the canonical fixture is a well-formed KDL document");
+    assert_eq!(
+        index(parsed.nodes()),
+        index(canonical.nodes()),
+        "emitted and canonical documents declare different top-level nodes",
+    );
+
+    if emitted != expected {
+        for (lineno, (a, b)) in emitted.lines().zip(expected.lines()).enumerate() {
             if a != b {
                 panic!(
                     "KDL diverges at line {}:\n  expected: {b:?}\n  actual:   {a:?}",
@@ -122,7 +215,7 @@ fn build_ir_matches_canonical_afi_kdl() {
         }
         panic!(
             "KDL diverges in length: actual_len={} expected_len={}",
-            actual.len(),
+            emitted.len(),
             expected.len(),
         );
     }

cores/mizan-rust/tests/merge_defects.rs

@@ -0,0 +1,68 @@
+//! `verify_invariants()` over a graph where one `merge` declaration matches
+//! two members of the context it names and another matches none.
+
+use mizan_core as mizan;
+use mizan_core::graph_check::verify_invariants;
+use mizan_core::prelude::*;
+use mizan_core::RequestHandle;
+use serde::{Deserialize, Serialize};
+
+#[derive(Mizan, Serialize, Deserialize, Debug, Clone)]
+pub struct Profile {
+    pub user_id: i64,
+    pub name: String,
+}
+
+#[derive(Mizan, Serialize, Deserialize, Debug, Clone)]
+pub struct Status {
+    pub ok: bool,
+}
+
+#[mizan::context("user")]
+pub struct UserCtx;
+
+#[mizan::client(context = UserCtx)]
+pub async fn user_profile(_req: &RequestHandle<'_>, user_id: i64) -> Profile {
+    Profile {
+        user_id,
+        name: format!("user-{user_id}"),
+    }
+}
+
+/// Same output shape as `user_profile`.
+#[mizan::client(context = UserCtx)]
+pub async fn user_card(_req: &RequestHandle<'_>, user_id: i64) -> Profile {
+    Profile {
+        user_id,
+        name: format!("card-{user_id}"),
+    }
+}
+
+#[mizan::client(merge = UserCtx)]
+pub async fn rename_user(_req: &RequestHandle<'_>, user_id: i64, name: String) -> Profile {
+    Profile { user_id, name }
+}
+
+/// No member of `user` returns this shape.
+#[mizan::client(merge = UserCtx)]
+pub async fn mark_seen(_req: &RequestHandle<'_>, user_id: i64) -> Status {
+    Status { ok: user_id > 0 }
+}
+
+#[test]
+#[should_panic(expected = "Merge resolution needs exactly one match")]
+fn a_merge_matching_several_members_is_ambiguous() {
+    verify_invariants();
+}
+
+#[test]
+#[should_panic(expected = "user_card")]
+fn an_ambiguous_merge_names_every_candidate_member() {
+    verify_invariants();
+}
+
+#[test]
+#[should_panic(expected = "no member of that context has output type")]
+fn a_merge_matching_no_member_has_no_slot() {
+    verify_invariants();
+}

cores/mizan-rust/tests/merge_resolution.rs

@@ -0,0 +1,113 @@
+//! `compute_merges` over a graph registered through `#[derive(Mizan)]`,
+//! `#[mizan::context]` and `#[mizan::client]`.
+
+use mizan_core as mizan;
+use mizan_core::prelude::*;
+use mizan_core::{compute_merges, RequestHandle, FUNCTIONS};
+use serde::{Deserialize, Serialize};
+
+#[derive(Mizan, Serialize, Deserialize, Debug, Clone)]
+pub struct ProfileOutput {
+    pub user_id: i64,
+    pub name: String,
+}
+
+#[derive(Mizan, Serialize, Deserialize, Debug, Clone)]
+pub struct StatusOutput {
+    pub ok: bool,
+}
+
+#[mizan::context("user")]
+pub struct UserCtx;
+
+#[mizan::client(context = UserCtx)]
+pub async fn user_profile(_req: &RequestHandle<'_>, user_id: i64) -> ProfileOutput {
+    ProfileOutput {
+        user_id,
+        name: format!("user-{user_id}"),
+    }
+}
+
+#[mizan::client(merge = UserCtx)]
+pub async fn rename_user(
+    _req: &RequestHandle<'_>,
+    user_id: i64,
+    name: String,
+) -> ProfileOutput {
+    ProfileOutput { user_id, name }
+}
+
+#[mizan::client(affects = UserCtx)]
+pub async fn touch_user(_req: &RequestHandle<'_>, user_id: i64) -> StatusOutput {
+    StatusOutput { ok: user_id > 0 }
+}
+
+/// The handlers above register into `FUNCTIONS` inside this test binary, so a
+/// name they declare always lands.
+fn spec(name: &str) -> &'static dyn FunctionSpec {
+    for fn_spec in FUNCTIONS.iter().copied() {
+        if fn_spec.name() == name {
+            return fn_spec;
+        }
+    }
+    panic!("no registered function named `{name}`");
+}
+
+/// `user_id` is a declared param of the `user` context; `name` is not.
+fn args() -> serde_json::Map<String, serde_json::Value> {
+    let mut args = serde_json::Map::new();
+    args.insert("user_id".to_string(), serde_json::Value::from(7));
+    args.insert("name".to_string(), serde_json::Value::from("Renamed"));
+    args
+}
+
+fn renamed() -> serde_json::Value {
+    serde_json::json!({ "user_id": 7, "name": "Renamed" })
+}
+
+#[test]
+fn a_merge_declaration_resolves_to_the_context_member_sharing_its_output() {
+    let result = renamed();
+    let merges = compute_merges(spec("rename_user"), &args(), &result);
+    let [entry] = merges.as_slice() else {
+        panic!(
+            "rename_user declares one merge; got {} entries",
+            merges.len()
+        );
+    };
+    assert_eq!(entry.context, "user");
+    assert_eq!(entry.slot, "user_profile");
+    assert_eq!(entry.value, result);
+}
+
+#[test]
+fn a_merge_entry_is_scoped_by_the_contexts_declared_params_alone() {
+    let result = renamed();
+    let merges = compute_merges(spec("rename_user"), &args(), &result);
+    let [entry] = merges.as_slice() else {
+        panic!(
+            "rename_user declares one merge; got {} entries",
+            merges.len()
+        );
+    };
+    let mut expected = serde_json::Map::new();
+    expected.insert("user_id".to_string(), serde_json::Value::from(7));
+    assert_eq!(entry.params, Some(expected));
+}
+
+#[test]
+fn a_function_declaring_only_affects_produces_no_merge_entries() {
+    let result = serde_json::json!({ "ok": true });
+    assert!(compute_merges(spec("touch_user"), &args(), &result).is_empty());
+}
+
+#[test]
+fn merge_resolution_answers_identically_across_calls() {
+    let result = renamed();
+    let first = compute_merges(spec("rename_user"), &args(), &result);
+    let second = compute_merges(spec("rename_user"), &args(), &result);
+    let slots: Vec<&str> = first.iter().map(|e| e.slot.as_str()).collect();
+    let again: Vec<&str> = second.iter().map(|e| e.slot.as_str()).collect();
+    assert_eq!(slots, again);
+    assert_eq!(slots, vec!["user_profile"]);
+}