@vernikr/size-report 2.5.0 → 2.7.0

package/src/page/panel.js

@@ -7,12 +7,11 @@ import { appData, appUi, appView, appFileAt, appFoldSet, appMeasured } from './s
 function appFileBox(i) {
   const f = appData.files[i];
   const where = appFileAt(i) + (f.path === null ? appUi.notOnHead : '');
-  return appBox(f.label, where + appUi.category
+  const box = appBox(f.label, where + appUi.category
     + (f.categoryBy === 'config' ? appUi.categoryFromConfig : appUi.categoryByExtension),
-  appView.files[i], (e) => {
-    appView.files[i] = e.target.checked;
-    appRender();
-  });
+  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
@@ -48,7 +47,7 @@ function appNode() {
  * 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, sub) {
+function appDirHead(name, here, sub) {
   const idx = appIndexes(sub);
   const total = appCount(sub);
   const label = name + '/';
@@ -59,37 +58,49 @@ 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 order inside one level, and the two rules of it: a hidden name (a leading dot) stands after every visible one —
+ * a project's service files are not what a reader looks for first — and otherwise the alphabet decides. "Other things
+ * being equal" is the whole of it: what the report holds stands before what it does not, and that partition is made
+ * before the names are compared. The rule is a function of two strings, which is what lets it be checked on its own
+ * rather than through a tree of a fixture that has no hidden files in it. */
+export function appName(a, b) {
+  const hidden = (name) => (name.charAt(0) === '.' ? 1 : 0);
+  if (hidden(a) !== hidden(b)) return hidden(a) - hidden(b);
+  return a < b ? -1 : (a > b ? 1 : 0);
+}
+
 /* 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.
  *
+ * The tree opens folded — the sign of an untouched folder says so — and the reader's unfolding is what the memory
+ * keeps (`appFoldSet`).
+ *
  * 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 ? '▸' : '▾');
-  box.title = (folded ? appUi.foldOpen : appUi.foldClose).replace('{name}', name);
+  const open = appView.open[path] === true;
+  const box = appEl('span', 'fold', open ? '▾' : '▸');
+  box.title = (open ? appUi.foldClose : appUi.foldOpen).replace('{name}', name);
   box.addEventListener('click', () => {
-    const now = !(appView.folded[path] === true);
+    const now = !(appView.open[path] === true);
     appFoldSet(path, now);
     const li = box.closest('li');
-    if (li !== null) li.classList.toggle('folded', now);
-    box.textContent = now ? '▸' : '▾';
-    box.title = (now ? appUi.foldOpen : appUi.foldClose).replace('{name}', name);
+    if (li !== null) li.classList.toggle('folded', !now);
+    box.textContent = now ? '▾' : '▸';
+    box.title = (now ? appUi.foldClose : appUi.foldOpen).replace('{name}', name);
   });
   return box;
 }
@@ -101,17 +112,17 @@ function appLeaves(node) {
   node.others.forEach((entry) => {
     items.push({ name: entry.path.split('/').pop(), i: null, entry: entry });
   });
-  return items.sort((a, b) => (a.name < b.name ? -1 : (a.name > b.name ? 1 : 0)));
+  return items.sort((a, b) => appName(a.name, b.name));
 }
 
 /* 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 folded = appView.open[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;
 }
@@ -129,7 +140,7 @@ function appLeaf(leaf) {
  * 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()
+  const dirs = [...node.dirs.keys()].sort(appName)
     .map((name) => ({ name: name, sub: node.dirs.get(name), inReport: appIndexes(node.dirs.get(name)).length > 0 }));
   const leaves = appLeaves(node);
   const inside = leaves.filter((leaf) => leaf.entry === null);
@@ -165,6 +176,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 = '';
@@ -173,11 +188,12 @@ 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
@@ -196,13 +212,102 @@ export function appPanel() {
   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
+  };
+}

package/src/page/state.js

@@ -1,3 +1,5 @@
+import { appDecode } from './payload.js';
+
 /* The page's choice state: what is switched on, how it survives a closing and how it travels as a link.
  *
  * An ordinary source file rather than a string inside the engine: a linter sees it, and it is pasted into the assembled
@@ -9,41 +11,61 @@
  * network: the styling arrives in the same file, and the cell markup follows the rules of the shared part of the styling
  * (`clip`, a commit's caption).
  *
- * The panel remembers the reader's choice between visits and can hand it over as a link ("the choice's memory" below):
- * the record is tied to the report's passport and keeps only what is switched off, by name, so someone else's record is
- * not applied while a vanished name simply means nothing. The same record goes into the address — which is what one
- * sends to a colleague.
+ * The panel remembers the reader's choice between visits ("the choice's memory" below): the record is tied to the
+ * report's passport and keeps only what is switched off, by name, so someone else's record is not applied while a
+ * vanished name simply means nothing. The record stays in the browser's memory and nowhere else: a report opened from
+ * disk keeps a clean address, and a link made in an earlier release is still read (`appLinkUse`).
  *
- * The page does not derive a number's accuracy itself: the marks of approximate cells arrive in the data, from the same
- * rule that names a metric's accuracy. The page draws no such conclusion from paths and formats — there will be no
- * second rule of accuracy. */
+ * The page draws no conclusion about how a number was obtained: the method of each metric arrives in the data, and the
+ * page prints it. There is no second rule of counting here, and no vocabulary of precision either. */
 
-export const appData = JSON.parse(document.getElementById('data').textContent);
 export const appUi = JSON.parse(document.getElementById('ui').textContent);
-export const appView = { metrics: {}, files: [], folded: {} };
-appData.metrics.forEach((m) => { appView.metrics[m.key] = true; });
-appData.files.forEach(() => { appView.files.push(true); });
 
-/* A metric's description by key: the tooltip of an approximate cell names the way its number was obtained — the same one
- * that stands in the metric's caption, so the page holds no two answers about "counted with what". */
-export const appMetric = {};
-appData.metrics.forEach((m) => { appMetric[m.key] = m; });
+/* The model is not a constant any longer: the block in the file is **packed** (gzipped and base64 encoded,
+ * `appUnpack` of the payload chapter), so unpacking is asynchronous and the model is set once, by `appBoot`,
+ * before anything is drawn and before any chapter below reads it. The names, their shapes and their order are what
+ * they were; only their appearance moved — from the parse to that one call. */
+export let appData = null;
+export let appView = null;
+export let appMetric = null;
+export let appMeasured = null;
+let appKey = null;
+let appFoldKey = null;
 
-/* A column by a file's path: the page's tree is the project's tree (every path of the catalogue) while the numbers
- * belong to columns only, so this pointer is what decides whether a leaf is a checkbox or a caption. The name follows the
- * same rule as the choice's record (`appFileAt`), so the tree and the reader's memory cannot drift apart. */
-export const appMeasured = {};
-appData.files.forEach((_f, i) => { appMeasured[appFileAt(i)] = i; });
+/* One place that turns the unpacked block into what the chapters speak: the sparse form is unrolled by the payload
+ * chapter into the dense contract every number comes from — snapshots per commit, the texts themselves, "now" as
+ * the state at HEAD — and the view starts switched on whole.
+ *
+ * A metric's description by key stands here too: the way the number was obtained is text under the switches, so the
+ * page holds no second answer about "counted with what".
+ *
+ * A column by a file's path is the pointer that decides whether a leaf of the tree is a checkbox or a caption (the
+ * page's tree is the project's tree while the numbers belong to columns only); the name follows the same rule as the
+ * choice's record (`appFileAt`), so the tree and the reader's memory cannot drift apart.
+ *
+ * The key the reader's memory lives under is counted here as well, because it is the report's passport: it depends
+ * on the data, and until the block is unpacked there is nothing to count it from. */
+export function appBoot(text) {
+  appData = appDecode(JSON.parse(text));
+  /* The tree is folded as it opens: a project's tree is longer than the window, and the reader's first look is at a
+   * short list rather than at everything. What is remembered is the opposite — the folders the reader unfolded
+   * (`appFoldRead`). */
+  appView = { metrics: {}, files: [], open: {} };
+  appMetric = {};
+  appMeasured = {};
+  appData.metrics.forEach((m) => { appView.metrics[m.key] = true; appMetric[m.key] = m; });
+  appData.files.forEach((_f, i) => { appView.files.push(true); appMeasured[appFileAt(i)] = i; });
+  appKey = 'size-report:' + appPassport();
+  appFoldKey = appKey + ':tree';
+}
 
 /* A link is that same choice in the address, under a name of its own: someone else's anchor on the page does not count
- * as a link, and there is nothing to argue with it about. */
+ * as a link, and there is nothing to argue with it about. The page does not write it any more — it only reads what came
+ * with the address — and this paragraph is what such a link is read by. */
 const APP_LINK = '#size-report=';
 
-/* Three circumstances of the first drawing, which act on it alone: the address is not rewritten during it (it was sent to
- * the reader rather than the other way), the memory is not touched (a link that came in is not the reader's choice), and
- * the message about the link has not faded yet. */
-let appStartup = true;
-let appForeign = false;
+/* One circumstance of the first drawing, and it acts on it alone: the memory is not written while somebody else's link
+ * is open — what came in is not the reader's choice, and only his own action makes it his. */
 let appTransient = false;
 
 /* -------- the reader's memory of his choice -------- */
@@ -70,12 +92,19 @@ function appHash(text) {
  * report's order. It is what tells one report from another — the record's key is chosen by it, so a choice made in
  * someone else's report is not picked up. The package version and the top of the history are absent on purpose: this is
  * the same report — updating the tool does not change what a column means, while a grown history is the very history the
- * reader comes back to. */
+ * reader comes back to.
+ *
+ * Counted once per document: it is a constant of the report, which depends on nothing the reader can change, and every
+ * click asks for it (the key of the memory and the passport of the record). A second count would be a second answer
+ * waiting to happen, and the labels it reads do not change while the page is open. */
+let appPassportValue = null;
 function appPassport() {
-  return appHash([appData.tool.name, appData.schema, appData.report.artifact,
-    appData.report.title, appData.files.map((f) => f.label).join('|')].join('\n'));
+  if (appPassportValue === null) {
+    appPassportValue = appHash([appData.tool.name, appData.schema, appData.report.artifact,
+      appData.report.title, appData.files.map((f) => f.label).join('|')].join('\n'));
+  }
+  return appPassportValue;
 }
-const appKey = 'size-report:' + appPassport();
 
 /* One record of the choice for everything: it goes both into the memory and into the address, so there are no two formats
  * of one state. Only what is switched off is kept, by name: "switched on" and "no record" are the same state, which is
@@ -93,32 +122,27 @@ function appRecordOk(rec) {
   return rec !== null && typeof rec === 'object' && rec.v === 1 && rec.passport === appPassport();
 }
 
+/* The record goes into the browser's memory and nowhere else: it is written on the click itself, which is what survives
+ * a closing, and the page's address keeps a clean tail — the report is a local page whose address is copied as it is,
+ * and a reader's choice belongs in the browser that made it rather than in the tab's title bar. What a link sent from an
+ * earlier release holds is still read (`appLinkUse`), and it is not written into the reader's memory: what came in is
+ * not his choice until he changes something. */
 export function appWrite() {
+  if (appTransient) return;
   const rec = appRecord();
   const empty = Object.keys(rec.metrics).length === 0 && Object.keys(rec.files).length === 0;
-  if (!appTransient) {
-    try {
-      if (empty) window.localStorage.removeItem(appKey);
-      else window.localStorage.setItem(appKey, JSON.stringify(rec));
-    } catch (_e) {
-      /* There is no memory (the browser grants this page none): the choice will not survive a closing, while the numbers
-       * and the markup do not depend on it. */
-    }
-  }
-  /* The address is the link for a colleague, which is why it repeats the choice. But not during the first drawing and not
-   * when the link turned out to be someone else's: an address that came in is not ours, and the reader has yet to read
-   * it. */
-  if (appStartup || appForeign) return;
   try {
-    window.history.replaceState(null, '', APP_LINK + encodeURIComponent(JSON.stringify(rec)));
+    if (empty) window.localStorage.removeItem(appKey);
+    else window.localStorage.setItem(appKey, JSON.stringify(rec));
   } catch (_e) {
-    /* The browser grants no change of the address: the link is then taken from the browser's memory. */
+    /* There is no memory (the browser grants this page none): the choice will not survive a closing, while the numbers
+     * and the markup do not depend on it. */
   }
 }
 
 /* A reset to "everything on": the border between "this is no longer in the report" and "switched off" is the record
- * rather than a missing value. A link carries the sender's whole choice, which is why it is applied to a clean view rather
- * than on top of someone else's. */
+ * rather than a missing value. A link carries the sender's whole choice, which is why it is applied to a clean view
+ * rather than on top of someone else's. */
 function appAll() {
   appData.metrics.forEach((m) => { appView.metrics[m.key] = true; });
   appData.files.forEach((_f, i) => { appView.files[i] = true; });
@@ -218,14 +242,15 @@ export function appApply(rec) {
   appData.files.forEach((_f, i) => { if (files[appFileAt(i)] === false) appView.files[i] = false; });
 }
 
-/* -------- the folded tree -------- */
-
-/* Folded folders are a memory of the same kind as the choice, but of a record of their own: it is about how much of the
- * tree is visible rather than about which numbers are read. Hence it does not go into the address: a link is sent for the
- * sake of the numbers, while an unfolded tree is the onlooker's business. As with the choice, only what is folded is kept
- * (`true`), and a folder's name is its path ("src/page"), so a vanished name simply means nothing. */
-const appFoldKey = appKey + ':tree';
+/* -------- the unfolded tree -------- */
 
+/* How much of the tree is visible is a memory of the same kind as the choice, but of a record of its own: it is about
+ * what the onlooker looks at rather than about which numbers are read, which is why it never goes into a link and never
+ * leaves the browser. The tree opens folded, so **the unfolded folders are what is kept** (`true`) — the default is the
+ * absence of the name, the same way "switched on" is the absence of a choice. A folder's name is its path ("src/page"),
+ * so a vanished name simply means nothing, and unfolding nothing is the state the page opens in: then the record is not
+ * kept at all rather than being kept empty. `appFoldKey` is set with the model (`appBoot`), for the reason the key
+ * itself is. */
 export function appFoldRead() {
   let text = null;
   try {
@@ -241,19 +266,19 @@ export function appFoldRead() {
     return;
   }
   if (!appRecordOk(rec)) return;
-  const folded = rec.folded || {};
-  Object.keys(folded).forEach((p) => { if (folded[p] === true) appView.folded[p] = true; });
+  const open = rec.open || {};
+  Object.keys(open).forEach((p) => { if (open[p] === true) appView.open[p] = true; });
 }
 
-export function appFoldSet(path, folded) {
-  if (folded) appView.folded[path] = true;
-  else delete appView.folded[path];
-  const rec = { v: 1, passport: appPassport(), folded: Object.assign({}, appView.folded) };
+export function appFoldSet(path, open) {
+  if (open) appView.open[path] = true;
+  else delete appView.open[path];
+  const rec = { v: 1, passport: appPassport(), open: Object.assign({}, appView.open) };
   try {
-    if (Object.keys(rec.folded).length === 0) window.localStorage.removeItem(appFoldKey);
+    if (Object.keys(rec.open).length === 0) window.localStorage.removeItem(appFoldKey);
     else window.localStorage.setItem(appFoldKey, JSON.stringify(rec));
   } catch (_e) {
-    /* There is no memory: what is folded will not survive a closing, while the view does not depend on it — the tree is
-     * folded exactly the way the reader folded it just now. */
+    /* There is no memory: what is unfolded will not survive a closing, while the view does not depend on it — the tree
+     * is unfolded exactly the way the reader unfolded it just now. */
   }
 }