mosaic-headless 1.2.1 → 1.4.0

package/tools/sweep_interactions.py

@@ -0,0 +1,352 @@
+#!/usr/bin/env python3
+"""Find out what shape an interaction animation has to be, by committing candidates.
+
+    python tools/sweep_interactions.py --config c.json --post 20 --slug probe-lab
+    python tools/sweep_interactions.py --config c.json --post 20 --slug probe-lab \
+        --csv data/interaction-verification.csv
+
+Mosaic has two animation systems. The CSS path - a `transition` plus a state - is
+fully verified elsewhere. This is the other one: keyframes driven by Mosaic's own
+JavaScript, which is the only way to get scroll-linked motion, and which this skill
+called UNSOLVED because `propertyMetas` and per-keyframe `properties` never survived
+into the page.
+
+The reason they never survived is legible in the source rather than guessable:
+
+    AnimationActionOptionsDataSubAbstract::createProperties()
+        $this->createDataArray('propertyMetas', KeyframePropertyMetasDataSub::class);
+
+    DataArray::initValues($arrayRawItems)
+        foreach ($arrayRawItems as $arrayRawItem) {
+            $arrayItem = $this->_createArrayItem($arrayRawItem->uuid);   // <-- here
+            unset($arrayRawItem->uuid);
+
+**A data array is a JSON list whose every item carries its own `uuid` field.** An
+item without one cannot be constructed, so the list is silently emptied - which
+looks exactly like "arrays are the wrong shape" and sends you off trying objects.
+
+And a keyframe's `properties` is a `DataGroup` whose descriptors are built at sync
+time, one per property meta, under `KeyframePropertyMetaDataSub::getName()`. For a
+`predefined` meta that name is the property itself (`PredefinedKeyframePropertyMeta\\
+OptionAbstract::getName() { return $this->getProperty(); }`), so `properties` is
+keyed by `"opacity"`, not by the meta's uuid.
+
+Both of those are readings of the source, which is exactly the kind of claim this
+skill refuses to make on its own. So each candidate below is committed to a live
+page and judged against `var mosaicInteractions` in the delivered HTML - the payload
+Mosaic's own frontend consumes - **including negative controls**, because a shape
+that works proves nothing about WHY unless the shape that differs by one field fails.
+
+Statuses
+--------
+    BOUND       the payload carries the animated properties: solved
+    TIMING_ONLY keyframes arrived with timing and nothing to animate
+    NO_PAYLOAD  the interaction did not reach `var mosaicInteractions` at all
+    DROPPED     the row stored, but the interaction was pruned out of the node data
+    REJECTED    the validator refused the commit
+"""
+from __future__ import annotations
+
+import argparse
+import csv
+import json
+import os
+import re
+import sys
+import time
+import urllib.request
+import uuid
+
+sys.path.insert(0, os.path.dirname(os.path.abspath(__file__)))
+from build_page import Surface  # noqa: E402
+from build_site import bind_page, build_page_document, build_shell  # noqa: E402
+from sweep_node_types import Client  # noqa: E402
+
+# Read off PredefinedKeyframePropertyMetaTypeFactory's constructor. `data/animatable-
+# properties.csv` carries the full list; these are the ones each candidate drives.
+OPACITY, MOVE_Y = "opacity", "translateY"
+
+
+def meta(name, uid=None, with_uuid=True):
+    m = {"type": "predefined", "timelineKey": "_", "predefinedOptions": {"name": name}}
+    if with_uuid:
+        m["uuid"] = uid or str(uuid.uuid4())
+    return m
+
+
+def interaction(options, trigger="scrollIntoView"):
+    """The envelope that is already verified: type, options, action slot, actions."""
+    ix = str(uuid.uuid4())
+    return [{
+        "type": trigger, "uuid": ix,
+        "%sOptions" % trigger: {
+            "name": "Probe", "ID": ix,
+            "actionSlots": {trigger: {"actions": [
+                {"type": "animation", "uuid": str(uuid.uuid4()),
+                 "animationOptions": options}]}},
+        }}]
+
+
+def candidates():
+    """Each case is (label, note, interactions). Negative controls included on
+    purpose: a candidate that works is only informative next to the one that does
+    not, and the pair is what identifies the field that matters."""
+    mid = str(uuid.uuid4())
+    cases = []
+
+    cases.append(("metas-with-uuid",
+                  "the hypothesis: DataArray items carry their own uuid",
+                  interaction({
+                      "propertyMetas": [meta(OPACITY, mid)],
+                      "initial": {OPACITY: 0},
+                      "keyframes": [{"uuid": str(uuid.uuid4()),
+                                     "progressData": {"delay": 0, "duration": 100},
+                                     "properties": {OPACITY: 1}}]})))
+
+    cases.append(("metas-without-uuid",
+                  "NEGATIVE CONTROL - identical but the meta has no uuid",
+                  interaction({
+                      "propertyMetas": [meta(OPACITY, with_uuid=False)],
+                      "initial": {OPACITY: 0},
+                      "keyframes": [{"uuid": str(uuid.uuid4()),
+                                     "progressData": {"delay": 0, "duration": 100},
+                                     "properties": {OPACITY: 1}}]})))
+
+    kid = str(uuid.uuid4())
+    cases.append(("properties-keyed-by-meta-uuid",
+                  "NEGATIVE CONTROL - properties keyed by the meta's uuid, not name",
+                  interaction({
+                      "propertyMetas": [meta(OPACITY, kid)],
+                      "initial": {kid: 0},
+                      "keyframes": [{"uuid": str(uuid.uuid4()),
+                                     "progressData": {"delay": 0, "duration": 100},
+                                     "properties": {kid: 1}}]})))
+
+    cases.append(("no-initial",
+                  "does the initial block have to be there?",
+                  interaction({
+                      "propertyMetas": [meta(OPACITY)],
+                      "keyframes": [{"uuid": str(uuid.uuid4()),
+                                     "progressData": {"delay": 0, "duration": 100},
+                                     "properties": {OPACITY: 1}}]})))
+
+    cases.append(("two-properties",
+                  "more than one meta, and a transform among them",
+                  interaction({
+                      "propertyMetas": [meta(OPACITY), meta(MOVE_Y)],
+                      "initial": {OPACITY: 0, MOVE_Y: "40px"},
+                      "keyframes": [{"uuid": str(uuid.uuid4()),
+                                     "progressData": {"delay": 0, "duration": 100},
+                                     "properties": {OPACITY: 1, MOVE_Y: "0px"}}]})))
+
+    cases.append(("two-keyframes",
+                  "a real timeline rather than a single step",
+                  interaction({
+                      "propertyMetas": [meta(OPACITY)],
+                      "initial": {OPACITY: 0},
+                      "keyframes": [
+                          {"uuid": str(uuid.uuid4()),
+                           "progressData": {"delay": 0, "duration": 50},
+                           "properties": {OPACITY: 1}},
+                          {"uuid": str(uuid.uuid4()),
+                           "progressData": {"delay": 50, "duration": 50},
+                           "properties": {OPACITY: 0.35}}]})))
+
+    cases.append(("timed-trigger",
+                  "the timed family rather than the progress family",
+                  interaction({
+                      "propertyMetas": [meta(OPACITY)],
+                      "initial": {OPACITY: 0},
+                      "keyframes": [{"uuid": str(uuid.uuid4()),
+                                     "progressData": {"delay": 0, "duration": 400},
+                                     "properties": {OPACITY: 1}}]},
+                      trigger="pointerEnter")))
+    return cases
+
+
+def probe_tree(cases):
+    """One div per case, each carrying its candidate and nothing else that could
+    explain a difference."""
+    return {
+        "type": "div", "data": {"attrID": "ix-root"},
+        "style": {"&": {"_": {"paddingTop": "40px", "paddingBottom": "600px",
+                              "display": "grid", "rowGap": "300px"}}},
+        "children": [
+            {"type": "div",
+             "data": {"attrID": "ix-%s" % label, "interactions": ix},
+             "style": {"&": {"_": {"height": "80px",
+                                   "backgroundColor": "rgb(9,99,199)"}}},
+             "children": [{"type": "text",
+                           "data": {"tagName": "p", "attrID": "ix-%s-t" % label},
+                           "text": label}]}
+            for label, _note, ix in cases],
+    }
+
+
+def fetch(url):
+    sep = "&" if "?" in url else "?"
+    req = urllib.request.Request(
+        "%s%s_v=%d" % (url, sep, int(time.time() * 1000)),
+        headers={"User-Agent": "Mozilla/5.0", "Cache-Control": "no-cache"})
+    with urllib.request.urlopen(req, timeout=90) as r:
+        return r.read().decode("utf-8", "replace")
+
+
+def payload_of(html):
+    m = re.search(r"var mosaicInteractions\s*=\s*(\[.*?\]);", html, re.S)
+    if not m:
+        return None
+    try:
+        return json.loads(m.group(1))
+    except ValueError:
+        return None
+
+
+def judge(entry):
+    """(status, evidence). The question is only ever whether a property arrived."""
+    if entry is None:
+        return "NO_PAYLOAD", "no entry for this trigger selector"
+    actions = []
+    for slot in (entry.get("action") or {}).values():
+        actions += (slot or {}).get("actions") or []
+    if not actions:
+        return "NO_PAYLOAD", "entry present but carries no actions"
+    props, timing = set(), 0
+    for act in actions:
+        opts = act.get("animationOptions") or {}
+        for tl in (opts.get("timelines") or {}).values():
+            for kf in tl.get("keyframes") or []:
+                timing += 1
+                props |= set((kf.get("properties") or {}).keys())
+            props |= set((tl.get("initial") or {}).keys())
+    if props:
+        return "BOUND", "%d keyframes driving %s" % (timing, ",".join(sorted(props)))
+    return "TIMING_ONLY", "%d keyframes, no properties" % timing
+
+
+def stored_interactions(client, master, template):
+    """The rows as the database holds them.
+
+    Without this the tool cannot tell a candidate REJECTED AT PARSE from one that
+    stored perfectly and was dropped on export, and those have opposite fixes. It is
+    also how the two-pass finding was made: `propertyMetas` turned out to be stored
+    exactly as sent while `initial` and the keyframes' `properties` were not."""
+    from sweep_node_types import unwrap  # noqa: E402
+    doc = unwrap(client.get("templateDocumentInstance/%s/%s" % (master, template)),
+                 "templateDocumentInstance")
+    out = {}
+    for node in doc.get("node/template/%s" % template, []):
+        data = node.get("data") or {}
+        if str(data.get("attrID", "")).startswith("ix-"):
+            out[data["attrID"]] = {"node": node, "interactions": data.get("interactions")}
+    return out
+
+
+def second_pass(client, master, template, cases):
+    """Re-commit the same nodes, unchanged, as an UPDATE.
+
+    The reason this exists is the whole finding. A keyframe's `properties` and the
+    `initial` block are not statically declared: their descriptors are created during
+    sync, one per property meta, by `syncAttachedPropertyMetas()`. On the commit that
+    first introduces the metas, the raw values are parsed BEFORE those descriptors
+    exist, so every property is an unknown key and is dropped - silently, with the
+    metas themselves stored perfectly, which is what makes it look like the metas are
+    the problem.
+
+    On a SECOND commit the stored metas are loaded and synced first, the descriptors
+    are therefore already in place, and the same values are accepted. So the payload
+    is not a shape problem at all. It is an ordering one."""
+    from sweep_node_types import envelopes, exceptions_of, unwrap  # noqa: E402
+    instance = "templateDocumentInstance/%s/%s" % (master, template)
+    doc = unwrap(client.get(instance), "templateDocumentInstance")
+    key = "node/template/%s" % template
+    want = {"ix-%s" % label: ix for label, _n, ix in cases}
+
+    revisions = []
+    for node in doc.get(key, []):
+        attr = (node.get("data") or {}).get("attrID")
+        if attr in want:
+            fresh = dict(node["data"], interactions=want[attr])
+            revisions.append({"newRevisionRecord": dict(node, data=fresh),
+                              "originalRevisionRecord": node})
+    if not revisions:
+        return
+    resp = client.commit(instance, envelopes(doc), {key: revisions})
+    err = exceptions_of(resp)
+    print("second pass: re-sent %d nodes%s"
+          % (len(revisions), ("  exceptions=%s" % err) if err else ""))
+
+
+def main():
+    ap = argparse.ArgumentParser()
+    ap.add_argument("--config", required=True)
+    ap.add_argument("--post", type=int, required=True)
+    ap.add_argument("--slug", required=True)
+    ap.add_argument("--csv")
+    ap.add_argument("--second-pass", action="store_true",
+                    help="re-commit the same nodes once more before judging")
+    a = ap.parse_args()
+
+    cfg = json.load(open(a.config, encoding="utf-8"))
+    client, surface = Client(cfg), Surface()
+    cases = candidates()
+
+    site = {"pages": [], "shell": {}}
+    master = build_shell(client, cfg, site, surface)
+    template = bind_page(client, cfg, master, a.slug, a.post)
+    n = build_page_document(client, cfg, master, template, probe_tree(cases), surface)
+
+    if a.second_pass:
+        second_pass(client, master, template, cases)
+
+    url = "%s/%s/" % (cfg["base"].rstrip("/"), a.slug)
+    html = fetch(url)
+    print("%s  %d bytes  %d nodes\n" % (url, len(html), n))
+
+    stored = stored_interactions(client, master, template)
+
+    payload = payload_of(html)
+    if payload is None:
+        sys.exit("no `var mosaicInteractions` on the page at all - nothing to judge")
+
+    # The frontend keys each entry by the trigger's generated class, so map each probe
+    # id to its class the same way verify_rwd does, then match entries by that class.
+    by_class = dict(re.findall(r'id="(ix-[^"]+)"[^>]*class="(M_EL\d+)', html))
+    entries = {e.get("triggerSelector", "").lstrip("."): e for e in payload}
+
+    rows, solved = [], 0
+    for label, note, _ix in cases:
+        cls = by_class.get("ix-%s" % label)
+        status, evidence = judge(entries.get(cls))
+        if cls is None:
+            status, evidence = "DROPPED", "probe element not in the delivered HTML"
+        kept = (stored.get("ix-%s" % label) or {}).get("interactions")
+        metas, props = 0, 0
+        for item in (kept if isinstance(kept, list) else []):
+            for opt in item.values():
+                if not isinstance(opt, dict):
+                    continue
+                for slot in (opt.get("actionSlots") or {}).values():
+                    for act in (slot or {}).get("actions") or []:
+                        ao = act.get("animationOptions") or {}
+                        metas += len(ao.get("propertyMetas") or [])
+                        props += len(ao.get("initial") or {})
+                        for kf in ao.get("keyframes") or []:
+                            props += len(kf.get("properties") or {})
+        kept_note = "stored: %d metas, %d property values" % (metas, props)
+        solved += status == "BOUND"
+        rows.append([label, note, status, evidence, kept_note])
+        print("  %-30s %-12s %-32s %s" % (label, status, evidence, kept_note))
+
+    print("\n%d of %d candidates bound their properties" % (solved, len(cases)))
+    if a.csv:
+        with open(a.csv, "w", newline="", encoding="utf-8") as fh:
+            w = csv.writer(fh)
+            w.writerow(["candidate", "note", "status", "evidence", "stored"])
+            w.writerows(rows)
+        print("wrote", a.csv)
+    sys.exit(0 if solved else 1)
+
+
+if __name__ == "__main__":
+    main()

package/tools/sweep_node_properties.py

@@ -28,6 +28,19 @@ Statuses
     APPLIED     the property changed the delivered HTML in the way it claims to
     NO_EFFECT   correctly shaped value, committed, nothing changed in the markup
     SKIPPED     no value could be derived from the validator chain; NOT a pass
+    INSTRUMENT  this sweep USES the property to run itself, so it cannot also be the
+                subject - but another pass covers it, named per row. NOT a pass here
+
+`INSTRUMENT` exists because the alternative is a lie in either direction. This sweep
+finds each probe node by its `attrID` and reads its `style` back out of the compiled
+CSS; asking it to probe those two is asking a ruler to measure itself, and it
+returned `SKIPPED` for both. But `SKIPPED` reads as "nobody checked", and `attrID`
+and `style` are in fact the two most heavily asserted properties in the skill: every
+row of `style-verification.csv` is a `style` assertion and every row of
+`rwd-verification.csv` is a `style` assertion located by `attrID`. Relabelling them
+as passes would be the blind-spot-scored-as-success failure this file was written to
+avoid; leaving them as SKIPPED understates the evidence by nearly seven hundred rows.
+So they get their own status, and it carries the count and the file that holds it.
 """
 import argparse
 import csv
@@ -163,8 +176,32 @@ def main():
     for r in types.values():
         by_class.setdefault(r["data_class"], []).append(r["type"])
 
+    # The count is read out of the covering CSV at run time rather than typed in, so
+    # the claim cannot drift away from the evidence it points at.
+    def covering(files):
+        parts = []
+        for name in files:
+            path = os.path.join(here, "..", "data", name + ".csv")
+            if not os.path.exists(path):
+                continue
+            with open(path, encoding="utf-8", newline="") as fh:
+                n = sum(1 for _ in csv.DictReader(fh))
+            parts.append("%s (%d rows)" % (name + ".csv", n))
+        return "; ".join(parts)
+
+    INSTRUMENT = {
+        "attrID": ["style-verification", "rwd-verification"],
+        "style": ["style-verification", "rwd-verification"],
+    }
+
     plan = []
     for row in props:
+        if row["property"] in INSTRUMENT:
+            plan.append((None, row["property"], None,
+                         ("INSTRUMENT", "this sweep locates and reads nodes THROUGH "
+                          "it; asserted instead by " +
+                          covering(INSTRUMENT[row["property"]]))))
+            continue
         value = probe_value(row)
         if value is None:
             plan.append((None, row["property"], None, "SKIPPED"))
@@ -245,7 +282,9 @@ def main():
             status = "EDITOR_ONLY"
         rows.append([prop, host, json.dumps(value, ensure_ascii=False), status, evidence])
     for host, prop, value, pre in plan:
-        if pre in ("SKIPPED", "NO_HOST"):
+        if isinstance(pre, tuple):
+            rows.append([prop, "", "", pre[0], pre[1]])
+        elif pre in ("SKIPPED", "NO_HOST"):
             rows.append([prop, "", "", pre, ""])
 
     counts = {}
@@ -253,7 +292,7 @@ def main():
         counts[r[3]] = counts.get(r[3], 0) + 1
     print()
     for k in ("APPLIED", "NO_EFFECT", "EDITOR_ONLY", "NO_ELEMENT", "NO_HOST",
-              "SKIPPED"):
+              "INSTRUMENT", "SKIPPED"):
         if counts.get(k):
             print("  %-12s %d" % (k, counts[k]))
     applied = sorted({r[0] for r in rows if r[3] == "APPLIED"})

package/tools/sweep_style_states.py

@@ -0,0 +1,225 @@
+#!/usr/bin/env python3
+"""Write a declaration under every style state and check the selector it compiled to.
+
+    python tools/sweep_style_states.py --config c.json --post 20 --slug probe-lab
+    python tools/sweep_style_states.py --config c.json --post 20 --slug probe-lab \
+        --csv data/style-state-verification.csv
+
+`data/style-states.csv` lists 53 states, each with the selector template Mosaic
+claims it produces. Exactly one of them - `hover` - had ever been written to a page.
+The other 52 were a table read off the source, which is the kind of claim this skill
+is supposed to refuse.
+
+The states are not interchangeable. Eight are `global` and go on anything; the
+remaining 45 are `node-type` scoped and only exist on one type - `___tab--active` is
+meaningless on a div. So each state is probed on a host derived from the factory file
+it was declared in, and where that host is a type the node sweep measured as unsafe
+to commit, the state is `NO_HOST` rather than a failure: **the state was not tested,
+and saying so is the whole point.**
+
+The probe value is `letterSpacing`, which the style sweep measured as COMPILED and
+ungrouped, at a pixel value unique to each state - so a match proves *that* state
+produced *that* rule, rather than proving some rule exists somewhere.
+
+Statuses
+--------
+    COMPILED   a rule with this state's selector carries the declaration
+    SELECTOR   the declaration compiled, but under a selector that is not the one
+               `style-states.csv` promises - the table is wrong for this state
+    ABSENT     committed, and no rule carrying the value exists at all
+    NO_HOST    the state belongs to a node type that cannot be safely committed
+    SKIPPED    no host could be derived from the source path; NOT a pass
+"""
+from __future__ import annotations
+
+import argparse
+import csv
+import json
+import os
+import re
+import sys
+import time
+import urllib.error
+import urllib.request
+
+sys.path.insert(0, os.path.dirname(os.path.abspath(__file__)))
+from build_page import Surface  # noqa: E402
+from build_site import bind_page, build_page_document, build_shell  # noqa: E402
+from sweep_node_types import Client  # noqa: E402
+
+DATA = os.path.join(os.path.dirname(os.path.abspath(__file__)), "..", "data")
+UNSAFE = {"COMMIT_500", "COMMIT_502", "BROKE_PAGE"}
+
+
+def load(name):
+    with open(os.path.join(DATA, name), encoding="utf-8", newline="") as fh:
+        return list(csv.DictReader(fh))
+
+
+def hosts_by_factory():
+    """type -> factory file, so a state's `declared_in` can name its host.
+
+    A node-type state is declared inside the factory of the type it belongs to, which
+    is the only link between the two tables. `StatesMeta.php` declares the global
+    ones and belongs to no type."""
+    return {r["file"]: r["type"] for r in load("node-types.csv")}
+
+
+def plan():
+    types = hosts_by_factory()
+    outcome = {r["type"]: r["outcome"] for r in load("node-verification.csv")}
+    out = []
+    for i, row in enumerate(load("style-states.csv")):
+        state, tpl, scope = row["state"], row["selector_template"], row["scope"]
+        if state == "&":
+            continue                      # the base state is what everything else is
+        if scope == "global":             # measured against 200-1000 elsewhere; any
+            host, why = "div", ""         # element will do
+        else:
+            host = types.get(row["declared_in"], "")
+            why = "" if host else "no node type declares %s" % row["declared_in"]
+            if host and outcome.get(host) in UNSAFE:
+                why = "host %s is %s - committing it breaks the page" % (
+                    host, outcome[host])
+        out.append({"state": state, "template": tpl, "scope": scope, "host": host,
+                    "blocked": why, "value": "%dpx" % (301 + i)})
+    return out
+
+
+def tree_for(cases):
+    """One node per testable state, each carrying that state and nothing else."""
+    kids = []
+    for c in cases:
+        if c["blocked"] or not c["host"]:
+            continue
+        c.pop("attr", None)
+        kids.append({
+            "type": c["host"],
+            "data": {"attrID": "st-%d" % len(kids)},
+            "style": {"&": {"_": {"paddingTop": "2px"}},
+                      c["state"]: {"_": {"letterSpacing": c["value"]}}},
+            "children": [],
+        })
+        c["attr"] = "st-%d" % (len(kids) - 1)
+    return {"type": "div", "data": {"attrID": "st-root"},
+            "style": {"&": {"_": {"paddingTop": "20px", "paddingBottom": "20px"}}},
+            "children": kids}
+
+
+def fetch(url):
+    sep = "&" if "?" in url else "?"
+    req = urllib.request.Request("%s%s_v=%d" % (url, sep, int(time.time() * 1000)),
+                                 headers={"User-Agent": "Mozilla/5.0",
+                                          "Cache-Control": "no-cache"})
+    # Never raise on an HTTP error. A probe page that 500s is a RESULT - it means one
+    # of the hosts cannot live where it was put - and a tool that dies on it reports
+    # nothing about the other fifty states.
+    try:
+        with urllib.request.urlopen(req, timeout=90) as r:
+            return r.read().decode("utf-8", "replace")
+    except urllib.error.HTTPError as e:
+        return e.read().decode("utf-8", "replace")
+
+
+def norm(text):
+    return re.sub(r"\s+", "", (text or "")).lower()
+
+
+def main():
+    ap = argparse.ArgumentParser()
+    ap.add_argument("--config", required=True)
+    ap.add_argument("--post", type=int, required=True)
+    ap.add_argument("--slug", required=True)
+    ap.add_argument("--csv")
+    a = ap.parse_args()
+
+    cfg = json.load(open(a.config, encoding="utf-8"))
+    client, surface = Client(cfg), Surface()
+    cases = plan()
+    testable = [c for c in cases if not c["blocked"] and c["host"]]
+
+    # ONE BATCH PER HOST TYPE. The first version of this tool put every host on a
+    # single page, and one type that cannot live under a plain div took the whole
+    # page to HTTP 500 - so all 37 probed states came back ABSENT, including the
+    # seven on a div that were certainly fine. A sweep whose failures are contagious
+    # measures its worst host rather than its surface.
+    batches, order = {}, []
+    for c in testable:
+        if c["host"] not in batches:
+            batches[c["host"]], _ = [], order.append(c["host"])
+        batches[c["host"]].append(c)
+
+    url = "%s/%s/" % (cfg["base"].rstrip("/"), a.slug)
+    site = {"pages": [], "shell": {}}
+    cls_of, rules_of, page_ok = {}, {}, {}
+    for host in order:
+        master = build_shell(client, cfg, site, surface)
+        template = bind_page(client, cfg, master, a.slug, a.post)
+        build_page_document(client, cfg, master, template,
+                            tree_for(batches[host]), surface)
+        html = fetch(url)
+        # Health is decided by DIRECT EVIDENCE, not by a byte count. The node sweep's
+        # 2,000-byte threshold is too low for this shell: a host whose page came back
+        # at 2,645 bytes - Mosaic's error string wrapped in the theme - passed it, and
+        # its state was then reported ABSENT when in truth it was never tested. The
+        # probe root either rendered or it did not, and that is the same question.
+        healthy = 'id="st-root"' in html
+        page_ok[host] = healthy
+        print("  host %-28s %-7s %6d bytes  %d states"
+              % (host, "ok" if healthy else "BROKEN", len(html), len(batches[host])))
+        for attr, cls in re.findall(r'id="(st-\d+)"[^>]*class="(M_EL\d+)', html):
+            cls_of[(host, attr)] = cls
+        rules_of[host] = re.findall(r"([^{}]+)\{([^{}]*)\}", html)
+    print()
+
+    rows, counts = [], {}
+    for c in cases:
+        host = c.get("host")
+        rules = rules_of.get(host, [])
+        state, value = c["state"], c["value"]
+        if c["blocked"]:
+            status, evidence = ("NO_HOST" if c["host"] else "SKIPPED"), c["blocked"]
+        elif (host, c.get("attr")) not in cls_of:
+            status, evidence = (("BROKE_PAGE", "this host's page did not render")
+                                if not page_ok.get(host, True)
+                                else ("ABSENT", "probe element never reached the page"))
+        else:
+            cls = cls_of[(host, c["attr"])]
+            hit = [sel for sel, body in rules
+                   if "letter-spacing:%s" % value in norm(body)]
+            if not hit:
+                status, evidence = "ABSENT", "no rule anywhere carries %s" % value
+            else:
+                want = norm(c["template"].replace("&", "." + cls))
+                exact = [s for s in hit if want in norm(s)]
+                if exact:
+                    status, evidence = "COMPILED", exact[0].strip()[:90]
+                else:
+                    status, evidence = "SELECTOR", hit[0].strip()[:90]
+        counts[status] = counts.get(status, 0) + 1
+        rows.append([state, c["scope"], c["host"], c["template"], status, evidence])
+
+    for state, scope, host, tpl, status, evidence in rows:
+        if status != "COMPILED":
+            print("  %-44s %-9s %s" % (state, status, evidence[:60]))
+    print()
+    for k in ("COMPILED", "SELECTOR", "ABSENT", "BROKE_PAGE", "NO_HOST",
+              "SKIPPED"):
+        if counts.get(k):
+            print("  %-10s %d" % (k, counts[k]))
+    print("\n%d of %d probed states compiled to the selector the table promises."
+          % (counts.get("COMPILED", 0), len(testable)))
+    print("NO_HOST and SKIPPED are states that were NOT tested; they are not passes.")
+
+    if a.csv:
+        with open(a.csv, "w", newline="", encoding="utf-8") as fh:
+            w = csv.writer(fh)
+            w.writerow(["state", "scope", "host", "selector_template", "status",
+                        "evidence"])
+            w.writerows(rows)
+        print("\nwrote", a.csv)
+    sys.exit(1 if counts.get("ABSENT") or counts.get("SELECTOR") else 0)
+
+
+if __name__ == "__main__":
+    main()