@techierathore/techieflow 1.0.4 → 1.1.1

package/.tfcore/utils/tf-verify-verdict.py

@@ -14,7 +14,10 @@ For each row, the seven checks in order, and the first that fails is the verdict
   render      every anchored control on its screen shows something — screens.json
   assets      every stylesheet and script its screen declares arrived — assets.json
   visual      nothing overlaps, nothing clipped or off-screen — screens.json
-  mockup      the screen carries the structure its mockup draws — parity.json
+  mockup      the screen carries the structure its mockup draws — parity.json, found by the screen's
+              name, its mockup's file name or its route ({id} in the row's route = one path segment, so
+              /processes/6/run counts for /processes/{id}/run); a driven screen with a mockup and no
+              comparison found FAILs this check, it is never skipped (Chatur TF-008)
   speed       within the row's perf-budget, only when it declares one — perf/<REQ>.json
   (standards has no script yet and is never listed as run)
 
@@ -22,7 +25,9 @@ Verdicts: PASS · FAIL (acceptance) · BUILD-FAIL · RENDER-FAIL · ASSET-FAIL
 PERF-FAIL · NOT-TESTED (no test carried the id, or every test carrying it was skipped; the screen
 checks passed or did not run) ·
 NOT-OBSERVABLE (an NFR row with no budget and no unit test) · NOT-DRIVEN (its screen was never driven:
-the head could not be booted, or has no driver). A row is Verified only on PASS. NOT-* rows keep their
+the head could not be booted, or has no driver) · DEFECT-OPEN (every check passed, but the old Remarks
+carry a defect no verify can see, tf_defect.py: the row goes to Needs re-verify, and so to a fix, with
+the defect kept; AppManager TF-021). A row is Verified only on PASS. NOT-* rows keep their
 status and get a Remark saying so; nothing is ever written as a static-only pass.
 
 Writes docs/.last-verify.json (the ledger the verify hook reads: date, app, scope, booted, the checks
@@ -38,6 +43,9 @@ import re
 import sys
 
 HERE = os.path.dirname(os.path.abspath(__file__))
+sys.path.insert(0, HERE)
+import tf_defect  # noqa: E402
+import tf_stack_check  # noqa: E402
 FAILING = {"BUILD-FAIL": "build", "FAIL": "acceptance", "RENDER-FAIL": "render", "ASSET-FAIL": "assets",
            "VISUAL-FAIL": "visual", "MOCKUP-FAIL": "mockup-parity", "PERF-FAIL": "perf"}
 STATUS = {"PASS": "Verified", "FAIL": "FAIL", "BUILD-FAIL": "FAIL", "RENDER-FAIL": "Needs re-verify", "ASSET-FAIL": "Needs re-verify",
@@ -71,6 +79,42 @@ def norm_route(r):
     return r or "/"
 
 
+def route_matches(pattern, route):
+    """A filled-in route against its pattern: /processes/6/run matches /processes/{id}/run, one path
+    segment per {…} (Chatur TF-008). A pattern with no {…} matches only itself. A query string on the
+    opened route (/start?all=1) is not part of the screen."""
+    p, r = norm_route(pattern), norm_route((route or "").split("?")[0].split("#")[0])
+    if "{" not in p:
+        return p == r
+    rx = "".join("[^/]+" if part.startswith("{") else re.escape(part) for part in re.split(r"(\{[^}]*\})", p))
+    return re.fullmatch(rx, r) is not None
+
+
+def stem(path):
+    return os.path.basename(path or "")[:-5].lower() if (path or "").lower().endswith(".html") else ""
+
+
+def parity_for(r, mockup, comparisons):
+    """The mockup comparison that graded a row's screen: named for the screen, for its mockup file
+    (the Mockup parity: line names each screen by its mockup's stem), or opened at the screen's route,
+    a {value} in it standing for any one segment. The worst one when several match: one per value
+    (Chatur TF-008)."""
+    screen, route = (r.get("screen") or "").lower(), r.get("route") or ""
+    hits = [s for s in comparisons
+            if (s.get("screen") or "").lower() in (screen, stem(mockup))
+            or (route and s.get("route") and route_matches(route, s.get("route")))]
+    order = {"FAIL": 0, "ERROR": 1, "UNGRADEABLE": 2, "NO-MOCKUP": 3, "PASS": 4}
+    return min(hits, key=lambda s: order.get(s.get("verdict"), 5)) if hits else None
+
+
+def quoted(s, n=None):
+    """A test's own words — its title or its failure message — in backticks, so the Remark shows them as
+    quoted and tf-doc-check reads them as quoted: a title saying "Found/Not found" failed the checker's
+    not-present rule on every verify (Lekhak TF-012)."""
+    s = re.sub(r"\s+", " ", (s or "").replace("`", "'").replace("|", "/")).strip()
+    return f"`{s[:n] if n else s}`" if s else ""
+
+
 def words(s, n=60):
     w = s.split()
     return s if len(w) <= n else " ".join(w[:n]) + "…"   # the ellipsis rides on the last word: the checker counts words, and a bare "…" was a 61st (miss 29)
@@ -92,15 +136,25 @@ def main(argv):
     tests_ran = os.path.isfile(os.path.join(d, "tests.json"))
     screens = load(os.path.join(d, "screens.json")) or {}
     scr_by_name = {s["name"]: s for s in screens.get("screens", [])}
+    # screens tf-verify-screens did not drive because their route needs a sample value (Lekhak TF-005)
+    scr_skipped = {s["name"]: s for s in screens.get("skipped", []) or []}
     assets = load(os.path.join(d, "assets.json")) or {}
     pages = {norm_route(p.get("path")): p for p in assets.get("pages", [])}
     parity = load(os.path.join(d, "parity.json")) or {}
-    par_by_name = {s.get("screen"): s for s in parity.get("screens", [])}
-    par_by_route = {norm_route(s.get("route")): s for s in parity.get("screens", [])}
+    comparisons = parity.get("screens", []) or []
+    # the mockup each listed screen is graded against; a row's own *Mockup:* line when its screen has none
+    mock_of = {s.get("name"): s.get("mockup") or "" for s in lst.get("screens", []) or []}
     grade = perf_grader()
 
     booted = boot.get("mode") not in (None, "none")
     build_failed = boot.get("reason_kind") == "build-error"
+    # the packages the Architecture requires are in the code (tf_stack_check.py): a model once replaced the
+    # mandated UI library with plain components and had every row Verified
+    stack = tf_stack_check.check(os.getcwd(), app)
+    if stack["verdict"] == "FAIL":
+        build_failed = True
+        boot = dict(boot, reason=f"the Architecture requires {', '.join(stack['missing'])} and no project file references "
+                    + ("it" if len(stack["missing"]) == 1 else "them") + " (tf-stack-check.sh): add the package, never a workaround")
     boot_text = (f"{boot.get('head')} via {boot.get('rung')} at {boot.get('url')}" if booted
                  else f"not booted: {boot.get('reason')}")
     checks_ran = set()
@@ -114,6 +168,7 @@ def main(argv):
         notes = []
         scr = scr_by_name.get(r.get("screen") or "")
         driven = bool(scr) and scr.get("render") != "UNREACHABLE"
+        nonames = " (names not measured on a Mac)" if scr and scr.get("anchors_not_measured") else ""
         t = tests.get(rid)
         # A row whose every clause was SKIPPED is NOT-TESTED: the acceptance gate did not run on
         # it. It is neither a pass nor a defect, so it grades exactly like a row with no test at
@@ -122,6 +177,21 @@ def main(argv):
         if skipped_only:
             notes.append(f"acceptance not measured ({len(t.get('skipped') or [])} test(s) skipped, none ran)")
             t = None
+        # the OS zoom keys (coding-standards-dotnet.md §9b): a row whose acceptance carries "zoom-check: keys"
+        # or "zoom-check: kept" is graded by tf-verify-zoom.sh --json-out zoom/<REQ>.json, which stands as its
+        # test; a failing zoom outranks a passing test, and "kept" counts only a run made after a restart
+        if r.get("zoom_check"):
+            zf = load(os.path.join(d, "zoom", f"{rid}.json"))
+            if zf is None:
+                notes.append("zoom not measured (no tf-verify-zoom run for this row)")
+            elif r["zoom_check"] == "kept" and not zf.get("kept_checked"):
+                notes.append("zoom kept across a restart not measured (run with --expect-restored after a restart)")
+            else:
+                zfail = [c for c in zf.get("checks", []) if not c.get("ok")]
+                zt = {"result": "FAIL" if zfail else "PASS", "tests": [f"tf-verify-zoom {zf.get('head', '')}".strip()],
+                      "reason": f"zoom: {zfail[0]['text']}" if zfail else "", "screenshot": zf.get("evidence", "")}
+                if not t or (zfail and t.get("result") == "PASS"):
+                    t = zt
         # every check on its own: (name, ran, failed, verdict, class, detail, evidence); the first failure wins
         checks = []
 
@@ -129,7 +199,7 @@ def main(argv):
         checks.append(("build", booted or build_failed, build_failed, "BUILD-FAIL", "build-error", boot.get("reason", "build failed"), ""))
         # 2 acceptance
         if t:
-            checks.append(("acceptance", True, t["result"] != "PASS", "FAIL", "assert-fail", t.get("reason") or "test failed", t.get("screenshot") or ""))
+            checks.append(("acceptance", True, t["result"] != "PASS", "FAIL", "assert-fail", quoted(t.get("reason")) or "test failed", t.get("screenshot") or ""))
         # 3 render
         if scr:
             if scr.get("render") == "UNREACHABLE":
@@ -140,6 +210,10 @@ def main(argv):
                 w, f = bad[0] if bad else (None, None)
                 checks.append(("render", True, bool(bad), "RENDER-FAIL", f["class"] if f else None,
                                f"{f['detail']} on {r['screen']} @{w['width']}" if f else "", w.get("screenshot", "") if w else ""))
+            # a Mac web view head: blank, error bar, overlap and the picture were checked, the
+            # controls by name were not (owner decision A, 2026-10-07): said, never counted as a pass
+            if scr.get("anchors_not_measured") and bad:
+                notes.append(f"control names not measured on {r['screen']} (a Mac web view does not show them)")
         # 4 assets
         pg = pages.get(norm_route(r.get("route"))) if r.get("route") else None
         if pg and pg.get("graded", 0) > 0:
@@ -155,16 +229,40 @@ def main(argv):
             checks.append(("visual", True, bool(bad), "VISUAL-FAIL", f["class"] if f else None,
                            f"{f['detail']} on {r['screen']}" if f else "", w.get("screenshot", "") if w else ""))
         # 6 mockup parity
-        ps = (par_by_name.get(r.get("screen")) or par_by_route.get(norm_route(r.get("route")))) if r.get("screen") else None
+        mockup = mock_of.get(r.get("screen")) or r.get("mockup") or ""
+        ps = parity_for(r, mockup, comparisons) if r.get("screen") else None
+        if not ps and driven and mockup and boot.get("mode") == "appium":
+            # a Mac head: tf-mockup-parity does not run there (verify-phase step 5), so no comparison is
+            # expected, and the row is never failed for its absence; said, not counted as a pass
+            notes.append("mockup not compared on a Mac head (compare it on the web or Windows head)")
+        elif not ps and driven and mockup:
+            # Chatur TF-008: /processes/6/run was compared and FAILed, but the row's route reads
+            # /processes/{id}/run and the comparison was named process-run, so it was never found and
+            # 11 rows were Verified without it. A driven screen that has a mockup and no comparison fails.
+            checks.append(("mockup-parity", True, True, "MOCKUP-FAIL", "other",
+                           f"mockup-parity not found: {r['screen']} ({r.get('route')}) has mockup {mockup} and "
+                           + ("parity.json has no comparison for it" if comparisons else "no mockup comparison ran")
+                           + f"; run tf-mockup-parity.sh --screen {stem(mockup) or 'name'}={r.get('route')} with its value filled in",
+                           os.path.join(d, "parity.json") if comparisons else ""))
         if ps:
             v = ps.get("verdict")
             if v in ("PASS", "FAIL"):
                 f = (ps.get("findings") or [{}])[0]
                 checks.append(("mockup-parity", True, v == "FAIL", "MOCKUP-FAIL", "mockup-drift",
-                               f"{f.get('class', 'drift')} on {f.get('key', ps.get('screen'))} @{f.get('width', '')}: {str(f.get('detail', ''))[:80]}",
+                               f"{f.get('class', 'drift')} on {f.get('key', ps.get('screen'))} @{f.get('width', '')}"
+                               + (f" in {f['theme']} mode" if f.get("theme") else "") + f": {str(f.get('detail', ''))[:80]}",
+                               os.path.join(d, "parity.json")))
+            elif v == "ERROR":
+                checks.append(("mockup-parity", True, True, "MOCKUP-FAIL", "other",
+                               f"mockup-parity could not open {ps.get('route')}: "
+                               + str(next((w.get("error") for w in ps.get("widths", []) if w.get("error")), "every width failed"))[:80],
                                os.path.join(d, "parity.json")))
             elif v == "UNGRADEABLE":
                 notes.append("mockup-parity UNGRADEABLE (add data-testid anchors to the mockup)")
+            nm = (ps.get("coverage") or {}).get("not_measured") or []
+            if nm:   # sample rows the app had no data for (Chatur TF-002)
+                notes.append(f"mockup-parity: {len(nm)} sample box(es) not measured, the app drew no data there "
+                             "(a tests/verify/seed/ script puts it in the drawn state)")
             elif v == "NO-MOCKUP":
                 notes.append("no mockup to compare")
         # 7 speed
@@ -192,42 +290,62 @@ def main(argv):
                 detail = "NFR row with no perf-budget and no unit test carrying its id"
             elif not t and r.get("screen") and not driven:
                 verdict = "NOT-DRIVEN"
+                sk = scr_skipped.get(r["screen"])
                 detail = (f"{boot.get('head', 'the app')} not driven: {boot.get('reason')}" if not booted
+                          else f"screen {r['screen']} was not driven: {sk['reason']}" if sk and sk.get("reason")
+                          else f"screen {r['screen']} was not driven: its route {sk['route']} needs --route-value "
+                               + ", ".join(f"{n}=<id>" for n in sk.get("needs", [])) if sk
                           else f"screen {r['screen']} was not driven in this run")
             elif not t:
                 verdict = "NOT-TESTED"
                 detail = (f"every test named {rid} was skipped" if skipped_only else f"no test named {rid} ran") \
-                    + (f"; screen {r['screen']} renders and looks right" if driven else "")
-            elif r.get("screen") and not driven and not booted:
+                    + (f"; screen {r['screen']} renders and looks right{nonames}" if driven else "")
+            elif r.get("screen") and not driven:
+                # a passing test is not a screen check: a row on a screen that was not driven is never
+                # Verified, booted or not. The Settings rows of /settings/{tab} were (Chatur TF-003).
                 verdict = "NOT-DRIVEN"
-                detail = f"test passed but {boot.get('head', 'the app')} was not driven: {boot.get('reason')}"
+                sk = scr_skipped.get(r["screen"])
+                detail = ("test passed but " + (f"{boot.get('head', 'the app')} was not driven: {boot.get('reason')}" if not booted
+                          else f"screen {r['screen']} was not driven: {sk['reason']}" if sk and sk.get("reason")
+                          else f"screen {r['screen']} was not driven: its route {sk['route']} needs --route-value "
+                               + ", ".join(f"{n}=<id>" for n in sk.get("needs", [])) if sk
+                          else f"screen {r['screen']} was not driven in this run"))
             else:
                 verdict = "PASS"
-                parts = [f"test {t['tests'][0][:60]}" if t and t.get("tests") else "test passed"]
+                parts = [f"test {quoted(t['tests'][0], 60)}" if t and t.get("tests") else "test passed"]
                 if driven:
-                    parts.append(f"{r['screen']} renders and looks right @{'/'.join(str(w['width']) for w in scr['widths'])}")
+                    ws = list(dict.fromkeys(str(w['width']) for w in scr['widths']))
+                    th = list(dict.fromkeys(w['theme'] for w in scr['widths'] if w.get('theme')))
+                    parts.append(f"{r['screen']} renders and looks right @{'/'.join(ws)}" + (f" in {' and '.join(th)} mode" if len(th) > 1 else "") + nonames)
                 if "mockup-parity" in ran:
                     parts.append("matches its mockup")
                 if "perf" in ran:
                     parts.append("within its speed budget")
                 detail = "; ".join(parts)
 
-        status = STATUS.get(verdict, prior)
+        # A defect found by the guide, the owner's testing or production is not in the acceptance line, so
+        # a pass cannot clear it and a rewrite must not erase it (TF-021). tests/regression/run.sh am_021.
+        kept = tf_defect.unseen(r.get("remarks"))
+        if kept and verdict == "PASS":
+            verdict = "DEFECT-OPEN"
+        status = STATUS.get(verdict, "Needs re-verify" if verdict == "DEFECT-OPEN" else prior)
         pct = r.get("pct")
         if verdict == "PASS":
             pct = 100
-        elif verdict in ("RENDER-FAIL", "ASSET-FAIL", "VISUAL-FAIL", "MOCKUP-FAIL", "PERF-FAIL"):
+        elif verdict in ("DEFECT-OPEN", "RENDER-FAIL", "ASSET-FAIL", "VISUAL-FAIL", "MOCKUP-FAIL", "PERF-FAIL"):
             pct = min(pct if pct is not None else 75, 75)
         gate = FAILING.get(verdict)
         marks = {"FAIL": "⚠ acceptance", "BUILD-FAIL": "⚠ build", "RENDER-FAIL": "⚠ render", "ASSET-FAIL": "⚠ assets",
                  "VISUAL-FAIL": "⚠ visual", "MOCKUP-FAIL": "⚠ mockup-parity", "PERF-FAIL": "⚠ perf",
-                 "NOT-TESTED": "not verified", "NOT-OBSERVABLE": "not observable", "NOT-DRIVEN": "not verified", "PASS": "PASS"}
+                 "NOT-TESTED": "not verified", "NOT-OBSERVABLE": "not observable", "NOT-DRIVEN": "not verified", "PASS": "PASS",
+                 "DEFECT-OPEN": "checks pass, defect open"}
         remark = f"{today} verify: {marks[verdict]} — {detail}"
         if evidence:
             remark += f" ({evidence})"
         if notes:
             remark += "; " + "; ".join(notes[:2])
-        remark = words(remark.replace("|", "/"), 60)
+        carried = words(" ".join(kept).replace("|", "/"), 30) if kept else ""
+        remark = words(remark.replace("|", "/"), 60 - len(carried.split())) + (f" {carried}" if carried else "")
         emit = verdict == "PASS" or gate is not None
         row = {"id": rid, "class": r["class"], "verdict": verdict, "gate": gate, "gates_run": ran, "failure_class": cls if gate else None,
                "prior_verdict": prior or None, "status": status, "pct": pct, "remark": remark, "screen": r.get("screen"),
@@ -240,13 +358,37 @@ def main(argv):
     for c in ("build", "acceptance", "render", "assets", "visual", "mockup-parity", "perf"):
         if any(c in x["gates_run"] for x in rows_out):
             checks.append(c)
-    ledger = {"date": today, "app": app, "scope": lst.get("scope", "all"), "booted": boot_text, "gates": checks,
-              "evidence": d, "run_id": started, "rows": ledger_rows}
+    # Lekhak TF-007: a targeted verify rewrote the ledger with its own rows only (395 became 1), so every
+    # other row lost its last verdict. The ledger is kept row by row: a row this run graded is replaced,
+    # with the date and run it was graded in; the rest keep theirs. A scope-all run starts it afresh.
+    # The verify guard unlocks a Verified only for a row graded today, and fix-close reads only the rows
+    # graded since its fix began, by these dates.
+    # Sevak TF-005: every row carries the phase whose checklist it was graded in, and a scope-all run
+    # starts afresh only for its own phase. Phase 2's run used to wipe phase 1's verdicts. A row from an
+    # older ledger that names no phase is kept.
+    phase = lst.get("phase") or 1
+    all_rows, row_dates, row_runs = dict(ledger_rows), {k: today for k in ledger_rows}, {k: started for k in ledger_rows}
+    row_phases = {k: phase for k in ledger_rows}
+    prev = load(os.path.join("docs", ".last-verify.json")) if os.path.isfile(os.path.join("docs", ".last-verify.json")) else None
+    if isinstance(prev, dict) and prev.get("app") in (None, app) \
+            and isinstance(prev.get("rows"), dict) and prev.get("mode") != "reconcile":
+        for k, v in prev["rows"].items():
+            was = (prev.get("row_phases") or {}).get(k, prev.get("phase"))
+            if k not in all_rows and (lst.get("scope", "all") != "all" or was != phase):
+                all_rows[k] = v
+                row_dates[k] = (prev.get("row_dates") or {}).get(k, prev.get("date", ""))
+                row_runs[k] = (prev.get("row_runs") or {}).get(k, prev.get("run_id", ""))
+                if was is not None:
+                    row_phases[k] = was
+    ledger = {"date": today, "app": app, "scope": lst.get("scope", "all"), "phase": phase, "checklist": lst.get("checklist"),
+              "booted": boot_text, "gates": checks,
+              "evidence": d, "run_id": started, "rows": all_rows, "row_dates": row_dates, "row_runs": row_runs,
+              "row_phases": row_phases, "this_run": sorted(ledger_rows)}
     os.makedirs("docs", exist_ok=True)
     with open(os.path.join("docs", ".last-verify.json"), "w", encoding="utf-8") as f:
         json.dump(ledger, f, indent=1)
     with open(os.path.join(d, "verdicts.json"), "w", encoding="utf-8") as f:
-        json.dump({"app": app, "scope": lst.get("scope", "all"), "date": today, "started": started, "booted": boot_text,
+        json.dump({"app": app, "scope": lst.get("scope", "all"), "phase": phase, "date": today, "started": started, "booted": boot_text,
                    "build_result": "fail" if build_failed else ("pass" if booted else "not-run"), "checks": checks,
                    "checklist": lst.get("checklist"), "rows": rows_out}, f, indent=1)
 
@@ -275,7 +417,7 @@ def main(argv):
     counts = {}
     for x in rows_out:
         counts[x["verdict"]] = counts.get(x["verdict"], 0) + 1
-    print(f"# tf-verify-verdict — {app} — scope {lst.get('scope')} — booted: {boot_text}")
+    print(f"# tf-verify-verdict — {app} — phase {phase} ({lst.get('checklist')}) — scope {lst.get('scope')} — booted: {boot_text}")
     print(f"Checks that ran: {', '.join(checks) or 'none'}. Rows: " + ", ".join(f"{v} {k}" for k, v in sorted(counts.items())))
     print()
     print("| ID | Verdict | First failing check | Status | Detail |")
@@ -283,7 +425,7 @@ def main(argv):
     for t in table:
         print("| " + " | ".join(str(x).replace("|", "/") for x in t) + " |")
     print()
-    print(f"Ledger: docs/.last-verify.json ({len(ledger_rows)} rows). Verdicts: {os.path.join(d, 'verdicts.json')}."
+    print(f"Ledger: docs/.last-verify.json ({len(ledger_rows)} rows graded now, {len(all_rows)} in all). Verdicts: {os.path.join(d, 'verdicts.json')}."
           + (f" Checklist: {applied} row(s) rewritten in {lst.get('checklist')}." if apply else " Checklist untouched (no --apply)."))
     return 0
 

package/.tfcore/utils/tf-verify-zoom.mjs

@@ -0,0 +1,193 @@
+// tf-verify-zoom.mjs — presses the OS zoom keys on a Blazor Hybrid head and measures what they did
+// (coding-standards-dotnet.md §9b; Lekhak, 2026-10-11). Called by tf-verify-zoom.sh; see there.
+//
+// Mac (--appium): mac2 presses Cmd+= / Cmd+- / Cmd+0 as real keys, so they go through the menu bar the
+// way a person's do; macOS takes the window alone after each. The accessibility tree does not follow a
+// WKWebView's page zoom (its text heights stayed 13 px at 130% on BlogAdmin), so the level is measured
+// from the pictures: the scale that best maps the actual-size picture onto the zoomed one, from the
+// first row where the two differ (the web view's top edge; the title bar above it does not zoom).
+// Windows and any Chromium web view (--cdp): Playwright presses Ctrl+= / Ctrl+- / Ctrl+0 in the page
+// and reads the zoom it paints at (CSS zoom on <html> times the device pixel ratio).
+
+import { execFileSync } from 'node:child_process';
+import { mkdirSync, readFileSync, writeFileSync, existsSync } from 'node:fs';
+import { inflateSync } from 'node:zlib';
+import { join } from 'node:path';
+
+const args = process.argv.slice(2);
+const opt = (k, d = '') => { const i = args.indexOf(k); return i >= 0 && i + 1 < args.length ? args[i + 1] : d; };
+const flag = (k) => args.includes(k);
+const OUT = opt('--out', 'tests/.artifacts/verify/zoom');
+const LEAVE = parseInt(opt('--leave', '0'), 10) || 0;
+const STEPS = [
+  // what is pressed, how often, the level expected afterwards (1.0 = actual size)
+  { key: 'reset', n: 1, want: 1.0, say: 'actual size' },
+  { key: 'in', n: 3, want: 1.3, say: 'zoom in 3 times' },
+  { key: 'out', n: 1, want: 1.2, say: 'zoom out once' },
+  { key: 'reset', n: 1, want: 1.0, say: 'actual size again' },
+];
+const TOL = 0.05;
+
+// ---- PNG, 8-bit RGB or RGBA, not interlaced: what screencapture and sips write -------------------
+export function decodePng(buf) {
+  let p = 8, w = 0, h = 0, ct = 0; const idat = [];
+  while (p < buf.length) {
+    const len = buf.readUInt32BE(p); const type = buf.toString('latin1', p + 4, p + 8);
+    const data = buf.subarray(p + 8, p + 8 + len);
+    if (type === 'IHDR') { w = data.readUInt32BE(0); h = data.readUInt32BE(4); ct = data[9]; if (data[8] !== 8 || data[12]) throw new Error('only 8-bit, non-interlaced PNG'); }
+    if (type === 'IDAT') idat.push(data);
+    if (type === 'IEND') break;
+    p += 12 + len;
+  }
+  const bpp = ct === 6 ? 4 : ct === 2 ? 3 : ct === 0 ? 1 : ct === 4 ? 2 : 0;
+  if (!bpp) throw new Error(`PNG colour type ${ct} not read`);
+  const raw = inflateSync(Buffer.concat(idat)); const stride = w * bpp;
+  const px = Buffer.alloc(h * stride); const gray = new Float32Array(w * h);
+  for (let y = 0; y < h; y++) {
+    const f = raw[y * (stride + 1)]; const src = y * (stride + 1) + 1; const row = y * stride;
+    for (let x = 0; x < stride; x++) {
+      const a = x >= bpp ? px[row + x - bpp] : 0; const b = y ? px[row - stride + x] : 0; const c = x >= bpp && y ? px[row - stride + x - bpp] : 0;
+      let v = raw[src + x];
+      if (f === 1) v += a; else if (f === 2) v += b; else if (f === 3) v += (a + b) >> 1;
+      else if (f === 4) { const pp = a + b - c; const pa = Math.abs(pp - a), pb = Math.abs(pp - b), pc = Math.abs(pp - c); v += pa <= pb && pa <= pc ? a : pb <= pc ? b : c; }
+      px[row + x] = v & 255;
+    }
+    for (let x = 0; x < w; x++) { const o = row + x * bpp; gray[y * w + x] = bpp >= 3 ? 0.299 * px[o] + 0.587 * px[o + 1] + 0.114 * px[o + 2] : px[o]; }
+  }
+  return { w, h, gray };
+}
+
+// a picture shrunk to 640 px wide by sips (macOS), so the search stays quick
+function load(file) {
+  const small = file.replace(/\.png$/, '.small.png');
+  try { execFileSync('sips', ['-Z', '1000', file, '--out', small], { stdio: 'ignore' }); } catch { /* not macOS: read it whole */ }
+  return decodePng(readFileSync(existsSync(small) ? small : file));
+}
+
+// The page zoom that turns picture `base` (actual size) into picture `zoomed`. Page zoom scales every
+// horizontal position from the web view's left edge, but not always vertical ones: a header or sidebar
+// sized to the window height keeps its height (BlogAdmin's did), so a 2-D match read 121% for 130%.
+// So the two pictures are compared across the window only: for each column, how much vertical edge
+// (a border, a box side, the strokes of text) it holds below the title bar, and the scale that best
+// lines the actual-size profile up with the zoomed one. The title bar is the rows the two share.
+export function scaleBetween(zoomed, base) {
+  const { w, h } = base; if (zoomed.w !== w || zoomed.h !== h) return { scale: 0, why: 'the two pictures differ in size' };
+  let top = 0;
+  for (; top < h; top++) { let d = 0; for (let x = 0; x < w; x++) d += Math.abs(zoomed.gray[top * w + x] - base.gray[top * w + x]); if (d / w > 2) break; }
+  if (top >= h - 10) return { scale: 1, top, why: 'the pictures are the same' };
+  const profile = (img) => {
+    const p = new Float64Array(w);
+    for (let y = top; y < h; y++) for (let x = 0; x + 1 < w; x++) p[x] += Math.abs(img.gray[y * w + x + 1] - img.gray[y * w + x]);
+    return p;
+  };
+  const pz = profile(zoomed), pb = profile(base);
+  let best = { scale: 0, r: -2 };
+  for (let s = 0.5; s <= 3.0001; s += 0.01) {
+    let n = 0, sa = 0, sb = 0, saa = 0, sbb = 0, sab = 0;
+    for (let x = 0; x < w; x++) {
+      const bx = x / s; const i = Math.floor(bx); if (i + 1 >= w) break;
+      const a = pz[x], b = pb[i] + (pb[i + 1] - pb[i]) * (bx - i);
+      n++; sa += a; sb += b; saa += a * a; sbb += b * b; sab += a * b;
+    }
+    if (n < w / 4) continue;
+    const r = (sab - (sa * sb) / n) / Math.sqrt(Math.max(1e-9, (saa - (sa * sa) / n) * (sbb - (sb * sb) / n)));
+    if (r > best.r) best = { scale: Math.round(s * 100) / 100, r };
+  }
+  return { scale: best.scale, top };
+}
+
+const RESULT = { checks: [], kept_checked: false, head: '', evidence: '' };
+const line = (ok, text) => { console.log(`${ok ? 'OK  ' : 'FAIL'} ${text}`); RESULT.checks.push({ ok, text }); return ok; };
+
+async function mac() {
+  const { openSession, parseSource, appPid, windowShot } = await import('./tf-appium.mjs');
+  let boot = {}; try { boot = JSON.parse(readFileSync('tests/.artifacts/verify/boot.json', 'utf8')); } catch { /* flags only */ }
+  const appPath = opt('--app', boot.app_path || ''); const bundleId = opt('--bundle', boot.bundle || '');
+  let s;
+  try { s = await openSession(opt('--appium'), { bundleId, appPath }); }
+  catch (e) { line(false, `no session on the app at ${opt('--appium')}: ${e.message} (boot it with bash .tfcore/utils/tf-verify-boot.sh start --head maccatalyst)`); return 2; }
+  const pid = appPid(appPath);
+  let ok = true; let k = 0;
+  const shot = (name, same = false) => { const f = join(OUT, `${String(same ? k : k++).padStart(2, '0')}-${name}-mac.png`); return windowShot(pid, f) ? f : ''; };
+  const press = async (key) => {
+    await s.call('POST', '/execute/sync', { script: 'macos: keys', args: [{ keys: [{ key: { in: '=', out: '-', reset: '0' }[key], modifierFlags: 1 << 4 }] }] });
+    await new Promise((r) => setTimeout(r, 700));
+  };
+  // the View menu names the three commands
+  const nodes = parseSource(await s.source());
+  const view = nodes.find((n) => n.type === 'MenuBarItem' && /^view$/i.test(n.title || n.label));
+  const items = []; if (view) { const todo = [...view.kids]; while (todo.length) { const n = nodes[todo.shift()]; if (n.type === 'MenuItem') items.push(n.title || n.label); todo.push(...n.kids); } }
+  const missing = ['Zoom In', 'Zoom Out', 'Actual Size'].filter((t) => !items.includes(t));
+  ok = line(!missing.length, missing.length ? `the View menu has no ${missing.join(', ')} (it has: ${items.filter(Boolean).join(', ') || 'no View menu'})` : 'View › Zoom In, Zoom Out, Actual Size are in the menu bar') && ok;
+  // A mac2 session starts the app again: wait for a drawn page that holds still for two pictures
+  // (the first ones on BlogAdmin were the bare window while Blazor started)
+  const ink = (f) => { const g = load(f); let e = 0; for (let i = 1; i < g.gray.length; i++) e += Math.abs(g.gray[i] - g.gray[i - 1]); return e / g.gray.length; };
+  let opened = ''; let last = -1;
+  for (let t = Date.now(); Date.now() - t < 60000;) {
+    const f = shot('as-opened', true); const e = f ? ink(f) : 0;   // a bare window reads 0.04, a drawn page 0.96
+    if (e > 0.2 && last > 0 && Math.abs(e - last) / last < 0.02) { opened = f; break; }
+    last = e; await new Promise((r) => setTimeout(r, 1500));
+  }
+  k++;
+  if (!opened) { await s.close(); line(false, 'the app showed no drawn page within 60 s'); return 2; }
+  await press('reset'); const actual = shot('actual-size');
+  if (!opened || !actual) { await s.close(); return line(false, 'could not take the window (the terminal needs Screen Recording)') ? 0 : 5; }
+  RESULT.head = 'maccatalyst'; RESULT.evidence = actual;
+  const base = load(actual);
+  const restored = scaleBetween(load(opened), base).scale;
+  console.log(`INFO opened at ${Math.round(restored * 100)}% (the level the last run left; run again after a restart with --leave 3 before it to check the level is kept)`);
+  if (flag('--expect-restored')) RESULT.kept_checked = true;
+  if (flag('--expect-restored')) ok = line(Math.abs(restored - parseFloat(opt('--expect-restored'))) <= TOL, `opened at ${Math.round(restored * 100)}%, expected ${Math.round(parseFloat(opt('--expect-restored')) * 100)}% from the last run`) && ok;
+  for (const st of STEPS.slice(1)) {
+    for (let i = 0; i < st.n; i++) await press(st.key);
+    const f = shot(st.key); const got = f ? scaleBetween(load(f), base).scale : 0;
+    ok = line(Math.abs(got - st.want) <= TOL, `${st.say} (Cmd+${{ in: '=', out: '-', reset: '0' }[st.key]}): ${Math.round(got * 100)}%, expected ${Math.round(st.want * 100)}%`) && ok;
+  }
+  for (let i = 0; i < LEAVE; i++) await press('in');
+  if (LEAVE) console.log(`INFO left at ${100 + LEAVE * 10}% for the restart check`);
+  await s.close();
+  return ok ? 0 : 5;
+}
+
+async function cdp() {
+  const { chromium } = await import('playwright');
+  let browser;
+  try { browser = await chromium.connectOverCDP(opt('--cdp')); }
+  catch (e) { line(false, `nothing answers at ${opt('--cdp')}: ${e.message.split('\n')[0]}`); return 2; }
+  const page = browser.contexts().flatMap((c) => c.pages()).find((p) => !p.url().startsWith('devtools:')) || null;
+  if (!page) { line(false, 'no page to drive at ' + opt('--cdp')); return 2; }
+  const level = () => page.evaluate(() => (parseFloat(getComputedStyle(document.documentElement).zoom) || 1) * window.devicePixelRatio);
+  let ok = true; let k = 0;
+  const press = async (key) => { await page.keyboard.press({ in: 'Control+Equal', out: 'Control+Minus', reset: 'Control+Digit0' }[key]); await page.waitForTimeout(400); };
+  RESULT.head = 'cdp';
+  const opened = await level(); await press('reset'); const base = await level();
+  console.log(`INFO opened at ${Math.round((opened / base) * 100)}% (the level the last run left)`);
+  if (flag('--expect-restored')) RESULT.kept_checked = true;
+  if (flag('--expect-restored')) ok = line(Math.abs(opened / base - parseFloat(opt('--expect-restored'))) <= TOL, `opened at ${Math.round((opened / base) * 100)}%, expected ${Math.round(parseFloat(opt('--expect-restored')) * 100)}%`) && ok;
+  for (const st of STEPS.slice(1)) {
+    for (let i = 0; i < st.n; i++) await press(st.key);
+    await page.screenshot({ path: join(OUT, `${String(k++).padStart(2, '0')}-${st.key}-cdp.png`) }).catch(() => {});
+    const got = (await level()) / base;
+    ok = line(Math.abs(got - st.want) <= TOL, `${st.say} (Ctrl+${{ in: '=', out: '-', reset: '0' }[st.key]}): ${Math.round(got * 100)}%, expected ${Math.round(st.want * 100)}%`) && ok;
+  }
+  // Ctrl+wheel up is one step in
+  await page.mouse.move(200, 200); await page.keyboard.down('Control'); await page.mouse.wheel(0, -100); await page.keyboard.up('Control'); await page.waitForTimeout(400);
+  const wheel = (await level()) / base;
+  ok = line(Math.abs(wheel - 1.1) <= TOL, `Ctrl+wheel up: ${Math.round(wheel * 100)}%, expected 110%`) && ok;
+  await press('reset');
+  for (let i = 0; i < LEAVE; i++) await press('in');
+  if (LEAVE) console.log(`INFO left at ${100 + LEAVE * 10}% for the restart check`);
+  await browser.close().catch(() => {});
+  return ok ? 0 : 5;
+}
+
+if (process.argv[1] && process.argv[1].endsWith('tf-verify-zoom.mjs')) {
+  if (flag('--scale')) {           // tf-verify-zoom.mjs --scale <zoomed.png> <actual.png>: the measure alone
+    console.log(scaleBetween(load(args[args.indexOf('--scale') + 1]), load(args[args.indexOf('--scale') + 2])).scale);
+    process.exit(0);
+  }
+  mkdirSync(OUT, { recursive: true });
+  const rc = flag('--appium') ? await mac() : flag('--cdp') ? await cdp() : (console.error('tf-verify-zoom: --appium <url> or --cdp <url>'), 3);
+  if (opt('--json-out')) writeFileSync(opt('--json-out'), JSON.stringify({ ...RESULT, verdict: rc === 0 ? 'PASS' : 'FAIL' }, null, 1));
+  process.exit(rc);
+}

package/.tfcore/utils/tf-verify-zoom.sh

@@ -0,0 +1,29 @@
+#!/usr/bin/env bash
+# tf-verify-zoom.sh — presses the OS zoom keys on a booted Blazor Hybrid head and says what they did
+# (coding-standards-dotnet.md §9b; Lekhak, 2026-10-11).
+#
+#   bash .tfcore/utils/tf-verify-zoom.sh --appium http://localhost:4723 [--leave 3] [--expect-restored 1.3]
+#        a Mac Catalyst head booted by tf-verify-boot.sh (its .app and bundle come from boot.json)
+#   bash .tfcore/utils/tf-verify-zoom.sh --cdp <the boot url> [--leave 3] [--expect-restored 1.3]
+#        a Windows (WebView2) head, or any Chromium web view, over its debugging address
+#
+# Checks, in order: (Mac) View › Zoom In, Zoom Out and Actual Size are in the menu bar; the level the
+# app opened at is printed, then Cmd/Ctrl+0 is actual size; zoom in 3 times reads 130%, zoom out once
+# 120%, actual size 100%; (Windows) Ctrl+wheel up reads 110%. The kept level across a restart is two
+# runs: the first with --leave 3 (it ends at 130%), then stop and start the head, then the second with
+# --expect-restored 1.3. Pictures go to tests/.artifacts/verify/zoom/. The Mac level is measured from
+# the window's pictures, because a WKWebView's accessibility tree does not follow its page zoom.
+# Exit 0 every check passed · 5 one failed · 2 nothing to drive · 3 usage · 4 Playwright missing (--cdp).
+set -uo pipefail
+HERE="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+case "${1:-}" in
+  -h|--help) sed -n '2,19p' "$0" | sed 's/^# \{0,1\}//'; exit 0 ;;
+  "")        sed -n '2,19p' "$0" | sed 's/^# \{0,1\}//'; exit 3 ;;
+esac
+command -v node >/dev/null 2>&1 || { echo "tf-verify-zoom: node is required (bash .tfcore/utils/tf-verify-env.sh)" >&2; exit 4; }
+case " $* " in *" --cdp "*)
+  node -e "import('playwright').then(()=>process.exit(0)).catch(()=>process.exit(1))" 2>/dev/null || {
+    echo "tf-verify-zoom: the 'playwright' package is not resolvable from this folder; run bash .tfcore/utils/tf-verify-env.sh" >&2; exit 4; } ;;
+esac
+source "$HERE/tf-lock.sh"; tf_take_lock verify-screens   # one check drives the app at a time
+node "$HERE/tf-verify-zoom.mjs" "$@"