From 3f5ef88de5f8033d666af3357d0bb241c5e7e21f Mon Sep 17 00:00:00 2001 From: 3dtours Date: Thu, 1 Oct 2026 20:30:25 +0700 Subject: [PATCH] web: the mark of a reading follows the folder the walk stands in, and the head of the tree never wears it MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit The mark was pinned to the folder a reading was kept to, which is a fine thing to say and no use at all to look at: a reading kept to the roll is kept to the roll for the whole of an afternoon, so the one row that said anything said the same word from the first frame to the last while the walk went through every folder under it. The reader asking which folder is being read was told, in answer, which folder they had asked about. A reading is where it is, not where it was pointed, and where it is is a thing only the reading knows — so the walk now tells it. The frame in hand names the folder it sits in, and the progress carried to the screen says so with the rest, which is where the column reads it. The mark is a way down and not a single row: the folder being read says so, and so does every folder above it. That is what keeps a reading visible under a branch folded shut — the row doing the work is the row the fold takes away, and the rows above it are all a reader would have left. Two rows say the same thing and no more, which is the point: the eye follows the marks down to the work. The head of the tree is never one of them, and this is the rule that survives from the last reading of the question. A roll is the head of everything under it, and a head marked while one folder below it is read says the whole of the tree is being read — an answer that is both loud and false, and worse than the silence it replaced. So the mark stops one row short of the top. The one case left bare is a reading whose frames sit in the roll's own folder and nowhere else: there is no row between the work and the head, and a flat roll is a roll in which the toolbar's line, which names the count, is the whole of what there is to say. --- docker/frontend/src/Library.tsx | 26 +++++++++++++------------- docker/frontend/src/engine/library.ts | 21 +++++++++++++++++++-- 2 files changed, 32 insertions(+), 15 deletions(-) diff --git a/docker/frontend/src/Library.tsx b/docker/frontend/src/Library.tsx index 17f8e0c..4337e9d 100644 --- a/docker/frontend/src/Library.tsx +++ b/docker/frontend/src/Library.tsx @@ -1065,20 +1065,20 @@ export function Library() { > {rows.map((n) => { const folder = folders.find((f) => f.name === n.key.split('/')[0]) ?? null; - // 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. + // The row that says a reading is under way is the folder the + // reading stands in — not the folder it was pointed at, which + // would be the same row for the whole of an afternoon while + // the work went on somewhere the reader cannot see — together + // with every folder above it, so a branch folded shut still + // shows the work going on under it. The roll's own row is + // never one of them: it is the head of everything below it, + // and a head that says all of a tree is being read says + // nothing about the folder the reading is actually in. The + // frames that sit in the roll's own folder are the one case + // left bare, and the toolbar's line is what carries them. 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 at = live && live.folder === folder?.name && live.progress.at ? `${live.progress.at}/` : null; + const scanning = dir !== null && dir !== '' && at !== null && (dir === at || at.startsWith(dir)); const under = parents.has(n.key); return (