diff --git a/Dockerfile b/Dockerfile
index 2e550d913..1c34a4a79 100644
--- a/Dockerfile
+++ b/Dockerfile
@@ -92,7 +92,12 @@ HEALTHCHECK --interval=10s --timeout=2s --start-period=3s --retries=3 \
 # process by design, see api/security.py (the allowed_roots trust set is
 # in-memory; multi-worker would split it).
 ENTRYPOINT ["/srv/.venv/bin/python", "-m", "api"]
-CMD ["--port", "8080"]
+# --host is explicit because the CLI defaults to loopback (an unauthenticated
+# API that serves any scanned root should not reach the network by default).
+# In a container that default would make the port unreachable from the host:
+# here 0.0.0.0 is the container's own namespace, and only published ports get
+# out. Any `command:` override must repeat this — see docker-compose.dev.yml.
+CMD ["--port", "8080", "--host", "0.0.0.0"]
 
 # Populated by CI via --build-arg.
 ARG GIT_SHA=dev
diff --git a/api/__main__.py b/api/__main__.py
index d06435706..f416bb7ae 100644
--- a/api/__main__.py
+++ b/api/__main__.py
@@ -1,9 +1,10 @@
 """api CLI entrypoint.
 
-    python -m api                Serve on :8080 (single uvicorn process).
-    python -m api --port 8000    Override port.
-    python -m api --reload       Auto-reload on source changes (dev only).
-    python -m api --version      Print version.
+    python -m api                    Serve on 127.0.0.1:8080 (single process).
+    python -m api --port 8000        Override port.
+    python -m api --host 0.0.0.0     Expose on the network (see --host below).
+    python -m api --reload           Auto-reload on source changes (dev only).
+    python -m api --version          Print version.
 
 SINGLE PROCESS by design — see api/security.py (the allowed_roots trust
 set is in-memory; multi-worker would split it). No --workers flag.
@@ -27,7 +28,16 @@ def _build_parser() -> argparse.ArgumentParser:
     )
     p.add_argument("--version", action="version", version=f"codecity {__version__}")
     p.add_argument("--port", type=int, default=8080, help="HTTP port (default 8080).")
-    p.add_argument("--host", default="0.0.0.0", help="Bind host (default 0.0.0.0).")
+    # Loopback by default: the API is unauthenticated, and once a scan registers
+    # a root, /api/file serves anything under it. Binding every interface would
+    # hand the whole scanned tree to anyone on the same network. Containers pass
+    # --host 0.0.0.0 explicitly, since there the bind is the container's own
+    # namespace and only published ports are reachable.
+    p.add_argument(
+        "--host",
+        default="127.0.0.1",
+        help="Bind host (default 127.0.0.1; use 0.0.0.0 to expose on the network).",
+    )
     p.add_argument("--reload", action="store_true", help="Auto-reload (dev only).")
     return p
 
diff --git a/api/config.py b/api/config.py
index 85d5a134b..626f270e6 100644
--- a/api/config.py
+++ b/api/config.py
@@ -14,6 +14,10 @@
 MAX_FILE_BYTES = 100 * 1024 * 1024
 # Bodies under this skip gzip — framing overhead exceeds the savings.
 GZIP_MIN_BYTES = 256
+# Paths accepted per POST /api/images or /api/fingerprints; the rest of the
+# body is ignored. Served over /api/config so the client chunks to the same
+# number instead of hardcoding its own guess and silently losing the tail.
+MAX_BATCH_PATHS = 64
 
 # Root for every on-disk cache — the single source of truth for where codecity
 # stores things. cache.py hangs its manifest/file-stat/git-history subdirs off
diff --git a/api/models/responses.py b/api/models/responses.py
index 229a668ba..0fda90c13 100644
--- a/api/models/responses.py
+++ b/api/models/responses.py
@@ -38,10 +38,7 @@ class HealthResponse(BaseModel):
 
 class ConfigResponse(BaseModel):
     allowLocalRepos: bool
-
-
-class CacheClearResponse(BaseModel):
-    deleted: int
+    maxBatchPaths: int
 
 
 class CommitDetailResponse(BaseModel):
diff --git a/api/routers/file.py b/api/routers/file.py
index 6fca2fbfb..fe1a86874 100644
--- a/api/routers/file.py
+++ b/api/routers/file.py
@@ -18,7 +18,7 @@
 from fastapi.responses import JSONResponse
 from pydantic import BaseModel
 
-from api.config import MAX_FILE_BYTES
+from api.config import MAX_BATCH_PATHS, MAX_FILE_BYTES
 from api.models.responses import (
     ImageBatchEntry,
     FileTooLargeResponse,
@@ -31,9 +31,9 @@
 
 router = APIRouter(prefix="/api", tags=["file"])
 
-# Server-side bounds on one batch response; oversized or non-image paths are
-# omitted and the client falls back to the streaming GET /api/file.
-_MAX_BATCH_PATHS = 64
+# Server-side bound on one batch response; oversized or non-image paths are
+# omitted and the client falls back to the streaming GET /api/file. The path
+# count lives in config.py because /api/config publishes it to the client.
 _MAX_BATCH_IMAGE_BYTES = 8 * 1024 * 1024
 
 _SHA_RE = re.compile(r"[0-9a-f]{40}")
@@ -124,7 +124,7 @@ def get_images(req: PathBatchRequest) -> dict[str, ImageBatchEntry]:
     never batched (they stream their poster frame), so this is images only.
     """
     out: dict[str, ImageBatchEntry] = {}
-    for path in req.paths[:_MAX_BATCH_PATHS]:
+    for path in req.paths[:MAX_BATCH_PATHS]:
         sha = (req.shas or {}).get(path)
         try:
             target = TRUST.assert_inside(Path(path), must_exist=sha is None)
@@ -157,7 +157,7 @@ def get_fingerprints(req: PathBatchRequest) -> dict[str, FingerprintEntry]:
     unreadable paths are silently omitted. Raw binary bytes never leave the
     server — only the head is read, and only the fingerprint image returned."""
     out: dict[str, FingerprintEntry] = {}
-    for path in req.paths[:_MAX_BATCH_PATHS]:
+    for path in req.paths[:MAX_BATCH_PATHS]:
         try:
             target = TRUST.assert_inside(Path(path))
         except (NoRootsRegisteredError, OutsideRootError, OSError, RuntimeError):
diff --git a/api/routers/manifest.py b/api/routers/manifest.py
index 98f5790de..c8a52616e 100644
--- a/api/routers/manifest.py
+++ b/api/routers/manifest.py
@@ -1,10 +1,9 @@
 """The manifest routes: GET /api/manifest (SSE stream), GET
-/api/manifest/signature, GET /api/timeline (SSE stream), DELETE
-/api/manifest/cache.
+/api/manifest/signature, GET /api/timeline (SSE stream).
 
 Source classification/resolution lives in api.services.source; these are the
 thin HTTP handlers over it. A ResolveError carries a status + message: the
-signature/cache routes turn it into an HTTPException, while the manifest and
+signature route turns it into an HTTPException, while the manifest and
 timeline SSE routes turn it into an `error` event (EventSource can't read 4xx
 bodies)."""
 
@@ -32,10 +31,8 @@
     TimelineProgressEvent,
 )
 from api.models.manifest import SignatureResponse
-from api.models.responses import CacheClearResponse
 from api.security import TRUST
 from api.services.cache import (
-    cache_clear_all,
     cache_clear_timeline,
     cache_load_manifest,
     cache_load_ref_manifest,
@@ -49,11 +46,9 @@
     CloneError,
     HostUnreachableError,
     RepoNotFoundError,
-    clone_dir_for,
     ensure_clone,
     fetch_lfs_history,
     hydrate_blobs,
-    remove_clone,
 )
 from api.services.gitobj import resolve_ref
 from api.services.scan import (
@@ -247,34 +242,6 @@ def _run() -> None:
     return EventSourceResponse(gen())
 
 
-@router.delete("/manifest/cache", response_model=CacheClearResponse)
-def clear_cache(
-    src: str = Query(...),
-    branch: str | None = Query(None),
-) -> CacheClearResponse:
-    if not src:
-        raise HTTPException(400, "missing 'src' query param")
-    kind = classify(src)
-    if kind is SourceKind.INVALID:
-        raise HTTPException(400, "unrecognized source: pass a local path or a git URL")
-    if kind is SourceKind.REMOTE:
-        abs_root = clone_dir_for(src, branch)
-    else:
-        # Non-strict resolve so a recents entry for a since-deleted path
-        # still drops its cache.
-        abs_root = Path(src).resolve(strict=False)
-    # Full clean slate for this source: every per-root cache (manifest,
-    # file-stat, git-history). For a REMOTE source also delete the clone working
-    # tree so a re-add re-clones from scratch — the recovery path for a corrupt
-    # clone. Hold the clone lock so we never rmtree a clone a concurrent request
-    # is mid-clone into.
-    deleted = cache_clear_all(abs_root)
-    if kind is SourceKind.REMOTE:
-        with TRUST.clone_lock:
-            remove_clone(src, branch)
-    return CacheClearResponse(deleted=deleted)
-
-
 def _sse(event: "ScanEvent | TimelineEvent", payload: dict[str, Any]) -> dict[str, Any]:
     """sse-starlette event dict: {'event': name, 'data': json-string}. Both
     StrEnums serialize to their wire string ('manifest-complete', 'timeline-
diff --git a/api/routers/meta.py b/api/routers/meta.py
index 1105ffcd0..0c97813ef 100644
--- a/api/routers/meta.py
+++ b/api/routers/meta.py
@@ -6,7 +6,7 @@
 
 from fastapi import APIRouter
 
-from api.config import local_repos_allowed
+from api.config import MAX_BATCH_PATHS, local_repos_allowed
 from api.models.responses import ConfigResponse, HealthResponse
 
 router = APIRouter(prefix="/api", tags=["meta"])
@@ -19,4 +19,7 @@ def health() -> HealthResponse:
 
 @router.get("/config", response_model=ConfigResponse)
 def config() -> ConfigResponse:
-    return ConfigResponse(allowLocalRepos=local_repos_allowed())
+    return ConfigResponse(
+        allowLocalRepos=local_repos_allowed(),
+        maxBatchPaths=MAX_BATCH_PATHS,
+    )
diff --git a/api/services/cache.py b/api/services/cache.py
index 85a44df06..07b1c6340 100644
--- a/api/services/cache.py
+++ b/api/services/cache.py
@@ -393,10 +393,9 @@ def _manifest_cache_path(abs_root: Path, content_signature: str) -> Path:
 
 
 def _ref_manifest_cache_path(abs_root: Path, ref_sha: str) -> Path:
-    # `__ref-` (not `__`) so cache_clear_manifests's `{repo_key}__*.json.gz`
-    # glob still sweeps these alongside content-signature entries, while the
-    # prefix keeps a ref-sha visually distinct from a content signature in
-    # directory listings.
+    # `__ref-` prefix keeps a ref-sha visually distinct from a content
+    # signature in directory listings, while staying inside the
+    # `{repo_key}__*.json.gz` shape the other per-root globs match.
     return CACHE_ROOT / "manifests" / f"{repo_key(abs_root)}__ref-{ref_sha}.json.gz"
 
 
@@ -462,6 +461,83 @@ def _save_gz_manifest(path: Path, manifest: "Manifest") -> None:
     )
 
 
+# Entries are keyed by repo CONTENT, so without a cap this directory grows for
+# the life of the install. Sized by how far back a re-read is plausible; these
+# are pure performance caches, so evicting costs a rescan, never correctness.
+_KEEP_CONTENT_MANIFESTS = 5
+_KEEP_REF_MANIFESTS = 20
+_KEEP_TIMELINE_BUNDLES = 3
+
+
+def _entry_family(name_rest: str) -> str:
+    """Which retention pool a `{repo_key}__<rest>` cache file belongs to."""
+    if name_rest.startswith("ref-"):
+        return "ref"
+    if name_rest.startswith("timeline-"):
+        return "timeline"
+    return "content"
+
+
+_FAMILY_KEEP = {
+    "content": _KEEP_CONTENT_MANIFESTS,
+    "ref": _KEEP_REF_MANIFESTS,
+    "timeline": _KEEP_TIMELINE_BUNDLES,
+}
+
+
+def prune_manifest_cache(abs_root: Path, *, protect: Path | None = None) -> int:
+    """Drop this root's oldest manifest-dir entries, per family. Returns the
+    count deleted.
+
+    `protect` is never evicted. Callers pass the path they just wrote: mtime
+    resolution is only one second on some filesystems, so a burst of saves can
+    tie and sort the newest entry into the tail — which would delete the very
+    manifest the caller is about to read back.
+
+    Ordering is by mtime rather than access time, which macOS and most Linux
+    mounts do not track (relatime), so this is write-recency, not LRU: an old
+    signature that keeps being re-read still ages out. That is the right trade
+    here, since re-reading it only ever saved a rescan.
+
+    Best-effort, like the rest of this module: a failed unlink (or a file a
+    concurrent request removed first) must never break the response."""
+    manifests_dir = CACHE_ROOT / "manifests"
+    if not manifests_dir.exists():
+        return 0
+
+    prefix = f"{repo_key(abs_root)}__"
+    families: dict[str, list[tuple[float, Path]]] = {
+        "content": [],
+        "ref": [],
+        "timeline": [],
+    }
+    for path in manifests_dir.glob(f"{prefix}*.json.gz"):
+        if protect is not None and path == protect:
+            continue  # counts against nothing; it always stays
+        try:
+            mtime = path.stat().st_mtime
+        except OSError:
+            continue  # vanished under us; nothing to prune
+        families[_entry_family(path.name[len(prefix) :])].append((mtime, path))
+
+    deleted = 0
+    for family, entries in families.items():
+        # The protected entry is out of `entries`, so leave room for it.
+        keep = _FAMILY_KEEP[family]
+        if protect is not None and _entry_family(protect.name[len(prefix) :]) == family:
+            keep -= 1
+        if len(entries) <= keep:
+            continue
+        entries.sort(key=lambda e: e[0], reverse=True)  # newest first
+        for _, path in entries[keep:]:
+            try:
+                path.unlink()
+                deleted += 1
+            except OSError:
+                pass
+    return deleted
+
+
 def cache_load_manifest(
     abs_root: Path,
     content_signature: str,
@@ -476,20 +552,23 @@ def cache_save_manifest(
     manifest: "Manifest",
 ) -> None:
     """Atomically write the manifest cache for this (root, content_signature)."""
-    _save_gz_manifest(_manifest_cache_path(abs_root, content_signature), manifest)
+    path = _manifest_cache_path(abs_root, content_signature)
+    _save_gz_manifest(path, manifest)
+    prune_manifest_cache(abs_root, protect=path)
 
 
 def cache_load_ref_manifest(abs_root: Path, ref_sha: str) -> "Manifest | None":
     """Load the cached manifest for this (root, ref_sha). A resolved commit
     sha's manifest is immutable (the commit's content never changes), so
-    unlike the content-signature cache this key never needs invalidating —
-    only `cache_clear_manifests`/`cache_clear_all` remove it."""
+    unlike the content-signature cache this key never needs invalidating."""
     return _load_gz_manifest(_ref_manifest_cache_path(abs_root, ref_sha))
 
 
 def cache_save_ref_manifest(abs_root: Path, ref_sha: str, manifest: "Manifest") -> None:
     """Atomically write the ref-keyed manifest cache for (root, ref_sha)."""
-    _save_gz_manifest(_ref_manifest_cache_path(abs_root, ref_sha), manifest)
+    path = _ref_manifest_cache_path(abs_root, ref_sha)
+    _save_gz_manifest(path, manifest)
+    prune_manifest_cache(abs_root, protect=path)
 
 
 def _excludes_key(excludes: frozenset[str]) -> str:
@@ -531,12 +610,14 @@ def cache_save_timeline(
     excludes: frozenset[str] = frozenset(),
 ) -> None:
     """Atomically write the timeline bundle cache for (root, head_sha, excludes)."""
+    path = _timeline_cache_path(abs_root, head_sha, excludes)
     _save_gz_envelope(
-        _timeline_cache_path(abs_root, head_sha, excludes),
+        path,
         envelope_key="bundle",
         version=_TIMELINE_CACHE_VERSION,
         payload=cast("dict[str, object]", bundle),
     )
+    prune_manifest_cache(abs_root, protect=path)
 
 
 def cache_clear_timeline(abs_root: Path) -> int:
@@ -556,50 +637,3 @@ def cache_clear_timeline(abs_root: Path) -> int:
         except OSError:
             pass
     return count
-
-
-def cache_clear_manifests(abs_root: Path) -> int:
-    """Delete every cached manifest file for this root, across all
-    signatures, every ref-keyed manifest, AND every timeline bundle (the
-    `__*.json.gz` glob below matches `__<signature>.json.gz`,
-    `__ref-<sha>.json.gz`, and `__timeline-<sha>.json.gz`).
-    Returns the count deleted.
-
-    Silently ignores I/O errors per the rest of this module's hygiene —
-    cache cleanup failures must never break the response."""
-    manifests_dir = CACHE_ROOT / "manifests"
-    if not manifests_dir.exists():
-        return 0
-    pattern = f"{repo_key(abs_root)}__*.json.gz"
-    count = 0
-    for path in manifests_dir.glob(pattern):
-        try:
-            path.unlink()
-            count += 1
-        except OSError:
-            pass
-    return count
-
-
-def cache_clear_all(abs_root: Path) -> int:
-    """Delete EVERY per-root cache for this root — manifest (all
-    signatures), file-stat, git-history, and blob-stats. Returns the count
-    deleted.
-
-    Backs the "clear cache" flow's clean-slate guarantee for a source.
-    The git clone working tree lives outside CACHE_ROOT, so the caller
-    removes it separately (see clone.remove_clone). Same swallow-errors
-    hygiene as the rest of this module — cleanup failures must never
-    break the response."""
-    count = cache_clear_manifests(abs_root)
-    for path in (
-        _file_cache_path(abs_root),
-        _git_history_cache_path(abs_root),
-        _blob_cache_path(abs_root),
-    ):
-        try:
-            path.unlink()
-            count += 1
-        except OSError:
-            pass  # missing file or I/O error — best-effort cleanup
-    return count
diff --git a/api/services/clone.py b/api/services/clone.py
index e07db4afa..f050220d1 100644
--- a/api/services/clone.py
+++ b/api/services/clone.py
@@ -70,7 +70,6 @@ class CloneInterruptedError(CloneError):
     "fetch_lfs_history",
     "hydrate_blobs",
     "list_remote_branches",
-    "remove_clone",
 ]
 
 
@@ -855,17 +854,6 @@ def _partial_clone_filter(target: Path) -> str | None:
         return None
 
 
-def remove_clone(url: str, branch: str | None) -> bool:
-    """Delete the cached clone working tree for ``(url, branch)``. Returns
-    True if a directory existed and was removed, False if there was nothing
-    to remove. Best-effort: rmtree errors are swallowed (ignore_errors)."""
-    target = clone_dir_for(url, branch)
-    if not target.exists():
-        return False
-    shutil.rmtree(target, ignore_errors=True)
-    return True
-
-
 # ls-remote timeout: bounded so a black-holed remote can't wedge a request.
 # 20s covers a slow-but-live remote; a real hang trips it and surfaces a clean
 # HostUnreachableError to the caller.
diff --git a/api/services/manifest_types.py b/api/services/manifest_types.py
index cb5c058a9..3638129f8 100644
--- a/api/services/manifest_types.py
+++ b/api/services/manifest_types.py
@@ -13,10 +13,11 @@
 leaf both import from. It imports only the pure models layer (never
 services), so it stays cycle-free for both.
 
-Mirrors app/types/manifest.ts. Keep both in sync — the web app consumes
-the JSON exactly as these TypedDicts describe it. Drift here is shape
-drift in the wire format and will be caught by pyright on the Python
-side and tsc on the TS side, but only within each language.
+The frontend does not mirror this module by hand: `api/models/` produces the
+OpenAPI schema, `just gen-types` turns that into
+app/src/types/manifest.generated.ts, and app/src/types/manifest.ts derives from
+it. So the pairing to keep honest is this module against `api/models/` — pyright
+checks each side internally, but nothing checks the two against each other.
 """
 
 from __future__ import annotations
diff --git a/api/services/stats.py b/api/services/stats.py
index 46ee83e61..371622021 100644
--- a/api/services/stats.py
+++ b/api/services/stats.py
@@ -94,8 +94,8 @@ def _longest_streak(dates: list[str]) -> int:
 
 
 def _author_hue(name: str) -> int:
-    """FNV-1a over the name's UTF-8 bytes, mod 360. Mirrors the 32-bit unsigned
-    arithmetic of the JS original so a name keeps the hue it already had."""
+    """FNV-1a over the name's UTF-8 bytes, mod 360. The & 0xFFFFFFFF keeps the
+    hash in 32-bit unsigned range; widening it would repaint every author."""
     h = 0x811C9DC5
     for byte in name.encode("utf-8"):
         h ^= byte
diff --git a/api/services/timeline.py b/api/services/timeline.py
index d81ce4a6e..9a33e58ae 100644
--- a/api/services/timeline.py
+++ b/api/services/timeline.py
@@ -300,8 +300,8 @@ def compute_commit_line_ranges(
 
 
 def _iso_ms(value: str | None) -> int | None:
-    """Epoch ms for a Z-suffixed UTC stamp, or None. Matches JS Date.parse,
-    which the client used before this moved server-side."""
+    """Epoch ms for a Z-suffixed UTC stamp, or None. Semantics match JS
+    Date.parse, since these values are compared against client-side dates."""
     if not value:
         return None
     try:
@@ -321,10 +321,13 @@ def compute_commit_date_ranges(
     commit — what the weathering (color, lit windows, grime) normalizes against,
     so range[HEAD] equals the live manifest's dateRanges.
 
-    Mirrors the client replay it replaces: a file uses its own full-precision
-    date once it has reached its final change, and the date of its latest change
-    commit before that; creation is fixed at its own date, falling back to its
-    genesis commit."""
+    A file uses its own full-precision date once it has reached its final
+    change, and the date of its latest change commit before that; creation is
+    fixed at its own date, falling back to its genesis commit.
+
+    The client walks these same deltas in city/timeline/replay.ts, but to build
+    a per-path index for per-frame scrub queries. Different output, different
+    consumer — neither is a copy of the other."""
     commit_ms = [_iso_ms(c["date"]) or 0 for c in commits]
 
     final_idx: dict[str, int] = {}
diff --git a/api/tests/test_cache.py b/api/tests/test_cache.py
index 013637a36..880d179b3 100644
--- a/api/tests/test_cache.py
+++ b/api/tests/test_cache.py
@@ -3,6 +3,7 @@
 from __future__ import annotations
 
 import json
+import os
 import unittest
 from pathlib import Path
 
@@ -508,29 +509,6 @@ def test_manifest_rejects_when_git_history_version_changed(self):
         # Loader must reject.
         self.assertIsNone(cache_load_manifest(root, sig))
 
-    def test_clear_manifests_deletes_every_signature(self) -> None:
-        root = Path("/x")
-        manifest = self._make_manifest()
-        cache_mod.cache_save_manifest(root, "a" * 32, manifest)
-        cache_mod.cache_save_manifest(root, "b" * 32, manifest)
-        # Unrelated root — must NOT be deleted.
-        cache_mod.cache_save_manifest(Path("/y"), "c" * 32, manifest)
-
-        deleted = cache_mod.cache_clear_manifests(root)
-        self.assertEqual(deleted, 2)
-        self.assertIsNone(cache_mod.cache_load_manifest(root, "a" * 32))
-        self.assertIsNone(cache_mod.cache_load_manifest(root, "b" * 32))
-        # Unrelated root's cache survives.
-        self.assertIsNotNone(cache_mod.cache_load_manifest(Path("/y"), "c" * 32))
-
-    def test_clear_manifests_no_entries_returns_zero(self) -> None:
-        self.assertEqual(cache_mod.cache_clear_manifests(Path("/never/scanned")), 0)
-
-    def test_clear_manifests_missing_dir_returns_zero(self) -> None:
-        # CACHE_ROOT/manifests doesn't exist yet (no saves have happened).
-        self.assertFalse((cache_mod.CACHE_ROOT / "manifests").exists())
-        self.assertEqual(cache_mod.cache_clear_manifests(Path("/x")), 0)
-
     def test_ref_manifest_roundtrip(self) -> None:
         root = Path("/some/repo")
         sha = "a" * 40
@@ -543,19 +521,6 @@ def test_ref_manifest_load_missing_returns_none(self) -> None:
             cache_mod.cache_load_ref_manifest(Path("/never/scanned"), "b" * 40)
         )
 
-    def test_clear_manifests_also_sweeps_ref_manifests(self) -> None:
-        # cache_clear_manifests's `{repo_key}__*.json.gz` glob covers BOTH
-        # content-signature and `__ref-<sha>` keyed files.
-        root = Path("/x")
-        manifest = self._make_manifest()
-        cache_mod.cache_save_manifest(root, "a" * 32, manifest)
-        cache_mod.cache_save_ref_manifest(root, "b" * 40, manifest)
-
-        deleted = cache_mod.cache_clear_manifests(root)
-        self.assertEqual(deleted, 2)
-        self.assertIsNone(cache_mod.cache_load_manifest(root, "a" * 32))
-        self.assertIsNone(cache_mod.cache_load_ref_manifest(root, "b" * 40))
-
     def _make_bundle(self) -> dict:
         return {
             "commits": [],
@@ -617,18 +582,6 @@ def test_timeline_excludes_key_separately(self) -> None:
             cache_mod.cache_load_timeline(root, sha, frozenset({"other"}))
         )
 
-    def test_clear_manifests_also_sweeps_timeline(self) -> None:
-        # cache_clear_manifests's `{repo_key}__*.json.gz` glob covers
-        # content-signature, `__ref-<sha>`, AND `__timeline-<sha>` keyed files.
-        root = Path("/x")
-        cache_mod.cache_save_manifest(root, "a" * 32, self._make_manifest())
-        cache_mod.cache_save_timeline(root, "b" * 40, self._make_bundle())
-
-        deleted = cache_mod.cache_clear_manifests(root)
-        self.assertEqual(deleted, 2)
-        self.assertIsNone(cache_mod.cache_load_manifest(root, "a" * 32))
-        self.assertIsNone(cache_mod.cache_load_timeline(root, "b" * 40))
-
     def test_clear_timeline_evicts_all_heads_only(self) -> None:
         # A no_cache scan clears every timeline bundle for the root (all HEADs)
         # but leaves the manifest caches untouched.
@@ -794,3 +747,93 @@ def test_blob_stats_cache_version_mismatch_is_miss(tmp_path, monkeypatch):
 
 if __name__ == "__main__":
     unittest.main()
+
+
+class ManifestCachePruneTests(CacheTestBase):
+    """Retention on the manifests/ dir.
+
+    Every entry there is keyed by repo CONTENT, so the directory grew for the
+    life of the install — 844 files / 281 MB on one dev machine before this.
+    """
+
+    def _manifest(self) -> dict:
+        return {
+            "root": "/some/repo",
+            "scanned_at": "2026-05-17T00:00:00Z",
+            "content_signature": "deadbeef" * 4,
+            "tree": {"name": "repo", "type": "dir", "path": "", "children": []},
+        }
+
+    def _names(self, root: Path) -> list[str]:
+        prefix = f"{cache_mod.repo_key(root)}__"
+        d = cache_mod.CACHE_ROOT / "manifests"
+        return sorted(p.name[len(prefix) :] for p in d.glob(f"{prefix}*.json.gz"))
+
+    def test_content_signatures_are_capped(self) -> None:
+        root = Path("/x")
+        keep = cache_mod._KEEP_CONTENT_MANIFESTS
+        for i in range(keep + 4):
+            cache_mod.cache_save_manifest(root, f"{i:032x}", self._manifest())
+
+        self.assertEqual(len(self._names(root)), keep)
+
+    def test_the_entry_just_written_always_survives(self) -> None:
+        # Pruning runs after the save, so the newest write is never the victim.
+        root = Path("/x")
+        for i in range(cache_mod._KEEP_CONTENT_MANIFESTS + 3):
+            sig = f"{i:032x}"
+            cache_mod.cache_save_manifest(root, sig, self._manifest())
+            self.assertIsNotNone(cache_mod.cache_load_manifest(root, sig))
+
+    def test_families_are_capped_independently(self) -> None:
+        # A scrub session writing many ref manifests must not evict the live
+        # content-signature manifest out from under the running scan.
+        root = Path("/x")
+        cache_mod.cache_save_manifest(root, "a" * 32, self._manifest())
+        for i in range(cache_mod._KEEP_REF_MANIFESTS + 5):
+            cache_mod.cache_save_ref_manifest(root, f"{i:040x}", self._manifest())
+
+        self.assertIsNotNone(cache_mod.cache_load_manifest(root, "a" * 32))
+        refs = [n for n in self._names(root) if n.startswith("ref-")]
+        self.assertEqual(len(refs), cache_mod._KEEP_REF_MANIFESTS)
+
+    def test_pruning_one_repo_leaves_another_alone(self) -> None:
+        other = Path("/y")
+        cache_mod.cache_save_manifest(other, "c" * 32, self._manifest())
+        for i in range(cache_mod._KEEP_CONTENT_MANIFESTS + 3):
+            cache_mod.cache_save_manifest(Path("/x"), f"{i:032x}", self._manifest())
+
+        self.assertIsNotNone(cache_mod.cache_load_manifest(other, "c" * 32))
+
+    def test_prune_on_a_never_scanned_root_is_a_noop(self) -> None:
+        self.assertEqual(cache_mod.prune_manifest_cache(Path("/never/scanned")), 0)
+
+    def test_prune_with_no_manifests_dir_is_a_noop(self) -> None:
+        self.assertFalse((cache_mod.CACHE_ROOT / "manifests").exists())
+        self.assertEqual(cache_mod.prune_manifest_cache(Path("/x")), 0)
+
+    def test_protect_survives_even_when_it_ranks_oldest(self) -> None:
+        # Why `protect` exists rather than trusting the mtime sort: some
+        # filesystems resolve mtime only to the second, so a burst of saves ties
+        # and the just-written entry can rank anywhere — including the evicted
+        # tail. Pin it to the oldest possible mtime, the worst case, and it must
+        # still survive, because the caller is about to read it back.
+        root = Path("/x")
+        d = cache_mod.CACHE_ROOT / "manifests"
+        d.mkdir(parents=True, exist_ok=True)
+
+        # Write past the cap directly, so setup does not prune as it goes.
+        paths = []
+        for i in range(cache_mod._KEEP_CONTENT_MANIFESTS + 3):
+            path = cache_mod._manifest_cache_path(root, f"{i:032x}")
+            cache_mod._save_gz_manifest(path, self._manifest())
+            paths.append(path)
+
+        victim = paths[0]
+        os.utime(victim, (1, 1))  # oldest by a wide margin -> first to go
+
+        cache_mod.prune_manifest_cache(root, protect=victim)
+
+        self.assertTrue(victim.exists(), "protected entry was evicted")
+        remaining = list(d.glob(f"{cache_mod.repo_key(root)}__*.json.gz"))
+        self.assertEqual(len(remaining), cache_mod._KEEP_CONTENT_MANIFESTS)
diff --git a/api/tests/test_cli.py b/api/tests/test_cli.py
index 46f5072ec..33d4d5411 100644
--- a/api/tests/test_cli.py
+++ b/api/tests/test_cli.py
@@ -42,3 +42,23 @@ def test_main_invokes_uvicorn() -> None:
         run.assert_called_once()
         assert run.call_args.kwargs["port"] == 9999
         assert run.call_args.kwargs["workers"] == 1
+
+
+def test_binds_loopback_by_default() -> None:
+    """The API is unauthenticated and serves any registered scan root, so the
+    default bind must not reach the network. Containers opt in explicitly."""
+    from unittest import mock
+    from api.__main__ import main
+
+    with mock.patch("api.__main__.uvicorn.run") as run:
+        assert main([]) == 0
+        assert run.call_args.kwargs["host"] == "127.0.0.1"
+
+
+def test_host_flag_can_opt_into_exposure() -> None:
+    from unittest import mock
+    from api.__main__ import main
+
+    with mock.patch("api.__main__.uvicorn.run") as run:
+        assert main(["--host", "0.0.0.0"]) == 0
+        assert run.call_args.kwargs["host"] == "0.0.0.0"
diff --git a/api/tests/test_models.py b/api/tests/test_models.py
index bf0b9d352..1ccdea1fb 100644
--- a/api/tests/test_models.py
+++ b/api/tests/test_models.py
@@ -168,8 +168,8 @@ def test_health_and_config(self) -> None:
 
         self.assertEqual(HealthResponse(ok=True).model_dump(), {"ok": True})
         self.assertEqual(
-            ConfigResponse(allowLocalRepos=False).model_dump(),
-            {"allowLocalRepos": False},
+            ConfigResponse(allowLocalRepos=False, maxBatchPaths=64).model_dump(),
+            {"allowLocalRepos": False, "maxBatchPaths": 64},
         )
 
     def test_sse_event_serialization(self) -> None:
diff --git a/api/tests/test_scan_dirty.py b/api/tests/test_scan_dirty.py
index 2440c7e25..f6654792e 100644
--- a/api/tests/test_scan_dirty.py
+++ b/api/tests/test_scan_dirty.py
@@ -117,8 +117,8 @@ def test_dirty_file_count_matches_flags(tmp_path: Path):
 
 
 def test_hash_repo_info_has_no_repo_level_dirty_set_param():
-    # Dirty rides per-file now (Task 4); _hash_repo_info must not accept a
-    # repo-wide dirty_paths set anymore.
+    # Dirtiness is per-file, so a repo-wide dirty_paths set would recompute the
+    # signature for every file whenever any one of them changed.
     assert list(inspect.signature(_hash_repo_info).parameters) == ["sig", "repo_info"]
 
 
diff --git a/api/tests/test_server_cache.py b/api/tests/test_server_cache.py
deleted file mode 100644
index abbc43379..000000000
--- a/api/tests/test_server_cache.py
+++ /dev/null
@@ -1,93 +0,0 @@
-"""TestClient coverage for DELETE /api/manifest/cache."""
-
-from __future__ import annotations
-
-import subprocess
-from pathlib import Path
-
-import pytest
-from fastapi.testclient import TestClient
-
-from api.app import create_app
-from api.services.cache import cache_save_manifest
-from api.services.scan import signature_tree
-
-
-def _git(*a: str, cwd: Path) -> None:
-    subprocess.run(["git", *a], cwd=cwd, check=True, capture_output=True)
-
-
-@pytest.fixture()
-def repo(tmp_path: Path) -> Path:
-    p = tmp_path / "repo"
-    p.mkdir()
-    _git("init", "-q", cwd=p)
-    _git("config", "user.email", "a@b.c", cwd=p)
-    _git("config", "user.name", "T", cwd=p)
-    (p / "f.txt").write_text("x")
-    _git("add", ".", cwd=p)
-    _git("commit", "-qm", "c", cwd=p)
-    return p
-
-
-@pytest.fixture()
-def client(tmp_path: Path, redirect_cache_root) -> TestClient:
-    static = tmp_path / "static"
-    static.mkdir()
-    (static / "index.html").write_text("x")
-    return TestClient(create_app(static_dir=static))
-
-
-def test_cache_missing_src(client: TestClient) -> None:
-    assert client.delete("/api/manifest/cache").status_code in (400, 422)
-
-
-def test_cache_invalid_src_400(client: TestClient) -> None:
-    r = client.delete("/api/manifest/cache", params={"src": "neither-path-nor-url"})
-    assert r.status_code == 400
-
-
-def test_cache_clears_warmed_local_source(client: TestClient, repo: Path) -> None:
-    # Warm the cache directly via the service layer (no SSE stream yet).
-    sig = signature_tree(str(repo), use_cache=False)["content_signature"]
-    cache_save_manifest(repo.resolve(), sig, {"root": str(repo)})  # type: ignore[arg-type]
-    r = client.delete("/api/manifest/cache", params={"src": str(repo)})
-    assert r.status_code == 200
-    assert r.json()["deleted"] >= 1
-
-
-def test_cache_delete_not_gated_by_local_repos(
-    client: TestClient, repo: Path, monkeypatch
-) -> None:
-    # Cache-delete must work even when local repos are disabled.
-    monkeypatch.delenv("CODECITY_ALLOW_LOCAL_REPOS", raising=False)
-    r = client.delete("/api/manifest/cache", params={"src": str(repo)})
-    assert r.status_code == 200
-    assert "deleted" in r.json()
-
-
-def test_cache_clear_removes_remote_clone_dir(client: TestClient) -> None:
-    # For a REMOTE source, clearing the cache also deletes the clone working
-    # tree so a re-add re-clones from scratch (the corrupt-clone recovery path).
-    from api.services import clone as clone_mod
-
-    url = "https://example.com/owner/repo.git"
-    clone_dir = clone_mod.clone_dir_for(url, None)
-    clone_dir.mkdir(parents=True)
-    (clone_dir / "marker.txt").write_text("x")
-    r = client.delete("/api/manifest/cache", params={"src": url})
-    assert r.status_code == 200
-    assert not clone_dir.exists(), "remote clone dir should be removed on cache clear"
-
-
-def test_cache_clear_does_not_delete_local_project(
-    client: TestClient, repo: Path
-) -> None:
-    # A LOCAL source's actual project directory must NEVER be deleted — only
-    # its per-root caches under CACHE_ROOT are dropped.
-    sig = signature_tree(str(repo), use_cache=False)["content_signature"]
-    cache_save_manifest(repo.resolve(), sig, {"root": str(repo)})  # type: ignore[arg-type]
-    r = client.delete("/api/manifest/cache", params={"src": str(repo)})
-    assert r.status_code == 200
-    assert repo.is_dir(), "local project directory must not be deleted"
-    assert (repo / "f.txt").is_file()
diff --git a/api/tests/test_server_config.py b/api/tests/test_server_config.py
index 9ad6b4b24..4f80ea4ea 100644
--- a/api/tests/test_server_config.py
+++ b/api/tests/test_server_config.py
@@ -8,6 +8,7 @@
 from fastapi.testclient import TestClient
 
 from api.app import create_app
+from api.config import MAX_BATCH_PATHS
 
 
 @pytest.fixture()
@@ -20,9 +21,23 @@ def client(tmp_path: Path) -> TestClient:
 
 def test_config_enabled(client: TestClient, monkeypatch) -> None:
     monkeypatch.setenv("CODECITY_ALLOW_LOCAL_REPOS", "1")
-    assert client.get("/api/config").json() == {"allowLocalRepos": True}
+    assert client.get("/api/config").json() == {
+        "allowLocalRepos": True,
+        "maxBatchPaths": MAX_BATCH_PATHS,
+    }
 
 
 def test_config_disabled(client: TestClient, monkeypatch) -> None:
     monkeypatch.delenv("CODECITY_ALLOW_LOCAL_REPOS", raising=False)
-    assert client.get("/api/config").json() == {"allowLocalRepos": False}
+    assert client.get("/api/config").json() == {
+        "allowLocalRepos": False,
+        "maxBatchPaths": MAX_BATCH_PATHS,
+    }
+
+
+def test_config_publishes_the_cap_the_batch_routes_enforce() -> None:
+    """The batch routes truncate at MAX_BATCH_PATHS; /api/config is how the
+    client learns that number instead of hardcoding its own."""
+    from api.routers import file as file_router
+
+    assert file_router.MAX_BATCH_PATHS == MAX_BATCH_PATHS
diff --git a/api/tests/test_server_health.py b/api/tests/test_server_health.py
index 09daf0506..3534cf6e5 100644
--- a/api/tests/test_server_health.py
+++ b/api/tests/test_server_health.py
@@ -8,6 +8,7 @@
 from fastapi.testclient import TestClient
 
 from api.app import create_app
+from api.config import MAX_BATCH_PATHS
 
 
 @pytest.fixture()
@@ -40,7 +41,7 @@ def test_config_default_disabled(
     app = create_app(static_dir=static)
     r = TestClient(app).get("/api/config")
     assert r.status_code == 200
-    assert r.json() == {"allowLocalRepos": False}
+    assert r.json() == {"allowLocalRepos": False, "maxBatchPaths": MAX_BATCH_PATHS}
 
 
 def test_root_serves_index(client: TestClient) -> None:
diff --git a/app/.prettierignore b/app/.prettierignore
index 2f17f3385..2517415ab 100644
--- a/app/.prettierignore
+++ b/app/.prettierignore
@@ -3,6 +3,10 @@ node_modules
 package-lock.json
 coverage
 dist
+# Scanner fixtures: a nested git repo whose file contents, line counts and
+# mtimes the scan tests assert on. Formatting them rewrites those and fails
+# test_scan, while the outer `git status` stays clean because it is its own repo.
+../api/tests/fixtures
 # Auto-generated from the OpenAPI schema by `just gen-types` (openapi-typescript).
 # Edit api/models/*.py and regenerate; never hand-format this file.
 src/types/manifest.generated.ts
diff --git a/app/package-lock.json b/app/package-lock.json
index 303bb7f49..c8652e5fe 100644
--- a/app/package-lock.json
+++ b/app/package-lock.json
@@ -613,10 +613,33 @@
       "dev": true,
       "license": "Apache-2.0"
     },
+    "node_modules/@emnapi/core": {
+      "version": "1.11.1",
+      "resolved": "https://registry.npmjs.org/@emnapi/core/-/core-1.11.1.tgz",
+      "integrity": "sha512-RSvbQmHzdKzNsLYa/wHrbc3KN4sYLKAdPZxqiM2HATqv/SBk2/ENSHpvXGaLOMcsAyz0poEGqkmmKYG3OWiJEQ==",
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "dependencies": {
+        "@emnapi/wasi-threads": "1.2.2",
+        "tslib": "^2.4.0"
+      }
+    },
+    "node_modules/@emnapi/runtime": {
+      "version": "1.11.1",
+      "resolved": "https://registry.npmjs.org/@emnapi/runtime/-/runtime-1.11.1.tgz",
+      "integrity": "sha512-vgj7R3y3Wgx24IQaGPA/R6YFXLHVMOZ0uVEyIQPaWs+rd1AzfEMXlAC22FYwO1XkKR6NPsq7mUandH8oIRdZFw==",
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "dependencies": {
+        "tslib": "^2.4.0"
+      }
+    },
     "node_modules/@emnapi/wasi-threads": {
-      "version": "1.2.1",
-      "resolved": "https://registry.npmjs.org/@emnapi/wasi-threads/-/wasi-threads-1.2.1.tgz",
-      "integrity": "sha512-uTII7OYF+/Mes/MrcIOYp5yOtSMLBWSIoLPpcgwipoiKbli6k322tcoFsxoIIxPDqW01SQGAgko4EzZi2BNv2w==",
+      "version": "1.2.2",
+      "resolved": "https://registry.npmjs.org/@emnapi/wasi-threads/-/wasi-threads-1.2.2.tgz",
+      "integrity": "sha512-c95qOXkHdydNKhscBTebqEC1CVAZpyqOfVfBzQ1qgzyl3gfeldUjIggDbIZgDKsHLgnsM+igH7TJ/eAasaVuMA==",
       "dev": true,
       "license": "MIT",
       "optional": true,
@@ -887,14 +910,14 @@
       }
     },
     "node_modules/@napi-rs/wasm-runtime": {
-      "version": "1.1.4",
-      "resolved": "https://registry.npmjs.org/@napi-rs/wasm-runtime/-/wasm-runtime-1.1.4.tgz",
-      "integrity": "sha512-3NQNNgA1YSlJb/kMH1ildASP9HW7/7kYnRI2szWJaofaS1hWmbGI4H+d3+22aGzXXN9IJ+n+GiFVcGipJP18ow==",
+      "version": "1.1.6",
+      "resolved": "https://registry.npmjs.org/@napi-rs/wasm-runtime/-/wasm-runtime-1.1.6.tgz",
+      "integrity": "sha512-ZLv/JdUfkvOy9eCnnBaGfiO+XimbjebAeO+MRQqD/B+FR1tnRN0tpKSJHRbE8sFfS6aqsXZ67TQjfwfsxULVbg==",
       "dev": true,
       "license": "MIT",
       "optional": true,
       "dependencies": {
-        "@tybys/wasm-util": "^0.10.1"
+        "@tybys/wasm-util": "^0.10.3"
       },
       "funding": {
         "type": "github",
@@ -906,9 +929,9 @@
       }
     },
     "node_modules/@oxc-project/types": {
-      "version": "0.124.0",
-      "resolved": "https://registry.npmjs.org/@oxc-project/types/-/types-0.124.0.tgz",
-      "integrity": "sha512-VBFWMTBvHxS11Z5Lvlr3IWgrwhMTXV+Md+EQF0Xf60+wAdsGFTBx7X7K/hP4pi8N7dcm1RvcHwDxZ16Qx8keUg==",
+      "version": "0.139.0",
+      "resolved": "https://registry.npmjs.org/@oxc-project/types/-/types-0.139.0.tgz",
+      "integrity": "sha512-r9gHphtCs+1M7J0pw6Sn/hh/Wpa/iQrOOkrNAlVLF/gHq+/CJmHIWKKUUhdWjcD6CIa8idarspCsASiXCXvFUw==",
       "dev": true,
       "license": "MIT",
       "funding": {
@@ -1072,9 +1095,9 @@
       "license": "MIT"
     },
     "node_modules/@redocly/openapi-core": {
-      "version": "1.34.15",
-      "resolved": "https://registry.npmjs.org/@redocly/openapi-core/-/openapi-core-1.34.15.tgz",
-      "integrity": "sha512-HAwCnNyKcs5XGQqms+9t7OdAPM/5TDstmhF+0i7tdCFato2QKuYIlyWETwkXd8c5zbltr1oB+6y9NTeQLr2d6Q==",
+      "version": "1.34.17",
+      "resolved": "https://registry.npmjs.org/@redocly/openapi-core/-/openapi-core-1.34.17.tgz",
+      "integrity": "sha512-wsV2keCt6B806XpSdezbWZ9aFJYf14YVh+XQf0ESt7M90yqVuxH9//PxvtC70sgj9OCkRM3nRaLfu4MsGQZRig==",
       "dev": true,
       "license": "MIT",
       "dependencies": {
@@ -1083,7 +1106,7 @@
         "colorette": "1.4.0",
         "https-proxy-agent": "7.0.6",
         "js-levenshtein": "1.1.6",
-        "js-yaml": "4.1.1",
+        "js-yaml": "4.2.0",
         "minimatch": "5.1.9",
         "pluralize": "8.0.0",
         "yaml-ast-parser": "0.0.43"
@@ -1101,9 +1124,9 @@
       "license": "MIT"
     },
     "node_modules/@redocly/openapi-core/node_modules/brace-expansion": {
-      "version": "2.1.1",
-      "resolved": "https://registry.npmjs.org/brace-expansion/-/brace-expansion-2.1.1.tgz",
-      "integrity": "sha512-WR1cURNjuvBLMZBMbqM0UoE+WAfdUcEV1ccD8PVBVOI+Z3ND4+SZbN8RsfT2bMuG1qwz5RFvPukSZm5fF2D5eA==",
+      "version": "2.1.2",
+      "resolved": "https://registry.npmjs.org/brace-expansion/-/brace-expansion-2.1.2.tgz",
+      "integrity": "sha512-w5JZcKgdhDOgOwm8H+KgbosopHMuGcl6qbulwjtz3SM7I7P3yW1eAjzMPLrIE+NQ9vjgANKHWeMHnrT0OXW1oA==",
       "dev": true,
       "license": "MIT",
       "dependencies": {
@@ -1124,9 +1147,9 @@
       }
     },
     "node_modules/@rolldown/binding-android-arm64": {
-      "version": "1.0.0-rc.15",
-      "resolved": "https://registry.npmjs.org/@rolldown/binding-android-arm64/-/binding-android-arm64-1.0.0-rc.15.tgz",
-      "integrity": "sha512-YYe6aWruPZDtHNpwu7+qAHEMbQ/yRl6atqb/AhznLTnD3UY99Q1jE7ihLSahNWkF4EqRPVC4SiR4O0UkLK02tA==",
+      "version": "1.1.5",
+      "resolved": "https://registry.npmjs.org/@rolldown/binding-android-arm64/-/binding-android-arm64-1.1.5.tgz",
+      "integrity": "sha512-lZg8fqIv2v7FF237bwMgzGZEJvGL79/s5knJ/i6FmsGF4XXlzccZ4jb+TrFIxtSSxFtIpdsgrPZeMk1I9AFcyQ==",
       "cpu": [
         "arm64"
       ],
@@ -1141,9 +1164,9 @@
       }
     },
     "node_modules/@rolldown/binding-darwin-arm64": {
-      "version": "1.0.0-rc.15",
-      "resolved": "https://registry.npmjs.org/@rolldown/binding-darwin-arm64/-/binding-darwin-arm64-1.0.0-rc.15.tgz",
-      "integrity": "sha512-oArR/ig8wNTPYsXL+Mzhs0oxhxfuHRfG7Ikw7jXsw8mYOtk71W0OkF2VEVh699pdmzjPQsTjlD1JIOoHkLP1Fg==",
+      "version": "1.1.5",
+      "resolved": "https://registry.npmjs.org/@rolldown/binding-darwin-arm64/-/binding-darwin-arm64-1.1.5.tgz",
+      "integrity": "sha512-51Bnx9pNiMRKSUNtBfySkNJ9vMU9Hh3I1ozDd6gyPPYzaXCfnptUcEZxXGYFn+ul2dtcMUiqGR1Yai2K10uoTw==",
       "cpu": [
         "arm64"
       ],
@@ -1158,9 +1181,9 @@
       }
     },
     "node_modules/@rolldown/binding-darwin-x64": {
-      "version": "1.0.0-rc.15",
-      "resolved": "https://registry.npmjs.org/@rolldown/binding-darwin-x64/-/binding-darwin-x64-1.0.0-rc.15.tgz",
-      "integrity": "sha512-YzeVqOqjPYvUbJSWJ4EDL8ahbmsIXQpgL3JVipmN+MX0XnXMeWomLN3Fb+nwCmP/jfyqte5I3XRSm7OfQrbyxw==",
+      "version": "1.1.5",
+      "resolved": "https://registry.npmjs.org/@rolldown/binding-darwin-x64/-/binding-darwin-x64-1.1.5.tgz",
+      "integrity": "sha512-Tm+gbfC0aHu1tBA/JvKQh32S0K6YgCHkiAF4/W6xX0K0RmNuc94VeK419dJoE65R5aRxmo+noZQSWrAMF6yb6g==",
       "cpu": [
         "x64"
       ],
@@ -1175,9 +1198,9 @@
       }
     },
     "node_modules/@rolldown/binding-freebsd-x64": {
-      "version": "1.0.0-rc.15",
-      "resolved": "https://registry.npmjs.org/@rolldown/binding-freebsd-x64/-/binding-freebsd-x64-1.0.0-rc.15.tgz",
-      "integrity": "sha512-9Erhx956jeQ0nNTyif1+QWAXDRD38ZNjr//bSHrt6wDwB+QkAfl2q6Mn1k6OBPerznjRmbM10lgRb1Pli4xZPw==",
+      "version": "1.1.5",
+      "resolved": "https://registry.npmjs.org/@rolldown/binding-freebsd-x64/-/binding-freebsd-x64-1.1.5.tgz",
+      "integrity": "sha512-JMzDKCCXq93YccG5gz3hvOs1oXRKAf0XYpfOS88e+wZrC8Iugj6j68867vrYZkvpDDpKn/KoKORThmchMpF6TA==",
       "cpu": [
         "x64"
       ],
@@ -1192,9 +1215,9 @@
       }
     },
     "node_modules/@rolldown/binding-linux-arm-gnueabihf": {
-      "version": "1.0.0-rc.15",
-      "resolved": "https://registry.npmjs.org/@rolldown/binding-linux-arm-gnueabihf/-/binding-linux-arm-gnueabihf-1.0.0-rc.15.tgz",
-      "integrity": "sha512-cVwk0w8QbZJGTnP/AHQBs5yNwmpgGYStL88t4UIaqcvYJWBfS0s3oqVLZPwsPU6M0zlW4GqjP0Zq5MnAGwFeGA==",
+      "version": "1.1.5",
+      "resolved": "https://registry.npmjs.org/@rolldown/binding-linux-arm-gnueabihf/-/binding-linux-arm-gnueabihf-1.1.5.tgz",
+      "integrity": "sha512-uML21j2K5TfPGutKxub+M+nLjZIrWjXQ5Grx4lCe/nimTj9B4L63zHpjXLl4y0L3mcm2htEQIb06oCG/szerNw==",
       "cpu": [
         "arm"
       ],
@@ -1209,9 +1232,9 @@
       }
     },
     "node_modules/@rolldown/binding-linux-arm64-gnu": {
-      "version": "1.0.0-rc.15",
-      "resolved": "https://registry.npmjs.org/@rolldown/binding-linux-arm64-gnu/-/binding-linux-arm64-gnu-1.0.0-rc.15.tgz",
-      "integrity": "sha512-eBZ/u8iAK9SoHGanqe/jrPnY0JvBN6iXbVOsbO38mbz+ZJsaobExAm1Iu+rxa4S1l2FjG0qEZn4Rc6X8n+9M+w==",
+      "version": "1.1.5",
+      "resolved": "https://registry.npmjs.org/@rolldown/binding-linux-arm64-gnu/-/binding-linux-arm64-gnu-1.1.5.tgz",
+      "integrity": "sha512-navSiuTMogvnQoZoM/v+l3ZWo50/NTwSHSzheABx/RCnmUPaKwq9qSo4Br2OYRs21+Fz8uFqITZM3H4opOB0/Q==",
       "cpu": [
         "arm64"
       ],
@@ -1226,9 +1249,9 @@
       }
     },
     "node_modules/@rolldown/binding-linux-arm64-musl": {
-      "version": "1.0.0-rc.15",
-      "resolved": "https://registry.npmjs.org/@rolldown/binding-linux-arm64-musl/-/binding-linux-arm64-musl-1.0.0-rc.15.tgz",
-      "integrity": "sha512-ZvRYMGrAklV9PEkgt4LQM6MjQX2P58HPAuecwYObY2DhS2t35R0I810bKi0wmaYORt6m/2Sm+Z+nFgb0WhXNcQ==",
+      "version": "1.1.5",
+      "resolved": "https://registry.npmjs.org/@rolldown/binding-linux-arm64-musl/-/binding-linux-arm64-musl-1.1.5.tgz",
+      "integrity": "sha512-lAryqH7IteztmCXQXk0etKj4wBQ7Gx5S6LjKhsgp9zb8I5bsuvU/2llH1hDQcjsFeqIsovMVN339/8pUDDBXxA==",
       "cpu": [
         "arm64"
       ],
@@ -1243,9 +1266,9 @@
       }
     },
     "node_modules/@rolldown/binding-linux-ppc64-gnu": {
-      "version": "1.0.0-rc.15",
-      "resolved": "https://registry.npmjs.org/@rolldown/binding-linux-ppc64-gnu/-/binding-linux-ppc64-gnu-1.0.0-rc.15.tgz",
-      "integrity": "sha512-VDpgGBzgfg5hLg+uBpCLoFG5kVvEyafmfxGUV0UHLcL5irxAK7PKNeC2MwClgk6ZAiNhmo9FLhRYgvMmedLtnQ==",
+      "version": "1.1.5",
+      "resolved": "https://registry.npmjs.org/@rolldown/binding-linux-ppc64-gnu/-/binding-linux-ppc64-gnu-1.1.5.tgz",
+      "integrity": "sha512-fsK/sNBnxzBlL4O1JNrZakVQxPspqpED5dLtNsZS9oOKmtSpdNIzxH2kkol5HYTWJN47sE20ztMJPxfZ89qGOg==",
       "cpu": [
         "ppc64"
       ],
@@ -1260,9 +1283,9 @@
       }
     },
     "node_modules/@rolldown/binding-linux-s390x-gnu": {
-      "version": "1.0.0-rc.15",
-      "resolved": "https://registry.npmjs.org/@rolldown/binding-linux-s390x-gnu/-/binding-linux-s390x-gnu-1.0.0-rc.15.tgz",
-      "integrity": "sha512-y1uXY3qQWCzcPgRJATPSOUP4tCemh4uBdY7e3EZbVwCJTY3gLJWnQABgeUetvED+bt1FQ01OeZwvhLS2bpNrAQ==",
+      "version": "1.1.5",
+      "resolved": "https://registry.npmjs.org/@rolldown/binding-linux-s390x-gnu/-/binding-linux-s390x-gnu-1.1.5.tgz",
+      "integrity": "sha512-gLYb4BIadlfTOYT5gO503n8zQjXflgzpD0FcyKh0Mzx3rqCZKnHoJWV9xe1KXUJ5lx2JfcSHr/mhzS0PC/McAA==",
       "cpu": [
         "s390x"
       ],
@@ -1277,9 +1300,9 @@
       }
     },
     "node_modules/@rolldown/binding-linux-x64-gnu": {
-      "version": "1.0.0-rc.15",
-      "resolved": "https://registry.npmjs.org/@rolldown/binding-linux-x64-gnu/-/binding-linux-x64-gnu-1.0.0-rc.15.tgz",
-      "integrity": "sha512-023bTPBod7J3Y/4fzAN6QtpkSABR0rigtrwaP+qSEabUh5zf6ELr9Nc7GujaROuPY3uwdSIXWrvhn1KxOvurWA==",
+      "version": "1.1.5",
+      "resolved": "https://registry.npmjs.org/@rolldown/binding-linux-x64-gnu/-/binding-linux-x64-gnu-1.1.5.tgz",
+      "integrity": "sha512-FjcpEKUyJygHgs1o50VYNvkt5+7Le/VEdYt0AkRpkL33MnyQfwr8l5mXwMmfmTbyMPr5vJLC+8/Gd9gXnwU1QQ==",
       "cpu": [
         "x64"
       ],
@@ -1294,9 +1317,9 @@
       }
     },
     "node_modules/@rolldown/binding-linux-x64-musl": {
-      "version": "1.0.0-rc.15",
-      "resolved": "https://registry.npmjs.org/@rolldown/binding-linux-x64-musl/-/binding-linux-x64-musl-1.0.0-rc.15.tgz",
-      "integrity": "sha512-witB2O0/hU4CgfOOKUoeFgQ4GktPi1eEbAhaLAIpgD6+ZnhcPkUtPsoKKHRzmOoWPZue46IThdSgdo4XneOLYw==",
+      "version": "1.1.5",
+      "resolved": "https://registry.npmjs.org/@rolldown/binding-linux-x64-musl/-/binding-linux-x64-musl-1.1.5.tgz",
+      "integrity": "sha512-Me+PfPI2TMeOQk0gYWfLQZtTktrmzbr8cDboqX83XKc7UrgAi55gF+2dUkWdxd19n55Essp2yeca+O9N5rBxHg==",
       "cpu": [
         "x64"
       ],
@@ -1311,9 +1334,9 @@
       }
     },
     "node_modules/@rolldown/binding-openharmony-arm64": {
-      "version": "1.0.0-rc.15",
-      "resolved": "https://registry.npmjs.org/@rolldown/binding-openharmony-arm64/-/binding-openharmony-arm64-1.0.0-rc.15.tgz",
-      "integrity": "sha512-UCL68NJ0Ud5zRipXZE9dF5PmirzJE4E4BCIOOssEnM7wLDsxjc6Qb0sGDxTNRTP53I6MZpygyCpY8Aa8sPfKPg==",
+      "version": "1.1.5",
+      "resolved": "https://registry.npmjs.org/@rolldown/binding-openharmony-arm64/-/binding-openharmony-arm64-1.1.5.tgz",
+      "integrity": "sha512-yc5WrLzXks6zCQfn9Oxr8pORKyl/pF+QjHmW/Qx3qu0oyrrNC+y2JLTU1E2rcWYAmzlnqngWXHQjy51VzW70Vw==",
       "cpu": [
         "arm64"
       ],
@@ -1328,9 +1351,9 @@
       }
     },
     "node_modules/@rolldown/binding-wasm32-wasi": {
-      "version": "1.0.0-rc.15",
-      "resolved": "https://registry.npmjs.org/@rolldown/binding-wasm32-wasi/-/binding-wasm32-wasi-1.0.0-rc.15.tgz",
-      "integrity": "sha512-ApLruZq/ig+nhaE7OJm4lDjayUnOHVUa77zGeqnqZ9pn0ovdVbbNPerVibLXDmWeUZXjIYIT8V3xkT58Rm9u5Q==",
+      "version": "1.1.5",
+      "resolved": "https://registry.npmjs.org/@rolldown/binding-wasm32-wasi/-/binding-wasm32-wasi-1.1.5.tgz",
+      "integrity": "sha512-VbQGPX2b4r48TAMIM2cjgluIM1HYutm4pcTEJsle7iEP7sB1dFqtPLBVbdLAZCxy1txCcPxf4QFf4v8uvltPqA==",
       "cpu": [
         "wasm32"
       ],
@@ -1338,41 +1361,18 @@
       "license": "MIT",
       "optional": true,
       "dependencies": {
-        "@emnapi/core": "1.9.2",
-        "@emnapi/runtime": "1.9.2",
-        "@napi-rs/wasm-runtime": "^1.1.3"
+        "@emnapi/core": "1.11.1",
+        "@emnapi/runtime": "1.11.1",
+        "@napi-rs/wasm-runtime": "^1.1.6"
       },
       "engines": {
-        "node": ">=14.0.0"
-      }
-    },
-    "node_modules/@rolldown/binding-wasm32-wasi/node_modules/@emnapi/core": {
-      "version": "1.9.2",
-      "resolved": "https://registry.npmjs.org/@emnapi/core/-/core-1.9.2.tgz",
-      "integrity": "sha512-UC+ZhH3XtczQYfOlu3lNEkdW/p4dsJ1r/bP7H8+rhao3TTTMO1ATq/4DdIi23XuGoFY+Cz0JmCbdVl0hz9jZcA==",
-      "dev": true,
-      "license": "MIT",
-      "optional": true,
-      "dependencies": {
-        "@emnapi/wasi-threads": "1.2.1",
-        "tslib": "^2.4.0"
-      }
-    },
-    "node_modules/@rolldown/binding-wasm32-wasi/node_modules/@emnapi/runtime": {
-      "version": "1.9.2",
-      "resolved": "https://registry.npmjs.org/@emnapi/runtime/-/runtime-1.9.2.tgz",
-      "integrity": "sha512-3U4+MIWHImeyu1wnmVygh5WlgfYDtyf0k8AbLhMFxOipihf6nrWC4syIm/SwEeec0mNSafiiNnMJwbza/Is6Lw==",
-      "dev": true,
-      "license": "MIT",
-      "optional": true,
-      "dependencies": {
-        "tslib": "^2.4.0"
+        "node": "^20.19.0 || >=22.12.0"
       }
     },
     "node_modules/@rolldown/binding-win32-arm64-msvc": {
-      "version": "1.0.0-rc.15",
-      "resolved": "https://registry.npmjs.org/@rolldown/binding-win32-arm64-msvc/-/binding-win32-arm64-msvc-1.0.0-rc.15.tgz",
-      "integrity": "sha512-KmoUoU7HnN+Si5YWJigfTws1jz1bKBYDQKdbLspz0UaqjjFkddHsqorgiW1mxcAj88lYUE6NC/zJNwT+SloqtA==",
+      "version": "1.1.5",
+      "resolved": "https://registry.npmjs.org/@rolldown/binding-win32-arm64-msvc/-/binding-win32-arm64-msvc-1.1.5.tgz",
+      "integrity": "sha512-gHv82k63z4qpV5+Q1y/12KrK0ltWBukVDI8nZcbT7Tt/ZlOIVwppazneq0F93oDxTo3IgAMEDIoQh3E2n6mVsw==",
       "cpu": [
         "arm64"
       ],
@@ -1387,9 +1387,9 @@
       }
     },
     "node_modules/@rolldown/binding-win32-x64-msvc": {
-      "version": "1.0.0-rc.15",
-      "resolved": "https://registry.npmjs.org/@rolldown/binding-win32-x64-msvc/-/binding-win32-x64-msvc-1.0.0-rc.15.tgz",
-      "integrity": "sha512-3P2A8L+x75qavWLe/Dll3EYBJLQmtkJN8rfh+U/eR3MqMgL/h98PhYI+JFfXuDPgPeCB7iZAKiqii5vqOvnA0g==",
+      "version": "1.1.5",
+      "resolved": "https://registry.npmjs.org/@rolldown/binding-win32-x64-msvc/-/binding-win32-x64-msvc-1.1.5.tgz",
+      "integrity": "sha512-tTZuDBPw85tEN5PQi1pnEBzDy0Z49HtScLAbD5t6hyeU92A95pRWaSMw1GZZi/RwgSgUIl0xrSlXIT/9QzvYSA==",
       "cpu": [
         "x64"
       ],
@@ -1404,9 +1404,9 @@
       }
     },
     "node_modules/@rolldown/pluginutils": {
-      "version": "1.0.0-rc.15",
-      "resolved": "https://registry.npmjs.org/@rolldown/pluginutils/-/pluginutils-1.0.0-rc.15.tgz",
-      "integrity": "sha512-UromN0peaE53IaBRe9W7CjrZgXl90fqGpK+mIZbA3qSTeYqg3pqpROBdIPvOG3F5ereDHNwoHBI2e50n1BDr1g==",
+      "version": "1.0.1",
+      "resolved": "https://registry.npmjs.org/@rolldown/pluginutils/-/pluginutils-1.0.1.tgz",
+      "integrity": "sha512-2j9bGt5Jh8hj+vPtgzPtl72j0yRxHAyumoo6TNfAjsLB04UtpSvPbPcDcBMxz7n+9CYB0c1GxQFxYRg2jimqGw==",
       "dev": true,
       "license": "MIT"
     },
@@ -1455,9 +1455,9 @@
       "license": "MIT"
     },
     "node_modules/@tybys/wasm-util": {
-      "version": "0.10.1",
-      "resolved": "https://registry.npmjs.org/@tybys/wasm-util/-/wasm-util-0.10.1.tgz",
-      "integrity": "sha512-9tTaPJLSiejZKx+Bmog4uSubteqTvFrVrURwkmHixBo0G4seD0zUxp98E1DzUBJxLQ3NPwXrGKDiVjwx/DpPsg==",
+      "version": "0.10.3",
+      "resolved": "https://registry.npmjs.org/@tybys/wasm-util/-/wasm-util-0.10.3.tgz",
+      "integrity": "sha512-F3fo1MYrRJYL3zER0OUOmkutjr1Vp23m7OsSgp7nq4SP6OqX6C/56XFIPAl5bt3zaBRjmW7SGz3u/6LwFpYcOg==",
       "dev": true,
       "license": "MIT",
       "optional": true,
@@ -2100,16 +2100,16 @@
       "license": "ISC"
     },
     "node_modules/brace-expansion": {
-      "version": "5.0.5",
-      "resolved": "https://registry.npmjs.org/brace-expansion/-/brace-expansion-5.0.5.tgz",
-      "integrity": "sha512-VZznLgtwhn+Mact9tfiwx64fA9erHH/MCXEUfB/0bX/6Fz6ny5EGTXYltMocqg4xFAQZtnO3DHWWXi8RiuN7cQ==",
+      "version": "5.0.8",
+      "resolved": "https://registry.npmjs.org/brace-expansion/-/brace-expansion-5.0.8.tgz",
+      "integrity": "sha512-JZyDyq3D4AUifKTPOB7DELf6XsB3WdPuNxCtob1vFXPsSXhdAiHBWJ/tJ8HAc9aH84BK+5JFZLNkJKx3G9kzQg==",
       "dev": true,
       "license": "MIT",
       "dependencies": {
         "balanced-match": "^4.0.2"
       },
       "engines": {
-        "node": "18 || 20 || >=22"
+        "node": "20 || >=22"
       }
     },
     "node_modules/browserslist": {
@@ -3148,10 +3148,20 @@
       "license": "MIT"
     },
     "node_modules/js-yaml": {
-      "version": "4.1.1",
-      "resolved": "https://registry.npmjs.org/js-yaml/-/js-yaml-4.1.1.tgz",
-      "integrity": "sha512-qQKT4zQxXl8lLwBtHMWwaTcGfFOZviOJet3Oy/xmGk2gZH677CJM9EvtfdSkgWcATZhj/55JZ0rmy3myCT5lsA==",
+      "version": "4.2.0",
+      "resolved": "https://registry.npmjs.org/js-yaml/-/js-yaml-4.2.0.tgz",
+      "integrity": "sha512-ePWsvanv0DWuDRsW8dnt+R4jQ31SCRCQ7hhNcPXZPsoBZiemuZNYGf7adZdqX2D86j6rvKp3RpCxVTSb8WQlOw==",
       "dev": true,
+      "funding": [
+        {
+          "type": "github",
+          "url": "https://github.com/sponsors/puzrin"
+        },
+        {
+          "type": "github",
+          "url": "https://github.com/sponsors/nodeca"
+        }
+      ],
       "license": "MIT",
       "dependencies": {
         "argparse": "^2.0.1"
@@ -3725,9 +3735,9 @@
       "license": "MIT"
     },
     "node_modules/nanoid": {
-      "version": "3.3.11",
-      "resolved": "https://registry.npmjs.org/nanoid/-/nanoid-3.3.11.tgz",
-      "integrity": "sha512-N8SpfPUnUp1bK+PMYW8qSWdl9U+wwNWI4QKxOYDy9JAro3WMX7p2OeVRF9v+347pnakNevPmiHhNmZ2HbFA76w==",
+      "version": "3.3.16",
+      "resolved": "https://registry.npmjs.org/nanoid/-/nanoid-3.3.16.tgz",
+      "integrity": "sha512-bzlKTyNJ7+LdGIIwy8ijFpIqEQIvafahV7eYykJ8Cvh42EdJeODoJ6gUJXpQJvej1BddH8OqTXZNE/KfbWAu8Q==",
       "dev": true,
       "funding": [
         {
@@ -3982,9 +3992,9 @@
       "license": "ISC"
     },
     "node_modules/picomatch": {
-      "version": "4.0.4",
-      "resolved": "https://registry.npmjs.org/picomatch/-/picomatch-4.0.4.tgz",
-      "integrity": "sha512-QP88BAKvMam/3NxH6vj2o21R6MjxZUAd6nlwAS/pnGvN9IVLocLHxGYIzFhg6fUQ+5th6P4dv4eW9jX3DSIj7A==",
+      "version": "4.0.5",
+      "resolved": "https://registry.npmjs.org/picomatch/-/picomatch-4.0.5.tgz",
+      "integrity": "sha512-RvwwcruNjI1ncT5xRakeyS9Lf8lcItv34KD+aif+VH9kduAyfYBipGh12274xtenIPZ119/R9BdTBa8gAwSh0A==",
       "dev": true,
       "license": "MIT",
       "engines": {
@@ -4052,9 +4062,9 @@
       }
     },
     "node_modules/postcss": {
-      "version": "8.5.10",
-      "resolved": "https://registry.npmjs.org/postcss/-/postcss-8.5.10.tgz",
-      "integrity": "sha512-pMMHxBOZKFU6HgAZ4eyGnwXF/EvPGGqUr0MnZ5+99485wwW41kW91A4LOGxSHhgugZmSChL5AlElNdwlNgcnLQ==",
+      "version": "8.5.23",
+      "resolved": "https://registry.npmjs.org/postcss/-/postcss-8.5.23.tgz",
+      "integrity": "sha512-g50586zr4bZmwFiTlflMu8E0bDTb5I5gertgwAKmsdUlTQIhZtunzUlD1WSzwcVWPoAVpsrA6vlfCD7oXvRwgg==",
       "dev": true,
       "funding": [
         {
@@ -4072,7 +4082,7 @@
       ],
       "license": "MIT",
       "dependencies": {
-        "nanoid": "^3.3.11",
+        "nanoid": "^3.3.16",
         "picocolors": "^1.1.1",
         "source-map-js": "^1.2.1"
       },
@@ -4262,14 +4272,14 @@
       }
     },
     "node_modules/rolldown": {
-      "version": "1.0.0-rc.15",
-      "resolved": "https://registry.npmjs.org/rolldown/-/rolldown-1.0.0-rc.15.tgz",
-      "integrity": "sha512-Ff31guA5zT6WjnGp0SXw76X6hzGRk/OQq2hE+1lcDe+lJdHSgnSX6nK3erbONHyCbpSj9a9E+uX/OvytZoWp2g==",
+      "version": "1.1.5",
+      "resolved": "https://registry.npmjs.org/rolldown/-/rolldown-1.1.5.tgz",
+      "integrity": "sha512-t9z29cJjXf/vxQ8dyhCSpt6H6aSwHTk8cT5I3iy6SMXuFpk5mB6PL6XfC8PCwrPTx93udwKUm9HRteAlTGBLiA==",
       "dev": true,
       "license": "MIT",
       "dependencies": {
-        "@oxc-project/types": "=0.124.0",
-        "@rolldown/pluginutils": "1.0.0-rc.15"
+        "@oxc-project/types": "=0.139.0",
+        "@rolldown/pluginutils": "^1.0.0"
       },
       "bin": {
         "rolldown": "bin/cli.mjs"
@@ -4278,21 +4288,21 @@
         "node": "^20.19.0 || >=22.12.0"
       },
       "optionalDependencies": {
-        "@rolldown/binding-android-arm64": "1.0.0-rc.15",
-        "@rolldown/binding-darwin-arm64": "1.0.0-rc.15",
-        "@rolldown/binding-darwin-x64": "1.0.0-rc.15",
-        "@rolldown/binding-freebsd-x64": "1.0.0-rc.15",
-        "@rolldown/binding-linux-arm-gnueabihf": "1.0.0-rc.15",
-        "@rolldown/binding-linux-arm64-gnu": "1.0.0-rc.15",
-        "@rolldown/binding-linux-arm64-musl": "1.0.0-rc.15",
-        "@rolldown/binding-linux-ppc64-gnu": "1.0.0-rc.15",
-        "@rolldown/binding-linux-s390x-gnu": "1.0.0-rc.15",
-        "@rolldown/binding-linux-x64-gnu": "1.0.0-rc.15",
-        "@rolldown/binding-linux-x64-musl": "1.0.0-rc.15",
-        "@rolldown/binding-openharmony-arm64": "1.0.0-rc.15",
-        "@rolldown/binding-wasm32-wasi": "1.0.0-rc.15",
-        "@rolldown/binding-win32-arm64-msvc": "1.0.0-rc.15",
-        "@rolldown/binding-win32-x64-msvc": "1.0.0-rc.15"
+        "@rolldown/binding-android-arm64": "1.1.5",
+        "@rolldown/binding-darwin-arm64": "1.1.5",
+        "@rolldown/binding-darwin-x64": "1.1.5",
+        "@rolldown/binding-freebsd-x64": "1.1.5",
+        "@rolldown/binding-linux-arm-gnueabihf": "1.1.5",
+        "@rolldown/binding-linux-arm64-gnu": "1.1.5",
+        "@rolldown/binding-linux-arm64-musl": "1.1.5",
+        "@rolldown/binding-linux-ppc64-gnu": "1.1.5",
+        "@rolldown/binding-linux-s390x-gnu": "1.1.5",
+        "@rolldown/binding-linux-x64-gnu": "1.1.5",
+        "@rolldown/binding-linux-x64-musl": "1.1.5",
+        "@rolldown/binding-openharmony-arm64": "1.1.5",
+        "@rolldown/binding-wasm32-wasi": "1.1.5",
+        "@rolldown/binding-win32-arm64-msvc": "1.1.5",
+        "@rolldown/binding-win32-x64-msvc": "1.1.5"
       }
     },
     "node_modules/safe-buffer": {
@@ -4557,9 +4567,9 @@
       }
     },
     "node_modules/tinyglobby": {
-      "version": "0.2.16",
-      "resolved": "https://registry.npmjs.org/tinyglobby/-/tinyglobby-0.2.16.tgz",
-      "integrity": "sha512-pn99VhoACYR8nFHhxqix+uvsbXineAasWm5ojXoN8xEwK5Kd3/TrhNn1wByuD52UxWRLy8pu+kRMniEi6Eq9Zg==",
+      "version": "0.2.17",
+      "resolved": "https://registry.npmjs.org/tinyglobby/-/tinyglobby-0.2.17.tgz",
+      "integrity": "sha512-wXR/dYpcqKmfWpEdZjiKJOwCNFndD0DMnrW/cYjVGttEkBfVgcLFHoNrlj47mjOVic9yyNu65alsgF4NQyTa2g==",
       "dev": true,
       "license": "MIT",
       "dependencies": {
@@ -4728,9 +4738,9 @@
       }
     },
     "node_modules/undici": {
-      "version": "7.25.0",
-      "resolved": "https://registry.npmjs.org/undici/-/undici-7.25.0.tgz",
-      "integrity": "sha512-xXnp4kTyor2Zq+J1FfPI6Eq3ew5h6Vl0F/8d9XU5zZQf1tX9s2Su1/3PiMmUANFULpmksxkClamIZcaUqryHsQ==",
+      "version": "7.29.0",
+      "resolved": "https://registry.npmjs.org/undici/-/undici-7.29.0.tgz",
+      "integrity": "sha512-IDxfleLmmbSskfWSUATiN1nfn2rDuvnMOqb5CWR92iIfojA0Ud+ulOAAEQ57LPr9rWmsreUyf5lwyao+7GNNVw==",
       "dev": true,
       "license": "MIT",
       "engines": {
@@ -4800,17 +4810,17 @@
       "license": "MIT"
     },
     "node_modules/vite": {
-      "version": "8.0.8",
-      "resolved": "https://registry.npmjs.org/vite/-/vite-8.0.8.tgz",
-      "integrity": "sha512-dbU7/iLVa8KZALJyLOBOQ88nOXtNG8vxKuOT4I2mD+Ya70KPceF4IAmDsmU0h1Qsn5bPrvsY9HJstCRh3hG6Uw==",
+      "version": "8.1.5",
+      "resolved": "https://registry.npmjs.org/vite/-/vite-8.1.5.tgz",
+      "integrity": "sha512-7ULLwsCdYx/nRyrpiEwvqb5TFHrMVZyBt+rg/OAXT7rgj/z+DtTDyKFeLAdDkubDVDKD8jOsndmy7m55XcfUsw==",
       "dev": true,
       "license": "MIT",
       "dependencies": {
         "lightningcss": "^1.32.0",
-        "picomatch": "^4.0.4",
-        "postcss": "^8.5.8",
-        "rolldown": "1.0.0-rc.15",
-        "tinyglobby": "^0.2.15"
+        "picomatch": "^4.0.5",
+        "postcss": "^8.5.17",
+        "rolldown": "~1.1.5",
+        "tinyglobby": "^0.2.17"
       },
       "bin": {
         "vite": "bin/vite.js"
@@ -4826,7 +4836,7 @@
       },
       "peerDependencies": {
         "@types/node": "^20.19.0 || >=22.12.0",
-        "@vitejs/devtools": "^0.1.0",
+        "@vitejs/devtools": "^0.3.0",
         "esbuild": "^0.27.0 || ^0.28.0",
         "jiti": ">=1.21.0",
         "less": "^4.0.0",
diff --git a/app/src/api/config.ts b/app/src/api/config.ts
index f3a8216bf..1510b65a3 100644
--- a/app/src/api/config.ts
+++ b/app/src/api/config.ts
@@ -7,23 +7,50 @@
 // path input that the server will reject anyway.
 
 import { apiUrl } from '@/api/apiUrl';
+import type { components } from '@/types/manifest.generated';
 
-export interface ServerConfig {
-  allowLocalRepos: boolean;
-}
+// Derived from the OpenAPI schema rather than re-declared, so a field added to
+// the backend's ConfigResponse cannot drift from what this layer exposes.
+export type ServerConfig = components['schemas']['ConfigResponse'];
 
-const DISABLED: ServerConfig = { allowLocalRepos: false };
+// Pre-boot defaults, replaced by the real /api/config response. maxBatchPaths
+// starts low because guessing high fails silently: the batch routes truncate
+// anything past their cap, so an over-large chunk loses its tail. Guessing low
+// only costs an extra request.
+export const DEFAULT_SERVER_CONFIG: ServerConfig = {
+  allowLocalRepos: false,
+  maxBatchPaths: 16,
+};
 
 let _cached: Promise<ServerConfig> | null = null;
+// The resolved value, for callers that need it synchronously mid-request (the
+// batch coalescers). Not a second source of truth: it is written only from the
+// memoized fetch below, which is the same one the SERVER_CONFIG signal mirrors.
+let _resolved: ServerConfig = DEFAULT_SERVER_CONFIG;
+
+/** The server config as last resolved, or the defaults before boot completes. */
+export function serverConfigNow(): ServerConfig {
+  return _resolved;
+}
 
 export async function fetchServerConfig(): Promise<ServerConfig> {
   try {
     const resp = await fetch(apiUrl('config'));
-    if (!resp.ok) return DISABLED;
+    if (!resp.ok) return DEFAULT_SERVER_CONFIG;
     const body = (await resp.json()) as Partial<ServerConfig>;
-    return { allowLocalRepos: !!body.allowLocalRepos };
+    // Spread over the defaults rather than re-projecting field by field: the
+    // old shape listed each key by hand, so a field added on the server was
+    // silently dropped here. Only override what the body actually carries, so
+    // a truncated response can't yield a zero batch size.
+    return {
+      ...DEFAULT_SERVER_CONFIG,
+      allowLocalRepos: !!body.allowLocalRepos,
+      ...(typeof body.maxBatchPaths === 'number' && body.maxBatchPaths > 0
+        ? { maxBatchPaths: body.maxBatchPaths }
+        : {}),
+    };
   } catch (_) {
-    return DISABLED;
+    return DEFAULT_SERVER_CONFIG;
   }
 }
 
@@ -34,7 +61,12 @@ export async function fetchServerConfig(): Promise<ServerConfig> {
  * tests that want a fresh roundtrip.
  */
 export function getServerConfig(): Promise<ServerConfig> {
-  if (_cached === null) _cached = fetchServerConfig();
+  if (_cached === null) {
+    _cached = fetchServerConfig().then((cfg) => {
+      _resolved = cfg;
+      return cfg;
+    });
+  }
   return _cached;
 }
 
@@ -42,4 +74,5 @@ export function getServerConfig(): Promise<ServerConfig> {
  *  return different responses without leaking state. */
 export function _resetServerConfigForTests(): void {
   _cached = null;
+  _resolved = DEFAULT_SERVER_CONFIG;
 }
diff --git a/app/src/api/fingerprint.ts b/app/src/api/fingerprint.ts
index c9a981e58..53e12bd91 100644
--- a/app/src/api/fingerprint.ts
+++ b/app/src/api/fingerprint.ts
@@ -1,62 +1,22 @@
-// api/fingerprint.ts — coalesces binary-file fingerprint fetches into POST
-// /api/fingerprints batches (mirrors mediaBatch). The server returns a small
-// base64 byte-pattern PNG per path; callers feed it to an <img> via a data URL.
-// A path the endpoint omits resolves to null. Shared by the city's data-building
-// facade loader and the preview pane's data card.
+// api/fingerprint.ts — binary-file fingerprints via POST /api/fingerprints.
+// The server returns a small base64 byte-pattern PNG per path; callers feed it
+// to an <img> via a data URL. A path the endpoint omits resolves to null.
+// Shared by the city's data-building facade loader and the preview pane's data
+// card. Coalescing lives in createPathBatcher, shared with mediaBatch.
 
-/** Max paths per request — mirrors the server-side cap. */
-const BATCH_SIZE = 32;
-/** Coalescing window: data buildings register in a burst at scene build. */
-const FLUSH_MS = 16;
+import { createPathBatcher } from '@/api/pathBatcher';
 
-interface BatchEntry {
+interface FingerprintEntry {
   b64: string;
 }
 
-type Waiter = (b64: string | null) => void;
-
-const _queue = new Map<string, Waiter[]>();
-let _timer: ReturnType<typeof setTimeout> | null = null;
+const batcher = createPathBatcher<string, FingerprintEntry>({
+  endpoint: '/api/fingerprints',
+  decode: (entry) => entry.b64,
+});
 
 /** Request a binary file's fingerprint PNG (base64) via the batch endpoint.
  *  Resolves with the base64 string, or null when the server omitted it. */
 export function fetchFingerprintB64(path: string): Promise<string | null> {
-  return new Promise((resolve) => {
-    const waiters = _queue.get(path);
-    if (waiters) {
-      waiters.push(resolve);
-    } else {
-      _queue.set(path, [resolve]);
-    }
-    if (_timer === null) _timer = setTimeout(_flush, FLUSH_MS);
-  });
-}
-
-function _flush(): void {
-  _timer = null;
-  // Snapshot + clear so requests arriving during the awaits start a fresh batch.
-  const pending = new Map(_queue);
-  _queue.clear();
-  const paths = [...pending.keys()];
-  for (let i = 0; i < paths.length; i += BATCH_SIZE) {
-    void _sendBatch(paths.slice(i, i + BATCH_SIZE), pending);
-  }
-}
-
-async function _sendBatch(paths: string[], pending: Map<string, Waiter[]>): Promise<void> {
-  let result: Record<string, BatchEntry> = {};
-  try {
-    const res = await fetch('/api/fingerprints', {
-      method: 'POST',
-      headers: { 'content-type': 'application/json' },
-      body: JSON.stringify({ paths }),
-    });
-    if (res.ok) result = (await res.json()) as Record<string, BatchEntry>;
-  } catch {
-    // Network failure → every path resolves null; callers keep their placeholder.
-  }
-  for (const path of paths) {
-    const entry = result[path];
-    for (const resolve of pending.get(path) ?? []) resolve(entry ? entry.b64 : null);
-  }
+  return batcher.request(path);
 }
diff --git a/app/src/api/manifest.ts b/app/src/api/manifest.ts
index f624d7b3b..e202fd76d 100644
--- a/app/src/api/manifest.ts
+++ b/app/src/api/manifest.ts
@@ -220,12 +220,3 @@ export function streamManifest(
     },
   };
 }
-
-/**
- * Clear the server-side scan cache for one (src, branch) pair. Best-effort —
- * failures are swallowed (cache-clear is a UX nicety, not a correctness path).
- */
-export function clearManifestCache(src: string, branch?: string): void {
-  const url = apiUrl('manifest/cache', { [URL_PARAMS.SRC]: src, [URL_PARAMS.BRANCH]: branch });
-  fetch(url, { method: 'DELETE' }).catch(() => {});
-}
diff --git a/app/src/api/pathBatcher.ts b/app/src/api/pathBatcher.ts
new file mode 100644
index 000000000..73d8c30be
--- /dev/null
+++ b/app/src/api/pathBatcher.ts
@@ -0,0 +1,84 @@
+// api/pathBatcher.ts — coalesces per-path requests into POST batches.
+//
+// Both media images and binary fingerprints hit the same wall: the scene asks
+// for one asset per building, and firing a separate GET each exhausts the
+// browser's HTTP/1.1 connection pool on asset-heavy repos (Infisical: 2.6k
+// images). Each collects the paths requested inside a short window and sends
+// them as a handful of batched POSTs instead of thousands of singletons.
+//
+// The two differ only in endpoint, request body and how a response entry
+// decodes, so that is all a caller supplies.
+
+import { serverConfigNow } from '@/api/config';
+
+/** One request's resolver. `null` means the server omitted that path. */
+type Waiter<T> = (value: T | null) => void;
+
+export interface PathBatcherOptions<T, E> {
+  /** POST target, e.g. `/api/images`. */
+  endpoint: string;
+  /** Turn one response entry into the caller's value; return null to omit. */
+  decode: (entry: E) => T | null;
+  /** Extra fields merged into the POST body alongside `paths`. */
+  bodyFor?: (paths: string[]) => Record<string, unknown>;
+  /** Runs once per path after its batch settles, before waiters resolve. */
+  onSettled?: (path: string) => void;
+  /** Coalescing window. One frame gathers essentially a whole scene build. */
+  flushMs?: number;
+}
+
+export interface PathBatcher<T> {
+  request(path: string): Promise<T | null>;
+}
+
+export function createPathBatcher<T, E>(opts: PathBatcherOptions<T, E>): PathBatcher<T> {
+  const { endpoint, decode, bodyFor, onSettled, flushMs = 16 } = opts;
+  const queue = new Map<string, Waiter<T>[]>();
+  let timer: ReturnType<typeof setTimeout> | null = null;
+
+  async function sendBatch(paths: string[], pending: Map<string, Waiter<T>[]>): Promise<void> {
+    let result: Record<string, E> = {};
+    try {
+      const res = await fetch(endpoint, {
+        method: 'POST',
+        headers: { 'content-type': 'application/json' },
+        body: JSON.stringify({ paths, ...(bodyFor?.(paths) ?? {}) }),
+      });
+      if (res.ok) result = (await res.json()) as Record<string, E>;
+    } catch {
+      // Network failure: every path in this batch resolves null, and callers
+      // fall back to whatever single-path route they have.
+    }
+    for (const path of paths) {
+      const entry = result[path];
+      const value = entry === undefined ? null : decode(entry);
+      onSettled?.(path);
+      for (const resolve of pending.get(path) ?? []) resolve(value);
+    }
+  }
+
+  function flush(): void {
+    timer = null;
+    // Snapshot + clear so requests arriving during the awaits start a fresh batch.
+    const pending = new Map(queue);
+    queue.clear();
+    const paths = [...pending.keys()];
+    // The server truncates past its cap, so chunk to the number it published
+    // rather than a local guess that could silently drop the tail.
+    const batchSize = serverConfigNow().maxBatchPaths;
+    for (let i = 0; i < paths.length; i += batchSize) {
+      void sendBatch(paths.slice(i, i + batchSize), pending);
+    }
+  }
+
+  return {
+    request(path: string): Promise<T | null> {
+      return new Promise((resolve) => {
+        const waiters = queue.get(path);
+        if (waiters) waiters.push(resolve);
+        else queue.set(path, [resolve]);
+        if (timer === null) timer = setTimeout(flush, flushMs);
+      });
+    },
+  };
+}
diff --git a/app/src/city/capture/shots.ts b/app/src/city/capture/shots.ts
index 39c631f9d..dd3d1694d 100644
--- a/app/src/city/capture/shots.ts
+++ b/app/src/city/capture/shots.ts
@@ -12,7 +12,7 @@
 import type { SceneHandle } from '@/state/stores/scene';
 import { NodeKind, type Manifest, type DirNode } from '@/types';
 import { CAMERA } from '@/state/stores/settings/camera';
-import { TIMELINE_MODE, SCRUB_POS, TIMELINE_BUNDLE } from '@/state/stores/timeline';
+import { TIMELINE_MODE, SCRUB_MAX, TIMELINE_BUNDLE, setScrubPos } from '@/state/stores/timeline';
 import { loadTimelineScene } from '@/hooks/useTimelineMode';
 
 /** Set the default-view angle (degrees); the rig re-frames the whole city to
@@ -41,10 +41,10 @@ export type ShotPose = (
  *  treeAnchor(sha) is null for commits the layout didn't place a tree for, so a
  *  specific stat sha (e.g. the busiest commit) often misses. Walk commits
  *  most-authors-first so the tree we land on also has the most firefly orbs. */
-function placedTree(h: SceneHandle, m: Manifest) {
-  const byAuthors = [...m.commits].sort((a, b) => b.authors.length - a.authors.length);
+function placedTree(handle: SceneHandle, manifest: Manifest) {
+  const byAuthors = [...manifest.commits].sort((x, y) => y.authors.length - x.authors.length);
   for (const c of byAuthors) {
-    const tree = h.rig.treeAnchor(c.sha);
+    const tree = handle.rig.treeAnchor(c.sha);
     if (tree) return tree;
   }
   return null;
@@ -84,33 +84,33 @@ let _timelineKickedOff = false;
 export const SHOTS: Record<string, ShotPose> = {
   // Low side-on skyline. Aim just above the gem (toward the floating repo
   // label) and pull in close so the label reads and stays framed.
-  banner: (h, _m, o) => {
-    const a = h.rig.captureAnchors();
-    const base = a.gem ?? a.center;
+  banner: (handle, _m, o) => {
+    const anchors = handle.rig.captureAnchors();
+    const base = anchors.gem ?? anchors.center;
     if (!base) {
-      h.rig.reset();
+      handle.rig.reset();
       return;
     }
     const target = base.clone();
-    target.y += a.cityRadius * 0.12; // lift toward the label so it stays in frame
-    h.rig.captureView({
+    target.y += anchors.cityRadius * 0.12; // lift toward the label so it stays in frame
+    handle.rig.captureView({
       target,
-      distance: o.dist ?? a.cityRadius * 0.55,
+      distance: o.dist ?? anchors.cityRadius * 0.55,
       elevation: o.elev ?? 9,
       azimuth: o.az ?? 12,
     });
   },
   // Whole-city framing: the rig fits the entire city to the chosen angle.
-  overview: (h, _m, o) => {
+  overview: (handle, _m, o) => {
     angle(o.elev ?? 46, o.az ?? 34);
-    h.rig.reset();
+    handle.rig.reset();
   },
 
   // The whole city part-built at an older commit: enter Timeline mode, scrub to
   // mid-history, and frame the union city. No settings overrides — the shot
   // reflects the defaults (deleted stubs on, future files off). loadTimelineScene
   // is async, so return false until the mode + bundle are live — the harness retries.
-  timeline: (h, _m, o) => {
+  timeline: (handle, _m, o) => {
     if (!TIMELINE_MODE.peek()) {
       if (!_timelineKickedOff) {
         _timelineKickedOff = true;
@@ -120,59 +120,59 @@ export const SHOTS: Record<string, ShotPose> = {
     }
     const bundle = TIMELINE_BUNDLE.peek();
     if (!bundle || bundle.commits.length === 0) return false;
-    SCRUB_POS.value = Math.floor((bundle.commits.length - 1) * 0.5);
+    setScrubPos(Math.floor(SCRUB_MAX.peek() * 0.5));
     angle(o.elev ?? 44, o.az ?? 32);
-    h.rig.reset();
+    handle.rig.reset();
   },
 
   // Close-up on the street whose buildings span the most file types (hue =
   // extension), for the widest spread of colors. The gem may be in view.
-  buildings: (h, m, o) => {
-    const a = h.rig.captureAnchors();
-    const path = mostColorfulDirPath(m.tree);
-    const street = path ? h.rig.streetAnchor(path) : null;
-    const target = street?.pos ?? a.tallestBuilding ?? a.center;
+  buildings: (handle, manifest, o) => {
+    const anchors = handle.rig.captureAnchors();
+    const path = mostColorfulDirPath(manifest.tree);
+    const street = path ? handle.rig.streetAnchor(path) : null;
+    const target = street?.pos ?? anchors.tallestBuilding ?? anchors.center;
     if (!target) {
-      h.rig.reset();
+      handle.rig.reset();
       return;
     }
-    if (street) target.y = a.tallestHeight * 0.25; // look at building mid-height, not the road
-    h.rig.captureView({
+    if (street) target.y = anchors.tallestHeight * 0.25; // look at building mid-height, not the road
+    handle.rig.captureView({
       target,
-      distance: o.dist ?? a.tallestHeight * 1.6,
+      distance: o.dist ?? anchors.tallestHeight * 1.6,
       elevation: o.elev ?? 16,
       azimuth: o.az ?? 24,
     });
   },
-  streets: (h, m, o) => {
-    const a = h.rig.captureAnchors();
-    const path = m.stats.maxChildrenDir?.path;
-    const street = path ? h.rig.streetAnchor(path) : null;
-    const target = street?.pos ?? a.center;
+  streets: (handle, manifest, o) => {
+    const anchors = handle.rig.captureAnchors();
+    const path = manifest.stats.maxChildrenDir?.path;
+    const street = path ? handle.rig.streetAnchor(path) : null;
+    const target = street?.pos ?? anchors.center;
     if (!target) {
-      h.rig.reset();
+      handle.rig.reset();
       return;
     }
     // Steep look down over the densest directory's street so the labeled road
     // grid fills the frame, not the gem.
-    h.rig.captureView({
+    handle.rig.captureView({
       target,
-      distance: o.dist ?? a.cityRadius * 0.3,
+      distance: o.dist ?? anchors.cityRadius * 0.3,
       elevation: o.elev ?? 64,
       azimuth: o.az ?? 18,
     });
   },
-  gem: (h, _m, o) => {
-    const a = h.rig.captureAnchors();
-    if (!a.gem) {
-      h.rig.reset();
+  gem: (handle, _m, o) => {
+    const anchors = handle.rig.captureAnchors();
+    if (!anchors.gem) {
+      handle.rig.reset();
       return;
     }
     // Looking down at the floating gem, pulled back so it clears the frame (its
     // size scales with the root street width, so distance does too).
-    h.rig.captureView({
-      target: a.gem.clone(),
-      distance: o.dist ?? Math.max(a.rootStreetWidth * 6, 60),
+    handle.rig.captureView({
+      target: anchors.gem.clone(),
+      distance: o.dist ?? Math.max(anchors.rootStreetWidth * 6, 60),
       elevation: o.elev ?? 46,
       azimuth: o.az ?? 20,
     });
@@ -183,13 +183,13 @@ export const SHOTS: Record<string, ShotPose> = {
   // knows which slice of its recording to keep. Time-based, so the duration
   // holds regardless of frame rate, and a full 360deg loops seamlessly.
   // Tuning: ?elev = view angle, ?dist = distance, ?az = seconds per turn.
-  orbit: (h, _m, o) => {
-    const a = h.rig.captureAnchors();
-    const target = a.gem ?? a.center;
+  orbit: (handle, _m, o) => {
+    const anchors = handle.rig.captureAnchors();
+    const target = anchors.gem ?? anchors.center;
     if (!target) return false;
     const anchor = target.clone();
     const elevation = o.elev ?? 30;
-    const distance = o.dist ?? a.cityRadius * 0.95;
+    const distance = o.dist ?? anchors.cityRadius * 0.95;
     const durationMs = (o.az ?? 18) * 1000;
     let startMs: number | null = null;
     const step = (nowMs: number): void => {
@@ -198,7 +198,12 @@ export const SHOTS: Record<string, ShotPose> = {
         document.documentElement.dataset.ccOrbitStart = '1';
       }
       const p = Math.min((nowMs - startMs) / durationMs, 1);
-      h.rig.captureView({ target: anchor.clone(), distance, elevation, azimuth: -180 + p * 360 });
+      handle.rig.captureView({
+        target: anchor.clone(),
+        distance,
+        elevation,
+        azimuth: -180 + p * 360,
+      });
       if (p >= 1) {
         document.documentElement.dataset.ccOrbitDone = '1';
         return;
@@ -212,28 +217,28 @@ export const SHOTS: Record<string, ShotPose> = {
   // app/scripts/screenshots.mjs); codecity itself is too sparse to show either.
   // trees: wide forest immersion (dense trees fill the foreground, city behind);
   // fireflies: tighter on a busy tree so the author orbs read.
-  trees: (h, m, o) => {
-    const a = h.rig.captureAnchors();
-    const tree = placedTree(h, m);
+  trees: (handle, manifest, o) => {
+    const anchors = handle.rig.captureAnchors();
+    const tree = placedTree(handle, manifest);
     if (!tree) return false; // trees not placed yet: retry
     // Wide, low pull-back over a forest tree (distance scales with the city, not
     // the tree's canopy) so the forest fills the foreground with the city behind.
-    h.rig.captureView({
+    handle.rig.captureView({
       target: tree.pos,
-      distance: o.dist ?? a.cityRadius * 0.16,
+      distance: o.dist ?? anchors.cityRadius * 0.16,
       elevation: o.elev ?? 9,
       azimuth: o.az ?? 30,
     });
   },
-  fireflies: (h, m, o) => {
-    const tree = placedTree(h, m);
+  fireflies: (handle, manifest, o) => {
+    const tree = placedTree(handle, manifest);
     if (!tree) return false; // trees not placed yet: retry
     // Fit the tree's bounding sphere to the view (same math as the rig's
     // focusTree) at a low angle, so the single tree fills the frame.
     const span = tree.radius * 2;
     const boundingRadius = 0.5 * Math.sqrt(span * span * 2 + tree.height * tree.height);
     tree.pos.y = tree.height * 0.45;
-    h.rig.captureView({
+    handle.rig.captureView({
       target: tree.pos,
       distance: o.dist, // omitted -> fit the bounding sphere below
       fitRadius: boundingRadius,
diff --git a/app/src/city/components/buildings/buildingKind.ts b/app/src/city/components/buildings/buildingKind.ts
index 5c93a6105..aeea4721c 100644
--- a/app/src/city/components/buildings/buildingKind.ts
+++ b/app/src/city/components/buildings/buildingKind.ts
@@ -1,5 +1,7 @@
-// Per-instance building render kind (the iKind attribute). Mirror these float
-// values in building.vert/frag.glsl.
+// Per-instance building render kind (the iKind attribute). building.frag.glsl
+// redeclares these as `const int KIND_*`; building-shader.test.ts asserts the
+// two agree, since drift would silently render a whole class of buildings in
+// the wrong mode.
 export const BuildingKind = {
   Normal: 0,
   Ruin: 1, // Timeline: deleted → crumbled gray stub
diff --git a/app/src/city/components/buildings/facadePanels.ts b/app/src/city/components/buildings/facadePanels.ts
index 9c0455579..5b40ddc36 100644
--- a/app/src/city/components/buildings/facadePanels.ts
+++ b/app/src/city/components/buildings/facadePanels.ts
@@ -707,7 +707,7 @@ function _releaseSlot(): void {
  * Videos: never batched (we only need the first frame, and <video> streams just
  * enough to grab it) — loaded individually through the same semaphore.
  */
-export function asyncLoadMediaForBuilding(
+function asyncLoadMediaForBuilding(
   ads: InstancedFacadePanels,
   b: Building,
   layer: number,
@@ -736,7 +736,7 @@ export function asyncLoadMediaForBuilding(
  * other binary gets the server byte-pattern fingerprint. A missing/failed facade
  * just leaves the sealed placeholder — a valid look, so no error tint.
  */
-export function asyncLoadDataFacadeForBuilding(
+function asyncLoadDataFacadeForBuilding(
   ads: InstancedFacadePanels,
   b: Building,
   layer: number,
diff --git a/app/src/city/components/buildings/index.ts b/app/src/city/components/buildings/index.ts
index de54c874f..849c2ea8d 100644
--- a/app/src/city/components/buildings/index.ts
+++ b/app/src/city/components/buildings/index.ts
@@ -469,6 +469,9 @@ export function createBuildings(ctx: SceneContext): Buildings {
     // fresh diff above re-seeds from the current on-screen matrices, so clearing
     // loses no animation continuity.
     _tweens.clear();
+    // Same hazard as the tweens: it holds the old manifest's Buildings.
+    // reapplyTimelineScene reinstalls one, so only a repo switch leaves it null.
+    _scrubController = null;
     if (!_firstBuildDone) {
       _firstBuildDone = true;
     } else if (!TIMELINE_MODE.peek()) {
diff --git a/app/src/city/components/buildings/mediaBatch.ts b/app/src/city/components/buildings/mediaBatch.ts
index 8dd8167d5..082891faa 100644
--- a/app/src/city/components/buildings/mediaBatch.ts
+++ b/app/src/city/components/buildings/mediaBatch.ts
@@ -1,93 +1,33 @@
-// city/components/buildings/mediaBatch.ts — coalesces media-image fetches into
-// POST /api/images batches. The scene loads one billboard texture per media
-// file; firing a separate GET /api/file per image exhausts the browser's
-// HTTP/1.1 connection pool on media-heavy repos (Infisical: 2.6k images), so we
-// collect the paths requested within a short window and fetch them in a handful
-// of batched requests instead of thousands of singletons.
+// city/components/buildings/mediaBatch.ts — media images via POST /api/images.
 //
 // The caller gets back a Blob it wraps in an object URL and feeds to the
-// existing <img> decode path — so SVGs, color profiles, etc. still render
+// existing <img> decode path, so SVGs, color profiles, etc. still render
 // through the browser exactly as a direct GET would. A path the batch endpoint
 // omits (non-image, too large, out of root) resolves to null; the caller then
 // falls back to the streaming GET /api/file for that one file.
+//
+// Coalescing lives in createPathBatcher, shared with the fingerprint batcher.
 
-/** Max paths per POST /api/images request — mirrors the server-side cap so a
- *  single batch response stays bounded. */
-const BATCH_SIZE = 32;
-/** Coalescing window: media buildings register in a burst at scene build, so a
- *  one-frame delay gathers essentially all of them before the first flush. */
-const FLUSH_MS = 16;
+import { createPathBatcher } from '@/api/pathBatcher';
 
-interface BatchEntry {
+interface MediaEntry {
   mime: string;
   b64: string;
 }
 
-type Waiter = (blob: Blob | null) => void;
-
-const _queue = new Map<string, Waiter[]>();
-let _timer: ReturnType<typeof setTimeout> | null = null;
-
-/** Request a media image's bytes via the batch endpoint. Resolves with a Blob
- *  (use URL.createObjectURL + revoke), or null when the server omitted it. */
-export function fetchMediaBlob(path: string, sha?: string | null): Promise<Blob | null> {
-  return new Promise((resolve) => {
-    const waiters = _queue.get(path);
-    if (waiters) {
-      waiters.push(resolve);
-    } else {
-      _queue.set(path, [resolve]);
-    }
-    if (sha) _shas.set(path, sha);
-    if (_timer === null) _timer = setTimeout(_flush, FLUSH_MS);
-  });
-}
-
 // path -> blob sha for the scrubbed commit; empty in Live.
-const _shas = new Map<string, string>();
-
-function _flush(): void {
-  _timer = null;
-  // Snapshot + clear so requests arriving during the awaits start a fresh batch.
-  const pending = new Map(_queue);
-  _queue.clear();
-  const paths = [...pending.keys()];
-  for (let i = 0; i < paths.length; i += BATCH_SIZE) {
-    void _sendBatch(paths.slice(i, i + BATCH_SIZE), pending);
-  }
-}
+const shas = new Map<string, string>();
 
-async function _sendBatch(paths: string[], pending: Map<string, Waiter[]>): Promise<void> {
-  let result: Record<string, BatchEntry> = {};
-  try {
-    const res = await fetch('/api/images', {
-      method: 'POST',
-      headers: { 'content-type': 'application/json' },
-      body: JSON.stringify({ paths, shas: _shasFor(paths) }),
-    });
-    if (res.ok) result = (await res.json()) as Record<string, BatchEntry>;
-  } catch {
-    // Network failure → every path in this batch resolves null; callers fall
-    // back to the individual GET path.
-  }
-  for (const path of paths) {
-    const entry = result[path];
-    const blob = entry ? _decode(entry) : null;
-    _shas.delete(path);
-    for (const resolve of pending.get(path) ?? []) resolve(blob);
-  }
-}
-
-function _shasFor(paths: string[]): Record<string, string> {
+function shasFor(paths: string[]): Record<string, string> {
   const out: Record<string, string> = {};
-  for (const p of paths) {
-    const sha = _shas.get(p);
-    if (sha) out[p] = sha;
+  for (const path of paths) {
+    const sha = shas.get(path);
+    if (sha) out[path] = sha;
   }
   return out;
 }
 
-function _decode(entry: BatchEntry): Blob | null {
+function decodeBlob(entry: MediaEntry): Blob | null {
   try {
     const bin = atob(entry.b64);
     const bytes = new Uint8Array(bin.length);
@@ -97,3 +37,18 @@ function _decode(entry: BatchEntry): Blob | null {
     return null;
   }
 }
+
+const batcher = createPathBatcher<Blob, MediaEntry>({
+  endpoint: '/api/images',
+  decode: decodeBlob,
+  bodyFor: (paths) => ({ shas: shasFor(paths) }),
+  onSettled: (path) => shas.delete(path),
+});
+
+/** Request a media image's bytes via the batch endpoint. Resolves with a Blob
+ *  (use URL.createObjectURL + revoke), or null when the server omitted it. */
+export function fetchMediaBlob(path: string, sha?: string | null): Promise<Blob | null> {
+  // Recorded before the request so the sha is present when the batch flushes.
+  if (sha) shas.set(path, sha);
+  return batcher.request(path);
+}
diff --git a/app/src/city/components/gem/mesh.ts b/app/src/city/components/gem/mesh.ts
index 1d32a1db9..a2979b99c 100644
--- a/app/src/city/components/gem/mesh.ts
+++ b/app/src/city/components/gem/mesh.ts
@@ -78,10 +78,10 @@ export function createRootGem(street: Street): THREE.Group {
   const group = new THREE.Group();
 
   // Gem size scales with the street's width. The layout reserves extra dead
-  // space at the root street's origin end (see GEM_SIZING), so the origin
-  // cap has no buildings overlapping it — the road's rounded cap IS the
-  // plaza. RADIUS_AS_STREET_FRAC MUST match what layout.ts uses to reserve
-  // that pad.
+  // space at the root street's origin end, so the origin cap has no buildings
+  // overlapping it — the road's rounded cap IS the plaza. layout/algorithm.ts
+  // sizes that pad from this same GEM_SIZING signal, so the two agree by
+  // construction rather than by being kept in step.
   const radiusFrac = sizing.RADIUS_AS_STREET_FRAC;
   const minRadius = sizing.MIN_RADIUS;
   const hoverFrac = GEM_HOVER_LIFT_FRAC;
diff --git a/app/src/city/components/streets/streets.ts b/app/src/city/components/streets/streets.ts
index 16c88ea29..3ad2cbfed 100644
--- a/app/src/city/components/streets/streets.ts
+++ b/app/src/city/components/streets/streets.ts
@@ -185,7 +185,7 @@ function _buildStadiumGeometry(
 // and rounded only at the open end. Layout stamps each non-root street with
 // `joinSide`. The SAME cap style feeds both sidewalk + asphalt so their flat ends
 // line up and the visible sidewalk strip stays uniform around the cap.
-export function capStyleFor(street: StreetWithJoin): CapStyle {
+function capStyleFor(street: StreetWithJoin): CapStyle {
   if (street.isRoot) return CapStyle.Both;
   if (street.joinSide === JoinSide.High) return CapStyle.Low; // round the low/open end
   return CapStyle.High; // round the high/open end
@@ -311,7 +311,7 @@ export function sidewalkStreetForFace(
 // color and not pickable, so every street's asphalt merges into a single mesh —
 // see the streets component. Concentric with the sidewalk cap (asphaltDims) so
 // the sidewalk strip stays a uniform width around the perimeter.
-export function buildAsphaltGeometry(street: StreetWithJoin, yBase: number): THREE.BufferGeometry {
+function buildAsphaltGeometry(street: StreetWithJoin, yBase: number): THREE.BufferGeometry {
   const { asphaltWidth, asphaltLength } = asphaltDims(street);
   const geo = _buildStadiumGeometry(
     asphaltLength,
diff --git a/app/src/city/index.ts b/app/src/city/index.ts
index 2d6ea3951..09248d497 100644
--- a/app/src/city/index.ts
+++ b/app/src/city/index.ts
@@ -8,6 +8,7 @@ import { effect, untracked } from '@preact/signals';
 
 import type { Manifest, RangeStat } from '@/types';
 import { CURRENT_SOURCE_KEY } from '@/state/stores/source';
+import { MANIFEST } from '@/state/stores/manifest';
 import { TIMELINE_MODE, SCRUB_DRAGGING, SCRUB_POS } from '@/state/stores/timeline';
 
 import { registerShaderChunks } from './utils/shaders/registerShaderChunks';
@@ -255,20 +256,20 @@ export async function createCity(canvas: HTMLCanvasElement, manifest: Manifest):
       buildings.setScrubController(null);
       _scrubController?.dispose();
       _scrubController = null;
-      // Restore the full forest immediately — don't wait on exit's manifest reload.
-      trees.setScrubCommit(null);
-      fireflies.setScrubCommit(null);
     },
     setStreetsTransparent: (on: boolean): void => streets.setStreetsTransparent(on),
     setFootprintsTransparent: (on: boolean): void => footprint.setFootprintsTransparent(on),
   };
 
-  // Reacts to every Timeline-mode exit (toggle, source switch) so the scene teardown is uniform regardless of trigger.
+  // Every Timeline exit. The union city holds buildings that do not exist at
+  // HEAD, so only a rebuild from the live MANIFEST is a valid live city.
   const stopTimelineTeardown = effect(() => {
     if (TIMELINE_MODE.value || !_scrubController) return;
     timelineApi.uninstallScrubController();
-    timelineApi.setStreetsTransparent(false);
-    timelineApi.setFootprintsTransparent(false);
+    const live = MANIFEST.peek() as Manifest | null;
+    // Best-effort: a dispose or a newer apply can supersede this mid-flight,
+    // and neither is a failure worth surfacing from a teardown.
+    if (live) void applyManifest(live).catch(() => {});
   });
 
   return {
diff --git a/app/src/city/interaction/picker.ts b/app/src/city/interaction/picker.ts
index 41dbf5d94..17c226f2d 100644
--- a/app/src/city/interaction/picker.ts
+++ b/app/src/city/interaction/picker.ts
@@ -167,15 +167,15 @@ export function createPicker({
       return;
     }
     if (key.kind === NodeKind.File) {
-      const b = world.getBuildingByPath(key.path);
+      const resolved = world.getBuildingByPath(key.path);
       _suspendKeyDerive = true;
-      if (b) {
+      if (resolved) {
         selection.value = {
           kind: NodeKind.File,
-          mesh: b.mesh,
-          data: b.building,
-          file: b.building.file,
-          instanceId: b.instanceId,
+          mesh: resolved.mesh,
+          data: resolved.building,
+          file: resolved.building.file,
+          instanceId: resolved.instanceId,
         };
       } else {
         selection.value = null;
@@ -296,20 +296,20 @@ export function createPicker({
   // rig.focusSelection.
   function targetForPath(path: string): PickTarget | null {
     if (!path) return null;
-    const b = world.getBuildingByPath(path);
-    if (b) {
+    const resolved = world.getBuildingByPath(path);
+    if (resolved) {
       return {
         kind: NodeKind.File,
-        mesh: b.mesh,
-        data: b.building,
-        file: b.building.file,
-        instanceId: b.instanceId,
+        mesh: resolved.mesh,
+        data: resolved.building,
+        file: resolved.building.file,
+        instanceId: resolved.instanceId,
       };
     }
-    const sw = world.getSidewalkByDir(path);
-    const st = world.getStreetByDir(path);
-    if (sw && st && st.dir) {
-      return { kind: NodeKind.Directory, sidewalk: sw, street: st, dir: st.dir };
+    const sidewalk = world.getSidewalkByDir(path);
+    const street = world.getStreetByDir(path);
+    if (sidewalk && street && street.dir) {
+      return { kind: NodeKind.Directory, sidewalk, street, dir: street.dir };
     }
     return null;
   }
@@ -317,8 +317,8 @@ export function createPicker({
   // Resolve a path and set it as the selection. Used by tree-row clicks and
   // breadcrumb-segment clicks. No-op if the path doesn't match anything.
   function selectByPath(path: string): void {
-    const t = targetForPath(path);
-    if (t) setSelection(t);
+    const target = targetForPath(path);
+    if (target) setSelection(target);
   }
 
   // Resolve a commit sha to its live tree target and select it. No-op if
@@ -338,8 +338,8 @@ export function createPicker({
   // Resolve a path and set it as the hover target (tree-row hover → city
   // highlight). No-op if the path doesn't match anything.
   function hoverByPath(path: string): void {
-    const t = targetForPath(path);
-    if (t) setHover(t);
+    const target = targetForPath(path);
+    if (target) setHover(target);
   }
 
   // ── Timeline scrub-hidden guard ─────────────────────────────────────
@@ -461,74 +461,75 @@ export function createPicker({
   // the same shape held by hover / selection signals. Returns null for
   // hits that aren't selectable (e.g. street labels, which don't have
   // userData.type populated for picking).
+  /** A tree instance carries the commit that grew it. */
+  function commitTargetFor(mesh: THREE.InstancedMesh, slot: number | undefined): PickTarget | null {
+    if (slot == null) return null;
+    if (TIMELINE_MODE.peek() && _treeScrubHidden(mesh, slot)) return null;
+    const commit = world.getTrees()?.commitForInstance(mesh, slot);
+    if (!commit) return null;
+    return { kind: NodeKind.Commit, mesh, instanceId: slot, commit };
+  }
+
+  /** A CellTile detail mesh: the Building comes from BuildingIndex by
+   *  "cellId:slotId", since one mesh carries many buildings. */
+  function buildingTargetFor(
+    mesh: THREE.InstancedMesh,
+    cellId: unknown,
+    slot: number | undefined
+  ): PickTarget | null {
+    if (slot == null) return null;
+    if (TIMELINE_MODE.peek() && _buildingScrubHidden(mesh, slot)) return null;
+    const building = world.getBuildingIndex()?.byCellSlot(`${cellId}:${slot}`);
+    if (!building?.file) return null;
+    return {
+      kind: NodeKind.File,
+      mesh: mesh as THREE.Mesh,
+      data: building,
+      file: building.file,
+      instanceId: slot,
+      isRuin: TIMELINE_MODE.peek() && _buildingIsRuin(mesh, slot),
+    };
+  }
+
+  /** Merged sidewalk: every street shares one mesh, so the hit face resolves to
+   *  its street through the faceIndex map baked onto userData. */
+  function sidewalkTargetFor(hit: THREE.Intersection<THREE.Object3D>): PickTarget | null {
+    const mesh = hit.object as THREE.Mesh;
+    if (TIMELINE_MODE.peek() && _streetScrubHidden(mesh, hit.face?.a)) return null;
+    const street = sidewalkStreetForFace(hit.object, hit.faceIndex ?? 0);
+    if (!street?.dir) return null;
+    // A future folder's road is only a pad: it does not exist at this scrub
+    // position, so it is not selectable.
+    if (TIMELINE_MODE.peek() && FUTURE_STREET_DIRS.has(street.dir.path)) return null;
+    return {
+      kind: NodeKind.Directory,
+      sidewalk: mesh,
+      street,
+      dir: street.dir,
+      isRuin: TIMELINE_MODE.peek() && RUINED_STREET_DIRS.has(street.dir.path),
+      vertexHint: hit.face?.a,
+    };
+  }
+
   function interpretHit(hit: THREE.Intersection<THREE.Object3D> | null): PickTarget | null {
     if (!hit || !hit.object) return null;
     const ud = hit.object.userData;
-    if (ud.type === NodeKind.Gem) {
-      return { kind: NodeKind.Gem, mesh: hit.object };
-    }
-    if (
-      hit.object instanceof THREE.InstancedMesh &&
-      (ud.meshKind === 'tree-canopy' || ud.meshKind === 'tree-trunk')
-    ) {
-      const slot = hit.instanceId;
-      if (slot == null) return null;
-      if (TIMELINE_MODE.peek() && _treeScrubHidden(hit.object, slot)) return null;
-      const trees = world.getTrees();
-      const commit = trees?.commitForInstance(hit.object, slot);
-      if (!commit) return null;
-      return {
-        kind: NodeKind.Commit,
-        mesh: hit.object,
-        instanceId: slot,
-        commit,
-      };
-    }
-    // InstancedMesh hit from a CellTile. detailMesh carries userData.cellId
-    // and userData.meshKind === 'detail'. The Building is looked up via
-    // BuildingIndex.byCellSlot("cellId:slotId").
-    if (
-      hit.object instanceof THREE.InstancedMesh &&
-      ud.cellId != null &&
-      ud.meshKind === 'detail'
-    ) {
-      const slot = hit.instanceId;
-      if (slot == null) return null;
-      if (TIMELINE_MODE.peek() && _buildingScrubHidden(hit.object, slot)) return null;
-      const idx = world.getBuildingIndex();
-      const building = idx?.byCellSlot(`${ud.cellId}:${slot}`);
-      if (!building?.file) return null;
-      return {
-        kind: NodeKind.File,
-        mesh: hit.object as THREE.Mesh,
-        data: building,
-        file: building.file,
-        instanceId: slot,
-        isRuin: TIMELINE_MODE.peek() && _buildingIsRuin(hit.object, slot),
-      };
-    }
-    // Merged sidewalk: all streets share one mesh, so resolve the hit face to
-    // its street via the faceIndex→street map baked onto userData.
-    if (ud.type === NodeKind.Directory && ud.pickStreets) {
-      if (TIMELINE_MODE.peek() && _streetScrubHidden(hit.object as THREE.Mesh, hit.face?.a)) {
-        return null;
+
+    // Each branch owns its kind outright: a null from inside one means "this is
+    // that kind, but nothing selectable here", never "try the next one".
+    if (ud.type === NodeKind.Gem) return { kind: NodeKind.Gem, mesh: hit.object };
+
+    if (hit.object instanceof THREE.InstancedMesh) {
+      if (ud.meshKind === 'tree-canopy' || ud.meshKind === 'tree-trunk') {
+        return commitTargetFor(hit.object, hit.instanceId);
       }
-      const street = sidewalkStreetForFace(hit.object, hit.faceIndex ?? 0);
-      // A future folder's road is only a pad — it doesn't exist at this scrub position, so it's not selectable.
-      if (street?.dir && TIMELINE_MODE.peek() && FUTURE_STREET_DIRS.has(street.dir.path))
-        return null;
-      if (street?.dir) {
-        return {
-          kind: NodeKind.Directory,
-          sidewalk: hit.object as THREE.Mesh,
-          street,
-          dir: street.dir,
-          isRuin: TIMELINE_MODE.peek() && RUINED_STREET_DIRS.has(street.dir.path),
-          vertexHint: hit.face?.a,
-        };
+      if (ud.cellId != null && ud.meshKind === 'detail') {
+        return buildingTargetFor(hit.object, ud.cellId, hit.instanceId);
       }
-      return null;
     }
+
+    if (ud.type === NodeKind.Directory && ud.pickStreets) return sidewalkTargetFor(hit);
+
     if (ud.street && ud.street.dir) {
       return {
         kind: NodeKind.Directory,
diff --git a/app/src/city/layout/algorithm.ts b/app/src/city/layout/algorithm.ts
index 7de54ef6b..485a50277 100644
--- a/app/src/city/layout/algorithm.ts
+++ b/app/src/city/layout/algorithm.ts
@@ -769,11 +769,7 @@ export function _markJoinSides(streets: StreetWithJoin[]): void {
 // the building ends up on the opposite side of its own street with its door
 // pointing away.
 // -----------------------------------------------------------------------------
-export function _mirrorOrient(
-  orient: BuildingOrient,
-  negateX: boolean,
-  negateY: boolean
-): BuildingOrient {
+function _mirrorOrient(orient: BuildingOrient, negateX: boolean, negateY: boolean): BuildingOrient {
   if (negateX) {
     if (orient === BuildingOrient.East) orient = BuildingOrient.West;
     else if (orient === BuildingOrient.West) orient = BuildingOrient.East;
diff --git a/app/src/city/layout/dimensions.ts b/app/src/city/layout/dimensions.ts
index 2543eb174..c3f4310ac 100644
--- a/app/src/city/layout/dimensions.ts
+++ b/app/src/city/layout/dimensions.ts
@@ -87,6 +87,66 @@ export function computeFileStats(stats: RepoStats | null | undefined): {
 // out below MAX_* (short/narrow city) instead of always stretching to the cap,
 // while the per-repo relative order is retained. Without a stats object, the
 // corresponding dimension falls back to MIN_*.
+type Dims = typeof BUILDING_DIMENSIONS.value;
+
+/** Floors from line count, sqrt-normalized over the project range.
+ *
+ *  The repo's tallest building only reaches the full cap if its largest file is
+ *  >= FULL_HEIGHT_LINES, so a repo of small files reads as a low-rise city
+ *  rather than being stretched to full height. Relative order is preserved. */
+function floorsForLines(
+  fileLines: number | null | undefined,
+  lineStats: RangeStat | undefined,
+  dims: Dims,
+  maxFloorsCap: number
+): number {
+  if (!lineStats || lineStats.max <= lineStats.min) return dims.MIN_FLOORS;
+  const lines = fileLines && fileLines > 0 ? fileLines : 1;
+  const sMin = Math.sqrt(lineStats.min);
+  const sMax = Math.sqrt(lineStats.max);
+  let tH = (Math.sqrt(lines) - sMin) / (sMax - sMin);
+  if (tH < 0) tH = 0;
+  else if (tH > 1) tH = 1;
+
+  const refLines =
+    dims.FULL_HEIGHT_LINES && dims.FULL_HEIGHT_LINES > 0 ? dims.FULL_HEIGHT_LINES : 2000;
+  let ceilH = Math.sqrt(lineStats.max) / Math.sqrt(refLines);
+  if (ceilH > 1) ceilH = 1;
+
+  const repoMaxFloors = dims.MIN_FLOORS + ceilH * (maxFloorsCap - dims.MIN_FLOORS);
+  const floors = Math.round(dims.MIN_FLOORS + tH * (repoMaxFloors - dims.MIN_FLOORS));
+  return floors < dims.MIN_FLOORS ? dims.MIN_FLOORS : floors;
+}
+
+/** Width from byte size, log-normalized over the project range. Mirrors the
+ *  floors ceiling: full width only when the largest file is >= FULL_WIDTH_KB.
+ *
+ *  Both the range and the per-file size clamp to >= 1, because log(0) is
+ *  -Infinity and would carry NaN into every downstream dimension. */
+function widthForBytes(
+  fileSize: number | null | undefined,
+  byteStats: RangeStat | undefined,
+  dims: Dims
+): number {
+  const bMin = Math.max(1, byteStats?.min ?? 1);
+  const bMax = Math.max(1, byteStats?.max ?? 1);
+  if (!byteStats || bMax <= bMin) return dims.MIN_WIDTH;
+
+  const bytes = fileSize && fileSize > 0 ? fileSize : 1;
+  const lMin = Math.log(bMin);
+  let tW = (Math.log(bytes) - lMin) / (Math.log(bMax) - lMin);
+  if (tW < 0) tW = 0;
+  else if (tW > 1) tW = 1;
+
+  const refBytes = (dims.FULL_WIDTH_KB && dims.FULL_WIDTH_KB > 0 ? dims.FULL_WIDTH_KB : 64) * 1024;
+  let ceilW = Math.log(bMax) / Math.log(refBytes);
+  if (ceilW < 0) ceilW = 0;
+  else if (ceilW > 1) ceilW = 1;
+
+  const repoMaxWidth = dims.MIN_WIDTH + ceilW * (dims.MAX_WIDTH - dims.MIN_WIDTH);
+  return dims.MIN_WIDTH + tW * (repoMaxWidth - dims.MIN_WIDTH);
+}
+
 export function getBuildingDimensions(
   file: {
     lines?: number | null;
@@ -107,57 +167,12 @@ export function getBuildingDimensions(
   // the whole floors curve and takes the slab branch below instead.
   const empty = isEmptyFile(file);
 
-  // ---- Floors from line count (sqrt-normalized over project range) ----
-  const lines = file.lines && file.lines > 0 ? file.lines : 1;
-  let floors = dims.MIN_FLOORS;
-  if (!empty && lineStats && lineStats.max > lineStats.min) {
-    const sMin = Math.sqrt(lineStats.min);
-    const sMax = Math.sqrt(lineStats.max);
-    const sLines = Math.sqrt(lines);
-    let tH = (sLines - sMin) / (sMax - sMin);
-    if (tH < 0) tH = 0;
-    else if (tH > 1) tH = 1;
-    // Absolute ceiling: the repo's tallest building reaches the full cap only if
-    // its largest file is >= FULL_HEIGHT_LINES; smaller-file repos top out lower
-    // (sqrt of the biggest file vs the reference). So the per-repo relative
-    // spread (tH) is preserved, but a repo of tiny files reads as a low-rise
-    // city instead of being stretched to full height.
-    const refLines =
-      dims.FULL_HEIGHT_LINES && dims.FULL_HEIGHT_LINES > 0 ? dims.FULL_HEIGHT_LINES : 2000;
-    let ceilH = Math.sqrt(lineStats.max) / Math.sqrt(refLines);
-    if (ceilH > 1) ceilH = 1;
-    const repoMaxFloors = dims.MIN_FLOORS + ceilH * (maxFloorsCap - dims.MIN_FLOORS);
-    floors = Math.round(dims.MIN_FLOORS + tH * (repoMaxFloors - dims.MIN_FLOORS));
-    if (floors < dims.MIN_FLOORS) floors = dims.MIN_FLOORS;
-  }
+  const floors = empty
+    ? dims.MIN_FLOORS
+    : floorsForLines(file.lines, lineStats, dims, maxFloorsCap);
   const height = floors * dims.FLOOR_HEIGHT;
 
-  // ---- Width from byte size (log-normalized over project range) ----
-  const bytes = file.size && file.size > 0 ? file.size : 1;
-  let width = dims.MIN_WIDTH;
-  // Clamp the range to >= 1 so Math.log stays finite even if the project byte
-  // range ever includes a 0-byte file (log(0) = -Infinity → NaN width → NaN
-  // geometry). Per-file `bytes` is already clamped to >= 1 above.
-  const bMin = Math.max(1, byteStats?.min ?? 1);
-  const bMax = Math.max(1, byteStats?.max ?? 1);
-  if (byteStats && bMax > bMin) {
-    const lMin = Math.log(bMin);
-    const lMax = Math.log(bMax);
-    const lBytes = Math.log(bytes);
-    let tW = (lBytes - lMin) / (lMax - lMin);
-    if (tW < 0) tW = 0;
-    else if (tW > 1) tW = 1;
-    // Absolute ceiling mirrors floors: full width only when the repo's largest
-    // file is >= FULL_WIDTH_KB; smaller-file repos keep proportionally narrower
-    // footprints while retaining the per-repo relative spread (tW).
-    const refBytes =
-      (dims.FULL_WIDTH_KB && dims.FULL_WIDTH_KB > 0 ? dims.FULL_WIDTH_KB : 64) * 1024;
-    let ceilW = Math.log(bMax) / Math.log(refBytes);
-    if (ceilW < 0) ceilW = 0;
-    else if (ceilW > 1) ceilW = 1;
-    const repoMaxWidth = dims.MIN_WIDTH + ceilW * (dims.MAX_WIDTH - dims.MIN_WIDTH);
-    width = dims.MIN_WIDTH + tW * (repoMaxWidth - dims.MIN_WIDTH);
-  }
+  const width = widthForBytes(file.size, byteStats, dims);
 
   // Media files (image/video) override the lines-driven height: the
   // building's silhouette mirrors the image's natural aspect ratio
diff --git a/app/src/city/layout/occupancyIndex.ts b/app/src/city/layout/occupancyIndex.ts
index 838d6c6cb..0609a15fb 100644
--- a/app/src/city/layout/occupancyIndex.ts
+++ b/app/src/city/layout/occupancyIndex.ts
@@ -48,18 +48,41 @@ export class WorldOccupancy {
   }
 
   query(minX: number, minY: number, maxX: number, maxY: number): WorldRect[] {
-    return this.tree.search({ minX, minY, maxX, maxY }).filter(
-      (r) =>
-        // Strict overlap (touching edges return false).
+    // Compact in place rather than `.filter()`: rbush already allocated this
+    // array, and the stem solver runs ~3M queries over ~32M results on a large
+    // repo, so a second array plus a second pass per query is not free.
+    const found = this.tree.search({ minX, minY, maxX, maxY });
+    let kept = 0;
+    for (let i = 0; i < found.length; i++) {
+      const r = found[i];
+      // Strict overlap (touching edges return false).
+      if (
         r.minX < maxX - OVERLAP_EPS &&
         r.maxX > minX + OVERLAP_EPS &&
         r.minY < maxY - OVERLAP_EPS &&
         r.maxY > minY + OVERLAP_EPS
-    );
+      ) {
+        found[kept++] = r;
+      }
+    }
+    found.length = kept;
+    return found;
   }
 
   hasOverlap(minX: number, minY: number, maxX: number, maxY: number): boolean {
-    return this.query(minX, minY, maxX, maxY).length > 0;
+    // Stops at the first hit instead of compacting the whole result just to
+    // read `.length > 0`.
+    for (const r of this.tree.search({ minX, minY, maxX, maxY })) {
+      if (
+        r.minX < maxX - OVERLAP_EPS &&
+        r.maxX > minX + OVERLAP_EPS &&
+        r.minY < maxY - OVERLAP_EPS &&
+        r.maxY > minY + OVERLAP_EPS
+      ) {
+        return true;
+      }
+    }
+    return false;
   }
 
   size(): number {
diff --git a/app/src/city/layout/overlaps.ts b/app/src/city/layout/overlaps.ts
index 26fe7a181..4610179bf 100644
--- a/app/src/city/layout/overlaps.ts
+++ b/app/src/city/layout/overlaps.ts
@@ -24,8 +24,8 @@ import { WorldRectKind } from './occupancyIndex';
 //     widths). This is the documented flat join the renderer fuses.
 // Anything else is 'unexpected'.
 //
-// `_isStreetJoinPair` mirrors the geometry test in tests/city/layout.test.ts
-// (kept independent so the runtime helper has no test-file dependency).
+// `_isStreetJoinPair` re-derives the T-junction geometry rather than sharing a
+// helper, so this runtime diagnostic never depends on layout internals moving.
 function _isStreetJoinPair(a: Street, b: Street): boolean {
   if (a.orientation === b.orientation) return false;
   const aLong = a.orientation === StreetAxis.X ? 'x' : 'y';
diff --git a/app/src/city/layout/stemSolver.ts b/app/src/city/layout/stemSolver.ts
index 899e012ae..d6817609b 100644
--- a/app/src/city/layout/stemSolver.ts
+++ b/app/src/city/layout/stemSolver.ts
@@ -156,6 +156,18 @@ interface FindSmallestValidStemParams {
 // set the final stem (or null if the chosen stem equals the baseline), and
 // trace.stem with the returned value. The trace param has no effect on the
 // algorithm or return value; it is purely an out-parameter.
+// Interval endpoints for one findSmallestValidStem call. Module-level and
+// reused: the function is called in a loop by placeChild, never recursively, so
+// a single pair of buffers is safe. Same scratch pattern as the colour helpers.
+let _loScratch = new Float64Array(256);
+let _hiScratch = new Float64Array(256);
+
+function _growScratch(buf: Float64Array<ArrayBuffer>): Float64Array<ArrayBuffer> {
+  const next = new Float64Array(buf.length * 2);
+  next.set(buf);
+  return next;
+}
+
 export function findSmallestValidStem(
   p: FindSmallestValidStemParams,
   trace?: VariantTrace
@@ -175,15 +187,22 @@ export function findSmallestValidStem(
   // no sort); trace keeps full records for the stem-placement debugger.
   const tracing = trace !== undefined;
   const forbidden: ForbiddenIntervalRecord[] = [];
-  const lo: number[] = [];
-  const hi: number[] = [];
+  // Reused scratch rather than two fresh arrays per call: a large repo pushes
+  // ~32M endpoints across ~240k calls, so allocation and regrowth dominate.
+  let loCount = 0;
+  let lo = _loScratch;
+  let hi = _hiScratch;
+
+  // Orientation is fixed for the whole call, and the inner loop runs per
+  // candidate (~32M times on a large repo), so decide it once.
+  const alongIsX = p.parentOrient === StreetAxis.X;
 
   for (let rIdx = 0; rIdx < p.childRects.length; rIdx++) {
     const r = p.childRects[rIdx];
     const flipped = applyFlips(r, flipX, flipY);
 
     let alongMin0: number, alongMax0: number, perpMin: number, perpMax: number;
-    if (p.parentOrient === StreetAxis.X) {
+    if (alongIsX) {
       alongMin0 = flipped.x - flipped.w / 2 + p.parentOriginX;
       alongMax0 = flipped.x + flipped.w / 2 + p.parentOriginX;
       perpMin = flipped.y - flipped.d / 2 + p.parentOriginY;
@@ -197,16 +216,15 @@ export function findSmallestValidStem(
 
     // Skip obstacles whose far edge is behind the frontier (−1 margin for FP).
     const loAlong = alongMin0 + baseline - maxSep - 1;
-    const candidates =
-      p.parentOrient === StreetAxis.X
-        ? p.occupancy.query(loAlong, perpMin, Infinity, perpMax)
-        : p.occupancy.query(perpMin, loAlong, perpMax, Infinity);
+    const candidates = alongIsX
+      ? p.occupancy.query(loAlong, perpMin, Infinity, perpMax)
+      : p.occupancy.query(perpMin, loAlong, perpMax, Infinity);
     _profCount('stem.queries', 1);
     _profCount('stem.candidates', candidates.length);
 
     for (const g of candidates) {
-      const gMinAlong = p.parentOrient === StreetAxis.X ? g.minX : g.minY;
-      const gMaxAlong = p.parentOrient === StreetAxis.X ? g.maxX : g.maxY;
+      const gMinAlong = alongIsX ? g.minX : g.minY;
+      const gMaxAlong = alongIsX ? g.maxX : g.maxY;
 
       // Separation to this obstacle. The parent-body phantom isn't a sibling —
       // the gap to it is just the building baseline (its branch-join spacing
@@ -221,8 +239,13 @@ export function findSmallestValidStem(
         if (tracing) {
           forbidden.push({ lower, upper, obstacle: g, fromChildRectIndex: rIdx });
         } else {
-          lo.push(lower);
-          hi.push(upper);
+          if (loCount === lo.length) {
+            lo = _loScratch = _growScratch(lo);
+            hi = _hiScratch = _growScratch(hi);
+          }
+          lo[loCount] = lower;
+          hi[loCount] = upper;
+          loCount++;
         }
       }
     }
@@ -248,7 +271,7 @@ export function findSmallestValidStem(
     trace.bindingIndex = bindingIndex;
     trace.stem = s;
   } else {
-    const n = lo.length;
+    const n = loCount;
     for (let rounds = 0; ; rounds++) {
       let ns = s;
       for (let i = 0; i < n; i++) {
@@ -259,7 +282,7 @@ export function findSmallestValidStem(
       // A long chain (e.g. a big flat dir) makes the round loop expensive; finish
       // it with a one-off sorted scan to keep the O(F log F) bound.
       if (rounds > STEM_SCAN_SORT_FALLBACK_ROUNDS) {
-        const order = Array.from(lo.keys()).sort((a, b) => lo[a] - lo[b]);
+        const order = Array.from({ length: n }, (_, i) => i).sort((a, b) => lo[a] - lo[b]);
         s = baseline;
         for (const i of order) {
           if (s < lo[i]) break;
@@ -270,7 +293,7 @@ export function findSmallestValidStem(
     }
   }
 
-  _profCount('stem.forbidden', tracing ? forbidden.length : lo.length);
+  _profCount('stem.forbidden', tracing ? forbidden.length : loCount);
   _profEnd('findSmallestValidStem', _t0);
   return s;
 }
diff --git a/app/src/city/timeline/replay.ts b/app/src/city/timeline/replay.ts
index e7ee8b589..ce6aa18bf 100644
--- a/app/src/city/timeline/replay.ts
+++ b/app/src/city/timeline/replay.ts
@@ -5,8 +5,13 @@ export interface PathTimeline {
   intervals: { start: number; end: number | null }[];
 }
 
-// Mirrors the backend replay: walking deltas[0..i] reproduces the file set + lines at commit i.
+// Walking deltas[0..i] reproduces the file set + lines at commit i.
 // Intervals (not a single created/deleted pair) let a resurrected path have a dead gap in between.
+//
+// The server walks the same deltas, but for a different output: per-commit
+// aggregate ranges, shipped in the bundle. This builds a per-path index the
+// scrub queries below read at any fractional position, several times per frame
+// per building, so it has to be local — it is not a copy of the server's pass.
 export function buildPathTimelines(bundle: TimelineBundle): Map<string, PathTimeline> {
   const timelines = new Map<string, PathTimeline>();
 
@@ -36,7 +41,7 @@ export function buildPathTimelines(bundle: TimelineBundle): Map<string, PathTime
   return timelines;
 }
 
-export function isPresent(pt: PathTimeline, pos: number): boolean {
+function isPresent(pt: PathTimeline, pos: number): boolean {
   return pt.intervals.some((iv) => pos >= iv.start && (iv.end === null || pos < iv.end));
 }
 
diff --git a/app/src/city/timeline/scrubController.ts b/app/src/city/timeline/scrubController.ts
index 158b897e2..0d0539bbc 100644
--- a/app/src/city/timeline/scrubController.ts
+++ b/app/src/city/timeline/scrubController.ts
@@ -19,7 +19,7 @@ import { BUILDING_DIMENSIONS, BUILDINGS } from '@/state/stores/settings/building
 import { RUINS } from '@/state/stores/settings/ruins';
 import { BLUEPRINTS } from '@/state/stores/settings/blueprints';
 import { FadeDetail, NodeKind } from '@/types';
-import type { Building, RangeStat, Street } from '@/types';
+import type { Building, FileNode, RangeStat, Street } from '@/types';
 import type { BuildingIndex } from '@/city/components/buildings/buildingIndex';
 import type { InstancedFacadePanels } from '@/city/components/buildings/facadePanels';
 import type { createPicker } from '@/city/interaction/picker';
@@ -151,293 +151,400 @@ export function createScrubController(deps: ScrubControllerDeps) {
   const _color = new THREE.Color();
   const _futureColor = new THREE.Color();
 
-  function update(): void {
-    const pos = SCRUB_POS.peek();
-    deps.trees.setScrubCommit(Math.floor(pos));
-    deps.fireflies.setScrubCommit(Math.floor(pos));
+  // Everything `update` reads once per frame: the commit's height range, the
+  // ruin/future settings, the replayed date ranges, and the hover/selection
+  // targets the neighborhood fade cascade needs.
+  interface ScrubFrame {
+    pos: number;
+    lineStats: RangeStat;
+    ruinsOn: boolean;
+    ruinBuildingOpacity: number;
+    ruinHeight: number;
+    ruinGrayMix: number;
+    futureOn: boolean;
+    futureBuildingOpacity: number;
+    futureHeight: number;
+    futureTint: number;
+    minMod: number;
+    minCreated: number;
+    modSpread: number;
+    createdSpread: number;
+    bldgTargetFile: FileNode | null;
+    dirTarget: ReturnType<typeof resolveDirTarget>;
+    hoverFile: FileNode | null;
+    fadeCfg: ReturnType<typeof BUILDINGS.peek>;
+  }
+
+  function readScrubFrame(pos: number): ScrubFrame {
     // Height range for this commit → matches Live-at-that-commit. Degenerate {0,0} → {1,1}.
     const ri = Math.max(0, Math.min(deps.commitLineRanges.length - 1, Math.floor(pos)));
     const r = deps.commitLineRanges[ri];
-    const lineStats: RangeStat = r && (r.min > 0 || r.max > 0) ? r : { min: 1, max: 1 };
-    const dirtyMeshes = new Set<THREE.InstancedMesh>();
-    const dirtyFades = new Set<THREE.BufferAttribute>();
-    const dirtyColors = new Set<THREE.InstancedMesh>();
-    const dirtyFloors = new Set<THREE.BufferAttribute>();
-    const dirtyModifiedAges = new Set<THREE.BufferAttribute>();
-    const dirtyIconUVs = new Set<THREE.BufferAttribute>();
-    const dirtyKinds = new Set<THREE.BufferAttribute>();
-    // A street fades with its PRESENT descendants; a ruin-only or future-only
-    // street renders fully opaque, set apart by color instead of fading.
-    const maxPresentOp = new Map<Street, number>();
-    const ruinStreets = new Set<Street>();
-    // Ad-panel opacity by path: the building's op when present, else 0 (a ruin or
-    // absent building shows no media image). Feeds applyBuildingFades only.
-    const opByPath = new Map<string, number>();
-    const presentStreets = new Set<Street>();
-    RUINED_STREET_DIRS.clear();
-    FUTURE_STREET_DIRS.clear();
 
     const floorHeight = BUILDING_DIMENSIONS.peek().FLOOR_HEIGHT;
     const ruins = RUINS.peek();
-    const ruinsOn = ruins.ENABLED;
-    const ruinBuildingOpacity = ruins.BUILDING_OPACITY;
-    const ruinHeight = ruins.STUB_HEIGHT * floorHeight;
-    const ruinGrayMix = ruins.DESATURATION;
-
     const bp = BLUEPRINTS.peek();
-    const futureOn = bp.ENABLED;
-    const futureBuildingOpacity = bp.BUILDING_OPACITY;
-    const futureHeight = FUTURE_SLAB_FLOORS * floorHeight;
-    const futureTint = bp.BUILDING_TINT;
     _futureColor.set(bp.BUILDING_COLOR);
 
     // Backend-replayed date ranges over the present set, like heights use
     // commitLineRanges. At HEAD the present set == live, so weathering matches.
     const dateRange = _dateRanges[Math.min(Math.floor(pos), _dateRanges.length - 1)];
     const minMod = dateRange?.minModified ?? 0;
-    const maxMod = dateRange?.maxModified ?? 0;
     const minCreated = dateRange?.minCreated ?? 0;
-    const maxCreated = dateRange?.maxCreated ?? 0;
-    // Spread 0 (all present files share a date) → the live view's getSaturation/
-    // getModifiedAge treat that as freshest (recency 1); createdAge as newest (0).
-    const modSpread = maxMod - minMod;
-    const createdSpread = maxCreated - minCreated;
-
-    // Neighborhood fade cascade — the SAME tier decision buildingFader uses in
-    // Live, so a hover/selection dims the surrounding city identically while
-    // scrubbing. The fader is dormant in Timeline (it owns iFade in Live; the
-    // scrub controller owns it here), so this is where the cascade gets applied.
+
+    // The SAME tier decision buildingFader uses in Live, so a hover/selection
+    // dims the surrounding city identically while scrubbing. The fader is
+    // dormant in Timeline (it owns iFade in Live; this controller owns it here).
     const sel = deps.picker.selection.peek();
     const hov = deps.picker.hover.peek();
-    const bldgTargetFile = sel?.kind === NodeKind.File ? sel.file : null;
-    const dirTarget = resolveDirTarget(sel, hov, deps.streetsByDir);
-    const hoverFile = hov?.kind === NodeKind.File ? hov.file : null;
-    const fadeCfg = BUILDINGS.peek();
-
-    for (const { b, pt, streets, createdIdx, finalIdx } of entries) {
-      const state = ruinStateAt(pt, pos);
-      const present = state === 'present';
-      const ruin = state === 'ruin' && ruinsOn;
-      // Future: not yet created at this scrub position (genesis is ahead). Shown
-      // as an ultra-low tinted slab at its eventual footprint — a marker of where
-      // it WILL land, rendered via the building mesh (not the footprint plots).
-      const future = !present && !ruin && futureOn && createdIdx > pos;
-      // present → fully present; ruin → faint stub; future → faint slab;
-      // before-genesis (out of range) or ruins-off deletion → gone.
-      const op = present
-        ? presenceAt(pt, pos, 0)
-        : ruin
-          ? ruinBuildingOpacity
-          : future
-            ? futureBuildingOpacity
-            : 0;
 
-      // Neighborhood fade cascade for PRESENT buildings: dim / silhouette /
-      // outline this building by its dir-tree distance from the hover/selection
-      // target, exactly as Live's fader does (op is 1 for a present file, so
-      // op * tier.bodyOpacity reproduces the Live absolute). Non-present states
-      // (ruin/future/absent) keep their own faint opacity, no cascade.
-      let bodyOp = op;
-      let silhouette = 0;
-      let tierOutlineOp = 0;
-      if (present) {
-        const tier = tierFor(b.file, bldgTargetFile, dirTarget, hoverFile, fadeCfg);
-        bodyOp = tier.detail === FadeDetail.Hidden ? 0 : op * tier.bodyOpacity;
-        silhouette = tier.detail === FadeDetail.Silhouette ? 1 : 0;
-        tierOutlineOp = tier.outlineEnabled ? tier.outlineOpacity : 0;
-      }
+    return {
+      pos,
+      lineStats: r && (r.min > 0 || r.max > 0) ? r : { min: 1, max: 1 },
+      ruinsOn: ruins.ENABLED,
+      ruinBuildingOpacity: ruins.BUILDING_OPACITY,
+      ruinHeight: ruins.STUB_HEIGHT * floorHeight,
+      ruinGrayMix: ruins.DESATURATION,
+      futureOn: bp.ENABLED,
+      futureBuildingOpacity: bp.BUILDING_OPACITY,
+      futureHeight: FUTURE_SLAB_FLOORS * floorHeight,
+      futureTint: bp.BUILDING_TINT,
+      minMod,
+      minCreated,
+      // Spread 0 (all present files share a date) → the live view's
+      // getSaturation/getModifiedAge treat that as freshest (recency 1);
+      // createdAge as newest (0).
+      modSpread: (dateRange?.maxModified ?? 0) - minMod,
+      createdSpread: (dateRange?.maxCreated ?? 0) - minCreated,
+      bldgTargetFile: sel?.kind === NodeKind.File ? sel.file : null,
+      dirTarget: resolveDirTarget(sel, hov, deps.streetsByDir),
+      hoverFile: hov?.kind === NodeKind.File ? hov.file : null,
+      fadeCfg: BUILDINGS.peek(),
+    };
+  }
+
+  // What one pass over the buildings accumulates: the GPU attributes that need
+  // re-upload, and the per-street rollup the street pass then consumes.
+  interface ScrubSinks {
+    meshes: Set<THREE.InstancedMesh>;
+    fades: Set<THREE.BufferAttribute>;
+    colors: Set<THREE.InstancedMesh>;
+    floors: Set<THREE.BufferAttribute>;
+    modifiedAges: Set<THREE.BufferAttribute>;
+    iconUVs: Set<THREE.BufferAttribute>;
+    kinds: Set<THREE.BufferAttribute>;
+    // A street fades with its PRESENT descendants; a ruin-only or future-only
+    // street renders fully opaque, set apart by color instead of fading.
+    maxPresentOp: Map<Street, number>;
+    ruinStreets: Set<Street>;
+    presentStreets: Set<Street>;
+    // Ad-panel opacity by path: the building's op when present, else 0 (a ruin
+    // or absent building shows no media image). Feeds applyBuildingFades only.
+    opByPath: Map<string, number>;
+  }
+
+  function createSinks(): ScrubSinks {
+    return {
+      meshes: new Set(),
+      fades: new Set(),
+      colors: new Set(),
+      floors: new Set(),
+      modifiedAges: new Set(),
+      iconUVs: new Set(),
+      kinds: new Set(),
+      maxPresentOp: new Map(),
+      ruinStreets: new Set(),
+      presentStreets: new Set(),
+      opByPath: new Map(),
+    };
+  }
 
-      // Driven for EVERY union building (even one with no detail mesh on a large
-      // repo), else the footprint/street strand at their defaults. A street's
-      // future state isn't tracked per-building: any non-present, non-ruin street
-      // is a future road (see the final loop), so the whole road network shows.
-      for (const street of streets) {
-        if (present) {
-          maxPresentOp.set(street, Math.max(maxPresentOp.get(street) ?? 0, op));
-          presentStreets.add(street);
-        } else if (ruin) {
-          ruinStreets.add(street);
-        }
+  function flushSinks(s: ScrubSinks): void {
+    for (const mesh of s.meshes) mesh.instanceMatrix.needsUpdate = true;
+    for (const iFade of s.fades) iFade.needsUpdate = true;
+    for (const mesh of s.colors) {
+      if (mesh.instanceColor) mesh.instanceColor.needsUpdate = true;
+    }
+    for (const attr of s.floors) attr.needsUpdate = true;
+    for (const attr of s.modifiedAges) attr.needsUpdate = true;
+    for (const attr of s.iconUVs) attr.needsUpdate = true;
+    for (const attr of s.kinds) attr.needsUpdate = true;
+  }
+
+  /** Height + matrix for one building, by scrub state. Writes iFloors too,
+   *  since a ruin and a future slab both blank their window rows. */
+  function writeBuildingShape(
+    b: Building,
+    slot: number,
+    iFloorsAttr: THREE.BufferAttribute | undefined,
+    present: boolean,
+    ruin: boolean,
+    future: boolean,
+    scrubFile: FileNode,
+    createdAge: number,
+    f: ScrubFrame,
+    s: ScrubSinks
+  ): void {
+    if (present) {
+      // Gate height on presence (intervals), not line count: media/empty files are present with 0 lines.
+      // Height uses lineStats (this commit's range); width stays layout-baked (b.w), so dims.w is unused.
+      const dims = getBuildingDimensions(scrubFile, f.lineStats, deps.heightCtx.byteStats);
+      if (iFloorsAttr) {
+        iFloorsAttr.setX(slot, dims.floors);
+        s.floors.add(iFloorsAttr);
       }
-      // opByPath feeds ONLY the facade panels — gate on presence so a ruin/absent/
-      // future building shows no media image, just its stub or slab. Uses the
-      // neighborhood-dimmed bodyOp so a media panel fades with its building body.
-      opByPath.set(b.file.path, present ? bodyOp : 0);
-      // Footprint plot: present + ruin only. A future building IS the slab, so it
-      // gets no plot (keeps future independent of the footprint controls).
-      deps.footprints.setBuildingFootprintOpacity(b.file.path, future ? 0 : op, ruin);
-
-      const resolved = deps.getMeshForBuilding(b);
-      if (!resolved) continue;
-      const { mesh, slot } = resolved;
-
-      // createdAge (0=newest, 1=oldest) is scrub-relative here — needed for both
-      // the lean shear (below) and the window/grime weathering (iIconUV.w later).
-      const createdMs = createdMsFor(b, createdIdx);
-      const createdAge =
-        present && createdSpread > 0
-          ? 1 - Math.max(0, Math.min(1, (createdMs - minCreated) / createdSpread))
-          : 0;
+      // Bake the age-lean shear into the matrix so the picker + outline follow it.
+      const { tiltX, tiltZ } = getBuildingTiltAtAge(b.file.path, createdAge);
+      _pos.set(b.x, dims.h / 2, b.y);
+      _scale.set(b.w, dims.h, b.d);
+      composeShearMatrix(_pos, _scale, tiltX, tiltZ, _m);
+    } else if (ruin) {
+      // A deleted building: uniform low stub, blank facade (0 window rows) — reads as rubble.
+      if (iFloorsAttr) {
+        iFloorsAttr.setX(slot, 0);
+        s.floors.add(iFloorsAttr);
+      }
+      _m.makeScale(b.w, f.ruinHeight, b.d);
+      _m.setPosition(b.x, f.ruinHeight / 2, b.y);
+    } else if (future) {
+      // A future building: ultra-low slab at its real footprint, blank facade.
+      if (iFloorsAttr) {
+        iFloorsAttr.setX(slot, 0);
+        s.floors.add(iFloorsAttr);
+      }
+      _m.makeScale(b.w, f.futureHeight, b.d);
+      _m.setPosition(b.x, f.futureHeight / 2, b.y);
+    } else {
+      // Absent → fully zero-scaled, not a flat (w, 0, d) quad that would still
+      // write depth and outline as a cutout on the road.
+      _m.makeScale(0, 0, 0);
+    }
+  }
 
-      const iFloorsAttr = mesh.geometry.getAttribute('iFloors') as
+  /** Color / lit-windows / grime-age from the file's DATES at this scrub
+   *  position (not a commit-index proxy), normalized against the present-file
+   *  ranges — the exact formulas the live view bakes, so HEAD matches. Absent
+   *  buildings are already scaled/faded to 0, so they are skipped. */
+  function writeBuildingWeathering(
+    b: Building,
+    pt: PathTimeline,
+    mesh: THREE.InstancedMesh,
+    slot: number,
+    finalIdx: number,
+    present: boolean,
+    ruin: boolean,
+    future: boolean,
+    createdAge: number,
+    f: ScrubFrame,
+    s: ScrubSinks
+  ): void {
+    if (present) {
+      // recency = modified-date t (0=oldest, 1=newest) → getBuildingColor's curve.
+      const modMs = modifiedMsAt(b, pt, finalIdx, f.pos);
+      const recency =
+        f.modSpread > 0 ? Math.max(0, Math.min(1, (modMs - f.minMod) / f.modSpread)) : 1;
+      _color.set(
+        getBuildingColorForRecency(
+          b.file as unknown as Parameters<typeof getBuildingColorForRecency>[0],
+          recency
+        )
+      );
+      mesh.setColorAt(slot, _color);
+      s.colors.add(mesh);
+
+      // getModifiedAge polarity: 0=most recent, 1=longest-untouched.
+      const iModifiedAgeAttr = mesh.geometry.getAttribute('iModifiedAge') as
         | THREE.BufferAttribute
         | undefined;
-      // Height tweens, so it takes the interpolated count. The union node's
-      // `size` is a max-over-history footprint, so only the replay can say what
-      // this file measured HERE.
-      const scrubFile = present ? { ...b.file, lines: linesAt(pt, pos) } : b.file;
-      // Emptiness is a fact about the blob in effect, not a point on a curve:
-      // between a 0-line commit and a later big one, a lerp reads non-empty.
-      const emptyFile = present ? { ...b.file, lines: entryAt(pt, pos)?.lines ?? 0 } : b.file;
-      if (present) {
-        // Gate height on presence (intervals), not line count: media/empty files are present with 0 lines.
-        // Height uses lineStats (this commit's range); width stays layout-baked (b.w), so dims.w is unused.
-        const dims = getBuildingDimensions(scrubFile, lineStats, deps.heightCtx.byteStats);
-        if (iFloorsAttr) {
-          iFloorsAttr.setX(slot, dims.floors);
-          dirtyFloors.add(iFloorsAttr);
-        }
-        // Bake the age-lean shear into the matrix so the picker + outline follow it.
-        const { tiltX, tiltZ } = getBuildingTiltAtAge(b.file.path, createdAge);
-        _pos.set(b.x, dims.h / 2, b.y);
-        _scale.set(b.w, dims.h, b.d);
-        composeShearMatrix(_pos, _scale, tiltX, tiltZ, _m);
-      } else if (ruin) {
-        // A deleted building: uniform low stub, blank facade (0 window rows) — reads as rubble.
-        if (iFloorsAttr) {
-          iFloorsAttr.setX(slot, 0);
-          dirtyFloors.add(iFloorsAttr);
-        }
-        _m.makeScale(b.w, ruinHeight, b.d);
-        _m.setPosition(b.x, ruinHeight / 2, b.y);
-      } else if (future) {
-        // A future building: ultra-low slab at its real footprint, blank facade.
-        if (iFloorsAttr) {
-          iFloorsAttr.setX(slot, 0);
-          dirtyFloors.add(iFloorsAttr);
-        }
-        _m.makeScale(b.w, futureHeight, b.d);
-        _m.setPosition(b.x, futureHeight / 2, b.y);
-      } else {
-        // Absent → fully zero-scaled, not a flat (w, 0, d) quad that would still
-        // write depth and outline as a cutout on the road.
-        _m.makeScale(0, 0, 0);
-      }
-      mesh.setMatrixAt(slot, _m);
-      dirtyMeshes.add(mesh);
-
-      // iKind render mode, rewritten every frame so a state change resets it:
-      // Ruin/Future for scrub states, else Empty for a file with no content at
-      // this position, else Data for a present binary, else Normal.
-      const iKindAttr = mesh.geometry.getAttribute('iKind') as THREE.BufferAttribute | undefined;
-      if (iKindAttr) {
-        let kind: number = BuildingKind.Normal;
-        if (ruin) kind = BuildingKind.Ruin;
-        else if (future) kind = BuildingKind.Future;
-        else if (isEmptyFile(emptyFile)) kind = BuildingKind.Empty;
-        else if (isDataBuilding(b.file)) kind = BuildingKind.Data;
-        iKindAttr.setX(slot, kind);
-        dirtyKinds.add(iKindAttr);
+      if (iModifiedAgeAttr) {
+        iModifiedAgeAttr.setX(slot, 1 - recency);
+        s.modifiedAges.add(iModifiedAgeAttr);
       }
 
-      const iFade = mesh.geometry.getAttribute('iFade') as THREE.BufferAttribute | undefined;
-      if (iFade) {
-        // Present → neighborhood-tiered body(.x)/silhouette(.y)/outline(.z), owning
-        // all three so a hover cascade actually shows. Non-present → its faint op
-        // with no silhouette/outline, so a leftover Live-mode overlay can't linger.
-        if (present) iFade.setXYZ(slot, bodyOp, silhouette, tierOutlineOp);
-        else iFade.setXYZ(slot, op, 0, 0);
-        dirtyFades.add(iFade);
+      // createdAge drives grime/weathering: 0=newest, 1=oldest.
+      const iIconUVAttr = mesh.geometry.getAttribute('iIconUV') as
+        | THREE.BufferAttribute
+        | undefined;
+      if (iIconUVAttr) {
+        iIconUVAttr.setW(slot, createdAge);
+        s.iconUVs.add(iIconUVAttr);
       }
-
-      // Weather: color / lit-windows / grime-age from the file's DATES at this
-      // scrub position (not a commit-index proxy), normalized against the
-      // present-file ranges — the exact formulas the live view bakes, so HEAD
-      // matches. Absent buildings are already scaled/faded to 0, so skip them.
-      if (present) {
-        // recency = modified-date t (0=oldest, 1=newest) → getBuildingColor's curve.
-        const modMs = modifiedMsAt(b, pt, finalIdx, pos);
-        const recency = modSpread > 0 ? Math.max(0, Math.min(1, (modMs - minMod) / modSpread)) : 1;
-        _color.set(
+    } else if (ruin) {
+      // A ghost ruin keeps a muted memory of its file's hue, pulled toward gray.
+      _color
+        .set(
           getBuildingColorForRecency(
             b.file as unknown as Parameters<typeof getBuildingColorForRecency>[0],
-            recency
+            RUIN_BASE_RECENCY
           )
-        );
-        mesh.setColorAt(slot, _color);
-        dirtyColors.add(mesh);
-
-        // getModifiedAge polarity: 0=most recent, 1=longest-untouched.
-        const iModifiedAgeAttr = mesh.geometry.getAttribute('iModifiedAge') as
-          | THREE.BufferAttribute
-          | undefined;
-        if (iModifiedAgeAttr) {
-          iModifiedAgeAttr.setX(slot, 1 - recency);
-          dirtyModifiedAges.add(iModifiedAgeAttr);
-        }
-
-        // createdAge (hoisted above) drives grime/weathering: 0=newest, 1=oldest.
-        const iIconUVAttr = mesh.geometry.getAttribute('iIconUV') as
-          | THREE.BufferAttribute
-          | undefined;
-        if (iIconUVAttr) {
-          iIconUVAttr.setW(slot, createdAge);
-          dirtyIconUVs.add(iIconUVAttr);
-        }
-      } else if (ruin) {
-        // A ghost ruin keeps a muted memory of its file's hue, pulled toward gray.
-        _color
-          .set(
-            getBuildingColorForRecency(
-              b.file as unknown as Parameters<typeof getBuildingColorForRecency>[0],
-              RUIN_BASE_RECENCY
-            )
-          )
-          .lerp(_RUIN_GRAY, ruinGrayMix);
-        mesh.setColorAt(slot, _color);
-        dirtyColors.add(mesh);
-      } else if (future) {
-        // A future slab keeps its file's own hue, pulled toward the future color.
-        _color
-          .set(
-            getBuildingColorForRecency(
-              b.file as unknown as Parameters<typeof getBuildingColorForRecency>[0],
-              FUTURE_BASE_RECENCY
-            )
+        )
+        .lerp(_RUIN_GRAY, f.ruinGrayMix);
+      mesh.setColorAt(slot, _color);
+      s.colors.add(mesh);
+    } else if (future) {
+      // A future slab keeps its file's own hue, pulled toward the future color.
+      _color
+        .set(
+          getBuildingColorForRecency(
+            b.file as unknown as Parameters<typeof getBuildingColorForRecency>[0],
+            FUTURE_BASE_RECENCY
           )
-          .lerp(_futureColor, futureTint);
-        mesh.setColorAt(slot, _color);
-        dirtyColors.add(mesh);
+        )
+        .lerp(_futureColor, f.futureTint);
+      mesh.setColorAt(slot, _color);
+      s.colors.add(mesh);
+    }
+  }
+
+  // Reused scratch: this resolves once per building per frame, so returning a
+  // fresh object would allocate tens of thousands of times a frame.
+  const _scrubState = { present: false, ruin: false, future: false, op: 0 };
+
+  function resolveScrubState(
+    pt: PathTimeline,
+    createdIdx: number,
+    f: ScrubFrame
+  ): typeof _scrubState {
+    const state = ruinStateAt(pt, f.pos);
+    const present = state === 'present';
+    const ruin = state === 'ruin' && f.ruinsOn;
+    // Future: not yet created at this scrub position (genesis is ahead). Shown
+    // as an ultra-low tinted slab at its eventual footprint — a marker of where
+    // it WILL land, rendered via the building mesh (not the footprint plots).
+    const future = !present && !ruin && f.futureOn && createdIdx > f.pos;
+    _scrubState.present = present;
+    _scrubState.ruin = ruin;
+    _scrubState.future = future;
+    // present → fully present; ruin → faint stub; future → faint slab;
+    // before-genesis (out of range) or ruins-off deletion → gone.
+    _scrubState.op = present
+      ? presenceAt(pt, f.pos, 0)
+      : ruin
+        ? f.ruinBuildingOpacity
+        : future
+          ? f.futureBuildingOpacity
+          : 0;
+    return _scrubState;
+  }
+
+  /** iKind render mode, recomputed every frame so a state change resets it:
+   *  Ruin/Future for scrub states, else Empty for a file with no content at this
+   *  position, else Data for a binary, else Normal. */
+  function resolveBuildingKind(
+    file: FileNode,
+    emptyFile: FileNode,
+    ruin: boolean,
+    future: boolean
+  ): number {
+    if (ruin) return BuildingKind.Ruin;
+    if (future) return BuildingKind.Future;
+    if (isEmptyFile(emptyFile)) return BuildingKind.Empty;
+    if (isDataBuilding(file)) return BuildingKind.Data;
+    return BuildingKind.Normal;
+  }
+
+  function applyBuildingAtScrub(
+    entry: (typeof entries)[number],
+    f: ScrubFrame,
+    s: ScrubSinks
+  ): void {
+    const { b, pt, streets, createdIdx, finalIdx } = entry;
+    const pos = f.pos;
+    const { present, ruin, future, op } = resolveScrubState(pt, createdIdx, f);
+
+    // Neighborhood fade cascade for PRESENT buildings: dim / silhouette /
+    // outline this building by its dir-tree distance from the hover/selection
+    // target, exactly as Live's fader does (op is 1 for a present file, so
+    // op * tier.bodyOpacity reproduces the Live absolute). Non-present states
+    // (ruin/future/absent) keep their own faint opacity, no cascade.
+    let bodyOp = op;
+    let silhouette = 0;
+    let tierOutlineOp = 0;
+    if (present) {
+      const tier = tierFor(b.file, f.bldgTargetFile, f.dirTarget, f.hoverFile, f.fadeCfg);
+      bodyOp = tier.detail === FadeDetail.Hidden ? 0 : op * tier.bodyOpacity;
+      silhouette = tier.detail === FadeDetail.Silhouette ? 1 : 0;
+      tierOutlineOp = tier.outlineEnabled ? tier.outlineOpacity : 0;
+    }
+
+    // Driven for EVERY union building (even one with no detail mesh on a large
+    // repo), else the footprint/street strand at their defaults. A street's
+    // future state isn't tracked per-building: any non-present, non-ruin street
+    // is a future road (see applyStreetsAtScrub), so the whole road network shows.
+    for (const street of streets) {
+      if (present) {
+        s.maxPresentOp.set(street, Math.max(s.maxPresentOp.get(street) ?? 0, op));
+        s.presentStreets.add(street);
+      } else if (ruin) {
+        s.ruinStreets.add(street);
       }
     }
+    // opByPath feeds ONLY the facade panels — gate on presence so a ruin/absent/
+    // future building shows no media image, just its stub or slab. Uses the
+    // neighborhood-dimmed bodyOp so a media panel fades with its building body.
+    s.opByPath.set(b.file.path, present ? bodyOp : 0);
+    // Footprint plot: present + ruin only. A future building IS the slab, so it
+    // gets no plot (keeps future independent of the footprint controls).
+    deps.footprints.setBuildingFootprintOpacity(b.file.path, future ? 0 : op, ruin);
 
-    for (const mesh of dirtyMeshes) mesh.instanceMatrix.needsUpdate = true;
-    for (const iFade of dirtyFades) iFade.needsUpdate = true;
-    for (const mesh of dirtyColors) {
-      if (mesh.instanceColor) mesh.instanceColor.needsUpdate = true;
+    const resolved = deps.getMeshForBuilding(b);
+    if (!resolved) return;
+    const { mesh, slot } = resolved;
+
+    // createdAge (0=newest, 1=oldest) is scrub-relative here — needed for both
+    // the lean shear and the window/grime weathering (iIconUV.w).
+    const createdMs = createdMsFor(b, createdIdx);
+    const createdAge =
+      present && f.createdSpread > 0
+        ? 1 - Math.max(0, Math.min(1, (createdMs - f.minCreated) / f.createdSpread))
+        : 0;
+
+    const iFloorsAttr = mesh.geometry.getAttribute('iFloors') as THREE.BufferAttribute | undefined;
+    // Height tweens, so it takes the interpolated count. The union node's
+    // `size` is a max-over-history footprint, so only the replay can say what
+    // this file measured HERE.
+    const scrubFile = present ? { ...b.file, lines: linesAt(pt, pos) } : b.file;
+    // Emptiness is a fact about the blob in effect, not a point on a curve:
+    // between a 0-line commit and a later big one, a lerp reads non-empty.
+    const emptyFile = present ? { ...b.file, lines: entryAt(pt, pos)?.lines ?? 0 } : b.file;
+
+    writeBuildingShape(b, slot, iFloorsAttr, present, ruin, future, scrubFile, createdAge, f, s);
+    mesh.setMatrixAt(slot, _m);
+    s.meshes.add(mesh);
+
+    const iKindAttr = mesh.geometry.getAttribute('iKind') as THREE.BufferAttribute | undefined;
+    if (iKindAttr) {
+      iKindAttr.setX(slot, resolveBuildingKind(b.file, emptyFile, ruin, future));
+      s.kinds.add(iKindAttr);
     }
-    for (const attr of dirtyFloors) attr.needsUpdate = true;
-    for (const attr of dirtyModifiedAges) attr.needsUpdate = true;
-    for (const attr of dirtyIconUVs) attr.needsUpdate = true;
-    for (const attr of dirtyKinds) attr.needsUpdate = true;
-    // ?? 0 (not null): a panel the scrub never drives must HIDE, not linger at
-    // its shown default — mirrors the footprint default-hidden fix. (Live-mode
-    // buildingFader still uses null = "leave untouched".)
-    deps.getFacadePanels()?.applyBuildingFades((p) => opByPath.get(p) ?? 0);
+
+    const iFade = mesh.geometry.getAttribute('iFade') as THREE.BufferAttribute | undefined;
+    if (iFade) {
+      // Present → neighborhood-tiered body(.x)/silhouette(.y)/outline(.z), owning
+      // all three so a hover cascade actually shows. Non-present → its faint op
+      // with no silhouette/outline, so a leftover Live-mode overlay can't linger.
+      if (present) iFade.setXYZ(slot, bodyOp, silhouette, tierOutlineOp);
+      else iFade.setXYZ(slot, op, 0, 0);
+      s.fades.add(iFade);
+    }
+
+    writeBuildingWeathering(b, pt, mesh, slot, finalIdx, present, ruin, future, createdAge, f, s);
+  }
+
+  function applyStreetsAtScrub(f: ScrubFrame, s: ScrubSinks): void {
     // Every street gets written each frame (defaulting to 0) so an orphaned street can't stick at a stale opacity.
     // ROOT is forced to 1: the repo root directory always exists, even when scrubbed back to an empty tree.
     for (const street of allStreets) {
-      const hasPresent = presentStreets.has(street);
+      const hasPresent = s.presentStreets.has(street);
       // Present descendants fade the road with the buildings; else a deleted-folder
       // road is a ruin, and any remaining non-root road is future (a folder not yet
       // created at this scrub position). Ruin + future roads render fully opaque,
       // set apart by their color, not by fading. Present wins over ruin over future.
-      const streetRuin = ruinsOn && !street.isRoot && !hasPresent && ruinStreets.has(street);
-      const streetFuture = futureOn && !street.isRoot && !hasPresent && !streetRuin;
+      const streetRuin = f.ruinsOn && !street.isRoot && !hasPresent && s.ruinStreets.has(street);
+      const streetFuture = f.futureOn && !street.isRoot && !hasPresent && !streetRuin;
       const op = street.isRoot
         ? 1
         : hasPresent
-          ? (maxPresentOp.get(street) ?? 0)
+          ? (s.maxPresentOp.get(street) ?? 0)
           : streetRuin || streetFuture
             ? 1
             : 0;
@@ -459,6 +566,27 @@ export function createScrubController(deps: ScrubControllerDeps) {
     }
   }
 
+  function update(): void {
+    const pos = SCRUB_POS.peek();
+    deps.trees.setScrubCommit(Math.floor(pos));
+    deps.fireflies.setScrubCommit(Math.floor(pos));
+
+    RUINED_STREET_DIRS.clear();
+    FUTURE_STREET_DIRS.clear();
+
+    const frame = readScrubFrame(pos);
+    const sinks = createSinks();
+
+    for (const entry of entries) applyBuildingAtScrub(entry, frame, sinks);
+
+    flushSinks(sinks);
+    // ?? 0 (not null): a panel the scrub never drives must HIDE, not linger at
+    // its shown default — mirrors the footprint default-hidden fix. (Live-mode
+    // buildingFader still uses null = "leave untouched".)
+    deps.getFacadePanels()?.applyBuildingFades((p) => sinks.opByPath.get(p) ?? 0);
+    applyStreetsAtScrub(frame, sinks);
+  }
+
   function dispose(): void {
     entries.length = 0;
     RUINED_STREET_DIRS.clear();
diff --git a/app/src/city/utils/color/colors.ts b/app/src/city/utils/color/colors.ts
index 928b0c06d..7a1c3d5e5 100644
--- a/app/src/city/utils/color/colors.ts
+++ b/app/src/city/utils/color/colors.ts
@@ -84,7 +84,7 @@ export function shadeByRatio(
 
 /** Linear sRGB → OKLab (Cartesian). Out-parameter for allocation-free use
  *  in per-frame / per-instance hot paths (e.g. treeRenderer color ramps). */
-export function linearToOklab(
+function linearToOklab(
   r: number,
   g: number,
   b: number,
@@ -104,7 +104,7 @@ export function linearToOklab(
 /** OKLab (Cartesian) → linear sRGB. Out-parameter; result is NOT clamped
  *  to [0, 1] — out-of-gamut highly-saturated OKLab triplets can produce
  *  negative or >1 channels and the caller decides what to do. */
-export function oklabToLinear(
+function oklabToLinear(
   L: number,
   a: number,
   b: number,
diff --git a/app/src/components/HljsThemeLink/HljsThemeLink.tsx b/app/src/components/HljsThemeLink/HljsThemeLink.tsx
index cf3d1ffe6..f9d3ae7d5 100644
--- a/app/src/components/HljsThemeLink/HljsThemeLink.tsx
+++ b/app/src/components/HljsThemeLink/HljsThemeLink.tsx
@@ -3,14 +3,75 @@
 // document.head via Preact's createPortal so the syntax-highlighting CSS
 // follows the SYNTAX_THEME signal automatically — no module-load effect,
 // no manual <link> element management.
+//
+// Bundled same-origin rather than fetched from a CDN: remote CSS leaks the
+// viewer's IP and theme choice, breaks offline use, and can exfiltrate via
+// attribute-selector url(). `?url` keeps each theme a separate asset, so only
+// the selected one is fetched.
 
 import './HljsThemeLink.css';
 import { createPortal } from 'preact/compat';
-import { SYNTAX_THEME } from '@/state/stores/settings/syntaxTheme';
+import {
+  SYNTAX_THEME,
+  SYNTAX_THEME_DEFAULT,
+  type SyntaxThemeValue,
+} from '@/state/stores/settings/syntaxTheme';
 
-const HLJS_VERSION = '11.11.1';
+import a11yDark from 'highlight.js/styles/a11y-dark.min.css?url';
+import agate from 'highlight.js/styles/agate.min.css?url';
+import androidstudio from 'highlight.js/styles/androidstudio.min.css?url';
+import atomOneDark from 'highlight.js/styles/atom-one-dark.min.css?url';
+import cybertopiaCherry from 'highlight.js/styles/cybertopia-cherry.min.css?url';
+import cybertopiaIcecap from 'highlight.js/styles/cybertopia-icecap.min.css?url';
+import dracula from 'highlight.js/styles/base16/dracula.min.css?url';
+import githubDark from 'highlight.js/styles/github-dark.min.css?url';
+import irBlack from 'highlight.js/styles/ir-black.min.css?url';
+import monokai from 'highlight.js/styles/monokai.min.css?url';
+import monokaiSublime from 'highlight.js/styles/monokai-sublime.min.css?url';
+import nightOwl from 'highlight.js/styles/night-owl.min.css?url';
+import nord from 'highlight.js/styles/nord.min.css?url';
+import obsidian from 'highlight.js/styles/obsidian.min.css?url';
+import rosePine from 'highlight.js/styles/rose-pine.min.css?url';
+import rosePineMoon from 'highlight.js/styles/rose-pine-moon.min.css?url';
+import shadesOfPurple from 'highlight.js/styles/shades-of-purple.min.css?url';
+import solarizedDark from 'highlight.js/styles/base16/solarized-dark.min.css?url';
+import stackoverflowDark from 'highlight.js/styles/stackoverflow-dark.min.css?url';
+import tokyoNightDark from 'highlight.js/styles/tokyo-night-dark.min.css?url';
+import vs2015 from 'highlight.js/styles/vs2015.min.css?url';
+
+// Keyed on SyntaxThemeValue, so adding an option without its stylesheet is a
+// typecheck failure rather than a silently unstyled pane.
+export const THEME_HREF: Record<SyntaxThemeValue, string> = {
+  'a11y-dark': a11yDark,
+  agate,
+  androidstudio,
+  'atom-one-dark': atomOneDark,
+  'cybertopia-cherry': cybertopiaCherry,
+  'cybertopia-icecap': cybertopiaIcecap,
+  'base16/dracula': dracula,
+  'github-dark': githubDark,
+  'ir-black': irBlack,
+  monokai,
+  'monokai-sublime': monokaiSublime,
+  'night-owl': nightOwl,
+  nord,
+  obsidian,
+  'rose-pine': rosePine,
+  'rose-pine-moon': rosePineMoon,
+  'shades-of-purple': shadesOfPurple,
+  'base16/solarized-dark': solarizedDark,
+  'stackoverflow-dark': stackoverflowDark,
+  'tokyo-night-dark': tokyoNightDark,
+  vs2015,
+};
+
+export function hrefForTheme(theme: string): string {
+  return THEME_HREF[theme as SyntaxThemeValue] ?? THEME_HREF[SYNTAX_THEME_DEFAULT];
+}
 
 export function HljsThemeLink() {
-  const href = `https://cdn.jsdelivr.net/npm/highlight.js@${HLJS_VERSION}/styles/${SYNTAX_THEME.value}.min.css`;
-  return createPortal(<link id="hljs-theme" rel="stylesheet" href={href} />, document.head);
+  return createPortal(
+    <link id="hljs-theme" rel="stylesheet" href={hrefForTheme(SYNTAX_THEME.value)} />,
+    document.head
+  );
 }
diff --git a/app/src/components/LoadingProgress/LoadingProgress.tsx b/app/src/components/LoadingProgress/LoadingProgress.tsx
index a7e186fc4..08ed0509b 100644
--- a/app/src/components/LoadingProgress/LoadingProgress.tsx
+++ b/app/src/components/LoadingProgress/LoadingProgress.tsx
@@ -5,7 +5,7 @@
 // state mapping has exactly one definition and the two surfaces never drift.
 
 import './LoadingProgress.css';
-import { PENDING_SOURCE_LABEL } from '@/state/stores/source';
+
 import { SourceKind } from '@/utils/sources';
 import {
   LoadingStep,
@@ -13,6 +13,7 @@ import {
   LOADING_STEPS,
   LOADING_STEP_LABELS,
 } from '@/constants/loadingSteps';
+import { PENDING_SOURCE_LABEL } from '@/state/stores/ui';
 
 export interface LoadingProgressProps {
   activeStep: LoadingStep;
diff --git a/app/src/components/PathBreadcrumbs/PathBreadcrumbs.css b/app/src/components/PathBreadcrumbs/PathBreadcrumbs.css
index f57bbcd34..6849cc059 100644
--- a/app/src/components/PathBreadcrumbs/PathBreadcrumbs.css
+++ b/app/src/components/PathBreadcrumbs/PathBreadcrumbs.css
@@ -12,12 +12,9 @@
   text-overflow: ellipsis;
 }
 
-/* Shell + hover in .btn-icon. Per-class overrides: smaller padding,
-   inherited font, muted color, and the Electron drag-region marker.
-   The leaf modifier disables interactivity (last crumb = current). */
-/* Visual style in .btn-icon + .btn-icon--text + .btn-icon--no-drag.
-   Leaf-state behavior moved to .is-leaf modifier (used by breadcrumb
-   leaf segment + file-path-segment leaf). */
+/* Visual style in .btn-icon + .btn-icon--text + .btn-icon--no-drag: smaller
+   padding, inherited font, muted color, and the Electron drag-region marker.
+   .is-leaf disables interactivity, since the last crumb is the current node. */
 .btn-icon.is-leaf {
   color: var(--cc-text-strong);
   cursor: default;
diff --git a/app/src/components/TimeTravelBar/TimeTravelBar.tsx b/app/src/components/TimeTravelBar/TimeTravelBar.tsx
index bb8c99641..7a84771a5 100644
--- a/app/src/components/TimeTravelBar/TimeTravelBar.tsx
+++ b/app/src/components/TimeTravelBar/TimeTravelBar.tsx
@@ -6,7 +6,14 @@
 
 import './TimeTravelBar.css';
 import { useEffect, useMemo, useRef } from 'preact/hooks';
-import { TIMELINE_MODE, SCRUB_POS, TIMELINE_BUNDLE, SCRUB_DRAGGING } from '@/state/stores/timeline';
+import {
+  TIMELINE_MODE,
+  SCRUB_POS,
+  SCRUB_MAX,
+  TIMELINE_BUNDLE,
+  SCRUB_DRAGGING,
+  setScrubPos,
+} from '@/state/stores/timeline';
 import { ACCENT_THEME } from '@/state/stores/settings/theme';
 import { SCRUBBER } from '@/state/stores/settings/scrubber';
 import { formatShortDate } from '@/utils/dates';
@@ -20,8 +27,7 @@ import {
 } from './scrubberScale';
 
 export function TimeTravelBar() {
-  if (!TIMELINE_MODE.value) return null;
-
+  const inTimeline = TIMELINE_MODE.value;
   const bundle = TIMELINE_BUNDLE.value;
   const commits = bundle?.commits ?? [];
 
@@ -39,12 +45,15 @@ export function TimeTravelBar() {
   const trackRef = useRef<HTMLDivElement>(null);
   const canvasRef = useRef<HTMLCanvasElement>(null);
 
-  const maxIndex = Math.max(0, commits.length - 1);
-  const pos = Math.min(Math.max(SCRUB_POS.value, 0), maxIndex);
+  const maxIndex = SCRUB_MAX.value;
+  const pos = SCRUB_POS.value;
   // A single-commit repo has no history to scrub: the handle pins to the present
   // (right edge, via the scale) and the track is inert rather than grab-and-freeze.
   const inert = maxIndex === 0;
   const accentTheme = ACCENT_THEME.value; // repaint the canvas when the accent changes
+  // Leaving Timeline destroys the canvas and returning builds a fresh blank one,
+  // so the draw has to re-run on this even when nothing else changed.
+  const mounted = inTimeline && commits.length > 0;
 
   // Paint the track: an accent played-fill + past ticks, neutral future ticks.
   // One canvas draw for all commits, DPR-crisp, null-guards a missing 2d context.
@@ -87,9 +96,11 @@ export function TimeTravelBar() {
     const ro = new ResizeObserver(draw);
     ro.observe(track);
     return () => ro.disconnect();
-  }, [scale, pos, accentTheme]);
+  }, [scale, pos, accentTheme, mounted]);
 
-  if (commits.length === 0) return null;
+  // Bail only AFTER the hooks: returning above them froze this instance's effect
+  // deps while it rendered nothing.
+  if (!mounted) return null;
 
   const commit = commits[Math.min(Math.round(pos), maxIndex)];
   const remote = bundle?.unionManifest?.repo?.remote_url ?? null;
@@ -107,7 +118,7 @@ export function TimeTravelBar() {
     if (!el) return;
     const r = el.getBoundingClientRect();
     if (r.width === 0) return;
-    SCRUB_POS.value = fractionToIndex(scale, (clientX - r.left) / r.width);
+    setScrubPos(fractionToIndex(scale, (clientX - r.left) / r.width));
   };
 
   const onPointerDown = (e: PointerEvent) => {
@@ -146,7 +157,7 @@ export function TimeTravelBar() {
     else return;
     e.preventDefault();
     e.stopPropagation();
-    SCRUB_POS.value = Math.max(0, Math.min(maxIndex, next));
+    setScrubPos(next);
   };
 
   return (
@@ -156,7 +167,7 @@ export function TimeTravelBar() {
           type="button"
           class="time-travel-edge"
           title="Jump to the first commit"
-          onClick={() => (SCRUB_POS.value = 0)}
+          onClick={() => setScrubPos(0)}
         >
           {formatShortDate(commits[0].date)}
         </button>
@@ -187,7 +198,7 @@ export function TimeTravelBar() {
           type="button"
           class="time-travel-edge"
           title="Jump to the latest commit"
-          onClick={() => (SCRUB_POS.value = maxIndex)}
+          onClick={() => setScrubPos(maxIndex)}
         >
           {formatShortDate(commits[maxIndex].date)}
         </button>
diff --git a/app/src/hooks/useDocumentTitle.ts b/app/src/hooks/useDocumentTitle.ts
index ffe04e930..eb0cfec48 100644
--- a/app/src/hooks/useDocumentTitle.ts
+++ b/app/src/hooks/useDocumentTitle.ts
@@ -7,7 +7,7 @@
 
 import { useSignalEffect } from '@preact/signals';
 import { MANIFEST } from '@/state/stores/manifest';
-import { PENDING_SOURCE_LABEL } from '@/state/stores/source';
+import { PENDING_SOURCE_LABEL } from '@/state/stores/ui';
 
 export function useDocumentTitle(): void {
   useSignalEffect(() => {
diff --git a/app/src/hooks/useManifestSource.ts b/app/src/hooks/useManifestSource.ts
index 78dac7685..4df6d154f 100644
--- a/app/src/hooks/useManifestSource.ts
+++ b/app/src/hooks/useManifestSource.ts
@@ -29,23 +29,18 @@ import { effect } from '@preact/signals';
 import { manifestUrlFor, signatureUrlFor, streamManifest, ScanPhase } from '@/api/manifest';
 import { getServerConfig } from '@/api/config';
 import { LIVE_UPDATES } from '@/state/stores/settings/updates';
-import {
-  PENDING_SOURCE_LABEL,
-  SOURCE_ERROR,
-  setCurrentSource,
-  CURRENT_SOURCE,
-} from '@/state/stores/source';
+import { RECENTS, SOURCE_ERROR, setCurrentSource, CURRENT_SOURCE } from '@/state/stores/source';
 import { SERVER_CONFIG } from '@/state/stores/serverConfig';
 import { MANIFEST, setManifest, markError, markRebuilding } from '@/state/stores/manifest';
 import { SCAN_PROGRESS } from '@/state/stores/scanProgress';
 import { TIMELINE_MODE, resetTimelineMode } from '@/state/stores/timeline';
-import { loadTimelineScene } from '@/hooks/useTimelineMode';
 import { activeExcludePathsFor, ACTIVE_EXCLUDES } from '@/state/stores/excludes';
 import { srcKind, SourceKind, srcNeedsBranch, identityBranch, sourceKey } from '@/utils/sources';
 import { isEmptyManifest } from '@/utils/manifest';
 import { URL_PARAMS } from '@/constants/urlParams';
 import type { Manifest } from '@/types';
 import type { SourcePayload } from '@/state/stores/ui';
+import { PENDING_SOURCE_LABEL } from '@/state/stores/ui';
 
 // ── Shared helpers ───────────────────────────────────────────────────
 
@@ -106,6 +101,15 @@ async function pumpManifestStream(
   return lastManifest;
 }
 
+// Injected, not imported: useTimelineMode imports this module, so importing it
+// back was a cycle. TIMELINE_MODE only turns on via that module, so by the time
+// this can be reached it has registered.
+let timelineRefresh: (() => Promise<void>) | null = null;
+
+export function setTimelineRefreshHandler(fn: (() => Promise<void>) | null): void {
+  timelineRefresh = fn;
+}
+
 // ── Single-writer generation guard ───────────────────────────────────
 // MANIFEST has many would-be writers — the cold-boot load, each user switch,
 // and the background live-update poll — all targeting one signal. A monotonic
@@ -141,6 +145,9 @@ export async function loadSource(payload: SourcePayload): Promise<void> {
   // legacy recent could carry one) so the fetch URL, overlay, committed source,
   // and prefill all stay branch-less. The checked-out branch is display-only.
   const branch = identityBranch(payload.src, payload.branch);
+  // Seed the overlay header from recents: the server's label arrives with the
+  // first stream event, which is after the overlay is already on screen.
+  PENDING_SOURCE_LABEL.value = RECENTS.peek().find((r) => r.src === payload.src)?.label ?? null;
   const meta = {
     kind: srcKind(payload.src),
     branch,
@@ -198,7 +205,6 @@ export async function loadSource(payload: SourcePayload): Promise<void> {
     // not clear it out from under the newer load that's still streaming.
     if (myGen === loadGeneration) {
       SCAN_PROGRESS.value = null;
-      PENDING_SOURCE_LABEL.value = null;
       if (loadController === controller) loadController = null;
     }
   }
@@ -345,8 +351,8 @@ export function setupLiveUpdates(): () => void {
     // Timeline owns the scene: excludes change the union data, so refetch its bundle
     // + re-pack (it owns its own rebuilding footer). Live: in-place re-scan.
     let refresh: Promise<void>;
-    if (TIMELINE_MODE.peek()) {
-      refresh = loadTimelineScene({ inPlace: true });
+    if (TIMELINE_MODE.peek() && timelineRefresh) {
+      refresh = timelineRefresh();
     } else {
       markRebuilding(); // flip the footer now, not after the re-scan streams back
       refresh = fetchAndApply(cur.src, cur.branch);
@@ -401,7 +407,7 @@ export function useManifestSource(): {
       if (cancelled) return;
 
       const serverConfig = await getServerConfig();
-      SERVER_CONFIG.value = { allowLocalRepos: serverConfig.allowLocalRepos };
+      SERVER_CONFIG.value = serverConfig;
 
       // One poll loop for the app's lifetime; no-ops until a source is loaded,
       // re-reads CURRENT_SOURCE + MANIFEST.content_signature each tick (covers
diff --git a/app/src/hooks/useSwitcherShowcase.ts b/app/src/hooks/useSwitcherShowcase.ts
index c9f1ab0dd..d34ad6888 100644
--- a/app/src/hooks/useSwitcherShowcase.ts
+++ b/app/src/hooks/useSwitcherShowcase.ts
@@ -10,6 +10,15 @@
 import { useEffect } from 'preact/hooks';
 import { effect } from '@preact/signals';
 import { SWITCHER_SHOWCASE } from '@/state/stores/ui';
+import {
+  TIMELINE_MODE,
+  TIMELINE_BUNDLE,
+  SCRUB_POS,
+  enterTimelineMode,
+  resetTimelineMode,
+} from '@/state/stores/timeline';
+import { reapplyTimelineScene } from '@/hooks/useTimelineMode';
+import type { TimelineBundle } from '@/types';
 import { SCENE_HANDLE, type SceneHandle } from '@/state/stores/scene';
 import { CURRENT_SOURCE_KEY } from '@/state/stores/source';
 import { NodeKind, type PickerSelectionKey } from '@/types';
@@ -37,6 +46,9 @@ export function useSwitcherShowcase(): void {
     let savedPose: CameraPose | null = null;
     let savedSelKey: PickerSelectionKey | null = null;
     let savedSourceKey: string | null = null;
+    // The backdrop is always plain live, so Timeline is parked on open and put
+    // back on dismiss.
+    let savedTimeline: { bundle: TimelineBundle; scrubPos: number } | null = null;
 
     // peek the handle (untracked): showcase only turns true over a loaded city,
     // so the handle is present — no need to re-run when it changes.
@@ -50,6 +62,11 @@ export function useSwitcherShowcase(): void {
         savedSourceKey = CURRENT_SOURCE_KEY.peek();
         savedPose = handle.rig.getPose();
         savedSelKey = handle.picker.selectionKey.peek();
+        const bundle = TIMELINE_BUNDLE.peek();
+        if (TIMELINE_MODE.peek() && bundle) {
+          savedTimeline = { bundle, scrubPos: SCRUB_POS.peek() };
+          resetTimelineMode(); // the city layer reacts by rebuilding live
+        }
         handle.picker.clearSelection();
         setChromeHidden(true);
         handle.rig.enterShowcase({ autoRotate: !prefersReducedMotion() });
@@ -63,11 +80,21 @@ export function useSwitcherShowcase(): void {
           if (CURRENT_SOURCE_KEY.peek() === savedSourceKey) {
             if (savedPose) handle.rig.applyPose(savedPose);
             restoreSelection(handle, savedSelKey);
+            if (savedTimeline) {
+              // Re-pack from the saved bundle rather than refetching it, and only
+              // enter once it is packed. A switcher reopened meanwhile owns the mode.
+              const { bundle, scrubPos } = savedTimeline;
+              TIMELINE_BUNDLE.value = bundle;
+              void reapplyTimelineScene().then(() => {
+                if (!active) enterTimelineMode(scrubPos);
+              });
+            }
           }
         }
         savedPose = null;
         savedSelKey = null;
         savedSourceKey = null;
+        savedTimeline = null;
       }
     });
 
diff --git a/app/src/hooks/useTimelineMode.ts b/app/src/hooks/useTimelineMode.ts
index 024b62884..f2d1c245a 100644
--- a/app/src/hooks/useTimelineMode.ts
+++ b/app/src/hooks/useTimelineMode.ts
@@ -6,11 +6,9 @@
 // tear the controller down and reload live HEAD. Called by the header toggle.
 // teardownTimelineMode only flips TIMELINE_MODE; the city-layer effect (city/index.ts) does the actual scene teardown for every exit path.
 
-import { batch } from '@preact/signals';
-
 import { fetchTimelineBundle } from '@/api/timeline';
 import { buildPathTimelines } from '@/city/timeline/replay';
-import { CURRENT_SOURCE, SOURCE_INFO, PENDING_SOURCE_LABEL } from '@/state/stores/source';
+import { CURRENT_SOURCE, SOURCE_INFO } from '@/state/stores/source';
 import { SCENE_HANDLE } from '@/state/stores/scene';
 import { markError, markRebuilding } from '@/state/stores/manifest';
 import {
@@ -19,16 +17,19 @@ import {
   setLoadingStepTail,
   hideLoadingOverlay,
   setLoadingCancel,
+  PENDING_SOURCE_LABEL,
 } from '@/state/stores/ui';
 import { LoadingStep, TIMELINE_LOADING_STEPS } from '@/constants/loadingSteps';
 import { srcKind } from '@/utils/sources';
 import {
   TIMELINE_MODE,
-  SCRUB_POS,
   TIMELINE_BUNDLE,
+  SCRUB_POS,
   resetTimelineMode,
+  enterTimelineMode,
+  setScrubPos,
 } from '@/state/stores/timeline';
-import { loadSource, cancelLoad } from '@/hooks/useManifestSource';
+import { loadSource, cancelLoad, setTimelineRefreshHandler } from '@/hooks/useManifestSource';
 import { activeExcludePathsFor } from '@/state/stores/excludes';
 import type { Manifest, TimelineProgress } from '@/types';
 
@@ -80,7 +81,6 @@ export async function loadTimelineScene({ inPlace = false } = {}): Promise<void>
         cancelled = true;
         abort.abort();
         hideLoadingOverlay();
-        PENDING_SOURCE_LABEL.value = null;
       }
     );
     setLoadingStep(LoadingStep.TimelineLoading);
@@ -109,21 +109,13 @@ export async function loadTimelineScene({ inPlace = false } = {}): Promise<void>
     handle.timeline.setStreetsTransparent(true);
     handle.timeline.setFootprintsTransparent(true);
     handle.timeline.installScrubController(timelines, bundle.commitLineRanges);
-    batch(() => {
-      TIMELINE_MODE.value = true;
-      if (inPlace) {
-        // Excludes filter files, not commits, but clamp in case the list shrank.
-        const maxPos = Math.max(0, bundle.commits.length - 1);
-        if (SCRUB_POS.peek() > maxPos) SCRUB_POS.value = maxPos;
-      } else {
-        SCRUB_POS.value = Math.max(0, bundle.commits.length - 1); // start at present
-      }
-    });
+    // An in-place refetch holds position (self-clamping if the bundle shrank);
+    // a fresh enter starts at the present.
+    enterTimelineMode(inPlace ? SCRUB_POS.peek() : undefined);
     if (!inPlace) {
       // Hold the overlay through the union city's first painted frame, then reveal.
       requestAnimationFrame(() => {
         hideLoadingOverlay();
-        PENDING_SOURCE_LABEL.value = null;
       });
     }
   } catch (err) {
@@ -141,12 +133,18 @@ export async function loadTimelineScene({ inPlace = false } = {}): Promise<void>
         /* teardown failed; surfacing err + hiding the overlay below is what matters */
       }
       hideLoadingOverlay();
-      PENDING_SOURCE_LABEL.value = null;
     }
     markError(err);
   }
 }
 
+// An excludes change while Timeline is active must refetch the bundle rather
+// than re-scan HEAD. useManifestSource is the lower layer and cannot import this
+// module (that was a cycle), so hand it the callback here. Registering at module
+// scope is safe: TIMELINE_MODE only turns on via loadTimelineScene above, so this
+// has always run by the time the handler can be reached.
+setTimelineRefreshHandler(() => loadTimelineScene({ inPlace: true }));
+
 // Enter Timeline mode if it isn't already on, then scrub to the given commit.
 // Called by the commit pane's "view in timeline" button — in Live mode it enters
 // first, in Timeline mode it just jumps. No-op if the sha isn't in the bundle
@@ -159,7 +157,7 @@ export async function viewCommitInTimeline(sha: string): Promise<void> {
   const bundle = TIMELINE_BUNDLE.peek();
   if (!bundle) return;
   const idx = bundle.commits.findIndex((c) => c.sha === sha);
-  if (idx >= 0) SCRUB_POS.value = idx;
+  if (idx >= 0) setScrubPos(idx);
 }
 
 // Re-pack the union city + re-install the scrub controller from the warm bundle
@@ -193,7 +191,7 @@ export function exitTimelineMode(): void {
   setLoadingCancel(() => {
     cancelLoad();
     void loadTimelineScene().then(() => {
-      if (TIMELINE_MODE.peek()) SCRUB_POS.value = scrubPos;
+      if (TIMELINE_MODE.peek()) setScrubPos(scrubPos);
     });
   });
   void loadSource({ src: cur.src, branch: cur.branch });
diff --git a/app/src/layout/App/App.css b/app/src/layout/App/App.css
index 007ae060f..bfde43085 100644
--- a/app/src/layout/App/App.css
+++ b/app/src/layout/App/App.css
@@ -49,7 +49,6 @@ body {
 #app.cc-showcase #left-sidebar,
 #app.cc-showcase #right-sidebar,
 #app.cc-showcase #app-footer,
-#app.cc-showcase #scene-controls,
-#app.cc-showcase .timeline-notice {
+#app.cc-showcase #scene-controls {
   display: none;
 }
diff --git a/app/src/state/stores/scrubbedManifest.ts b/app/src/state/stores/scrubbedManifest.ts
index a21a2dbfe..c8fd7ec8e 100644
--- a/app/src/state/stores/scrubbedManifest.ts
+++ b/app/src/state/stores/scrubbedManifest.ts
@@ -10,7 +10,35 @@ import type { Manifest } from '@/types';
 import { activeExcludePathsFor } from '@/state/stores/excludes';
 
 // Reconstruction is immutable per commit, so a visited commit is free to revisit.
+// Bounded, because an entry is a whole repo tree: scrubbing a long history or
+// switching repos would otherwise grow this for the life of the tab. Insertion
+// order is the recency order, so the oldest key is the first one.
 const _cache = new Map<string, Manifest>();
+const _CACHE_MAX = 16;
+
+function cacheGet(key: string): Manifest | undefined {
+  const hit = _cache.get(key);
+  if (hit) {
+    _cache.delete(key);
+    _cache.set(key, hit);
+  }
+  return hit;
+}
+
+function cacheSet(key: string, manifest: Manifest): void {
+  _cache.delete(key);
+  _cache.set(key, manifest);
+  while (_cache.size > _CACHE_MAX) {
+    const oldest = _cache.keys().next().value;
+    if (oldest === undefined) break;
+    _cache.delete(oldest);
+  }
+}
+
+/** Test-only: drop every cached reconstruction. */
+export function _clearScrubbedManifestCache(): void {
+  _cache.clear();
+}
 
 export const SCRUBBED_MANIFEST = signal<Manifest | null>(null);
 export const SCRUBBED_MANIFEST_PENDING = signal(false);
@@ -26,7 +54,7 @@ export async function loadManifestAt(
   // Excludes reshape the tree, so they're part of the identity of what we cached.
   const exclude = activeExcludePathsFor(src);
   const key = `${src}@${sha}@${exclude.join(',')}`;
-  const cached = _cache.get(key);
+  const cached = cacheGet(key);
   if (cached) {
     SCRUBBED_MANIFEST.value = cached;
     return;
@@ -42,7 +70,7 @@ export async function loadManifestAt(
       signal: ctrl.signal,
     })) {
       if (ev.phase === ScanPhase.CompleteManifest) {
-        _cache.set(key, ev.manifest);
+        cacheSet(key, ev.manifest);
         if (!ctrl.signal.aborted) SCRUBBED_MANIFEST.value = ev.manifest;
       }
     }
diff --git a/app/src/state/stores/serverConfig.ts b/app/src/state/stores/serverConfig.ts
index 11cd4e0f4..a968f4d9b 100644
--- a/app/src/state/stores/serverConfig.ts
+++ b/app/src/state/stores/serverConfig.ts
@@ -1,11 +1,15 @@
 // state/stores/serverConfig.ts — Runtime signal holding server capabilities
 // fetched once during app boot. Written by useManifestSource after getServerConfig().
 // Read by ProjectsView to decide whether to show the local-repos tab.
+//
+// The shape and defaults live in @/api/config: that is the layer that speaks to
+// the server, and it must not depend on this one. This store is the reactive
+// mirror for the UI.
 
 import { signal } from '@preact/signals';
+import { DEFAULT_SERVER_CONFIG, type ServerConfig } from '@/api/config';
 
-export interface ServerConfig {
-  allowLocalRepos: boolean;
-}
+export type { ServerConfig };
+export { DEFAULT_SERVER_CONFIG };
 
-export const SERVER_CONFIG = signal<ServerConfig>({ allowLocalRepos: false });
+export const SERVER_CONFIG = signal<ServerConfig>(DEFAULT_SERVER_CONFIG);
diff --git a/app/src/state/stores/settings/syntaxTheme.ts b/app/src/state/stores/settings/syntaxTheme.ts
index e2752d64c..7c35f63b5 100644
--- a/app/src/state/stores/settings/syntaxTheme.ts
+++ b/app/src/state/stores/settings/syntaxTheme.ts
@@ -12,11 +12,14 @@ export interface SyntaxThemeOption {
   label: string;
 }
 
-// Curated DARK theme list. All filenames verified against
-// node_modules/highlight.js/styles/ (highlight.js 11.11.1). Light themes
-// are intentionally not offered — codecity's UI is a dark theme and bright
-// code panels clash visually. Alphabetized by display label.
-export const SYNTAX_THEME_OPTIONS: SyntaxThemeOption[] = [
+// Curated DARK theme list. Light themes are intentionally not offered —
+// codecity's UI is a dark theme and bright code panels clash visually.
+// Alphabetized by display label.
+//
+// `as const` makes the values a literal union, which HljsThemeLink's stylesheet
+// map is keyed on: adding a theme here fails typecheck until its CSS is
+// imported there, so the two cannot drift.
+export const SYNTAX_THEME_OPTIONS = [
   { value: 'a11y-dark', label: 'A11y Dark' },
   { value: 'agate', label: 'Agate' },
   { value: 'androidstudio', label: 'Android Studio' },
@@ -38,13 +41,18 @@ export const SYNTAX_THEME_OPTIONS: SyntaxThemeOption[] = [
   { value: 'stackoverflow-dark', label: 'Stack Overflow Dark' },
   { value: 'tokyo-night-dark', label: 'Tokyo Night' },
   { value: 'vs2015', label: 'VS 2015' },
-];
+] as const satisfies readonly SyntaxThemeOption[];
+
+export type SyntaxThemeValue = (typeof SYNTAX_THEME_OPTIONS)[number]['value'];
 
 // Default matches the hand-rolled theme bundled in HljsThemeLink.css.
-// Changing to a CDN theme overrides those .hljs-* rules because the <link>
-// is injected into <head> after the bundled CSS (later in the cascade wins
-// at equal specificity, and these are the same specificity).
-export const SYNTAX_THEME_DEFAULT = 'atom-one-dark';
+// Selecting a theme overrides those .hljs-* rules because the <link> is
+// injected into <head> after the bundled CSS (later in the cascade wins at
+// equal specificity, and these are the same specificity).
+export const SYNTAX_THEME_DEFAULT: SyntaxThemeValue = 'atom-one-dark';
+// Typed `string`, not SyntaxThemeValue: the persisted value comes from
+// localStorage and may name a theme from an older build. HljsThemeLink
+// resolves anything unrecognized back to the default.
 export const SYNTAX_THEME = persistedSignal<string>('SYNTAX_THEME', SYNTAX_THEME_DEFAULT);
 
 // SYNTAX_THEME is a setting (it lives in the Appearance tab) but uses a plain
diff --git a/app/src/state/stores/source.ts b/app/src/state/stores/source.ts
index e64525b62..85a1f9576 100644
--- a/app/src/state/stores/source.ts
+++ b/app/src/state/stores/source.ts
@@ -67,15 +67,6 @@ effect(() => {
   history.replaceState(null, '', url.toString());
 });
 
-/**
- * Label of the source currently being LOADED (from the server's progress `src`),
- * or null when no load is in flight. Drives the "(pending)" document title while
- * streaming; useDocumentTitle prefers it over MANIFEST so a source switch shows
- * the new project name immediately, before its manifest lands. Cleared when the
- * stream settles (success or failure).
- */
-export const PENDING_SOURCE_LABEL = signal<string | null>(null);
-
 export interface SourceInfo {
   /** Human-readable project label (owner/repo or directory name). */
   label: string;
diff --git a/app/src/state/stores/timeline.ts b/app/src/state/stores/timeline.ts
index 0cf64cf2c..ea06b7ac9 100644
--- a/app/src/state/stores/timeline.ts
+++ b/app/src/state/stores/timeline.ts
@@ -1,11 +1,28 @@
-import { signal, batch, computed, effect } from '@preact/signals';
+import { signal, batch, computed, effect, type ReadonlySignal } from '@preact/signals';
 import type { TimelineBundle } from '@/types';
 
 // Distinct render mode (union city + scrub). SCRUB_POS is a float commit index so scrubbing interpolates.
 export const TIMELINE_MODE = signal(false);
-export const SCRUB_POS = signal(0);
 export const TIMELINE_BUNDLE = signal<TimelineBundle | null>(null);
 
+/** Highest valid scrub index for the loaded bundle, 0 when there is none. */
+export const SCRUB_MAX = computed(() =>
+  Math.max(0, (TIMELINE_BUNDLE.value?.commits.length ?? 0) - 1)
+);
+
+const _scrubPos = signal(0);
+
+// Clamped against the current bundle, not at each write, so a bundle swap alone
+// can't leave a stale position out of range. Readers never clamp defensively.
+export const SCRUB_POS: ReadonlySignal<number> = computed(() =>
+  Math.min(Math.max(_scrubPos.value, 0), SCRUB_MAX.value)
+);
+
+/** The only way to move the scrubber; readonly SCRUB_POS makes that a type error to bypass. */
+export function setScrubPos(pos: number): void {
+  _scrubPos.value = pos;
+}
+
 // The whole commit index SCRUB_POS lands on. Per-path presence only changes at
 // integer commits, so the sidebar's present-path filter (keyed on this) recomputes
 // once per commit crossing, not on every sub-commit interpolation frame.
@@ -25,11 +42,20 @@ effect(() => {
   if (!SCRUB_DRAGGING.value) SETTLED_COMMIT.value = commit;
 });
 
+// Every entry path, called only once the union city is packed: flipping the mode
+// before that leaves Timeline pointed at live geometry. `pos` defaults to the present.
+export function enterTimelineMode(pos?: number): void {
+  batch(() => {
+    TIMELINE_MODE.value = true;
+    setScrubPos(pos ?? SCRUB_MAX.peek());
+  });
+}
+
 // Shared by every exit path (toggle-off, source switch); scene-free, the scene layer reacts to TIMELINE_MODE.
 export function resetTimelineMode(): void {
   batch(() => {
     TIMELINE_MODE.value = false;
-    SCRUB_POS.value = 0;
+    setScrubPos(0);
     TIMELINE_BUNDLE.value = null;
     SCRUB_DRAGGING.value = false;
   });
diff --git a/app/src/state/stores/ui.ts b/app/src/state/stores/ui.ts
index a9be5e0a7..34f9495df 100644
--- a/app/src/state/stores/ui.ts
+++ b/app/src/state/stores/ui.ts
@@ -82,6 +82,11 @@ export function clearProjectsViewError(): void {
 
 import { LoadingStep } from '@/constants/loadingSteps';
 
+/** Repo name in the loading overlay's header, so a switch shows the incoming
+ *  project immediately rather than waiting on its manifest. Lives here because
+ *  its lifetime is the overlay's: showLoadingOverlay/hideLoadingOverlay own it. */
+export const PENDING_SOURCE_LABEL = signal<string | null>(null);
+
 export interface LoadingOverlayState {
   visible: boolean;
   showOpts: LoadingOverlayShowOpts | null;
@@ -133,6 +138,9 @@ export function setLoadingCancel(onCancel: (() => void) | null): void {
 export function hideLoadingOverlay(): void {
   LOADING_OVERLAY.value = { ...LOADING_OVERLAY.peek(), visible: false };
   LOADING_CANCEL.value = null;
+  // The header belongs to the overlay: every caller used to clear it by hand
+  // right after this, and the one that forgot blanked the header mid-load.
+  PENDING_SOURCE_LABEL.value = null;
 }
 
 export function setLoadingStep(step: LoadingStep): void {
diff --git a/app/src/types/manifest.generated.ts b/app/src/types/manifest.generated.ts
index dbc343393..8f1e0c612 100644
--- a/app/src/types/manifest.generated.ts
+++ b/app/src/types/manifest.generated.ts
@@ -174,23 +174,6 @@ export interface paths {
         patch?: never;
         trace?: never;
     };
-    "/api/manifest/cache": {
-        parameters: {
-            query?: never;
-            header?: never;
-            path?: never;
-            cookie?: never;
-        };
-        get?: never;
-        put?: never;
-        post?: never;
-        /** Clear Cache */
-        delete: operations["clear_cache_api_manifest_cache_delete"];
-        options?: never;
-        head?: never;
-        patch?: never;
-        trace?: never;
-    };
     "/api/manifest": {
         parameters: {
             query?: never;
@@ -238,11 +221,6 @@ export interface components {
             /** Busy */
             busy: number;
         };
-        /** CacheClearResponse */
-        CacheClearResponse: {
-            /** Deleted */
-            deleted: number;
-        };
         /**
          * CloneProgressEvent
          * @description `clone-progress` — git source is being cloned; carries clone progress.
@@ -327,6 +305,8 @@ export interface components {
         ConfigResponse: {
             /** Allowlocalrepos */
             allowLocalRepos: boolean;
+            /** Maxbatchpaths */
+            maxBatchPaths: number;
         };
         /** DateRangeMs */
         DateRangeMs: {
@@ -1029,38 +1009,6 @@ export interface operations {
             };
         };
     };
-    clear_cache_api_manifest_cache_delete: {
-        parameters: {
-            query: {
-                src: string;
-                branch?: string | null;
-            };
-            header?: never;
-            path?: never;
-            cookie?: never;
-        };
-        requestBody?: never;
-        responses: {
-            /** @description Successful Response */
-            200: {
-                headers: {
-                    [name: string]: unknown;
-                };
-                content: {
-                    "application/json": components["schemas"]["CacheClearResponse"];
-                };
-            };
-            /** @description Validation Error */
-            422: {
-                headers: {
-                    [name: string]: unknown;
-                };
-                content: {
-                    "application/json": components["schemas"]["HTTPValidationError"];
-                };
-            };
-        };
-    };
     manifest_api_manifest_get: {
         parameters: {
             query?: {
diff --git a/app/src/views/ControlsPane/partials/Buildings.ts b/app/src/views/ControlsPane/partials/Buildings.ts
index bcb56f178..37c5d6d73 100644
--- a/app/src/views/ControlsPane/partials/Buildings.ts
+++ b/app/src/views/ControlsPane/partials/Buildings.ts
@@ -24,7 +24,7 @@ export const BUILDINGS_SECTION: SectionNode = {
   key: 'buildings',
   label: 'Buildings',
   description:
-    'Per-file boxes — height from line count, width from byte size, color from extension + age.',
+    'Per-file boxes: height from line count, width from byte size, color from extension + age.',
   children: [
     {
       key: 'layout',
diff --git a/app/src/views/ControlsPane/partials/Footprint.ts b/app/src/views/ControlsPane/partials/Footprint.ts
index e00ef372b..b89879593 100644
--- a/app/src/views/ControlsPane/partials/Footprint.ts
+++ b/app/src/views/ControlsPane/partials/Footprint.ts
@@ -9,7 +9,7 @@ export const FOOTPRINT_SECTION: SectionNode = {
   key: 'footprint',
   label: 'City footprint',
   description:
-    'The dark paved apron beneath the city — overlapping inflated rects around every building, street, and path compose into one slab that follows the city silhouette.',
+    'The dark paved apron beneath the city: overlapping inflated rects around every building, street, and path compose into one slab that follows the city silhouette.',
   children: [
     field(FOOTPRINT, 'ENABLED'),
     field(FOOTPRINT, 'COLOR'),
diff --git a/app/src/views/ControlsPane/partials/Scene.ts b/app/src/views/ControlsPane/partials/Scene.ts
index a58ebb723..f41e01d15 100644
--- a/app/src/views/ControlsPane/partials/Scene.ts
+++ b/app/src/views/ControlsPane/partials/Scene.ts
@@ -8,7 +8,7 @@ export const SCENE_SECTION: SectionNode = {
   key: 'scene',
   label: 'Scene',
   description:
-    'Sky, stars, ground, and atmosphere — everything that frames the city. (Sun lighting is fixed in code.)',
+    'Sky, stars, ground, and atmosphere: everything that frames the city. (Sun lighting is fixed in code.)',
   children: [
     { key: 'sky', label: 'Sky', children: [field(SCENE, 'SKY_COLOR')] },
     {
diff --git a/app/src/views/ControlsPane/partials/Trees.ts b/app/src/views/ControlsPane/partials/Trees.ts
index 12868230d..c5c348992 100644
--- a/app/src/views/ControlsPane/partials/Trees.ts
+++ b/app/src/views/ControlsPane/partials/Trees.ts
@@ -9,7 +9,7 @@ export const TREES_SECTION: SectionNode = {
   key: 'trees',
   label: 'Trees',
   description:
-    'One tree per commit — height tracks age, width tracks file count, color tracks commits-per-day (same-day commits share a color).',
+    'One tree per commit: height tracks age, width tracks file count, color tracks commits-per-day (same-day commits share a color).',
   children: [
     { key: 'visibility', label: 'Visibility', children: [field(TREES, 'ENABLED')] },
     {
diff --git a/app/src/views/FilePreviewPane/FilePreviewPane.css b/app/src/views/FilePreviewPane/FilePreviewPane.css
index 22a5fdccf..5fc29bc18 100644
--- a/app/src/views/FilePreviewPane/FilePreviewPane.css
+++ b/app/src/views/FilePreviewPane/FilePreviewPane.css
@@ -1,34 +1,5 @@
 /* ── File preview pane ── */
 
-/* Middle-truncation ellipsis placeholder — shared by the header breadcrumb
- * and the file-preview pane path. Shown when middle segments are hidden to
- * prevent the row from overflowing. Hovering reveals a tooltip listing the
- * hidden segment names. */
-.file-path-ellipsis {
-  flex: 0 0 auto;
-  color: var(--cc-text-muted);
-  padding: 0 var(--cc-space-1);
-  cursor: help;
-  user-select: none;
-}
-
-/* File-preview pane path segments rendered inside .text-pane-title. */
-.file-path-segment {
-  flex: 0 0 auto;
-  color: var(--cc-text-secondary);
-  white-space: nowrap;
-}
-.file-path-segment.is-leaf {
-  color: var(--cc-text-primary);
-}
-.file-path-sep {
-  flex: 0 0 auto;
-  color: var(--cc-text-faint);
-  font-size: var(--cc-font-sm);
-  pointer-events: none;
-  padding: 0 var(--cc-space-px);
-}
-
 /* ── File preview pane (right sidebar) ──────────────────────────────────
    Outer container that wraps the pane header (filename + × close) and the
    editor body. The wrapper itself fills the sidebar's vertical space; the
diff --git a/app/src/views/InfoPane/InfoPane.css b/app/src/views/InfoPane/InfoPane.css
index 31d2d1ac5..2dd2193a1 100644
--- a/app/src/views/InfoPane/InfoPane.css
+++ b/app/src/views/InfoPane/InfoPane.css
@@ -136,8 +136,8 @@
   margin: var(--cc-space-7) 0;
 }
 
-/* Shell from .code-inline; this rule adds the info-markdown specific
-   larger font and primary text color. */
+/* Standalone: marked emits bare <code>, which no class reaches, so the pill
+   styling is redeclared here rather than composed from an atom. */
 .info-markdown code {
   border: 1px solid var(--cc-accent-bg);
   color: var(--cc-text-strong);
diff --git a/app/src/views/InfoPane/almanac.ts b/app/src/views/InfoPane/almanac.ts
index ee0f6dbee..a572c2ec0 100644
--- a/app/src/views/InfoPane/almanac.ts
+++ b/app/src/views/InfoPane/almanac.ts
@@ -264,7 +264,7 @@ function buildingsSection(m: Manifest): AlmanacSection {
       label: 'Oldest',
       leader: s.oldestCreatedFile,
       secondary: (l) => formatShortDate(l.created),
-      tip: "Earliest-created file, by git history — the city's founding structure.",
+      tip: "Earliest-created file, by git history: the city's founding structure.",
     }),
     fileFact({
       group: 'Age',
@@ -278,14 +278,14 @@ function buildingsSection(m: Manifest): AlmanacSection {
       label: 'Stalest',
       leader: s.oldestModifiedFile,
       secondary: (l) => formatShortDate(l.modified),
-      tip: 'File whose last commit is the oldest — the dimmest building.',
+      tip: 'File whose last commit is the oldest: the dimmest building.',
     }),
     fileFact({
       group: 'Last touched',
       label: 'Freshest',
       leader: s.newestModifiedFile,
       secondary: (l) => formatShortDate(l.modified),
-      tip: "File with the newest commit — the date that drives a building's brightness.",
+      tip: "File with the newest commit: the date that drives a building's brightness.",
     }),
     fileFact({
       group: 'Height',
@@ -379,7 +379,7 @@ function mediaSection(m: Manifest): AlmanacSection {
           label: 'Only',
           leader: hi,
           secondary: (l) => `${bytesFmt(l)}${dims}`,
-          tip: 'The only billboard — its byte size and pixel resolution.',
+          tip: 'The only billboard: its byte size and pixel resolution.',
         }),
       ]),
     };
@@ -482,14 +482,14 @@ function streetsSection(m: Manifest): AlmanacSection {
       label: 'Smallest',
       leader: s.minChildrenDir,
       secondary: childCount,
-      tip: 'Directory with the fewest direct children (ties broken by fewest descendants) — the quietest street.',
+      tip: 'Directory with the fewest direct children (ties broken by fewest descendants): the quietest street.',
     }),
     dirFact({
       group: 'Size',
       label: 'Biggest',
       leader: s.maxChildrenDir,
       secondary: childCount,
-      tip: 'Directory with the most direct children — files and sub-directories on that street.',
+      tip: 'Directory with the most direct children: files and sub-directories on that street.',
     }),
   ]);
   return {
@@ -524,13 +524,13 @@ function forestSection(m: Manifest, treesEnabled: boolean): AlmanacSection {
       group: 'Canopy',
       label: 'Sparsest',
       leader: s.minFilesPerCommit,
-      tip: 'Commit that changed the fewest files — the smallest tree.',
+      tip: 'Commit that changed the fewest files: the smallest tree.',
     }),
     commitFact({
       group: 'Canopy',
       label: 'Grandest',
       leader: s.maxFilesPerCommit,
-      tip: 'Commit that changed the most files — the widest tree.',
+      tip: 'Commit that changed the most files: the widest tree.',
     }),
     s.maxCommitsPerDay
       ? statFact({
@@ -573,7 +573,7 @@ function firefliesSection(m: Manifest): AlmanacSection {
     label: 'Most active',
     primary: most.name,
     secondary: pluralize(most.commits, 'commit'),
-    tip: 'Author with the most commits — the largest firefly.',
+    tip: 'Author with the most commits: the largest firefly.',
   });
   const facts =
     count >= 2
diff --git a/app/src/views/StreetPane/StreetPane.css b/app/src/views/StreetPane/StreetPane.css
index f1ab4425e..c7d7472ac 100644
--- a/app/src/views/StreetPane/StreetPane.css
+++ b/app/src/views/StreetPane/StreetPane.css
@@ -1,16 +1,3 @@
-/* ── Street labels (rendered on canvas; these are the overlay fallback) ── */
-
-.street-label {
-  position: absolute;
-  font-size: var(--cc-font-2xs);
-  font-weight: var(--cc-fw-medium);
-  color: var(--cc-text-base);
-  pointer-events: none;
-  white-space: nowrap;
-  text-shadow: var(--cc-shadow-text);
-  user-select: none;
-}
-
 /* ── Street pane (right sidebar) ────────────────────────────────────────
    Shown when a directory (road) is selected. Composition-forward:
      - pane header (badge + leaf, like FilePreviewPane)
diff --git a/app/src/views/TreePane/TreePane.css b/app/src/views/TreePane/TreePane.css
index 518eafc87..0fb607792 100644
--- a/app/src/views/TreePane/TreePane.css
+++ b/app/src/views/TreePane/TreePane.css
@@ -66,13 +66,13 @@
 }
 
 /* Tree rows use .row + .row--tight (the tight modifier collapses the
-   chevron-to-label gap). Selection highlight in .row--selected
-   near the top of the file. */
+   chevron-to-label gap). Selection highlight is .tree-item.tree-selected > .row
+   near the top of the file — the tree tracks selection on the item, not the row.
 
-/* Tree rows sit closer to the pane edge than the default .row inset: the tree
+   Rows also sit closer to the pane edge than the default .row inset: the tree
    reaches depth by expanding, so a big starting indent just wastes width. Half
    the default keeps the top level near the edge while still clearing the
-   .row--selected highlight's rounded corner. */
+   selected highlight's rounded corner. */
 .tree-item > .row {
   padding-left: var(--tree-row-inset);
   /* Squared hover/selected highlight (Zed-style), overriding .row's rounded
diff --git a/app/tests/_helpers/cityFixtures.ts b/app/tests/_helpers/cityFixtures.ts
index be6e8ead3..d1064c504 100644
--- a/app/tests/_helpers/cityFixtures.ts
+++ b/app/tests/_helpers/cityFixtures.ts
@@ -1,36 +1,12 @@
-// Shared test fixtures for city scene tests. Replaces inline copies of
-// bbox()/emptyLayout()/mkFile()/mkDir() and the trees/buildings
-// config resets that had begun to drift between callers (audit 2026-05-25).
-// Task 8 migrates the consumers; this file only adds the helpers.
-//
-// Audit reality vs. plan:
-//   - bbox()         : 4 byte-identical inline copies (treePlacement,
-//                      treePlacementClient, worldBounds, and one more).
-//   - emptyLayout()  : 3 byte-identical inline copies (same files minus
-//                      worldBounds).
-//   - mkFile/mkDir   : 4 inline copies across layoutPacker.test.ts,
-//                      layout.test.ts (two variants inside one file), and
-//                      bench/layout.bench.test.ts. Three are the simple
-//                      `(name)` shape; the bench variant takes `(name,
-//                      depth)` to pre-stamp paths and skips child-path
-//                      prefixing in mkDir. We export the simple/canonical
-//                      forms here (matches 3 of 4 call sites); the bench
-//                      and the recursive quickjs-scenario `mkDir` in
-//                      layout.test.ts (1233) stay local in Task 8.
-//   - resets         : plan named these `resetTreesConfig` /
-//                      `resetBuildingsConfig` but actual call sites use
-//                      `resetTrees` / `resetBuildings` (treePlacement).
-//                      We export two small functions in Task 8.
-//
-// The mkFile/mkDir helpers return `any` on purpose: the inline versions
-// all do, because the real FileNode/DirNode interfaces require fields
-// (fullPath, binary, git, descendants_file_count, ...) that the test
-// fixtures intentionally omit. Tightening the return type would require
-// padding every fixture with stub fields the production code under test
-// never reads.
+// Shared fixtures for city scene tests: scene contexts, bboxes, layouts, tree
+// nodes, and the trees/buildings config resets.
 
+import * as THREE from 'three';
+import { signal } from '@preact/signals';
 import { NodeKind } from '@/types';
-import type { CityBbox, CityLayout } from '@/types';
+import type { CityBbox, CityLayout, PickTarget } from '@/types';
+import type { SceneContext } from '@/city/types';
+import type { Picker } from '@/city/interaction/picker';
 import { TREES } from '@/state/stores/settings/trees';
 import { BUILDING_DIMENSIONS } from '@/state/stores/settings/buildings';
 import { createCityState, type CityState } from '@/city/state';
@@ -48,6 +24,50 @@ export function makeCityState(): CityState {
   return createCityState(STUB_LAYOUT_CLIENT as never);
 }
 
+/** A canvas whose clientWidth/clientHeight track a mutable `size`, so a test can
+ *  resize it and call onResize(). jsdom reports 0 for both otherwise. */
+function makeSizedCanvas(): { canvas: HTMLCanvasElement; size: { w: number; h: number } } {
+  const size = { w: 800, h: 600 };
+  const canvas = document.createElement('canvas');
+  Object.defineProperty(canvas, 'clientWidth', { get: () => size.w, configurable: true });
+  Object.defineProperty(canvas, 'clientHeight', { get: () => size.h, configurable: true });
+  return { canvas, size };
+}
+
+/** SceneContext for components that never touch the picker. Camera and renderer
+ *  are null: nothing under test reads them, and a real WebGL renderer cannot be
+ *  constructed in jsdom. */
+export function makeSceneContext(cityState: CityState = makeCityState()): SceneContext {
+  return {
+    scene: new THREE.Scene(),
+    canvas: makeSizedCanvas().canvas,
+    picker: null as unknown as Picker,
+    camera: null as unknown as THREE.PerspectiveCamera,
+    renderer: null as unknown as THREE.WebGLRenderer,
+    cityState,
+  } as unknown as SceneContext;
+}
+
+/** SceneContext whose picker carries real signals, returned alongside them so a
+ *  test can drive hover/selection and assert what the component does. */
+export function makePickableSceneContext(cityState: CityState = makeCityState()): {
+  ctx: SceneContext;
+  selection: ReturnType<typeof signal<PickTarget | null>>;
+  hover: ReturnType<typeof signal<PickTarget | null>>;
+  size: { w: number; h: number };
+} {
+  const selection = signal<PickTarget | null>(null);
+  const hover = signal<PickTarget | null>(null);
+  const { canvas, size } = makeSizedCanvas();
+  const ctx = {
+    scene: new THREE.Scene(),
+    canvas,
+    picker: { selection, hover } as unknown as Picker,
+    cityState,
+  } as unknown as SceneContext;
+  return { ctx, selection, hover, size };
+}
+
 /** Builds a CityBbox from extents, deriving cx/cy/width/depth. */
 export function bbox(minX: number, minY: number, maxX: number, maxY: number): CityBbox {
   return {
diff --git a/app/tests/_helpers/layoutTreeFixtures.ts b/app/tests/_helpers/layoutTreeFixtures.ts
index 624ae3af7..4e6659bc3 100644
--- a/app/tests/_helpers/layoutTreeFixtures.ts
+++ b/app/tests/_helpers/layoutTreeFixtures.ts
@@ -41,6 +41,68 @@ export function mkDir(name: string, children: any[], path: string): any {
   };
 }
 
+// The size/line extremes that the weighted + nested generators never produce:
+// they always emit `size >= 200`, `lines >= 5`, extension `.c`. Those are the
+// inputs that broke building geometry before — a 0-byte or 0-line file reaches
+// Math.log(0) in the dimension math, and a media file takes the aspect-ratio
+// branch instead. Kept separate from the generators above so the captured
+// golden digests stay valid.
+export function edgeCaseFiles(path: string): any[] {
+  return [
+    // Empty file: both log inputs are zero.
+    {
+      name: 'empty.txt',
+      type: NodeKind.File,
+      path: `${path}/empty.txt`,
+      extension: '.txt',
+      size: 0,
+      lines: 0,
+    },
+    // Non-empty but unlined — how the scanner reports a binary blob.
+    {
+      name: 'blob.bin',
+      type: NodeKind.File,
+      path: `${path}/blob.bin`,
+      extension: '.bin',
+      size: 4096,
+      lines: 0,
+      binary: true,
+    },
+    // Media with dimensions: takes the aspect-ratio branch.
+    {
+      name: 'wide.png',
+      type: NodeKind.File,
+      path: `${path}/wide.png`,
+      extension: '.png',
+      size: 51200,
+      lines: 0,
+      media_width: 1920,
+      media_height: 1080,
+    },
+    // Media whose reported dimensions are degenerate — a divide-by-zero aspect
+    // if the ratio is taken unguarded.
+    {
+      name: 'zero.svg',
+      type: NodeKind.File,
+      path: `${path}/zero.svg`,
+      extension: '.svg',
+      size: 120,
+      lines: 1,
+      media_width: 0,
+      media_height: 0,
+    },
+    // Single byte, single line: the smallest non-degenerate file.
+    {
+      name: 'one.c',
+      type: NodeKind.File,
+      path: `${path}/one.c`,
+      extension: '.c',
+      size: 1,
+      lines: 1,
+    },
+  ];
+}
+
 /** Root directory holding `n` files and no subdirectories. */
 export function flatTree(n: number, rng: () => number): any {
   const files = Array.from({ length: n }, (_, i) =>
diff --git a/app/tests/a11y/audit.test.tsx b/app/tests/a11y/audit.test.tsx
index 3085f114e..6806036e8 100644
--- a/app/tests/a11y/audit.test.tsx
+++ b/app/tests/a11y/audit.test.tsx
@@ -53,6 +53,14 @@ interface Surface {
   axeMount?: (c: HTMLElement) => void;
 }
 
+// A timed-out run never settles, so axe's `_running` latch stays set and every
+// later surface throws. teardown() clears caches but not that latch, so
+// releasing it is what breaks the cascade. `_running` is not in axe's types.
+function resetAxe(): void {
+  axe.teardown();
+  (axe as unknown as { _running: boolean })._running = false;
+}
+
 const SURFACES: Surface[] = [
   {
     name: 'ControlsPane',
@@ -113,6 +121,7 @@ describe('accessibility audit (issue #79)', () => {
     }
     closeDebug();
     closeShortcuts();
+    resetAxe();
   });
 
   function mountSurface(mount: (c: HTMLElement) => void): HTMLElement {
@@ -124,9 +133,9 @@ describe('accessibility audit (issue #79)', () => {
   }
 
   for (const surface of SURFACES) {
-    // Generous timeout: the settings DOM is large and CI is slower than a dev
-    // box. axe is also a singleton — a run that times out mid-flight leaves it
-    // "running" and the next surface throws, so it must be allowed to finish.
+    // Generous timeout: the settings DOM is large, and the gate runs pytest +
+    // vitest + coverage concurrently, so wall-clock here is far worse than on a
+    // dev box. Blowing it now fails only this surface — afterEach unwedges axe.
     it(`${surface.name}: no axe violations`, async () => {
       const c = mountSurface(surface.axeMount ?? surface.mount);
       const results = await axe.run(c, {
@@ -171,4 +180,18 @@ describe('accessibility audit (issue #79)', () => {
       expect(positiveTab).toHaveLength(0);
     });
   }
+
+  // Guards the cascade fix: a timed-out run leaves `_running` set, which used
+  // to make every subsequent surface throw instead of scanning.
+  it('a wedged axe latch does not poison the next surface (issue #108)', async () => {
+    (axe as unknown as { _running: boolean })._running = true;
+    resetAxe();
+
+    const c = mountSurface(SURFACES[SURFACES.length - 1].mount);
+    const results = await axe.run(c, {
+      resultTypes: ['violations'],
+      rules: { 'color-contrast': { enabled: false }, region: { enabled: false } },
+    });
+    expect(results.violations).toEqual([]);
+  });
 });
diff --git a/app/tests/api/config.test.ts b/app/tests/api/config.test.ts
index e7da1278c..3f8cba559 100644
--- a/app/tests/api/config.test.ts
+++ b/app/tests/api/config.test.ts
@@ -1,5 +1,6 @@
 import { describe, it, expect, beforeEach, vi } from 'vitest';
 import { fetchServerConfig, getServerConfig, _resetServerConfigForTests } from '@/api/config';
+import { DEFAULT_SERVER_CONFIG } from '@/state/stores/serverConfig';
 
 describe('fetchServerConfig', () => {
   beforeEach(() => {
@@ -12,7 +13,7 @@ describe('fetchServerConfig', () => {
       new Response(JSON.stringify({ allowLocalRepos: true }), { status: 200 })
     );
     const cfg = await fetchServerConfig();
-    expect(cfg).toEqual({ allowLocalRepos: true });
+    expect(cfg).toEqual({ ...DEFAULT_SERVER_CONFIG, allowLocalRepos: true });
   });
 
   it('coerces a missing allowLocalRepos to false', async () => {
@@ -20,25 +21,43 @@ describe('fetchServerConfig', () => {
       new Response(JSON.stringify({}), { status: 200 })
     );
     const cfg = await fetchServerConfig();
-    expect(cfg).toEqual({ allowLocalRepos: false });
+    expect(cfg).toEqual(DEFAULT_SERVER_CONFIG);
   });
 
   it('fails closed on a non-200 response', async () => {
     vi.spyOn(globalThis, 'fetch').mockResolvedValueOnce(new Response('oops', { status: 500 }));
     const cfg = await fetchServerConfig();
-    expect(cfg).toEqual({ allowLocalRepos: false });
+    expect(cfg).toEqual(DEFAULT_SERVER_CONFIG);
   });
 
   it('fails closed on a network error', async () => {
     vi.spyOn(globalThis, 'fetch').mockRejectedValueOnce(new Error('offline'));
     const cfg = await fetchServerConfig();
-    expect(cfg).toEqual({ allowLocalRepos: false });
+    expect(cfg).toEqual(DEFAULT_SERVER_CONFIG);
   });
 
   it('fails closed on malformed JSON', async () => {
     vi.spyOn(globalThis, 'fetch').mockResolvedValueOnce(new Response('not-json', { status: 200 }));
     const cfg = await fetchServerConfig();
-    expect(cfg).toEqual({ allowLocalRepos: false });
+    expect(cfg).toEqual(DEFAULT_SERVER_CONFIG);
+  });
+
+  // Regression: the parser used to list each field by hand, so a field added
+  // server-side was dropped here and the client kept its stale default.
+  it('carries through a field the hardcoded parser would have dropped', async () => {
+    vi.spyOn(globalThis, 'fetch').mockResolvedValueOnce(
+      new Response(JSON.stringify({ allowLocalRepos: false, maxBatchPaths: 64 }), { status: 200 })
+    );
+    const cfg = await fetchServerConfig();
+    expect(cfg.maxBatchPaths).toBe(64);
+  });
+
+  it('keeps the safe default when the server sends a nonsense batch cap', async () => {
+    vi.spyOn(globalThis, 'fetch').mockResolvedValueOnce(
+      new Response(JSON.stringify({ allowLocalRepos: false, maxBatchPaths: 0 }), { status: 200 })
+    );
+    const cfg = await fetchServerConfig();
+    expect(cfg.maxBatchPaths).toBe(DEFAULT_SERVER_CONFIG.maxBatchPaths);
   });
 });
 
diff --git a/app/tests/api/pathBatcher.test.ts b/app/tests/api/pathBatcher.test.ts
new file mode 100644
index 000000000..eda3ffb55
--- /dev/null
+++ b/app/tests/api/pathBatcher.test.ts
@@ -0,0 +1,143 @@
+// pathBatcher.test.ts — the coalescing core shared by the media and fingerprint
+// batchers. Chunking at the server's published cap is the case worth pinning:
+// the server silently truncates anything past it, so an over-large chunk loses
+// its tail with no error anywhere.
+
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
+import { createPathBatcher } from '@/api/pathBatcher';
+import { serverConfigNow } from '@/api/config';
+
+vi.mock('@/api/config', () => ({
+  serverConfigNow: vi.fn(() => ({ allowLocalRepos: false, maxBatchPaths: 3 })),
+}));
+
+interface Entry {
+  v: string;
+}
+
+function mockFetch(handler: (paths: string[]) => unknown, ok = true) {
+  const bodies: { url: string; paths: string[]; raw: Record<string, unknown> }[] = [];
+  const fn = vi.fn(async (url: string, opts: { body: string }) => {
+    const raw = JSON.parse(opts.body) as Record<string, unknown>;
+    bodies.push({ url, paths: raw.paths as string[], raw });
+    return { ok, json: async () => handler(raw.paths as string[]) } as Response;
+  });
+  vi.stubGlobal('fetch', fn);
+  return bodies;
+}
+
+const echo = (paths: string[]) => Object.fromEntries(paths.map((p) => [p, { v: `${p}!` }]));
+
+function makeBatcher(over: Partial<Parameters<typeof createPathBatcher<string, Entry>>[0]> = {}) {
+  return createPathBatcher<string, Entry>({
+    endpoint: '/api/things',
+    decode: (e) => e.v,
+    ...over,
+  });
+}
+
+describe('createPathBatcher', () => {
+  beforeEach(() => vi.useFakeTimers());
+  afterEach(() => {
+    vi.useRealTimers();
+    vi.unstubAllGlobals();
+  });
+
+  it('coalesces requests inside the window into one POST', async () => {
+    const bodies = mockFetch(echo);
+    const batcher = makeBatcher();
+    const all = Promise.all([batcher.request('a'), batcher.request('b')]);
+    await vi.runAllTimersAsync();
+
+    expect(bodies).toHaveLength(1);
+    expect(bodies[0].url).toBe('/api/things');
+    expect(await all).toEqual(['a!', 'b!']);
+  });
+
+  it('splits into chunks no larger than the cap the server published', async () => {
+    const bodies = mockFetch(echo);
+    const batcher = makeBatcher();
+    const paths = ['a', 'b', 'c', 'd', 'e', 'f', 'g'];
+    const all = Promise.all(paths.map((p) => batcher.request(p)));
+    await vi.runAllTimersAsync();
+
+    // cap is 3, so 7 paths -> 3 + 3 + 1, and every path still resolves.
+    expect(bodies.map((b) => b.paths.length)).toEqual([3, 3, 1]);
+    expect(bodies.flatMap((b) => b.paths)).toEqual(paths);
+    expect(await all).toEqual(paths.map((p) => `${p}!`));
+  });
+
+  it('re-reads the cap per flush, so a config that arrives late is honoured', async () => {
+    const bodies = mockFetch(echo);
+    vi.mocked(serverConfigNow).mockReturnValueOnce({ allowLocalRepos: false, maxBatchPaths: 2 });
+    const batcher = makeBatcher();
+    const all = Promise.all(['a', 'b', 'c'].map((p) => batcher.request(p)));
+    await vi.runAllTimersAsync();
+
+    expect(bodies.map((b) => b.paths.length)).toEqual([2, 1]);
+    expect(await all).toEqual(['a!', 'b!', 'c!']);
+  });
+
+  it('merges bodyFor fields into the request alongside paths', async () => {
+    const bodies = mockFetch(echo);
+    const batcher = makeBatcher({ bodyFor: (paths) => ({ shas: { [paths[0]]: 'deadbeef' } }) });
+    void batcher.request('a');
+    await vi.runAllTimersAsync();
+
+    expect(bodies[0].raw.shas).toEqual({ a: 'deadbeef' });
+  });
+
+  it('gives every waiter on one path the same value, with a single queue entry', async () => {
+    const bodies = mockFetch(echo);
+    const batcher = makeBatcher();
+    const all = Promise.all([batcher.request('a'), batcher.request('a')]);
+    await vi.runAllTimersAsync();
+
+    expect(bodies[0].paths).toEqual(['a']);
+    expect(await all).toEqual(['a!', 'a!']);
+  });
+
+  it('runs onSettled once per path so per-request state can be released', async () => {
+    mockFetch(echo);
+    const settled: string[] = [];
+    const batcher = makeBatcher({ onSettled: (p) => settled.push(p) });
+    void Promise.all([batcher.request('a'), batcher.request('b')]);
+    await vi.runAllTimersAsync();
+
+    expect(settled).toEqual(['a', 'b']);
+  });
+
+  it('resolves null for a path the server omits', async () => {
+    mockFetch(() => ({}));
+    const batcher = makeBatcher();
+    const value = batcher.request('a');
+    await vi.runAllTimersAsync();
+
+    expect(await value).toBeNull();
+  });
+
+  it('resolves null for every path when the request fails', async () => {
+    vi.stubGlobal(
+      'fetch',
+      vi.fn(async () => {
+        throw new Error('offline');
+      })
+    );
+    const batcher = makeBatcher();
+    const all = Promise.all([batcher.request('a'), batcher.request('b')]);
+    await vi.runAllTimersAsync();
+
+    expect(await all).toEqual([null, null]);
+  });
+
+  it('starts a fresh batch for requests arriving after a flush', async () => {
+    const bodies = mockFetch(echo);
+    const batcher = makeBatcher();
+    void batcher.request('a');
+    await vi.runAllTimersAsync();
+    void batcher.request('b');
+    await vi.runAllTimersAsync();
+
+    expect(bodies.map((b) => b.paths)).toEqual([['a'], ['b']]);
+  });
+});
diff --git a/app/tests/city/applyManifestScenic.test.ts b/app/tests/city/applyManifestScenic.test.ts
index 76d3cb520..a4102c63d 100644
--- a/app/tests/city/applyManifestScenic.test.ts
+++ b/app/tests/city/applyManifestScenic.test.ts
@@ -12,24 +12,12 @@
 //   #6  supersede → the winning apply's layout is the one that lands
 
 import { describe, it, expect, afterEach, vi } from 'vitest';
-import * as THREE from 'three';
 
 import { createCityState } from '@/city/state';
 import { createStreets } from '@/city/components/streets';
 import { NodeKind, StreetAxis } from '@/types';
 import type { CityLayout, DateRanges, Manifest, Street } from '@/types';
-import type { Picker } from '@/city/interaction/picker';
-import type { SceneContext } from '@/city/types';
-
-function makeCtx(cityState: ReturnType<typeof createCityState>): SceneContext {
-  return {
-    scene: new THREE.Scene(),
-    picker: null as unknown as Picker,
-    camera: null as unknown as THREE.PerspectiveCamera,
-    renderer: null as unknown as THREE.WebGLRenderer,
-    cityState,
-  } as unknown as SceneContext;
-}
+import { makeSceneContext } from '../_helpers/cityFixtures';
 
 function makeRootStreet(): Street {
   return {
@@ -95,7 +83,7 @@ describe('cityState.applyManifest — scenic reactivity parity', () => {
     );
 
     const cityState = createCityState(layoutClient as never);
-    const streets = createStreets(makeCtx(cityState));
+    const streets = createStreets(makeSceneContext(cityState));
     disposers.push(() => streets.dispose());
 
     return { cityState, streets, layoutClient };
diff --git a/app/tests/city/components/buildings/index.test.ts b/app/tests/city/components/buildings/index.test.ts
index edf3ffd6a..ea2713d58 100644
--- a/app/tests/city/components/buildings/index.test.ts
+++ b/app/tests/city/components/buildings/index.test.ts
@@ -16,17 +16,17 @@
 
 import { describe, it, expect, beforeEach, afterEach, vi } from 'vitest';
 import * as THREE from 'three';
-import { signal } from '@preact/signals';
 
 import { createBuildings } from '@/city/components/buildings';
-import { makeCityState } from '../../../_helpers/cityFixtures';
+import { makeCityState, makePickableSceneContext } from '../../../_helpers/cityFixtures';
 import { getBuildingMaterial } from '@/city/components/buildings/material';
 import buildingFragSrc from '@/city/components/buildings/building.frag.glsl?raw';
 import { BUILDINGS } from '@/state/stores/settings/buildings';
 import { SCENE } from '@/state/stores/settings/scene';
 import { RUINS } from '@/state/stores/settings/ruins';
+import { TIMELINE_MODE } from '@/state/stores/timeline';
 import { NodeKind } from '@/types';
-import type { Building, CityLayout, DateRanges, FileTarget, PickTarget } from '@/types';
+import type { Building, CityLayout, DateRanges, FileTarget } from '@/types';
 import type { Picker } from '@/city/interaction/picker';
 import type { SceneContext } from '@/city/types';
 import { building } from '../../../_helpers/buildingFixture';
@@ -44,21 +44,6 @@ function resetStores(): void {
 // A SceneContext whose picker exposes controllable selection + hover signals,
 // and a real (fake) renderer.domElement canvas so the outline LineMaterial can
 // read clientWidth/Height during arming.
-function makeCtx(): {
-  ctx: SceneContext;
-  selection: ReturnType<typeof signal<PickTarget | null>>;
-  hover: ReturnType<typeof signal<PickTarget | null>>;
-} {
-  const selection = signal<PickTarget | null>(null);
-  const hover = signal<PickTarget | null>(null);
-  const ctx = {
-    scene: new THREE.Scene(),
-    canvas: document.createElement('canvas'),
-    picker: { selection, hover } as unknown as Picker,
-    cityState: makeCityState(),
-  } as unknown as SceneContext;
-  return { ctx, selection, hover };
-}
 
 // Pre-picker ctx: picker null (the construction-time window). Used to prove the
 // theme effect is safe to run at construction and the overlays do NOT arm.
@@ -122,6 +107,7 @@ describe('createBuildings()', () => {
 
   afterEach(() => {
     buildings?.dispose();
+    TIMELINE_MODE.value = false;
   });
 
   // ---------------------------------------------------------------------------
@@ -129,7 +115,7 @@ describe('createBuildings()', () => {
   // ---------------------------------------------------------------------------
 
   it('constructs with an empty named group (pre-rebuild), no throws', () => {
-    const { ctx } = makeCtx();
+    const { ctx } = makePickableSceneContext();
     buildings = createBuildings(ctx);
     expect(buildings.group).toBeInstanceOf(THREE.Group);
     expect(buildings.group.name).toBe('city-buildings');
@@ -151,7 +137,7 @@ describe('createBuildings()', () => {
   // ---------------------------------------------------------------------------
 
   it('rebuild() populates the group, cells, index, and lookups', async () => {
-    const { ctx } = makeCtx();
+    const { ctx } = makePickableSceneContext();
     buildings = createBuildings(ctx);
 
     const b0 = building({ x: 10, y: 10, h: 4, file: fileOf('src/a.ts') as never });
@@ -181,8 +167,35 @@ describe('createBuildings()', () => {
     expect(resolved!.slot).toBe(b0.slotId);
   });
 
+  it('rebuild() drops a scrub controller installed for the previous city', async () => {
+    // Same hazard the tween queue already guards: the controller holds the old
+    // manifest's Buildings, whose cellId/slotId resolve into the NEW cells.
+    const { ctx } = makePickableSceneContext();
+    buildings = createBuildings(ctx);
+    TIMELINE_MODE.value = true;
+
+    const oldA = building({ x: 10, y: 10, h: 4, file: fileOf('old/a.ts') as never });
+    await buildings.rebuild(buildingLayout([oldA]), EMPTY_DATE_RANGES);
+
+    const controller = { update: vi.fn() };
+    buildings.setScrubController(controller);
+    buildings.tick(0, { camera: CAMERA } as never);
+    expect(controller.update, 'sanity: driven while its city is live').toHaveBeenCalled();
+    controller.update.mockClear();
+
+    // A different repo lands while Timeline is still flagged on.
+    const newA = building({ x: 10, y: 10, h: 4, file: fileOf('new/a.ts') as never });
+    await buildings.rebuild(buildingLayout([newA]), EMPTY_DATE_RANGES);
+    buildings.tick(0, { camera: CAMERA } as never);
+
+    expect(
+      controller.update,
+      'a controller from the previous city must not keep writing into this one'
+    ).not.toHaveBeenCalled();
+  });
+
   it('rebuild() colors the buildings (writes b.color from the date ranges)', async () => {
-    const { ctx } = makeCtx();
+    const { ctx } = makePickableSceneContext();
     buildings = createBuildings(ctx);
     const b0 = building({ x: 1, y: 1, color: '__unset__', file: fileOf('src/a.ts') as never });
     await buildings.rebuild(buildingLayout([b0]), EMPTY_DATE_RANGES);
@@ -193,7 +206,7 @@ describe('createBuildings()', () => {
   });
 
   it('rebuild() disposes the prior cell root WITHOUT freeing the shared material', async () => {
-    const { ctx } = makeCtx();
+    const { ctx } = makePickableSceneContext();
     buildings = createBuildings(ctx);
 
     await buildings.rebuild(
@@ -230,7 +243,7 @@ describe('createBuildings()', () => {
   // ---------------------------------------------------------------------------
 
   it('material effect re-applies uOutlineWidth on BUILDINGS Save', async () => {
-    const { ctx } = makeCtx();
+    const { ctx } = makePickableSceneContext();
     buildings = createBuildings(ctx);
     // Force the shared material to exist (created lazily during rebuild).
     await buildings.rebuild(
@@ -247,7 +260,7 @@ describe('createBuildings()', () => {
   });
 
   it('fog falloff reaches the shader as the raw fraction, unscaled by any city height', async () => {
-    const { ctx } = makeCtx();
+    const { ctx } = makePickableSceneContext();
     buildings = createBuildings(ctx);
     await buildings.rebuild(
       buildingLayout([building({ x: 1, y: 1, file: fileOf('src/a.ts') as never })]),
@@ -263,7 +276,7 @@ describe('createBuildings()', () => {
   });
 
   it('ruin cross uniforms track the RUINS store', async () => {
-    const { ctx } = makeCtx();
+    const { ctx } = makePickableSceneContext();
     buildings = createBuildings(ctx);
     await buildings.rebuild(
       buildingLayout([building({ x: 1, y: 1, file: fileOf('src/a.ts') as never })]),
@@ -291,7 +304,7 @@ describe('createBuildings()', () => {
   // ---------------------------------------------------------------------------
 
   it('does NOT arm the overlays before the first tick (no ghost mesh in scene)', async () => {
-    const { ctx, hover } = makeCtx();
+    const { ctx, hover } = makePickableSceneContext();
     buildings = createBuildings(ctx);
     const b0 = building({ x: 5, y: 5, file: fileOf('src/a.ts') as never });
     await buildings.rebuild(buildingLayout([b0]), EMPTY_DATE_RANGES);
@@ -309,7 +322,7 @@ describe('createBuildings()', () => {
   });
 
   it('arms overlays on first tick; a later hover drives the ghost overlay', async () => {
-    const { ctx, hover } = makeCtx();
+    const { ctx, hover } = makePickableSceneContext();
     buildings = createBuildings(ctx);
     const b0 = building({ x: 5, y: 5, file: fileOf('src/a.ts') as never });
     await buildings.rebuild(buildingLayout([b0]), EMPTY_DATE_RANGES);
@@ -339,7 +352,7 @@ describe('createBuildings()', () => {
   // ---------------------------------------------------------------------------
 
   it('the FIRST rebuild (boot) does NOT fire enter tweens — the city snaps in', async () => {
-    const { ctx } = makeCtx();
+    const { ctx } = makePickableSceneContext();
     buildings = createBuildings(ctx);
 
     const b0 = building({ x: 10, y: 10, h: 8, file: fileOf('src/a.ts') as never });
@@ -368,7 +381,7 @@ describe('createBuildings()', () => {
   });
 
   it('a SECOND rebuild introducing a new building fires its enter tween through tick() and lands the final transform', async () => {
-    const { ctx } = makeCtx();
+    const { ctx } = makePickableSceneContext();
     buildings = createBuildings(ctx);
     // Isolate the tween's scale+position landing from the age-lean shear (baked
     // into the instance matrix, tilt.ts) — otherwise the landed X/Z carry the
@@ -418,7 +431,7 @@ describe('createBuildings()', () => {
   // ---------------------------------------------------------------------------
 
   it('dispose() empties the group, removes overlays, and stops the material effect', async () => {
-    const { ctx } = makeCtx();
+    const { ctx } = makePickableSceneContext();
     buildings = createBuildings(ctx);
     await buildings.rebuild(
       buildingLayout([building({ x: 1, y: 1, file: fileOf('src/a.ts') as never })]),
diff --git a/app/tests/city/components/fireflies/index.test.ts b/app/tests/city/components/fireflies/index.test.ts
index 536182550..941f4b912 100644
--- a/app/tests/city/components/fireflies/index.test.ts
+++ b/app/tests/city/components/fireflies/index.test.ts
@@ -14,10 +14,9 @@
 
 import { describe, it, expect, beforeEach, afterEach } from 'vitest';
 import * as THREE from 'three';
-import { signal } from '@preact/signals';
 
 import { createFireflies } from '@/city/components/fireflies';
-import { makeCityState } from '../../../_helpers/cityFixtures';
+import { makeCityState, makePickableSceneContext } from '../../../_helpers/cityFixtures';
 import { FIREFLIES } from '@/state/stores/settings/fireflies';
 import { NodeKind } from '@/types';
 import type { CommitEntry } from '@/types';
@@ -39,22 +38,6 @@ const PLACEMENTS: TreePlacement[] = [{ x: 0, y: 0, seed: 0, commitIndex: 0 } as
 
 const _origFireflies = FIREFLIES.value;
 
-function makeCtx(): {
-  ctx: SceneContext;
-  selection: ReturnType<typeof signal<PickTarget | null>>;
-  hover: ReturnType<typeof signal<PickTarget | null>>;
-} {
-  const selection = signal<PickTarget | null>(null);
-  const hover = signal<PickTarget | null>(null);
-  const ctx = {
-    scene: new THREE.Scene(),
-    canvas: document.createElement('canvas'),
-    picker: { selection, hover } as unknown as Picker,
-    cityState: makeCityState(),
-  } as unknown as SceneContext;
-  return { ctx, selection, hover };
-}
-
 function makePrePickerCtx(): SceneContext {
   return {
     scene: new THREE.Scene(),
@@ -111,7 +94,7 @@ describe('createFireflies() component door', () => {
   });
 
   it('rebuild() builds the inner assembly under the group; clear() empties + nulls', () => {
-    const { ctx } = makeCtx();
+    const { ctx } = makePickableSceneContext();
     comp = createFireflies(ctx);
     comp.rebuild(PLACEMENTS, COMMITS, commitStats(COMMITS));
     // The inner assembly's group is the sole child of the component group.
@@ -124,7 +107,7 @@ describe('createFireflies() component door', () => {
   });
 
   it('rebuild() disposes the prior assembly (no accumulation)', () => {
-    const { ctx } = makeCtx();
+    const { ctx } = makePickableSceneContext();
     comp = createFireflies(ctx);
     comp.rebuild(PLACEMENTS, COMMITS, commitStats(COMMITS));
     const first = comp.group.children[0];
@@ -135,7 +118,7 @@ describe('createFireflies() component door', () => {
   });
 
   it('theme effect pushes fresh animation uniforms on FIREFLIES Save', () => {
-    const { ctx } = makeCtx();
+    const { ctx } = makePickableSceneContext();
     comp = createFireflies(ctx);
     comp.rebuild(PLACEMENTS, COMMITS, commitStats(COMMITS));
     const u = orbUniforms(comp);
@@ -144,7 +127,7 @@ describe('createFireflies() component door', () => {
   });
 
   it('tick() writes frame.time into the bob uTime uniform', () => {
-    const { ctx } = makeCtx();
+    const { ctx } = makePickableSceneContext();
     comp = createFireflies(ctx);
     comp.rebuild(PLACEMENTS, COMMITS, commitStats(COMMITS));
     comp.tick(0, FRAME(CAMERA, 4.5));
@@ -152,7 +135,7 @@ describe('createFireflies() component door', () => {
   });
 
   it('does NOT boost a hover set before the first tick; arming pushes it in', () => {
-    const { ctx, hover } = makeCtx();
+    const { ctx, hover } = makePickableSceneContext();
     comp = createFireflies(ctx);
     comp.rebuild(PLACEMENTS, COMMITS, commitStats(COMMITS));
     const u = orbUniforms(comp);
@@ -171,7 +154,7 @@ describe('createFireflies() component door', () => {
   });
 
   it('select boost follows picker.selection after arming', () => {
-    const { ctx, selection } = makeCtx();
+    const { ctx, selection } = makePickableSceneContext();
     comp = createFireflies(ctx);
     comp.rebuild(PLACEMENTS, COMMITS, commitStats(COMMITS));
     comp.tick(0, FRAME(CAMERA));
@@ -184,7 +167,7 @@ describe('createFireflies() component door', () => {
   });
 
   it('REBUILD-SURVIVAL: boost effects reach the NEW inner on the next signal change', () => {
-    const { ctx, hover } = makeCtx();
+    const { ctx, hover } = makePickableSceneContext();
     comp = createFireflies(ctx);
     comp.rebuild(PLACEMENTS, COMMITS, commitStats(COMMITS));
     comp.tick(0, FRAME(CAMERA)); // arm
@@ -203,7 +186,7 @@ describe('createFireflies() component door', () => {
   });
 
   it('onResize(w, h) is safe before and after the inner assembly is built', () => {
-    const { ctx } = makeCtx();
+    const { ctx } = makePickableSceneContext();
     comp = createFireflies(ctx);
     expect(() => comp.onResize(800, 600)).not.toThrow(); // null inner → no-op
     comp.rebuild(PLACEMENTS, COMMITS, commitStats(COMMITS));
@@ -211,7 +194,7 @@ describe('createFireflies() component door', () => {
   });
 
   it('dispose() empties the group and stops all effects', () => {
-    const { ctx, hover } = makeCtx();
+    const { ctx, hover } = makePickableSceneContext();
     comp = createFireflies(ctx);
     comp.rebuild(PLACEMENTS, COMMITS, commitStats(COMMITS));
     comp.tick(0, FRAME(CAMERA)); // arm
diff --git a/app/tests/city/components/footprint/index.test.ts b/app/tests/city/components/footprint/index.test.ts
index ae31e3fae..f4f7fc983 100644
--- a/app/tests/city/components/footprint/index.test.ts
+++ b/app/tests/city/components/footprint/index.test.ts
@@ -11,9 +11,7 @@ import { createFootprint } from '@/city/components/footprint';
 import { FOOTPRINT } from '@/state/stores/settings/footprint';
 import { StreetAxis } from '@/types';
 import type { CityLayout } from '@/types';
-import type { Picker } from '@/city/interaction/picker';
-import type { SceneContext } from '@/city/types';
-import { makeCityState } from '../../../_helpers/cityFixtures';
+import { makeSceneContext } from '../../../_helpers/cityFixtures';
 
 function resetFootprint() {
   FOOTPRINT.value = { ENABLED: true, HALO_WIDTH: 32, CORNER_RADIUS: 1.25, COLOR: '#0a0b0f' };
@@ -21,15 +19,6 @@ function resetFootprint() {
 
 // footprint reads ctx.cityState for its layout effect; layout stays null here
 // (effect no-ops) and tests drive rebuild() directly.
-function makeCtx(): SceneContext {
-  return {
-    scene: new THREE.Scene(),
-    picker: null as unknown as Picker,
-    camera: null as unknown as THREE.PerspectiveCamera,
-    renderer: null as unknown as THREE.WebGLRenderer,
-    cityState: makeCityState(),
-  } as unknown as SceneContext;
-}
 
 function singleBuildingLayout(): CityLayout {
   return {
@@ -56,7 +45,7 @@ describe('createFootprint()', () => {
 
   beforeEach(() => {
     resetFootprint();
-    fp = createFootprint(makeCtx());
+    fp = createFootprint(makeSceneContext());
   });
 
   afterEach(() => {
diff --git a/app/tests/city/components/gem/gem.test.ts b/app/tests/city/components/gem/gem.test.ts
index 61b05521f..2202db466 100644
--- a/app/tests/city/components/gem/gem.test.ts
+++ b/app/tests/city/components/gem/gem.test.ts
@@ -1,9 +1,8 @@
 import { describe, it, expect, afterEach } from 'vitest';
 import * as THREE from 'three';
-import { signal } from '@preact/signals';
 
 import { createGem } from '@/city/components/gem';
-import { makeCityState } from '../../../_helpers/cityFixtures';
+import { makeCityState, makePickableSceneContext } from '../../../_helpers/cityFixtures';
 import { GEM } from '@/state/stores/settings/gem';
 import { NodeKind, StreetAxis } from '@/types';
 import type { Street, PickTarget } from '@/types';
@@ -25,19 +24,6 @@ function makeStreet(): Street {
 }
 
 // Build a SceneContext whose picker exposes a controllable hover signal.
-function makeCtx(hover: PickTarget | null): {
-  ctx: SceneContext;
-  hover: ReturnType<typeof signal<PickTarget | null>>;
-} {
-  const hoverSig = signal<PickTarget | null>(hover);
-  const ctx = {
-    scene: new THREE.Scene(),
-    canvas: document.createElement('canvas'),
-    picker: { hover: hoverSig } as unknown as Picker,
-    cityState: makeCityState(),
-  } as unknown as SceneContext;
-  return { ctx, hover: hoverSig };
-}
 
 const CAMERA = new THREE.PerspectiveCamera();
 
@@ -67,7 +53,7 @@ describe('createGem()', () => {
   });
 
   it('rebuild(street) builds an inner gem with a Gem-typed body and per-face color attribute', () => {
-    const { ctx } = makeCtx(null);
+    const { ctx } = makePickableSceneContext();
     gem = createGem(ctx);
     gem.rebuild(makeStreet());
 
@@ -81,7 +67,7 @@ describe('createGem()', () => {
   });
 
   it('rebuild disposes the prior inner gem and swaps in the new one', () => {
-    const { ctx } = makeCtx(null);
+    const { ctx } = makePickableSceneContext();
     gem = createGem(ctx);
     gem.rebuild(makeStreet());
     const first = gem.getRootGroup()!;
@@ -92,7 +78,8 @@ describe('createGem()', () => {
   });
 
   it('tick lerps gem.scale toward HOVER_SCALE when a Gem is hovered', () => {
-    const { ctx } = makeCtx({ kind: NodeKind.Gem } as PickTarget);
+    const { ctx, hover } = makePickableSceneContext();
+    hover.value = { kind: NodeKind.Gem } as PickTarget;
     gem = createGem(ctx);
     gem.rebuild(makeStreet());
 
@@ -105,7 +92,7 @@ describe('createGem()', () => {
   });
 
   it('dispose() stops the effect — later GEM mutations do not throw', () => {
-    const { ctx } = makeCtx(null);
+    const { ctx } = makePickableSceneContext();
     gem = createGem(ctx);
     gem.rebuild(makeStreet());
     gem.dispose();
diff --git a/app/tests/city/components/pathLine/index.test.ts b/app/tests/city/components/pathLine/index.test.ts
index f731abfac..376b348e4 100644
--- a/app/tests/city/components/pathLine/index.test.ts
+++ b/app/tests/city/components/pathLine/index.test.ts
@@ -15,19 +15,16 @@
 
 import { describe, it, expect, beforeEach, afterEach } from 'vitest';
 import * as THREE from 'three';
-import { signal } from '@preact/signals';
 import { LineSegments2 } from 'three/addons/lines/LineSegments2.js';
 
 import { createPathLine } from '@/city/components/pathLine';
 import { createCityState } from '@/city/state';
-import { makeCityState } from '../../../_helpers/cityFixtures';
+import { makeCityState, makePickableSceneContext } from '../../../_helpers/cityFixtures';
 import { computePathLinewidthPixels } from '@/city/components/pathLine/renderer';
 import { STREETS } from '@/state/stores/settings/streets';
 import { NodeKind, StreetAxis } from '@/types';
 import type { CityLayout, Street } from '@/types';
 import type { PickTarget } from '@/types/picker';
-import type { Picker } from '@/city/interaction/picker';
-import type { SceneContext } from '@/city/types';
 
 const DEFAULTS = {
   ASPHALT_COLOR: '#313544',
@@ -44,25 +41,6 @@ const DEFAULTS = {
   HOVER_PATH_OPACITY: 0.25,
 };
 
-function makeCtx(cityState: ReturnType<typeof createCityState>): {
-  ctx: SceneContext;
-  selection: ReturnType<typeof signal<PickTarget | null>>;
-  hover: ReturnType<typeof signal<PickTarget | null>>;
-} {
-  const selection = signal<PickTarget | null>(null);
-  const hover = signal<PickTarget | null>(null);
-  const canvas = document.createElement('canvas');
-  Object.defineProperty(canvas, 'clientWidth', { value: 800 });
-  Object.defineProperty(canvas, 'clientHeight', { value: 600 });
-  const ctx = {
-    scene: new THREE.Scene(),
-    canvas,
-    picker: { selection, hover } as unknown as Picker,
-    cityState,
-  } as unknown as SceneContext;
-  return { ctx, selection, hover };
-}
-
 const SRC_STREET = {
   x: 0,
   y: 0,
@@ -125,7 +103,7 @@ describe('createPathLine() component door', () => {
 
   it('constructs with an empty named group; nothing armed, nothing subscribed', () => {
     const { cityState, counters } = makeSeeded();
-    const { ctx, selection } = makeCtx(cityState);
+    const { ctx, selection } = makePickableSceneContext(cityState);
     comp = createPathLine(ctx);
     expect(comp.group.name).toBe('city-path-line');
     expect(comp.group.children).toHaveLength(0);
@@ -142,7 +120,7 @@ describe('createPathLine() component door', () => {
 
   it('first tick() arms the inner renderer: two line meshes + a live rebuild effect', () => {
     const { cityState, counters } = makeSeeded();
-    const { ctx } = makeCtx(cityState);
+    const { ctx } = makePickableSceneContext(cityState);
     comp = createPathLine(ctx);
     comp.tick(0, FRAME());
     expect(lines(comp)).toHaveLength(2);
@@ -158,7 +136,7 @@ describe('createPathLine() component door', () => {
 
   it('a selection after arming shows the selection path line; clearing hides it', () => {
     const { cityState } = makeSeeded();
-    const { ctx, selection } = makeCtx(cityState);
+    const { ctx, selection } = makePickableSceneContext(cityState);
     comp = createPathLine(ctx);
     comp.tick(0, FRAME());
     const [pathLine] = lines(comp);
@@ -177,7 +155,7 @@ describe('createPathLine() component door', () => {
 
   it('theme effect pushes a fresh linewidth into both materials on STREETS Save', () => {
     const { cityState } = makeSeeded();
-    const { ctx } = makeCtx(cityState);
+    const { ctx } = makePickableSceneContext(cityState);
     comp = createPathLine(ctx);
     comp.tick(0, FRAME());
     STREETS.value = { ...STREETS.value, PATH_LINEWIDTH_PCT: 25 };
@@ -192,7 +170,7 @@ describe('createPathLine() component door', () => {
 
   it('untracked discipline: a hover change fires ONLY the hover effect, not the theme effect', () => {
     const { cityState, counters } = makeSeeded();
-    const { ctx, hover } = makeCtx(cityState);
+    const { ctx, hover } = makePickableSceneContext(cityState);
     comp = createPathLine(ctx);
     comp.tick(0, FRAME());
 
@@ -206,7 +184,7 @@ describe('createPathLine() component door', () => {
 
   it('dispose() stops the rebuild effect + all picker effects', () => {
     const { cityState, counters } = makeSeeded();
-    const { ctx, selection } = makeCtx(cityState);
+    const { ctx, selection } = makePickableSceneContext(cityState);
     comp = createPathLine(ctx);
     comp.tick(0, FRAME());
 
diff --git a/app/tests/city/components/repoLabel/repoLabel.test.ts b/app/tests/city/components/repoLabel/repoLabel.test.ts
index 434c6c1da..7421a6183 100644
--- a/app/tests/city/components/repoLabel/repoLabel.test.ts
+++ b/app/tests/city/components/repoLabel/repoLabel.test.ts
@@ -10,9 +10,8 @@ import * as THREE from 'three';
 import { createRepoLabel } from '@/city/components/repoLabel';
 import { REPO_LABEL } from '@/state/stores/settings/gem';
 import { RENDER_ORDERS } from '@/city/types/renderOrders';
-import { makeCityState, resetBuildingsConfig } from '../../../_helpers/cityFixtures';
-import type { Picker } from '@/city/interaction/picker';
-import type { FrameContext, SceneContext } from '@/city/types';
+import { resetBuildingsConfig, makeSceneContext } from '../../../_helpers/cityFixtures';
+import type { FrameContext } from '@/city/types';
 
 // Positioning math below assumes BUILDING_DIMENSIONS.MAX_FLOORS=96,
 // FLOOR_HEIGHT=16 → maxBldgH = 1536. resetBuildingsConfig pins both so
@@ -31,15 +30,6 @@ function resetStore() {
 }
 
 // The repoLabel uses nothing from ctx at construction; a minimal stub suffices.
-function makeCtx(): SceneContext {
-  return {
-    scene: new THREE.Scene(),
-    picker: null as unknown as Picker,
-    camera: null as unknown as THREE.PerspectiveCamera,
-    renderer: null as unknown as THREE.WebGLRenderer,
-    cityState: makeCityState(),
-  } as unknown as SceneContext;
-}
 
 function makeFrame(camera: THREE.Camera): FrameContext {
   return { dt: 0.016, time: 0, camera: camera as THREE.PerspectiveCamera };
@@ -50,7 +40,7 @@ describe('createRepoLabel()', () => {
 
   beforeEach(() => {
     resetStore();
-    label = createRepoLabel(makeCtx(), { getGem: () => null });
+    label = createRepoLabel(makeSceneContext(), { getGem: () => null });
   });
 
   afterEach(() => {
diff --git a/app/tests/city/components/repoLabel/repoLabelPositioning.test.ts b/app/tests/city/components/repoLabel/repoLabelPositioning.test.ts
index d38398d36..b1f840d24 100644
--- a/app/tests/city/components/repoLabel/repoLabelPositioning.test.ts
+++ b/app/tests/city/components/repoLabel/repoLabelPositioning.test.ts
@@ -13,9 +13,7 @@ import { describe, it, expect, beforeEach, afterEach } from 'vitest';
 import * as THREE from 'three';
 import { createRepoLabel } from '@/city/components/repoLabel';
 import { REPO_LABEL } from '@/state/stores/settings/gem';
-import { makeCityState, resetBuildingsConfig } from '../../../_helpers/cityFixtures';
-import type { Picker } from '@/city/interaction/picker';
-import type { SceneContext } from '@/city/types';
+import { resetBuildingsConfig, makeSceneContext } from '../../../_helpers/cityFixtures';
 
 // Positioning math below assumes BUILDING_DIMENSIONS.MAX_FLOORS=96,
 // FLOOR_HEIGHT=16 → maxBldgH = 1536. resetBuildingsConfig pins both so
@@ -34,21 +32,12 @@ function resetStore() {
 }
 
 // The repoLabel uses nothing from ctx at construction; a minimal stub suffices.
-function makeCtx(): SceneContext {
-  return {
-    scene: new THREE.Scene(),
-    picker: null as unknown as Picker,
-    camera: null as unknown as THREE.PerspectiveCamera,
-    renderer: null as unknown as THREE.WebGLRenderer,
-    cityState: makeCityState(),
-  } as unknown as SceneContext;
-}
 
 describe('RepoLabel positioning', () => {
   let label: ReturnType<typeof createRepoLabel>;
   beforeEach(() => {
     resetStore();
-    label = createRepoLabel(makeCtx(), { getGem: () => null });
+    label = createRepoLabel(makeSceneContext(), { getGem: () => null });
     label.setRepoName('codecity');
   });
   afterEach(() => label.dispose());
diff --git a/app/tests/city/components/scenicReactivity.test.ts b/app/tests/city/components/scenicReactivity.test.ts
index c50d34a9b..9188a54d4 100644
--- a/app/tests/city/components/scenicReactivity.test.ts
+++ b/app/tests/city/components/scenicReactivity.test.ts
@@ -18,26 +18,13 @@
 import { describe, it, expect, afterEach } from 'vitest';
 import * as THREE from 'three';
 
-import { createCityState } from '@/city/state';
-import { makeCityState } from '../../_helpers/cityFixtures';
+import { makeCityState, makeSceneContext } from '../../_helpers/cityFixtures';
 import { createStreets } from '@/city/components/streets';
 import { createGem } from '@/city/components/gem';
 import { createIsland } from '@/city/components/island';
 import { createRepoLabel } from '@/city/components/repoLabel';
 import { NodeKind, StreetAxis } from '@/types';
 import type { CityLayout, Manifest, Street } from '@/types';
-import type { Picker } from '@/city/interaction/picker';
-import type { SceneContext } from '@/city/types';
-
-function makeCtx(cityState: ReturnType<typeof createCityState>): SceneContext {
-  return {
-    scene: new THREE.Scene(),
-    picker: null as unknown as Picker,
-    camera: null as unknown as THREE.PerspectiveCamera,
-    renderer: null as unknown as THREE.WebGLRenderer,
-    cityState,
-  } as unknown as SceneContext;
-}
 
 function makeRootStreet(): Street {
   return {
@@ -91,7 +78,7 @@ describe('scenic reactivity — structureRevision gates rebuilds', () => {
 
   it('streets: rebuilds on a structure change, skips on a reuse apply', () => {
     const cityState = makeCityState();
-    const streets = createStreets(makeCtx(cityState));
+    const streets = createStreets(makeSceneContext(cityState));
     disposers.push(() => streets.dispose());
 
     // First structure apply (structureRevision bumps) → rebuild swaps in a fresh
@@ -114,7 +101,7 @@ describe('scenic reactivity — structureRevision gates rebuilds', () => {
 
   it('gem: rebuilds on a structure change, skips on a reuse apply', () => {
     const cityState = makeCityState();
-    const gem = createGem(makeCtx(cityState));
+    const gem = createGem(makeSceneContext(cityState));
     disposers.push(() => gem.dispose());
 
     applyStructure(cityState, makeLayout());
@@ -143,7 +130,7 @@ describe('scenic reactivity — structureRevision gates rebuilds', () => {
 
   it('island: resizes on a structure change, skips on a reuse apply', () => {
     const cityState = makeCityState();
-    const island = createIsland(makeCtx(cityState));
+    const island = createIsland(makeSceneContext(cityState));
     disposers.push(() => island.dispose());
 
     // The island mesh is group.children[0]; setBounds swaps its geometry.
@@ -168,7 +155,7 @@ describe('scenic reactivity — structureRevision gates rebuilds', () => {
 
   it('repoLabel: repositions on every manifest change (name + anchor)', () => {
     const cityState = makeCityState();
-    const label = createRepoLabel(makeCtx(cityState), { getGem: () => null });
+    const label = createRepoLabel(makeSceneContext(cityState), { getGem: () => null });
     disposers.push(() => label.dispose());
 
     cityState.manifest.value = makeManifest('repo-a');
diff --git a/app/tests/city/components/sky/sky.test.ts b/app/tests/city/components/sky/sky.test.ts
index cfd7f5267..4d83222ab 100644
--- a/app/tests/city/components/sky/sky.test.ts
+++ b/app/tests/city/components/sky/sky.test.ts
@@ -11,8 +11,8 @@ import * as THREE from 'three';
 import { createSky } from '@/city/components/sky';
 import { SCENE } from '@/state/stores/settings/scene';
 import { RENDER_ORDERS } from '@/city/types/renderOrders';
-import type { Picker } from '@/city/interaction/picker';
-import type { FrameContext, SceneContext } from '@/city/types';
+import type { FrameContext } from '@/city/types';
+import { makeSceneContext } from '../../../_helpers/cityFixtures';
 
 function resetStores() {
   SCENE.value = {
@@ -26,21 +26,13 @@ function resetStores() {
 }
 
 // The sky uses nothing from ctx at construction; a minimal stub suffices.
-function makeCtx(): SceneContext {
-  return {
-    scene: new THREE.Scene(),
-    picker: null as unknown as Picker,
-    camera: null as unknown as THREE.PerspectiveCamera,
-    renderer: null as unknown as THREE.WebGLRenderer,
-  } as unknown as SceneContext;
-}
 
 describe('createSky()', () => {
   let sky: ReturnType<typeof createSky>;
 
   beforeEach(() => {
     resetStores();
-    sky = createSky(makeCtx());
+    sky = createSky(makeSceneContext());
   });
 
   afterEach(() => {
diff --git a/app/tests/city/components/streets/index.test.ts b/app/tests/city/components/streets/index.test.ts
index 22046502c..058dc576e 100644
--- a/app/tests/city/components/streets/index.test.ts
+++ b/app/tests/city/components/streets/index.test.ts
@@ -12,10 +12,9 @@
 // fix: a selection set AFTER the first tick must re-tint the sidewalk.
 import { describe, it, expect, beforeEach, afterEach } from 'vitest';
 import * as THREE from 'three';
-import { signal } from '@preact/signals';
 
 import { createStreets } from '@/city/components/streets';
-import { makeCityState } from '../../../_helpers/cityFixtures';
+import { makeCityState, makePickableSceneContext } from '../../../_helpers/cityFixtures';
 import { STREETS } from '@/state/stores/settings/streets';
 import { NodeKind, StreetAxis } from '@/types';
 import type { CityLayout, PickTarget, Street } from '@/types';
@@ -42,21 +41,6 @@ function resetStreets() {
 }
 
 // A SceneContext whose picker exposes controllable selection + hover signals.
-function makeCtx(): {
-  ctx: SceneContext;
-  selection: ReturnType<typeof signal<PickTarget | null>>;
-  hover: ReturnType<typeof signal<PickTarget | null>>;
-} {
-  const selection = signal<PickTarget | null>(null);
-  const hover = signal<PickTarget | null>(null);
-  const ctx = {
-    scene: new THREE.Scene(),
-    canvas: document.createElement('canvas'),
-    picker: { selection, hover } as unknown as Picker,
-    cityState: makeCityState(),
-  } as unknown as SceneContext;
-  return { ctx, selection, hover };
-}
 
 function makeStreet(overrides: Partial<Street> = {}): Street {
   return {
@@ -130,7 +114,7 @@ describe('createStreets()', () => {
   // ---------------------------------------------------------------------------
 
   it('constructs with an empty named group (pre-rebuild), no throws', () => {
-    const { ctx } = makeCtx();
+    const { ctx } = makePickableSceneContext();
     streets = createStreets(ctx);
     expect(streets.group).toBeInstanceOf(THREE.Group);
     expect(streets.group.name).toBe('city-streets');
@@ -157,7 +141,7 @@ describe('createStreets()', () => {
   // ---------------------------------------------------------------------------
 
   it('rebuild() populates group.children, pickables, asphalt, and labels', () => {
-    const { ctx } = makeCtx();
+    const { ctx } = makePickableSceneContext();
     streets = createStreets(ctx);
     streets.rebuild(singleStreetLayout());
 
@@ -170,7 +154,7 @@ describe('createStreets()', () => {
   });
 
   it('rebuild() builds the sidewalk lookup keyed by street dir.path', () => {
-    const { ctx } = makeCtx();
+    const { ctx } = makePickableSceneContext();
     streets = createStreets(ctx);
     streets.rebuild(
       singleStreetLayout({
@@ -184,7 +168,7 @@ describe('createStreets()', () => {
   });
 
   it('rebuild() disposes the prior street set and rebuilds (no leak in group)', () => {
-    const { ctx } = makeCtx();
+    const { ctx } = makePickableSceneContext();
     streets = createStreets(ctx);
     streets.rebuild(singleStreetLayout());
     const firstSidewalk = streets.getPickables()[0];
@@ -206,7 +190,7 @@ describe('createStreets()', () => {
   // ---------------------------------------------------------------------------
 
   it('theme effect recolors asphalt on STREETS.ASPHALT_COLOR mutation', () => {
-    const { ctx } = makeCtx();
+    const { ctx } = makePickableSceneContext();
     streets = createStreets(ctx);
     streets.rebuild(singleStreetLayout());
 
@@ -216,7 +200,7 @@ describe('createStreets()', () => {
   });
 
   it('theme effect resets sidewalk origColor + tint on SIDEWALK_DEFAULT mutation', () => {
-    const { ctx } = makeCtx();
+    const { ctx } = makePickableSceneContext();
     streets = createStreets(ctx);
     streets.rebuild(singleStreetLayout());
 
@@ -227,7 +211,7 @@ describe('createStreets()', () => {
   });
 
   it('theme effect rescales label height on LABEL_HEIGHT_FRAC mutation', () => {
-    const { ctx } = makeCtx();
+    const { ctx } = makePickableSceneContext();
     streets = createStreets(ctx);
     streets.rebuild(singleStreetLayout());
     const label = labelsOf(streets)[0];
@@ -244,7 +228,7 @@ describe('createStreets()', () => {
   // ---------------------------------------------------------------------------
 
   it('does NOT re-tint on selection before the first tick (effects not yet armed)', () => {
-    const { ctx, selection } = makeCtx();
+    const { ctx, selection } = makePickableSceneContext();
     streets = createStreets(ctx);
     streets.rebuild(singleStreetLayout());
     const sw = streets.getPickables()[0];
@@ -261,7 +245,7 @@ describe('createStreets()', () => {
   });
 
   it('arms picker-tint effects on first tick; a later selection re-tints to SELECTED', () => {
-    const { ctx, selection } = makeCtx();
+    const { ctx, selection } = makePickableSceneContext();
     streets = createStreets(ctx);
     streets.rebuild(singleStreetLayout());
     const sw = streets.getPickables()[0];
@@ -286,7 +270,7 @@ describe('createStreets()', () => {
   });
 
   it('arms hover tinting; hovering this sidewalk paints SIDEWALK_HOVER', () => {
-    const { ctx, hover } = makeCtx();
+    const { ctx, hover } = makePickableSceneContext();
     streets = createStreets(ctx);
     streets.rebuild(singleStreetLayout());
     const sw = streets.getPickables()[0];
@@ -302,8 +286,8 @@ describe('createStreets()', () => {
   });
 
   it('tick() hides labels that project too small (visibility LOD) and re-shows up close', () => {
-    const { ctx } = makeCtx();
-    Object.defineProperty(ctx.canvas, 'clientHeight', { value: 800, configurable: true });
+    const { ctx, size } = makePickableSceneContext();
+    size.h = 800;
     streets = createStreets(ctx);
     streets.rebuild(singleStreetLayout());
     const label = labelsOf(streets)[0];
@@ -331,7 +315,7 @@ describe('createStreets()', () => {
   // ---------------------------------------------------------------------------
 
   it('tick() flips a label past the −0.15 hysteresis and un-flips past +0.15', () => {
-    const { ctx } = makeCtx();
+    const { ctx } = makePickableSceneContext();
     streets = createStreets(ctx);
     streets.rebuild(singleStreetLayout()); // X-oriented → uses rightX
     const label = labelsOf(streets)[0];
@@ -365,7 +349,7 @@ describe('createStreets()', () => {
   // ---------------------------------------------------------------------------
 
   it('dispose() empties the group and stops effects (later STREETS mutations no-op)', () => {
-    const { ctx, selection } = makeCtx();
+    const { ctx, selection } = makePickableSceneContext();
     streets = createStreets(ctx);
     streets.rebuild(singleStreetLayout());
     streets.tick(0.016, { dt: 0.016, time: 0, camera: cameraRight(1) });
diff --git a/app/tests/city/components/streets/streetOpacity.test.ts b/app/tests/city/components/streets/streetOpacity.test.ts
index 7eb843201..78973f663 100644
--- a/app/tests/city/components/streets/streetOpacity.test.ts
+++ b/app/tests/city/components/streets/streetOpacity.test.ts
@@ -8,15 +8,12 @@
 
 import { describe, it, expect, beforeEach, afterEach } from 'vitest';
 import * as THREE from 'three';
-import { signal } from '@preact/signals';
 
 import { createStreets } from '@/city/components/streets';
-import { makeCityState } from '../../../_helpers/cityFixtures';
+import { makeSceneContext } from '../../../_helpers/cityFixtures';
 import { STREETS } from '@/state/stores/settings/streets';
 import { NodeKind, StreetAxis } from '@/types';
-import type { CityLayout, PickTarget, Street } from '@/types';
-import type { Picker } from '@/city/interaction/picker';
-import type { SceneContext } from '@/city/types';
+import type { CityLayout, Street } from '@/types';
 
 const DEFAULTS = {
   ASPHALT_COLOR: '#313544',
@@ -33,18 +30,6 @@ const DEFAULTS = {
   HOVER_PATH_OPACITY: 0.25,
 };
 
-function makeCtx(): SceneContext {
-  return {
-    scene: new THREE.Scene(),
-    canvas: document.createElement('canvas'),
-    picker: {
-      selection: signal<PickTarget | null>(null),
-      hover: signal<PickTarget | null>(null),
-    } as unknown as Picker,
-    cityState: makeCityState(),
-  } as unknown as SceneContext;
-}
-
 function mkStreet(path: string, over: Partial<Street> = {}): Street {
   return {
     x: 0,
@@ -104,7 +89,7 @@ describe('street opacity', () => {
   });
 
   it('seeds aOpacity to 1 on both merged meshes and keeps materials opaque by default', () => {
-    streets = createStreets(makeCtx());
+    streets = createStreets(makeSceneContext());
     streets.rebuild(threeStreetLayout());
 
     const sidewalk = streets.getPickables()[0] as FlatMesh;
@@ -123,7 +108,7 @@ describe('street opacity', () => {
   });
 
   it('setStreetOpacity writes only the target street span on both meshes', () => {
-    streets = createStreets(makeCtx());
+    streets = createStreets(makeSceneContext());
     streets.rebuild(threeStreetLayout());
 
     const sidewalk = streets.getPickables()[0] as FlatMesh;
@@ -156,7 +141,7 @@ describe('street opacity', () => {
   });
 
   it("setStreetLabelOpacity fades one street's labels without touching another street's", () => {
-    streets = createStreets(makeCtx());
+    streets = createStreets(makeSceneContext());
     streets.rebuild(threeStreetLayout());
 
     const ranges = streets.getStreetRanges();
@@ -181,7 +166,7 @@ describe('street opacity', () => {
   });
 
   it("setStreetLabelOpacity(street, 0) force-hides that street's label group", () => {
-    streets = createStreets(makeCtx());
+    streets = createStreets(makeSceneContext());
     streets.rebuild(threeStreetLayout());
 
     const ranges = streets.getStreetRanges();
@@ -200,7 +185,7 @@ describe('street opacity', () => {
   });
 
   it('setStreetsTransparent(true) moves both materials into the transparent pass', () => {
-    streets = createStreets(makeCtx());
+    streets = createStreets(makeSceneContext());
     streets.rebuild(threeStreetLayout());
 
     const sidewalk = streets.getPickables()[0] as FlatMesh;
diff --git a/app/tests/city/components/trees/index.test.ts b/app/tests/city/components/trees/index.test.ts
index c9c14e969..bf3b8463c 100644
--- a/app/tests/city/components/trees/index.test.ts
+++ b/app/tests/city/components/trees/index.test.ts
@@ -14,11 +14,10 @@
 
 import { describe, it, expect, beforeEach, afterEach, vi } from 'vitest';
 import * as THREE from 'three';
-import { signal } from '@preact/signals';
 import { LineSegments2 } from 'three/addons/lines/LineSegments2.js';
 
 import { createTrees } from '@/city/components/trees';
-import { makeCityState } from '../../../_helpers/cityFixtures';
+import { makeCityState, makePickableSceneContext } from '../../../_helpers/cityFixtures';
 import { TREES } from '@/state/stores/settings/trees';
 import { NodeKind } from '@/types';
 import type { CommitEntry } from '@/types';
@@ -50,26 +49,6 @@ const _origTrees = TREES.value;
 // A SceneContext whose picker exposes controllable selection + hover signals,
 // and a fake renderer.domElement canvas (with resizable client dims) so the
 // outline LineMaterial can read clientWidth/Height during arming.
-function makeCtx(): {
-  ctx: SceneContext;
-  selection: ReturnType<typeof signal<PickTarget | null>>;
-  hover: ReturnType<typeof signal<PickTarget | null>>;
-  size: { w: number; h: number };
-} {
-  const selection = signal<PickTarget | null>(null);
-  const hover = signal<PickTarget | null>(null);
-  const size = { w: 800, h: 600 };
-  const canvas = document.createElement('canvas');
-  Object.defineProperty(canvas, 'clientWidth', { get: () => size.w });
-  Object.defineProperty(canvas, 'clientHeight', { get: () => size.h });
-  const ctx = {
-    scene: new THREE.Scene(),
-    canvas,
-    picker: { selection, hover } as unknown as Picker,
-    cityState: makeCityState(),
-  } as unknown as SceneContext;
-  return { ctx, selection, hover, size };
-}
 
 // Pre-picker ctx: picker null (the construction-time window).
 function makePrePickerCtx(): SceneContext {
@@ -108,7 +87,7 @@ describe('createTrees() component door', () => {
   });
 
   it('constructs with an empty named group and a null handle (pre-rebuild)', () => {
-    const { ctx } = makeCtx();
+    const { ctx } = makePickableSceneContext();
     trees = createTrees(ctx);
     expect(trees.group).toBeInstanceOf(THREE.Group);
     expect(trees.group.name).toBe('city-trees');
@@ -124,7 +103,7 @@ describe('createTrees() component door', () => {
   });
 
   it('signal-driven rebuild runs without a cycle (clears + bumps decorationRevision)', async () => {
-    const { ctx } = makeCtx();
+    const { ctx } = makePickableSceneContext();
     const cs = ctx.cityState;
     trees = createTrees(ctx);
     const before = cs.decorationRevision.value;
@@ -141,7 +120,7 @@ describe('createTrees() component door', () => {
   });
 
   it('rebuild() builds the inner renderer under the group; getRenderer() is live', () => {
-    const { ctx } = makeCtx();
+    const { ctx } = makePickableSceneContext();
     trees = createTrees(ctx);
     trees.rebuild(PLACEMENTS, COMMITS, BUSY, commitStats(COMMITS));
     const handle = trees.getRenderer();
@@ -154,7 +133,7 @@ describe('createTrees() component door', () => {
   });
 
   it('clear() disposes the inner renderer, empties the group, nulls the handle', () => {
-    const { ctx } = makeCtx();
+    const { ctx } = makePickableSceneContext();
     trees = createTrees(ctx);
     trees.rebuild(PLACEMENTS, COMMITS, BUSY, commitStats(COMMITS));
     trees.clear();
@@ -165,7 +144,7 @@ describe('createTrees() component door', () => {
   });
 
   it('rebuild() disposes the prior inner renderer (no accumulation)', () => {
-    const { ctx } = makeCtx();
+    const { ctx } = makePickableSceneContext();
     trees = createTrees(ctx);
     trees.rebuild(PLACEMENTS, COMMITS, BUSY, commitStats(COMMITS));
     const first = trees.getRenderer()!;
@@ -176,7 +155,7 @@ describe('createTrees() component door', () => {
   });
 
   it('theme effect refreshes the inner renderer on TREES Save', () => {
-    const { ctx } = makeCtx();
+    const { ctx } = makePickableSceneContext();
     trees = createTrees(ctx);
     trees.rebuild(PLACEMENTS, COMMITS, BUSY, commitStats(COMMITS));
     const refreshSpy = vi.spyOn(trees.getRenderer()!, 'refresh');
@@ -185,7 +164,7 @@ describe('createTrees() component door', () => {
   });
 
   it('does NOT show an outline for a selection set before the first tick (not yet armed)', () => {
-    const { ctx, selection } = makeCtx();
+    const { ctx, selection } = makePickableSceneContext();
     trees = createTrees(ctx);
     trees.rebuild(PLACEMENTS, COMMITS, BUSY, commitStats(COMMITS));
     selection.value = commitTarget(SHA_A);
@@ -195,7 +174,7 @@ describe('createTrees() component door', () => {
   });
 
   it('arms the outline on first tick; the pending Commit selection becomes visible', () => {
-    const { ctx, selection } = makeCtx();
+    const { ctx, selection } = makePickableSceneContext();
     trees = createTrees(ctx);
     trees.rebuild(PLACEMENTS, COMMITS, BUSY, commitStats(COMMITS));
     selection.value = commitTarget(SHA_A);
@@ -222,7 +201,7 @@ describe('createTrees() component door', () => {
   });
 
   it('onResize() pushes fresh canvas dimensions into the outline materials', () => {
-    const { ctx, size } = makeCtx();
+    const { ctx, size } = makePickableSceneContext();
     trees = createTrees(ctx);
     trees.rebuild(PLACEMENTS, COMMITS, BUSY, commitStats(COMMITS));
     trees.tick(0, FRAME(CAMERA)); // arm
@@ -236,7 +215,7 @@ describe('createTrees() component door', () => {
   });
 
   it('dispose() clears the inner renderer, stops the theme effect, removes outlines', () => {
-    const { ctx, selection } = makeCtx();
+    const { ctx, selection } = makePickableSceneContext();
     trees = createTrees(ctx);
     trees.rebuild(PLACEMENTS, COMMITS, BUSY, commitStats(COMMITS));
     trees.tick(0, FRAME(CAMERA)); // arm
diff --git a/app/bench/decorationGolden.bench.test.ts b/app/tests/city/decorationGolden.test.ts
similarity index 87%
rename from app/bench/decorationGolden.bench.test.ts
rename to app/tests/city/decorationGolden.test.ts
index 9df0d7335..597e7daee 100644
--- a/app/bench/decorationGolden.bench.test.ts
+++ b/app/tests/city/decorationGolden.test.ts
@@ -1,5 +1,4 @@
-// decorationGolden.bench.test.ts — bit-identical guard for the decoration-pass
-// perf work. Digests the full output of placeTrees, placeFireflies, and the
+// decorationGolden.test.ts — bit-identical guard for the decoration pass. Digests the full output of placeTrees, placeFireflies, and the
 // tree renderer's instance matrix/color buffers for deterministic inputs, and
 // compares against the captured baseline. Any drift fails, so the
 // memoization/compute-once/slim-payload changes can prove output is unchanged.
@@ -16,8 +15,8 @@ import {
   bboxOf,
   genCommits,
   makeDigestHasher,
-} from '../tests/_helpers/layoutTreeFixtures';
-import { commitStats, fileStats } from '../tests/_helpers/statsFixtures';
+} from '../_helpers/layoutTreeFixtures';
+import { commitStats, fileStats } from '../_helpers/statsFixtures';
 
 // Baseline is settings-default-sensitive: it digests the canopy instance
 // matrices, so a TREES width/height default change legitimately moves the hash
@@ -25,6 +24,8 @@ import { commitStats, fileStats } from '../tests/_helpers/statsFixtures';
 const EXPECTED = '12k:trees43000:orbs51600:eb52d6b7';
 
 describe('decoration golden (bit-identical guard)', () => {
+  // Explicit timeout: compute-bound like the layout golden, and CI's coverage
+  // instrumentation multiplies it well past what a jsdom default assumes.
   it('placeTrees + placeFireflies + renderer buffers match baseline', () => {
     const rng = makeRng(0xc0ffee);
     const tree = genNestedTree('root', 'root', 12000, 0, rng);
@@ -76,5 +77,5 @@ describe('decoration golden (bit-identical guard)', () => {
 
     const digest = `12k:trees${placements.length}:orbs${orbs.length}:${hasher.hex()}`;
     expect(digest).toEqual(EXPECTED);
-  });
+  }, 60_000);
 });
diff --git a/app/tests/city/index.test.ts b/app/tests/city/index.test.ts
index 5376112bc..ec2695173 100644
--- a/app/tests/city/index.test.ts
+++ b/app/tests/city/index.test.ts
@@ -113,20 +113,18 @@ describe('createCity', () => {
   // TIMELINE_MODE off directly (scene-free); this effect is what actually tears
   // the scene down, uniformly for the toggle button AND a source switch.
   describe('Timeline-mode scene teardown', () => {
-    it('reacts to TIMELINE_MODE going true→false by uninstalling the controller and un-transparenting streets/footprints', async () => {
+    // Only the uninstall is asserted here: the rebuild it triggers needs a
+    // populated manifest to observe, which this harness does not build.
+    it('reacts to TIMELINE_MODE going true→false by uninstalling the controller', async () => {
       const handle = await createCity(makeCanvas(), EMPTY_MANIFEST);
       handle.timeline.installScrubController(new Map(), []);
       const uninstallSpy = vi.spyOn(handle.timeline, 'uninstallScrubController');
-      const streetsSpy = vi.spyOn(handle.timeline, 'setStreetsTransparent');
-      const footprintsSpy = vi.spyOn(handle.timeline, 'setFootprintsTransparent');
 
       TIMELINE_MODE.value = true; // entering must not trip the teardown
       expect(uninstallSpy).not.toHaveBeenCalled();
 
       TIMELINE_MODE.value = false; // same flip a source switch performs
       expect(uninstallSpy).toHaveBeenCalledTimes(1);
-      expect(streetsSpy).toHaveBeenCalledWith(false);
-      expect(footprintsSpy).toHaveBeenCalledWith(false);
 
       handle.dispose();
     });
diff --git a/app/tests/city/layout/edgeSizeDimensions.test.ts b/app/tests/city/layout/edgeSizeDimensions.test.ts
new file mode 100644
index 000000000..01bf3cb19
--- /dev/null
+++ b/app/tests/city/layout/edgeSizeDimensions.test.ts
@@ -0,0 +1,132 @@
+// The file-size edge cases that produced NaN building geometry (#73).
+// Asserts the invariant rather than a digest: a baseline captured from a broken
+// run would enshrine the NaN as expected.
+
+import { describe, it, expect } from 'vitest';
+import { layoutCity } from '@/city/layout/algorithm.js';
+import { NodeKind } from '@/types';
+import {
+  edgeCaseFiles,
+  mkDir,
+  mkFile,
+  makeRng,
+  statsFromTree,
+} from '../../_helpers/layoutTreeFixtures';
+
+const NUMERIC_FIELDS = ['x', 'y', 'w', 'd', 'h', 'floors'] as const;
+const POSITIVE_FIELDS = ['w', 'd', 'h'] as const;
+
+function edgeTree(): any {
+  return mkDir('root', edgeCaseFiles('root'), 'root');
+}
+
+// Edge files beside ordinary ones: alone they make every range degenerate, which
+// can mask a bug that only appears when a real min/max spread exists.
+function mixedTree(): any {
+  const rng = makeRng(0xed6e);
+  const normal = Array.from({ length: 12 }, (_, i) => mkFile(`f${i}.c`, 'root', rng));
+  return mkDir('root', [...edgeCaseFiles('root'), ...normal], 'root');
+}
+
+describe.each([
+  ['edge files only', edgeTree],
+  ['edge files mixed with ordinary ones', mixedTree],
+])('layout dimensions with %s', (_label, build) => {
+  it('emits a building per file with finite, positive dimensions', () => {
+    const tree = build();
+    const layout = layoutCity({ tree, stats: statsFromTree(tree) });
+
+    const fileCount = tree.children.filter((c: any) => c.type === NodeKind.File).length;
+    expect(layout.buildings).toHaveLength(fileCount);
+
+    for (const b of layout.buildings) {
+      for (const f of NUMERIC_FIELDS) {
+        expect(Number.isFinite(b[f]), `building.${f} = ${b[f]}`).toBe(true);
+      }
+      for (const f of POSITIVE_FIELDS) {
+        expect(b[f], `building.${f}`).toBeGreaterThan(0);
+      }
+    }
+  });
+
+  it('keeps streets finite too, since they size off the same ranges', () => {
+    const tree = build();
+    const layout = layoutCity({ tree, stats: statsFromTree(tree) });
+
+    for (const s of layout.streets) {
+      for (const f of ['x', 'y', 'length', 'width'] as const) {
+        expect(Number.isFinite(s[f]), `street.${f} = ${s[f]}`).toBe(true);
+      }
+      expect(s.width).toBeGreaterThan(0);
+    }
+  });
+});
+
+// statsFromTree builds ranges from non-zero files only, like the server does,
+// so edge files alone never reach the >= 1 clamp. A zero min does: it puts
+// Math.log(0) into the normalization, and every width downstream goes NaN.
+describe('layout dimensions given a zero-floored stats range', () => {
+  const tree = () => mkDir('root', edgeCaseFiles('root'), 'root');
+
+  it('survives a byte range starting at zero', () => {
+    const layout = layoutCity({
+      tree: tree(),
+      stats: {
+        byteSizeRange: { min: 0, max: 51200 },
+        lineCountRange: { min: 1, max: 400 },
+      } as any,
+    });
+
+    expect(layout.buildings.length).toBeGreaterThan(0);
+    for (const b of layout.buildings) {
+      expect(Number.isFinite(b.w), `w = ${b.w}`).toBe(true);
+      expect(b.w).toBeGreaterThan(0);
+    }
+  });
+
+  it('survives a line range starting at zero', () => {
+    const layout = layoutCity({
+      tree: tree(),
+      stats: {
+        byteSizeRange: { min: 1, max: 51200 },
+        lineCountRange: { min: 0, max: 400 },
+      } as any,
+    });
+
+    for (const b of layout.buildings) {
+      expect(Number.isFinite(b.h), `h = ${b.h}`).toBe(true);
+      expect(Number.isFinite(b.floors), `floors = ${b.floors}`).toBe(true);
+      expect(b.h).toBeGreaterThan(0);
+    }
+  });
+});
+
+// statsFromTree skips zero values when building its ranges, so an all-empty repo
+// hands the layout a 0..0 range — the degenerate case behind Math.log(0).
+describe('layout dimensions when every file is empty', () => {
+  it('still produces finite, positive buildings', () => {
+    const tree = mkDir(
+      'root',
+      [0, 1, 2].map((i) => ({
+        name: `e${i}.txt`,
+        type: NodeKind.File,
+        path: `root/e${i}.txt`,
+        extension: '.txt',
+        size: 0,
+        lines: 0,
+      })),
+      'root'
+    );
+    const layout = layoutCity({ tree, stats: statsFromTree(tree) });
+
+    expect(layout.buildings).toHaveLength(3);
+    for (const b of layout.buildings) {
+      for (const f of NUMERIC_FIELDS) {
+        expect(Number.isFinite(b[f]), `${f} = ${b[f]}`).toBe(true);
+      }
+      for (const f of POSITIVE_FIELDS) {
+        expect(b[f], String(f)).toBeGreaterThan(0);
+      }
+    }
+  });
+});
diff --git a/app/bench/layoutGolden.bench.test.ts b/app/tests/city/layout/layoutGolden.test.ts
similarity index 77%
rename from app/bench/layoutGolden.bench.test.ts
rename to app/tests/city/layout/layoutGolden.test.ts
index c15c9733d..dc217fac7 100644
--- a/app/bench/layoutGolden.bench.test.ts
+++ b/app/tests/city/layout/layoutGolden.test.ts
@@ -1,10 +1,5 @@
-// layoutGolden.bench.test.ts — bit-identical output guard for the #63 perf
-// refactor. Computes a stable digest of layoutCity's full output for a set of
-// deterministic trees and compares it against the captured baseline below. Any
-// coordinate/dimension drift fails the test, so the perf refactor can prove it
-// kept output identical. The digests are tied to the production settings
-// defaults; an intentional default change is a real output change and would
-// (correctly) require recapturing EXPECTED.
+// Digests are tied to the production settings defaults, so an intentional
+// default change is a real output change and requires recapturing EXPECTED.
 
 import { describe, it, expect } from 'vitest';
 import { layoutCity } from '@/city/layout/algorithm.js';
@@ -14,7 +9,7 @@ import {
   genWeightedTree,
   makeDigestHasher,
   statsFromTree,
-} from '../tests/_helpers/layoutTreeFixtures';
+} from '../../_helpers/layoutTreeFixtures';
 
 // Digest: round every coordinate to 4 decimals (below the layout's OVERLAP_EPS)
 // and roll buildings + streets into a 32-bit hash.
@@ -55,6 +50,8 @@ const EXPECTED: Record<string, string> = {
 };
 
 describe('layoutCity golden (bit-identical guard)', () => {
+  // Explicit timeout: 30k buildings is compute-bound and CI adds coverage
+  // instrumentation, which took this past the unit project's 15s default.
   it('output digests match the captured baseline', () => {
     const digests: Record<string, string> = {};
     for (const [label, budget] of CASES) {
@@ -66,5 +63,5 @@ describe('layoutCity golden (bit-identical guard)', () => {
       digests[label] = digest(layoutCity({ tree, stats: statsFromTree(tree) }));
     }
     expect(digests).toEqual(EXPECTED);
-  });
+  }, 60_000);
 });
diff --git a/app/tests/city/timeline/scrubController.test.ts b/app/tests/city/timeline/scrubController.test.ts
index 2cf06ecdb..bbc0f430d 100644
--- a/app/tests/city/timeline/scrubController.test.ts
+++ b/app/tests/city/timeline/scrubController.test.ts
@@ -6,7 +6,7 @@ import { createScrubController, FUTURE_SLAB_FLOORS } from '@/city/timeline/scrub
 import { getBuildingDimensions } from '@/city/layout/dimensions';
 import type { HeightContext } from '@/city/layout/dimensions';
 import { BuildingKind } from '@/city/components/buildings/buildingKind';
-import { SCRUB_POS, TIMELINE_BUNDLE } from '@/state/stores/timeline';
+import { TIMELINE_BUNDLE, setScrubPos } from '@/state/stores/timeline';
 import { RUINS } from '@/state/stores/settings/ruins';
 import { BLUEPRINTS } from '@/state/stores/settings/blueprints';
 import { BuildingIndex } from '@/city/components/buildings/buildingIndex';
@@ -508,7 +508,7 @@ let _origRuins: typeof RUINS.value | null = null;
 let _origBlueprints: typeof BLUEPRINTS.value | null = null;
 
 beforeEach(() => {
-  SCRUB_POS.value = 0;
+  setScrubPos(0);
   TIMELINE_BUNDLE.value = null;
   _origRuins = { ...RUINS.value };
   _origBlueprints = { ...BLUEPRINTS.value };
@@ -541,7 +541,7 @@ test('scaleY reflects the interpolated height at the scrub position', () => {
     anchorHiFile,
   ]);
   const fake = fakes.get('f.txt')!;
-  SCRUB_POS.value = 1.5;
+  setScrubPos(1.5);
   controller.update();
 
   const expected = heightForLines(file, 4); // lines lerp 2→6 at pos 1.5
@@ -556,7 +556,7 @@ test('at HEAD the height factor is ~1 (matches the union baseline)', () => {
     anchorHiFile,
   ]);
   const fake = fakes.get('f.txt')!;
-  SCRUB_POS.value = 2; // last live commit index, 6 lines
+  setScrubPos(2); // last live commit index, 6 lines
   controller.update();
   expect(fake.scaleY).toBeCloseTo(heightForLines(file, 6), 5);
 });
@@ -567,7 +567,7 @@ test('height normalizes against commitLineRanges[pos], not the union heightCtx',
   // per-commit range (at HEAD this range == the live scan's lineCountRange).
   const wide: RangeStat[] = Array.from({ length: 8 }, () => ({ min: 1, max: 20000 }));
   const { fake, controller } = setup(undefined, undefined, undefined, 0, wide);
-  SCRUB_POS.value = 2; // HEAD, 6 lines
+  setScrubPos(2); // HEAD, 6 lines
   controller.update();
   const expected = getBuildingDimensions(
     { ...file, lines: 6 } as unknown as FileNode,
@@ -584,7 +584,7 @@ test('a degenerate per-commit range (min==max) collapses to MIN_FLOORS, matching
   // of that 1-file state shows (getBuildingDimensions returns MIN_FLOORS).
   const degenerate: RangeStat[] = Array.from({ length: 8 }, () => ({ min: 6, max: 6 }));
   const { fake, controller } = setup(undefined, undefined, undefined, 0, degenerate);
-  SCRUB_POS.value = 2;
+  setScrubPos(2);
   controller.update();
   const minFloors = getBuildingDimensions(
     { ...file, lines: 6 } as unknown as FileNode,
@@ -596,7 +596,7 @@ test('a degenerate per-commit range (min==max) collapses to MIN_FLOORS, matching
 
 test('before its creation the building is flat and fully transparent', () => {
   const { fake, controller } = setup();
-  SCRUB_POS.value = 0.5; // before createdIdx = 1
+  setScrubPos(0.5); // before createdIdx = 1
   controller.update();
   expect(fake.scaleY).toBe(0);
   expect(fake.iFadeX).toBeCloseTo(0, 5);
@@ -604,7 +604,7 @@ test('before its creation the building is flat and fully transparent', () => {
 
 test('after deletion (ruins off) opacity drops to 0 and the body vanishes', () => {
   const { fake, controller } = setup();
-  SCRUB_POS.value = 3; // deletedIdx
+  setScrubPos(3); // deletedIdx
   controller.update();
   expect(fake.scaleY).toBe(0);
   expect(fake.iFadeX).toBe(0);
@@ -613,7 +613,7 @@ test('after deletion (ruins off) opacity drops to 0 and the body vanishes', () =
 test('ruins on: a deleted building becomes a faint, blank-facade stub shorter than its lived height', () => {
   RUINS.value = { ...RUINS.value, ENABLED: true, BUILDING_OPACITY: 0.3, STUB_HEIGHT: 0.35 };
   const { fake, controller } = setup();
-  SCRUB_POS.value = 3; // deletedIdx → ruin
+  setScrubPos(3); // deletedIdx → ruin
   controller.update();
   expect(fake.iFadeX).toBeCloseTo(0.3, 5); // the BUILDING_OPACITY setting, faint
   expect(fake.scaleY).toBeGreaterThan(0); // a stub, not vanished
@@ -625,7 +625,7 @@ test('ruins on: a deleted building becomes a faint, blank-facade stub shorter th
 test('ruins on: the stub height is the STUB_HEIGHT setting × a floor, not the lived height', () => {
   RUINS.value = { ...RUINS.value, ENABLED: true, STUB_HEIGHT: 0.5 };
   const { fake, controller } = setup();
-  SCRUB_POS.value = 3;
+  setScrubPos(3);
   controller.update();
   // Uniform: STUB_HEIGHT floors, independent of the file's size/lines.
   const expected = 0.5 * BUILDING_DIMENSIONS.value.FLOOR_HEIGHT;
@@ -636,7 +636,7 @@ test('ruins on: the stub height is the STUB_HEIGHT setting × a floor, not the l
 test('ruins on: a before-genesis building stays absent (nothing to ruin yet)', () => {
   RUINS.value = { ...RUINS.value, ENABLED: true };
   const { fake, controller } = setup();
-  SCRUB_POS.value = 0; // f.txt created at 1 → before it existed
+  setScrubPos(0); // f.txt created at 1 → before it existed
   controller.update();
   expect(fake.iFadeX).toBe(0);
   expect(fake.scaleY).toBe(0);
@@ -646,7 +646,7 @@ test('ruins on: a before-genesis building stays absent (nothing to ruin yet)', (
 // quad: a flat quad still writes depth and shows as a cutout/outline on the road.
 test('an absent building (before creation) gets a fully zero-scale matrix, not a flat quad', () => {
   const { fake, controller } = setup();
-  SCRUB_POS.value = 0.5; // before createdIdx = 1
+  setScrubPos(0.5); // before createdIdx = 1
   controller.update();
   expect(fake.scaleX).toBeCloseTo(0, 5);
   expect(fake.scaleY).toBeCloseTo(0, 5);
@@ -655,7 +655,7 @@ test('an absent building (before creation) gets a fully zero-scale matrix, not a
 
 test('an absent building (after deletion) gets a fully zero-scale matrix, not a flat quad', () => {
   const { fake, controller } = setup();
-  SCRUB_POS.value = 3; // deletedIdx
+  setScrubPos(3); // deletedIdx
   controller.update();
   expect(fake.scaleX).toBeCloseTo(0, 5);
   expect(fake.scaleY).toBeCloseTo(0, 5);
@@ -696,18 +696,18 @@ test('drives footprint opacity even when the building has no detail mesh (LOD ce
     fireflies: noopFireflies,
   });
 
-  SCRUB_POS.value = 0; // before genesis → absent
+  setScrubPos(0); // before genesis → absent
   controller.update();
   expect(fp.buildingOpacity.get('f.txt')).toBe(0);
 
-  SCRUB_POS.value = 2; // present
+  setScrubPos(2); // present
   controller.update();
   expect(fp.buildingOpacity.get('f.txt')).toBe(1);
 });
 
 test('a present building keeps its full footprint (scaleX/scaleZ), only height animates', () => {
   const { b, fake, controller } = setup();
-  SCRUB_POS.value = 1.5; // mid-growth: height interpolated, footprint stays full
+  setScrubPos(1.5); // mid-growth: height interpolated, footprint stays full
   controller.update();
   expect(fake.scaleX).toBeCloseTo(b.w, 5);
   expect(fake.scaleZ).toBeCloseTo(b.d, 5);
@@ -716,7 +716,7 @@ test('a present building keeps its full footprint (scaleX/scaleZ), only height a
 
 test('an absent building has its outline (iFade.z) driven to 0, even if left over from a Live-mode fade sweep', () => {
   const { fake, controller } = setup(undefined, undefined, undefined, 0.8);
-  SCRUB_POS.value = 3; // deletedIdx: absent
+  setScrubPos(3); // deletedIdx: absent
   controller.update();
   expect(fake.iFadeZ).toBe(0);
 });
@@ -724,7 +724,7 @@ test('an absent building has its outline (iFade.z) driven to 0, even if left ove
 test('facade panels fade in lockstep with a present building body', () => {
   const fakeFacadePanels = makeFakeFacadePanels();
   const { b, controller } = setup(() => fakeFacadePanels.facadePanels);
-  SCRUB_POS.value = 1.5;
+  setScrubPos(1.5);
   controller.update();
   expect(fakeFacadePanels.calls).toBe(1);
   expect(fakeFacadePanels.lastGetFade!(b.file.path)).toBeCloseTo(1, 5);
@@ -733,7 +733,7 @@ test('facade panels fade in lockstep with a present building body', () => {
 test('facade panels fade to 0 once the building is deleted (ruins off)', () => {
   const fakeFacadePanels = makeFakeFacadePanels();
   const { b, controller } = setup(() => fakeFacadePanels.facadePanels);
-  SCRUB_POS.value = 3; // deletedIdx
+  setScrubPos(3); // deletedIdx
   controller.update();
   expect(fakeFacadePanels.lastGetFade!(b.file.path)).toBe(0);
 });
@@ -742,7 +742,7 @@ test('facade panels stay hidden on a ruin (media is gone, only the stub shows)',
   RUINS.value = { ...RUINS.value, ENABLED: true, BUILDING_OPACITY: 0.3 };
   const fakeFacadePanels = makeFakeFacadePanels();
   const { b, controller } = setup(() => fakeFacadePanels.facadePanels);
-  SCRUB_POS.value = 3; // deleted → ruin
+  setScrubPos(3); // deleted → ruin
   controller.update();
   // The stub/footprint ghost at 0.3, but the media panel must be 0 (no image on a ruin).
   expect(fakeFacadePanels.lastGetFade!(b.file.path)).toBe(0);
@@ -750,14 +750,14 @@ test('facade panels stay hidden on a ruin (media is gone, only the stub shows)',
 
 test('preserves the silhouette/outline iFade channels', () => {
   const { fake, controller } = setup();
-  SCRUB_POS.value = 2;
+  setScrubPos(2);
   controller.update();
   expect(fake.iFadeY).toBe(0);
 });
 
 test('sets needsUpdate exactly once per mesh and per iFade attribute', () => {
   const { fake, controller } = setup();
-  SCRUB_POS.value = 1.5;
+  setScrubPos(1.5);
   controller.update();
   expect(fake.matUpdates).toBe(1);
   expect(fake.iFadeUpdates).toBe(1);
@@ -767,26 +767,28 @@ test('gates trees on the floored scrub position', () => {
   const fakeTrees = makeFakeTrees();
   const { controller } = setup(() => null, fakeTrees.trees);
 
-  SCRUB_POS.value = 1.9;
+  setScrubPos(1.9);
   controller.update();
   expect(fakeTrees.calls.at(-1)).toBe(1);
 
-  SCRUB_POS.value = -0.5;
+  // Out of range never reaches the scene: SCRUB_POS clamps, so the gate is 0.
+  setScrubPos(-0.5);
   controller.update();
-  expect(fakeTrees.calls.at(-1)).toBe(-1);
+  expect(fakeTrees.calls.at(-1)).toBe(0);
 });
 
 test('gates fireflies on the floored scrub position, same value as the tree gate', () => {
   const fakeFireflies = makeFakeFireflies();
   const { controller } = setup(() => null, noopTrees, fakeFireflies.fireflies);
 
-  SCRUB_POS.value = 1.9;
+  setScrubPos(1.9);
   controller.update();
   expect(fakeFireflies.calls.at(-1)).toBe(1);
 
-  SCRUB_POS.value = -0.5;
+  // Out of range never reaches the scene: SCRUB_POS clamps, so the gate is 0.
+  setScrubPos(-0.5);
   controller.update();
-  expect(fakeFireflies.calls.at(-1)).toBe(-1);
+  expect(fakeFireflies.calls.at(-1)).toBe(0);
 });
 
 test('a present media/0-line file gets a non-zero scaleY; an absent one stays flat', () => {
@@ -827,6 +829,7 @@ test('a present media/0-line file gets a non-zero scaleY; an absent one stays fl
   index.insert(b);
   const fake = makeFakeMesh();
   const timelines = buildPathTimelines(mediaBundle);
+  TIMELINE_BUNDLE.value = mediaBundle;
 
   const controller = createScrubController({
     getBuildingIndex: () => index,
@@ -843,7 +846,7 @@ test('a present media/0-line file gets a non-zero scaleY; an absent one stays fl
     fireflies: noopFireflies,
   });
 
-  SCRUB_POS.value = 1;
+  setScrubPos(1);
   controller.update();
   expect(fake.scaleY).toBeGreaterThan(0);
   expect(fake.iFadeX).toBeCloseTo(1, 5);
@@ -851,7 +854,7 @@ test('a present media/0-line file gets a non-zero scaleY; an absent one stays fl
 
 test('an absent building (never present) stays flat at scaleY 0', () => {
   const { fake, controller } = setup();
-  SCRUB_POS.value = -1; // strictly before f.txt's creation
+  setScrubPos(-1); // strictly before f.txt's creation
   controller.update();
   expect(fake.scaleY).toBe(0);
 });
@@ -998,6 +1001,7 @@ test('dedup: two buildings sharing one InstancedMesh set needsUpdate exactly onc
 
   const anchorMesh = makeFakeMesh();
   const timelines = buildPathTimelines(twoPathBundle);
+  TIMELINE_BUNDLE.value = twoPathBundle;
   const controller = createScrubController({
     getBuildingIndex: () => index,
     getFacadePanels: () => null,
@@ -1018,7 +1022,7 @@ test('dedup: two buildings sharing one InstancedMesh set needsUpdate exactly onc
     fireflies: noopFireflies,
   });
 
-  SCRUB_POS.value = 1.5;
+  setScrubPos(1.5);
   controller.update();
 
   expect(matUpdates).toBe(1);
@@ -1106,6 +1110,7 @@ test('couples street opacity to the max opacity of its buildings (block fade)',
   };
 
   const timelines = buildPathTimelines(blockBundle);
+  TIMELINE_BUNDLE.value = blockBundle;
   const controller = createScrubController({
     getBuildingIndex: () => index,
     getFacadePanels: () => null,
@@ -1121,12 +1126,12 @@ test('couples street opacity to the max opacity of its buildings (block fade)',
     fireflies: noopFireflies,
   });
 
-  SCRUB_POS.value = 2; // before K, everything present
+  setScrubPos(2); // before K, everything present
   controller.update();
   expect(opacityByStreet.get(dStreet)).toBeCloseTo(1, 5);
   expect(opacityByStreet.get(eStreet)).toBeCloseTo(1, 5);
 
-  SCRUB_POS.value = 3.5; // after K, d/'s buildings are both deleted
+  setScrubPos(3.5); // after K, d/'s buildings are both deleted
   controller.update();
   expect(opacityByStreet.get(dStreet)).toBe(0);
   expect(opacityByStreet.get(eStreet)).toBeCloseTo(1, 5);
@@ -1217,7 +1222,7 @@ test('block-fade is a true max, not last-write-wins: one deleted sibling cannot
     fireflies: noopFireflies,
   });
 
-  SCRUB_POS.value = 3.5; // after K: f2 deleted, f1 still alive
+  setScrubPos(3.5); // after K: f2 deleted, f1 still alive
   controller.update();
   expect(opacityByStreet.get(dStreet)).toBeCloseTo(1, 5);
 });
@@ -1294,6 +1299,7 @@ test('descendant rollup: a container street with no direct files inherits its ch
   };
 
   const timelines = buildPathTimelines(rollupBundle);
+  TIMELINE_BUNDLE.value = rollupBundle;
   const controller = createScrubController({
     getBuildingIndex: () => index,
     getFacadePanels: () => null,
@@ -1309,13 +1315,13 @@ test('descendant rollup: a container street with no direct files inherits its ch
     fireflies: noopFireflies,
   });
 
-  SCRUB_POS.value = 2; // before deletion, everything present
+  setScrubPos(2); // before deletion, everything present
   controller.update();
   expect(opacityByStreet.get(srcAStreet)).toBeCloseTo(1, 5);
   expect(opacityByStreet.get(srcStreet)).toBeCloseTo(1, 5); // rolled up from src/a
   expect(opacityByStreet.get(eStreet)).toBeCloseTo(1, 5); // unrelated container unaffected
 
-  SCRUB_POS.value = 3.5; // after deletion, src/a/f.txt is gone
+  setScrubPos(3.5); // after deletion, src/a/f.txt is gone
   controller.update();
   expect(opacityByStreet.get(srcAStreet)).toBe(0);
   expect(opacityByStreet.get(srcStreet)).toBe(0); // dropped along with its only child
@@ -1380,6 +1386,7 @@ test('footprints: a deleted building/street fades to 0 while a live sibling stay
   const fakeFootprints = makeFakeFootprints();
 
   const timelines = buildPathTimelines(footprintBundle);
+  TIMELINE_BUNDLE.value = footprintBundle;
   const controller = createScrubController({
     getBuildingIndex: () => index,
     getFacadePanels: () => null,
@@ -1395,7 +1402,7 @@ test('footprints: a deleted building/street fades to 0 while a live sibling stay
     fireflies: noopFireflies,
   });
 
-  SCRUB_POS.value = 3.5; // after K: d/f1.txt deleted, e/f2.txt still alive
+  setScrubPos(3.5); // after K: d/f1.txt deleted, e/f2.txt still alive
   controller.update();
 
   expect(fakeFootprints.buildingOpacity.get('d/f1.txt')).toBe(0);
@@ -1451,7 +1458,7 @@ test('the ROOT street stays at opacity 1 even when every building is absent, unl
     fireflies: noopFireflies,
   });
 
-  SCRUB_POS.value = 0.5; // before f.txt's creation: every building absent
+  setScrubPos(0.5); // before f.txt's creation: every building absent
   controller.update();
 
   expect(opacityByStreet.get(rootStreet)).toBe(1);
@@ -1524,7 +1531,7 @@ test('weathering at HEAD is 1:1 with live: same-day commits still spread by full
   } as unknown as TimelineBundle;
 
   const { controller, fakes } = makeAnchoredScene(sameDayBundle, [fresh, stale]);
-  SCRUB_POS.value = 1; // HEAD
+  setScrubPos(1); // HEAD
   controller.update();
 
   const freshColor = fakes.get('fresh.txt')!.lastColor!;
@@ -1544,7 +1551,7 @@ test('weathering at HEAD is 1:1 with live: same-day commits still spread by full
 
 test('weathering: at the exact scrub position of last modification, color matches the freshest end of the reused age-color curve', () => {
   const { fake, controller } = setup();
-  SCRUB_POS.value = 2; // f.txt's last-modified index
+  setScrubPos(2); // f.txt's last-modified index
   controller.update();
 
   const expected = new THREE.Color(
@@ -1591,7 +1598,7 @@ test('weathering: recency-at-scrub runs through the exact same reused color func
 
   const { controller, fakes } = makeAnchoredScene(datedBundle, [file, anchorLoFile, anchorHiFile]);
   const fake = fakes.get('f.txt')!;
-  SCRUB_POS.value = 2.3; // subject last-modified at commit 1; anchorLo freshest at commit 2
+  setScrubPos(2.3); // subject last-modified at commit 1; anchorLo freshest at commit 2
   controller.update();
 
   const minMod = Date.parse(isoAt(0)); // anchorHi
@@ -1635,7 +1642,7 @@ test('weathering: far past its last modification, color approaches the weathered
 
   const { controller, fakes } = makeAnchoredScene(longBundle, [file, anchorLoFile, anchorHiFile]);
   const fake = fakes.get('f.txt')!;
-  SCRUB_POS.value = 10;
+  setScrubPos(10);
   controller.update();
 
   const minMod = Date.parse(isoAt(0)); // anchorHi, oldest present last-mod
@@ -1655,11 +1662,11 @@ test('weathering: far past its last modification, color approaches the weathered
 test('weathering: absent buildings (before creation / after deletion) are not colored', () => {
   const { fake, controller } = setup();
 
-  SCRUB_POS.value = 0.5; // before f.txt's creation
+  setScrubPos(0.5); // before f.txt's creation
   controller.update();
   expect(fake.colorSetCount).toBe(0);
 
-  SCRUB_POS.value = 3; // after deletion
+  setScrubPos(3); // after deletion
   controller.update();
   expect(fake.colorSetCount).toBe(0);
 });
@@ -1675,7 +1682,7 @@ test('iFloors reflects the scrub-position line count, not the union/final-commit
     anchorHiFile,
   ]);
   const fake = fakes.get('f.txt')!;
-  SCRUB_POS.value = 1.5; // lines lerp 2->6 at pos 1.5 => 4 lines
+  setScrubPos(1.5); // lines lerp 2->6 at pos 1.5 => 4 lines
   controller.update();
 
   const scrubDims = getBuildingDimensions(
@@ -1700,11 +1707,11 @@ test('iFloors changes as SCRUB_POS moves: an earlier (shorter) scrub state has f
   ]);
   const fake = fakes.get('f.txt')!;
 
-  SCRUB_POS.value = 1; // createdIdx, 2 lines
+  setScrubPos(1); // createdIdx, 2 lines
   controller.update();
   const earlyFloors = fake.floors;
 
-  SCRUB_POS.value = 2; // last live commit, 6 lines
+  setScrubPos(2); // last live commit, 6 lines
   controller.update();
   const lateFloors = fake.floors;
 
@@ -1714,14 +1721,14 @@ test('iFloors changes as SCRUB_POS moves: an earlier (shorter) scrub state has f
 
 test('iFloors: needsUpdate set exactly once per mesh per frame', () => {
   const { fake, controller } = setup();
-  SCRUB_POS.value = 1.5;
+  setScrubPos(1.5);
   controller.update();
   expect(fake.floorsUpdates).toBe(1);
 });
 
 test('iModifiedAge matches the recency direction: 0 at the exact last-modified scrub position (freshest)', () => {
   const { fake, controller } = setup();
-  SCRUB_POS.value = 2; // f.txt's last-modified index
+  setScrubPos(2); // f.txt's last-modified index
   controller.update();
   expect(fake.modifiedAge).toBeCloseTo(0, 5);
 });
@@ -1757,11 +1764,11 @@ test('iModifiedAge grows toward 1 (most stale) as scrub moves away from the last
 
   const { controller, fakes } = makeAnchoredScene(datedBundle, [file, anchorLoFile, anchorHiFile]);
   const fake = fakes.get('f.txt')!;
-  SCRUB_POS.value = 1.5; // anchorLo's latest touch is still commit 1, tied with the subject
+  setScrubPos(1.5); // anchorLo's latest touch is still commit 1, tied with the subject
   controller.update();
   const atModified = fake.modifiedAge;
 
-  SCRUB_POS.value = 2.5; // anchorLo re-touched at commit 2, now the freshest present file
+  setScrubPos(2.5); // anchorLo re-touched at commit 2, now the freshest present file
   controller.update();
   const afterModified = fake.modifiedAge;
 
@@ -1770,14 +1777,14 @@ test('iModifiedAge grows toward 1 (most stale) as scrub moves away from the last
 
 test('iModifiedAge: needsUpdate set exactly once per mesh per frame', () => {
   const { fake, controller } = setup();
-  SCRUB_POS.value = 2;
+  setScrubPos(2);
   controller.update();
   expect(fake.modifiedAgeUpdates).toBe(1);
 });
 
 test('iIconUV.w (createdAge) is 0 at the exact scrub-position creation index (newest)', () => {
   const { fake, controller } = setup();
-  SCRUB_POS.value = 1; // f.txt's createdIdx
+  setScrubPos(1); // f.txt's createdIdx
   controller.update();
   expect(fake.iconUvW).toBeCloseTo(0, 5);
 });
@@ -1813,11 +1820,11 @@ test('iIconUV.w grows toward 1 (oldest) as scrub moves away from the created ind
 
   const { controller, fakes } = makeAnchoredScene(datedBundle, [file, anchorLoFile, anchorNewFile]);
   const fake = fakes.get('f.txt')!;
-  SCRUB_POS.value = 1; // subject's creation index; only it + anchorOld are present
+  setScrubPos(1); // subject's creation index; only it + anchorOld are present
   controller.update();
   const atCreated = fake.iconUvW;
 
-  SCRUB_POS.value = 2; // anchorNew now present, created after the subject
+  setScrubPos(2); // anchorNew now present, created after the subject
   controller.update();
   const later = fake.iconUvW;
 
@@ -1831,14 +1838,14 @@ test('iIconUV.w grows toward 1 (oldest) as scrub moves away from the created ind
 
 test('iIconUV.w: needsUpdate set exactly once per mesh per frame', () => {
   const { fake, controller } = setup();
-  SCRUB_POS.value = 1.5;
+  setScrubPos(1.5);
   controller.update();
   expect(fake.iconUvUpdates).toBe(1);
 });
 
 test('absent buildings leave iFloors/iModifiedAge/iIconUV.w untouched (not overwritten with stale/garbage values)', () => {
   const { fake, controller } = setup();
-  SCRUB_POS.value = 0.5; // before createdIdx = 1: absent
+  setScrubPos(0.5); // before createdIdx = 1: absent
   controller.update();
   expect(fake.floorsUpdates).toBe(0);
   expect(fake.modifiedAgeUpdates).toBe(0);
@@ -1847,7 +1854,7 @@ test('absent buildings leave iFloors/iModifiedAge/iIconUV.w untouched (not overw
 
 test('weathering: sets instanceColor.needsUpdate exactly once per mesh', () => {
   const { fake, controller } = setup();
-  SCRUB_POS.value = 2;
+  setScrubPos(2);
   controller.update();
   expect(fake.colorUpdates).toBe(1);
 });
@@ -1863,7 +1870,7 @@ test('future: a not-yet-created building renders as an ultra-low tinted slab', (
     BUILDING_TINT: 1, // full tint → pure building color, independent of the file hue
   };
   const { b, fake, controller } = setup();
-  SCRUB_POS.value = 0.5; // before f.txt's creation at commit 1 → future
+  setScrubPos(0.5); // before f.txt's creation at commit 1 → future
   controller.update();
 
   const slabHeight = FUTURE_SLAB_FLOORS * BUILDING_DIMENSIONS.value.FLOOR_HEIGHT;
@@ -1887,7 +1894,7 @@ test('future: at tint 0 the slab keeps its own file hue, not the building color'
     BUILDING_TINT: 0,
   };
   const { fake, controller } = setup();
-  SCRUB_POS.value = 0.5;
+  setScrubPos(0.5);
   controller.update();
   const fileHue = new THREE.Color(
     getBuildingColorForRecency(
@@ -1902,10 +1909,10 @@ test('future: at tint 0 the slab keeps its own file hue, not the building color'
 test('future: opacity is uniform regardless of how far ahead the creation is', () => {
   BLUEPRINTS.value = { ...BLUEPRINTS.value, ENABLED: true, BUILDING_OPACITY: 0.3 };
   const { fake, controller } = setup();
-  SCRUB_POS.value = 0; // furthest before creation
+  setScrubPos(0); // furthest before creation
   controller.update();
   const far = fake.iFadeX;
-  SCRUB_POS.value = 0.9; // just before creation
+  setScrubPos(0.9); // just before creation
   controller.update();
   expect(fake.iFadeX).toBeCloseTo(far, 5); // no distance fade
   expect(fake.iFadeX).toBeCloseTo(0.3, 5);
@@ -1914,7 +1921,7 @@ test('future: opacity is uniform regardless of how far ahead the creation is', (
 test('future: with future files off, a not-yet-created building stays hidden', () => {
   BLUEPRINTS.value = { ...BLUEPRINTS.value, ENABLED: false };
   const { fake, controller } = setup();
-  SCRUB_POS.value = 0.5;
+  setScrubPos(0.5);
   controller.update();
   expect(fake.scaleY).toBe(0);
   expect(fake.iFadeX).toBe(0);
@@ -1968,7 +1975,7 @@ test('future roads always render: a non-present, non-ruin street is a future roa
     fireflies: noopFireflies,
   });
 
-  SCRUB_POS.value = 0.5; // before f.txt's creation: root empty, d never has a file
+  setScrubPos(0.5); // before f.txt's creation: root empty, d never has a file
   controller.update();
 
   expect(opacityByStreet.get(rootStreet)).toBe(1); // root always renders
@@ -2031,7 +2038,7 @@ test('a file empty at the scrub position renders as a slab, not a MIN_FLOORS bui
     fireflies: noopFireflies,
   });
 
-  SCRUB_POS.value = 1;
+  setScrubPos(1);
   controller.update();
 
   const slabHeight =
@@ -2041,7 +2048,7 @@ test('a file empty at the scrub position renders as a slab, not a MIN_FLOORS bui
   expect(fake.kind).toBe(BuildingKind.Empty);
 
   // ...and it grows into a real building once the file has content.
-  SCRUB_POS.value = 2;
+  setScrubPos(2);
   controller.update();
   expect(fake.scaleY).toBeGreaterThan(slabHeight);
   expect(fake.kind).toBe(BuildingKind.Normal);
@@ -2110,7 +2117,7 @@ function setupAlwaysEmpty() {
 test('an always-empty file that is deleted renders as a ruin, not a slab', () => {
   RUINS.value = { ...RUINS.value, ENABLED: true };
   const { fake, controller } = setupAlwaysEmpty();
-  SCRUB_POS.value = 2; // deletedIdx
+  setScrubPos(2); // deletedIdx
   controller.update();
   expect(fake.kind).toBe(BuildingKind.Ruin);
 });
@@ -2118,7 +2125,7 @@ test('an always-empty file that is deleted renders as a ruin, not a slab', () =>
 test('an always-empty file before its creation renders as future, not a slab', () => {
   BLUEPRINTS.value = { ...BLUEPRINTS.value, ENABLED: true };
   const { fake, controller } = setupAlwaysEmpty();
-  SCRUB_POS.value = 0.5; // before createdIdx = 1
+  setScrubPos(0.5); // before createdIdx = 1
   controller.update();
   expect(fake.kind).toBe(BuildingKind.Future);
 });
diff --git a/app/tests/components/RecentsList.test.tsx b/app/tests/components/RecentsList.test.tsx
index 630e358c8..218246478 100644
--- a/app/tests/components/RecentsList.test.tsx
+++ b/app/tests/components/RecentsList.test.tsx
@@ -4,11 +4,10 @@
 import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
 import { render } from 'preact';
 import { RECENTS, CURRENT_SOURCE } from '@/state/stores/source';
-import { SERVER_CONFIG } from '@/state/stores/serverConfig';
+import { SERVER_CONFIG, DEFAULT_SERVER_CONFIG } from '@/state/stores/serverConfig';
 import { setManifest } from '@/state/stores/manifest';
 import { EMPTY_MANIFEST } from '@/constants/manifest';
 import { RecentsList } from '@/components/RecentsList/RecentsList';
-import * as manifestApi from '@/api/manifest';
 import type { Manifest } from '@/types';
 import { flush } from '../_helpers/preact';
 
@@ -38,7 +37,7 @@ describe('RecentsList', () => {
     RECENTS.value = [];
     CURRENT_SOURCE.value = null;
     setManifest(EMPTY_MANIFEST);
-    SERVER_CONFIG.value = { allowLocalRepos: false };
+    SERVER_CONFIG.value = { ...DEFAULT_SERVER_CONFIG, allowLocalRepos: false };
   });
 
   it('marks the CURRENT_SOURCE row active', async () => {
@@ -62,7 +61,7 @@ describe('RecentsList', () => {
   });
 
   it('renders a branch-less local recent with no @branch pill, matched active by path', async () => {
-    SERVER_CONFIG.value = { allowLocalRepos: true };
+    SERVER_CONFIG.value = { ...DEFAULT_SERVER_CONFIG, allowLocalRepos: true };
     // A local recent is branch-less; CURRENT_SOURCE is too, so they match by src
     // even though the loaded manifest reports a checkout branch (display only).
     RECENTS.value = [{ src: '/Users/me/proj', label: 'proj', lastOpenedAt: 3 }];
@@ -77,8 +76,7 @@ describe('RecentsList', () => {
     expect(container.querySelector('.recent-row--active')).toBeTruthy();
   });
 
-  it('remove is non-destructive: forgets the entry, does not touch the cache', async () => {
-    const spy = vi.spyOn(manifestApi, 'clearManifestCache');
+  it('remove forgets the entry behind a confirm step', async () => {
     render(<RecentsList onOpen={() => {}} />, container);
     await flush();
 
@@ -100,6 +98,5 @@ describe('RecentsList', () => {
     await flush();
 
     expect(RECENTS.value.find((r) => r.label === 'o/alpha')).toBeUndefined();
-    expect(spy).not.toHaveBeenCalled();
   });
 });
diff --git a/app/tests/components/TimeTravelBar.test.tsx b/app/tests/components/TimeTravelBar.test.tsx
index a69c4964a..98b2a91a2 100644
--- a/app/tests/components/TimeTravelBar.test.tsx
+++ b/app/tests/components/TimeTravelBar.test.tsx
@@ -4,8 +4,8 @@
 import { describe, it, expect, beforeEach, afterEach } from 'vitest';
 import { render } from 'preact';
 import { TimeTravelBar } from '@/components/TimeTravelBar/TimeTravelBar';
-import { TIMELINE_MODE, SCRUB_POS, TIMELINE_BUNDLE } from '@/state/stores/timeline';
-import { flush } from '../_helpers/preact';
+import { TIMELINE_MODE, SCRUB_POS, TIMELINE_BUNDLE, setScrubPos } from '@/state/stores/timeline';
+import { flush, drainAsync } from '../_helpers/preact';
 import type { CommitEntry, TimelineBundle } from '@/types';
 
 const commit = (sha: string, date: string, subject: string): CommitEntry => ({
@@ -42,14 +42,14 @@ describe('TimeTravelBar', () => {
     document.body.appendChild(container);
     TIMELINE_MODE.value = true;
     TIMELINE_BUNDLE.value = BUNDLE;
-    SCRUB_POS.value = 2;
+    setScrubPos(2);
   });
 
   afterEach(() => {
     render(null, container);
     document.body.removeChild(container);
     TIMELINE_MODE.value = false;
-    SCRUB_POS.value = 0;
+    setScrubPos(0);
     TIMELINE_BUNDLE.value = null;
   });
 
@@ -81,7 +81,7 @@ describe('TimeTravelBar', () => {
   });
 
   it('jumps to the first / latest commit when an edge date is clicked', async () => {
-    SCRUB_POS.value = 1;
+    setScrubPos(1);
     render(<TimeTravelBar />, container);
     await flush();
     const edges = container.querySelectorAll<HTMLButtonElement>('button.time-travel-edge');
@@ -149,7 +149,7 @@ describe('TimeTravelBar', () => {
   });
 
   it('shows the interpolated date + "no commits" when scrubbed into a gap', async () => {
-    SCRUB_POS.value = 1.5; // halfway between the Feb 1 and Mar 1 commits (a >2-day gap)
+    setScrubPos(1.5); // halfway between the Feb 1 and Mar 1 commits (a >2-day gap)
     render(<TimeTravelBar />, container);
     await flush();
     const nocommit = container.querySelector('.time-travel-nocommit');
@@ -170,7 +170,7 @@ describe('TimeTravelBar', () => {
       blobSizes: {},
       note: null,
     } as unknown as TimelineBundle;
-    SCRUB_POS.value = 0;
+    setScrubPos(0);
     render(<TimeTravelBar />, container);
     await flush();
 
@@ -208,7 +208,7 @@ describe('TimeTravelBar', () => {
       blobSizes: {},
       note: null,
     } as unknown as TimelineBundle;
-    SCRUB_POS.value = 2;
+    setScrubPos(2);
     render(<TimeTravelBar />, container);
     await flush();
 
@@ -232,14 +232,48 @@ describe('TimeTravelBar', () => {
   });
 
   it('tracks SCRUB_POS updates from outside the component', async () => {
-    SCRUB_POS.value = 0;
+    setScrubPos(0);
     render(<TimeTravelBar />, container);
     await flush();
 
-    SCRUB_POS.value = 1;
+    setScrubPos(1);
     await flush();
 
     expect(track(container).getAttribute('aria-valuenow')).toBe('1');
     expect(container.querySelector('.time-travel-sha')!.textContent).toBe(mid.sha.slice(0, 7));
   });
+
+  // Regression: the mode check used to sit above the hooks, so this instance kept
+  // its effect deps while rendering nothing. Re-entering on the same bundle and
+  // position left the rebuilt canvas blank until a drag changed a dep.
+  it('repaints the tick canvas after leaving and re-entering on identical deps', async () => {
+    const proto = HTMLElement.prototype;
+    const saved = {
+      w: Object.getOwnPropertyDescriptor(proto, 'clientWidth'),
+      h: Object.getOwnPropertyDescriptor(proto, 'clientHeight'),
+    };
+    // jsdom reports 0, which makes the draw bail before it paints anything.
+    Object.defineProperty(proto, 'clientWidth', { configurable: true, get: () => 200 });
+    Object.defineProperty(proto, 'clientHeight', { configurable: true, get: () => 24 });
+    const ticks = () => container.querySelector<HTMLCanvasElement>('canvas.time-travel-ticks');
+    try {
+      render(<TimeTravelBar />, container);
+      await drainAsync(3, 20); // useEffect lands on rAF, which jsdom runs at ~16ms
+      const first = ticks()!;
+      expect(first.width).toBe(200);
+
+      TIMELINE_MODE.value = false;
+      await drainAsync(3, 20); // useEffect lands on rAF, which jsdom runs at ~16ms
+      expect(ticks()).toBeNull();
+
+      TIMELINE_MODE.value = true; // same bundle, same position: no dep changes
+      await drainAsync(3, 20); // useEffect lands on rAF, which jsdom runs at ~16ms
+      const second = ticks()!;
+      expect(second, 'the canvas is rebuilt, not reused').not.toBe(first);
+      expect(second.width, 'and must be repainted').toBe(200);
+    } finally {
+      if (saved.w) Object.defineProperty(proto, 'clientWidth', saved.w);
+      if (saved.h) Object.defineProperty(proto, 'clientHeight', saved.h);
+    }
+  });
 });
diff --git a/app/tests/components/hljsThemeLink.test.tsx b/app/tests/components/hljsThemeLink.test.tsx
new file mode 100644
index 000000000..1b32cd2b8
--- /dev/null
+++ b/app/tests/components/hljsThemeLink.test.tsx
@@ -0,0 +1,25 @@
+// vitest stubs CSS assets, so `?url` imports are "" here and asserting on the
+// resolved URLs would pass vacuously. Completeness is enforced by the
+// Record<SyntaxThemeValue, string> type; only the lookup is testable at runtime.
+
+import { describe, it, expect } from 'vitest';
+import { THEME_HREF, hrefForTheme } from '@/components/HljsThemeLink/HljsThemeLink';
+import { SYNTAX_THEME_OPTIONS, SYNTAX_THEME_DEFAULT } from '@/state/stores/settings/syntaxTheme';
+
+describe('hljs theme stylesheets', () => {
+  it('has a stylesheet entry for every offered theme', () => {
+    const missing = SYNTAX_THEME_OPTIONS.filter((o) => !(o.value in THEME_HREF));
+    expect(missing.map((o) => o.value)).toEqual([]);
+  });
+
+  it('offers a theme for every stylesheet entry, with no strays', () => {
+    const offered = new Set<string>(SYNTAX_THEME_OPTIONS.map((o) => o.value));
+    expect(Object.keys(THEME_HREF).filter((k) => !offered.has(k))).toEqual([]);
+  });
+
+  it('falls back to the default for a theme name it does not recognize', () => {
+    // A persisted setting can name a theme that a later build dropped; that
+    // must resolve to the default entry rather than an undefined href.
+    expect(hrefForTheme('theme-from-an-older-build')).toBe(THEME_HREF[SYNTAX_THEME_DEFAULT]);
+  });
+});
diff --git a/app/tests/components/loadingOverlay.test.tsx b/app/tests/components/loadingOverlay.test.tsx
index 6b839a305..789fa79dd 100644
--- a/app/tests/components/loadingOverlay.test.tsx
+++ b/app/tests/components/loadingOverlay.test.tsx
@@ -8,8 +8,9 @@ import {
   hideLoadingOverlay,
   setLoadingStep,
   setLoadingStepTail,
+  PENDING_SOURCE_LABEL,
 } from '@/state/stores/ui';
-import { PENDING_SOURCE_LABEL } from '@/state/stores/source';
+
 import { LoadingStep } from '@/constants/loadingSteps';
 import { SourceKind } from '@/utils/sources';
 import { flush } from '../_helpers/preact';
diff --git a/app/tests/hooks/useDocumentTitle.test.tsx b/app/tests/hooks/useDocumentTitle.test.tsx
index 418c74505..a642b3b2a 100644
--- a/app/tests/hooks/useDocumentTitle.test.tsx
+++ b/app/tests/hooks/useDocumentTitle.test.tsx
@@ -2,10 +2,11 @@ import { describe, it, expect, beforeEach, afterEach } from 'vitest';
 import { render } from 'preact';
 import { useDocumentTitle } from '@/hooks/useDocumentTitle';
 import { setManifest } from '@/state/stores/manifest';
-import { PENDING_SOURCE_LABEL } from '@/state/stores/source';
+
 import { EMPTY_MANIFEST } from '@/constants/manifest';
 import type { Manifest } from '@/types';
 import { drainAsync } from '../_helpers/preact';
+import { PENDING_SOURCE_LABEL } from '@/state/stores/ui';
 
 // useDocumentTitle is the single owner of document.title. It reacts to the
 // canonical signals — PENDING_SOURCE_LABEL while a source is loading, MANIFEST
diff --git a/app/tests/hooks/useManifestSource.test.ts b/app/tests/hooks/useManifestSource.test.ts
index ef69e611e..03501b141 100644
--- a/app/tests/hooks/useManifestSource.test.ts
+++ b/app/tests/hooks/useManifestSource.test.ts
@@ -1,9 +1,10 @@
 import { describe, it, expect, beforeEach, afterEach } from 'vitest';
 import { loadSource, cancelLoad } from '@/hooks/useManifestSource';
-import { SOURCE_ERROR, CURRENT_SOURCE } from '@/state/stores/source';
+import { SOURCE_ERROR, CURRENT_SOURCE, RECENTS } from '@/state/stores/source';
 import { MANIFEST } from '@/state/stores/manifest';
-import { TIMELINE_MODE, SCRUB_POS, TIMELINE_BUNDLE } from '@/state/stores/timeline';
+import { TIMELINE_MODE, SCRUB_POS, TIMELINE_BUNDLE, setScrubPos } from '@/state/stores/timeline';
 import type { TimelineBundle } from '@/types';
+import { PENDING_SOURCE_LABEL } from '@/state/stores/ui';
 
 // EventSource stub with driveable events: records listeners so a test can emit
 // a named SSE event (e.g. a `manifest-partial` skeleton), and records
@@ -42,6 +43,36 @@ describe('useManifestSource loadSource cancellation', () => {
     (globalThis as unknown as { EventSource: unknown }).EventSource = originalEventSource;
   });
 
+  describe('loading header label', () => {
+    it('is up before the server sends one, seeded from recents', async () => {
+      RECENTS.value = [
+        { src: 'https://github.com/o/r', label: 'o/r', lastOpenedAt: 1 },
+      ] as typeof RECENTS.value;
+      PENDING_SOURCE_LABEL.value = null;
+
+      const p = loadSource({ src: 'https://github.com/o/r' });
+      // No event has arrived yet: the overlay is already on screen.
+      expect(PENDING_SOURCE_LABEL.value, 'header must not be blank while resolving').toBe('o/r');
+
+      cancelLoad();
+      await p;
+    });
+
+    it('survives the stream ending, since the city is still being built', async () => {
+      RECENTS.value = [];
+      const p = loadSource({ src: 'https://github.com/o/r' });
+      StubEventSource.instances[0]!.emit(
+        'manifest-complete',
+        JSON.stringify({ manifest: { tree: { name: 'o/r' } } })
+      );
+      await p;
+
+      // loadSource is done; the overlay lives on through Building/Decorating,
+      // and the header has to live exactly as long as the overlay.
+      expect(PENDING_SOURCE_LABEL.value, 'cleared with the stream, not the overlay').toBe('o/r');
+    });
+  });
+
   it('canceling a load leaves SOURCE_ERROR null and CURRENT_SOURCE unchanged', async () => {
     const before = CURRENT_SOURCE.value;
 
@@ -125,13 +156,13 @@ describe('loadSource exits Timeline mode', () => {
   afterEach(() => {
     (globalThis as unknown as { EventSource: unknown }).EventSource = originalEventSource;
     TIMELINE_MODE.value = false;
-    SCRUB_POS.value = 0;
+    setScrubPos(0);
     TIMELINE_BUNDLE.value = null;
   });
 
   it('flips TIMELINE_MODE off and clears the scrub store before the fetch starts', async () => {
     TIMELINE_MODE.value = true;
-    SCRUB_POS.value = 3;
+    setScrubPos(3);
     TIMELINE_BUNDLE.value = { commits: [{ sha: 'a' }] } as unknown as TimelineBundle;
 
     const p = loadSource({ src: 'https://github.com/o/r' });
diff --git a/app/tests/hooks/useTimelineMode.test.ts b/app/tests/hooks/useTimelineMode.test.ts
index 065ef8b43..52104c629 100644
--- a/app/tests/hooks/useTimelineMode.test.ts
+++ b/app/tests/hooks/useTimelineMode.test.ts
@@ -2,7 +2,7 @@ import { describe, it, expect, beforeEach, afterEach, vi } from 'vitest';
 
 import { loadTimelineScene, exitTimelineMode, teardownTimelineMode } from '@/hooks/useTimelineMode';
 import { EXCLUDES, addExclude } from '@/state/stores/excludes';
-import { TIMELINE_MODE, SCRUB_POS, TIMELINE_BUNDLE } from '@/state/stores/timeline';
+import { TIMELINE_MODE, SCRUB_POS, TIMELINE_BUNDLE, setScrubPos } from '@/state/stores/timeline';
 import { CURRENT_SOURCE } from '@/state/stores/source';
 import { SCENE_HANDLE } from '@/state/stores/scene';
 import { MANIFEST, REBUILD_STATUS, RebuildStatus } from '@/state/stores/manifest';
@@ -73,7 +73,7 @@ describe('loadTimelineScene', () => {
   beforeEach(() => {
     CURRENT_SOURCE.value = { src: 's', branch: undefined };
     TIMELINE_MODE.value = false;
-    SCRUB_POS.value = 0;
+    setScrubPos(0);
     TIMELINE_BUNDLE.value = null;
     LOADING_OVERLAY.value = { visible: false, showOpts: null, activeStep: null, stepTails: {} };
     REBUILD_STATUS.value = RebuildStatus.Idle;
@@ -216,7 +216,7 @@ describe('exitTimelineMode', () => {
     (globalThis as unknown as { EventSource: unknown }).EventSource = StubEventSource;
     CURRENT_SOURCE.value = { src: 's', branch: undefined };
     TIMELINE_MODE.value = true;
-    SCRUB_POS.value = 2;
+    setScrubPos(2);
     TIMELINE_BUNDLE.value = BUNDLE;
   });
   afterEach(() => {
@@ -247,7 +247,7 @@ describe('teardownTimelineMode', () => {
 
   it('is a pure signal flip — no source reload, scene-free', () => {
     TIMELINE_MODE.value = true;
-    SCRUB_POS.value = 2;
+    setScrubPos(2);
     TIMELINE_BUNDLE.value = BUNDLE;
 
     teardownTimelineMode();
@@ -304,7 +304,7 @@ describe('loadTimelineScene inPlace refetch', () => {
   beforeEach(() => {
     CURRENT_SOURCE.value = { src: 's', branch: undefined };
     TIMELINE_MODE.value = true;
-    SCRUB_POS.value = 2;
+    setScrubPos(2);
     TIMELINE_BUNDLE.value = BUNDLE;
     REBUILD_STATUS.value = RebuildStatus.Idle; // inPlace uses the footer (markRebuilding)
     (fetchTimelineBundle as unknown as ReturnType<typeof vi.fn>).mockReset();
@@ -354,7 +354,7 @@ describe('exclude edit in Timeline routes to a bundle refetch (regression: #128)
     MANIFEST.value = { content_signature: 'sig0', tree: {} } as never;
     SCAN_PROGRESS.value = null;
     TIMELINE_MODE.value = true;
-    SCRUB_POS.value = 2;
+    setScrubPos(2);
     TIMELINE_BUNDLE.value = BUNDLE;
     EXCLUDES.value = {};
     (fetchTimelineBundle as unknown as ReturnType<typeof vi.fn>).mockReset();
diff --git a/app/tests/state/historyManifest.test.ts b/app/tests/state/historyManifest.test.ts
index c0f8dc5d2..363e0fbe5 100644
--- a/app/tests/state/historyManifest.test.ts
+++ b/app/tests/state/historyManifest.test.ts
@@ -1,7 +1,7 @@
 import { afterEach, expect, test } from 'vitest';
 import { NodeKind } from '@/types';
 import type { TimelineBundle, TreeNode } from '@/types';
-import { TIMELINE_MODE, TIMELINE_BUNDLE, SCRUB_POS } from '@/state/stores/timeline';
+import { TIMELINE_MODE, TIMELINE_BUNDLE, setScrubPos } from '@/state/stores/timeline';
 import { RUINS } from '@/state/stores/settings/ruins';
 import { BLUEPRINTS } from '@/state/stores/settings/blueprints';
 import { HISTORY_MANIFEST } from '@/state/stores/historyManifest';
@@ -57,13 +57,13 @@ function paths(m: unknown): Set<string> {
 afterEach(() => {
   TIMELINE_MODE.value = false;
   TIMELINE_BUNDLE.value = null;
-  SCRUB_POS.value = 0;
+  setScrubPos(0);
 });
 
 test('only present-at-scrub paths survive (deleted + future dropped, empty dirs pruned)', () => {
   TIMELINE_BUNDLE.value = bundle;
   TIMELINE_MODE.value = true;
-  SCRUB_POS.value = 2;
+  setScrubPos(2);
 
   const p = paths(HISTORY_MANIFEST.value);
   expect(p.has('present.txt')).toBe(true);
@@ -75,7 +75,7 @@ test('only present-at-scrub paths survive (deleted + future dropped, empty dirs
 test('present-only regardless of the ruins / future toggles', () => {
   TIMELINE_BUNDLE.value = bundle;
   TIMELINE_MODE.value = true;
-  SCRUB_POS.value = 2;
+  setScrubPos(2);
   RUINS.value = { ...RUINS.value, ENABLED: true };
   BLUEPRINTS.value = { ...BLUEPRINTS.value, ENABLED: true };
 
diff --git a/app/tests/state/loadingReactions.test.ts b/app/tests/state/loadingReactions.test.ts
index ad725ef58..c42d1f5c4 100644
--- a/app/tests/state/loadingReactions.test.ts
+++ b/app/tests/state/loadingReactions.test.ts
@@ -1,8 +1,9 @@
 import { describe, it, expect, beforeEach, afterEach } from 'vitest';
 import { attachLoadingReactions } from '@/state/loadingReactions';
 import { SCAN_PROGRESS } from '@/state/stores/scanProgress';
+
 import { REBUILD_STATUS, RebuildStatus } from '@/state/stores/manifest';
-import { LOADING_OVERLAY } from '@/state/stores/ui';
+import { LOADING_OVERLAY, PENDING_SOURCE_LABEL } from '@/state/stores/ui';
 import { SourceKind } from '@/utils/sources';
 import { ScanPhase, CloneStage } from '@/api/manifest';
 import { LoadingStep } from '@/constants/loadingSteps';
@@ -70,6 +71,22 @@ describe('loadingReactions', () => {
     expect(LOADING_OVERLAY.value.visible).toBe(false);
   });
 
+  it('keeps the repo name up for the whole overlay, not just the stream', () => {
+    // The stream ends well before the city is assembled, so clearing the label
+    // with the stream blanked the header while Building was still on screen.
+    PENDING_SOURCE_LABEL.value = 'owner/repo';
+    SCAN_PROGRESS.value = { kind: SourceKind.Remote, phase: ScanPhase.CompleteManifest };
+    REBUILD_STATUS.value = RebuildStatus.Rebuilding;
+    SCAN_PROGRESS.value = null;
+
+    expect(LOADING_OVERLAY.value.visible, 'still building').toBe(true);
+    expect(PENDING_SOURCE_LABEL.value, 'header must survive the build phase').toBe('owner/repo');
+
+    REBUILD_STATUS.value = RebuildStatus.Decorating;
+    expect(LOADING_OVERLAY.value.visible).toBe(false);
+    expect(PENDING_SOURCE_LABEL.value, 'and clear with the overlay').toBeNull();
+  });
+
   it('does NOT show the overlay for a settings rebuild (no stream)', () => {
     // A config Save sets Rebuilding with no SCAN_PROGRESS — the footer owns that
     // status, not the loading overlay.
diff --git a/app/tests/state/presentPaths.test.ts b/app/tests/state/presentPaths.test.ts
index bd8fd7f88..ca9787431 100644
--- a/app/tests/state/presentPaths.test.ts
+++ b/app/tests/state/presentPaths.test.ts
@@ -1,7 +1,7 @@
 import { afterEach, expect, test } from 'vitest';
 import { NodeKind } from '@/types';
 import type { TimelineBundle } from '@/types';
-import { TIMELINE_MODE, TIMELINE_BUNDLE, SCRUB_POS } from '@/state/stores/timeline';
+import { TIMELINE_MODE, TIMELINE_BUNDLE, setScrubPos } from '@/state/stores/timeline';
 import { PRESENT_PATHS, scrubbedBlobShaFor, scrubbedStatsFor } from '@/state/stores/presentPaths';
 
 // At commit 2: src/present.txt is live; src/gone.txt was deleted at commit 2;
@@ -52,13 +52,13 @@ const bundle = {
 afterEach(() => {
   TIMELINE_MODE.value = false;
   TIMELINE_BUNDLE.value = null;
-  SCRUB_POS.value = 0;
+  setScrubPos(0);
 });
 
 test('present files + their ancestor dirs are in the set; deleted/future are not', () => {
   TIMELINE_BUNDLE.value = bundle;
   TIMELINE_MODE.value = true;
-  SCRUB_POS.value = 2;
+  setScrubPos(2);
 
   const p = PRESENT_PATHS.value;
   expect(p.has('src/present.txt')).toBe(true);
@@ -101,13 +101,13 @@ test('displayed stats describe the blob being served, across unchanged commits',
   // one of them must report that blob's numbers — no drift toward the later
   // edit, which is what put "42 lines" over a 36-line body.
   for (const pos of [0, 0.7, 1, 2, 2.9]) {
-    SCRUB_POS.value = pos;
+    setScrubPos(pos);
     expect(scrubbedBlobShaFor('f.txt')).toBe('small');
     expect(scrubbedStatsFor('f.txt')?.lines).toBe(36);
     expect(scrubbedStatsFor('f.txt')?.bytes).toBe(100);
   }
 
-  SCRUB_POS.value = 3;
+  setScrubPos(3);
   expect(scrubbedBlobShaFor('f.txt')).toBe('big');
   expect(scrubbedStatsFor('f.txt')?.lines).toBe(46);
   expect(scrubbedStatsFor('f.txt')?.bytes).toBe(200);
diff --git a/app/tests/state/scrubbedManifest.test.ts b/app/tests/state/scrubbedManifest.test.ts
index f6468a949..73218ca98 100644
--- a/app/tests/state/scrubbedManifest.test.ts
+++ b/app/tests/state/scrubbedManifest.test.ts
@@ -11,6 +11,7 @@ import {
   SCRUBBED_MANIFEST,
   loadManifestAt,
   resetScrubbedManifest,
+  _clearScrubbedManifestCache,
 } from '@/state/stores/scrubbedManifest';
 
 function completes(manifest: unknown) {
@@ -21,6 +22,7 @@ function completes(manifest: unknown) {
 
 afterEach(() => {
   resetScrubbedManifest();
+  _clearScrubbedManifestCache();
   streamManifest.mockReset();
 });
 
@@ -49,3 +51,37 @@ describe('loadManifestAt', () => {
     expect((SCRUBBED_MANIFEST.value as { root?: string })?.root).toBe('/good');
   });
 });
+
+describe('reconstruction cache', () => {
+  // Each entry is a whole repo tree, so an unbounded cache grows for the life of
+  // the tab as you scrub a long history or switch repos.
+  const sha = (n: number) => String(n).padStart(40, '0');
+
+  async function load(n: number) {
+    streamManifest.mockImplementation(completes({ root: '/r', tree: { path: `t${n}` } }));
+    await loadManifestAt('/r', 'main', sha(n));
+  }
+
+  it('evicts the oldest entry once the cache is full', async () => {
+    for (let i = 0; i < 20; i++) await load(i);
+    streamManifest.mockClear();
+
+    // The 16 most recent are still warm: no refetch.
+    for (let i = 4; i < 20; i++) await load(i);
+    expect(streamManifest).not.toHaveBeenCalled();
+
+    // The four evicted ones are refetched.
+    for (let i = 0; i < 4; i++) await load(i);
+    expect(streamManifest).toHaveBeenCalledTimes(4);
+  });
+
+  it('a re-read counts as recent, so it is not the next one evicted', async () => {
+    for (let i = 0; i < 16; i++) await load(i);
+    await load(0); // touch the oldest, promoting it
+    await load(99); // pushes one out — entry 1, not entry 0
+    streamManifest.mockClear();
+
+    await load(0);
+    expect(streamManifest, 'the promoted entry should still be cached').not.toHaveBeenCalled();
+  });
+});
diff --git a/app/tests/state/settingsTips.test.ts b/app/tests/state/settingsTips.test.ts
index 21db0e276..7feb42479 100644
--- a/app/tests/state/settingsTips.test.ts
+++ b/app/tests/state/settingsTips.test.ts
@@ -1,21 +1,30 @@
+// User-facing copy uses colons or commas, never an em-dash.
+//
+// Two halves because neither alone is enough: settings tips are reachable at
+// runtime, but the almanac builds its tips inside computeAlmanac, where a
+// fixture missing a branch would under-enforce silently. Reading source has no
+// such blind spot. Globs, not hand-written lists, which had already drifted.
+
 import { describe, it, expect } from 'vitest';
 import { forEachSettingStore, getFieldKeys, getFieldDef } from '@/state/settingsSchema';
-// Import every settings store so it self-registers before we iterate.
-import '@/state/stores/settings/buildings';
-import '@/state/stores/settings/camera';
-import '@/state/stores/settings/effects';
-import '@/state/stores/settings/fireflies';
-import '@/state/stores/settings/footprint';
-import '@/state/stores/settings/gem';
-import '@/state/stores/settings/island';
-import '@/state/stores/settings/scene';
-import '@/state/stores/settings/streets';
-import '@/state/stores/settings/syntaxTheme';
-import '@/state/stores/settings/trees';
-import '@/state/stores/settings/updates';
 
-describe('field descriptions', () => {
-  it('contain no em-dashes (use colons or commas)', () => {
+// Self-registration happens on import; glob so a new store is covered the day
+// it lands rather than whenever someone remembers to add it here.
+const STORE_MODULES = import.meta.glob('../../src/state/stores/settings/*.ts', { eager: true });
+
+// Source text via the same `?raw` import the shaders use, rather than node's fs
+// — this tsconfig has no node types, and the app is browser-targeted.
+const SOURCES = import.meta.glob('../../src/**/*.{ts,tsx}', {
+  query: '?raw',
+  import: 'default',
+  eager: true,
+}) as Record<string, string>;
+
+// Object keys whose string values reach the user.
+const COPY_KEYS = ['tip', 'description', 'placeholder', 'hint'];
+
+describe('user-facing copy', () => {
+  it('has no em-dashes in settings field tips', () => {
     const offenders: string[] = [];
     forEachSettingStore((store) => {
       for (const key of getFieldKeys(store as object)) {
@@ -23,6 +32,31 @@ describe('field descriptions', () => {
         if (tip && tip.includes('—')) offenders.push(`${key}: ${tip}`);
       }
     });
-    expect(offenders).toEqual([]);
+    expect(offenders, offenders.join('\n')).toEqual([]);
+  });
+
+  it('registers at least one store per file in settings/, so the glob is doing its job', () => {
+    // Not an equality check: stores register from outside settings/ too, so
+    // pinning an exact number would encode a relationship this test has no
+    // business asserting.
+    let registered = 0;
+    forEachSettingStore(() => registered++);
+    expect(registered).toBeGreaterThanOrEqual(Object.keys(STORE_MODULES).length);
+  });
+
+  it('has no em-dashes in other user-facing copy', () => {
+    // `tip: '...'` on one line. Template literals and multi-line strings are not
+    // matched; those would need a parser, and copy rarely uses them.
+    const re = new RegExp(
+      `\\b(${COPY_KEYS.join('|')})\\s*:\\s*(['"])((?:\\\\.|(?!\\2).)*)\\2`,
+      'g'
+    );
+    const offenders: string[] = [];
+    for (const [path, source] of Object.entries(SOURCES)) {
+      for (const m of source.matchAll(re)) {
+        if (m[3].includes('—')) offenders.push(`${path}  ${m[1]}: ${m[3]}`);
+      }
+    }
+    expect(offenders, offenders.join('\n')).toEqual([]);
   });
 });
diff --git a/app/tests/state/stores/timeline.test.ts b/app/tests/state/stores/timeline.test.ts
new file mode 100644
index 000000000..00af09c35
--- /dev/null
+++ b/app/tests/state/stores/timeline.test.ts
@@ -0,0 +1,58 @@
+import { describe, it, expect, beforeEach } from 'vitest';
+import {
+  SCRUB_POS,
+  SCRUB_MAX,
+  TIMELINE_BUNDLE,
+  setScrubPos,
+  resetTimelineMode,
+} from '@/state/stores/timeline';
+import type { TimelineBundle } from '@/types';
+
+const bundleOf = (n: number) =>
+  ({
+    commits: Array.from({ length: n }, (_, i) => ({ sha: `c${i}` })),
+  }) as unknown as TimelineBundle;
+
+describe('SCRUB_POS range', () => {
+  beforeEach(() => {
+    resetTimelineMode();
+  });
+
+  it('is 0 with no bundle loaded', () => {
+    expect(SCRUB_MAX.value).toBe(0);
+    setScrubPos(5);
+    expect(SCRUB_POS.value).toBe(0);
+  });
+
+  it('clamps both ends to the loaded bundle', () => {
+    TIMELINE_BUNDLE.value = bundleOf(4);
+    expect(SCRUB_MAX.value).toBe(3);
+
+    setScrubPos(-2);
+    expect(SCRUB_POS.value).toBe(0);
+    setScrubPos(99);
+    expect(SCRUB_POS.value).toBe(3);
+    setScrubPos(1.5); // float index: scrubbing interpolates between commits
+    expect(SCRUB_POS.value).toBe(1.5);
+  });
+
+  // The bug this replaced: exitTimelineMode and the switcher save a position and
+  // replay it later, so a shorter bundle used to leave it out of range until the
+  // next write. Clamping against the CURRENT bundle makes the swap alone enough.
+  it('re-clamps when the bundle shrinks, with no new write', () => {
+    TIMELINE_BUNDLE.value = bundleOf(10);
+    setScrubPos(9);
+    expect(SCRUB_POS.value).toBe(9);
+
+    TIMELINE_BUNDLE.value = bundleOf(3);
+    expect(SCRUB_POS.value).toBe(2);
+  });
+
+  it('restores the saved position when the bundle grows back', () => {
+    TIMELINE_BUNDLE.value = bundleOf(10);
+    setScrubPos(9);
+    TIMELINE_BUNDLE.value = bundleOf(3);
+    TIMELINE_BUNDLE.value = bundleOf(10);
+    expect(SCRUB_POS.value).toBe(9);
+  });
+});
diff --git a/app/tests/views/ProjectsView/ProjectsView.test.tsx b/app/tests/views/ProjectsView/ProjectsView.test.tsx
index e0b6345bb..ad42aff43 100644
--- a/app/tests/views/ProjectsView/ProjectsView.test.tsx
+++ b/app/tests/views/ProjectsView/ProjectsView.test.tsx
@@ -13,11 +13,12 @@ import {
   openProjectsView,
   closeProjectsView,
   setLoadingStepTail,
+  PENDING_SOURCE_LABEL,
 } from '@/state/stores/ui';
 import { LoadingStep } from '@/constants/loadingSteps';
 import { SCAN_PROGRESS } from '@/state/stores/scanProgress';
-import { PENDING_SOURCE_LABEL } from '@/state/stores/source';
-import { SERVER_CONFIG } from '@/state/stores/serverConfig';
+
+import { SERVER_CONFIG, DEFAULT_SERVER_CONFIG } from '@/state/stores/serverConfig';
 import { RECENTS } from '@/state/stores/source';
 import { ScanPhase } from '@/api/manifest';
 import { SourceKind } from '@/utils/sources';
@@ -29,7 +30,7 @@ describe('ProjectsView', () => {
   beforeEach(() => {
     container = document.createElement('div');
     document.body.appendChild(container);
-    SERVER_CONFIG.value = { allowLocalRepos: true };
+    SERVER_CONFIG.value = { ...DEFAULT_SERVER_CONFIG, allowLocalRepos: true };
   });
 
   afterEach(() => {
diff --git a/app/vitest.config.js b/app/vitest.config.js
index fe1ed4aa3..b5feee1a3 100644
--- a/app/vitest.config.js
+++ b/app/vitest.config.js
@@ -8,6 +8,10 @@ const appDir = import.meta.dirname;
 //   - `unit`  → tests/**/*.test.{js,ts}   (run by `npm test`)
 //   - `bench` → bench/**/*.test.{js,ts}   (run by `npm run bench`)
 // `extends: true` inherits the root resolve.alias so we don't duplicate it.
+//
+// bench/ holds timing harnesses only. The bit-identical golden guards live in
+// tests/ because they assert correctness, not speed — parked in bench/ they ran
+// in neither CI nor the pre-push gate, which is the whole point of a guard.
 export default defineConfig({
   // Preact plugin mirrors vite.config.js so vitest can parse JSX/TSX in
   // source modules that tests transitively import.
@@ -54,10 +58,14 @@ export default defineConfig({
         'src/three-augment.d.ts',
         'src/vite-env.d.ts',
       ],
-      // No thresholds — coverage is measured + reported, not enforced.
-      // Current baseline ~51% lines / 39% branches; raising the bar is
-      // future work (would require tests for entrypoints, renderLoop,
-      // scene effects, UI shell).
+      // Floors, not targets: a few points under measured, so ordinary movement
+      // passes and a regression fails.
+      thresholds: {
+        lines: 82,
+        statements: 79,
+        functions: 80,
+        branches: 68,
+      },
     },
   },
 });
diff --git a/docker-compose.dev.yml b/docker-compose.dev.yml
index 3f7a6f955..a03a58ebc 100644
--- a/docker-compose.dev.yml
+++ b/docker-compose.dev.yml
@@ -11,7 +11,10 @@ services:
     # The image ENTRYPOINT is `/srv/.venv/bin/python -m api`; this `command:`
     # supplies just the flags appended to it. Adds `--reload` so source edits
     # under ./api auto-restart uvicorn, and pins the port to 8000 for dev.
-    command: ["--reload", "--port", "8000"]
+    # `--host` repeats the Dockerfile CMD's value because this replaces CMD
+    # outright: without it the CLI's loopback default would make the api
+    # unreachable from the app container.
+    command: ["--reload", "--port", "8000", "--host", "0.0.0.0"]
     volumes:
       # Bind source for auto-reload. Read-only inside the container — host
       # owns the files.