diff --git a/CLAUDE.md b/CLAUDE.md
index abfa63e..756f4ae 100644
--- a/CLAUDE.md
+++ b/CLAUDE.md
@@ -18,6 +18,7 @@ screen.js
 ├── Teardown / rebuild           — teardownPanels, rebuildLayout, captureCurrentPrefs
 ├── Start / stop                 — startSplitScreen, stopSplitScreen, toggle
 ├── Time sync                    — startTimeSync, stopTimeSync
+├── Host-feature diagnostics     — _warnOnce, hostFeatures(), _hostFramesSeen, _lanRelayOk
 ├── Toolbar buttons              — createLayoutBtn, createHideBtn, createFloatingShowBtn,
 │                                  togglePanelBar, toggleControlsVisibility, updateBtn, injectBtn
 └── Hooks into core              — wraps window.playSong, listens for screen:changing
@@ -36,6 +37,7 @@ screen.js
 | `VIZ_PREFIX` | `'__viz__'` | Prefix for generic viz-plugin entries. Select value: `__viz__:<pluginId>:<arrIndex>`; saved pref: `__viz__:<pluginId>:<arrName>` |
 | `DETECT_CHANNEL_CYCLE` | `['mono','left','right']` | Channel cycle order |
 | `DETECT_CHANNEL_LABELS` | `{mono:'M',left:'L',right:'R'}` | Channel button labels |
+| `LAN_SHARE_DIAG_FAILURES` | `3` | Consecutive `/ws/sync` connect attempts that never open before splitscreen reports the relay missing (splitscreen#69) |
 
 ## Module-level state
 
@@ -55,6 +57,9 @@ screen.js
 | `layoutBtn` | element\|null | The layout `<select>` injected into `#player-controls` |
 | `hideBtn` | element\|null | The `▾ Bar` button injected into `#player-controls` |
 | `floatBtn` | element\|null | The floating `▴ Controls` restore button appended to `#player` |
+| `_hostFramesSeen` | bool\|null | Whether the host exposes the coordinated-frame API — `null` until the first panel highway is inspected (splitscreen#69) |
+| `_lanRelayOk` | bool\|null | Whether the server's `/ws/sync` relay answered the share in flight — `null` while none is (reset by `startLanShare`/`stopLanShare`) |
+| `_warnedOnce` | Set | Ids already reported by `_warnOnce()`, so an unsupported host is named once per page load |
 
 ## localStorage keys
 
@@ -334,6 +339,25 @@ Retired (splitscreen#47): `window.createJumpingTabPane` and `window.createTabVie
 
 The `{ onSongInfo: () => {} }` passed to `hw.connect()` suppresses the default behavior where receiving `song_info` would overwrite the main player's HUD, audio element, and arrangement dropdown. This is required for every panel WebSocket connection. See slopsmith issue #27.
 
+## Host compatibility (splitscreen#69)
+
+The plugin's features span several core API generations, so there is **no `minHost` in `plugin.json`** — one unqualified claim would hide three degraded modes. Core's loader exposes `minHost` as metadata only (no frontend enforcement found in the inspected checkout), and the basic-mode floor has not been exercised end-to-end against a released host, so declaring a value today would advertise something untested. The per-feature matrix (user-facing copy, keep in sync with this table) lives in README.md under "Host compatibility".
+
+| Feature | Required? | Host API | Core commit |
+|---|---|---|---|
+| Basic split view | **Required** | `window.createHighway` + `setRenderer` lifecycle + chart/playback access | source-level present at tag `v0.3.0-alpha.1` (not certified end-to-end) |
+| LAN sharing | Optional | server `/ws/sync/{session_id}` | `03e1c1d` (#1030/#1032) — on canonical and fork `main` |
+| Coordinated / offline frame rendering | Optional | `Highway.renderFrame` / `renderFrameAt` / `setExternalFrameDriver` | `f7c761c` (#81) — fork only |
+| Per-player identity / targeted difficulty | Optional | `window.feedBack.playerContexts`, `player-difficulty.v1` | `7633211` (#83) — fork only |
+
+Rules when touching these paths:
+
+- **Never raise the basic-mode floor because an optional feature needs a newer host.** A missing optional API must only disable its own feature.
+- **Every optional feature degrades quietly, so say it once.** `_warnOnce(id, msg)` names the core commit the host is missing; the LAN path additionally toasts via `_showMainToast` after `LAN_SHARE_DIAG_FAILURES` consecutive connect attempts that never open. Every never-opened attempt counts, including the `new WebSocket()` call that throws outright (mixed content, blocked scheme) and never reaches `onclose`. `_lanConnect`'s `opened` flag is what keeps a post-connect drop from being misreported as a missing relay — the reconnect loop keeps running either way, so a server upgraded mid-share recovers on its own.
+- **`_lanRelayOk` can only be `true`/`false` from a socket outcome** — `/ws/sync` is a server endpoint a page cannot feature-detect, hence the initial `null` (and `_hostFramesSeen`'s, meaning "no panel highway inspected yet"). `startLanShare`/`stopLanShare` reset it to `null`, so the reported verdict always belongs to the share still in flight rather than a finished one.
+- **One predicate per feature, shared by the probe and the call site.** `hostFeatures()` must not re-derive capability differently from the path that uses it: `playerIdentity` reads `_hasPlayerContextApi()` (the same check `_publishPanelContext` makes, so a namespace without `upsert` isn't reported as supported), and `_recordHostFrameApi()` answers "does this host have the coordinated-frame API" for both the probe and `beginOfflineRender`'s warning. The warning gates on exactly what `renderFrameAt()` will then reject, so it can't accuse a host of a gap it doesn't have.
+- `window.slopsmithSplitscreen.hostFeatures()` exposes the same answers to consumers (Visual Export uses it to avoid promising a deterministic frame the host can't produce). New optional host APIs get a row in that probe plus a `_warnOnce` at the guarded call site.
+
 ## Adding a new panel mode
 
 Only reach for a hand-rolled sentinel (like `LYRICS_VALUE`) when the mode manages
diff --git a/README.md b/README.md
index 0596fe7..0ed8fb0 100644
--- a/README.md
+++ b/README.md
@@ -27,7 +27,49 @@ git clone https://github.com/got-feedBack/feedBack-plugin-splitscreen.git splits
 docker compose restart
 ```
 
-**Compatibility** — splitscreen runs on any feedBack core. On cores with the `highway:visibility` plugin API (~0.2.7.1+), a visualization plugin that mounts a sibling overlay — e.g. the 3D Highway's WebGL overlay — hides itself cleanly while splitscreen is active. On older cores that overlay may bleed through the panels; update the core (and the 3D Highway plugin) to fix it.
+**Compatibility** — split view itself runs on any feedBack core that exposes the highway factory; each *optional* feature needs its own host API. See [Host compatibility](#host-compatibility) for the per-feature requirements and what you lose without them.
+
+## Host compatibility
+
+Split screen's features span several generations of core API, so there is no single version string that describes them. This plugin therefore declares **no `minHost`** in its manifest — see [Why there is no `minHost`](#why-there-is-no-minhost) — and documents the requirement per feature instead.
+
+| Feature | Required? | Needs from the host | Added in | Without it |
+|---------|-----------|---------------------|----------|------------|
+| **Basic split view** — layouts, per-panel arrangement, invert/lefty, visualization picker, lyrics pane, pop-out to a second monitor on *this* machine | **Required** | `window.createHighway()` plus the per-instance renderer lifecycle (`setRenderer`), chart access and the playback clock | core `v0.3.0-alpha.1` (source-level check — see the note below) | The plugin cannot build a panel. |
+| **LAN sharing** (📡) | Optional | The server's `/ws/sync/{session_id}` relay endpoint | [`03e1c1d`](https://github.com/got-feedBack/feedBack/commit/03e1c1d) — *feat(server): session-sync relay WebSocket* (core #1030/#1032), 22 Jul 2026 | The dialog opens but no viewer can ever join. Everything else — including pop-out on this machine — is unaffected. |
+| **Coordinated / offline frame rendering** (Visual Export and anything else asking for one shared frame) | Optional | `Highway.renderFrame`, `renderFrameAt`, `setExternalFrameDriver` | [`f7c761c`](https://github.com/got-feedBack/feedBack/commit/f7c761c) — *feat(highway): add coordinated frame rendering* (fork [#81](https://github.com/get-flashbacks/feedBack/issues/81)) | Live panels keep their own render loops, which is invisible during play; an offline export cannot paint a shared frame. |
+| **Per-player identity + targeted difficulty** (publishing a player context per panel) | Optional | `window.feedBack.playerContexts` and the `player-difficulty.v1` capability | [`7633211`](https://github.com/got-feedBack/feedBack/commit/7633211) — *core: add player identity capability for concurrent play* (fork [#83](https://github.com/get-flashbacks/feedBack/issues/83)) | Panels stay anonymous to plugins that address players by context; panel names, the visualization picker and every panel feature keep working. |
+
+Notes on the "Added in" column:
+
+- **`03e1c1d` (LAN relay)** is on `main` of both [got-feedBack/feedBack](https://github.com/got-feedBack/feedBack) and the [get-flashbacks/feedBack](https://github.com/get-flashbacks/feedBack) fork.
+- **`f7c761c` and `7633211` are merged in the fork only** — neither is on canonical `main` yet (their core issues are the fork's [#81](https://github.com/get-flashbacks/feedBack/issues/81) and [#83](https://github.com/get-flashbacks/feedBack/issues/83)). Running splitscreen against canonical core gives you basic split view and LAN sharing, but not coordinated rendering or per-player identity.
+- **Basic mode on `v0.3.0-alpha.1` is a source-level finding, not an end-to-end certification.** That tag's `static/highway.js` exposes `createHighway` and the `setRenderer` lifecycle, and every `hw.*` method split screen calls in basic mode (`connect`, `init`, `setTime`, `setInverted`/`setLefty`/`setMastery` and their getters, `resize`, `stop`, `setLyricsVisible`, `getRenderScale`, `hasPhraseData`, `_onReady`), and its `static/index.html` loads that file as a classic script, so the factory lands on `window`. It has no `renderFrame`/`renderFrameAt`/`setExternalFrameDriver`, which is exactly why those are a separate row.
+
+Not a requirement, but worth knowing: on cores with the `highway:visibility` plugin API (~0.2.7.1+), a visualization plugin that mounts a sibling overlay — e.g. the 3D Highway's WebGL overlay — hides itself cleanly while split view is active. On older cores that overlay may bleed through the panels; update the core (and the 3D Highway plugin) to fix it.
+
+### Checking your host
+
+Every optional feature is capability-checked and degrades quietly, so the plugin itself never blocks on an old core. It does tell you once, in the console, when a host is missing an API a feature needs — and it exposes the same answer programmatically:
+
+```js
+const ss = window.feedBackSplitscreen || window.slopsmithSplitscreen;
+ss.hostFeatures();
+// {
+//   splitView:          true,          // window.createHighway is present
+//   coordinatedFrames:  true | false | null,  // core f7c761c; null = no panel built yet
+//   playerIdentity:     true | false,         // core 7633211
+//   lanRelay:           true | false | null,  // core 03e1c1d; null = no share in flight
+// }
+```
+
+`lanRelay` is the server's endpoint rather than a browser API, so it cannot be feature-detected: it is `null` whenever no share is in flight, and otherwise reports whether the current share's relay socket ever opened. Consecutive connect attempts that never open — including a `WebSocket` the browser refuses to construct at all — are counted, and once the third lands it is reported as a missing relay (on screen as well as in the console). The reconnect loop keeps running either way, so a server upgraded mid-share recovers on its own.
+
+### Why there is no `minHost`
+
+The core plugin loader exposes `minHost` as metadata; no frontend enforcement was found in the inspected core checkout, so a value would not stop an incompatible install — it would only be a claim. Basic mode has not been tested end-to-end against a released host yet, and its floor (`v0.3.0-alpha.1`) is a source-level reading rather than a certified one, so declaring it would advertise something untested. The floor is also deliberately **not** raised by the optional features: LAN sharing, coordinated rendering and per-player identity each need a newer core, but their absence never stops basic split view.
+
+Once a host build has been exercised against the basic path end to end, the floor belongs here — and in `plugin.json` — as a tested minimum. Core-side tracking: [feedBack#102](https://github.com/get-flashbacks/feedBack/issues/102).
 
 ## Usage
 
@@ -81,12 +123,12 @@ The **room key** is generated once and saved (Settings → Split Screen shows it
 Requirements & caveats:
 
 - The server must be reachable on your LAN. On the desktop app, enable **LAN access** (Plugin Manager → Network); Docker/standalone servers just need the port reachable. Your OS firewall may prompt once.
-- Needs a server with the `/ws/sync` relay endpoint (feedBack ≥ the #1030 relay). On an older server, LAN sharing simply won't connect; everything else is unaffected.
+- Needs a server with the `/ws/sync` relay endpoint (core [`03e1c1d`](https://github.com/got-feedBack/feedBack/commit/03e1c1d), the core #1030 relay). On an older server, LAN sharing never connects — split view says so once, both on screen and in the console, and everything else is unaffected.
 - Viewer devices need WebGL2 for the 3D highway (any recent tablet/laptop is fine; the renderer auto-scales on weak GPUs).
 - Browsers only keep screens awake on secure pages, so a tablet viewing over plain `http://` may sleep mid-song — tap it awake, or raise the device's screen-timeout for the session.
 - If your machine's LAN IP changes (DHCP), bookmarked URLs go stale — give it a DHCP reservation in your router if that bites.
 
-**Security note:** the LAN share room follows feedBack's overall trusted-network design — the room key controls *discovery*, not authentication. `/ws/sync/{room_key}` is a broadcast room: anyone who joins with the key (not just the host) can send playback/session messages that every other viewer treats as authoritative. This is only a concern if you share your key with, or otherwise expose your server to, people or devices you don't trust on that network — the same trust boundary as every other unauthenticated route in the app. A real fix would need host-issued per-connection tokens in feedBack core, which isn't planned while the app has no broader auth layer (see [splitscreen#24](https://github.com/get-flashbacks/feedBack-plugin-splitscreen/issues/24)).
+**Security note:** the LAN share room follows feedBack's overall trusted-network design — the room key controls *discovery*, not authentication. `/ws/sync/{session_id}` is a broadcast room: anyone who joins with the key (not just the host) can send playback/session messages that every other viewer treats as authoritative. This is only a concern if you share your key with, or otherwise expose your server to, people or devices you don't trust on that network — the same trust boundary as every other unauthenticated route in the app. A real fix would need host-issued per-connection tokens in feedBack core, which isn't planned while the app has no broader auth layer (see [splitscreen#24](https://github.com/get-flashbacks/feedBack-plugin-splitscreen/issues/24)).
 
 ## Settings
 
@@ -261,7 +303,7 @@ Plugins that need to act on individual panels — apply a per-panel setting, mou
 const ss = window.feedBackSplitscreen || window.slopsmithSplitscreen;
 if (ss && ss.isActive()) {
     for (const p of ss.getPanels()) {
-        // p = { index, name, canvas, focused, poppedOut }
+        // p = { index, name, canvas, focused, poppedOut, player_context }
         console.log(p.index, p.name, p.focused);
     }
 }
@@ -270,7 +312,8 @@ if (ss && ss.isActive()) {
 | Member | Returns / effect |
 |--------|------------------|
 | `isActive()` | `true` while split (or in a follower window that has built its panels) |
-| `getPanels()` | `[{ index, name, canvas, focused, poppedOut }]` for the current window — including a **follower window's own panels** once it has split |
+| `getPanels()` | `[{ index, name, canvas, focused, poppedOut, player_context }]` for the current window — including a **follower window's own panels** once it has split. `player_context` is the panel's published player identity, or `null` for a panel that hasn't published one yet *and* for every panel on a host without the per-player identity API (core `7633211`) |
+| `hostFeatures()` | which optional host APIs this feedBack build provides — see [Host compatibility](#host-compatibility) |
 | `panelIndexFor(canvas)` | the panel index a highway `canvas` belongs to (or `null`) |
 | `isCanvasFocused(canvas)` | whether that canvas's panel is the focused one |
 | `panelName(i)` / `setPanelName(i, name)` | read / set a panel's name |
@@ -308,8 +351,9 @@ Messages arrive in the order listed above. Do not start rendering until you rece
 
 ## Requirements
 
-- feedBack with the highway factory (`createHighway()`) and `setRenderer` support exposed on `window` — available in all recent builds (slopsmith#36)
+- feedBack exposing the highway factory (`createHighway()`) on `window` and `setRenderer` support — required for every panel; source-level present since core `v0.3.0-alpha.1`. Optional features (LAN sharing, coordinated rendering, per-player identity) each need their own host API — see [Host compatibility](#host-compatibility)
 - A song with ≥2 arrangements to see any benefit; 1-arrangement songs simply render the same view in every panel
+- **For [Visual Export](https://github.com/get-flashbacks/feedback-plugin-visual-export) users:** split screen `1.14.8` or newer (the release that added `beginOfflineRender()` / `renderFrameAt()` / `endOfflineRender()`) on a host at or after core `f7c761c`. Visual Export drives one shared frame across all panels, so it needs the coordinated-rendering row above — see [visual-export#6](https://github.com/get-flashbacks/feedback-plugin-visual-export/issues/6)
 
 ## Other Plugins
 
diff --git a/plugin.json b/plugin.json
index 557d0db..658f835 100644
--- a/plugin.json
+++ b/plugin.json
@@ -1,7 +1,7 @@
 {
   "id": "splitscreen",
   "name": "Split Screen",
-  "version": "1.14.22",
+  "version": "1.15.0",
   "private": false,
   "standards": ["capability-pipelines.v1", "plugin-runtime-idempotent.v1"],
   "capabilities": {
diff --git a/screen.js b/screen.js
index ce79fdb..c205a9d 100644
--- a/screen.js
+++ b/screen.js
@@ -198,10 +198,35 @@ try {
     let currentFilename = null;
     let arrangements = []; // arrangement list from song_info
 
+    // Every optional host feature is capability-checked, so an older feedBack
+    // runs the plugin perfectly well — which leaves "this host predates the
+    // API" and "this feature was never wired up" looking identical from the
+    // outside. Say each one once so a user (or a bug report) learns which host
+    // they're on without turning on debug logging (splitscreen#69).
+    const _warnedOnce = new Set();
+    /**
+     * Warn Once.
+     * @param {*} id
+     * @param {*} msg
+     */
+    function _warnOnce(id, msg) {
+        if (_warnedOnce.has(id)) return;
+        _warnedOnce.add(id);
+        console.warn('[splitscreen] ' + msg);
+    }
+
     function _playerContextApi() {
         return window.feedBack && window.feedBack.playerContexts;
     }
 
+    // The one definition of "this host can publish a player context". hostFeatures()
+    // and the publish path must agree: a host that exposes the namespace without a
+    // usable upsert would otherwise be reported as supported and then never be.
+    function _hasPlayerContextApi() {
+        const api = _playerContextApi();
+        return !!(api && typeof api.upsert === 'function');
+    }
+
     function _panelRole(panel) {
         if (panel.lyricsMode) return { instrument: 'voice', role: 'karaoke' };
         const arrangement = arrangements[panel.arrIndex] || {};
@@ -217,7 +242,15 @@ try {
 
     function _publishPanelContext(panel) {
         const api = _playerContextApi();
-        if (!api || typeof api.upsert !== 'function' || !panel) return null;
+        if (!_hasPlayerContextApi() || !panel) {
+            if (panel) {
+                _warnOnce('player-identity',
+                    'This feedBack build has no player-context API (core 7633211: '
+                    + 'window.feedBack.playerContexts) — panels stay anonymous to plugins that '
+                    + 'address players by context, and getPanels() reports a null player_context.');
+            }
+            return null;
+        }
         if (!panel.playerId) panel.playerId = `player-${nextPlayerNumber++}`;
         const role = _panelRole(panel);
         const arrangement = arrangements[panel.arrIndex] || {};
@@ -672,11 +705,44 @@ try {
         // to the single-instance main-player path when the user isn't split.
         isActive() { return active; },
 
+        // Which optional feedBack APIs this host actually provides
+        // (splitscreen#69). Every optional feature is capability-checked and
+        // degrades quietly, so this is the honest signal for a consumer
+        // (Visual Export deciding whether it can promise a deterministic
+        // frame) and for bug reports. `splitView` is the required floor —
+        // without it the plugin cannot build a panel at all.
+        hostFeatures() {
+            return {
+                splitView: typeof window.createHighway === 'function',
+                // Core f7c761c — Highway.renderFrame / renderFrameAt /
+                // setExternalFrameDriver. null until a panel highway has been
+                // inspected, so "not observed yet" never reads as "missing".
+                coordinatedFrames: _hostFramesSeen,
+                // Core 7633211 — window.feedBack.playerContexts.
+                playerIdentity: _hasPlayerContextApi(),
+                // Core 03e1c1d — the server's /ws/sync endpoint, which a page
+                // cannot feature-detect: null whenever no share is in flight
+                // (start/stop reset it), so the verdict always belongs to the
+                // share that produced it rather than outliving it.
+                lanRelay: _lanRelayOk,
+            };
+        },
+
         // Offline exporters supply each chart timestamp themselves. Suspend
         // the live audio-clock loop for that short render pass so all panels
         // paint the same requested instant, then restore it in endOfflineRender.
         beginOfflineRender() {
             if (!active || _offlineRenderActive) return;
+            _recordHostFrameApi();
+            // Same predicate renderFrameAt() validates below, so this names the
+            // gap the export will actually hit rather than a nearby one.
+            if (!panels.every((panel) => panel.hw && typeof panel.hw.renderFrameAt === 'function')) {
+                _warnOnce('coordinated-frames',
+                    'This feedBack build cannot render an offline frame for split panels (core '
+                    + 'f7c761c: Highway.renderFrameAt / renderFrame / setExternalFrameDriver) — '
+                    + 'renderFrameAt() will keep returning false, so no shared export frame can '
+                    + 'be produced.');
+            }
             _offlineRenderActive = true;
             _pauseLiveTimeSyncForOfflineRender();
         },
@@ -3739,13 +3805,31 @@ try {
     let _offlineRenderActive = false;
     const _frameRenderFailures = new WeakSet();
 
+    // Whether the running host exposes the coordinated-frame API (core
+    // f7c761c). Recorded from the first panel highways we inspect so
+    // hostFeatures() can report it without probing a global the plugin never
+    // touches; null until then (splitscreen#69).
+    let _hostFramesSeen = null;
+
     function _canDriveFrames(panel) {
         return !!(panel && panel.hw
             && typeof panel.hw.setExternalFrameDriver === 'function'
             && typeof panel.hw.renderFrame === 'function');
     }
 
+    // One rAF owns every panel frame when the host hands us that control
+    // (setExternalFrameDriver + renderFrame), and an offline export drives the
+    // panels itself (renderFrameAt) — so the host has the whole API, or the
+    // coordinated-rendering feature is only half there. Recorded once: the
+    // first panels we see are as good an answer as any later ones.
+    function _recordHostFrameApi() {
+        if (_hostFramesSeen !== null || !panels.length) return;
+        _hostFramesSeen = panels.some(_canDriveFrames)
+            && panels.every((panel) => panel.hw && typeof panel.hw.renderFrameAt === 'function');
+    }
+
     function _startDeterministicFrames() {
+        _recordHostFrameApi();
         // Keep the coordinator state separate from the transient rAF handle:
         // the handle is intentionally null while tick() is executing.
         _deterministicFramesActive = true;
@@ -3924,7 +4008,14 @@ try {
     //  crashes or reloads resumes publishing on the same key and viewers
     //  reconnect without interaction.
     // ══════════════════════════════════════════════════════════════════════
-    let _lanShare = null;          // { key, cfg, ws, retryTimer, backoffMs } | null
+    let _lanShare = null;          // { key, cfg, ws, retryTimer, backoffMs, opened, failures } | null
+    // /ws/sync is a server endpoint, so a page cannot feature-detect it — the
+    // socket's own outcome is the only evidence (and what hostFeatures()
+    // reports). Attempts that keep failing without ever opening mean this host
+    // predates the relay (core 03e1c1d), so say so once instead of retrying
+    // silently forever (splitscreen#69).
+    const LAN_SHARE_DIAG_FAILURES = 3;
+    let _lanRelayOk = null;
     let _lanLastTimeSentPerf = 0;
     // ~20 Hz on the network leg (the local BroadcastChannel stays ≤60 Hz).
     // The follower clock interpolates between messages, so this is visually
@@ -3963,15 +4054,48 @@ try {
         };
     }
 
+    /**
+     * Count an attempt that never opened, and report a missing relay once the
+     * threshold is crossed. Every failure route funnels through here —
+     * including a WebSocket constructor that throws outright (mixed content,
+     * a blocked scheme), which never reaches onclose and would otherwise
+     * retry forever in silence.
+     */
+    function _lanNoteConnectFailure() {
+        // A share that opened once proves the relay exists, so a later drop is
+        // an ordinary network blip and the backoff loop is the right answer.
+        if (!_lanShare || _lanShare.opened) return;
+        _lanShare.failures = (_lanShare.failures || 0) + 1;
+        if (_lanShare.failures !== LAN_SHARE_DIAG_FAILURES) return;
+        _lanRelayOk = false;
+        _warnOnce('lan-relay',
+            'This feedBack server does not answer the /ws/sync relay — LAN sharing needs a '
+            + 'host with that endpoint (core 03e1c1d, #1030). Everything else keeps working; '
+            + 'viewers can never join this share.');
+        _showMainToast('This feedBack server has no /ws/sync relay — LAN sharing needs a newer host (core 03e1c1d, #1030).');
+    }
+
     /**
      * Lan Connect.
      */
     function _lanConnect() {
         if (!_lanShare || _lanShare.ws) return;
         let ws;
-        try { ws = new WebSocket(getSyncUrl(_lanShare.key)); } catch (_) { _lanScheduleReconnect(); return; }
+        try {
+            ws = new WebSocket(getSyncUrl(_lanShare.key));
+        } catch (_) {
+            _lanNoteConnectFailure();
+            _lanScheduleReconnect();
+            return;
+        }
         _lanShare.ws = ws;
-        ws.onopen = () => { if (_lanShare) _lanShare.backoffMs = 1000; };
+        ws.onopen = () => {
+            if (!_lanShare) return;
+            _lanShare.backoffMs = 1000;
+            _lanShare.failures = 0;
+            _lanShare.opened = true;
+            _lanRelayOk = true;
+        };
         ws.onmessage = (ev) => {
             if (!_lanShare) return;
             let msg = null;
@@ -3984,6 +4108,7 @@ try {
         ws.onclose = () => {
             if (!_lanShare || _lanShare.ws !== ws) return;
             _lanShare.ws = null;
+            _lanNoteConnectFailure();
             _lanScheduleReconnect();
         };
         ws.onerror = () => { try { ws.close(); } catch (_) {} };
@@ -4024,7 +4149,10 @@ try {
         }
         const key = ensureRoomKey();
         const cfg = panel ? _lanCaptureCfg(panel) : null;
-        _lanShare = { key, cfg, ws: null, retryTimer: null, backoffMs: 1000 };
+        _lanShare = { key, cfg, ws: null, retryTimer: null, backoffMs: 1000, opened: false, failures: 0 };
+        // This share answers for itself: a previous share's verdict says
+        // nothing about whether the socket this one opens on gets a relay.
+        _lanRelayOk = null;
         try {
             localStorage.setItem('splitscreenLanShareActive', 'true');
             localStorage.setItem('splitscreenLanShareCfg', JSON.stringify(cfg));
@@ -4043,6 +4171,7 @@ try {
         const s = _lanShare;
         const ws = s.ws;
         _lanShare = null;                    // null first: onclose must not reconnect
+        _lanRelayOk = null;                  // the verdict dies with its share
         if (s.retryTimer) clearTimeout(s.retryTimer);
         // Send the terminal share-ended message directly against the captured
         // `ws`, not via _lanSend() — that reads the module-level _lanShare,
@@ -4111,7 +4240,7 @@ try {
             if (localStorage.getItem('splitscreenLanShareActive') !== 'true') return;
             let cfg = null;
             try { cfg = JSON.parse(localStorage.getItem('splitscreenLanShareCfg') || 'null'); } catch (_) {}
-            _lanShare = { key: ensureRoomKey(), cfg, ws: null, retryTimer: null, backoffMs: 1000 };
+            _lanShare = { key: ensureRoomKey(), cfg, ws: null, retryTimer: null, backoffMs: 1000, opened: false, failures: 0 };
             _lanConnect();
             _ensureMainBroadcasterAndListener();
             _startPopupBroadcaster();
@@ -6032,6 +6161,8 @@ try {
             _setWrapForTest(next) { wrap = next; },
             stopLanShare,
             startLanShare,
+            _lanConnect,
+            LAN_SHARE_DIAG_FAILURES,
             _lanSend,
             _maybeResumeLanShare,
             _setCurrentFilenameForTest(next) { currentFilename = next; },
diff --git a/tests/screen.test.js b/tests/screen.test.js
index 036440b..f8cf3ad 100644
--- a/tests/screen.test.js
+++ b/tests/screen.test.js
@@ -3773,3 +3773,315 @@ test('_startFollowerInterp is idempotent — a second call while already running
         global.cancelAnimationFrame = originalCaf;
     }
 });
+
+// ── Host-feature diagnostics (splitscreen#69) ──────────────────────────────
+// Optional features are capability-checked, so an older host runs the plugin
+// fine — but silently. These tests pin the two halves of the fix: hostFeatures()
+// reports what the running core actually provides, and each unsupported feature
+// says so once, naming the core commit that added the API it wants. Without a
+// diagnostic, "your host is too old" and "this feature is broken" are the same
+// bug report.
+
+// console.warn is replaced (not the whole console) so the runner keeps its own
+// output; the captured lines are what the assertions below read.
+function capturingWarnings(body) {
+    const original = console.warn;
+    const warnings = [];
+    console.warn = (...args) => { warnings.push(args.join(' ')); };
+    try {
+        body(warnings);
+    } finally {
+        console.warn = original;
+    }
+    return warnings;
+}
+
+// A missing optional feature is a user-facing dead end, not just a console
+// line, so the relay diagnosis also toasts. The harness's createElement stub is
+// wrapped to keep whatever text _showMainToast put on the node it built.
+function capturingToasts(body) {
+    const original = global.document.createElement;
+    const toasts = [];
+    global.document.createElement = (tag) => {
+        const el = original(tag);
+        toasts.push(el);
+        return el;
+    };
+    try {
+        body();
+    } finally {
+        global.document.createElement = original;
+    }
+    return toasts.map((el) => el.textContent).filter(Boolean);
+}
+
+test('hostFeatures reports the host as missing every optional feature on a bare core', () => {
+    const mod = freshPlugin();
+    assert.deepEqual(global.window.slopsmithSplitscreen.hostFeatures(), {
+        splitView: false,          // no window.createHighway in the Node harness
+        coordinatedFrames: null,   // no panel highway inspected yet — not "missing"
+        playerIdentity: false,
+        lanRelay: null,            // /ws/sync is a server endpoint: not probed yet
+    });
+});
+
+test('hostFeatures reflects window.createHighway for the required split-view floor', () => {
+    const mod = freshPlugin();
+    const original = global.window.createHighway;
+    global.window.createHighway = () => ({});
+    try {
+        assert.equal(global.window.slopsmithSplitscreen.hostFeatures().splitView, true);
+    } finally {
+        if (original === undefined) delete global.window.createHighway;
+        else global.window.createHighway = original;
+    }
+});
+
+test('hostFeatures reports playerIdentity from window.feedBack.playerContexts', () => {
+    const mod = freshPlugin();
+    global.window.feedBack = { playerContexts: { upsert() {}, leave() {} } };
+    assert.equal(global.window.slopsmithSplitscreen.hostFeatures().playerIdentity, true);
+});
+
+test('hostFeatures reports playerIdentity false for a namespace it cannot publish through', () => {
+    const mod = freshPlugin();
+    // A host exposing the namespace without upsert() is not a usable
+    // player-context API: reporting true here would promise an identity the
+    // publish path silently drops.
+    global.window.feedBack = { playerContexts: { leave() {} } };
+    assert.equal(global.window.slopsmithSplitscreen.hostFeatures().playerIdentity, false);
+});
+
+test('hostFeatures reports coordinatedFrames true once a panel highway exposes the frame API', () => {
+    const mod = freshPlugin();
+    mod._setActiveForTest(true);
+    mod._setPanelsForTest([{ hw: { setExternalFrameDriver() {}, renderFrame() {}, renderFrameAt() {} } }]);
+
+    const warnings = capturingWarnings(() => {
+        global.window.slopsmithSplitscreen.beginOfflineRender();
+    });
+
+    assert.deepEqual(warnings, []);
+    assert.equal(global.window.slopsmithSplitscreen.hostFeatures().coordinatedFrames, true);
+});
+
+test('hostFeatures reports coordinatedFrames false once a panel highway lacks the frame API', () => {
+    const mod = freshPlugin();
+    mod._setActiveForTest(true);
+    mod._setPanelsForTest([{ hw: {} }]);
+
+    capturingWarnings(() => {
+        global.window.slopsmithSplitscreen.beginOfflineRender();
+    });
+
+    assert.equal(global.window.slopsmithSplitscreen.hostFeatures().coordinatedFrames, false);
+});
+
+test('hostFeatures reports coordinatedFrames false when only the live half of the frame API is present', () => {
+    const mod = freshPlugin();
+    mod._setActiveForTest(true);
+    // setExternalFrameDriver + renderFrame without renderFrameAt: the live
+    // coordinator works, an offline export cannot. The feature is half there,
+    // and the probe must not claim it.
+    mod._setPanelsForTest([{ hw: { setExternalFrameDriver() {}, renderFrame() {} } }]);
+
+    const warnings = capturingWarnings(() => {
+        global.window.slopsmithSplitscreen.beginOfflineRender();
+    });
+
+    assert.equal(warnings.length, 1);
+    assert.equal(global.window.slopsmithSplitscreen.hostFeatures().coordinatedFrames, false);
+});
+
+test('beginOfflineRender warns once — naming core f7c761c — when no panel highway can render a frame at a time', () => {
+    const mod = freshPlugin();
+    mod._setActiveForTest(true);
+    mod._setPanelsForTest([{ hw: {} }, { hw: { setExternalFrameDriver() {} } }]);
+
+    // Each pass is closed before the next one begins: a second beginOfflineRender()
+    // while one is already active returns early, so back-to-back calls would
+    // leave the dedup unexercised. setInterval is stubbed because endOfflineRender
+    // restarts the live audio-clock loop.
+    const warnings = withGlobals({ setInterval: () => 0 }, () => capturingWarnings(() => {
+        global.window.slopsmithSplitscreen.beginOfflineRender();
+        global.window.slopsmithSplitscreen.endOfflineRender();
+        global.window.slopsmithSplitscreen.beginOfflineRender();
+    }));
+
+    assert.equal(warnings.length, 1, 'the same host gap must not be re-reported per call');
+    assert.match(warnings[0], /f7c761c/);
+});
+
+test('beginOfflineRender stays silent when every panel highway exposes the frame API', () => {
+    const mod = freshPlugin();
+    mod._setActiveForTest(true);
+    mod._setPanelsForTest([{ hw: { setExternalFrameDriver() {}, renderFrame() {}, renderFrameAt() {} } }]);
+
+    const warnings = capturingWarnings(() => {
+        global.window.slopsmithSplitscreen.beginOfflineRender();
+    });
+
+    assert.deepEqual(warnings, []);
+});
+
+test('setPlayerContext warns once — naming core 7633211 — on a host with no player-context API', () => {
+    const mod = freshPlugin();
+    mod._setPanelsForTest([{ hw: {} }]);
+
+    const warnings = capturingWarnings(() => {
+        global.window.slopsmithSplitscreen.setPlayerContext(0, { skill: 'overall' });
+        global.window.slopsmithSplitscreen.setPlayerContext(0, { skill: 'lead' });
+    });
+
+    assert.equal(warnings.length, 1, 'a host without the API must not warn on every panel publish');
+    assert.match(warnings[0], /7633211/);
+});
+
+test('setPlayerContext stays silent on a host that provides player-context', () => {
+    const mod = freshPlugin();
+    const upserts = [];
+    global.window.feedBack = {
+        playerContexts: { upsert: (input) => { upserts.push(input); return input; }, leave() {} },
+    };
+    mod._setPanelsForTest([{ hw: {} }]);
+
+    const warnings = capturingWarnings(() => {
+        global.window.slopsmithSplitscreen.setPlayerContext(0, { skill: 'lead' });
+    });
+
+    assert.deepEqual(warnings, []);
+    assert.equal(upserts.length, 1);
+});
+
+test('a relay socket that never opens is diagnosed once, then reconnect attempts keep going', () => {
+    const mod = freshPlugin();
+    const opened = [];
+    withGlobals({
+        BroadcastChannel: undefined, // absent → _ssChannel's null path — see section comment
+        WebSocket: fakeRelaySocket(opened),
+        setTimeout: () => 0,          // the backoff timer must not fire for real
+    }, () => {
+        let warnings;
+        const toasts = capturingToasts(() => {
+            warnings = capturingWarnings(() => {
+                mod.startLanShare(fakePanel());
+                // Each close drops _lanShare.ws, so the reconnect has to be driven
+                // explicitly — exactly what the backoff timer does in the browser.
+                for (let i = 0; i < mod.LAN_SHARE_DIAG_FAILURES - 1; i++) {
+                    opened[opened.length - 1].onclose();
+                    assert.equal(global.window.slopsmithSplitscreen.hostFeatures().lanRelay, null,
+                        'a socket that has not failed enough times yet proves nothing');
+                    mod._lanConnect();
+                }
+                opened[opened.length - 1].onclose(); // the failure that crosses the threshold
+                mod._lanConnect();
+            });
+        });
+
+        assert.equal(warnings.length, 1, 'the missing-relay diagnosis must not repeat on every retry');
+        assert.match(warnings[0], /\/ws\/sync/);
+        assert.match(warnings[0], /03e1c1d/);
+        // A console line nobody reads is not a diagnostic: a viewer who opens
+        // the share dialog and watches nothing join needs this on screen.
+        assert.equal(toasts.length, 1, 'the missing-relay diagnosis must reach the user, not just the console');
+        assert.match(toasts[0], /\/ws\/sync/);
+        assert.match(toasts[0], /03e1c1d/);
+        assert.equal(global.window.slopsmithSplitscreen.hostFeatures().lanRelay, false);
+        assert.equal(opened.length, mod.LAN_SHARE_DIAG_FAILURES + 1,
+            'the diagnosis must not stop the reconnect loop — a server upgraded mid-share recovers on its own');
+    });
+});
+
+test('a WebSocket that cannot even be constructed is diagnosed like a socket that never opens', () => {
+    const mod = freshPlugin();
+    let scheduled = 0;
+    withGlobals({
+        BroadcastChannel: undefined,
+        // Mixed content or a blocked scheme: the constructor throws, so there is
+        // no socket and therefore no onclose to notice it.
+        WebSocket: function () { throw new Error('blocked'); },
+        setTimeout: () => { scheduled++; return 0; },
+    }, () => {
+        const warnings = capturingWarnings(() => {
+            mod.startLanShare(fakePanel());
+            for (let i = 0; i < mod.LAN_SHARE_DIAG_FAILURES - 1; i++) mod._lanConnect();
+        });
+
+        assert.equal(warnings.length, 1, 'a throw path that skipped the counter would retry in silence forever');
+        assert.match(warnings[0], /03e1c1d/);
+        assert.equal(global.window.slopsmithSplitscreen.hostFeatures().lanRelay, false);
+        assert.ok(scheduled >= mod.LAN_SHARE_DIAG_FAILURES, 'each attempt must still back off and retry');
+    });
+});
+
+test('a relay socket that opened once is not reported as missing after a later drop', () => {
+    const mod = freshPlugin();
+    const opened = [];
+    withGlobals({
+        BroadcastChannel: undefined,
+        WebSocket: fakeRelaySocket(opened),
+        setTimeout: () => 0,
+    }, () => {
+        const warnings = capturingWarnings(() => {
+            mod.startLanShare(fakePanel());
+            opened[0].onopen();
+            opened[0].onclose();
+            mod._lanConnect();
+            opened[1].onclose();
+        });
+
+        assert.deepEqual(warnings, [], 'a host that connected once is serving the relay — a drop is a network blip');
+        assert.equal(global.window.slopsmithSplitscreen.hostFeatures().lanRelay, true);
+    });
+});
+
+test('a finished share takes its relay verdict with it', () => {
+    const mod = freshPlugin();
+    const opened = [];
+    withGlobals({
+        BroadcastChannel: undefined,
+        WebSocket: fakeRelaySocket(opened),
+        setTimeout: () => 0,
+    }, () => {
+        capturingWarnings(() => {
+            mod.startLanShare(fakePanel());
+            opened[0].onopen();
+            assert.equal(global.window.slopsmithSplitscreen.hostFeatures().lanRelay, true);
+
+            mod.stopLanShare();
+            assert.equal(global.window.slopsmithSplitscreen.hostFeatures().lanRelay, null,
+                'no share is in flight, so there is no verdict to report');
+
+            mod.startLanShare(fakePanel());
+            assert.equal(global.window.slopsmithSplitscreen.hostFeatures().lanRelay, null,
+                'a new share knows nothing about the relay until its own socket opens');
+        });
+    });
+});
+
+test('a share diagnosed as missing does not report the old verdict for the next one', () => {
+    const mod = freshPlugin();
+    const opened = [];
+    withGlobals({
+        BroadcastChannel: undefined,
+        WebSocket: fakeRelaySocket(opened),
+        setTimeout: () => 0,
+    }, () => {
+        capturingWarnings(() => {
+            mod.startLanShare(fakePanel());
+            for (let i = 0; i < mod.LAN_SHARE_DIAG_FAILURES; i++) {
+                opened[opened.length - 1].onclose();
+                mod._lanConnect();
+            }
+            assert.equal(global.window.slopsmithSplitscreen.hostFeatures().lanRelay, false);
+
+            // A server upgraded (or a share that was simply stopped) between
+            // the two must not leave the next one looking like a dead relay.
+            mod.stopLanShare();
+            mod.startLanShare(fakePanel());
+            assert.equal(global.window.slopsmithSplitscreen.hostFeatures().lanRelay, null);
+            opened[opened.length - 1].onopen();
+            assert.equal(global.window.slopsmithSplitscreen.hostFeatures().lanRelay, true);
+        });
+    });
+});