@@ -134,6 +134,7 @@ def size_frame(page,width):
     # viewport is resized; its content uses the requested responsive media queries.
     element=page.locator('iframe[name="editor-canvas"]')
     element.wait_for(state='visible',timeout=60000)
+    grown=False
     for _ in range(8):
         element.evaluate('(e,w)=>{e.style.setProperty("width",w+"px","important");e.style.setProperty("height","900px","important");e.style.setProperty("max-width","none","important")}',width)
         frame=element.element_handle().content_frame()
@@ -143,7 +144,18 @@ def size_frame(page,width):
         if actual=={'width':width,'height':900}:
             # Every row of the canvas viewport must reach the screenshot.
             clip=element.evaluate(CLIP)
-            if clip['visibleTop']>clip['top']+.5 or clip['visibleBottom']<clip['bottom']-.5:
+            short=clip['bottom']-clip['visibleBottom']
+            # The region holding the canvas is the admin window less its chrome
+            # (WordPress 7.1 keeps its 32px toolbar in fullscreen mode and has a
+            # taller footer: 891px for the 900px canvas). A region short at the
+            # bottom only gets a window that much taller, once; the canvas's own
+            # viewport is unchanged. Clipped again, or from above, it fails.
+            if not grown and short>.5 and clip['visibleTop']<=clip['top']+.5:
+                grown=True
+                view=page.viewport_size
+                page.set_viewport_size({'width':view['width'],'height':view['height']+math.ceil(short)})
+                continue
+            if clip['visibleTop']>clip['top']+.5 or short>.5:
                 raise RuntimeError(f'Editor canvas is clipped by the administration layout: {clip}')
             return frame
     raise RuntimeError(f'Editor iframe viewport differs: {actual}, expected {width}x900')
@@ -168,11 +180,13 @@ def size_frame(page,width):
 
 # The administration chrome around the canvas keeps its layout space but is
 # not painted: the admin toolbar's shadow extends one pixel over a mobile
-# iframe's edge. The post editor's meta box pane takes none: with it, the
-# region holding the canvas was 899px tall and clipped the 900px iframe's
-# last row, which every scroll tile ended on (the pane's border, then the
-# admin's white: a seam every 450px down a tall capture).
-ADMIN_CHROME='.interface-interface-skeleton__header,.interface-interface-skeleton__footer{visibility:hidden!important}.edit-post-meta-boxes-main{display:none!important}'
+# iframe's edge. Nor is WordPress's admin bar, which 7.1 keeps in fullscreen
+# mode: the capture's pointer, parked at 0,0, opened its WordPress menu over
+# the canvas; hidden, it takes no hover. The post editor's meta box pane
+# takes no space: with it, the region holding the canvas was 899px tall and
+# clipped the 900px iframe's last row, which every scroll tile ended on (the
+# pane's border, then the admin's white: a seam every 450px down a tall capture).
+ADMIN_CHROME='#wpadminbar,.interface-interface-skeleton__header,.interface-interface-skeleton__footer{visibility:hidden!important}.edit-post-meta-boxes-main{display:none!important}'
 # The canvas iframe's box against everything that clips it (the admin
 # window and every ancestor with overflow): what a tile can capture.
 CLIP='''e=>{const r=e.getBoundingClientRect();let top=Math.max(0,r.top),bottom=Math.min(innerHeight,r.bottom);
 
@@ -245,6 +245,8 @@ def test_smoke_captures_1440_only_and_full_all_three(self):
         self.assertEqual(shots, ['1440-about-source.png', '1440-about-wp.png', '1440-home-source.png', '1440-home-wp.png', 'captures.json'])
         # Not evidence: no import, no editor. The phase itself is what ran.
         self.assertFalse(report['passed'])
+        # Never signed in to wp-admin: the WordPress version is recorded as unknown.
+        self.assertEqual(report['wordpress'], {'version': None})
         report, _ = self.verify()
         self.assertEqual(report['scope'], 'full')
         self.assertEqual(sorted((r['path'], r['width']) for r in report['visual']),
@@ -310,5 +312,31 @@ def test_workers_must_be_positive(self):
         self.assertIn('--workers', run.stderr)
 
 
+class WordPressVersionTest(unittest.TestCase):
+    """The report records the WordPress version the admin screen names
+    (its `version-7-1-2` body class), and null when it cannot tell."""
+
+    def test_the_admin_body_class_names_the_version(self):
+        from playwright.sync_api import sync_playwright
+        spec = importlib.util.spec_from_file_location('h2wp_verify_under_test', VERIFY)
+        verify = importlib.util.module_from_spec(spec)
+        spec.loader.exec_module(verify)
+        with sync_playwright() as pw:
+            browser = pw.chromium.launch()
+            page = browser.new_page()
+            for body, version in (('wp-admin wp-core-ui js is-fullscreen-mode branch-7-1 version-7-1-2 admin-color-modern', '7.1.2'),
+                                  ('wp-admin branch-7 version-7-0-2 locale-en-us', '7.0.2'),
+                                  ('wp-admin version-7-2', '7.2'),
+                                  ('wp-admin my-version-7-1-2 version-x', None), ('', None)):
+                page.set_content(f'<body class="{body}"></body>')
+                self.assertEqual(verify.wordpress_version(page), version, body)
+            browser.close()
+
+        class Gone:
+            def wait_for_load_state(self, *a):
+                raise RuntimeError('Target page, context or browser has been closed')
+        self.assertIsNone(verify.wordpress_version(Gone()))
+
+
 if __name__ == '__main__':
     unittest.main()
@@ -188,12 +188,30 @@ def new_page_gate(page,args,nonce):
     return result
 
 
+# Every wp-admin screen's body carries the WordPress version it runs
+# (`version-7-1-2`, admin-header.php); the report records it.
+ADMIN_VERSION=re.compile(r'(?:^|\s)version-(\d+(?:-\d+)*)(?=\s|$)')
+
+
+def wordpress_version(page):
+    """The WordPress version of the admin screen `page` shows ('7.1.2'), or
+    None when it cannot be read: the version is recorded, never checked."""
+    try:
+        page.wait_for_load_state('domcontentloaded')
+        found = ADMIN_VERSION.search(page.evaluate('document.body ? document.body.className : ""') or '')
+        return found.group(1).replace('-', '.') if found else None
+    except Exception:
+        return None
+
+
 def sign_in(page, args):
-    """Log `page` in to wp-admin; returns the REST nonce of that session."""
+    """Log `page` in to wp-admin; returns the REST nonce of that session and
+    notes the WordPress version it signed in to (args.wordpress_version)."""
     page.goto(args.site + '/wp-login.php')
     fill_login(page, args.user, args.password)  # read back and retried: lib/capture_ready.py
     page.locator('#wp-submit').click()
     page.wait_for_url('**/wp-admin/**')
+    args.wordpress_version = wordpress_version(page)
     return page.request.get(args.site + '/wp-admin/admin-ajax.php?action=rest-nonce').text().strip()
 
 
@@ -701,6 +719,8 @@ def visual_phase():
     except Exception as error:
         report['passed']=False
         report['error']=str(error)
+    # The WordPress the gate measured (null: never signed in, or unreadable).
+    report['wordpress']={'version':getattr(args,'wordpress_version',None)}
     Path(args.out).parent.mkdir(parents=True,exist_ok=True)
     Path(args.out).write_text(json.dumps(report,indent=2))
     print(json.dumps({k:v for k,v in report.items() if k not in ('editor','visual','editorVisual','import')}))