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>

backends/mizan-fastapi/src/mizan_fastapi/__init__.py

@@ -1,27 +1,12 @@
 """
 mizan-fastapi — FastAPI backend adapter for the Mizan protocol.
 
-HTTP RPC dispatch, context bundling, and a WebSocket carrying channel
-subscriptions and RPC on mizan-django's envelope. Forms, Shapes and SSR are
-out of scope — FastAPI projects use native equivalents.
-
-Usage:
-    from fastapi import FastAPI
-    from mizan_fastapi import router, mizan_exception_handler, MizanError
-
-    app = FastAPI()
-    app.include_router(router, prefix="/api/mizan")
-    app.include_router(ws_router, prefix="/api/mizan")
-    app.add_exception_handler(MizanError, mizan_exception_handler)
-
-    # Register your @client-decorated functions
-    from mizan_core.client.function import client
-    from mizan_core.registry import register
-    from .my_functions import echo
-    register(echo, "echo")
+Re-exports the adapter's surface: two routers (HTTP dispatch and the WebSocket),
+the error hierarchy with its exception handlers, and the channel base class with
+its registry.
 """
 
-from .executor import (
+from mizan_fastapi.executor import (
     ErrorCode,
     MizanError,
     NotFound,
@@ -34,14 +19,19 @@ from .executor import (
     compute_invalidation,
     execute_function,
 )
-from .router import router, mizan_exception_handler, mizan_validation_handler
-from .websocket import ws_router
-from .channels import ReactChannel, broadcast, get_channel, register as register_channel
+from mizan_fastapi.router import router, mizan_exception_handler, mizan_validation_handler
+from mizan_fastapi.websocket import ws_router
+from mizan_fastapi.channels import (
+    Channel,
+    broadcast,
+    get_channel,
+    register as register_channel,
+)
 
 __all__ = [
     "router",
     "ws_router",
-    "ReactChannel",
+    "Channel",
     "register_channel",
     "get_channel",
     "broadcast",

backends/mizan-fastapi/src/mizan_fastapi/channels.py

@@ -5,10 +5,8 @@ A channel names a group of subscribers and decides who may join it. `group(param
 is the fan-out key, so two subscribers with the same params share a group and a push
 addressed to those params reaches both.
 
-Membership is held in this process. Django's channel layer carries groups across
-workers through Redis; nothing here does, so a push reaches only the subscribers
-connected to the process that sent it. One process — a desktop shell, a single
-uvicorn worker — is the shape this serves.
+Membership is held in this process. A push therefore reaches only the subscribers
+whose socket is attached to the process that sent it.
 """
 
 from __future__ import annotations
@@ -20,20 +18,27 @@ from typing import Any, ClassVar
 from fastapi.encoders import jsonable_encoder
 from pydantic import BaseModel
 
+from mizan_core.registry import RegistryExtension, register_extension
+
 # group name -> the live sockets subscribed to it
 _groups: dict[str, set[Any]] = defaultdict(set)
-_registry: dict[str, type["ReactChannel"]] = {}
+_registry: dict[str, type["Channel"]] = {}
 _lock = asyncio.Lock()
 
 
-class ReactChannel:
+class Channel:
     """A named fan-out. Subclass, override what the channel decides, and register it.
 
-    A subclass may define `on_connect(params)` / `on_disconnect()`; the socket handler
-    calls them when they exist.
+    The three nested models are the channel's payload types, named from the client's
+    side: `Params` keys the fan-out, `ClientMessage` travels up, `ServerMessage`
+    travels down. A subclass may also define `on_connect(params)` / `on_disconnect()`;
+    the socket handler calls them when they exist.
     """
 
     name: ClassVar[str] = ""
+    Params: ClassVar[type[BaseModel] | None] = None
+    ClientMessage: ClassVar[type[BaseModel] | None] = None
+    ServerMessage: ClassVar[type[BaseModel] | None] = None
 
     def authorize(self, params: BaseModel | None = None) -> bool:
         """Whether this subscriber may join. Default: anyone may."""
@@ -68,16 +73,16 @@ class _Params:
         return self._values
 
 
-def register(channel_class: type[ReactChannel], name: str) -> None:
+def register(channel_class: type[Channel], name: str) -> None:
     channel_class.name = name
     _registry[name] = channel_class
 
 
-def get_channel(name: str) -> type[ReactChannel] | None:
+def get_channel(name: str) -> type[Channel] | None:
     return _registry.get(name)
 
 
-def registered() -> dict[str, type[ReactChannel]]:
+def registered() -> dict[str, type[Channel]]:
     return dict(_registry)
 
 
@@ -122,3 +127,36 @@ async def broadcast(
         except Exception as e:
             print(f"mizan.channels: dropping subscriber from {group}: {type(e).__name__}: {e}")
             await leave(group, socket)
+
+
+class _ChannelsExtension(RegistryExtension):
+    """The `channels` slot of the core registry — one entry per registered channel,
+    each carrying the JSON schema of whichever payload models the channel declares.
+    """
+
+    def all(self) -> dict[str, type[Channel]]:
+        return dict(_registry)
+
+    def schema(self) -> dict[str, Any]:
+        out: dict[str, Any] = {}
+        for name, channel_class in _registry.items():
+            entry: dict[str, Any] = {
+                "name": name,
+                "type": "channel",
+                "bidirectional": False,
+            }
+            if channel_class.Params is not None:
+                entry["params"] = channel_class.Params.model_json_schema()
+            if channel_class.ClientMessage is not None:
+                entry["client_message"] = channel_class.ClientMessage.model_json_schema()
+                entry["bidirectional"] = True
+            if channel_class.ServerMessage is not None:
+                entry["server_message"] = channel_class.ServerMessage.model_json_schema()
+            out[name] = entry
+        return out
+
+    def clear(self) -> None:
+        _registry.clear()
+
+
+register_extension("channels", _ChannelsExtension())

backends/mizan-fastapi/src/mizan_fastapi/ir.py

@@ -6,8 +6,7 @@ Usage:
 
 Imports the named module (whose import side effects must register every
 @client function with `mizan_core.registry`), then writes the canonical
-Mizan IR as KDL to stdout. The Rust codegen binary consumes this
-directly.
+Mizan IR as KDL to stdout.
 """
 
 from __future__ import annotations

backends/mizan-fastapi/src/mizan_fastapi/router.py

@@ -1,15 +1,9 @@
 """
 FastAPI router exposing Mizan's HTTP endpoints:
 
+    GET  /session/             — session-init probe
     POST /call/                — RPC dispatch
     GET  /ctx/{context_name}/  — bundled context fetch
-
-    from fastapi import FastAPI
-    from mizan_fastapi import router, mizan_exception_handler, MizanError
-
-    app = FastAPI()
-    app.include_router(router, prefix="/api/mizan")
-    app.add_exception_handler(MizanError, mizan_exception_handler)
 """
 
 from __future__ import annotations
@@ -23,7 +17,7 @@ from pydantic import BaseModel, Field
 
 from mizan_core.registry import get_context_groups, get_function
 
-from .executor import (
+from mizan_fastapi.executor import (
     ErrorCode,
     MizanError,
     NotFound,
@@ -45,12 +39,7 @@ def _no_store(payload: Any, status_code: int = 200) -> JSONResponse:
 
 @router.get("/session/")
 async def session_init() -> JSONResponse:
-    """Session-init probe. Parity with mizan-django's session endpoint.
-
-    CSRF is a Django-only concern at the protocol level; FastAPI surfaces a
-    null token so the response shape stays uniform across backends. The
-    wire-parity harness uses this endpoint as its readiness probe.
-    """
+    """Session-init probe. The CSRF slot is null — nothing on this backend issues a token."""
     return _no_store({"csrfToken": None})
 
 

backends/mizan-fastapi/src/mizan_fastapi/websocket.py

@@ -14,13 +14,8 @@ The WebSocket endpoint — channel subscriptions and RPC over one connection.
         {"id": "request-id", "ok": false, "error": {"code": "...", "message": "..."}}
         {"error": "..."}
 
-The envelope is mizan-django's, so a client speaks to either backend unchanged. RPC
-dispatches through the same `execute_function` the HTTP route calls — one dispatch path,
-so the two transports cannot disagree about what a function does.
-
-`data` is the `{result, invalidate, merge}` envelope every non-HTTP transport hands the
-kernel, so `mizanCall` applies a socket mutation's invalidation exactly as it applies an
-HTTP one. mizan-django's socket sends a bare result and drops it.
+An `rpc` reply's `data` is the `{result, invalidate, merge}` envelope, the same one the
+HTTP route builds, and both are produced by `execute_function`.
 """
 
 from __future__ import annotations
@@ -47,9 +42,9 @@ ws_router = APIRouter()
 class _SocketRequest:
     """What a server function receives when the call arrived over the socket.
 
-    The HTTP path hands functions a Starlette `Request`; there is none here, so this
-    carries the surface a function actually reads — `state`, headers, and a method, since
-    a socket RPC sends data and expects an answer.
+    There is no Starlette `Request` on a socket, so this carries the surface a function
+    actually reads — `state`, headers, and a method, since a socket RPC sends data and
+    expects an answer.
     """
 
     method = "POST"
@@ -64,7 +59,7 @@ class _SocketRequest:
 
 def _params_model(channel_cls: Any, raw: dict[str, Any] | None) -> Any:
     """Params as the channel's declared model, or a bare holder when it declares none."""
-    model = getattr(channel_cls, "Params", None)
+    model = channel_cls.Params
     if model is not None and raw:
         return model(**raw)
     return channels._Params(raw) if raw else None
@@ -203,10 +198,10 @@ _ACTIONS = {
 
 @ws_router.websocket("/ws/")
 async def mizan_socket(socket: WebSocket) -> None:
-    """One connection, every action. A disconnect ends the loop and clears the membership.
+    """One connection, every action.
 
-    A close is how a socket ends, so the disconnect is reported as the departure it is
-    rather than raised as a fault; `finally` clears the membership either way.
+    A close is how a socket ends, so the disconnect is logged rather than raised;
+    `finally` clears the membership either way.
     """
     await socket.accept()
     try:

backends/mizan-fastapi/tests/test_dispatch.py

@@ -88,7 +88,7 @@ def app():
 
     @client
     async def async_echo(request, text: str) -> EchoOutput:
-        # await something on the loop to prove we're really running async
+        # Yielding to the loop fails outright if the handler is not awaited.
         await asyncio.sleep(0)
         return EchoOutput(message=f"async: {text}")
 
@@ -183,18 +183,19 @@ class ContextFetchTests:
         assert r.json()["error"]["code"] == "NOT_FOUND"
 
 
-# ─── Invalidation ───────────────────────────────────────────────────────────
+# ─── Auth gating ────────────────────────────────────────────────────────────
 
 
 class AuthTests:
-    """The decorator normalizes auth=True → meta['auth']='required'; executor must match both."""
-
     def test_anonymous_request_to_auth_required_returns_401(self, http):
         r = http.post("/api/mizan/call/", json={"fn": "whoami", "args": {}})
         assert r.status_code == 401
         assert r.json()["error"]["code"] == "UNAUTHORIZED"
 
 
+# ─── Invalidation ───────────────────────────────────────────────────────────
+
+
 class InvalidationTests:
     def test_mutation_emits_invalidate_list(self, http):
         r = http.post(
@@ -211,8 +212,6 @@ class InvalidationTests:
 
 
 class StructuredOutputTests:
-    """list[BaseModel] and Optional[BaseModel] should reach the wire as bare values, not {result: ...}."""
-
     def test_list_of_basemodel_returns_bare_array(self, http):
         r = http.post("/api/mizan/call/", json={"fn": "list_items", "args": {}})
         assert r.status_code == 200
@@ -232,21 +231,20 @@ class StructuredOutputTests:
         assert r_missing.json()["result"] is None
 
 
-# ─── Merge protocol ─────────────────────────────────────────────────────────
+# ─── Async handlers ─────────────────────────────────────────────────────────
 
 
 class AsyncHandlerTests:
-    """`async def` handlers dispatch on the loop via view.acall."""
-
     def test_async_handler_returns_awaited_result(self, http):
         r = http.post("/api/mizan/call/", json={"fn": "async_echo", "args": {"text": "hello"}})
         assert r.status_code == 200
         assert r.json()["result"] == {"message": "async: hello"}
 
 
-class MergeTests:
-    """@client(merge=...) emits a `merge` field in the response so the kernel can splice without refetch."""
+# ─── Merge protocol ─────────────────────────────────────────────────────────
 
+
+class MergeTests:
     def test_merge_target_emits_merge_entry(self, http):
         r = http.post(
             "/api/mizan/call/",
@@ -254,9 +252,8 @@ class MergeTests:
         )
         assert r.status_code == 200
         body = r.json()
-        # Server resolves slot — items_list returns list[ItemOutput], mutation returns ItemOutput
+        # items_list returns list[ItemOutput], so the slot resolves to items_list.
         assert body["merge"] == [
             {"context": "items", "slot": "items_list", "value": {"id": 42, "name": "renamed"}}
         ]
-        # invalidate stays empty when only merge is declared
         assert body["invalidate"] == []