web: a reading says so on the way down to the folder it was kept to, and the roll's row speaks only for itself

A reading was made to say so on one row only — the folder it was kept to — and
that row is the wrong row to say it alone, because it is the row a folded branch
takes away. A reader who has closed the folder being read, or who is looking at
a branch of it, is left with a tree in which nothing at all is happening while a
reading runs under the fold. The rows that say a reading is under way are now the
folder it was kept to and every folder above it on the way down. Depth is the
whole of the rule: the way down is what the eye follows to reach the folder, so a
mark on that path is a mark the reader can walk to the work from.

The roll's own row is the exception, and the reason is the same depth read the
other way. A roll is the head of everything under it, and a roll that marks
itself while one folder of it is being read tells the reader that the whole of
it is being read — the one answer a tree of a hundred folders cannot afford, and
the exact answer the row's counts were already forbidden from giving. The roll
says so only when the roll itself is the folder being read. Nothing under the row
being read says anything at all: a reading has not reached the folders below it,
and a mark there would be a row claiming work done in a folder nothing has yet
looked at.

The rule turns on one of those boundaries being emptier than it looks. The path
of the picked folder is the empty string, and every path has the empty string in
front of it, so a prefix test against the way down answers yes for the head of
the tree no matter which folder below it is being read — the roll marking itself
for a branch was not an exception that had to be written, but a comparison that
had to be spelled so the empty path is asked about its own self and nothing else.

docker/frontend/src/Library.tsx

@@ -1065,12 +1065,20 @@ export function Library() {
                   >
                     {rows.map((n) => {
                       const folder = folders.find((f) => f.name === n.key.split('/')[0]) ?? null;
-                      // The row being read says so, and no other: a roll is read
-                      // from one folder down, and every row of that roll spinning
-                      // is a tree that says all of itself is being read when one
-                      // branch of it is. The row is the folder the reading was
-                      // kept to, which for a whole roll is the roll's own row.
-                      const scanning = !!folder && live?.folder === folder.name && relOf(n.key) === live.progress.from;
+                      // The rows that say a reading is under way are the folder it
+                      // was kept to and every folder above it on the way down, and
+                      // never a folder under it, which the reading has not reached.
+                      // Depth is why: a branch folded shut hides the row being read,
+                      // and the rows above it are what keeps the work in sight while
+                      // the folder doing it is out of sight. The roll's own row is
+                      // the exception, and says so only when the roll itself is what
+                      // is being read — a roll asked to speak for one branch of
+                      // itself tells the reader the whole of it is being read, which
+                      // is the one answer a deep tree cannot afford.
+                      const dir = relOf(n.key);
+                      const from: string | null = live && live.folder === folder?.name ? live.progress.from : null;
+                      const scanning =
+                        dir !== null && from !== null && (dir === '' ? from === '' : dir === from || from.startsWith(dir));
                       const under = parents.has(n.key);
                       return (
                         <button