.gitignore

@@ -9,4 +9,3 @@
 /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 and reading history
+- SQLite for cached directory metadata, search indexes, and reading history
 - AppImage as the primary distribution format
 - Korean-first UI with all user-facing strings kept translatable
 
@@ -38,28 +38,23 @@ 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.
-- Filter the currently displayed browser directory by filename and restore all
+- Search folder and ZIP names recursively below the current location using the
-  entries when the search text is cleared.
+  cached index.
 - 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. Persist the last selected
+  that advance by one page to adjust page pairing.
-  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,19 +182,17 @@ checksum = "3d7b894f5411737b7867f4827955924d7c254fc9f4d91a6aad6b097804b1018b"
 
 [[package]]
 name = "comicviewer"
-version = "0.2.20"
+version = "0.2.6"
 dependencies = [
  "anyhow",
  "chrono",
  "filetime",
- "flate2",
  "gtk4",
  "image",
  "percent-encoding",
  "rusqlite",
  "serde",
  "sha2",
- "tar",
  "tempfile",
  "toml 0.9.12+spec-1.1.0",
  "zip",
@@ -1213,17 +1211,6 @@ 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"
@@ -1488,16 +1475,6 @@ 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.20"
+version = "0.2.6"
 edition = "2024"
 description = "A comic archive viewer for local and remote locations"
 license = "GPL-3.0-or-later"
@@ -8,16 +8,14 @@ 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_12"] }
+gtk = { package = "gtk4", version = "0.10", features = ["v4_10"] }
 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,20 +26,6 @@
   </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,16 +9,15 @@ Comicviewer는 CachyOS와 Arch Linux에서 사용할 수 있는 만화·미디
 설치합니다. 설치 과정에서 `sudo` 암호와 pacman 확인을 요청할 수 있습니다.
 
 ```sh
-sudo pacman -S fuse2 gtk4 dav1d gvfs gvfs-smb gstreamer curl \
+sudo pacman -S fuse2 gtk4 dav1d gvfs gvfs-smb gstreamer \
   gst-plugins-base gst-plugins-good gst-plugins-bad gst-libav
 ```
 
 - `fuse2`: AppImage 마운트 및 실행
-- `gtk4` 4.12 이상, `dav1d`: 화면 표시와 이미지 디코딩
+- `gtk4`, `dav1d`: 화면 표시와 이미지 디코딩
 - `gvfs`: FTP와 SFTP 접근
 - `gvfs-smb`: SMB 공유 접근
 - `gstreamer`, `gst-plugins-*`, `gst-libav`: MP4 등 동영상 재생
-- `curl`: About 창에서 최신 업데이트 다운로드
 
 ## 2. 권장 방법: 통합 번들로 설치 또는 업데이트
 
@@ -83,9 +82,6 @@ Comicviewer는 XDG 표준 경로를 사용합니다.
 - 기본 영구 ZIP 캐시 한도는 10GB이며 오래된 파일부터 자동으로 삭제됩니다.
 - 메인 창의 `캐시 비우기` 버튼으로 현재 열려 있지 않은 ZIP 캐시를 직접 삭제할 수 있습니다.
 - 캐시 한도는 설정 파일의 `cache_quota_gb`로 변경하며, 0은 영구 캐시를 사용하지 않는 값입니다.
-- 메인 창 검색은 현재 표시 중인 폴더의 파일명을 필터링하며, 입력을 지우면 전체 목록을 복원합니다.
-- 위치 목록의 `최근 열어본 파일`은 성공적으로 연 ZIP·이미지·동영상을 최신순으로 최대 100개 보관합니다.
-- 최근 파일 기록에는 원격 위치 재접속 정보가 함께 저장되며 `최근 기록 비우기`로 전체 기록만 삭제할 수 있습니다.
 
 ## 뷰어 조작
 
@@ -93,14 +89,9 @@ 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.20-x86_64.AppImage.sha256`
+- `dist/Comicviewer-0.2.6-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.20"
+git commit -m "Release v0.2.6"
-git tag -a v0.2.20 -m "Comicviewer v0.2.20"
+git tag -a v0.2.6 -m "Comicviewer v0.2.6"
 git push origin main
-git push origin v0.2.20
+git push origin v0.2.6
 ```
 
 이미 원격에 공개한 태그는 이동하거나 덮어쓰지 않습니다. 수정이 필요하면 새

packaging/install-or-update.sh

@@ -39,7 +39,7 @@ install_dependencies() {
     fi
 
     set --
-    for package in fuse2 gtk4 dav1d gvfs gvfs-smb gstreamer curl gst-plugins-base \
+    for package in fuse2 gtk4 dav1d gvfs gvfs-smb gstreamer 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,10 +12,8 @@ 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 {
@@ -25,10 +23,8 @@ 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(),
         }
     }
 }
@@ -54,13 +50,6 @@ 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 {
@@ -190,7 +179,6 @@ 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,
@@ -212,18 +200,6 @@ 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();
@@ -231,8 +207,6 @@ 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]
@@ -241,9 +215,7 @@ 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]
@@ -259,17 +231,4 @@ 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,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/source.rs

@@ -16,32 +16,6 @@ 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,
@@ -138,7 +112,7 @@ where
         }
     };
     let mut entries = Vec::new();
-    let mut enumeration = EnumerationProgress::default();
+    let mut scanned = 0;
 
     loop {
         let batch = enumerator
@@ -147,21 +121,19 @@ where
         if batch.is_empty() {
             break;
         }
-        enumeration.begin_batch();
+        scanned += batch.len();
+        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(),
@@ -181,10 +153,6 @@ where
                     .map(Into::into),
             });
         }
-        if enumeration.repeated_batch() {
-            break;
-        }
-        progress(enumeration.len());
     }
     Ok(entries)
 }
@@ -481,26 +449,6 @@ 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();