@@ -828,7 +828,8 @@
         "lock": "lock",
         "metadata": "metadata",
         "className": "string",
-        "anchor": "string"
+        "anchor": "string",
+        "h2wpSettledFrame": "x:settledFrame"
       },
       "children": false
     },
@@ -1443,6 +1444,9 @@
         "youtube"
       ]
     },
+    "x:settledFrame": {
+      "check": "x:settledFrame"
+    },
     "x:slug": {
       "check": "x:slug"
     },
 
@@ -1245,6 +1245,11 @@ def av_block(self, node):
             attrs['playsInline'] = 'playsinline' in node.attrs
             if node.attrs.get('poster'):
                 attrs['poster'] = self.media_url(node.attrs['poster'])
+            # WordPress wraps the <video> in a figure the source never had: the
+            # source classes move back to the <video> and the figure takes no
+            # box (render_block_core/video), so a source script's
+            # `.scroll-video` finds the player, not its figure.
+            attrs['className'] = (attrs.get('className', '') + ' h2wp-source-video').strip()
         elif 'controls' not in node.attrs:
             self.finding('media-controls', 'core/audio always renders controls')
         if node.attrs.get('preload') in ('auto', 'metadata', 'none'):
@@ -3931,7 +3936,10 @@ def flash_scan(dist, script, kind):
 
 # The editor canvas runs no source script, so content a listed script reveals
 # (a scroll-in fade) stays in its hidden state there. Flash writes the settled
-# state of those reveals to a canvas-only sheet (contract.editorStyles).
+# state of those reveals to a canvas-only sheet (contract.editorStyles). It
+# declares no video's settled frame (core/video h2wpSettledFrame, a value a
+# review measures on the frontend): a video a listed script leaves on a frame
+# keeps its poster in the canvas, a Flash limitation.
 FLASH_SETTLED = 'assets/gutenberg-flash-settled.css'
 REVEAL_PROPERTIES = ('opacity', 'visibility', 'transform', 'translate', 'scale', 'rotate', 'filter', 'clip-path')
 CLASS_ADDED = re.compile(r'classList\.add\(([^)]*)\)|\.addClass\(\s*[\'"`]([^\'"`]*)[\'"`]')
 
@@ -1095,7 +1095,7 @@ def test_media_and_table_mappings(self):
             '<iframe class="yt" src="https://www.youtube.com/embed/dQw4w9WgXcQ?rel=0" width="640" height="480"></iframe>'
             '<iframe src="https://player.vimeo.com/video/12345"></iframe>'
             '<iframe src="https://maps.example.com/embed"></iframe>'
-            '<video autoplay muted loop playsinline poster="/assets/a.jpg"><source src="/assets/clip.mp4" type="video/mp4"></video>'
+            '<video class="clip" autoplay muted loop playsinline poster="/assets/a.jpg"><source src="/assets/clip.mp4" type="video/mp4"></video>'
             '<table class="t"><caption>Rates</caption><thead><tr><th scope="col">Plan</th><th>Price</th></tr></thead>'
             '<tbody><tr><td>Single</td><td colspan="2"><strong>$80</strong></td></tr></tbody></table>'
             '<table><tr><td><div>block</div></td></tr></table>'
@@ -1106,6 +1106,7 @@ def test_media_and_table_mappings(self):
         self.assertEqual((vimeo['attributes']['url'], vimeo['attributes']['providerNameSlug']), ('https://vimeo.com/12345', 'vimeo'))
         self.assertEqual(video['name'], 'core/video')
         self.assertEqual({k: video['attributes'][k] for k in ('src', 'poster', 'autoplay', 'muted', 'loop', 'playsInline', 'controls')}, {'src': 'asset:assets/clip.mp4', 'poster': 'asset:assets/a.jpg', 'autoplay': True, 'muted': True, 'loop': True, 'playsInline': True, 'controls': False})
+        self.assertEqual(video['attributes']['className'], 'clip h2wp-source-video')  # the source classes go back on the <video>
         self.assertEqual(table['name'], 'core/table')
         self.assertEqual(table['attributes']['caption'], 'Rates')
         self.assertEqual(table['attributes']['head'], [{'cells': [{'content': 'Plan', 'tag': 'th', 'scope': 'col'}, {'content': 'Price', 'tag': 'th'}]}])
 
@@ -542,6 +542,14 @@ def _x_focalPoint(self, value, at, kind):
             if not _number(v) or not (0 <= v <= 1):
                 _raise(f'{at}: focalPoint.{k} must be 0-1')
 
+    def _x_settledFrame(self, value, at, kind):
+        if not isinstance(value, dict) or ','.join(sorted(_keys(value))) != 'from,seconds':
+            _raise(f'{at}: settledFrame must be {{from,seconds}}')
+        if value['from'] not in ('start', 'end'):
+            _raise(f'{at}: settledFrame.from must be start or end')
+        if not _number(value['seconds']) or not (0 <= value['seconds'] <= 86400):
+            _raise(f'{at}: settledFrame.seconds must be 0-86400')
+
     def _x_tableRows(self, value, at, kind):
         if not isinstance(value, list) or len(value) > 1000:
             _raise(f'{at}: expected table rows')
 
@@ -220,6 +220,12 @@ reveal properties are written with the class taken as present
 element of the source markup. A reveal gated on a script's own class
 (`.js .reveal`) needs none: the canvas never has the gate. Whether an
 only-added class is the settled state is the scan's guess, not a review.
+Flash declares no video's settled frame (`core/video`
+`attributes.h2wpSettledFrame`, a value a review measures on the frontend,
+`references/repair.md` §6): a video a listed script leaves on a frame (a
+scroll video's last frame under reduced motion) keeps its poster in the
+canvas, and the page's editor rows show that box. That is a Flash limitation,
+not a converter gap.
 The summary's `revealsUnsettled` names what may stay hidden on the live site:
 per hidden selector a page renders (its markup, plus the classes the scripts
 it runs add), the reveal class none of those scripts adds or toggles, the
 
@@ -112,6 +112,7 @@ merely moved is only the symptom.
 |---|---|---|
 | a class missing in WP (`.in`, `.is-visible`, `spa-in`), opacity 0 / translateY left | a source script that runs in the original never runs in WordPress | §6, the reveal incidents |
 | the editor only (the page's frontend rows green): a rule matches on the frontend that the editor draws otherwise, with the same classes in the source | a listed script wraps or re-parents text (a `spring-scale`, split-text or per-letter wrapper), and a rule such as `.strip span` matches that wrapper. The editor runs no script, so it never gets the wrapper | the script's DOM writes (`createElement`, `innerHTML`, `.wrap`). Lever: `contract.editorStyles` with the settled values (§6, the script-wrapped text incident). Stop (§5) if the page's frontend row is red too, or the box is one the runtime owns |
+| the editor only (the page's frontend rows green): a video box, the poster in the editor and another frame of the video on the frontend | a listed script seeks the player and leaves it there (a scroll video under reduced motion: `currentTime = duration - 0.05`, its last frame). The editor runs no script, so it shows the poster | the script's writes to `currentTime`, and `video.currentTime` / `video.duration` read on the frontend at rest under the gates' capture conditions (reduced motion). Lever: the settled-frame flag on the block's proposal, `h2wpSettledFrame` (§6, the scroll video incident). Stop (§5) if the page's frontend row is red too |
 | margin / padding / gap differs, same classes | cascade: a WordPress layout rule or a reset outranks the source rule (layers, `revert-layer`, flow-layout margins, `blockGap`) | the WordPress rule that wins: DevTools "computed → rule" on the WP side |
 | font-family / colour differs | a stylesheet missing or out of cascade order on that page (a per-page sheet, an inline `<style>` between links) | the page's `<head>` order on both sides |
 | an image blank on one side | not decoded (lazy image outside the viewport) or a request failed | the gate's `failedRequests` / `behavior.images` |
@@ -211,7 +212,9 @@ forbidden (§1) or a converter gap (§5).
 **Gutenberg block plan (`block-plan/`)**
 - Page proposals (`block-plan/pages/<key>.json`, the owning worker's file):
   block choice, `className`, `h2wp/field` `name`s, a page's own `styles[]`
-  (at most 20, source order) and its own scripts.
+  (at most 20, source order) and its own scripts; a `core/video`'s settled
+  frame (`attributes.h2wpSettledFrame`, canvas only, §6 the scroll video
+  incident).
 - `contract.scripts[]` (dist `.js`/`.mjs`) and `contract.headScripts[]`: only
   **reviewed source scripts**. The planner extracts every inline source script
   to `assets/gutenberg-script-<hash>.js` and names that file in the
@@ -390,12 +393,15 @@ fidelity, C4 menus, C5 collections, C6 shop.
 - **Causes:** invalid blocks (a proposal the compiler accepts but the editor
   re-serializes differently); content a page script reveals, which the editor
   shows in its hidden state; text a page script wraps on the frontend (a
-  wrapper span a rule then matches); per-page sheets outside the source layer; canvas
+  wrapper span a rule then matches); a video a page script leaves on a frame
+  the editor never seeks to (it shows the poster); per-page sheets outside the source layer; canvas
   width against the content column; a box-less region (`display:contents`)
   measured by the union of its descendants.
 - **Lever:** `contract.editorStyles` for a settled script state (a reveal's
   end state, or the typography of script-wrapped text, measured on the
-  frontend); the proposal for invalid blocks.
+  frontend); for a video a script leaves on a frame, the settled-frame flag
+  on its `core/video` proposal (`attributes.h2wpSettledFrame`, measured on the
+  frontend, §6); the proposal for invalid blocks.
 - **Stop:** layering, width, height instability, the drop zone → the canvas
   runtime's to fix → report (§6).
 
@@ -480,6 +486,7 @@ for the report's reader.
 | A component form's email input with neither `name` nor `id` (finalize `field-name`; HTML: an empty submission) | A field the browser does not name is never submitted. The form's only unnamed email/tel/url field is named by its type. Anything ambiguous stays a finding | HTML: stage 2.65 `normalize-form-fields.py --apply`. Gutenberg: set the `h2wp/field` `name` in the proposal (what a mail handler expects: `email`, `phone`, `message`…) and resolve with the name chosen | coordinator (auto-naming: df6f4df) |
 | A source's inline reveal script never runs in WordPress, so `.reveal` never gets `.in` and sections stay hidden (G-front, e.g. clara `/index_v5/` 1.4%) | A behaviour the source's OWN script performs does not happen unless that script is shipped. The planner extracts it and blocks on `source-runtime`. Review the file and list it; then the editor, which runs no script, needs the settled state as canvas CSS | `contract.scripts` += the reviewed `assets/gutenberg-script-<hash>.js`; `contract.editorStyles` += a sheet setting the revealed end state (e.g. `.reveal{opacity:1;transform:none}`); resolve `source-runtime` naming the file and what it does | coordinator |
 | A strip of names drawn in the editor as authored, not as the frontend showed it: the page's script wrapped each name in `<span class="spring-scale">`, which `.press-logos span` (uppercase, sans, letter-spaced) then matched on the frontend, while the canvas, which runs no script, showed the `:nth-child(even)` rule as written (italic serif, 3 px taller) (G-editor 3.9-9.9% on the front page only; G-front green) | A structure a listed script adds exists only on the frontend. The canvas gets its settled state as CSS only when all of these hold: the page's frontend rows are green (frontend matches source); the cause is traced to a script in `contract.scripts` and its named DOM write; the sheet expresses nothing but that settled state; it styles no box the runtime owns. Anything else is a converter gap (§5) | `contract.editorStyles` += the settled typography of the wrapped text, with values from `getComputedStyle` of the wrapper on the frontend at 1440, 820 and 390 (§2.4), never copied from the authoring sheet (`clamp()`, `var()`); resolve `source-runtime` naming the script, the wrapper it adds, the rule that matches on the frontend, the values on both sides and the width. Then prove it canvas-only: the page's frontend rows are unchanged and green, and `theme-report.json` has no stale-CSS warning for the sheet | coordinator |
+| A scroll video drawn as its poster in the editor while the frontend showed its last frame: under reduced motion the page's script seeks `.scroll-video` to `duration - 0.05` and leaves it there, and the canvas, which runs no script, keeps the poster (G-editor 1.1-1.3% on the front page only; G-front green) | The canvas seeks a video only to a frame the coordinator declares, and only when all of these hold: the page's frontend rows are green (frontend matches source); the cause is traced to a script in `contract.scripts` (or the page's `scripts`) and its named seek; the frame declared is the one the frontend rests on under the gates' capture conditions (reduced motion, loaded, not playing), never a frame mid-scrub or mid-play, even when the page shows those to a visitor without reduced motion. Anything else is a converter gap (§5) | in `block-plan/pages/<key>.json`, on the video's `core/video` node, `attributes.h2wpSettledFrame`: `{"from": "end", "seconds": s}` for a script that counts back from the end (s = `duration - currentTime`), `{"from": "start", "seconds": t}` for one that seeks to a time (t = `currentTime`; 0 is the first frame). Read both on the frontend at rest under reduced motion (Playwright `reduced_motion='reduce'`, `networkidle`, then `video.currentTime` and `video.duration` once `video.seeking` is false); write the script's own constant when it states one (`0.05`), else the measured value rounded to the millisecond. The canvas seeks to exactly that. Resolve `source-runtime` naming the script, its seek, the measured `currentTime`/`duration` and the value declared. Then prove it canvas-only: the frontend markup and rows are unchanged and green, and the page's editor rows are green | coordinator |
 | Reveal margins guessed after the first 16 components, so a late component waited as deep as another it resembled (G-front, a scroll step late) | Every component's reveal margin is measured. One with no margin reveals on entry | re-run stage -1 once the build carries it | fixed in the converter (e1fd04a) |
 | A fast scroll, an anchor jump or a 700 px capture step carried a reveal past the viewport between two frames, and it never played (B/G-front: an image 40 px low on one run in two) | A reveal the page has scrolled past, or one on screen at the end of the document, plays | none; a reveal stuck at its start offset on a current build → report | fixed in the converter (7da8bd5) |
 | Smooth scrolling (`scroll-behavior: smooth`) turned a gate's 700 px scroll-through into animations the next step retargeted: an image near its reveal depth photographed revealed on one run and 40 px low on the next (gate B) | Every scroll-through sets `scroll-behavior: auto` for its walk and restores it after | none in the gates; do the same in any scroll you script | fixed in the converter (2aa098c) |