@@ -13,10 +13,12 @@
 
 from __future__ import annotations
 
+import functools
 import hashlib
 import re
 from collections.abc import Callable, Iterable, Mapping
 from dataclasses import dataclass, field
+from types import MappingProxyType
 
 from mhfu_port import behaviour, motion, slots
 from mhfu_port import layout as layouts
@@ -77,8 +79,11 @@ def clip_table(anim: AnimPack) -> dict[int, Fingerprint]:
     return {s: (frames, bool(loop)) for s, (frames, loop) in slots.slot_prints(anim).items()}
 
 
-def pac_clip_table(pac: bytes) -> dict[int, Fingerprint]:
-    return clip_table(slots.anim_of(pac))
+@functools.lru_cache(maxsize=2)
+def pac_clip_table(pac: bytes) -> Mapping[int, Fingerprint]:
+    """`clip_table` of a built PAC, parsed once per PAC: the findings ask every few seconds.
+    Read-only, as the table is shared by every caller."""
+    return MappingProxyType(clip_table(slots.anim_of(pac)))
 
 
 def source_clip_table(moveset: bytes) -> dict[int, Fingerprint]:
 
@@ -215,7 +215,7 @@ def _pac(m: Manifest, pac: bytes | None, sources: Mapping[int, int]) -> list[Fin
         return []
     out = []
     try:
-        table: dict[int, clips.Fingerprint] | None = clips.pac_clip_table(pac)
+        table: Mapping[int, clips.Fingerprint] | None = clips.pac_clip_table(pac)
     except ValueError as e:
         out.append(_f("error", "PAC_UNREADABLE", "", f"no clip table in the PAC: {e}"))
         table = None
@@ -232,7 +232,7 @@ def _pac(m: Manifest, pac: bytes | None, sources: Mapping[int, int]) -> list[Fin
 
 
 def _clips(
-    m: Manifest, table: dict[int, clips.Fingerprint], sources: Mapping[int, int]
+    m: Manifest, table: Mapping[int, clips.Fingerprint], sources: Mapping[int, int]
 ) -> list[Finding]:
     out = []
     moved = {
 
@@ -12,7 +12,7 @@
 
 import dataclasses
 import tomllib
-from collections.abc import Callable, Hashable, Sequence
+from collections.abc import Callable, Hashable, Mapping, Sequence
 from concurrent.futures import Future, ThreadPoolExecutor
 from contextlib import AbstractContextManager
 from dataclasses import dataclass
@@ -955,7 +955,7 @@ def attack_session(self) -> AttackSession | None:
 
     # clips
 
-    def clip_table(self) -> dict[int, clips.Fingerprint]:
+    def clip_table(self) -> Mapping[int, clips.Fingerprint]:
         """The open build's fingerprints."""
         sc = self.scene
         if sc is None:
 
@@ -33,6 +33,12 @@
     from mhfu_studio.shell.viewport import Viewport
 
 
+SLOW_COST, SLOW_EVERY = 0.05, 60.0
+"""Seconds: a check dearer than the first is not repeated on its own for the second, since a stall
+is the check's whole length and the interval's share of the time does not bound that. A change
+(`Findings.stale`) re-checks at once."""
+
+
 class Findings:
     """The active document's findings, re-checked on demand and, when `auto`, now and then.
 
@@ -55,7 +61,8 @@ def get(self, doc: Any, now: float | None = None) -> list[Finding]:
         if doc is None:
             self.found, self._doc = [], None
             return self.found
-        due = self.auto and now - self._at >= max(1.0, 10 * self._cost)
+        wait = SLOW_EVERY if self._cost > SLOW_COST else max(1.0, 10 * self._cost)
+        due = self.auto and now - self._at >= wait
         if self._stale or doc is not self._doc or due:
             t0 = time.monotonic()
             try:
 
@@ -237,3 +237,52 @@ def test_zinogre(games, built, ports):
 def test_brute(built):
     table = C.pac_clip_table(built("brute_tigrex"))
     assert len(table) == 77 and table[61] == (382, False) and 24 not in table
+
+
+@pytest.fixture
+def parses(monkeypatch):
+    """The PACs `pac_clip_table` parsed, with a table that says which."""
+    seen: list[bytes] = []
+    monkeypatch.setattr(slots, "anim_of", lambda pac: seen.append(pac) or pac)
+    monkeypatch.setattr(C, "clip_table", lambda pack: {1: (len(pack), True)})
+    C.pac_clip_table.cache_clear()
+    yield seen
+    C.pac_clip_table.cache_clear()
+
+
+def test_a_pac_is_parsed_once_whoever_asks(parses):
+    pac = b"a pac"
+    first = C.pac_clip_table(pac)
+    assert C.pac_clip_table(pac) is first and C.pac_clip_table(bytes(bytearray(pac))) is first
+    assert parses == [pac]
+
+
+def test_other_bytes_are_another_table(parses):
+    one, two = C.pac_clip_table(b"one"), C.pac_clip_table(b"three")
+    assert one is not two and dict(one) == {1: (3, True)} and dict(two) == {1: (5, True)}
+    assert parses == [b"one", b"three"]
+
+
+def test_the_table_is_shared_so_no_caller_can_change_it(parses):
+    table = C.pac_clip_table(b"pac")
+    with pytest.raises(TypeError):
+        table[2] = (1, False)
+    with pytest.raises(TypeError):
+        del table[1]
+    assert dict(C.pac_clip_table(b"pac")) == {1: (3, True)}
+
+
+def test_an_unreadable_pac_is_not_remembered(monkeypatch):
+    tries = []
+
+    def broken(pac):
+        tries.append(pac)
+        raise ValueError("no clips")
+
+    monkeypatch.setattr(slots, "anim_of", broken)
+    C.pac_clip_table.cache_clear()
+    for _ in range(2):
+        with pytest.raises(ValueError, match="no clips"):
+            C.pac_clip_table(b"bad")
+    assert len(tries) == 2
+    C.pac_clip_table.cache_clear()
@@ -0,0 +1,113 @@
+# SPDX-License-Identifier: GPL-3.0-or-later
+# SPDX-FileCopyrightText: 2026 sp00ktober
+"""The findings' own clock: how often a re-check runs, and what a slow one does to it."""
+
+from __future__ import annotations
+
+import pytest
+from mhfu_studio.shell import studio
+from mhfu_studio.shell.findings import Finding
+from mhfu_studio.shell.studio import SLOW_COST, SLOW_EVERY, Findings
+
+
+class Clock:
+    """`time.monotonic`, moved by the checks themselves."""
+
+    def __init__(self) -> None:
+        self.t = 0.0
+
+    def __call__(self) -> float:
+        return self.t
+
+
+class Doc:
+    """A document whose check costs `cost` seconds on `clock`."""
+
+    def __init__(self, clock: Clock, cost: float) -> None:
+        self.clock, self.cost, self.calls = clock, cost, 0
+
+    def findings(self) -> list[Finding]:
+        self.calls += 1
+        self.clock.t += self.cost
+        return []
+
+
+@pytest.fixture
+def clock(monkeypatch: pytest.MonkeyPatch) -> Clock:
+    c = Clock()
+    monkeypatch.setattr(studio.time, "monotonic", c)
+    return c
+
+
+def run(fs: Findings, doc: Doc, secs: float, step: float = 0.25) -> list[float]:
+    """The times in the next `secs` seconds (the window ticks every `step`) a check ran."""
+    ran, t = [], 0.0
+    while t <= secs:
+        before = doc.calls
+        fs.get(doc, now=t)
+        if doc.calls > before:
+            ran.append(t)
+        t += step
+    return ran
+
+
+def test_a_cheap_check_repeats_every_second(clock: Clock) -> None:
+    doc = Doc(clock, 0.005)
+    assert run(Findings(), doc, 5) == [0.0, 1.0, 2.0, 3.0, 4.0, 5.0]
+
+
+def test_a_check_dearer_than_a_tenth_of_its_interval_waits_longer_as_before(clock: Clock) -> None:
+    doc = Doc(clock, 0.04)
+    assert SLOW_COST > 0.04 and run(Findings(), doc, 3) == [0.0, 1.0, 2.0, 3.0]
+
+
+def test_a_slow_check_is_not_repeated_for_a_minute(clock: Clock) -> None:
+    doc = Doc(clock, 0.4)
+    assert SLOW_COST < 0.4
+    ran = run(Findings(), doc, 130)
+    assert ran == [0.0, SLOW_EVERY, 2 * SLOW_EVERY]
+
+
+def test_a_change_still_re_checks_at_once_however_slow_the_last_was(clock: Clock) -> None:
+    fs, doc = Findings(), Doc(clock, 0.4)
+    fs.get(doc, now=0.0)
+    fs.get(doc, now=10.0)
+    assert doc.calls == 1
+    fs.stale()
+    fs.get(doc, now=10.25)
+    assert doc.calls == 2
+
+
+def test_a_cheap_check_after_a_slow_one_brings_the_interval_back(clock: Clock) -> None:
+    fs, doc = Findings(), Doc(clock, 0.4)
+    fs.get(doc, now=0.0)
+    doc.cost = 0.005  # the cache is warm
+    fs.stale()
+    fs.get(doc, now=1.0)
+    assert doc.calls == 2
+    fs.get(doc, now=1.5)
+    fs.get(doc, now=2.0)
+    assert doc.calls == 3
+
+
+def test_another_document_is_checked_at_once(clock: Clock) -> None:
+    fs = Findings()
+    fs.get(Doc(clock, 0.4), now=0.0)
+    other = Doc(clock, 0.4)
+    fs.get(other, now=1.0)
+    assert other.calls == 1
+
+
+def test_a_check_that_fails_says_so_and_a_slow_failure_backs_off_too(clock: Clock) -> None:
+    class Bad(Doc):
+        def findings(self) -> list[Finding]:
+            self.calls += 1
+            self.clock.t += self.cost
+            raise ValueError("no")
+
+    fs, bad = Findings(), Bad(clock, 0.4)
+    assert [f.code for f in fs.get(bad, now=0.0)] == ["check-failed"]
+    fs.get(bad, now=5.0)
+    assert bad.calls == 1
+    fs.get(bad, now=SLOW_EVERY)
+    assert bad.calls == 2