fix(media_player,config_flow): close the batch review's O2 and O3 (t17)

Both observations from the t8-t12 batch review, settled by execution rather than
by argument.

O2 — WHICH STATES MAY CARRY A NOW-PLAYING ROW. The review read
`extra_state_attributes` and argued the row publishes the entity state verbatim,
so `now_playing_state: on` is reachable, while the README documents only
playing/paused/buffering/idle; t10's author had reported that `on` and `off`
publish no row at all. The probe settles both halves:

* the t10 account is true on the NATURAL ladder — `on` means no source reported a
  power or playback fact, and every tier that can produce a reading sets
  `reported = True` in the ladder, so the two cannot meet;
* the review is right about the RULE. It was "publish unless the state is off", an
  assumption nothing enforced: forcing the ladder to `on` (and to `standby`, which
  the README does not even mention) published `now_playing_state: on`/`standby`
  beside a real title.

So the rule is now explicit — `NOW_PLAYING_STATE_VALUES = ("playing", "paused",
"buffering", "idle")` — and a reading is dropped whole when the entity state is
anything else, exactly as `off` always dropped it. Nothing legitimate is lost: a
tier only ever answers in one of those four (`idle` for "reported, nothing
playing", which is where the foreground tier's remembered-playback bridge lands).
The README says the same thing in the table row and in prose, and
tests/test_now_playing_publication.py walks EVERY `MediaPlayerState` member with a
reading present (the four publish themselves; on/off/standby publish nothing),
then reads the four values back OUT OF THE README and compares them to the
constant, so code and docs cannot drift again.

O3 — A REJECTED APP PASTE NAMES ITS BAD LINES. The bulk paste was all-or-nothing
and reported a generic `invalid_app_map`, so a 30-row paste with one typo had to
be bisected by hand. `_app_map_parse` now returns `(map | None, problems)` where
each problem carries the 1-based line NUMBER, the line as the user typed it, and
why (empty/space-bearing package, empty name, space in the icon), and the
rejection puts them in the form's `description_placeholders["invalid_lines"]`,
which the error copy interpolates — capped at 4 named lines with the remaining
count, so the message stays readable. The map is still None when anything is
wrong (never half-stored) and the detail is cleared as soon as a paste parses.
The single-row editor is untouched and keeps its own `invalid_app_row`; a test
asserts the new per-line report and `_valid_app_row` accept and refuse the same
rows, so a paste and a typed row cannot disagree.

Verify: 794 passed / 4 skipped, 795 passed / 3 skipped (with androidtvremote2),
ruff clean.

tests/test_now_playing_publication.py

@@ -0,0 +1,175 @@
+"""tests/test_now_playing_publication.py — which entity states may carry a reading (t17/O2).
+
+THE OBSERVATION THIS CLOSES. The batch review read `extra_state_attributes` and
+argued the now-playing row publishes "the entity state verbatim", so a dashboard
+could see `now_playing_state: on`, while the README documents only `playing`,
+`paused`, `buffering` and `idle`. t10's author had reported the opposite (an
+`on` or `off` device publishes no row at all). Both accounts were about a
+different thing, and this file settles it BY EXECUTION:
+
+* the t10 account is true for the NATURAL ladder — `on` means no source reported
+  a power or playback fact, and a reading only exists when a tier answered, so
+  the two cannot meet in practice;
+* the review was right about the RULE, which was "publish unless the state is
+  `off`" — an unenforced assumption, and the probe below shows it publishing
+  `now_playing_state: on` (and `standby`) the moment a reading exists beside that
+  state. `standby` is not even in the README, and nothing in the code stopped it.
+
+WHAT WAS CHANGED. The publication rule now names the four values a reading may
+carry (`NOW_PLAYING_STATE_VALUES`) and drops the reading when the entity state is
+anything else, exactly as a state of `off` always did. The README says the same
+thing in words. The two tests here walk EVERY ``MediaPlayerState`` member and
+compare the README against the code constant, so neither can drift again.
+"""
+
+from __future__ import annotations
+
+import re
+import sys
+from pathlib import Path
+
+sys.path.insert(0, str(Path(__file__).resolve().parent))
+import entity_stublib  # noqa: E402
+import pytest  # noqa: E402
+from entity_stublib import MediaPlayerState, load_entity_modules  # noqa: E402
+
+
+@pytest.fixture(autouse=True)
+def scoped_entity_stubs():
+    """Container for the HA stubs + the loaded entity modules (t7 discipline)."""
+    snapshot = entity_stublib.snapshot_modules()
+    entity_stublib.install()
+    yield load_entity_modules()
+    entity_stublib.restore_modules(snapshot)
+
+
+README = Path(__file__).resolve().parent.parent / "README.md"
+
+#: The states the README documents, read from the file itself (never from the
+#: constant under test) so a code change cannot silently rewrite the pin.
+def _documented_states() -> set[str]:
+    text = README.read_text(encoding="utf-8")
+    row = re.search(r"^\| `now_playing_state` \|(.*)\|$", text, re.M)
+    assert row, "the README's now_playing_state table row is gone"
+    return {value for value in re.findall(r"`([a-z_]+)`", row.group(1)) if value != "on"}
+
+
+def _player_for_state(modules, member):
+    """A player whose ladder answers `member` while a reading is available.
+
+    The state is forced by patching the ``state`` property, which is the only way
+    to ask "what would be published IF the ladder ever answered this?" — the
+    question the review raised. A reading is genuine: the foreground tier answers
+    it through the same code path production uses (``_now_playing``).
+    """
+    from test_command_routing import TIVIMATE_PACKAGE, _now_playing_attrs, _state_player
+
+    player, _manager = _state_player(modules, foreground=TIVIMATE_PACKAGE)
+    player._last_channel = "101"
+    media_player_cls = type(player)
+    original = media_player_cls.__dict__.get("state")
+    media_player_cls.state = property(lambda self, forced=member: forced)
+    try:
+        reading = player._now_playing()
+        attrs = _now_playing_attrs(player)
+    finally:
+        if original is None:  # pragma: no cover - the class always declares it
+            del media_player_cls.state
+        else:
+            media_player_cls.state = original
+    return reading, attrs
+
+
+class TestThePublicationRule:
+    """One reading in, one row out — for EVERY member the enum has."""
+
+    def test_the_documented_four_publish_the_reading(self, scoped_entity_stubs):
+        modules = scoped_entity_stubs
+        documented = {
+            MediaPlayerState.PLAYING: "playing",
+            MediaPlayerState.PAUSED: "paused",
+            MediaPlayerState.BUFFERING: "buffering",
+            MediaPlayerState.IDLE: "idle",
+        }
+
+        for member, value in documented.items():
+            reading, attrs = _player_for_state(modules, member)
+
+            assert reading, f"{value}: the fixture must have a reading to publish"
+            assert attrs["now_playing_state"] == value
+            assert attrs["now_playing_title"] == "101"
+
+    def test_a_state_outside_the_documented_four_publishes_nothing(self, scoped_entity_stubs):
+        """The review's case, executed: `on` publishes no row — by construction now."""
+        modules = scoped_entity_stubs
+        reading_available = {
+            MediaPlayerState.ON: "on",
+            MediaPlayerState.OFF: "off",
+            MediaPlayerState.STANDBY: "standby",
+        }
+
+        for member, value in reading_available.items():
+            reading, attrs = _player_for_state(modules, member)
+
+            assert reading, f"{value}: the fixture still HAS a reading (that is the point)"
+            assert attrs == {}, f"{value} must publish no now-playing row, got {attrs}"
+
+    def test_every_enum_member_is_accounted_for(self, scoped_entity_stubs):
+        """The matrix is exhaustive: no state is left untested as the enum grows."""
+        modules = scoped_entity_stubs
+        published = {}
+        for member in MediaPlayerState:
+            reading, attrs = _player_for_state(modules, member)
+            published[member.value] = attrs.get("now_playing_state")
+
+        assert set(published) == {member.value for member in MediaPlayerState}
+        for value in ("playing", "paused", "buffering", "idle"):
+            assert published[value] == value
+        for value in ("on", "off", "standby"):
+            assert published[value] is None, f"{value} published a state: {published[value]}"
+
+    def test_the_gate_reads_the_named_constant(self, scoped_entity_stubs):
+        """The rule is the constant, not a hard-coded pair of states."""
+        from nsh.media_player import NOW_PLAYING_STATE_VALUES
+
+        assert NOW_PLAYING_STATE_VALUES == ("playing", "paused", "buffering", "idle")
+        assert self._published_for(scoped_entity_stubs, MediaPlayerState.ON) == {}
+
+    @staticmethod
+    def _published_for(modules, member) -> dict:
+        _reading, attrs = _player_for_state(modules, member)
+        return attrs
+
+
+class TestTheReadmeAgrees:
+    """The docs and the code say the same four values (t17/O2's anti-drift pin)."""
+
+    def test_the_table_row_lists_exactly_the_constant(self, scoped_entity_stubs):
+        from nsh.media_player import NOW_PLAYING_STATE_VALUES
+
+        assert _documented_states() == set(NOW_PLAYING_STATE_VALUES)
+
+    def test_the_prose_names_the_same_set_and_excludes_on(self, scoped_entity_stubs):
+        text = README.read_text(encoding="utf-8")
+        from nsh.media_player import NOW_PLAYING_STATE_VALUES
+
+        paragraph = re.search(
+            r"\*\*`now_playing_state` is one of FOUR values[^*]*\*\*(.*?)\n-", text, re.S
+        )
+        assert paragraph, "the README's now_playing_state paragraph is gone"
+        body = paragraph.group(1)
+        # the sentence that names the set, read apart from the sentence that
+        # excludes `on`/`off` — otherwise the exclusion would look like a member
+        sentence = re.search(r"full set is ([^.]+)\.", body)
+        assert sentence, "the README no longer names the full set"
+        named = set(re.findall(r"`([a-z_]+)`", sentence.group(1)))
+        assert named == set(NOW_PLAYING_STATE_VALUES), named
+        assert "`on`" in body and "not one of them" in text, (
+            "the paragraph must say `on` is excluded"
+        )
+
+    def test_the_off_and_on_prose_still_says_no_rows(self, scoped_entity_stubs):
+        text = README.read_text(encoding="utf-8")
+
+        assert "**A device that reads `off` publishes none of them.**" in text
+        assert "publishes none either" in text

tests/test_standalone_setup.py

@@ -706,6 +706,160 @@ class TestAppIconColumn:
         assert "app_name_map" not in flow._options  # nothing half-stored
 
 
+class TestAppPasteRejectionNamesTheLine:
+    """t17/O3: a rejected paste says WHICH line is wrong, not just that one is.
+
+    The all-or-nothing rule stays (nothing is half-stored), but the message now
+    quotes each offending line with its number and the reason, so a 30-row paste
+    with one typo is fixed instead of bisected by hand. The row editor's own
+    single-row behaviour is pinned alongside, because neither half may regress.
+    """
+
+    def _flow(self, tmp_path, options=None):
+        module = _form_module()
+        entry = SimpleNamespace(options=dict(options or {}), title="Shield")
+        flow = module.NvidiaShieldOptionsFlow()
+        flow.config_entry = entry  # t29 G3b: HA assigns config_entry
+        flow.hass = FakeHass(str(tmp_path))
+        flow.async_show_form = lambda **kwargs: {"type": "form", **kwargs}
+        flow.async_create_entry = lambda **kwargs: {"type": "create_entry", **kwargs}
+        return module, flow
+
+    async def test_the_message_names_the_numbered_bad_line(self, tmp_path):
+        module, flow = self._flow(tmp_path)
+
+        result = await _options_submit(
+            flow,
+            {
+                "app_name_map": (
+                    "ar.tvplayer.tv=TiviMate\n"
+                    "com.no.equals.sign\n"
+                    "com.netflix.ninja=Netflix"
+                )
+            },
+        )
+
+        assert result["errors"] == {"base": "invalid_app_map"}
+        detail = result["description_placeholders"]["invalid_lines"]
+        # the SECOND line is the bad one, and it is quoted as the user wrote it
+        assert "line 2" in detail
+        assert "com.no.equals.sign" in detail
+        assert "no '='" in detail
+        assert "line 1" not in detail and "line 3" not in detail
+        assert "app_name_map" not in flow._options  # still all-or-nothing
+
+    async def test_every_bad_line_is_named_up_to_the_cap(self, tmp_path):
+        module, flow = self._flow(tmp_path)
+
+        result = await _options_submit(
+            flow,
+            {
+                "app_name_map": (
+                    "com.good.one=Name\n"
+                    "com.bad.space in id=Name\n"
+                    "com.bad.blank=\n"
+                    "com.bad.icon=Name|http://x y/z.png"
+                )
+            },
+        )
+
+        detail = result["description_placeholders"]["invalid_lines"]
+        assert "line 2" in detail and "package id" in detail
+        assert "line 3" in detail and "name after the '='" in detail
+        assert "line 4" in detail and "icon after the '|'" in detail
+        assert "line 1" not in detail  # no false accusation
+
+    async def test_a_long_bad_paste_is_capped_and_counts_the_rest(self, tmp_path):
+        module, flow = self._flow(tmp_path)
+
+        result = await _options_submit(
+            flow,
+            {"app_name_map": "\n".join(f"no-equals-{n}" for n in range(1, 8))},
+        )
+
+        detail = result["description_placeholders"]["invalid_lines"]
+        assert module.APP_MAP_PROBLEM_LIMIT == 4
+        assert "line 4" in detail
+        assert "line 5" not in detail
+        assert "3 more line(s)" in detail, detail
+
+    async def test_a_blank_line_is_not_a_row_and_never_a_problem(self, tmp_path):
+        module, flow = self._flow(tmp_path)
+
+        await _options_submit(
+            flow, {"app_name_map": "\n\nar.tvplayer.tv=TiviMate\n\n"}
+        )
+
+        assert flow._options["app_name_map"] == {"ar.tvplayer.tv": "TiviMate"}
+
+    async def test_a_good_paste_clears_the_previous_rejection(self, tmp_path):
+        module, flow = self._flow(tmp_path)
+        await _options_submit(flow, {"app_name_map": "com.bad row=Name"})
+        assert flow._app_map_problems
+
+        result = await _options_submit(flow, {"app_name_map": "com.good.one=Name"})
+
+        assert result["type"] == "menu"  # back at the Apps screen, nothing left over
+        assert flow._app_map_problems == ""
+        assert flow._options_dict["app_name_map"] == {"com.good.one": "Name"}
+
+    async def test_the_parser_reports_problems_in_a_pure_call(self):
+        module = _form_module()
+
+        app_map, problems = module._app_map_parse("com.a=One\nbroken\ncom.b=", {})
+
+        assert app_map is None
+        assert [number for number, _line, _why in problems] == [2, 3]
+        assert problems[0][1] == "broken"
+        assert "no '='" in problems[0][2][0]
+        assert "name after the '='" in problems[1][2][0]
+        # and a valid paste reports nothing at all
+        assert module._app_map_parse("com.a=One", {}) == ({"com.a": "One"}, [])
+
+    async def test_the_report_and_the_wrapper_cannot_disagree(self):
+        module = _form_module()
+        icons: dict[str, str] = {}
+
+        assert module._app_map_from_text("com.a=One|http://x/i.png", icons) == {
+            "com.a": "One"
+        }
+        assert icons == {"com.a": "http://x/i.png"}
+        assert module._app_map_from_text("com.bad row=One", {}) is None
+
+    def test_the_paste_report_and_the_row_editor_apply_the_same_rule(self):
+        """t17/O3 rider: the one-row path is unchanged, and both paths agree.
+
+        The row editor is driven in tests/test_config_flow_ux.py
+        (``test_an_invalid_row_is_refused_and_stores_nothing``); what matters HERE
+        is that the new per-line report cannot reject a row the editor accepts (or
+        wave one through that the editor refuses) — otherwise a paste and a typed
+        row would disagree about the same text.
+        """
+        module = _form_module()
+        rows = [
+            ("com.a", "Alpha", "", True),
+            ("com.a", "Alpha", "http://x/i.png", True),
+            ("com.bad row", "Alpha", "", False),
+            ("", "Alpha", "", False),
+            ("com.a", "", "", False),
+            ("com.a", "Alpha", "http://x y/i.png", False),
+        ]
+
+        for package, name, icon, valid in rows:
+            assert module._valid_app_row(package, name, icon) is valid, (package, name)
+            assert bool(module._app_row_problems(package, name, icon)) is not valid, (
+                package,
+                name,
+                icon,
+            )
+
+        # the paste path STRIPS before checking, which is why a whitespace-only
+        # name cannot get in through it either (t49: nothing blank is stored)
+        app_map, problems = module._app_map_parse("com.a=   ", {})
+        assert app_map is None
+        assert problems[0][2] == ["the name after the '=' is empty"]
+
+
 class TestChannelEntryOptions:
     """P5-2: digit-delay + optional send-enter on the options page."""