feat(i18n): the server's closed English vocabularies named in the reader's language (E30 S2)

- lib/vocab + the `vocab` locale area: TMDB crew jobs and departments, auto-tags (D1 A: the data
  stays English, the catalog is named at its one source, useTags), built-in download profiles,
  YouTube topics; held key-for-key to the backend's own lists by backendIds.contract.
- Countries by ISO code: TMDB parse stores {code, name}; rows stored before are coded from TMDB's
  own country list in one request (run_enrich); Intl names them, historic codes (YU, SU, XI…)
  from the catalog.
- Player tracks named from the language tag, forced/SDH flags and codec tail, not Plex's
  server-language displayTitle; no invented "Audio N" on the server.
- Download lifecycle notices (shared / expiring / expired / evicted) named from data; the share
  notice carries the title.
- Scheduler: the job result rides along as data and is named per key (dashboard + run notice).
- Invite status named; a render crash's notice no longer shows the engine's English message.
- Fix: YouTube links …/wiki/Humour, the tagger looked for "Humor" — Comedy never came from a topic.

frontend/src/components/AdminUsers.tsx

@@ -728,7 +728,11 @@ function AdminInvites() {
               <div key={i.id} className="flex items-center gap-2">
                 <span className="truncate flex-1">{i.email}</span>
                 <span className={i.status === "approved" ? "text-accent" : "text-danger"}>
-                  {i.status}
+                  {t(
+                    i.status === "approved"
+                      ? "settings.invites.status.approved"
+                      : "settings.invites.status.denied",
+                  )}
                 </span>
                 {/* Only an approved row with NOBODY behind it yet: this button means "the door is
                     open, come in", which is meaningless to someone already inside — and half the

frontend/src/components/ChannelAbout.tsx

@@ -3,35 +3,27 @@ import { ExternalLink } from "lucide-react";
 import type { ChannelDetail } from "../lib/api";
 import { linkify } from "../lib/linkify";
 import { Badge } from "./ui/Badge";
+import { languageName, regionName, vocab } from "../lib/vocab";
 
 // --- About-tab metadata helpers (shared by the channel page and the manager's About overlay) ---
-function displayName(code: string, lang: string, type: "region" | "language"): string {
-  try {
-    return (
-      new Intl.DisplayNames([lang], { type }).of(type === "region" ? code.toUpperCase() : code) ??
-      code
-    );
-  } catch {
-    return code;
-  }
-}
 // YouTube keywords are ONE space-separated string with multi-word tags quoted: gaming "let's play".
 function parseKeywords(s: string): string[] {
   return (s.match(/"[^"]+"|\S+/g) ?? []).map((k) => k.replace(/^"|"$/g, "")).filter(Boolean);
 }
-// topicCategories are Wikipedia URLs (…/wiki/Music) → a readable label, de-duplicated.
-function topicLabels(urls: string[]): string[] {
+// topicCategories are Wikipedia URLs (…/wiki/Music) → the page slug ("Pop_music"), de-duplicated. The
+// slug is the vocabulary word (E30): named in the reader's language, else shown with spaces.
+function topicSlugs(urls: string[]): string[] {
   const seen = new Set<string>();
   for (const url of urls) {
     const seg = url.split("/wiki/")[1] ?? url.split("/").pop() ?? url;
-    let label = seg;
+    let slug = seg;
     try {
-      label = decodeURIComponent(seg);
+      slug = decodeURIComponent(seg);
     } catch {
       /* keep raw */
     }
-    label = label.replace(/_/g, " ").trim();
-    if (label) seen.add(label);
+    slug = slug.trim();
+    if (slug) seen.add(slug);
   }
   return [...seen];
 }
@@ -43,7 +35,7 @@ function topicLabels(urls: string[]): string[] {
  */
 export default function ChannelAboutContent({ ch }: { ch: ChannelDetail }) {
   const { t, i18n } = useTranslation();
-  const topics = ch.topic_categories?.length ? topicLabels(ch.topic_categories) : [];
+  const topics = ch.topic_categories?.length ? topicSlugs(ch.topic_categories) : [];
   const keywords = ch.keywords ? parseKeywords(ch.keywords) : [];
   const hasAboutDetails =
     !!ch.country || !!ch.default_language || topics.length > 0 || keywords.length > 0;
@@ -86,14 +78,14 @@ export default function ChannelAboutContent({ ch }: { ch: ChannelDetail }) {
                     aria-hidden
                   />
                 )}
-                {displayName(ch.country, i18n.language, "region")}
+                {regionName(t, ch.country, i18n.language)}
               </span>
             </div>
           )}
           {ch.default_language && (
             <div className="flex gap-2">
               <span className="text-muted w-24 shrink-0">{t("channel.language")}</span>
-              <span>{displayName(ch.default_language, i18n.language, "language")}</span>
+              <span>{languageName(ch.default_language, i18n.language, ch.default_language)}</span>
             </div>
           )}
           {topics.length > 0 && (
@@ -102,7 +94,7 @@ export default function ChannelAboutContent({ ch }: { ch: ChannelDetail }) {
               <div className="flex flex-wrap gap-1.5">
                 {/* Future search epic: these topic chips become clickable filters. */}
                 {topics.map((tp) => (
-                  <Badge key={tp}>{tp}</Badge>
+                  <Badge key={tp}>{vocab(t, "topic", tp, tp.replace(/_/g, " "))}</Badge>
                 ))}
               </div>
             </div>

frontend/src/components/ChannelPage.tsx

@@ -1,6 +1,6 @@
 import { useCallback, useEffect, useRef, useState } from "react";
 import { useTranslation } from "react-i18next";
-import { useMutation, useQuery, useQueryClient } from "@tanstack/react-query";
+import { useMutation, useQueryClient } from "@tanstack/react-query";
 import { useLiveQuery } from "../lib/useLiveQuery";
 import { channelDetailPollMs, useBackfillFeedRefresh } from "../lib/channelDetailPoll";
 import { qk } from "../lib/queryKeys";
@@ -42,6 +42,7 @@ import { Button } from "./ui/Button";
 import { IconButton } from "./ui/IconButton";
 import { IconLink } from "./ui/LinkButton";
 import { PageHeading } from "./ui/Headings";
+import { useTags } from "../lib/useTags";
 
 // A dedicated channel page: an "About"-style header (banner, avatar, stats, subscribe) over the
 // channel's videos (the catalog filtered to this channel). For an un-subscribed channel it
@@ -230,11 +231,7 @@ export default function ChannelPage({
   // invalidates the manager list so a tag added here shows there too.
   // Only fetch the tag catalog when the editor will actually render (subscribed, non-demo) — an
   // unsubscribed/demo channel page never shows the control, so the request would be thrown away.
-  const tagsQuery = useQuery({
-    queryKey: qk.tags(),
-    queryFn: api.tags,
-    enabled: !!ch?.subscribed && !me.is_demo,
-  });
+  const tagsQuery = useTags({ enabled: !!ch?.subscribed && !me.is_demo });
   const userTags = (tagsQuery.data ?? []).filter((tg) => !tg.system);
   const { toggleTag, createAndAttachTag } = useChannelTagActions({
     optimisticToggle: (id, tagId, attach) =>

frontend/src/components/Channels.tsx

@@ -54,6 +54,7 @@ import { useNavigationActions } from "./navigationContext";
 import { useFeedFilters, useFeedFiltersActions } from "./feedFiltersContext";
 import { useWizard } from "./wizardContext";
 import { useMe } from "../lib/useMe";
+import { useTags } from "../lib/useTags";
 
 export type ChannelsView = "subscribed" | "discovery" | "hidden" | "blocked";
 
@@ -118,7 +119,7 @@ export default function Channels() {
   };
 
   const channelsQuery = useQuery({ queryKey: qk.channels(), queryFn: api.channels });
-  const tagsQuery = useQuery({ queryKey: qk.tags(), queryFn: api.tags });
+  const tagsQuery = useTags();
   const statusQuery = useQuery({ queryKey: qk.myStatus(), queryFn: api.myStatus });
   const blockedQuery = useQuery({ queryKey: qk.blockedChannels(), queryFn: api.blockedChannels });
   const [tagManagerOpen, setTagManagerOpen] = useState(false);

frontend/src/components/DownloadDialog.tsx

@@ -12,6 +12,7 @@ const ProfileEditor = lazy(() => import("./ProfileEditor"));
 import { notify } from "../lib/notifications";
 import { notifyActionError } from "../lib/actionErrors";
 import { navigateTo } from "../lib/nav";
+import { profileName } from "../lib/vocab";
 import FilterSelect from "./ui/FilterSelect";
 import { Input } from "./ui/Input";
 
@@ -75,7 +76,7 @@ export default function DownloadDialog({
         hideLabel
         selected={chosen == null ? [] : [String(chosen)]}
         onChange={([v]) => v && setProfileId(Number(v))}
-        options={profiles.map((p) => ({ value: String(p.id), label: p.name }))}
+        options={profiles.map((p) => ({ value: String(p.id), label: profileName(t, p) }))}
       />
       <Button variant="link" onClick={() => setManage(true)} className="text-xs mt-1 mb-4">
         {t("downloads.dialog.manage")}

frontend/src/components/ErrorBoundary.message.dom.test.tsx

@@ -0,0 +1,39 @@
+// @vitest-environment jsdom
+//
+// E30: a render crash's notice speaks the reader's language. It showed `error.message` — the JS
+// engine's English ("Cannot read properties of undefined (reading 'x')") — in the toast and the inbox,
+// where it outlives the reload. The technical text stays in the `ui.crash` log.
+import { afterEach, expect, it, vi } from "vitest";
+import { cleanup, render } from "@testing-library/react";
+
+const notify = vi.fn();
+vi.mock("../lib/notifications", () => ({ notify: (...args: unknown[]) => notify(...args) }));
+
+import i18n from "../i18n";
+import { clear, events } from "../lib/log";
+import ErrorBoundary from "./ErrorBoundary";
+
+afterEach(() => {
+  cleanup();
+  clear();
+  vi.restoreAllMocks();
+});
+
+it("a crash is reported in words the reader reads; the engine's text goes to the log", () => {
+  vi.spyOn(console, "error").mockImplementation(() => {}); // React reports the throw itself too
+  const Broken = () => {
+    throw new TypeError("Cannot read properties of undefined (reading 'x')");
+  };
+  render(
+    <ErrorBoundary>
+      <Broken />
+    </ErrorBoundary>,
+  );
+
+  expect(notify).toHaveBeenCalledWith(
+    expect.objectContaining({ level: "fatal", message: i18n.t("errors.boundary.notifMessage") }),
+  );
+  expect(JSON.stringify(events().filter((e) => e.event === "ui.crash"))).toContain(
+    "Cannot read properties of undefined",
+  );
+});

frontend/src/components/ErrorBoundary.tsx

@@ -32,7 +32,9 @@ export default class ErrorBoundary extends Component<Props, State> {
     notify({
       level: "fatal",
       title: i18n.t("errors.boundary.notifTitle"),
-      message: error.message || i18n.t("errors.boundary.notifMessage"),
+      // Never the raw `error.message`: a JS engine's English ("Cannot read properties of undefined…")
+      // is no message for the reader (E30) — the `ui.crash` log above carries it for diagnosis.
+      message: i18n.t("errors.boundary.notifMessage"),
       requiresInteraction: true,
     });
   }

frontend/src/components/NotificationsPanel.menu.dom.test.tsx

@@ -330,3 +330,37 @@ describe("NotificationsPanel · the page's background menu", () => {
     expect(menuRows()).toEqual(["inbox.markAllRead"]);
   });
 });
+
+describe("a download-lifecycle notice (E30)", () => {
+  it("is named from its data in the reader's language, never the server's English title", () => {
+    h.server = [
+      server(1, {
+        type: "download_shared",
+        title: "Cats was shared with you",
+        body: null,
+        data: { kind: "download_shared", from: "a@b.c", title: "Cats" },
+      } as never),
+      server(2, {
+        type: "download_expiring",
+        title: "Dogs",
+        data: { kind: "download_expiring", title: "Dogs" },
+      } as never),
+      server(3, {
+        type: "download_expired",
+        title: "download", // an untitled video: the server's English fallback word
+        data: { kind: "download_expired", title: null },
+      } as never),
+      server(4, {
+        type: "download_evicted",
+        title: "Birds",
+        data: { kind: "download_evicted", title: "Birds" },
+      } as never),
+    ];
+    mount();
+    for (const key of ["downloadShared", "downloadExpiring", "downloadExpired", "downloadEvicted"])
+      expect(screen.getByText(`inbox.${key}.title`)).toBeTruthy();
+    for (const title of ["Cats", "Dogs", "Birds"]) expect(screen.getByText(title)).toBeTruthy();
+    expect(screen.queryByText("Cats was shared with you")).toBeNull();
+    expect(screen.queryByText("download")).toBeNull();
+  });
+});

frontend/src/components/NotificationsPanel.tsx

@@ -18,7 +18,8 @@ import {
   UserPlus,
   X,
 } from "lucide-react";
-import { api, type AppNotification } from "../lib/api";
+import { api, type AppNotification, type JobResult } from "../lib/api";
+import { jobResultText } from "../lib/jobResult";
 import { notifyActionError } from "../lib/actionErrors";
 import { useLiveQuery } from "../lib/useLiveQuery";
 import { focusAccessRequestsTab } from "../lib/adminUsersTab";
@@ -438,6 +439,14 @@ export default function NotificationsPanel() {
 }
 
 /** A server notification's link, from its type and typed payload (the row's button and its menu). */
+// The download-lifecycle notification types → their `inbox.<key>` copy.
+const DOWNLOAD_LIFECYCLE: Record<string, string | undefined> = {
+  download_shared: "downloadShared",
+  download_expiring: "downloadExpiring",
+  download_expired: "downloadExpired",
+  download_evicted: "downloadEvicted",
+};
+
 function serverKind(n: AppNotification): "scheduler" | "download" | null {
   if (n.type === "scheduler" && typeof n.data?.job_id === "string") return "scheduler";
   if (n.type === "download_done") return "download";
@@ -508,6 +517,8 @@ function NotificationRow({
   const isScheduler = serverKind(n) === "scheduler";
   const isDownloadDone = serverKind(n) === "download";
   const isEmailUndelivered = n.type === "email_undelivered" && typeof n.data?.reason === "string";
+  // A download's life after it is done (E30): shared with you, about to expire, expired, evicted.
+  const lifecycle = DOWNLOAD_LIFECYCLE[n.type];
   let title = n.title;
   let body = n.body;
   if (isMaintenance) {
@@ -516,13 +527,14 @@ function NotificationRow({
     title = t("inbox.maintenance.title");
     body = t("inbox.maintenance.body", { count: d.count });
   } else if (isScheduler) {
-    // "<Job label> finished/failed", with the raw result summary as the (technical) body.
-    const d = n.data as { job_id: string; status?: string; summary?: string };
+    // "<Job label> finished/failed", with the result as the body — named in the reader's language
+    // when it rode along as data (E30), else the English summary of an older notice.
+    const d = n.data as { job_id: string; status?: string; summary?: string; result?: JobResult };
     const job = t(`scheduler.jobs.${d.job_id}`, d.job_id);
     title = t(d.status === "error" ? "inbox.jobDone.titleError" : "inbox.jobDone.titleOk", {
       job,
     });
-    body = d.summary || n.body;
+    body = d.result ? jobResultText(t, d.result) : d.summary || n.body;
   } else if (isEmailUndelivered) {
     // Email is fail-soft: a drop leaves no error anywhere else, so this notice IS the trace. Name
     // the message that was lost, since that is what tells the operator what their users didn't get.
@@ -534,6 +546,13 @@ function NotificationRow({
         : "inbox.emailUndelivered.sendFailed",
       { subject: d.subject || n.body || "" },
     );
+  } else if (lifecycle) {
+    // The server stores an English title ("… was shared with you", or the bare word "download" for an
+    // untitled video); the notice is named from `data`, the video's title as the body — none when it
+    // has no title (or the share notice predates the title riding along).
+    const d = n.data as { title?: string | null; from?: string };
+    title = t(`inbox.${lifecycle}.title`, { from: d.from ?? "" });
+    body = d.title || null;
   } else if (isDownloadDone) {
     // "Download ready" / "Edit ready" per the producer's kind, with the video's title as the body
     // (shipped in data.title). Same notification type; the copy differs so an edit isn't mislabelled.

frontend/src/components/PlexInfo.dom.test.tsx

@@ -64,7 +64,11 @@ const detail: PlexItemDetail = {
       { name: "Sam Writer", job: "Writer" },
     ],
     studios: ["Studio A", "Studio B"],
-    production_countries: ["United States"],
+    // One coded (named in the reader's language), one from a row enriched before codes were stored.
+    production_countries: [
+      { code: "HU", name: "Hungary" },
+      { code: null, name: "United States" },
+    ],
     recommendations: [],
     backdrops: [],
   },
@@ -93,7 +97,8 @@ describe("PlexInfo enriched detail (page)", () => {
     expect(screen.getByText("$160M")).toBeTruthy();
     expect(screen.getByText("$830M")).toBeTruthy();
     expect(screen.getByText("Studio A")).toBeTruthy(); // tmdb.studios preferred over the fallback
-    expect(screen.getByText("United States")).toBeTruthy();
+    // E30: a coded country is named through the vocab (key-echo i18n here), an uncoded one as stored.
+    expect(screen.getByText("vocab.region.HU, United States")).toBeTruthy();
   });
 
   it("keyword chips filter the library on click", () => {
@@ -127,6 +132,8 @@ describe("PlexInfo enriched detail (page)", () => {
     const onOpenPerson = vi.fn();
     wrap(<PlexInfo onPlayItem={noop} detail={detail} variant="page" onOpenPerson={onOpenPerson} />);
     expect(screen.getByText("plex.info.crew")).toBeTruthy();
+    // E30: the job is TMDB's English word, named through the vocab (key-echo i18n here).
+    expect(screen.getByText("vocab.crewJob.Director")).toBeTruthy();
     fireEvent.click(screen.getByText("Jane Director"));
     expect(onOpenPerson).toHaveBeenCalledWith("Jane Director");
   });

frontend/src/components/PlexInfo.tsx

@@ -28,6 +28,7 @@ import { PlexMenu } from "./PlexMenu";
 import { useContextMenu } from "./ui/useContextMenu";
 import { usePlexCardActions } from "./usePlexCardActions";
 import { toggleWatchState } from "../lib/plexWatch";
+import { regionName, vocab } from "../lib/vocab";
 
 // The rich "media info" surface for a Plex item — poster/art, IMDb score + link, content rating,
 // genres, director, cast (with photos), summary. Reused in TWO places: a full-page view opened from
@@ -233,7 +234,9 @@ function FactsPanel({
     rows.push({
       key: "countries",
       label: t("plex.info.facts.countries"),
-      node: tmdb.production_countries.join(", "),
+      node: tmdb.production_countries
+        .map((c) => regionName(t, c.code, i18n.language, c.name))
+        .join(", "),
     });
   if (rows.length === 0) return null;
   return (
@@ -309,7 +312,7 @@ function CrewPanel({
             ) : (
               <div className="truncate text-sm font-medium">{c.name}</div>
             )}
-            <div className="truncate text-2xs text-muted">{c.job}</div>
+            <div className="truncate text-2xs text-muted">{vocab(t, "crewJob", c.job)}</div>
           </div>
         ))}
       </div>

frontend/src/components/PlexPersonView.dom.test.tsx

@@ -113,7 +113,8 @@ describe("PlexPersonView", () => {
     expect(screen.getByText("plex.person.shows")).toBeTruthy();
 
     // E5 S6 bio hero: department, biography, birth facts, aka.
-    expect(screen.getByText("Acting")).toBeTruthy();
+    // E30: TMDB's English department, named through the vocab (key-echo i18n here).
+    expect(screen.getByText("vocab.department.Acting")).toBeTruthy();
     expect(screen.getByText("A celebrated actor.")).toBeTruthy();
     expect(screen.getByText(/1970-01-01/)).toBeTruthy();
     expect(screen.getByText(/plex\.person\.aka/)).toBeTruthy();

frontend/src/components/PlexPlayer.tsx

@@ -27,7 +27,7 @@ import {
   Volume2,
   VolumeX,
 } from "lucide-react";
-import { api, HttpError } from "../lib/api";
+import { api, HttpError, type PlexTrackNaming } from "../lib/api";
 import { notifyActionError } from "../lib/actionErrors";
 import {
   audioOrdForLang,
@@ -88,6 +88,7 @@ import { PopoverItem, PopoverSurface } from "./ui/AnchoredPopover";
 import { closeThenAct, useAnchoredPopover } from "./ui/anchoredPopoverHooks";
 import { Slider } from "./ui/NativeControls";
 import { formatUnit } from "../lib/format";
+import { trackLabel } from "../lib/vocab";
 
 // The rich info overlay (poster/cast/ratings) reuses the same component as the card's info page.
 const PlexInfo = lazy(() => import("./PlexInfo"));
@@ -131,13 +132,16 @@ const DOUBLE_TAP_MS = 300;
 type Props = { itemId: string; onClose: () => void; queue?: string[]; fromStart?: boolean };
 
 export default function PlexPlayer({ itemId, onClose, queue, fromStart = false }: Props) {
-  const { t } = useTranslation();
+  const { t, i18n } = useTranslation();
   // `t` changes identity on a language switch. loadSession only uses it for error strings, so read it
   // through a ref — keeping it OUT of loadSession's deps. Otherwise a mid-playback language change
   // rebuilt loadSession → re-ran the detail effect → reloaded the session from the STALE saved resume
   // position (losing live progress). See the detail effect's deps.
   const tRef = useRef(t);
   tRef.current = t;
+  // E30: a track named in the reader's language (lib/vocab), not in the Plex server's ("English (AC3 5.1)").
+  const audioName = (a: PlexTrackNaming) => trackLabel(t, a, "audio", i18n.language);
+  const subtitleName = (x: PlexTrackNaming) => trackLabel(t, x, "subtitle", i18n.language);
   const qc = useQueryClient();
   const [id, setId] = useState(itemId);
   // Serve the player's title/summary/rich detail in the active language (E5 S6), matching the grid.
@@ -1238,16 +1242,21 @@ export default function PlexPlayer({ itemId, onClose, queue, fromStart = false }
         audio: () => {
           const ord = cycleAudio();
           if (ord === undefined) return; // one track (or none): nothing to say
-          const label = detail?.audio_streams.find((a) => a.ord === (ord ?? 0))?.label;
-          flashOsd(`${t("plex.player.audio")} · ${label ?? "—"}`);
+          const track = detail?.audio_streams.find((a) => a.ord === (ord ?? 0));
+          flashOsd(
+            `${t("plex.player.audio")} · ${track ? trackLabel(t, track, "audio", i18n.language) : "—"}`,
+          );
         },
         subtitle: () => {
           const ord = cycleSubtitle();
           if (ord === undefined) return;
+          const track = ord == null ? null : detail?.subtitle_streams.find((x) => x.ord === ord);
           const label =
             ord == null
               ? t("plex.player.subOff")
-              : (detail?.subtitle_streams.find((x) => x.ord === ord)?.label ?? "—");
+              : track
+                ? trackLabel(t, track, "subtitle", i18n.language)
+                : "—";
           flashOsd(`${t("plex.player.subtitles")} · ${label}`);
         },
         info: () => setInfoOpen((v) => !v),
@@ -1309,6 +1318,7 @@ export default function PlexPlayer({ itemId, onClose, queue, fromStart = false }
     cycleSubtitle,
     flashOsd,
     t,
+    i18n.language,
     detail,
     prevId,
     nextId,
@@ -1336,6 +1346,9 @@ export default function PlexPlayer({ itemId, onClose, queue, fromStart = false }
   const bufPct = duration > 0 ? (seekableEnd / duration) * 100 : 0;
   // While scrubbing the head follows the finger (preview); otherwise it tracks playback.
   const headPct = scrub != null && duration > 0 ? (scrub / duration) * 100 : pct;
+  // The tracks playing now, for the stats overlay.
+  const currentAudio = detail?.audio_streams.find((x) => x.ord === (audioOrd ?? 0));
+  const currentSub = detail?.subtitle_streams.find((x) => x.ord === subOrd);
 
   // Portaled to <body>, like every other full-screen overlay here (Modal, PlayerModal, ChatDock,
   // BackToTop). A fixed, full-viewport player must not be painted inside the page scroller: the
@@ -1412,7 +1425,7 @@ export default function PlexPlayer({ itemId, onClose, queue, fromStart = false }
             kind="subtitles"
             src={api.plexSubtitleUrl(id, selectedSub.ord, subTrackOffset, subGen)}
             srcLang={selectedSub.language ?? undefined}
-            label={selectedSub.label}
+            label={subtitleName(selectedSub)}
             {...subTrackListeners}
             default
           />
@@ -1466,7 +1479,7 @@ export default function PlexPlayer({ itemId, onClose, queue, fromStart = false }
             ) : (
               <>
                 <Loader2 className="h-4 w-4 shrink-0 animate-spin" aria-hidden />
-                <span>{t("plex.player.subPreparing", { label: selectedSub.label })}</span>
+                <span>{t("plex.player.subPreparing", { label: subtitleName(selectedSub) })}</span>
               </>
             )}
           </div>
@@ -1783,14 +1796,14 @@ export default function PlexPlayer({ itemId, onClose, queue, fromStart = false }
                             tone="media"
                             role="menuitemradio"
                             checked={(audioOrd ?? 0) === a.ord}
-                            label={a.label}
+                            label={audioName(a)}
                             onSelect={() => changeAudio(a.ord)}
                             className={`${TRACK_ROW} ${
                               (audioOrd ?? 0) === a.ord ? "text-accent" : "text-white"
                             }`}
                           >
                             <MenuCheck kind="one" on={(audioOrd ?? 0) === a.ord} />
-                            <span className="truncate">{a.label}</span>
+                            <span className="truncate">{audioName(a)}</span>
                           </PopoverItem>
                         ))}
                       </div>
@@ -1815,14 +1828,14 @@ export default function PlexPlayer({ itemId, onClose, queue, fromStart = false }
                             tone="media"
                             role="menuitemradio"
                             checked={subOrd === sub.ord}
-                            label={sub.label}
+                            label={subtitleName(sub)}
                             onSelect={() => changeSubtitle(sub.ord)}
                             className={`${TRACK_ROW} ${
                               subOrd === sub.ord ? "text-accent" : "text-white"
                             }`}
                           >
                             <MenuCheck kind="one" on={subOrd === sub.ord} />
-                            <span className="truncate">{sub.label}</span>
+                            <span className="truncate">{subtitleName(sub)}</span>
                           </PopoverItem>
                         ))}
                       </div>
@@ -1896,13 +1909,13 @@ export default function PlexPlayer({ itemId, onClose, queue, fromStart = false }
           videoRef={videoRef}
           hlsRef={hlsRef}
           fragMeterRef={fragMeterRef}
-          audioLabel={
-            detail?.audio_streams.find((a) => a.ord === (audioOrd ?? 0))?.label ?? undefined
-          }
+          audioLabel={currentAudio ? audioName(currentAudio) : undefined}
           subLabel={
             subOrd == null
               ? t("plex.player.subOff")
-              : (detail?.subtitle_streams.find((x) => x.ord === subOrd)?.label ?? undefined)
+              : currentSub
+                ? subtitleName(currentSub)
+                : undefined
           }
           playable={detail?.playable ?? ""}
           hwRef={hwRef}

frontend/src/components/ProfileEditor.tsx

@@ -6,6 +6,7 @@ import { Lock, Pencil, Plus, Trash2 } from "lucide-react";
 import Modal from "./ui/Modal";
 import { useConfirm } from "./confirmContext";
 import { api, type DownloadProfile, type DownloadSpec } from "../lib/api";
+import { profileName } from "../lib/vocab";
 import { Button } from "./ui/Button";
 import SegmentedToggle from "./ui/SegmentedToggle";
 import FilterSelect from "./ui/FilterSelect";
@@ -118,7 +119,7 @@ export default function ProfileEditor({ onClose }: { onClose: () => void }) {
         {builtins.map((p) => (
           <div key={p.id} className={`${SURFACE.card} flex items-center gap-2 text-sm px-3 py-1.5`}>
             <Lock className="w-3.5 h-3.5 text-muted shrink-0" />
-            <span className="flex-1 truncate">{p.name}</span>
+            <span className="flex-1 truncate">{profileName(t, p)}</span>
           </div>
         ))}
         {mine.length > 0 && (

frontend/src/components/Scheduler.dom.test.tsx

@@ -32,6 +32,7 @@ const status = (over: Partial<SchedulerStatus> = {}): SchedulerStatus => ({
       last_started: null,
       last_finished: null,
       last_result: null,
+      result: null,
       last_error: null,
       progress: null,
     },
@@ -258,3 +259,25 @@ describe("Scheduler while paused (E28 audit F13)", () => {
     expect(runOne).not.toHaveBeenCalled();
   });
 });
+
+describe("a job's last result (E30)", () => {
+  it("is named from its data, not the server's English one-liner", async () => {
+    const base = status();
+    await mount({
+      ...base,
+      jobs: [
+        {
+          ...base.jobs[0]!,
+          last_finished: new Date().toISOString(),
+          last_result: "new=3, failed=0",
+          result: { new: 3, failed: 0 },
+        },
+      ],
+    });
+    // Key-echo i18n: the keys named, the counts shown.
+    expect(
+      await screen.findByText(/scheduler\.result\.new: 3 · scheduler\.result\.failed: 0/),
+    ).toBeTruthy();
+    expect(screen.queryByText(/new=3/)).toBeNull();
+  });
+});

frontend/src/components/Scheduler.menu.dom.test.tsx

@@ -30,6 +30,7 @@ const status = (over: Partial<SchedulerStatus> = {}): SchedulerStatus => ({
       last_started: null,
       last_finished: null,
       last_result: null,
+      result: null,
       last_error: null,
       progress: null,
     },

frontend/src/components/Scheduler.tsx

@@ -35,6 +35,7 @@ import { useContextMenu } from "./ui/useContextMenu";
 import { ContextMenu } from "./ui/ContextMenu";
 import { MoreButton } from "./ui/MoreButton";
 import { type ActionMenuItem } from "./ui/ActionMenu";
+import { jobResultText } from "../lib/jobResult";
 
 const POLL_MS = 4000;
 // While any job is running, poll faster so short scheduled runs aren't missed between ticks.
@@ -255,6 +256,8 @@ function JobRow({
               : t("scheduler.neverRun")}
           {job.last_error ? (
             <span className="text-danger"> · {job.last_error}</span>
+          ) : job.result ? (
+            <span> · {jobResultText(t, job.result)}</span>
           ) : job.last_result ? (
             <span> · {job.last_result}</span>
           ) : null}

frontend/src/components/Sidebar.tsx

@@ -21,6 +21,7 @@ import MatchToggle from "./ui/MatchToggle";
 import { useFeedFilters, useFeedFiltersActions } from "./feedFiltersContext";
 import { useChannelsActions } from "./channelsContext";
 import { useMe } from "../lib/useMe";
+import { useTags } from "../lib/useTags";
 
 // Filter ids; display labels resolved at render time via t("sidebar.sort.<id>") etc.
 const DATE_PRESETS: { days: number; key: string }[] = [
@@ -53,7 +54,7 @@ export default function Sidebar({
   const { setFilters } = useFeedFiltersActions();
   // "Focus this channel in the manager" (from the tag manager here) lives in ChannelsProvider.
   const { focusChannel: onFocusChannel } = useChannelsActions();
-  const tagsQuery = useQuery({ queryKey: qk.tags(), queryFn: api.tags });
+  const tagsQuery = useTags();
   const tags = tagsQuery.data ?? [];
 
   // Live per-tag channel counts for the current filter context. Debounce the search term so

frontend/src/components/TagManager.tsx

@@ -16,6 +16,7 @@ import { IconButton } from "./ui/IconButton";
 import { Pressable } from "./ui/Pressable";
 import { Input } from "./ui/Input";
 import { SURFACE } from "./ui/surfaces";
+import { useTags } from "../lib/useTags";
 
 // One editable row: rename in place (commit on Enter/blur), delete with a confirm, and a
 // hover popover on the count listing the tagged channels (each a link that focuses it in the
@@ -112,7 +113,7 @@ export default function TagManager({
   const confirm = useConfirm();
   const listFade = useScrollFade();
   const [newName, setNewName] = useState("");
-  const tagsQuery = useQuery({ queryKey: qk.tags(), queryFn: api.tags });
+  const tagsQuery = useTags();
   const channelsQuery = useQuery({ queryKey: qk.channels(), queryFn: api.channels });
   const userTags = (tagsQuery.data ?? []).filter((tg) => !tg.system);
   const channelsForTag = (tagId: number) =>

frontend/src/components/VideoInfoCard.tsx

@@ -10,6 +10,7 @@ import { PopoverSurface } from "./ui/AnchoredPopover";
 import { useAnchoredPopover } from "./ui/anchoredPopoverHooks";
 import { SURFACE } from "./ui/surfaces";
 import { Badge } from "./ui/Badge";
+import { useTags } from "../lib/useTags";
 
 // A video's details (E8·S3, decision D3): full (un-clamped) title, channel, views·duration·date, a
 // description snippet, and the channel's tags. E28 C1 moved it from a hover ⓘ on the thumbnail into
@@ -58,11 +59,7 @@ export default function VideoDetailsAt({
     enabled: !!video.channel_id,
     staleTime: 5 * 60_000,
   });
-  const { data: tags } = useQuery({
-    queryKey: qk.tags(),
-    queryFn: () => api.tags(),
-    staleTime: 5 * 60_000,
-  });
+  const { data: tags } = useTags({ staleTime: 5 * 60_000 });
 
   // The channel's tags (`tag_ids`), in the channel's own id order, resolved to names via the tag list.
   // These are the channel-tags the channel actually carries; an unknown id (a just-deleted tag) drops.

frontend/src/components/adminInvites.dom.test.tsx

@@ -162,6 +162,9 @@ describe("Access requests — the delete affordance", () => {
     await openAccessTab();
 
     fireEvent.click(await screen.findByText(/settings\.invites\.decided/));
+    // E30: the decision is named, not the raw status word ("denied").
+    expect(screen.getByText("settings.invites.status.denied")).toBeTruthy();
+    expect(screen.queryByText("denied")).toBeNull();
     fireEvent.click(await screen.findByLabelText("settings.invites.deleteLabel:asker@example.com"));
 
     await waitFor(() => expect(deleteMock).toHaveBeenCalledWith(1));

frontend/src/components/plexViews.tsx

@@ -57,6 +57,7 @@ import { Chip } from "./ui/Chip";
 import { Pressable } from "./ui/Pressable";
 import { SURFACE } from "./ui/surfaces";
 import { PageHeading } from "./ui/Headings";
+import { vocab } from "../lib/vocab";
 
 // The Plex sub-router's view branches, split out of PlexBrowse. Each is invoked by PlexBrowse with
 // shell callbacks as props (onBack/onPlay/onFilter/…) — no view reaches back into the shell's state,
@@ -243,7 +244,9 @@ export function PlexPersonView({
               <div className="min-w-0 flex-1">
                 <PageHeading className="text-xl font-semibold">{d.name}</PageHeading>
                 {d.known_for_department && (
-                  <p className="text-xs font-medium text-accent">{d.known_for_department}</p>
+                  <p className="text-xs font-medium text-accent">
+                    {vocab(t, "department", d.known_for_department)}
+                  </p>
                 )}
                 <p className="mt-1 mb-2 text-xs text-muted">
                   {t("plex.person.credits", { movies: d.movies.length, shows: d.shows.length })}

frontend/src/i18n/backendIds.contract.test.ts

@@ -1,5 +1,6 @@
 import { readdirSync, readFileSync } from "node:fs";
 import { describe, expect, it } from "vitest";
+import { vocabKey } from "../lib/vocab";
 
 // Every id the BACKEND owns and the UI names must have its name in both languages. The UI looks these
 // up with the raw id as the fallback — `t(\`config.fields.${key}.label\`, key)` — so a missing key never
@@ -147,6 +148,45 @@ const youtubeReasons = [
   ).matchAll(/"(\w+)"/g),
 ].map((m) => m[1]!);
 
+// E30: the closed English vocabularies the backend WRITES into data, named through `vocab.<group>`
+// (lib/vocab) by their letters-and-digits key. A word the backend adds shows in English until named —
+// so each list is read from its source here: the TMDB crew jobs kept, every auto-tag the tagger can
+// create, and the built-in download profiles of the latest migration that seeds them.
+const pyStrings = (block: string | undefined, re: RegExp) =>
+  [...(block ?? "").matchAll(re)].map((m) => m[1]!);
+const between = (src: string, start: string, end: string) => src.split(start)[1]?.split(end)[0];
+const tmdbPy = backend("plex/tmdb.py");
+const crewJobs = [
+  ...new Set([
+    ...pyStrings(between(tmdbPy, "_MOVIE_CREW_JOBS = (", ")"), /"([^"]+)"/g),
+    ...pyStrings(between(tmdbPy, "_TV_CREW_JOBS = (", ")"), /"([^"]+)"/g),
+  ]),
+];
+const autotagPy = backend("sync/autotag.py");
+const autoTags = [
+  ...new Set([
+    ...pyStrings(between(autotagPy, "LANG_NAMES = {", "}"), /:\s*"([^"]+)"/g),
+    ...pyStrings(between(autotagPy, "TOPIC_COLORS = {", "}"), /"([^"]+)":/g),
+    ...pyStrings(between(autotagPy, "_TOPIC_SLUGS = {", "}"), /:\s*"([^"]+)"/g),
+    ...pyStrings(between(autotagPy, "_CATEGORY_NAMES = {", "}"), /:\s*"([^"]+)"/g),
+    ...pyStrings(between(autotagPy, "def map_topic_slug", "\n\n\n"), /return "([^"]+)"/g),
+  ]),
+];
+const migrations = readdirSync(new URL("../../../backend/alembic/versions/", import.meta.url))
+  .filter((f) => f.endsWith(".py"))
+  .sort();
+const seeding = migrations
+  .map((f) =>
+    readFileSync(new URL(`../../../backend/alembic/versions/${f}`, import.meta.url), "utf-8"),
+  )
+  .filter((src) => src.includes("_BUILTINS = ["))
+  .pop();
+const builtinProfiles = pyStrings(
+  between(seeding ?? "", "_BUILTINS = [", "\n]"),
+  /^\s+\("([^"]+)",/gm,
+);
+const VOCAB = { crewJob: crewJobs, autoTag: autoTags, profile: builtinProfiles };
+
 /** The ids under `prefix` a locale names, `prefix.<id>` or `prefix.<id>.<anything>`. */
 const idsUnder = (keys: Set<string>, prefix: string) =>
   new Set(
@@ -170,6 +210,13 @@ describe("backend ids have their names in both languages", () => {
     expect(goneWhats).toEqual(expect.arrayContaining(["playlist", "download", "job"]));
     expect(opaqueWhats).toEqual([]);
     expect(youtubeReasons).toEqual(["quota", "reconnect", "unavailable"]);
+    expect(crewJobs).toEqual(
+      expect.arrayContaining(["Director", "Creator", "Director of Photography"]),
+    );
+    expect(autoTags).toEqual(
+      expect.arrayContaining(["English", "Gaming", "Health & Fitness", "Hobbies", "Sports"]),
+    );
+    expect(builtinProfiles).toEqual(expect.arrayContaining(["720p (MP4)", "Video only (MP4)"]));
     expect(refusedReasons).toEqual(
       expect.arrayContaining(["weak_password", "setting_too_low", "plex_write_failed"]),
     );
@@ -254,6 +301,17 @@ describe("backend ids have their names in both languages", () => {
       ).toEqual([]);
     });
 
+    it(`${lang}: every crew job, auto-tag and built-in profile the backend writes, and no other`, () => {
+      for (const [group, words] of Object.entries(VOCAB)) {
+        const wanted = words.map((w) => `vocab.${group}.${vocabKey(w)}`);
+        expect(missing(wanted), group).toEqual([]);
+        expect(
+          [...keys].filter((k) => k.startsWith(`vocab.${group}.`) && !wanted.includes(k)),
+          group,
+        ).toEqual([]);
+      }
+    });
+
     it(`${lang}: every admin refusal reason`, () => {
       expect(missing(adminReasons.map((r) => `errors.admin.${r}`))).toEqual([]);
       expect([...idsUnder(keys, "errors.admin")].filter((r) => !adminReasons.includes(r))).toEqual(

frontend/src/i18n/locales/en/inbox.json

@@ -34,5 +34,17 @@
     "title": "Email is not going out",
     "notConfigured": "SMTP is not configured, so nothing this instance sends is being delivered — verification links, password resets and access requests alike. One of them was “{{subject}}”. Set it up under Configuration → Email / SMTP.",
     "sendFailed": "Couldn't send email, so messages are not being delivered. One of them was “{{subject}}”. Check Configuration → Email / SMTP and send a test; the server log has the reason."
+  },
+  "downloadShared": {
+    "title": "{{from}} shared a download with you"
+  },
+  "downloadExpiring": {
+    "title": "A download expires soon"
+  },
+  "downloadExpired": {
+    "title": "A download expired and was removed"
+  },
+  "downloadEvicted": {
+    "title": "A download was removed to free up space"
   }
 }

frontend/src/i18n/locales/en/scheduler.json

@@ -113,5 +113,70 @@
   "purgeDiscovery": "Purge discovery",
   "purgeDiscoveryHint": "Delete all un-kept discovery content now (search results nobody watched/saved, and explored-but-unsubscribed channels) — ignoring the grace period.",
   "purgeConfirmTitle": "Purge discovery content?",
-  "purgedDiscovery": "Deleted {{count}} discovery items"
+  "purgedDiscovery": "Deleted {{count}} discovery items",
+  "result": {
+    "new": "new videos",
+    "failed": "failed",
+    "fallback": "read through the API",
+    "channels_processed": "channels processed",
+    "videos_added": "videos added",
+    "reconciled_full": "fully reconciled",
+    "reason": "reason",
+    "channels_tagged": "channels tagged",
+    "orphan_tags_removed": "orphan tags removed",
+    "probed": "checked",
+    "shorts": "Shorts",
+    "users": "users",
+    "playlists_synced": "playlists synced",
+    "rechecked": "rechecked",
+    "recovered": "recovered",
+    "deleted": "deleted",
+    "notified": "notified",
+    "revalidated": "revalidated",
+    "flagged": "flagged",
+    "skipped": "skipped",
+    "playlists_seeded": "playlists seeded",
+    "expired": "expired",
+    "videos_deleted": "videos deleted",
+    "channels_deleted": "channels deleted",
+    "search_videos_deleted": "search results deleted",
+    "warned": "warned",
+    "evicted": "evicted",
+    "reaped": "cleaned up",
+    "swept": "swept",
+    "libraries": "libraries",
+    "movies": "movies",
+    "shows": "shows",
+    "seasons": "seasons",
+    "episodes": "episodes",
+    "collections": "collections",
+    "overlaid": "HU overlay",
+    "pruned": "pruned",
+    "people_enriched": "people enriched",
+    "media_probed": "media probed",
+    "people_pruned": "people pruned",
+    "error": "error",
+    "links": "links",
+    "watched": "watched",
+    "in_progress": "in progress",
+    "repushed": "re-sent",
+    "movie_probes": "movie probes",
+    "applied": "applied",
+    "cleared": "cleared",
+    "scanned": "scanned",
+    "enriched": "enriched",
+    "countries_coded": "countries coded",
+    "sessions_closed": "sessions closed",
+    "sessions_reaped": "sessions cleaned up",
+    "recent": "recent",
+    "deep": "deep"
+  },
+  "skip": {
+    "disabled": "disabled",
+    "PlexserverURLortokenisnotconfigured": "Plex server URL or token is not configured",
+    "tmdbapikeynotset": "TMDB API key not set",
+    "nodemoaccount": "no demo account",
+    "noserviceuser": "no service user",
+    "syncpaused": "sync paused"
+  }
 }

frontend/src/i18n/locales/en/settings.json

@@ -192,7 +192,11 @@
     "deleteFailed": "Couldn't delete the entry",
     "emailOff": "Email sending is not configured, so nobody gets a verification link and no request reaches you by email. Watch this list and your Notifications instead, and fix it under Configuration → Email / SMTP.",
     "deletedStillAllowed": "Entry deleted, but this address is still allow-listed by the server's configuration, so it keeps access. Remove it from ALLOWED_EMAILS / ADMIN_EMAILS to change that.",
-    "deleteConfirmStillAllowed": "Forget {{email}}? Careful: this address is also allow-listed in the server's configuration (ALLOWED_EMAILS / ADMIN_EMAILS), so deleting this row will NOT take its access away — and an ADMIN_EMAILS address is made an admin again on its next Google sign-in."
+    "deleteConfirmStillAllowed": "Forget {{email}}? Careful: this address is also allow-listed in the server's configuration (ALLOWED_EMAILS / ADMIN_EMAILS), so deleting this row will NOT take its access away — and an ADMIN_EMAILS address is made an admin again on its next Google sign-in.",
+    "status": {
+      "approved": "Approved",
+      "denied": "Denied"
+    }
   },
   "diagnostics": {
     "title": "Logging level",

frontend/src/i18n/locales/en/vocab.json

@@ -0,0 +1,169 @@
+{
+  "crewJob": {
+    "Director": "Director",
+    "Writer": "Writer",
+    "Screenplay": "Screenplay",
+    "Story": "Story",
+    "Producer": "Producer",
+    "ExecutiveProducer": "Executive Producer",
+    "Editor": "Editor",
+    "DirectorofPhotography": "Director of Photography",
+    "OriginalMusicComposer": "Original Music Composer",
+    "Creator": "Creator"
+  },
+  "department": {
+    "Acting": "Acting",
+    "Directing": "Directing",
+    "Writing": "Writing",
+    "Production": "Production",
+    "Sound": "Sound",
+    "Camera": "Camera",
+    "Editing": "Editing",
+    "Art": "Art",
+    "CostumeMakeUp": "Costume & Make-Up",
+    "Crew": "Crew",
+    "VisualEffects": "Visual Effects",
+    "Lighting": "Lighting",
+    "Creator": "Creator"
+  },
+  "autoTag": {
+    "English": "English",
+    "Hungarian": "Hungarian",
+    "German": "German",
+    "French": "French",
+    "Spanish": "Spanish",
+    "Italian": "Italian",
+    "Portuguese": "Portuguese",
+    "Dutch": "Dutch",
+    "Russian": "Russian",
+    "Polish": "Polish",
+    "Romanian": "Romanian",
+    "Czech": "Czech",
+    "Slovak": "Slovak",
+    "Turkish": "Turkish",
+    "Swedish": "Swedish",
+    "Danish": "Danish",
+    "Norwegian": "Norwegian",
+    "Finnish": "Finnish",
+    "Japanese": "Japanese",
+    "Korean": "Korean",
+    "Chinese": "Chinese",
+    "Hindi": "Hindi",
+    "Arabic": "Arabic",
+    "Ukrainian": "Ukrainian",
+    "Greek": "Greek",
+    "Gaming": "Gaming",
+    "Music": "Music",
+    "Cooking": "Cooking",
+    "Tech": "Tech",
+    "Education": "Education",
+    "Sports": "Sports",
+    "Film": "Film",
+    "TV": "TV",
+    "Politics": "Politics",
+    "HealthFitness": "Health & Fitness",
+    "Vehicles": "Vehicles",
+    "Animals": "Animals",
+    "FashionBeauty": "Fashion & Beauty",
+    "Travel": "Travel",
+    "Comedy": "Comedy",
+    "Entertainment": "Entertainment",
+    "Business": "Business",
+    "Science": "Science",
+    "News": "News",
+    "Society": "Society",
+    "PerformingArts": "Performing Arts",
+    "Military": "Military",
+    "Religion": "Religion",
+    "Hobbies": "Hobbies"
+  },
+  "profile": {
+    "720pMP4": "720p (MP4)",
+    "1080pMP4": "1080p (MP4)",
+    "BestMP4": "Best (MP4)",
+    "AudioM4A": "Audio (M4A)",
+    "AudioMP3": "Audio (MP3)",
+    "VideoonlyMP4": "Video only (MP4)"
+  },
+  "topic": {
+    "Music": "Music",
+    "Christianmusic": "Christian music",
+    "Classicalmusic": "Classical music",
+    "Countrymusic": "Country music",
+    "Electronicmusic": "Electronic music",
+    "Hiphopmusic": "Hip hop music",
+    "Independentmusic": "Independent music",
+    "Jazz": "Jazz",
+    "MusicofAsia": "Music of Asia",
+    "MusicofLatinAmerica": "Music of Latin America",
+    "Popmusic": "Pop music",
+    "Reggae": "Reggae",
+    "Rhythmandblues": "Rhythm and blues",
+    "Rockmusic": "Rock music",
+    "Soulmusic": "Soul music",
+    "Videogameculture": "Video game culture",
+    "Actiongame": "Action game",
+    "Actionadventuregame": "Action-adventure game",
+    "Casualgame": "Casual game",
+    "Musicvideogame": "Music video game",
+    "Puzzlevideogame": "Puzzle video game",
+    "Racingvideogame": "Racing video game",
+    "Roleplayingvideogame": "Role-playing video game",
+    "Simulationvideogame": "Simulation video game",
+    "Sportsgame": "Sports game",
+    "Strategyvideogame": "Strategy video game",
+    "Sport": "Sport",
+    "Americanfootball": "American football",
+    "Associationfootball": "Association football",
+    "Baseball": "Baseball",
+    "Basketball": "Basketball",
+    "Boxing": "Boxing",
+    "Cricket": "Cricket",
+    "Golf": "Golf",
+    "Icehockey": "Ice hockey",
+    "Mixedmartialarts": "Mixed martial arts",
+    "Motorsport": "Motorsport",
+    "Professionalwrestling": "Professional wrestling",
+    "Tennis": "Tennis",
+    "Volleyball": "Volleyball",
+    "Entertainment": "Entertainment",
+    "Humour": "Humour",
+    "Film": "Film",
+    "Performingarts": "Performing arts",
+    "Televisionprogram": "Television program",
+    "Lifestylesociology": "Lifestyle (sociology)",
+    "Fashion": "Fashion",
+    "Physicalfitness": "Physical fitness",
+    "Food": "Food",
+    "Hobby": "Hobby",
+    "Pet": "Pet",
+    "Physicalattractiveness": "Physical attractiveness",
+    "Technology": "Technology",
+    "Tourism": "Tourism",
+    "Vehicle": "Vehicle",
+    "Society": "Society",
+    "Business": "Business",
+    "Health": "Health",
+    "Military": "Military",
+    "Politics": "Politics",
+    "Religion": "Religion",
+    "Knowledge": "Knowledge"
+  },
+  "region": {
+    "AN": "Netherlands Antilles",
+    "SU": "Soviet Union",
+    "XC": "Czechoslovakia",
+    "XG": "East Germany",
+    "XI": "Northern Ireland",
+    "YU": "Yugoslavia",
+    "ZR": "Zaire"
+  },
+  "track": {
+    "forced": "forced",
+    "sdh": "SDH",
+    "stereo": "Stereo",
+    "mono": "Mono",
+    "audioN": "Audio {{n}}",
+    "subtitleN": "Subtitle {{n}}"
+  }
+}

frontend/src/i18n/locales/hu/inbox.json

@@ -34,5 +34,17 @@
     "title": "Nem megy ki e-mail",
     "notConfigured": "Az SMTP nincs beállítva, így semmi nem kézbesíthető, amit ez a példány küldene — megerősítő linkek, jelszó-visszaállítások és hozzáférés-kérelmek egyaránt. Az egyik ilyen: „{{subject}}”. Állítsd be a Konfiguráció → E-mail / SMTP fülön.",
     "sendFailed": "Nem sikerült e-mailt küldeni, így az üzenetek nem kézbesíthetők. Az egyik ilyen: „{{subject}}”. Nézd meg a Konfiguráció → E-mail / SMTP fület, és küldj tesztet; az okot a szerver naplója tartalmazza."
+  },
+  "downloadShared": {
+    "title": "{{from}} megosztott veled egy letöltést"
+  },
+  "downloadExpiring": {
+    "title": "Hamarosan lejár egy letöltés"
+  },
+  "downloadExpired": {
+    "title": "Egy letöltés lejárt, és törlődött"
+  },
+  "downloadEvicted": {
+    "title": "Egy letöltés helyhiány miatt törlődött"
   }
 }

frontend/src/i18n/locales/hu/scheduler.json

@@ -113,5 +113,70 @@
   "purgeDiscovery": "Felfedezés ürítése",
   "purgeDiscoveryHint": "Most törli az összes meg nem tartott felfedezés-tartalmat (senki által meg nem nézett/mentett keresési találatok és felfedezett, de nem követett csatornák) — a türelmi időt figyelmen kívül hagyva.",
   "purgeConfirmTitle": "Felfedezés-tartalom törlése?",
-  "purgedDiscovery": "{{count}} felfedezés-elem törölve"
+  "purgedDiscovery": "{{count}} felfedezés-elem törölve",
+  "result": {
+    "new": "új videó",
+    "failed": "sikertelen",
+    "fallback": "API-n át olvasva",
+    "channels_processed": "feldolgozott csatorna",
+    "videos_added": "hozzáadott videó",
+    "reconciled_full": "teljesen egyeztetve",
+    "reason": "ok",
+    "channels_tagged": "címkézett csatorna",
+    "orphan_tags_removed": "törölt árva címke",
+    "probed": "ellenőrizve",
+    "shorts": "Shorts",
+    "users": "felhasználó",
+    "playlists_synced": "szinkronizált lejátszási lista",
+    "rechecked": "újraellenőrizve",
+    "recovered": "helyreállt",
+    "deleted": "törölve",
+    "notified": "értesítve",
+    "revalidated": "újraérvényesítve",
+    "flagged": "megjelölve",
+    "skipped": "kihagyva",
+    "playlists_seeded": "létrehozott lejátszási lista",
+    "expired": "lejárt",
+    "videos_deleted": "törölt videó",
+    "channels_deleted": "törölt csatorna",
+    "search_videos_deleted": "törölt keresési találat",
+    "warned": "figyelmeztetve",
+    "evicted": "helyhiány miatt törölve",
+    "reaped": "eltakarítva",
+    "swept": "kisöpörve",
+    "libraries": "könyvtár",
+    "movies": "film",
+    "shows": "sorozat",
+    "seasons": "évad",
+    "episodes": "epizód",
+    "collections": "gyűjtemény",
+    "overlaid": "magyar átfedés",
+    "pruned": "eltávolítva",
+    "people_enriched": "kiegészített személy",
+    "media_probed": "vizsgált média",
+    "people_pruned": "eltávolított személy",
+    "error": "hiba",
+    "links": "kapcsolat",
+    "watched": "megnézve",
+    "in_progress": "folyamatban",
+    "repushed": "újraküldve",
+    "movie_probes": "filmvizsgálat",
+    "applied": "alkalmazva",
+    "cleared": "törölve",
+    "scanned": "átvizsgálva",
+    "enriched": "kiegészítve",
+    "countries_coded": "országkód pótolva",
+    "sessions_closed": "lezárt munkamenet",
+    "sessions_reaped": "eltakarított munkamenet",
+    "recent": "friss",
+    "deep": "mély"
+  },
+  "skip": {
+    "disabled": "kikapcsolva",
+    "PlexserverURLortokenisnotconfigured": "a Plex-szerver címe vagy tokenje nincs beállítva",
+    "tmdbapikeynotset": "nincs TMDB API-kulcs",
+    "nodemoaccount": "nincs demófiók",
+    "noserviceuser": "nincs szolgáltatásfiók",
+    "syncpaused": "a szinkron szünetel"
+  }
 }

frontend/src/i18n/locales/hu/settings.json

@@ -192,7 +192,11 @@
     "deleteFailed": "Nem sikerült törölni a bejegyzést",
     "emailOff": "Az e-mail-küldés nincs beállítva, így senki nem kap megerősítő linket, és e-mailben egy kérelem sem jut el hozzád. Ezt a listát és az Értesítéseket figyeld helyette, a javítás pedig a Konfiguráció → E-mail / SMTP fülön van.",
     "deletedStillAllowed": "A bejegyzés törölve, de ezt a címet a szerver konfigurációja továbbra is engedélyezi, tehát megmarad a hozzáférése. Vedd ki az ALLOWED_EMAILS / ADMIN_EMAILS listából, ha ezen változtatnál.",
-    "deleteConfirmStillAllowed": "Elfelejted {{email}} címet? Figyelem: ezt a címet a szerver konfigurációja is engedélyezi (ALLOWED_EMAILS / ADMIN_EMAILS), így a bejegyzés törlése NEM veszi el a hozzáférését — sőt egy ADMIN_EMAILS cím a következő Google-belépéskor újra adminná válik."
+    "deleteConfirmStillAllowed": "Elfelejted {{email}} címet? Figyelem: ezt a címet a szerver konfigurációja is engedélyezi (ALLOWED_EMAILS / ADMIN_EMAILS), így a bejegyzés törlése NEM veszi el a hozzáférését — sőt egy ADMIN_EMAILS cím a következő Google-belépéskor újra adminná válik.",
+    "status": {
+      "approved": "Jóváhagyva",
+      "denied": "Elutasítva"
+    }
   },
   "diagnostics": {
     "title": "Naplózási szint",

frontend/src/i18n/locales/hu/vocab.json

@@ -0,0 +1,169 @@
+{
+  "crewJob": {
+    "Director": "Rendező",
+    "Writer": "Író",
+    "Screenplay": "Forgatókönyv",
+    "Story": "Történet",
+    "Producer": "Producer",
+    "ExecutiveProducer": "Vezető producer",
+    "Editor": "Vágó",
+    "DirectorofPhotography": "Operatőr",
+    "OriginalMusicComposer": "Zeneszerző",
+    "Creator": "Alkotó"
+  },
+  "department": {
+    "Acting": "Színészet",
+    "Directing": "Rendezés",
+    "Writing": "Írás",
+    "Production": "Produkció",
+    "Sound": "Hang",
+    "Camera": "Operatőri munka",
+    "Editing": "Vágás",
+    "Art": "Látványtervezés",
+    "CostumeMakeUp": "Jelmez és smink",
+    "Crew": "Stáb",
+    "VisualEffects": "Vizuális effektek",
+    "Lighting": "Világítás",
+    "Creator": "Alkotó"
+  },
+  "autoTag": {
+    "English": "Angol",
+    "Hungarian": "Magyar",
+    "German": "Német",
+    "French": "Francia",
+    "Spanish": "Spanyol",
+    "Italian": "Olasz",
+    "Portuguese": "Portugál",
+    "Dutch": "Holland",
+    "Russian": "Orosz",
+    "Polish": "Lengyel",
+    "Romanian": "Román",
+    "Czech": "Cseh",
+    "Slovak": "Szlovák",
+    "Turkish": "Török",
+    "Swedish": "Svéd",
+    "Danish": "Dán",
+    "Norwegian": "Norvég",
+    "Finnish": "Finn",
+    "Japanese": "Japán",
+    "Korean": "Koreai",
+    "Chinese": "Kínai",
+    "Hindi": "Hindi",
+    "Arabic": "Arab",
+    "Ukrainian": "Ukrán",
+    "Greek": "Görög",
+    "Gaming": "Videojátékok",
+    "Music": "Zene",
+    "Cooking": "Főzés",
+    "Tech": "Technika",
+    "Education": "Oktatás",
+    "Sports": "Sport",
+    "Film": "Film",
+    "TV": "TV",
+    "Politics": "Politika",
+    "HealthFitness": "Egészség és fitnesz",
+    "Vehicles": "Járművek",
+    "Animals": "Állatok",
+    "FashionBeauty": "Divat és szépség",
+    "Travel": "Utazás",
+    "Comedy": "Humor",
+    "Entertainment": "Szórakozás",
+    "Business": "Üzlet",
+    "Science": "Tudomány",
+    "News": "Hírek",
+    "Society": "Társadalom",
+    "PerformingArts": "Előadóművészet",
+    "Military": "Katonaság",
+    "Religion": "Vallás",
+    "Hobbies": "Hobbik"
+  },
+  "profile": {
+    "720pMP4": "720p (MP4)",
+    "1080pMP4": "1080p (MP4)",
+    "BestMP4": "Legjobb (MP4)",
+    "AudioM4A": "Hang (M4A)",
+    "AudioMP3": "Hang (MP3)",
+    "VideoonlyMP4": "Csak videó (MP4)"
+  },
+  "topic": {
+    "Music": "Zene",
+    "Christianmusic": "Keresztény zene",
+    "Classicalmusic": "Klasszikus zene",
+    "Countrymusic": "Country",
+    "Electronicmusic": "Elektronikus zene",
+    "Hiphopmusic": "Hiphop",
+    "Independentmusic": "Független zene",
+    "Jazz": "Jazz",
+    "MusicofAsia": "Ázsiai zene",
+    "MusicofLatinAmerica": "Latin-amerikai zene",
+    "Popmusic": "Popzene",
+    "Reggae": "Reggae",
+    "Rhythmandblues": "R&B",
+    "Rockmusic": "Rockzene",
+    "Soulmusic": "Soul",
+    "Videogameculture": "Videojáték-kultúra",
+    "Actiongame": "Akciójáték",
+    "Actionadventuregame": "Akció-kalandjáték",
+    "Casualgame": "Casual játék",
+    "Musicvideogame": "Zenei videojáték",
+    "Puzzlevideogame": "Logikai játék",
+    "Racingvideogame": "Autóversenyzős játék",
+    "Roleplayingvideogame": "Szerepjáték",
+    "Simulationvideogame": "Szimulátor",
+    "Sportsgame": "Sportjáték",
+    "Strategyvideogame": "Stratégiai játék",
+    "Sport": "Sport",
+    "Americanfootball": "Amerikai futball",
+    "Associationfootball": "Labdarúgás",
+    "Baseball": "Baseball",
+    "Basketball": "Kosárlabda",
+    "Boxing": "Ökölvívás",
+    "Cricket": "Krikett",
+    "Golf": "Golf",
+    "Icehockey": "Jégkorong",
+    "Mixedmartialarts": "MMA",
+    "Motorsport": "Motorsport",
+    "Professionalwrestling": "Pankráció",
+    "Tennis": "Tenisz",
+    "Volleyball": "Röplabda",
+    "Entertainment": "Szórakozás",
+    "Humour": "Humor",
+    "Film": "Film",
+    "Performingarts": "Előadóművészet",
+    "Televisionprogram": "Tévéműsor",
+    "Lifestylesociology": "Életmód",
+    "Fashion": "Divat",
+    "Physicalfitness": "Fitnesz",
+    "Food": "Gasztronómia",
+    "Hobby": "Hobbi",
+    "Pet": "Háziállatok",
+    "Physicalattractiveness": "Szépség",
+    "Technology": "Technológia",
+    "Tourism": "Turizmus",
+    "Vehicle": "Járművek",
+    "Society": "Társadalom",
+    "Business": "Üzlet",
+    "Health": "Egészség",
+    "Military": "Katonaság",
+    "Politics": "Politika",
+    "Religion": "Vallás",
+    "Knowledge": "Tudás"
+  },
+  "region": {
+    "AN": "Holland Antillák",
+    "SU": "Szovjetunió",
+    "XC": "Csehszlovákia",
+    "XG": "Német Demokratikus Köztársaság",
+    "XI": "Észak-Írország",
+    "YU": "Jugoszlávia",
+    "ZR": "Zaire"
+  },
+  "track": {
+    "forced": "kényszerített",
+    "sdh": "hallássérülteknek",
+    "stereo": "sztereó",
+    "mono": "monó",
+    "audioN": "{{n}}. hangsáv",
+    "subtitleN": "{{n}}. felirat"
+  }
+}

frontend/src/lib/api/admin.ts

@@ -190,6 +190,8 @@ function logParams(query: LogQuery, extra: Record<string, string | number | null
   return s ? `?${s}` : "";
 }
 
+export type JobResult = { [key: string]: number | string | JobResult };
+
 export interface SchedulerJob {
   id: string;
   interval_minutes: number;
@@ -198,7 +200,10 @@ export interface SchedulerJob {
   status: "ok" | "error" | "skipped" | null;
   last_started: string | null;
   last_finished: string | null;
-  last_result: string | null;
+  last_result: string | null; // the English one-liner — the fallback for a job with no `result`
+  // The last result as data (E30): counts, a `skipped` / `reason` word, a nested dict per phase —
+  // named in the reader's language by lib/jobResult.
+  result: JobResult | null;
   last_error: string | null;
   // Live progress while running (null when idle or for jobs that don't report it).
   // total is null for indeterminate progress (e.g. enrichment drains an unknown queue).

frontend/src/lib/api/plex.ts

@@ -73,7 +73,8 @@ export interface PlexTmdb {
   keywords: string[];
   crew: PlexTmdbCrew[];
   studios: string[];
-  production_countries: string[];
+  // ISO code (null on a row enriched before E30 whose name TMDB's list lacked) + TMDB's English name.
+  production_countries: { code: string | null; name: string }[];
   recommendations: { tmdb_id?: number | null; title?: string | null; in_library: boolean }[];
   backdrops: string[];
 }
@@ -132,6 +133,16 @@ export interface PlexMarker {
   start_s: number;
   end_s: number;
 }
+// What the player names an audio/subtitle track from (E30, `lib/vocab` trackLabel). Plex's own title
+// (`label`) is in the Plex SERVER's language, so it is only the fallback for a track with no language tag.
+export interface PlexTrackNaming {
+  ord: number;
+  label: string | null;
+  lang_tag?: string | null;
+  forced?: boolean;
+  hearing_impaired?: boolean;
+  detail?: string | null; // the codec tail, "AC3 5.1"
+}
 export interface PlexItemDetail {
   id: string;
   kind: "movie" | "episode";
@@ -157,15 +168,13 @@ export interface PlexItemDetail {
   studio?: string | null;
   tagline?: string | null;
   markers: PlexMarker[];
-  audio_streams: { ord: number; label: string; language?: string | null; default: boolean }[];
+  audio_streams: (PlexTrackNaming & { language?: string | null; default: boolean })[];
   // `text`=true → offered as a WebVTT <track>; image subs (PGS/VobSub) are text=false (hidden).
-  subtitle_streams: {
-    ord: number;
-    label: string;
+  subtitle_streams: (PlexTrackNaming & {
     language?: string | null;
     codec?: string;
     text: boolean;
-  }[];
+  })[];
   status: string;
   position_seconds: number;
   show_title?: string | null;

frontend/src/lib/jobResult.dom.test.ts

@@ -0,0 +1,41 @@
+// @vitest-environment jsdom
+//
+// E30: a scheduler job's result in the reader's language, through the REAL catalog. The server's own
+// one-liner was "recent={'channels_processed': 0, …}, deep={…}" — English keys and a Python repr.
+import { afterEach, describe, expect, it } from "vitest";
+import i18n, { setLanguage } from "../i18n";
+import { jobResultText } from "./jobResult";
+
+afterEach(() => setLanguage("en"));
+
+describe("a job's result", () => {
+  it("names each count, and a phase's own counts inside it", () => {
+    setLanguage("hu");
+    const t = i18n.getFixedT("hu");
+    expect(jobResultText(t, { new: 3, failed: 0 })).toBe("új videó: 3 · sikertelen: 0");
+    expect(
+      jobResultText(t, {
+        recent: { channels_processed: 0, videos_added: 0, reason: "no service user" },
+        deep: { channels_processed: 2, videos_added: 5, reconciled_full: 1 },
+      }),
+    ).toBe(
+      "friss (feldolgozott csatorna: 0 · hozzáadott videó: 0 · ok: nincs szolgáltatásfiók) · " +
+        "mély (feldolgozott csatorna: 2 · hozzáadott videó: 5 · teljesen egyeztetve: 1)",
+    );
+  });
+
+  it("names a skip reason; an upstream error stays its own text", () => {
+    const t = i18n.getFixedT("hu");
+    expect(jobResultText(t, { enriched: 0, skipped: "tmdb_api_key not set" })).toBe(
+      "kiegészítve: 0 · kihagyva: nincs TMDB API-kulcs",
+    );
+    expect(jobResultText(t, { error: "Plex returned 500" })).toBe("hiba: Plex returned 500");
+  });
+
+  it("shows a key or word it does not know as it is, readable", () => {
+    const t = i18n.getFixedT("hu");
+    expect(jobResultText(t, { brand_new_count: 3, skipped: "moon is full" })).toBe(
+      "brand new count: 3 · kihagyva: moon is full",
+    );
+  });
+});

frontend/src/lib/jobResult.ts

@@ -0,0 +1,22 @@
+import type { TFunction } from "i18next";
+import type { JobResult } from "./api";
+import { formatNumber } from "./format";
+import { vocabKey } from "./vocab";
+
+/** A scheduler job's result in the reader's language (E30): "új videó: 3 · sikertelen: 0". The server
+ *  stored "new=3, failed=0" — English keys, a Python dict repr for a nested phase. A count's key is
+ *  named from `scheduler.result`, a `skipped` / `reason` word from `scheduler.skip`; an unnamed key or
+ *  word shows as it is, and an `error` stays the upstream's own text (it is diagnostic). */
+export function jobResultText(t: TFunction, result: JobResult): string {
+  return Object.entries(result)
+    .map(([key, value]) => {
+      const label = t(`scheduler.result.${key}`, { defaultValue: key.replace(/_/g, " ") });
+      if (typeof value === "number") return `${label}: ${formatNumber(value)}`;
+      if (typeof value === "string")
+        return key === "error"
+          ? `${label}: ${value}`
+          : `${label}: ${t(`scheduler.skip.${vocabKey(value)}`, { defaultValue: value })}`;
+      return `${label} (${jobResultText(t, value)})`;
+    })
+    .join(" · ");
+}

frontend/src/lib/useActiveFilters.ts

@@ -3,6 +3,7 @@ import { useQuery } from "@tanstack/react-query";
 import { qk } from "./queryKeys";
 import { api, DEFAULT_TAG_MODES, type FeedFilters } from "./api";
 import { parseSort } from "./feedSort";
+import { useTags } from "./useTags";
 
 /** One narrowing the user has applied, with the label to show and the way to undo just this one. */
 export interface ActiveFilter {
@@ -47,7 +48,7 @@ export function useActiveFilters(
   setFilters: (f: FeedFilters) => void,
 ): ActiveFilter[] {
   const { t } = useTranslation();
-  const tagsQuery = useQuery({ queryKey: qk.tags(), queryFn: api.tags });
+  const tagsQuery = useTags();
   const channelsQuery = useQuery({
     queryKey: qk.channels(),
     queryFn: api.channels,

frontend/src/lib/useTags.dom.test.tsx

@@ -0,0 +1,50 @@
+// @vitest-environment jsdom
+//
+// E30 (D1 A): the tag catalog as every reader sees it. A system (auto) tag is stored in English and
+// named in the reader's language; a user's own tag stays as they typed it, even when it happens to be
+// a vocabulary word.
+import { describe, expect, it, vi } from "vitest";
+import type { ReactNode } from "react";
+import { renderHook, waitFor } from "@testing-library/react";
+import { QueryClient, QueryClientProvider } from "@tanstack/react-query";
+import { setLanguage } from "../i18n";
+import { api, type Tag } from "./api";
+import { useTags } from "./useTags";
+
+const tag = (id: number, name: string, system: boolean): Tag => ({
+  id,
+  name,
+  system,
+  color: null,
+  category: "topic",
+  channel_count: 1,
+});
+
+function wrapper({ children }: { children: ReactNode }) {
+  const qc = new QueryClient({ defaultOptions: { queries: { retry: false } } });
+  return <QueryClientProvider client={qc}>{children}</QueryClientProvider>;
+}
+
+describe("the tag catalog", () => {
+  it("names an auto-tag in the reader's language, a user's tag as typed", async () => {
+    vi.spyOn(api, "tags").mockResolvedValue([
+      tag(1, "Health & Fitness", true),
+      tag(2, "Hungarian", true),
+      tag(3, "Gaming", false), // the user's own, spelled like a vocabulary word
+      tag(4, "Somethingnew", true), // an auto-tag the catalog does not name yet
+    ]);
+    setLanguage("hu");
+    try {
+      const { result } = renderHook(() => useTags(), { wrapper });
+      await waitFor(() => expect(result.current.data).toBeDefined());
+      expect(result.current.data!.map((tg) => tg.name)).toEqual([
+        "Egészség és fitnesz",
+        "Magyar",
+        "Gaming",
+        "Somethingnew",
+      ]);
+    } finally {
+      setLanguage("en");
+    }
+  });
+});

frontend/src/lib/useTags.ts

@@ -0,0 +1,20 @@
+import { useQuery } from "@tanstack/react-query";
+import { useTranslation } from "react-i18next";
+import { api, type Tag } from "./api";
+import { qk } from "./queryKeys";
+import { vocab } from "./vocab";
+
+/** The tag catalog, every reader's ONE way to it: a system (auto) tag is stored under its English name
+ *  ("Health & Fitness", "Hungarian") and named here in the reader's language (E30, decision D1 A — the
+ *  data stays language-neutral, filters and saved views hold ids). A user's own tag is theirs, as typed.
+ *  Naming it once, at the source, is what reaches every chip, column, menu and sort that shows one. */
+export function useTags(opts: { enabled?: boolean; staleTime?: number } = {}) {
+  const { t } = useTranslation();
+  return useQuery({
+    queryKey: qk.tags(),
+    queryFn: api.tags,
+    ...opts,
+    select: (tags: Tag[]) =>
+      tags.map((tg) => (tg.system ? { ...tg, name: vocab(t, "autoTag", tg.name) } : tg)),
+  });
+}

frontend/src/lib/vocab.dom.test.ts

@@ -0,0 +1,115 @@
+// @vitest-environment jsdom
+//
+// E30: the server's closed English vocabularies, named in the reader's language — through the REAL
+// catalog, so a missing or misnamed key shows here as the English word coming through.
+import { describe, expect, it } from "vitest";
+import i18n from "../i18n";
+import { languageName, profileName, regionName, trackLabel, vocab } from "./vocab";
+
+const hu = i18n.getFixedT("hu");
+const en = i18n.getFixedT("en");
+
+describe("a vocabulary word", () => {
+  it.each([
+    ["crewJob", "Director of Photography", "Operatőr"],
+    ["crewJob", "Executive Producer", "Vezető producer"],
+    ["department", "Acting", "Színészet"],
+    ["autoTag", "Health & Fitness", "Egészség és fitnesz"],
+    ["autoTag", "Hungarian", "Magyar"],
+    ["profile", "Video only (MP4)", "Csak videó (MP4)"],
+    ["topic", "Lifestyle_(sociology)", "Életmód"],
+  ] as const)("%s %j reads %j in Hungarian", (group, word, shown) => {
+    expect(vocab(hu, group, word)).toBe(shown);
+  });
+
+  it("the English reader sees the word as it was", () => {
+    expect(vocab(en, "crewJob", "Director of Photography")).toBe("Director of Photography");
+    expect(vocab(en, "topic", "Pop_music", "Pop music")).toBe("Pop music");
+  });
+
+  it("an unknown word is shown, not hidden or keyed", () => {
+    expect(vocab(hu, "crewJob", "Gaffer")).toBe("Gaffer");
+    expect(vocab(hu, "topic", "Knitting_(craft)", "Knitting (craft)")).toBe("Knitting (craft)");
+  });
+});
+
+describe("a country", () => {
+  it("is named from its code in the reader's language", () => {
+    expect(regionName(hu, "US", "hu", "United States of America")).toBe("Egyesült Államok");
+    expect(regionName(en, "DE", "en", "Germany")).toBe("Germany");
+  });
+
+  it("that no longer exists keeps its own name — Intl would call Yugoslavia Serbia", () => {
+    expect(regionName(hu, "YU", "hu", "Yugoslavia")).toBe("Jugoszlávia");
+    expect(regionName(hu, "SU", "hu", "Soviet Union")).toBe("Szovjetunió");
+    expect(regionName(en, "XI", "en", "Northern Ireland")).toBe("Northern Ireland");
+  });
+
+  it("without a code shows the stored name", () => {
+    expect(regionName(hu, null, "hu", "Hungary")).toBe("Hungary");
+  });
+});
+
+describe("a language", () => {
+  it("stands alone capitalized, region kept", () => {
+    expect(languageName("hu", "hu")).toBe("Magyar");
+    expect(languageName("en-US", "en")).toBe("American English");
+  });
+
+  it("falls back to what was given for a tag Intl cannot name", () => {
+    expect(languageName("qqq", "hu", "Klingon")).toBe("Klingon");
+    expect(languageName("und", "hu", "Unknown")).toBe("Unknown"); // "undetermined": no language
+  });
+});
+
+describe("a player track", () => {
+  const track = { ord: 0, label: "English (AC3 5.1)", lang_tag: "en-US", detail: "AC3 5.1" };
+
+  it("is named from its language, not Plex's server-language title", () => {
+    expect(trackLabel(hu, track, "audio", "hu")).toBe("Angol (AC3 5.1)");
+    expect(trackLabel(en, track, "audio", "en")).toBe("English (AC3 5.1)");
+  });
+
+  it("says forced / SDH and translates the channel word", () => {
+    expect(
+      trackLabel(
+        hu,
+        { ord: 1, label: "magyar Forced", lang_tag: "hu", forced: true },
+        "subtitle",
+        "hu",
+      ),
+    ).toBe("Magyar, kényszerített");
+    expect(
+      trackLabel(
+        hu,
+        { ord: 2, label: "中文", lang_tag: "zh", detail: "EAC3 Stereo" },
+        "audio",
+        "hu",
+      ),
+    ).toBe("Kínai (EAC3 sztereó)");
+    expect(
+      trackLabel(
+        en,
+        { ord: 3, label: "English SDH", lang_tag: "en", hearing_impaired: true },
+        "subtitle",
+        "en",
+      ),
+    ).toBe("English, SDH");
+  });
+
+  it("with no language keeps Plex's title, and with nothing is numbered", () => {
+    expect(trackLabel(hu, { ord: 0, label: "Commentary" }, "audio", "hu")).toBe("Commentary");
+    expect(trackLabel(hu, { ord: 2, label: null, lang_tag: "und" }, "audio", "hu")).toBe(
+      "3. hangsáv",
+    );
+    expect(trackLabel(hu, { ord: 1, label: null }, "subtitle", "hu")).toBe("2. felirat");
+    expect(trackLabel(en, { ord: 0, label: null }, "audio", "en")).toBe("Audio 1");
+  });
+});
+
+describe("a download profile", () => {
+  it("built in, is named in the reader's language; the user's own stays as typed", () => {
+    expect(profileName(hu, { name: "Audio (MP3)", is_builtin: true })).toBe("Hang (MP3)");
+    expect(profileName(hu, { name: "Audio (MP3)", is_builtin: false })).toBe("Audio (MP3)");
+  });
+});

frontend/src/lib/vocab.ts

@@ -0,0 +1,83 @@
+import type { TFunction } from "i18next";
+import type { PlexTrackNaming } from "./api";
+
+// E30: the closed vocabularies the server stores in ENGLISH — a TMDB crew job or department, an
+// auto-tag, a built-in download profile, a YouTube topic — named in the reader's language. The data
+// stays language-neutral (it is filtered and matched on); only the NAME is translated, here, from the
+// `vocab` locale area. A word the area does not hold shows as stored, so a new server value is never
+// hidden — and the backend's own lists are held key-for-key to the area by backendIds.contract.
+
+type Group = "crewJob" | "department" | "autoTag" | "profile" | "topic";
+
+/** A vocabulary word's key: its letters and digits ("Health & Fitness" → "HealthFitness"). */
+export function vocabKey(word: string): string {
+  return word.replace(/[^A-Za-z0-9]/g, "");
+}
+
+/** One stored English word of `group`, in the reader's language (`fallback`, by default the word
+ *  itself, when the area does not hold it). */
+export function vocab(t: TFunction, group: Group, word: string, fallback = word): string {
+  const key = vocabKey(word);
+  return key ? t(`vocab.${group}.${key}`, { defaultValue: fallback }) : fallback;
+}
+
+/** A download profile's name: a built-in one is seeded under an English name and named here; a user's
+ *  own is theirs, as typed. */
+export function profileName(t: TFunction, p: { name: string; is_builtin: boolean }): string {
+  return p.is_builtin ? vocab(t, "profile", p.name) : p.name;
+}
+
+function intlName(code: string, lang: string, type: "region" | "language"): string | undefined {
+  try {
+    return new Intl.DisplayNames([lang], { type, fallback: "none" }).of(code);
+  } catch {
+    return undefined; // not a well-formed code
+  }
+}
+
+/** A country from its ISO 3166 code. A code no longer in use (Yugoslavia, the Soviet Union) is
+ *  named from `vocab.region` — Intl renames those to today's state (YU → Serbia) or cannot name them
+ *  (XI, TMDB's Northern Ireland); `fallback` (the stored English name) when neither can. */
+export function regionName(
+  t: TFunction,
+  code: string | null | undefined,
+  lang: string,
+  fallback = "",
+): string {
+  if (!code) return fallback;
+  const up = code.toUpperCase();
+  return (
+    t(`vocab.region.${up}`, { defaultValue: "" }) || intlName(up, lang, "region") || fallback || up
+  );
+}
+
+/** A language from its BCP 47 tag ("en-US" → "American English"), capitalized to stand alone as a
+ *  label ("magyar" → "Magyar"); `fallback` for a tag Intl cannot name ("und", a typo). */
+export function languageName(tag: string | null | undefined, lang: string, fallback = ""): string {
+  const name = tag ? intlName(tag.replace(/_/g, "-"), lang, "language") : undefined;
+  if (!name || name === tag) return fallback;
+  return name.charAt(0).toLocaleUpperCase(lang) + name.slice(1);
+}
+
+/** An audio or subtitle track's name in the reader's language: "Angol (AC3 5.1)", "Magyar,
+ *  kényszerített". Built from the language tag; a track without one keeps Plex's own title, and a
+ *  track with neither is numbered. */
+export function trackLabel(
+  t: TFunction,
+  track: PlexTrackNaming,
+  kind: "audio" | "subtitle",
+  lang: string,
+): string {
+  // The language alone: Plex tags one track "en-US" and the next "en", and both are just English here.
+  const name = languageName(track.lang_tag?.split(/[-_]/)[0], lang);
+  if (!name) return track.label || t(`vocab.track.${kind}N`, { n: track.ord + 1 });
+  const flags = [
+    track.forced ? t("vocab.track.forced") : null,
+    track.hearing_impaired ? t("vocab.track.sdh") : null,
+  ].filter(Boolean);
+  // The codec tail is technical and language-neutral but for its channel word ("AC3 Stereo").
+  const detail = track.detail
+    ?.replace(/\bStereo\b/i, t("vocab.track.stereo"))
+    .replace(/\bMono\b/i, t("vocab.track.mono"));
+  return [name, ...flags].join(", ") + (detail ? ` (${detail})` : "");
+}