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 0c246aa..73304c6 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -47,3 +47,42 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
   whole export, so leaving it captured would have baked a clock frozen at t=0
   into every precomposed layer. **Exported videos no longer show the song
   metadata, clock or Up Next line.**
+- **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 8e729c6..c4591cb 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:533`; `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:589`; `songInfo.full_mix_url`
   is the *preferred* audio source, falling back to `audio.currentSrc` /
-  `audio.src` / `window._juceAudioUrl` (`screen.js:541`) — the whole
+  `audio.src` / `window._juceAudioUrl` at `screen.js:597` — 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:392`) — but both
+  `window.highway.getSections()` for HUD text (`screen.js:402`) — 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: precomposed layers + per-frame dynamic roots
 
@@ -69,15 +103,17 @@ the acquire gives every in-flight append the same stale base, each gets a full
 prefix. A rejected append truncates back to that snapshot — never unlink, or a
 single over-limit chunk destroys the whole render.
 
-**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. Its container is excluded from
-the precomposed layers and re-described (and re-rasterized per element
-reference, via a `WeakMap` cache) instead, the same way the split-lyrics pane
-handles its own per-timestamp DOM rebuilds — so this behaviour is now shared
-with lyrics rather than special-cased, but the underlying issue is tracked as
-issue **#2**. Don't assume that bug is fixed without checking whether #4 has
-merged.
+**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.
 
 ## Encoder pipeline and transport
 
@@ -121,7 +157,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:711`) exists only
+chrome's Plugins rail. A `setInterval` poll (`screen.js:789`) 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 4183563..def5ed3 100644
--- a/README.md
+++ b/README.md
@@ -56,15 +56,51 @@ alive, the browser uploads the mix, and the mux is retried.
 The server only ever contacts that configured origin, and it refuses redirects,
 so a song URL cannot redirect the fetch to another host.
 
-## 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 4a0864a..b6ffbe8 100644
--- a/plugin.json
+++ b/plugin.json
@@ -1,7 +1,7 @@
 {
   "id": "visual_export",
   "name": "Visual Export",
-  "version": "0.3.0",
+  "version": "0.3.1",
   "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 01fe3ff..11df9fc 100644
--- a/screen.js
+++ b/screen.js
@@ -550,6 +550,37 @@
     } catch (_) { /* the server also expires abandoned sessions */ }
   }
 
+  // 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');
@@ -583,12 +614,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;
     const info = window.highway?.getSongInfo?.() || songInfo;
     const exportName = `${info.artist || 'feedback'}-${info.title || 'export'}`;
@@ -606,7 +638,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();
       compositor = await createCompositor(output, includeChrome);
 
       // Issue #9, phase 3: when the host serves the song mix from its own origin
@@ -747,7 +779,7 @@
       if (backpressure) backpressure.stop();
       if (compositor) compositor.dispose();
       await discardExportSession(session);
-      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..6f81afa
--- /dev/null
+++ b/tests/js/screen.test.js
@@ -0,0 +1,123 @@
+'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);
+}
+
+// `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 = statement("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