@vernikr/size-report 2.5.0 → 2.7.0

package/src/doctor.js

@@ -48,12 +48,12 @@ function environment(root) {
 
 /* Dependencies: what counts the metrics here and now. The very loaders the sensors use are asked
  * (`minifier`, `tokenizer`), so the answer cannot drift from the number: without the minifier `min` counts
- * by approximation, without the dictionary `tok` by estimate.
+ * by simplification, without the dictionary `tok` by estimate.
  *
  * Only what the project actually asked for is loaded: the dictionary weighs megabytes, and touching it for
  * the sake of an "installed" line would mean paying for an answer the numbers never needed (the same rule as
  * in the report: `test/tokens.test.js`). An unwanted sensor is named unneeded rather than unknown — it does
- * not affect accuracy, and that is the answer; "unknown" stays for the case where the settings are unreadable
+ * not affect the count, and that is the answer; "unknown" stays for the case where the settings are unreadable
  * and there is nobody to ask. */
 const UNREADABLE = 'unknown: the settings cannot be read';
 
@@ -132,8 +132,8 @@ function hookFindings(hooks) {
 }
 
 /* Coverage is the same answer `size check` gives, plus the kind of trouble if there is one: an incomplete path
- * or an approximating sensor (the kinds weigh differently — `WEIGHT`), with incompleteness outranking, because
- * without it there are no numbers at all.
+ * or a sensor counting another way (the kinds weigh differently — `WEIGHT`), with incompleteness outranking,
+ * because without it there are no numbers at all.
  * What becomes a finding and what does not: the report holds the whole coverage block (the same text as
  * `size check`), so incompleteness is not retold a second time — it weighs. Sensors do get a finding:
  * `size check` prints them as a `!` line, while here they are part of the answer. */

package/src/history.js

@@ -1,7 +1,7 @@
 import fs from 'fs';
 import path from 'path';
 import { assertFullHistory, diskForm, diskHashes, git, headTree, readBlobs, readHistory } from './git.js';
-import { METRICS, measureBlob, pointExact } from './metrics.js';
+import { METRICS, measureBlob } from './metrics.js';
 import { touchedSection } from './journal.js';
 import { EXIT, refuse } from './refusal.js';
 
@@ -82,15 +82,10 @@ function applyPicks(pass, c, picks) {
     }
     const blob = pass.blobs.get(pick.spec);
     const cells = {};
-    /* Approximation is a property of the path rather than of the blob: whether the format goes to
-     * the minifier depends on its extension. It is computed here along with the measurement, and
-     * so it does not enter the content cache. */
-    const approx = {};
     pass.metrics.forEach((m) => {
       cells[m] = pass.measure(m, blob, pick.path, c.sha);
-      approx[m] = !pointExact(m, pick.path, pass.cfg);
     });
-    pass.state[i] = { path: pick.path, sha: blob.sha, cells: cells, approx: approx };
+    pass.state[i] = { path: pick.path, sha: blob.sha, cells: cells };
   });
 }
 
@@ -127,8 +122,7 @@ function stepCommit(pass, c, ci) {
     when: c.when,
     subject: c.subject,
     section: section,
-    cells: pass.state.map((s) => (s === null ? null : s.cells)),
-    approx: pass.state.map((s) => (s === null ? null : s.approx))
+    cells: pass.state.map((s) => (s === null ? null : s.cells))
   });
 }
 

package/src/init.js

@@ -14,7 +14,8 @@ import { packageManager } from './project.js';
  * pass the very check the first run will apply**, or the advice leads a person into a new dead end.
  */
 
-/* What to say after writing: what was written, what will replace the approximations, and what to do
+/* What to say after writing: what was written, what counts the same numbers when the optional
+ * dependency is missing, and what to do
  * next. The lines are assembled into a list rather than printed as they come, so that "what was said"
  * can be read as a whole. */
 function draftLines(root, target, cfg) {

package/src/locales.js

@@ -9,7 +9,7 @@ export const LOCALES = {
     commit: 'Коммит',
     total: 'Общий объём',
     now: 'сейчас',
-    categories: { code: 'Код', docs: 'Документация', chore: 'Служебные', assets: 'Ресурсы' },
+    categories: { code: 'Код', tests: 'Тесты', docs: 'Документация', chore: 'Служебные', assets: 'Ресурсы' },
     /* The page texts live inside the report file itself (a dictionary of their own, next to
      * the data), so changing a word costs a rebuild of the report — otherwise the file
      * drifts from the history. */
@@ -37,12 +37,6 @@ export const LOCALES = {
       categoryByExtension: 'по расширению',
       all: 'все',
       sub: '{tool} {version} · {artifact}',
-      /* Words of precision: a metric label speaks about the worst in its column, a cell
-       * about its own number. One word serves both the label and the cell hint, so the two
-       * cannot drift or sound differently. */
-      exact: 'точное число',
-      approximate: 'приближение',
-      approximateCell: 'приближённое число: ',
       panelMethod: 'способ:',
       emptyMetrics: 'Ни одна метрика не выбрана — таблицу не из чего собрать. '
         + 'Включите хотя бы одну в панели выше: без метрик нет ни одной колонки с числом.',
@@ -54,6 +48,14 @@ export const LOCALES = {
         + 'что выбрано в этом браузере.',
       linkExtra: 'Часть ссылки пропущена: в этом отчёте нет {n} названных имён. '
         + 'Остальное применено.',
+      /* Данные отчёта лежат в файле сжатыми, и распаковывает их браузер. Текст называет причину
+       * (браузера нет в списке тех, что умеют `DecompressionStream`) и что с этим делать — пустая
+       * таблица не сказала бы читателю ничего. */
+      unpack: 'Данные отчёта сжаты, а браузер не умеет их распаковать: в нём нет DecompressionStream. '
+        + 'Обновите браузер — таблицу показывать не из чего.',
+      /* Полоска вверху страницы: имя для тех, кто читает страницу не глазами, — она показывает,
+       * что идёт отрисовка колонок, а не что отчёт завис. */
+      working: 'отрисовка колонок',
       note: 'Абсолютные размеры стоят один раз — в строке «{now}». Строк: {rows}: коммиты без '
         + 'изменения объёма и коммиты, тронувшие только выключенные файлы, строк не получают. '
         + 'Собрано из истории git: {command}.'
@@ -81,7 +83,7 @@ export const LOCALES = {
     commit: 'Commit',
     total: 'Total',
     now: 'now',
-    categories: { code: 'Code', docs: 'Documentation', chore: 'Chores', assets: 'Assets' },
+    categories: { code: 'Code', tests: 'Tests', docs: 'Docs', chore: 'Chores', assets: 'Assets' },
     page: {
       metrics: 'Metrics',
       files: 'Files',
@@ -99,9 +101,6 @@ export const LOCALES = {
       categoryByExtension: 'by extension',
       all: 'all',
       sub: '{tool} {version} · {artifact}',
-      exact: 'an exact number',
-      approximate: 'an approximation',
-      approximateCell: 'an approximate number: ',
       panelMethod: 'method:',
       emptyMetrics: 'No metric is selected — there is nothing to build the table from. '
         + 'Turn on at least one above: without metrics there is no column holding a number.',
@@ -113,6 +112,13 @@ export const LOCALES = {
         + 'has.',
       linkExtra: 'Part of the link is skipped: this report has none of the {n} names '
         + 'it mentions. The rest is applied.',
+      /* The report's data lies in the file compressed and the browser unpacks it; this text is what a
+       * browser without `DecompressionStream` gets instead of an empty table. */
+      unpack: 'The report\u2019s data is compressed and this browser cannot unpack it: there is no '
+        + 'DecompressionStream. Update the browser — there is nothing to build the table from.',
+      /* The bar at the top of the page: a name for whoever reads the page without eyes — it shows
+       * that the columns are being drawn rather than that the report has hung. */
+      working: 'drawing the columns',
       note: 'Absolute sizes appear once — in the “{now}” row. Rows: {rows}: commits that change '
         + 'no number, and commits touching only the disabled files, get no row. '
         + 'Collected from git history: {command}.'

package/src/metrics.js

@@ -4,9 +4,9 @@ import { EXACT_STRATEGIES, assertCompilable, byteLen, minifyForm, strategyFor }
 import { MINIFY_LOADERS, minifier, minifyWithEsbuild } from './minify.js';
 import { CHARS_PER_TOKEN, isBinary, tokenCount, tokenizer } from './tokens.js';
 
-/* The registry of metrics: what is measured, whether a metric needs the text, and how honest
- * its number is. Separate from the ways of stripping ballast: a metric is a promise about a
- * number rather than a way to obtain one.
+/* The registry of metrics: what is measured, whether a metric needs the text, and how its
+ * number is obtained. Separate from the ways of stripping ballast: a metric is a promise about
+ * a number rather than a way to obtain one.
  *
  * The description a reader sees comes from `metricView` rather than from the registry fields:
  * for one and the same metric it depends on the settings (`min` is either real compression or
@@ -14,8 +14,8 @@ import { CHARS_PER_TOKEN, isBinary, tokenCount, tokenizer } from './tokens.js';
  * question have nowhere to drift apart. */
 
 /* The ways to obtain the `min` metric: stripping ballast and real compression. Their mechanism
- * differs, and so does their promise, so each has its own method, its own honesty and its own
- * note — and neither is passed off as the other. */
+ * differs, and so does the method a reader is told, so each has its own text — and neither is
+ * passed off as the other. */
 export const MINIFY_ENGINES = ['strip', 'esbuild'];
 
 const STYLES = {
@@ -33,12 +33,12 @@ const STYLES = {
     },
     method: { ru: 'esbuild {version} (minify, rename)', en: 'esbuild {version} (minify, rename)' },
     fallback: {
-      ru: '; остальные форматы ({exts}) — упрощение без комментариев и отступов, то есть приближение',
-      en: '; other formats ({exts}) lose comments and indentation — an approximation'
+      ru: '; остальные форматы ({exts}) — упрощение без комментариев и отступов',
+      en: '; other formats ({exts}) lose comments and indentation'
     },
     unavailable: {
-      ru: ' (минификатор esbuild недоступен — счёт упрощением, то есть приближением)',
-      en: ' (the esbuild minifier is unavailable — comments and indentation are stripped: an approximation)'
+      ru: ' (минификатор esbuild недоступен — счёт идёт упрощением)',
+      en: ' (the esbuild minifier is unavailable — comments and indentation are stripped)'
     }
   },
   tok: {
@@ -48,12 +48,12 @@ const STYLES = {
     },
     method: { ru: '{tool} {version}, {encoding} (BPE)', en: '{tool} {version}, {encoding} (BPE)' },
     binary: {
-      ru: '; для бинарных форматов ({exts}) это счёт байтов, а не текста — приближение',
-      en: '; binary formats ({exts}) are counted by bytes rather than text — an approximation'
+      ru: '; для бинарных форматов ({exts}) это счёт байтов, а не текста',
+      en: '; binary formats ({exts}) are counted by bytes rather than text'
     },
     estimate: {
-      ru: 'оценка по длине: 1 токен ≈ {chars} знака ({encoding} недоступен) — приближение',
-      en: 'length-based estimate: 1 token ≈ {chars} characters ({encoding} is unavailable) — an approximation'
+      ru: 'оценка по длине: 1 токен ≈ {chars} знака ({encoding} недоступен)',
+      en: 'length-based estimate: 1 token ≈ {chars} characters ({encoding} is unavailable)'
     }
   }
 };
@@ -71,7 +71,6 @@ export const METRICS = {
       ru: 'размер объекта git',
       en: 'the size of the git object'
     },
-    accuracy: 'exact',
     measure: (text) => byteLen(text)
   },
   min: {
@@ -103,57 +102,50 @@ export const METRICS = {
     needsText: true,
     note: { ru: 'сжатый поток (zlib, уровень 9)', en: 'compressed stream (zlib, level 9)' },
     method: { ru: 'zlib, уровень 9', en: 'zlib, level 9' },
-    accuracy: 'exact',
     measure: (text) => zlib.gzipSync(Buffer.from(text, 'utf8'), { level: 9 }).length
   }
 };
 
 /* The description of a metric for a reader: `note` is what the number means, `method` how it
- * was obtained, `accuracy` whether it is exact or approximate. */
+ * was obtained. */
 export function metricView(name, cfg) {
   const metric = METRICS[name];
   if (metric.view !== undefined) return metric.view(cfg);
   return {
     label: metric.label,
     note: metric.note[cfg.locale],
-    method: metric.method[cfg.locale],
-    accuracy: metric.accuracy
+    method: metric.method[cfg.locale]
   };
 }
 
-/* The label of the `min` metric. The honesty convention: `accuracy` speaks about the worst in
- * the column, while the method says where exactly the approximation is — so one format without
- * a minifier makes the whole metric approximate instead of hiding behind the "exact" of a
- * neighbouring file. The worst is taken by the same rule as the cell marks (`pointExact`)
- * rather than by the name of the method: a report with no approximate format at all is exact
- * even with the ballast stripped. */
+/* The label of the `min` metric. The method names the formats this metric counts another way: a
+ * format the minifier does not take is given in words rather than hidden behind the neighbouring
+ * one, so a reader sees what the column is made of. The list comes from the same rule the counting
+ * uses (`otherCountFormats`) rather than from the name of the method. */
 function minView(cfg) {
   const loc = cfg.locale;
-  const rough = approximateFormats('min', cfg);
+  const other = otherCountFormats('min', cfg);
   if (minEngine(cfg) === 'esbuild') {
     let method = STYLES.esbuild.method[loc].replace('{version}', minifier().version);
-    if (rough.length > 0) method += STYLES.esbuild.fallback[loc].replace('{exts}', rough.join(' '));
+    if (other.length > 0) method += STYLES.esbuild.fallback[loc].replace('{exts}', other.join(' '));
     return {
       label: METRICS.min.label,
       note: STYLES.esbuild.note[loc],
-      method: method,
-      accuracy: rough.length === 0 ? 'exact' : 'approximate'
+      method: method
     };
   }
   const degraded = cfg.minify.engine === 'esbuild';
   return {
     label: METRICS.min.label,
     note: STYLES.strip.note[loc],
-    method: STYLES.strip.method[loc] + (degraded ? STYLES.esbuild.unavailable[loc] : ''),
-    accuracy: rough.length === 0 ? 'exact' : 'approximate'
+    method: STYLES.strip.method[loc] + (degraded ? STYLES.esbuild.unavailable[loc] : '')
   };
 }
 
-/* The label of the `tok` metric. The honesty convention is the same as for `min`: the method
- * says which dictionary produced the number (family and encoding are part of the count rather
- * than a detail), and `accuracy` says whether it is exact or approximate. It turns approximate
- * in two cases, both spelled out: formats for which tokens are not counted (their number runs
- * by bytes) and a missing dictionary (then the count is an estimate by length). */
+/* The label of the `tok` metric. The method says which dictionary produced the number (family and
+ * encoding are part of the count rather than a detail) and names the two cases where the count is
+ * another one, both spelled out: formats for which tokens are not counted (their number runs by
+ * bytes) and a missing dictionary (then the count is an estimate by length). */
 function tokView(cfg) {
   const loc = cfg.locale;
   const settings = cfg.tokens;
@@ -163,44 +155,38 @@ function tokView(cfg) {
       label: METRICS.tok.label,
       note: STYLES.tok.note[loc],
       method: STYLES.tok.estimate[loc]
-        .replace('{chars}', CHARS_PER_TOKEN).replace('{encoding}', settings.encoding),
-      accuracy: 'approximate'
+        .replace('{chars}', CHARS_PER_TOKEN).replace('{encoding}', settings.encoding)
     };
   }
-  const binary = approximateFormats('tok', cfg);
+  const binary = otherCountFormats('tok', cfg);
   let method = STYLES.tok.method[loc]
     .replace('{tool}', 'gpt-tokenizer').replace('{version}', version).replace('{encoding}', settings.encoding);
   if (binary.length > 0) method += STYLES.tok.binary[loc].replace('{exts}', binary.join(' '));
   return {
     label: METRICS.tok.label,
     note: STYLES.tok.note[loc],
-    method: method,
-    accuracy: binary.length === 0 ? 'exact' : 'approximate'
+    method: method
   };
 }
 
-/* Whether a particular cell holds an exact number — one rule for both the metric label and the
- * cell mark. That is why the label cannot drift from the cells, and why the list of
- * approximate formats is computed here, by the same rule.
- *
- * `min` is exact where the file really is minified: by the minifier, or by parsing a format
- * that cannot get any shorter (JSON loses only insignificant whitespace — the list of exact
- * strategies is owned by `strip.js`, where the strategies live). `tok` is exact where a
- * dictionary exists and the format is text: the "tokens" of a picture or a font are its bytes.
- * `raw` and `gzip` are always exact: they are unambiguous quantities. */
-export function pointExact(name, file, cfg) {
-  if (name === 'min') return minifiedForm(file, cfg);
-  if (name === 'tok') return tokenizer(cfg.tokens).tool !== null && !isBinary(file);
-  return true;
+/* Whether a file of this report is really minified: by the minifier, or by parsing a format that
+ * cannot get any shorter (JSON loses only insignificant whitespace — the list of exact strategies
+ * is owned by `strip.js`, where the strategies live). */
+function minifiedForm(file, cfg) {
+  return esbuildLoader(file, cfg) !== null || EXACT_STRATEGIES.indexOf(strategyFor(file, cfg)) >= 0;
 }
 
-/* The formats of this report that will be measured approximately. The list is derived from the
- * settings and the rule of exactness rather than written by hand. */
-function approximateFormats(name, cfg) {
+/* The formats of this report that the metric counts another way — the minifier does not take
+ * them, or tokens are meaningless for them (the "tokens" of a picture or a font are its bytes).
+ * The list is derived from the settings and the counting rule rather than written by hand, and
+ * it is what the method names in words. */
+function otherCountFormats(name, cfg) {
   const exts = [];
   cfg.columns.forEach((col) => {
     col.paths.forEach((p) => {
-      if (pointExact(name, p, cfg)) return;
+      const counted = name === 'min' ? minifiedForm(p, cfg)
+        : tokenizer(cfg.tokens).tool !== null && !isBinary(p);
+      if (counted) return;
       const ext = path.extname(p).toLowerCase();
       if (exts.indexOf(ext) < 0) exts.push(ext);
     });
@@ -208,10 +194,6 @@ function approximateFormats(name, cfg) {
   return exts.sort();
 }
 
-function minifiedForm(file, cfg) {
-  return esbuildLoader(file, cfg) !== null || EXACT_STRATEGIES.indexOf(strategyFor(file, cfg)) >= 0;
-}
-
 /* Whether the file goes to the minifier: compression is requested, available and not overridden
  * by an explicit choice of the project — `minify.ext` outranks the engine and serves as the way
  * out when an extension lied about its content. One answer serves two questions: how to count
@@ -224,8 +206,8 @@ function esbuildLoader(file, cfg) {
 }
 
 /* The engine actually in force: the requested one may be unavailable, in which case the metric
- * falls back to another count — and the fallback is announced (`sensorGaps`), or an
- * approximation would travel as an exact number. */
+ * counts another way — and that is announced (`sensorGaps`), or a different count would travel
+ * into CI as the requested one. */
 export function minEngine(cfg) {
   if (cfg.minify.engine !== 'esbuild') return 'strip';
   return minifier().tool === null ? 'strip' : 'esbuild';

package/src/minify.js

@@ -10,8 +10,8 @@ import { refuseCause } from './refusal.js';
  * number. */
 
 /* The extensions the minifier answers for. This table is the single source of truth both for
- * the measurement and for the metric label ("the other formats are an approximation"), so the
- * two cannot drift apart. JSX and TSX are not here: the output depends on the project's `jsx`
+ * the measurement and for the metric label ("the other formats lose comments and
+ * indentation"), so the two cannot drift apart. JSX and TSX are not here: the output depends on the project's `jsx`
  * setting (`React.createElement` versus `react/jsx-runtime`), and measuring someone else's
  * decision about a runtime is not this tool's business — such files are honestly counted as a
  * simplification. */

package/src/modes.js

@@ -26,9 +26,9 @@ function kmb(bytes) {
 }
 
 /* Degradation is a fact of the report, not an error: the numbers came from a different
- * method (stripping instead of minification, an estimate instead of an exact count) because
+ * method (stripping instead of minification, an estimate instead of a counted one) because
  * an optional dependency is missing. The fact is printed once per sensor and becomes code
- * 4 — otherwise an approximation would travel into CI as success. */
+ * 4 — otherwise a different count would travel into CI as the requested one. */
 function note(gaps) {
   gaps.forEach((gap) => console.error('! ' + gap.why + '\n  fix: ' + gap.fix));
   return gaps.length === 0 ? EXIT.OK : EXIT.SENSOR;
@@ -39,11 +39,11 @@ function sensorNote(cfg) {
 }
 
 /* The mode's verdict together with the sensor notes: the note is printed always — silence
- * about a different count reads as an exact number, and a disagreement would be left without
- * a cause — while the code stays the more important one. A violation outranks an
- * approximation (the same order as in `check` and `doctor`): code 4 claims the numbers are
- * honest but counted differently, and when the table disagrees nobody checked that — the
- * disagreement may be a real edit that went past the report. */
+ * about a different count reads as the requested one, and a disagreement would be left without
+ * a cause — while the code stays the more important one. A violation outranks a sensor note
+ * (the same order as in `check` and `doctor`): code 4 claims the difference is explained by the
+ * missing sensor, and when the table disagrees nobody checked that — the disagreement may be a
+ * real edit that went past the report. */
 function verdict(code, gaps) {
   const sensors = note(gaps);
   return code === EXIT.OK ? sensors : code;
@@ -127,7 +127,7 @@ export function coverageMode(cfg, root, configFile, asJson) {
 /* Diagnostics in one answer (`size doctor`): environment, dependencies, settings and
  * coverage, assembled from the same pieces as the other modes. The exit code is not
  * "something is wrong" but the first by importance (settings → history → coverage →
- * approximation): an agent branches on it, a human reads the text. */
+ * sensor): an agent branches on it, a human reads the text. */
 export function doctorMode(root, configFile, asJson) {
   return answer(doctor(root, configFile), asJson, doctorText).exit;
 }

package/src/optional.js

@@ -1,8 +1,8 @@
 import { createRequire } from 'module';
 
 /* Optional dependencies: the minifier and the tokenizer. Missing ones are not a refusal but a
- * different count (a simplification instead of compression, an estimate instead of an exact
- * count), so their loading is shared and shaped the same way: lazy, synchronous
+ * different count (a simplification instead of compression, an estimate instead of a counted
+ * one), so their loading is shared and shaped the same way: lazy, synchronous
  * (`createRequire` — measuring is one synchronous pass, and `import()` would make the whole
  * chain asynchronous for the sake of a single sensor) and without an exception escaping —
  * unavailability comes back as an answer.

package/src/page/app.css

@@ -6,7 +6,7 @@
  *
  * The shared part is frozen by the artifact's bytes (`src/css.js`), which is why everything where the page departs from
  * its geometry is gathered in the "adaptations" section together with its reason: the shared part cannot grow, while on a
- * narrow screen the 300px commit column would eat the whole screen. */
+ * narrow screen the commit column would eat the whole screen. */
 
 :root {
   color-scheme: light dark;
@@ -111,12 +111,8 @@ h1 { margin: 0 0 3px; font-size: 21px; font-weight: 650; letter-spacing: -.012em
 .box.plain input { cursor: default; }
 
 /* There is no legend under the file tree, and on purpose: below the list it pushed the numbers away, while its content
- * already stands next to what it explains — the colour of a delta is named by the sign of the number itself, accuracy
- * stands under the metric switches, and the mark of a file that is not there yet lives in the cell's tooltip.
- *
- * An approximate number is marked by a dashed line rather than a colour: colour in the table is taken by the delta (growth
- * and fall), and a second meaning on the same sign would read as the first. */
-#grid td.approx { text-decoration: underline dotted; text-underline-offset: 2.5px; }
+ * already stands next to what it explains — the colour of a delta is named by the sign of the number itself, the way each
+ * number was counted stands under the metric switches, and the mark of a gap lives in the cell's text. */
 
 /* The table has a frame and a scroll of its own: the header and the commit column stick to it (the rules of stickiness
  * live in the shared part) rather than to the page, so scrolling sideways shows whose row it is while scrolling down shows
@@ -131,6 +127,33 @@ h1 { margin: 0 0 3px; font-size: 21px; font-weight: 650; letter-spacing: -.012em
 /* Numbers are denser than the page's text: there are more of them, they are shorter, and they are read by their digits. */
 #grid { font-size: 12.5px; }
 
+/* The stripe of a long drawing: over the window's own top edge for as long as a switch is being drawn (`src/page/work.js`).
+ * It is fixed rather than laid out — the page's shape is a grid of five rows, and a stripe appearing inside it would move the
+ * numbers every time a switch is drawn — and it is taken away as soon as the drawing is over, so the reader never sees it at
+ * rest. It **does not fill**: the drawing is one task of the browser's own layout, inside which nothing can repaint, so a
+ * share would be a share nobody has (`src/page/work.js` says what was measured). What moves instead is an indeterminate
+ * stripe — a travelling highlight, which is what this state is in the language of progress — and it moves by a transform,
+ * so the stripe itself costs the compositor rather than the page. Its colour is the system accent, the one colour the page
+ * uses for anything but the numbers, and it carries a role and a name, because a reader without eyes has to be told that
+ * work is going on rather than that the report is broken. */
+.bar { position: fixed; top: 0; left: 0; right: 0; z-index: 5; height: 3px; overflow: hidden; }
+.bar[hidden] { display: none; }
+.bar > i {
+  display: block;
+  width: 30%;
+  height: 100%;
+  background: AccentColor;
+  animation: bar-run 1.1s linear infinite;
+}
+@keyframes bar-run {
+  from { transform: translateX(-100%); }
+  to { transform: translateX(333%); }
+}
+/* Whoever asked the system for less motion gets a still stripe: the state is what matters, not its travelling. */
+@media (prefers-reduced-motion: reduce) {
+  .bar > i { animation: none; width: 100%; }
+}
+
 /* The message about a link that came in stands above the table, so that it cannot be missed, while it does not push the
  * table away: one line in the place of the page. Its colour is the system one (the accent), for the page keeps no colours
  * of its own. */
@@ -230,5 +253,7 @@ h1 { margin: 0 0 3px; font-size: 21px; font-weight: 650; letter-spacing: -.012em
   h1 { font-size: 18px; }
   #grid { font-size: 12px; }
   .shell { max-height: calc(100vh - 260px); }
-  .clip { width: 190px; }
+  /* The commit column needs no rule of its own here any more: its width is the measure `--clip` of the shared part
+   * (`src/table.css`), and on a narrow screen that measure stands as it is. A shorter one would be `--clip: 150px`
+   * here — the adaptation the shared part cannot make for itself. */
 }