Hold a tracing photo steady, and switch it on where you would look

The photo blinked out for a frame or two and sometimes never arrived, from
three causes that each present as the same bug. The still cache emptied
itself on the frame it filled, so every still on screen had to be fetched
and decoded again — every 48 frames of a scrub, and with two traced faces a
permanent flicker, each one's still evicting the other's; it drops the least
recently used now, a still being touched on every frame it is drawn. A still
cannot decode in the animation frame that asks for it, and a face whose next
one had not arrived drew nothing, so it now keeps the still it was showing
until the new one is there. And nothing was read ahead, so continuous
playback was always a frame behind its own footage; the next few frames'
stills are asked for while the playhead is moving on its own, and only then,
because a scrub asks for a different few at every step.

Whether the footage shows is no longer the document's. It was an :underlay
on an instance, inherited down the row path, nearest wins, and it went
through edit — so showing a reference photo was an undo step that travelled
to collaborators. It is [:ui :trace] now, the faces switched on and one
opacity, like solo, and there is nothing left to inherit: a face is the same
face wherever it is placed, so one switch covers every placement of it. The
paint loop asks for its own redraw when that changes, since the resolver no
longer does it for them.

Opening a face shows its footage, because a symbol has measured footage
behind it only because it was traced from that; a take does not, because a
take is the picture. The switch is on the bar above the stage, with the tone
and the tool, and on each face's timeline row beside solo — not a section
that appeared once the right row had been found. A face open in its own tab
could not show its footage at all before, shown having walked instances, and
that is the one place tracing matters most. The inspector keeps the face's
own keyed facts, its trace keys and its origin, and says why it cannot key a
frame rather than greying out the only button in the section.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>

frontend/test/arthur/domain/trace_test.cljs

@@ -70,39 +70,47 @@
         "a continuous head carries the held photo along with it")))
 
 (defn- wrapped
-  "Face-1's take placed, moved, inside a symbol :wrap, with `underlays` on the
-  instances named."
-  [{:keys [outer inner]}]
-  (-> @frozen
-      (assoc-in [:symbols :wrap] {:id :wrap :frames 200
-                                  :nodes {:m (cond-> {:id :m :kind :instance :of :main :z "a0"
-                                                      :channels {[:xform :pos] {:animated? false
-                                                                                :value [30 -10]}}}
-                                               outer (assoc :underlay outer))}})
-      (cond-> inner (assoc-in [:symbols :main :nodes :face-1 :underlay] inner))))
+  "Face-1's take placed, moved, inside a symbol :wrap."
+  []
+  (assoc-in @frozen [:symbols :wrap]
+            {:id :wrap :frames 200
+             :nodes {:m {:id :m :kind :instance :of :main :z "a0"
+                         :channels {[:xform :pos] {:animated? false :value [30 -10]}}}}}))
 
-(deftest an-underlay-covers-the-faces-below-it-and-the-nearest-decides
-  (is (= [{:path [:m :face-1] :face :face-1 :opacity 0.3}]
-         (trace/shown (wrapped {:outer {:on? true :opacity 0.3}}) :wrap))
-      "switched on at the take, its face shows")
-  (is (= [] (trace/shown (wrapped {:outer {:on? true} :inner {:on? false}}) :wrap))
-      "and the face can still be switched off inside it")
-  (is (= [{:path [:m :face-1] :face :face-1 :opacity 0.8}]
-         (trace/shown (wrapped {:inner {:on? true :opacity 0.8}}) :wrap)))
-  (let [c (wrapped {:outer {:on? true :opacity 0.3}})]
-    (is (= {:on? true :opacity 0.3 :own? false} (trace/underlay-at c :wrap [:m :face-1])))
-    (is (= {:on? true :opacity 0.3 :own? true} (trace/underlay-at c :wrap [:m])))
-    (is (nil? (trace/underlay-at @frozen :main [:face-1])))))
+(deftest a-face-switched-on-shows-wherever-it-is-placed
+  (let [c (wrapped)]
+    (is (= [{:path [:m :face-1] :in :main :face :face-1}] (trace/shown c :wrap #{:face-1}))
+        "a face inside a take inside a symbol, at the row path it is at")
+    (is (= [] (trace/shown c :wrap #{})) "and nothing when it is switched off")
+    (is (= [{:path [:face-1] :in :main :face :face-1}] (trace/shown c :main #{:face-1}))
+        "the same switch, one symbol down")
+    (is (= [{:path [] :in :face-1 :face :face-1}] (trace/shown c :face-1 #{:face-1}))
+        "the face open in its own tab is at no path at all — it IS the stage")
+    (is (= [] (trace/shown c :wrap #{:main}))
+        "a symbol that is not a face has no footage of its own to show")))
+
+(deftest the-faces-that-can-be-traced-are-listed-once-each
+  (is (= [:face-1] (trace/traceable-faces (wrapped) :wrap)))
+  (is (= [:face-1] (trace/traceable-faces @frozen :main)) "the take it was frozen into")
+  (is (= [:face-1] (trace/traceable-faces @frozen :face-1)) "itself, open to draw over"))
+
+(deftest a-face-opened-to-be-drawn-over-starts-with-its-footage-showing
+  (let [c (wrapped)]
+    (is (= #{:face-1} (trace/showing-for c :face-1 #{})) "the face's own tab")
+    (is (= #{} (trace/showing-for c :main #{}))
+        "and not the take it is placed in, which is the picture itself")
+    (is (= #{:face-1} (trace/showing-for c :main #{:face-1}))
+        "one already switched on stays on wherever you go")))
 
 (deftest a-take-lists-the-faces-in-it
   (is (= [{:path [:face-1] :in :main :face :face-1}] (trace/faces @frozen :main)))
-  (is (= [{:path [:m :face-1] :in :main :face :face-1}] (trace/faces (wrapped {}) :wrap)))
+  (is (= [{:path [:m :face-1] :in :main :face :face-1}] (trace/faces (wrapped) :wrap)))
   (is (= [] (trace/faces @frozen :face-1))))
 
 (deftest the-resolver-says-where-a-nested-head-went-on-its-last-frame
   ;; The same answer as `nest/placement`, which walks and resolves the path all
   ;; over again — the resolver has it already, from drawing the frame.
-  (let [c (wrapped {})
+  (let [c (wrapped)
         r (clip/resolver c @store pal/index-of :wrap)
         path [:m :face-1 :head]]
     (doseq [f [0 17 60]]