v1.12.4

NEWS.md

@@ -6,6 +6,14 @@ width: 128px;
 border-radius: 128px;
 " />
 
+## v1.12.5
+
+- Fixes
+    - Fix "Last Read" column in table view crashing.
+    - Ignore dotfiles.
+- Features
+    - Select by range in multi-select with shift+click.
+
 ## v1.12.4
 
 - Fixes

cfg/eslint.config.base.js

@@ -14,6 +14,7 @@ import * as eslintPluginMdx from "eslint-plugin-mdx";
 import eslintPluginNoSecrets from "eslint-plugin-no-secrets";
 import eslintPluginNoUnsanitized from "eslint-plugin-no-unsanitized";
 import eslintPluginNoUseExtendNative from "eslint-plugin-no-use-extend-native";
+import eslintPluginPackageJson from "eslint-plugin-package-json";
 import eslintPluginPerfectionist from "eslint-plugin-perfectionist";
 import eslintPluginPrettierRecommended from "eslint-plugin-prettier/recommended";
 import eslintPluginPromise from "eslint-plugin-promise";
@@ -53,7 +54,6 @@ export const CONFIGS = {
     },
     rules: {
       "@stylistic/multiline-comment-style": "off", // Multiple bugs with this rule
-      // "import-x/order": "off",
       "max-params": ["warn", 4],
       "no-console": "warn",
       "no-debugger": "warn",
@@ -124,6 +124,9 @@ export default defineConfig([
     ...eslintJson.configs.recommended,
     language: "json/json",
   },
+  eslintPluginPackageJson.configs.recommended,
+  eslintPluginPackageJson.configs.stylistic,
+  eslintPluginPackageJson.configs["recommended-publishable"],
   {
     files: ["package.json"],
     languageOptions: {

codex/librarian/fs/filters.py

@@ -1,6 +1,7 @@
 """Filter files with regexes."""
 
 import re
+from contextlib import suppress
 from pathlib import Path
 
 from comicbox.box import Comicbox
@@ -9,6 +10,53 @@
 from codex.models.paths import CustomCover
 from codex.settings import CUSTOM_COVERS_DIR, CUSTOM_COVERS_GROUP_DIRS
 
+# Component-level ignore registry consulted by the poller's walker and
+# the watchfiles filter. Either constant can be extended to add new
+# patterns without touching the walker/filter call sites:
+#
+#   _IGNORED_BASENAMES — exact-match basenames (case-sensitive). Use
+#     this for OS / archive metadata trees that don't follow a prefix
+#     convention. Examples for future extension: ``"@eaDir"``
+#     (Synology), ``"__MACOSX"`` (Mac archive metadata), ``"Thumbs.db"``
+#     / ``"desktop.ini"`` (Windows), ``"#recycle"`` (recycle bins).
+#
+#   _IGNORED_BASENAME_PREFIXES — prefix matches. Currently catches all
+#     hidden files / directories ("." prefix) so VCS metadata (.git),
+#     macOS spotlight (.Spotlight-V100), trash (.Trashes), and stray
+#     dotfiles (.DS_Store, .nomedia) are skipped wholesale.
+#
+# A path is ignored when *any* component (relative to its library
+# root) matches either rule. The check is applied to every entry the
+# walker sees and every event the watcher receives.
+_IGNORED_BASENAMES: frozenset[str] = frozenset()
+_IGNORED_BASENAME_PREFIXES: tuple[str, ...] = (".",)
+
+
+def is_ignored_basename(name: str) -> bool:
+    """Return True when ``name`` matches any registered ignore rule."""
+    return name in _IGNORED_BASENAMES or any(
+        name.startswith(prefix) for prefix in _IGNORED_BASENAME_PREFIXES
+    )
+
+
+def is_ignored_path(path: Path | str, root: Path | str | None = None) -> bool:
+    """
+    Return True when any component (relative to ``root``) is ignored.
+
+    The check is component-by-component so a hidden ancestor
+    (``.git/HEAD``) is caught even when the basename itself is
+    innocuous. When ``root`` is provided, components of the root are
+    skipped — a library whose path lives under a hidden parent (e.g.
+    ``/Users/aj/.archive/comics``) still polls its contents.
+    """
+    ppath = path if isinstance(path, Path) else Path(path)
+    rel = ppath
+    if root is not None:
+        with suppress(ValueError):
+            rel = ppath.relative_to(root)
+    return any(is_ignored_basename(part) for part in rel.parts)
+
+
 _IMAGE_REGEX = r"\.(jpe?g|webp|png|gif|bmp)"
 _IMAGE_MATCHER: re.Pattern = re.compile(_IMAGE_REGEX, re.IGNORECASE)
 

codex/librarian/fs/poller/snapshot.py

@@ -8,6 +8,7 @@
 from django.db.models import Model
 
 from codex.librarian.fs.filters import (
+    is_ignored_basename,
     match_comic,
     match_folder_cover,
     match_group_cover_image,
@@ -121,6 +122,14 @@ def _init_walk(self):
     def _walk(self, root: str) -> None:
         """Walk the directory tree and populate lookups."""
         for entry in os.scandir(root):
+            # Walking only the surviving children means the recursion
+            # never enters an ignored dir (``.git`` / ``.Trashes`` /
+            # ``@eaDir`` if registered / …), so a per-component check
+            # at each scandir level suffices — no need to re-check
+            # ancestors. See ``filters._IGNORED_BASENAMES`` /
+            # ``_IGNORED_BASENAME_PREFIXES`` for the registered rules.
+            if is_ignored_basename(entry.name):
+                continue
             path = Path(entry.path)
             is_dir = entry.is_dir(follow_symlinks=self._follow_symlinks)
             if is_dir:

codex/librarian/fs/watcher/dirs.py

@@ -7,6 +7,7 @@
 
 from codex.librarian.fs.events import FSChange, FSEvent
 from codex.librarian.fs.filters import (
+    is_ignored_basename,
     match_comic,
     match_folder_cover,
     match_group_cover_image,
@@ -42,8 +43,15 @@ def expand_dir_added(
     if not root.is_dir():
         return
     count = 0
-    for dirpath, _dirnames, filenames in os.walk(root):
+    for dirpath, dirnames, filenames in os.walk(root):
+        # Prune ignored directories in place so ``os.walk`` never
+        # descends into them under a freshly-added tree. Rules come
+        # from the central registry in ``filters`` — extend that
+        # module to add more patterns.
+        dirnames[:] = [d for d in dirnames if not is_ignored_basename(d)]
         for filename in filenames:
+            if is_ignored_basename(filename):
+                continue
             file_path = Path(dirpath) / filename
             if event := _classify_added_file(file_path, covers_only=covers_only):
                 batch.added.append((library_pk, event))

codex/librarian/fs/watcher/watcher.py

@@ -8,6 +8,7 @@
 from watchfiles import Change, watch
 
 from codex.librarian.fs.filters import (
+    is_ignored_path,
     match_comic,
     match_folder_cover,
     match_group_cover_image,
@@ -29,27 +30,37 @@
 class CodexWatchFilter:
     """Watchfiles watcher class for both types of library."""
 
-    def __init__(self, covers_only_paths: set[str]):
-        """Set covers_only_paths."""
+    def __init__(self, library_paths: set[str], covers_only_paths: set[str]):
+        """Set library and covers_only paths."""
+        self._library_paths = library_paths
         self._covers_only_paths = covers_only_paths
 
+    def _library_root_for(self, ppath: Path) -> str | None:
+        """Return the watched library root containing ``ppath``, if any."""
+        for lib_path in self._library_paths:
+            if ppath.is_relative_to(lib_path):
+                return lib_path
+        return None
+
     def __call__(self, change: Change, path: str) -> bool:
         """
         Filter method.
 
-        Deleted paths can't be inspected on disk, so let them all through;
-        event processing filters by DB lookup and suffix matching instead.
+        Deleted paths can't be inspected on disk, but the ignore-path
+        check runs purely on the path string so events under registered
+        ignore patterns are suppressed without a stat. Non-deleted
+        events also fall through to the suffix / cover predicates that
+        the poller mirrors.
         """
+        ppath = Path(path)
+        lib_root = self._library_root_for(ppath)
+        if lib_root is None or is_ignored_path(ppath, root=lib_root):
+            return False
+
         if change == Change.deleted:
             return True
 
-        ppath = Path(path)
-        covers_only = False
-        for covers_only_path in self._covers_only_paths:
-            if ppath.is_relative_to(covers_only_path):
-                covers_only = True
-                break
-
+        covers_only = lib_root in self._covers_only_paths
         if covers_only:
             return match_group_cover_image(ppath)
         return ppath.is_dir() or match_comic(ppath) or match_folder_cover(ppath)
@@ -161,7 +172,6 @@ def _get_extant_paths(self, paths: list[str]) -> list[str]:
 
     def _watch_loop(self) -> None:
         """Run the watchfiles loop, restarting when paths change."""
-        watch_filter = CodexWatchFilter(self._covers_only_paths)
         while not self._shutdown_event.is_set():
             self._restart_event.clear()
             paths = list(self._library_paths.keys())
@@ -170,6 +180,14 @@ def _watch_loop(self) -> None:
                 self._restart_event.wait(timeout=5.0)
                 continue
             extant_paths = self._get_extant_paths(paths)
+            # Built per iteration so a ``restart()`` from
+            # ``_update_paths_from_db`` (which rebinds the path sets)
+            # immediately propagates new libraries / covers-only flags
+            # into the filter — the previous outer-scope binding froze
+            # the filter to the path sets present at process startup.
+            watch_filter = CodexWatchFilter(
+                set(self._library_paths.keys()), self._covers_only_paths
+            )
             try:
                 for changes in watch(
                     *extant_paths,

codex/templates/pwa/serviceworker.js

@@ -21,10 +21,12 @@ self.addEventListener("install", (event) => {
 self.addEventListener("activate", (event) => {
   event.waitUntil(
     Promise.all([
-      // Pair with skipWaiting() so the new SW takes control of
-      // already-open pages immediately. Without this, replacing a
-      // stale SW (e.g. one with a stale CSP) would need a second
-      // reload to take effect.
+      /*
+       * Pair with skipWaiting() so the new SW takes control of
+       * already-open pages immediately. Without this, replacing a
+       * stale SW (e.g. one with a stale CSP) would need a second
+       * reload to take effect.
+       */
       self.clients.claim(),
       caches.keys().then((cacheNames) => {
         return Promise.all(
@@ -39,11 +41,13 @@ self.addEventListener("activate", (event) => {
 });
 // Serve from Cache
 self.addEventListener("fetch", (event) => {
-  // Pass through non-GET and cross-origin requests so the browser
-  // handles them under the page's CSP rather than the SW's snapshot
-  // taken at install time. Vite HMR talks to a separate origin
-  // (5173) and would otherwise be blocked by a stale SW CSP that
-  // pre-dates the dev-only overlay.
+  /*
+   * Pass through non-GET and cross-origin requests so the browser
+   * handles them under the page's CSP rather than the SW's snapshot
+   * taken at install time. Vite HMR talks to a separate origin
+   * (5173) and would otherwise be blocked by a stale SW CSP that
+   * pre-dates the dev-only overlay.
+   */
   const url = new URL(event.request.url);
   if (event.request.method !== "GET" || url.origin !== self.location.origin) {
     return;

codex/views/browser/annotate/order.py

@@ -227,15 +227,39 @@ def _annotate_page_count(self, qs):
         return qs
 
     def _annotate_bookmark_updated_at(self, qs) -> QuerySet:
-        if self.is_opds_acquisition or self.order_key == "bookmark_updated_at":
-            bmua_agg = self.get_max_bookmark_updated_at_aggregate(
-                qs.model, agg_func=self.order_agg_func
-            )
+        # Aggregate triggers:
+        # - OPDS acquisition needs the per-entry "last read" timestamp.
+        # - Sorting by ``bookmark_updated_at`` needs it as the order key.
+        # - Group rows in table view display it as a column; the cell
+        #   display path (``_emit_column`` → ``getattr``) reads the
+        #   annotation directly, so without this branch the column would
+        #   crash ``compute_group_intersections`` (the field can't be
+        #   aggregated as a Comic-relative scalar without the user
+        #   filter). Comic rows keep going through
+        #   ``annotate_comic_extra_specials`` to avoid double-annotation.
+        primary = self.is_opds_acquisition or self.order_key == "bookmark_updated_at"
+        table_column = (
+            qs.model is not Comic
+            and self.params.get("view_mode") == "table"
+            and self.order_key != "bookmark_updated_at"
+        )
+        if not primary and not table_column:
+            return qs
+        agg_func = self.order_agg_func if primary else Max
+        bmua_agg = self.get_max_bookmark_updated_at_aggregate(
+            qs.model, agg_func=agg_func
+        )
+        if primary:
             # `self.bmua_is_max` is read by `annotate.bookmark` to skip a
             # second aggregate, and by the serializer to compute mtime.
-            self.bmua_is_max = self.order_agg_func is Max
-            qs = qs.annotate(bookmark_updated_at=bmua_agg)
-        return qs
+            # Only set in the primary branch — that path annotates both
+            # group and Comic querysets, so the scalar exists on every
+            # serialized row. The table-column branch annotates only
+            # group rows; flipping the flag here would make
+            # ``get_mtime`` reach for a missing ``bookmark_updated_at``
+            # on Comic books in the same response.
+            self.bmua_is_max = agg_func is Max
+        return qs.annotate(bookmark_updated_at=bmua_agg)
 
     def _annotate_search_scores(self, qs, *, for_cover: bool = False):
         """Annotate Search Scores."""

codex/views/browser/intersections.py

@@ -86,7 +86,11 @@ def _format_identifier(source_name: str | None, id_type: str, key: str) -> str:
         "metadata_mtime": "metadata_mtime",
         "created_at": "created_at",
         "updated_at": "updated_at",
-        "bookmark_updated_at": "bookmark_updated_at",
+        # ``bookmark_updated_at`` is intentionally absent: it's not a
+        # Comic field but a per-user-filtered ``Max(bookmark__updated_at)``
+        # aggregate. The annotate pipeline attaches it directly to group
+        # rows in table view (see ``_annotate_bookmark_updated_at``); the
+        # cell display then falls through to ``getattr`` in ``_emit_column``.
         # FK-to-name columns (Comic FK → related model.name).
         "country": "country__name",
         "language": "language__name",