Release v0.2.20

.gitignore

@@ -9,3 +9,4 @@
 /dist/*.tar.gz.part-*
 /dist/*.tar.gz.parts.sha256
 /dist/*-install.sh
+/.release-credentials

AGENTS.md

@@ -10,7 +10,7 @@ standalone images, and videos.
 
 - Rust
 - GTK4 with GIO/GVfs for desktop and remote filesystem integration
-- SQLite for cached directory metadata, search indexes, and reading history
+- SQLite for cached directory metadata and reading history
 - AppImage as the primary distribution format
 - Korean-first UI with all user-facing strings kept translatable
 
@@ -38,23 +38,28 @@ standalone images, and videos.
 - Support ascending and descending sorting by name, modification time, and
   creation time. Treat unavailable creation times as unknown rather than
   inventing values.
-- Search folder and ZIP names recursively below the current location using the
+- Filter the currently displayed browser directory by filename and restore all
-  cached index.
+  entries when the search text is cleared.
 - Provide 100%, fit-width, fit-height, two-page, and continuous vertical viewing.
 - Support both right-to-left and left-to-right two-page layouts, plus controls
-  that advance by one page to adjust page pairing.
+  that advance by one page to adjust page pairing. Persist the last selected
+  two-page direction and restore it in newly opened archive viewers.
 - Reuse viewer windows when moving between ZIP, image, and video files. Preserve
   fullscreen state and keep the registered GTK titlebar widget stable while the
   displayed header changes.
 - Provide a toggleable file list on the right side of each viewer. Double-click
   or Enter opens the selected viewable file; its context menu provides favorite
   and download actions.
+- Filter each viewer's current file list with a temporary search field and
+  restore the complete list when the search text is cleared.
 - Accept one local file or folder dropped onto the main window or a viewer.
   Browse dropped folders in the main window; for dropped files, browse the
   parent folder and open the exact naturally sorted item in a new viewer window.
 - Save favorites for local and remote folders and files, and preserve the saved
   location profile needed to reconnect to remote favorites.
 - Save progress per ZIP and save the most recently read ZIP for resume support.
+- Let users update from the About window by downloading the fixed Cafe24 latest
+  bundle and checksum, verifying SHA-256, and reusing the atomic installer.
 
 ## Data Locations
 

Cargo.lock

@@ -182,17 +182,19 @@ checksum = "3d7b894f5411737b7867f4827955924d7c254fc9f4d91a6aad6b097804b1018b"
 
 [[package]]
 name = "comicviewer"
-version = "0.2.6"
+version = "0.2.20"
 dependencies = [
  "anyhow",
  "chrono",
  "filetime",
+ "flate2",
  "gtk4",
  "image",
  "percent-encoding",
  "rusqlite",
  "serde",
  "sha2",
+ "tar",
  "tempfile",
  "toml 0.9.12+spec-1.1.0",
  "zip",
@@ -1211,6 +1213,17 @@ dependencies = [
  "version-compare",
 ]
 
+[[package]]
+name = "tar"
+version = "0.4.46"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3f6221d9a6003c78398e3b239969f352578258df48c8eb051caadae0015bc840"
+dependencies = [
+ "filetime",
+ "libc",
+ "xattr",
+]
+
 [[package]]
 name = "target-lexicon"
 version = "0.13.5"
@@ -1475,6 +1488,16 @@ dependencies = [
  "memchr",
 ]
 
+[[package]]
+name = "xattr"
+version = "1.6.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "32e45ad4206f6d2479085147f02bc2ef834ac85886624a23575ae137c8aa8156"
+dependencies = [
+ "libc",
+ "rustix",
+]
+
 [[package]]
 name = "zerocopy"
 version = "0.8.54"

Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "comicviewer"
-version = "0.2.6"
+version = "0.2.20"
 edition = "2024"
 description = "A comic archive viewer for local and remote locations"
 license = "GPL-3.0-or-later"
@@ -8,14 +8,16 @@ license = "GPL-3.0-or-later"
 [dependencies]
 anyhow = "1.0"
 chrono = { version = "0.4", default-features = false, features = ["clock"] }
-gtk = { package = "gtk4", version = "0.10", features = ["v4_10"] }
+gtk = { package = "gtk4", version = "0.10", features = ["v4_12"] }
 image = { version = "0.25", default-features = false, features = ["avif-native", "bmp", "gif", "jpeg", "png", "webp"] }
 filetime = "0.2"
+flate2 = "1.0"
 percent-encoding = "2.3"
 rusqlite = { version = "0.37", features = ["bundled"] }
 serde = { version = "1.0", features = ["derive"] }
 sha2 = "0.10"
 tempfile = "3.20"
+tar = "0.4"
 toml = "0.9"
 zip = { version = "8", default-features = false, features = ["deflate"] }
 

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

@@ -26,6 +26,20 @@
   </provides>
   <content_rating type="oars-1.1" />
   <releases>
+    <release version="0.2.20" date="2026-08-21" />
+    <release version="0.2.19" date="2026-08-21" />
+    <release version="0.2.18" date="2026-08-21" />
+    <release version="0.2.17" date="2026-08-21" />
+    <release version="0.2.16" date="2026-08-21" />
+    <release version="0.2.15" date="2026-08-21" />
+    <release version="0.2.14" date="2026-08-21" />
+    <release version="0.2.13" date="2026-08-21" />
+    <release version="0.2.12" date="2026-07-29" />
+    <release version="0.2.11" date="2026-07-24" />
+    <release version="0.2.10" date="2026-07-24" />
+    <release version="0.2.9" date="2026-07-24" />
+    <release version="0.2.8" date="2026-07-24" />
+    <release version="0.2.7" date="2026-07-24" />
     <release version="0.2.6" date="2026-07-23" />
     <release version="0.2.5" date="2026-07-23" />
     <release version="0.2.4" date="2026-07-23" />

docs/INSTALL.ko.md

@@ -9,15 +9,16 @@ Comicviewer는 CachyOS와 Arch Linux에서 사용할 수 있는 만화·미디
 설치합니다. 설치 과정에서 `sudo` 암호와 pacman 확인을 요청할 수 있습니다.
 
 ```sh
-sudo pacman -S fuse2 gtk4 dav1d gvfs gvfs-smb gstreamer \
+sudo pacman -S fuse2 gtk4 dav1d gvfs gvfs-smb gstreamer curl \
   gst-plugins-base gst-plugins-good gst-plugins-bad gst-libav
 ```
 
 - `fuse2`: AppImage 마운트 및 실행
-- `gtk4`, `dav1d`: 화면 표시와 이미지 디코딩
+- `gtk4` 4.12 이상, `dav1d`: 화면 표시와 이미지 디코딩
 - `gvfs`: FTP와 SFTP 접근
 - `gvfs-smb`: SMB 공유 접근
 - `gstreamer`, `gst-plugins-*`, `gst-libav`: MP4 등 동영상 재생
+- `curl`: About 창에서 최신 업데이트 다운로드
 
 ## 2. 권장 방법: 통합 번들로 설치 또는 업데이트
 
@@ -82,6 +83,9 @@ Comicviewer는 XDG 표준 경로를 사용합니다.
 - 기본 영구 ZIP 캐시 한도는 10GB이며 오래된 파일부터 자동으로 삭제됩니다.
 - 메인 창의 `캐시 비우기` 버튼으로 현재 열려 있지 않은 ZIP 캐시를 직접 삭제할 수 있습니다.
 - 캐시 한도는 설정 파일의 `cache_quota_gb`로 변경하며, 0은 영구 캐시를 사용하지 않는 값입니다.
+- 메인 창 검색은 현재 표시 중인 폴더의 파일명을 필터링하며, 입력을 지우면 전체 목록을 복원합니다.
+- 위치 목록의 `최근 열어본 파일`은 성공적으로 연 ZIP·이미지·동영상을 최신순으로 최대 100개 보관합니다.
+- 최근 파일 기록에는 원격 위치 재접속 정보가 함께 저장되며 `최근 기록 비우기`로 전체 기록만 삭제할 수 있습니다.
 
 ## 뷰어 조작
 
@@ -89,9 +93,14 @@ Comicviewer는 XDG 표준 경로를 사용합니다.
 - `Home`과 `End`: 폴더의 첫 번째/마지막 파일 열기
 - 동영상에서 `←`와 `→`: 5초 뒤/앞으로 이동
 - 동영상에서 `↑`와 `↓`: 음량을 5%씩 조절
+- 이미지에서 `1`, `2`, `3`, `4`: 폭 맞춤, 높이 맞춤, 2페이지, 100%로 전환 (`3`은 ZIP 뷰어에서 사용)
+- 창보다 크게 표시된 이미지에서 `←`, `→`, `↑`, `↓`: 해당 방향으로 최대 100px 이동
 - `L`: 우측 파일 목록 표시 또는 숨기기
-- 이미지에서 `+`와 `-`: 현재 화면의 이미지를 임시로 10%씩 확대 또는 축소
+- 파일 목록 상단 검색: 현재 재생 목록을 임시로 필터링하며, 입력을 지우면 전체 목록 복원
+- About 창의 `업데이트`: Cafe24에서 최신 번들을 내려받아 검증 후 사용자 영역에 설치
+- 이미지에서 `+`/`=`와 `-`: 현재 화면의 이미지를 임시로 10%씩 확대 또는 축소
 - 이미지에서 `Ctrl` + 마우스 휠: 현재 화면의 이미지를 임시로 10%씩 확대 또는 축소
+- 2페이지의 `좌→우`/`우→좌` 방향은 마지막 선택을 저장해 다음 뷰어에서 복원
 - 전체 화면에서 마우스 클릭: 숨겨진 컨트롤을 5초 동안 표시
 - 전체 화면에서 `←`, `→`, `↑`, `↓`: 컨트롤을 즉시 숨기고 해당 키 동작 실행
 - 파일 목록의 더블클릭 또는 선택 후 `Enter`: 해당 파일 열기

docs/RELEASING.ko.md

@@ -55,7 +55,7 @@ AppImage 빌드가 끝나면 다음 스크립트로 체크섬과 통합 `tar.gz`
 
 스크립트는 `Cargo.toml`에서 버전을 읽고 다음 파일을 생성합니다.
 
-- `dist/Comicviewer-0.2.6-x86_64.AppImage.sha256`
+- `dist/Comicviewer-0.2.20-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 "Release v0.2.6"
+git commit -m "Release v0.2.20"
-git tag -a v0.2.6 -m "Comicviewer v0.2.6"
+git tag -a v0.2.20 -m "Comicviewer v0.2.20"
 git push origin main
-git push origin v0.2.6
+git push origin v0.2.20
 ```
 
 이미 원격에 공개한 태그는 이동하거나 덮어쓰지 않습니다. 수정이 필요하면 새

packaging/install-or-update.sh

@@ -39,7 +39,7 @@ install_dependencies() {
     fi
 
     set --
-    for package in fuse2 gtk4 dav1d gvfs gvfs-smb gstreamer gst-plugins-base \
+    for package in fuse2 gtk4 dav1d gvfs gvfs-smb gstreamer curl gst-plugins-base \
         gst-plugins-good gst-plugins-bad gst-libav; do
         if ! pacman -Q "${package}" >/dev/null 2>&1; then
             set -- "$@" "${package}"

src/config.rs

@@ -12,8 +12,10 @@ pub struct AppConfig {
     pub fast_image_loading: bool,
     pub case_insensitive_sort: bool,
     pub viewer_mode: ViewerMode,
+    pub two_page_right_to_left: bool,
     pub locations: Vec<LocationProfile>,
     pub favorites: Vec<FavoriteEntry>,
+    pub recent_files: Vec<RecentFileEntry>,
 }
 
 impl Default for AppConfig {
@@ -23,8 +25,10 @@ impl Default for AppConfig {
             fast_image_loading: true,
             case_insensitive_sort: true,
             viewer_mode: ViewerMode::FitWidth,
+            two_page_right_to_left: true,
             locations: Vec::new(),
             favorites: Vec::new(),
+            recent_files: Vec::new(),
         }
     }
 }
@@ -50,6 +54,13 @@ pub struct FavoriteEntry {
     pub profile: LocationProfile,
 }
 
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct RecentFileEntry {
+    pub name: String,
+    pub uri: String,
+    pub profile: LocationProfile,
+}
+
 #[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
 #[serde(rename_all = "lowercase")]
 pub enum LocationKind {
@@ -179,6 +190,7 @@ mod tests {
             fast_image_loading: true,
             case_insensitive_sort: true,
             viewer_mode: ViewerMode::FitWidth,
+            two_page_right_to_left: true,
             locations: vec![LocationProfile {
                 name: "테스트".into(),
                 kind: LocationKind::Sftp,
@@ -200,6 +212,18 @@ mod tests {
                     domain: String::new(),
                 },
             }],
+            recent_files: vec![RecentFileEntry {
+                name: "최근 영상.mp4".into(),
+                uri: "sftp://example.invalid/comics/recent.mp4".into(),
+                profile: LocationProfile {
+                    name: "최근 서버".into(),
+                    kind: LocationKind::Sftp,
+                    address: "sftp://example.invalid/comics".into(),
+                    username: "recent-reader".into(),
+                    password: "recent-password".into(),
+                    domain: String::new(),
+                },
+            }],
         };
 
         let encoded = toml::to_string(&config).unwrap();
@@ -207,6 +231,8 @@ mod tests {
         assert_eq!(decoded.locations[0].password, "plain-password");
         assert_eq!(decoded.favorites[0].profile.username, "favorite-reader");
         assert_eq!(decoded.favorites[0].profile.password, "favorite-password");
+        assert_eq!(decoded.recent_files[0].profile.username, "recent-reader");
+        assert_eq!(decoded.recent_files[0].profile.password, "recent-password");
     }
 
     #[test]
@@ -215,7 +241,9 @@ mod tests {
         assert!(decoded.fast_image_loading);
         assert!(decoded.case_insensitive_sort);
         assert_eq!(decoded.viewer_mode, ViewerMode::FitWidth);
+        assert!(decoded.two_page_right_to_left);
         assert!(decoded.favorites.is_empty());
+        assert!(decoded.recent_files.is_empty());
     }
 
     #[test]
@@ -231,4 +259,17 @@ mod tests {
         }
         assert_eq!(ViewerMode::from_dropdown_index(99), ViewerMode::FitWidth);
     }
+
+    #[test]
+    fn two_page_direction_defaults_to_rtl_and_round_trips_ltr() {
+        let existing: AppConfig = toml::from_str("cache_quota_gb = 10\n").unwrap();
+        assert!(existing.two_page_right_to_left);
+
+        let config = AppConfig {
+            two_page_right_to_left: false,
+            ..AppConfig::default()
+        };
+        let decoded: AppConfig = toml::from_str(&toml::to_string(&config).unwrap()).unwrap();
+        assert!(!decoded.two_page_right_to_left);
+    }
 }

src/database.rs

@@ -2,11 +2,8 @@ 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,
 }
@@ -108,124 +105,6 @@ 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)]
@@ -243,51 +122,4 @@ 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/source.rs

@@ -16,6 +16,32 @@ const RECURSIVE_ATTRIBUTES: &str = "standard::display-name,standard::name,standa
 const MAX_RECURSIVE_DIRECTORIES: usize = 10_000;
 const MAX_RECURSIVE_ENTRIES: usize = 100_000;
 
+#[derive(Default)]
+struct EnumerationProgress {
+    seen: HashSet<String>,
+    new_in_batch: usize,
+}
+
+impl EnumerationProgress {
+    fn begin_batch(&mut self) {
+        self.new_in_batch = 0;
+    }
+
+    fn record(&mut self, uri: String) -> bool {
+        let inserted = self.seen.insert(uri);
+        self.new_in_batch += usize::from(inserted);
+        inserted
+    }
+
+    fn repeated_batch(&self) -> bool {
+        self.new_in_batch == 0
+    }
+
+    fn len(&self) -> usize {
+        self.seen.len()
+    }
+}
+
 #[derive(Clone, Copy, Default)]
 pub struct RecursiveProgress {
     pub directories: usize,
@@ -112,7 +138,7 @@ where
         }
     };
     let mut entries = Vec::new();
-    let mut scanned = 0;
+    let mut enumeration = EnumerationProgress::default();
 
     loop {
         let batch = enumerator
@@ -121,19 +147,21 @@ where
         if batch.is_empty() {
             break;
         }
-        scanned += batch.len();
+        enumeration.begin_batch();
-        progress(scanned);
         for info in batch {
+            let child = enumerator.child(&info);
+            let uri: String = info
+                .attribute_string("standard::target-uri")
+                .map_or_else(|| child.uri().into(), Into::into);
+            if !enumeration.record(uri.clone()) {
+                continue;
+            }
             let kind = match info.file_type() {
                 gio::FileType::Directory => EntryKind::Directory,
                 gio::FileType::Mountable | gio::FileType::Shortcut => EntryKind::Directory,
                 gio::FileType::Regular => classify_file(Path::new(info.display_name().as_str())),
                 _ => continue,
             };
-            let child = enumerator.child(&info);
-            let uri = info
-                .attribute_string("standard::target-uri")
-                .map_or_else(|| child.uri().into(), Into::into);
             entries.push(BrowserEntry {
                 uri,
                 name: info.display_name().into(),
@@ -153,6 +181,10 @@ where
                     .map(Into::into),
             });
         }
+        if enumeration.repeated_batch() {
+            break;
+        }
+        progress(enumeration.len());
     }
     Ok(entries)
 }
@@ -449,6 +481,26 @@ mod tests {
         assert!(encoded_input.equal(&encoded));
     }
 
+    #[test]
+    fn enumeration_allows_large_unique_directories_and_stops_repeated_batches() {
+        let mut enumeration = EnumerationProgress::default();
+        for batch_start in (0..330_001).step_by(128) {
+            enumeration.begin_batch();
+            for index in batch_start..(batch_start + 128).min(330_001) {
+                assert!(enumeration.record(format!("smb://server/share/file-{index}")));
+            }
+            assert!(!enumeration.repeated_batch());
+        }
+        assert_eq!(enumeration.len(), 330_001);
+
+        enumeration.begin_batch();
+        for index in 0..128 {
+            assert!(!enumeration.record(format!("smb://server/share/file-{index}")));
+        }
+        assert!(enumeration.repeated_batch());
+        assert_eq!(enumeration.len(), 330_001);
+    }
+
     #[test]
     fn recursively_lists_viewable_files_without_following_symlinks() {
         let directory = tempfile::tempdir().unwrap();