Add deep scan page browsing

backend/app.py

@@ -206,6 +206,11 @@ async def init_db():
             {
                 "sql": "CREATE TABLE IF NOT EXISTS pi_scans (post_id TEXT PRIMARY KEY, url TEXT, exif_type INTEGER)"
             },
+            {
+                "sql": "CREATE TABLE IF NOT EXISTS pi_scan_pages ("
+                "post_id TEXT, page INTEGER, url TEXT, exif_type INTEGER, "
+                "PRIMARY KEY (post_id, page))"
+            },
             {"sql": "CREATE TABLE IF NOT EXISTS pi_meta (key TEXT PRIMARY KEY, value TEXT)"},
             {
                 "sql": "CREATE TABLE IF NOT EXISTS pi_cache (key TEXT PRIMARY KEY, value TEXT, updated_at INTEGER)"
@@ -227,6 +232,8 @@ async def init_db():
         "ALTER TABLE pi_searches DROP COLUMN created_at",
         "ALTER TABLE pi_searches ADD COLUMN found_exif INTEGER DEFAULT 0",
         "ALTER TABLE pi_searches ADD COLUMN total_searched INTEGER DEFAULT 0",
+        "ALTER TABLE pi_searches ADD COLUMN deep_scan INTEGER DEFAULT 0",
+        "ALTER TABLE pi_scans ADD COLUMN deep_scanned INTEGER DEFAULT 0",
     ):
         try:
             await turso_execute([{"sql": sql}])
@@ -355,16 +362,17 @@ def get_search_api_url(raw, keywords):
     return f"https://www.pixiv.net/ajax/search/artworks/{encoded}?{params}"
 
 
-async def save_search(search_id, post_ids):
+async def save_search(search_id, post_ids, deep_scan=False):
     if not post_ids:
         return
     if task_canceled(search_id):
         raise TaskCanceled()
     stmt = {
-        "sql": "INSERT OR REPLACE INTO pi_searches (id, post_ids) VALUES (?, ?)",
+        "sql": "INSERT OR REPLACE INTO pi_searches (id, post_ids, deep_scan) VALUES (?, ?, ?)",
         "args": [
             {"type": "text", "value": search_id},
             {"type": "text", "value": json.dumps(post_ids)},
+            {"type": "integer", "value": "1" if deep_scan else "0"},
         ],
     }
     await turso_execute([stmt])
@@ -680,6 +688,32 @@ async def get_unscanned_post_ids(search_id):
     return [cell_value(row, 0, "") for row in first_rows(resp) if cell_value(row, 0, "")]
 
 
+async def get_deep_scan_targets(search_id):
+    resp = await turso_execute(
+        [
+            {
+                "sql": "WITH ids AS ("
+                "SELECT CAST(j.value AS TEXT) post_id, CAST(j.key AS INTEGER) pos "
+                "FROM pi_searches p, json_each(p.post_ids) j WHERE p.id = ?"
+                ") SELECT ids.post_id, s.url, s.exif_type FROM ids "
+                "JOIN pi_scans s ON s.post_id = ids.post_id "
+                "WHERE s.exif_type IS NOT NULL AND COALESCE(s.deep_scanned, 0) = 0 "
+                "ORDER BY ids.pos",
+                "args": [{"type": "text", "value": search_id}],
+            }
+        ]
+    )
+    return [
+        {
+            "post_id": cell_value(row, 0, ""),
+            "url": cell_value(row, 1, ""),
+            "exif_type": int(cell_value(row, 2, "0")),
+        }
+        for row in first_rows(resp)
+        if cell_value(row, 0, "")
+    ]
+
+
 async def get_incomplete_search_ids():
     resp = await turso_execute(
         [
@@ -689,13 +723,30 @@ async def get_incomplete_search_ids():
                 "FROM pi_searches p JOIN json_each(p.post_ids) j "
                 "LEFT JOIN pi_scans s ON s.post_id = CAST(j.value AS TEXT) "
                 "GROUP BY p.id"
-                ") SELECT id FROM counts WHERE total > scanned ORDER BY id",
+                ") SELECT p.id FROM pi_searches p JOIN counts ON counts.id = p.id "
+                "WHERE total > scanned OR (COALESCE(p.deep_scan, 0) = 1 AND EXISTS ("
+                "SELECT 1 FROM json_each(p.post_ids) j JOIN pi_scans s "
+                "ON s.post_id = CAST(j.value AS TEXT) WHERE s.exif_type IS NOT NULL "
+                "AND COALESCE(s.deep_scanned, 0) = 0)) ORDER BY p.id",
             }
         ]
     )
     return [cell_value(row, 0, "") for row in first_rows(resp) if cell_value(row, 0, "")]
 
 
+async def search_uses_deep_scan(search_id):
+    resp = await turso_execute(
+        [
+            {
+                "sql": "SELECT deep_scan FROM pi_searches WHERE id = ?",
+                "args": [{"type": "text", "value": search_id}],
+            }
+        ]
+    )
+    rows = first_rows(resp)
+    return bool(rows and int(cell_value(rows[0], 0, "0")))
+
+
 async def get_refresh_search_ids():
     resp = await turso_execute(
         [
@@ -800,6 +851,28 @@ def decrypt_log(value):
     return json.loads(data.decode())
 
 
+async def get_result_pages(post_ids):
+    if not post_ids:
+        return {}
+    pages = {}
+    for i in range(0, len(post_ids), 500):
+        chunk = post_ids[i : i + 500]
+        marks = ",".join("?" for _ in chunk)
+        resp = await turso_execute(
+            [
+                {
+                    "sql": f"SELECT post_id, page FROM pi_scan_pages WHERE post_id IN ({marks}) ORDER BY post_id, page",
+                    "args": [{"type": "text", "value": str(pid)} for pid in chunk],
+                }
+            ]
+        )
+        for row in first_rows(resp):
+            pages.setdefault(cell_value(row, 0, ""), []).append(
+                int(cell_value(row, 1, "0"))
+            )
+    return pages
+
+
 async def get_result_page(search_id, page, allowed):
     where_sql, filter_args = result_filter_sql(allowed)
     page = max(page, 1)
@@ -858,11 +931,13 @@ async def get_result_page(search_id, page, allowed):
         int(cell_value(row, 0, "0")): int(cell_value(row, 1, "0"))
         for row in type_rows
     }
+    result_pages = await get_result_pages([cell_value(row, 0, "") for row in item_rows])
     items = []
     for row in item_rows:
         pid = cell_value(row, 0, "")
         url = cell_value(row, 2, "")
         exif_type = cell_value(row, 3)
+        pages = result_pages.get(pid) or [page_num_from_url(url)]
         items.append(
             {
                 "post_id": pid,
@@ -870,6 +945,8 @@ async def get_result_page(search_id, page, allowed):
                 "url": url,
                 "exif_type": int(exif_type) if exif_type else None,
                 "scanned": True,
+                "pages": pages,
+                "page_count": len(pages),
                 **image_links(pid, url),
             }
         )
@@ -889,7 +966,7 @@ def user_search_id(user_id):
     return f"{base26_time()}_{user_id}"
 
 
-async def pixiv_search_live(url, pages, mode, phpsessid, search_id):
+async def pixiv_search_live(url, pages, mode, phpsessid, search_id, deep_scan=False):
     keywords = get_search_keywords(url)
     api_url = get_search_api_url(url, keywords)
     first_url = f"{api_url}&p=1"
@@ -936,7 +1013,7 @@ async def pixiv_search_live(url, pages, mode, phpsessid, search_id):
                 if done % 25 == 0:
                     if task_canceled(search_id):
                         raise TaskCanceled()
-                    await save_search(search_id, post_ids)
+                    await save_search(search_id, post_ids, deep_scan)
         finally:
             for task in tasks:
                 if not task.done():
@@ -944,7 +1021,7 @@ async def pixiv_search_live(url, pages, mode, phpsessid, search_id):
             await asyncio.gather(*tasks, return_exceptions=True)
     if task_canceled(search_id):
         raise TaskCanceled()
-    await save_search(search_id, post_ids)
+    await save_search(search_id, post_ids, deep_scan)
     return post_ids, keywords, first_url
 
 
@@ -1412,6 +1489,52 @@ async def scan_post(post_id, session, post_sem, exif_sem, img_sem):
             return post_id, None, None
 
 
+async def scan_page_result(post_id, url, session, exif_sem, img_sem):
+    metadata = await get_exif_range(url, session, exif_sem)
+    exif_type = determine_exif_type(metadata)
+    fallback = EXIF_TYPE_TO_CODE.get(exif_type) if exif_type in FALLBACK_EXIF_TYPES else None
+    if exif_type and not fallback:
+        return post_id, url, EXIF_TYPE_TO_CODE.get(exif_type)
+    img_data = await fetch_image(session, url, img_sem)
+    if not img_data:
+        return (post_id, url, fallback) if fallback else None
+    exif_type = determine_exif_type(parse_image_metadata(img_data))
+    if exif_type in FALLBACK_EXIF_TYPES:
+        fallback = fallback or EXIF_TYPE_TO_CODE.get(exif_type)
+    elif exif_type:
+        return post_id, url, EXIF_TYPE_TO_CODE.get(exif_type)
+    metadata, detected = parse_stealth_metadata(img_data)
+    exif_type = determine_exif_type(metadata)
+    if exif_type in FALLBACK_EXIF_TYPES:
+        fallback = fallback or EXIF_TYPE_TO_CODE.get(exif_type)
+    elif exif_type:
+        return post_id, url, EXIF_TYPE_TO_CODE.get(exif_type)
+    if detected:
+        return post_id, url, EXIF_TYPE_TO_CODE.get("stealth")
+    return (post_id, url, fallback) if fallback else None
+
+
+async def deep_scan_post(item, session, post_sem, exif_sem, img_sem):
+    async with post_sem:
+        try:
+            post_id = item["post_id"]
+            pages = await get_post_pages(post_id, session)
+            first_page = page_num_from_url(item["url"])
+            results = [(post_id, first_page, item["url"], item["exif_type"])]
+            for page in range(len(pages)):
+                if page == first_page:
+                    continue
+                url = pages[page]["original"]
+                if image_ext(url) not in METADATA_EXTS:
+                    continue
+                result = await scan_page_result(post_id, url, session, exif_sem, img_sem)
+                if result:
+                    results.append((post_id, page, result[1], result[2]))
+            return post_id, results
+        except Exception:
+            return None
+
+
 async def get_exif_range(url, session, sem):
     hdrs = {
         "Referer": "https://www.pixiv.net/",
@@ -1506,10 +1629,62 @@ async def run_scan(post_ids, phpsessid, task_id=None, save_live=False, done_offs
     return results
 
 
+async def run_deep_scan(targets, phpsessid, task_id=None):
+    post_sem = asyncio.Semaphore(POST_SCAN_LIMIT)
+    exif_sem = asyncio.Semaphore(EXIF_RANGE_LIMIT)
+    img_sem = asyncio.Semaphore(FULL_IMAGE_LIMIT)
+    cookies = {"PHPSESSID": phpsessid}
+    completed = 0
+    pending = []
+    async with aiohttp.ClientSession(cookies=cookies, headers=PIXIV_HEADERS) as session:
+        tasks = {
+            asyncio.create_task(deep_scan_post(item, session, post_sem, exif_sem, img_sem))
+            for item in targets
+        }
+        created = set(tasks)
+        if task_id:
+            TASK_SCAN_TASKS.setdefault(task_id, set()).update(tasks)
+        try:
+            while tasks:
+                if task_canceled(task_id):
+                    raise TaskCanceled()
+                done, tasks = await asyncio.wait(
+                    tasks, timeout=1, return_when=asyncio.FIRST_COMPLETED
+                )
+                if task_canceled(task_id):
+                    raise TaskCanceled()
+                for task in done:
+                    result = task.result()
+                    completed += 1
+                    if result:
+                        pending.append(result)
+                    if task_id and task_id in ACTIVE_TASKS:
+                        ACTIVE_TASKS[task_id]["done"] = completed
+                    if len(pending) >= 20:
+                        await save_deep_scan_results(pending)
+                        pending = []
+            if pending:
+                await save_deep_scan_results(pending)
+        finally:
+            for task in created:
+                task.cancel()
+            await asyncio.gather(*created, return_exceptions=True)
+            if task_id and task_id in TASK_SCAN_TASKS:
+                TASK_SCAN_TASKS[task_id].difference_update(created)
+                if not TASK_SCAN_TASKS[task_id]:
+                    TASK_SCAN_TASKS.pop(task_id, None)
+
+
 async def save_scan_results(results):
     stmts = []
     for post_id, url, exif_type in results:
         short_url = url.replace(IMG_BASE, "", 1) if url else ""
+        stmts.append(
+            {
+                "sql": "DELETE FROM pi_scan_pages WHERE post_id = ?",
+                "args": [{"type": "text", "value": str(post_id)}],
+            }
+        )
         stmts.append(
             {
                 "sql": "INSERT OR REPLACE INTO pi_scans (post_id, url, exif_type) VALUES (?, ?, ?)",
@@ -1527,6 +1702,32 @@ async def save_scan_results(results):
             await turso_batch(stmts[i : i + 200])
 
 
+async def save_deep_scan_results(results):
+    stmts = []
+    for post_id, pages in results:
+        for _, page, url, exif_type in pages:
+            short_url = url.replace(IMG_BASE, "", 1) if url else ""
+            stmts.append(
+                {
+                    "sql": "INSERT OR REPLACE INTO pi_scan_pages (post_id, page, url, exif_type) VALUES (?, ?, ?, ?)",
+                    "args": [
+                        {"type": "text", "value": str(post_id)},
+                        {"type": "integer", "value": str(page)},
+                        {"type": "text", "value": short_url},
+                        {"type": "integer", "value": str(exif_type)},
+                    ],
+                }
+            )
+        stmts.append(
+            {
+                "sql": "UPDATE pi_scans SET deep_scanned = 1 WHERE post_id = ?",
+                "args": [{"type": "text", "value": str(post_id)}],
+            }
+        )
+    for i in range(0, len(stmts), 200):
+        await turso_batch(stmts[i : i + 200])
+
+
 async def get_reclass_targets(allowed):
     where_sql, args = scan_filter_sql(allowed)
     resp = await turso_execute(
@@ -1778,7 +1979,17 @@ async def bg_search_task(search_id, url, pages, mode, phpsessid):
         await finish_task(search_id)
 
 
-async def bg_user_task(search_id, user_id, phpsessid):
+async def deep_scan_search(search_id, phpsessid):
+    targets = await get_deep_scan_targets(search_id)
+    if not targets:
+        return
+    ACTIVE_TASKS[search_id].update(
+        {"phase": "deep scanning", "total": len(targets), "done": 0, "raw_total": 0}
+    )
+    await run_deep_scan(targets, phpsessid, task_id=search_id)
+
+
+async def bg_user_task(search_id, user_id, phpsessid, deep_scan=False):
     if not start_task(search_id, {
         "type": "user_search",
         "phase": "searching",
@@ -1797,7 +2008,7 @@ async def bg_user_task(search_id, user_id, phpsessid):
         ACTIVE_TASKS[search_id]["done"] = 1
         if not post_ids:
             return
-        await save_search(search_id, post_ids)
+        await save_search(search_id, post_ids, deep_scan)
         to_scan = await get_unscanned_post_ids(search_id)
         if to_scan:
             ACTIVE_TASKS[search_id].update({
@@ -1805,6 +2016,8 @@ async def bg_user_task(search_id, user_id, phpsessid):
                 **await scan_progress_counts(search_id, len(to_scan)),
             })
             await run_scan(to_scan, phpsessid, task_id=search_id, save_live=True)
+        if deep_scan:
+            await deep_scan_search(search_id, phpsessid)
         await update_search_stats(search_id)
         await patch_explorer_cache(search_id, front=True)
     except TaskCanceled:
@@ -1815,13 +2028,16 @@ async def bg_user_task(search_id, user_id, phpsessid):
         await finish_task(search_id)
 
 
-async def bg_user_batch_task(jobs, phpsessid):
+async def bg_user_batch_task(jobs, phpsessid, deep_scan=False):
     await asyncio.gather(
-        *(bg_user_task(search_id, user_id, phpsessid) for search_id, user_id in jobs)
+        *(
+            bg_user_task(search_id, user_id, phpsessid, deep_scan)
+            for search_id, user_id in jobs
+        )
     )
 
 
-async def bg_scan_task(search_id, post_ids, phpsessid):
+async def bg_scan_task(search_id, post_ids, phpsessid, deep_scan=False):
     if not start_task(search_id, {
         "type": "scan",
         "phase": "scanning",
@@ -1832,6 +2048,8 @@ async def bg_scan_task(search_id, post_ids, phpsessid):
     completed = False
     try:
         await run_scan(post_ids, phpsessid, task_id=search_id, save_live=True)
+        if deep_scan:
+            await deep_scan_search(search_id, phpsessid)
         await update_search_stats(search_id)
         await patch_explorer_cache(search_id)
         completed = True
@@ -1846,7 +2064,9 @@ async def bg_scan_task(search_id, post_ids, phpsessid):
         await finish_task(search_id)
 
 
-async def bg_search_and_scan_task(search_id, url, pages, mode, phpsessid):
+async def bg_search_and_scan_task(
+    search_id, url, pages, mode, phpsessid, deep_scan=False
+):
     if not start_task(search_id, {
         "type": "search+scan",
         "phase": "searching",
@@ -1857,7 +2077,9 @@ async def bg_search_and_scan_task(search_id, url, pages, mode, phpsessid):
         return
     completed = False
     try:
-        await pixiv_search_live(url, pages, mode, phpsessid, search_id)
+        await pixiv_search_live(
+            url, pages, mode, phpsessid, search_id, deep_scan
+        )
         to_scan = await get_unscanned_post_ids(search_id)
         if to_scan:
             ACTIVE_TASKS[search_id].update({
@@ -1865,6 +2087,8 @@ async def bg_search_and_scan_task(search_id, url, pages, mode, phpsessid):
                 **await scan_progress_counts(search_id, len(to_scan)),
             })
             await run_scan(to_scan, phpsessid, task_id=search_id, save_live=True)
+        if deep_scan:
+            await deep_scan_search(search_id, phpsessid)
         await update_search_stats(search_id)
         await patch_explorer_cache(search_id, front=True)
         completed = True
@@ -1956,11 +2180,13 @@ class SearchRequest(BaseModel):
     pages: int = 30
     mode: str = "ai"
     action: str = "search"
+    deep_scan: bool = False
 
 
 class UserSearchRequest(BaseModel):
     user_ids: list
     action: str = "search"
+    deep_scan: bool = False
 
 
 class PostSearchRequest(BaseModel):
@@ -2031,8 +2257,11 @@ async def resume_incomplete_scans():
             if search_id in ACTIVE_TASKS:
                 continue
             post_ids = await get_unscanned_post_ids(search_id)
-            if post_ids:
-                asyncio.create_task(bg_scan_task(search_id, post_ids, PHPSESSID))
+            deep_scan = await search_uses_deep_scan(search_id)
+            if post_ids or deep_scan:
+                asyncio.create_task(
+                    bg_scan_task(search_id, post_ids, PHPSESSID, deep_scan)
+                )
                 started += 1
             else:
                 await update_search_stats(search_id)
@@ -2127,7 +2356,13 @@ async def submit_search(req: SearchRequest, bg: BackgroundTasks):
     search_id = base26_time()
     phpsessid = PHPSESSID
     bg.add_task(
-        bg_search_and_scan_task, search_id, req.url, req.pages, req.mode, phpsessid
+        bg_search_and_scan_task,
+        search_id,
+        req.url,
+        req.pages,
+        req.mode,
+        phpsessid,
+        req.deep_scan,
     )
     return {"id": search_id, "status": "started"}
 
@@ -2137,7 +2372,7 @@ async def submit_users(req: UserSearchRequest, bg: BackgroundTasks):
     phpsessid = PHPSESSID
     user_ids = list(dict.fromkeys(int(u) for u in req.user_ids))
     jobs = [(user_search_id(uid), uid) for uid in user_ids]
-    bg.add_task(bg_user_batch_task, jobs, phpsessid)
+    bg.add_task(bg_user_batch_task, jobs, phpsessid, req.deep_scan)
     return {"ids": [search_id for search_id, _ in jobs], "status": "started"}
 
 

frontend/app.js

@@ -11,6 +11,9 @@ const PAGE_SIZE = 60
 const SEARCH_PAGE_SIZE = 10
 let viewerScale = 1
 let viewerDrag = null
+let viewerPostId = ""
+let viewerPages = []
+let viewerPageIndex = 0
 let explorerEvents = null
 let explorerPage = 1
 let explorerDebounce = null
@@ -37,6 +40,7 @@ $("#btn-submit").addEventListener("click", async () => {
   if (!url) return
   const pages = parseInt($("#input-pages").value) || 30
   const mode = $("#input-mode").value
+  const deepScan = $("#input-deep-scan").checked
   const status = $("#submit-status")
   status.textContent = "Submitting..."
   status.className = ""
@@ -57,13 +61,13 @@ $("#btn-submit").addEventListener("click", async () => {
       resp = await fetch("/api/submit_users", {
         method: "POST",
         headers: { "Content-Type": "application/json" },
-        body: JSON.stringify({ user_ids: userIds })
+        body: JSON.stringify({ user_ids: userIds, deep_scan: deepScan })
       })
     } else {
       resp = await fetch("/api/submit", {
         method: "POST",
         headers: { "Content-Type": "application/json" },
-        body: JSON.stringify({ url, pages, mode })
+        body: JSON.stringify({ url, pages, mode, deep_scan: deepScan })
       })
     }
     const data = await resp.json()
@@ -548,7 +552,7 @@ function pageSuffix(url) {
 }
 
 function resultCardKey(item) {
-  return `${item.post_id}|${item.url || ""}`
+  return `${item.post_id}|${item.url || ""}|${(item.pages || []).join(",")}`
 }
 
 function resultBadge(item) {
@@ -563,6 +567,7 @@ function resultCardHtml(item) {
   const pg = item.url ? pageSuffix(item.url) : ""
   const label = pid + pg
   const index = item.scan_index || 0
+  const pageCount = item.page_count || 1
   const download = item.download_url ? `<a class="download-link" href="${esc(item.download_url)}">Download</a>` : ""
   const thumb = item.image_url
     ? `<button class="thumb" data-preview="${esc(item.preview_url || item.image_url)}" data-download="${esc(item.download_url || "")}"><img src="${esc(item.image_url)}" loading="lazy" alt="${esc(label)}"></button>`
@@ -574,6 +579,7 @@ function resultCardHtml(item) {
         ${download}
       </div>
       ${resultBadge(item)}
+      ${pageCount > 1 ? `<span class="result-pages">${pageCount}</span>` : ""}
       <span class="result-index">${index}</span>
     </div>`
 }
@@ -588,7 +594,7 @@ function createResultCard(item) {
   const thumb = card.querySelector(".thumb")
   if (thumb) {
     const img = thumb.querySelector("img")
-    thumb.addEventListener("click", () => openViewer(thumb.dataset.preview, thumb.dataset.download))
+    thumb.addEventListener("click", () => openViewer(item))
     img.addEventListener("load", () => thumb.classList.add("thumb-loaded"))
     img.addEventListener("error", () => thumb.classList.add("thumb-error"))
     if (img.complete) thumb.classList.add(img.naturalWidth ? "thumb-loaded" : "thumb-error")
@@ -622,21 +628,44 @@ function renderPostSearchResults(items) {
   $("#post-search-grid").replaceChildren(...cards)
 }
 
-function openViewer(src, download) {
-  if (!src) return
+function openViewer(item) {
+  if (!item.preview_url && !item.image_url) return
+  viewerPostId = item.post_id
+  viewerPages = item.pages?.length ? item.pages : [item.page || 0]
+  viewerPageIndex = Math.max(viewerPages.indexOf(item.page || 0), 0)
   viewerScale = 1
-  $("#viewer-img").src = src
-  $("#viewer-download").href = download || src
   $("#viewer").classList.remove("hidden")
   $("#viewer").setAttribute("aria-hidden", "false")
+  showViewerPage()
+}
+
+function showViewerPage() {
+  const page = viewerPages[viewerPageIndex]
+  const pid = encodeURIComponent(viewerPostId)
+  $("#viewer-img").src = `/api/i/${pid}/v?p=${page}`
+  $("#viewer-download").href = `/api/i/${pid}/o?p=${page}`
+  $("#viewer-prev").disabled = viewerPageIndex <= 0
+  $("#viewer-next").disabled = viewerPageIndex >= viewerPages.length - 1
+  $("#viewer-prev").classList.toggle("hidden", viewerPages.length <= 1)
+  $("#viewer-next").classList.toggle("hidden", viewerPages.length <= 1)
+  viewerScale = 1
   applyViewerZoom()
 }
 
+function moveViewerPage(step) {
+  const next = Math.min(Math.max(viewerPageIndex + step, 0), viewerPages.length - 1)
+  if (next === viewerPageIndex) return
+  viewerPageIndex = next
+  showViewerPage()
+}
+
 function closeViewer() {
   $("#viewer").classList.add("hidden")
   $("#viewer").setAttribute("aria-hidden", "true")
   $("#viewer-img").src = ""
   $("#viewer-download").href = ""
+  viewerPostId = ""
+  viewerPages = []
   viewerDrag = null
   $("#viewer-stage").classList.remove("dragging")
 }
@@ -657,6 +686,8 @@ $("#viewer-zoom-out").addEventListener("click", () => {
 })
 
 $("#viewer-close").addEventListener("click", closeViewer)
+$("#viewer-prev").addEventListener("click", () => moveViewerPage(-1))
+$("#viewer-next").addEventListener("click", () => moveViewerPage(1))
 $("#viewer").addEventListener("click", e => { if (e.target.id === "viewer") closeViewer() })
 $("#viewer-stage").addEventListener("wheel", e => {
   e.preventDefault()
@@ -664,7 +695,7 @@ $("#viewer-stage").addEventListener("wheel", e => {
   applyViewerZoom()
 })
 $("#viewer-stage").addEventListener("pointerdown", e => {
-  if (e.button !== 0) return
+  if (e.button !== 0 || e.target.closest(".viewer-nav")) return
   const stage = $("#viewer-stage")
   viewerDrag = {
     x: e.clientX,
@@ -690,7 +721,12 @@ $("#viewer-stage").addEventListener("pointercancel", () => {
   viewerDrag = null
   $("#viewer-stage").classList.remove("dragging")
 })
-window.addEventListener("keydown", e => { if (e.key === "Escape") closeViewer() })
+window.addEventListener("keydown", e => {
+  if ($("#viewer").classList.contains("hidden")) return
+  if (e.key === "Escape") closeViewer()
+  if (e.key === "ArrowLeft") { e.preventDefault(); moveViewerPage(-1) }
+  if (e.key === "ArrowRight") { e.preventDefault(); moveViewerPage(1) }
+})
 
 function renderPager(id, data) {
   const pager = $("#pager")

frontend/index.html

@@ -5,7 +5,7 @@
 <meta name="viewport" content="width=device-width, initial-scale=1.0">
 <link rel="icon" href="data:;base64,=">
 <title>Pixif2</title>
-<link rel="stylesheet" href="style.css?v=20260704-1">
+<link rel="stylesheet" href="style.css?v=20260716-1">
 </head>
 <body>
 <div class="topbar">
@@ -41,6 +41,10 @@
           <option value="real">Real only</option>
         </select>
       </div>
+      <label class="check-field">
+        <input type="checkbox" id="input-deep-scan">
+        <span>Deep scan</span>
+      </label>
       <button id="btn-submit" class="btn-primary">Submit</button>
     </div>
     <div id="submit-status"></div>
@@ -106,9 +110,11 @@
     <button id="viewer-close" class="btn-secondary">Close</button>
   </div>
   <div id="viewer-stage">
+    <button id="viewer-prev" class="viewer-nav" aria-label="Previous result page">&lsaquo;</button>
     <img id="viewer-img" alt="">
+    <button id="viewer-next" class="viewer-nav" aria-label="Next result page">&rsaquo;</button>
   </div>
 </div>
-<script src="app.js?v=20260715-1"></script>
+<script src="app.js?v=20260716-1"></script>
 </body>
 </html>

frontend/style.css

@@ -91,10 +91,21 @@ h1 {
 }
 .submit-grid {
   display: grid;
-  grid-template-columns: minmax(18rem, 1fr) 8rem 10rem auto;
+  grid-template-columns: minmax(14rem, 1fr) 6rem 8rem auto auto;
   gap: .75rem;
   align-items: end;
 }
+.check-field {
+  height: 42px;
+  display: flex;
+  align-items: center;
+  gap: .45rem;
+  color: var(--muted);
+  font-size: .78rem;
+  font-weight: 800;
+  white-space: nowrap;
+}
+.check-field input { width: auto; height: auto; accent-color: var(--accent); }
 .form-group { min-width: 0; }
 .form-group label {
   display: block;
@@ -487,6 +498,15 @@ input:focus, select:focus, textarea:focus { outline: none; border-color: var(--a
   font-size: .72rem;
   font-weight: 800;
 }
+.result-pages {
+  position: absolute;
+  left: .55rem;
+  bottom: .45rem;
+  color: var(--accent);
+  font-family: Consolas, "SFMono-Regular", monospace;
+  font-size: .72rem;
+  font-weight: 800;
+}
 #viewer {
   position: fixed;
   inset: 0;
@@ -506,6 +526,12 @@ input:focus, select:focus, textarea:focus { outline: none; border-color: var(--a
   background: #080808ee;
   border-bottom: 1px solid var(--line);
 }
+#viewer-download {
+  display: inline-flex;
+  align-items: center;
+  padding-top: .12rem;
+  line-height: 1;
+}
 #viewer-zoom {
   min-width: 4rem;
   text-align: center;
@@ -513,6 +539,7 @@ input:focus, select:focus, textarea:focus { outline: none; border-color: var(--a
   font-size: .85rem;
 }
 #viewer-stage {
+  position: relative;
   flex: 1;
   display: flex;
   align-items: flex-start;
@@ -522,6 +549,22 @@ input:focus, select:focus, textarea:focus { outline: none; border-color: var(--a
   cursor: grab;
   touch-action: none;
 }
+.viewer-nav {
+  position: fixed;
+  top: 50%;
+  z-index: 1;
+  width: 46px;
+  height: 64px;
+  background: #080808dd;
+  border: 1px solid var(--line);
+  color: var(--text);
+  font-size: 2rem;
+  cursor: pointer;
+}
+.viewer-nav:hover { color: var(--accent); border-color: var(--accent); }
+.viewer-nav:disabled { opacity: .3; cursor: default; }
+#viewer-prev { left: 1rem; }
+#viewer-next { right: 1rem; }
 #viewer-stage.dragging { cursor: grabbing; }
 #viewer-img {
   max-width: none;