Mizan codegen substrate: Rust kernel + Rust codegen binary, JS generator deleted

The Mizan codegen substrate moves off JavaScript template-literal emission
onto a compiled Rust binary that consumes the same OpenAPI + x-mizan-* IR
the JS substrate consumed. Three structural wins fall out of one move:

1. Moat closes. The codegen logic (how `affects` becomes auto-invalidation,
   how named contexts collapse onto bundled fetches, how the registry-to-
   Provider mapping is shaped) ships compiled instead of as source bytes
   in every consumer's node_modules.

2. Pattern F (lines.push append-walls) becomes structurally unauthorable.
   The emit substrate is askama templates in templates/<target>/*.j2 —
   actual target-language files with {{ ... }} substitution markers,
   syntax-highlighted natively, type-checked against the render context
   structs at compile time. The Rust emit modules build typed render
   contexts and call .render(); no string-builder surface exists.

3. OpenAPI `default`-bearing fields now emit as non-optional in TS / Python
   / Rust — the server always populates them, so consumer code reads them
   without nullable checks. Surfaced by Blazr's typecheck on regeneration.

Layout:
  frontends/mizan-rust/        — Rust port of @mizan/base; #[cfg(feature="pyo3")]
                                 exposes PyMizanClient for the Python target.
  protocol/mizan-codegen/      — codegen binary source + askama templates.
  protocol/mizan-generate/     — npm-package shim. bin/launcher.mjs dispatches
                                 to the platform-appropriate prebuilt binary.
                                 Old generator/ JS tree deleted.
  tests/rust/                  — wire-parity drivers. drive_kernel exercises
                                 raw client.call() / fetch_context(); drive_emitted
                                 exercises the typed crate the codegen emits.
  tests/afi/afi_codegen_app.py — codegen entrypoint module (imports + registers).
  backends/mizan-fastapi/.../schema.py — adds outputNullable so the Rust
                                 codegen can wrap T | None responses in Option<T>.

Verification:
  - 20 mizan-codegen tests green (IR deserialization, byte-equivalent
    parity vs JS baseline for stage1/rust/python/react/vue/svelte,
    structural test for channels).
  - tests/rust/run_wire_parity.py — 12/12 probes green via the Rust binary
    driving the FastAPI fixture end-to-end.

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

protocol/mizan-codegen/src/emit/vue.rs

@@ -0,0 +1,107 @@
+//! Vue target — composable per context + composable per call.
+//! Output shape lives at `templates/vue/vue.ts.j2`.
+
+use std::path::PathBuf;
+
+use askama::Template;
+
+use crate::config::Config;
+use crate::emit::CodegenTarget;
+use crate::emit::EmittedFile;
+use crate::emit::casing::pascal_case;
+use crate::ir::{IsContext, MizanFunction, MizanIR};
+
+
+pub struct VueAdapter;
+
+
+impl CodegenTarget for VueAdapter {
+    fn name(&self) -> &'static str { "vue" }
+
+    fn emit(&self, ir: &MizanIR, _config: &Config) -> Vec<EmittedFile> {
+        let content = build_template(ir).render().expect("vue template renders");
+        vec![EmittedFile::new(PathBuf::from("vue.ts"), content)]
+    }
+}
+
+
+#[derive(Template)]
+#[template(path = "vue/vue.ts.j2", escape = "none")]
+struct VueTemplate<'a> {
+    stage1_imports: Vec<String>,
+    contexts: Vec<CtxRender<'a>>,
+    calls: Vec<CallRender>,
+}
+
+
+struct CtxRender<'a> {
+    pascal: String,
+    name: &'a str,
+    has_params: bool,
+    params_arg: &'static str,
+    fns: Vec<FnRender<'a>>,
+}
+
+
+struct FnRender<'a> {
+    camel_name: &'a str,
+    name: &'a str,
+    output_type: &'a str,
+}
+
+
+struct CallRender {
+    pascal: String,
+    has_input: bool,
+}
+
+
+fn build_template(ir: &MizanIR) -> VueTemplate<'_> {
+    let contexts: Vec<CtxRender> = ir.contexts.iter()
+        .map(|(ctx_name, ctx_meta)| {
+            let has_params = !ctx_meta.params.is_empty();
+            let ctx_fns: Vec<FnRender> = ir.functions.iter()
+                .filter(|f| f.is_context.as_str() == Some(ctx_name.as_str()))
+                .map(|f| FnRender {
+                    camel_name: &f.camel_name,
+                    name: &f.name,
+                    output_type: &f.output_type,
+                })
+                .collect();
+            CtxRender {
+                pascal: pascal_case(ctx_name),
+                name: ctx_name,
+                has_params,
+                params_arg: if has_params { "params" } else { "{} as any" },
+                fns: ctx_fns,
+            }
+        })
+        .collect();
+
+    let mutations: Vec<&MizanFunction> = ir.functions.iter()
+        .filter(|f| matches!(f.is_context, IsContext::No) && !f.is_form && !f.affects.is_empty())
+        .collect();
+    let plain_fns: Vec<&MizanFunction> = ir.functions.iter()
+        .filter(|f| matches!(f.is_context, IsContext::No) && !f.is_form && f.affects.is_empty())
+        .collect();
+
+    let calls: Vec<CallRender> = mutations.iter().chain(plain_fns.iter())
+        .map(|f| CallRender {
+            pascal: pascal_case(&f.camel_name),
+            has_input: f.has_input,
+        })
+        .collect();
+
+    let mut stage1: Vec<String> = Vec::new();
+    for ctx_name in ir.contexts.keys() {
+        let p = pascal_case(ctx_name);
+        stage1.push(format!("fetch{p}Context"));
+        stage1.push(format!("type {p}ContextData"));
+        stage1.push(format!("type {p}ContextParams"));
+    }
+    for fn_meta in mutations.iter().chain(plain_fns.iter()) {
+        stage1.push(format!("call{}", pascal_case(&fn_meta.camel_name)));
+    }
+
+    VueTemplate { stage1_imports: stage1, contexts, calls }
+}