feat: websocket-based rpc

Cargo.lock

@@ -546,6 +546,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "8b52af3cb4058c895d37317bb27508dccc8e5f2d39454016b297bf4a400597b8"
 dependencies = [
  "axum-core",
+ "base64 0.22.1",
  "bytes",
  "form_urlencoded",
  "futures-util",
@@ -558,15 +559,16 @@ dependencies = [
  "matchit",
  "memchr",
  "mime",
- "multer",
  "percent-encoding",
  "pin-project-lite",
  "serde_core",
  "serde_json",
  "serde_path_to_error",
  "serde_urlencoded",
+ "sha1",
  "sync_wrapper",
  "tokio",
+ "tokio-tungstenite",
  "tower",
  "tower-layer",
  "tower-service",
@@ -1564,6 +1566,12 @@ dependencies = [
  "serde",
 ]
 
+[[package]]
+name = "data-encoding"
+version = "2.10.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d7a1e2f27636f116493b8b860f5546edb47c8d8f8ea73e1d2a20be88e28d1fea"
+
 [[package]]
 name = "deranged"
 version = "0.5.5"
@@ -1870,6 +1878,18 @@ dependencies = [
  "syn 2.0.114",
 ]
 
+[[package]]
+name = "enum_dispatch"
+version = "0.3.13"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "aa18ce2bc66555b3218614519ac839ddb759a7d6720732f979ef8d13be147ecd"
+dependencies = [
+ "once_cell",
+ "proc-macro2",
+ "quote",
+ "syn 2.0.114",
+]
+
 [[package]]
 name = "enumflags2"
 version = "0.7.12"
@@ -4059,10 +4079,12 @@ name = "koharu"
 version = "0.30.1"
 dependencies = [
  "anyhow",
+ "async-trait",
  "axum",
  "blake3",
  "clap",
  "dirs",
+ "enum_dispatch",
  "futures",
  "git-version",
  "icu",
@@ -4076,7 +4098,8 @@ dependencies = [
  "postcard",
  "rayon",
  "rfd",
- "rust-embed",
+ "rmp-serde",
+ "rmpv",
  "serde",
  "serde_bytes",
  "strum",
@@ -4085,6 +4108,7 @@ dependencies = [
  "tauri-build",
  "thiserror 2.0.18",
  "tokio",
+ "tower",
  "tower-http",
  "tracing",
  "tracing-subscriber",
@@ -4630,23 +4654,6 @@ dependencies = [
  "windows-sys 0.60.2",
 ]
 
-[[package]]
-name = "multer"
-version = "3.1.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "83e87776546dc87511aa5ee218730c92b666d7264ab6ed41f9d215af9cd5224b"
-dependencies = [
- "bytes",
- "encoding_rs",
- "futures-util",
- "http",
- "httparse",
- "memchr",
- "mime",
- "spin",
- "version_check",
-]
-
 [[package]]
 name = "naga"
 version = "28.0.0"
@@ -6373,48 +6380,42 @@ dependencies = [
 ]
 
 [[package]]
-name = "roxmltree"
-version = "0.21.1"
+name = "rmp"
+version = "0.8.15"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f1964b10c76125c36f8afe190065a4bf9a87bf324842c05701330bba9f1cacbb"
+checksum = "4ba8be72d372b2c9b35542551678538b562e7cf86c3315773cae48dfbfe7790c"
 dependencies = [
- "memchr",
+ "num-traits",
 ]
 
 [[package]]
-name = "rust-embed"
-version = "8.11.0"
+name = "rmp-serde"
+version = "1.3.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "04113cb9355a377d83f06ef1f0a45b8ab8cd7d8b1288160717d66df5c7988d27"
+checksum = "72f81bee8c8ef9b577d1681a70ebbc962c232461e397b22c208c43c04b67a155"
 dependencies = [
- "rust-embed-impl",
- "rust-embed-utils",
- "walkdir",
+ "rmp",
+ "serde",
 ]
 
 [[package]]
-name = "rust-embed-impl"
-version = "8.11.0"
+name = "rmpv"
+version = "1.3.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "da0902e4c7c8e997159ab384e6d0fc91c221375f6894346ae107f47dd0f3ccaa"
+checksum = "7a4e1d4b9b938a26d2996af33229f0ca0956c652c1375067f0b45291c1df8417"
 dependencies = [
- "proc-macro2",
- "quote",
- "rust-embed-utils",
- "shellexpand",
- "syn 2.0.114",
- "walkdir",
+ "rmp",
+ "serde",
+ "serde_bytes",
 ]
 
 [[package]]
-name = "rust-embed-utils"
-version = "8.11.0"
+name = "roxmltree"
+version = "0.21.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5bcdef0be6fe7f6fa333b1073c949729274b05f123a0ad7efcb8efd878e5c3b1"
+checksum = "f1964b10c76125c36f8afe190065a4bf9a87bf324842c05701330bba9f1cacbb"
 dependencies = [
- "mime_guess",
- "sha2",
- "walkdir",
+ "memchr",
 ]
 
 [[package]]
@@ -6905,15 +6906,6 @@ dependencies = [
  "lazy_static",
 ]
 
-[[package]]
-name = "shellexpand"
-version = "3.1.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8b1fdf65dd6331831494dd616b30351c38e96e45921a27745cf98490458b90bb"
-dependencies = [
- "dirs",
-]
-
 [[package]]
 name = "shlex"
 version = "1.3.0"
@@ -7793,6 +7785,18 @@ dependencies = [
  "tokio",
 ]
 
+[[package]]
+name = "tokio-tungstenite"
+version = "0.28.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d25a406cddcc431a75d3d9afc6a7c0f7428d4891dd973e4d54c56b46127bf857"
+dependencies = [
+ "futures-util",
+ "log",
+ "tokio",
+ "tungstenite",
+]
+
 [[package]]
 name = "tokio-util"
 version = "0.7.18"
@@ -8070,6 +8074,23 @@ version = "0.25.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "d2df906b07856748fa3f6e0ad0cbaa047052d4a7dd609e231c4f72cee8c36f31"
 
+[[package]]
+name = "tungstenite"
+version = "0.28.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8628dcc84e5a09eb3d8423d6cb682965dea9133204e8fb3efee74c2a0c259442"
+dependencies = [
+ "bytes",
+ "data-encoding",
+ "http",
+ "httparse",
+ "log",
+ "rand 0.9.2",
+ "sha1",
+ "thiserror 2.0.18",
+ "utf-8",
+]
+
 [[package]]
 name = "typed-path"
 version = "0.12.2"

Cargo.toml

@@ -106,13 +106,13 @@ fontdue = "0.9"
 wgpu = "28.0"
 etagere = "0.2"
 bytemuck = { version = "1.21", features = ["derive"] }
-axum = { version = "0.8", features = ["json", "multipart"] }
-tower-http = { version = "0.6", features = ["fs", "cors"] }
-rust-embed = { version = "8.11", features = [
-    "interpolate-folder-path",
-    "debug-embed",
-    "mime-guess",
-] }
+axum = { version = "0.8", features = ["ws"] }
+tower-http = { version = "0.6", features = ["fs"] }
+tower = { version = "0.5", features = ["timeout", "util"] }
+rmp-serde = "1"
+rmpv = { version = "1", features = ["with-serde"] }
+enum_dispatch = "0.3"
+async-trait = "0.1"
 criterion = { version = "0.8", features = ["html_reports"] }
 git-version = "0.3"
 

koharu/Cargo.toml

@@ -50,7 +50,11 @@ sys-locale = { workspace = true }
 icu = { workspace = true }
 axum = { workspace = true }
 tower-http = { workspace = true }
-rust-embed = { workspace = true }
+tower = { workspace = true }
+rmp-serde = { workspace = true }
+rmpv = { workspace = true }
+enum_dispatch = { workspace = true }
+async-trait = { workspace = true }
 git-version = { workspace = true }
 
 [target.'cfg(target_os = "windows")'.dependencies]

koharu/src/app.rs

@@ -1,10 +1,4 @@
-use std::{
-    path::PathBuf,
-    sync::{
-        Arc,
-        atomic::{AtomicU16, Ordering},
-    },
-};
+use std::{path::PathBuf, sync::Arc};
 
 use anyhow::{Context, Result};
 use clap::Parser;
@@ -17,8 +11,9 @@ use tokio::{net::TcpListener, sync::RwLock};
 use tracing_subscriber::fmt::format::FmtSpan;
 
 use crate::{
-    command, llm, ml,
+    llm, ml,
     renderer::Renderer,
+    rpc::SharedResources,
     server,
     state::{AppState, State},
 };
@@ -165,13 +160,11 @@ async fn update_app() -> Result<()> {
 async fn prefetch() -> Result<()> {
     ensure_dylibs(LIB_ROOT.to_path_buf()).await?;
     ml::prefetch().await?;
-    // Skip for now as it's too big
-    // llm::prefetch().await?;
 
     Ok(())
 }
 
-async fn build_resources(cpu: bool, _register_file_assoc: bool) -> Result<AppResources> {
+async fn build_resources(cpu: bool) -> Result<AppResources> {
     if cuda_is_available() {
         ensure_dylibs(LIB_ROOT.to_path_buf())
             .await
@@ -180,7 +173,7 @@ async fn build_resources(cpu: bool, _register_file_assoc: bool) -> Result<AppRes
 
         #[cfg(target_os = "windows")]
         {
-            if _register_file_assoc && let Err(err) = crate::windows::register_khr() {
+            if let Err(err) = crate::windows::register_khr() {
                 tracing::warn!(?err, "Failed to register .khr file association");
             }
 
@@ -237,64 +230,49 @@ pub async fn run() -> Result<()> {
         }
     });
 
-    if headless {
-        let resources = build_resources(cpu, false).await?;
-        let listener = TcpListener::bind(format!("127.0.0.1:{}", port.unwrap_or(0))).await?;
+    let listener = TcpListener::bind(format!("127.0.0.1:{}", port.unwrap_or(0))).await?;
+    let ws_port = listener.local_addr()?.port();
+    let shared: SharedResources = Arc::new(tokio::sync::OnceCell::new());
 
-        let server_resources = resources.clone();
-        tokio::spawn(async move {
-            if let Err(err) = server::serve_with_listener(listener, server_resources).await {
-                tracing::error!("HTTP server error: {err:#}");
+    let app = tauri::Builder::default()
+        .append_invoke_initialization_script(format!("window.__KOHARU_WS_PORT__ = {};", ws_port))
+        .build(tauri::generate_context!())?;
+
+    let resolver = Arc::new(app.asset_resolver());
+    tokio::spawn({
+        let shared = shared.clone();
+        async move {
+            if let Err(err) = server::serve_with_listener(listener, shared, resolver).await {
+                tracing::error!("Server error: {err:#}");
             }
-        });
+        }
+    });
 
+    if headless {
+        let resources = build_resources(cpu).await?;
+        shared.set(resources).ok();
         tokio::signal::ctrl_c().await?;
-        return Ok(());
+    } else {
+        let handle = app.handle().clone();
+        tokio::spawn(async move {
+            let resources = build_resources(cpu)
+                .await
+                .expect("failed to build app resources");
+            shared.set(resources).ok();
+
+            handle
+                .get_webview_window("splashscreen")
+                .expect("splashscreen window not found")
+                .close()
+                .ok();
+            handle
+                .get_webview_window("main")
+                .expect("main window not found")
+                .show()
+                .ok();
+        });
+        app.run(|_, _| {});
     }
 
-    tauri::Builder::default()
-        .invoke_handler(tauri::generate_handler![
-            command::initialize,
-            command::download_progress,
-        ])
-        .manage(AtomicU16::new(0))
-        .setup(move |app| {
-            let handle = app.handle().clone();
-            tauri::async_runtime::spawn(async move {
-                let resources = build_resources(cpu, true)
-                    .await
-                    .expect("failed to build app resources");
-                let listener = TcpListener::bind(format!("127.0.0.1:{}", port.unwrap_or(0)))
-                    .await
-                    .expect("failed to bind HTTP server");
-                let port = listener
-                    .local_addr()
-                    .expect("failed to get listener address")
-                    .port();
-
-                handle.state::<AtomicU16>().store(port, Ordering::SeqCst);
-
-                let server_resources = resources.clone();
-                tokio::spawn(async move {
-                    server::serve_with_listener(listener, server_resources)
-                        .await
-                        .expect("failed to run HTTP server");
-                });
-
-                handle
-                    .get_webview_window("splashscreen")
-                    .expect("splashscreen window not found")
-                    .close()
-                    .ok();
-                handle
-                    .get_webview_window("main")
-                    .expect("main window not found")
-                    .show()
-                    .ok();
-            });
-            Ok(())
-        })
-        .run(tauri::generate_context!())?;
-
     Ok(())
 }

koharu/src/command.rs

@@ -1,39 +0,0 @@
-use std::sync::atomic::{AtomicU16, Ordering};
-
-use tauri::State;
-use tauri::ipc::Channel;
-
-use crate::result::Result;
-
-#[tauri::command]
-pub async fn initialize(port: State<'_, AtomicU16>) -> Result<u16> {
-    loop {
-        let p = port.load(Ordering::SeqCst);
-        if p != 0 {
-            return Ok(p);
-        }
-
-        tokio::time::sleep(std::time::Duration::from_millis(50)).await;
-    }
-}
-
-#[tauri::command]
-pub async fn download_progress(
-    channel: Channel<koharu_core::download::DownloadProgress>,
-) -> Result<()> {
-    let mut rx = koharu_core::download::subscribe();
-    tokio::spawn(async move {
-        loop {
-            match rx.recv().await {
-                Ok(progress) => {
-                    if channel.send(progress).is_err() {
-                        break;
-                    }
-                }
-                Err(tokio::sync::broadcast::error::RecvError::Lagged(_)) => continue,
-                Err(tokio::sync::broadcast::error::RecvError::Closed) => break,
-            }
-        }
-    });
-    Ok(())
-}

koharu/src/lib.rs

@@ -1,13 +1,13 @@
 pub mod app;
-pub mod command;
-pub mod endpoints;
 pub mod image;
 pub mod khr;
 pub mod llm;
 pub mod ml;
+pub mod operations;
 pub mod pipeline;
 pub mod renderer;
 pub mod result;
+pub mod rpc;
 pub mod server;
 pub mod state;
 pub mod version;

koharu/src/{endpoints.rs → operations.rs}

@@ -1,20 +1,8 @@
 use std::{io::Cursor, path::PathBuf, str::FromStr};
 
-use std::convert::Infallible;
-
-use axum::{
-    Json,
-    body::Body,
-    extract::{Multipart, State},
-    http::{HeaderValue, StatusCode, header},
-    response::{
-        Response,
-        sse::{Event, KeepAlive, Sse},
-    },
-};
 use image::{GenericImageView, ImageFormat, RgbaImage};
 use koharu_ml::llm::ModelId;
-use koharu_renderer::renderer::{TextShaderEffect, WgpuDeviceInfo};
+use koharu_renderer::renderer::TextShaderEffect;
 use rayon::iter::{IntoParallelIterator, ParallelIterator};
 use serde::{Deserialize, Serialize};
 use strum::IntoEnumIterator;
@@ -26,27 +14,26 @@ use crate::{
     image::SerializableDynamicImage,
     khr::{deserialize_khr, has_khr_magic, serialize_khr},
     llm,
-    result::Result,
     state::{Document, TextBlock},
     version,
 };
 
-pub async fn app_version(State(_state): State<AppResources>) -> Result<Json<String>> {
-    Ok(Json(version::current().to_string()))
+pub async fn app_version(_state: AppResources) -> anyhow::Result<String> {
+    Ok(version::current().to_string())
 }
 
 #[derive(Debug, Clone, Serialize, Deserialize)]
 #[serde(rename_all = "camelCase")]
 pub struct DeviceInfo {
     pub ml_device: String,
-    pub wgpu: WgpuDeviceInfo,
+    pub wgpu: koharu_renderer::renderer::WgpuDeviceInfo,
 }
 
-pub async fn device(State(state): State<AppResources>) -> Result<Json<DeviceInfo>> {
-    Ok(Json(DeviceInfo {
+pub async fn device(state: AppResources) -> anyhow::Result<DeviceInfo> {
+    Ok(DeviceInfo {
         ml_device: state.ml_device.to_string(),
         wgpu: state.renderer.wgpu_device_info(),
-    }))
+    })
 }
 
 #[derive(Debug, Deserialize)]
@@ -55,14 +42,14 @@ pub struct OpenExternalPayload {
     pub url: String,
 }
 
-pub async fn open_external(Json(payload): Json<OpenExternalPayload>) -> Result<Json<()>> {
+pub fn open_external(payload: OpenExternalPayload) -> anyhow::Result<()> {
     open::that(&payload.url)?;
-    Ok(Json(()))
+    Ok(())
 }
 
-pub async fn get_documents(State(state): State<AppResources>) -> Result<Json<usize>> {
+pub async fn get_documents(state: AppResources) -> anyhow::Result<usize> {
     let guard = state.state.read().await;
-    Ok(Json(guard.documents.len()))
+    Ok(guard.documents.len())
 }
 
 #[derive(Debug, Deserialize)]
@@ -71,23 +58,28 @@ pub struct IndexPayload {
     pub index: usize,
 }
 
-pub async fn get_document(
-    State(state): State<AppResources>,
-    Json(payload): Json<IndexPayload>,
-) -> Result<Json<Document>> {
+pub async fn get_document(state: AppResources, payload: IndexPayload) -> anyhow::Result<Document> {
     let guard = state.state.read().await;
-    let doc = guard
+    guard
         .documents
         .get(payload.index)
         .cloned()
-        .ok_or_else(|| anyhow::anyhow!("Document not found at index {}", payload.index))?;
-    Ok(Json(doc))
+        .ok_or_else(|| anyhow::anyhow!("Document not found at index {}", payload.index))
+}
+
+/// Returns WebP-encoded thumbnail bytes.
+#[derive(Debug, Serialize)]
+#[serde(rename_all = "camelCase")]
+pub struct ThumbnailResult {
+    #[serde(with = "serde_bytes")]
+    pub data: Vec<u8>,
+    pub content_type: String,
 }
 
 pub async fn get_thumbnail(
-    State(state): State<AppResources>,
-    Json(payload): Json<IndexPayload>,
-) -> Result<Response> {
+    state: AppResources,
+    payload: IndexPayload,
+) -> anyhow::Result<ThumbnailResult> {
     let guard = state.state.read().await;
     let doc = guard
         .documents
@@ -100,43 +92,60 @@ pub async fn get_thumbnail(
     let mut buf = Cursor::new(Vec::new());
     thumbnail.write_to(&mut buf, ImageFormat::WebP)?;
 
-    let mut response = Response::new(Body::from(buf.into_inner()));
-    response
-        .headers_mut()
-        .insert(header::CONTENT_TYPE, HeaderValue::from_static("image/webp"));
-    Ok(response)
+    Ok(ThumbnailResult {
+        data: buf.into_inner(),
+        content_type: "image/webp".to_string(),
+    })
+}
+
+#[derive(Debug, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct FileEntry {
+    pub name: String,
+    #[serde(with = "serde_bytes")]
+    pub data: Vec<u8>,
+}
+
+#[derive(Debug, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct OpenDocumentsPayload {
+    pub files: Vec<FileEntry>,
 }
 
 pub async fn open_documents(
-    State(state): State<AppResources>,
-    mut multipart: Multipart,
-) -> Result<Json<usize>> {
-    let mut inputs: Vec<(PathBuf, Vec<u8>)> = Vec::new();
-
-    while let Some(field) = multipart.next_field().await? {
-        let name = field
-            .file_name()
-            .map(|s| s.to_string())
-            .unwrap_or_else(|| "unknown".to_string());
-        let bytes = field.bytes().await?.to_vec();
-        inputs.push((PathBuf::from(name), bytes));
-    }
+    state: AppResources,
+    payload: OpenDocumentsPayload,
+) -> anyhow::Result<usize> {
+    let inputs: Vec<(PathBuf, Vec<u8>)> = payload
+        .files
+        .into_iter()
+        .map(|f| (PathBuf::from(f.name), f.data))
+        .collect();
 
     if inputs.is_empty() {
-        Err(anyhow::anyhow!("No files uploaded"))?;
+        anyhow::bail!("No files uploaded");
     }
 
     let docs = load_documents(inputs)?;
     let count = docs.len();
     let mut guard = state.state.write().await;
     guard.documents = docs;
-    Ok(Json(count))
+    Ok(count)
 }
 
-pub async fn save_documents(State(state): State<AppResources>) -> Result<Response> {
+#[derive(Debug, Serialize)]
+#[serde(rename_all = "camelCase")]
+pub struct FileResult {
+    pub filename: String,
+    #[serde(with = "serde_bytes")]
+    pub data: Vec<u8>,
+    pub content_type: String,
+}
+
+pub async fn save_documents(state: AppResources) -> anyhow::Result<FileResult> {
     let guard = state.state.read().await;
     if guard.documents.is_empty() {
-        Err(anyhow::anyhow!("No documents to save"))?;
+        anyhow::bail!("No documents to save");
     }
 
     let filename = if guard.documents.len() == 1 {
@@ -153,17 +162,17 @@ pub async fn save_documents(State(state): State<AppResources>) -> Result<Respons
     let bytes = serialize_khr(&guard.documents)?;
     drop(guard);
 
-    Ok(attachment_response(
-        &filename,
-        bytes,
-        "application/octet-stream",
-    )?)
+    Ok(FileResult {
+        filename,
+        data: bytes,
+        content_type: "application/octet-stream".to_string(),
+    })
 }
 
 pub async fn export_document(
-    State(state): State<AppResources>,
-    Json(payload): Json<IndexPayload>,
-) -> Result<Response> {
+    state: AppResources,
+    payload: IndexPayload,
+) -> anyhow::Result<FileResult> {
     let guard = state.state.read().await;
     let document = guard
         .documents
@@ -184,16 +193,18 @@ pub async fn export_document(
 
     let bytes = encode_image(rendered, &ext)?;
     let filename = format!("{}_koharu.{}", document.name, ext);
+    let content_type = mime_from_ext(&ext).to_string();
     drop(guard);
 
-    Ok(attachment_response(&filename, bytes, mime_from_ext(&ext))?)
+    Ok(FileResult {
+        filename,
+        data: bytes,
+        content_type,
+    })
 }
 
 #[instrument(level = "info", skip_all)]
-pub async fn detect(
-    State(state): State<AppResources>,
-    Json(payload): Json<IndexPayload>,
-) -> Result<Json<()>> {
+pub async fn detect(state: AppResources, payload: IndexPayload) -> anyhow::Result<()> {
     let mut snapshot = {
         let guard = state.state.read().await;
         guard
@@ -211,14 +222,11 @@ pub async fn detect(
         .get_mut(payload.index)
         .ok_or_else(|| anyhow::anyhow!("Document not found"))?;
     *document = snapshot;
-    Ok(Json(()))
+    Ok(())
 }
 
 #[instrument(level = "info", skip_all)]
-pub async fn ocr(
-    State(state): State<AppResources>,
-    Json(payload): Json<IndexPayload>,
-) -> Result<Json<()>> {
+pub async fn ocr(state: AppResources, payload: IndexPayload) -> anyhow::Result<()> {
     let mut snapshot = {
         let guard = state.state.read().await;
         guard
@@ -236,14 +244,11 @@ pub async fn ocr(
         .get_mut(payload.index)
         .ok_or_else(|| anyhow::anyhow!("Document not found"))?;
     *document = snapshot;
-    Ok(Json(()))
+    Ok(())
 }
 
 #[instrument(level = "info", skip_all)]
-pub async fn inpaint(
-    State(state): State<AppResources>,
-    Json(payload): Json<IndexPayload>,
-) -> Result<Json<()>> {
+pub async fn inpaint(state: AppResources, payload: IndexPayload) -> anyhow::Result<()> {
     let mut snapshot = {
         let guard = state.state.read().await;
         guard
@@ -261,21 +266,22 @@ pub async fn inpaint(
         .get_mut(payload.index)
         .ok_or_else(|| anyhow::anyhow!("Document not found"))?;
     *document = snapshot;
-    Ok(Json(()))
+    Ok(())
 }
 
 #[derive(Debug, Deserialize)]
 #[serde(rename_all = "camelCase")]
 pub struct UpdateInpaintMaskPayload {
     pub index: usize,
+    #[serde(with = "serde_bytes")]
     pub mask: Vec<u8>,
     pub region: Option<InpaintRegion>,
 }
 
 pub async fn update_inpaint_mask(
-    State(state): State<AppResources>,
-    Json(payload): Json<UpdateInpaintMaskPayload>,
-) -> Result<Json<()>> {
+    state: AppResources,
+    payload: UpdateInpaintMaskPayload,
+) -> anyhow::Result<()> {
     let snapshot = {
         let guard = state.state.read().await;
         guard
@@ -298,13 +304,13 @@ pub async fn update_inpaint_mask(
         Some(region) => {
             let (patch_width, patch_height) = update_image.dimensions();
             if patch_width != region.width || patch_height != region.height {
-                Err(anyhow::anyhow!(
+                anyhow::bail!(
                     "Mask patch size mismatch: expected {}x{}, got {}x{}",
                     region.width,
                     region.height,
                     patch_width,
                     patch_height
-                ))?;
+                );
             }
 
             let x0 = region.x.min(doc_width.saturating_sub(1));
@@ -313,7 +319,7 @@ pub async fn update_inpaint_mask(
             let y1 = region.y.saturating_add(region.height).min(doc_height);
 
             if x1 <= x0 || y1 <= y0 {
-                return Ok(Json(()));
+                return Ok(());
             }
 
             let patch_rgba = update_image.to_rgba8();
@@ -326,13 +332,13 @@ pub async fn update_inpaint_mask(
         None => {
             let (mask_width, mask_height) = update_image.dimensions();
             if mask_width != doc_width || mask_height != doc_height {
-                Err(anyhow::anyhow!(
+                anyhow::bail!(
                     "Mask size mismatch: expected {}x{}, got {}x{}",
                     doc_width,
                     doc_height,
                     mask_width,
                     mask_height
-                ))?;
+                );
             }
             base_mask = update_image.to_rgba8();
         }
@@ -347,21 +353,22 @@ pub async fn update_inpaint_mask(
         .get_mut(payload.index)
         .ok_or_else(|| anyhow::anyhow!("Document not found"))?;
     *document = updated;
-    Ok(Json(()))
+    Ok(())
 }
 
 #[derive(Debug, Deserialize)]
 #[serde(rename_all = "camelCase")]
 pub struct UpdateBrushLayerPayload {
     pub index: usize,
+    #[serde(with = "serde_bytes")]
     pub patch: Vec<u8>,
     pub region: InpaintRegion,
 }
 
 pub async fn update_brush_layer(
-    State(state): State<AppResources>,
-    Json(payload): Json<UpdateBrushLayerPayload>,
-) -> Result<Json<()>> {
+    state: AppResources,
+    payload: UpdateBrushLayerPayload,
+) -> anyhow::Result<()> {
     let snapshot = {
         let guard = state.state.read().await;
         guard
@@ -373,20 +380,20 @@ pub async fn update_brush_layer(
 
     let (img_width, img_height) = (snapshot.width, snapshot.height);
     let Some((x0, y0, width, height)) = clamp_region(&payload.region, img_width, img_height) else {
-        return Ok(Json(()));
+        return Ok(());
     };
 
     let patch_image = image::load_from_memory(&payload.patch)?;
     let (patch_width, patch_height) = patch_image.dimensions();
 
     if patch_width != payload.region.width || patch_height != payload.region.height {
-        Err(anyhow::anyhow!(
+        anyhow::bail!(
             "Brush patch size mismatch: expected {}x{}, got {}x{}",
             payload.region.width,
             payload.region.height,
             patch_width,
             patch_height
-        ))?;
+        );
     }
 
     let brush_rgba = patch_image.to_rgba8();
@@ -411,7 +418,7 @@ pub async fn update_brush_layer(
         .get_mut(payload.index)
         .ok_or_else(|| anyhow::anyhow!("Document not found"))?;
     *document = updated;
-    Ok(Json(()))
+    Ok(())
 }
 
 #[derive(Debug, Deserialize)]
@@ -423,9 +430,9 @@ pub struct InpaintPartialPayload {
 
 #[instrument(level = "info", skip_all)]
 pub async fn inpaint_partial(
-    State(state): State<AppResources>,
-    Json(payload): Json<InpaintPartialPayload>,
-) -> Result<Json<()>> {
+    state: AppResources,
+    payload: InpaintPartialPayload,
+) -> anyhow::Result<()> {
     let snapshot = {
         let guard = state.state.read().await;
         guard
@@ -441,7 +448,7 @@ pub async fn inpaint_partial(
         .ok_or_else(|| anyhow::anyhow!("Segment image not found"))?;
 
     if payload.region.width == 0 || payload.region.height == 0 {
-        return Ok(Json(()));
+        return Ok(());
     }
 
     let (img_width, img_height) = (snapshot.width, snapshot.height);
@@ -461,7 +468,7 @@ pub async fn inpaint_partial(
     let crop_height = y1.saturating_sub(y0);
 
     if crop_width == 0 || crop_height == 0 {
-        return Ok(Json(()));
+        return Ok(());
     }
 
     let patch_x1 = x0 + crop_width;
@@ -476,7 +483,7 @@ pub async fn inpaint_partial(
     });
 
     if !overlaps_text {
-        return Ok(Json(()));
+        return Ok(());
     }
 
     let image_crop =
@@ -517,7 +524,7 @@ pub async fn inpaint_partial(
         .get_mut(payload.index)
         .ok_or_else(|| anyhow::anyhow!("Document not found"))?;
     *document = updated;
-    Ok(Json(()))
+    Ok(())
 }
 
 #[derive(Debug, Deserialize)]
@@ -529,10 +536,7 @@ pub struct RenderPayload {
 }
 
 #[instrument(level = "info", skip_all)]
-pub async fn render(
-    State(state): State<AppResources>,
-    Json(payload): Json<RenderPayload>,
-) -> Result<Json<()>> {
+pub async fn render(state: AppResources, payload: RenderPayload) -> anyhow::Result<()> {
     let snapshot = {
         let guard = state.state.read().await;
         guard
@@ -555,7 +559,7 @@ pub async fn render(
         .get_mut(payload.index)
         .ok_or_else(|| anyhow::anyhow!("Document not found"))?;
     *document = updated;
-    Ok(Json(()))
+    Ok(())
 }
 
 #[derive(Debug, Deserialize)]
@@ -566,23 +570,23 @@ pub struct UpdateTextBlocksPayload {
 }
 
 pub async fn update_text_blocks(
-    State(state): State<AppResources>,
-    Json(payload): Json<UpdateTextBlocksPayload>,
-) -> Result<Json<()>> {
+    state: AppResources,
+    payload: UpdateTextBlocksPayload,
+) -> anyhow::Result<()> {
     let mut guard = state.state.write().await;
     let document = guard
         .documents
         .get_mut(payload.index)
         .ok_or_else(|| anyhow::anyhow!("Document not found"))?;
     document.text_blocks = payload.text_blocks;
-    Ok(Json(()))
+    Ok(())
 }
 
-pub async fn list_font_families(State(state): State<AppResources>) -> Result<Json<Vec<String>>> {
-    Ok(Json(state.renderer.available_fonts()?))
+pub async fn list_font_families(state: AppResources) -> anyhow::Result<Vec<String>> {
+    state.renderer.available_fonts()
 }
 
-pub async fn llm_list(State(state): State<AppResources>) -> Result<Json<Vec<llm::ModelInfo>>> {
+pub async fn llm_list(state: AppResources) -> anyhow::Result<Vec<llm::ModelInfo>> {
     let mut models: Vec<ModelId> = ModelId::iter().collect();
     let cpu_factor = if state.llm.is_cpu() { 10 } else { 1 };
     let zh_locale_factor = match get_locale().unwrap_or_default() {
@@ -602,7 +606,7 @@ pub async fn llm_list(State(state): State<AppResources>) -> Result<Json<Vec<llm:
         ModelId::HunyuanMT7B => 500 / non_zh_en_locale_factor,
     });
 
-    Ok(Json(models.into_iter().map(llm::ModelInfo::new).collect()))
+    Ok(models.into_iter().map(llm::ModelInfo::new).collect())
 }
 
 #[derive(Debug, Deserialize)]
@@ -612,22 +616,19 @@ pub struct LlmLoadPayload {
 }
 
 #[instrument(level = "info", skip_all)]
-pub async fn llm_load(
-    State(state): State<AppResources>,
-    Json(payload): Json<LlmLoadPayload>,
-) -> Result<Json<()>> {
+pub async fn llm_load(state: AppResources, payload: LlmLoadPayload) -> anyhow::Result<()> {
     let id = ModelId::from_str(&payload.id)?;
     state.llm.load(id).await;
-    Ok(Json(()))
+    Ok(())
 }
 
-pub async fn llm_offload(State(state): State<AppResources>) -> Result<Json<()>> {
+pub async fn llm_offload(state: AppResources) -> anyhow::Result<()> {
     state.llm.offload().await;
-    Ok(Json(()))
+    Ok(())
 }
 
-pub async fn llm_ready(State(state): State<AppResources>) -> Result<Json<bool>> {
-    Ok(Json(state.llm.ready().await))
+pub async fn llm_ready(state: AppResources) -> anyhow::Result<bool> {
+    Ok(state.llm.ready().await)
 }
 
 #[derive(Debug, Deserialize)]
@@ -639,10 +640,7 @@ pub struct LlmGeneratePayload {
 }
 
 #[instrument(level = "info", skip_all)]
-pub async fn llm_generate(
-    State(state): State<AppResources>,
-    Json(payload): Json<LlmGeneratePayload>,
-) -> Result<Json<()>> {
+pub async fn llm_generate(state: AppResources, payload: LlmGeneratePayload) -> anyhow::Result<()> {
     let snapshot = {
         let guard = state.state.read().await;
         guard
@@ -677,10 +675,49 @@ pub async fn llm_generate(
         .get_mut(payload.index)
         .ok_or_else(|| anyhow::anyhow!("Document not found"))?;
     *document = updated;
-    Ok(Json(()))
+    Ok(())
 }
 
-// Helpers
+// --- Auto-processing pipeline endpoints ---
+
+pub async fn process(
+    state: AppResources,
+    payload: crate::pipeline::ProcessRequest,
+) -> anyhow::Result<()> {
+    {
+        let guard = state.pipeline.read().await;
+        if guard.is_some() {
+            anyhow::bail!("A processing pipeline is already running");
+        }
+    }
+
+    let cancel = std::sync::Arc::new(std::sync::atomic::AtomicBool::new(false));
+    {
+        let mut guard = state.pipeline.write().await;
+        *guard = Some(crate::pipeline::PipelineHandle {
+            cancel: cancel.clone(),
+        });
+    }
+
+    let resources = state.clone();
+    tokio::spawn(async move {
+        crate::pipeline::run_pipeline(resources, payload, cancel).await;
+    });
+
+    Ok(())
+}
+
+pub async fn process_cancel(state: AppResources) -> anyhow::Result<()> {
+    let guard = state.pipeline.read().await;
+    if let Some(handle) = guard.as_ref() {
+        handle
+            .cancel
+            .store(true, std::sync::atomic::Ordering::Relaxed);
+    }
+    Ok(())
+}
+
+// --- Helpers ---
 
 #[derive(Debug, Clone, Serialize, Deserialize)]
 #[serde(rename_all = "camelCase")]
@@ -715,21 +752,13 @@ fn encode_image(image: &SerializableDynamicImage, ext: &str) -> anyhow::Result<V
     Ok(buf)
 }
 
-fn attachment_response(
-    filename: &str,
-    bytes: Vec<u8>,
-    content_type: &str,
-) -> anyhow::Result<Response> {
-    let mut response = Response::new(Body::from(bytes));
-    *response.status_mut() = StatusCode::OK;
-    response
-        .headers_mut()
-        .insert(header::CONTENT_TYPE, HeaderValue::from_str(content_type)?);
-    response.headers_mut().insert(
-        header::CONTENT_DISPOSITION,
-        HeaderValue::from_str(&format!("attachment; filename=\"{filename}\""))?,
-    );
-    Ok(response)
+fn mime_from_ext(ext: &str) -> &'static str {
+    match ext {
+        "png" => "image/png",
+        "jpg" | "jpeg" => "image/jpeg",
+        "webp" => "image/webp",
+        _ => "application/octet-stream",
+    }
 }
 
 pub fn load_documents(inputs: Vec<(PathBuf, Vec<u8>)>) -> anyhow::Result<Vec<Document>> {
@@ -760,87 +789,7 @@ pub fn load_documents(inputs: Vec<(PathBuf, Vec<u8>)>) -> anyhow::Result<Vec<Doc
     Ok(documents)
 }
 
-fn mime_from_ext(ext: &str) -> &'static str {
-    match ext {
-        "png" => "image/png",
-        "jpg" | "jpeg" => "image/jpeg",
-        "webp" => "image/webp",
-        _ => "application/octet-stream",
-    }
-}
-
 fn blank_rgba(width: u32, height: u32, color: image::Rgba<u8>) -> SerializableDynamicImage {
     let blank = RgbaImage::from_pixel(width, height, color);
     image::DynamicImage::ImageRgba8(blank).into()
 }
-
-pub async fn download_progress()
--> Sse<impl futures::Stream<Item = std::result::Result<Event, Infallible>>> {
-    let rx = koharu_core::download::subscribe();
-    let stream = futures::stream::unfold(rx, |mut rx| async {
-        loop {
-            match rx.recv().await {
-                Ok(p) => return Some((Ok(Event::default().json_data(p).unwrap()), rx)),
-                Err(tokio::sync::broadcast::error::RecvError::Lagged(_)) => continue,
-                Err(tokio::sync::broadcast::error::RecvError::Closed) => return None,
-            }
-        }
-    });
-    Sse::new(stream).keep_alive(KeepAlive::default())
-}
-
-// --- Auto-processing pipeline endpoints ---
-
-/// Start the processing pipeline. Returns immediately; progress is available
-/// via the `process_progress` SSE endpoint.
-pub async fn process(
-    State(state): State<AppResources>,
-    Json(payload): Json<crate::pipeline::ProcessRequest>,
-) -> Result<Json<()>> {
-    {
-        let guard = state.pipeline.read().await;
-        if guard.is_some() {
-            Err(anyhow::anyhow!("A processing pipeline is already running"))?;
-        }
-    }
-
-    let cancel = std::sync::Arc::new(std::sync::atomic::AtomicBool::new(false));
-    {
-        let mut guard = state.pipeline.write().await;
-        *guard = Some(crate::pipeline::PipelineHandle {
-            cancel: cancel.clone(),
-        });
-    }
-
-    let resources = state.clone();
-    tokio::spawn(async move {
-        crate::pipeline::run_pipeline(resources, payload, cancel).await;
-    });
-
-    Ok(Json(()))
-}
-
-pub async fn process_progress()
--> Sse<impl futures::Stream<Item = std::result::Result<Event, Infallible>>> {
-    let rx = crate::pipeline::subscribe();
-    let stream = futures::stream::unfold(rx, |mut rx| async {
-        loop {
-            match rx.recv().await {
-                Ok(p) => return Some((Ok(Event::default().json_data(p).unwrap()), rx)),
-                Err(tokio::sync::broadcast::error::RecvError::Lagged(_)) => continue,
-                Err(tokio::sync::broadcast::error::RecvError::Closed) => return None,
-            }
-        }
-    });
-    Sse::new(stream).keep_alive(KeepAlive::default())
-}
-
-pub async fn process_cancel(State(state): State<AppResources>) -> Result<Json<()>> {
-    let guard = state.pipeline.read().await;
-    if let Some(handle) = guard.as_ref() {
-        handle
-            .cancel
-            .store(true, std::sync::atomic::Ordering::Relaxed);
-    }
-    Ok(Json(()))
-}

koharu/src/result.rs

@@ -14,9 +14,6 @@ pub enum CommandError {
 
     #[error(transparent)]
     Image(#[from] image::ImageError),
-
-    #[error(transparent)]
-    Multipart(#[from] axum::extract::multipart::MultipartError),
 }
 
 impl serde::Serialize for CommandError {

koharu/src/rpc.rs

@@ -0,0 +1,569 @@
+use std::sync::Arc;
+use std::time::Duration;
+
+use anyhow::Result;
+use async_trait::async_trait;
+use axum::{
+    extract::{
+        State,
+        ws::{Message, WebSocket, WebSocketUpgrade},
+    },
+    response::IntoResponse,
+};
+use futures::{SinkExt, StreamExt};
+use serde::{Deserialize, Serialize};
+use tokio::sync::{broadcast, mpsc};
+use tower::{Service, ServiceBuilder, ServiceExt, service_fn, timeout::TimeoutLayer};
+
+use crate::app::AppResources;
+use crate::operations;
+
+// --- Shared Resources (lazy init) ---
+
+pub type SharedResources = Arc<tokio::sync::OnceCell<AppResources>>;
+
+// --- Wire Protocol ---
+
+#[derive(Debug, Deserialize)]
+struct RawIncoming {
+    id: u32,
+    method: String,
+    params: Option<rmpv::Value>,
+}
+
+#[derive(Debug, Serialize)]
+#[serde(tag = "type")]
+pub enum OutgoingMessage {
+    #[serde(rename = "res")]
+    Response {
+        id: u32,
+        #[serde(skip_serializing_if = "Option::is_none")]
+        result: Option<rmpv::Value>,
+        #[serde(skip_serializing_if = "Option::is_none")]
+        error: Option<String>,
+    },
+    #[serde(rename = "ntf")]
+    Notification { method: String, params: rmpv::Value },
+}
+
+fn ok_response(id: u32, result: rmpv::Value) -> OutgoingMessage {
+    OutgoingMessage::Response {
+        id,
+        result: Some(result),
+        error: None,
+    }
+}
+
+fn err_response(id: u32, msg: &str) -> OutgoingMessage {
+    OutgoingMessage::Response {
+        id,
+        result: None,
+        error: Some(msg.to_string()),
+    }
+}
+
+// --- Value conversion helpers ---
+
+fn to_value<T: Serialize>(val: &T) -> Result<rmpv::Value> {
+    let bytes = rmp_serde::to_vec_named(val)?;
+    Ok(rmp_serde::from_slice(&bytes)?)
+}
+
+fn from_value<T: serde::de::DeserializeOwned>(val: rmpv::Value) -> Result<T> {
+    let bytes = rmp_serde::to_vec_named(&val)?;
+    Ok(rmp_serde::from_slice(&bytes)?)
+}
+
+// --- Handler Trait ---
+
+#[async_trait]
+#[enum_dispatch::enum_dispatch]
+pub trait RpcCall {
+    async fn call(self, res: AppResources) -> Result<rmpv::Value>;
+}
+
+// --- Handler Structs ---
+
+// No-param handlers
+
+#[derive(Deserialize)]
+pub struct AppVersionHandler;
+
+#[async_trait]
+impl RpcCall for AppVersionHandler {
+    async fn call(self, state: AppResources) -> Result<rmpv::Value> {
+        let v = operations::app_version(state).await?;
+        to_value(&v)
+    }
+}
+
+#[derive(Deserialize)]
+pub struct DeviceHandler;
+
+#[async_trait]
+impl RpcCall for DeviceHandler {
+    async fn call(self, state: AppResources) -> Result<rmpv::Value> {
+        let v = operations::device(state).await?;
+        to_value(&v)
+    }
+}
+
+#[derive(Deserialize)]
+pub struct GetDocumentsHandler;
+
+#[async_trait]
+impl RpcCall for GetDocumentsHandler {
+    async fn call(self, state: AppResources) -> Result<rmpv::Value> {
+        let v = operations::get_documents(state).await?;
+        to_value(&v)
+    }
+}
+
+#[derive(Deserialize)]
+pub struct ListFontFamiliesHandler;
+
+#[async_trait]
+impl RpcCall for ListFontFamiliesHandler {
+    async fn call(self, state: AppResources) -> Result<rmpv::Value> {
+        let v = operations::list_font_families(state).await?;
+        to_value(&v)
+    }
+}
+
+#[derive(Deserialize)]
+pub struct LlmListHandler;
+
+#[async_trait]
+impl RpcCall for LlmListHandler {
+    async fn call(self, state: AppResources) -> Result<rmpv::Value> {
+        let v = operations::llm_list(state).await?;
+        to_value(&v)
+    }
+}
+
+#[derive(Deserialize)]
+pub struct LlmOffloadHandler;
+
+#[async_trait]
+impl RpcCall for LlmOffloadHandler {
+    async fn call(self, state: AppResources) -> Result<rmpv::Value> {
+        operations::llm_offload(state).await?;
+        Ok(rmpv::Value::Nil)
+    }
+}
+
+#[derive(Deserialize)]
+pub struct LlmReadyHandler;
+
+#[async_trait]
+impl RpcCall for LlmReadyHandler {
+    async fn call(self, state: AppResources) -> Result<rmpv::Value> {
+        let v = operations::llm_ready(state).await?;
+        to_value(&v)
+    }
+}
+
+#[derive(Deserialize)]
+pub struct SaveDocumentsHandler;
+
+#[async_trait]
+impl RpcCall for SaveDocumentsHandler {
+    async fn call(self, state: AppResources) -> Result<rmpv::Value> {
+        let v = operations::save_documents(state).await?;
+        to_value(&v)
+    }
+}
+
+#[derive(Deserialize)]
+pub struct ProcessCancelHandler;
+
+#[async_trait]
+impl RpcCall for ProcessCancelHandler {
+    async fn call(self, state: AppResources) -> Result<rmpv::Value> {
+        operations::process_cancel(state).await?;
+        Ok(rmpv::Value::Nil)
+    }
+}
+
+// Index-based handlers (wrapping IndexPayload)
+
+#[derive(Deserialize)]
+#[serde(transparent)]
+pub struct GetDocumentHandler(operations::IndexPayload);
+
+#[async_trait]
+impl RpcCall for GetDocumentHandler {
+    async fn call(self, state: AppResources) -> Result<rmpv::Value> {
+        let v = operations::get_document(state, self.0).await?;
+        to_value(&v)
+    }
+}
+
+#[derive(Deserialize)]
+#[serde(transparent)]
+pub struct GetThumbnailHandler(operations::IndexPayload);
+
+#[async_trait]
+impl RpcCall for GetThumbnailHandler {
+    async fn call(self, state: AppResources) -> Result<rmpv::Value> {
+        let v = operations::get_thumbnail(state, self.0).await?;
+        to_value(&v)
+    }
+}
+
+#[derive(Deserialize)]
+#[serde(transparent)]
+pub struct ExportDocumentHandler(operations::IndexPayload);
+
+#[async_trait]
+impl RpcCall for ExportDocumentHandler {
+    async fn call(self, state: AppResources) -> Result<rmpv::Value> {
+        let v = operations::export_document(state, self.0).await?;
+        to_value(&v)
+    }
+}
+
+#[derive(Deserialize)]
+#[serde(transparent)]
+pub struct DetectHandler(operations::IndexPayload);
+
+#[async_trait]
+impl RpcCall for DetectHandler {
+    async fn call(self, state: AppResources) -> Result<rmpv::Value> {
+        operations::detect(state, self.0).await?;
+        Ok(rmpv::Value::Nil)
+    }
+}
+
+#[derive(Deserialize)]
+#[serde(transparent)]
+pub struct OcrHandler(operations::IndexPayload);
+
+#[async_trait]
+impl RpcCall for OcrHandler {
+    async fn call(self, state: AppResources) -> Result<rmpv::Value> {
+        operations::ocr(state, self.0).await?;
+        Ok(rmpv::Value::Nil)
+    }
+}
+
+#[derive(Deserialize)]
+#[serde(transparent)]
+pub struct InpaintHandler(operations::IndexPayload);
+
+#[async_trait]
+impl RpcCall for InpaintHandler {
+    async fn call(self, state: AppResources) -> Result<rmpv::Value> {
+        operations::inpaint(state, self.0).await?;
+        Ok(rmpv::Value::Nil)
+    }
+}
+
+// Complex payload handlers
+
+#[derive(Deserialize)]
+#[serde(transparent)]
+pub struct OpenExternalHandler(operations::OpenExternalPayload);
+
+#[async_trait]
+impl RpcCall for OpenExternalHandler {
+    async fn call(self, _state: AppResources) -> Result<rmpv::Value> {
+        operations::open_external(self.0)?;
+        Ok(rmpv::Value::Nil)
+    }
+}
+
+#[derive(Deserialize)]
+#[serde(transparent)]
+pub struct OpenDocumentsHandler(operations::OpenDocumentsPayload);
+
+#[async_trait]
+impl RpcCall for OpenDocumentsHandler {
+    async fn call(self, state: AppResources) -> Result<rmpv::Value> {
+        let v = operations::open_documents(state, self.0).await?;
+        to_value(&v)
+    }
+}
+
+#[derive(Deserialize)]
+#[serde(transparent)]
+pub struct UpdateInpaintMaskHandler(operations::UpdateInpaintMaskPayload);
+
+#[async_trait]
+impl RpcCall for UpdateInpaintMaskHandler {
+    async fn call(self, state: AppResources) -> Result<rmpv::Value> {
+        operations::update_inpaint_mask(state, self.0).await?;
+        Ok(rmpv::Value::Nil)
+    }
+}
+
+#[derive(Deserialize)]
+#[serde(transparent)]
+pub struct UpdateBrushLayerHandler(operations::UpdateBrushLayerPayload);
+
+#[async_trait]
+impl RpcCall for UpdateBrushLayerHandler {
+    async fn call(self, state: AppResources) -> Result<rmpv::Value> {
+        operations::update_brush_layer(state, self.0).await?;
+        Ok(rmpv::Value::Nil)
+    }
+}
+
+#[derive(Deserialize)]
+#[serde(transparent)]
+pub struct InpaintPartialHandler(operations::InpaintPartialPayload);
+
+#[async_trait]
+impl RpcCall for InpaintPartialHandler {
+    async fn call(self, state: AppResources) -> Result<rmpv::Value> {
+        operations::inpaint_partial(state, self.0).await?;
+        Ok(rmpv::Value::Nil)
+    }
+}
+
+#[derive(Deserialize)]
+#[serde(transparent)]
+pub struct RenderHandler(operations::RenderPayload);
+
+#[async_trait]
+impl RpcCall for RenderHandler {
+    async fn call(self, state: AppResources) -> Result<rmpv::Value> {
+        operations::render(state, self.0).await?;
+        Ok(rmpv::Value::Nil)
+    }
+}
+
+#[derive(Deserialize)]
+#[serde(transparent)]
+pub struct UpdateTextBlocksHandler(operations::UpdateTextBlocksPayload);
+
+#[async_trait]
+impl RpcCall for UpdateTextBlocksHandler {
+    async fn call(self, state: AppResources) -> Result<rmpv::Value> {
+        operations::update_text_blocks(state, self.0).await?;
+        Ok(rmpv::Value::Nil)
+    }
+}
+
+#[derive(Deserialize)]
+#[serde(transparent)]
+pub struct LlmLoadHandler(operations::LlmLoadPayload);
+
+#[async_trait]
+impl RpcCall for LlmLoadHandler {
+    async fn call(self, state: AppResources) -> Result<rmpv::Value> {
+        operations::llm_load(state, self.0).await?;
+        Ok(rmpv::Value::Nil)
+    }
+}
+
+#[derive(Deserialize)]
+#[serde(transparent)]
+pub struct LlmGenerateHandler(operations::LlmGeneratePayload);
+
+#[async_trait]
+impl RpcCall for LlmGenerateHandler {
+    async fn call(self, state: AppResources) -> Result<rmpv::Value> {
+        operations::llm_generate(state, self.0).await?;
+        Ok(rmpv::Value::Nil)
+    }
+}
+
+#[derive(Deserialize)]
+#[serde(transparent)]
+pub struct ProcessHandler(crate::pipeline::ProcessRequest);
+
+#[async_trait]
+impl RpcCall for ProcessHandler {
+    async fn call(self, state: AppResources) -> Result<rmpv::Value> {
+        operations::process(state, self.0).await?;
+        Ok(rmpv::Value::Nil)
+    }
+}
+
+// --- Method Dispatch Enum ---
+
+#[derive(Deserialize)]
+#[serde(tag = "method", content = "params")]
+#[enum_dispatch::enum_dispatch(RpcCall)]
+pub enum Method {
+    #[serde(rename = "app_version")]
+    AppVersion(AppVersionHandler),
+    #[serde(rename = "device")]
+    Device(DeviceHandler),
+    #[serde(rename = "open_external")]
+    OpenExternal(OpenExternalHandler),
+    #[serde(rename = "get_documents")]
+    GetDocuments(GetDocumentsHandler),
+    #[serde(rename = "get_document")]
+    GetDocument(GetDocumentHandler),
+    #[serde(rename = "get_thumbnail")]
+    GetThumbnail(GetThumbnailHandler),
+    #[serde(rename = "open_documents")]
+    OpenDocuments(OpenDocumentsHandler),
+    #[serde(rename = "save_documents")]
+    SaveDocuments(SaveDocumentsHandler),
+    #[serde(rename = "export_document")]
+    ExportDocument(ExportDocumentHandler),
+    #[serde(rename = "detect")]
+    Detect(DetectHandler),
+    #[serde(rename = "ocr")]
+    Ocr(OcrHandler),
+    #[serde(rename = "inpaint")]
+    Inpaint(InpaintHandler),
+    #[serde(rename = "update_inpaint_mask")]
+    UpdateInpaintMask(UpdateInpaintMaskHandler),
+    #[serde(rename = "update_brush_layer")]
+    UpdateBrushLayer(UpdateBrushLayerHandler),
+    #[serde(rename = "inpaint_partial")]
+    InpaintPartial(InpaintPartialHandler),
+    #[serde(rename = "render")]
+    Render(RenderHandler),
+    #[serde(rename = "update_text_blocks")]
+    UpdateTextBlocks(UpdateTextBlocksHandler),
+    #[serde(rename = "list_font_families")]
+    ListFontFamilies(ListFontFamiliesHandler),
+    #[serde(rename = "llm_list")]
+    LlmList(LlmListHandler),
+    #[serde(rename = "llm_load")]
+    LlmLoad(LlmLoadHandler),
+    #[serde(rename = "llm_offload")]
+    LlmOffload(LlmOffloadHandler),
+    #[serde(rename = "llm_ready")]
+    LlmReady(LlmReadyHandler),
+    #[serde(rename = "llm_generate")]
+    LlmGenerate(LlmGenerateHandler),
+    #[serde(rename = "process")]
+    Process(ProcessHandler),
+    #[serde(rename = "process_cancel")]
+    ProcessCancel(ProcessCancelHandler),
+}
+
+/// Parse method name + params into a Method enum using serde adjacently-tagged deserialization.
+fn parse_call(method: &str, params: rmpv::Value) -> Result<Method> {
+    let tagged = rmpv::Value::Map(vec![
+        (
+            rmpv::Value::String("method".into()),
+            rmpv::Value::String(method.into()),
+        ),
+        (rmpv::Value::String("params".into()), params),
+    ]);
+    from_value(tagged)
+}
+
+// --- WebSocket State ---
+
+#[derive(Clone)]
+pub struct WsState {
+    pub resources: SharedResources,
+}
+
+// --- WebSocket Handler ---
+
+pub async fn ws_handler(ws: WebSocketUpgrade, State(state): State<WsState>) -> impl IntoResponse {
+    ws.max_message_size(1024 * 1024 * 1024)
+        .on_upgrade(|socket| handle_socket(socket, state))
+}
+
+async fn handle_socket(socket: WebSocket, state: WsState) {
+    let (mut ws_sender, mut ws_receiver) = socket.split();
+    let (tx, mut send_rx) = mpsc::channel::<OutgoingMessage>(256);
+
+    // Notification forwarders
+    spawn_notification_forwarder(
+        "download_progress",
+        koharu_core::download::subscribe(),
+        tx.clone(),
+    );
+    spawn_notification_forwarder("process_progress", crate::pipeline::subscribe(), tx.clone());
+
+    // Sender task: drain mpsc → WebSocket binary frames
+    let send_task = tokio::spawn(async move {
+        while let Some(msg) = send_rx.recv().await {
+            let Ok(bytes) = rmp_serde::to_vec_named(&msg) else {
+                continue;
+            };
+            if ws_sender.send(Message::Binary(bytes.into())).await.is_err() {
+                break;
+            }
+        }
+    });
+
+    // Tower dispatch service (cloned per request)
+    let dispatch_svc = ServiceBuilder::new()
+        .layer(TimeoutLayer::new(Duration::from_secs(300)))
+        .service(service_fn(
+            |(method, res): (Method, AppResources)| async move { method.call(res).await },
+        ));
+
+    // Receive loop
+    while let Some(Ok(msg)) = ws_receiver.next().await {
+        let data = match msg {
+            Message::Binary(data) => data,
+            Message::Close(_) => break,
+            _ => continue,
+        };
+
+        let raw: RawIncoming = match rmp_serde::from_slice(&data) {
+            Ok(r) => r,
+            Err(e) => {
+                let _ = tx
+                    .send(err_response(0, &format!("Decode error: {e}")))
+                    .await;
+                continue;
+            }
+        };
+
+        let id = raw.id;
+        let tx = tx.clone();
+        let resources = state.resources.clone();
+        let mut svc = dispatch_svc.clone();
+
+        tokio::spawn(async move {
+            let response = match resources.get() {
+                Some(res) => {
+                    let params = raw.params.unwrap_or(rmpv::Value::Nil);
+                    match parse_call(&raw.method, params) {
+                        Ok(method) => match svc.ready().await {
+                            Ok(ready) => match ready.call((method, res.clone())).await {
+                                Ok(result) => ok_response(id, result),
+                                Err(e) => err_response(id, &format!("{e:#}")),
+                            },
+                            Err(e) => err_response(id, &format!("{e}")),
+                        },
+                        Err(e) => err_response(id, &format!("{e:#}")),
+                    }
+                }
+                None => err_response(id, "Resources not initialized"),
+            };
+            let _ = tx.send(response).await;
+        });
+    }
+
+    send_task.abort();
+}
+
+fn spawn_notification_forwarder<T: Serialize + Clone + Send + 'static>(
+    method: &'static str,
+    mut rx: broadcast::Receiver<T>,
+    tx: mpsc::Sender<OutgoingMessage>,
+) {
+    tokio::spawn(async move {
+        loop {
+            match rx.recv().await {
+                Ok(payload) => {
+                    let params = to_value(&payload).unwrap_or(rmpv::Value::Nil);
+                    let msg = OutgoingMessage::Notification {
+                        method: method.to_string(),
+                        params,
+                    };
+                    if tx.send(msg).await.is_err() {
+                        break;
+                    }
+                }
+                Err(broadcast::error::RecvError::Lagged(_)) => continue,
+                Err(broadcast::error::RecvError::Closed) => break,
+            }
+        }
+    });
+}

koharu/src/server.rs

@@ -1,30 +1,31 @@
+use std::sync::Arc;
+
 use anyhow::Result;
 use axum::{
     Router,
     body::Body,
-    extract::DefaultBodyLimit,
     http::{HeaderValue, StatusCode, Uri, header},
     response::{IntoResponse, Response},
-    routing::{get, post},
+    routing::get,
 };
-use rust_embed::Embed;
+use tauri::AssetResolver;
 use tokio::net::TcpListener;
-use tower_http::cors::{CorsLayer, ExposeHeaders};
 
-use crate::{app::AppResources, endpoints::*};
+use crate::rpc::{self, SharedResources, WsState};
 
-impl IntoResponse for crate::result::CommandError {
-    fn into_response(self) -> Response {
-        (StatusCode::INTERNAL_SERVER_ERROR, self.to_string()).into_response()
-    }
-}
+fn build_router(shared: SharedResources, resolver: Arc<AssetResolver<tauri::Wry>>) -> Router {
+    let ws_state = WsState { resources: shared };
 
-#[derive(Embed)]
-#[folder = "$CARGO_WORKSPACE_DIR/ui/out"]
-#[allow_missing = true]
-struct EmbeddedUi;
+    Router::new()
+        .route("/ws", get(rpc::ws_handler))
+        .with_state(ws_state)
+        .fallback(move |uri: Uri| {
+            let resolver = resolver.clone();
+            async move { serve_asset(&resolver, uri) }
+        })
+}
 
-async fn serve_embedded(uri: Uri) -> impl IntoResponse {
+fn serve_asset(resolver: &AssetResolver<tauri::Wry>, uri: Uri) -> Response {
     let path = uri.path();
     let target = if path == "/" {
         "index.html"
@@ -32,64 +33,26 @@ async fn serve_embedded(uri: Uri) -> impl IntoResponse {
         path.trim_start_matches('/')
     };
 
-    embedded_response(target)
-        .or_else(|| embedded_response("index.html"))
+    resolve_asset(resolver, target)
+        .or_else(|| resolve_asset(resolver, "index.html"))
         .unwrap_or_else(|| (StatusCode::NOT_FOUND, "Not Found").into_response())
 }
 
-fn embedded_response(path: &str) -> Option<Response> {
-    let asset = EmbeddedUi::get(path)?;
-    let mime = asset.metadata.mimetype();
-    let mut response = Response::new(Body::from(asset.data.into_owned()));
-    if let Ok(ct) = HeaderValue::from_str(mime) {
+fn resolve_asset(resolver: &AssetResolver<tauri::Wry>, path: &str) -> Option<Response> {
+    let asset = resolver.get(path.to_string())?;
+    let mut response = Response::new(Body::from(asset.bytes));
+    if let Ok(ct) = HeaderValue::from_str(&asset.mime_type) {
         response.headers_mut().insert(header::CONTENT_TYPE, ct);
     }
     Some(response)
 }
 
-fn build_router(state: AppResources) -> Router {
-    Router::new()
-        .route("/api/app_version", get(app_version).post(app_version))
-        .route("/api/device", get(device).post(device))
-        .route("/api/open_external", post(open_external))
-        .route("/api/get_documents", get(get_documents).post(get_documents))
-        .route("/api/get_document", get(get_document).post(get_document))
-        .route("/api/get_thumbnail", get(get_thumbnail).post(get_thumbnail))
-        .route("/api/open_documents", post(open_documents))
-        .route("/api/save_documents", post(save_documents))
-        .route("/api/export_document", post(export_document))
-        .route("/api/detect", post(detect))
-        .route("/api/ocr", post(ocr))
-        .route("/api/inpaint", post(inpaint))
-        .route("/api/update_inpaint_mask", post(update_inpaint_mask))
-        .route("/api/update_brush_layer", post(update_brush_layer))
-        .route("/api/inpaint_partial", post(inpaint_partial))
-        .route("/api/render", post(render))
-        .route("/api/update_text_blocks", post(update_text_blocks))
-        .route(
-            "/api/list_font_families",
-            get(list_font_families).post(list_font_families),
-        )
-        .route("/api/llm_list", get(llm_list).post(llm_list))
-        .route("/api/llm_load", post(llm_load))
-        .route("/api/llm_offload", post(llm_offload))
-        .route("/api/llm_ready", get(llm_ready).post(llm_ready))
-        .route("/api/llm_generate", post(llm_generate))
-        .route("/api/download_progress", get(download_progress))
-        .route("/api/process", post(process))
-        .route("/api/process_cancel", post(process_cancel))
-        .route("/api/process_progress", get(process_progress))
-        .with_state(state)
-        .layer(DefaultBodyLimit::max(1024 * 1024 * 1024))
-        .layer(
-            CorsLayer::very_permissive()
-                .expose_headers(ExposeHeaders::list([header::CONTENT_DISPOSITION])),
-        )
-        .fallback(serve_embedded)
-}
-
-pub async fn serve_with_listener(listener: TcpListener, resources: AppResources) -> Result<()> {
-    let router = build_router(resources);
+pub async fn serve_with_listener(
+    listener: TcpListener,
+    shared: SharedResources,
+    resolver: Arc<AssetResolver<tauri::Wry>>,
+) -> Result<()> {
+    let router = build_router(shared, resolver);
     tracing::info!("HTTP server listening on http://{}", listener.local_addr()?);
     axum::serve(listener, router.into_make_service()).await?;
     Ok(())

ui/app/(app)/about/page.tsx

@@ -30,7 +30,7 @@ export default function AboutPage() {
     const checkVersion = async () => {
       try {
         if (isTauri()) {
-          const version = await invoke<string>('app_version')
+          const version = await invoke('app_version')
           setAppVersion(version)
 
           const res = await fetch(

ui/app/(app)/settings/page.tsx

@@ -20,19 +20,7 @@ import {
   SelectValue,
 } from '@/components/ui/select'
 import { invoke, isTauri } from '@/lib/backend'
-
-interface WgpuDeviceInfo {
-  name: string
-  backend: string
-  deviceType: string
-  driver: string
-  driverInfo: string
-}
-
-interface DeviceInfo {
-  mlDevice: string
-  wgpu: WgpuDeviceInfo
-}
+import type { DeviceInfo } from '@/lib/rpc-types'
 
 const THEME_OPTIONS = [
   { value: 'light', icon: SunIcon, labelKey: 'settings.themeLight' },
@@ -54,7 +42,7 @@ export default function SettingsPage() {
 
     const loadDeviceInfo = async () => {
       try {
-        const info = await invoke<DeviceInfo>('device')
+        const info = await invoke('device')
         setDeviceInfo(info)
       } catch (error) {
         console.error('Failed to load device info', error)

ui/app/providers.tsx

@@ -16,7 +16,7 @@ export function Providers({ children }: { children: ReactNode }) {
     let unlisten: (() => void) | undefined
     ;(async () => {
       try {
-        const count = await invoke<number>('get_documents')
+        const count = await invoke('get_documents')
         if (count > 0) {
           setTotalPages(count)
         }

ui/app/splashscreen/page.tsx

@@ -2,7 +2,7 @@
 
 import { useEffect, useRef, useState } from 'react'
 import { useTranslation } from 'react-i18next'
-import { isTauri, type DownloadProgress } from '@/lib/backend'
+import { subscribeDownloadProgress, type DownloadProgress } from '@/lib/backend'
 
 type AggregateProgress = {
   filename: string
@@ -12,71 +12,65 @@ type AggregateProgress = {
 export default function SplashScreen() {
   const { t } = useTranslation()
   const [progress, setProgress] = useState<AggregateProgress | null>(null)
-  const channelRef = useRef<unknown>(null)
   const filesRef = useRef<Map<string, { downloaded: number; total: number }>>(
     new Map(),
   )
 
   useEffect(() => {
-    if (!isTauri()) return
-    ;(async () => {
-      const { Channel, invoke } = await import('@tauri-apps/api/core')
-      const channel = new Channel<DownloadProgress>()
-      channelRef.current = channel
-      channel.onmessage = (msg) => {
-        const files = filesRef.current
+    const unsub = subscribeDownloadProgress((msg: DownloadProgress) => {
+      const files = filesRef.current
 
-        if (msg.status === 'Started') {
-          files.set(msg.filename, { downloaded: 0, total: msg.total ?? 0 })
-        } else if (msg.status === 'Downloading') {
-          const entry = files.get(msg.filename)
-          if (entry) {
-            entry.downloaded = msg.downloaded
-            if (msg.total) entry.total = msg.total
-          } else {
-            files.set(msg.filename, {
-              downloaded: msg.downloaded,
-              total: msg.total ?? 0,
-            })
-          }
+      if (msg.status === 'Started') {
+        files.set(msg.filename, { downloaded: 0, total: msg.total ?? 0 })
+      } else if (msg.status === 'Downloading') {
+        const entry = files.get(msg.filename)
+        if (entry) {
+          entry.downloaded = msg.downloaded
+          if (msg.total) entry.total = msg.total
         } else {
-          // Completed or Failed — lock this file at 100%
-          const entry = files.get(msg.filename)
-          if (entry) {
-            entry.downloaded = entry.total
-          }
+          files.set(msg.filename, {
+            downloaded: msg.downloaded,
+            total: msg.total ?? 0,
+          })
         }
-
-        // Compute aggregate
-        let totalBytes = 0
-        let downloadedBytes = 0
-        for (const entry of files.values()) {
-          totalBytes += entry.total
-          downloadedBytes += entry.downloaded
+      } else {
+        // Completed or Failed — lock this file at 100%
+        const entry = files.get(msg.filename)
+        if (entry) {
+          entry.downloaded = entry.total
         }
+      }
 
-        // Find current active file (last non-completed)
-        const activeFilename =
-          msg.status === 'Started' || msg.status === 'Downloading'
-            ? msg.filename
-            : null
+      // Compute aggregate
+      let totalBytes = 0
+      let downloadedBytes = 0
+      for (const entry of files.values()) {
+        totalBytes += entry.total
+        downloadedBytes += entry.downloaded
+      }
 
-        const percent =
-          totalBytes > 0
-            ? Math.min(100, Math.round((downloadedBytes / totalBytes) * 100))
-            : undefined
+      // Find current active file (last non-completed)
+      const activeFilename =
+        msg.status === 'Started' || msg.status === 'Downloading'
+          ? msg.filename
+          : null
 
-        if (activeFilename) {
-          setProgress({ filename: activeFilename, percent })
-        } else {
-          // All done — keep showing 100% briefly
-          setProgress((prev) =>
-            prev ? { ...prev, percent: percent ?? 100 } : null,
-          )
-        }
+      const percent =
+        totalBytes > 0
+          ? Math.min(100, Math.round((downloadedBytes / totalBytes) * 100))
+          : undefined
+
+      if (activeFilename) {
+        setProgress({ filename: activeFilename, percent })
+      } else {
+        // All done — keep showing 100% briefly
+        setProgress((prev) =>
+          prev ? { ...prev, percent: percent ?? 100 } : null,
+        )
       }
-      await invoke('download_progress', { channel })
-    })()
+    })
+
+    return () => unsub()
   }, [])
 
   return (

ui/components/Image.tsx

@@ -5,7 +5,7 @@ import { useCallback, useEffect, useRef, useState } from 'react'
 import { convertToBlob } from '@/lib/util'
 
 type ImageProps = {
-  data?: number[]
+  data?: Uint8Array
   visible?: boolean
   opacity?: number
   transition?: boolean

ui/hooks/useMaskDrawing.ts

@@ -201,7 +201,7 @@ export function useMaskDrawing({
     ctx.restore()
   }
 
-  const exportMaskBytes = async (): Promise<number[] | null> => {
+  const exportMaskBytes = async (): Promise<Uint8Array | null> => {
     const canvas = canvasRef.current
     if (!canvas) return null
     const blob = await new Promise<Blob | null>((resolve) => {
@@ -213,7 +213,7 @@ export function useMaskDrawing({
 
   const exportMaskPatch = async (
     region: InpaintRegion,
-  ): Promise<number[] | null> => {
+  ): Promise<Uint8Array | null> => {
     const canvas = canvasRef.current
     if (!canvas || region.width <= 0 || region.height <= 0) return null
 

ui/hooks/useRenderBrushDrawing.ts

@@ -152,7 +152,7 @@ export function useRenderBrushDrawing({
 
   const exportPatch = async (
     region: InpaintRegion,
-  ): Promise<number[] | null> => {
+  ): Promise<Uint8Array | null> => {
     const canvas = targetCanvasRef?.current ?? canvasRef.current
     if (!canvas || region.width <= 0 || region.height <= 0) return null
 

ui/lib/backend.ts

@@ -1,32 +1,50 @@
 'use client'
 
+import { WsRpcClient } from './ws'
 import { pickFiles, saveFile } from './fs'
+import { toArrayBuffer } from './util'
+import type { RpcMethodMap, RpcNotificationMap, FileResult } from './rpc-types'
 
-let apiBase = '/api'
-let _initPromise: Promise<void> | null = null
+// --- Singleton client ---
 
-const isTauriEnv = (): boolean =>
-  typeof window !== 'undefined' && !!(window as any).__TAURI_INTERNALS__
+let client: WsRpcClient | null = null
 
-async function ensureInitialized(): Promise<void> {
-  if (!isTauriEnv()) {
-    // In browser/headless mode, use relative URLs
-    return
-  }
+function getClient(): WsRpcClient {
+  if (client) return client
 
-  if (_initPromise) {
-    return _initPromise
+  let url: string
+  if (typeof window !== 'undefined' && (window as any).__KOHARU_WS_PORT__) {
+    const port = (window as any).__KOHARU_WS_PORT__ as number
+    url = `ws://127.0.0.1:${port}/ws`
+  } else {
+    // Browser / headless mode: derive from current location
+    const proto =
+      typeof location !== 'undefined' && location.protocol === 'https:'
+        ? 'wss:'
+        : 'ws:'
+    const host = typeof location !== 'undefined' ? location.host : '127.0.0.1'
+    url = `${proto}//${host}/ws`
   }
 
-  _initPromise = (async () => {
-    const { invoke } = await import('@tauri-apps/api/core')
-    const port = await invoke<number>('initialize')
-    apiBase = `http://127.0.0.1:${port}/api`
-  })()
+  client = new WsRpcClient(url)
+  client.connect()
+  return client
+}
+
+// --- Environment helpers ---
+
+const isTauriEnv = (): boolean =>
+  typeof window !== 'undefined' && !!(window as any).__TAURI_INTERNALS__
+
+export const isTauri = isTauriEnv
 
-  return _initPromise
+export const isMacOS = (): boolean => {
+  if (typeof window === 'undefined') return false
+  return /Mac|iPhone|iPad|iPod/.test(navigator.userAgent)
 }
 
+// --- Progress bar ---
+
 export enum ProgressBarStatus {
   None = 'none',
   Normal = 'normal',
@@ -54,12 +72,13 @@ export function getCurrentWindow(): ProgressTarget {
 
   return {
     async setProgressBar() {
-      // no-op in headless mode
       return
     },
   }
 }
 
+// --- Window resize listener ---
+
 export async function listen<T>(
   event: string,
   handler: (event: { payload: T }) => void,
@@ -78,227 +97,123 @@ export async function listen<T>(
   return async () => {}
 }
 
-export async function invoke<T>(
-  cmd: string,
-  args?: Record<string, any>,
-): Promise<T> {
-  await ensureInitialized()
-
-  // Browser-only implementations (no Tauri available)
-  if (!isTauriEnv()) {
-    switch (cmd) {
-      case 'open_external': {
-        const url = typeof args?.url === 'string' ? args.url : undefined
-        if (url) {
-          window.open(url, '_blank', 'noopener,noreferrer')
-        }
-        return undefined as T
-      }
-    }
-  }
+// --- Window controls ---
 
-  // File operations with special handling
-  switch (cmd) {
-    case 'open_documents':
-      return (await openDocumentsHttp()) as T
-    case 'save_documents':
-      return (await saveBinary(`${apiBase}/save_documents`)) as T
-    case 'export_document':
-      return (await saveBinary(`${apiBase}/export_document`, args)) as T
-    default:
-      return invokeHttp<T>(cmd, args)
-  }
+export const windowControls = {
+  async minimize() {
+    if (isTauriEnv()) {
+      const { getCurrentWindow } = await import('@tauri-apps/api/window')
+      return getCurrentWindow().minimize()
+    }
+  },
+  async toggleMaximize() {
+    if (isTauriEnv()) {
+      const { getCurrentWindow } = await import('@tauri-apps/api/window')
+      return getCurrentWindow().toggleMaximize()
+    }
+  },
+  async close() {
+    if (isTauriEnv()) {
+      const { getCurrentWindow } = await import('@tauri-apps/api/window')
+      return getCurrentWindow().close()
+    }
+  },
+  async isMaximized(): Promise<boolean> {
+    if (isTauriEnv()) {
+      const { getCurrentWindow } = await import('@tauri-apps/api/window')
+      return getCurrentWindow().isMaximized()
+    }
+    return false
+  },
 }
 
-async function invokeHttp<T>(
-  cmd: string,
-  args?: Record<string, any>,
-): Promise<T> {
-  const body = args ?? {}
-  const res = await fetch(`${apiBase}/${cmd}`, {
-    method: 'POST',
-    headers: {
-      'Content-Type': 'application/json',
-    },
-    body: JSON.stringify(body),
-  })
+// --- Typed RPC invoke ---
+
+export async function invoke<M extends keyof RpcMethodMap>(
+  method: M,
+  ...args: RpcMethodMap[M][0] extends void ? [] : [RpcMethodMap[M][0]]
+): Promise<RpcMethodMap[M][1]> {
+  const params = args[0]
+
+  // Browser-only: open_external in a new tab
+  if (!isTauriEnv() && method === 'open_external') {
+    const p = params as { url: string }
+    if (p?.url) {
+      window.open(p.url, '_blank', 'noopener,noreferrer')
+    }
+    return undefined as RpcMethodMap[M][1]
+  }
 
-  if (!res.ok) {
-    throw new Error(await readError(res))
+  // Special file-pick flow for open_documents
+  if (method === 'open_documents') {
+    return (await openDocumentsRpc()) as RpcMethodMap[M][1]
   }
 
-  const contentType = res.headers.get('content-type') ?? ''
-  if (contentType.includes('application/json')) {
-    return (await res.json()) as T
+  // Special file-save flow for save_documents / export_document
+  if (method === 'save_documents' || method === 'export_document') {
+    const result = await getClient().invoke<FileResult>(method, params)
+    const blob = new Blob([toArrayBuffer(result.data)])
+    await saveFile(blob, result.filename)
+    return undefined as RpcMethodMap[M][1]
   }
 
-  const buffer = await res.arrayBuffer()
-  return buffer as unknown as T
+  return getClient().invoke<RpcMethodMap[M][1]>(method, params)
 }
 
-async function openDocumentsHttp<T>(): Promise<T> {
+async function openDocumentsRpc(): Promise<number> {
   const files = await pickFiles(
     [
       {
         description: 'Documents',
         accept: {
-          // 'application/octet-stream': ['.khr'],
           'image/*': ['.png', '.jpg', '.jpeg', '.webp'],
         },
       },
     ],
     true,
   )
-  if (!files.length) {
-    return 0 as unknown as T
-  }
-
-  const formData = new FormData()
-  for (const file of files) {
-    formData.append('files', file, file.name)
-  }
-
-  const res = await fetch(`${apiBase}/open_documents`, {
-    method: 'POST',
-    body: formData,
-  })
-  if (!res.ok) {
-    throw new Error(await readError(res))
-  }
+  if (!files.length) return 0
 
-  return (await res.json()) as T
-}
-
-async function saveBinary(
-  endpoint: string,
-  args?: Record<string, any>,
-): Promise<void> {
-  const hasBody = args && Object.keys(args).length > 0
-  const res = await fetch(endpoint, {
-    method: 'POST',
-    headers: hasBody ? { 'Content-Type': 'application/json' } : undefined,
-    body: hasBody ? JSON.stringify(args) : undefined,
-  })
-
-  if (!res.ok) {
-    throw new Error(await readError(res))
-  }
-
-  const blob = await res.blob()
-  const suggestedName =
-    parseFilename(res.headers.get('content-disposition')) ?? 'download.bin'
-  await saveFile(blob, suggestedName)
-}
+  const entries = await Promise.all(
+    files.map(async (file) => ({
+      name: file.name,
+      data: new Uint8Array(await file.arrayBuffer()),
+    })),
+  )
 
-function parseFilename(disposition?: string | null): string | undefined {
-  if (!disposition) return undefined
-  const match = /filename="?([^\";]+)"?/i.exec(disposition)
-  return match?.[1]
+  return getClient().invoke<number>('open_documents', { files: entries })
 }
 
-async function readError(res: Response): Promise<string> {
-  const contentType = res.headers.get('content-type') ?? ''
-  if (contentType.includes('application/json')) {
-    try {
-      const body = (await res.json()) as { error?: string }
-      if (body?.error) return body.error
-    } catch (_) {}
-  }
-  try {
-    return await res.text()
-  } catch (_) {
-    return res.statusText || 'Request failed'
-  }
-}
+// --- Thumbnail fetch ---
 
 export async function fetchThumbnail(index: number): Promise<Blob> {
-  await ensureInitialized()
-  const res = await fetch(`${apiBase}/get_thumbnail`, {
-    method: 'POST',
-    headers: { 'Content-Type': 'application/json' },
-    body: JSON.stringify({ index }),
+  const result = await getClient().invoke<{
+    data: Uint8Array
+    contentType: string
+  }>('get_thumbnail', { index })
+  return new Blob([toArrayBuffer(result.data)], {
+    type: result.contentType,
   })
-  if (!res.ok) {
-    throw new Error(await readError(res))
-  }
-  return res.blob()
 }
 
-export type DownloadProgress = {
-  filename: string
-  downloaded: number
-  total?: number
-  status: 'Started' | 'Downloading' | 'Completed' | { Failed: string }
-}
+// --- Notification subscriptions ---
 
-export type ProcessProgress = {
-  status: 'running' | 'completed' | 'cancelled' | { failed: string }
-  step: string | null
-  currentDocument: number
-  totalDocuments: number
-  currentStepIndex: number
-  totalSteps: number
-  overallPercent: number
-}
+export type { DownloadProgress, ProcessProgress } from './rpc-types'
 
-function subscribeSSE<T>(
-  endpoint: string,
-  callback: (data: T) => void,
+export function subscribeDownloadProgress(
+  cb: (p: RpcNotificationMap['download_progress']) => void,
 ): () => void {
-  let es: EventSource | null = null
-
-  ;(async () => {
-    await ensureInitialized()
-    es = new EventSource(`${apiBase}/${endpoint}`)
-    es.onmessage = (event) => {
-      try {
-        callback(JSON.parse(event.data) as T)
-      } catch (_) {}
-    }
-  })()
-
-  return () => {
-    es?.close()
-  }
-}
-
-export const subscribeDownloadProgress = (cb: (p: DownloadProgress) => void) =>
-  subscribeSSE<DownloadProgress>('download_progress', cb)
-
-export const subscribeProcessProgress = (cb: (p: ProcessProgress) => void) =>
-  subscribeSSE<ProcessProgress>('process_progress', cb)
-
-export const isTauri = isTauriEnv
-
-export const isMacOS = (): boolean => {
-  if (typeof window === 'undefined') return false
-  return /Mac|iPhone|iPad|iPod/.test(navigator.userAgent)
+  return getClient().onNotification<RpcNotificationMap['download_progress']>(
+    'download_progress',
+    cb,
+  )
 }
 
-export const windowControls = {
-  async minimize() {
-    if (isTauriEnv()) {
-      const { getCurrentWindow } = await import('@tauri-apps/api/window')
-      return getCurrentWindow().minimize()
-    }
-  },
-  async toggleMaximize() {
-    if (isTauriEnv()) {
-      const { getCurrentWindow } = await import('@tauri-apps/api/window')
-      return getCurrentWindow().toggleMaximize()
-    }
-  },
-  async close() {
-    if (isTauriEnv()) {
-      const { getCurrentWindow } = await import('@tauri-apps/api/window')
-      return getCurrentWindow().close()
-    }
-  },
-  async isMaximized(): Promise<boolean> {
-    if (isTauriEnv()) {
-      const { getCurrentWindow } = await import('@tauri-apps/api/window')
-      return getCurrentWindow().isMaximized()
-    }
-    return false
-  },
+export function subscribeProcessProgress(
+  cb: (p: RpcNotificationMap['process_progress']) => void,
+): () => void {
+  return getClient().onNotification<RpcNotificationMap['process_progress']>(
+    'process_progress',
+    cb,
+  )
 }

ui/lib/rpc-types.ts

@@ -0,0 +1,111 @@
+import type { Document, InpaintRegion, RenderEffect, TextBlock } from '@/types'
+
+// Params → Result type map for all RPC methods
+
+export type ThumbnailResult = {
+  data: Uint8Array
+  contentType: string
+}
+
+export type FileEntry = {
+  name: string
+  data: Uint8Array
+}
+
+export type FileResult = {
+  filename: string
+  data: Uint8Array
+  contentType: string
+}
+
+export type WgpuDeviceInfo = {
+  name: string
+  backend: string
+  deviceType: string
+  driver: string
+  driverInfo: string
+}
+
+export type DeviceInfo = {
+  mlDevice: string
+  wgpu: WgpuDeviceInfo
+}
+
+export type LlmModelInfo = {
+  id: string
+  languages: string[]
+}
+
+export type RpcMethodMap = {
+  app_version: [void, string]
+  device: [void, DeviceInfo]
+  open_external: [{ url: string }, void]
+  get_documents: [void, number]
+  get_document: [{ index: number }, Document]
+  get_thumbnail: [{ index: number }, ThumbnailResult]
+  open_documents: [void, number]
+  save_documents: [void, void]
+  export_document: [{ index: number }, void]
+  detect: [{ index: number }, void]
+  ocr: [{ index: number }, void]
+  inpaint: [{ index: number }, void]
+  update_inpaint_mask: [
+    { index: number; mask: Uint8Array; region?: InpaintRegion },
+    void,
+  ]
+  update_brush_layer: [
+    { index: number; patch: Uint8Array; region: InpaintRegion },
+    void,
+  ]
+  inpaint_partial: [{ index: number; region: InpaintRegion }, void]
+  render: [
+    {
+      index: number
+      textBlockIndex?: number
+      shaderEffect?: RenderEffect
+    },
+    void,
+  ]
+  update_text_blocks: [{ index: number; textBlocks: TextBlock[] }, void]
+  list_font_families: [void, string[]]
+  llm_list: [void, LlmModelInfo[]]
+  llm_load: [{ id: string }, void]
+  llm_offload: [void, void]
+  llm_ready: [void, boolean]
+  llm_generate: [
+    { index: number; textBlockIndex?: number; language?: string },
+    void,
+  ]
+  process: [
+    {
+      index?: number
+      llmModelId?: string
+      language?: string
+      shaderEffect?: RenderEffect
+    },
+    void,
+  ]
+  process_cancel: [void, void]
+}
+
+export type DownloadProgress = {
+  filename: string
+  downloaded: number
+  total?: number
+  status: 'Started' | 'Downloading' | 'Completed' | { Failed: string }
+}
+
+export type ProcessProgress = {
+  status: 'running' | 'completed' | 'cancelled' | { failed: string }
+  step: string | null
+  currentDocument: number
+  totalDocuments: number
+  currentStepIndex: number
+  totalSteps: number
+  overallPercent: number
+}
+
+export type RpcNotificationMap = {
+  download_progress: DownloadProgress
+  process_progress: ProcessProgress
+}

ui/lib/store.ts

@@ -60,7 +60,7 @@ const textBlockSyncer = createTextBlockSyncer()
 const createMaskSyncer = () => {
   type MaskUpdate = {
     index: number
-    mask: number[]
+    mask: Uint8Array
     region?: InpaintRegion
   }
   let pending: MaskUpdate[] = []
@@ -176,15 +176,15 @@ type AppState = OperationSlice & {
   fetchAvailableFonts: () => Promise<void>
   updateTextBlocks: (textBlocks: TextBlock[]) => Promise<void>
   updateMask: (
-    mask: number[],
+    mask: Uint8Array,
     options?: {
       sync?: boolean
-      patch?: number[]
+      patch?: Uint8Array
       patchRegion?: InpaintRegion
     },
   ) => Promise<void>
   paintRendered: (
-    patch: number[],
+    patch: Uint8Array,
     region: InpaintRegion,
     options?: { index?: number },
   ) => Promise<void>
@@ -265,7 +265,7 @@ export const useAppStore = create<AppState>((set, get) => {
 
       set({ currentDocumentLoading: true })
       try {
-        const doc = await invoke<Document>('get_document', { index })
+        const doc = await invoke('get_document', { index })
         // Only update if we're still on the same index
         if (get().currentDocumentIndex === index) {
           set({ currentDocument: doc, currentDocumentLoading: false })
@@ -283,7 +283,7 @@ export const useAppStore = create<AppState>((set, get) => {
     openDocuments: async () => {
       get().startOperation({ type: 'load-khr', cancellable: false })
       try {
-        const count = await invoke<number>('open_documents')
+        const count = await invoke('open_documents')
         get().setTotalPages(count)
       } finally {
         get().finishOperation()
@@ -364,7 +364,7 @@ export const useAppStore = create<AppState>((set, get) => {
     setRenderEffect: (effect: RenderEffect) => set({ renderEffect: effect }),
     fetchAvailableFonts: async () => {
       try {
-        const fonts = await invoke<string[]>('list_font_families')
+        const fonts = await invoke('list_font_families')
         set({ availableFonts: fonts })
       } catch (_) {}
     },
@@ -484,7 +484,7 @@ export const useAppStore = create<AppState>((set, get) => {
     },
     llmList: async () => {
       try {
-        const models = await invoke<LlmModelInfo[]>('llm_list')
+        const models = await invoke('llm_list')
         set({ llmModels: models })
         const currentModel = get().llmSelectedModel
         const currentLanguage = get().llmSelectedLanguage
@@ -574,7 +574,7 @@ export const useAppStore = create<AppState>((set, get) => {
         return
       }
       try {
-        llmReadyCheckInFlight = invoke<boolean>('llm_ready')
+        llmReadyCheckInFlight = invoke('llm_ready')
         const ready = await llmReadyCheckInFlight
         set({ llmReady: ready })
       } catch (_) {}

ui/lib/util.ts

@@ -1,13 +1,21 @@
-export function convertToBlob(bytes: number[]): Blob {
-  return new Blob([new Uint8Array(bytes)], { type: 'image/*' })
+/** Extract a standalone ArrayBuffer from a Uint8Array view (msgpack may return views into a shared decode buffer). */
+export function toArrayBuffer(bytes: Uint8Array): ArrayBuffer {
+  return bytes.buffer.slice(
+    bytes.byteOffset,
+    bytes.byteOffset + bytes.byteLength,
+  ) as ArrayBuffer
 }
 
-export function convertToImageBitmap(bytes: number[]): Promise<ImageBitmap> {
+export function convertToBlob(bytes: Uint8Array): Blob {
+  return new Blob([toArrayBuffer(bytes)])
+}
+
+export function convertToImageBitmap(bytes: Uint8Array): Promise<ImageBitmap> {
   const blob = convertToBlob(bytes)
   return createImageBitmap(blob)
 }
 
-export async function blobToUint8Array(blob: Blob): Promise<number[]> {
+export async function blobToUint8Array(blob: Blob): Promise<Uint8Array> {
   const buffer = await blob.arrayBuffer()
-  return Array.from(new Uint8Array(buffer))
+  return new Uint8Array(buffer)
 }

ui/lib/ws.ts

@@ -0,0 +1,189 @@
+'use client'
+
+import { encode, decode } from '@msgpack/msgpack'
+
+type OutgoingRequest = {
+  type: 'req'
+  id: number
+  method: string
+  params?: unknown
+}
+
+type IncomingResponse = {
+  type: 'res'
+  id: number
+  result?: unknown
+  error?: string
+}
+
+type IncomingNotification = {
+  type: 'ntf'
+  method: string
+  params: unknown
+}
+
+type IncomingMessage = IncomingResponse | IncomingNotification
+
+type PendingRequest = {
+  resolve: (value: unknown) => void
+  reject: (reason: Error) => void
+}
+
+export class WsRpcClient {
+  private ws: WebSocket | null = null
+  private nextId = 1
+  private pending = new Map<number, PendingRequest>()
+  private notificationHandlers = new Map<
+    string,
+    Set<(params: unknown) => void>
+  >()
+  private url: string
+  private reconnectTimer: ReturnType<typeof setTimeout> | null = null
+  private closed = false
+  private readyQueue: Array<() => void> = []
+
+  constructor(url: string) {
+    this.url = url
+  }
+
+  connect(): void {
+    if (this.ws) return
+    this.closed = false
+
+    const ws = new WebSocket(this.url)
+    ws.binaryType = 'arraybuffer'
+
+    ws.onopen = () => {
+      if (this.reconnectTimer) {
+        clearTimeout(this.reconnectTimer)
+        this.reconnectTimer = null
+      }
+      const queue = this.readyQueue.splice(0)
+      for (const fn of queue) fn()
+    }
+
+    ws.onmessage = (event: MessageEvent) => {
+      if (!(event.data instanceof ArrayBuffer)) return
+      let msg: IncomingMessage
+      try {
+        msg = decode(new Uint8Array(event.data)) as IncomingMessage
+      } catch {
+        return
+      }
+
+      if (msg.type === 'res') {
+        const p = this.pending.get(msg.id)
+        if (p) {
+          this.pending.delete(msg.id)
+          if (msg.error) {
+            p.reject(new Error(msg.error))
+          } else {
+            p.resolve(msg.result)
+          }
+        }
+      } else if (msg.type === 'ntf') {
+        const handlers = this.notificationHandlers.get(msg.method)
+        if (handlers) {
+          for (const handler of handlers) {
+            try {
+              handler(msg.params)
+            } catch {}
+          }
+        }
+      }
+    }
+
+    ws.onclose = () => {
+      this.ws = null
+      // Reject queued and pending requests
+      const queue = this.readyQueue.splice(0)
+      for (const fn of queue) fn()
+      for (const [, p] of this.pending) {
+        p.reject(new Error('WebSocket closed'))
+      }
+      this.pending.clear()
+
+      if (!this.closed) {
+        this.scheduleReconnect()
+      }
+    }
+
+    ws.onerror = () => {
+      // onclose will fire after this
+    }
+
+    this.ws = ws
+  }
+
+  close(): void {
+    this.closed = true
+    if (this.reconnectTimer) {
+      clearTimeout(this.reconnectTimer)
+      this.reconnectTimer = null
+    }
+    this.ws?.close()
+    this.ws = null
+  }
+
+  invoke<T = unknown>(method: string, params?: unknown): Promise<T> {
+    return new Promise((resolve, reject) => {
+      const send = () => {
+        if (!this.ws || this.ws.readyState !== WebSocket.OPEN) {
+          reject(new Error('WebSocket not connected'))
+          return
+        }
+
+        const id = this.nextId++
+        this.pending.set(id, {
+          resolve: resolve as (v: unknown) => void,
+          reject,
+        })
+
+        const msg: OutgoingRequest = { type: 'req', id, method }
+        if (params !== undefined) {
+          msg.params = params
+        }
+
+        const bytes = encode(msg)
+        this.ws.send(bytes)
+      }
+
+      if (this.ws?.readyState === WebSocket.CONNECTING) {
+        this.readyQueue.push(send)
+      } else {
+        send()
+      }
+    })
+  }
+
+  onNotification<T = unknown>(
+    method: string,
+    handler: (params: T) => void,
+  ): () => void {
+    let handlers = this.notificationHandlers.get(method)
+    if (!handlers) {
+      handlers = new Set()
+      this.notificationHandlers.set(method, handlers)
+    }
+    const wrapped = handler as (params: unknown) => void
+    handlers.add(wrapped)
+    return () => {
+      handlers!.delete(wrapped)
+      if (handlers!.size === 0) {
+        this.notificationHandlers.delete(method)
+      }
+    }
+  }
+
+  get connected(): boolean {
+    return this.ws?.readyState === WebSocket.OPEN
+  }
+
+  private scheduleReconnect(): void {
+    if (this.reconnectTimer) return
+    this.reconnectTimer = setTimeout(() => {
+      this.reconnectTimer = null
+      this.connect()
+    }, 1000)
+  }
+}

ui/package.json

@@ -39,6 +39,7 @@
     "react-rnd": "^10.5.2",
     "remark-gfm": "^4.0.1",
     "tailwind-merge": "^3.4.0",
+    "@msgpack/msgpack": "^3.0.0-beta.3",
     "zustand": "^5.0.11"
   },
   "devDependencies": {

ui/types.d.ts

@@ -36,7 +36,7 @@ export type TextBlock = {
   translation?: string
   style?: TextStyle
   fontPrediction?: FontPrediction
-  rendered?: number[]
+  rendered?: Uint8Array
 }
 
 export type ToolMode = 'select' | 'block' | 'brush' | 'repairBrush' | 'eraser'
@@ -52,12 +52,12 @@ export type Document = {
   id: string
   path: string
   name: string
-  image: number[]
+  image: Uint8Array
   width: number
   height: number
   textBlocks: TextBlock[]
-  segment?: number[]
-  inpainted?: number[]
-  brushLayer?: number[]
-  rendered?: number[]
+  segment?: Uint8Array
+  inpainted?: Uint8Array
+  brushLayer?: Uint8Array
+  rendered?: Uint8Array
 }