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-tauri-transport/package.json

@@ -0,0 +1,15 @@
+{
+  "name": "@mizan/tauri-transport",
+  "version": "0.1.0",
+  "description": "Mizan transport adapter routing calls through Tauri's IPC instead of HTTP. Paired with the `mizan-tauri` Rust plugin.",
+  "type": "module",
+  "main": "src/index.ts",
+  "exports": {
+    ".": "./src/index.ts"
+  },
+  "peerDependencies": {
+    "@mizan/base": "*",
+    "@tauri-apps/api": "^2"
+  },
+  "license": "MIT"
+}

frontends/mizan-tauri-transport/src/index.ts

@@ -0,0 +1,81 @@
+/**
+ * @mizan/tauri-transport — routes Mizan calls through Tauri's IPC
+ * instead of HTTP fetch. Paired with the `mizan-tauri` Rust plugin
+ * (which exposes a single `mizan_invoke` command).
+ *
+ * Usage:
+ *
+ *   import { configure } from '@mizan/base'
+ *   import { tauriTransport } from '@mizan/tauri-transport'
+ *
+ *   configure({ transport: tauriTransport() })
+ *
+ * The transport keeps the same protocol surface as the HTTP transport
+ * (call/fetch envelopes, {result, invalidate, merge} response shape),
+ * so the codegen output and React adapter are unchanged — only the
+ * wire channel differs.
+ */
+
+import { invoke } from '@tauri-apps/api/core'
+import { MizanError, type MizanCallResponse, type MizanTransport } from '@mizan/base'
+
+/** Plugin-prefixed Tauri command — `init()` on the Rust side installs
+ * the plugin under the name `mizan`, so the dispatch command is
+ * reachable from JS as `plugin:mizan|mizan_invoke`. */
+const COMMAND = 'plugin:mizan|mizan_invoke'
+
+type TauriError = {
+    code?: string
+    message?: string
+    details?: unknown
+}
+
+/**
+ * Wrap a `mizan-tauri` error payload into a `MizanError` so consumers
+ * see one error surface regardless of transport. Tauri's invoke()
+ * rejects with the raw `Err` payload from the Rust command; we re-shape
+ * it to the same `{error: {code, message, details}}` envelope the HTTP
+ * transport surfaces.
+ */
+function wrapError(raw: unknown): MizanError {
+    if (raw && typeof raw === 'object') {
+        const err = raw as TauriError
+        const body = JSON.stringify({ error: { code: err.code, message: err.message, details: err.details } })
+        // 0 means "no HTTP status" — the IPC transport bypassed the
+        // protocol's HTTP layer. The error envelope still carries
+        // .code/.message/.details so consumers don't have to special-case.
+        return new MizanError(0, body)
+    }
+    return new MizanError(0, JSON.stringify({ error: { message: String(raw) } }))
+}
+
+/**
+ * Build a Mizan transport that routes through Tauri's IPC. Install via:
+ *
+ *   import { configure } from '@mizan/base'
+ *   import { tauriTransport } from '@mizan/tauri-transport'
+ *   configure({ transport: tauriTransport() })
+ */
+export function tauriTransport(): MizanTransport {
+    return {
+        async call(fnName, args): Promise<MizanCallResponse> {
+            try {
+                const data = await invoke<MizanCallResponse>(COMMAND, {
+                    envelope: { op: 'call', fn: fnName, args },
+                })
+                return data
+            } catch (e) {
+                throw wrapError(e)
+            }
+        },
+        async fetch(contextName, params) {
+            try {
+                return await invoke(COMMAND, {
+                    envelope: { op: 'fetch', context: contextName, params: params ?? {} },
+                })
+            } catch (e) {
+                throw wrapError(e)
+            }
+        },
+    }
+}