From 8143e8661703811f2b32b46dbd029eb5544cd94e Mon Sep 17 00:00:00 2001
From: "pullfrog[bot]" <226033991+pullfrog[bot]@users.noreply.github.com>
Date: Thu, 1 Oct 2026 19:10:46 +0000
Subject: [PATCH 1/2] fix: declare host compatibility by capability, not a
 wrong minHost

Issue #6. The manifest declared minHost 1.14.8, which is a Split Screen
plugin version, while the plugin spec defines minHost as the minimum *Host
(core)* version -- so the field claimed a core compatibility level the
number says nothing about.

No core version can honestly replace it: feedBack's VERSION file has read
0.3.0-alpha.2 since 2026-08-10, five weeks before highway.renderFrameAt()
landed in f7c761c, and feedBack publishes no releases or tags. So 0.3.0-alpha.2
admits hosts that cannot export and anything higher names a release that does
not exist. feedBack issue #102 says the same and proposes publishing a
traceable baseline version. minHost is also advisory-only in the current
host (no reference to it in static/js/plugin-loader.js).

Remove the field and enforce the requirement by capability instead. The
pre-flight check now names the side that is actually missing: the
always-required highway.renderFrameAt() (feedBack f7c761c), or Split Screen's
beginOfflineRender()/renderFrameAt()/endOfflineRender() bridge (Split Screen
1.14.8) when a split layout is being exported. Previously one message named
both at once, so a stale Split Screen was indistinguishable from a stale host.

Requiring the whole bridge is substantive, not cosmetic: Split Screen's
renderFrameAt() returns false unless beginOfflineRender() has run, so a
partial bridge always failed on frame 0 with a misleading 'visualization is
not ready' error. It is now reported up front, by name.

Also: document the two host floors separately from WebCodecs and FFmpeg in
README.md and CLAUDE.md, drop the getCanvas() dependency that screen.js never
used, correct CLAUDE.md's bridge attribution to Split Screen's own release
wording (added in 2301dd5, completed in 87e3622a), and clear the Staff View
'known gap' note now that PR #4 has merged.

screen.js has no exports, so tests/js/screen.test.js extracts the gate from the
real source and drives it directly; custom-checks.yml runs it.
---
 .github/workflows/custom-checks.yml |   2 +
 CHANGELOG.md                        |  42 ++++++++++-
 CLAUDE.md                           | 106 ++++++++++++++++----------
 README.md                           |  50 ++++++++++--
 plugin.json                         |   5 +-
 screen.js                           |  42 +++++++++--
 tests/js/screen.test.js             | 113 ++++++++++++++++++++++++++++
 7 files changed, 306 insertions(+), 54 deletions(-)
 create mode 100644 tests/js/screen.test.js

diff --git a/.github/workflows/custom-checks.yml b/.github/workflows/custom-checks.yml
index c35633f..a788e81 100644
--- a/.github/workflows/custom-checks.yml
+++ b/.github/workflows/custom-checks.yml
@@ -38,6 +38,8 @@ jobs:
           PY
       - name: Check JavaScript syntax
         run: node --check screen.js
+      - name: Run screen.js behaviour tests
+        run: node --test tests/js/screen.test.js
       - name: Reject print calls in routes
         run: |
           ! grep -nE '(^|[^A-Za-z0-9_])(print|traceback\.print_exc)[[:space:]]*\(' routes.py
diff --git a/CHANGELOG.md b/CHANGELOG.md
index 1604106..9d2c345 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -7,4 +7,44 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
-<!-- Add entries under Added, Changed, Deprecated, Removed, Fixed, or Security as changes land. -->
+### Changed
+
+- **Host compatibility is now checked by capability, and reported per
+  component.** The single failure message ("does not provide deterministic
+  frame rendering. Update the host and Splitscreen plugin") named both sides
+  at once, so an out-of-date Split Screen was indistinguishable from an
+  out-of-date feedBack host. The exporter now names the missing interface and
+  the build that introduced it, and checks the two requirements separately:
+  `highway.renderFrameAt()` is a feedBack requirement for every export, while
+  Split Screen's `beginOfflineRender()` / `renderFrameAt()` /
+  `endOfflineRender()` bridge is required only when a split layout is being
+  exported.
+
+### Removed
+
+- **`minHost: "1.14.8"` from `plugin.json`.** The plugin spec defines
+  `minHost` as the minimum *Host (core)* version, and `1.14.8` is a Split
+  Screen plugin version, so the field claimed a core compatibility level the
+  number says nothing about. No core version can replace it honestly:
+  feedBack's `VERSION` has read `0.3.0-alpha.2` since 2026-08-10, before
+  `highway.renderFrameAt()` landed in `f7c761c` on 2026-09-16, and feedBack
+  publishes no releases — so `0.3.0-alpha.2` would admit hosts that cannot
+  export, and anything higher would name a release that does not exist.
+  `minHost` is also advisory-only in the current host. See
+  get-flashbacks/feedBack issue #102. The manifest will regain the field when
+  a feedBack release identifies a baseline.
+
+### Fixed
+
+- **A partial Split Screen offline-render bridge is reported as a version
+  problem instead of a generic render failure.** The bridge calls were
+  individually optional-chained, so a Split Screen build providing
+  `renderFrameAt()` without `beginOfflineRender()` / `endOfflineRender()` got
+  past the pre-flight check and then failed on the first frame with "The
+  selected visualization is not ready for offline rendering" — which says
+  nothing about the actual cause. (It did not corrupt the video: Split
+  Screen's own `renderFrameAt()` returns `false` unless `beginOfflineRender()`
+  has run.) All three hooks are now required together whenever Split Screen is
+  active, and the message names which are missing.
+- **`README.md` no longer lists `highway.getCanvas()` as a host dependency.**
+  It is never called; highway canvases are read from the DOM snapshot instead.
diff --git a/CLAUDE.md b/CLAUDE.md
index 8ae2482..a13e7fa 100644
--- a/CLAUDE.md
+++ b/CLAUDE.md
@@ -11,37 +11,71 @@ this file covers the parts an agent needs that the README doesn't.
 
 - **Single-highway export:** `window.highway.renderFrameAt(time)`, added
   to feedBack core in `f7c761c` (Sep 16) — see `get-flashbacks/feedBack`
-  issue #102 for the org-wide core-compatibility audit that pins this
-  floor (it does not pin the Splitscreen floor — see that bullet). The
-  export also calls
-  `window.highway.getSongInfo()` (`screen.js:219`; `songInfo.full_mix_url`
+  issue #102 for the org-wide core-compatibility audit (it tracks this
+  dependency but deliberately does **not** pin a version for it; see the
+  `minHost` bullet). The export also calls
+  `window.highway.getSongInfo()` (`screen.js:281`; `songInfo.full_mix_url`
   is the *preferred* audio source, falling back to `audio.currentSrc` /
-  `audio.src` / `window._juceAudioUrl` at `screen.js:227` — the whole
+  `audio.src` / `window._juceAudioUrl` at `screen.js:289` — the whole
   export only bails when all four are empty, so a host with no
   `getSongInfo` at all can still export via the `<audio>` element) and
-  `window.highway.getSections()` for HUD text (`screen.js:198`) — but both
+  `window.highway.getSections()` for HUD text (`screen.js:230`) — but both
   are long-standing core APIs in `get-flashbacks/feedBack`'s
   `static/highway.js`, present in all 35 commits back to its root commit
   `6c110398` (Jun 16), and are **not** part of the `f7c761c` floor (issue
   #102 attributes only `renderFrameAt`/`renderFrame`/`setExternalFrameDriver`
-  to that commit). `getCanvas()` is not called anywhere in `screen.js`
-  despite being listed as a dependency in `README.md:40` — don't rely on
-  it.
+  to that commit). `getCanvas()` is never called in `screen.js` — canvases are
+  found as `HTMLCanvasElement` instances during the DOM snapshot and drawn with
+  `ctx.drawImage`. `README.md` used to list `getCanvas()` as a dependency; that
+  was wrong and is now removed, so don't reintroduce it.
 - **Split-layout export:** additionally needs Splitscreen's
   `beginOfflineRender()` / `renderFrameAt(time)` / `endOfflineRender()`
-  bridge, added in `feedback-plugin-splitscreen` commit `87e3622a`
-  (manifest **v1.14.8** — not pinned by issue #102, which covers only
-  feedBack-core floors; this Splitscreen version comes from that repo's
-  own history). Before that commit existed, **no** Splitscreen version
-  implemented this bridge at all — issues #6 and #7 in this repo document
-  that history; #7 in particular is worth reading before citing any
-  Splitscreen version as a floor, since the first two rounds of that issue
-  concluded (correctly, at the time) that no working version existed yet.
-- **`minHost: "1.0.0"`** in `plugin.json` reflects neither of the above —
-  see issue #6. Don't treat it as accurate; it's a known-wrong placeholder
-  tracked for correction, not a decision already made.
-- Chromium-family WebCodecs H.264 support, and FFmpeg reachable via `PATH`
-  or the desktop app's bundled `resources/bin`.
+  bridge. Split Screen's own v1.14.20 release notes describe these as
+  "deterministic offline-render hooks added in `2301dd5` and completed in
+  `87e3622a`" — use that attribution rather than either commit alone. The
+  bridge first shipped in manifest **v1.14.8**: `87e3622a` ("fix: support
+  deterministic offline export") is the commit that set that repo's manifest
+  to 1.14.8, and its parent `7cd0ec5` is manifest `1.14.7` with no
+  `beginOfflineRender`. `2301dd5` ("feat: coordinate split panel frames",
+  02:33Z) lands 99 minutes after `87e3622a` (00:51Z) on the same day and
+  is also inside 1.14.8. Cite the floor as 1.14.8 and cite both commits;
+  do not assert that one of them "introduced" the bridge on its own.
+  Before `87e3622a` existed, **no** Splitscreen version implemented this
+  bridge at all — issues #6 and #7 in this repo document that history; #7 in
+  particular is worth reading before citing any Splitscreen version as a
+  floor, since the first two rounds of that issue concluded (correctly, at
+  the time) that no working version existed yet.
+  The three hooks are genuinely all-or-nothing rather than a nicety: the
+  plugin's `renderFrameAt` starts with `if (!active ||
+  !_offlineRenderActive || ...) return false`, so a host exposing
+  `renderFrameAt` without `beginOfflineRender` can never paint a frame.
+- **`plugin.json` deliberately declares no `minHost`.** Issue #6 asked for
+  the host floor to be declared, and that cannot be done honestly: per
+  `feedBack-plugin-spec` §4.1, `minHost` means the minimum **Host (core)**
+  version, and the value that sat there before (`1.14.8`) was a *Splitscreen*
+  version — the exact core/plugin conflation to avoid. There is also no
+  core version that is a true floor: feedBack's `VERSION` file has read
+  `0.3.0-alpha.2` since commit `ec1157ac` (2026-08-10), five weeks before
+  `f7c761c`, and it still reads `0.3.0-alpha.2` on `main` — `f7c761c`'s own
+  parent reports the same string — while feedBack publishes no releases or
+  tags at all. So `0.3.0-alpha.2` admits ~5 weeks of pre-`renderFrameAt`
+  builds, and any higher number would name a release that does not exist.
+  feedBack issue #102 says the same thing and proposes publishing a
+  traceable baseline version instead. `minHost` is advisory-only in the
+  current host anyway (no `minHost` reference in feedBack's
+  `static/js/plugin-loader.js`), so an inaccurate value buys nothing and
+  would mislead a future enforcing host. The requirement is instead enforced
+  by capability in `frameDriverProblem()` (`screen.js`), which reports the
+  core gap and the Splitscreen gap separately. When a real feedBack release
+  identifies a baseline, add `minHost` back at that version.
+- **WebCodecs (browser, separate from the host version):** Chromium-family
+  H.264 `VideoEncoder` support. Checked independently in `startExport` before
+  any host lookup, so a missing WebCodecs build reports as itself rather than
+  as a compatibility problem.
+- **FFmpeg (server, separate again):** reachable via `PATH` or the desktop
+  app's bundled `resources/bin`. Only needed once frames are rendered, so its
+  absence surfaces from `routes.py` as a muxing failure (503) rather than as a
+  host compatibility error.
 
 ## Frame capture: static snapshot + per-frame dynamic layer
 
@@ -52,21 +86,17 @@ per frame what's expected to change (highway canvases via
 independent of song duration but does depend on visualization cost and
 resolution.
 
-**Known gap: Staff View (alphaTab) notation goes stale or never
-appears.** Staff View renders sheet music as `<svg>`, swapped out by
-alphaTab as playback scrolls to a new system. The one-time snapshot
-rasterizes each top-level `<svg>` **once, at export start** — see the
-comment at `screen.js:131-135` — so a Staff View export shows either
-nothing (if alphaTab hadn't rendered yet at snapshot time) or whatever was
-on screen at t=0, frozen, for the entire video. This is tracked as issue
-**#2** (open) with a candidate fix in PR **#4** (open, not yet merged as
-of this writing): exclude Staff View's container from the one-time
-snapshot and instead re-describe/re-rasterize it every composited frame
-(via a `WeakMap` cache keyed by element, so an unchanged SVG isn't
-re-encoded every frame), the same way the split-lyrics pane already
-handles its own per-timestamp DOM rebuilds. **Do not assume this is fixed
-without checking whether #4 has merged** — the bug reproduces against the
-`main` branch's current `screen.js` as of this file's writing.
+**Fixed: Staff View (alphaTab) notation no longer goes stale.** Staff View
+renders sheet music as `<svg>`, swapped out by alphaTab as playback scrolls to
+a new system, so a one-time snapshot froze whatever was on screen at t=0.
+Resolved by PR **#4** (commit `fb03961`, "Fix Staff View notation never
+appearing in exported video"), which excludes Staff View's container from the
+one-time snapshot and re-describes/re-rasterizes it every composited frame,
+using a `WeakMap` cache keyed by element so an unchanged SVG isn't re-encoded
+each frame — the same way the split-lyrics pane already handles its own
+per-timestamp DOM rebuilds. Issue #2 is closed (2026-09-28). Earlier revisions
+of this file listed this as an open gap and pointed at PR #4 as unmerged; that
+warning was left in place after the fix landed.
 
 **Known non-goal:** Jumping Tab panes don't provide deterministic frame
 rendering and aren't supported in offline split exports (README's own
@@ -76,7 +106,7 @@ without a host-side contract for it first.
 ## Mount lifecycle
 
 `mountButton()` injects the "Export video" control into the v3 player
-chrome's Plugins rail. A `setInterval` poll (`screen.js:327`) exists only
+chrome's Plugins rail. A `setInterval` poll (`screen.js:390`) exists only
 to catch the slot not being ready yet at initial page load (a v3-chrome
 mount race); once the first successful mount happens, the poll stops
 itself and all future remounts are covered by the `screen:changed`
diff --git a/README.md b/README.md
index 1a7e80c..c205e71 100644
--- a/README.md
+++ b/README.md
@@ -33,15 +33,51 @@ work is limited to highway canvases and dynamic text/lyrics. Export speed is
 therefore independent of the song's playback duration, but still depends on
 visualization cost, resolution, and hardware encoding performance.
 
-## Host integration
+## Requirements
 
-The exporter relies on the following host interfaces:
+Visual Export needs four independent things. Only the first is a feedBack
+requirement; the rest are separate and are checked separately.
 
-- A highway renderer with `renderFrameAt(time)` and `getCanvas()`.
-- When exporting a split layout, Splitscreen's `beginOfflineRender()`,
-  `renderFrameAt(time)`, and `endOfflineRender()` bridge.
-- Chromium-family WebCodecs H.264 support and FFmpeg available to the server
-  through `PATH` or the desktop application's bundled `resources/bin` folder.
+### feedBack host (required for every export)
+
+- `window.highway.renderFrameAt(time)`, which paints one explicit chart time
+  without sampling the playback clock. It arrived in feedBack commit
+  `f7c761c` (Sep 16 2026); see get-flashbacks/feedBack issue #102.
+
+The exporter also calls `window.highway.getSongInfo()` and
+`window.highway.getSections()`, but both are long-standing feedBack APIs that
+predate `f7c761c` by months and are not part of the export's floor.
+
+There is deliberately **no `minHost` version in the manifest**. feedBack's
+`VERSION` file has read `0.3.0-alpha.2` since 2026-08-10 — before
+`renderFrameAt()` existed — and feedBack publishes no releases, so no version
+string identifies a build that can export. Rather than declare a number that is
+either too low or does not exist, the plugin checks for the interface itself
+and, when it is absent, says which build to update to.
+
+### Split Screen (required only when exporting a split layout)
+
+When Split Screen is active, the export additionally needs its offline-render
+bridge: `beginOfflineRender()`, `renderFrameAt(time)`, and
+`endOfflineRender()`. The bridge arrived in Split Screen **1.14.8** (commits
+`2301dd5` and `87e3622a`); 1.14.7 is the last version without it. All three are
+required together, because Split Screen's `renderFrameAt()` refuses to paint
+unless `beginOfflineRender()` has already run — so a partial bridge could never
+export in the first place. The exporter checks all three up front and reports
+the missing ones by name instead of failing mid-render. Without Split Screen
+installed, single-highway export is unaffected.
+
+### WebCodecs (browser)
+
+Chromium-family browser with H.264 `VideoEncoder` support. Missing WebCodecs is
+reported on its own, separately from any host or Split Screen problem.
+
+### FFmpeg (server)
+
+FFmpeg reachable through `PATH` or the desktop application's bundled
+`resources/bin` folder. It muxes the encoded frames with the song audio and is
+only needed once rendering succeeds, so its absence surfaces as a muxing
+failure rather than a host compatibility error.
 
 ## Limits
 
diff --git a/plugin.json b/plugin.json
index 2c2d294..414a7ed 100644
--- a/plugin.json
+++ b/plugin.json
@@ -1,7 +1,7 @@
 {
   "id": "visual_export",
   "name": "Visual Export",
-  "version": "0.2.1",
+  "version": "0.2.2",
   "description": "Renders the current player layout to a video file for the entire song, without a live performance.",
   "type": "tools",
   "script": "screen.js",
@@ -12,6 +12,5 @@
     "category": "custom"
   },
   "routes": "routes.py",
-  "icon": "🎬",
-  "minHost": "1.14.8"
+  "icon": "🎬"
 }
diff --git a/screen.js b/screen.js
index d44796e..c75d6e9 100644
--- a/screen.js
+++ b/screen.js
@@ -243,6 +243,37 @@
     throw new Error('This browser cannot encode H.264 at the selected resolution. Try 1080p or Chromium/Chrome.');
   }
 
+  // A split-layout export needs Split Screen's offline-render bridge as a whole.
+  // Split Screen's own renderFrameAt() begins `if (!active || !_offlineRenderActive
+  // ...) return false`, so beginOfflineRender() is a precondition of painting any
+  // frame, not just bookkeeping. Requiring all three up front turns the partial
+  // case into a named version error instead of a generic failure on frame 0.
+  const SPLIT_BRIDGE = ['beginOfflineRender', 'renderFrameAt', 'endOfflineRender'];
+
+  // Deterministic frame rendering is a host contract, and no host version
+  // number identifies a build that provides it: feedBack's VERSION file has
+  // read 0.3.0-alpha.2 since 2026-08-10, well before highway.renderFrameAt()
+  // landed in commit f7c761c on 2026-09-16, so no semver floor could admit
+  // exactly the builds that can export. Test the capability instead, and name
+  // the side that is actually missing -- the always-required host, or the Split
+  // Screen integration that only a split layout needs.
+  function frameDriverProblem(split, splitActive) {
+    if (typeof window.highway?.renderFrameAt !== 'function') {
+      return 'This feedBack build has no highway.renderFrameAt(), so it cannot render frames '
+        + 'deterministically. That arrived in feedBack commit f7c761c (Sep 16 2026); the host '
+        + 'version string does not identify it, so update to a build containing that commit.';
+    }
+    if (splitActive) {
+      const missing = SPLIT_BRIDGE.filter(name => typeof split?.[name] !== 'function');
+      if (missing.length) {
+        return `Split Screen is active but does not provide ${missing.join(', ')}. Offline split `
+          + 'export needs the whole offline-render bridge, which arrived in Split Screen 1.14.8 '
+          + '(commits 2301dd5 and 87e3622a). Update Split Screen; this feedBack host is new enough.';
+      }
+    }
+    return null;
+  }
+
   async function startExport(dialog) {
     if (exporting) return;
     const audio = document.getElementById('audio');
@@ -276,12 +307,13 @@
     audio.pause();
     const split = window.feedBackSplitscreen || window.slopsmithSplitscreen;
     const splitActive = !!split?.isActive?.();
-    const renderFrameAt = splitActive ? split?.renderFrameAt : window.highway?.renderFrameAt;
-    if (typeof renderFrameAt !== 'function') {
+    const driverProblem = frameDriverProblem(split, splitActive);
+    if (driverProblem) {
       exporting = false; startBtn.disabled = false; cancelBtn.hidden = true;
       if (!wasPaused) audio.play().catch(() => {});
-      return status(dialog, 'This feedBack build does not provide deterministic frame rendering. Update the host and Splitscreen plugin.');
+      return status(dialog, driverProblem);
     }
+    const renderFrameAt = splitActive ? split.renderFrameAt : window.highway.renderFrameAt;
     const output = document.createElement('canvas'); output.width = width; output.height = height;
     let encoder;
     let composeFrame;
@@ -295,7 +327,7 @@
       // offline-render mode with no matching endOfflineRender() call. Moved
       // inside the try so any failure here still hits the same
       // catch/finally as a failure mid-render.
-      if (splitActive) split.beginOfflineRender?.();
+      if (splitActive) split.beginOfflineRender();
       composeFrame = await createCompositor(output, includeChrome);
       status(dialog, 'Loading source audio…', 0);
       const audioResponse = await fetch(audioUrl);
@@ -349,7 +381,7 @@
       if (encoder && encoder.state !== 'closed') { try { encoder.close(); } catch (_) {} }
       status(dialog, err?.name === 'AbortError' ? 'Export cancelled.' : `Export failed: ${err?.message || err}`);
     } finally {
-      if (splitActive) split.endOfflineRender?.();
+      if (splitActive) split.endOfflineRender();
       try { audio.currentTime = oldTime; } catch (_) {}
       if (!wasPaused && !cancelled) audio.play().catch(() => {});
       exporting = false; startBtn.disabled = false; cancelBtn.hidden = true;
diff --git a/tests/js/screen.test.js b/tests/js/screen.test.js
new file mode 100644
index 0000000..50ef2f9
--- /dev/null
+++ b/tests/js/screen.test.js
@@ -0,0 +1,113 @@
+'use strict';
+// Behavioural coverage for the export pre-flight capability gate. screen.js is
+// a browser IIFE with no exports, so extract the gate and its constant from the
+// real source and drive them directly -- that keeps these assertions tied to
+// shipped code rather than a reimplementation that could drift.
+
+const test = require('node:test');
+const assert = require('node:assert/strict');
+const fs = require('node:fs');
+
+// The JS suite runs from the repository root (see .github/workflows), so keep
+// this fixture literal rather than building a path from external input.
+const source = fs.readFileSync('screen.js', 'utf8');
+
+function block(signature) {
+    const start = source.indexOf(signature);
+    assert.ok(start >= 0, `missing ${signature}`);
+    const open = source.indexOf('{', start);
+    let depth = 1;
+    let end = open + 1;
+    while (depth && end < source.length) {
+        if (source[end] === '{') depth++;
+        else if (source[end] === '}') depth--;
+        end++;
+    }
+    assert.equal(depth, 0, `${signature} must be balanced`);
+    return source.slice(start, end);
+}
+
+// Build a frameDriverProblem bound to a stub host. `highway` stands in for the
+// feedBack core global; the split object stands in for whichever Splitscreen
+// global the plugin picked up.
+function gateFor(highway) {
+    const constant = block("const SPLIT_BRIDGE =");
+    const fn = block('function frameDriverProblem(');
+    return new Function('window', `${constant}\n${fn}\nreturn frameDriverProblem;`)(
+        { highway }
+    );
+}
+
+// The bridge as Split Screen v1.14.8 shipped it.
+function fullBridge() {
+    return {
+        isActive: () => true,
+        beginOfflineRender() {},
+        renderFrameAt() { return true; },
+        endOfflineRender() {},
+    };
+}
+
+// A pre-bridge build: splits and is active, but exposes no offline hooks.
+function preBridge() {
+    return { isActive: () => true, renderFrameAt() { return true; } };
+}
+
+test('a host without renderFrameAt is rejected on its own, not as a Split Screen problem', () => {
+    const problem = gateFor(undefined)(fullBridge(), true);
+    assert.match(problem, /highway\.renderFrameAt\(\)/);
+    assert.match(problem, /f7c761c/);
+    // The core gap takes precedence and must not blame the plugin.
+    assert.doesNotMatch(problem, /Split Screen/);
+});
+
+test('a host that merely lacks the function type is still rejected', () => {
+    const problem = gateFor({ renderFrameAt: 'not a function' })(fullBridge(), true);
+    assert.match(problem, /highway\.renderFrameAt\(\)/);
+});
+
+test('an up-to-date host exports without Split Screen installed', () => {
+    assert.equal(gateFor({ renderFrameAt() {} })(undefined, false), null);
+});
+
+test('Split Screen is only required while a split layout is being exported', () => {
+    // Inactive splitscreen still exposes the bridge, but a stale build must not
+    // block a single-instance export.
+    assert.equal(gateFor({ renderFrameAt() {} })(preBridge(), false), null);
+});
+
+test('an active pre-bridge Split Screen is reported as a Split Screen version problem', () => {
+    const problem = gateFor({ renderFrameAt() {} })(preBridge(), true);
+    assert.match(problem, /Split Screen is active/);
+    assert.match(problem, /beginOfflineRender/);
+    assert.match(problem, /endOfflineRender/);
+    assert.match(problem, /1\.14\.8/);
+    // The host is fine here, so the message must say so.
+    assert.match(problem, /this feedBack host is new enough/);
+});
+
+test('a partial bridge names only the hooks that are actually absent', () => {
+    const problem = gateFor({ renderFrameAt() {} })(
+        { isActive: () => true, renderFrameAt() { return true; }, beginOfflineRender() {} },
+        true
+    );
+    assert.match(problem, /endOfflineRender/);
+    assert.doesNotMatch(problem, /beginOfflineRender/);
+});
+
+test('a bridge missing renderFrameAt alone is also rejected', () => {
+    const problem = gateFor({ renderFrameAt() {} })(
+        { isActive: () => true, beginOfflineRender() {}, endOfflineRender() {} },
+        true
+    );
+    assert.match(problem, /renderFrameAt/);
+});
+
+test('an active Split Screen with the complete bridge exports', () => {
+    assert.equal(gateFor({ renderFrameAt() {} })(fullBridge(), true), null);
+});
+
+test('the core gap is reported even when Split Screen is also too old', () => {
+    const problem = gateFor(undefined)(preBridge(), true);
+    assert.match(problem, /highway\.renderFrameAt\(\)/);
+});
\ No newline at end of file

From 61d967a67f67ade7394b2b38773e5058616711de Mon Sep 17 00:00:00 2001
From: "pullfrog[bot]" <226033991+pullfrog[bot]@users.noreply.github.com>
Date: Thu, 1 Oct 2026 19:43:15 +0000
Subject: [PATCH 2/2] fix: correct screen.js citations and extract SPLIT_BRIDGE
 to its semicolon

CLAUDE.md cited screen.js lines 281/289/390; the code is at 282/290/391.
230 was already correct.

block("const SPLIT_BRIDGE =") brace-matched an array literal, so it
swallowed frameDriverProblem along with it and the rebuilt body declared
that function twice -- legal only because new Function bodies are sloppy
mode. Extract the constant to its terminating semicolon instead.
---
 CLAUDE.md               |  6 +++---
 tests/js/screen.test.js | 12 +++++++++++-
 2 files changed, 14 insertions(+), 4 deletions(-)

diff --git a/CLAUDE.md b/CLAUDE.md
index a13e7fa..1ed8e62 100644
--- a/CLAUDE.md
+++ b/CLAUDE.md
@@ -14,9 +14,9 @@ this file covers the parts an agent needs that the README doesn't.
   issue #102 for the org-wide core-compatibility audit (it tracks this
   dependency but deliberately does **not** pin a version for it; see the
   `minHost` bullet). The export also calls
-  `window.highway.getSongInfo()` (`screen.js:281`; `songInfo.full_mix_url`
+  `window.highway.getSongInfo()` (`screen.js:282`; `songInfo.full_mix_url`
   is the *preferred* audio source, falling back to `audio.currentSrc` /
-  `audio.src` / `window._juceAudioUrl` at `screen.js:289` — the whole
+  `audio.src` / `window._juceAudioUrl` at `screen.js:290` — the whole
   export only bails when all four are empty, so a host with no
   `getSongInfo` at all can still export via the `<audio>` element) and
   `window.highway.getSections()` for HUD text (`screen.js:230`) — but both
@@ -106,7 +106,7 @@ without a host-side contract for it first.
 ## Mount lifecycle
 
 `mountButton()` injects the "Export video" control into the v3 player
-chrome's Plugins rail. A `setInterval` poll (`screen.js:390`) exists only
+chrome's Plugins rail. A `setInterval` poll (`screen.js:391`) exists only
 to catch the slot not being ready yet at initial page load (a v3-chrome
 mount race); once the first successful mount happens, the poll stops
 itself and all future remounts are covered by the `screen:changed`
diff --git a/tests/js/screen.test.js b/tests/js/screen.test.js
index 50ef2f9..6f81afa 100644
--- a/tests/js/screen.test.js
+++ b/tests/js/screen.test.js
@@ -27,11 +27,21 @@ function block(signature) {
     return source.slice(start, end);
 }
 
+// `SPLIT_BRIDGE` is a statement, not a braced block: slice to the terminating
+// semicolon so the extraction cannot run past it into the function below.
+function statement(signature) {
+    const start = source.indexOf(signature);
+    assert.ok(start >= 0, `missing ${signature}`);
+    const end = source.indexOf(';', start);
+    assert.ok(end > start, `${signature} must be terminated`);
+    return source.slice(start, end + 1);
+}
+
 // Build a frameDriverProblem bound to a stub host. `highway` stands in for the
 // feedBack core global; the split object stands in for whichever Splitscreen
 // global the plugin picked up.
 function gateFor(highway) {
-    const constant = block("const SPLIT_BRIDGE =");
+    const constant = statement("const SPLIT_BRIDGE =");
     const fn = block('function frameDriverProblem(');
     return new Function('window', `${constant}\n${fn}\nreturn frameDriverProblem;`)(
         { highway }