diff --git a/CLAUDE.md b/CLAUDE.md
index fac37d5..c3e2ade 100644
--- a/CLAUDE.md
+++ b/CLAUDE.md
@@ -24,11 +24,29 @@ This document provides comprehensive guidance for AI assistants (like Claude) wo
    - Prevents UI blocking during heavy parsing operations
    - Communication via postMessage/onmessage pattern
 
-3. **LocalStorage Persistence**
+3. **Persistence**
    - Uploaded files and parsing configs persist across sessions
-   - 5MB storage limit with quota handling
+   - IndexedDB is the primary store (`src/utils/idb.js` opens the shared DB);
+     localStorage is the fallback where IndexedDB is unavailable, with a 5MB
+     limit and quota handling
    - Config saved on every change (with safeguards)
 
+4. **Perfetto-style Cache Links** (`src/utils/sessionCache.js` + `cacheUrl.js`)
+   - Every analysis (files + parsed metrics + parsing config) is snapshotted to
+     IndexedDB under a UUID and addressed by `#!/viewer?local_cache_key=<uuid>`
+   - Reload, bookmark or a second tab reopens the same logs without re-uploading
+   - Local to the browser by design — nothing is uploaded anywhere
+   - Four stores, split by write frequency: `sessionIndex` (summaries, so
+     listing never reads log text), `sessions` (small metadata), `content`
+     (one record per file, UTF-8 bytes), `metrics` (one record per file,
+     Float64Array pairs). Content and metrics are written only when they
+     actually change, so a checkbox toggle writes ~4ms regardless of how many
+     hundreds of MB are cached
+   - LRU eviction by age (30d), count (20) and bytes (min of 2GB and half the
+     origin's quota); `navigator.storage.persist()` is requested best-effort
+   - Out of space: evict other analyses, then keep the parsed series and drop
+     the raw logs (charts still render; files are flagged for re-upload)
+
 4. **Global Drag-and-Drop**
    - Full-page drag overlay for intuitive file uploads
    - Supports dropping files anywhere in the application
@@ -52,10 +70,15 @@ This document provides comprehensive guidance for AI assistants (like Claude) wo
 │   │   ├── Header.jsx             # Header with language/theme toggle
 │   │   ├── RegexControls.jsx      # Global parsing config
 │   │   ├── ResizablePanel.jsx     # Draggable chart height
+│   │   ├── SessionsModal.jsx      # Cached analyses / cache links
 │   │   └── ThemeToggle.jsx        # Dark mode toggle
 │   ├── utils/             # Utility functions
 │   │   ├── __tests__/    # Utility tests (colocated)
 │   │   ├── ValueExtractor.js   # Core parsing logic
+│   │   ├── idb.js              # Shared IndexedDB open/upgrade
+│   │   ├── fileStorage.js      # Active working set persistence
+│   │   ├── sessionCache.js     # Cached analyses (local_cache_key)
+│   │   ├── cacheUrl.js         # local_cache_key URL plumbing
 │   │   ├── getMinSteps.js      # Chart step calculation
 │   │   └── mergeFiles.js       # File merging logic
 │   ├── workers/
diff --git a/README.md b/README.md
index 1c78e29..e201036 100644
--- a/README.md
+++ b/README.md
@@ -22,6 +22,7 @@
 - 🎛️ **灵活展示**：可独立启用或禁用文件和图表，支持调整数据范围与图表尺寸，图表高度可拖拽调整。
 - ⚡ **易用特性**：支持匹配预览、智能推荐解析规则，图表 Shift+拖动可快速缩放。
 - 💾 **数据导出**：每个图表均支持导出 PNG、复制图片到剪贴板以及导出 CSV 数据。
+- 🔗 **本地缓存链接**：上传的日志与解析结果会缓存在浏览器中，地址栏自动生成 `#!/viewer?local_cache_key=<uuid>` 链接（同 [ui.perfetto.dev](https://ui.perfetto.dev/) 的做法）。收藏该链接即可随时回到同一次分析，无需重新上传；链接仅在本机本浏览器有效，日志不会上传到任何服务器。
 
 ## 快速上手 ⚡
 
@@ -30,6 +31,7 @@
 3. 查看自动生成的图表，必要时可上传第二个文件进行对比分析。
 4. 调整图表显示或数据范围以获得更精确的结果。
 5. 使用图表右上角的按钮导出 PNG、复制图片或下载 CSV 数据。
+6. 收藏地址栏中的 `local_cache_key` 链接，或点击侧边栏「缓存」新建、打开、重命名、删除已缓存的分析。
 
 ## 部署
 
diff --git a/package-lock.json b/package-lock.json
index 176dd73..e9ec429 100644
--- a/package-lock.json
+++ b/package-lock.json
@@ -36,6 +36,7 @@
         "eslint": "^9.25.0",
         "eslint-plugin-react-hooks": "^5.2.0",
         "eslint-plugin-react-refresh": "^0.4.19",
+        "fake-indexeddb": "^6.2.5",
         "globals": "^16.0.0",
         "jsdom": "^24.0.0",
         "vite": "^6.3.5",
@@ -5021,6 +5022,16 @@
         "url": "https://github.com/sindresorhus/execa?sponsor=1"
       }
     },
+    "node_modules/fake-indexeddb": {
+      "version": "6.2.5",
+      "resolved": "https://registry.npmjs.org/fake-indexeddb/-/fake-indexeddb-6.2.5.tgz",
+      "integrity": "sha512-CGnyrvbhPlWYMngksqrSSUT1BAVP49dZocrHuK0SvtR0D5TMs5wP0o3j7jexDJW01KSadjBp1M/71o/KR3nD1w==",
+      "dev": true,
+      "license": "Apache-2.0",
+      "engines": {
+        "node": ">=18"
+      }
+    },
     "node_modules/fast-deep-equal": {
       "version": "3.1.3",
       "resolved": "https://registry.npmjs.org/fast-deep-equal/-/fast-deep-equal-3.1.3.tgz",
diff --git a/package.json b/package.json
index f35d3b4..2229a4c 100644
--- a/package.json
+++ b/package.json
@@ -42,6 +42,7 @@
     "eslint": "^9.25.0",
     "eslint-plugin-react-hooks": "^5.2.0",
     "eslint-plugin-react-refresh": "^0.4.19",
+    "fake-indexeddb": "^6.2.5",
     "globals": "^16.0.0",
     "jsdom": "^24.0.0",
     "vite": "^6.3.5",
diff --git a/public/locales/en/translation.json b/public/locales/en/translation.json
index b736650..edfa537 100644
--- a/public/locales/en/translation.json
+++ b/public/locales/en/translation.json
@@ -259,5 +259,24 @@
   "toast.reportSaved": "Report saved",
   "toast.exportFailed": "Export failed",
   "toast.noChartsToExport": "No charts to export — upload a log first.",
-  "toast.clipboardUnsupported": "Clipboard API unavailable. Use Download instead."
+  "toast.clipboardUnsupported": "Clipboard API unavailable. Use Download instead.",
+  "header.sessions": "Cache",
+  "sessions.aria": "Cached analyses",
+  "sessions.title": "Cached analyses",
+  "sessions.close": "Close",
+  "sessions.hint": "Every analysis is cached in this browser and gets a local_cache_key link in the address bar. Bookmark it to come back to the exact same logs without re-uploading. Links only work in this browser on this machine — nothing is ever uploaded to a server.",
+  "sessions.currentLink": "Link to the current analysis",
+  "sessions.copyLink": "Copy link",
+  "sessions.linkCopied": "Link copied",
+  "sessions.empty": "Nothing cached yet — upload a log and it appears here.",
+  "sessions.open": "Open",
+  "sessions.delete": "Delete",
+  "sessions.clearAll": "Clear cache",
+  "sessions.current": "Current",
+  "sessions.meta": "{{files}} files · {{size}} · {{time}}",
+  "sessions.truncated": "too large to cache in full — metrics only",
+  "sessions.notFound": "No cached analysis for this link in this browser (cache links are local to the machine that made them).",
+  "sessions.newAnalysis": "New analysis (keeps the current one cached)",
+  "sessions.rename": "Rename",
+  "sessions.firstHint": "This analysis is cached — bookmark the link in the address bar to come straight back to it."
 }
diff --git a/public/locales/zh/translation.json b/public/locales/zh/translation.json
index 163a460..b8938d2 100644
--- a/public/locales/zh/translation.json
+++ b/public/locales/zh/translation.json
@@ -259,5 +259,24 @@
   "toast.reportSaved": "报告已保存",
   "toast.exportFailed": "导出失败",
   "toast.noChartsToExport": "暂无图表可导出——请先上传日志。",
-  "toast.clipboardUnsupported": "剪贴板 API 不可用，请改用下载。"
+  "toast.clipboardUnsupported": "剪贴板 API 不可用，请改用下载。",
+  "header.sessions": "缓存",
+  "sessions.aria": "已缓存的分析",
+  "sessions.title": "已缓存的分析",
+  "sessions.close": "关闭",
+  "sessions.hint": "每次上传的日志和解析结果都会缓存在本浏览器中，并在地址栏生成一个 local_cache_key 链接。收藏该链接即可随时回到这次分析，无需重新上传。链接只在本机本浏览器有效，日志不会上传到任何服务器。",
+  "sessions.currentLink": "当前分析的链接",
+  "sessions.copyLink": "复制链接",
+  "sessions.linkCopied": "链接已复制",
+  "sessions.empty": "暂无缓存，上传日志后会自动生成。",
+  "sessions.open": "打开",
+  "sessions.delete": "删除",
+  "sessions.clearAll": "清空缓存",
+  "sessions.current": "当前",
+  "sessions.meta": "{{files}} 个文件 · {{size}} · {{time}}",
+  "sessions.truncated": "文件过大，仅缓存了解析结果",
+  "sessions.notFound": "该链接对应的缓存不在此浏览器中（缓存链接仅在本机有效）。",
+  "sessions.newAnalysis": "新建分析（保留当前缓存）",
+  "sessions.rename": "重命名",
+  "sessions.firstHint": "本次分析已缓存，地址栏的链接可以收藏，下次直接回到这里。"
 }
diff --git a/src/App.jsx b/src/App.jsx
index 3034549..443bcf3 100644
--- a/src/App.jsx
+++ b/src/App.jsx
@@ -15,14 +15,27 @@ import { CollapsibleCardHeader } from './components/CollapsibleCardHeader.jsx';
 import { SmoothCollapse } from './components/SmoothCollapse.jsx';
 import { ShortcutHelp } from './components/ShortcutHelp.jsx';
 import { SettingsModal } from './components/SettingsModal.jsx';
+import { SessionsModal } from './components/SessionsModal.jsx';
 import { ExportMenu } from './components/ExportMenu.jsx';
 import { useCollapsedSection } from './utils/useCollapsedSection.js';
 import { useKeyboardShortcuts } from './utils/useKeyboardShortcuts.js';
-import { PanelLeftClose, PanelLeftOpen, HelpCircle, Settings as SettingsIcon, Github, FileBarChart, Copy, Download } from 'lucide-react';
+import { PanelLeftClose, PanelLeftOpen, HelpCircle, Settings as SettingsIcon, Github, FileBarChart, Copy, Download, History } from 'lucide-react';
 import { mergeFilesWithReplacement } from './utils/mergeFiles.js';
 import { useToast } from './components/ToastContext.jsx';
 import { loadFiles as loadFilesFromStorage, saveFiles as saveFilesToStorage, clearFiles as clearFilesInStorage } from './utils/fileStorage.js';
 import { detectAnomalies } from './utils/anomalyDetection.js';
+import {
+  isCacheAvailable,
+  saveSession,
+  loadSession,
+  listSessions,
+  deleteSession as deleteCachedSession,
+  clearSessions
+} from './utils/sessionCache.js';
+import { readCacheKey, writeCacheKey, clearCacheKey, generateCacheKey } from './utils/cacheUrl.js';
+
+// One-time explainer for the cache link that appears in the address bar
+const CACHE_HINT_KEY = 'sessions.hintShown';
 
 // Threshold for "large file" - files above this won't have content persisted
 const LARGE_FILE_THRESHOLD = 5 * 1024 * 1024; // 5MB of content
@@ -86,6 +99,9 @@ function App() {
   // Sync init from legacy localStorage so the first paint matches prior behavior;
   // an async IndexedDB load below will replace this state if richer data is present.
   const [uploadedFiles, setUploadedFiles] = useState(() => {
+    // A cache key in the URL wins: its snapshot loads asynchronously below, and
+    // painting the previous working set first would just flash the wrong logs.
+    if (readCacheKey()) return [];
     const stored = localStorage.getItem('uploadedFiles');
     if (!stored) return [];
     try {
@@ -143,6 +159,18 @@ function App() {
   // report export without lifting all chart state into App.
   const chartContainerRef = useRef(null);
   const savingDisabledRef = useRef(false);
+  // Perfetto-style cache key for the analysis currently on screen. Mirrored in
+  // the URL hash so a reload, bookmark or second tab reopens the same logs.
+  const [cacheKey, setCacheKey] = useState(() => readCacheKey());
+  const sessionIdRef = useRef(readCacheKey());
+  const cacheDisabledRef = useRef(false);
+  // Set when state was just loaded *from* the cache, so the save effect doesn't
+  // immediately write the snapshot it has only just read back.
+  const skipNextSaveRef = useRef(false);
+  // The debounced write still in flight, if any. Switching analyses cancels the
+  // timer, so it has to be flushed first or the last edit is silently lost.
+  const pendingSaveRef = useRef(null);
+  const [sessionsOpen, setSessionsOpen] = useState(false);
   const enabledFiles = uploadedFiles.filter(file => file.enabled);
   const workerRef = useRef(null);
 
@@ -232,25 +260,90 @@ function App() {
     }
   }, [enabledFiles, baselineFile]);
 
-  // Async load from IndexedDB on mount. Overrides the sync localStorage init
-  // if richer data is present (e.g. after migration or in IDB-capable browsers).
+  // Write out a debounced save that has not fired yet.
+  const flushPendingSave = useCallback(async () => {
+    const pending = pendingSaveRef.current;
+    if (!pending) return;
+    pendingSaveRef.current = null;
+    try {
+      await saveSession(pending);
+    } catch {
+      // Best effort — the same failure surfaces through the save effect
+    }
+  }, []);
+
+  // Apply a cached snapshot to the live app state.
+  const applySession = useCallback((key, record) => {
+    skipNextSaveRef.current = true;
+    sessionIdRef.current = key;
+    setCacheKey(key);
+    setUploadedFiles((record.files || []).map(restoreFile));
+    if (record.globalParsingConfig) {
+      setGlobalParsingConfig(record.globalParsingConfig);
+    }
+  }, []);
+
+  // Restore on mount, in order of preference:
+  //   1. the `local_cache_key` in the URL — a bookmarked/reloaded analysis
+  //   2. the most recently used cached analysis (bare URL keeps working)
+  //   3. the legacy single working set, which the first save adopts into a
+  //      cache entry of its own
   useEffect(() => {
     let cancelled = false;
-    loadFilesFromStorage().then(files => {
-      if (cancelled) return;
-      initialLoadDoneRef.current = true;
-      if (Array.isArray(files) && files.length > 0) {
-        setUploadedFiles(prev => {
-          // Avoid overwriting if user already added files during async load
-          if (prev.length > 0) return prev;
-          return files.map(restoreFile);
-        });
+
+    const loadWorkingSet = () => {
+      loadFilesFromStorage().then(files => {
+        if (cancelled) return;
+        initialLoadDoneRef.current = true;
+        if (Array.isArray(files) && files.length > 0) {
+          setUploadedFiles(prev => {
+            // Avoid overwriting if user already added files during async load
+            if (prev.length > 0) return prev;
+            return files.map(restoreFile);
+          });
+        }
+      }).catch(() => {
+        initialLoadDoneRef.current = true;
+      });
+    };
+
+    (async () => {
+      const urlKey = readCacheKey();
+      if (isCacheAvailable()) {
+        try {
+          let key = urlKey;
+          let record = key ? await loadSession(key) : null;
+          if (urlKey && !record) {
+            // The key is valid but names nothing here: cache links are local to
+            // the browser that made them, so this is the expected miss.
+            toastRef.current.warning(tRef.current('sessions.notFound'));
+            clearCacheKey();
+            key = null;
+          }
+          if (!record && !urlKey) {
+            const [latest] = await listSessions();
+            if (latest) {
+              record = await loadSession(latest.id);
+              key = latest.id;
+            }
+          }
+          if (cancelled) return;
+          if (record) {
+            applySession(key, record);
+            writeCacheKey(key);
+            initialLoadDoneRef.current = true;
+            return;
+          }
+        } catch {
+          // Cache unreadable — fall through to the legacy working set
+        }
+        if (cancelled) return;
       }
-    }).catch(() => {
-      initialLoadDoneRef.current = true;
-    });
+      loadWorkingSet();
+    })();
+
     return () => { cancelled = true; };
-  }, []);
+  }, [applySession]);
 
   // Persist configuration to localStorage
   useEffect(() => {
@@ -263,8 +356,69 @@ function App() {
     localStorage.setItem('chartConfig', JSON.stringify(chartConfig));
   }, [chartConfig]);
 
+  // Persist the analysis. Where IndexedDB exists the snapshot goes to the
+  // session cache under the URL's cache key (minted on first save); otherwise
+  // we keep the legacy single localStorage working set.
   useEffect(() => {
     if (savingDisabledRef.current) return;
+    // Don't write before the restore above has had its say, or an empty initial
+    // state would overwrite the snapshot we are about to load.
+    if (!initialLoadDoneRef.current) return;
+    if (skipNextSaveRef.current) {
+      skipNextSaveRef.current = false;
+      return;
+    }
+
+    if (isCacheAvailable() && !cacheDisabledRef.current) {
+      if (uploadedFiles.length === 0) {
+        const staleId = sessionIdRef.current;
+        pendingSaveRef.current = null;
+        if (staleId) {
+          sessionIdRef.current = null;
+          setCacheKey(null);
+          clearCacheKey();
+          deleteCachedSession(staleId).catch(() => { /* best effort */ });
+        }
+        return;
+      }
+      // Caching mid-parse would snapshot empty metrics; the parse completion
+      // re-runs this effect a moment later.
+      if (uploadedFiles.some(file => file.isParsing)) return;
+
+      const minted = !sessionIdRef.current;
+      const id = sessionIdRef.current || generateCacheKey();
+      sessionIdRef.current = id;
+      const payload = { id, files: uploadedFiles, globalParsingConfig };
+      pendingSaveRef.current = payload;
+      const timer = setTimeout(() => {
+        if (pendingSaveRef.current === payload) pendingSaveRef.current = null;
+        saveSession(payload)
+          .then(() => {
+            setCacheKey(prev => (prev === id ? prev : id));
+            writeCacheKey(id);
+            // Explain the URL that just appeared — once per browser.
+            if (minted) {
+              try {
+                if (!localStorage.getItem(CACHE_HINT_KEY)) {
+                  localStorage.setItem(CACHE_HINT_KEY, '1');
+                  toastRef.current.info(tRef.current('sessions.firstHint'));
+                }
+              } catch { /* private mode — the hint is optional */ }
+            }
+          })
+          .catch(err => {
+            if (err && (err.name === 'QuotaExceededError' || err.code === 22)) {
+              cacheDisabledRef.current = true;
+              console.warn('Storage quota exceeded; analysis will not be cached.');
+              toastRef.current.warning(tRef.current('toast.storageQuotaExceeded'));
+            } else {
+              console.warn('Failed to cache analysis', err);
+            }
+          });
+      }, 600);
+      return () => clearTimeout(timer);
+    }
+
     // Smart serialization: for large files, only store metricsData (not raw content).
     // Charts still render after refresh, but re-parsing requires re-upload.
     const serialized = uploadedFiles.map(({ id, name, enabled, content, config, metricsData }) => {
@@ -288,7 +442,7 @@ function App() {
         console.warn('Failed to persist uploaded files', err);
       }
     });
-  }, [uploadedFiles, t]);
+  }, [uploadedFiles, globalParsingConfig, t]);
 
   const handleFilesUploaded = useCallback((files) => {
     const filesWithDefaults = files.map(file => ({
@@ -467,12 +621,53 @@ function App() {
     setUploadedFiles([]);
   }, []);
 
+  // Open a cached analysis by its cache key (from the sessions list or a link).
+  const handleOpenSession = useCallback(async (id) => {
+    await flushPendingSave();
+    const record = await loadSession(id);
+    if (!record) {
+      toastRef.current.warning(tRef.current('sessions.notFound'));
+      return;
+    }
+    applySession(id, record);
+    // pushState, not replaceState: Back should return to the previous analysis.
+    writeCacheKey(id, { replace: false });
+  }, [applySession, flushPendingSave]);
+
+  // Start a fresh analysis while keeping the current one in the cache. Without
+  // this the only way to an empty canvas is "clear all", which throws the
+  // current snapshot away — and then the cache never holds more than one entry.
+  const handleNewAnalysis = useCallback(async () => {
+    await flushPendingSave();
+    sessionIdRef.current = null;
+    setCacheKey(null);
+    clearCacheKey();
+    setUploadedFiles([]);
+  }, [flushPendingSave]);
+
+  // Back/forward between cache links, or a link pasted into the same tab.
+  const openSessionRef = useRef(handleOpenSession);
+  useEffect(() => { openSessionRef.current = handleOpenSession; }, [handleOpenSession]);
+  useEffect(() => {
+    const onHashChange = () => {
+      const key = readCacheKey();
+      if (!key || key === sessionIdRef.current) return;
+      openSessionRef.current(key);
+    };
+    window.addEventListener('hashchange', onHashChange);
+    return () => window.removeEventListener('hashchange', onHashChange);
+  }, []);
+
   // Reset configuration
   const handleResetConfig = useCallback(() => {
     savingDisabledRef.current = true;
     localStorage.removeItem('globalParsingConfig');
     localStorage.removeItem('chartConfig');
     clearFilesInStorage();
+    clearSessions();
+    sessionIdRef.current = null;
+    setCacheKey(null);
+    clearCacheKey();
     setGlobalParsingConfig(JSON.parse(JSON.stringify(DEFAULT_GLOBAL_PARSING_CONFIG)));
     setChartConfig({ ...DEFAULT_CHART_CONFIG });
     setUploadedFiles([]);
@@ -675,6 +870,15 @@ function App() {
                     <SettingsIcon size={13} aria-hidden="true" />
                     <span>{t('header.settings')}</span>
                   </button>
+                  <button
+                    onClick={() => setSessionsOpen(true)}
+                    className="inline-flex items-center gap-1.5 px-2 py-1 text-xs font-medium text-gray-700 dark:text-gray-200 hover:bg-gray-100 dark:hover:bg-gray-700 focus:outline-none focus:ring-2 focus:ring-blue-500 rounded-md"
+                    aria-label={t('sessions.aria')}
+                    title={t('sessions.aria')}
+                  >
+                    <History size={13} aria-hidden="true" />
+                    <span>{t('header.sessions')}</span>
+                  </button>
                   <button
                     onClick={() => setHelpOpen(true)}
                     className="inline-flex items-center gap-1.5 px-2 py-1 text-xs font-medium text-gray-700 dark:text-gray-200 hover:bg-gray-100 dark:hover:bg-gray-700 focus:outline-none focus:ring-2 focus:ring-blue-500 rounded-md"
@@ -966,6 +1170,15 @@ function App() {
         }}
       />
 
+      <SessionsModal
+        isOpen={sessionsOpen}
+        onClose={() => setSessionsOpen(false)}
+        currentKey={cacheKey}
+        onOpenSession={handleOpenSession}
+        onNewAnalysis={handleNewAnalysis}
+        hasFiles={uploadedFiles.length > 0}
+      />
+
       <ShortcutHelp
         isOpen={helpOpen}
         onClose={() => setHelpOpen(false)}
diff --git a/src/components/SessionsModal.jsx b/src/components/SessionsModal.jsx
new file mode 100644
index 0000000..a59c562
--- /dev/null
+++ b/src/components/SessionsModal.jsx
@@ -0,0 +1,259 @@
+import React, { useCallback, useEffect, useRef, useState } from 'react';
+import { X, History, Link2, Trash2, FolderOpen, Info, Pencil, FilePlus2 } from 'lucide-react';
+import { useTranslation } from 'react-i18next';
+import { listSessions, deleteSession, clearSessions, renameSession } from '../utils/sessionCache.js';
+import { buildShareUrl } from '../utils/cacheUrl.js';
+import { useToast } from './ToastContext.jsx';
+
+function formatBytes(bytes) {
+  if (!bytes || bytes < 1024) return `${bytes || 0} B`;
+  const units = ['KB', 'MB', 'GB'];
+  let value = bytes / 1024;
+  let i = 0;
+  while (value >= 1024 && i < units.length - 1) {
+    value /= 1024;
+    i += 1;
+  }
+  return `${value < 10 ? value.toFixed(1) : Math.round(value)} ${units[i]}`;
+}
+
+// Cached analyses, Perfetto-style: every snapshot has a `local_cache_key` link
+// that reopens it in this browser. Links are local by design — the modal says
+// so, because a "link" users can't send to a colleague needs explaining once.
+export function SessionsModal({ isOpen, onClose, currentKey, onOpenSession, onNewAnalysis, hasFiles }) {
+  const { t, i18n } = useTranslation();
+  const toast = useToast();
+  const [sessions, setSessions] = useState([]);
+  const [editingId, setEditingId] = useState(null);
+  const [draftName, setDraftName] = useState('');
+  const closeBtnRef = useRef(null);
+
+  const refresh = useCallback(() => {
+    listSessions().then(setSessions).catch(() => setSessions([]));
+  }, []);
+
+  useEffect(() => {
+    if (!isOpen) return;
+    setEditingId(null);
+    refresh();
+    if (closeBtnRef.current) closeBtnRef.current.focus();
+  }, [isOpen, refresh]);
+
+  const commitRename = useCallback(async () => {
+    const id = editingId;
+    const name = draftName.trim();
+    setEditingId(null);
+    if (!id || !name) return;
+    await renameSession(id, name);
+    refresh();
+  }, [editingId, draftName, refresh]);
+
+  const copyLink = useCallback(async (key) => {
+    const url = buildShareUrl(key);
+    try {
+      await navigator.clipboard.writeText(url);
+      toast.success(t('sessions.linkCopied'));
+    } catch {
+      toast.error(t('toast.clipboardUnsupported'));
+    }
+  }, [t, toast]);
+
+  const handleDelete = useCallback(async (id) => {
+    await deleteSession(id);
+    refresh();
+  }, [refresh]);
+
+  const handleClearAll = useCallback(async () => {
+    await clearSessions();
+    refresh();
+  }, [refresh]);
+
+  if (!isOpen) return null;
+
+  return (
+    <div
+      className="fixed inset-0 bg-black/50 z-50 flex items-center justify-center p-4 drag-overlay-fade-in"
+      role="dialog"
+      aria-modal="true"
+      aria-labelledby="sessions-modal-title"
+      onClick={onClose}
+    >
+      <div
+        className="bg-white dark:bg-gray-800 rounded-xl shadow-2xl w-full max-w-2xl max-h-[85vh] flex flex-col drag-modal-scale-in"
+        onClick={(e) => e.stopPropagation()}
+      >
+        <div className="flex items-center justify-between px-5 py-4 border-b border-gray-200 dark:border-gray-700">
+          <div className="flex items-center gap-2">
+            <History size={18} className="text-blue-600 dark:text-blue-400" aria-hidden="true" />
+            <h2 id="sessions-modal-title" className="text-base font-semibold text-gray-900 dark:text-gray-100">
+              {t('sessions.title')}
+            </h2>
+          </div>
+          <button
+            ref={closeBtnRef}
+            type="button"
+            onClick={onClose}
+            className="p-1 text-gray-400 hover:text-gray-700 dark:hover:text-gray-200 rounded focus:outline-none focus:ring-2 focus:ring-blue-500"
+            aria-label={t('sessions.close')}
+          >
+            <X size={18} aria-hidden="true" />
+          </button>
+        </div>
+
+        <div className="flex-1 min-h-0 overflow-y-auto px-5 py-4 space-y-4">
+          <p className="flex items-start gap-2 text-xs text-gray-500 dark:text-gray-400 leading-relaxed">
+            <Info size={14} className="mt-0.5 shrink-0" aria-hidden="true" />
+            <span>{t('sessions.hint')}</span>
+          </p>
+
+          {(currentKey || hasFiles) && (
+            <button
+              type="button"
+              onClick={() => { onNewAnalysis(); onClose(); }}
+              className="w-full inline-flex items-center justify-center gap-1.5 px-3 py-2 text-xs font-medium rounded-md border border-dashed border-gray-300 dark:border-gray-600 text-gray-700 dark:text-gray-200 hover:border-blue-400 hover:text-blue-600 dark:hover:text-blue-400 focus:outline-none focus:ring-2 focus:ring-blue-500"
+            >
+              <FilePlus2 size={14} aria-hidden="true" />
+              {t('sessions.newAnalysis')}
+            </button>
+          )}
+
+          {currentKey && (
+            <div className="rounded-md border border-blue-200 dark:border-blue-900 bg-blue-50 dark:bg-blue-950/40 p-3">
+              <div className="text-xs font-medium text-blue-900 dark:text-blue-200 mb-1.5">
+                {t('sessions.currentLink')}
+              </div>
+              <div className="flex items-center gap-2">
+                <input
+                  readOnly
+                  value={buildShareUrl(currentKey)}
+                  onFocus={(e) => e.target.select()}
+                  className="input-field flex-1 font-mono text-[11px] py-1"
+                  aria-label={t('sessions.currentLink')}
+                />
+                <button
+                  type="button"
+                  onClick={() => copyLink(currentKey)}
+                  className="inline-flex items-center gap-1.5 px-2.5 py-1.5 text-xs font-medium rounded-md bg-blue-600 text-white hover:bg-blue-700 focus:outline-none focus:ring-2 focus:ring-blue-500 shrink-0"
+                >
+                  <Link2 size={13} aria-hidden="true" />
+                  {t('sessions.copyLink')}
+                </button>
+              </div>
+            </div>
+          )}
+
+          {sessions.length === 0 ? (
+            <p className="text-sm text-gray-500 dark:text-gray-400 py-6 text-center">
+              {t('sessions.empty')}
+            </p>
+          ) : (
+            <ul className="space-y-2">
+              {sessions.map(session => {
+                const isCurrent = session.id === currentKey;
+                return (
+                  <li
+                    key={session.id}
+                    className={`flex items-center gap-3 p-3 rounded-md border transition-colors ${
+                      isCurrent
+                        ? 'border-blue-300 dark:border-blue-800 bg-blue-50/60 dark:bg-blue-950/30'
+                        : 'border-gray-200 dark:border-gray-700 hover:bg-gray-50 dark:hover:bg-gray-700/40'
+                    }`}
+                  >
+                    <div className="flex-1 min-w-0">
+                      <div className="flex items-center gap-2">
+                        {editingId === session.id ? (
+                          <input
+                            autoFocus
+                            value={draftName}
+                            onChange={(e) => setDraftName(e.target.value)}
+                            onBlur={commitRename}
+                            onKeyDown={(e) => {
+                              if (e.key === 'Enter') commitRename();
+                              if (e.key === 'Escape') setEditingId(null);
+                            }}
+                            className="input-field py-0.5 text-sm flex-1 min-w-0"
+                            aria-label={t('sessions.rename')}
+                          />
+                        ) : (
+                          <button
+                            type="button"
+                            onClick={() => { setEditingId(session.id); setDraftName(session.name); }}
+                            className="group flex items-center gap-1.5 min-w-0 text-left focus:outline-none focus:ring-2 focus:ring-blue-500 rounded"
+                            title={t('sessions.rename')}
+                          >
+                            <span className="text-sm font-medium text-gray-900 dark:text-gray-100 truncate">
+                              {session.name}
+                            </span>
+                            <Pencil size={11} className="shrink-0 text-gray-400 opacity-0 group-hover:opacity-100" aria-hidden="true" />
+                          </button>
+                        )}
+                        {isCurrent && (
+                          <span className="shrink-0 text-[10px] uppercase tracking-wide px-1.5 py-0.5 rounded bg-blue-600 text-white">
+                            {t('sessions.current')}
+                          </span>
+                        )}
+                      </div>
+                      <div className="text-xs text-gray-500 dark:text-gray-400 mt-0.5 tabular-nums">
+                        {t('sessions.meta', {
+                          files: session.fileCount,
+                          size: formatBytes(session.bytes),
+                          time: new Date(session.updatedAt).toLocaleString(i18n.language)
+                        })}
+                        {session.truncated ? ` · ${t('sessions.truncated')}` : ''}
+                      </div>
+                    </div>
+                    <div className="flex items-center gap-1 shrink-0">
+                      <button
+                        type="button"
+                        onClick={() => { onOpenSession(session.id); onClose(); }}
+                        disabled={isCurrent}
+                        className="p-1.5 rounded text-gray-500 hover:text-blue-600 hover:bg-blue-50 dark:hover:bg-blue-950 disabled:opacity-40 disabled:hover:bg-transparent disabled:hover:text-gray-500 focus:outline-none focus:ring-2 focus:ring-blue-500"
+                        aria-label={t('sessions.open')}
+                        title={t('sessions.open')}
+                      >
+                        <FolderOpen size={15} aria-hidden="true" />
+                      </button>
+                      <button
+                        type="button"
+                        onClick={() => copyLink(session.id)}
+                        className="p-1.5 rounded text-gray-500 hover:text-blue-600 hover:bg-blue-50 dark:hover:bg-blue-950 focus:outline-none focus:ring-2 focus:ring-blue-500"
+                        aria-label={t('sessions.copyLink')}
+                        title={t('sessions.copyLink')}
+                      >
+                        <Link2 size={15} aria-hidden="true" />
+                      </button>
+                      <button
+                        type="button"
+                        onClick={() => handleDelete(session.id)}
+                        className="p-1.5 rounded text-gray-500 hover:text-red-600 hover:bg-red-50 dark:hover:bg-red-950 focus:outline-none focus:ring-2 focus:ring-red-500"
+                        aria-label={t('sessions.delete')}
+                        title={t('sessions.delete')}
+                      >
+                        <Trash2 size={15} aria-hidden="true" />
+                      </button>
+                    </div>
+                  </li>
+                );
+              })}
+            </ul>
+          )}
+        </div>
+
+        {sessions.length > 0 && (
+          <div className="px-5 py-3 border-t border-gray-200 dark:border-gray-700 flex justify-end">
+            <button
+              type="button"
+              onClick={handleClearAll}
+              className="inline-flex items-center gap-1.5 px-2.5 py-1.5 text-xs font-medium rounded-md text-red-600 dark:text-red-400 hover:bg-red-50 dark:hover:bg-red-950 focus:outline-none focus:ring-2 focus:ring-red-500"
+            >
+              <Trash2 size={13} aria-hidden="true" />
+              {t('sessions.clearAll')}
+            </button>
+          </div>
+        )}
+      </div>
+    </div>
+  );
+}
+
+export default SessionsModal;
diff --git a/src/components/__tests__/SessionCache.test.jsx b/src/components/__tests__/SessionCache.test.jsx
new file mode 100644
index 0000000..265e200
--- /dev/null
+++ b/src/components/__tests__/SessionCache.test.jsx
@@ -0,0 +1,139 @@
+// End-to-end check of the Perfetto-style cache: uploading a log mints a
+// `local_cache_key`, and that key brings the same analysis back on reload.
+import 'fake-indexeddb/auto';
+import React from 'react';
+import { render, screen, waitFor, cleanup } from '@testing-library/react';
+import userEvent from '@testing-library/user-event';
+import { describe, it, expect, beforeEach, afterEach, vi } from 'vitest';
+import '@testing-library/jest-dom/vitest';
+import App from '../../App.jsx';
+import { ToastProvider } from '../ToastContext.jsx';
+import i18n from '../../i18n';
+import { clearSessions, listSessions } from '../../utils/sessionCache.js';
+import { readCacheKey } from '../../utils/cacheUrl.js';
+
+vi.mock('chart.js', () => {
+  const Chart = {
+    register: vi.fn(),
+    defaults: { plugins: { legend: { labels: { generateLabels: vi.fn(() => []) } } } }
+  };
+  return {
+    Chart, ChartJS: Chart, CategoryScale: {}, LinearScale: {}, LogarithmicScale: {},
+    PointElement: {}, LineElement: {}, BarElement: {}, BarController: {},
+    LineController: {}, ScatterController: {}, Title: {}, Tooltip: {}, Legend: {}
+  };
+});
+vi.mock('react-chartjs-2', async () => {
+  const ReactMod = await import('react');
+  const Stub = ReactMod.forwardRef(() => <div data-testid="line-chart" />);
+  return { Chart: Stub, Line: Stub, Scatter: Stub, Bar: Stub };
+});
+vi.mock('chartjs-plugin-zoom', () => ({ default: {} }));
+vi.mock('chartjs-plugin-annotation', () => ({ default: {} }));
+
+// The setup-file Worker mock echoes messages back unchanged, which leaves files
+// stuck "parsing"; the cache deliberately waits for metrics, so answer properly.
+class ParsingWorker {
+  constructor() { this.onmessage = () => {}; }
+  postMessage({ type, payload }) {
+    if (type !== 'PARSE_FILE') return;
+    setTimeout(() => {
+      this.onmessage({
+        data: {
+          type: 'PARSE_COMPLETE',
+          payload: { fileId: payload.fileId, metricsData: { Loss: [{ x: 0, y: 1 }] } }
+        }
+      });
+    }, 0);
+  }
+  terminate() {}
+}
+
+function stubFileReader(result) {
+  class FileReaderMock {
+    constructor() { this.onload = null; }
+    readAsText() { this.onload({ target: { result } }); }
+  }
+  global.FileReader = FileReaderMock;
+}
+
+async function uploadLog(user, name = 'train.log') {
+  const input = screen.getByLabelText(i18n.t('fileUpload.aria'));
+  await user.upload(input, new File(['loss: 1'], name, { type: 'text/plain' }));
+}
+
+describe('local_cache_key session cache', () => {
+  beforeEach(async () => {
+    localStorage.clear();
+    window.location.hash = '';
+    global.Worker = ParsingWorker;
+    stubFileReader('loss: 1');
+    await clearSessions();
+  });
+
+  afterEach(() => {
+    cleanup();
+  });
+
+  it('mints a cache key in the URL after a log is parsed', async () => {
+    const user = userEvent.setup();
+    render(<App />);
+    await uploadLog(user);
+
+    await waitFor(() => expect(readCacheKey()).not.toBeNull(), { timeout: 4000 });
+    const key = readCacheKey();
+    expect(window.location.hash).toContain('local_cache_key=');
+
+    const sessions = await listSessions();
+    expect(sessions).toHaveLength(1);
+    expect(sessions[0].id).toBe(key);
+    expect(sessions[0].fileNames).toEqual(['train.log']);
+  }, 15000);
+
+  it('restores the analysis from the cache key on reload', async () => {
+    const user = userEvent.setup();
+    const { unmount } = render(<App />);
+    await uploadLog(user);
+    await waitFor(() => expect(readCacheKey()).not.toBeNull(), { timeout: 4000 });
+    const key = readCacheKey();
+    unmount();
+    cleanup();
+
+    // Simulate a reload landing on the cache link: no localStorage working set,
+    // only the key in the URL.
+    localStorage.removeItem('uploadedFiles');
+    window.location.hash = `#!/viewer?local_cache_key=${key}`;
+    render(<App />);
+
+    expect(await screen.findByText('train.log', {}, { timeout: 4000 })).toBeInTheDocument();
+    expect(readCacheKey()).toBe(key);
+  }, 15000);
+
+  it('keeps the previous analysis cached when starting a new one', async () => {
+    const user = userEvent.setup();
+    render(<App />);
+    await uploadLog(user, 'run-a.log');
+    await waitFor(() => expect(readCacheKey()).not.toBeNull(), { timeout: 4000 });
+    const firstKey = readCacheKey();
+
+    await user.click(screen.getByLabelText(i18n.t('sessions.aria')));
+    await user.click(await screen.findByText(i18n.t('sessions.newAnalysis')));
+    await waitFor(() => expect(readCacheKey()).toBeNull());
+
+    await uploadLog(user, 'run-b.log');
+    await waitFor(() => expect(readCacheKey()).not.toBeNull(), { timeout: 4000 });
+    expect(readCacheKey()).not.toBe(firstKey);
+
+    const sessions = await listSessions();
+    expect(sessions).toHaveLength(2);
+    expect(sessions.map(s => s.name).sort()).toEqual(['run-a.log', 'run-b.log']);
+  }, 15000);
+
+  it('warns and drops the key when the link is not cached in this browser', async () => {
+    window.location.hash = '#!/viewer?local_cache_key=11111111-2222-3333-4444-555555555555';
+    render(<ToastProvider><App /></ToastProvider>);
+
+    expect(await screen.findByText(i18n.t('sessions.notFound'), {}, { timeout: 4000 })).toBeInTheDocument();
+    await waitFor(() => expect(readCacheKey()).toBeNull());
+  }, 15000);
+});
diff --git a/src/utils/__tests__/cacheUrl.test.js b/src/utils/__tests__/cacheUrl.test.js
new file mode 100644
index 0000000..1271be6
--- /dev/null
+++ b/src/utils/__tests__/cacheUrl.test.js
@@ -0,0 +1,59 @@
+import { describe, it, expect } from 'vitest';
+import {
+  parseCacheKey,
+  buildCacheHash,
+  isValidCacheKey,
+  generateCacheKey,
+  buildShareUrl,
+  CACHE_KEY_PARAM
+} from '../cacheUrl';
+
+const KEY = '00000000-0000-0000-1343-6d0de2416d47';
+
+describe('cacheUrl', () => {
+  it('parses a key out of a viewer hash', () => {
+    expect(parseCacheKey(`#!/viewer?${CACHE_KEY_PARAM}=${KEY}`)).toBe(KEY);
+  });
+
+  it('ignores hashes without a key', () => {
+    expect(parseCacheKey('')).toBeNull();
+    expect(parseCacheKey('#!/viewer')).toBeNull();
+    expect(parseCacheKey('#!/viewer?other=1')).toBeNull();
+  });
+
+  it('rejects keys that are not cache-key shaped', () => {
+    expect(parseCacheKey(`#!/viewer?${CACHE_KEY_PARAM}=../etc/passwd`)).toBeNull();
+    expect(parseCacheKey(`#!/viewer?${CACHE_KEY_PARAM}=abc`)).toBeNull();
+    expect(isValidCacheKey(KEY)).toBe(true);
+    expect(isValidCacheKey(undefined)).toBe(false);
+  });
+
+  it('builds a hash and round-trips through the parser', () => {
+    const hash = buildCacheHash(KEY);
+    expect(hash).toBe(`#!/viewer?${CACHE_KEY_PARAM}=${KEY}`);
+    expect(parseCacheKey(hash)).toBe(KEY);
+  });
+
+  it('preserves other params already in the hash', () => {
+    const hash = buildCacheHash(KEY, '#!/viewer?tab=stats');
+    expect(hash).toContain('tab=stats');
+    expect(parseCacheKey(hash)).toBe(KEY);
+  });
+
+  it('drops the key (and the hash entirely) when clearing', () => {
+    expect(buildCacheHash(null, `#!/viewer?${CACHE_KEY_PARAM}=${KEY}`)).toBe('');
+    expect(buildCacheHash(null, `#!/viewer?${CACHE_KEY_PARAM}=${KEY}&tab=stats`)).toBe('#!/viewer?tab=stats');
+  });
+
+  it('generates unique, valid keys', () => {
+    const a = generateCacheKey();
+    const b = generateCacheKey();
+    expect(isValidCacheKey(a)).toBe(true);
+    expect(a).not.toBe(b);
+  });
+
+  it('builds an absolute share url from a location', () => {
+    const loc = { origin: 'https://log.javazero.top', pathname: '/', search: '', hash: '#whatever' };
+    expect(buildShareUrl(KEY, loc)).toBe(`https://log.javazero.top/#!/viewer?${CACHE_KEY_PARAM}=${KEY}`);
+  });
+});
diff --git a/src/utils/__tests__/sessionCache.test.js b/src/utils/__tests__/sessionCache.test.js
new file mode 100644
index 0000000..ec8cd4c
--- /dev/null
+++ b/src/utils/__tests__/sessionCache.test.js
@@ -0,0 +1,225 @@
+// jsdom has no IndexedDB, so this suite runs the real store logic against
+// fake-indexeddb — the same code path browsers take.
+import 'fake-indexeddb/auto';
+import { describe, it, expect, beforeEach, vi } from 'vitest';
+import {
+  saveSession,
+  loadSession,
+  listSessions,
+  deleteSession,
+  clearSessions,
+  pruneSessions,
+  renameSession,
+  planWrites,
+  packMetrics,
+  unpackMetrics,
+  metricsFingerprint,
+  estimateBytes,
+  deriveSessionName,
+  isCacheAvailable,
+  MAX_SESSIONS,
+  MAX_AGE_MS
+} from '../sessionCache';
+
+const SERIES = [{ x: 0, y: 1 }, { x: 1, y: 0.5 }];
+
+function file(name, content = 'loss: 1\n', metrics = { Loss: SERIES }) {
+  return {
+    id: name,
+    name,
+    enabled: true,
+    content,
+    config: { metrics: [] },
+    metricsData: metrics,
+    // runtime-only fields that must not be persisted
+    isParsing: true,
+    progress: 0.5
+  };
+}
+
+describe('sessionCache', () => {
+  beforeEach(async () => {
+    await clearSessions();
+  });
+
+  it('reports availability when IndexedDB exists', () => {
+    expect(isCacheAvailable()).toBe(true);
+  });
+
+  it('round-trips a snapshot under its cache key', async () => {
+    await saveSession({
+      id: 'key-1',
+      files: [file('a.log')],
+      globalParsingConfig: { stepKeyword: 'iter:' }
+    });
+    const record = await loadSession('key-1');
+    expect(record.files).toHaveLength(1);
+    expect(record.files[0].name).toBe('a.log');
+    expect(record.files[0].content).toBe('loss: 1\n');
+    expect(record.files[0].metricsData.Loss).toEqual(SERIES);
+    expect(record.globalParsingConfig.stepKeyword).toBe('iter:');
+  });
+
+  it('strips runtime-only fields from the snapshot', async () => {
+    await saveSession({ id: 'key-1', files: [file('a.log')] });
+    const record = await loadSession('key-1');
+    expect(record.files[0].isParsing).toBeUndefined();
+    expect(record.files[0].progress).toBeUndefined();
+  });
+
+  it('returns null for an unknown key', async () => {
+    expect(await loadSession('00000000-0000-0000-0000-000000000000')).toBeNull();
+  });
+
+  it('overwrites in place and keeps the original creation time', async () => {
+    const first = await saveSession({ id: 'key-1', files: [file('a.log')] });
+    await saveSession({ id: 'key-1', files: [file('a.log'), file('b.log')] });
+    const list = await listSessions();
+    expect(list).toHaveLength(1);
+    expect(list[0].fileCount).toBe(2);
+    expect(list[0].createdAt).toBe(first.createdAt);
+  });
+
+  it('drops the records of files removed from a session', async () => {
+    await saveSession({ id: 'key-1', files: [file('a.log'), file('b.log')] });
+    await saveSession({ id: 'key-1', files: [file('a.log')] });
+    const record = await loadSession('key-1');
+    expect(record.files.map(f => f.name)).toEqual(['a.log']);
+  });
+
+  it('lists summaries newest first, without file contents', async () => {
+    const t0 = Date.now();
+    await saveSession({ id: 'key-1', files: [file('a.log')], now: t0 });
+    await saveSession({ id: 'key-2', files: [file('b.log'), file('c.log')], now: t0 + 1000 });
+    const list = await listSessions();
+    expect(list.map(s => s.id)).toEqual(['key-2', 'key-1']);
+    expect(list[0].name).toBe('b.log +1');
+    expect(list[0].fileNames).toEqual(['b.log', 'c.log']);
+    expect(list[0].files).toBeUndefined();
+  });
+
+  it('renames a snapshot without touching its payload', async () => {
+    await saveSession({ id: 'key-1', files: [file('a.log')] });
+    await renameSession('key-1', 'ResNet sweep');
+    const [summary] = await listSessions();
+    expect(summary.name).toBe('ResNet sweep');
+    expect((await loadSession('key-1')).files).toHaveLength(1);
+    // A later save keeps the chosen name rather than reverting to file names.
+    await saveSession({ id: 'key-1', files: [file('a.log'), file('b.log')] });
+    expect((await listSessions())[0].name).toBe('ResNet sweep');
+  });
+
+  it('deletes a snapshot and its summary', async () => {
+    await saveSession({ id: 'key-1', files: [file('a.log')] });
+    await deleteSession('key-1');
+    expect(await loadSession('key-1')).toBeNull();
+    expect(await listSessions()).toEqual([]);
+  });
+
+  it('evicts the least recently used snapshot past the count ceiling', async () => {
+    for (let i = 0; i < MAX_SESSIONS + 2; i += 1) {
+      await saveSession({ id: `key-${String(i).padStart(3, '0')}`, files: [file(`f${i}.log`)] });
+    }
+    const list = await listSessions();
+    expect(list).toHaveLength(MAX_SESSIONS);
+    expect(list.some(s => s.id === 'key-000')).toBe(false);
+    expect(list.some(s => s.id === `key-${String(MAX_SESSIONS + 1).padStart(3, '0')}`)).toBe(true);
+  });
+
+  it('never evicts the snapshot being written', async () => {
+    await saveSession({ id: 'keep-me', files: [file('a.log')] });
+    const evicted = await pruneSessions({
+      keepId: 'keep-me',
+      now: Date.now() + MAX_AGE_MS * 2
+    });
+    expect(evicted).toEqual([]);
+    expect(await loadSession('keep-me')).not.toBeNull();
+  });
+
+  it('evicts snapshots older than the age ceiling', async () => {
+    await saveSession({ id: 'key-old', files: [file('a.log')] });
+    const evicted = await pruneSessions({ now: Date.now() + MAX_AGE_MS + 1000 });
+    expect(evicted).toEqual(['key-old']);
+    expect(await listSessions()).toEqual([]);
+  });
+
+  it('evicts past the byte ceiling, least recently used first', async () => {
+    const t0 = Date.now();
+    await saveSession({ id: 'small-old', files: [file('a.log', 'x'.repeat(1000))], now: t0 });
+    await saveSession({ id: 'small-new', files: [file('b.log', 'x'.repeat(1000))], now: t0 + 1000 });
+    const evicted = await pruneSessions({ budget: 1500, now: t0 + 2000 });
+    expect(evicted).toEqual(['small-old']);
+    expect((await listSessions()).map(s => s.id)).toEqual(['small-new']);
+  });
+
+  describe('incremental writes', () => {
+    // Writing content and metrics on every state change is what made the first
+    // version unusable with many large logs; these are the rules that stop it.
+    it('writes content and metrics on the first save', () => {
+      const plan = planWrites([file('a.log')], null, 'key-1');
+      expect(plan.contentWrites).toHaveLength(1);
+      expect(plan.metricsWrites).toHaveLength(1);
+    });
+
+    it('writes nothing but metadata when only a checkbox changed', () => {
+      const first = planWrites([file('a.log')], null, 'key-1');
+      const previous = { files: first.entries };
+      const toggled = { ...file('a.log'), enabled: false };
+      const plan = planWrites([toggled], previous, 'key-1');
+      expect(plan.contentWrites).toEqual([]);
+      expect(plan.metricsWrites).toEqual([]);
+      expect(plan.entries[0].enabled).toBe(false);
+    });
+
+    it('does not even encode content it is not going to write', () => {
+      // Encoding first and deciding after is the same cost as writing: it put
+      // seconds back into every checkbox toggle once before.
+      const first = planWrites([file('a.log')], null, 'key-1');
+      const encode = vi.spyOn(TextEncoder.prototype, 'encode');
+      planWrites([{ ...file('a.log'), enabled: false }], { files: first.entries }, 'key-1');
+      expect(encode).not.toHaveBeenCalled();
+      encode.mockRestore();
+    });
+
+    it('rewrites metrics — and only metrics — after a re-parse', () => {
+      const first = planWrites([file('a.log')], null, 'key-1');
+      const previous = { files: first.entries };
+      const reparsed = { ...file('a.log'), metricsData: { Loss: [{ x: 0, y: 9 }] } };
+      const plan = planWrites([reparsed], previous, 'key-1');
+      expect(plan.contentWrites).toEqual([]);
+      expect(plan.metricsWrites).toHaveLength(1);
+    });
+
+    it('reports files that dropped out of the session', () => {
+      const first = planWrites([file('a.log'), file('b.log')], null, 'key-1');
+      const plan = planWrites([file('a.log')], { files: first.entries }, 'key-1');
+      expect(plan.staleIds).toEqual(['b.log']);
+    });
+  });
+
+  it('packs and unpacks series losslessly', () => {
+    const metrics = { Loss: [{ x: 0, y: 1.5 }, { x: 10, y: -2.25e-8 }] };
+    const packed = packMetrics(metrics);
+    expect(packed.Loss.x).toBeInstanceOf(Float64Array);
+    expect(unpackMetrics(packed)).toEqual(metrics);
+  });
+
+  it('fingerprints a parse by count and endpoints', () => {
+    const a = metricsFingerprint({ Loss: SERIES });
+    expect(metricsFingerprint({ Loss: [...SERIES] })).toBe(a);
+    expect(metricsFingerprint({ Loss: [...SERIES, { x: 2, y: 3 }] })).not.toBe(a);
+    expect(metricsFingerprint({ Loss: [{ x: 0, y: 1 }, { x: 1, y: 0.6 }] })).not.toBe(a);
+  });
+
+  it('sizes a snapshot from content bytes and point counts', () => {
+    expect(estimateBytes([])).toBe(0);
+    expect(estimateBytes([{ content: 'abcde', metricsData: { L: [1, 2, 3] } }])).toBe(5 + 3 * 16);
+    expect(estimateBytes([{ content: 'ab', metricsData: {} }])).toBe(2);
+  });
+
+  it('names a session after its files', () => {
+    expect(deriveSessionName([])).toBe('Untitled');
+    expect(deriveSessionName([{ name: 'a.log' }])).toBe('a.log');
+    expect(deriveSessionName([{ name: 'a.log' }, { name: 'b.log' }])).toBe('a.log +1');
+  });
+});
diff --git a/src/utils/cacheUrl.js b/src/utils/cacheUrl.js
new file mode 100644
index 0000000..61efb5e
--- /dev/null
+++ b/src/utils/cacheUrl.js
@@ -0,0 +1,83 @@
+// URL plumbing for Perfetto-style cache links.
+//
+// A cached analysis is addressed by an opaque key carried in the location hash:
+//   https://log.javazero.top/#!/viewer?local_cache_key=<uuid>
+// The hash (rather than a query string) keeps this a purely client-side route,
+// so it works unchanged on GitHub Pages, Vercel and `vite preview`.
+//
+// The key names a snapshot in *this browser's* IndexedDB — it is a bookmark,
+// not a share link. Opening it elsewhere yields "not found" by design; nothing
+// ever leaves the machine.
+
+export const CACHE_KEY_PARAM = 'local_cache_key';
+export const VIEWER_ROUTE = '!/viewer';
+
+const KEY_RE = /^[0-9a-fA-F][0-9a-fA-F-]{7,63}$/;
+
+export function isValidCacheKey(key) {
+  return typeof key === 'string' && KEY_RE.test(key);
+}
+
+export function generateCacheKey() {
+  if (typeof crypto !== 'undefined' && typeof crypto.randomUUID === 'function') {
+    return crypto.randomUUID();
+  }
+  // Fallback for older/insecure contexts where randomUUID is unavailable.
+  const rnd = () => Math.floor((1 + Math.random()) * 0x10000).toString(16).slice(1);
+  return `${rnd()}${rnd()}-${rnd()}-${rnd()}-${rnd()}-${rnd()}${rnd()}${rnd()}`;
+}
+
+// Pull the key out of a raw location hash (with or without the leading '#').
+export function parseCacheKey(hash) {
+  if (!hash) return null;
+  const q = String(hash).indexOf('?');
+  if (q === -1) return null;
+  let value = null;
+  try {
+    value = new URLSearchParams(String(hash).slice(q + 1)).get(CACHE_KEY_PARAM);
+  } catch {
+    return null;
+  }
+  return isValidCacheKey(value) ? value : null;
+}
+
+// Build the hash for a key, preserving any other params already in `hash`.
+export function buildCacheHash(key, hash = '') {
+  const q = String(hash).indexOf('?');
+  const params = new URLSearchParams(q === -1 ? '' : String(hash).slice(q + 1));
+  if (key) {
+    params.set(CACHE_KEY_PARAM, key);
+  } else {
+    params.delete(CACHE_KEY_PARAM);
+  }
+  const qs = params.toString();
+  if (!qs) return '';
+  return `#${VIEWER_ROUTE}?${qs}`;
+}
+
+export function readCacheKey(loc = typeof window !== 'undefined' ? window.location : null) {
+  return loc ? parseCacheKey(loc.hash) : null;
+}
+
+// Rewrite the address bar without reloading or adding history noise.
+export function writeCacheKey(key, { replace = true } = {}) {
+  if (typeof window === 'undefined' || !window.history) return;
+  const { pathname, search, hash } = window.location;
+  const nextHash = buildCacheHash(key, hash);
+  const url = `${pathname}${search}${nextHash}`;
+  if (url === `${pathname}${search}${hash}`) return;
+  if (replace) {
+    window.history.replaceState(window.history.state, '', url);
+  } else {
+    window.history.pushState(window.history.state, '', url);
+  }
+}
+
+export function clearCacheKey() {
+  writeCacheKey(null);
+}
+
+export function buildShareUrl(key, loc = typeof window !== 'undefined' ? window.location : null) {
+  if (!loc) return '';
+  return `${loc.origin}${loc.pathname}${loc.search}${buildCacheHash(key, '')}`;
+}
diff --git a/src/utils/fileStorage.js b/src/utils/fileStorage.js
index ced7879..398d238 100644
--- a/src/utils/fileStorage.js
+++ b/src/utils/fileStorage.js
@@ -1,39 +1,17 @@
-// File persistence layer. Prefers IndexedDB (multi-MB capacity) and falls back
-// to localStorage where IndexedDB is unavailable (e.g. jsdom tests, restricted
-// contexts). All keys are stable so legacy localStorage data is migrated on
-// first IndexedDB load.
+// File persistence layer for the active working set. Prefers IndexedDB
+// (multi-MB capacity) and falls back to localStorage where IndexedDB is
+// unavailable (e.g. jsdom tests, restricted contexts). All keys are stable so
+// legacy localStorage data is migrated on first IndexedDB load.
+//
+// Snapshots addressable by a cache key live in sessionCache.js; both share the
+// database opened by idb.js.
+
+import { openDB, hasIDB, FILES_STORE as STORE } from './idb.js';
 
-const DB_NAME = 'log-parser';
-const DB_VERSION = 1;
-const STORE = 'files';
 const FILES_KEY = 'all';
 export const LEGACY_LS_KEY = 'uploadedFiles';
 const LS_MAX_BYTES = 5 * 1024 * 1024;
 
-const hasIDB = typeof indexedDB !== 'undefined';
-
-let dbPromise = null;
-
-function openDB() {
-  if (!hasIDB) return Promise.reject(new Error('IndexedDB unavailable'));
-  if (!dbPromise) {
-    dbPromise = new Promise((resolve, reject) => {
-      const req = indexedDB.open(DB_NAME, DB_VERSION);
-      req.onupgradeneeded = () => {
-        const db = req.result;
-        if (!db.objectStoreNames.contains(STORE)) {
-          db.createObjectStore(STORE);
-        }
-      };
-      req.onsuccess = () => resolve(req.result);
-      req.onerror = () => reject(req.error);
-      req.onblocked = () => reject(new Error('IndexedDB open blocked'));
-    });
-    dbPromise.catch(() => { dbPromise = null; });
-  }
-  return dbPromise;
-}
-
 function quotaError(message) {
   const err = new Error(message);
   err.name = 'QuotaExceededError';
@@ -87,7 +65,7 @@ async function idbDelete() {
 }
 
 export async function loadFiles() {
-  if (hasIDB) {
+  if (hasIDB()) {
     try {
       const data = await idbGetAll();
       if (Array.isArray(data) && data.length > 0) {
@@ -113,7 +91,7 @@ export async function loadFiles() {
 }
 
 export async function saveFiles(files) {
-  if (hasIDB) {
+  if (hasIDB()) {
     try {
       await idbPut(files);
       try { localStorage.removeItem(LEGACY_LS_KEY); } catch { /* ignore */ }
@@ -142,13 +120,11 @@ export async function saveFiles(files) {
 }
 
 export async function clearFiles() {
-  if (hasIDB) {
+  if (hasIDB()) {
     try { await idbDelete(); } catch { /* ignore */ }
   }
   try { localStorage.removeItem(LEGACY_LS_KEY); } catch { /* ignore */ }
 }
 
 // Exposed for tests: clears in-memory DB promise so a fresh open is attempted.
-export function _resetForTests() {
-  dbPromise = null;
-}
+export { _resetDbForTests as _resetForTests } from './idb.js';
diff --git a/src/utils/idb.js b/src/utils/idb.js
new file mode 100644
index 0000000..5133098
--- /dev/null
+++ b/src/utils/idb.js
@@ -0,0 +1,90 @@
+// Shared IndexedDB handle for the app.
+//
+// The object stores live in one database and therefore must be created by a
+// single upgrade path — two modules opening the same database at different
+// versions would make the older opener fail with a VersionError:
+//   files        – the single active working set (fileStorage.js)
+//   sessionIndex – lightweight summaries, so listing cached analyses never
+//                  touches log text
+//   sessions     – per-analysis metadata: file names, enabled flags, configs,
+//                  and references into the two stores below
+//   content      – one record per file, holding the raw log
+//   metrics      – one record per file, holding parsed series as typed arrays
+//
+// Content and metrics are split out of the session record on purpose: they are
+// large and rarely change, while the session record is small and rewritten on
+// every checkbox toggle. Keeping them together made a toggle rewrite hundreds
+// of megabytes (measured at ~1.5s per 100MB); split, it writes ~1ms.
+
+const DB_NAME = 'log-parser';
+const DB_VERSION = 3;
+
+export const FILES_STORE = 'files';
+export const SESSIONS_STORE = 'sessions';
+export const SESSION_INDEX_STORE = 'sessionIndex';
+export const CONTENT_STORE = 'content';
+export const METRICS_STORE = 'metrics';
+
+export function hasIDB() {
+  return typeof indexedDB !== 'undefined';
+}
+
+let dbPromise = null;
+
+export function openDB() {
+  if (!hasIDB()) return Promise.reject(new Error('IndexedDB unavailable'));
+  if (!dbPromise) {
+    dbPromise = new Promise((resolve, reject) => {
+      const req = indexedDB.open(DB_NAME, DB_VERSION);
+      req.onupgradeneeded = () => {
+        const db = req.result;
+        if (!db.objectStoreNames.contains(FILES_STORE)) {
+          db.createObjectStore(FILES_STORE);
+        }
+        if (!db.objectStoreNames.contains(SESSIONS_STORE)) {
+          db.createObjectStore(SESSIONS_STORE, { keyPath: 'id' });
+        }
+        if (!db.objectStoreNames.contains(SESSION_INDEX_STORE)) {
+          const idx = db.createObjectStore(SESSION_INDEX_STORE, { keyPath: 'id' });
+          idx.createIndex('lastAccess', 'lastAccess');
+        }
+        if (!db.objectStoreNames.contains(CONTENT_STORE)) {
+          db.createObjectStore(CONTENT_STORE);
+        }
+        if (!db.objectStoreNames.contains(METRICS_STORE)) {
+          db.createObjectStore(METRICS_STORE);
+        }
+      };
+      req.onsuccess = () => resolve(req.result);
+      req.onerror = () => reject(req.error);
+      req.onblocked = () => reject(new Error('IndexedDB open blocked'));
+    });
+    dbPromise.catch(() => { dbPromise = null; });
+  }
+  return dbPromise;
+}
+
+// Promisify a request inside a transaction the caller owns.
+export function requestToPromise(req) {
+  return new Promise((resolve, reject) => {
+    req.onsuccess = () => resolve(req.result);
+    req.onerror = () => reject(req.error);
+  });
+}
+
+export function txDone(tx) {
+  return new Promise((resolve, reject) => {
+    tx.oncomplete = () => resolve();
+    tx.onerror = () => reject(tx.error);
+    tx.onabort = () => reject(tx.error || new Error('IndexedDB transaction aborted'));
+  });
+}
+
+export function isQuotaError(err) {
+  return !!err && (err.name === 'QuotaExceededError' || err.code === 22);
+}
+
+// Exposed for tests: forces a fresh open on the next call.
+export function _resetDbForTests() {
+  dbPromise = null;
+}
diff --git a/src/utils/sessionCache.js b/src/utils/sessionCache.js
new file mode 100644
index 0000000..e0c74d3
--- /dev/null
+++ b/src/utils/sessionCache.js
@@ -0,0 +1,486 @@
+// Perfetto-style local cache for parsed logs.
+//
+// ui.perfetto.dev keeps every opened trace in browser storage under a UUID and
+// puts that UUID in the URL (`?local_cache_key=…`), so a reload, a bookmark or
+// a second tab can bring the exact same trace back without re-uploading it.
+// This module is the same idea for log analyses: each snapshot (files + their
+// parsed metrics + the parsing config that produced them) is written to
+// IndexedDB under a cache key, and `cacheUrl.js` puts that key in the hash.
+//
+// Layout matters here, because people routinely open a lot of large logs:
+//
+//   sessionIndex  small summary per analysis — listing never reads log text
+//   sessions      small metadata record — names, enabled flags, configs, refs
+//   content       one record per file, holding the raw log (a Blob when the
+//                 original File is still around, which stores by reference)
+//   metrics       one record per file, series packed as Float64Array pairs
+//
+// Content and metrics are written only when they actually change, so toggling a
+// checkbox or editing a range rewrites the small record and nothing else. The
+// measurements that drove this (Chromium, IndexedDB): 100MB of logs in one
+// record costs ~1.5s to write and was rewritten on *every* state change; split
+// out, the same toggle writes ~1ms. Packing 1M points as typed arrays instead
+// of {x,y} objects took writes from 779ms to 106ms and reads from 931ms to
+// 191ms.
+//
+// Eviction is LRU with age, count and byte ceilings — a cache that grows until
+// the browser kills the origin's storage is worse than one that forgets.
+
+import {
+  openDB,
+  hasIDB,
+  isQuotaError,
+  requestToPromise,
+  txDone,
+  SESSIONS_STORE,
+  SESSION_INDEX_STORE,
+  CONTENT_STORE,
+  METRICS_STORE
+} from './idb.js';
+
+export const MAX_SESSIONS = 20;
+// Ceiling on everything the cache holds. Also clamped to half the origin's
+// reported quota, so a small disk doesn't get filled by cached logs.
+export const MAX_TOTAL_BYTES = 2 * 1024 * 1024 * 1024;
+export const MIN_TOTAL_BYTES = 128 * 1024 * 1024;
+export const MAX_AGE_MS = 30 * 24 * 60 * 60 * 1000;
+// Two Float64s per point.
+const BYTES_PER_POINT = 16;
+
+export function isCacheAvailable() {
+  return hasIDB();
+}
+
+const recordKey = (sessionId, fileId) => `${sessionId}:${fileId}`;
+const sessionRange = (sessionId) => IDBKeyRange.bound(`${sessionId}:`, `${sessionId}:￿`);
+
+// Ask the browser not to evict us under storage pressure. Best effort: it is a
+// no-op where unsupported, and a denial just means the cache behaves as before.
+let persistRequested = false;
+function requestPersistence() {
+  if (persistRequested) return;
+  persistRequested = true;
+  try {
+    navigator?.storage?.persist?.().catch(() => {});
+  } catch { /* unsupported */ }
+}
+
+async function totalBudget() {
+  try {
+    const quota = (await navigator?.storage?.estimate?.())?.quota;
+    if (quota) {
+      return Math.max(MIN_TOTAL_BYTES, Math.min(MAX_TOTAL_BYTES, Math.floor(quota / 2)));
+    }
+  } catch { /* estimate unavailable */ }
+  return MAX_TOTAL_BYTES;
+}
+
+export function countPoints(metricsData) {
+  return Object.values(metricsData || {})
+    .reduce((n, series) => n + (Array.isArray(series) ? series.length : 0), 0);
+}
+
+// Byte cost of one file's cached form: raw log plus packed series. Content is
+// sized by character count — an upper bound for the UTF-8 bytes actually
+// stored, for the ASCII that training logs are made of.
+export function fileBytes(file) {
+  return contentBytes(file) + countPoints(file.metricsData) * BYTES_PER_POINT;
+}
+
+export function estimateBytes(files) {
+  return (files || []).reduce((total, file) => total + fileBytes(file), 0);
+}
+
+// Points are plain {x, y} numbers (see logParser.worker.js), so two Float64
+// arrays hold them losslessly at a fraction of the structured-clone cost.
+export function packMetrics(metricsData) {
+  const packed = {};
+  Object.keys(metricsData || {}).forEach(name => {
+    const series = metricsData[name];
+    if (!Array.isArray(series)) return;
+    const x = new Float64Array(series.length);
+    const y = new Float64Array(series.length);
+    for (let i = 0; i < series.length; i += 1) {
+      const point = series[i] || {};
+      x[i] = point.x;
+      y[i] = point.y;
+    }
+    packed[name] = { x, y };
+  });
+  return packed;
+}
+
+export function unpackMetrics(packed) {
+  const out = {};
+  Object.keys(packed || {}).forEach(name => {
+    const entry = packed[name];
+    if (!entry) return;
+    if (Array.isArray(entry)) { out[name] = entry; return; }
+    const { x, y } = entry;
+    const points = new Array(x.length);
+    for (let i = 0; i < x.length; i += 1) points[i] = { x: x[i], y: y[i] };
+    out[name] = points;
+  });
+  return out;
+}
+
+// Cheap change detector, so an unchanged parse is not rewritten. A re-parse
+// always changes the point count or the values at one of the ends.
+export function metricsFingerprint(metricsData) {
+  return Object.keys(metricsData || {}).sort().map(name => {
+    const series = metricsData[name];
+    if (!Array.isArray(series) || series.length === 0) return `${name}:0`;
+    const first = series[0] || {};
+    const last = series[series.length - 1] || {};
+    return `${name}:${series.length}:${first.x},${first.y}:${last.x},${last.y}`;
+  }).join('|');
+}
+
+function contentBytes(file) {
+  const content = file.content;
+  return content ? content.length : 0;
+}
+
+// The raw log, stored so that re-parsing works after a reload.
+//
+// Stored as UTF-8 bytes taken from the text we already hold, deliberately not
+// as the original File: a File is a reference to the file on disk, so the next
+// training run overwriting train.log would leave the cache serving content that
+// no longer matches the metrics parsed from it — or failing to read at all.
+// The encoded copy also halves the stored bytes for ASCII logs, since JS
+// strings are UTF-16, and structured-clones far faster than a string does.
+function contentValue(file) {
+  if (file.content == null) return null;
+  if (typeof TextEncoder === 'function') return new TextEncoder().encode(file.content);
+  return file.content;
+}
+
+async function readContentValue(value) {
+  if (value == null) return null;
+  try {
+    if (typeof value === 'string') return value;
+    if (value instanceof ArrayBuffer || ArrayBuffer.isView(value)) {
+      return new TextDecoder().decode(value);
+    }
+    // Blob, from a cache written by an older build.
+    if (typeof value.text === 'function') return await value.text();
+  } catch {
+    // Unreadable record — treat it as a file that has to be re-uploaded
+    // before it can be re-parsed. The parsed series still render.
+  }
+  return null;
+}
+
+export function deriveSessionName(files) {
+  const names = (files || []).map(f => f.name).filter(Boolean);
+  if (names.length === 0) return 'Untitled';
+  if (names.length === 1) return names[0];
+  return `${names[0]} +${names.length - 1}`;
+}
+
+async function readIndex() {
+  const db = await openDB();
+  const tx = db.transaction(SESSION_INDEX_STORE, 'readonly');
+  const all = await requestToPromise(tx.objectStore(SESSION_INDEX_STORE).getAll());
+  return Array.isArray(all) ? all : [];
+}
+
+async function removeIds(ids) {
+  if (ids.length === 0) return;
+  const db = await openDB();
+  const tx = db.transaction(
+    [SESSIONS_STORE, SESSION_INDEX_STORE, CONTENT_STORE, METRICS_STORE],
+    'readwrite'
+  );
+  const sessions = tx.objectStore(SESSIONS_STORE);
+  const index = tx.objectStore(SESSION_INDEX_STORE);
+  const content = tx.objectStore(CONTENT_STORE);
+  const metrics = tx.objectStore(METRICS_STORE);
+  ids.forEach(id => {
+    sessions.delete(id);
+    index.delete(id);
+    // Keys are `${sessionId}:${fileId}`, so one range clears all of a
+    // session's files without reading the record first.
+    content.delete(sessionRange(id));
+    metrics.delete(sessionRange(id));
+  });
+  await txDone(tx);
+}
+
+// Enforce the age / count / byte ceilings, least-recently-used first.
+// `keepId` is never evicted — dropping the analysis currently on screen would
+// break the link in the address bar.
+export async function pruneSessions({ keepId = null, now = Date.now(), budget } = {}) {
+  if (!hasIDB()) return [];
+  let entries;
+  try {
+    entries = await readIndex();
+  } catch {
+    return [];
+  }
+  const byteCeiling = budget ?? await totalBudget();
+  const evict = new Set();
+  const survivors = [];
+  entries.forEach(entry => {
+    if (entry.id !== keepId && now - (entry.lastAccess || entry.updatedAt || 0) > MAX_AGE_MS) {
+      evict.add(entry.id);
+    } else {
+      survivors.push(entry);
+    }
+  });
+  // Oldest access first, so the tail of this list is what we drop.
+  survivors.sort((a, b) => (a.lastAccess || 0) - (b.lastAccess || 0));
+  let total = survivors.reduce((n, e) => n + (e.bytes || 0), 0);
+  let count = survivors.length;
+  for (const entry of survivors) {
+    if (count <= MAX_SESSIONS && total <= byteCeiling) break;
+    if (entry.id === keepId) continue;
+    evict.add(entry.id);
+    total -= entry.bytes || 0;
+    count -= 1;
+  }
+  const ids = [...evict];
+  try {
+    await removeIds(ids);
+  } catch {
+    return [];
+  }
+  return ids;
+}
+
+async function getRecord(store, key) {
+  if (!hasIDB() || !key) return null;
+  try {
+    const db = await openDB();
+    const tx = db.transaction(store, 'readonly');
+    const result = await requestToPromise(tx.objectStore(store).get(key));
+    return result || null;
+  } catch {
+    return null;
+  }
+}
+
+export function getSummary(id) {
+  return getRecord(SESSION_INDEX_STORE, id);
+}
+
+// Decide what actually has to be written. Content is immutable for a given file
+// id, so it is written once; metrics are rewritten only when the parse changed.
+// Exported for tests: this is the rule that keeps a checkbox toggle from
+// rewriting hundreds of megabytes.
+export function planWrites(files, previous, sessionId, { withContent = true } = {}) {
+  const prevById = new Map((previous?.files || []).map(entry => [entry.id, entry]));
+  const contentWrites = [];
+  const metricsWrites = [];
+  const entries = files.map(file => {
+    const prev = prevById.get(file.id);
+    const bytes = contentBytes(file);
+    // Decide before encoding: a file already in the cache must not be re-encoded
+    // just to find out it does not need writing. Encoding first is what made a
+    // checkbox toggle cost seconds on a few hundred MB of logs.
+    const reuseContent = !!prev?.hasContent && prev.contentBytes === bytes;
+    let hasContent = reuseContent;
+    if (withContent && !reuseContent) {
+      const value = contentValue(file);
+      if (value != null) {
+        contentWrites.push([recordKey(sessionId, file.id), value]);
+        hasContent = true;
+      }
+    }
+
+    const fingerprint = metricsFingerprint(file.metricsData);
+    const points = countPoints(file.metricsData);
+    if (points > 0 && prev?.fingerprint !== fingerprint) {
+      metricsWrites.push([recordKey(sessionId, file.id), packMetrics(file.metricsData)]);
+    }
+
+    return {
+      id: file.id,
+      name: file.name,
+      enabled: file.enabled ?? true,
+      config: file.config,
+      hasContent,
+      contentBytes: bytes,
+      fingerprint,
+      points
+    };
+  });
+  const staleIds = [...prevById.keys()].filter(id => !files.some(f => f.id === id));
+  return { entries, contentWrites, metricsWrites, staleIds };
+}
+
+async function commit({ record, summary, contentWrites, metricsWrites, staleIds, sessionId }) {
+  const db = await openDB();
+  const tx = db.transaction(
+    [SESSIONS_STORE, SESSION_INDEX_STORE, CONTENT_STORE, METRICS_STORE],
+    'readwrite'
+  );
+  const content = tx.objectStore(CONTENT_STORE);
+  const metrics = tx.objectStore(METRICS_STORE);
+  contentWrites.forEach(([key, value]) => content.put(value, key));
+  metricsWrites.forEach(([key, value]) => metrics.put(value, key));
+  staleIds.forEach(fileId => {
+    content.delete(recordKey(sessionId, fileId));
+    metrics.delete(recordKey(sessionId, fileId));
+  });
+  tx.objectStore(SESSIONS_STORE).put(record);
+  tx.objectStore(SESSION_INDEX_STORE).put(summary);
+  await txDone(tx);
+}
+
+/**
+ * Write (or overwrite) the snapshot stored under `id`.
+ * Returns the index summary, or null when caching is unavailable.
+ * Throws QuotaExceededError if the browser refuses the write even after
+ * evicting other analyses and giving up the raw logs.
+ */
+export async function saveSession({ id, files, globalParsingConfig, name, createdAt, now = Date.now() }) {
+  if (!hasIDB()) return null;
+  requestPersistence();
+
+  const previous = await getRecord(SESSIONS_STORE, id);
+  const existingSummary = await getSummary(id);
+
+  const build = (opts) => {
+    const plan = planWrites(files || [], previous, id, opts);
+    const bytes = plan.entries.reduce(
+      (total, entry) => total + (entry.hasContent ? entry.contentBytes : 0) + entry.points * BYTES_PER_POINT,
+      0
+    );
+    return {
+      plan,
+      record: {
+        id,
+        files: plan.entries,
+        globalParsingConfig: globalParsingConfig ? JSON.parse(JSON.stringify(globalParsingConfig)) : null,
+        createdAt: createdAt || previous?.createdAt || existingSummary?.createdAt || now,
+        updatedAt: now
+      },
+      summary: {
+        id,
+        name: name || existingSummary?.name || deriveSessionName(files),
+        fileNames: plan.entries.map(f => f.name),
+        fileCount: plan.entries.length,
+        bytes,
+        truncated: plan.entries.some(f => !f.hasContent && f.points > 0),
+        createdAt: createdAt || previous?.createdAt || existingSummary?.createdAt || now,
+        updatedAt: now,
+        lastAccess: now
+      }
+    };
+  };
+
+  const write = async ({ plan, record, summary }) => {
+    await commit({
+      record,
+      summary,
+      contentWrites: plan.contentWrites,
+      metricsWrites: plan.metricsWrites,
+      staleIds: plan.staleIds,
+      sessionId: id
+    });
+    return summary;
+  };
+
+  const full = build();
+  try {
+    const summary = await write(full);
+    await pruneSessions({ keepId: id, now });
+    return summary;
+  } catch (err) {
+    if (!isQuotaError(err)) throw err;
+    // Storage is full. First give up the other cached analyses…
+    const entries = await readIndex().catch(() => []);
+    await removeIds(entries.map(e => e.id).filter(otherId => otherId !== id)).catch(() => {});
+    try {
+      return await write(build());
+    } catch (retryErr) {
+      if (!isQuotaError(retryErr)) throw retryErr;
+      // …then the raw logs. Charts still render from the parsed series; the
+      // files are flagged so the UI can ask for a re-upload before re-parsing.
+      await removeIds([id]).catch(() => {});
+      return write(build({ withContent: false }));
+    }
+  }
+}
+
+/** Read a snapshot back and mark it as most-recently used. */
+export async function loadSession(id) {
+  if (!hasIDB() || !id) return null;
+  const record = await getRecord(SESSIONS_STORE, id);
+  if (!record) return null;
+
+  let contents = [];
+  let metrics = [];
+  try {
+    const db = await openDB();
+    const tx = db.transaction([CONTENT_STORE, METRICS_STORE], 'readonly');
+    const contentStore = tx.objectStore(CONTENT_STORE);
+    const metricsStore = tx.objectStore(METRICS_STORE);
+    const keys = (record.files || []).map(entry => recordKey(id, entry.id));
+    contents = await Promise.all(keys.map(key => requestToPromise(contentStore.get(key))));
+    metrics = await Promise.all(keys.map(key => requestToPromise(metricsStore.get(key))));
+  } catch {
+    return null;
+  }
+
+  const files = await Promise.all((record.files || []).map(async (entry, i) => {
+    const content = await readContentValue(contents[i]);
+    return {
+      id: entry.id,
+      name: entry.name,
+      enabled: entry.enabled ?? true,
+      config: entry.config,
+      content,
+      metricsData: unpackMetrics(metrics[i]),
+      // Mirrors the working set's own flag: no raw log means re-parsing needs
+      // the file back, even though the charts render fine without it.
+      isLargeFile: content == null
+    };
+  }));
+
+  await touchSession(id).catch(() => {});
+  return { id: record.id, files, globalParsingConfig: record.globalParsingConfig };
+}
+
+async function putSummary(summary) {
+  const db = await openDB();
+  const tx = db.transaction(SESSION_INDEX_STORE, 'readwrite');
+  tx.objectStore(SESSION_INDEX_STORE).put(summary);
+  await txDone(tx);
+  return summary;
+}
+
+export async function touchSession(id, now = Date.now()) {
+  const summary = await getSummary(id);
+  if (!summary) return null;
+  return putSummary({ ...summary, lastAccess: now });
+}
+
+export async function renameSession(id, name) {
+  const summary = await getSummary(id);
+  if (!summary) return null;
+  return putSummary({ ...summary, name });
+}
+
+/** Summaries for the cache list, most recently updated first. */
+export async function listSessions() {
+  if (!hasIDB()) return [];
+  try {
+    const entries = await readIndex();
+    return entries.sort((a, b) => (b.updatedAt || 0) - (a.updatedAt || 0));
+  } catch {
+    return [];
+  }
+}
+
+export async function deleteSession(id) {
+  if (!hasIDB() || !id) return;
+  await removeIds([id]).catch(() => {});
+}
+
+export async function clearSessions() {
+  if (!hasIDB()) return;
+  const entries = await readIndex().catch(() => []);
+  await removeIds(entries.map(e => e.id)).catch(() => {});
+}