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/fixtures/toolchain/channels-tsconfig.json

@@ -0,0 +1,13 @@
+{
+    "compilerOptions": {
+        "strict": true,
+        "noEmit": true,
+        "target": "ES2020",
+        "module": "ESNext",
+        "moduleResolution": "Node",
+        "jsx": "preserve",
+        "skipLibCheck": true,
+        "types": []
+    },
+    "files": ["shims/mizan-channels.d.ts", "channels.ts", "channels.hooks.tsx"]
+}

protocol/mizan-codegen/tests/fixtures/toolchain/drivers/react.tsx

@@ -0,0 +1,59 @@
+import {
+    MizanContext,
+    UserContext,
+    useEcho,
+    useFindUser,
+    useMizan,
+    useRenameUser,
+    useUpdateProfile,
+    useUserContext,
+    useUserOrders,
+    useUserProfile,
+    useWhoami,
+    type ContextState,
+} from '../src/react'
+import type { UserContextData } from '../src/index'
+
+export function Screen() {
+    return (
+        <MizanContext baseUrl="/api/mizan" session={false}>
+            <UserContext user_id={1}>
+                <Panel />
+            </UserContext>
+        </MizanContext>
+    )
+}
+
+function Panel() {
+    const context: ContextState<UserContextData> = useUserContext()
+    const orders = useUserOrders()
+    const profile = useUserProfile()
+
+    const echo = useEcho()
+    const findUser = useFindUser()
+    const renameUser = useRenameUser()
+    const updateProfile = useUpdateProfile()
+    const whoami = useWhoami()
+    const { call, fetch } = useMizan()
+
+    async function run() {
+        const echoed = await echo.mutate({ text: 'hello' })
+        const found = await findUser.mutate({ user_id: 1 })
+        const renamed = await renameUser.mutate({ user_id: 1, name: 'renamed' })
+        const updated = await updateProfile.mutate({ user_id: 1, name: 'renamed' })
+        const identity = await whoami.mutate()
+        const raw = await call('echo', { text: 'hello' })
+        const bundle = await fetch('user', { user_id: 1 })
+        console.log(echoed.message, found.name, renamed.name, updated.ok,
+                    identity.authenticated, raw, bundle)
+    }
+
+    const pending: boolean = echo.isPending
+    const failure: Error | null = echo.error
+
+    return (
+        <button onClick={run} disabled={pending}>
+            {context.status} {orders?.length ?? 0} {profile?.name ?? ''} {failure?.message ?? ''}
+        </button>
+    )
+}

protocol/mizan-codegen/tests/fixtures/toolchain/drivers/stage1.ts

@@ -0,0 +1,58 @@
+import {
+    callEcho,
+    callFindUser,
+    callRenameUser,
+    callUpdateProfile,
+    callWhoami,
+    fetchUserContext,
+    type UserContextData,
+    type UserContextParams,
+    type echoInput,
+    type echoOutput,
+    type findUserInput,
+    type findUserOutput,
+    type renameUserInput,
+    type renameUserOutput,
+    type updateProfileInput,
+    type updateProfileOutput,
+    type userOrdersInput,
+    type userOrdersOutput,
+    type userProfileInput,
+    type userProfileOutput,
+    type whoamiOutput,
+} from '../src/index'
+
+export async function everyStage1EntryPoint(): Promise<void> {
+    const echoArgs: echoInput = { text: 'hello' }
+    const echoed: echoOutput = await callEcho(echoArgs)
+    const message: string = echoed.message
+
+    const whoami: whoamiOutput = await callWhoami()
+    const email: string = whoami.email
+    const authenticated: boolean = whoami.authenticated
+
+    const findArgs: findUserInput = { user_id: 1 }
+    const found: findUserOutput = await callFindUser(findArgs)
+    const foundName: string = found.name
+
+    const renameArgs: renameUserInput = { user_id: 1, name: 'renamed' }
+    const renamed: renameUserOutput = await callRenameUser(renameArgs)
+    const renamedId: number = renamed.user_id
+
+    const updateArgs: updateProfileInput = { user_id: 1, name: 'renamed' }
+    const updated: updateProfileOutput = await callUpdateProfile(updateArgs)
+    const ok: boolean = updated.ok
+
+    const params: UserContextParams = { user_id: 1 }
+    const bundle: UserContextData = await fetchUserContext(params)
+    const orders: userOrdersOutput = bundle.user_orders
+    const profile: userProfileOutput = bundle.user_profile
+
+    const ordersArgs: userOrdersInput = { user_id: 1 }
+    const profileArgs: userProfileInput = { user_id: 1 }
+
+    console.log(
+        message, email, authenticated, foundName, renamedId, ok,
+        orders.length, profile.name, ordersArgs.user_id, profileArgs.user_id,
+    )
+}

protocol/mizan-codegen/tests/fixtures/toolchain/drivers/svelte.ts

@@ -0,0 +1,28 @@
+import {
+    callEcho,
+    callFindUser,
+    callRenameUser,
+    callUpdateProfile,
+    callWhoami,
+    createUserContext,
+    type ContextState,
+} from '../src/stores/svelte'
+import type { UserContextData, UserContextParams } from '../src/index'
+
+export async function everySvelteStoreEntryPoint(): Promise<void> {
+    const params: UserContextParams = { user_id: 1 }
+    const store = createUserContext(params)
+
+    const unsubscribe = store.subscribe((state: ContextState<UserContextData>) => {
+        console.log(state.status, state.data?.user_profile.name ?? '')
+    })
+    unsubscribe()
+
+    const echoed = await callEcho({ text: 'hello' })
+    const found = await callFindUser({ user_id: 1 })
+    const renamed = await callRenameUser({ user_id: 1, name: 'renamed' })
+    const updated = await callUpdateProfile({ user_id: 1, name: 'renamed' })
+    const identity = await callWhoami()
+
+    console.log(echoed.message, found.name, renamed.name, updated.ok, identity.authenticated)
+}

protocol/mizan-codegen/tests/fixtures/toolchain/drivers/vue.ts

@@ -0,0 +1,32 @@
+import {
+    useEcho,
+    useFindUser,
+    useRenameUser,
+    useUpdateProfile,
+    useUserContext,
+    useWhoami,
+    type ContextState,
+} from '../src/composables/vue'
+import type { UserContextData, UserContextParams } from '../src/index'
+
+export async function everyVueComposable(): Promise<void> {
+    const params: UserContextParams = { user_id: 1 }
+    const user = useUserContext(params)
+
+    const state: ContextState<UserContextData> = user.state.value
+    const orders = user.userOrders.value
+    const profile = user.userProfile.value
+    const loading: boolean = user.loading.value
+    const failure: Error | null = user.error.value
+
+    const echoed = await useEcho().mutate({ text: 'hello' })
+    const found = await useFindUser().mutate({ user_id: 1 })
+    const renamed = await useRenameUser().mutate({ user_id: 1, name: 'renamed' })
+    const updated = await useUpdateProfile().mutate({ user_id: 1, name: 'renamed' })
+    const identity = await useWhoami().mutate()
+
+    console.log(
+        state.status, orders?.length ?? 0, profile?.name ?? '', loading, failure?.message ?? '',
+        echoed.message, found.name, renamed.name, updated.ok, identity.authenticated,
+    )
+}

protocol/mizan-codegen/tests/fixtures/toolchain/mizan_rust.py

@@ -0,0 +1,46 @@
+"""Import target for the generated client's `from mizan_rust import ...`.
+
+The real module is a compiled PyO3 extension; this one records each call so the
+driver can read the name and payload the generated method sent, and replies with
+whatever `reply` currently holds.
+"""
+
+from typing import Any, Callable
+
+
+class PyContextSubscription:
+    def __init__(self, name: str, params: dict[str, Any],
+                 callback: Callable[[dict[str, Any]], None]) -> None:
+        self.name = name
+        self.params = params
+        self.callback = callback
+
+
+class PyMizanClient:
+    def __init__(self, base_url: str, *, session: bool,
+                 csrf_cookie_name: str, csrf_header_name: str) -> None:
+        self.base_url = base_url
+        self.session = session
+        self.csrf_cookie_name = csrf_cookie_name
+        self.csrf_header_name = csrf_header_name
+        self.calls: list[tuple[str, dict[str, Any]]] = []
+        self.invalidated: list[tuple[str, dict[str, Any] | None]] = []
+        self.reply: Any = None
+
+    def call(self, name: str, args: dict[str, Any]) -> Any:
+        self.calls.append((name, args))
+        return self.reply
+
+    def fetch_context(self, name: str, params: dict[str, Any]) -> Any:
+        self.calls.append((name, params))
+        return self.reply
+
+    def subscribe_context(self, name: str, params: dict[str, Any],
+                          callback: Callable[[dict[str, Any]], None]) -> PyContextSubscription:
+        return PyContextSubscription(name, params, callback)
+
+    def invalidate(self, context: str) -> None:
+        self.invalidated.append((context, None))
+
+    def invalidate_scoped(self, context: str, params: dict[str, Any]) -> None:
+        self.invalidated.append((context, params))

protocol/mizan-codegen/tests/fixtures/toolchain/python_driver.py

@@ -0,0 +1,73 @@
+"""Runs every generated client method against the recording kernel stub."""
+
+from mizan_client import MizanClient
+from mizan_client.client import UserContextData
+from mizan_client.types import (
+    EchoInput,
+    EchoOutput,
+    FindUserInput,
+    FindUserOutput,
+    OrderOutput,
+    RenameUserInput,
+    RenameUserOutput,
+    UpdateProfileInput,
+    UpdateProfileOutput,
+    UserProfileOutput,
+    WhoamiOutput,
+)
+
+client = MizanClient("http://127.0.0.1:9/api/mizan")
+kernel = client._inner
+
+kernel.reply = {"message": "hi"}
+echoed = client.call_echo(EchoInput(text="hello"))
+assert isinstance(echoed, EchoOutput)
+assert echoed.message == "hi"
+assert kernel.calls[-1] == ("echo", {"text": "hello"})
+
+kernel.reply = {"email": "ryth@example.com", "authenticated": True}
+identity = client.call_whoami()
+assert isinstance(identity, WhoamiOutput)
+assert identity.authenticated is True
+assert kernel.calls[-1] == ("whoami", {})
+
+kernel.reply = {"user_id": 1, "name": "ryth"}
+found = client.call_find_user(FindUserInput(user_id=1))
+assert isinstance(found, FindUserOutput)
+assert found.name == "ryth"
+assert kernel.calls[-1] == ("find_user", {"user_id": 1})
+
+kernel.reply = None
+assert client.call_find_user(FindUserInput(user_id=2)) is None
+
+kernel.reply = {"user_id": 1, "name": "renamed"}
+renamed = client.call_rename_user(RenameUserInput(user_id=1, name="renamed"))
+assert isinstance(renamed, RenameUserOutput)
+assert renamed.name == "renamed"
+
+kernel.reply = {"ok": True}
+updated = client.call_update_profile(UpdateProfileInput(user_id=1, name="renamed"))
+assert isinstance(updated, UpdateProfileOutput)
+assert updated.ok is True
+
+kernel.reply = {
+    "user_orders": [{"id": 7, "user_id": 1, "total": 42}],
+    "user_profile": {"user_id": 1, "name": "ryth"},
+}
+bundle = client.fetch_user_context(1)
+assert isinstance(bundle, UserContextData)
+assert isinstance(bundle.user_profile, UserProfileOutput)
+assert isinstance(bundle.user_orders[0], OrderOutput)
+assert bundle.user_orders[0].total == 42
+assert kernel.calls[-1] == ("user", {"user_id": 1})
+
+received: list[dict] = []
+subscription = client.subscribe_user_context(1, received.append)
+assert subscription.name == "user"
+assert subscription.params == {"user_id": 1}
+
+client.invalidate("user")
+client.invalidate_scoped("user", {"user_id": 1})
+assert kernel.invalidated == [("user", None), ("user", {"user_id": 1})]
+
+print("generated python client exercised")

protocol/mizan-codegen/tests/fixtures/toolchain/rust_driver.rs

@@ -0,0 +1,97 @@
+//! Consumer of the generated crate, compiled and run by `cargo test` inside
+//! that crate. Every path, signature and re-export named here has to resolve
+//! for the file to build at all.
+
+use fixture_client::contexts::user::{fetch_user_context, UserContextData, UserContextParams};
+use fixture_client::functions::echo::call_echo;
+use fixture_client::functions::find_user::call_find_user;
+use fixture_client::functions::rename_user::call_rename_user;
+use fixture_client::functions::whoami::call_whoami;
+use fixture_client::mutations::update_profile::call_update_profile;
+use fixture_client::types::{
+    EchoInput, EchoOutput, FindUserInput, FindUserOutput, OrderOutput, RenameUserInput,
+    RenameUserOutput, UpdateProfileInput, UpdateProfileOutput, UserOrdersOutput,
+    UserProfileOutput, WhoamiOutput,
+};
+use fixture_client::{MizanClient, MizanConfig, MizanError};
+
+
+async fn every_generated_entry_point(client: &MizanClient) -> Result<(), MizanError> {
+    let echoed: EchoOutput = call_echo(
+        client,
+        &EchoInput { text: "hello".to_string() },
+    ).await?;
+
+    let identity: WhoamiOutput = call_whoami(client).await?;
+
+    let found: Option<FindUserOutput> = call_find_user(
+        client,
+        &FindUserInput { user_id: 1 },
+    ).await?;
+
+    let renamed: RenameUserOutput = call_rename_user(
+        client,
+        &RenameUserInput { user_id: 1, name: "renamed".to_string() },
+    ).await?;
+
+    let updated: UpdateProfileOutput = call_update_profile(
+        client,
+        &UpdateProfileInput { user_id: 1, name: "renamed".to_string() },
+    ).await?;
+
+    let bundle: UserContextData = fetch_user_context(
+        client,
+        &UserContextParams { user_id: 1 },
+    ).await?;
+    let orders: UserOrdersOutput = bundle.user_orders;
+    let profile: UserProfileOutput = bundle.user_profile;
+
+    println!(
+        "{} {} {} {} {} {} {}",
+        echoed.message,
+        identity.authenticated,
+        found.is_some(),
+        renamed.name,
+        updated.ok,
+        orders.len(),
+        profile.name,
+    );
+    Ok(())
+}
+
+
+#[test]
+fn generated_entry_points_build_a_callable_future() {
+    let client = MizanClient::new(MizanConfig {
+        base_url: "http://127.0.0.1:9/api/mizan".to_string(),
+        session: false,
+        ..MizanConfig::default()
+    });
+    drop(every_generated_entry_point(&client));
+}
+
+
+#[test]
+fn generated_types_decode_the_wire_shape() {
+    let raw = r#"{
+        "user_orders": [{"id": 7, "user_id": 1, "total": 42}],
+        "user_profile": {"user_id": 1, "name": "ryth"}
+    }"#;
+    let bundle: UserContextData = serde_json::from_str(raw).expect("context bundle decodes");
+
+    assert_eq!(bundle.user_profile.user_id, 1);
+    assert_eq!(bundle.user_profile.name, "ryth");
+    assert_eq!(bundle.user_orders.len(), 1);
+
+    let order: &OrderOutput = &bundle.user_orders[0];
+    assert_eq!(order.id, 7);
+    assert_eq!(order.total, 42);
+
+    let echoed: EchoOutput =
+        serde_json::from_str(r#"{"message": "hi"}"#).expect("echo output decodes");
+    assert_eq!(echoed.message, "hi");
+
+    let encoded = serde_json::to_string(&EchoInput { text: "hi".to_string() })
+        .expect("echo input encodes");
+    assert_eq!(encoded, r#"{"text":"hi"}"#);
+}

protocol/mizan-codegen/tests/fixtures/toolchain/shims/mizan-channels.d.ts

@@ -0,0 +1,22 @@
+declare module 'mizan/channels' {
+    export interface ChannelSubscription<
+        TParams = unknown,
+        TServerMessage = unknown,
+        TClientMessage = unknown,
+    > {
+        status: 'connecting' | 'connected' | 'disconnected'
+        messages: TServerMessage[]
+        send: TClientMessage extends never ? never : (message: TClientMessage) => void
+        unsubscribe: () => void
+        clearMessages: () => void
+    }
+
+    export function useChannel<
+        TParams = undefined,
+        TServerMessage = unknown,
+        TClientMessage = unknown,
+    >(
+        channelName: string,
+        params?: TParams,
+    ): ChannelSubscription<TParams, TServerMessage, TClientMessage>
+}

protocol/mizan-codegen/tests/fixtures/toolchain/shims/svelte-store.d.ts

@@ -0,0 +1,13 @@
+declare module 'svelte/store' {
+    export type Subscriber<T> = (value: T) => void
+    export type Unsubscriber = () => void
+
+    export interface Readable<T> {
+        subscribe(run: Subscriber<T>): Unsubscriber
+    }
+
+    export function readable<T>(
+        value: T,
+        start?: (set: Subscriber<T>) => Unsubscriber | void,
+    ): Readable<T>
+}

protocol/mizan-codegen/tests/fixtures/toolchain/shims/vue.d.ts

@@ -0,0 +1,15 @@
+declare module 'vue' {
+    export interface Ref<T> {
+        value: T
+    }
+
+    export interface ComputedRef<T> {
+        readonly value: T
+    }
+
+    export function ref<T>(value: T): Ref<T>
+    export function computed<T>(getter: () => T): ComputedRef<T>
+    export function onMounted(hook: () => void): void
+    export function onUnmounted(hook: () => void): void
+    export function onServerPrefetch(hook: () => void | Promise<void>): void
+}

protocol/mizan-codegen/tests/fixtures/toolchain/tsconfig.json

@@ -0,0 +1,13 @@
+{
+    "compilerOptions": {
+        "noEmit": true,
+        "strict": true,
+        "target": "ES2022",
+        "lib": ["ES2022", "DOM"],
+        "module": "ESNext",
+        "moduleResolution": "bundler",
+        "jsx": "react-jsx",
+        "skipLibCheck": true
+    },
+    "include": ["src/**/*", "shims/**/*", "drivers/**/*"]
+}