@vernikr/size-report 2.8.2 → 2.8.4

package/README.md

@@ -10,7 +10,7 @@ shows.
 
 ## Status
 
-**Release 2.8.2 (2026-09-18).** The tool lives as a package of its own: the registry name is
+**Release 2.8.4 (2026-09-18).** The tool lives as a package of its own: the registry name is
 `@vernikr/size-report` (published by tag from CI, with no secret). A project may keep no settings at
 all: without a config file the tool derives them from the project itself and says so in one line,
 and `--init` pins what was derived into a file. The report is **one file**, the self-contained page
@@ -19,6 +19,34 @@ is installed and on the first run. The version is in the manifest, and every rel
 the journal — `worklog/` for today's entries, `worklog/archive/WORKLOG.md` for the earlier ones:
 what changes in the numbers is measured rather than retold.
 
+2.8.4 is about the volume of the tree rather than of a report, and it is a sweep — no feature. **The six probes that
+measured the page's steps are archived** (`probes/archive/`, 1 458 lines): the plan they served is settled, its figures
+stand in `plans/2026-09-17-page-perf/` and in the worklog, so the instruments stay as the record of how the numbers were
+taken, with every reference following them. **The open notes are closed**: the help's continuation lines are no longer
+read as commands (the list falls from ten words to six), an advice without a flag is a command again, two assertions
+that could not fail are gone (`test/check.test.js`, `test/gates-verify.test.js`), the last two Russian comments left
+`src/` (the locale's strings stay — they are data), and `tools/run-tests.js` hands its extra flags to `node --test`
+**before** the file, where node 22 reads them. **The copies below the sensors' thresholds went too**: one helper
+spawns the frozen copy instead of two builders' own, one function sets the identity git refuses to commit without
+(three sites had grown the loop), and a suite's temporary directory removes itself when the process ends — 25 suites
+opened with the same pair of lines. Nine `export` keywords on names nothing outside their module reads left the
+surface, and `TODO.md` fell from 96 lines to 31. The checks are at **87** in the fast profile and **192** in the full
+one, none added and none removed; the code of the tree changed by −44 lines. The figures and the reasoning stand in
+`worklog/0213-the-volume-swept-and-the-probes-archived.md`.
+
+2.8.3 is about what a sideways scroll of the report costs, and its figures are measured rather than retold. **A step
+sideways moves the window instead of building it:** a row is made once and lives through the move, keeping its node and
+its numbers — the window's columns are the range of that row's numbers, so the columns that entered it are made and the
+ones that left are dropped, the header's line of names and its line of metrics by the same rule. A switch of the
+reader's own and the shell's resize are the one thing that cannot be a move — a column that is not built cannot be
+shown — and they build the window from nothing as they did. **Measured on this repository's own report in live Chrome**
+(`probes/archive/step-12-window.mjs`, two rounds, 1440 × 900): the page's own handling of one step **10.4 → 0.6 ms** (worst
+19.2 → 3.6) and the layout the step forces **14.4 → 5.9 ms**; over a sweep of forty steps the browser's own accounting
+gives layout **0.605 → 0.246 s**, style recalculation 0.169 → 0.056 s and task time **1.281 → 0.350 s**. The checks go
+86 → **87** in the fast profile and 191 → **192** in the full one: `test/page-grid.test.js` holds the rule by node
+identity — a page that built the same numbers again would read the same — and by the numbers of the window built at
+that place in one leap. The figures and the reasoning stand in `worklog/0211-sideways-step.md`.
+
 2.8.2 is about the page's own sources and the checks that guard them, and its figures are measured rather than retold.
 **The four page suites that went quiet with the `<table>` are alive again against the window:** `test/page-view.test.js`,
 `page-cols`, `page-tree` and `page-choice` read the grid and the panel they guard rather than markup that no longer
@@ -91,7 +119,7 @@ class changes are about 2 µs a node; on this page the whole Table of Contents o
 the same click in 37 slices paid that relayout 37 times — **169 layouts and 151.9 s of pure layout time against
 1.04 s**, with the tab growing to gigabytes of repaint and the reader waiting four minutes for a switch that
 costs him less than a second unsliced. Within one task nothing can repaint, so a bar that filled would be a bar
-nobody could read: the stripe travels and says the work is going on (`probes/step-12-columns.mjs`, the records in
+nobody could read: the stripe travels and says the work is going on (`probes/archive/step-12-columns.mjs`, the records in
 `worklog/0207-page-choice-bar.md`). The order of the columns did not change there: what the last commit touched
 still stands first, the rest after it in the settings' order.
 
@@ -271,8 +299,8 @@ commits and installs hooks; the reason for each expensive file is named line by
 
 | Run | Command | Checks |
 |---|---|---|
-| Fast — every edit | `pnpm test` | **86 of 191** |
-| Full — release and CI | `pnpm test:all` | **191** |
+| Fast — every edit | `pnpm test` | **87 of 192** |
+| Full — release and CI | `pnpm test:all` | **192** |
 
 No check is lost or weakened: the full run starts every file, the fast one takes part of them. The default is the full run — a file becomes fast only explicitly and with a reason — so new
 expensive work cannot quietly move into the fast one. Two declarations guard that:
@@ -396,7 +424,7 @@ left it and what entered it. The header sticks to the top of the shell and the c
 number belongs to and the file it stands under are always in sight. The price of a table is what this step removed:
 238 500 cells were 253 770 nodes in the document and 377 396 in the browser, **1.46 GB** of a fresh Chrome's memory at
 rest, and any change of a column's visibility meant the browser laying the whole of it out again — 234.5 ms of layout for
-a *single* cell of this repository's report, 539 ms for 6 000 (`probes/step-12-columns.mjs`). A window of the same
+a *single* cell of this repository's report, 539 ms for 6 000 (`probes/archive/step-12-columns.mjs`). A window of the same
 table is **2 460 nodes and 0.15 GB**, a hundredth of the nodes and a tenth of the memory, and the whole-table scroll
 pass that took 36 s of task time over 60 steps takes **1.1 s over 251** (`worklog/0208-table-window.md`). **The columns
 are one width and fixed, 70px each**: the numbers are short and of one kind, and a width that came out of the text is a
@@ -407,7 +435,10 @@ right edge of the pinned commit column rather than under it, and every line of t
 cell, along a group's left edge — is one pixel of one colour: a heavier line would promise a hierarchy to work out
 rather than read. The geometry is four figures — a column, a row, the header, the pinned column — written in the styling
 and in the script that counts the window's ordinals in them, and `test/page-grid.test.js` reads both and holds them
-together.
+together. **A step sideways moves that window rather than building it:** the rows live through the move and only the
+columns that entered are made, at 10.4 → **0.6 ms** for the page's own handling of the step, 14.4 → **5.9 ms** for the
+layout it forces and 1.281 → **0.350 s** of task time over a sweep of forty steps
+(`probes/archive/step-12-window.mjs`).
 
 **A click builds the window again, and that is cheap now.** A file switched off is simply not among the columns that
 are built, and a metric switched off not among the metrics: there is nothing to hide and nothing to carry, and the
@@ -586,7 +617,7 @@ acceptance for each.
 | `tools/parity-freeze.js` | Takes the parity reference (`pnpm run parity`): with the frozen copy, at the project revision from the manifest — `--json`, the config, the artifact's hash, the tool's hash |
 | `tools/make-fixture.js` | Assembles the synthetic fixture (`pnpm run fixture`): a deterministic history with traps plus the reference numbers |
 | `tools/synthetic/` | The subjects of that assembly, one per matter: `repo.js` — how git is spoken to (pinned time, author, settings), `content.js` — what the files hold, `history.js` — which commits come of it, `note.js` — the fixture's note with the list of traps |
-| `probes/` | The scripted measurements behind `plans/2026-09-17-page-perf/`: one file per step, run by hand against live Chrome at the debug port — the fixed layout, where `content-visibility` acts at all, and the two border models with their pixels (`probes/README.md`). Outside the sensors' paths on purpose: they measure the product rather than being part of it, and a suite cannot see layout, paint or a browser's own skipping |
+| `probes/` | The archived scripted measurements behind `plans/2026-09-17-page-perf/` (`probes/archive/`, one file per step, run by hand against live Chrome at the debug port — the fixed layout, where `content-visibility` acts at all, the price of a switch and of a step sideways) and their index (`probes/README.md`). Kept as the record of how the plan's figures were taken; outside the sensors' paths on purpose: they measure the product rather than being part of it, and a suite cannot see layout, paint or a browser's own skipping |
 | `tools/parity-live.js` | Compares the engine with the live project on a clone: the numbers and the self-contained report at the path the consumer's settings give (`pnpm run parity:live`) |
 | `tools/pack-check.js` | Assembles the tarball and checks that everything works from it: all sources arrived, the numbers and the report as from the repository (`pnpm run pack:check`) |
 | `tools/check-standards.js` | Checks that both references reproduce: a re-take goes nowhere and is compared with what is committed (our files byte for byte, the bundle by content), and that the live-history bundle carries `HEAD` (`pnpm run check:standards`) |
@@ -622,7 +653,7 @@ acceptance for each.
 | `src/page/state.js` | The page's state: the report's data (the block unrolled by the payload chapter), the view of the checkboxes, the pointer "which path is which column", the unfolded folders, the record's passport, the browser's memory and the link that is read out of the address — a chapter of the page's program |
 | `src/page/dom.js` | The page's nodes: the small helpers of markup (`appEl`, `appBox`) — one set for the panel and the table alike |
 | `src/page/panel.js` | The panel of choices: the switches of metrics and files, the categories, the tree of the project's paths (files outside the report keep a checkbox off with a reason and stand after the rest, and a hidden name after every visible one; the tree opens folded and folders carry a sign that hides the subtree by a class rather than by a rebuild); built once, with the fields of the switches and of the folders and categories written where they stand |
-| `src/page/table.js` | The page's table as a window: the rows and the columns the reader can see (plus four beyond each edge), a cell, a commit's caption, the header, the empty states and the order of the columns — markup over the shared calculation, with the totals counted per row from the choice, the geometry in pixels that the styling mirrors, and the reason a library was not taken |
+| `src/page/table.js` | The page's table as a window: the rows and the columns the reader can see (plus four beyond each edge), moved by a scroll rather than built again (a row lives through a step sideways and only the columns that entered it are made), a cell, a commit's caption, the header, the empty states and the order of the columns — markup over the shared calculation, with the totals counted per row from the choice, the geometry in pixels that the styling mirrors, and the reason a library was not taken |
 | `src/page/app.js` | Assembling and starting the page: the first drawing, then a switch that builds the window again and writes the fields it reached without making a node of the panel; an anchor change; pasted into the assembled page |
 | `src/page/build.js` | Assembling the page: data, styling and program in one file with no external references — the pasted text is **squeezed** on the way in (comments and indentation out, the same stripping the `min` metric counts) while the sources keep them, and the result is guarded by the stripper's own `assertCompilable` |
 | `src/git.js` | The only border where git is called: the pinned settings, blobs by the batch, the history, the comparison with the working tree |
@@ -755,7 +786,7 @@ The same release can be taken by a reference to the repository — installation
 registry, but stays tied to a revision:
 
 ```bash
-pnpm add -D github:vernikr/size-report#v2.8.2
+pnpm add -D github:vernikr/size-report#v2.8.4
 ```
 
 With no network (or nothing to fetch from codeload) — the tarball: `pnpm pack` in the package clone, then
@@ -767,7 +798,7 @@ the branch moves on the installation fails with `Could not resolve <sha> to a co
 observation rather than reasoning: the short pin `6530237` installed while `main` stood on it and stopped
 working at the very next commit, while the same sha in full installed. A branch name (`#main`) and a tag
 are both accepted, but a branch is a moving target and a tag is constant: this release stands on the tag
-`v2.8.2`, which is also the one in the example (forty characters work as well, but they have to be copied
+`v2.8.4`, which is also the one in the example (forty characters work as well, but they have to be copied
 out of the history by eye).
 
 The revision in the example is a part of the claim rather than decoration: what is described below is

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vernikr/size-report",
-  "version": "2.8.2",
+  "version": "2.8.4",
   "author": "vernikr",
   "repository": {
     "type": "git",
@@ -65,7 +65,7 @@
     "report"
   ],
   "devDependencies": {
-    "@vernikr/size-report": "2.8.1",
+    "@vernikr/size-report": "2.8.3",
     "c8": "10",
     "dependency-cruiser": "17",
     "eslint": "^9.18.0",

package/src/config.js

@@ -76,7 +76,7 @@ export function gitRoot() {
  * request for that very file, so its absence stays a refusal (otherwise a typo in the path would
  * silently yield someone else's settings). `path` is given in words rather than as a path: there is no
  * file, and "edit <path>" would lead the reader to something the project does not have. */
-export function derivedConfig(root) {
+function derivedConfig(root) {
   const cfg = derivedProfile(root);
   cfg.path = 'derived from the project';
   cfg.derived = true;

package/src/hook.js

@@ -2,10 +2,9 @@ import fs from 'fs';
 import path from 'path';
 import { fileURLToPath } from 'url';
 import { EXIT, Refusal, cliCommand, refuseCause } from './refusal.js';
-import { installSpec } from './tool.js';
+import { TOOL_PKG, installSpec } from './tool.js';
 import { git, gitTry } from './git.js';
 import { loadConfig } from './config.js';
-import { TOOL_PKG } from './tool.js';
 import { rebuild } from './artifact.js';
 
 /* The `post-commit` and `post-merge` hooks: after every commit and merge the report rebuilds itself and, when it is tracked
@@ -120,6 +119,16 @@ function script(entry) {
     + 'exec node ' + entry.quoted + ' hook-run\n';
 }
 
+/* Writing the hook files, executable: the named command and the silent install write the same bytes, since a difference
+ * between them would surface only after somebody's commit. */
+function installFiles(hooks, entry, files) {
+  fs.mkdirSync(hooks.dir, { recursive: true });
+  files.forEach((file) => {
+    fs.writeFileSync(file, script(entry));
+    fs.chmodSync(file, 0o755);
+  });
+}
+
 /* The hook's state for `size doctor`: whether it is installed and how its last run ended. It counts nothing and commits
  * to nothing. */
 export function hookStatus(root) {
@@ -180,11 +189,7 @@ export function installHook(root, cfg) {
       '  to remove it: ' + cliCommand('uninstall-hook')
     ] };
   }
-  fs.mkdirSync(hooks.dir, { recursive: true });
-  files.forEach((file) => {
-    fs.writeFileSync(file, script(entry));
-    fs.chmodSync(file, 0o755);
-  });
+  installFiles(hooks, entry, files);
 
   const lines = [
     '✓ hook: ' + rels.join(', '),
@@ -219,11 +224,7 @@ export function autoInstall(root, cfg) {
     const files = HOOKS.map((name) => path.join(hooks.dir, name));
     if (files.some((f) => fs.existsSync(f) && !isOurs(f))) return null;
     if (files.every(isOurs)) return null;
-    fs.mkdirSync(hooks.dir, { recursive: true });
-    files.forEach((file) => {
-      fs.writeFileSync(file, script(entry));
-      fs.chmodSync(file, 0o755);
-    });
+    installFiles(hooks, entry, files);
     return files.map((f) => path.relative(root, f));
   } catch (_e) {
     /* Not a git repository, no rights on `.git`, a foreign format — all of it means one thing: there will be no automation

package/src/locales.js

@@ -48,9 +48,6 @@ export const LOCALES = {
         + 'что выбрано в этом браузере.',
       linkExtra: 'Часть ссылки пропущена: в этом отчёте нет {n} названных имён. '
         + 'Остальное применено.',
-      /* Данные отчёта лежат в файле сжатыми, и распаковывает их браузер. Текст называет причину
-       * (браузера нет в списке тех, что умеют `DecompressionStream`) и что с этим делать — пустая
-       * таблица не сказала бы читателю ничего. */
       unpack: 'Данные отчёта сжаты, а браузер не умеет их распаковать: в нём нет DecompressionStream. '
         + 'Обновите браузер — таблицу показывать не из чего.',
       note: 'Абсолютные размеры стоят один раз — в строке «{now}». Строк: {rows}: коммиты без '

package/src/metrics.js

@@ -58,9 +58,6 @@ const STYLES = {
   }
 };
 
-/* Метрика объявляет, нужен ли ей текст блоба: `needsText: false` вместе с
- * `fromSize: true` означает «хватит размера объекта», и тогда содержимое не
- * читается вовсе (`git cat-file --batch` не вызывается). */
 export const METRICS = {
   raw: {
     label: 'raw',
@@ -208,7 +205,7 @@ function esbuildLoader(file, cfg) {
 /* The engine actually in force: the requested one may be unavailable, in which case the metric
  * counts another way — and that is announced (`sensorGaps`), or a different count would travel
  * into CI as the requested one. */
-export function minEngine(cfg) {
+function minEngine(cfg) {
   if (cfg.minify.engine !== 'esbuild') return 'strip';
   return minifier().tool === null ? 'strip' : 'esbuild';
 }

package/src/page/table.js

@@ -8,8 +8,8 @@ import { appData, appUi, appView } from './state.js';
  *
  * **Why not a `<table>`.** Measured on this repository's own report (238 500 cells = 370 758 nodes, a table 71 712 ×
  * 5 982 px): about 1.4 GB of a browser's memory, of which roughly half the nodes and half the painted area, and a
- * browser's relayout of it costs close to a second on any switch (`probes/step-12-columns.mjs`). `content-visibility:
- * auto`, the cheap way out, is ignored on a table row by Chrome 153 (`probes/step-10-tables.mjs`), so the answer is
+ * browser's relayout of it costs close to a second on any switch (`probes/archive/step-12-columns.mjs`). `content-visibility:
+ * auto`, the cheap way out, is ignored on a table row by Chrome 153 (`probes/archive/step-10-tables.mjs`), so the answer is
  * to build less rather than to promise the browser will skip it. A grid of `position: absolute` rows has no layout to
  * be redone: a row is placed by its `top`, a column by the `left` of the group of cells that starts it, and the
  * browser never measures a cell to decide a width — every column is `--col` wide (70px), which is what the numbers
@@ -31,6 +31,14 @@ import { appData, appUi, appView } from './state.js';
  * table, against 6.5 ms for building the whole window again). The header sticks to the shell's top and the commit
  * column to its left (both `position: sticky`), so the row and the column a number belongs to are always in sight.
  *
+ * **A step down the table and a step sideways cost the same kind of work.** A row is made once and then stands at its
+ * own place in the scrolled content while the window moves over it: the window's columns are the range of that row's
+ * numbers, so a step sideways makes the columns that entered and drops the ones that left (`appStrip`) — a cell per
+ * row, the header's two lines included. A row that left the window vertically is dropped and made again when the
+ * reader comes back to it, which is what makes a jump down the table cost the same as a step. Building the rows again
+ * on every sideways scroll — the first version of this step — is what `probes/archive/step-12-window.mjs` measures against the
+ * splice (`worklog/0211-sideways-step.md`).
+ *
  * The choice is applied by building the window again: the columns of a switched-off file are simply not among the
  * columns that are built, so there is nothing to hide and nothing to recount — the totals are the sum over the files
  * that are on, counted by `rowModel` for the rows the window holds (`src/derived.js`, one place for that
@@ -138,6 +146,27 @@ export function appState(metricsCount, filesCount) {
   document.getElementById('shell').hidden = metricsCount === 0;
 }
 
+/* A strip of pieces of one range, moved to another: the pieces the two ranges share are kept, and only the ends are
+ * made and dropped. The unit of a strip is its child — a row's numbers are one column to a child, the header's line of
+ * names one group, its line of metrics one column — so the same movement serves all three, and a group of metrics
+ * cannot be split by the window (a column of numbers would lose its caption). A window that jumped clear of the old
+ * range — the reader dragged the scrollbar — has nothing to keep and the strip is made again; the empty range
+ * `[c, c - 1]` is how a strip that holds nothing yet says so. */
+function appStrip(strip, was, now, make) {
+  const a = Math.max(was[0], now[0]);
+  const b = Math.min(was[1], now[1]);
+  if (a > b) {
+    strip.textContent = '';
+    for (let c = now[0]; c <= now[1]; c++) strip.appendChild(make(c));
+    return;
+  }
+  for (let n = a - was[0]; n > 0; n--) strip.firstChild.remove();
+  for (let n = was[1] - b; n > 0; n--) strip.lastChild.remove();
+  const edge = strip.firstChild;
+  for (let c = a - 1; c >= now[0]; c--) strip.insertBefore(make(c), edge);
+  for (let c = b + 1; c <= now[1]; c++) strip.appendChild(make(c));
+}
+
 /* One cell of the window: the column decides what it holds. The group is the column's ordinal divided by the number of
  * metrics — `0` is the total over the files, `g ≥ 1` is the g-th column of the order — and it is the same arithmetic
  * the header is placed by, so a column and its caption cannot drift apart. The model lists the *enabled* files in the
@@ -153,9 +182,13 @@ function appCell(model, c, now, cache) {
   return appNum(now ? valueParts(cell) : cellParts(cell.value, cell.delta, '−'), cls);
 }
 
-/* A row of the window: the caption of the commit and the numbers of the columns the window holds. The top row is the
- * state at HEAD (`nowModel`) rather than the last commit's cells: an absolute number stands in the table once, and
- * the deltas below it add up to it. */
+/* A row of the window: the caption of the commit and an empty strip of numbers for the window to fill (`appCells`).
+ * The top row is the state at HEAD (`nowModel`) rather than the last commit's cells: an absolute number stands in the
+ * table once, and the deltas below it add up to it.
+ *
+ * The model is kept in the entry beside the node because the numbers of a row depend on the commit and the choice
+ * rather than on the place the window stands at: a step sideways asks for a cell's arithmetic, never for `rowModel`
+ * again. The strip is born empty — the range `[c0, c0 - 1]` — and is filled by the first `appCells`. */
 function appRow(cache, r, span) {
   const last = appData.rows.length;
   const now = r === 0;
@@ -163,28 +196,36 @@ function appRow(cache, r, span) {
   const model = now
     ? nowModel(appData.now, cache.keys, appView.files)
     : rowModel(appData.rows[i].values, i === 0 ? null : appData.rows[i - 1].values, cache.keys, appView.files);
-  const row = appEl('div', 'row' + (now ? ' now' : ''));
-  row.style.top = (APP_HEAD + r * APP_ROW) + 'px';
+  const el = appEl('div', 'row' + (now ? ' now' : ''));
+  el.style.top = (APP_HEAD + r * APP_ROW) + 'px';
   const commit = appEl('div', 'c-commit');
   if (now) commit.textContent = appUi.now;
   else commit.appendChild(appCommit(appData.rows[i]));
-  row.appendChild(commit);
+  el.appendChild(commit);
   const cells = appEl('div', 'cells');
-  /* The numbers stand beside the commit column rather than under it: the column is pinned over the content, so what the
-   * grid holds begins where the column ends. */
-  cells.style.left = (APP_COMMIT + span.c0 * APP_COL) + 'px';
-  for (let c = span.c0; c <= span.c1; c++) cells.appendChild(appCell(model, c, now, cache));
-  row.appendChild(cells);
-  return row;
+  el.appendChild(cells);
+  return { el: el, cells: cells, model: model, now: now, cols: [span.c0, span.c0 - 1] };
+}
+
+/* A row's numbers at the window's columns: the columns the two windows share keep their cells, and a column that
+ * entered is made. The numbers stand beside the pinned commit column rather than under it — the column lies over the
+ * content — so the strip is placed by the window's first column, and the cells of it follow their strip. A step down
+ * the table asks for the columns it already holds, and the row is not touched at all. */
+function appCells(entry, cache, span) {
+  const cols = [span.c0, span.c1];
+  if (entry.cols[0] === cols[0] && entry.cols[1] === cols[1]) return;
+  entry.cells.style.left = (APP_COMMIT + cols[0] * APP_COL) + 'px';
+  appStrip(entry.cells, entry.cols, cols, (c) => appCell(entry.model, c, entry.now, cache));
+  entry.cols = cols;
 }
 
 /* A built row into the window: the map is what says which rows are in the markup, so a row goes into it where it is
  * made — otherwise a window that moved would build its rows beside the ones that are still there. */
 function appPlace(cache, r, span) {
-  const row = appRow(cache, r, span);
-  cache.rows.set(r, row);
-  cache.grid.appendChild(row);
-  return row;
+  const entry = appRow(cache, r, span);
+  cache.rows.set(r, entry);
+  appCells(entry, cache, span);
+  cache.grid.appendChild(entry.el);
 }
 
 /* A caption of the header: a file's name or a metric's. The room is a fixed number of columns, so a name that does
@@ -197,30 +238,39 @@ function appCaption(text, cls, span) {
   return el;
 }
 
-/* The header: the total and the enabled files over their columns, and one caption per metric column under them. It
- * holds the window's columns alone and is built again only when the window moves sideways — scrolling down leaves it
- * untouched, and the two rows of it are placed by `grid-column`, so a group of metrics is a group in the grid. */
-function appHead(cache, span) {
-  const count = cache.keys.length;
-  const g0 = Math.floor(span.c0 / count);
-  const g1 = Math.floor(span.c1 / count);
-  const left = (APP_COMMIT + g0 * count * APP_COL) + 'px';
-  const head = appEl('div', 'head');
-  head.appendChild(appEl('div', 'c-commit', appUi.commit));
+/* The header's frame: the commit column and the two empty strips that `appStrip` fills — the names of the groups over
+ * the columns, their metrics under them. An empty strip says `[0, -1]`, which is what makes the first `appHead` fill
+ * it rather than move it. */
+function appHeadNew() {
+  const el = appEl('div', 'head');
   const groups = appEl('div', 'hgroups');
-  groups.style.left = left;
   const metrics = appEl('div', 'hmetrics');
-  metrics.style.left = left;
-  for (let g = g0; g <= g1; g++) {
-    const label = g === 0 ? appUi.total : appData.files[cache.list[g - 1]].label;
-    groups.appendChild(appCaption(label, 'gh', count));
-    for (let mi = 0; mi < count; mi++) {
-      metrics.appendChild(appCaption(cache.labels[mi], mi === 0 ? 'g' : '', 1));
-    }
-  }
-  head.appendChild(groups);
-  head.appendChild(metrics);
-  return head;
+  el.appendChild(appEl('div', 'c-commit', appUi.commit));
+  el.appendChild(groups);
+  el.appendChild(metrics);
+  return { el: el, groups: groups, metrics: metrics, g: [0, -1] };
+}
+
+/* The header: the total and the enabled files over their columns, and one caption per metric column under them. The two
+ * strips move by the same `appStrip` as a row's numbers, and the unit of the metrics line is a column, so its strip is
+ * asked for whole groups — the metrics of a column stand under their file even when the window cuts the last group.
+ * A window that did not leave a group (a step down the table) leaves the header alone. */
+function appHead(cache, span) {
+  const count = cache.keys.length;
+  const g0 = count === 0 ? 0 : Math.floor(span.c0 / count);
+  const g1 = count === 0 ? -1 : Math.floor(span.c1 / count);
+  if (cache.head === null) cache.head = appHeadNew();
+  const h = cache.head;
+  if (h.g[0] === g0 && h.g[1] === g1) return h.el;
+  const was = h.g;
+  h.g = [g0, g1];
+  h.groups.style.left = (APP_COMMIT + g0 * count * APP_COL) + 'px';
+  h.metrics.style.left = h.groups.style.left;
+  appStrip(h.groups, was, h.g, (g) => appCaption(
+    g === 0 ? appUi.total : appData.files[cache.list[g - 1]].label, 'gh', count));
+  appStrip(h.metrics, [was[0] * count, was[1] * count + count - 1], [g0 * count, g1 * count + count - 1],
+    (c) => appCaption(cache.labels[c % count], c % count === 0 ? 'g' : '', 1));
+  return h.el;
 }
 
 /* The window the shell shows: the rows and the columns, in the ordinals of the whole grid, and the size of that
@@ -259,26 +309,32 @@ export function appSpan(cache) {
   };
 }
 
-/* The window drawn. A scroll costs what left the window and what entered it, and nothing else: the row that is
- * already built is not touched. Sideways — the window of columns is another window — the header and the rows are
- * built again, because a column that is not there cannot be shown; the reader's own choice (`redraw`) is the same
- * kind of change, and comes here by the same road. */
+/* The window drawn. Moving over the grid costs what left it and what entered it, and nothing else: the rows in the
+ * markup are the window's rows (what left it is dropped, what entered it is made) and each of them holds the columns
+ * of the window (`appCells`), so a step in either direction is paid by the rows that moved rather than by the table.
+ *
+ * The reader's own choice (`redraw`) is the one thing that cannot be a move: the columns of a switched-off file are
+ * simply not among the columns that are built, so there is nothing to hide and nothing to recount — the totals are the
+ * sum over the files that are on (`rowModel`), and the window is built from nothing. The shell's own size is the same
+ * kind of change: it decides how much of the grid is in sight, which is not a place to move to. */
 export function appWindow(cache, redraw) {
   const span = appSpan(cache);
   const was = cache.win;
   cache.win = span;
-  if (redraw === true || was === null || was.c0 !== span.c0 || was.c1 !== span.c1) {
+  if (redraw === true || was === null) {
     /* The grid holds the header and the rows of the window and nothing else, so the whole of it is thrown away rather
      * than tracked piece by piece — and the rows that are made below say in the map that they are there. */
     cache.grid.textContent = '';
     cache.rows.clear();
+    cache.head = null;
     cache.grid.appendChild(appHead(cache, span));
     for (let r = span.r0; r <= span.r1; r++) appPlace(cache, r, span);
     return;
   }
+  appHead(cache, span);
   [...cache.rows.keys()].forEach((r) => {
-    if (r >= span.r0 && r <= span.r1) return;
-    cache.rows.get(r).remove();
+    if (r >= span.r0 && r <= span.r1) { appCells(cache.rows.get(r), cache, span); return; }
+    cache.rows.get(r).el.remove();
     cache.rows.delete(r);
   });
   for (let r = span.r0; r <= span.r1; r++) {
@@ -299,6 +355,7 @@ export function appTable(grid) {
     rank: [],
     slot: [],
     rows: new Map(),
+    head: null,
     win: null
   };
   cache.shell.addEventListener('scroll', () => appWindow(cache));

package/src/project.js

@@ -204,7 +204,7 @@ function columnsOf(files, journal) {
 }
 
 export function projectConfig(root) {
-  const output = outputOf(root);
+  const output = outputOf();
   const journal = journalOf(root);
   const files = allPaths(root);
   /* Only what git tracks becomes a column: a file absent at HEAD has nothing to measure (it would be

package/src/strip/js.js

@@ -59,16 +59,21 @@ function regexAllowed(last, word) {
   return '([{,;:=!&|?+-*%~^<>'.indexOf(last) !== -1;
 }
 
-function takeRegex(s) {
-  if (s.src[s.i] !== '/' || !regexAllowed(s.last, s.word)) return false;
-  const end = endOfRegex(s.src, s.i);
+/* A token taken whole: it goes into the output and the pass state is advanced over it — the token itself, not the word
+ * before it, decides where a regex may stand next, and the word being read ends with it. */
+function take(s, end, last) {
   s.out += s.src.slice(s.i, end);
   s.i = end;
-  s.last = '/';
+  s.last = last;
   s.word = '';
   return true;
 }
 
+function takeRegex(s) {
+  if (s.src[s.i] !== '/' || !regexAllowed(s.last, s.word)) return false;
+  return take(s, endOfRegex(s.src, s.i), '/');
+}
+
 function endOfRegex(src, start) {
   let i = start + 1;
   let inClass = false;
@@ -88,12 +93,7 @@ function endOfRegex(src, start) {
 function takeString(s) {
   const quote = s.src[s.i];
   if (quote !== '"' && quote !== "'" && quote !== '`') return false;
-  const end = endOfString(s.src, s.i, quote);
-  s.out += s.src.slice(s.i, end);
-  s.i = end;
-  s.last = quote;
-  s.word = '';
-  return true;
+  return take(s, endOfString(s.src, s.i, quote), quote);
 }
 
 function endOfString(src, start, quote) {

package/src/tokens.js

@@ -28,7 +28,7 @@ export const CHARS_PER_TOKEN = 3;
  * and the tokenizer would split them into anything at all, giving a random number. The list
  * exists so that the metric says this in words instead of passing such a count off as counted.
  * SVG is deliberately not here: it is text, and its tokens are meaningful. */
-export const BINARY_EXTS = [
+const BINARY_EXTS = [
   '.png', '.jpg', '.jpeg', '.gif', '.webp', '.ico', '.avif',
   '.woff', '.woff2', '.ttf', '.otf', '.eot',
   '.pdf', '.zip', '.gz', '.tar', '.mp4', '.mp3', '.mov'