Optimize sorting, index loading, and caches

app.py

@@ -13,7 +13,7 @@ import threading
 import time
 import unicodedata
 from functools import lru_cache
-from contextlib import asynccontextmanager
+from contextlib import asynccontextmanager, contextmanager
 from pathlib import Path
 from typing import Literal, Optional
 from urllib.parse import parse_qs, quote, unquote
@@ -32,6 +32,8 @@ FULLTEXT_DIR = BASE_DIR / "data/fulltext"
 INDEX_BUILD_STATUS_PATH = FULLTEXT_DIR / "build-status.json"
 BUCKET_INDEX_STATUS_PATH = FULLTEXT_DIR / "bucket-index-status.json"
 records: list[dict] = []
+name_order: list[int] = []
+size_order: list[int] = []
 record_map: dict[str, dict] = {}
 record_map_index: dict[str, int] = {}
 sources: list[dict] = []
@@ -47,8 +49,12 @@ TOKENIZER_VERSION = "cjk-bigram-boundary-fts5-v6-snippet-anchors"
 LITERAL_PREFIX = "\0literal:"
 API_CACHE_TTL_SECONDS = 120
 SEARCH_CACHE_TTL_SECONDS = 300
+API_CACHE_MAX_ENTRIES = 500
+SEARCH_CACHE_MAX_ENTRIES = 500
 api_response_cache: dict[tuple, tuple[float, object]] = {}
 api_response_cache_lock = threading.Lock()
+search_response_cache: dict[tuple, tuple[float, object]] = {}
+search_response_cache_lock = threading.Lock()
 ZIP_TOKEN_TTL_SECONDS = 600
 ZIP_TOKEN_MAX_ENTRIES = 32
 zip_download_tokens: dict[str, tuple[float, list[str]]] = {}
@@ -110,6 +116,7 @@ class FulltextDatabases:
         self.directory = directory
         self.in_memory = in_memory
         self.lock = threading.RLock()
+        self.refresh_lock = threading.Lock()
         self.connections = {}
         self.has_doc_counts = {}
         self.tokenizer_versions = {}
@@ -118,27 +125,45 @@ class FulltextDatabases:
         self.document_counts = {}
         self.fts_counts = {}
         self.file_signatures = {}
-        self.retired_connections = []
+        self.connection_readers = {}
+        self.retired_connections = set()
+        self.closed = False
         self.generation = 0
         if refresh:
             self.refresh()
 
     def refresh(self) -> None:
-        with self.lock:
+        with self.refresh_lock:
             for path in self.directory.glob("*.sqlite3"):
                 try:
                     stat = path.stat()
                     signature = (stat.st_ino, stat.st_size, stat.st_mtime_ns)
                 except OSError:
                     continue
-                if self.file_signatures.get(path.stem) == signature:
-                    continue
+                with self.lock:
+                    if self.closed or self.file_signatures.get(path.stem) == signature:
+                        continue
                 try:
-                    self._open(path, signature)
+                    candidate = self._open_candidate(path)
                 except (OSError, sqlite3.Error) as exc:
                     print(f"fulltext_open_failed={path.name}:{exc}")
+                    continue
+                try:
+                    current_stat = path.stat()
+                    current_signature = (current_stat.st_ino, current_stat.st_size, current_stat.st_mtime_ns)
+                except OSError:
+                    candidate["connection"].close()
+                    continue
+                if current_signature != signature:
+                    candidate["connection"].close()
+                    continue
+                with self.lock:
+                    if self.closed or self.file_signatures.get(path.stem) == signature:
+                        candidate["connection"].close()
+                        continue
+                    self._install_candidate(path.stem, signature, candidate)
 
-    def _open(self, path: Path, signature: tuple[int, int, int] | None = None) -> None:
+    def _open_candidate(self, path: Path) -> dict:
         uri = f"file:{path.resolve()}?mode=ro&immutable=1"
         source_connection = sqlite3.connect(uri, uri=True, check_same_thread=False)
         connection = source_connection
@@ -165,48 +190,96 @@ class FulltextDatabases:
         except Exception:
             if connection is not source_connection:
                 connection.close()
-            connection.close()
+            source_connection.close()
             raise
         finally:
             if source_connection is not connection:
                 source_connection.close()
-        old_connection = self.connections.get(path.stem)
-        self.connections[path.stem] = connection
-        self.has_doc_counts[path.stem] = "doc_count" in columns
-        self.tokenizer_versions[path.stem] = version_row[0] if version_row else "legacy"
-        self.has_content_fts[path.stem] = has_content_fts
-        self.has_snippet_anchors[path.stem] = has_snippet_anchors
-        self.document_counts[path.stem] = document_count
-        self.fts_counts[path.stem] = fts_count
-        if signature is None:
-            stat = path.stat()
-            signature = (stat.st_ino, stat.st_size, stat.st_mtime_ns)
-        self.file_signatures[path.stem] = signature
+        return {
+            "connection": connection,
+            "has_doc_counts": "doc_count" in columns,
+            "tokenizer_version": version_row[0] if version_row else "legacy",
+            "has_content_fts": has_content_fts,
+            "has_snippet_anchors": has_snippet_anchors,
+            "document_count": document_count,
+            "fts_count": fts_count,
+        }
+
+    def _install_candidate(self, source: str, signature: tuple[int, int, int], candidate: dict) -> None:
+        connection = candidate["connection"]
+        old_connection = self.connections.get(source)
+        self.connections[source] = connection
+        self.has_doc_counts[source] = candidate["has_doc_counts"]
+        self.tokenizer_versions[source] = candidate["tokenizer_version"]
+        self.has_content_fts[source] = candidate["has_content_fts"]
+        self.has_snippet_anchors[source] = candidate["has_snippet_anchors"]
+        self.document_counts[source] = candidate["document_count"]
+        self.fts_counts[source] = candidate["fts_count"]
+        self.file_signatures[source] = signature
         self.generation += 1
         if old_connection is not None:
-            # An in-flight request may still be reading the prior immutable file.
-            self.retired_connections.append(old_connection)
-            while len(self.retired_connections) > 3:
-                self.retired_connections.pop(0).close()
+            if self.connection_readers.get(old_connection, 0):
+                self.retired_connections.add(old_connection)
+            else:
+                old_connection.close()
 
-    def close(self) -> None:
+    @contextmanager
+    def _lease_source(self, source: str):
         with self.lock:
-            for connection in self.connections.values():
-                connection.close()
-            for connection in self.retired_connections:
-                connection.close()
+            connection = self.connections.get(source)
+            if connection is None or self.closed:
+                lease = None
+            else:
+                self.connection_readers[connection] = self.connection_readers.get(connection, 0) + 1
+                lease = (connection, {
+                    "has_doc_counts": self.has_doc_counts.get(source, False),
+                    "tokenizer_version": self.tokenizer_versions.get(source),
+                    "has_content_fts": self.has_content_fts.get(source, False),
+                    "has_snippet_anchors": self.has_snippet_anchors.get(source, False),
+                })
+        try:
+            yield lease
+        finally:
+            if lease is None:
+                return
+            with self.lock:
+                remaining = self.connection_readers.get(connection, 1) - 1
+                if remaining:
+                    self.connection_readers[connection] = remaining
+                else:
+                    self.connection_readers.pop(connection, None)
+                    if connection in self.retired_connections:
+                        self.retired_connections.remove(connection)
+                        connection.close()
+
+    def close(self) -> None:
+        with self.refresh_lock:
+            with self.lock:
+                self.closed = True
+                connections = set(self.connections.values()) | self.retired_connections
+                self.connections.clear()
+                self.retired_connections = {
+                    connection for connection in connections
+                    if self.connection_readers.get(connection, 0)
+                }
+                for connection in connections - self.retired_connections:
+                    connection.close()
 
     def search_source(self, source: str, query: str, exact: bool = False) -> set[int]:
         with self.lock:
-            connection = self.connections.get(source)
-            if connection is None:
-                self.refresh()
-                connection = self.connections.get(source)
-            if connection is None:
+            missing = source not in self.connections
+        if missing:
+            self.refresh()
+        with self._lease_source(source) as lease:
+            if lease is None:
                 return set()
-            version = self.tokenizer_versions.get(source)
-            has_content_fts = self.has_content_fts.get(source)
-            has_doc_counts = self.has_doc_counts.get(source)
+            connection, state = lease
+            return self._search_source_connection(connection, query, exact, state)
+
+    def _search_source_connection(self, connection: sqlite3.Connection, query: str, exact: bool, state: dict) -> set[int]:
+        version = state["tokenizer_version"]
+        has_content_fts = state["has_content_fts"]
+        has_doc_counts = state["has_doc_counts"]
         if exact and has_content_fts:
             normalized_query = normalize_text(query)
             try:
@@ -238,7 +311,7 @@ class FulltextDatabases:
                         "SELECT rowid FROM content_fts WHERE instr(content, ?) > 0", (normalized_query,)
                     )
                     return {int(row[0]) for row in rows}
-                candidates = self._search_postings(connection, source, tokens)
+                candidates = self._search_postings(connection, has_doc_counts, tokens)
                 return candidates
             except sqlite3.OperationalError:
                 pass
@@ -277,12 +350,12 @@ class FulltextDatabases:
             result = self.verify_wildcard_content(connection, result, query)
         return result
 
-    def _search_postings(self, connection: sqlite3.Connection, source: str, tokens: list[str]) -> set[int]:
+    def _search_postings(self, connection: sqlite3.Connection, has_doc_counts: bool, tokens: list[str]) -> set[int]:
         if not tokens:
             return set()
         matched = None
         token_hashes = [hashlib.sha256(token.encode("utf-8")).digest()[:16] for token in tokens]
-        if self.has_doc_counts.get(source):
+        if has_doc_counts:
             placeholders = ",".join("?" for _ in token_hashes)
             rows = connection.execute(
                 f"SELECT token_hash, docs, doc_count FROM postings WHERE token_hash IN ({placeholders})",
@@ -359,34 +432,38 @@ class FulltextDatabases:
         return matched
 
     def can_trust_exact_content(self, source: str, query: str) -> bool:
-        return (
-            self.tokenizer_versions.get(source) == TOKENIZER_VERSION
-            and self.has_content_fts.get(source, False)
-            and "*" not in query
-            and "?" not in query
-        )
+        with self.lock:
+            return (
+                self.tokenizer_versions.get(source) == TOKENIZER_VERSION
+                and self.has_content_fts.get(source, False)
+                and "*" not in query
+                and "?" not in query
+            )
 
     def summaries(self, doc_ids: list[str]) -> dict[str, str]:
-        self.refresh()
         grouped = {}
         for doc_id in doc_ids:
             grouped.setdefault(doc_id.split(":", 1)[0], []).append(doc_id)
+        with self.lock:
+            missing = any(source not in self.connections for source in grouped)
+        if missing:
+            self.refresh()
         summaries = {}
         for source, source_doc_ids in grouped.items():
-            connection = self.connections.get(source)
-            if connection is None:
-                continue
-            for offset in range(0, len(source_doc_ids), 500):
-                batch = source_doc_ids[offset:offset + 500]
-                rows = connection.execute(
-                    f"SELECT doc_id, summary FROM documents WHERE doc_id IN ({','.join('?' for _ in batch)})",
-                    batch,
-                )
-                summaries.update(rows)
+            with self._lease_source(source) as lease:
+                if lease is None:
+                    continue
+                connection, _state = lease
+                for offset in range(0, len(source_doc_ids), 500):
+                    batch = source_doc_ids[offset:offset + 500]
+                    rows = connection.execute(
+                        f"SELECT doc_id, summary FROM documents WHERE doc_id IN ({','.join('?' for _ in batch)})",
+                        batch,
+                    )
+                    summaries.update(rows)
         return summaries
 
     def matched_snippets(self, doc_ids: list[str], query: str, exact: bool = False, timings=None) -> dict[str, dict]:
-        self.refresh()
         normalized_query = normalize_text(query.strip())
         # A fixed wildcard fragment can occur long before the actual match.
         # Let the original-text snippet endpoint locate the verified span.
@@ -403,88 +480,100 @@ class FulltextDatabases:
             source, _, number = doc_id.partition(":")
             if number.isdigit():
                 grouped.setdefault(source, []).append((doc_id, int(number)))
+        with self.lock:
+            missing = any(source not in self.connections for source in grouped)
+        if missing:
+            self.refresh()
         snippets = {}
         for source, source_docs in grouped.items():
-            connection = self.connections.get(source)
-            if connection is None or not self.has_content_fts.get(source, False):
-                continue
-            doc_id_by_number = {number: doc_id for doc_id, number in source_docs}
-            numbers = list(doc_id_by_number)
-            anchored_numbers = set()
-            # Exact snippets retain the established literal/wildcard path. Normal snippets
-            # can seek directly to a token anchor without scanning FTS content with instr().
-            if not exact and self.has_snippet_anchors.get(source, False):
-                token_hash = hashlib.sha256(needle.encode("utf-8")).digest()[:16]
-                for offset in range(0, len(numbers), 500):
-                    batch = numbers[offset:offset + 500]
-                    placeholders = ",".join("?" for _ in batch)
-                    try:
-                        anchor_started = time.perf_counter()
-                        rows = connection.execute(
-                            f"""
-                            SELECT content_fts.rowid, snippet_anchors.char_offset, length(content),
-                                   substr(content, max(snippet_anchors.char_offset - 219, 1), 440 + length(?))
-                            FROM content_fts JOIN snippet_anchors ON snippet_anchors.doc_number = content_fts.rowid
-                            WHERE snippet_anchors.token_hash = ? AND content_fts.rowid IN ({placeholders})
-                            """,
-                            [needle, token_hash, *batch],
-                        ).fetchall()
-                        if timings is not None:
-                            timings["snippet_anchor_sql"] = timings.get("snippet_anchor_sql", 0) + (time.perf_counter() - anchor_started) * 1000
-                        for number, char_offset, content_length, text in rows:
-                            payload_started = time.perf_counter()
-                            payload = build_normalized_snippet_payload(text or "", query)
-                            if timings is not None:
-                                timings["snippet_payload"] = timings.get("snippet_payload", 0) + (time.perf_counter() - payload_started) * 1000
-                            if not payload["highlights"]:
-                                continue
-                            extracted_start = max(int(char_offset) - 219, 1)
-                            if extracted_start > 1 and not payload["snippet"].startswith("..."):
-                                payload["snippet"] = "..." + payload["snippet"]
-                            if extracted_start + len(text or "") <= int(content_length or 0) and not payload["snippet"].endswith("..."):
-                                payload["snippet"] += "..."
-                            snippets[doc_id_by_number[int(number)]] = payload
-                            anchored_numbers.add(int(number))
-                    except sqlite3.OperationalError:
-                        break
-            numbers = [number for number in numbers if number not in anchored_numbers]
+            with self._lease_source(source) as lease:
+                if lease is None:
+                    continue
+                connection, state = lease
+                if not state["has_content_fts"]:
+                    continue
+                self._matched_snippets_source(
+                    snippets, connection, state, source_docs, needle, query, exact, timings,
+                )
+        return snippets
+
+    def _matched_snippets_source(self, snippets, connection, state, source_docs, needle, query, exact, timings) -> None:
+        doc_id_by_number = {number: doc_id for doc_id, number in source_docs}
+        numbers = list(doc_id_by_number)
+        anchored_numbers = set()
+        # Exact snippets retain the established literal path. Normal snippets can seek
+        # directly to a token anchor without scanning FTS content with instr().
+        if not exact and state["has_snippet_anchors"]:
+            token_hash = hashlib.sha256(needle.encode("utf-8")).digest()[:16]
             for offset in range(0, len(numbers), 500):
                 batch = numbers[offset:offset + 500]
                 placeholders = ",".join("?" for _ in batch)
                 try:
-                    fallback_started = time.perf_counter()
+                    anchor_started = time.perf_counter()
                     rows = connection.execute(
                         f"""
-                        SELECT rowid, instr(content, ?) AS match_position, length(content),
-                               substr(content, max(instr(content, ?) - 220, 1), 440 + length(?))
-                        FROM content_fts
-                        WHERE rowid IN ({placeholders})
+                        SELECT content_fts.rowid, snippet_anchors.char_offset, length(content),
+                               substr(content, max(snippet_anchors.char_offset - 219, 1), 440 + length(?))
+                        FROM content_fts JOIN snippet_anchors ON snippet_anchors.doc_number = content_fts.rowid
+                        WHERE snippet_anchors.token_hash = ? AND content_fts.rowid IN ({placeholders})
                         """,
-                        [needle, needle, needle, *batch],
+                        [needle, token_hash, *batch],
                     ).fetchall()
                     if timings is not None:
-                        timings["snippet_fallback_sql"] = timings.get("snippet_fallback_sql", 0) + (time.perf_counter() - fallback_started) * 1000
-                    for number, match_position, content_length, text in rows:
+                        timings["snippet_anchor_sql"] = timings.get("snippet_anchor_sql", 0) + (time.perf_counter() - anchor_started) * 1000
+                    for number, char_offset, content_length, text in rows:
                         payload_started = time.perf_counter()
-                        extracted_start = max(int(match_position or 0) - 220, 1)
-                        if exact and not has_wildcard_query(query):
-                            payload = build_normalized_exact_snippet_payload(text or "", query)
-                            if not payload["highlights"]:
-                                payload = build_snippet_payload(text or "", query, exact=True)
-                        else:
-                            payload = build_snippet_payload(text or "", query, exact=exact)
-                            if not payload["highlights"]:
-                                payload = build_snippet_payload(text or "", needle, exact=True)
+                        payload = build_normalized_snippet_payload(text or "", query)
                         if timings is not None:
                             timings["snippet_payload"] = timings.get("snippet_payload", 0) + (time.perf_counter() - payload_started) * 1000
-                        if payload["snippet"] and extracted_start > 1 and not payload["snippet"].startswith("..."):
+                        if not payload["highlights"]:
+                            continue
+                        extracted_start = max(int(char_offset) - 219, 1)
+                        if extracted_start > 1 and not payload["snippet"].startswith("..."):
                             payload["snippet"] = "..." + payload["snippet"]
-                        if payload["snippet"] and extracted_start + len(text or "") <= int(content_length or 0) and not payload["snippet"].endswith("..."):
+                        if extracted_start + len(text or "") <= int(content_length or 0) and not payload["snippet"].endswith("..."):
                             payload["snippet"] += "..."
                         snippets[doc_id_by_number[int(number)]] = payload
+                        anchored_numbers.add(int(number))
                 except sqlite3.OperationalError:
-                    continue
-        return snippets
+                    break
+        numbers = [number for number in numbers if number not in anchored_numbers]
+        for offset in range(0, len(numbers), 500):
+            batch = numbers[offset:offset + 500]
+            placeholders = ",".join("?" for _ in batch)
+            try:
+                fallback_started = time.perf_counter()
+                rows = connection.execute(
+                    f"""
+                    SELECT rowid, instr(content, ?) AS match_position, length(content),
+                           substr(content, max(instr(content, ?) - 220, 1), 440 + length(?))
+                    FROM content_fts
+                    WHERE rowid IN ({placeholders})
+                    """,
+                    [needle, needle, needle, *batch],
+                ).fetchall()
+                if timings is not None:
+                    timings["snippet_fallback_sql"] = timings.get("snippet_fallback_sql", 0) + (time.perf_counter() - fallback_started) * 1000
+                for number, match_position, content_length, text in rows:
+                    payload_started = time.perf_counter()
+                    extracted_start = max(int(match_position or 0) - 220, 1)
+                    if exact and not has_wildcard_query(query):
+                        payload = build_normalized_exact_snippet_payload(text or "", query)
+                        if not payload["highlights"]:
+                            payload = build_snippet_payload(text or "", query, exact=True)
+                    else:
+                        payload = build_snippet_payload(text or "", query, exact=exact)
+                        if not payload["highlights"]:
+                            payload = build_snippet_payload(text or "", needle, exact=True)
+                    if timings is not None:
+                        timings["snippet_payload"] = timings.get("snippet_payload", 0) + (time.perf_counter() - payload_started) * 1000
+                    if payload["snippet"] and extracted_start > 1 and not payload["snippet"].startswith("..."):
+                        payload["snippet"] = "..." + payload["snippet"]
+                    if payload["snippet"] and extracted_start + len(text or "") <= int(content_length or 0) and not payload["snippet"].endswith("..."):
+                        payload["snippet"] += "..."
+                    snippets[doc_id_by_number[int(number)]] = payload
+            except sqlite3.OperationalError:
+                continue
 fulltext_databases: Optional[FulltextDatabases] = None
 
 def tokenize(text: str) -> list[str]:
@@ -616,7 +705,7 @@ def load_json_gz(path: Path):
     return json.loads(gzip.decompress(path.read_bytes()).decode("utf-8"))
 
 def build_indexes() -> None:
-    global word_index, source_records_map, extension_counts, source_extension_counts
+    global word_index, source_records_map, extension_counts, source_extension_counts, name_order, size_order
     word_index = {}
     source_records_map = {}
     extension_counts = {}
@@ -637,6 +726,18 @@ def build_indexes() -> None:
         rec["_rank_path_key"] = rec["display_rel_path"].lower()
         for token in tokens:
             word_index.setdefault(token, set()).add(idx)
+    name_order = sorted(
+        range(len(records)),
+        key=lambda idx: (records[idx]["display_rel_path"].lower(), records[idx]["doc_id"]),
+    )
+    size_order = sorted(
+        range(len(records)),
+        key=lambda idx: (
+            -(records[idx].get("size") or 0),
+            records[idx]["display_rel_path"].lower(),
+            records[idx]["doc_id"],
+        ),
+    )
 
 def load_data() -> None:
     global records, record_map, record_map_index, sources, source_counts, folder_tree_data, folder_browser_data
@@ -674,6 +775,22 @@ def relevance_page(indices, query_tokens: list[str], search_paths: bool, start:
     )
     return ranked[start:limit]
 
+def ordered_page(indices, ordering: list[int], start: int, page_size: int) -> list[int]:
+    candidates = set(indices)
+    if not candidates or page_size <= 0:
+        return []
+    selected = []
+    matched = 0
+    for idx in ordering:
+        if idx not in candidates:
+            continue
+        if matched >= start:
+            selected.append(idx)
+            if len(selected) >= page_size:
+                break
+        matched += 1
+    return selected
+
 def apply_filters(indices: list[int], sources_filter=None, folders=None, min_size=None, max_size=None):
     result = []
     for idx in indices:
@@ -826,16 +943,19 @@ def search(q="", sources_filter=None, folders=None, min_size=None, max_size=None
             paged_indices = relevance_page(filtered, tokens, search_paths, start, page_size)
             if timings is not None:
                 timings["rank"] = (time.perf_counter() - rank_started) * 1000
-    sort_started = time.perf_counter()
-    if sort == "name":
-        filtered.sort(key=lambda idx: (records[idx]["display_rel_path"].lower(), records[idx]["doc_id"]))
-    elif sort == "size":
-        filtered.sort(key=lambda idx: (-records[idx].get("size", 0), records[idx]["display_rel_path"].lower(), records[idx]["doc_id"]))
-    if timings is not None and sort in {"name", "size"}:
-        timings["sort"] = (time.perf_counter() - sort_started) * 1000
     total = len(filtered)
     if q and sort == "relevance":
         selected = paged_indices
+    elif sort == "name":
+        sort_started = time.perf_counter()
+        selected = ordered_page(filtered, name_order, start, page_size)
+        if timings is not None:
+            timings["sort"] = (time.perf_counter() - sort_started) * 1000
+    elif sort == "size":
+        sort_started = time.perf_counter()
+        selected = ordered_page(filtered, size_order, start, page_size)
+        if timings is not None:
+            timings["sort"] = (time.perf_counter() - sort_started) * 1000
     else:
         selected = filtered[start:start + page_size]
     result_items = [trim_record(records[idx]) for idx in selected]
@@ -880,18 +1000,15 @@ def fulltext_search(q="", sources_filter=None, folders=None, min_size=None, max_
             timings["rank"] = (time.perf_counter() - rank_started) * 1000
     elif sort == "name":
         sort_started = time.perf_counter()
-        filtered.sort(key=lambda idx: (records[idx]["display_rel_path"].lower(), records[idx]["doc_id"]))
+        selected = ordered_page(filtered, name_order, (page - 1) * page_size, page_size)
         if timings is not None:
             timings["sort"] = (time.perf_counter() - sort_started) * 1000
     elif sort == "size":
         sort_started = time.perf_counter()
-        filtered.sort(key=lambda idx: (-records[idx].get("size", 0), records[idx]["display_rel_path"].lower(), records[idx]["doc_id"]))
+        selected = ordered_page(filtered, size_order, (page - 1) * page_size, page_size)
         if timings is not None:
             timings["sort"] = (time.perf_counter() - sort_started) * 1000
     total = len(filtered)
-    start = (page - 1) * page_size
-    if sort != "relevance":
-        selected = filtered[start:start + page_size]
     summaries_started = time.perf_counter()
     result_items = add_summaries(
         [trim_record(records[idx]) for idx in selected],
@@ -917,12 +1034,11 @@ def get_folder_contents(source_slug: str, path: str) -> dict:
         return entry
     return {"folders": [], "files": [], "current_path": path}
 
-def cached_payload(key: tuple, builder, timings=None):
+def _cached_payload(cache, lock, key: tuple, builder, ttl: int, max_entries: int, timings=None):
     cache_started = time.perf_counter()
     now = time.monotonic()
-    with api_response_cache_lock:
-        cached = api_response_cache.get(key)
-        ttl = SEARCH_CACHE_TTL_SECONDS if key and key[0] == "search" else API_CACHE_TTL_SECONDS
+    with lock:
+        cached = cache.get(key)
         if cached and now - cached[0] < ttl:
             if timings is not None:
                 timings["cache"] = "hit"
@@ -932,24 +1048,38 @@ def cached_payload(key: tuple, builder, timings=None):
         timings["cache"] = "miss"
         timings["cache_lookup"] = (time.perf_counter() - cache_started) * 1000
     value = builder()
-    with api_response_cache_lock:
-        api_response_cache[key] = (now, value)
-        if len(api_response_cache) > 500:
-            oldest_key = min(api_response_cache, key=lambda item: api_response_cache[item][0])
-            api_response_cache.pop(oldest_key, None)
+    inserted_at = time.monotonic()
+    with lock:
+        cache[key] = (inserted_at, value)
+        while len(cache) > max_entries:
+            oldest_key = min(cache, key=lambda item: cache[item][0])
+            cache.pop(oldest_key, None)
     return value
 
+def cached_payload(key: tuple, builder, timings=None):
+    return _cached_payload(
+        api_response_cache, api_response_cache_lock, key, builder,
+        API_CACHE_TTL_SECONDS, API_CACHE_MAX_ENTRIES, timings,
+    )
+
+def cached_search_payload(key: tuple, builder, timings=None):
+    return _cached_payload(
+        search_response_cache, search_response_cache_lock, key, builder,
+        SEARCH_CACHE_TTL_SECONDS, SEARCH_CACHE_MAX_ENTRIES, timings,
+    )
+
 def ready_fulltext_sources() -> set[str]:
     if fulltext_databases is None:
         return set()
-    return {
-        source for source in fulltext_databases.connections
-        if fulltext_databases.tokenizer_versions.get(source) == TOKENIZER_VERSION
-        and fulltext_databases.has_content_fts.get(source, False)
-        and fulltext_databases.has_snippet_anchors.get(source, False)
-        and fulltext_databases.document_counts.get(source) == source_counts.get(source)
-        and fulltext_databases.fts_counts.get(source) == source_counts.get(source)
-    }
+    with fulltext_databases.lock:
+        return {
+            source for source in fulltext_databases.connections
+            if fulltext_databases.tokenizer_versions.get(source) == TOKENIZER_VERSION
+            and fulltext_databases.has_content_fts.get(source, False)
+            and fulltext_databases.has_snippet_anchors.get(source, False)
+            and fulltext_databases.document_counts.get(source) == source_counts.get(source)
+            and fulltext_databases.fts_counts.get(source) == source_counts.get(source)
+        }
 @asynccontextmanager
 
 async def lifespan(app: FastAPI):
@@ -1065,7 +1195,11 @@ def zip_response(doc_ids: list[str]):
 
 def run_search(body: SearchRequest, sources_filter=None, timings=None):
     selected_sources = sources_filter if sources_filter is not None else body.sources
-    fulltext_generation = fulltext_databases.generation if fulltext_databases is not None else 0
+    if fulltext_databases is None:
+        fulltext_generation = 0
+    else:
+        with fulltext_databases.lock:
+            fulltext_generation = fulltext_databases.generation
     key = (
         "search",
         fulltext_generation,
@@ -1081,7 +1215,7 @@ def run_search(body: SearchRequest, sources_filter=None, timings=None):
         body.search_paths,
         body.fulltext,
     )
-    result = cached_payload(
+    result = cached_search_payload(
         key,
         lambda: fulltext_search(
             body.q, selected_sources, body.folders, body.min_size, body.max_size,

prepare_fulltext_index.py

@@ -94,20 +94,18 @@ def main() -> int:
         if not isinstance(databases, dict):
             raise ValueError("missing databases manifest")
         paths = {source: validated_database(bucket, source, databases.get(source)) for source in SOURCES}
+        if len({path.parent for path, _size in paths.values()}) != 1:
+            raise ValueError("databases span multiple generations")
+        if any(path.stat().st_size != expected_bytes for path, expected_bytes in paths.values()):
+            raise ValueError("database size does not match manifest")
     except Exception as exc:
         pointer_error = {"error": type(exc).__name__, "detail": str(exc)}
         paths = None
 
-    discovered = discover_latest_generation(bucket)
-    if discovered is not None:
-        generation, discovered_paths = discovered
-        manifest_generation = None
-        if paths:
-            parents = {path.parent.name for path, _size in paths.values()}
-            if len(parents) == 1:
-                manifest_generation = parents.pop()
-        if paths is None or generation != manifest_generation:
-            paths = discovered_paths
+    if paths is None:
+        discovered = discover_latest_generation(bucket)
+        if discovered is not None:
+            generation, paths = discovered
             write_status(state="checking", generation=generation, source="bucket_scan", pointer_error=pointer_error)
 
     if paths is None:

static/sw.js

@@ -1,32 +1,15 @@
 const CACHE_NAME = "vomebook-search-v1.0.0";
 
 const PRECACHE_URLS = [
-  "/",
   "/static/style.css",
   "/static/app.js",
-  "/manifest.json",
-  "/data/initial/manifest.json",
-  "/data/sidebar/manifest.json"
+  "/manifest.json"
 ];
 
-function cacheManifestUrls(cache, manifestUrl) {
-  return fetch(manifestUrl)
-    .then((response) => response.ok ? response.json() : null)
-    .then((manifest) => {
-      const urls = manifest && Array.isArray(manifest.urls) ? manifest.urls : [];
-      return urls.length ? cache.addAll(urls) : null;
-    });
-}
-
 self.addEventListener("install", (event) => {
   event.waitUntil(
     caches.open(CACHE_NAME).then((cache) => {
-      return cache.addAll(PRECACHE_URLS).then(() => {
-        return Promise.all([
-          cacheManifestUrls(cache, "/data/initial/manifest.json"),
-          cacheManifestUrls(cache, "/data/sidebar/manifest.json")
-        ]);
-      }).catch((err) => {
+      return cache.addAll(PRECACHE_URLS).catch((err) => {
         console.warn("[SW] precache partial failure:", err);
       });
     }).then(() => self.skipWaiting())