web: a reading of a hundred thousand frames says where it is once, counts what the catalogue holds, and keeps a quarter of the disk it kept

A roll of a hundred thousand frames is read by a walk that tells the screen
about every frame it lands. The column is redrawn out of that count, so the
telling was a whole tree rebuilt a frame at a time — on the large library that
is the reading spending its afternoon drawing itself, and to the reader it looks
like a scan that has started over from the top every time the column breathes.
Five tellings a second is a counter that still moves to the eye and a page that
is doing the reading instead; every frame still lands in the counts, and only
the copy the screen reads waits.

What the counter said was wrong twice over, and both were the same mistake told
two ways. The total was the frames already reached plus the frames still in the
queue, so a roll whose catalogue already holds most of it announced itself as
`29980/61211` — the numbers of the reading underneath, printed as if they were
the numbers of the roll. The reading now measures itself against the frames the
catalogue already holds of the folder it was pointed at: the roll's own size
while the walk is still up in its first folders, and the frames under a
subfolder alone when it was kept to one. And a row says at least what the
catalogue holds of it, never less — where the reading's number alone had the
head of the tree count 29980 while the line above it counted a hundred
thousand, one question with two answers. Nor is a scan of nothing announced as
`0/0` before its first pass has come back; the line waits until it knows what it
is reading.

The third thing is not a number but a weight. The tile kept for a frame is the
tile the grid cell and the strip both paint, and there is one of them per frame
of a roll that reaches six figures. At 512 on the long edge a tile weighed 42KB
and a hundred and sixty thousand of them weighed six and a half gigabytes of the
reader's disk — for a grid cell that is ~240px wide and a strip tile that is 132.
A quarter of the pixels at the quality Lightroom keeps its own grid previews at
puts the same picture in the same cell: the tile is now ~12KB and the roll a
quarter of the disk it was. The canvas a tile is drawn onto is told it is opaque,
so it no longer carries a channel of noughts through every draw and every encode.
The stage loses a little softness at 2.4x, which is the trade and is known.

docker/frontend/src/Library.tsx

@@ -666,7 +666,12 @@ export function Library() {
   const read = live && !live.progress.from ? live.progress.counts : null;
   const nodes = useMemo<Node[]>(() => {
     const hits = new Map<string, number>();
-    const counted = (key: string, hit: number | undefined) => read?.[key] ?? hit ?? 0;
+    // The reading's own count is a floor, never a ceiling: a row says at least
+    // what the catalogue already holds of it. A roll being read again says its
+    // own size while the reading is still walking up to it — where the reading's
+    // number alone would have the head of the tree count 29980 while the line
+    // above it counts a hundred thousand, one question with two answers.
+    const counted = (key: string, hit: number | undefined) => Math.max(hit ?? 0, read?.[key] ?? 0);
     const foldersUnder = new Map<string, Set<string>>();
     // One path per folder between the picked one and `rel`, so a row is drawn for
     // every folder on the way to a frame as well as for the frame's own.
@@ -976,8 +981,14 @@ export function Library() {
               <span className="hint lib-bar-hint" title={t('lib.hint')}>
                 {t('lib.hint')}
               </span>
+              {/* Nothing is drawn until the reading knows what it is reading: a
+                  roll of nothing over nothing is the line talking before the
+                  first pass has come back, which is a scan of a hundred
+                  thousand frames announced as `0/0`. */}
               <span className="hint" data-key="lib-progress">
-                {live ? t('lib.scanning', { done: live.progress.done, total: live.progress.total, added: live.progress.added }) : ''}
+                {live && live.progress.total
+                  ? t('lib.scanning', { done: live.progress.done, total: live.progress.total, added: live.progress.added })
+                  : ''}
               </span>
               <span className="adm-spacer" />
               {folders.length > 0 ? (