Cleaned dead code and updated documents

CLAUDE.md

@@ -17,15 +17,24 @@ backends/         server protocol adapters
     mizan-django/    Django adapter
     mizan-fastapi/   FastAPI adapter (RPC + context + invalidation; AFI-common scope)
     mizan-ts/        TypeScript adapter (proves the protocol is language-agnostic)
-frontends/        client kernel + per-framework adapters
+    mizan-rust-axum/ Rust/Axum adapter (server-side substrate; three-way parity)
+    mizan-tauri/     Tauri-as-Mizan-backend substrate
+frontends/        client kernel + per-framework adapters + transports
     mizan-base/      framework-agnostic kernel; owns data, status, error; adapters subscribe
     mizan-react/     React contexts + hooks over the kernel
-    mizan-vue/       Vue composables over the kernel
-    mizan-svelte/    Svelte stores/runes over the kernel
+    mizan-vue/       Vue composables over the kernel (codegen target; runtime package unimplemented)
+    mizan-svelte/    Svelte stores over the kernel (codegen target; runtime package unimplemented)
+    mizan-rust/      Rust kernel (PyO3 bridge; consumed by the Rust codegen's python target)
+    mizan-tauri-transport/    Tauri IPC transport for the kernel
+    mizan-webview-transport/  VSCode-webview transport for the kernel
+    mizan-webview-channels/   webview channel transport
 cores/            shared language-level primitives
     mizan-python/    @client decorator, registry, MWT, HMAC cache keys; consumed by both Python backends
+    mizan-rust/      shared Rust primitives (IR, KDL, registry, graph-check)
+    mizan-rust-macros/ proc-macros for the Rust backend/kernel
 protocol/         protocol-level tooling
-    mizan-generate/  codegen — fetches schema from any backend, emits typed React/Vue/Svelte client
+    mizan-codegen/   the codegen — a Rust binary; reads KDL IR, emits typed clients per target
+    mizan-generate/  thin npm launcher around the compiled mizan-codegen binary
 workers/          runtime workers / bridges
     mizan-ssr/       Bun subprocess used by the Django template backend
 ```
@@ -446,22 +455,18 @@ urlpatterns = [
 
 ## Codegen — Current State
 
-The codegen is `protocol/mizan-generate/` — framework-agnostic, two-stage. Stage 1 emits the protocol layer (`callXxx` for mutations, `fetchXxx` for context bundles, types). Stage 2 emits per-framework hooks/composables/stores that subscribe to the `mizan-base` kernel.
+The codegen is a **Rust binary**, `protocol/mizan-codegen/` (crate `mizan-codegen`). `protocol/mizan-generate/` is a thin npm launcher (`bin/launcher.mjs`) that shells out to the compiled binary. The IR is **KDL** — each backend emits KDL describing its functions/contexts; the binary reads it (`src/fetch.rs`, `src/ir.rs`) and emits per-target output from Askama templates (`templates/`, dispatched in `src/emit/`).
 
-**What's in place:**
+Two layers, same as before: a framework-agnostic protocol layer (`callXxx` for mutations, `fetchXxx` for context bundles, types) and a per-framework adapter layer that subscribes to the `mizan-base` kernel.
 
-- Function hooks (`useEcho`, `useUserProfile`, etc.) in the React adapter, subscribing to kernel state via `useSyncExternalStore`
-- Context hooks for named contexts and `global`
-- Channel hooks for WebSocket transport
-- Vue and Svelte equivalents (Stage 2 templates compile, but no live-backend example exercises them — see `ISSUES.md` A4)
+**Targets** (`src/emit/`, each byte-checked by a `*_parity.rs` test):
 
-**What's not yet emitted (the wrapper layer):**
+- `react` — function/context hooks over `useSyncExternalStore`, plus the full wrapper layer: the `MizanContext` root provider (calls `configure()`, mounts the global context), `useMizan()` imperative escape hatch, and `useMutation`-backed hooks exposing `{ mutate, isPending, error }`.
+- `vue`, `svelte` — composables / `readable` stores. Byte-parity-tested, but no runtime adapter package or live-backend example exercises them yet (the `mizan-vue`/`mizan-svelte` packages are unimplemented stubs).
+- `channels` — WebSocket transport hooks.
+- `stage1` — the framework-agnostic protocol files.
+- `python`, `rust` — typed clients for the Python (PyO3) and Rust frontends.
 
-- `<MizanContext>` provider component for React (calls `configure()` and mounts the kernel into the component tree)
-- `useMizan()` hook for accessing the kernel from React
-- Framework-named error class (e.g. `DjangoError`) wrapping `MizanError` from the kernel
-- Vue and Svelte equivalents
+The pre-kernel `MizanProvider` in `mizan-react/src/context.tsx` (~750 lines) still ships and is imported by the desktop example; it coexists with the generated `MizanContext`. Forms (`mizan-react/src/forms.ts`) are hand-written and consume the pre-kernel provider — a form codegen target wired to `mizanCall` is still owed. See `ISSUES.md`.
 
-The legacy `MizanProvider` in `mizan-react/src/context.tsx` (~750 lines) and the `forms.ts` consumer (~1163 lines) still depend on the pre-kernel API. They're tracked as `ISSUES.md` A1 and A3. Removing them is gated on the wrapper layer above being emitted.
-
-The SSR pipeline is independent of the codegen — it renders whatever components are registered in the Bun worker.
+The SSR pipeline is independent of the codegen — the Bun worker resolves a component by **file path** (`import(file)` + `renderToString`), not via a registry.