feat(files): cache served files and add HTML text viewer

File cache:
- Add my_modules/filecache with metadata, blob, validator and store layers
- Cache convex.get_file via AsyncCache, TTL clamped to the file expiry
- Skip caching for missing, incomplete or already expired records
- Add a process-local, size-bounded LRU for immutable storage blobs
- Build the cache stack from FILE_CACHE_* env vars in build_file_cache
- Attach the cache to the app in my_modules/app/setup.py
- Expose app-bound helpers in filecache/access.py for routes

Serving:
- Send strong ETag, Last-Modified and Cache-Control on served files
- Answer If-None-Match and If-Modified-Since with 304 from metadata only
- Avoid pulling the blob from Convex on a revalidation hit
- Add a short Cloudflare-CDN-Cache-Control edge window for deleted files
- Record cache_status in the wide event on a 304
- Invalidate cached metadata after file update and delete in both routes

Text viewer:
- Add my_modules/textview to render text/plain and text/markdown as HTML
- Linkify http(s) URLs and trim trailing sentence punctuation
- Resolve links pointing at this instance to the referenced file
- Inline image previews, mark missing and expired targets
- Cap resolution at MAX_LOOKUPS backend lookups per document
- Serve the viewer only for real browser navigations, never for curl or CLI
- Keep raw bytes for ?raw=1, downloads and Accept headers without text/html
- Add templates/side/views/webpage/files/text_view.htm with a raw link

Other:
- Add tests for cache layers, serving, text rendering and the route
- Bump multidict to 7.2.1 in uv.lock
- Update the my_helpers submodule pointer

my_modules/filecache/validators.py

@@ -0,0 +1,104 @@
+from __future__ import annotations
+
+import hashlib
+import time
+from email.utils import parsedate_to_datetime
+
+def build_etag(file_id: str, file_data: dict, download: bool = False) -> str:
+  """Strong validator for a stored file.
+
+  The blob behind a file_id never changes (updateFile only patches metadata),
+  so uploaded_at plus the storage id identify the bytes. The download flag is
+  part of the tag because it changes Content-Disposition.
+  """
+  parts = [
+    str(file_id),
+    str(file_data.get('uploaded_at', '')),
+    str(file_data.get('db_image_url', '')),
+    str(file_data.get('file_name', '')),
+    'attachment' if download else 'inline',
+  ]
+  digest = hashlib.sha256('\x1f'.join(parts).encode('utf-8')).hexdigest()[:32]
+  return f'"{digest}"'
+
+def _split_etags(header: str) -> list[str]:
+  return [value.strip() for value in header.split(',') if value.strip()]
+
+def etag_matches(if_none_match: str | None, etag: str) -> bool:
+  """RFC 9110 If-None-Match: '*' matches, weak comparison otherwise."""
+  if not if_none_match or not etag:
+    return False
+
+  header = if_none_match.strip()
+  if header == '*':
+    return True
+
+  def normalize(value: str) -> str:
+    return value.removeprefix('W/')
+
+  target = normalize(etag)
+  return any(normalize(candidate) == target for candidate in _split_etags(header))
+
+def _parse_http_date(value: str):
+  try:
+    return parsedate_to_datetime(value)
+  except (TypeError, ValueError):
+    return None
+
+def not_modified_since(if_modified_since: str | None, last_modified_epoch: float | None) -> bool:
+  if not if_modified_since or last_modified_epoch is None:
+    return False
+
+  parsed = _parse_http_date(if_modified_since)
+  if parsed is None:
+    return False
+
+  # HTTP dates have second precision, so compare truncated values.
+  return int(last_modified_epoch) <= int(parsed.timestamp())
+
+def is_fresh(
+  if_none_match: str | None,
+  if_modified_since: str | None,
+  etag: str,
+  last_modified_epoch: float | None,
+) -> bool:
+  """Decide a 304 from metadata alone, before any blob is fetched."""
+  if if_none_match is not None:
+    # An ETag was offered, so it alone decides and the date is ignored.
+    return etag_matches(if_none_match, etag)
+  return not_modified_since(if_modified_since, last_modified_epoch)
+
+def remaining_seconds(expires_at, now_ms: float | None = None) -> int | None:
+  """Seconds until expires_at (epoch ms), or None when the file never expires."""
+  if expires_at in (None, '', 0):
+    return None
+  try:
+    expires_ms = float(expires_at)
+  except (TypeError, ValueError):
+    return None
+
+  if now_ms is None:
+    now_ms = time.time() * 1000
+  return int((expires_ms - now_ms) / 1000)
+
+def _clamped_max_age(expires_at, max_age: int) -> int:
+  if max_age <= 0:
+    return 0
+  remaining = remaining_seconds(expires_at)
+  if remaining is None:
+    return max_age
+  return min(max_age, max(0, remaining))
+
+def cache_control(expires_at, max_age: int) -> str:
+  """Browser caching for immutable blobs, clamped to the remaining lifetime."""
+  clamped = _clamped_max_age(expires_at, max_age)
+  return f'public, max-age={clamped}' if clamped > 0 else 'no-cache'
+
+def edge_cache_control(expires_at, max_age: int) -> str:
+  """Separate, deliberately short TTL for Cloudflare.
+
+  Shared caches keep serving a file after it was deleted or expired at the
+  origin, so the edge gets a much smaller window than the browser does.
+  """
+  clamped = _clamped_max_age(expires_at, max_age)
+  return f'public, max-age={clamped}' if clamped > 0 else 'no-store'