mizan-tauri + Pydantic-aware codegen: Tauri-as-Mizan-backend substrate

Tauri now joins FastAPI/Django/axum as a first-class Mizan backend. The
React frontend calls Mizan-registered functions through Tauri's IPC
with the same {result, invalidate, merge} envelope the HTTP path uses;
the schema flows Pydantic → decoru → Rust → KDL → TS in one
mizan-generate invocation.

New packages:
* backends/mizan-tauri — Tauri plugin exposing a single `mizan_invoke`
  command that routes through mizan-core's FUNCTIONS / CONTEXTS
  registries. No per-function tauri::command; the linkme slice IS the
  dispatch table.
* frontends/mizan-tauri-transport — TS package exporting
  tauriTransport() that wraps invoke('plugin:mizan|mizan_invoke', ...)
  and re-shapes errors into MizanError. Pairs with mizan-tauri.

@mizan/base — pluggable transport:
* Adds MizanTransport interface + transport config field.
* Existing fetch-based body factored into httpTransport() (default).
* mizanCall/mizanFetch delegate to config.transport; merge/invalidate
  side-effects stay in the kernel (transport-agnostic).
* Consumers swap via configure({ transport: tauriTransport() }).

mizan-codegen — Rust source + Pydantic pre-step:
* [source.rust] runs a Cargo bin (cargo run --bin <name>) and parses
  KDL from stdout. The bin uses mizan_core::build_ir() after
  force-linking the consumer's #[derive(Mizan)] / #[mizan::client]
  registrations.
* [source.rust.pydantic] is an optional pre-step that pipes an
  embedded Python bridge (scripts/run_decoru.py) to python and writes
  decoru-emitted Rust types into the consumer crate. The bridge
  auto-discovers BaseModel subclasses AND Enum subclasses
  (last-variant-is-default convention so decoru's impl Default keeps
  compiling against enum-typed fields without explicit Pydantic
  defaults).
* Pure-Rust usage stays intact — omit pydantic block and write Rust
  types by hand.

mizan-macros:
* #[mizan::client] now supports Result<T, MizanError> returns. The
  dispatch wrapper `?`-unwraps the user fn so server-side errors
  surface as the protocol's standard {code, message, details?}
  envelope; T-returning functions stay unchanged.
* #[derive(Mizan)] strips the r# raw-identifier prefix and honors
  field-level #[serde(rename = "...")] when emitting IR field names.
  Matches serde's wire shape — fixes IR-vs-JSON drift for Rust-keyword
  fields (e.g. `r#type` → `type`).

react.tsx template:
* Conditionally emits context-related imports / useContextSubscription
  helper based on has_global || !named_contexts.is_empty(). Consumers
  without contexts (mutation/RPC-only apps like claude-manage) no
  longer get dead imports that trip noUnusedLocals.

Verified end-to-end: cargo build clean across mizan-tauri,
mizan-codegen, AFI rust_app; AFI three-way KDL parity tests pass;
claude-manage migration drives the full stack (Pydantic schema →
generated TS api → Tauri-IPC transport → mizan-core dispatch).

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

frontends/mizan-base/src/index.ts

@@ -30,6 +30,39 @@ export class MizanError extends Error {
     }
 }
 
+// === Transport ===
+
+/**
+ * Wire surface the kernel uses to reach a Mizan backend. The default
+ * implementation is `httpTransport()` (POST /call/, GET /ctx/). Tauri
+ * apps swap in `tauriTransport()` from `@mizan/tauri-transport`. Any
+ * future transport — workers, edge runtimes, channels — implements this
+ * interface and replaces the default via `configure({ transport })`.
+ */
+export interface MizanTransport {
+    /** RPC dispatch — invokes a Mizan-registered function. */
+    call(
+        fnName: string,
+        args: Record<string, any>,
+    ): Promise<MizanCallResponse>
+    /** Context-bundle fetch — invokes a Mizan-registered context. */
+    fetch(
+        contextName: string,
+        params?: Record<string, any>,
+    ): Promise<any>
+}
+
+/**
+ * Raw envelope a transport returns from `call()`. The kernel uses the
+ * `merge` and `invalidate` arrays to drive client-side cache updates;
+ * `result` is the function's typed return value.
+ */
+export interface MizanCallResponse {
+    result: any
+    invalidate?: Array<string | { context: string; params?: Record<string, any> } | { function: string }>
+    merge?: Array<{ context: string; slot: string; value: unknown; params?: Record<string, any> }>
+}
+
 // === Configuration ===
 
 interface MizanConfig {
@@ -45,6 +78,13 @@ interface MizanConfig {
      * this onto the schema-advertised capability surface.
      */
     session: boolean
+    /**
+     * Wire transport. Defaults to `httpTransport()` (fetch-based,
+     * compatible with FastAPI / Django backends). Swap with a custom
+     * transport (e.g. `tauriTransport()`) at app entry to route
+     * Mizan calls through a different channel.
+     */
+    transport: MizanTransport
 }
 
 const config: MizanConfig = {
@@ -53,6 +93,8 @@ const config: MizanConfig = {
     csrfCookieName: 'csrftoken',
     csrfHeaderName: 'X-CSRFToken',
     session: true,
+    // Initialized below once httpTransport is defined.
+    transport: null as unknown as MizanTransport,
 }
 
 export function configure(opts: Partial<MizanConfig>): void {
@@ -344,42 +386,68 @@ async function resolveHeaders(): Promise<Record<string, string>> {
     }
 }
 
+/**
+ * Default Mizan transport — POST `${baseUrl}/call/` and GET
+ * `${baseUrl}/ctx/${name}/`. Compatible with `mizan-fastapi`,
+ * `mizan-django`, and `mizan-rust-axum`. Swap with a different
+ * transport via `configure({ transport })` when running in a
+ * non-HTTP host (e.g. Tauri).
+ */
+export function httpTransport(): MizanTransport {
+    return {
+        async call(functionName, args) {
+            const headers = await resolveHeaders()
+            headers['Content-Type'] = 'application/json'
+
+            const res = await fetch(`${config.baseUrl}/call/`, {
+                method: 'POST',
+                headers,
+                credentials: 'same-origin',
+                body: JSON.stringify({ fn: functionName, args }),
+            })
+            if (!res.ok) throw new MizanError(res.status, await res.text())
+            return res.json()
+        },
+        async fetch(contextName, params) {
+            const url = new URL(
+                `${config.baseUrl}/ctx/${contextName}/`,
+                typeof globalThis.location !== 'undefined'
+                    ? globalThis.location.origin
+                    : 'http://localhost',
+            )
+            if (params) {
+                for (const [k, v] of Object.entries(params)) {
+                    url.searchParams.set(k, String(v))
+                }
+            }
+            const headers = await resolveHeaders()
+            const res = await fetchWithRetry(url.toString(), {
+                headers,
+                credentials: 'same-origin',
+            })
+            if (!res.ok) throw new MizanError(res.status, await res.text())
+            return res.json()
+        },
+    }
+}
+
+// Install the default transport now that httpTransport is in scope. The
+// config object was constructed earlier with a placeholder so the type
+// stayed honest; this line is the actual binding.
+config.transport = httpTransport()
+
 export async function mizanFetch(
     contextName: string,
     params?: Record<string, any>,
 ): Promise<any> {
-    const url = new URL(
-        `${config.baseUrl}/ctx/${contextName}/`,
-        typeof globalThis.location !== 'undefined' ? globalThis.location.origin : 'http://localhost',
-    )
-    if (params) {
-        for (const [k, v] of Object.entries(params)) {
-            url.searchParams.set(k, String(v))
-        }
-    }
-
-    const headers = await resolveHeaders()
-    const res = await fetchWithRetry(url.toString(), { headers, credentials: 'same-origin' })
-    if (!res.ok) throw new MizanError(res.status, await res.text())
-    return res.json()
+    return config.transport.fetch(contextName, params)
 }
 
 export async function mizanCall(
     functionName: string,
     args: Record<string, any>,
 ): Promise<any> {
-    const headers = await resolveHeaders()
-    headers['Content-Type'] = 'application/json'
-
-    const res = await fetch(`${config.baseUrl}/call/`, {
-        method: 'POST',
-        headers,
-        credentials: 'same-origin',
-        body: JSON.stringify({ fn: functionName, args }),
-    })
-    if (!res.ok) throw new MizanError(res.status, await res.text())
-
-    const data = await res.json()
+    const data = await config.transport.call(functionName, args)
 
     // Server-driven merges run before invalidations so a context that is
     // both merged-into and invalidated ends in the invalidation state — the
@@ -395,9 +463,12 @@ export async function mizanCall(
         for (const entry of data.invalidate) {
             if (typeof entry === 'string') {
                 invalidate(entry)
-            } else {
+            } else if ('context' in entry) {
                 invalidate(entry.context, entry.params)
             }
+            // {function: name} entries route through the kernel's
+            // function-output cache layer, which lives in the framework
+            // adapter; mizan-base treats them as a no-op here.
         }
     }