fix: make clippy happy

bun.lock

@@ -39,6 +39,7 @@
         "@tanstack/react-query": "^5.99.0",
         "@tanstack/react-virtual": "^3.13.24",
         "@tauri-apps/api": "^2.10.1",
+        "@tauri-apps/plugin-dialog": "^2.7.0",
         "@tauri-apps/plugin-opener": "^2.4.0",
         "@tauri-apps/plugin-process": "^2.3.1",
         "@tauri-apps/plugin-updater": "^2.10.1",
@@ -855,6 +856,8 @@
 
     "@tauri-apps/cli-win32-x64-msvc": ["@tauri-apps/cli-win32-x64-msvc@2.10.1", "", { "os": "win32", "cpu": "x64" }, "sha512-6Cn7YpPFwzChy0ERz6djKEmUehWrYlM+xTaNzGPgZocw3BD7OfwfWHKVWxXzdjEW2KfKkHddfdxK1XXTYqBRLg=="],
 
+    "@tauri-apps/plugin-dialog": ["@tauri-apps/plugin-dialog@2.7.0", "", { "dependencies": { "@tauri-apps/api": "^2.10.1" } }, "sha512-4nS/hfGMGCXiAS3LtVjH9AgsSAPJeG/7R+q8agTFqytjnMa4Zq95Bq8WzVDkckpanX+yyRHXnRtrKXkANKDHvw=="],
+
     "@tauri-apps/plugin-fs": ["@tauri-apps/plugin-fs@2.5.0", "", { "dependencies": { "@tauri-apps/api": "^2.10.1" } }, "sha512-c83kbz61AK+rKjhS+je9+stIO27nXj7p9cqeg36TwkIUtxpCFTttlHHtqon6h6FN54cXjyAjlMPOJcW3mwE5XQ=="],
 
     "@tauri-apps/plugin-opener": ["@tauri-apps/plugin-opener@2.5.3", "", { "dependencies": { "@tauri-apps/api": "^2.8.0" } }, "sha512-CCcUltXMOfUEArbf3db3kCE7Ggy1ExBEBl51Ko2ODJ6GDYHRp1nSNlQm5uNCFY5k7/ufaK5Ib3Du/Zir19IYQQ=="],

koharu-app/bin/pipeline.rs

@@ -253,10 +253,8 @@ async fn run() -> Result<()> {
         Err(e) => eprintln!("=> pipeline failed: {e:#}"),
     }
 
-    if ensure_translation_fallback {
-        if let Err(e) = synthesize_translations(&app, page_id).await {
-            eprintln!("warn: failed to synthesize translations: {e:#}");
-        }
+    if ensure_translation_fallback && let Err(e) = synthesize_translations(&app, page_id).await {
+        eprintln!("warn: failed to synthesize translations: {e:#}");
     }
 
     dump_artifacts(&session, page_id, &cli.output_dir)

koharu-app/src/app.rs

@@ -257,7 +257,7 @@ pub fn shared_llama_backend(runtime: &RuntimeManager) -> Result<Arc<LlamaBackend
     if let Some(backend) = LLAMA_BACKEND.get() {
         return Ok(backend.clone());
     }
-    koharu_llm::sys::initialize(runtime).map_err(anyhow::Error::from)?;
+    koharu_llm::sys::initialize(runtime)?;
     let backend = Arc::new(LlamaBackend::init().map_err(anyhow::Error::from)?);
     let _ = LLAMA_BACKEND.set(backend.clone());
     Ok(backend)

koharu-app/src/config.rs

@@ -187,10 +187,10 @@ pub fn save(config: &AppConfig) -> Result<()> {
 /// Apply a `ConfigPatch` in-place. Missing fields leave the existing value
 /// alone. Providers are replaced wholesale (the list, not field-by-field).
 pub fn apply_patch(config: &mut AppConfig, patch: koharu_core::ConfigPatch) {
-    if let Some(data) = patch.data {
-        if let Some(path) = data.path {
-            config.data.path = camino::Utf8PathBuf::from(path);
-        }
+    if let Some(data) = patch.data
+        && let Some(path) = data.path
+    {
+        config.data.path = camino::Utf8PathBuf::from(path);
     }
     if let Some(http) = patch.http {
         if let Some(v) = http.connect_timeout {

koharu-app/src/pipeline/engines/support.rs

@@ -18,7 +18,7 @@ use crate::blobs::BlobStore;
 
 /// Find the Source image node on `page`. Returns `(node_id, image_data)`.
 /// Every valid page has exactly one; absence means the page is malformed.
-pub fn source_node<'a>(scene: &'a Scene, page: PageId) -> Result<(NodeId, &'a ImageData)> {
+pub fn source_node(scene: &Scene, page: PageId) -> Result<(NodeId, &ImageData)> {
     let page = scene
         .page(page)
         .with_context(|| format!("page {} not found", page))?;
@@ -58,10 +58,7 @@ pub fn find_mask_node(scene: &Scene, page: PageId, role: MaskRole) -> Option<(No
 
 /// Collect `(NodeId, &Transform, &TextData)` for every text node on `page`,
 /// in stacking order.
-pub fn text_nodes<'a>(
-    scene: &'a Scene,
-    page: PageId,
-) -> Vec<(NodeId, &'a Transform, &'a TextData)> {
+pub fn text_nodes(scene: &Scene, page: PageId) -> Vec<(NodeId, &Transform, &TextData)> {
     let Some(page) = scene.page(page) else {
         return Vec::new();
     };
@@ -122,6 +119,7 @@ pub fn core_text_direction_to_ml(d: koharu_core::TextDirection) -> koharu_ml::ty
 // ---------------------------------------------------------------------------
 
 /// Build an `AddNode` for a new `Image { role }` layer.
+#[allow(clippy::too_many_arguments)]
 pub fn add_image_node_op(
     page: PageId,
     role: ImageRole,
@@ -309,13 +307,12 @@ pub fn clear_text_nodes_ops(scene: &Scene, page: PageId) -> Vec<Op> {
         .nodes
         .iter()
         .enumerate()
-        .filter_map(|(idx, (id, node))| {
-            matches!(&node.kind, NodeKind::Text(_)).then(|| Op::RemoveNode {
-                page,
-                id: *id,
-                prev_node: node.clone(),
-                prev_index: idx,
-            })
+        .filter(|(_, (_, node))| matches!(&node.kind, NodeKind::Text(_)))
+        .map(|(idx, (id, node))| Op::RemoveNode {
+            page,
+            id: *id,
+            prev_node: node.clone(),
+            prev_index: idx,
         })
         .collect()
 }

koharu-app/src/pipeline/mod.rs

@@ -89,6 +89,7 @@ pub enum Scope {
 
 /// Execute `spec` against `session`. Each engine step becomes one `Op::Batch`
 /// applied via the session's history (one undo step per step per page).
+#[allow(clippy::too_many_arguments)]
 #[tracing::instrument(level = "info", skip_all)]
 pub async fn run(
     session: Arc<ProjectSession>,

koharu-app/src/projects.rs

@@ -167,11 +167,9 @@ fn slugify(input: &str) -> String {
                 out.push('-');
                 prev_dash = true;
             }
-        } else if c.is_whitespace() {
-            if !out.is_empty() && !prev_dash {
-                out.push('-');
-                prev_dash = true;
-            }
+        } else if c.is_whitespace() && !out.is_empty() && !prev_dash {
+            out.push('-');
+            prev_dash = true;
         }
         // Other chars dropped silently.
     }

koharu-app/src/renderer.rs

@@ -117,7 +117,7 @@ impl Renderer {
                     .first()
                     .map(|(family, _)| family.clone())
                     .unwrap_or_else(|| face.post_script_name.clone());
-                seen.insert(family_name.clone()).then(|| FontFaceInfo {
+                seen.insert(family_name.clone()).then_some(FontFaceInfo {
                     family_name,
                     post_script_name: face.post_script_name,
                     source: FontSource::System,
@@ -146,6 +146,7 @@ impl Renderer {
     /// the full page + per-block sprites. Blocks with an empty translation
     /// are skipped (they appear as holes in the composite, falling through to
     /// the inpainted plane).
+    #[allow(clippy::too_many_arguments)]
     #[tracing::instrument(level = "info", skip_all, fields(blocks = blocks.len()))]
     pub fn render_page(
         &self,
@@ -186,8 +187,7 @@ impl Renderer {
             imageops::overlay(&mut canvas, &brush.to_rgba8(), 0, 0);
         }
         for out in &rendered_blocks {
-            let (x, y) =
-                placement_origin(&find_input(blocks, out.node_id), &out.expanded_transform);
+            let (x, y) = placement_origin(find_input(blocks, out.node_id), &out.expanded_transform);
             imageops::overlay(&mut canvas, &out.sprite.to_rgba8(), x as i64, y as i64);
         }
         Ok(RenderOutput {
@@ -237,11 +237,10 @@ impl Renderer {
 
         let font = self.select_font(&style)?;
         let block_effect = style.effect.unwrap_or(*effect);
-        let color = style
-            .effect
-            .is_some()
-            .then_some(style.color)
-            .unwrap_or_else(|| {
+        let color = if style.effect.is_some() {
+            style.color
+        } else {
+            {
                 if block.style.is_some() {
                     style.color
                 } else if let Some(pred) = &block.font_prediction {
@@ -254,7 +253,8 @@ impl Renderer {
                 } else {
                     [0, 0, 0, 255]
                 }
-            });
+            }
+        };
 
         let writing_mode = writing_mode_for_block(&layout_source);
         // Translations default to centre alignment inside a bubble — each
@@ -296,13 +296,12 @@ impl Renderer {
         // Re-run the layout with `max_width = actual_content_width` so
         // every line is centred relative to the block's widest line.
         let layout = if layout.width > layout_box.width + 0.5 {
-            let expanded = layout_builder
+            layout_builder
                 .clone()
                 .with_font_size(layout.font_size)
                 .with_max_width(layout.width)
                 .with_max_height(layout_box.height)
-                .run(&normalized)?;
-            expanded
+                .run(&normalized)?
         } else {
             layout
         };
@@ -588,7 +587,7 @@ fn core_align_to_renderer(a: koharu_core::TextAlign) -> RendererTextAlign {
 // Helpers: placement
 // ---------------------------------------------------------------------------
 
-fn find_input<'a>(blocks: &'a [RenderBlockInput], id: NodeId) -> &'a RenderBlockInput {
+fn find_input(blocks: &[RenderBlockInput], id: NodeId) -> &RenderBlockInput {
     blocks
         .iter()
         .find(|b| b.node_id == id)

koharu-core/src/op.rs

@@ -10,6 +10,12 @@
 //! let undo = op.inverse();                                    // pure
 //! ```
 
+// `Op` / `NodeDataPatch` are wire-format data types; their variant-size
+// asymmetry is inherent (Text patches carry many optional fields), and
+// boxing would change the serialised representation. Silence clippy here
+// rather than smear `#[allow]` across every producer.
+#![allow(clippy::large_enum_variant)]
+
 use chrono::{DateTime, Utc};
 use schemars::JsonSchema;
 use serde::{Deserialize, Serialize};

koharu-core/src/scene.rs

@@ -3,6 +3,10 @@
 //! Three primitives: `Node`, `Blob` (via `BlobRef`), `Op` (in `op.rs`).
 //! Everything visual on a page is a `Node`; scene mutations flow through `Op`s.
 
+// `NodeKind::Text` naturally carries more data than `Image`/`Mask`, and
+// boxing would change the wire format. Same reasoning as in `op.rs`.
+#![allow(clippy::large_enum_variant)]
+
 use chrono::{DateTime, Utc};
 use indexmap::IndexMap;
 use schemars::JsonSchema;

koharu-renderer/src/layout.rs

@@ -636,10 +636,11 @@ mod tests {
     }
 
     fn assert_approx_eq(actual: f32, expected: f32) {
-        if actual.is_infinite() && expected.is_infinite() {
-            if actual.is_sign_positive() == expected.is_sign_positive() {
-                return;
-            }
+        if actual.is_infinite()
+            && expected.is_infinite()
+            && actual.is_sign_positive() == expected.is_sign_positive()
+        {
+            return;
         }
         let eps = 1e-4;
         assert!(

koharu-rpc/src/binary.rs

@@ -66,7 +66,7 @@ async fn get_scene_bin(State(app): State<AppState>) -> ApiResult<Response> {
         let epoch = session.epoch();
         let bytes = postcard::to_allocvec(&WireSnapshot {
             epoch,
-            scene: &*scene,
+            scene: &scene,
         })
         .map_err(|e| ApiError::internal(anyhow::Error::new(e)))?;
         (epoch, bytes)

koharu-rpc/src/events.rs

@@ -101,7 +101,7 @@ async fn events(
 fn snapshot_frame(app: &AppState) -> Result<Event, axum::Error> {
     let snap = snapshot_from(app);
     Event::default()
-        .json_data(&AppEvent::Snapshot(snap))
+        .json_data(AppEvent::Snapshot(snap))
         .map_err(axum::Error::new)
 }
 

koharu-rpc/src/psd_export.rs

@@ -19,6 +19,17 @@ use koharu_psd::{
     write_document,
 };
 
+/// Resolved page artifacts ready to hand to `koharu-psd`.
+struct ResolvedPage {
+    doc: PsdDocument,
+    source: DynamicImage,
+    segment: Option<DynamicImage>,
+    inpainted: Option<DynamicImage>,
+    rendered: Option<DynamicImage>,
+    brush: Option<DynamicImage>,
+    block_images: HashMap<PsdBlobRef, DynamicImage>,
+}
+
 /// Encode a single page as PSD bytes.
 pub fn psd_bytes_for_page(session: &Arc<ProjectSession>, page_id: PageId) -> Result<Vec<u8>> {
     let scene: Scene = session.scene_snapshot();
@@ -26,8 +37,15 @@ pub fn psd_bytes_for_page(session: &Arc<ProjectSession>, page_id: PageId) -> Res
         .pages
         .get(&page_id)
         .ok_or_else(|| anyhow::anyhow!("page {page_id} not found"))?;
-    let (doc, source, segment, inpainted, rendered, brush, block_images) =
-        resolve_page_blobs(session, page).with_context(|| format!("page {page_id}"))?;
+    let ResolvedPage {
+        doc,
+        source,
+        segment,
+        inpainted,
+        rendered,
+        brush,
+        block_images,
+    } = resolve_page_blobs(session, page).with_context(|| format!("page {page_id}"))?;
     let resolved = ResolvedDocument {
         document: &doc,
         source: &source,
@@ -43,18 +61,7 @@ pub fn psd_bytes_for_page(session: &Arc<ProjectSession>, page_id: PageId) -> Res
     Ok(buf)
 }
 
-fn resolve_page_blobs(
-    session: &ProjectSession,
-    page: &koharu_core::Page,
-) -> Result<(
-    PsdDocument,
-    DynamicImage,
-    Option<DynamicImage>,
-    Option<DynamicImage>,
-    Option<DynamicImage>,
-    Option<DynamicImage>,
-    HashMap<PsdBlobRef, DynamicImage>,
-)> {
+fn resolve_page_blobs(session: &ProjectSession, page: &koharu_core::Page) -> Result<ResolvedPage> {
     let mut source: Option<DynamicImage> = None;
     let mut segment: Option<DynamicImage> = None;
     let mut inpainted: Option<DynamicImage> = None;
@@ -105,7 +112,7 @@ fn resolve_page_blobs(
         height: page.height,
         text_blocks,
     };
-    Ok((
+    Ok(ResolvedPage {
         doc,
         source,
         segment,
@@ -113,7 +120,7 @@ fn resolve_page_blobs(
         rendered,
         brush,
         block_images,
-    ))
+    })
 }
 
 /// Encode a single page's image for `role` as PNG bytes. Returns `None` if

koharu-rpc/src/routes/pages.rs

@@ -346,24 +346,22 @@ async fn add_image_layer(
             .len()
     };
 
-    let mut filename = String::from("layer.png");
-    let mut bytes: Option<Vec<u8>> = None;
-    while let Some(field) = multipart
+    // The handler only accepts a single image layer per request, so we
+    // pull the first multipart field and ignore the rest.
+    let field = multipart
         .next_field()
         .await
         .map_err(|e| ApiError::bad_request(format!("multipart: {e}")))?
-    {
-        if let Some(name) = field.file_name() {
-            filename = name.to_string();
-        }
-        let data = field
-            .bytes()
-            .await
-            .map_err(|e| ApiError::bad_request(format!("read file: {e}")))?;
-        bytes = Some(data.to_vec());
-        break;
-    }
-    let bytes = bytes.ok_or_else(|| ApiError::bad_request("no file uploaded"))?;
+        .ok_or_else(|| ApiError::bad_request("no file uploaded"))?;
+    let filename = field
+        .file_name()
+        .map(|s| s.to_string())
+        .unwrap_or_else(|| String::from("layer.png"));
+    let bytes = field
+        .bytes()
+        .await
+        .map_err(|e| ApiError::bad_request(format!("read file: {e}")))?
+        .to_vec();
 
     let decoded = image::load_from_memory(&bytes)
         .map_err(|e| ApiError::bad_request(format!("decode: {e}")))?;

koharu-rpc/src/routes/projects.rs

@@ -2,14 +2,12 @@
 //! `{data.path}/projects/` directory; clients never supply filesystem
 //! paths. A project's `id` is the `.khrproj/` directory basename.
 //!
-//! - `GET    /projects`                  — list managed projects
-//! - `POST   /projects`                  — create a new project (`{name}`),
-//!                                         server allocates the path
-//! - `POST   /projects/import`           — extract a `.khr` archive into a
-//!                                         fresh allocated directory + open
-//! - `PUT    /projects/current`          — open a managed project by `id`
-//! - `DELETE /projects/current`          — close current session
-//! - `POST   /projects/current/export`   — export current; returns bytes
+//! - `GET    /projects` — list managed projects
+//! - `POST   /projects` — create a new project (`{name}`), server allocates path
+//! - `POST   /projects/import` — extract a `.khr` archive into a fresh dir + open
+//! - `PUT    /projects/current` — open a managed project by `id`
+//! - `DELETE /projects/current` — close current session
+//! - `POST   /projects/current/export` — export current; returns bytes
 
 use axum::Json;
 use axum::body::{Body, Bytes};
@@ -311,7 +309,7 @@ async fn export_image_role(
             "no pages have the requested layer populated",
         ));
     }
-    Ok(files_to_response(files, project_name, role_ext(role))?)
+    files_to_response(files, project_name, role_ext(role))
 }
 
 fn resolve_page_ids(

koharu-rpc/tests/snapshots/openapi__openapi_paths_snapshot.snap

@@ -0,0 +1,194 @@
+---
+source: koharu-rpc/tests/openapi.rs
+assertion_line: 34
+expression: paths
+---
+[
+    (
+        "/blobs/{hash}",
+        [
+            "get",
+        ],
+    ),
+    (
+        "/config",
+        [
+            "get",
+            "patch",
+        ],
+    ),
+    (
+        "/config/providers/{id}/secret",
+        [
+            "delete",
+            "put",
+        ],
+    ),
+    (
+        "/downloads",
+        [
+            "get",
+            "post",
+        ],
+    ),
+    (
+        "/engines",
+        [
+            "get",
+        ],
+    ),
+    (
+        "/events",
+        [
+            "get",
+        ],
+    ),
+    (
+        "/fonts",
+        [
+            "get",
+        ],
+    ),
+    (
+        "/google-fonts",
+        [
+            "get",
+        ],
+    ),
+    (
+        "/google-fonts/{family}/fetch",
+        [
+            "post",
+        ],
+    ),
+    (
+        "/google-fonts/{family}/{file}",
+        [
+            "get",
+        ],
+    ),
+    (
+        "/history/apply",
+        [
+            "post",
+        ],
+    ),
+    (
+        "/history/redo",
+        [
+            "post",
+        ],
+    ),
+    (
+        "/history/undo",
+        [
+            "post",
+        ],
+    ),
+    (
+        "/llm/catalog",
+        [
+            "get",
+        ],
+    ),
+    (
+        "/llm/current",
+        [
+            "delete",
+            "get",
+            "put",
+        ],
+    ),
+    (
+        "/meta",
+        [
+            "get",
+        ],
+    ),
+    (
+        "/operations",
+        [
+            "get",
+        ],
+    ),
+    (
+        "/operations/{id}",
+        [
+            "delete",
+        ],
+    ),
+    (
+        "/pages",
+        [
+            "post",
+        ],
+    ),
+    (
+        "/pages/from-paths",
+        [
+            "post",
+        ],
+    ),
+    (
+        "/pages/{id}/image-layers",
+        [
+            "post",
+        ],
+    ),
+    (
+        "/pages/{id}/masks/{role}",
+        [
+            "put",
+        ],
+    ),
+    (
+        "/pages/{id}/thumbnail",
+        [
+            "get",
+        ],
+    ),
+    (
+        "/pipelines",
+        [
+            "post",
+        ],
+    ),
+    (
+        "/projects",
+        [
+            "get",
+            "post",
+        ],
+    ),
+    (
+        "/projects/current",
+        [
+            "delete",
+            "put",
+        ],
+    ),
+    (
+        "/projects/current/export",
+        [
+            "post",
+        ],
+    ),
+    (
+        "/projects/import",
+        [
+            "post",
+        ],
+    ),
+    (
+        "/scene.bin",
+        [
+            "get",
+        ],
+    ),
+    (
+        "/scene.json",
+        [
+            "get",
+        ],
+    ),
+]

tests/integration-tests/client/src/lib.rs

@@ -1,5 +1,8 @@
+// Auto-generated by openapi-generator — silence clippy across the whole
+// crate so CI stays green without hand-patching generator output.
 #![allow(unused_imports)]
-#![allow(clippy::too_many_arguments)]
+#![allow(clippy::all)]
+#![allow(clippy::pedantic)]
 
 extern crate reqwest;
 extern crate serde;

ui/package.json

@@ -38,6 +38,7 @@
     "@tanstack/react-query": "^5.99.0",
     "@tanstack/react-virtual": "^3.13.24",
     "@tauri-apps/api": "^2.10.1",
+    "@tauri-apps/plugin-dialog": "^2.7.0",
     "@tauri-apps/plugin-opener": "^2.4.0",
     "@tauri-apps/plugin-process": "^2.3.1",
     "@tauri-apps/plugin-updater": "^2.10.1",