Release v0.2.3

Cargo.lock

@@ -182,7 +182,7 @@ checksum = "3d7b894f5411737b7867f4827955924d7c254fc9f4d91a6aad6b097804b1018b"
 
 [[package]]
 name = "comicviewer"
-version = "0.2.2"
+version = "0.2.3"
 dependencies = [
  "anyhow",
  "chrono",

Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "comicviewer"
-version = "0.2.2"
+version = "0.2.3"
 edition = "2024"
 description = "A comic archive viewer for local and remote locations"
 license = "GPL-3.0-or-later"

data/io.github.comicviewer.Comicviewer.desktop

@@ -4,9 +4,9 @@ Name=Comicviewer
 Name[ko]=코믹뷰어
 Comment=Read comic images stored in ZIP archives
 Comment[ko]=ZIP으로 압축된 만화 이미지를 봅니다
-Exec=comicviewer
+Exec=comicviewer %f
 Icon=io.github.comicviewer.Comicviewer
 Terminal=false
 Categories=Graphics;Viewer;
-MimeType=application/zip;application/vnd.comicbook+zip;
+MimeType=application/zip;image/jpeg;image/png;image/webp;image/gif;image/bmp;image/avif;video/mp4;video/x-m4v;video/matroska;video/x-matroska;video/webm;video/quicktime;video/vnd.avi;video/x-msvideo;video/mpeg;video/ogg;inode/directory;
 StartupNotify=true

data/io.github.comicviewer.Comicviewer.metainfo.xml

@@ -26,6 +26,7 @@
   </provides>
   <content_rating type="oars-1.1" />
   <releases>
+    <release version="0.2.3" date="2026-07-23" />
     <release version="0.2.2" date="2026-07-22" />
     <release version="0.2.1" date="2026-07-22" />
     <release version="0.2.0" date="2026-07-21" />

docs/RELEASING.ko.md

@@ -55,7 +55,7 @@ AppImage 빌드가 끝나면 다음 스크립트로 체크섬과 통합 `tar.gz`
 
 스크립트는 `Cargo.toml`에서 버전을 읽고 다음 파일을 생성합니다.
 
-- `dist/Comicviewer-0.2.2-x86_64.AppImage.sha256`
+- `dist/Comicviewer-0.2.3-x86_64.AppImage.sha256`
 - `dist/Comicviewer-latest-x86_64.tar.gz`
 - `dist/Comicviewer-latest-x86_64.tar.gz.sha256`
 
@@ -78,10 +78,10 @@ sha256sum -c Comicviewer-latest-x86_64.tar.gz.sha256
 
 ```sh
 git add Cargo.toml Cargo.lock data packaging README.md docs
-git commit -m "Prepare v0.2.2 release"
+git commit -m "Release v0.2.3"
-git tag -a v0.2.2 -m "Comicviewer v0.2.2"
+git tag -a v0.2.3 -m "Comicviewer v0.2.3"
 git push origin main
-git push origin v0.2.2
+git push origin v0.2.3
 ```
 
 이미 원격에 공개한 태그는 이동하거나 덮어쓰지 않습니다. 수정이 필요하면 새

packaging/install-or-update.sh

@@ -109,7 +109,7 @@ temporary_appimage=""
 ln -sfn "${installed_appimage}" "${launcher}"
 while IFS= read -r line || [ -n "${line}" ]; do
     case "${line}" in
-        Exec=*) printf 'Exec="%s"\n' "${launcher}" ;;
+        Exec=*) printf 'Exec="%s" %%f\n' "${launcher}" ;;
         *) printf '%s\n' "${line}" ;;
     esac
 done < "${desktop_file}" > "${temporary_desktop}"

src/browser.rs

@@ -21,6 +21,7 @@ impl EntryKind {
 pub struct BrowserEntry {
     pub uri: String,
     pub name: String,
+    pub list_name: Option<String>,
     pub kind: EntryKind,
     pub size: Option<u64>,
     pub modified: Option<SystemTime>,
@@ -28,6 +29,12 @@ pub struct BrowserEntry {
     pub etag: Option<String>,
 }
 
+impl BrowserEntry {
+    pub fn display_name(&self) -> &str {
+        self.list_name.as_deref().unwrap_or(&self.name)
+    }
+}
+
 #[derive(Debug, Clone, Copy, PartialEq, Eq)]
 pub enum SortField {
     Name,
@@ -62,20 +69,28 @@ pub fn sort_entries(
 
         match field {
             SortField::Name => apply_direction(
-                natural_cmp_with_case(&left.name, &right.name, case_insensitive),
+                natural_cmp_with_case(left.display_name(), right.display_name(), case_insensitive),
                 direction,
             ),
             SortField::Modified => compare_optional_time(left.modified, right.modified, direction)
                 .then_with(|| {
                     apply_direction(
-                        natural_cmp_with_case(&left.name, &right.name, case_insensitive),
+                        natural_cmp_with_case(
+                            left.display_name(),
+                            right.display_name(),
+                            case_insensitive,
+                        ),
                         direction,
                     )
                 }),
             SortField::Created => compare_optional_time(left.created, right.created, direction)
                 .then_with(|| {
                     apply_direction(
-                        natural_cmp_with_case(&left.name, &right.name, case_insensitive),
+                        natural_cmp_with_case(
+                            left.display_name(),
+                            right.display_name(),
+                            case_insensitive,
+                        ),
                         direction,
                     )
                 }),
@@ -212,6 +227,30 @@ mod tests {
         );
     }
 
+    #[test]
+    fn recursive_entries_sort_by_relative_display_path() {
+        let mut entries = ["10권/page.jpg", "2권/page.jpg"].map(|list_name| BrowserEntry {
+            uri: format!("file:///{list_name}"),
+            name: "page.jpg".into(),
+            list_name: Some(list_name.into()),
+            kind: EntryKind::Image,
+            size: None,
+            modified: None,
+            created: None,
+            etag: None,
+        });
+
+        sort_entries(
+            &mut entries,
+            SortField::Name,
+            SortDirection::Ascending,
+            true,
+        );
+
+        assert_eq!(entries[0].display_name(), "2권/page.jpg");
+        assert_eq!(entries[1].display_name(), "10권/page.jpg");
+    }
+
     #[test]
     fn zip_extension_is_case_insensitive() {
         assert_eq!(classify_file(Path::new("comic.ZIP")), EntryKind::ZipArchive);

src/database.rs

@@ -2,8 +2,11 @@ use std::path::Path;
 use std::time::{SystemTime, UNIX_EPOCH};
 
 use anyhow::{Context, Result};
+use gtk::gio::prelude::*;
 use rusqlite::{Connection, OptionalExtension, params};
 
+use crate::browser::{BrowserEntry, EntryKind};
+
 pub struct Database {
     connection: Connection,
 }
@@ -105,6 +108,124 @@ impl Database {
         )?;
         Ok(())
     }
+
+    pub fn load_cached_tree(&self, location_id: &str, root_uri: &str) -> Result<Vec<BrowserEntry>> {
+        let mut statement = self.connection.prepare(
+            "WITH RECURSIVE tree(uri, name, path, entry_kind, size, modified_at, created_at, etag) AS (
+                 SELECT uri, name, name, entry_kind, size, modified_at, created_at, etag
+                 FROM cached_entries
+                 WHERE location_id = ?1 AND parent_uri = ?2
+                 UNION ALL
+                 SELECT child.uri, child.name, tree.path || '/' || child.name,
+                        child.entry_kind, child.size, child.modified_at, child.created_at, child.etag
+                 FROM cached_entries AS child
+                 JOIN tree ON child.parent_uri = tree.uri
+                 WHERE child.location_id = ?1
+             )
+             SELECT uri, name, path, entry_kind, size, modified_at, created_at, etag
+             FROM tree ORDER BY path",
+        )?;
+        let rows = statement.query_map(params![location_id, root_uri], |row| {
+            let kind = entry_kind_from_i64(row.get(3)?);
+            let size = row
+                .get::<_, Option<i64>>(4)?
+                .and_then(|value| u64::try_from(value).ok());
+            Ok(BrowserEntry {
+                uri: row.get(0)?,
+                name: row.get(1)?,
+                list_name: Some(row.get(2)?),
+                kind,
+                size,
+                modified: row.get::<_, Option<i64>>(5)?.and_then(system_time_from_i64),
+                created: row.get::<_, Option<i64>>(6)?.and_then(system_time_from_i64),
+                etag: row.get(7)?,
+            })
+        })?;
+        rows.collect::<rusqlite::Result<Vec<_>>>()
+            .map_err(Into::into)
+    }
+
+    pub fn replace_cached_tree(
+        &self,
+        location_id: &str,
+        root_uri: &str,
+        entries: &[BrowserEntry],
+    ) -> Result<()> {
+        let transaction = self.connection.unchecked_transaction()?;
+        transaction.execute(
+            "WITH RECURSIVE tree(uri) AS (
+                 SELECT uri FROM cached_entries WHERE location_id = ?1 AND parent_uri = ?2
+                 UNION
+                 SELECT child.uri FROM cached_entries AS child
+                 JOIN tree ON child.parent_uri = tree.uri
+                 WHERE child.location_id = ?1
+             )
+             DELETE FROM cached_entries
+             WHERE location_id = ?1 AND uri IN (SELECT uri FROM tree)",
+            params![location_id, root_uri],
+        )?;
+        let refreshed_at = system_time_to_i64(SystemTime::now());
+        {
+            let mut statement = transaction.prepare(
+                "INSERT INTO cached_entries
+                     (location_id, parent_uri, uri, name, entry_kind, size, modified_at,
+                      created_at, etag, refreshed_at)
+                 VALUES (?1, ?2, ?3, ?4, ?5, ?6, ?7, ?8, ?9, ?10)",
+            )?;
+            for entry in entries {
+                let parent_uri = gtk::gio::File::for_uri(&entry.uri)
+                    .parent()
+                    .map(|parent| parent.uri().to_string())
+                    .unwrap_or_else(|| root_uri.to_owned());
+                statement.execute(params![
+                    location_id,
+                    parent_uri,
+                    entry.uri,
+                    entry.name,
+                    entry_kind_to_i64(entry.kind),
+                    entry.size.and_then(|value| i64::try_from(value).ok()),
+                    entry.modified.map(system_time_to_i64),
+                    entry.created.map(system_time_to_i64),
+                    entry.etag,
+                    refreshed_at,
+                ])?;
+            }
+        }
+        transaction.commit()?;
+        Ok(())
+    }
+}
+
+fn entry_kind_to_i64(kind: EntryKind) -> i64 {
+    match kind {
+        EntryKind::Directory => 0,
+        EntryKind::ZipArchive => 1,
+        EntryKind::Image => 2,
+        EntryKind::Video => 3,
+        EntryKind::OtherFile => 4,
+    }
+}
+
+fn entry_kind_from_i64(value: i64) -> EntryKind {
+    match value {
+        0 => EntryKind::Directory,
+        1 => EntryKind::ZipArchive,
+        2 => EntryKind::Image,
+        3 => EntryKind::Video,
+        _ => EntryKind::OtherFile,
+    }
+}
+
+fn system_time_to_i64(time: SystemTime) -> i64 {
+    time.duration_since(UNIX_EPOCH)
+        .unwrap_or_default()
+        .as_secs() as i64
+}
+
+fn system_time_from_i64(seconds: i64) -> Option<SystemTime> {
+    u64::try_from(seconds)
+        .ok()
+        .map(|seconds| UNIX_EPOCH + std::time::Duration::from_secs(seconds))
 }
 
 #[cfg(test)]
@@ -122,4 +243,51 @@ mod tests {
         database.save_progress("test.zip", 9, 20).unwrap();
         assert_eq!(database.load_progress("test.zip").unwrap(), Some(9));
     }
+
+    #[test]
+    fn cached_tree_replaces_descendants_and_restores_relative_paths() {
+        let database = Database::open(Path::new(":memory:")).unwrap();
+        let entries = vec![
+            BrowserEntry {
+                uri: "file:///library/series".into(),
+                name: "series".into(),
+                list_name: Some("series".into()),
+                kind: EntryKind::Directory,
+                size: None,
+                modified: None,
+                created: None,
+                etag: None,
+            },
+            BrowserEntry {
+                uri: "file:///library/series/book.zip".into(),
+                name: "book.zip".into(),
+                list_name: Some("series/book.zip".into()),
+                kind: EntryKind::ZipArchive,
+                size: Some(42),
+                modified: None,
+                created: None,
+                etag: Some("v1".into()),
+            },
+        ];
+
+        database
+            .replace_cached_tree("library", "file:///library", &entries)
+            .unwrap();
+        let loaded = database
+            .load_cached_tree("library", "file:///library")
+            .unwrap();
+        assert_eq!(loaded.len(), 2);
+        assert_eq!(loaded[1].display_name(), "series/book.zip");
+
+        database
+            .replace_cached_tree("library", "file:///library", &entries[..1])
+            .unwrap();
+        assert_eq!(
+            database
+                .load_cached_tree("library", "file:///library")
+                .unwrap()
+                .len(),
+            1
+        );
+    }
 }

src/main.rs

@@ -8,36 +8,86 @@ mod viewer;
 mod window;
 mod zip_cache;
 
+use std::cell::RefCell;
+use std::rc::Rc;
+
 use anyhow::Result;
+use gtk::gio;
 use gtk::prelude::*;
 
 const APP_ID: &str = "io.github.comicviewer.Comicviewer";
 
 fn main() {
-    let application = gtk::Application::builder().application_id(APP_ID).build();
+    let application = gtk::Application::builder()
+        .application_id(APP_ID)
+        .flags(application_flags())
+        .build();
+    let state = Rc::new(ApplicationState::default());
 
-    application.connect_activate(|application| {
+    let activate_state = Rc::clone(&state);
-        if let Err(error) = activate(application) {
+    application.connect_activate(move |application| {
-            eprintln!("Comicviewer를 시작하지 못했습니다: {error:#}");
+        match activate_state.ensure_main_window(application) {
-            application.quit();
+            Ok(window) => window.present(),
+            Err(error) => startup_failed(application, &error),
+        }
+    });
+    application.connect_open(move |application, files, _| {
+        match state.ensure_main_window(application) {
+            Ok(window) => window.open_local_items(files),
+            Err(error) => startup_failed(application, &error),
         }
     });
 
     application.run();
 }
 
-fn activate(application: &gtk::Application) -> Result<()> {
+#[derive(Default)]
-    let app_paths = paths::AppPaths::discover()?;
+struct ApplicationState {
-    let config = config::AppConfig::load_or_create(&app_paths.config_file)?;
+    main_window: RefCell<Option<Rc<window::ComicWindow>>>,
-    let database = database::Database::open(&app_paths.database_file)?;
+}
-    let zip_cache = zip_cache::ZipCache::new(app_paths.zip_cache_dir, config.cache_quota_gb)?;
+
-    let window = window::ComicWindow::new(
+impl ApplicationState {
-        application,
+    fn ensure_main_window(
-        config,
+        &self,
-        app_paths.config_file,
+        application: &gtk::Application,
-        database,
+    ) -> Result<Rc<window::ComicWindow>> {
-        zip_cache,
+        if let Some(window) = self.main_window.borrow().as_ref() {
-    )?;
+            return Ok(Rc::clone(window));
-    window.present();
+        }
-    Ok(())
+        let app_paths = paths::AppPaths::discover()?;
+        let config = config::AppConfig::load_or_create(&app_paths.config_file)?;
+        let database = database::Database::open(&app_paths.database_file)?;
+        let zip_cache = zip_cache::ZipCache::new(app_paths.zip_cache_dir, config.cache_quota_gb)?;
+        let window = Rc::new(window::ComicWindow::new(
+            application,
+            config,
+            app_paths.config_file,
+            database,
+            zip_cache,
+        )?);
+        self.main_window.replace(Some(Rc::clone(&window)));
+        Ok(window)
+    }
+}
+
+fn startup_failed(application: &gtk::Application, error: &anyhow::Error) {
+    eprintln!("Comicviewer를 시작하지 못했습니다: {error:#}");
+    application.quit();
+}
+
+fn application_flags() -> gio::ApplicationFlags {
+    gio::ApplicationFlags::HANDLES_OPEN
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn application_accepts_files_as_a_single_instance() {
+        let flags = application_flags();
+        assert!(flags.contains(gio::ApplicationFlags::HANDLES_OPEN));
+        assert!(!flags.contains(gio::ApplicationFlags::NON_UNIQUE));
+        assert!(!flags.contains(gio::ApplicationFlags::HANDLES_COMMAND_LINE));
+    }
 }

src/source.rs

@@ -1,3 +1,4 @@
+use std::collections::{HashSet, VecDeque};
 use std::path::Path;
 use std::time::{Duration, UNIX_EPOCH};
 
@@ -11,6 +12,17 @@ use crate::browser::{BrowserEntry, EntryKind, classify_file};
 use crate::config::{LocationKind, LocationProfile};
 
 const ATTRIBUTES: &str = "standard::display-name,standard::name,standard::type,standard::size,standard::target-uri,mountable::can-mount,time::modified,time::created,etag::value";
+const RECURSIVE_ATTRIBUTES: &str = "standard::display-name,standard::name,standard::type,standard::is-symlink,standard::size,time::modified,time::created,etag::value,id::file,id::filesystem";
+const MAX_RECURSIVE_DIRECTORIES: usize = 10_000;
+const MAX_RECURSIVE_ENTRIES: usize = 100_000;
+
+#[derive(Clone, Copy, Default)]
+pub struct RecursiveProgress {
+    pub directories: usize,
+    pub scanned: usize,
+    pub viewable: usize,
+    pub skipped: usize,
+}
 
 pub fn root_file(profile: &LocationProfile) -> Result<gio::File> {
     validate_profile(profile)?;
@@ -125,6 +137,7 @@ where
             entries.push(BrowserEntry {
                 uri,
                 name: info.display_name().into(),
+                list_name: None,
                 kind,
                 size: info
                     .has_attribute("standard::size")
@@ -144,6 +157,143 @@ where
     Ok(entries)
 }
 
+pub async fn enumerate_tree_entries<F>(
+    profile: &LocationProfile,
+    root: &gio::File,
+    operation: Option<&gtk::MountOperation>,
+    mut progress: F,
+) -> Result<(Vec<BrowserEntry>, RecursiveProgress)>
+where
+    F: FnMut(RecursiveProgress),
+{
+    if profile.kind != LocationKind::Local && !root.is_native() {
+        let operation = operation.context("원격 폴더 마운트 정보가 없습니다")?;
+        ensure_mounted(root, profile, operation).await?;
+    }
+    let mut pending = VecDeque::from([(root.clone(), String::new())]);
+    let mut visited = HashSet::new();
+    let mut visited_identities = HashSet::new();
+    if let Ok(info) = root
+        .query_info_future(
+            "id::file,id::filesystem",
+            gio::FileQueryInfoFlags::NOFOLLOW_SYMLINKS,
+            glib::Priority::DEFAULT,
+        )
+        .await
+        && let Some(identity) = recursive_file_identity(&info)
+    {
+        visited_identities.insert(identity);
+    }
+    let mut entries = Vec::new();
+    let mut state = RecursiveProgress::default();
+
+    while let Some((directory, relative_directory)) = pending.pop_front() {
+        let directory_uri: String = directory.uri().into();
+        if !visited.insert(directory_uri.clone()) {
+            continue;
+        }
+        if visited.len() > MAX_RECURSIVE_DIRECTORIES {
+            bail!("하위 폴더 수가 안전 제한을 초과합니다 (최대 {MAX_RECURSIVE_DIRECTORIES}개)");
+        }
+        let enumerator = match directory
+            .enumerate_children_future(
+                RECURSIVE_ATTRIBUTES,
+                gio::FileQueryInfoFlags::NOFOLLOW_SYMLINKS,
+                glib::Priority::DEFAULT,
+            )
+            .await
+        {
+            Ok(enumerator) => enumerator,
+            Err(error) if directory.equal(root) => {
+                return Err(error)
+                    .with_context(|| format!("폴더에 접근할 수 없습니다: {}", directory.uri()));
+            }
+            Err(_) => {
+                state.skipped += 1;
+                progress(state);
+                continue;
+            }
+        };
+        state.directories += 1;
+        loop {
+            let batch = enumerator
+                .next_files_future(128, glib::Priority::DEFAULT)
+                .await?;
+            if batch.is_empty() {
+                break;
+            }
+            state.scanned += batch.len();
+            if state.scanned > MAX_RECURSIVE_ENTRIES {
+                bail!("하위 항목 수가 안전 제한을 초과합니다 (최대 {MAX_RECURSIVE_ENTRIES}개)");
+            }
+            for info in batch {
+                let child = enumerator.child(&info);
+                if info.is_symlink() || !is_within_root(&child, root) {
+                    continue;
+                }
+                let display_name = info.display_name();
+                let relative_name = if relative_directory.is_empty() {
+                    display_name.to_string()
+                } else {
+                    format!("{relative_directory}/{display_name}")
+                };
+                match info.file_type() {
+                    gio::FileType::Directory => {
+                        if let Some(identity) = recursive_file_identity(&info)
+                            && !visited_identities.insert(identity)
+                        {
+                            continue;
+                        }
+                        pending.push_back((child.clone(), relative_name.clone()));
+                        entries.push(BrowserEntry {
+                            uri: child.uri().into(),
+                            name: display_name.into(),
+                            list_name: Some(relative_name),
+                            kind: EntryKind::Directory,
+                            size: None,
+                            modified: attribute_time(&info, "time::modified"),
+                            created: attribute_time(&info, "time::created"),
+                            etag: info
+                                .has_attribute("etag::value")
+                                .then(|| info.etag())
+                                .flatten()
+                                .map(Into::into),
+                        });
+                    }
+                    gio::FileType::Regular => {
+                        let kind = classify_file(Path::new(display_name.as_str()));
+                        if !kind.is_viewable() {
+                            continue;
+                        }
+                        state.viewable += 1;
+                        entries.push(BrowserEntry {
+                            uri: child.uri().into(),
+                            name: display_name.into(),
+                            list_name: Some(relative_name),
+                            kind,
+                            size: info
+                                .has_attribute("standard::size")
+                                .then(|| info.size())
+                                .filter(|size| *size >= 0)
+                                .map(|size| size as u64),
+                            modified: attribute_time(&info, "time::modified"),
+                            created: attribute_time(&info, "time::created"),
+                            etag: info
+                                .has_attribute("etag::value")
+                                .then(|| info.etag())
+                                .flatten()
+                                .map(Into::into),
+                        });
+                    }
+                    _ => {}
+                }
+            }
+            progress(state);
+        }
+    }
+    Ok((entries, state))
+}
+
 pub fn mount_operation(
     profile: &LocationProfile,
     parent: &impl glib::object::IsA<gtk::Window>,
@@ -239,8 +389,16 @@ fn attribute_time(info: &gio::FileInfo, attribute: &str) -> Option<std::time::Sy
         .then(|| UNIX_EPOCH + Duration::from_secs(info.attribute_uint64(attribute)))
 }
 
+fn recursive_file_identity(info: &gio::FileInfo) -> Option<String> {
+    let filesystem = info.attribute_string("id::filesystem")?;
+    let file = info.attribute_string("id::file")?;
+    Some(format!("{filesystem}:{file}"))
+}
+
 #[cfg(test)]
 mod tests {
+    use std::fs;
+
     use super::*;
 
     #[test]
@@ -290,4 +448,43 @@ mod tests {
         let encoded_input = file_from_user_input(LocationKind::Ftp, encoded.uri().as_str());
         assert!(encoded_input.equal(&encoded));
     }
+
+    #[test]
+    fn recursively_lists_viewable_files_without_following_symlinks() {
+        let directory = tempfile::tempdir().unwrap();
+        let subdirectory = directory.path().join("2권");
+        fs::create_dir(&subdirectory).unwrap();
+        fs::write(directory.path().join("10.zip"), []).unwrap();
+        fs::write(subdirectory.join("page2.jpg"), []).unwrap();
+        fs::write(subdirectory.join("notes.txt"), []).unwrap();
+        #[cfg(unix)]
+        std::os::unix::fs::symlink(directory.path(), subdirectory.join("loop")).unwrap();
+        let profile = LocationProfile {
+            name: "test".into(),
+            kind: LocationKind::Local,
+            address: directory.path().to_string_lossy().into_owned(),
+            username: String::new(),
+            password: String::new(),
+            domain: String::new(),
+        };
+        let root = gio::File::for_path(directory.path());
+        let (entries, progress) = glib::MainContext::default()
+            .block_on(enumerate_tree_entries(&profile, &root, None, |_| {}))
+            .unwrap();
+
+        assert!(
+            entries.iter().any(|entry| {
+                entry.kind == EntryKind::Directory && entry.display_name() == "2권"
+            })
+        );
+        assert!(entries.iter().any(|entry| {
+            entry.kind == EntryKind::ZipArchive && entry.display_name() == "10.zip"
+        }));
+        assert!(entries.iter().any(|entry| {
+            entry.kind == EntryKind::Image && entry.display_name() == "2권/page2.jpg"
+        }));
+        assert!(!entries.iter().any(|entry| entry.name == "notes.txt"));
+        assert!(!entries.iter().any(|entry| entry.name == "loop"));
+        assert_eq!(progress.skipped, 0);
+    }
 }

src/viewer.rs

@@ -3,7 +3,7 @@ use std::collections::{HashMap, HashSet, VecDeque};
 use std::rc::{Rc, Weak};
 use std::sync::mpsc::{self, TryRecvError};
 use std::thread;
-use std::time::Duration;
+use std::time::{Duration, Instant};
 
 use gtk::gdk;
 use gtk::glib;
@@ -26,12 +26,12 @@ const MEDIA_VIEWER_CONTROLLER_KEY: &str = "comicviewer-media-viewer-controller";
 fn clear_viewer_controller(window: &gtk::ApplicationWindow) {
     unsafe {
         if let Some(controller) = window.steal_data::<Rc<ViewerController>>(VIEWER_CONTROLLER_KEY) {
-            controller.stop_animations();
+            controller.detach_window_controllers();
         }
         if let Some(controller) =
             window.steal_data::<Rc<MediaViewerController>>(MEDIA_VIEWER_CONTROLLER_KEY)
         {
-            controller.stop_playback();
+            controller.prepare_for_navigation();
         }
     }
 }
@@ -47,7 +47,45 @@ fn ensure_viewer_close_handler(window: &gtk::ApplicationWindow) {
     });
 }
 
-pub(crate) fn set_viewer_header(window: &gtk::ApplicationWindow, header: &gtk::HeaderBar) {
+pub(crate) fn set_viewer_loading(window: &gtk::ApplicationWindow, loading: bool) {
+    if !window.has_css_class("viewer-loading-key-handler") {
+        window.add_css_class("viewer-loading-key-handler");
+        let keys = gtk::EventControllerKey::new();
+        keys.set_propagation_phase(gtk::PropagationPhase::Capture);
+        let weak_window = window.downgrade();
+        keys.connect_key_pressed(move |_, key, _, _| {
+            let Some(window) = weak_window.upgrade() else {
+                return glib::Propagation::Proceed;
+            };
+            if !window.has_css_class("viewer-loading") || !window.is_fullscreen() {
+                return glib::Propagation::Proceed;
+            }
+            if let Some(titlebar) = window.titlebar() {
+                titlebar.set_visible(true);
+            }
+            if key == gdk::Key::Escape
+                || key
+                    .to_unicode()
+                    .is_some_and(|character| character.eq_ignore_ascii_case(&'f'))
+            {
+                window.unfullscreen();
+                return glib::Propagation::Stop;
+            }
+            glib::Propagation::Proceed
+        });
+        window.add_controller(keys);
+    }
+    if loading {
+        window.add_css_class("viewer-loading");
+    } else {
+        window.remove_css_class("viewer-loading");
+    }
+}
+
+pub(crate) fn set_viewer_header(
+    window: &gtk::ApplicationWindow,
+    header: &gtk::HeaderBar,
+) -> gtk::Box {
     let host = window
         .titlebar()
         .and_downcast::<gtk::Box>()
@@ -62,6 +100,8 @@ pub(crate) fn set_viewer_header(window: &gtk::ApplicationWindow, header: &gtk::H
     }
     header.set_hexpand(true);
     host.append(header);
+    host.set_visible(!window.is_fullscreen());
+    host
 }
 
 pub struct ViewerWindow;
@@ -244,6 +284,7 @@ impl ViewerWindow {
         });
         install_file_drop_target(&window, file_drop_control);
         ensure_viewer_close_handler(&window);
+        set_viewer_loading(&window, false);
         window.set_title(Some(&title));
         let header = gtk::HeaderBar::new();
         header.set_title_widget(Some(&gtk::Label::new(Some(&title))));
@@ -255,7 +296,7 @@ impl ViewerWindow {
         header.pack_end(&download_button);
         header.pack_end(&favorite_button);
         header.pack_end(&file_list_button);
-        set_viewer_header(&window, &header);
+        let titlebar_host = set_viewer_header(&window, &header);
 
         let root = gtk::Box::new(gtk::Orientation::Vertical, 0);
         let toolbar = gtk::Box::new(gtk::Orientation::Horizontal, 6);
@@ -358,6 +399,7 @@ impl ViewerWindow {
 
         let controller = Rc::new(ViewerController {
             window,
+            titlebar_host,
             source,
             database,
             stack,
@@ -372,6 +414,7 @@ impl ViewerWindow {
             page_label,
             page_seek,
             page_seek_row,
+            toolbar,
             status_label,
             previous_button,
             next_button,
@@ -395,6 +438,10 @@ impl ViewerWindow {
             last_pointer_position: Cell::new(None),
             key_controller: RefCell::new(None),
             motion_controller: RefCell::new(None),
+            fullscreen_key_controller: RefCell::new(None),
+            fullscreen_ui_hide_timer: RefCell::new(None),
+            fullscreen_ui_visible: Cell::new(false),
+            fullscreen_notify_handler: RefCell::new(None),
             navigation_message,
             navigation_message_label,
             navigation_message_generation: Rc::new(Cell::new(0)),
@@ -417,6 +464,7 @@ impl ViewerWindow {
             }),
         });
         controller.connect_signals();
+        controller.fullscreen_changed();
         if controller.file_list_button.is_active() {
             controller.refresh_file_list();
         }
@@ -506,6 +554,7 @@ struct ViewerState {
 
 struct ViewerController {
     window: gtk::ApplicationWindow,
+    titlebar_host: gtk::Box,
     source: ArchiveSource,
     database: Rc<Database>,
     stack: gtk::Stack,
@@ -520,6 +569,7 @@ struct ViewerController {
     page_label: gtk::Label,
     page_seek: gtk::Scale,
     page_seek_row: gtk::Box,
+    toolbar: gtk::Box,
     status_label: gtk::Label,
     previous_button: gtk::Button,
     next_button: gtk::Button,
@@ -543,6 +593,10 @@ struct ViewerController {
     last_pointer_position: Cell<Option<(f64, f64)>>,
     key_controller: RefCell<Option<gtk::EventControllerKey>>,
     motion_controller: RefCell<Option<gtk::EventControllerMotion>>,
+    fullscreen_key_controller: RefCell<Option<gtk::EventControllerKey>>,
+    fullscreen_ui_hide_timer: RefCell<Option<glib::SourceId>>,
+    fullscreen_ui_visible: Cell<bool>,
+    fullscreen_notify_handler: RefCell<Option<glib::SignalHandlerId>>,
     navigation_message: gtk::Box,
     navigation_message_label: gtk::Label,
     navigation_message_generation: Rc<Cell<u64>>,
@@ -612,7 +666,11 @@ impl ViewerController {
         let controller = Rc::downgrade(self);
         self.file_list_button.connect_toggled(move |button| {
             if let Some(controller) = controller.upgrade() {
-                controller.file_list_panel.set_visible(button.is_active());
+                controller.file_list_panel.set_visible(
+                    button.is_active()
+                        && (!controller.window.is_fullscreen()
+                            || controller.fullscreen_ui_visible.get()),
+                );
                 if button.is_active() {
                     controller.window.add_css_class("viewer-file-list-visible");
                 } else {
@@ -631,6 +689,22 @@ impl ViewerController {
                 controller.open_file_list_row(row.index());
             }
         });
+        let file_list_typeahead = Rc::new(RefCell::new(TypeaheadBuffer::default()));
+        let file_list_keys = gtk::EventControllerKey::new();
+        let controller = Rc::downgrade(self);
+        file_list_keys.connect_key_pressed(move |_, key, _, modifiers| {
+            let Some(controller) = controller.upgrade() else {
+                return glib::Propagation::Proceed;
+            };
+            file_list_typeahead_select(
+                &controller.file_list,
+                &controller.file_list_files.borrow(),
+                &mut file_list_typeahead.borrow_mut(),
+                key,
+                modifiers,
+            )
+        });
+        self.file_list.add_controller(file_list_keys);
         let file_list_click = gtk::GestureClick::builder().button(3).build();
         let controller = Rc::downgrade(self);
         file_list_click.connect_pressed(move |_, _, x, y| {
@@ -717,13 +791,30 @@ impl ViewerController {
         self.window.add_controller(motion_controller.clone());
         self.motion_controller.replace(Some(motion_controller));
 
+        let fullscreen_keys = gtk::EventControllerKey::new();
+        fullscreen_keys.set_propagation_phase(gtk::PropagationPhase::Capture);
+        let controller = Rc::downgrade(self);
+        fullscreen_keys.connect_key_pressed(move |_, _, _, _| {
+            if let Some(controller) = controller.upgrade()
+                && controller.window.is_fullscreen()
+            {
+                controller.show_fullscreen_ui_temporarily();
+            }
+            glib::Propagation::Proceed
+        });
+        self.window.add_controller(fullscreen_keys.clone());
+        self.fullscreen_key_controller
+            .replace(Some(fullscreen_keys));
+
         let key_controller = gtk::EventControllerKey::new();
         let controller = Rc::downgrade(self);
         key_controller.connect_key_pressed(move |_, key, _, _| {
             let Some(controller) = controller.upgrade() else {
                 return glib::Propagation::Proceed;
             };
-            controller.hide_seek();
+            if !controller.window.is_fullscreen() {
+                controller.hide_seek();
+            }
             match key {
                 gdk::Key::Home => {
                     controller.seek_edge(false);
@@ -783,6 +874,15 @@ impl ViewerController {
         });
         self.window.add_controller(key_controller.clone());
         self.key_controller.replace(Some(key_controller));
+        let controller = Rc::downgrade(self);
+        let handler = self
+            .window
+            .connect_notify_local(Some("fullscreened"), move |_, _| {
+                if let Some(controller) = controller.upgrade() {
+                    controller.fullscreen_changed();
+                }
+            });
+        self.fullscreen_notify_handler.replace(Some(handler));
     }
 
     fn open_sibling(&self, forward: bool) {
@@ -876,12 +976,22 @@ impl ViewerController {
 
     fn detach_window_controllers(&self) {
         self.stop_animations();
+        if let Some(timer) = self.seek_hide_timer.borrow_mut().take() {
+            timer.remove();
+        }
+        self.cancel_fullscreen_ui_timer();
+        if let Some(handler) = self.fullscreen_notify_handler.borrow_mut().take() {
+            self.window.disconnect(handler);
+        }
         if let Some(controller) = self.key_controller.borrow_mut().take() {
             self.window.remove_controller(&controller);
         }
         if let Some(controller) = self.motion_controller.borrow_mut().take() {
             self.window.remove_controller(&controller);
         }
+        if let Some(controller) = self.fullscreen_key_controller.borrow_mut().take() {
+            self.window.remove_controller(&controller);
+        }
     }
 
     fn stop_animations(&self) {
@@ -913,7 +1023,11 @@ impl ViewerController {
             return;
         }
         self.last_pointer_position.set(Some((x, y)));
-        self.show_seek_temporarily();
+        if self.window.is_fullscreen() {
+            self.show_fullscreen_ui_temporarily();
+        } else {
+            self.show_seek_temporarily();
+        }
     }
 
     fn hide_seek(self: &Rc<Self>) {
@@ -947,6 +1061,62 @@ impl ViewerController {
         }
     }
 
+    fn fullscreen_changed(self: &Rc<Self>) {
+        self.cancel_fullscreen_ui_timer();
+        self.hide_seek();
+        if self.window.is_fullscreen() {
+            self.set_fullscreen_ui_visible(false);
+        } else {
+            self.fullscreen_ui_visible.set(true);
+            self.titlebar_host.set_visible(true);
+            self.toolbar.set_visible(true);
+            self.status_label.set_visible(true);
+            self.file_list_panel
+                .set_visible(self.file_list_button.is_active());
+        }
+    }
+
+    fn show_fullscreen_ui_temporarily(self: &Rc<Self>) {
+        if !self.window.is_fullscreen() {
+            return;
+        }
+        self.cancel_fullscreen_ui_timer();
+        self.set_fullscreen_ui_visible(true);
+        let controller = Rc::downgrade(self);
+        let timer = glib::timeout_add_local_once(Duration::from_secs(5), move || {
+            if let Some(controller) = controller.upgrade() {
+                controller.fullscreen_ui_hide_timer.borrow_mut().take();
+                controller.set_fullscreen_ui_visible(false);
+            }
+        });
+        self.fullscreen_ui_hide_timer.replace(Some(timer));
+    }
+
+    fn cancel_fullscreen_ui_timer(&self) {
+        if let Some(timer) = self.fullscreen_ui_hide_timer.borrow_mut().take() {
+            timer.remove();
+        }
+    }
+
+    fn set_fullscreen_ui_visible(self: &Rc<Self>, visible: bool) {
+        self.fullscreen_ui_visible.set(visible);
+        self.titlebar_host.set_visible(visible);
+        self.toolbar.set_visible(visible);
+        self.page_seek_row.set_visible(visible);
+        self.status_label.set_visible(visible);
+        self.file_list_panel
+            .set_visible(visible && self.file_list_button.is_active());
+        self.window.queue_allocate();
+        let controller = Rc::downgrade(self);
+        glib::idle_add_local_once(move || {
+            if let Some(controller) = controller.upgrade() {
+                controller.stack.queue_allocate();
+                controller.resize_continuous_rows();
+                controller.render();
+            }
+        });
+    }
+
     fn load_archive(self: &Rc<Self>) {
         self.spinner.start();
         let path = self.source.local_path.clone();
@@ -1727,6 +1897,7 @@ impl MediaViewerWindow {
         });
         install_file_drop_target(&window, file_drop_control);
         ensure_viewer_close_handler(&window);
+        set_viewer_loading(&window, false);
         window.set_title(Some(&title));
         let header = gtk::HeaderBar::new();
         header.set_title_widget(Some(&gtk::Label::new(Some(&title))));
@@ -1752,7 +1923,7 @@ impl MediaViewerWindow {
         header.pack_end(&download_button);
         header.pack_end(&favorite_button);
         header.pack_end(&file_list_button);
-        set_viewer_header(&window, &header);
+        let titlebar_host = set_viewer_header(&window, &header);
 
         let root = gtk::Box::new(gtk::Orientation::Vertical, 0);
         let stack = gtk::Stack::new();
@@ -1816,6 +1987,7 @@ impl MediaViewerWindow {
 
         let controller = Rc::new(MediaViewerController {
             window,
+            titlebar_host,
             source,
             kind,
             picture,
@@ -1845,6 +2017,10 @@ impl MediaViewerWindow {
             last_pointer_position: Cell::new(None),
             key_controller: RefCell::new(None),
             motion_controller: RefCell::new(None),
+            fullscreen_key_controller: RefCell::new(None),
+            fullscreen_ui_hide_timer: RefCell::new(None),
+            fullscreen_ui_visible: Cell::new(false),
+            fullscreen_notify_handler: RefCell::new(None),
             navigation_message,
             navigation_message_label,
             navigation_message_generation: Rc::new(Cell::new(0)),
@@ -1858,6 +2034,7 @@ impl MediaViewerWindow {
             });
         }
         controller.connect_signals();
+        controller.fullscreen_changed();
         if controller.file_list_button.is_active() {
             controller.refresh_file_list();
         }
@@ -1883,6 +2060,7 @@ impl MediaViewerWindow {
 
 struct MediaViewerController {
     window: gtk::ApplicationWindow,
+    titlebar_host: gtk::Box,
     source: ArchiveSource,
     kind: EntryKind,
     picture: gtk::Picture,
@@ -1912,6 +2090,10 @@ struct MediaViewerController {
     last_pointer_position: Cell<Option<(f64, f64)>>,
     key_controller: RefCell<Option<gtk::EventControllerKey>>,
     motion_controller: RefCell<Option<gtk::EventControllerMotion>>,
+    fullscreen_key_controller: RefCell<Option<gtk::EventControllerKey>>,
+    fullscreen_ui_hide_timer: RefCell<Option<glib::SourceId>>,
+    fullscreen_ui_visible: Cell<bool>,
+    fullscreen_notify_handler: RefCell<Option<glib::SignalHandlerId>>,
     navigation_message: gtk::Box,
     navigation_message_label: gtk::Label,
     navigation_message_generation: Rc<Cell<u64>>,
@@ -1930,6 +2112,21 @@ impl MediaViewerController {
         self.window.add_controller(motion_controller.clone());
         self.motion_controller.replace(Some(motion_controller));
 
+        let fullscreen_keys = gtk::EventControllerKey::new();
+        fullscreen_keys.set_propagation_phase(gtk::PropagationPhase::Capture);
+        let controller = Rc::downgrade(self);
+        fullscreen_keys.connect_key_pressed(move |_, _, _, _| {
+            if let Some(controller) = controller.upgrade()
+                && controller.window.is_fullscreen()
+            {
+                controller.show_fullscreen_ui_temporarily();
+            }
+            glib::Propagation::Proceed
+        });
+        self.window.add_controller(fullscreen_keys.clone());
+        self.fullscreen_key_controller
+            .replace(Some(fullscreen_keys));
+
         let keys = gtk::EventControllerKey::new();
         let controller = Rc::downgrade(self);
         keys.connect_key_pressed(move |_, key, _, modifiers| {
@@ -1943,7 +2140,9 @@ impl MediaViewerController {
             ) {
                 return glib::Propagation::Proceed;
             }
-            controller.hide_seek();
+            if !controller.window.is_fullscreen() {
+                controller.hide_seek();
+            }
             match key {
                 gdk::Key::Left if controller.kind == EntryKind::Video => {
                     controller.seek_video(-VIDEO_SEEK_STEP_US);
@@ -2014,6 +2213,15 @@ impl MediaViewerController {
         self.window.add_controller(keys.clone());
         self.key_controller.replace(Some(keys));
         let controller = Rc::downgrade(self);
+        let handler = self
+            .window
+            .connect_notify_local(Some("fullscreened"), move |_, _| {
+                if let Some(controller) = controller.upgrade() {
+                    controller.fullscreen_changed();
+                }
+            });
+        self.fullscreen_notify_handler.replace(Some(handler));
+        let controller = Rc::downgrade(self);
         self.favorite_button.connect_clicked(move |_| {
             if let Some(controller) = controller.upgrade() {
                 let active = (controller.favorite_toggle)();
@@ -2032,7 +2240,11 @@ impl MediaViewerController {
         let controller = Rc::downgrade(self);
         self.file_list_button.connect_toggled(move |button| {
             if let Some(controller) = controller.upgrade() {
-                controller.file_list_panel.set_visible(button.is_active());
+                controller.file_list_panel.set_visible(
+                    button.is_active()
+                        && (!controller.window.is_fullscreen()
+                            || controller.fullscreen_ui_visible.get()),
+                );
                 if button.is_active() {
                     controller.window.add_css_class("viewer-file-list-visible");
                 } else {
@@ -2051,6 +2263,22 @@ impl MediaViewerController {
                 controller.open_file_list_row(row.index());
             }
         });
+        let file_list_typeahead = Rc::new(RefCell::new(TypeaheadBuffer::default()));
+        let file_list_keys = gtk::EventControllerKey::new();
+        let controller = Rc::downgrade(self);
+        file_list_keys.connect_key_pressed(move |_, key, _, modifiers| {
+            let Some(controller) = controller.upgrade() else {
+                return glib::Propagation::Proceed;
+            };
+            file_list_typeahead_select(
+                &controller.file_list,
+                &controller.file_list_files.borrow(),
+                &mut file_list_typeahead.borrow_mut(),
+                key,
+                modifiers,
+            )
+        });
+        self.file_list.add_controller(file_list_keys);
         let file_list_click = gtk::GestureClick::builder().button(3).build();
         let controller = Rc::downgrade(self);
         file_list_click.connect_pressed(move |_, _, x, y| {
@@ -2318,7 +2546,11 @@ impl MediaViewerController {
             return;
         }
         self.last_pointer_position.set(Some((x, y)));
-        self.show_seek_temporarily();
+        if self.window.is_fullscreen() {
+            self.show_fullscreen_ui_temporarily();
+        } else {
+            self.show_seek_temporarily();
+        }
     }
 
     fn hide_seek(self: &Rc<Self>) {
@@ -2377,12 +2609,22 @@ impl MediaViewerController {
 
     fn prepare_for_navigation(&self) {
         self.stop_playback();
+        if let Some(timer) = self.seek_hide_timer.borrow_mut().take() {
+            timer.remove();
+        }
+        self.cancel_fullscreen_ui_timer();
+        if let Some(handler) = self.fullscreen_notify_handler.borrow_mut().take() {
+            self.window.disconnect(handler);
+        }
         if let Some(controller) = self.key_controller.borrow_mut().take() {
             self.window.remove_controller(&controller);
         }
         if let Some(controller) = self.motion_controller.borrow_mut().take() {
             self.window.remove_controller(&controller);
         }
+        if let Some(controller) = self.fullscreen_key_controller.borrow_mut().take() {
+            self.window.remove_controller(&controller);
+        }
     }
 
     fn stop_playback(&self) {
@@ -2400,6 +2642,61 @@ impl MediaViewerController {
         }
     }
 
+    fn fullscreen_changed(self: &Rc<Self>) {
+        self.cancel_fullscreen_ui_timer();
+        self.hide_seek();
+        if self.window.is_fullscreen() {
+            self.set_fullscreen_ui_visible(false);
+        } else {
+            self.fullscreen_ui_visible.set(true);
+            self.titlebar_host.set_visible(true);
+            self.status_label.set_visible(true);
+            self.file_list_panel
+                .set_visible(self.file_list_button.is_active());
+        }
+    }
+
+    fn show_fullscreen_ui_temporarily(self: &Rc<Self>) {
+        if !self.window.is_fullscreen() {
+            return;
+        }
+        self.cancel_fullscreen_ui_timer();
+        self.set_fullscreen_ui_visible(true);
+        let controller = Rc::downgrade(self);
+        let timer = glib::timeout_add_local_once(Duration::from_secs(5), move || {
+            if let Some(controller) = controller.upgrade() {
+                controller.fullscreen_ui_hide_timer.borrow_mut().take();
+                controller.set_fullscreen_ui_visible(false);
+            }
+        });
+        self.fullscreen_ui_hide_timer.replace(Some(timer));
+    }
+
+    fn cancel_fullscreen_ui_timer(&self) {
+        if let Some(timer) = self.fullscreen_ui_hide_timer.borrow_mut().take() {
+            timer.remove();
+        }
+    }
+
+    fn set_fullscreen_ui_visible(self: &Rc<Self>, visible: bool) {
+        self.fullscreen_ui_visible.set(visible);
+        self.titlebar_host.set_visible(visible);
+        self.media_seek_row.set_visible(visible);
+        self.status_label.set_visible(visible);
+        self.file_list_panel
+            .set_visible(visible && self.file_list_button.is_active());
+        self.window.queue_allocate();
+        let controller = Rc::downgrade(self);
+        glib::idle_add_local_once(move || {
+            if let Some(controller) = controller.upgrade() {
+                controller.stack.queue_allocate();
+                controller.picture.queue_allocate();
+                controller.video.queue_allocate();
+                controller.resize_image_picture();
+            }
+        });
+    }
+
     fn load_image(self: &Rc<Self>) {
         self.stack.set_visible_child_name("image");
         self.status_label.set_text("이미지를 읽는 중...");
@@ -2458,6 +2755,85 @@ struct ViewerFileList {
     list: gtk::ListBox,
 }
 
+#[derive(Default)]
+struct TypeaheadBuffer {
+    query: String,
+    last_input: Option<Instant>,
+}
+
+fn file_list_typeahead_select(
+    list: &gtk::ListBox,
+    files: &[SiblingFile],
+    state: &mut TypeaheadBuffer,
+    key: gdk::Key,
+    modifiers: gdk::ModifierType,
+) -> glib::Propagation {
+    let blocked = gdk::ModifierType::CONTROL_MASK
+        | gdk::ModifierType::ALT_MASK
+        | gdk::ModifierType::SUPER_MASK;
+    if modifiers.intersects(blocked) {
+        return glib::Propagation::Proceed;
+    }
+    if key == gdk::Key::Escape {
+        state.query.clear();
+        state.last_input = None;
+        return glib::Propagation::Proceed;
+    }
+    if matches!(key, gdk::Key::space)
+        || key.to_unicode().is_some_and(|character| {
+            character.eq_ignore_ascii_case(&'f') || matches!(character, '[' | ']')
+        })
+    {
+        return glib::Propagation::Proceed;
+    }
+    let now = Instant::now();
+    if state
+        .last_input
+        .is_none_or(|last| now.duration_since(last) > Duration::from_millis(1200))
+    {
+        state.query.clear();
+    }
+    if key == gdk::Key::BackSpace {
+        return if state.query.pop().is_some() {
+            state.last_input = Some(now);
+            glib::Propagation::Stop
+        } else {
+            glib::Propagation::Proceed
+        };
+    }
+    let Some(character) = key.to_unicode().filter(|character| !character.is_control()) else {
+        return glib::Propagation::Proceed;
+    };
+    let input = character.to_lowercase().collect::<String>();
+    let repeated_single = state.query.chars().count() == 1 && state.query == input;
+    if !repeated_single {
+        state.query.push_str(&input);
+    }
+    state.last_input = Some(now);
+    let selected = list.selected_row().map(|row| row.index() as usize);
+    let start = if repeated_single {
+        selected.map_or(0, |index| index + 1)
+    } else {
+        0
+    };
+    let found = find_sibling_prefix(files, &state.query, start);
+    if let Some(row) = found.and_then(|index| list.row_at_index(index as i32)) {
+        list.select_row(Some(&row));
+        let _ = row.grab_focus();
+    }
+    glib::Propagation::Stop
+}
+
+fn find_sibling_prefix(files: &[SiblingFile], query: &str, start: usize) -> Option<usize> {
+    if files.is_empty() {
+        return None;
+    }
+    let query = query.to_lowercase();
+    (0..files.len())
+        .map(|offset| (start + offset) % files.len())
+        .find(|index| files[*index].name.to_lowercase().starts_with(&query))
+}
+
 fn viewer_file_list() -> ViewerFileList {
     let list = gtk::ListBox::new();
     list.set_selection_mode(gtk::SelectionMode::Single);
@@ -2943,6 +3319,19 @@ mod tests {
         assert_eq!(video_volume_target(0.5, 0.05), 0.55);
     }
 
+    #[test]
+    fn viewer_file_typeahead_wraps_by_display_name() {
+        let files = ["Alpha.zip", "beta.jpg", "Bravo.mp4"].map(|name| SiblingFile {
+            uri: format!("file:///{name}"),
+            name: name.into(),
+            kind: EntryKind::Image,
+        });
+
+        assert_eq!(find_sibling_prefix(&files, "br", 0), Some(2));
+        assert_eq!(find_sibling_prefix(&files, "b", 2), Some(2));
+        assert_eq!(find_sibling_prefix(&files, "b", 3), Some(1));
+    }
+
     #[test]
     fn navigation_boundary_messages_match_direction() {
         assert_eq!(

src/window.rs

@@ -1,4 +1,4 @@
-use std::cell::RefCell;
+use std::cell::{Cell, RefCell};
 use std::fs;
 use std::path::{Path, PathBuf};
 use std::rc::Rc;
@@ -17,13 +17,14 @@ use crate::browser::{
 use crate::config::{AppConfig, FavoriteEntry, LocationKind, LocationProfile, ViewerMode};
 use crate::database::Database;
 use crate::source::{
-    display_remote_uri, ensure_mounted, enumerate_directory, file_from_user_input, is_within_root,
+    display_remote_uri, ensure_mounted, enumerate_directory, enumerate_tree_entries,
-    mount_operation, parent_within_root, root_file, validate_profile,
+    file_from_user_input, is_within_root, mount_operation, parent_within_root, root_file,
+    validate_profile,
 };
 use crate::viewer::{
     FavoriteControl, FileDownloadControl, FileDropControl, FileViewerControls, MediaViewerWindow,
     SiblingFile, SiblingFileActions, SiblingNavigator, SiblingTarget, ViewModeControl,
-    ViewerWindow, install_file_drop_target, set_viewer_header,
+    ViewerWindow, install_file_drop_target, set_viewer_header, set_viewer_loading,
 };
 use crate::zip_cache::ZipCache;
 
@@ -94,7 +95,7 @@ impl ComicWindow {
 
         let controls = gtk::Box::new(gtk::Orientation::Horizontal, 6);
         let search_entry = gtk::SearchEntry::builder()
-            .placeholder_text("현재 폴더에서 검색")
+            .placeholder_text("현재 위치 아래 폴더와 ZIP 검색")
             .hexpand(true)
             .build();
         let sort_dropdown = gtk::DropDown::from_strings(&["이름", "수정 시간", "생성 시간"]);
@@ -149,6 +150,10 @@ impl ComicWindow {
                 current_uri: root_uri,
                 entries: Vec::new(),
                 visible_entries: Vec::new(),
+                recursive_entries: Vec::new(),
+                recursive_root_uri: None,
+                recursive_ready: false,
+                recursive_scanning: false,
                 sort_field: SortField::Name,
                 sort_direction: SortDirection::Ascending,
                 generation: 0,
@@ -160,6 +165,8 @@ impl ComicWindow {
             database: Rc::new(database),
             zip_cache,
             listing_task: RefCell::new(None),
+            search_task: RefCell::new(None),
+            search_generation: Cell::new(0),
         });
 
         controller.rebuild_profiles();
@@ -179,6 +186,12 @@ impl ComicWindow {
     pub fn present(&self) {
         self.controller.window.present();
     }
+
+    pub fn open_local_items(&self, files: &[gio::File]) {
+        self.present();
+        self.controller
+            .open_dropped_files(files.to_vec(), self.controller.window.clone().upcast());
+    }
 }
 
 struct BrowserState {
@@ -189,6 +202,10 @@ struct BrowserState {
     current_uri: String,
     entries: Vec<BrowserEntry>,
     visible_entries: Vec<BrowserEntry>,
+    recursive_entries: Vec<BrowserEntry>,
+    recursive_root_uri: Option<String>,
+    recursive_ready: bool,
+    recursive_scanning: bool,
     sort_field: SortField,
     sort_direction: SortDirection,
     generation: u64,
@@ -215,6 +232,8 @@ struct BrowserController {
     database: Rc<Database>,
     zip_cache: Rc<ZipCache>,
     listing_task: RefCell<Option<glib::JoinHandle<()>>>,
+    search_task: RefCell<Option<glib::JoinHandle<()>>>,
+    search_generation: Cell<u64>,
 }
 
 impl BrowserController {
@@ -296,7 +315,7 @@ impl BrowserController {
             .set_list_factory(Some(&location_factory));
         let controller = Rc::clone(self);
         self.search_entry
-            .connect_search_changed(move |_| controller.render());
+            .connect_search_changed(move |_| controller.search_changed());
         let controller = Rc::clone(self);
         self.sort_dropdown
             .connect_selected_notify(move |_| controller.change_sort_field());
@@ -321,7 +340,7 @@ impl BrowserController {
         let key_controller = gtk::EventControllerKey::new();
         let controller = Rc::clone(self);
         key_controller.connect_key_pressed(move |_, key, _, modifiers| {
-            if key == gtk::gdk::Key::BackSpace {
+            if key == gtk::gdk::Key::BackSpace && !controller.typeahead_is_active() {
                 controller.go_up();
                 glib::Propagation::Stop
             } else {
@@ -400,6 +419,7 @@ impl BrowserController {
 
     fn show_favorites(&self) {
         self.cancel_listing();
+        self.cancel_recursive_search();
         self.edit_location_button.set_sensitive(false);
         self.delete_location_button.set_sensitive(false);
         self.path_entry.set_text("즐겨찾기");
@@ -495,6 +515,7 @@ impl BrowserController {
                 .unwrap_or_else(|| BrowserEntry {
                     uri: favorite.uri.clone(),
                     name: favorite.name.clone(),
+                    list_name: None,
                     kind,
                     size: None,
                     modified: None,
@@ -560,6 +581,7 @@ impl BrowserController {
             return;
         }
         self.cancel_listing();
+        self.cancel_recursive_search();
         let (profile, uri, generation) = {
             let mut state = self.state.borrow_mut();
             state.generation = state.generation.wrapping_add(1);
@@ -605,6 +627,9 @@ impl BrowserController {
                 Ok(entries) => {
                     controller.state.borrow_mut().entries = entries;
                     controller.render();
+                    if !controller.search_entry.text().is_empty() {
+                        controller.start_recursive_search();
+                    }
                 }
                 Err(error) => controller.status_label.set_text(&format!("{error:#}")),
             }
@@ -618,6 +643,142 @@ impl BrowserController {
         }
     }
 
+    fn cancel_recursive_search(&self) {
+        if let Some(task) = self.search_task.borrow_mut().take() {
+            task.abort();
+        }
+        self.search_generation
+            .set(self.search_generation.get().wrapping_add(1));
+        let mut state = self.state.borrow_mut();
+        state.recursive_entries.clear();
+        state.recursive_root_uri = None;
+        state.recursive_ready = false;
+        state.recursive_scanning = false;
+    }
+
+    fn search_changed(self: &Rc<Self>) {
+        if self.search_entry.text().is_empty() {
+            self.cancel_recursive_search();
+            self.render();
+            return;
+        }
+        self.render();
+        if !self.state.borrow().browsing_favorites {
+            self.start_recursive_search();
+        }
+    }
+
+    fn start_recursive_search(self: &Rc<Self>) {
+        let (profile, root_uri) = {
+            let mut state = self.state.borrow_mut();
+            if state.browsing_favorites
+                || (state.recursive_root_uri.as_deref() == Some(&state.current_uri)
+                    && (state.recursive_ready || state.recursive_scanning))
+            {
+                return;
+            }
+            let root_uri = state.current_uri.clone();
+            state.recursive_root_uri = Some(root_uri.clone());
+            state.recursive_entries.clear();
+            state.recursive_ready = false;
+            state.recursive_scanning = true;
+            (
+                state
+                    .favorite_profile
+                    .clone()
+                    .unwrap_or_else(|| self.profiles()[state.profile_index].clone()),
+                root_uri,
+            )
+        };
+        if let Some(task) = self.search_task.borrow_mut().take() {
+            task.abort();
+        }
+        let generation = self.search_generation.get().wrapping_add(1);
+        self.search_generation.set(generation);
+        let root = gio::File::for_uri(&root_uri);
+        let location_id = root_file(&profile)
+            .map(|root| root.uri().to_string())
+            .unwrap_or_else(|_| profile.address.clone());
+        if let Ok(cached_entries) = self.database.load_cached_tree(&location_id, &root_uri)
+            && !cached_entries.is_empty()
+        {
+            let mut state = self.state.borrow_mut();
+            state.recursive_entries = cached_entries;
+            state.recursive_ready = true;
+            drop(state);
+            self.render();
+        }
+        let operation = mount_operation(&profile, &self.window);
+        let progress_controller = Rc::downgrade(self);
+        let controller = Rc::downgrade(self);
+        let task = glib::MainContext::default().spawn_local(async move {
+            let result =
+                enumerate_tree_entries(&profile, &root, Some(&operation), move |progress| {
+                    let Some(controller) = progress_controller.upgrade() else {
+                        return;
+                    };
+                    if controller.search_generation.get() == generation
+                        && !controller.search_entry.text().is_empty()
+                    {
+                        controller.status_label.set_text(&format!(
+                            "하위 폴더 검색 색인 생성 중... (폴더 {}개, 항목 {}개)",
+                            progress.directories, progress.scanned
+                        ));
+                    }
+                })
+                .await;
+            let Some(controller) = controller.upgrade() else {
+                return;
+            };
+            if controller.search_generation.get() != generation
+                || controller.state.borrow().current_uri != root_uri
+            {
+                return;
+            }
+            match result {
+                Ok((entries, progress)) => {
+                    let cache_error = (progress.skipped == 0)
+                        .then(|| {
+                            controller.database.replace_cached_tree(
+                                &location_id,
+                                &root_uri,
+                                &entries,
+                            )
+                        })
+                        .transpose()
+                        .err();
+                    let mut state = controller.state.borrow_mut();
+                    state.recursive_entries = entries;
+                    state.recursive_ready = true;
+                    state.recursive_scanning = false;
+                    drop(state);
+                    if !controller.search_entry.text().is_empty() {
+                        controller.render();
+                        if progress.skipped > 0 {
+                            controller.status_label.set_text(&format!(
+                                "검색 결과 생성 완료 · 접근할 수 없는 폴더 {}개 건너뜀",
+                                progress.skipped
+                            ));
+                        } else if let Some(error) = cache_error {
+                            controller
+                                .status_label
+                                .set_text(&format!("검색 색인을 저장할 수 없습니다: {error:#}"));
+                        }
+                    }
+                }
+                Err(error) => {
+                    controller.state.borrow_mut().recursive_scanning = false;
+                    if !controller.search_entry.text().is_empty() {
+                        controller
+                            .status_label
+                            .set_text(&format!("하위 폴더 검색을 완료할 수 없습니다: {error:#}"));
+                    }
+                }
+            }
+        });
+        self.search_task.replace(Some(task));
+    }
+
     fn render(&self) {
         while let Some(child) = self.list_box.first_child() {
             self.list_box.remove(&child);
@@ -625,10 +786,17 @@ impl BrowserController {
         let query = self.search_entry.text().to_lowercase();
         let case_insensitive = self.config.borrow().case_insensitive_sort;
         let mut state = self.state.borrow_mut();
-        let mut visible_entries: Vec<_> = state
+        let recursive_ready = !query.is_empty()
-            .entries
+            && state.recursive_ready
+            && state.recursive_root_uri.as_deref() == Some(&state.current_uri);
+        let source = if recursive_ready {
+            &state.recursive_entries
+        } else {
+            &state.entries
+        };
+        let mut visible_entries: Vec<_> = source
             .iter()
-            .filter(|entry| entry.name.to_lowercase().contains(query.as_str()))
+            .filter(|entry| query.is_empty() || recursive_search_match(entry, query.as_str()))
             .cloned()
             .collect();
         sort_entries(
@@ -642,7 +810,14 @@ impl BrowserController {
         }
         let count = visible_entries.len();
         state.visible_entries = visible_entries;
-        self.status_label.set_text(&format!("{count}개 항목"));
+        let status = if query.is_empty() {
+            format!("{count}개 항목")
+        } else if state.recursive_scanning {
+            format!("현재 폴더 결과 {count}개 · 하위 폴더 색인 생성 중...")
+        } else {
+            format!("하위 폴더 검색 결과 {count}개")
+        };
+        self.status_label.set_text(&status);
     }
 
     fn typeahead(
@@ -656,10 +831,21 @@ impl BrowserController {
         if modifiers.intersects(blocked) {
             return glib::Propagation::Proceed;
         }
-        let Some(character) = key
+        if key == gtk::gdk::Key::Escape {
-            .to_unicode()
+            let mut state = self.state.borrow_mut();
-            .filter(|character| character.is_alphanumeric())
+            state.typeahead_query.clear();
-        else {
+            state.typeahead_last_input = None;
+            return glib::Propagation::Stop;
+        }
+        if key == gtk::gdk::Key::BackSpace {
+            let mut state = self.state.borrow_mut();
+            if state.typeahead_query.pop().is_none() {
+                return glib::Propagation::Proceed;
+            }
+            state.typeahead_last_input = Some(Instant::now());
+            return glib::Propagation::Stop;
+        }
+        let Some(character) = key.to_unicode().filter(|character| !character.is_control()) else {
             return glib::Propagation::Proceed;
         };
 
@@ -686,7 +872,7 @@ impl BrowserController {
             0
         };
         let found = find_prefix_index(&state.visible_entries, &query, start);
-        let found_name = found.map(|index| state.visible_entries[index].name.clone());
+        let found_name = found.map(|index| state.visible_entries[index].display_name().to_owned());
         drop(state);
 
         if let Some(index) = found
@@ -705,6 +891,14 @@ impl BrowserController {
         glib::Propagation::Stop
     }
 
+    fn typeahead_is_active(&self) -> bool {
+        let state = self.state.borrow();
+        !state.typeahead_query.is_empty()
+            && state.typeahead_last_input.is_some_and(|last| {
+                Instant::now().duration_since(last) <= Duration::from_millis(1200)
+            })
+    }
+
     fn change_sort_field(&self) {
         self.state.borrow_mut().sort_field = match self.sort_dropdown.selected() {
             1 => SortField::Modified,
@@ -757,6 +951,23 @@ impl BrowserController {
                 self.refresh();
             }
             EntryKind::ZipArchive | EntryKind::Image | EntryKind::Video => {
+                if !self.search_entry.text().is_empty() && entry.list_name.is_some() {
+                    let siblings = self
+                        .state
+                        .borrow()
+                        .visible_entries
+                        .iter()
+                        .filter(|candidate| candidate.kind.is_viewable())
+                        .cloned()
+                        .collect::<Vec<_>>();
+                    self.open_viewable(
+                        entry.clone(),
+                        Rc::new(siblings),
+                        self.current_profile(),
+                        None,
+                    );
+                    return;
+                }
                 let current_kind = entry.kind;
                 let case_insensitive = self.config.borrow().case_insensitive_sort;
                 let siblings = {
@@ -859,7 +1070,7 @@ impl BrowserController {
                 .iter()
                 .map(|entry| SiblingFile {
                     uri: entry.uri.clone(),
-                    name: entry.name.clone(),
+                    name: entry.display_name().to_owned(),
                     kind: entry.kind,
                 })
                 .collect()
@@ -1075,6 +1286,17 @@ impl BrowserController {
         actions.set_margin_bottom(6);
         actions.set_margin_start(6);
         actions.set_margin_end(6);
+        if entry.kind == EntryKind::Directory {
+            let open_folder_button = gtk::Button::with_label("폴더 열기");
+            actions.append(&open_folder_button);
+            let controller = Rc::clone(self);
+            let popover_to_close = popover.clone();
+            let folder_entry = entry.clone();
+            open_folder_button.connect_clicked(move |_| {
+                popover_to_close.popdown();
+                controller.open_folder_recursive(folder_entry.clone());
+            });
+        }
         if can_favorite {
             let is_favorite = self.is_favorite(&entry.uri);
             let favorite_button = gtk::Button::with_label(if is_favorite {
@@ -1088,7 +1310,7 @@ impl BrowserController {
             let favorite_entry = entry.clone();
             favorite_button.connect_clicked(move |_| {
                 popover_to_close.popdown();
-                let profile = controller.current_profile();
+                let profile = controller.profile_for_entry(&favorite_entry);
                 controller.toggle_favorite(&favorite_entry, &profile);
             });
         }
@@ -1118,6 +1340,96 @@ impl BrowserController {
             .any(|favorite| favorite.uri == uri)
     }
 
+    fn profile_for_entry(&self, entry: &BrowserEntry) -> LocationProfile {
+        if self.state.borrow().browsing_favorites
+            && let Some(profile) = self
+                .config
+                .borrow()
+                .favorites
+                .iter()
+                .find(|favorite| favorite.uri == entry.uri)
+                .map(|favorite| favorite.profile.clone())
+        {
+            return profile;
+        }
+        self.current_profile()
+    }
+
+    fn open_folder_recursive(self: &Rc<Self>, entry: BrowserEntry) {
+        self.cancel_recursive_search();
+        let profile = self.profile_for_entry(&entry);
+        let Ok(profile_root) = root_file(&profile) else {
+            self.status_label
+                .set_text("폴더의 저장된 위치 정보를 확인할 수 없습니다.");
+            return;
+        };
+        let folder = gio::File::for_uri(&entry.uri);
+        if !is_within_root(&folder, &profile_root) {
+            self.status_label
+                .set_text("저장된 위치의 루트 아래 폴더만 열 수 있습니다.");
+            return;
+        }
+        self.cancel_listing();
+        let (generation, sort_field, sort_direction) = {
+            let mut state = self.state.borrow_mut();
+            state.generation = state.generation.wrapping_add(1);
+            (state.generation, state.sort_field, state.sort_direction)
+        };
+        let case_insensitive = self.config.borrow().case_insensitive_sort;
+        self.status_label
+            .set_text("하위 폴더에서 열 수 있는 파일을 찾는 중...");
+        let operation = mount_operation(&profile, &self.window);
+        let progress_controller = Rc::downgrade(self);
+        let controller = Rc::downgrade(self);
+        let task = glib::MainContext::default().spawn_local(async move {
+            let result =
+                enumerate_tree_entries(&profile, &folder, Some(&operation), move |progress| {
+                    let Some(controller) = progress_controller.upgrade() else {
+                        return;
+                    };
+                    if controller.state.borrow().generation == generation {
+                        controller.status_label.set_text(&format!(
+                            "하위 폴더 검색 중... (폴더 {}개, 항목 {}개, 파일 {}개)",
+                            progress.directories, progress.scanned, progress.viewable
+                        ));
+                    }
+                })
+                .await;
+            let Some(controller) = controller.upgrade() else {
+                return;
+            };
+            if controller.state.borrow().generation != generation {
+                return;
+            }
+            match result {
+                Ok((mut entries, progress)) => {
+                    entries.retain(|entry| entry.kind.is_viewable());
+                    sort_entries(&mut entries, sort_field, sort_direction, case_insensitive);
+                    let Some(initial) = entries.first().cloned() else {
+                        controller
+                            .status_label
+                            .set_text("하위 폴더에 열 수 있는 파일이 없습니다.");
+                        return;
+                    };
+                    let skipped = if progress.skipped == 0 {
+                        String::new()
+                    } else {
+                        format!(" · 접근할 수 없는 폴더 {}개 건너뜀", progress.skipped)
+                    };
+                    controller.status_label.set_text(&format!(
+                        "하위 폴더에서 {}개 파일을 찾았습니다{skipped}.",
+                        entries.len()
+                    ));
+                    controller.open_viewable(initial, Rc::new(entries), profile, None);
+                }
+                Err(error) => controller
+                    .status_label
+                    .set_text(&format!("하위 폴더를 열 수 없습니다: {error:#}")),
+            }
+        });
+        self.listing_task.replace(Some(task));
+    }
+
     fn favorite_control(
         self: &Rc<Self>,
         entry: &BrowserEntry,
@@ -1172,12 +1484,13 @@ impl BrowserController {
         }
         let file = file.clone();
         self.cancel_listing();
+        self.cancel_recursive_search();
         let generation = {
             let mut state = self.state.borrow_mut();
             state.generation = state.generation.wrapping_add(1);
             state.generation
         };
-        self.status_label.set_text("드롭한 항목을 확인하는 중...");
+        self.status_label.set_text("열 항목을 확인하는 중...");
         let controller = Rc::downgrade(self);
         let task = glib::MainContext::default().spawn_local(async move {
             let result: Result<_> = async {
@@ -1188,7 +1501,7 @@ impl BrowserController {
                         glib::Priority::DEFAULT,
                     )
                     .await
-                    .context("드롭한 항목을 확인할 수 없습니다")?;
+                    .context("열 항목을 확인할 수 없습니다")?;
                 let selected = match info.file_type() {
                     gio::FileType::Directory => None,
                     gio::FileType::Regular => {
@@ -1221,7 +1534,7 @@ impl BrowserController {
             let (directory, profile, entries, selected) = match result {
                 Ok(result) => result,
                 Err(error) => {
-                    let message = format!("드롭한 항목을 열 수 없습니다: {error:#}");
+                    let message = format!("항목을 열 수 없습니다: {error:#}");
                     controller.status_label.set_text(&message);
                     show_drop_error(&parent, &message);
                     return;
@@ -1236,7 +1549,7 @@ impl BrowserController {
                 .find(|entry| gio::File::for_uri(&entry.uri).equal(&selected))
                 .cloned()
             else {
-                show_drop_error(&parent, "드롭한 파일을 부모 폴더에서 찾을 수 없습니다.");
+                show_drop_error(&parent, "파일을 부모 폴더에서 찾을 수 없습니다.");
                 return;
             };
             let state = controller.state.borrow();
@@ -1248,7 +1561,7 @@ impl BrowserController {
                 controller.config.borrow().case_insensitive_sort,
             ) else {
                 drop(state);
-                show_drop_error(&parent, "드롭한 파일의 목록 위치를 확인할 수 없습니다.");
+                show_drop_error(&parent, "파일의 목록 위치를 확인할 수 없습니다.");
                 return;
             };
             drop(state);
@@ -1792,7 +2105,7 @@ fn entry_row(entry: &BrowserEntry) -> gtk::ListBoxRow {
     content.append(&gtk::Image::from_icon_name(icon));
     content.append(
         &gtk::Label::builder()
-            .label(&entry.name)
+            .label(entry.display_name())
             .hexpand(true)
             .xalign(0.0)
             .ellipsize(gtk::pango::EllipsizeMode::Middle)
@@ -1823,7 +2136,12 @@ fn find_prefix_index(entries: &[BrowserEntry], query: &str, start: usize) -> Opt
     let query = query.to_lowercase();
     (0..entries.len())
         .map(|offset| (start + offset) % entries.len())
-        .find(|index| entries[*index].name.to_lowercase().starts_with(&query))
+        .find(|index| {
+            entries[*index]
+                .display_name()
+                .to_lowercase()
+                .starts_with(&query)
+        })
 }
 
 fn navigable_sibling(current: EntryKind, candidate: EntryKind) -> bool {
@@ -1868,10 +2186,19 @@ fn sorted_navigable_selection(
     Some((entries, selected))
 }
 
+fn recursive_search_match(entry: &BrowserEntry, lowercase_query: &str) -> bool {
+    matches!(entry.kind, EntryKind::Directory | EntryKind::ZipArchive)
+        && entry
+            .display_name()
+            .to_lowercase()
+            .contains(lowercase_query)
+}
+
 fn favorite_browser_entry(favorite: &FavoriteEntry) -> BrowserEntry {
     BrowserEntry {
         uri: favorite.uri.clone(),
         name: favorite.name.clone(),
+        list_name: None,
         kind: if favorite.is_directory {
             EntryKind::Directory
         } else {
@@ -1889,6 +2216,7 @@ fn show_viewer_loading(
     file_name: &str,
     status: &str,
 ) -> gtk::Label {
+    set_viewer_loading(window, true);
     window.set_title(Some(file_name));
     let header = gtk::HeaderBar::new();
     header.set_title_widget(Some(&gtk::Label::new(Some(file_name))));
@@ -1953,6 +2281,7 @@ mod tests {
         BrowserEntry {
             uri: format!("file:///{name}"),
             name: name.into(),
+            list_name: None,
             kind: EntryKind::Directory,
             size: None,
             modified: None,
@@ -2044,6 +2373,19 @@ mod tests {
         assert_eq!(siblings[selected].name, "page10.jpg");
     }
 
+    #[test]
+    fn recursive_search_only_matches_folders_and_zip_names() {
+        let mut folder = entry("Comics");
+        folder.list_name = Some("Archive/Comics".into());
+        let mut zip = media_entry("book.zip");
+        zip.kind = EntryKind::ZipArchive;
+        let image = media_entry("book.jpg");
+
+        assert!(recursive_search_match(&folder, "comics"));
+        assert!(recursive_search_match(&zip, "book"));
+        assert!(!recursive_search_match(&image, "book"));
+    }
+
     #[test]
     fn dropped_directory_creates_local_root_profile() {
         let directory = tempfile::tempdir().unwrap();

src/zip_cache.rs

@@ -375,6 +375,7 @@ mod tests {
         let mut entry = BrowserEntry {
             uri: "sftp://example.invalid/a.zip".into(),
             name: "a.zip".into(),
+            list_name: None,
             kind: EntryKind::ZipArchive,
             size: Some(10),
             modified: None,