ranger-compiler 3.5.0 → 3.5.2

package/dist/lib/evgr/Cargo.lock

@@ -0,0 +1,21 @@
+# This file is automatically @generated by Cargo.
+# It is not intended for manual editing.
+version = 4
+
+[[package]]
+name = "evgr"
+version = "0.1.0"
+dependencies = [
+ "ranger",
+]
+
+[[package]]
+name = "ranger"
+version = "0.1.0"
+dependencies = [
+ "ranger-macros",
+]
+
+[[package]]
+name = "ranger-macros"
+version = "0.1.0"

package/dist/lib/evgr/Cargo.toml

@@ -0,0 +1,19 @@
+# SPDX-License-Identifier: MIT
+#
+# EVGr: EVG's layout as a strict Rust module (see src/lib.rs). The same
+# source builds here with cargo and with `rgrc` for the other targets.
+
+[package]
+name = "evgr"
+version = "0.1.0"
+edition = "2021"
+license = "MIT"
+publish = false
+
+[dependencies]
+ranger = { path = "../../runtime/rust/ranger" }
+
+[profile.release]
+overflow-checks = false
+
+[workspace]

package/dist/lib/evgr/README.md

@@ -0,0 +1,140 @@
+# EVGr — EVG's layout as a strict Rust module
+
+An experiment beside [`lib/evg`](../evg), which it does not replace: the layout
+of an EVG document — boxes styled with CSS declarations, laid out as flexbox
+and grid with EVG's box model and initial values — written once in Rust
+(`src/`, 2,300 lines) and built two ways:
+
+- by **cargo** into native code (`cargo run --release --bin bench`);
+- by **`rgrc`** into every Ranger target, the way any `.rs` module is
+  (`docs/plans/PLAN_RUST_SYNTAX.md`): `npm run evgr:build` writes
+  `bin/Evgr.cjs`, and `bench/NativeBench.rgr` — a Ranger program that imports
+  `src/lib.rs` beside `lib/evg` — builds for C++ and Go.
+
+The questions were how it does on the layout cases EVG is measured with, and
+how its speed compares with the Ranger engine.
+
+```sh
+npm run evgr:compare     # the layout cases: EVGr, EVG and Chromium
+npm run evgr:speed       # the layout-bench fixtures at 1k / 10k / 100k
+npx vitest run --config tests/vitest.config.ts evgr.test.ts
+```
+
+## What it lays out
+
+`display` block / flex / grid / none, `flex-direction` (and the reverse
+forms), `flex-wrap`, width / height and their min / max (px, %, `calc()` of
+px and %), padding (a percentage of the containing block's width), margin,
+gap, `flex-grow` / `-shrink` / `-basis` / `flex`, `justify-content`,
+`align-items` / `-self` / `-content` (with `baseline`), `aspect-ratio`,
+`position: absolute` with top / right / bottom / left, grid templates (px, %,
+fr, auto, `minmax()`, `fit-content()`, `repeat(n, …)`,
+`repeat(auto-fit | auto-fill, …)`), placement by line numbers, `span`,
+`grid-template-areas` / `grid-area`, auto placement with `dense`, and text
+measured with EVG's default advance table, wrapped at spaces.
+
+Not there: borders, images, overlays, connectors, the stylesheet, scrolling,
+RTL — everything of EVG that is not the box layout. A property EVGr does not
+know is reported (`unsupported_count` / `unsupported_at`).
+
+The tree is an arena (a node is an index), and a subtree laid out at the same
+width in the same pass is moved rather than laid out again, which is what
+keeps a column of rows linear.
+
+## The layout cases
+
+`bench/compare.mjs` runs the 47 cases of `lib/evg/bench/layout-cases.mjs`
+through the three engines; two agree on a case when every box is within half
+a pixel.
+
+| | agree |
+| --- | --- |
+| EVGr and Chromium | 42 of 47 |
+| EVGr and EVG | 39 of 47 |
+| EVG and Chromium | 34 of 47 |
+
+Where EVGr and Chromium differ, EVGr keeps a choice EVG made on purpose:
+the initial values of `flex-direction` (column), `flex-wrap` (wrap) and
+`align-items` (flex-start: `defaults-*`, `nested-flex-in-flex`), and an
+absolute box placed against the content box (`absolute-child`). EVGr also
+keeps two of EVG's rules the cases do not reach: a root without a height is
+as tall as the viewport, and a text leaf without a width fits its text even
+where a column stretches its boxes.
+
+Where EVGr and EVG differ, EVGr agrees with Chromium: `align-content:
+stretch` over wrapped lines, `row-reverse`, a grid cell holding a flex row, a
+grid template mixing px / % / fr / auto, `max-content` as a width,
+`aspect-ratio`, `calc()`, and `repeat(auto-fit, …)`.
+
+The three text cases hold on EVGr's boxes, and EVGr's text boxes are EVG's
+(same advance table, same line height).
+
+## Speed
+
+`bench/speed.mjs` builds the three fixtures of
+`lib/evg/bench/layout-bench.mjs` — nested flex (a column of cards, each a row
+of a rail and a growing column), a four-column grid of small flex columns,
+and the flex fixture with a line of text per card — and times a re-layout of
+the built tree (median of five). Every engine's boxes are summed into a
+checksum: on all nine fixture sizes EVG and EVGr lay the tree out the same,
+in JavaScript, C++, Go and native Rust.
+
+Re-layout, milliseconds, one run on the development container:
+
+| fixture | nodes | EVG js | EVGr js | EVGr rustc | EVG / EVGr (js) | EVG js / EVGr rustc |
+| --- | ---: | ---: | ---: | ---: | ---: | ---: |
+| flex | 1,002 | 3.7 | 2.9 | 0.24 | 1.3x | 16x |
+| flex | 10,004 | 12.1 | 6.7 | 2.7 | 1.8x | 4.4x |
+| flex | 100,003 | 284 | 105 | 49 | 2.7x | 5.8x |
+| grid | 1,001 | 6.5 | 3.3 | 0.17 | 2.0x | 38x |
+| grid | 10,001 | 20.6 | 7.0 | 1.8 | 3.0x | 11x |
+| grid | 100,001 | 380 | 85 | 35 | 4.5x | 11x |
+| text | 1,002 | 4.1 | 4.2 | 0.30 | 1.0x | 14x |
+| text | 10,004 | 19.6 | 10.7 | 2.7 | 1.8x | 7.2x |
+| text | 100,003 | 345 | 97 | 43 | 3.6x | 8.0x |
+
+The same program through Ranger to C++ (`g++ -O2`) and Go:
+
+| fixture | nodes | EVG C++ | EVGr C++ | EVG Go | EVGr Go |
+| --- | ---: | ---: | ---: | ---: | ---: |
+| flex | 100,003 | 198 | 144 | 148 | 129 |
+| grid | 100,001 | 329 | 125 | 285 | 73 |
+| text | 100,003 | 397 | 152 | 180 | 200 |
+
+What the numbers say:
+
+- Written as Rust and compiled by Ranger, EVGr's layout is faster than EVG's
+  on every target at 10k boxes and above — 2–4x in JavaScript. EVGr does less
+  (no stylesheet, no overlays, no paint bookkeeping) and caches more (a
+  subtree laid out at the same width is moved), so this measures the two
+  engines, not the two source languages.
+- The same Rust source built by rustc is 2–3x faster again than its
+  JavaScript build at 100k boxes, and 4–38x faster than EVG in JavaScript.
+- Ranger's C++ output is not the fast path for this code: EVGr through C++ is
+  slower than EVGr through JavaScript (`shared_ptr` everywhere, and the
+  `children.clone()` the Rust source does per node becomes a vector copy).
+  Go sits between.
+- Building the tree (parsing the CSS text) is where EVGr is slower than EVG
+  in JavaScript, 1–2x: its string handling is lowered from Rust's `split`,
+  `trim` and `find` one operation at a time.
+
+## Found on the way
+
+Writing a 2,300-line module in the subset found these, fixed in the
+compiler or the runtime:
+
+- `str::strip_prefix` / `strip_suffix` were not in the subset.
+- An associated function named like a field of its struct (`Len::px` beside
+  `Len.px`) came out under one name, which C++ rejects; it is now written as
+  `px_m`.
+- `f64::floor` / `ceil` lowered to Ranger's `floor` / `ceil`, which answer an
+  int: Go rejected it. They have their own templates now.
+
+Two limits of Ranger itself, met in `NativeBench.rgr`, are fixed too:
+
+- A static method named like an operator (`count`, `make`, `size`, `sort`,
+  …) was rewritten into the operator-method form and then looked up as an
+  instance method: `Util.count(3)` failed with "Class Util does not have
+  method count".
+- `sort` took only a comparison callback. `(sort xs)` of a `[double]` or
+  `[int]` now gives a new array in ascending order on every target.

package/dist/lib/evgr/bench/NativeBench.rgr

@@ -0,0 +1,246 @@
+; SPDX-License-Identifier: MIT
+
+; EVG and EVGr in one program, for a target the JavaScript harness cannot
+; drive: the fixtures of lib/evg/bench/layout-bench.mjs built for both
+; engines, laid out, and timed. One line per fixture, size and engine:
+;
+;   <fixture> <size> <engine> <nodes> <layout ms> <checksum>
+;
+; `layout ms` is the median of five re-layouts after one warm-up; the
+; checksum sums x + y + w + h over every box, so the two engines can be
+; compared on the same tree. `bench/speed.mjs --targets cpp,go` builds this
+; for C++ and Go and prints the table.
+
+Import "../../evg/EVGElement.rgr"
+Import "../../evg/EVGUnit.rgr"
+Import "../../evg/EVGLayout.rgr"
+Import "../src/lib.rs"
+
+class NativeBench {
+
+    sfn setCss:void (el:EVGElement css:string) {
+        def decls:[string] (strsplit css ";")
+        for decls d:string i {
+            def t:string (trim d)
+            if ((strlen t) == 0) {
+                continue
+            }
+            def c:int (indexOf t ":")
+            if (c < 0) {
+                continue
+            }
+            el.setAttribute((trim (substring t 0 c)) (trim (substring t (c + 1) (strlen t))))
+        }
+    }
+
+    sfn node:EVGElement (css:string) {
+        def el:EVGElement (new EVGElement())
+        NativeBench.setCss(el css)
+        return el
+    }
+
+    sfn css:string (name:string) {
+        if (name == "page") {
+            return "display:flex;flex-direction:column;flex-wrap:nowrap;width:1200px;gap:8px;align-items:stretch"
+        }
+        if (name == "card") {
+            return "display:flex;flex-direction:row;flex-wrap:nowrap;gap:12px;padding:8px;align-items:stretch"
+        }
+        if (name == "rail") {
+            return "width:48px;height:56px;background-color:#e4e4e7"
+        }
+        if (name == "body") {
+            return "display:flex;flex-direction:column;flex-wrap:nowrap;flex-grow:1;gap:4px;align-items:stretch"
+        }
+        if (name == "line") {
+            return "height:16px;background-color:#f4f4f5"
+        }
+        if (name == "gridc") {
+            return "display:grid;grid-template-columns:repeat(4, 1fr);gap:10px;width:1200px"
+        }
+        if (name == "cell") {
+            return "display:flex;flex-direction:column;flex-wrap:nowrap;gap:4px;padding:6px;align-items:stretch"
+        }
+        return "font-size:14px"
+    }
+
+    sfn word:string (i:int) {
+        def words:[string] ([] _:string ("Ada Lovelace" "Grace Hopper" "Alan Turing" "Edsger Dijkstra" "Barbara McClintock"))
+        return (itemAt words (i % 5))
+    }
+
+    sfn count:int (n:int per:int) {
+        def c:int (to_int ((to_double n) / (to_double per) + 0.5))
+        if (c < 1) {
+            return 1
+        }
+        return c
+    }
+
+    ; --- EVG
+
+    sfn evgTree:EVGElement (fixture:string n:int) {
+        if (fixture == "grid") {
+            def g:EVGElement (NativeBench.node((NativeBench.css("gridc"))))
+            def cells:int (NativeBench.count(n 5))
+            def i:int 0
+            while (i < cells) {
+                def cell:EVGElement (NativeBench.node((NativeBench.css("cell"))))
+                def j:int 0
+                while (j < 4) {
+                    cell.addChild((NativeBench.node((NativeBench.css("line")))))
+                    j = j + 1
+                }
+                g.addChild(cell)
+                i = i + 1
+            }
+            return g
+        }
+        def page:EVGElement (NativeBench.node((NativeBench.css("page"))))
+        def cards:int (NativeBench.count(n 7))
+        def k:int 0
+        while (k < cards) {
+            def card:EVGElement (NativeBench.node((NativeBench.css("card"))))
+            card.addChild((NativeBench.node((NativeBench.css("rail")))))
+            def body:EVGElement (NativeBench.node((NativeBench.css("body"))))
+            def q:int 0
+            while (q < 4) {
+                if ((fixture == "text") && (q == 0)) {
+                    def tx:EVGElement (NativeBench.node((NativeBench.css("text"))))
+                    tx.elementType = 1
+                    tx.textContent = (NativeBench.word(k))
+                    body.addChild(tx)
+                } {
+                    body.addChild((NativeBench.node((NativeBench.css("line")))))
+                }
+                q = q + 1
+            }
+            card.addChild(body)
+            page.addChild(card)
+            k = k + 1
+        }
+        return page
+    }
+
+    sfn evgSum:double (el:EVGElement) {
+        def s:double (((el.calculatedX + el.calculatedY) + el.calculatedWidth) + el.calculatedHeight)
+        for el.children k:EVGElement i {
+            s = s + (NativeBench.evgSum(k))
+        }
+        return s
+    }
+
+    sfn evgCount:int (el:EVGElement) {
+        def c:int 1
+        for el.children k:EVGElement i {
+            c = c + (NativeBench.evgCount(k))
+        }
+        return c
+    }
+
+    ; --- EVGr
+
+    sfn evgrTree:EvgrTree (fixture:string n:int) {
+        def t:EvgrTree (EvgrTree.new_())
+        if (fixture == "grid") {
+            def g:int (t.add(-1 (NativeBench.css("gridc"))))
+            def cells:int (NativeBench.count(n 5))
+            def i:int 0
+            while (i < cells) {
+                def cell:int (t.add(g (NativeBench.css("cell"))))
+                def j:int 0
+                while (j < 4) {
+                    t.add(cell (NativeBench.css("line")))
+                    j = j + 1
+                }
+                i = i + 1
+            }
+            return t
+        }
+        def page:int (t.add(-1 (NativeBench.css("page"))))
+        def cards:int (NativeBench.count(n 7))
+        def k:int 0
+        while (k < cards) {
+            def card:int (t.add(page (NativeBench.css("card"))))
+            t.add(card (NativeBench.css("rail")))
+            def body:int (t.add(card (NativeBench.css("body"))))
+            def q:int 0
+            while (q < 4) {
+                if ((fixture == "text") && (q == 0)) {
+                    t.add_text(body (NativeBench.css("text")) (NativeBench.word(k)))
+                } {
+                    t.add(body (NativeBench.css("line")))
+                }
+                q = q + 1
+            }
+            k = k + 1
+        }
+        return t
+    }
+
+    sfn evgrSum:double (t:EvgrTree) {
+        def s:double 0.0
+        def i:int 0
+        def n:int (t.count())
+        while (i < n) {
+            s = s + (((t.x(i) + t.y(i)) + t.w(i)) + t.h(i))
+            i = i + 1
+        }
+        return s
+    }
+
+    sfn median:double (xs:[double]) {
+        def s:[double] (sort xs)
+        return (itemAt s (idiv (array_length s) 2))
+    }
+
+    sfn fmt:string (v:double) {
+        def whole:int (to_int (v * 1000.0))
+        return (to_string ((to_double whole) / 1000.0))
+    }
+
+    sfn report:void (fx:string n:int engine:string nodes:int ms:double sum:double) {
+        def line:string ((fx + " ") + (to_string n))
+        line = ((line + " ") + engine)
+        line = ((line + " ") + (to_string nodes))
+        line = ((line + " ") + (NativeBench.fmt(ms)))
+        ; the checksum in hundreds, which an int of every target holds
+        line = ((line + " ") + (to_string (to_int (sum / 100.0))))
+        print line
+    }
+
+    sfn main:void () {
+        def fixtures:[string] ([] _:string ("flex" "grid" "text"))
+        def sizes:[int] ([] _:int (1000 10000 100000))
+        for fixtures fx:string fi {
+            for sizes n:int si {
+                ; EVG
+                def root:EVGElement (NativeBench.evgTree(fx n))
+                def lay:EVGLayout (new EVGLayout())
+                lay.setPageSize(1200.0 900.0)
+                lay.layout(root)
+                def times:[double]
+                def r:int 0
+                while (r < 5) {
+                    def a:double (wall_clock_ms)
+                    lay.layout(root)
+                    push times ((wall_clock_ms) - a)
+                    r = r + 1
+                }
+                NativeBench.report(fx n "evg" (NativeBench.evgCount(root)) (NativeBench.median(times)) (NativeBench.evgSum(root)))
+                ; EVGr
+                def t:EvgrTree (NativeBench.evgrTree(fx n))
+                t.layout(1200.0 900.0)
+                def times2:[double]
+                def r2:int 0
+                while (r2 < 5) {
+                    def b:double (wall_clock_ms)
+                    t.layout(1200.0 900.0)
+                    push times2 ((wall_clock_ms) - b)
+                    r2 = r2 + 1
+                }
+                NativeBench.report(fx n "evgr" (t.count()) (NativeBench.median(times2)) (NativeBench.evgrSum(t)))
+            }
+        }
+    }
+}

package/dist/lib/evgr/bench/compare.mjs

@@ -0,0 +1,252 @@
+#!/usr/bin/env node
+// SPDX-License-Identifier: MIT
+//
+// The layout cases of lib/evg/bench/layout-cases.mjs, laid out by three
+// engines: EVG (Ranger, compiled to JavaScript), EVGr (the strict Rust module
+// lib/evgr/src, compiled to JavaScript by rgrc) and Chromium.
+//
+//   npm run evgr:compare [-- --only <id>] [--verbose] [--json] [--no-browser]
+//
+// Every case is CSS text, split into declarations for EVG and EVGr and put in
+// a `style=` attribute for Chromium, exactly as layout-conformance.mjs does.
+// A pair of engines AGREES on a case when every box is within half a pixel.
+// Chromium is the reference for what the CSS says; EVG is the engine EVGr
+// sits beside, so both comparisons are reported.
+
+import fs from "node:fs";
+import path from "node:path";
+import { createRequire } from "node:module";
+import { fileURLToPath } from "node:url";
+import { CASES, TEXT_CASES } from "../../evg/bench/layout-cases.mjs";
+
+const HERE = path.dirname(fileURLToPath(import.meta.url));
+const ROOT = path.resolve(HERE, "..", "..", "..");
+const require = createRequire(import.meta.url);
+const EVG = require(path.join(ROOT, "lib/evg/bin/EvgLayoutBench.cjs"));
+const R = require(path.join(ROOT, "lib/evgr/bin/Evgr.cjs"));
+
+const argv = process.argv.slice(2);
+const AS_JSON = argv.includes("--json");
+const VERBOSE = argv.includes("--verbose");
+const NO_BROWSER = argv.includes("--no-browser");
+const ONLY = argv.includes("--only") ? argv[argv.indexOf("--only") + 1] : null;
+const EPS = 0.5;
+
+// --- EVG ---------------------------------------------------------------------
+
+function evgBuild(node) {
+  const el = new EVG.EVGElement();
+  for (const decl of (node.s || "").split(";")) {
+    const t = decl.trim();
+    if (!t) continue;
+    const i = t.indexOf(":");
+    if (i < 0) continue;
+    el.setAttribute(t.slice(0, i).trim(), t.slice(i + 1).trim());
+  }
+  if (node.text !== undefined) {
+    el.elementType = 1;
+    el.textContent = node.text;
+  }
+  for (const k of node.kids || []) el.addChild(evgBuild(k));
+  return el;
+}
+
+function evgBoxes(spec) {
+  EVG.EVGReject.clearNotes();
+  const root = evgBuild(spec);
+  const lay = new EVG.EVGLayout();
+  lay.setPageSize(1200, 900);
+  lay.layout(root);
+  const flat = [];
+  (function collect(el) {
+    flat.push({ x: el.calculatedX, y: el.calculatedY, w: el.calculatedWidth, h: el.calculatedHeight });
+    for (const k of el.children) collect(k);
+  })(root);
+  return flat;
+}
+
+// --- EVGr --------------------------------------------------------------------
+
+function evgrBuild(t, node, parent) {
+  const i = node.text !== undefined ? t.add_text(parent, node.s || "", node.text) : t.add(parent, node.s || "");
+  for (const k of node.kids || []) evgrBuild(t, k, i);
+  return i;
+}
+
+function evgrBoxes(spec) {
+  const t = R.EvgrTree.new_();
+  evgrBuild(t, spec, -1);
+  t.layout(1200, 900);
+  const flat = [];
+  for (let i = 0; i < t.count(); i++) flat.push({ x: t.x(i), y: t.y(i), w: t.w(i), h: t.h(i) });
+  const unsupported = [];
+  for (let k = 0; k < t.unsupported_count(); k++) unsupported.push(t.unsupported_at(k));
+  return { flat, unsupported };
+}
+
+// --- Chromium ----------------------------------------------------------------
+
+function html(spec) {
+  const render = (n) =>
+    `<div style="${(n.s || "").replace(/"/g, "&quot;")}">` +
+    (n.text !== undefined ? n.text.replace(/[<&]/g, (c) => (c === "<" ? "&lt;" : "&amp;")) : "") +
+    (n.kids || []).map(render).join("") +
+    `</div>`;
+  return (
+    `<!doctype html><meta charset="utf-8"><style>` +
+    `*{box-sizing:border-box;margin:0;padding:0;border:0 solid #000}` +
+    `html,body{margin:0;padding:0;font:16px/1.2 monospace}` +
+    `#host{position:absolute;left:0;top:0}` +
+    `</style><div id="host">${render(spec)}</div>`
+  );
+}
+
+async function browserBoxes(page, spec) {
+  await page.setContent(html(spec));
+  return page.evaluate(() => {
+    const out = [];
+    const host = document.getElementById("host");
+    const origin = host.firstElementChild.getBoundingClientRect();
+    (function collect(el) {
+      const r = el.getBoundingClientRect();
+      out.push({ x: r.left - origin.left, y: r.top - origin.top, w: r.width, h: r.height });
+      for (const c of el.children) collect(c);
+    })(host.firstElementChild);
+    return out;
+  });
+}
+
+// Whatever Chromium is on disk: this container's, a playwright cache's, or
+// the user's own Chrome.
+function chromiumPath() {
+  const roots = [process.env.PLAYWRIGHT_BROWSERS_PATH, "/opt/pw-browsers", path.join(process.env.HOME || "", "Library/Caches/ms-playwright"), path.join(process.env.HOME || "", ".cache/ms-playwright")];
+  for (const root of roots) {
+    if (!root || !fs.existsSync(root)) continue;
+    for (const dir of fs.readdirSync(root).filter((d) => d.startsWith("chromium-")).sort().reverse()) {
+      for (const rel of [
+        "chrome-linux/chrome",
+        "chrome-mac-arm64/Google Chrome for Testing.app/Contents/MacOS/Google Chrome for Testing",
+        "chrome-mac/Chromium.app/Contents/MacOS/Chromium",
+      ]) {
+        const p = path.join(root, dir, rel);
+        if (fs.existsSync(p)) return p;
+      }
+    }
+  }
+  return null;
+}
+
+// --- compare -----------------------------------------------------------------
+
+function agree(a, b) {
+  if (!a || !b) return null;
+  if (a.length !== b.length) return [{ id: "count", miss: true }];
+  const rows = [];
+  for (let i = 0; i < a.length; i++) {
+    const d = ["x", "y", "w", "h"].filter((k) => Math.abs(a[i][k] - b[i][k]) > EPS);
+    if (d.length) rows.push({ id: "n" + i, fields: d, a: a[i], b: b[i] });
+  }
+  return rows;
+}
+
+let page = null;
+let browser = null;
+if (!NO_BROWSER) {
+  const { chromium } = require("playwright-core");
+  const exe = chromiumPath();
+  browser = await chromium.launch(exe ? { executablePath: exe } : { channel: "chrome" });
+  page = await browser.newPage({ viewport: { width: 1200, height: 900 } });
+}
+
+const results = [];
+for (const c of CASES) {
+  if (ONLY && c.id !== ONLY) continue;
+  const evg = evgBoxes(c.root);
+  const r = evgrBoxes(c.root);
+  const css = page ? await browserBoxes(page, c.root) : null;
+  results.push({
+    id: c.id,
+    group: c.group,
+    why: c.why,
+    nodes: evg.length,
+    unsupported: r.unsupported,
+    evg,
+    evgr: r.flat,
+    css,
+    rCss: agree(r.flat, css),
+    rEvg: agree(r.flat, evg),
+    eCss: agree(evg, css),
+  });
+}
+
+// Text cases: EVG's own assertions, run on EVGr's boxes, and the boxes of
+// both engines side by side (they share the measurer's advance table).
+const textResults = [];
+for (const c of TEXT_CASES) {
+  if (ONLY && c.id !== ONLY) continue;
+  const evg = evgBoxes(c.root);
+  const r = evgrBoxes(c.root);
+  let ok = false;
+  try {
+    ok = !!c.assert(r.flat);
+  } catch (e) {
+    ok = false;
+  }
+  textResults.push({ id: c.id, why: c.why, ok, rEvg: agree(r.flat, evg), evg, evgr: r.flat });
+}
+
+if (browser) await browser.close();
+
+if (AS_JSON) {
+  // no process.exit: it would cut a piped stdout short
+  process.stdout.write(JSON.stringify({ results, textResults }, null, 2) + "\n");
+} else {
+  report();
+}
+
+function report() {
+
+// --- report ------------------------------------------------------------------
+
+const mark = (rows) => (rows === null ? "  - " : rows.length ? "DIFF" : " ok ");
+const pad = (s, n) => String(s).padEnd(n);
+const r2 = (v) => Math.round(v * 100) / 100;
+const f = (o) => `x=${r2(o.x)} y=${r2(o.y)} w=${r2(o.w)} h=${r2(o.h)}`;
+
+console.log("\nEVGr (Rust, via rgrc to JS) beside EVG and Chromium — the same CSS\n");
+console.log(`     ${pad("case", 28)} EVGr=CSS  EVGr=EVG  EVG=CSS`);
+let lastGroup = null;
+const count = { rCss: 0, rEvg: 0, eCss: 0 };
+for (const r of results) {
+  if (r.group !== lastGroup) {
+    console.log(`  ── ${r.group}`);
+    lastGroup = r.group;
+  }
+  for (const k of Object.keys(count)) if (r[k] && r[k].length === 0) count[k]++;
+  const note = r.unsupported.length ? `  (not laid out: ${r.unsupported.slice(0, 2).join("; ")}${r.unsupported.length > 2 ? "; …" : ""})` : "";
+  console.log(`     ${pad(r.id, 28)}   ${mark(r.rCss)}      ${mark(r.rEvg)}     ${mark(r.eCss)}${note}`);
+}
+const n = results.length;
+console.log(`\n  EVGr agrees with Chromium on ${count.rCss} of ${n}, with EVG on ${count.rEvg} of ${n}; EVG agrees with Chromium on ${count.eCss} of ${n}.`);
+
+console.log("\n  Text (EVG's assertions on EVGr's boxes; boxes against EVG's)");
+for (const t of textResults) {
+  console.log(`     ${t.ok ? " ok " : "FAIL"}  ${mark(t.rEvg)}  ${pad(t.id, 26)} ${t.why}`);
+}
+
+if (VERBOSE) {
+  for (const r of results) {
+    const rows = r.rCss && r.rCss.length ? r.rCss : [];
+    if (!rows.length) continue;
+    console.log(`\n  ${r.id} — ${r.why}`);
+    for (const d of rows.slice(0, 6)) {
+      if (d.miss) {
+        console.log(`     box count differs`);
+        continue;
+      }
+      console.log(`     ${d.id} [${d.fields.join(",")}]  EVGr ${f(d.a)}   CSS ${f(d.b)}   EVG ${f(r.evg[Number(d.id.slice(1))])}`);
+    }
+  }
+}
+console.log("");
+}