feat: export to psd

Cargo.lock

@@ -1936,53 +1936,44 @@ checksum = "77ce24cb58228fbb8aa041425bb1050850ac19177686ea6e0f41a70416f56fdb"
 
 [[package]]
 name = "font-types"
-version = "0.10.1"
+version = "0.11.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "39a654f404bbcbd48ea58c617c2993ee91d1cb63727a37bf2323a4edeed1b8c5"
+checksum = "b1e4d2d0cf79d38430cc9dc9aadec84774bff2e1ba30ae2bf6c16cfce9385a23"
 dependencies = [
  "bytemuck",
 ]
 
 [[package]]
-name = "font-types"
-version = "0.11.0"
+name = "fontconfig-parser"
+version = "0.5.8"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b1e4d2d0cf79d38430cc9dc9aadec84774bff2e1ba30ae2bf6c16cfce9385a23"
+checksum = "bbc773e24e02d4ddd8395fd30dc147524273a83e54e0f312d986ea30de5f5646"
 dependencies = [
- "bytemuck",
+ "roxmltree",
 ]
 
 [[package]]
-name = "fontdue"
-version = "0.9.3"
+name = "fontdb"
+version = "0.23.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2e57e16b3fe8ff4364c0661fdaac543fb38b29ea9bc9c2f45612d90adf931d2b"
+checksum = "457e789b3d1202543297a350643cf459f836cade38934e7a4cf6a39e7cde2905"
 dependencies = [
- "hashbrown 0.15.5",
- "ttf-parser 0.21.1",
+ "fontconfig-parser",
+ "log",
+ "memmap2",
+ "slotmap",
+ "tinyvec",
+ "ttf-parser 0.25.1",
 ]
 
 [[package]]
-name = "fontique"
-version = "0.7.0"
+name = "fontdue"
+version = "0.9.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "30bbc252c93499b6d3635d692f892a637db0dbb130ce9b32bf20b28e0dcc470b"
+checksum = "2e57e16b3fe8ff4364c0661fdaac543fb38b29ea9bc9c2f45612d90adf931d2b"
 dependencies = [
- "bytemuck",
- "hashbrown 0.16.1",
- "icu_locale_core",
- "linebender_resource_handle",
- "memmap2",
- "objc2",
- "objc2-core-foundation",
- "objc2-core-text",
- "objc2-foundation",
- "read-fonts 0.35.0",
- "roxmltree",
- "smallvec",
- "windows 0.58.0",
- "windows-core 0.58.0",
- "yeslogic-fontconfig-sys",
+ "hashbrown 0.15.5",
+ "ttf-parser 0.21.1",
 ]
 
 [[package]]
@@ -2865,7 +2856,7 @@ dependencies = [
  "bitflags 2.11.0",
  "bytemuck",
  "core_maths",
- "read-fonts 0.37.0",
+ "read-fonts",
  "smallvec",
 ]
 
@@ -3962,14 +3953,25 @@ dependencies = [
  "uuid",
 ]
 
+[[package]]
+name = "koharu-psd"
+version = "0.38.1"
+dependencies = [
+ "image",
+ "koharu-renderer",
+ "koharu-types",
+ "psd",
+ "thiserror 2.0.18",
+]
+
 [[package]]
 name = "koharu-renderer"
 version = "0.38.1"
 dependencies = [
  "anyhow",
  "criterion",
+ "fontdb",
  "fontdue",
- "fontique",
  "harfrust",
  "icu",
  "image",
@@ -3997,6 +3999,7 @@ dependencies = [
  "imageproc",
  "koharu-http",
  "koharu-pipeline",
+ "koharu-psd",
  "koharu-types",
  "rmcp",
  "rmp-serde",
@@ -4186,12 +4189,6 @@ dependencies = [
  "vcpkg",
 ]
 
-[[package]]
-name = "linebender_resource_handle"
-version = "0.1.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d4a5ff6bcca6c4867b1c4fd4ef63e4db7436ef363e0ad7531d1558856bae64f4"
-
 [[package]]
 name = "linux-raw-sys"
 version = "0.12.1"
@@ -4817,16 +4814,6 @@ dependencies = [
  "objc2-io-surface",
 ]
 
-[[package]]
-name = "objc2-core-text"
-version = "0.3.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0cde0dfb48d25d2b4862161a4d5fcc0e3c24367869ad306b0c9ec0073bfed92d"
-dependencies = [
- "bitflags 2.11.0",
- "objc2-core-foundation",
-]
-
 [[package]]
 name = "objc2-encode"
 version = "4.1.0"
@@ -5609,6 +5596,15 @@ dependencies = [
  "syn 2.0.117",
 ]
 
+[[package]]
+name = "psd"
+version = "0.3.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9a25f9b8cfffd65d911baf31a033239f7a0facb755faa2481575b70db5dc9195"
+dependencies = [
+ "thiserror 1.0.69",
+]
+
 [[package]]
 name = "pulp"
 version = "0.21.5"
@@ -6001,16 +5997,6 @@ dependencies = [
  "crossbeam-utils",
 ]
 
-[[package]]
-name = "read-fonts"
-version = "0.35.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6717cf23b488adf64b9d711329542ba34de147df262370221940dfabc2c91358"
-dependencies = [
- "bytemuck",
- "font-types 0.10.1",
-]
-
 [[package]]
 name = "read-fonts"
 version = "0.37.0"
@@ -6019,7 +6005,7 @@ checksum = "7b634fabf032fab15307ffd272149b622260f55974d9fad689292a5d33df02e5"
 dependencies = [
  "bytemuck",
  "core_maths",
- "font-types 0.11.0",
+ "font-types",
 ]
 
 [[package]]
@@ -6360,12 +6346,9 @@ dependencies = [
 
 [[package]]
 name = "roxmltree"
-version = "0.21.1"
+version = "0.20.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f1964b10c76125c36f8afe190065a4bf9a87bf324842c05701330bba9f1cacbb"
-dependencies = [
- "memchr",
-]
+checksum = "6c20b6793b5c2fa6553b250154b78d6d0db37e72700ae35fad9387a46f487c97"
 
 [[package]]
 name = "rustc-hash"
@@ -7024,7 +7007,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "7fbdfe3d2475fbd7ddd1f3e5cf8288a30eb3e5f95832829570cd88115a7434ac"
 dependencies = [
  "bytemuck",
- "read-fonts 0.37.0",
+ "read-fonts",
 ]
 
 [[package]]
@@ -7033,6 +7016,15 @@ version = "0.4.12"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "0c790de23124f9ab44544d7ac05d60440adc586479ce501c1d6d7da3cd8c9cf5"
 
+[[package]]
+name = "slotmap"
+version = "1.1.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "bdd58c3c93c3d278ca835519292445cb4b0d4dc59ccfdf7ceadaab3f8aeb4038"
+dependencies = [
+ "version_check",
+]
+
 [[package]]
 name = "smallvec"
 version = "1.15.1"
@@ -8267,6 +8259,9 @@ name = "ttf-parser"
 version = "0.25.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "d2df906b07856748fa3f6e0ad0cbaa047052d4a7dd609e231c4f72cee8c36f31"
+dependencies = [
+ "core_maths",
+]
 
 [[package]]
 name = "tungstenite"
@@ -8939,8 +8934,8 @@ dependencies = [
  "webview2-com-sys",
  "windows 0.61.3",
  "windows-core 0.61.2",
- "windows-implement 0.60.2",
- "windows-interface 0.59.3",
+ "windows-implement",
+ "windows-interface",
 ]
 
 [[package]]
@@ -9027,16 +9022,6 @@ dependencies = [
  "windows-version",
 ]
 
-[[package]]
-name = "windows"
-version = "0.58.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "dd04d41d93c4992d421894c18c8b43496aa748dd4c081bac0dc93eb0489272b6"
-dependencies = [
- "windows-core 0.58.0",
- "windows-targets 0.52.6",
-]
-
 [[package]]
 name = "windows"
 version = "0.61.3"
@@ -9080,27 +9065,14 @@ dependencies = [
  "windows-core 0.62.2",
 ]
 
-[[package]]
-name = "windows-core"
-version = "0.58.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6ba6d44ec8c2591c134257ce647b7ea6b20335bf6379a27dac5f1641fcf59f99"
-dependencies = [
- "windows-implement 0.58.0",
- "windows-interface 0.58.0",
- "windows-result 0.2.0",
- "windows-strings 0.1.0",
- "windows-targets 0.52.6",
-]
-
 [[package]]
 name = "windows-core"
 version = "0.61.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "c0fdd3ddb90610c7638aa2b3a3ab2904fb9e5cdbecc643ddb3647212781c4ae3"
 dependencies = [
- "windows-implement 0.60.2",
- "windows-interface 0.59.3",
+ "windows-implement",
+ "windows-interface",
  "windows-link 0.1.3",
  "windows-result 0.3.4",
  "windows-strings 0.4.2",
@@ -9112,8 +9084,8 @@ version = "0.62.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "b8e83a14d34d0623b51dce9581199302a221863196a1dde71a7663a4c2be9deb"
 dependencies = [
- "windows-implement 0.60.2",
- "windows-interface 0.59.3",
+ "windows-implement",
+ "windows-interface",
  "windows-link 0.2.1",
  "windows-result 0.4.1",
  "windows-strings 0.5.1",
@@ -9141,17 +9113,6 @@ dependencies = [
  "windows-threading 0.2.1",
 ]
 
-[[package]]
-name = "windows-implement"
-version = "0.58.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2bbd5b46c938e506ecbce286b6628a02171d56153ba733b6c741fc627ec9579b"
-dependencies = [
- "proc-macro2",
- "quote",
- "syn 2.0.117",
-]
-
 [[package]]
 name = "windows-implement"
 version = "0.60.2"
@@ -9163,17 +9124,6 @@ dependencies = [
  "syn 2.0.117",
 ]
 
-[[package]]
-name = "windows-interface"
-version = "0.58.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "053c4c462dc91d3b1504c6fe5a726dd15e216ba718e84a0e46a88fbe5ded3515"
-dependencies = [
- "proc-macro2",
- "quote",
- "syn 2.0.117",
-]
-
 [[package]]
 name = "windows-interface"
 version = "0.59.3"
@@ -9228,15 +9178,6 @@ dependencies = [
  "windows-strings 0.5.1",
 ]
 
-[[package]]
-name = "windows-result"
-version = "0.2.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1d1043d8214f791817bab27572aaa8af63732e11bf84aa21a45a78d6c317ae0e"
-dependencies = [
- "windows-targets 0.52.6",
-]
-
 [[package]]
 name = "windows-result"
 version = "0.3.4"
@@ -9255,16 +9196,6 @@ dependencies = [
  "windows-link 0.2.1",
 ]
 
-[[package]]
-name = "windows-strings"
-version = "0.1.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4cd9b125c486025df0eabcb585e62173c6c9eddcec5d117d3b6e8c30e2ee4d10"
-dependencies = [
- "windows-result 0.2.0",
- "windows-targets 0.52.6",
-]
-
 [[package]]
 name = "windows-strings"
 version = "0.4.2"
@@ -9763,17 +9694,6 @@ version = "0.8.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "7a5a4b21e1a62b67a2970e6831bc091d7b87e119e7f9791aef9702e3bef04448"
 
-[[package]]
-name = "yeslogic-fontconfig-sys"
-version = "6.0.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "503a066b4c037c440169d995b869046827dbc71263f6e8f3be6d77d4f3229dbd"
-dependencies = [
- "dlib",
- "once_cell",
- "pkg-config",
-]
-
 [[package]]
 name = "yoke"
 version = "0.7.5"

Cargo.toml

@@ -4,6 +4,7 @@ members = [
     "koharu-http",
     "koharu-ml",
     "koharu-runtime",
+    "koharu-psd",
     "koharu-renderer",
     "koharu-pipeline",
     "koharu-rpc",
@@ -31,6 +32,7 @@ publish = false
 koharu-http = { path = "koharu-http", default-features = false }
 koharu-runtime = { path = "koharu-runtime", default-features = false }
 koharu-ml = { path = "koharu-ml", default-features = false }
+koharu-psd = { path = "koharu-psd", default-features = false }
 koharu-renderer = { path = "koharu-renderer", default-features = false }
 koharu-pipeline = { path = "koharu-pipeline", default-features = false }
 koharu-rpc = { path = "koharu-rpc", default-features = false }
@@ -106,7 +108,7 @@ winreg = "0.56"
 skrifa = "0.40"
 harfrust = "0.5"
 icu = "2.1"
-fontique = "0.7"
+fontdb = "0.23"
 fontdue = "0.9"
 tiny-skia = "0.12"
 axum = { version = "0.8", features = ["multipart", "ws"] }

README.md

@@ -18,24 +18,29 @@ Under the hood, Koharu uses [candle](https://github.com/huggingface/candle) for
 > [!NOTE]
 > For help and support, please join our [Discord server](https://discord.gg/mHvHkxGnUY).
 
-## Features
-
-- Automatic speech bubble detection and segmentation
-- OCR for manga text recognition
-- Inpainting to remove original text from images
-- LLM-powered translation
-- Vertical text layout for CJK languages
-- MCP server for AI agents
+## Features
+
+- Automatic speech bubble detection and segmentation
+- OCR for manga text recognition
+- Inpainting to remove original text from images
+- LLM-powered translation
+- Vertical text layout for CJK languages
+- Export to layered PSD with editable text
+- MCP server for AI agents
 
 ## Usage
 
-### Hot keys
-
-- <kbd>Ctrl</kbd> + Mouse Wheel: Zoom in/out
-- <kbd>Ctrl</kbd> + Drag: Pan the canvas
-- <kbd>Del</kbd>: Delete selected text block
-
-### MCP Server
+### Hot keys
+
+- <kbd>Ctrl</kbd> + Mouse Wheel: Zoom in/out
+- <kbd>Ctrl</kbd> + Drag: Pan the canvas
+- <kbd>Del</kbd>: Delete selected text block
+
+### Export
+
+Koharu can export the current page as a rendered image or as a layered Photoshop PSD. PSD export preserves helper layers and writes translated text as editable text layers for further cleanup in Photoshop.
+
+### MCP Server
 
 Koharu has a built-in MCP server that can be used to integrate with AI agents. By default, the MCP server will listen on a random port, but you can specify the port using the `--port` flag.
 

docs/README.ja.md

@@ -23,6 +23,7 @@ Koharu は、ML の力を活用して翻訳工程を自動化する、新しい
 - 画像から元の文字を消すためのインペインティング
 - LLM による翻訳
 - CJK（中国語・日本語・韓国語）向けの縦書きレイアウト
+- 編集可能なテキスト付きのレイヤー PSD 書き出し
 - AI エージェントとの連携のための MCP サーバー
 
 ## 使い方
@@ -33,6 +34,10 @@ Koharu は、ML の力を活用して翻訳工程を自動化する、新しい
 - <kbd>Ctrl</kbd> + ドラッグ: キャンバスのパン（移動）
 - <kbd>Del</kbd>: 選択したテキストブロックを削除
 
+### 書き出し
+
+Koharu は現在のページをレンダリング済み画像として書き出すだけでなく、レイヤー付きの Photoshop PSD としても書き出せます。PSD 書き出しでは補助レイヤーを保持しつつ、翻訳済みテキストを編集可能なテキストレイヤーとして保存できます。
+
 ### MCP サーバー
 
 Koharu には MCP サーバーが内蔵されており、AI エージェントとの連携に使用できます。デフォルトでは、MCP サーバーはランダムなポートでリッスンしますが、`--port` フラグを使用してポートを指定できます。

docs/README.zh-CN.md

@@ -23,6 +23,7 @@ Koharu 引入了一种新的漫画翻译工作流，利用机器学习能力自
 - 通过图像修复去除原图文字
 - 基于 LLM 的翻译
 - 面向 CJK 语言的竖排文本布局
+- 支持导出带可编辑文字图层的 PSD
 - 面向 AI Agent 的 MCP 服务器
 
 ## 使用方法
@@ -33,6 +34,10 @@ Koharu 引入了一种新的漫画翻译工作流，利用机器学习能力自
 - <kbd>Ctrl</kbd> + 拖动：平移画布
 - <kbd>Del</kbd>：删除选中的文本块
 
+### 导出
+
+Koharu 既可以将当前页面导出为渲染后的图片，也可以导出为带图层的 Photoshop PSD。PSD 导出会保留辅助图层，并将翻译后的文字写成可编辑的文字图层，方便在 Photoshop 中继续调整。
+
 ### MCP 服务器
 
 Koharu 内置 MCP 服务器，可用于与 AI Agent 集成。默认情况下，MCP 服务器会监听一个随机端口；你也可以通过 `--port` 参数指定端口。

koharu-pipeline/src/ops/edit.rs

@@ -308,6 +308,7 @@ pub async fn update_text_block(
             }
 
             block.rendered = None;
+            block.rendered_direction = None;
             Ok(to_block_info(payload.text_block_index, block))
         },
     )

koharu-pipeline/src/ops/vision.rs

@@ -1,3 +1,4 @@
+use koharu_types::FontFaceInfo;
 use koharu_types::commands::{IndexPayload, RenderPayload};
 use tracing::instrument;
 
@@ -66,6 +67,6 @@ pub async fn render(state: AppResources, payload: RenderPayload) -> anyhow::Resu
     .await
 }
 
-pub async fn list_font_families(state: AppResources) -> anyhow::Result<Vec<String>> {
+pub async fn list_font_families(state: AppResources) -> anyhow::Result<Vec<FontFaceInfo>> {
     state.renderer.available_fonts()
 }

koharu-psd/Cargo.toml

@@ -0,0 +1,21 @@
+[package]
+name = "koharu-psd"
+version.workspace = true
+edition.workspace = true
+description.workspace = true
+license.workspace = true
+authors.workspace = true
+readme.workspace = true
+homepage.workspace = true
+repository.workspace = true
+keywords.workspace = true
+publish.workspace = true
+
+[dependencies]
+koharu-types = { workspace = true }
+image = { workspace = true }
+thiserror = { workspace = true }
+
+[dev-dependencies]
+koharu-renderer = { workspace = true }
+psd = "0.3.5"

koharu-psd/examples/from_image.rs

@@ -0,0 +1,201 @@
+use std::{error::Error, fs, path::PathBuf};
+
+use image::{DynamicImage, GrayImage, Luma, Rgba, RgbaImage};
+use koharu_psd::{PsdExportOptions, TextLayerMode, export_document};
+use koharu_renderer::facade::Renderer;
+use koharu_types::{
+    Document, FontPrediction, NamedFontPrediction, SerializableDynamicImage, TextAlign, TextBlock,
+    TextDirection, TextShaderEffect, TextStyle,
+};
+
+fn main() -> Result<(), Box<dyn Error>> {
+    let (input, output, editable) = parse_args()?;
+
+    if let Some(parent) = output.parent() {
+        fs::create_dir_all(parent)?;
+    }
+
+    let mut document = Document::open(input.clone())?;
+    apply_demo_layers(&mut document);
+    render_demo_text(&mut document)?;
+
+    let options = PsdExportOptions {
+        text_layer_mode: if editable {
+            TextLayerMode::Editable
+        } else {
+            TextLayerMode::Rasterized
+        },
+        ..Default::default()
+    };
+
+    let bytes = export_document(&document, &options)?;
+    fs::write(&output, bytes)?;
+
+    println!("input  {}", input.display());
+    println!(
+        "mode   {}",
+        match options.text_layer_mode {
+            TextLayerMode::Rasterized => "rasterized",
+            TextLayerMode::Editable => "editable",
+        }
+    );
+    println!("wrote  {}", output.display());
+    Ok(())
+}
+
+fn parse_args() -> Result<(PathBuf, PathBuf, bool), Box<dyn Error>> {
+    let mut input = None;
+    let mut output = None;
+    let mut editable = false;
+
+    for arg in std::env::args().skip(1) {
+        match arg.as_str() {
+            "--editable" => editable = true,
+            other if input.is_none() => input = Some(PathBuf::from(other)),
+            other if output.is_none() => output = Some(PathBuf::from(other)),
+            _ => {
+                return Err(
+                    "usage: cargo run -p koharu-psd --example from_image -- [--editable] <input-image> [output.psd]"
+                        .into(),
+                );
+            }
+        }
+    }
+
+    let input = input.ok_or_else(|| {
+        "usage: cargo run -p koharu-psd --example from_image -- [--editable] <input-image> [output.psd]"
+            .to_string()
+    })?;
+    let output = output.unwrap_or_else(|| input.with_extension("psd"));
+    Ok((input, output, editable))
+}
+
+fn apply_demo_layers(document: &mut Document) {
+    let width = document.width.max(document.image.width());
+    let height = document.height.max(document.image.height());
+    document.width = width;
+    document.height = height;
+
+    let base = document.image.to_rgba8();
+    let inpainted = softened_copy(&base);
+    let segment = build_segment(width, height);
+    let brush = build_brush(width, height);
+
+    document.inpainted = Some(to_serializable_rgba(inpainted));
+    document.segment = Some(to_serializable_luma(segment));
+    document.brush_layer = Some(to_serializable_rgba(brush));
+    document.rendered = None;
+    document.text_blocks = vec![
+        TextBlock {
+            id: "top-callout".to_string(),
+            x: (width as f32 * 0.08).floor(),
+            y: (height as f32 * 0.08).floor(),
+            width: width.min(420).max(180) as f32,
+            height: (height / 5).max(72) as f32,
+            translation: Some("Generated from your image".to_string()),
+            style: Some(TextStyle {
+                font_families: vec!["ArialMT".to_string()],
+                font_size: Some((height as f32 * 0.06).max(18.0)),
+                color: [24, 24, 28, 255],
+                effect: Some(TextShaderEffect {
+                    italic: false,
+                    bold: true,
+                }),
+                stroke: None,
+                text_align: Some(TextAlign::Center),
+            }),
+            lock_layout_box: true,
+            ..Default::default()
+        },
+        TextBlock {
+            id: "side-note".to_string(),
+            x: (width as f32 * 0.78).floor(),
+            y: (height as f32 * 0.18).floor(),
+            width: (width as f32 * 0.14).max(64.0),
+            height: (height as f32 * 0.42).max(180.0),
+            translation: Some("\u{7e26}\u{66f8}\u{304d}".to_string()),
+            source_direction: Some(TextDirection::Vertical),
+            style: Some(TextStyle {
+                font_families: vec!["YuGothic-Regular".to_string()],
+                font_size: Some((height as f32 * 0.05).max(18.0)),
+                color: [26, 54, 96, 255],
+                effect: None,
+                stroke: None,
+                text_align: None,
+            }),
+            font_prediction: Some(FontPrediction {
+                named_fonts: vec![NamedFontPrediction {
+                    index: 0,
+                    name: "YuGothic-Regular".to_string(),
+                    language: Some("ja".to_string()),
+                    probability: 0.9,
+                    serif: false,
+                }],
+                direction: TextDirection::Vertical,
+                text_color: [26, 54, 96],
+                font_size_px: (height as f32 * 0.05).max(18.0),
+                angle_deg: 6.0,
+                ..Default::default()
+            }),
+            lock_layout_box: true,
+            ..Default::default()
+        },
+    ];
+}
+
+fn softened_copy(base: &RgbaImage) -> RgbaImage {
+    let mut out = base.clone();
+    for pixel in out.pixels_mut() {
+        pixel.0[0] = ((u16::from(pixel.0[0]) * 9 + 255) / 10) as u8;
+        pixel.0[1] = ((u16::from(pixel.0[1]) * 9 + 248) / 10) as u8;
+        pixel.0[2] = ((u16::from(pixel.0[2]) * 9 + 240) / 10) as u8;
+    }
+    out
+}
+
+fn build_segment(width: u32, height: u32) -> GrayImage {
+    let mut image = GrayImage::new(width, height);
+    let x0 = width / 10;
+    let x1 = width.saturating_mul(9) / 10;
+    let y0 = height / 12;
+    let y1 = height.saturating_mul(11) / 12;
+
+    for y in 0..height {
+        for x in 0..width {
+            let bright = (x0..x1).contains(&x) && (y0..y1).contains(&y);
+            image.put_pixel(x, y, Luma([if bright { 150 } else { 24 }]));
+        }
+    }
+    image
+}
+
+fn build_brush(width: u32, height: u32) -> RgbaImage {
+    let mut image = RgbaImage::from_pixel(width, height, Rgba([0, 0, 0, 0]));
+    let left = width / 8;
+    let right = width.saturating_mul(7) / 8;
+    let top = height.saturating_mul(3) / 5;
+
+    for x in left..right {
+        for offset in 0..6 {
+            let y = top + offset;
+            if y < height {
+                image.put_pixel(x, y, Rgba([255, 0, 128, 120]));
+            }
+        }
+    }
+
+    image
+}
+
+fn render_demo_text(document: &mut Document) -> Result<(), Box<dyn Error>> {
+    Renderer::new()?.render(document, None, TextShaderEffect::none(), None, None)?;
+    Ok(())
+}
+
+fn to_serializable_rgba(image: RgbaImage) -> SerializableDynamicImage {
+    SerializableDynamicImage(DynamicImage::ImageRgba8(image))
+}
+
+fn to_serializable_luma(image: GrayImage) -> SerializableDynamicImage {
+    SerializableDynamicImage(DynamicImage::ImageLuma8(image))
+}

koharu-psd/examples/full_fixture.rs

@@ -0,0 +1,211 @@
+use std::{error::Error, fs, path::PathBuf};
+
+use image::{DynamicImage, GrayImage, Luma, Rgba, RgbaImage};
+use koharu_psd::{PsdExportOptions, TextLayerMode, export_document};
+use koharu_renderer::facade::Renderer;
+use koharu_types::{
+    Document, FontPrediction, NamedFontPrediction, SerializableDynamicImage, TextAlign, TextBlock,
+    TextDirection, TextShaderEffect, TextStyle,
+};
+
+fn main() -> Result<(), Box<dyn Error>> {
+    let (output, editable) = parse_args()?;
+
+    if let Some(parent) = output.parent() {
+        fs::create_dir_all(parent)?;
+    }
+
+    let mut document = build_document();
+    render_demo_text(&mut document)?;
+
+    let options = PsdExportOptions {
+        text_layer_mode: if editable {
+            TextLayerMode::Editable
+        } else {
+            TextLayerMode::Rasterized
+        },
+        ..Default::default()
+    };
+
+    let bytes = export_document(&document, &options)?;
+    fs::write(&output, bytes)?;
+
+    println!(
+        "mode   {}",
+        match options.text_layer_mode {
+            TextLayerMode::Rasterized => "rasterized",
+            TextLayerMode::Editable => "editable",
+        }
+    );
+    println!("wrote {}", output.display());
+    Ok(())
+}
+
+fn parse_args() -> Result<(PathBuf, bool), Box<dyn Error>> {
+    let mut output = None;
+    let mut editable = false;
+
+    for arg in std::env::args().skip(1) {
+        match arg.as_str() {
+            "--editable" => editable = true,
+            other if output.is_none() => output = Some(PathBuf::from(other)),
+            _ => {
+                return Err(
+                    "usage: cargo run -p koharu-psd --example full_fixture -- [--editable] [output.psd]"
+                        .into(),
+                );
+            }
+        }
+    }
+
+    Ok((
+        output.unwrap_or_else(|| PathBuf::from("target/koharu-psd/full-fixture.psd")),
+        editable,
+    ))
+}
+
+fn build_document() -> Document {
+    let width = 960;
+    let height = 640;
+
+    let original = build_original(width, height);
+    let inpainted = build_inpainted(&original);
+    let segment = build_segment(width, height);
+    let brush_layer = build_brush_layer(width, height);
+
+    Document {
+        id: "full-fixture".to_string(),
+        path: PathBuf::from("full-fixture.png"),
+        name: "full-fixture".to_string(),
+        image: to_serializable_rgba(original),
+        width,
+        height,
+        revision: 0,
+        text_blocks: vec![
+            TextBlock {
+                id: "hero-title".to_string(),
+                x: 130.0,
+                y: 84.0,
+                width: 300.0,
+                height: 110.0,
+                translation: Some("Editable PSD text".to_string()),
+                style: Some(TextStyle {
+                    font_families: vec!["ArialMT".to_string()],
+                    font_size: Some(44.0),
+                    color: [25, 24, 28, 255],
+                    effect: Some(TextShaderEffect {
+                        italic: false,
+                        bold: true,
+                    }),
+                    stroke: None,
+                    text_align: Some(TextAlign::Center),
+                }),
+                lock_layout_box: true,
+                ..Default::default()
+            },
+            TextBlock {
+                id: "side-note".to_string(),
+                x: 760.0,
+                y: 170.0,
+                width: 110.0,
+                height: 250.0,
+                translation: Some("\u{7e26}\u{66f8}\u{304d}".to_string()),
+                source_direction: Some(TextDirection::Vertical),
+                style: Some(TextStyle {
+                    font_families: vec!["YuGothic-Regular".to_string()],
+                    font_size: Some(36.0),
+                    color: [28, 50, 92, 255],
+                    effect: None,
+                    stroke: None,
+                    text_align: None,
+                }),
+                font_prediction: Some(FontPrediction {
+                    named_fonts: vec![NamedFontPrediction {
+                        index: 0,
+                        name: "YuGothic-Regular".to_string(),
+                        language: Some("ja".to_string()),
+                        probability: 0.94,
+                        serif: false,
+                    }],
+                    direction: TextDirection::Vertical,
+                    text_color: [28, 50, 92],
+                    font_size_px: 36.0,
+                    angle_deg: 4.0,
+                    ..Default::default()
+                }),
+                lock_layout_box: true,
+                ..Default::default()
+            },
+        ],
+        segment: Some(to_serializable_luma(segment)),
+        inpainted: Some(to_serializable_rgba(inpainted)),
+        rendered: None,
+        brush_layer: Some(to_serializable_rgba(brush_layer)),
+    }
+}
+
+fn build_original(width: u32, height: u32) -> RgbaImage {
+    let mut image = RgbaImage::new(width, height);
+    for y in 0..height {
+        for x in 0..width {
+            let warm = 210u8.saturating_add((x / 32 % 2) as u8 * 12);
+            let cool = 190u8.saturating_add((y / 24 % 2) as u8 * 18);
+            let blue = 170u8.saturating_add(((x + y) / 48 % 2) as u8 * 20);
+            image.put_pixel(x, y, Rgba([warm, cool, blue, 255]));
+        }
+    }
+    image
+}
+
+fn build_inpainted(original: &RgbaImage) -> RgbaImage {
+    let mut image = original.clone();
+    for y in 210..455 {
+        for x in 250..700 {
+            image.put_pixel(x, y, Rgba([244, 240, 230, 255]));
+        }
+    }
+    image
+}
+
+fn build_segment(width: u32, height: u32) -> GrayImage {
+    let mut image = GrayImage::new(width, height);
+    for y in 0..height {
+        for x in 0..width {
+            let inside = (120..440).contains(&x) && (60..220).contains(&y)
+                || (730..890).contains(&x) && (150..470).contains(&y)
+                || (240..720).contains(&x) && (210..470).contains(&y);
+            image.put_pixel(x, y, Luma([if inside { 180 } else { 32 }]));
+        }
+    }
+    image
+}
+
+fn build_brush_layer(width: u32, height: u32) -> RgbaImage {
+    let mut image = RgbaImage::from_pixel(width, height, Rgba([0, 0, 0, 0]));
+    for x in 240..720 {
+        for thickness in 0..8 {
+            image.put_pixel(x, 208 + thickness, Rgba([255, 0, 128, 150]));
+            image.put_pixel(x, 468 - thickness, Rgba([255, 0, 128, 150]));
+        }
+    }
+    for y in 208..468 {
+        for thickness in 0..8 {
+            image.put_pixel(240 + thickness, y, Rgba([255, 0, 128, 150]));
+            image.put_pixel(712 - thickness, y, Rgba([255, 0, 128, 150]));
+        }
+    }
+    image
+}
+
+fn render_demo_text(document: &mut Document) -> Result<(), Box<dyn Error>> {
+    Renderer::new()?.render(document, None, TextShaderEffect::none(), None, None)?;
+    Ok(())
+}
+
+fn to_serializable_rgba(image: RgbaImage) -> SerializableDynamicImage {
+    SerializableDynamicImage(DynamicImage::ImageRgba8(image))
+}
+
+fn to_serializable_luma(image: GrayImage) -> SerializableDynamicImage {
+    SerializableDynamicImage(DynamicImage::ImageLuma8(image))
+}

koharu-psd/src/descriptor.rs

@@ -0,0 +1,181 @@
+use crate::{error::PsdExportError, writer::PsdWriter};
+
+#[derive(Debug, Clone)]
+pub struct DescriptorObject {
+    pub name: String,
+    pub class_id: String,
+    pub items: Vec<DescriptorItem>,
+}
+
+#[derive(Debug, Clone)]
+pub struct DescriptorItem {
+    pub key: String,
+    pub value: DescriptorValue,
+}
+
+#[derive(Debug, Clone)]
+pub enum DescriptorValue {
+    Text(String),
+    Enum { type_id: String, value: String },
+    Integer(i32),
+    Double(f64),
+    UnitPixels(f64),
+    Raw(Vec<u8>),
+    Object(DescriptorObject),
+}
+
+impl DescriptorObject {
+    pub fn new(name: impl Into<String>, class_id: impl Into<String>) -> Self {
+        Self {
+            name: name.into(),
+            class_id: class_id.into(),
+            items: Vec::new(),
+        }
+    }
+
+    pub fn with_item(mut self, key: impl Into<String>, value: DescriptorValue) -> Self {
+        self.items.push(DescriptorItem {
+            key: key.into(),
+            value,
+        });
+        self
+    }
+}
+
+pub fn write_versioned_descriptor(
+    writer: &mut PsdWriter,
+    descriptor: &DescriptorObject,
+) -> Result<(), PsdExportError> {
+    writer.write_u32(16);
+    write_descriptor_object(writer, descriptor)
+}
+
+pub fn bounds_descriptor(
+    class_id: &str,
+    left: f64,
+    top: f64,
+    right: f64,
+    bottom: f64,
+) -> DescriptorObject {
+    DescriptorObject::new("", class_id)
+        .with_item("Left", DescriptorValue::UnitPixels(left))
+        .with_item("Top ", DescriptorValue::UnitPixels(top))
+        .with_item("Rght", DescriptorValue::UnitPixels(right))
+        .with_item("Btom", DescriptorValue::UnitPixels(bottom))
+}
+
+fn write_descriptor_object(
+    writer: &mut PsdWriter,
+    descriptor: &DescriptorObject,
+) -> Result<(), PsdExportError> {
+    validate_descriptor_id(&descriptor.class_id)?;
+    writer.write_unicode_string_with_padding(&descriptor.name);
+    writer.write_ascii_or_class_id(&descriptor.class_id);
+    writer.write_u32(descriptor.items.len() as u32);
+
+    for item in &descriptor.items {
+        validate_descriptor_key(&item.key)?;
+        writer.write_ascii_or_class_id(&item.key);
+        write_descriptor_value(writer, &item.value)?;
+    }
+
+    Ok(())
+}
+
+fn write_descriptor_value(
+    writer: &mut PsdWriter,
+    value: &DescriptorValue,
+) -> Result<(), PsdExportError> {
+    match value {
+        DescriptorValue::Text(text) => {
+            writer.write_signature("TEXT");
+            writer.write_unicode_string_with_padding(text);
+        }
+        DescriptorValue::Enum { type_id, value } => {
+            validate_descriptor_id(type_id)?;
+            validate_descriptor_id(value)?;
+            writer.write_signature("enum");
+            writer.write_ascii_or_class_id(type_id);
+            writer.write_ascii_or_class_id(value);
+        }
+        DescriptorValue::Integer(number) => {
+            writer.write_signature("long");
+            writer.write_i32(*number);
+        }
+        DescriptorValue::Double(number) => {
+            writer.write_signature("doub");
+            writer.write_f64(*number);
+        }
+        DescriptorValue::UnitPixels(number) => {
+            writer.write_signature("UntF");
+            writer.write_signature("#Pxl");
+            writer.write_f64(*number);
+        }
+        DescriptorValue::Raw(bytes) => {
+            writer.write_signature("tdta");
+            writer.write_u32(bytes.len() as u32);
+            writer.write_bytes(bytes);
+        }
+        DescriptorValue::Object(object) => {
+            writer.write_signature("Objc");
+            write_descriptor_object(writer, object)?;
+        }
+    }
+
+    Ok(())
+}
+
+fn validate_descriptor_id(value: &str) -> Result<(), PsdExportError> {
+    if value.is_empty() {
+        return Err(PsdExportError::InvalidDescriptor(
+            "descriptor IDs must not be empty".to_string(),
+        ));
+    }
+
+    if !value.is_ascii() {
+        return Err(PsdExportError::InvalidDescriptor(format!(
+            "descriptor IDs must be ASCII: {value:?}"
+        )));
+    }
+
+    Ok(())
+}
+
+fn validate_descriptor_key(value: &str) -> Result<(), PsdExportError> {
+    validate_descriptor_id(value)
+}
+
+#[cfg(test)]
+mod tests {
+    use super::{DescriptorObject, DescriptorValue, bounds_descriptor, write_versioned_descriptor};
+    use crate::writer::PsdWriter;
+
+    #[test]
+    fn versioned_descriptor_writes_expected_signatures() {
+        let descriptor = DescriptorObject::new("", "TxLr")
+            .with_item("Txt ", DescriptorValue::Text("HELLO".to_string()))
+            .with_item(
+                "Ornt",
+                DescriptorValue::Enum {
+                    type_id: "Ornt".to_string(),
+                    value: "Hrzn".to_string(),
+                },
+            )
+            .with_item("TextIndex", DescriptorValue::Integer(1))
+            .with_item(
+                "bounds",
+                DescriptorValue::Object(bounds_descriptor("bounds", 1.0, 2.0, 3.0, 4.0)),
+            );
+
+        let mut writer = PsdWriter::new();
+        write_versioned_descriptor(&mut writer, &descriptor).expect("descriptor");
+        let bytes = writer.into_inner();
+
+        assert_eq!(&bytes[..4], &[0, 0, 0, 16]);
+        assert!(bytes.windows(4).any(|window| window == b"TxLr"));
+        assert!(bytes.windows(4).any(|window| window == b"TEXT"));
+        assert!(bytes.windows(4).any(|window| window == b"enum"));
+        assert!(bytes.windows(4).any(|window| window == b"long"));
+        assert!(bytes.windows(4).any(|window| window == b"UntF"));
+    }
+}

koharu-psd/src/engine_data.rs

@@ -0,0 +1,852 @@
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub enum TextOrientation {
+    Horizontal,
+    Vertical,
+}
+
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub enum TextJustification {
+    Left,
+    Center,
+    Right,
+}
+
+#[derive(Debug, Clone)]
+pub struct TextEngineSpec {
+    pub text: String,
+    pub font_name: String,
+    pub font_size: f64,
+    pub color: [u8; 4],
+    pub faux_bold: bool,
+    pub faux_italic: bool,
+    pub orientation: TextOrientation,
+    pub justification: TextJustification,
+    pub box_width: f64,
+    pub box_height: f64,
+}
+
+#[derive(Debug, Clone)]
+enum EngineValue {
+    Int(i32),
+    Float(f64),
+    Bool(bool),
+    String(String),
+    Array(Vec<EngineValue>),
+    Dict(Vec<(String, EngineValue)>),
+}
+
+pub fn encode_engine_data(spec: &TextEngineSpec) -> Vec<u8> {
+    let text = normalize_text(&spec.text);
+    let paragraph_lengths = paragraph_run_lengths(&text);
+    let total_length = utf16_len(&text) as i32;
+
+    let font_name = if spec.font_name.trim().is_empty() {
+        "ArialMT"
+    } else {
+        spec.font_name.trim()
+    };
+    let font_index = if font_name == "AdobeInvisFont" { 0 } else { 1 };
+    let writing_direction = match spec.orientation {
+        TextOrientation::Horizontal => 0,
+        TextOrientation::Vertical => 2,
+    };
+    let procession = match spec.orientation {
+        TextOrientation::Horizontal => 0,
+        TextOrientation::Vertical => 1,
+    };
+
+    let paragraph_properties = paragraph_properties(spec.justification);
+    let base_style_sheet = base_style_sheet(font_index);
+    let style_run_sheet = style_run_sheet(spec, font_index);
+    let font_set = font_set(font_name);
+
+    let root = EngineValue::Dict(vec![
+        (
+            "EngineDict".to_string(),
+            EngineValue::Dict(vec![
+                (
+                    "Editor".to_string(),
+                    EngineValue::Dict(vec![("Text".to_string(), EngineValue::String(text))]),
+                ),
+                (
+                    "ParagraphRun".to_string(),
+                    EngineValue::Dict(vec![
+                        (
+                            "DefaultRunData".to_string(),
+                            EngineValue::Dict(vec![
+                                (
+                                    "ParagraphSheet".to_string(),
+                                    EngineValue::Dict(vec![
+                                        ("DefaultStyleSheet".to_string(), EngineValue::Int(0)),
+                                        ("Properties".to_string(), EngineValue::Dict(Vec::new())),
+                                    ]),
+                                ),
+                                (
+                                    "Adjustments".to_string(),
+                                    EngineValue::Dict(vec![
+                                        (
+                                            "Axis".to_string(),
+                                            EngineValue::Array(vec![
+                                                EngineValue::Float(1.0),
+                                                EngineValue::Float(0.0),
+                                                EngineValue::Float(1.0),
+                                            ]),
+                                        ),
+                                        (
+                                            "XY".to_string(),
+                                            EngineValue::Array(vec![
+                                                EngineValue::Float(0.0),
+                                                EngineValue::Float(0.0),
+                                            ]),
+                                        ),
+                                    ]),
+                                ),
+                            ]),
+                        ),
+                        (
+                            "RunArray".to_string(),
+                            EngineValue::Array(
+                                paragraph_lengths
+                                    .iter()
+                                    .map(|_| {
+                                        EngineValue::Dict(vec![
+                                            (
+                                                "ParagraphSheet".to_string(),
+                                                EngineValue::Dict(vec![
+                                                    (
+                                                        "DefaultStyleSheet".to_string(),
+                                                        EngineValue::Int(0),
+                                                    ),
+                                                    (
+                                                        "Properties".to_string(),
+                                                        EngineValue::Dict(
+                                                            paragraph_properties.clone(),
+                                                        ),
+                                                    ),
+                                                ]),
+                                            ),
+                                            (
+                                                "Adjustments".to_string(),
+                                                EngineValue::Dict(vec![
+                                                    (
+                                                        "Axis".to_string(),
+                                                        EngineValue::Array(vec![
+                                                            EngineValue::Float(1.0),
+                                                            EngineValue::Float(0.0),
+                                                            EngineValue::Float(1.0),
+                                                        ]),
+                                                    ),
+                                                    (
+                                                        "XY".to_string(),
+                                                        EngineValue::Array(vec![
+                                                            EngineValue::Float(0.0),
+                                                            EngineValue::Float(0.0),
+                                                        ]),
+                                                    ),
+                                                ]),
+                                            ),
+                                        ])
+                                    })
+                                    .collect(),
+                            ),
+                        ),
+                        (
+                            "RunLengthArray".to_string(),
+                            EngineValue::Array(
+                                paragraph_lengths
+                                    .iter()
+                                    .copied()
+                                    .map(EngineValue::Int)
+                                    .collect(),
+                            ),
+                        ),
+                        ("IsJoinable".to_string(), EngineValue::Int(1)),
+                    ]),
+                ),
+                (
+                    "StyleRun".to_string(),
+                    EngineValue::Dict(vec![
+                        (
+                            "DefaultRunData".to_string(),
+                            EngineValue::Dict(vec![(
+                                "StyleSheet".to_string(),
+                                EngineValue::Dict(vec![(
+                                    "StyleSheetData".to_string(),
+                                    EngineValue::Dict(Vec::new()),
+                                )]),
+                            )]),
+                        ),
+                        (
+                            "RunArray".to_string(),
+                            EngineValue::Array(vec![EngineValue::Dict(vec![(
+                                "StyleSheet".to_string(),
+                                EngineValue::Dict(vec![(
+                                    "StyleSheetData".to_string(),
+                                    EngineValue::Dict(style_run_sheet.clone()),
+                                )]),
+                            )])]),
+                        ),
+                        (
+                            "RunLengthArray".to_string(),
+                            EngineValue::Array(vec![EngineValue::Int(total_length)]),
+                        ),
+                        ("IsJoinable".to_string(), EngineValue::Int(2)),
+                    ]),
+                ),
+                (
+                    "GridInfo".to_string(),
+                    EngineValue::Dict(vec![
+                        ("GridIsOn".to_string(), EngineValue::Bool(false)),
+                        ("ShowGrid".to_string(), EngineValue::Bool(false)),
+                        ("GridSize".to_string(), EngineValue::Float(18.0)),
+                        ("GridLeading".to_string(), EngineValue::Float(22.0)),
+                        (
+                            "GridColor".to_string(),
+                            EngineValue::Dict(color_type_values([0, 0, 255, 255])),
+                        ),
+                        (
+                            "GridLeadingFillColor".to_string(),
+                            EngineValue::Dict(color_type_values([0, 0, 255, 255])),
+                        ),
+                        (
+                            "AlignLineHeightToGridFlags".to_string(),
+                            EngineValue::Bool(false),
+                        ),
+                    ]),
+                ),
+                ("AntiAlias".to_string(), EngineValue::Int(4)),
+                (
+                    "UseFractionalGlyphWidths".to_string(),
+                    EngineValue::Bool(true),
+                ),
+                (
+                    "Rendered".to_string(),
+                    EngineValue::Dict(vec![
+                        ("Version".to_string(), EngineValue::Int(1)),
+                        (
+                            "Shapes".to_string(),
+                            EngineValue::Dict(vec![
+                                (
+                                    "WritingDirection".to_string(),
+                                    EngineValue::Int(writing_direction),
+                                ),
+                                (
+                                    "Children".to_string(),
+                                    EngineValue::Array(vec![EngineValue::Dict(vec![
+                                        ("ShapeType".to_string(), EngineValue::Int(1)),
+                                        ("Procession".to_string(), EngineValue::Int(procession)),
+                                        (
+                                            "Lines".to_string(),
+                                            EngineValue::Dict(vec![
+                                                (
+                                                    "WritingDirection".to_string(),
+                                                    EngineValue::Int(writing_direction),
+                                                ),
+                                                (
+                                                    "Children".to_string(),
+                                                    EngineValue::Array(Vec::new()),
+                                                ),
+                                            ]),
+                                        ),
+                                        (
+                                            "Cookie".to_string(),
+                                            EngineValue::Dict(vec![(
+                                                "Photoshop".to_string(),
+                                                EngineValue::Dict(vec![
+                                                    ("ShapeType".to_string(), EngineValue::Int(1)),
+                                                    (
+                                                        "BoxBounds".to_string(),
+                                                        EngineValue::Array(vec![
+                                                            EngineValue::Float(0.0),
+                                                            EngineValue::Float(0.0),
+                                                            EngineValue::Float(spec.box_width),
+                                                            EngineValue::Float(spec.box_height),
+                                                        ]),
+                                                    ),
+                                                    (
+                                                        "Base".to_string(),
+                                                        EngineValue::Dict(vec![
+                                                            (
+                                                                "ShapeType".to_string(),
+                                                                EngineValue::Int(1),
+                                                            ),
+                                                            (
+                                                                "TransformPoint0".to_string(),
+                                                                EngineValue::Array(vec![
+                                                                    EngineValue::Float(1.0),
+                                                                    EngineValue::Float(0.0),
+                                                                ]),
+                                                            ),
+                                                            (
+                                                                "TransformPoint1".to_string(),
+                                                                EngineValue::Array(vec![
+                                                                    EngineValue::Float(0.0),
+                                                                    EngineValue::Float(1.0),
+                                                                ]),
+                                                            ),
+                                                            (
+                                                                "TransformPoint2".to_string(),
+                                                                EngineValue::Array(vec![
+                                                                    EngineValue::Float(0.0),
+                                                                    EngineValue::Float(0.0),
+                                                                ]),
+                                                            ),
+                                                        ]),
+                                                    ),
+                                                ]),
+                                            )]),
+                                        ),
+                                    ])]),
+                                ),
+                            ]),
+                        ),
+                    ]),
+                ),
+            ]),
+        ),
+        (
+            "ResourceDict".to_string(),
+            EngineValue::Dict(resource_dict(
+                font_set.clone(),
+                paragraph_properties.clone(),
+                base_style_sheet.clone(),
+            )),
+        ),
+        (
+            "DocumentResources".to_string(),
+            EngineValue::Dict(resource_dict(
+                font_set,
+                paragraph_properties,
+                base_style_sheet,
+            )),
+        ),
+    ]);
+
+    let mut out = Vec::new();
+    out.extend_from_slice(b"\n\n");
+    write_value(&mut out, &root, 0, false, None);
+    out
+}
+
+fn normalize_text(text: &str) -> String {
+    let normalized = text
+        .replace("\r\n", "\n")
+        .replace('\r', "\n")
+        .replace('\n', "\r");
+    format!("{normalized}\r")
+}
+
+fn paragraph_run_lengths(text: &str) -> Vec<i32> {
+    text.split_inclusive('\r')
+        .map(|run| utf16_len(run) as i32)
+        .collect()
+}
+
+fn utf16_len(text: &str) -> usize {
+    text.encode_utf16().count()
+}
+
+fn paragraph_properties(justification: TextJustification) -> Vec<(String, EngineValue)> {
+    vec![
+        (
+            "Justification".to_string(),
+            EngineValue::Int(match justification {
+                TextJustification::Left => 0,
+                TextJustification::Right => 1,
+                TextJustification::Center => 2,
+            }),
+        ),
+        ("FirstLineIndent".to_string(), EngineValue::Float(0.0)),
+        ("StartIndent".to_string(), EngineValue::Float(0.0)),
+        ("EndIndent".to_string(), EngineValue::Float(0.0)),
+        ("SpaceBefore".to_string(), EngineValue::Float(0.0)),
+        ("SpaceAfter".to_string(), EngineValue::Float(0.0)),
+        ("AutoHyphenate".to_string(), EngineValue::Bool(true)),
+        ("HyphenatedWordSize".to_string(), EngineValue::Int(6)),
+        ("PreHyphen".to_string(), EngineValue::Int(2)),
+        ("PostHyphen".to_string(), EngineValue::Int(2)),
+        ("ConsecutiveHyphens".to_string(), EngineValue::Int(8)),
+        ("Zone".to_string(), EngineValue::Float(36.0)),
+        (
+            "WordSpacing".to_string(),
+            EngineValue::Array(vec![
+                EngineValue::Float(0.8),
+                EngineValue::Float(1.0),
+                EngineValue::Float(1.33),
+            ]),
+        ),
+        (
+            "LetterSpacing".to_string(),
+            EngineValue::Array(vec![
+                EngineValue::Float(0.0),
+                EngineValue::Float(0.0),
+                EngineValue::Float(0.0),
+            ]),
+        ),
+        (
+            "GlyphSpacing".to_string(),
+            EngineValue::Array(vec![
+                EngineValue::Float(1.0),
+                EngineValue::Float(1.0),
+                EngineValue::Float(1.0),
+            ]),
+        ),
+        ("AutoLeading".to_string(), EngineValue::Float(1.2)),
+        ("LeadingType".to_string(), EngineValue::Int(0)),
+        ("Hanging".to_string(), EngineValue::Bool(false)),
+        ("Burasagari".to_string(), EngineValue::Bool(false)),
+        ("KinsokuOrder".to_string(), EngineValue::Int(0)),
+        ("EveryLineComposer".to_string(), EngineValue::Bool(false)),
+    ]
+}
+
+fn base_style_sheet(font_index: i32) -> Vec<(String, EngineValue)> {
+    vec![
+        ("Font".to_string(), EngineValue::Int(font_index)),
+        ("FontSize".to_string(), EngineValue::Float(12.0)),
+        ("FauxBold".to_string(), EngineValue::Bool(false)),
+        ("FauxItalic".to_string(), EngineValue::Bool(false)),
+        ("AutoLeading".to_string(), EngineValue::Bool(true)),
+        ("Leading".to_string(), EngineValue::Float(0.0)),
+        ("HorizontalScale".to_string(), EngineValue::Float(1.0)),
+        ("VerticalScale".to_string(), EngineValue::Float(1.0)),
+        ("Tracking".to_string(), EngineValue::Int(0)),
+        ("AutoKerning".to_string(), EngineValue::Bool(true)),
+        ("Kerning".to_string(), EngineValue::Int(0)),
+        ("BaselineShift".to_string(), EngineValue::Float(0.0)),
+        ("FontCaps".to_string(), EngineValue::Int(0)),
+        ("FontBaseline".to_string(), EngineValue::Int(0)),
+        ("Underline".to_string(), EngineValue::Bool(false)),
+        ("Strikethrough".to_string(), EngineValue::Bool(false)),
+        ("Ligatures".to_string(), EngineValue::Bool(true)),
+        ("DLigatures".to_string(), EngineValue::Bool(false)),
+        ("BaselineDirection".to_string(), EngineValue::Int(2)),
+        ("Tsume".to_string(), EngineValue::Float(0.0)),
+        ("StyleRunAlignment".to_string(), EngineValue::Int(2)),
+        ("Language".to_string(), EngineValue::Int(0)),
+        ("NoBreak".to_string(), EngineValue::Bool(false)),
+        (
+            "FillColor".to_string(),
+            EngineValue::Dict(color_type_values([0, 0, 0, 255])),
+        ),
+        (
+            "StrokeColor".to_string(),
+            EngineValue::Dict(color_type_values([0, 0, 0, 255])),
+        ),
+        ("FillFlag".to_string(), EngineValue::Bool(true)),
+        ("StrokeFlag".to_string(), EngineValue::Bool(false)),
+        ("FillFirst".to_string(), EngineValue::Bool(true)),
+        ("YUnderline".to_string(), EngineValue::Int(1)),
+        ("OutlineWidth".to_string(), EngineValue::Float(1.0)),
+        ("CharacterDirection".to_string(), EngineValue::Int(0)),
+        ("HindiNumbers".to_string(), EngineValue::Bool(false)),
+        ("Kashida".to_string(), EngineValue::Int(1)),
+        ("DiacriticPos".to_string(), EngineValue::Int(2)),
+    ]
+}
+
+fn style_run_sheet(spec: &TextEngineSpec, font_index: i32) -> Vec<(String, EngineValue)> {
+    vec![
+        ("Font".to_string(), EngineValue::Int(font_index)),
+        ("FontSize".to_string(), EngineValue::Float(spec.font_size)),
+        ("FauxBold".to_string(), EngineValue::Bool(spec.faux_bold)),
+        (
+            "FauxItalic".to_string(),
+            EngineValue::Bool(spec.faux_italic),
+        ),
+        ("AutoKerning".to_string(), EngineValue::Bool(true)),
+        ("Kerning".to_string(), EngineValue::Int(0)),
+        (
+            "FillColor".to_string(),
+            EngineValue::Dict(color_type_values(spec.color)),
+        ),
+    ]
+}
+
+fn resource_dict(
+    font_set: Vec<EngineValue>,
+    paragraph_properties: Vec<(String, EngineValue)>,
+    style_sheet: Vec<(String, EngineValue)>,
+) -> Vec<(String, EngineValue)> {
+    vec![
+        (
+            "KinsokuSet".to_string(),
+            EngineValue::Array(vec![
+                EngineValue::Dict(vec![
+                    (
+                        "Name".to_string(),
+                        EngineValue::String("PhotoshopKinsokuHard".to_string()),
+                    ),
+                    (
+                        "NoStart".to_string(),
+                        EngineValue::String(
+                            "\u{3001}\u{3002}\u{ff0c}\u{ff0e}\u{30fb}\u{ff1a}\u{ff1b}\u{ff1f}\u{ff01}\u{30fc}\u{2015}\u{2019}\u{201d}\u{ff09}\u{3015}\u{ff3d}\u{ff5d}\u{3009}\u{300b}\u{300d}\u{300f}\u{3011}\u{30fd}\u{30fe}\u{309d}\u{309e}\u{3005}\u{3041}\u{3043}\u{3045}\u{3047}\u{3049}\u{3063}\u{3083}\u{3085}\u{3087}\u{308e}\u{30a1}\u{30a3}\u{30a5}\u{30a7}\u{30a9}\u{30c3}\u{30e3}\u{30e5}\u{30e7}\u{30ee}\u{30f5}\u{30f6}\u{309b}\u{309c}?!)]},.:;\u{2103}\u{2109}\u{00a2}\u{ff05}\u{2030}".to_string(),
+                        ),
+                    ),
+                    (
+                        "NoEnd".to_string(),
+                        EngineValue::String(
+                            "\u{2018}\u{201c}\u{ff08}\u{3014}\u{ff3b}\u{ff5b}\u{3008}\u{300a}\u{300c}\u{300e}\u{3010}([{\u{ffe5}\u{ff04}\u{00a3}\u{ff20}\u{00a7}\u{3012}\u{ff03}".to_string(),
+                        ),
+                    ),
+                    (
+                        "Keep".to_string(),
+                        EngineValue::String("\u{2015}\u{2025}".to_string()),
+                    ),
+                    (
+                        "Hanging".to_string(),
+                        EngineValue::String("\u{3001}\u{3002}.,".to_string()),
+                    ),
+                ]),
+                EngineValue::Dict(vec![
+                    (
+                        "Name".to_string(),
+                        EngineValue::String("PhotoshopKinsokuSoft".to_string()),
+                    ),
+                    (
+                        "NoStart".to_string(),
+                        EngineValue::String(
+                            "\u{3001}\u{3002}\u{ff0c}\u{ff0e}\u{30fb}\u{ff1a}\u{ff1b}\u{ff1f}\u{ff01}\u{2019}\u{201d}\u{ff09}\u{3015}\u{ff3d}\u{ff5d}\u{3009}\u{300b}\u{300d}\u{300f}\u{3011}\u{30fd}\u{30fe}\u{309d}\u{309e}\u{3005}".to_string(),
+                        ),
+                    ),
+                    (
+                        "NoEnd".to_string(),
+                        EngineValue::String(
+                            "\u{2018}\u{201c}\u{ff08}\u{3014}\u{ff3b}\u{ff5b}\u{3008}\u{300a}\u{300c}\u{300e}\u{3010}".to_string(),
+                        ),
+                    ),
+                    (
+                        "Keep".to_string(),
+                        EngineValue::String("\u{2015}\u{2025}".to_string()),
+                    ),
+                    (
+                        "Hanging".to_string(),
+                        EngineValue::String("\u{3001}\u{3002}.,".to_string()),
+                    ),
+                ]),
+            ]),
+        ),
+        (
+            "MojiKumiSet".to_string(),
+            EngineValue::Array(vec![
+                EngineValue::Dict(vec![(
+                    "InternalName".to_string(),
+                    EngineValue::String("Photoshop6MojiKumiSet1".to_string()),
+                )]),
+                EngineValue::Dict(vec![(
+                    "InternalName".to_string(),
+                    EngineValue::String("Photoshop6MojiKumiSet2".to_string()),
+                )]),
+                EngineValue::Dict(vec![(
+                    "InternalName".to_string(),
+                    EngineValue::String("Photoshop6MojiKumiSet3".to_string()),
+                )]),
+                EngineValue::Dict(vec![(
+                    "InternalName".to_string(),
+                    EngineValue::String("Photoshop6MojiKumiSet4".to_string()),
+                )]),
+            ]),
+        ),
+        ("TheNormalStyleSheet".to_string(), EngineValue::Int(0)),
+        ("TheNormalParagraphSheet".to_string(), EngineValue::Int(0)),
+        (
+            "ParagraphSheetSet".to_string(),
+            EngineValue::Array(vec![EngineValue::Dict(vec![
+                (
+                    "Name".to_string(),
+                    EngineValue::String("Normal RGB".to_string()),
+                ),
+                ("DefaultStyleSheet".to_string(), EngineValue::Int(0)),
+                (
+                    "Properties".to_string(),
+                    EngineValue::Dict(paragraph_properties),
+                ),
+            ])]),
+        ),
+        (
+            "StyleSheetSet".to_string(),
+            EngineValue::Array(vec![EngineValue::Dict(vec![
+                (
+                    "Name".to_string(),
+                    EngineValue::String("Normal RGB".to_string()),
+                ),
+                ("StyleSheetData".to_string(), EngineValue::Dict(style_sheet)),
+            ])]),
+        ),
+        ("FontSet".to_string(), EngineValue::Array(font_set)),
+        ("SuperscriptSize".to_string(), EngineValue::Float(0.583)),
+        ("SuperscriptPosition".to_string(), EngineValue::Float(0.333)),
+        ("SubscriptSize".to_string(), EngineValue::Float(0.583)),
+        ("SubscriptPosition".to_string(), EngineValue::Float(0.333)),
+        ("SmallCapSize".to_string(), EngineValue::Float(0.7)),
+    ]
+}
+
+fn font_set(font_name: &str) -> Vec<EngineValue> {
+    let mut fonts = vec![font_descriptor("AdobeInvisFont")];
+    if font_name != "AdobeInvisFont" {
+        fonts.push(font_descriptor(font_name));
+    }
+    fonts
+}
+
+fn font_descriptor(name: &str) -> EngineValue {
+    EngineValue::Dict(vec![
+        ("Name".to_string(), EngineValue::String(name.to_string())),
+        ("Script".to_string(), EngineValue::Int(0)),
+        ("FontType".to_string(), EngineValue::Int(0)),
+        ("Synthetic".to_string(), EngineValue::Int(0)),
+    ])
+}
+
+fn color_type_values(color: [u8; 4]) -> Vec<(String, EngineValue)> {
+    vec![
+        ("Type".to_string(), EngineValue::Int(1)),
+        (
+            "Values".to_string(),
+            EngineValue::Array(vec![
+                EngineValue::Float(color[3] as f64 / 255.0),
+                EngineValue::Float(color[0] as f64 / 255.0),
+                EngineValue::Float(color[1] as f64 / 255.0),
+                EngineValue::Float(color[2] as f64 / 255.0),
+            ]),
+        ),
+    ]
+}
+
+fn write_value(
+    out: &mut Vec<u8>,
+    value: &EngineValue,
+    indent: usize,
+    in_property: bool,
+    key: Option<&str>,
+) {
+    match value {
+        EngineValue::Int(number) => {
+            write_prefix(out, indent, in_property);
+            out.extend_from_slice(number.to_string().as_bytes());
+        }
+        EngineValue::Float(number) => {
+            write_prefix(out, indent, in_property);
+            out.extend_from_slice(serialize_float(*number, key).as_bytes());
+        }
+        EngineValue::Bool(flag) => {
+            write_prefix(out, indent, in_property);
+            out.extend_from_slice(if *flag { b"true" } else { b"false" });
+        }
+        EngineValue::String(text) => {
+            write_prefix(out, indent, in_property);
+            out.push(b'(');
+            out.push(0xFE);
+            out.push(0xFF);
+            for unit in text.encode_utf16() {
+                write_escaped_byte(out, (unit >> 8) as u8);
+                write_escaped_byte(out, unit as u8);
+            }
+            out.push(b')');
+        }
+        EngineValue::Array(items) => {
+            write_prefix(out, indent, in_property);
+            if items.iter().all(is_scalar) {
+                out.extend_from_slice(b"[");
+                for item in items {
+                    out.push(b' ');
+                    write_inline_value(out, item, key);
+                }
+                out.extend_from_slice(b" ]");
+            } else {
+                out.extend_from_slice(b"[\n");
+                for item in items {
+                    write_value(out, item, indent + 1, false, key);
+                    out.push(b'\n');
+                }
+                write_indent(out, indent);
+                out.extend_from_slice(b"]");
+            }
+        }
+        EngineValue::Dict(entries) => {
+            if in_property {
+                out.push(b'\n');
+            } else {
+                write_indent(out, indent);
+            }
+            out.extend_from_slice(b"<<\n");
+            for (entry_key, entry_value) in entries {
+                write_indent(out, indent + 1);
+                out.push(b'/');
+                out.extend_from_slice(entry_key.as_bytes());
+                write_value(out, entry_value, indent + 1, true, Some(entry_key));
+                out.push(b'\n');
+            }
+            write_indent(out, indent);
+            out.extend_from_slice(b">>");
+        }
+    }
+}
+
+fn write_inline_value(out: &mut Vec<u8>, value: &EngineValue, key: Option<&str>) {
+    match value {
+        EngineValue::Int(number) => out.extend_from_slice(number.to_string().as_bytes()),
+        EngineValue::Float(number) => {
+            out.extend_from_slice(serialize_float(*number, key).as_bytes())
+        }
+        EngineValue::Bool(flag) => out.extend_from_slice(if *flag { b"true" } else { b"false" }),
+        _ => write_value(out, value, 0, false, key),
+    }
+}
+
+fn write_prefix(out: &mut Vec<u8>, indent: usize, in_property: bool) {
+    if in_property {
+        out.push(b' ');
+    } else {
+        write_indent(out, indent);
+    }
+}
+
+fn write_indent(out: &mut Vec<u8>, indent: usize) {
+    for _ in 0..indent {
+        out.push(b'\t');
+    }
+}
+
+fn write_escaped_byte(out: &mut Vec<u8>, byte: u8) {
+    if matches!(byte, b'(' | b')' | b'\\') {
+        out.push(b'\\');
+    }
+    out.push(byte);
+}
+
+fn is_scalar(value: &EngineValue) -> bool {
+    matches!(
+        value,
+        EngineValue::Int(_) | EngineValue::Float(_) | EngineValue::Bool(_) | EngineValue::String(_)
+    )
+}
+
+fn serialize_float(value: f64, key: Option<&str>) -> String {
+    let is_float = matches!(
+        key,
+        Some(
+            "Axis"
+                | "XY"
+                | "Zone"
+                | "WordSpacing"
+                | "FirstLineIndent"
+                | "GlyphSpacing"
+                | "StartIndent"
+                | "EndIndent"
+                | "SpaceBefore"
+                | "SpaceAfter"
+                | "LetterSpacing"
+                | "Values"
+                | "GridSize"
+                | "GridLeading"
+                | "PointBase"
+                | "BoxBounds"
+                | "TransformPoint0"
+                | "TransformPoint1"
+                | "TransformPoint2"
+                | "FontSize"
+                | "Leading"
+                | "HorizontalScale"
+                | "VerticalScale"
+                | "BaselineShift"
+                | "Tsume"
+                | "OutlineWidth"
+                | "AutoLeading"
+        )
+    ) || value.fract() != 0.0;
+
+    if !is_float {
+        return (value as i32).to_string();
+    }
+
+    let mut formatted = format!("{value:.5}");
+    if let Some(dot) = formatted.find('.') {
+        while formatted.ends_with('0') && formatted.len() > dot + 2 {
+            formatted.pop();
+        }
+    }
+    if formatted.starts_with("0.")
+        && formatted
+            .as_bytes()
+            .get(2)
+            .is_some_and(|digit| *digit != b'0')
+    {
+        formatted.remove(0);
+    } else if formatted.starts_with("-0.0")
+        && formatted
+            .as_bytes()
+            .get(4)
+            .is_some_and(|digit| digit.is_ascii_digit() && *digit != b'0')
+    {
+        formatted.remove(1);
+    }
+
+    formatted
+}
+
+#[cfg(test)]
+mod tests {
+    use super::{TextEngineSpec, TextJustification, TextOrientation, encode_engine_data};
+
+    #[test]
+    fn engine_data_contains_expected_sections_and_utf16_text() {
+        let bytes = encode_engine_data(&TextEngineSpec {
+            text: "Hello".to_string(),
+            font_name: "ArialMT".to_string(),
+            font_size: 14.0,
+            color: [1, 2, 3, 255],
+            faux_bold: true,
+            faux_italic: false,
+            orientation: TextOrientation::Horizontal,
+            justification: TextJustification::Center,
+            box_width: 100.0,
+            box_height: 32.0,
+        });
+
+        assert!(
+            bytes
+                .windows("/EngineDict".len())
+                .any(|window| window == b"/EngineDict")
+        );
+        assert!(
+            bytes
+                .windows("/FontSet".len())
+                .any(|window| window == b"/FontSet")
+        );
+        assert!(
+            bytes
+                .windows("/RunLengthArray".len())
+                .any(|window| window == b"/RunLengthArray")
+        );
+        assert!(bytes.windows(2).any(|window| window == [0xFE, 0xFF]));
+    }
+
+    #[test]
+    fn engine_data_keeps_float_tokens_for_font_size_and_transforms() {
+        let bytes = encode_engine_data(&TextEngineSpec {
+            text: "Hello".to_string(),
+            font_name: "ArialMT".to_string(),
+            font_size: 14.0,
+            color: [1, 2, 3, 255],
+            faux_bold: true,
+            faux_italic: false,
+            orientation: TextOrientation::Horizontal,
+            justification: TextJustification::Center,
+            box_width: 100.0,
+            box_height: 32.0,
+        });
+
+        assert!(
+            bytes
+                .windows("/FontSize 14.0".len())
+                .any(|w| w == b"/FontSize 14.0")
+        );
+        assert!(
+            bytes
+                .windows("/Axis [ 1.0 0.0 1.0 ]".len())
+                .any(|w| w == b"/Axis [ 1.0 0.0 1.0 ]")
+        );
+    }
+}

koharu-psd/src/error.rs

@@ -0,0 +1,25 @@
+use thiserror::Error;
+
+#[derive(Debug, Error)]
+pub enum PsdExportError {
+    #[error("classic PSD only supports dimensions up to 30000x30000, got {width}x{height}")]
+    UnsupportedDimensions { width: u32, height: u32 },
+    #[error("document is missing base image data")]
+    MissingBaseImage,
+    #[error("invalid layer bounds for {layer}: {width}x{height}")]
+    InvalidLayerBounds {
+        layer: String,
+        width: i32,
+        height: i32,
+    },
+    #[error("RLE row {row} for {layer} exceeded PSD limits ({length} bytes)")]
+    InvalidChannelEncoding {
+        layer: String,
+        row: usize,
+        length: usize,
+    },
+    #[error("invalid descriptor data: {0}")]
+    InvalidDescriptor(String),
+    #[error("I/O error: {0}")]
+    Io(#[from] std::io::Error),
+}

koharu-psd/src/export.rs

@@ -0,0 +1,827 @@
+use std::io::Write;
+
+use image::{DynamicImage, GrayImage, Rgba, RgbaImage, imageops::overlay};
+use koharu_types::{
+    Document, FontPrediction, SerializableDynamicImage, TextAlign, TextBlock, TextDirection,
+};
+
+use crate::{
+    descriptor::{
+        DescriptorObject, DescriptorValue, bounds_descriptor, write_versioned_descriptor,
+    },
+    engine_data::{TextEngineSpec, TextJustification, TextOrientation, encode_engine_data},
+    error::PsdExportError,
+    packbits::{ChannelId, encode_image_rle},
+    writer::PsdWriter,
+};
+
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub enum TextLayerMode {
+    Rasterized,
+    Editable,
+}
+
+#[derive(Debug, Clone)]
+pub struct PsdExportOptions {
+    pub include_original: bool,
+    pub include_inpainted: bool,
+    pub include_segment_mask: bool,
+    pub include_brush_layer: bool,
+    pub text_layer_mode: TextLayerMode,
+}
+
+impl Default for PsdExportOptions {
+    fn default() -> Self {
+        Self {
+            include_original: true,
+            include_inpainted: true,
+            include_segment_mask: true,
+            include_brush_layer: true,
+            text_layer_mode: TextLayerMode::Rasterized,
+        }
+    }
+}
+
+#[derive(Debug, Clone)]
+struct ExportLayer {
+    name: String,
+    left: i32,
+    top: i32,
+    pixels: RgbaImage,
+    hidden: bool,
+    text: Option<TextLayerMetadata>,
+}
+
+#[derive(Debug, Clone)]
+struct TextLayerMetadata {
+    index: i32,
+    text: String,
+    bounds: [f64; 4],
+    transform: [f64; 6],
+    orientation: TextOrientation,
+    justification: TextJustification,
+    font_name: String,
+    font_size: f64,
+    color: [u8; 4],
+    faux_bold: bool,
+    faux_italic: bool,
+    box_width: f64,
+    box_height: f64,
+}
+
+pub fn export_document(
+    document: &Document,
+    options: &PsdExportOptions,
+) -> Result<Vec<u8>, PsdExportError> {
+    let mut bytes = Vec::new();
+    write_document(&mut bytes, document, options)?;
+    Ok(bytes)
+}
+
+pub fn write_document<W: Write>(
+    mut writer: W,
+    document: &Document,
+    options: &PsdExportOptions,
+) -> Result<(), PsdExportError> {
+    let (width, height) = document_dimensions(document)?;
+    let layers_bottom_to_top = collect_layers(document, options)?;
+    let composite = merged_composite(document, &layers_bottom_to_top, width, height);
+    let layers_top_to_bottom: Vec<&ExportLayer> = layers_bottom_to_top.iter().rev().collect();
+
+    let mut psd = PsdWriter::new();
+    write_header(&mut psd, width, height);
+    psd.write_u32(0);
+    psd.write_u32(0);
+
+    let layer_mask_info = build_layer_and_mask_info(&layers_top_to_bottom)?;
+    psd.write_u32(layer_mask_info.len() as u32);
+    psd.write_bytes(&layer_mask_info);
+
+    write_image_data(&mut psd, &composite, "Merged Composite")?;
+
+    writer.write_all(&psd.into_inner())?;
+    Ok(())
+}
+
+fn document_dimensions(document: &Document) -> Result<(u32, u32), PsdExportError> {
+    let width = if document.width > 0 {
+        document.width
+    } else {
+        document.image.width()
+    };
+    let height = if document.height > 0 {
+        document.height
+    } else {
+        document.image.height()
+    };
+
+    if width == 0 || height == 0 {
+        return Err(PsdExportError::MissingBaseImage);
+    }
+
+    if width > 30_000 || height > 30_000 {
+        return Err(PsdExportError::UnsupportedDimensions { width, height });
+    }
+
+    Ok((width, height))
+}
+
+fn write_header(writer: &mut PsdWriter, width: u32, height: u32) {
+    writer.write_signature("8BPS");
+    writer.write_u16(1);
+    writer.write_zeroes(6);
+    writer.write_u16(4);
+    writer.write_u32(height);
+    writer.write_u32(width);
+    writer.write_u16(8);
+    writer.write_u16(3);
+}
+
+fn collect_layers(
+    document: &Document,
+    options: &PsdExportOptions,
+) -> Result<Vec<ExportLayer>, PsdExportError> {
+    let mut layers = Vec::new();
+    let include_inpainted = options.include_inpainted && document.inpainted.is_some();
+
+    if options.include_original {
+        let pixels = dynamic_to_rgba(&document.image);
+        validate_layer_pixels("Original Image", &pixels)?;
+        layers.push(ExportLayer {
+            name: "Original Image".to_string(),
+            left: 0,
+            top: 0,
+            pixels,
+            hidden: include_inpainted,
+            text: None,
+        });
+    }
+
+    if let Some(image) = document
+        .inpainted
+        .as_ref()
+        .filter(|_| options.include_inpainted)
+    {
+        let pixels = dynamic_to_rgba(image);
+        validate_layer_pixels("Inpainted", &pixels)?;
+        layers.push(ExportLayer {
+            name: "Inpainted".to_string(),
+            left: 0,
+            top: 0,
+            pixels,
+            hidden: false,
+            text: None,
+        });
+    }
+
+    if let Some(mask) = document
+        .segment
+        .as_ref()
+        .filter(|_| options.include_segment_mask)
+    {
+        let pixels = grayscale_mask_rgba(mask);
+        validate_layer_pixels("Segmentation Mask", &pixels)?;
+        layers.push(ExportLayer {
+            name: "Segmentation Mask".to_string(),
+            left: 0,
+            top: 0,
+            pixels,
+            hidden: true,
+            text: None,
+        });
+    }
+
+    if let Some(brush) = document
+        .brush_layer
+        .as_ref()
+        .filter(|_| options.include_brush_layer)
+    {
+        let pixels = dynamic_to_rgba(brush);
+        validate_layer_pixels("Brush Layer", &pixels)?;
+        layers.push(ExportLayer {
+            name: "Brush Layer".to_string(),
+            left: 0,
+            top: 0,
+            pixels,
+            hidden: false,
+            text: None,
+        });
+    }
+
+    let mut text_index = 1i32;
+    for block in &document.text_blocks {
+        if let Some(layer) = text_layer(block, text_index, options.text_layer_mode)? {
+            layers.push(layer);
+            text_index += 1;
+        }
+    }
+
+    Ok(layers)
+}
+
+fn text_layer(
+    block: &TextBlock,
+    index: i32,
+    mode: TextLayerMode,
+) -> Result<Option<ExportLayer>, PsdExportError> {
+    let text = block.translation.clone().unwrap_or_default();
+    let trimmed = text.trim();
+    if trimmed.is_empty() {
+        return Ok(None);
+    }
+
+    let left = block.x.trunc() as i32;
+    let top = block.y.trunc() as i32;
+
+    let pixels = if let Some(rendered) = block.rendered.as_ref() {
+        dynamic_to_rgba(rendered)
+    } else {
+        let width = block.width.ceil().max(1.0) as u32;
+        let height = block.height.ceil().max(1.0) as u32;
+        RgbaImage::from_pixel(width, height, Rgba([0, 0, 0, 0]))
+    };
+    validate_layer_pixels(&block.id, &pixels)?;
+
+    let text = match mode {
+        TextLayerMode::Rasterized => None,
+        TextLayerMode::Editable => {
+            let orientation = infer_orientation(block);
+            let justification = infer_justification(block, trimmed, orientation);
+            let font_name = infer_font_name(block);
+            let font_size = infer_font_size(block);
+            let color = infer_color(block);
+            let faux_bold = block
+                .style
+                .as_ref()
+                .and_then(|style| style.effect)
+                .map(|effect| effect.bold)
+                .unwrap_or(false);
+            let faux_italic = block
+                .style
+                .as_ref()
+                .and_then(|style| style.effect)
+                .map(|effect| effect.italic)
+                .unwrap_or(false);
+            let rotation_deg = block
+                .rotation_deg
+                .or_else(|| {
+                    block
+                        .font_prediction
+                        .as_ref()
+                        .map(|prediction| prediction.angle_deg)
+                })
+                .unwrap_or(0.0) as f64;
+            let rotation_rad = rotation_deg.to_radians();
+            let transform = [
+                rotation_rad.cos(),
+                rotation_rad.sin(),
+                -rotation_rad.sin(),
+                rotation_rad.cos(),
+                block.x as f64,
+                block.y as f64,
+            ];
+            let bounds = [
+                block.x as f64,
+                block.y as f64,
+                block.x as f64 + block.width as f64,
+                block.y as f64 + block.height as f64,
+            ];
+
+            Some(TextLayerMetadata {
+                index,
+                text: trimmed.to_string(),
+                bounds,
+                transform,
+                orientation,
+                justification,
+                font_name,
+                font_size,
+                color,
+                faux_bold,
+                faux_italic,
+                box_width: block.width.max(1.0) as f64,
+                box_height: block.height.max(1.0) as f64,
+            })
+        }
+    };
+
+    Ok(Some(ExportLayer {
+        name: format!("TL {index:03} {}", block.id),
+        left,
+        top,
+        pixels,
+        hidden: false,
+        text,
+    }))
+}
+
+fn validate_layer_pixels(layer: &str, pixels: &RgbaImage) -> Result<(), PsdExportError> {
+    let width = pixels.width() as i32;
+    let height = pixels.height() as i32;
+    if width <= 0 || height <= 0 {
+        return Err(PsdExportError::InvalidLayerBounds {
+            layer: layer.to_string(),
+            width,
+            height,
+        });
+    }
+    Ok(())
+}
+
+fn dynamic_to_rgba(image: &SerializableDynamicImage) -> RgbaImage {
+    image.to_rgba8()
+}
+
+fn grayscale_mask_rgba(image: &SerializableDynamicImage) -> RgbaImage {
+    let mask: GrayImage = image.to_luma8();
+    let mut rgba = RgbaImage::new(mask.width(), mask.height());
+    for (x, y, pixel) in mask.enumerate_pixels() {
+        rgba.put_pixel(x, y, Rgba([pixel[0], pixel[0], pixel[0], 255]));
+    }
+    rgba
+}
+
+fn merged_composite(
+    document: &Document,
+    layers_bottom_to_top: &[ExportLayer],
+    width: u32,
+    height: u32,
+) -> RgbaImage {
+    if let Some(rendered) = document.rendered.as_ref() {
+        return place_on_canvas(
+            &DynamicImage::from(rendered.clone()).to_rgba8(),
+            width,
+            height,
+        );
+    }
+
+    let mut canvas = RgbaImage::from_pixel(width, height, Rgba([0, 0, 0, 0]));
+    for layer in layers_bottom_to_top.iter().filter(|layer| !layer.hidden) {
+        overlay(
+            &mut canvas,
+            &layer.pixels,
+            i64::from(layer.left),
+            i64::from(layer.top),
+        );
+    }
+    canvas
+}
+
+fn place_on_canvas(image: &RgbaImage, width: u32, height: u32) -> RgbaImage {
+    if image.width() == width && image.height() == height {
+        return image.clone();
+    }
+
+    let mut canvas = RgbaImage::from_pixel(width, height, Rgba([0, 0, 0, 0]));
+    overlay(&mut canvas, image, 0, 0);
+    canvas
+}
+
+fn build_layer_and_mask_info(layers: &[&ExportLayer]) -> Result<Vec<u8>, PsdExportError> {
+    let mut layer_info = PsdWriter::new();
+    if layers.is_empty() {
+        layer_info.write_i16(0);
+    } else {
+        layer_info.write_i16(-(layers.len() as i16));
+    }
+
+    let mut encoded_layers = Vec::with_capacity(layers.len());
+    let mut extra_data = Vec::with_capacity(layers.len());
+
+    for layer in layers {
+        let channels = encode_image_rle(
+            &layer.pixels,
+            &[
+                ChannelId::Red,
+                ChannelId::Green,
+                ChannelId::Blue,
+                ChannelId::Alpha,
+            ],
+            &layer.name,
+        )?;
+        let extra = build_extra_data(layer)?;
+        encoded_layers.push(channels);
+        extra_data.push(extra);
+    }
+
+    for ((layer, channels), extra) in layers.iter().zip(&encoded_layers).zip(&extra_data) {
+        let width = i32::try_from(layer.pixels.width()).map_err(|_| {
+            PsdExportError::InvalidLayerBounds {
+                layer: layer.name.clone(),
+                width: i32::MAX,
+                height: layer.pixels.height() as i32,
+            }
+        })?;
+        let height = i32::try_from(layer.pixels.height()).map_err(|_| {
+            PsdExportError::InvalidLayerBounds {
+                layer: layer.name.clone(),
+                width,
+                height: i32::MAX,
+            }
+        })?;
+        let right =
+            layer
+                .left
+                .checked_add(width)
+                .ok_or_else(|| PsdExportError::InvalidLayerBounds {
+                    layer: layer.name.clone(),
+                    width,
+                    height,
+                })?;
+        let bottom =
+            layer
+                .top
+                .checked_add(height)
+                .ok_or_else(|| PsdExportError::InvalidLayerBounds {
+                    layer: layer.name.clone(),
+                    width,
+                    height,
+                })?;
+
+        layer_info.write_i32(layer.top);
+        layer_info.write_i32(layer.left);
+        layer_info.write_i32(bottom);
+        layer_info.write_i32(right);
+        layer_info.write_u16(channels.len() as u16);
+
+        for channel in channels {
+            layer_info.write_i16(channel.channel_id);
+            layer_info.write_u32((2 + channel.data.len()) as u32);
+        }
+
+        layer_info.write_signature("8BIM");
+        layer_info.write_signature("norm");
+        layer_info.write_u8(255);
+        layer_info.write_u8(0);
+        layer_info.write_u8(if layer.hidden { 0x0A } else { 0x08 });
+        layer_info.write_u8(0);
+        layer_info.write_u32(extra.len() as u32);
+        layer_info.write_bytes(extra);
+    }
+
+    for channels in &encoded_layers {
+        for channel in channels {
+            layer_info.write_u16(1);
+            layer_info.write_bytes(&channel.data);
+        }
+    }
+    layer_info.pad_to_multiple(4);
+
+    let mut full = PsdWriter::new();
+    full.write_u32(layer_info.len() as u32);
+    full.write_bytes(&layer_info.into_inner());
+    full.write_u32(0);
+    Ok(full.into_inner())
+}
+
+fn build_extra_data(layer: &ExportLayer) -> Result<Vec<u8>, PsdExportError> {
+    let mut extra = PsdWriter::new();
+    extra.write_u32(0);
+    extra.write_u32(0);
+    extra.write_pascal_string(&layer.name, 4);
+
+    if let Some(text) = layer.text.as_ref() {
+        write_additional_info_block(&mut extra, "luni", &luni_body(&layer.name), 4);
+        write_additional_info_block(&mut extra, "TySh", &tysh_body(text)?, 2);
+    }
+
+    Ok(extra.into_inner())
+}
+
+fn luni_body(name: &str) -> Vec<u8> {
+    let mut body = PsdWriter::new();
+    body.write_unicode_string(name);
+    body.into_inner()
+}
+
+fn tysh_body(text: &TextLayerMetadata) -> Result<Vec<u8>, PsdExportError> {
+    let engine_data = encode_engine_data(&TextEngineSpec {
+        text: text.text.clone(),
+        font_name: text.font_name.clone(),
+        font_size: text.font_size,
+        color: text.color,
+        faux_bold: text.faux_bold,
+        faux_italic: text.faux_italic,
+        orientation: text.orientation,
+        justification: text.justification,
+        box_width: text.box_width,
+        box_height: text.box_height,
+    });
+
+    let bounds = bounds_descriptor(
+        "bounds",
+        text.bounds[0],
+        text.bounds[1],
+        text.bounds[2],
+        text.bounds[3],
+    );
+    let bounding_box = bounds_descriptor(
+        "boundingBox",
+        text.bounds[0],
+        text.bounds[1],
+        text.bounds[2],
+        text.bounds[3],
+    );
+
+    let text_descriptor = DescriptorObject::new("", "TxLr")
+        .with_item("Txt ", DescriptorValue::Text(text.text.clone()))
+        .with_item(
+            "textGridding",
+            DescriptorValue::Enum {
+                type_id: "textGridding".to_string(),
+                value: "None".to_string(),
+            },
+        )
+        .with_item(
+            "Ornt",
+            DescriptorValue::Enum {
+                type_id: "Ornt".to_string(),
+                value: match text.orientation {
+                    TextOrientation::Horizontal => "Hrzn".to_string(),
+                    TextOrientation::Vertical => "Vrtc".to_string(),
+                },
+            },
+        )
+        .with_item(
+            "AntA",
+            DescriptorValue::Enum {
+                type_id: "Annt".to_string(),
+                value: "antiAliasSharp".to_string(),
+            },
+        )
+        .with_item("bounds", DescriptorValue::Object(bounds))
+        .with_item("boundingBox", DescriptorValue::Object(bounding_box))
+        .with_item("TextIndex", DescriptorValue::Integer(text.index))
+        .with_item("EngineData", DescriptorValue::Raw(engine_data));
+
+    let warp_descriptor = DescriptorObject::new("", "warp")
+        .with_item(
+            "warpStyle",
+            DescriptorValue::Enum {
+                type_id: "warpStyle".to_string(),
+                value: "warpNone".to_string(),
+            },
+        )
+        .with_item("warpValue", DescriptorValue::Double(0.0))
+        .with_item("warpPerspective", DescriptorValue::Double(0.0))
+        .with_item("warpPerspectiveOther", DescriptorValue::Double(0.0))
+        .with_item(
+            "warpRotate",
+            DescriptorValue::Enum {
+                type_id: "Ornt".to_string(),
+                value: match text.orientation {
+                    TextOrientation::Horizontal => "Hrzn".to_string(),
+                    TextOrientation::Vertical => "Vrtc".to_string(),
+                },
+            },
+        )
+        .with_item(
+            "bounds",
+            DescriptorValue::Object(bounds_descriptor(
+                "bounds",
+                text.bounds[0],
+                text.bounds[1],
+                text.bounds[2],
+                text.bounds[3],
+            )),
+        );
+
+    let mut body = PsdWriter::new();
+    body.write_i16(1);
+    for value in text.transform {
+        body.write_f64(value);
+    }
+    body.write_i16(50);
+    write_versioned_descriptor(&mut body, &text_descriptor)?;
+    body.write_i16(1);
+    write_versioned_descriptor(&mut body, &warp_descriptor)?;
+    for value in text.bounds {
+        body.write_f32(value as f32);
+    }
+    Ok(body.into_inner())
+}
+
+fn write_additional_info_block(writer: &mut PsdWriter, key: &str, body: &[u8], alignment: usize) {
+    let padding = (alignment - (body.len() % alignment)) % alignment;
+
+    writer.write_signature("8BIM");
+    writer.write_signature(key);
+    writer.write_u32((body.len() + padding) as u32);
+    writer.write_bytes(body);
+    writer.write_zeroes(padding);
+}
+
+fn write_image_data(
+    writer: &mut PsdWriter,
+    image: &RgbaImage,
+    name: &str,
+) -> Result<(), PsdExportError> {
+    writer.write_u16(1);
+    let channels = encode_image_rle(
+        image,
+        &[
+            ChannelId::Red,
+            ChannelId::Green,
+            ChannelId::Blue,
+            ChannelId::Alpha,
+        ],
+        name,
+    )?;
+
+    let row_lengths_len = image.height() as usize * 2;
+    for channel in &channels {
+        writer.write_bytes(&channel.data[..row_lengths_len]);
+    }
+    for channel in &channels {
+        writer.write_bytes(&channel.data[row_lengths_len..]);
+    }
+    Ok(())
+}
+
+fn infer_orientation(block: &TextBlock) -> TextOrientation {
+    match block.rendered_direction.or(block.source_direction) {
+        Some(TextDirection::Vertical) => TextOrientation::Vertical,
+        _ => TextOrientation::Horizontal,
+    }
+}
+
+fn infer_justification(
+    block: &TextBlock,
+    text: &str,
+    orientation: TextOrientation,
+) -> TextJustification {
+    if let Some(alignment) = block.style.as_ref().and_then(|style| style.text_align) {
+        return match alignment {
+            TextAlign::Left => TextJustification::Left,
+            TextAlign::Center => TextJustification::Center,
+            TextAlign::Right => TextJustification::Right,
+        };
+    }
+
+    if orientation == TextOrientation::Horizontal && is_probably_latin(text) {
+        TextJustification::Center
+    } else {
+        TextJustification::Left
+    }
+}
+
+fn infer_font_name(block: &TextBlock) -> String {
+    if let Some(style_font) = block.style.as_ref().and_then(|style| {
+        style
+            .font_families
+            .iter()
+            .find(|font| !font.trim().is_empty())
+    }) {
+        return style_font.trim().to_string();
+    }
+
+    if let Some(predicted_font) = block.font_prediction.as_ref().and_then(|prediction| {
+        prediction
+            .named_fonts
+            .iter()
+            .find(|font| !font.name.trim().is_empty())
+    }) {
+        return predicted_font.name.trim().to_string();
+    }
+
+    "ArialMT".to_string()
+}
+
+fn infer_font_size(block: &TextBlock) -> f64 {
+    if let Some(size) = block.style.as_ref().and_then(|style| style.font_size)
+        && size.is_finite() && size > 0.0 {
+            return size as f64;
+        }
+
+    if let Some(prediction) = block.font_prediction.as_ref()
+        && prediction.font_size_px.is_finite() && prediction.font_size_px > 0.0 {
+            return prediction.font_size_px as f64;
+        }
+
+    if let Some(size) = block.detected_font_size_px
+        && size.is_finite() && size > 0.0 {
+            return size as f64;
+        }
+
+    f64::max(6.0, f64::from(block.width.min(block.height)) * 0.7)
+}
+
+fn infer_color(block: &TextBlock) -> [u8; 4] {
+    if let Some(style) = block.style.as_ref() {
+        return style.color;
+    }
+
+    if let Some(FontPrediction { text_color, .. }) = block.font_prediction.as_ref() {
+        return [text_color[0], text_color[1], text_color[2], 255];
+    }
+
+    [0, 0, 0, 255]
+}
+
+fn contains_cjk(text: &str) -> bool {
+    text.chars().any(|ch| {
+        matches!(
+            ch as u32,
+            0x3040..=0x30FF
+                | 0x3400..=0x4DBF
+                | 0x4E00..=0x9FFF
+                | 0xAC00..=0xD7AF
+                | 0xF900..=0xFAFF
+                | 0xFF66..=0xFF9D
+        )
+    })
+}
+
+fn is_probably_latin(text: &str) -> bool {
+    text.chars().any(|ch| ch.is_ascii_alphabetic()) && !contains_cjk(text)
+}
+
+#[cfg(test)]
+mod tests {
+    use image::{Rgba, RgbaImage};
+
+    use crate::writer::PsdWriter;
+
+    use koharu_types::{TextBlock, TextDirection};
+
+    use super::{
+        TextOrientation, contains_cjk, infer_font_name, infer_orientation, is_probably_latin,
+        place_on_canvas, write_image_data,
+    };
+
+    #[test]
+    fn place_on_canvas_keeps_size_stable() {
+        let image = RgbaImage::new(4, 4);
+        let canvas = place_on_canvas(&image, 8, 6);
+        assert_eq!(canvas.width(), 8);
+        assert_eq!(canvas.height(), 6);
+    }
+
+    #[test]
+    fn language_heuristics_detect_cjk_vs_latin() {
+        assert!(contains_cjk("縦書き"));
+        assert!(is_probably_latin("HELLO"));
+        assert!(!is_probably_latin("縦書き"));
+    }
+
+    #[test]
+    fn orientation_uses_rendered_direction_not_geometry() {
+        let tall_english_block = TextBlock {
+            width: 40.0,
+            height: 120.0,
+            translation: Some("HELLO".to_string()),
+            ..Default::default()
+        };
+        assert_eq!(
+            infer_orientation(&tall_english_block),
+            TextOrientation::Horizontal
+        );
+
+        let vertical_block = TextBlock {
+            rendered_direction: Some(TextDirection::Vertical),
+            ..Default::default()
+        };
+        assert_eq!(
+            infer_orientation(&vertical_block),
+            TextOrientation::Vertical
+        );
+    }
+
+    #[test]
+    fn composite_image_data_groups_row_tables_before_channel_payloads() {
+        let mut image = RgbaImage::new(1, 1);
+        image.put_pixel(0, 0, Rgba([1, 2, 3, 4]));
+
+        let mut writer = PsdWriter::new();
+        write_image_data(&mut writer, &image, "Merged Composite").expect("write image data");
+
+        assert_eq!(
+            writer.into_inner(),
+            vec![
+                0, 1, // compression
+                0, 2, 0, 2, 0, 2, 0, 2, // row lengths
+                0, 1, // red
+                0, 2, // green
+                0, 3, // blue
+                0, 4, // alpha
+            ]
+        );
+    }
+
+    #[test]
+    fn style_font_name_is_used_for_editable_export() {
+        let block = TextBlock {
+            style: Some(koharu_types::TextStyle {
+                font_families: vec!["ArialMT".to_string()],
+                font_size: None,
+                color: [0, 0, 0, 255],
+                effect: None,
+                stroke: None,
+                text_align: None,
+            }),
+            ..Default::default()
+        };
+
+        assert_eq!(infer_font_name(&block), "ArialMT");
+    }
+}

koharu-psd/src/lib.rs

@@ -0,0 +1,9 @@
+mod descriptor;
+mod engine_data;
+mod error;
+mod export;
+mod packbits;
+mod writer;
+
+pub use error::PsdExportError;
+pub use export::{PsdExportOptions, TextLayerMode, export_document, write_document};

koharu-psd/src/packbits.rs

@@ -0,0 +1,150 @@
+use image::RgbaImage;
+
+use crate::error::PsdExportError;
+
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub enum ChannelId {
+    Red,
+    Green,
+    Blue,
+    Alpha,
+}
+
+impl ChannelId {
+    pub fn psd_id(self) -> i16 {
+        match self {
+            Self::Red => 0,
+            Self::Green => 1,
+            Self::Blue => 2,
+            Self::Alpha => -1,
+        }
+    }
+
+    fn rgba_offset(self) -> usize {
+        match self {
+            Self::Red => 0,
+            Self::Green => 1,
+            Self::Blue => 2,
+            Self::Alpha => 3,
+        }
+    }
+}
+
+#[derive(Debug, Clone)]
+pub struct EncodedChannel {
+    pub channel_id: i16,
+    pub data: Vec<u8>,
+}
+
+pub fn encode_image_rle(
+    image: &RgbaImage,
+    channels: &[ChannelId],
+    layer_name: &str,
+) -> Result<Vec<EncodedChannel>, PsdExportError> {
+    let mut encoded = Vec::with_capacity(channels.len());
+
+    for channel in channels {
+        let mut lengths = Vec::with_capacity(image.height() as usize);
+        let mut data = Vec::new();
+        let width = image.width() as usize;
+        let offset = channel.rgba_offset();
+
+        for y in 0..image.height() {
+            let start = data.len();
+            let mut row = Vec::with_capacity(width);
+            for x in 0..image.width() {
+                row.push(image.get_pixel(x, y).0[offset]);
+            }
+            encode_row(&row, &mut data);
+            let row_length = data.len() - start;
+            if row_length > u16::MAX as usize {
+                return Err(PsdExportError::InvalidChannelEncoding {
+                    layer: layer_name.to_string(),
+                    row: y as usize,
+                    length: row_length,
+                });
+            }
+            lengths.push(row_length as u16);
+        }
+
+        let mut out = Vec::with_capacity(lengths.len() * 2 + data.len());
+        for length in lengths {
+            out.extend_from_slice(&length.to_be_bytes());
+        }
+        out.extend_from_slice(&data);
+        encoded.push(EncodedChannel {
+            channel_id: channel.psd_id(),
+            data: out,
+        });
+    }
+
+    Ok(encoded)
+}
+
+fn encode_row(row: &[u8], out: &mut Vec<u8>) {
+    let mut i = 0usize;
+    while i < row.len() {
+        let run_len = repeated_run_len(row, i);
+        if run_len >= 3 {
+            let chunk = run_len.min(128);
+            out.push((1i16 - chunk as i16) as u8);
+            out.push(row[i]);
+            i += chunk;
+            continue;
+        }
+
+        let literal_start = i;
+        let mut literal_len = 0usize;
+        while i < row.len() && literal_len < 128 {
+            let next_run = repeated_run_len(row, i);
+            if next_run >= 3 {
+                break;
+            }
+            i += 1;
+            literal_len += 1;
+        }
+
+        out.push((literal_len - 1) as u8);
+        out.extend_from_slice(&row[literal_start..literal_start + literal_len]);
+    }
+}
+
+fn repeated_run_len(row: &[u8], start: usize) -> usize {
+    let value = row[start];
+    let mut len = 1usize;
+    while start + len < row.len() && row[start + len] == value && len < 128 {
+        len += 1;
+    }
+    len
+}
+
+#[cfg(test)]
+mod tests {
+    use image::{Rgba, RgbaImage};
+
+    use super::{ChannelId, encode_image_rle};
+
+    #[test]
+    fn packbits_repeated_rows_encode_with_short_repeat_packets() {
+        let mut image = RgbaImage::new(4, 1);
+        for x in 0..4 {
+            image.put_pixel(x, 0, Rgba([10, 0, 0, 255]));
+        }
+
+        let channels = encode_image_rle(&image, &[ChannelId::Red], "row").expect("encode");
+        assert_eq!(channels.len(), 1);
+        assert_eq!(channels[0].data, vec![0, 2, 253, 10]);
+    }
+
+    #[test]
+    fn packbits_literal_rows_keep_original_order() {
+        let mut image = RgbaImage::new(4, 1);
+        let values = [1u8, 2, 3, 4];
+        for (x, value) in values.into_iter().enumerate() {
+            image.put_pixel(x as u32, 0, Rgba([value, 0, 0, 255]));
+        }
+
+        let channels = encode_image_rle(&image, &[ChannelId::Red], "row").expect("encode");
+        assert_eq!(channels[0].data, vec![0, 5, 3, 1, 2, 3, 4]);
+    }
+}

koharu-psd/src/writer.rs

@@ -0,0 +1,143 @@
+#[derive(Debug, Default, Clone)]
+pub struct PsdWriter {
+    bytes: Vec<u8>,
+}
+
+impl PsdWriter {
+    pub fn new() -> Self {
+        Self::default()
+    }
+
+    pub fn len(&self) -> usize {
+        self.bytes.len()
+    }
+
+    pub fn into_inner(self) -> Vec<u8> {
+        self.bytes
+    }
+
+    pub fn write_bytes(&mut self, bytes: &[u8]) {
+        self.bytes.extend_from_slice(bytes);
+    }
+
+    pub fn write_zeroes(&mut self, count: usize) {
+        self.bytes.resize(self.bytes.len() + count, 0);
+    }
+
+    pub fn write_u8(&mut self, value: u8) {
+        self.bytes.push(value);
+    }
+
+    pub fn write_i16(&mut self, value: i16) {
+        self.write_bytes(&value.to_be_bytes());
+    }
+
+    pub fn write_u16(&mut self, value: u16) {
+        self.write_bytes(&value.to_be_bytes());
+    }
+
+    pub fn write_i32(&mut self, value: i32) {
+        self.write_bytes(&value.to_be_bytes());
+    }
+
+    pub fn write_u32(&mut self, value: u32) {
+        self.write_bytes(&value.to_be_bytes());
+    }
+
+    pub fn write_f32(&mut self, value: f32) {
+        self.write_bytes(&value.to_be_bytes());
+    }
+
+    pub fn write_f64(&mut self, value: f64) {
+        self.write_bytes(&value.to_be_bytes());
+    }
+
+    pub fn write_signature(&mut self, signature: &str) {
+        assert_eq!(signature.len(), 4, "PSD signatures must be 4 bytes");
+        self.write_bytes(signature.as_bytes());
+    }
+
+    pub fn write_ascii_or_class_id(&mut self, value: &str) {
+        let treat_as_class_id =
+            value.len() == 4 && !matches!(value, "warp" | "time" | "hold" | "list");
+        if treat_as_class_id {
+            self.write_i32(0);
+            self.write_signature(value);
+        } else {
+            self.write_i32(value.len() as i32);
+            self.write_bytes(value.as_bytes());
+        }
+    }
+
+    pub fn write_pascal_string(&mut self, text: &str, pad_to: usize) {
+        let ascii = ascii_legacy(text, 255);
+        self.write_u8(ascii.len() as u8);
+        self.write_bytes(ascii.as_bytes());
+
+        let mut total = ascii.len() + 1;
+        while !total.is_multiple_of(pad_to) {
+            self.write_u8(0);
+            total += 1;
+        }
+    }
+
+    pub fn write_unicode_string(&mut self, text: &str) {
+        let utf16: Vec<u16> = text.encode_utf16().collect();
+        self.write_u32(utf16.len() as u32);
+        for unit in utf16 {
+            self.write_u16(unit);
+        }
+    }
+
+    pub fn write_unicode_string_with_padding(&mut self, text: &str) {
+        let utf16: Vec<u16> = text.encode_utf16().collect();
+        self.write_u32((utf16.len() + 1) as u32);
+        for unit in utf16 {
+            self.write_u16(unit);
+        }
+        self.write_u16(0);
+    }
+
+    pub fn pad_to_multiple(&mut self, multiple: usize) {
+        while !self.bytes.len().is_multiple_of(multiple) {
+            self.write_u8(0);
+        }
+    }
+}
+
+pub fn ascii_legacy(text: &str, max_bytes: usize) -> String {
+    let mut out = String::new();
+    for ch in text.chars() {
+        let mapped = if ch.is_ascii() { ch } else { '?' };
+        if out.len() + mapped.len_utf8() > max_bytes {
+            break;
+        }
+        out.push(mapped);
+    }
+    out
+}
+
+#[cfg(test)]
+mod tests {
+    use super::{PsdWriter, ascii_legacy};
+
+    #[test]
+    fn ascii_legacy_replaces_unicode_and_truncates() {
+        assert_eq!(ascii_legacy("hello世界", 8), "hello??");
+        assert_eq!(ascii_legacy("abcdef", 4), "abcd");
+    }
+
+    #[test]
+    fn pascal_string_pads_to_requested_multiple() {
+        let mut writer = PsdWriter::new();
+        writer.write_pascal_string("abc", 4);
+        assert_eq!(writer.into_inner(), vec![3, b'a', b'b', b'c']);
+    }
+
+    #[test]
+    fn unicode_string_with_padding_appends_trailing_nul() {
+        let mut writer = PsdWriter::new();
+        writer.write_unicode_string_with_padding("A");
+        assert_eq!(writer.into_inner(), vec![0, 0, 0, 2, 0, 65, 0, 0]);
+    }
+}

koharu-psd/tests/export.rs

@@ -0,0 +1,214 @@
+use std::path::PathBuf;
+
+use image::{DynamicImage, GrayImage, Rgba, RgbaImage};
+use koharu_psd::{PsdExportError, PsdExportOptions, TextLayerMode, export_document};
+use koharu_types::{
+    Document, FontPrediction, NamedFontPrediction, SerializableDynamicImage, TextAlign, TextBlock,
+    TextDirection, TextShaderEffect, TextStrokeStyle, TextStyle,
+};
+
+fn rgba_image(width: u32, height: u32, color: [u8; 4]) -> SerializableDynamicImage {
+    SerializableDynamicImage(DynamicImage::ImageRgba8(RgbaImage::from_pixel(
+        width,
+        height,
+        Rgba(color),
+    )))
+}
+
+fn gray_image(width: u32, height: u32, value: u8) -> SerializableDynamicImage {
+    SerializableDynamicImage(DynamicImage::ImageLuma8(GrayImage::from_pixel(
+        width,
+        height,
+        image::Luma([value]),
+    )))
+}
+
+fn sample_document() -> Document {
+    Document {
+        id: "doc-1".to_string(),
+        path: PathBuf::from("sample.png"),
+        name: "sample".to_string(),
+        image: rgba_image(16, 12, [240, 240, 240, 255]),
+        width: 16,
+        height: 12,
+        revision: 0,
+        text_blocks: vec![
+            TextBlock {
+                id: "block-h".to_string(),
+                x: 2.0,
+                y: 3.0,
+                width: 8.0,
+                height: 4.0,
+                translation: Some("HELLO".to_string()),
+                style: Some(TextStyle {
+                    font_families: vec!["ArialMT".to_string()],
+                    font_size: Some(14.0),
+                    color: [1, 2, 3, 255],
+                    effect: Some(TextShaderEffect {
+                        italic: false,
+                        bold: true,
+                    }),
+                    stroke: Some(TextStrokeStyle::default()),
+                    text_align: Some(TextAlign::Center),
+                }),
+                rendered: Some(rgba_image(8, 4, [255, 0, 0, 200])),
+                ..Default::default()
+            },
+            TextBlock {
+                id: "block-v".to_string(),
+                x: 10.0,
+                y: 1.0,
+                width: 3.0,
+                height: 8.0,
+                translation: Some("縦書き".to_string()),
+                source_direction: Some(TextDirection::Vertical),
+                font_prediction: Some(FontPrediction {
+                    named_fonts: vec![NamedFontPrediction {
+                        index: 0,
+                        name: "YuGothic-Regular".to_string(),
+                        language: Some("ja".to_string()),
+                        probability: 0.9,
+                        serif: false,
+                    }],
+                    text_color: [20, 40, 60],
+                    font_size_px: 13.0,
+                    angle_deg: 12.0,
+                    ..Default::default()
+                }),
+                ..Default::default()
+            },
+        ],
+        segment: Some(gray_image(16, 12, 96)),
+        inpainted: Some(rgba_image(16, 12, [220, 220, 220, 255])),
+        rendered: Some(rgba_image(16, 12, [200, 210, 220, 255])),
+        brush_layer: Some(rgba_image(16, 12, [0, 255, 0, 100])),
+    }
+}
+
+fn count_occurrences(bytes: &[u8], needle: &[u8]) -> usize {
+    bytes
+        .windows(needle.len())
+        .filter(|window| *window == needle)
+        .count()
+}
+
+fn layer_count(bytes: &[u8]) -> i16 {
+    i16::from_be_bytes([bytes[42], bytes[43]])
+}
+
+#[test]
+fn exports_layered_psd_with_warning_free_raster_text_by_default() {
+    let document = sample_document();
+    let bytes = export_document(&document, &PsdExportOptions::default()).expect("export");
+
+    assert_eq!(&bytes[..4], b"8BPS");
+    assert_eq!(&bytes[12..14], &[0, 4]);
+    assert_eq!(&bytes[14..18], &[0, 0, 0, 12]);
+    assert_eq!(&bytes[18..22], &[0, 0, 0, 16]);
+    assert_eq!(&bytes[22..24], &[0, 8]);
+    assert_eq!(&bytes[24..26], &[0, 3]);
+    assert_eq!(layer_count(&bytes), -6);
+    assert_eq!(count_occurrences(&bytes, b"luni"), 0);
+    assert_eq!(count_occurrences(&bytes, b"TySh"), 0);
+    assert!(
+        bytes
+            .windows("TL 001 block-h".len())
+            .any(|window| window == b"TL 001 block-h")
+    );
+    assert!(
+        bytes
+            .windows("TL 002 block-v".len())
+            .any(|window| window == b"TL 002 block-v")
+    );
+}
+
+#[test]
+fn editable_text_layers_are_opt_in() {
+    let document = sample_document();
+    let options = PsdExportOptions {
+        text_layer_mode: TextLayerMode::Editable,
+        ..Default::default()
+    };
+
+    let bytes = export_document(&document, &options).expect("export");
+    assert_eq!(count_occurrences(&bytes, b"luni"), 2);
+    assert_eq!(count_occurrences(&bytes, b"TySh"), 2);
+}
+
+#[test]
+fn parse_smoke_test_uses_reader_crate_for_basic_validation() {
+    let document = sample_document();
+    let bytes = export_document(&document, &PsdExportOptions::default()).expect("export");
+
+    let parsed = psd::Psd::from_bytes(&bytes).expect("parse");
+    assert_eq!(parsed.width(), 16);
+    assert_eq!(parsed.height(), 12);
+}
+
+#[test]
+fn empty_translations_are_skipped() {
+    let mut document = sample_document();
+    document.text_blocks.push(TextBlock {
+        id: "block-empty".to_string(),
+        x: 0.0,
+        y: 0.0,
+        width: 4.0,
+        height: 4.0,
+        translation: Some("   ".to_string()),
+        ..Default::default()
+    });
+
+    let bytes = export_document(&document, &PsdExportOptions::default()).expect("export");
+    assert_eq!(layer_count(&bytes), -6);
+    assert_eq!(count_occurrences(&bytes, b"TySh"), 0);
+    assert!(
+        !bytes
+            .windows("TL 003 block-empty".len())
+            .any(|window| window == b"TL 003 block-empty")
+    );
+}
+
+#[test]
+fn dimensions_above_classic_psd_limit_fail() {
+    let mut document = sample_document();
+    document.width = 30_001;
+
+    let error = export_document(&document, &PsdExportOptions::default()).expect_err("too large");
+    assert!(matches!(
+        error,
+        PsdExportError::UnsupportedDimensions {
+            width: 30_001,
+            height: 12
+        }
+    ));
+}
+
+#[test]
+fn missing_rendered_text_bitmap_still_exports_editable_layer() {
+    let mut document = sample_document();
+    document.text_blocks[0].rendered = None;
+    let options = PsdExportOptions {
+        text_layer_mode: TextLayerMode::Editable,
+        ..Default::default()
+    };
+
+    let bytes = export_document(&document, &options).expect("export");
+    assert_eq!(count_occurrences(&bytes, b"TySh"), 2);
+}
+
+#[test]
+fn optional_helper_layers_can_be_disabled() {
+    let document = sample_document();
+    let options = PsdExportOptions {
+        include_original: false,
+        include_inpainted: false,
+        include_segment_mask: false,
+        include_brush_layer: false,
+        text_layer_mode: TextLayerMode::Rasterized,
+    };
+
+    let bytes = export_document(&document, &options).expect("export");
+    assert_eq!(layer_count(&bytes), -2);
+    assert_eq!(count_occurrences(&bytes, b"luni"), 0);
+    assert_eq!(count_occurrences(&bytes, b"TySh"), 0);
+}

koharu-renderer/Cargo.toml

@@ -21,7 +21,7 @@ serde = { workspace = true }
 skrifa = { workspace = true }
 harfrust = { workspace = true }
 icu = { workspace = true }
-fontique = { workspace = true }
+fontdb = { workspace = true }
 fontdue = { workspace = true }
 tiny-skia = { workspace = true }
 tracing = { workspace = true }

koharu-renderer/benches/rendering.rs

@@ -4,7 +4,7 @@ use std::hint::black_box;
 
 use criterion::{Criterion, criterion_group, criterion_main};
 use koharu_renderer::{
-    font::{FamilyName, FontBook, Properties},
+    font::FontBook,
     layout::{TextLayout, WritingMode},
     renderer::{RenderOptions, TinySkiaRenderer},
 };
@@ -15,8 +15,14 @@ const SAMPLE_TEXT: &str = "The quick brown fox jumps over the lazy dog.";
 fn rendering_benchmark(c: &mut Criterion) {
     let mut fontbook = FontBook::new();
     let renderer = TinySkiaRenderer::new().expect("Failed to create renderer");
+    let post_script_name = fontbook
+        .all_families()
+        .into_iter()
+        .find(|face| !face.post_script_name.is_empty())
+        .map(|face| face.post_script_name)
+        .expect("Failed to find font");
     let font = fontbook
-        .query(&[FamilyName::SansSerif], &Properties::default())
+        .query(&post_script_name)
         .expect("Failed to find font");
     let _ = font.fontdue().expect("Failed to load font");
     let layout = TextLayout::new(&font, Some(FONT_SIZE))

koharu-renderer/src/facade.rs

@@ -5,12 +5,12 @@ use image::{DynamicImage, GrayImage, imageops};
 use rayon::iter::{IntoParallelRefMutIterator, ParallelIterator};
 
 use koharu_types::{
-    Document, SerializableDynamicImage, TextAlign, TextBlock, TextShaderEffect, TextStrokeStyle,
-    TextStyle,
+    Document, FontFaceInfo, SerializableDynamicImage, TextAlign, TextBlock, TextShaderEffect,
+    TextStrokeStyle, TextStyle,
 };
 
 use crate::{
-    font::{FamilyName, Font, FontBook, Properties},
+    font::{FaceInfo, Font, FontBook},
     layout::{LayoutRun, TextLayout, WritingMode},
     renderer::{RenderOptions, RenderStrokeOptions, TinySkiaRenderer},
     text::{
@@ -43,14 +43,26 @@ impl Renderer {
         })
     }
 
-    pub fn available_fonts(&self) -> Result<Vec<String>> {
-        let mut fontbook = self
+    pub fn available_fonts(&self) -> Result<Vec<FontFaceInfo>> {
+        let fontbook = self
             .fontbook
             .lock()
             .map_err(|_| anyhow::anyhow!("Failed to lock fontbook"))?;
-        let mut families = fontbook.all_families();
-        families.sort();
-        Ok(families)
+        let mut fonts = fontbook
+            .all_families()
+            .into_iter()
+            .filter(|face| !face.post_script_name.is_empty())
+            .map(|face| FontFaceInfo {
+                family_name: face
+                    .families
+                    .first()
+                    .map(|(family, _)| family.clone())
+                    .unwrap_or_else(|| face.post_script_name.clone()),
+                post_script_name: face.post_script_name,
+            })
+            .collect::<Vec<_>>();
+        fonts.sort();
+        Ok(fonts)
     }
 
     pub fn render(
@@ -134,6 +146,8 @@ impl Renderer {
             width: seed_width,
             height: seed_height,
             translation: Some(translation.clone()),
+            source_direction: text_block.source_direction,
+            rendered_direction: text_block.rendered_direction,
             ..Default::default()
         };
 
@@ -264,7 +278,20 @@ impl Renderer {
         text_block.y = layout_box.y;
         text_block.width = layout_box.width;
         text_block.height = layout_box.height;
+        text_block.rendered_direction = Some(match writing_mode {
+            WritingMode::Horizontal => koharu_types::TextDirection::Horizontal,
+            WritingMode::VerticalRl => koharu_types::TextDirection::Vertical,
+        });
         text_block.rendered = Some(SerializableDynamicImage(DynamicImage::ImageRgba8(rendered)));
+        let persisted_style = text_block.style.get_or_insert_with(|| TextStyle {
+            font_families: Vec::new(),
+            font_size: None,
+            color,
+            effect: None,
+            stroke: None,
+            text_align: None,
+        });
+        persisted_style.font_families = vec![font.post_script_name().to_string()];
         Ok(())
     }
 
@@ -273,16 +300,15 @@ impl Renderer {
             .fontbook
             .lock()
             .map_err(|_| anyhow::anyhow!("Failed to lock fontbook"))?;
-        let font = fontbook.query(
-            style
-                .font_families
-                .iter()
-                .map(|family| FamilyName::Title(family.to_string()))
-                .collect::<Vec<_>>()
-                .as_slice(),
-            &Properties::default(),
-        )?;
-        Ok(font)
+        let faces = fontbook.all_families();
+        let post_script_name = style
+            .font_families
+            .iter()
+            .find_map(|candidate| face_post_script_name(&faces, candidate))
+            .ok_or_else(|| {
+                anyhow::anyhow!("no font found for candidates: {:?}", style.font_families)
+            })?;
+        fontbook.query(&post_script_name)
     }
 }
 
@@ -439,7 +465,6 @@ fn center_layout_vertically(layout: &mut LayoutRun<'_>, container_height: f32) {
 }
 
 fn load_symbol_fallbacks(fontbook: &mut FontBook) -> Vec<Font> {
-    let props = Properties::default();
     let candidates = [
         "Segoe UI Symbol",
         "Segoe UI Emoji",
@@ -451,13 +476,26 @@ fn load_symbol_fallbacks(fontbook: &mut FontBook) -> Vec<Font> {
         "Symbola",
         "Arial Unicode MS",
     ];
-    let mut fonts = Vec::new();
-    for name in candidates {
-        if let Ok(font) = fontbook.query(&[FamilyName::Title(name.to_string())], &props) {
-            fonts.push(font);
-        }
-    }
-    fonts
+    let faces = fontbook.all_families();
+    candidates
+        .iter()
+        .filter_map(|candidate| face_post_script_name(&faces, candidate))
+        .filter_map(|post_script_name| fontbook.query(&post_script_name).ok())
+        .collect()
+}
+
+fn face_post_script_name(faces: &[FaceInfo], candidate: &str) -> Option<String> {
+    faces
+        .iter()
+        .find(|face| {
+            face.post_script_name == candidate
+                || face
+                    .families
+                    .iter()
+                    .any(|(family, _)| family.as_str() == candidate)
+        })
+        .map(|face| face.post_script_name.clone())
+        .filter(|post_script_name| !post_script_name.is_empty())
 }
 
 #[cfg(test)]

koharu-renderer/src/font.rs

@@ -1,100 +1,38 @@
 use std::{collections::HashMap, sync::Arc};
 
 use anyhow::Context;
-use fontique::{
-    Attributes, Blob, Collection, CollectionOptions, FamilyId, FontStyle as Style,
-    FontWeight as Weight, FontWidth as Stretch, GenericFamily, QueryFamily, QueryStatus,
-    SourceCache, SourceCacheOptions,
-};
+pub use fontdb::FaceInfo;
+use fontdb::{Database, ID};
 use once_cell::sync::OnceCell;
 
-/// Font family names for font lookup.
-#[derive(Debug, Clone, PartialEq, Eq, Hash)]
-pub enum FamilyName {
-    /// A named font family.
-    Title(String),
-    /// Generic serif family.
-    Serif,
-    /// Generic sans-serif family.
-    SansSerif,
-    /// Generic cursive family.
-    Cursive,
-    /// Generic fantasy family.
-    Fantasy,
-    /// Generic monospace family.
-    Monospace,
-}
-
-impl FamilyName {
-    fn to_query_family(&self) -> QueryFamily<'_> {
-        match self {
-            FamilyName::Title(name) => QueryFamily::Named(name.as_str()),
-            FamilyName::Serif => QueryFamily::Generic(GenericFamily::Serif),
-            FamilyName::SansSerif => QueryFamily::Generic(GenericFamily::SansSerif),
-            FamilyName::Cursive => QueryFamily::Generic(GenericFamily::Cursive),
-            FamilyName::Fantasy => QueryFamily::Generic(GenericFamily::Fantasy),
-            FamilyName::Monospace => QueryFamily::Generic(GenericFamily::Monospace),
-        }
-    }
-}
-
-/// Font properties used to match against the font database.
-#[derive(Debug, Clone)]
-pub struct Properties {
-    pub weight: Weight,
-    pub stretch: Stretch,
-    pub style: Style,
-}
-
-impl Default for Properties {
-    fn default() -> Self {
-        Self {
-            weight: Weight::NORMAL,
-            stretch: Stretch::NORMAL,
-            style: Style::Normal,
-        }
-    }
-}
-
-impl Properties {
-    fn to_attributes(&self) -> Attributes {
-        Attributes::new(self.stretch, self.style, self.weight)
-    }
-}
-
 /// A loaded font ready for shaping and rendering.
-///
-/// The font data is reference-counted for cheap cloning.
 #[derive(Clone, Debug)]
 pub struct Font {
-    /// Font data stored in a shared blob for cheap cloning.
-    blob: Blob<u8>,
-    /// Index within font collection (0 for single-font files)
-    index: u32,
-    /// Cached fontdue font to avoid re-parsing font data on every render.
+    data: Arc<[u8]>,
+    face: FaceInfo,
     fontdue: Arc<OnceCell<Arc<fontdue::Font>>>,
 }
 
 impl Font {
     /// Creates a skrifa FontRef for metric queries.
     pub fn skrifa(&self) -> anyhow::Result<skrifa::FontRef<'_>> {
-        skrifa::FontRef::from_index(self.blob.as_ref(), self.index)
+        skrifa::FontRef::from_index(self.data.as_ref(), self.face.index)
             .context("failed to create skrifa FontRef")
     }
 
     /// Creates a harfrust FontRef for text shaping.
     pub fn harfrust(&self) -> anyhow::Result<harfrust::FontRef<'_>> {
-        harfrust::FontRef::from_index(self.blob.as_ref(), self.index)
+        harfrust::FontRef::from_index(self.data.as_ref(), self.face.index)
             .context("failed to create harfrust FontRef")
     }
 
     pub fn fontdue(&self) -> anyhow::Result<Arc<fontdue::Font>> {
         let font = self.fontdue.get_or_try_init(|| {
             let settings = fontdue::FontSettings {
-                collection_index: self.index,
+                collection_index: self.face.index,
                 ..Default::default()
             };
-            let font = fontdue::Font::from_bytes(self.blob.as_ref(), settings)
+            let font = fontdue::Font::from_bytes(self.data.as_ref(), settings)
                 .map_err(|err| anyhow::anyhow!(err))
                 .context("failed to create fontdue Font")?;
             Ok::<_, anyhow::Error>(Arc::new(font))
@@ -108,6 +46,14 @@ impl Font {
             .map(|font| font.has_glyph(character))
             .unwrap_or(false)
     }
+
+    pub fn post_script_name(&self) -> &str {
+        &self.face.post_script_name
+    }
+
+    pub fn face_info(&self) -> &FaceInfo {
+        &self.face
+    }
 }
 
 pub(crate) fn font_key(font: &Font) -> usize {
@@ -141,83 +87,64 @@ pub(crate) fn select_font(cluster: &str, fonts: &[&Font]) -> usize {
     0
 }
 
-#[derive(Clone, Debug, PartialEq, Eq, Hash)]
-struct CacheKey {
-    family_id: FamilyId,
-    family_index: usize,
-    index: u32,
-}
-
 /// A collection of font sources for font discovery and loading.
-///
-/// Combines system fonts with optional custom font directories.
 pub struct FontBook {
-    collection: Collection,
-    source_cache: SourceCache,
-    cache: HashMap<CacheKey, Font>,
+    database: Database,
+    cache: HashMap<ID, Font>,
 }
 
 impl FontBook {
-    /// Creates a FontBook with only system fonts.
+    /// Creates a FontBook with system fonts.
     pub fn new() -> Self {
-        let collection = Collection::new(CollectionOptions {
-            shared: false,
-            system_fonts: true,
-        });
-        let source_cache = SourceCache::new(SourceCacheOptions { shared: true });
+        let mut database = Database::new();
+        database.load_system_fonts();
+
         Self {
-            collection,
-            source_cache,
+            database,
             cache: HashMap::new(),
         }
     }
 
-    /// Returns all available font family names.
-    pub fn all_families(&mut self) -> Vec<String> {
-        self.collection
-            .family_names()
-            .map(|name| name.to_string())
-            .collect()
+    /// Returns all available font faces.
+    pub fn all_families(&self) -> Vec<FaceInfo> {
+        self.database.faces().cloned().collect()
     }
 
-    /// Queries for a font by family names (with fallbacks) and properties.
-    ///
-    /// The first matching font from the family list will be returned.
-    pub fn query(
-        &mut self,
-        families: &[FamilyName],
-        properties: &Properties,
-    ) -> anyhow::Result<Font> {
-        let mut query = self.collection.query(&mut self.source_cache);
-        query.set_families(families.iter().map(|name| name.to_query_family()));
-        query.set_attributes(properties.to_attributes());
-
-        let mut selected = None;
-        query.matches_with(|font| {
-            // Clone the necessary fields from font to avoid borrow issues
-            selected = Some((font.family.0, font.family.1, font.index, font.blob.clone()));
-            QueryStatus::Stop
-        });
-
-        let (family_id, family_index, index, blob) =
-            selected.with_context(|| format!("no font found for families: {families:?}"))?;
-
-        let cache_key = CacheKey {
-            family_id,
-            family_index,
-            index,
+    /// Loads a font by PostScript name.
+    pub fn query(&mut self, post_script_name: &str) -> anyhow::Result<Font> {
+        let Some(id) = self
+            .database
+            .faces()
+            .find_map(|face| (face.post_script_name == post_script_name).then_some(face.id))
+        else {
+            return Err(anyhow::anyhow!(
+                "no font found for PostScript name: {post_script_name}"
+            ));
         };
-        if let Some(font) = self.cache.get(&cache_key) {
+        self.load_font(id)
+    }
+
+    fn load_font(&mut self, id: ID) -> anyhow::Result<Font> {
+        if let Some(font) = self.cache.get(&id) {
             return Ok(font.clone());
         }
 
+        let face = self
+            .database
+            .face(id)
+            .cloned()
+            .with_context(|| format!("missing font face for id {:?}", id))?;
+        let data = self
+            .database
+            .with_face_data(id, |data, _| Arc::<[u8]>::from(data.to_vec()))
+            .with_context(|| format!("failed to load font data for {:?}", id))?;
+
         let font = Font {
-            blob,
-            index,
+            data,
+            face,
             fontdue: Arc::new(OnceCell::new()),
         };
-
-        self.cache.insert(cache_key, font.clone());
+        self.cache.insert(id, font.clone());
         Ok(font)
     }
 }

koharu-renderer/src/layout.rs

@@ -526,7 +526,7 @@ fn is_fullwidth_punctuation(ch: char) -> bool {
 #[cfg(test)]
 mod tests {
     use super::*;
-    use crate::font::{FamilyName, Font, FontBook, Properties};
+    use crate::font::{Font, FontBook};
     use skrifa::{
         MetadataProvider,
         instance::{LocationRef, Size},
@@ -534,7 +534,6 @@ mod tests {
 
     fn any_system_font() -> Font {
         let mut book = FontBook::new();
-        let props = Properties::default();
 
         // Prefer fonts that are commonly available depending on OS/environment.
         // This is only used to construct a `TextLayout` for calling `compute_bounds`.
@@ -549,11 +548,34 @@ mod tests {
         ];
 
         for name in preferred {
-            if let Ok(font) = book.query(&[FamilyName::Title(name.to_string())], &props) {
+            if let Some(post_script_name) = book
+                .all_families()
+                .into_iter()
+                .find(|face| {
+                    face.post_script_name == name
+                        || face
+                            .families
+                            .iter()
+                            .any(|(family, _)| family.as_str() == name)
+                })
+                .map(|face| face.post_script_name)
+                .filter(|post_script_name| !post_script_name.is_empty())
+                && let Ok(font) = book.query(&post_script_name)
+            {
                 return font;
             }
         }
 
+        if let Some(face) = book
+            .all_families()
+            .into_iter()
+            .find(|face| !face.post_script_name.is_empty())
+        {
+            return book
+                .query(&face.post_script_name)
+                .expect("failed to load first system font");
+        }
+
         panic!("no system font available for tests");
     }
 

koharu-renderer/src/shape.rs

@@ -182,7 +182,7 @@ pub(crate) fn shape_segment_with_fallbacks<'a>(
 #[cfg(test)]
 mod tests {
     use super::*;
-    use crate::font::{FamilyName, FontBook, Properties};
+    use crate::font::FontBook;
 
     const PRIMARY_FAMILIES: &[&str] = &[
         "Arial",
@@ -218,11 +218,19 @@ mod tests {
     ];
 
     fn query_font(book: &mut FontBook, name: &str) -> Option<Font> {
-        book.query(
-            &[FamilyName::Title(name.to_string())],
-            &Properties::default(),
-        )
-        .ok()
+        let post_script_name = book
+            .all_families()
+            .into_iter()
+            .find(|face| {
+                face.post_script_name == name
+                    || face
+                        .families
+                        .iter()
+                        .any(|(family, _)| family.as_str() == name)
+            })
+            .map(|face| face.post_script_name)
+            .filter(|post_script_name| !post_script_name.is_empty())?;
+        book.query(&post_script_name).ok()
     }
 
     #[test]

koharu-renderer/src/text/script.rs

@@ -126,7 +126,14 @@ fn is_cjk_text(text: &str) -> bool {
 
 #[cfg(test)]
 mod tests {
-    use super::{font_families_for_text, is_latin_only, normalize_translation_for_layout};
+    use koharu_types::{TextBlock, TextDirection};
+
+    use crate::layout::WritingMode;
+
+    use super::{
+        font_families_for_text, is_latin_only, normalize_translation_for_layout,
+        writing_mode_for_block,
+    };
 
     #[test]
     fn latin_detection_is_reasonable() {
@@ -145,4 +152,30 @@ mod tests {
         assert!(!font_families_for_text("hello").is_empty());
         assert!(!font_families_for_text("你好").is_empty());
     }
+
+    #[test]
+    fn writing_mode_uses_cjk_tall_box_heuristic() {
+        let block = TextBlock {
+            width: 40.0,
+            height: 120.0,
+            translation: Some("縦書き".to_string()),
+            ..Default::default()
+        };
+
+        assert_eq!(writing_mode_for_block(&block), WritingMode::VerticalRl);
+    }
+
+    #[test]
+    fn writing_mode_ignores_stale_rendered_direction() {
+        let block = TextBlock {
+            width: 40.0,
+            height: 120.0,
+            translation: Some("HELLO".to_string()),
+            source_direction: Some(TextDirection::Horizontal),
+            rendered_direction: Some(TextDirection::Vertical),
+            ..Default::default()
+        };
+
+        assert_eq!(writing_mode_for_block(&block), WritingMode::Horizontal);
+    }
 }

koharu-renderer/tests/rendering.rs

@@ -2,7 +2,7 @@ use std::path::PathBuf;
 
 use anyhow::Result;
 use koharu_renderer::{
-    font::{FamilyName, Font, FontBook, Properties},
+    font::{Font, FontBook},
     layout::{TextLayout, WritingMode},
     renderer::{RenderOptions, TinySkiaRenderer},
 };
@@ -21,10 +21,20 @@ fn output_dir() -> PathBuf {
 
 fn font(family_name: &str) -> Result<Font> {
     let mut book = FontBook::new();
-    let font = book.query(
-        &[FamilyName::Title(family_name.to_string())],
-        &Properties::default(),
-    )?;
+    let post_script_name = book
+        .all_families()
+        .into_iter()
+        .find(|face| {
+            face.post_script_name == family_name
+                || face
+                    .families
+                    .iter()
+                    .any(|(family, _)| family.as_str() == family_name)
+        })
+        .map(|face| face.post_script_name)
+        .filter(|post_script_name| !post_script_name.is_empty())
+        .ok_or_else(|| anyhow::anyhow!("font not found: {family_name}"))?;
+    let font = book.query(&post_script_name)?;
     // preload fontdue font
     let _ = font.fontdue()?;
 

koharu-rpc/Cargo.toml

@@ -13,6 +13,7 @@ publish.workspace = true
 
 [dependencies]
 koharu-http = { workspace = true }
+koharu-psd = { workspace = true }
 koharu-pipeline = { workspace = true }
 koharu-types = { workspace = true }
 anyhow = { workspace = true }

koharu-rpc/src/api.rs

@@ -21,13 +21,15 @@ use koharu_pipeline::{
     AppResources, operations,
     state_tx::{self, ChangedField},
 };
+use koharu_psd::{PsdExportOptions, TextLayerMode};
 use koharu_types::{
     ApiKeyGetPayload, ApiKeyResponse, ApiKeySetPayload, ApiKeyValue, CreateTextBlock, Document,
-    DocumentDetail, DocumentSummary, ExportLayer, ExportResult, FileEntry, IndexPayload,
-    InpaintPartialPayload, InpaintRegion, JobState, JobStatus, LlmLoadPayload, LlmLoadRequest,
-    LlmModelInfo, MaskRegionRequest, MetaInfo, OpenDocumentsPayload, PipelineJobRequest, Region,
-    RenderPayload, RenderRequest, SerializableDynamicImage, TextBlock, TextBlockDetail,
-    TextBlockPatch, TranslateRequest, UpdateBrushLayerPayload, UpdateInpaintMaskPayload,
+    DocumentDetail, DocumentSummary, ExportLayer, ExportResult, FileEntry, FontFaceInfo,
+    IndexPayload, InpaintPartialPayload, InpaintRegion, JobState, JobStatus, LlmLoadPayload,
+    LlmLoadRequest, LlmModelInfo, MaskRegionRequest, MetaInfo, OpenDocumentsPayload,
+    PipelineJobRequest, Region, RenderPayload, RenderRequest, SerializableDynamicImage, TextBlock,
+    TextBlockDetail, TextBlockPatch, TranslateRequest, UpdateBrushLayerPayload,
+    UpdateInpaintMaskPayload,
 };
 use serde::Deserialize;
 
@@ -93,6 +95,10 @@ pub fn router(resources: SharedResources, events: EventHub) -> Router {
             patch(patch_text_block).delete(delete_text_block),
         )
         .route("/documents/{document_id}/export", get(export_document))
+        .route(
+            "/documents/{document_id}/export/psd",
+            get(export_document_psd),
+        )
         .route("/llm/models", get(list_llm_models))
         .route("/llm/state", get(get_llm_state))
         .route("/llm/load", post(load_llm))
@@ -187,7 +193,7 @@ async fn get_meta(State(state): State<ApiState>) -> ApiResult<Json<MetaInfo>> {
     }))
 }
 
-async fn get_fonts(State(state): State<ApiState>) -> ApiResult<Json<Vec<String>>> {
+async fn get_fonts(State(state): State<ApiState>) -> ApiResult<Json<Vec<FontFaceInfo>>> {
     let resources = state.resources()?;
     let fonts = operations::list_font_families(resources)
         .await
@@ -684,6 +690,21 @@ async fn export_document(
     Ok(binary_response(data, content_type, Some(filename)))
 }
 
+async fn export_document_psd(
+    State(state): State<ApiState>,
+    Path(document_id): Path<String>,
+) -> ApiResult<Response> {
+    let resources = state.resources()?;
+    let (_, document) = find_document(&resources, &document_id).await?;
+    let data = koharu_psd::export_document(&document, &app_psd_export_options())
+        .map_err(|error| ApiError::bad_request(error.to_string()))?;
+    Ok(binary_response(
+        data,
+        "image/vnd.adobe.photoshop",
+        Some(psd_export_filename(&document)),
+    ))
+}
+
 async fn export_all(
     State(state): State<ApiState>,
     Query(query): Query<LayerQuery>,
@@ -852,6 +873,17 @@ fn export_target(
     }
 }
 
+fn psd_export_filename(document: &Document) -> String {
+    format!("{}_koharu.psd", document.name)
+}
+
+fn app_psd_export_options() -> PsdExportOptions {
+    PsdExportOptions {
+        text_layer_mode: TextLayerMode::Editable,
+        ..PsdExportOptions::default()
+    }
+}
+
 fn to_inpaint_region(region: Region) -> InpaintRegion {
     InpaintRegion {
         x: region.x,
@@ -918,19 +950,22 @@ fn apply_text_block_patch(block: &mut TextBlock, patch: TextBlockPatch) {
     }
     if invalidate_render {
         block.rendered = None;
+        block.rendered_direction = None;
     }
 }
 
 #[cfg(test)]
 mod tests {
-    use super::apply_text_block_patch;
-    use koharu_types::{TextAlign, TextBlock, TextBlockPatch, TextStyle};
+    use super::{app_psd_export_options, apply_text_block_patch, psd_export_filename};
+    use koharu_psd::TextLayerMode;
+    use koharu_types::{Document, TextAlign, TextBlock, TextBlockPatch, TextDirection, TextStyle};
 
     #[test]
     fn text_block_patch_updates_geometry_and_clears_rendered() {
         let mut block = TextBlock {
             width: 100.0,
             height: 50.0,
+            rendered_direction: Some(TextDirection::Vertical),
             rendered: Some(image::DynamicImage::new_rgba8(1, 1).into()),
             ..Default::default()
         };
@@ -962,5 +997,24 @@ mod tests {
         assert_eq!(block.height, 40.0);
         assert!(block.lock_layout_box);
         assert!(block.rendered.is_none());
+        assert!(block.rendered_direction.is_none());
+    }
+
+    #[test]
+    fn psd_export_filename_uses_koharu_suffix() {
+        let document = Document {
+            name: "chapter-01".to_string(),
+            ..Default::default()
+        };
+
+        assert_eq!(psd_export_filename(&document), "chapter-01_koharu.psd");
+    }
+
+    #[test]
+    fn app_psd_export_uses_editable_text_layers() {
+        assert_eq!(
+            app_psd_export_options().text_layer_mode,
+            TextLayerMode::Editable
+        );
     }
 }

koharu-rpc/src/mcp/mod.rs

@@ -95,7 +95,11 @@ impl KoharuMcp {
         let fonts = operations::list_font_families(res)
             .await
             .map_err(|e| e.to_string())?;
-        Ok(fonts.join(", "))
+        Ok(fonts
+            .into_iter()
+            .map(|font| format!("{} ({})", font.family_name, font.post_script_name))
+            .collect::<Vec<_>>()
+            .join(", "))
     }
 
     #[tool(description = "List available LLM translation models with supported languages")]

koharu-types/src/lib.rs

@@ -40,6 +40,7 @@ pub struct TextBlock {
     pub confidence: f32,
     pub line_polygons: Option<Vec<[[f32; 2]; 4]>>,
     pub source_direction: Option<TextDirection>,
+    pub rendered_direction: Option<TextDirection>,
     pub source_language: Option<String>,
     pub rotation_deg: Option<f32>,
     pub detected_font_size_px: Option<f32>,

koharu-types/src/protocol.rs

@@ -4,6 +4,14 @@ use ts_rs::TS;
 
 use crate::{Document, FontPrediction, TextBlock, TextShaderEffect, TextStrokeStyle, TextStyle};
 
+#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq, PartialOrd, Ord, JsonSchema, TS)]
+#[serde(rename_all = "camelCase")]
+#[ts(export)]
+pub struct FontFaceInfo {
+    pub family_name: String,
+    pub post_script_name: String,
+}
+
 #[derive(Debug, Clone, Serialize, Deserialize, JsonSchema, TS)]
 #[serde(rename_all = "camelCase")]
 #[ts(export)]
@@ -57,6 +65,7 @@ pub struct TextBlockDetail {
     pub confidence: f32,
     pub line_polygons: Option<Vec<[[f32; 2]; 4]>>,
     pub source_direction: Option<crate::TextDirection>,
+    pub rendered_direction: Option<crate::TextDirection>,
     pub source_language: Option<String>,
     pub rotation_deg: Option<f32>,
     pub detected_font_size_px: Option<f32>,
@@ -78,6 +87,7 @@ impl From<&TextBlock> for TextBlockDetail {
             confidence: block.confidence,
             line_polygons: block.line_polygons.clone(),
             source_direction: block.source_direction,
+            rendered_direction: block.rendered_direction,
             source_language: block.source_language.clone(),
             rotation_deg: block.rotation_deg,
             detected_font_size_px: block.detected_font_size_px,

ui/components/MenuBar.tsx

@@ -40,6 +40,7 @@ export function MenuBar() {
     inpaintAndRenderImage,
     processAllImages,
     exportDocument,
+    exportPsdDocument,
     exportAllInpainted,
     exportAllRendered,
   } = useDocumentMutations()
@@ -60,6 +61,13 @@ export function MenuBar() {
       onSelect: exportDocument,
       testId: 'menu-file-export',
     },
+    {
+      label: t('menu.exportPsd', {
+        defaultValue: 'Export PSD...',
+      }),
+      onSelect: exportPsdDocument,
+      testId: 'menu-file-export-psd',
+    },
     {
       label: t('menu.exportAllInpainted'),
       onSelect: exportAllInpainted,

ui/components/panels/RenderControlsPanel.tsx

@@ -20,6 +20,7 @@ import {
   TextAlign,
   TextStyle,
 } from '@/types'
+import type { FontFaceInfo } from '@/lib/protocol'
 import { Button } from '@/components/ui/button'
 import { ColorPicker } from '@/components/ui/color-picker'
 import { Input } from '@/components/ui/input'
@@ -42,7 +43,12 @@ import { useTextBlockMutations } from '@/lib/query/mutations'
 import { cn } from '@/lib/utils'
 
 const DEFAULT_COLOR: RgbaColor = [0, 0, 0, 255]
-const DEFAULT_FONT_FAMILIES = ['Arial']
+const DEFAULT_FONT_FACES: FontFaceInfo[] = [
+  {
+    familyName: 'Arial',
+    postScriptName: 'ArialMT',
+  },
+]
 const DEFAULT_EFFECT: RenderEffect = {
   italic: false,
   bold: false,
@@ -90,15 +96,37 @@ const hexToColor = (value: string, alpha: number): RgbaColor => {
   return [r, g, b, clampByte(alpha)]
 }
 
-const uniqueStrings = (values: string[]) => {
+const uniqueFontFaces = (values: FontFaceInfo[]) => {
   const seen = new Set<string>()
   return values.filter((value) => {
-    if (!value || seen.has(value)) return false
-    seen.add(value)
+    if (!value.postScriptName || seen.has(value.postScriptName)) return false
+    seen.add(value.postScriptName)
     return true
   })
 }
 
+const findFontFace = (fonts: FontFaceInfo[], value?: string) => {
+  if (!value) return undefined
+  return fonts.find(
+    (font) =>
+      font.postScriptName === value ||
+      font.familyName === value ||
+      font.familyName.trim() === value.trim(),
+  )
+}
+
+const normalizeFontValue = (fonts: FontFaceInfo[], value?: string) =>
+  findFontFace(fonts, value)?.postScriptName ?? value
+
+const fallbackFontFace = (value?: string): FontFaceInfo | undefined => {
+  const normalized = value?.trim()
+  if (!normalized) return undefined
+  return {
+    familyName: normalized,
+    postScriptName: normalized,
+  }
+}
+
 const normalizeEffect = (effect?: Partial<RenderEffect>): RenderEffect => ({
   italic: effect?.italic ?? false,
   bold: effect?.bold ?? false,
@@ -167,23 +195,32 @@ export function RenderControlsPanel() {
       : undefined
   const firstBlock = textBlocks[0]
   const hasBlocks = textBlocks.length > 0
-  const fallbackFontFamilies =
-    availableFonts.length > 0 ? [availableFonts[0]] : DEFAULT_FONT_FAMILIES
+  const fontCandidates = uniqueFontFaces(
+    [
+      ...availableFonts,
+      ...(fontFamily ? [fallbackFontFace(fontFamily)] : []),
+      ...(selectedBlock?.style?.fontFamilies
+        ?.slice(0, 1)
+        ?.map(fallbackFontFace) ?? []),
+      ...(firstBlock?.style?.fontFamilies?.slice(0, 1)?.map(fallbackFontFace) ??
+        []),
+      ...DEFAULT_FONT_FACES,
+    ].filter((value): value is FontFaceInfo => !!value),
+  )
+  const fallbackFontFaces =
+    fontCandidates.length > 0 ? fontCandidates : DEFAULT_FONT_FACES
   const fallbackColor = firstBlock?.style?.color ?? DEFAULT_COLOR
-  const fontCandidates =
-    availableFonts.length > 0
-      ? availableFonts
-      : [
-          ...(fontFamily ? [fontFamily] : []),
-          ...(selectedBlock?.style?.fontFamilies?.slice(0, 1) ?? []),
-          ...DEFAULT_FONT_FAMILIES,
-        ]
-  const fontOptions = uniqueStrings(fontCandidates)
-  const currentFont =
+  const fontOptions = fontCandidates
+  const currentFontCandidate =
     selectedBlock?.style?.fontFamilies?.[0] ??
     fontFamily ??
     firstBlock?.style?.fontFamilies?.[0] ??
-    (hasBlocks ? fallbackFontFamilies[0] : '')
+    (hasBlocks ? fallbackFontFaces[0]?.postScriptName : '')
+  const currentFontFace =
+    findFontFace(fontOptions, currentFontCandidate) ??
+    fallbackFontFace(currentFontCandidate)
+  const currentFont = currentFontFace?.postScriptName ?? ''
+  const currentFontFamilyName = currentFontFace?.familyName
   const currentEffect = normalizeEffect(
     selectedBlock?.style?.effect ?? renderEffect,
   )
@@ -264,7 +301,11 @@ export function RenderControlsPanel() {
     nextFont: string,
     current: string[] | undefined,
   ) => {
-    const base = current?.length ? current : fallbackFontFamilies
+    const base = (
+      current?.length
+        ? current
+        : fallbackFontFaces.map((font) => font.postScriptName)
+    ).map((family) => normalizeFontValue(fontOptions, family) ?? family)
     return [nextFont, ...base.filter((family) => family !== nextFont)]
   }
 
@@ -360,19 +401,23 @@ export function RenderControlsPanel() {
                 data-testid='render-font-select'
                 size='sm'
                 className='h-7 w-full min-w-0 text-xs'
-                style={currentFont ? { fontFamily: currentFont } : undefined}
+                style={
+                  currentFontFamilyName
+                    ? { fontFamily: currentFontFamilyName }
+                    : undefined
+                }
               >
                 <SelectValue placeholder={t('render.fontPlaceholder')} />
               </SelectTrigger>
               <SelectContent position='popper'>
                 {fontOptions.map((font, index) => (
                   <SelectItem
-                    key={font}
-                    value={font}
-                    style={{ fontFamily: font }}
+                    key={font.postScriptName}
+                    value={font.postScriptName}
+                    style={{ fontFamily: font.familyName }}
                     data-testid={`render-font-option-${index}`}
                   >
-                    {font}
+                    {font.familyName}
                   </SelectItem>
                 ))}
               </SelectContent>

ui/lib/api.ts

@@ -13,6 +13,7 @@ import type {
   DocumentDetail,
   DocumentSummary,
   ExportResult,
+  FontFaceInfo,
   JobState,
   LlmModelInfo,
   LlmState,
@@ -374,6 +375,21 @@ export const api = {
     })
   },
 
+  async exportPsdDocument(index: number): Promise<void> {
+    return withRpcError('export_psd_document', async () => {
+      const summary = await getDocumentSummaryAtIndex(index)
+      const file = await fetchBinary(`/documents/${summary.id}/export/psd`)
+      const blob = new Blob([toArrayBuffer(file.data)], {
+        type: file.contentType,
+      })
+      try {
+        await fileSave(blob, {
+          fileName: file.filename ?? `${summary.name}_koharu.psd`,
+        })
+      } catch {}
+    })
+  },
+
   async exportAllInpainted(): Promise<number> {
     return withRpcError('export_all_inpainted', async () => {
       const result = await fetchJson<ExportResult>('/exports?layer=inpainted', {
@@ -568,8 +584,8 @@ export const api = {
     })
   },
 
-  async listFontFamilies(): Promise<string[]> {
-    return fetchJson<string[]>('/fonts')
+  async listFonts(): Promise<FontFaceInfo[]> {
+    return fetchJson<FontFaceInfo[]>('/fonts')
   },
 
   async getApiKey(provider: string): Promise<string | null> {

ui/lib/errors.ts

@@ -8,6 +8,7 @@ const SURFACED_RPC_METHODS = new Set([
   'open_documents',
   'add_documents',
   'export_document',
+  'export_psd_document',
   'export_all_inpainted',
   'export_all_rendered',
   'detect',

ui/lib/generated/protocol/DocumentChangedEvent.ts

@@ -2,6 +2,6 @@
 
 export type DocumentChangedEvent = {
   documentId: string
-  revision: bigint
+  revision: number
   changed: Array<string>
 }

ui/lib/generated/protocol/DocumentDetail.ts

@@ -7,6 +7,6 @@ export type DocumentDetail = {
   name: string
   width: number
   height: number
-  revision: bigint
+  revision: number
   textBlocks: Array<TextBlockDetail>
 }

ui/lib/generated/protocol/DocumentSummary.ts

@@ -5,7 +5,7 @@ export type DocumentSummary = {
   name: string
   width: number
   height: number
-  revision: bigint
+  revision: number
   hasSegment: boolean
   hasInpainted: boolean
   hasBrushLayer: boolean

ui/lib/generated/protocol/DownloadState.ts

@@ -4,8 +4,8 @@ import type { TransferStatus } from './TransferStatus'
 export type DownloadState = {
   id: string
   filename: string
-  downloaded: bigint
-  total: bigint | null
+  downloaded: number
+  total: number | null
   status: TransferStatus
   error: string | null
 }

ui/lib/generated/protocol/FontFaceInfo.ts

@@ -0,0 +1,3 @@
+// This file was generated by [ts-rs](https://github.com/Aleph-Alpha/ts-rs). Do not edit this file manually.
+
+export type FontFaceInfo = { familyName: string; postScriptName: string }

ui/lib/generated/protocol/TextBlockDetail.ts

@@ -14,6 +14,7 @@ export type TextBlockDetail = {
     [[number, number], [number, number], [number, number], [number, number]]
   > | null
   sourceDirection: TextDirection | null
+  renderedDirection: TextDirection | null
   sourceLanguage: string | null
   rotationDeg: number | null
   detectedFontSizePx: number | null

ui/lib/protocol.ts

@@ -19,6 +19,7 @@ import type { DocumentsChangedEvent as GeneratedDocumentsChangedEvent } from '@/
 import type { DocumentSummary as GeneratedDocumentSummary } from '@/lib/generated/protocol/DocumentSummary'
 import type { ExportLayer } from '@/lib/generated/protocol/ExportLayer'
 import type { ExportResult } from '@/lib/generated/protocol/ExportResult'
+import type { FontFaceInfo } from '@/lib/generated/protocol/FontFaceInfo'
 import type { ImportMode } from '@/lib/generated/protocol/ImportMode'
 import type { ImportResult as GeneratedImportResult } from '@/lib/generated/protocol/ImportResult'
 import type { InpaintRegionRequest } from '@/lib/generated/protocol/InpaintRegionRequest'
@@ -46,6 +47,7 @@ export type {
   CreateTextBlock,
   ExportLayer,
   ExportResult,
+  FontFaceInfo,
   ImportMode,
   InpaintRegionRequest,
   JobState,

ui/lib/query/hooks.ts

@@ -56,7 +56,7 @@ export const useThumbnailQuery = (index: number, documentsVersion: number) =>
 export const useFontsQuery = () =>
   useQuery({
     queryKey: queryKeys.fonts,
-    queryFn: () => api.listFontFamilies(),
+    queryFn: () => api.listFonts(),
     staleTime: 10 * 60 * 1000,
   })
 

ui/lib/query/mutations.ts

@@ -519,6 +519,11 @@ export const useDocumentMutations = () => {
     await api.exportDocument(currentDocumentIndex)
   }, [])
 
+  const exportPsdDocument = useCallback(async () => {
+    const { currentDocumentIndex } = useEditorUiStore.getState()
+    await api.exportPsdDocument(currentDocumentIndex)
+  }, [])
+
   const exportAllInpainted = useCallback(async () => {
     await api.exportAllInpainted()
   }, [])
@@ -545,6 +550,7 @@ export const useDocumentMutations = () => {
     processAllImages,
     inpaintAndRenderImage,
     exportDocument,
+    exportPsdDocument,
     exportAllInpainted,
     exportAllRendered,
     cancelOperation,