fix(desktop/read): PDF TOC resize (real root cause) + robust jump + reveal-file button

#1 The PDF outline panel's width was fixed no matter what — the true cause was a
CSS class collision, not the drag logic: the panel carried `pdfjs-toc scroll`, and
the `.scroll` utility (`flex: 1`, defined LATER in the sheet than `.pdfjs-toc`'s
`flex: 0 0 auto`) won on equal specificity, so `flex-basis: 0` + `flex-grow: 1`
overrode the inline `width: tocW` entirely — the panel was sized by flex-grow, and
dragging updated tocW to no effect. Dropped the `scroll` class (the panel already
sets its own `overflow: auto`). This is why prior ResizeHandle fixes didn't help.

#1 ToC/inline-link jumps could land short: pages ABOVE the target may still be
reserving their true height (lazy render, late pageDims), shifting the target after
the scroll starts. scrollToPage now settles — recomputes the absolute target and
re-scrolls whenever it drifts, until the layout above stabilises.

#2 Attachment card gains a "Show in folder" action (+ inline folder icon): a new
`reveal_path` command reveals the file in the OS file manager — `explorer /select`
(Windows), `open -R` (macOS), containing folder via `xdg-open` (Linux). Path is a
single process arg, never a shell string.

Zotero-style left panel (thumbnails/outline tabs) + annotation tools are the next
slice.

Co-Authored-By: Claude Opus 4.8 <[email protected]>

Author: Ubuntu

desktop/src-tauri/src/lib.rs

@@ -340,6 +340,58 @@ fn open_url(url: &str) -> Result<(), String> {
         .map_err(|e| e.to_string())
 }
 
+/// Reveal a file in the OS file manager (selecting it where the platform supports
+/// it), so the user can find a linked attachment on disk. The path is passed as a
+/// single process argument — never through a shell — so it can't inject a command.
+#[tauri::command]
+fn reveal_path(path: String) -> Result<(), String> {
+    if path.trim().is_empty() {
+        return Err("empty path".into());
+    }
+    reveal(&path)
+}
+
+#[cfg(target_os = "windows")]
+fn reveal(path: &str) -> Result<(), String> {
+    use std::os::windows::process::CommandExt;
+    use std::process::Command;
+    const CREATE_NO_WINDOW: u32 = 0x0800_0000;
+    // `explorer /select,"<path>"` selects the file in its folder. explorer returns
+    // a non-zero exit code even on success, so we only require that it spawned.
+    // raw_arg keeps our exact quoting (a Windows path can't contain a `"`), which
+    // Rust's default arg-quoting would otherwise mangle for explorer.
+    Command::new("explorer")
+        .raw_arg(format!("/select,\"{path}\""))
+        .creation_flags(CREATE_NO_WINDOW)
+        .spawn()
+        .map(|_| ())
+        .map_err(|e| e.to_string())
+}
+
+#[cfg(target_os = "macos")]
+fn reveal(path: &str) -> Result<(), String> {
+    // `open -R` reveals and selects the file in Finder.
+    std::process::Command::new("open")
+        .args(["-R", path])
+        .spawn()
+        .map(|_| ())
+        .map_err(|e| e.to_string())
+}
+
+#[cfg(all(unix, not(target_os = "macos")))]
+fn reveal(path: &str) -> Result<(), String> {
+    // No portable "select the file" on Linux desktops — open the containing folder.
+    let target = std::path::Path::new(path)
+        .parent()
+        .map(std::path::Path::to_path_buf)
+        .unwrap_or_else(|| std::path::PathBuf::from(path));
+    std::process::Command::new("xdg-open")
+        .arg(target)
+        .spawn()
+        .map(|_| ())
+        .map_err(|e| e.to_string())
+}
+
 // ---- in-app browser window --------------------------------------------------
 // The J1 in-app browser tab is an <iframe>, which many sites forbid via
 // `X-Frame-Options` / `frame-ancestors` (arxiv.org, Google Scholar, most
@@ -424,6 +476,7 @@ pub fn run() {
             hub_request_bytes,
             system_proxy,
             open_external,
+            reveal_path,
             open_browser_window,
             storage::storage_pick_folder,
             storage::storage_reindex,

desktop/src/i18n/index.ts

@@ -686,6 +686,7 @@ const en: Dict = {
   'read.attType': 'Type',
   'read.attLocation': 'Location',
   'read.attOpen': 'Open in reader',
+  'read.attReveal': 'Show in folder',
   'read.attSession': 'Linked this session',
   'read.attMissing': 'Not found in the linked folder',
   'read.attNotLinked': 'No storage folder linked — link one in the Read tab',
@@ -1525,6 +1526,7 @@ const zh: Dict = {
   'read.attType': '类型',
   'read.attLocation': '位置',
   'read.attOpen': '在阅读器中打开',
+  'read.attReveal': '在文件夹中显示',
   'read.attSession': '本次会话已链接',
   'read.attMissing': '在已链接文件夹中未找到',
   'read.attNotLinked': '未链接存储文件夹 — 请在“阅读”标签中链接',

desktop/src/platform.ts

@@ -27,6 +27,18 @@ export function openExternal(url: string): void {
   }
 }
 
+/// Reveal a local file in the OS file manager (Finder / Explorer / files app),
+/// selecting it where the platform supports it. Desktop-only; a no-op in the
+/// browser build (no filesystem access).
+export function revealPath(path: string): void {
+  if (path === '' || !isTauri()) return;
+  void import('@tauri-apps/api/core')
+    .then(({ invoke }) => invoke('reveal_path', { path }))
+    .catch(() => {
+      /* best effort */
+    });
+}
+
 /// Open a URL in a real in-app browser *window* (a Tauri webview, not an iframe),
 /// so sites that forbid framing (`X-Frame-Options` — arxiv, Google Scholar, most
 /// publishers) still load. The browser build falls back to a new tab.

desktop/src/styles/app.css

@@ -5085,9 +5085,23 @@ th {
   font-family: var(--font-mono, monospace);
   font-size: var(--font-size-caption);
 }
+.att-reveal {
+  flex: 0 0 auto;
+  align-self: center;
+  color: var(--text-muted);
+  padding: 2px;
+}
+.att-reveal:hover {
+  color: var(--accent);
+}
+.att-actions {
+  display: flex;
+  flex-wrap: wrap;
+  gap: var(--spacing-s8);
+  margin-top: var(--spacing-s4);
+}
 .att-open {
   align-self: flex-start;
-  margin-top: var(--spacing-s4);
 }
 .epub-view {
   display: flex;

desktop/src/surfaces/ReadSurface.tsx

@@ -22,7 +22,7 @@ import {
   type ScrapePatch,
   type ScrapeSeed,
 } from '../discovery';
-import { isTauri } from '../platform';
+import { isTauri, revealPath } from '../platform';
 import { BrowserView } from './BrowserView';
 import { AgentCompanion } from '../ui/AgentCompanion';
 import { Markdown } from '../ui/Markdown';
@@ -379,10 +379,12 @@ function AttachmentInfo({
   const kind = viewKindFor(att.file);
   const ext = att.file.split('.').pop()?.toLowerCase() ?? '';
   const rel = rels.get(k);
+  // The absolute on-disk path, when known (Tauri storage link) — lets us reveal
+  // the file in the OS file manager. The browser build has only live File handles,
+  // so there is no path to reveal.
+  const absPath = present && rel !== undefined && path !== null ? `${path}/${rel}` : null;
   const location = present
-    ? rel !== undefined && path !== null
-      ? `${path}/${rel}`
-      : t('read.attSession')
+    ? absPath ?? t('read.attSession')
     : storageLinked
       ? t('read.attMissing')
       : t('read.attNotLinked');
@@ -429,13 +431,26 @@ function AttachmentInfo({
           <div className="att-field">
             <span className="att-k">{t('read.attLocation')}</span>
             <span className={present ? 'att-v mono' : 'att-v mono muted'}>{location}</span>
+            {absPath !== null && (
+              <button className="link-btn att-reveal" title={t('read.attReveal')} onClick={() => revealPath(absPath)}>
+                <Icon name="folder" size={14} />
+              </button>
+            )}
+          </div>
+          <div className="att-actions">
+            {absPath !== null && (
+              <button className="small att-locate" onClick={() => revealPath(absPath)}>
+                <Icon name="folder" size={14} />
+                {t('read.attReveal')}
+              </button>
+            )}
+            {present && embedded !== true && onOpen !== undefined && (
+              <button className="primary small att-open" onClick={onOpen}>
+                <Icon name="window" />
+                {t('read.attOpen')}
+              </button>
+            )}
           </div>
-          {present && embedded !== true && onOpen !== undefined && (
-            <button className="primary small att-open" onClick={onOpen}>
-              <Icon name="window" />
-              {t('read.attOpen')}
-            </button>
-          )}
         </div>
       </div>
     </div>

desktop/src/ui/PdfCanvas.tsx

@@ -441,15 +441,38 @@ export function PdfCanvas({
   }
 
   // Scroll so page `n`'s top (plus an optional in-page `yOffset`) sits just under
-  // the toolbar. Computed against the container's own scroll frame (not
-  // scrollIntoView) so an in-page offset can be added, and accurate because every
-  // page already reserves its true height via pageDims.
+  // the toolbar. The target is an ABSOLUTE content offset (invariant to the current
+  // scroll position), computed from the page's rect within the container's scroll
+  // frame — so an in-page offset can be added.
+  //
+  // A jump can otherwise land short: pages ABOVE the target may still be reserving
+  // their true height (lazy render, or pageDims not yet measured), which shifts the
+  // target down after the scroll begins. So we settle: recompute the target a few
+  // times and re-scroll whenever it drifts, until the layout above has stabilised.
   function scrollToPage(n: number, yOffset = 0): void {
     const container = scrollRef.current;
-    const el = container?.querySelector(`[data-page="${n}"]`);
-    if (!(el instanceof HTMLElement) || container === null) return;
-    const top = container.scrollTop + (el.getBoundingClientRect().top - container.getBoundingClientRect().top) + yOffset;
-    container.scrollTo({ top: Math.max(0, top - 8), behavior: 'smooth' });
+    if (container === null) return;
+    const targetTop = (): number | null => {
+      const el = container.querySelector(`[data-page="${n}"]`);
+      if (!(el instanceof HTMLElement)) return null;
+      const off = el.getBoundingClientRect().top - container.getBoundingClientRect().top;
+      return Math.max(0, container.scrollTop + off + yOffset - 8);
+    };
+    const first = targetTop();
+    if (first === null) return;
+    container.scrollTo({ top: first, behavior: 'smooth' });
+    let last = first;
+    let tries = 0;
+    const settle = (): void => {
+      tries += 1;
+      const t = targetTop();
+      if (t !== null && Math.abs(t - last) > 3) {
+        last = t;
+        container.scrollTo({ top: t, behavior: 'smooth' });
+      }
+      if (tries < 8) window.setTimeout(settle, 120);
+    };
+    window.setTimeout(settle, 160);
   }
 
   async function runSearch(): Promise<void> {
@@ -588,7 +611,7 @@ export function PdfCanvas({
       <div className="pdfjs-body">
         {showToc && outline.length > 0 && (
           <>
-            <div className="pdfjs-toc scroll" style={{ width: tocW }}>
+            <div className="pdfjs-toc" style={{ width: tocW }}>
               <OutlineList nodes={outline} onGo={(d) => void goToDest(d)} depth={0} />
             </div>
             <ResizeHandle