@vernikr/size-report 2.4.0 → 2.6.0

package/src/page/panel.js

@@ -1,53 +1,53 @@
 import { appEl, appBox, appOffBox } from './dom.js';
 import { appData, appUi, appView, appFileAt, appFoldSet, appMeasured } from './state.js';
 
-/* Галочку файла ставит только файл: и категория, и папка в дереве — способы
- * переставить те же галочки сразу группой, а своего состояния у них нет. Иначе
- * одно и то же решение жило бы в двух местах и расходилось. */
+/* Only a file sets a file's checkbox: both a category and a folder in the tree are ways to set the same checkboxes as
+ * a group and keep no state of their own. Otherwise one and the same decision would live in two places and drift
+ * apart. */
 function appFileBox(i) {
   const f = appData.files[i];
-  const where = appFileAt(i) + (f.path === null ? ' (нет на HEAD)' : '');
-  return appBox(f.label, where + ' · категория: '
-    + (f.categoryBy === 'config' ? 'из настроек' : 'по расширению'), appView.files[i], (e) => {
-    appView.files[i] = e.target.checked;
-    appRender();
-  });
+  const where = appFileAt(i) + (f.path === null ? appUi.notOnHead : '');
+  const box = appBox(f.label, where + appUi.category
+    + (f.categoryBy === 'config' ? appUi.categoryFromConfig : appUi.categoryByExtension),
+  appView.files[i], (e) => appSwitch(i, e.target.checked));
+  appFields.file[i] = box.querySelector('input');
+  return box;
 }
 
-/* Файл, которого в отчёте нет: он стоит в дереве на своём месте, но галочка у
- * него снята и недоступна — чисел для него не измеряли, и переключать нечего.
- * Причину читатель видит во всплывающей строке, а не догадывается по виду. */
+/* A file that is not in the report: it stands in its place in the tree with its checkbox off and unavailable — no
+ * numbers were measured for it, so there is nothing to switch. The reader sees the reason in the tooltip rather than
+ * guessing it from the look. */
 function appUnmeasuredBox(entry) {
   return appOffBox(entry.path.split('/').pop(), entry.path + ' · '
     + (entry.why === 'rule' ? appUi.notMeasuredRule : appUi.notMeasuredChoice));
 }
 
-/* Все измеряемые файлы поддерева — то, чем управляет переключатель папки: файл
- * вне отчёта переключать нечего. */
+/* Every measured file of a subtree — what a folder's switch controls: a file outside the report has nothing to
+ * switch. */
 function appIndexes(node) {
   const out = node.files.slice();
   node.dirs.forEach((sub) => { out.push(...appIndexes(sub)); });
   return out;
 }
 
-/* Сколько файлов в поддереве — вместе с теми, что в отчёт не попали. */
+/* How many files a subtree holds — including the ones that made it into no report. */
 function appCount(node) {
   let n = node.files.length + node.others.length;
   node.dirs.forEach((sub) => { n += appCount(sub); });
   return n;
 }
 
-/* Узел дерева: измеряемые файлы (колонки), прочие файлы проекта и подпапки. */
+/* A tree node: the measured files (columns), the project's other files and the subfolders. */
 function appNode() {
   return { files: [], others: [], dirs: new Map() };
 }
 
-/* Переключатель папки: его галочка ведёт за собой всё поддерево и показывает три
- * состояния — все файлы включены, часть, ни одного. Рядом число файлов; если в
- * папке есть и те, что вне отчёта, оно написано долей («2/5»): читателю важно, что
- * в папке пять файлов, а измеряются два. Папка без единого измеряемого файла
- * остаётся на месте, но её галочка снята и недоступна: включать в ней нечего. */
-function appDirHead(name, sub) {
+/* A folder's switch: its checkbox carries the whole subtree with it and shows three states — every file on, some,
+ * none. The number of files stands next to it; when the folder also holds files outside the report, it is written as
+ * a fraction ("2/5"): what matters to the reader is that the folder holds five files while two are measured. A folder
+ * without a single measured file stays in place with its checkbox off and unavailable: there is nothing to switch on
+ * in it. */
+function appDirHead(name, here, sub) {
   const idx = appIndexes(sub);
   const total = appCount(sub);
   const label = name + '/';
@@ -58,28 +58,24 @@ function appDirHead(name, sub) {
     const on = idx.map((i) => appView.files[i]);
     const every = on.every((v) => v);
     head = appBox(label, appUi.dir.replace('{name}', name).replace('{n}', idx.length),
-      every, (e) => {
-        idx.forEach((i) => { appView.files[i] = e.target.checked; });
-        appRender();
-      }, 'dir');
+      every, (e) => appSwitchGroup(idx, e.target.checked), 'dir');
     head.querySelector('input').indeterminate = !every && on.some((v) => v);
+    appFields.dir[here] = head;
   }
   head.appendChild(appEl('span', 'n', idx.length === total ? String(total) : idx.length + '/' + total));
   return head;
 }
 
-/* Знак папки — своя цель нажатия, отдельная от галочки: галочка отвечает за числа
- * (включает файлы поддерева), а знак — за то, сколько дерева видно. Одна цель на
- * два разных действия означала бы, что сложить папку можно только вместе с
- * включением её файлов. Знак нарисован спаном, а не кнопкой, потому что в строке
- * папки рядом уже стоит метка-галочка, а вложенная в метку кнопка поднимала бы её
- * же нажатие.
+/* The folder's sign is a click target of its own, separate from the checkbox: the checkbox answers for the numbers (it
+ * switches the subtree's files on), while the sign answers for how much of the tree is visible. One target for two
+ * different decisions would mean a folder can be folded only together with switching its files on. The sign is drawn
+ * as a span rather than a button and stands beside the label rather than inside it: a label is one click target, and a
+ * control nested in it would be reached as that same target.
  *
- * Клик по знаку ничего не пересобирает: поддерево лежит в разметке, а прячет его
- * класс на строке. Пересборка здесь была бы честной работой впустую — она считает
- * таблицу целиком (в этом проекте — сотни строк на полторы сотни колонок), то есть
- * платит за числа, которых складывание не меняет. Поэтому меняются только три
- * вещи, которые читатель и видит: класс, знак и запись в памяти. */
+ * A click on the sign rebuilds nothing: the subtree lies in the markup and a class on the row hides it. A rebuild here
+ * would be honest work for nothing — it counts the whole table (every row by every column) and so pays for numbers
+ * folding does not change. That is why only the three things the reader sees change: the class, the sign and the note
+ * in the memory. */
 function appFoldBox(name, path) {
   const folded = appView.folded[path] === true;
   const box = appEl('span', 'fold', folded ? '▸' : '▾');
@@ -95,8 +91,8 @@ function appFoldBox(name, path) {
   return box;
 }
 
-/* Листья уровня: измеряемые файлы и файлы вне отчёта — вперемешку и по алфавиту
- * имени, как в дереве файлов, а не отдельными списками. */
+/* The leaves of one level: measured files and files outside the report mixed together and sorted by name, the way a
+ * file tree reads, rather than as separate lists. */
 function appLeaves(node) {
   const items = node.files.map((i) => ({ name: appData.files[i].label, i: i, entry: null }));
   node.others.forEach((entry) => {
@@ -105,30 +101,29 @@ function appLeaves(node) {
   return items.sort((a, b) => (a.name < b.name ? -1 : (a.name > b.name ? 1 : 0)));
 }
 
-/* Строка папки: знак складывания, галочка с числом файлов и поддерево. Сложенная
- * папка отличается только классом — разметка одна и та же. */
+/* A folder row: the folding sign, the checkbox with the number of files and the subtree. A folded folder differs by
+ * its class alone — the markup stays the same. */
 function appDir(name, sub, prefix) {
   const here = prefix === '' ? name : prefix + '/' + name;
   const folded = appView.folded[here] === true;
   const li = appEl('li', folded ? 'folded' : null);
   li.appendChild(appFoldBox(name, here));
-  li.appendChild(appDirHead(name, sub));
+  li.appendChild(appDirHead(name, here, sub));
   li.appendChild(appTreeList(sub, here));
   return li;
 }
 
-// Строка листа: измеряемый файл — с галочкой, файл вне отчёта — со снятой.
+// A leaf row: a measured file comes with a checkbox, a file outside the report with one switched off.
 function appLeaf(leaf) {
   const li = appEl('li');
   li.appendChild(leaf.entry === null ? appFileBox(leaf.i) : appUnmeasuredBox(leaf.entry));
   return li;
 }
 
-/* Узлы одного уровня: сперва всё, что в отчёте (папки по алфавиту, затем листья —
- * их порядок из `appLeaves`), потом то, чего в отчёте нет: папки без измеряемых
- * файлов и файлы вне колонок. Так решено не из вкуса: у всего вне отчёта галочка
- * снята и недоступна, и в конце списка оно не отвлекает от того, что в таблице,
- * а найти его по-прежнему можно — оно там же, где было. */
+/* The nodes of one level: first everything in the report (folders alphabetically, then the leaves in the order
+ * `appLeaves` gives), then what is not in it — folders without a measured file and files outside the columns. That is
+ * not a matter of taste: everything outside the report has its checkbox off and unavailable, so at the end of the list
+ * it does not distract from what is in the table, while it can still be found — in the same place where it was. */
 function appTreeList(node, prefix) {
   const list = appEl('ul', 'tree');
   const dirs = [...node.dirs.keys()].sort()
@@ -142,8 +137,8 @@ function appTreeList(node, prefix) {
   return list;
 }
 
-/* Место листа в дереве: путь делится по «/», промежуточные папки заводятся по
- * дороге. Одно место на измеряемые и прочие — иначе они разошлись бы папками. */
+/* A leaf's place in the tree: the path is split on "/" and the intermediate folders are created on the way. One place
+ * for measured and other files alike — otherwise they would drift apart in folders. */
 function appLeafAt(node, p, i, entry) {
   const parts = p.split('/');
   for (let d = 0; d < parts.length - 1; d++) {
@@ -154,11 +149,10 @@ function appLeafAt(node, p, i, entry) {
   else node.others.push(entry);
 }
 
-/* Дерево страницы — дерево проекта: узлы берутся из каталога (все пути, которые
- * видит git), поэтому в нём есть и файлы вне отчёта. Измеряемый лист — колонка, и
- * путь у него тот же, что в подписи файла; колонка, чьего файла на HEAD уже нет, в
- * каталог не попала (в индексе её нет) и стоит на месте по последнему известному
- * пути. */
+/* The page's tree is the project's tree: the nodes come from the catalogue (every path git sees), which is why it also
+ * holds files outside the report. A measured leaf is a column, and its path is the one in the file's caption; a column
+ * whose file is gone from HEAD never entered the catalogue (the index does not hold it) and stands in place by the last
+ * path known. */
 function appTree() {
   const root = appNode();
   appData.files.forEach((_f, i) => appLeafAt(root, appFileAt(i), i, null));
@@ -168,6 +162,10 @@ function appTree() {
   return appTreeList(root, '');
 }
 
+/* The panel: built once, at the first drawing, and afterwards only its fields change. A rebuild would count the whole
+ * table for nothing — the tree, the counters and the tooltips are the same after every click — while it would also
+ * take the reader's place in the list away: the scroll of the panel and of the tree, and the field under the
+ * keyboard, would have to be put back by hand. Nothing of that is here, because there is nothing to put back. */
 export function appPanel() {
   const panel = document.getElementById('panel');
   panel.textContent = '';
@@ -176,16 +174,17 @@ export function appPanel() {
   metrics.appendChild(appEl('legend', null, appUi.metrics));
   const mrow = appEl('div', 'row');
   appData.metrics.forEach((m) => {
-    const word = m.accuracy === 'exact' ? appUi.exact : appUi.approximate;
-    mrow.appendChild(appBox(m.label, m.note + ' · ' + word, appView.metrics[m.key], (e) => {
+    const box = appBox(m.label, m.note, appView.metrics[m.key], (e) => {
       appView.metrics[m.key] = e.target.checked;
-      appRender();
-    }, 'metric'));
+      appSwitchMetric();
+    }, 'metric');
+    appFields.metric[m.key] = box.querySelector('input');
+    mrow.appendChild(box);
   });
   metrics.appendChild(mrow);
-  /* Чем получено каждое число — видно, а не только во всплывающей строке: словарь
-   * токенов и способ сжатия выбираются настройками запуска, переключить их
-   * странице нечем, и читателю важно знать это, не наводя мышь. */
+  /* What produced each number is visible rather than hidden in a tooltip: the token dictionary and the way of
+   * compression are chosen by the settings of the run, the page has nothing to switch them with, and the reader needs
+   * to know this without pointing a mouse. */
   appData.metrics.forEach((m) => {
     metrics.appendChild(appEl('p', 'about', m.label + ' — ' + appUi.methodLabel + ' ' + m.method));
   });
@@ -193,19 +192,108 @@ export function appPanel() {
 
   const files = appEl('fieldset', 'files');
   files.appendChild(appEl('legend', null, appUi.files));
-  /* Строка категорий помечена классом: список файлов листается, и она остаётся на
-   * виду (липкость — в широкой раскладке, там панель и прокручивается). */
+  /* The row of categories is marked by a class: the file list scrolls, and the row stays in sight (its stickiness lives
+   * in the wide layout, which is where the panel scrolls). */
   const cats = appEl('div', 'row cats');
   appData.categories.forEach((cat) => {
     const idx = [];
     appData.files.forEach((f, i) => { if (f.category === cat.key) idx.push(i); });
-    cats.appendChild(appBox(cat.label, appUi.all + ' · ' + cat.label, idx.every((i) => appView.files[i]),
-      (e) => {
-        idx.forEach((i) => { appView.files[i] = e.target.checked; });
-        appRender();
-      }, 'all'));
+    const box = appBox(cat.label, appUi.all + ' · ' + cat.label, idx.every((i) => appView.files[i]),
+      (e) => appSwitchGroup(idx, e.target.checked), 'all');
+    appFields.cat[cat.key] = box.querySelector('input');
+    cats.appendChild(box);
   });
   files.appendChild(cats);
   files.appendChild(appTree());
   panel.appendChild(files);
 }
+
+/* -------- the panel's fields after a choice -------- */
+
+/* The fields of the panel by name: the markup is built once, so a click needs a reference to the field it changes
+ * rather than a rebuild of the panel. Only a file owns a state — a folder and a category are ways to set the same
+ * boxes — which is why their fields are read from the files below them rather than kept. */
+const appFields = { metric: {}, file: {}, dir: {}, cat: {} };
+
+/* The boxes of a row's own subtree, read from the tree itself: the panel keeps no second list of the files a folder
+ * holds, and what the reader sees is exactly the boxes that are here. A file outside the report stands in the tree
+ * with nothing to switch, hence it is left out. */
+function appRowBoxes(box) {
+  return [...box.closest('li').querySelectorAll('.box:not(.dir):not(.plain) input')];
+}
+
+// A folder's field from its files: all on — checked, some — the third state, none — simply unchecked.
+function appDirState(box) {
+  const boxes = appRowBoxes(box);
+  const on = boxes.filter((b) => b.checked).length;
+  const input = box.querySelector('input');
+  input.checked = on === boxes.length;
+  input.indeterminate = on > 0 && on < boxes.length;
+}
+
+/* A category's field from its files — the same rule, taken from the data: a category's files are named by the
+ * category itself (`category`), and the boxes of the tree are a different view of the same files. */
+function appCatState(key) {
+  let all = 0;
+  let on = 0;
+  appData.files.forEach((f, i) => {
+    if (f.category !== key) return;
+    all++;
+    if (appView.files[i] === true) on++;
+  });
+  const input = appFields.cat[key];
+  input.checked = on === all;
+  input.indeterminate = on > 0 && on < all;
+}
+
+/* The folders a file lies in: the prefixes of its path, from the root down. The tree's folders are exactly those
+ * prefixes — that is how it is built (`appLeafAt`) — so no second naming rule is needed. */
+function appDirPath(path) {
+  const parts = path.split('/');
+  return parts.slice(0, -1).map((_part, i) => parts.slice(0, i + 1).join('/'));
+}
+
+/* A click reaches a folder's field through the files below it: every folder on the path of a switched file shows the
+ * share of what is left on. A folder without measured files has a field of its own too — it is off and unavailable,
+ * which is not the reader's state and must not be overwritten here. */
+function appDirsOf(indexes) {
+  const seen = {};
+  indexes.forEach((i) => {
+    appDirPath(appFileAt(i)).forEach((path) => {
+      if (seen[path] === true) return;
+      seen[path] = true;
+      if (appFields.dir[path] !== undefined) appDirState(appFields.dir[path]);
+    });
+  });
+}
+
+// The same for the quick buttons of the categories: every category one of the switched files belongs to.
+function appCatsOf(indexes) {
+  const seen = {};
+  indexes.forEach((i) => {
+    const key = appData.files[i].category;
+    if (seen[key] === true || appFields.cat[key] === undefined) return;
+    seen[key] = true;
+    appCatState(key);
+  });
+}
+
+/* What a click changed, written where it stands: the files' own boxes, then the fields of the folders and categories
+ * that hold them. Nothing is rebuilt, and no field the choice did not reach is touched. */
+export function appPanelState(indexes) {
+  indexes.forEach((i) => {
+    const input = appFields.file[i];
+    if (input !== undefined) input.checked = appView.files[i] === true;
+  });
+  appDirsOf(indexes);
+  appCatsOf(indexes);
+}
+
+/* The whole panel from the view: what a link, a record from the memory and the first drawing need. The metric boxes
+ * are the reader's own click otherwise, which is why they are not refreshed on a file's switch. */
+export function appPanelAll() {
+  appData.categories.forEach((c) => appCatState(c.key));
+  appData.metrics.forEach((m) => { appFields.metric[m.key].checked = appView.metrics[m.key] === true; });
+  appData.files.forEach((_f, i) => { appFields.file[i].checked = appView.files[i] === true; });
+  Object.keys(appFields.dir).forEach((path) => appDirState(appFields.dir[path]));
+}

package/src/page/payload.js

@@ -0,0 +1,168 @@
+/* The page's block: how the file carries it (gzipped and base64 encoded, `appUnpack`) and how the block in
+ * sparse form is turned back into the model the page already spoke.
+ *
+ * The packing is a **transport rather than the shape**: what comes out of the unpacker is the very block the
+ * page received before this chapter knew about gzip, with no field added or removed, and `--data`/`--json`
+ * answer with the dense contract as they always did. It buys the artifact's weight (the block is the whole file)
+ * and pays for it in two ways, both on purpose: the block can no longer be read by eye or by `diff`, and
+ * unpacking is **asynchronous** — the platform's own `DecompressionStream` is the only unpacker here, no library
+ * travels in the page and nothing is fetched, so the first drawing waits for a promise where it used to happen
+ * during the parse.
+ *
+ * Why the block is sparse. Of 56 019 cells of this repository's report the non-empty ones hold 1 183 distinct
+ * triples, and about a thousand cells differ from the row above: nine tenths of the block is yesterday's
+ * numbers written again. So the block keeps, for every file, the rows in which it appeared (absolute numbers),
+ * moved (deltas against its own previous record) or disappeared, and this chapter puts the snapshots back
+ * together. The whole history walk is O(number of changes) rather than O(rows × files).
+ *
+ * The model after `appDecode` is exactly `--data`: the calculation (`rowModel`, `totalsOf`, `cellParts`,
+ * `valueParts`), the table and the panel know nothing about the sparse form, so there is no second way to
+ * count a row. A value that did not move is **one object shared by the rows that hold it** — the heap keeps
+ * the distinct numbers rather than a copy per commit — and because every consumer reads `v[metric]` and
+ * compares nothing by identity, sharing changes no answer.
+ *
+ * Two rules of the chapters bind here as well: no `import` lines and no module state (the text is pasted into
+ * one file), and nothing but declarations (the round-trip check evaluates this file on its own).
+ *
+ * The dictionary (`strs`) is walked by the encoder in a stated order — files in the column order, rows in the
+ * history order, and only the order of the first appearance decides an index. The artifact is rebuilt after
+ * every commit and has to come out byte-identical on any machine, so the order of the walk is part of the
+ * format rather than a detail of the encoder.
+ */
+
+/* The block as the file carries it: the tag's `data-pack` says which packing it is, so the page asks rather than
+ * guesses, and a packing it does not know is an error rather than a half-read block. A tag without the marker
+ * carries the block itself — the same page works for a build that packs nothing.
+ *
+ * `DecompressionStream` answers with streams rather than with bytes, hence the reader loop: the promise this
+ * function is *is* the price of the weight (see the file's note). `atob` gives one character per byte, and every
+ * character above 127 has to be taken back as a byte (`charCodeAt`) rather than as text; `TextDecoder` turns the
+ * inflated bytes into the JSON text, which is UTF-8 with the report's own words in it. */
+export async function appUnpack(el) {
+  const pack = el.getAttribute('data-pack');
+  const text = el.textContent;
+  if (pack === null) return text;
+  if (pack !== 'base64+gzip') throw new Error('the page’s data is packed as “' + pack + '”, which this page cannot read');
+  const stream = new DecompressionStream('gzip');
+  const sink = stream.writable.getWriter();
+  /* The writing is not waited for before the reading: a stream that is filled before it is drained would stall on
+   * its own backpressure. A failure of the write surfaces in the reading loop, which is what this promise returns. */
+  const feeding = sink.write(appBytes(text)).then(() => sink.close()).catch(() => null);
+  const source = stream.readable.getReader();
+  const parts = [];
+  for (;;) {
+    const step = await source.read();
+    if (step.done) break;
+    parts.push(step.value);
+  }
+  await feeding;
+  return new TextDecoder().decode(appJoined(parts));
+}
+
+// base64 read as bytes: the browser's `atob` hands out one character per byte, whatever the byte.
+function appBytes(text) {
+  const raw = atob(text);
+  const bytes = new Uint8Array(raw.length);
+  for (let i = 0; i < raw.length; i++) bytes[i] = raw.charCodeAt(i);
+  return bytes;
+}
+
+/* The chunks of an inflated stream as one array: a chunk boundary falls wherever the platform put it. The length is
+ * summed by hand rather than by `reduce` — the page's shell computes no totals of its own, and this chapter is part
+ * of the shell the checks read (`test/page-view.test.js`). */
+function appJoined(parts) {
+  let size = 0;
+  parts.forEach((part) => { size += part.length; });
+  const all = new Uint8Array(size);
+  let at = 0;
+  parts.forEach((part) => { all.set(part, at); at += part.length; });
+  return all;
+}
+
+// The dictionary's entry: a text the block does not carry stays absent rather than becoming an empty string.
+function appText(p, i) {
+  return i === null ? null : p.strs[i];
+}
+
+// A value as the page reads it: the metrics by their keys, in the order the block lists them.
+function appValue(keys, nums) {
+  const out = {};
+  keys.forEach((key, mi) => { out[key] = nums[mi]; });
+  return out;
+}
+
+/* One record of a file's history applied to what the file was: the numbers are absolute when the file was
+ * absent and deltas against its own previous record otherwise. A record with nothing but a row means the file
+ * is gone from that revision, which is the same `null` the dense contract carries. What comes out is the
+ * object every later row shares until the file moves again. */
+function appStep(keys, was, rec) {
+  if (rec.length === 1) return null;
+  const nums = rec.slice(1);
+  if (was === null) return appValue(keys, nums);
+  return appValue(keys, nums.map((d, mi) => was[keys[mi]] + d));
+}
+
+/* The history unrolled, once, into a snapshot per commit — the shape the contract hands out. The records of
+ * every file are consumed in the order of the rows, and each row takes what the files were at it: a file whose
+ * record has not come around is the very object it was in the row above.
+ *
+ * The tail of the walk is "now": the report's last row is its last commit that moved a number, the commits
+ * after it moved none, and what the files were at the end is the state at HEAD — which is what the dense
+ * `now` is. */
+function appUnroll(p, keys) {
+  const at = p.files.map(() => 0);
+  const live = p.files.map(() => null);
+  const rows = [];
+  for (let r = 0; r < p.rows.length; r++) {
+    const row = [];
+    p.files.forEach((_f, i) => {
+      const rec = p.hist[i][at[i]];
+      if (rec !== undefined && rec[0] === r) {
+        live[i] = appStep(keys, live[i], rec);
+        at[i]++;
+      }
+      row.push(live[i]);
+    });
+    rows.push(row);
+  }
+  return { rows: rows, now: live.slice() };
+}
+
+/* A commit row: the caption and where it leads. The address is the block's one prefix plus what the row kept
+ * of its own link with the sha, and `added` travels as a mark rather than as a word. The name is not `appRow`:
+ * the chapters are pasted into **one scope**, where the table's own `appRow` would quietly win and this one
+ * would never be called (`test/page-view.test.js` holds the names apart for that very reason). */
+function appRowOf(p, r, values) {
+  const section = r[3] === null ? null : { id: appText(p, r[3]), head: appText(p, r[4]), added: r[5] === 1 };
+  return {
+    sha: appText(p, r[0]),
+    when: appText(p, r[1]),
+    subject: appText(p, r[2]),
+    section: section,
+    href: r[6] === null ? null : p.hrefPrefix + appText(p, r[6]),
+    values: values
+  };
+}
+
+/* The whole block, unrolled into the dense contract the page reads: `schema: 2` is refused by `appRecordOk`
+ * rather than unrolled — a record written for a block of another form describes another choice. */
+export function appDecode(p) {
+  const keys = p.metrics.map((m) => appText(p, m[0]));
+  const hist = appUnroll(p, keys);
+  const last = p.files.map(() => false);
+  p.last.forEach((i) => { last[i] = true; });
+  return {
+    schema: p.schema,
+    tool: p.tool,
+    report: p.report,
+    metrics: p.metrics.map((m) => ({ key: appText(p, m[0]), label: appText(p, m[1]),
+      note: appText(p, m[2]), method: appText(p, m[3]) })),
+    categories: p.cats.map((c) => ({ key: appText(p, c[0]), label: appText(p, c[1]) })),
+    files: p.files.map((f) => ({ label: appText(p, f[0]), path: appText(p, f[1]),
+      paths: f[2].map((i) => p.strs[i]), category: appText(p, f[3]), categoryBy: appText(p, f[4]) })),
+    catalog: p.catalog.map((e) => ({ path: appText(p, e[0]), why: appText(p, e[1]) })),
+    rows: p.rows.map((r, ri) => appRowOf(p, r, hist.rows[ri])),
+    now: hist.now,
+    last: last
+  };
+}