feat(keys): j/k and the arrows walk the channel, playlist and download lists

Third and last slice of the E11 keyboard layer (S4c). S4a/S4b covered every card grid and rail; the
table-shaped pages — the channel manager, a playlist, the download center — were still Tab-stop
country: a channel row carries a priority stepper, four action buttons and a tag picker before the next
row's name.

- `ui/DataTable keyboardNav`: the rows are the items, Enter clicks the element a column marks
  `data-nav-open`. DataTable renders its rows twice (a table, and a card list below `md`); both register
  and `lib/listNav` now walks only lists on screen (`checkVisibility`), so `j` past the last row never
  carries on into the hidden copy.
- `lib/listNav` leaves a key something before it already handled (`defaultPrevented`): during a keyboard
  drag a playlist row's grip moves the row with the arrows, and dnd-kit takes the key on the document
  before listNav's window listener. Without the guard ↓ moved the focus off the grip and dropped the drag.
- `ui/NavGrid as="tbody"` for a table whose body is the list (the playlist, under dnd-kit's
  SortableContext).
- Wired: Subscriptions and Discovery tables, the card layout (`ChannelLayoutGrid` → VirtualGrid
  `keyboardNav`), Hidden/Blocked cards (the ChannelLink name is a channel's open element); a playlist's
  rows (the title plays; the grip keeps Space/Enter); the download queue, library and shared lists (the
  play button opens, `IconBtn open`; a row without one opens nothing).
- `listNav.wiring.contract.test`: `VirtualGrid` and `DataTable` must say `keyboardNav` like `Carousel`,
  `DownloadRow` is a card; the audit log's table is the one exemption (its rows open nothing), and an
  exemption that no longer matches a tag fails the test.

Measured in Chrome: Channels table j → row, ring round the whole row; a row walked down keeps 12px above
the viewport edge, walked up clears the sticky header by 35px; Enter opens the channel. Cards 3 columns:
→ 0→1, ↓ 1→4. Hidden and Discovery: j + Enter open the channel. Playlist: j + Enter plays, Escape returns
focus to the row; a keyboard drag (Enter on the grip, ↓) moves the row with focus kept on the grip, and
Escape cancels with the order unchanged. Downloads library: Enter plays a video row, does nothing on a
plain file row.

frontend/src/components/listNav.wiring.contract.test.ts

@@ -3,7 +3,7 @@ import { describe, expect, it } from "vitest";
 // Every rail and every card of a card list is walkable by the keyboard (E11 S4, lib/listNav). Two
 // opt-in halves, both checked here, because either one missing silently leaves the keyboard out —
 // and a page where `j` walks two rails and skips the third reads as broken, not as unfinished:
-//   - a `Carousel` says `keyboardNav`, and a card says `navIndex`;
+//   - a `Carousel`, a `VirtualGrid` and a `DataTable` say `keyboardNav`, and a card says `navIndex`;
 //   - a card that says `navIndex` sits in a list that registers with listNav — a `NavGrid`, a
 //     `Carousel`, or a `VirtualGrid` (its `renderItem`). In a plain `<div className="grid">` the card
 //     is marked as an item of a list nobody walks.
@@ -11,7 +11,7 @@ import { describe, expect, it } from "vitest";
 //
 // The assertion pins the SET of offending tags, never a count, and checks the glob matched at all: a
 // guard whose glob stops matching is green over nothing (E10 review round 4, round 7).
-const RAIL = "Carousel";
+const WALKABLE = ["Carousel", "VirtualGrid", "DataTable"];
 const CARDS = [
   "VideoCard",
   "PlexPosterCard",
@@ -19,11 +19,15 @@ const CARDS = [
   "EpisodeCard",
   "PosterTile",
   "ShelfTile",
+  "DownloadRow",
 ];
 const LISTS = ["NavGrid", "Carousel", "VirtualGrid"];
 
-/** `path#tag#n` → why it is not a keyboard item. Empty today: every rail and card list is wired. */
-const EXEMPT: Record<string, string> = {};
+/** `path#tag#n` → why it is not a keyboard list. An entry that no longer matches a tag fails the test. */
+const EXEMPT: Record<string, string> = {
+  "components/AuditLog.tsx#DataTable#1":
+    "an admin log read in place: its rows open nothing, so stepping onto them would only move a ring",
+};
 
 interface Tag {
   start: number;
@@ -74,21 +78,25 @@ export function inList(code: string, pos: number): boolean {
 
 const has = (tag: Tag, prop: string) => new RegExp(`\\s${prop}\\b`).test(tag.text);
 
-function offenders(): { hits: string[]; tags: number } {
+function offenders(): { hits: string[]; tags: number; exempted: Set<string> } {
   const files = import.meta.glob("./**/*.tsx", { query: "?raw", import: "default", eager: true });
   const hits: string[] = [];
+  const exempted = new Set<string>();
   let tags = 0;
   for (const [rel, source] of Object.entries(files)) {
     const path = rel.replace(/^\.\//, "components/");
     if (/\.test\.tsx$/.test(path)) continue;
     const code = stripComments(String(source));
     const report = (id: string, why: string) => {
-      if (!(id in EXEMPT)) hits.push(`${id} ${why}`);
+      if (id in EXEMPT) exempted.add(id);
+      else hits.push(`${id} ${why}`);
     };
-    openingTags(code, RAIL).forEach((tag, n) => {
-      tags++;
-      if (!has(tag, "keyboardNav")) report(`${path}#${RAIL}#${n + 1}`, "no keyboardNav");
-    });
+    for (const name of WALKABLE) {
+      openingTags(code, name).forEach((tag, n) => {
+        tags++;
+        if (!has(tag, "keyboardNav")) report(`${path}#${name}#${n + 1}`, "no keyboardNav");
+      });
+    }
     for (const name of CARDS) {
       openingTags(code, name).forEach((tag, n) => {
         tags++;
@@ -98,14 +106,15 @@ function offenders(): { hits: string[]; tags: number } {
       });
     }
   }
-  return { hits: hits.sort(), tags };
+  return { hits: hits.sort(), tags, exempted };
 }
 
 describe("the keyboard-list wiring contract", () => {
   it("has no rail or card list the keyboard cannot walk", () => {
-    const { hits, tags } = offenders();
+    const { hits, tags, exempted } = offenders();
     expect(tags).toBeGreaterThan(15);
     expect(hits).toEqual([]);
+    expect(Object.keys(EXEMPT).filter((id) => !exempted.has(id))).toEqual([]);
   });
 
   it("reads a tag to its real end, past the > inside its attributes", () => {