diff --git a/docs-developers/architecture/cross-repo-contract.md b/docs-developers/architecture/cross-repo-contract.md
index c045fbe0..98ac80ea 100644
--- a/docs-developers/architecture/cross-repo-contract.md
+++ b/docs-developers/architecture/cross-repo-contract.md
@@ -418,6 +418,10 @@ Since podcasts are shown only to an identified 2.2.0 or later player, the
 cross-origin dev loop shows none unless a development build opts in with
 `EXPO_PUBLIC_IDENTIFY_CROSS_ORIGIN=1` (never in a production build).
 
+For an allowed origin the server also allows `Range` and exposes
+`Retry-After` and the OPML export's `X-OPML-*` counts (Phase 2d-2), with what
+an older server means for the player: [CORS](../server/api/index.md#cors).
+
 **A change requires:** nothing structural - just remember self-signed TLS (the
 server default) needs trusting in the browser, or use `AUDIOSILO_TLS_MODE=off`
 for plain-HTTP local dev.
@@ -823,7 +827,8 @@ security-critical: allowed and denied tests on the server.
 
 Phase 2c-2 extends the server/Bridge seam with episodes on disk, retention
 and on-demand fetching/status/Retry. Phase 2d-1 ships the player's views to
-players from 2.2.0; discovery and OPML in the player are Phase 2d-2.
+players from 2.2.0; Phase 2d-2 adds discovery, follow by URL, OPML and Check
+for new episodes to the player.
 See [Podcasts](../bridge/podcasts.md) and the
 [API reference](../server/api/reference.md#podcasts) for exact fields.
 
@@ -976,9 +981,13 @@ See [Podcasts](../bridge/podcasts.md) and the
   counts omissions in `X-OPML-Exported` / `X-OPML-Omitted-Private` /
   `X-OPML-Omitted-Unavailable`. An open subscribe is reused only at the same
   privacy (`409 privacy_conflict`). Optional flags `podcast_discovery` and
-  `podcast_opml`; exact shapes and the player rules are in the
-  [2d-2 handoff](../bridge/podcasts.md#player-handoff-discovery-and-opml-phase-2d-2-not-implemented)
-  and the [reference](../server/api/reference.md#podcast-discovery).
+  `podcast_opml`; exact shapes and the player's rules (search on submit,
+  artwork through the proxy only, the import waves, export with the
+  `Authorization` header) are in
+  [Player: discovery and OPML](../bridge/podcasts.md#player-discovery-and-opml-phase-2d-2)
+  and the [reference](../server/api/reference.md#podcast-discovery). CORS
+  exposes `Retry-After` and the `X-OPML-*` counts and allows `Range` for an
+  allowed origin ([CORS](../server/api/index.md#cors)).
 - **CHAP:** the [sidecar](../bridge/attachments.md#podcast-chap-attachments)
   is a version-1 stem-prefixed `chapters.json` using `from:id3_chap`, Fetch timestamp and one matching
   basename/size/duration. No ASR/agent/generated flag; server consumes valid
diff --git a/docs-developers/bridge/index.md b/docs-developers/bridge/index.md
index dddc418f..1651bb0d 100644
--- a/docs-developers/bridge/index.md
+++ b/docs-developers/bridge/index.md
@@ -39,8 +39,10 @@ reserved download slot for play requests. **Phase 2c-3** adds server-side
 podcast [directory search and OPML import/export](podcasts.md#discovery-and-opml-transfer)
 with no Bridge change. **Phase 2d-1** adds the player's
 [podcast views](podcasts.md#player-phase-2d-1) (players from 2.2.0), again
-with no Bridge change. Discovery and OPML in the player (Phase 2d-2), read-along,
-Audible backups and file moves arrive later.
+with no Bridge change, and **Phase 2d-2** its
+[discovery, follow by URL and OPML screens](podcasts.md#player-discovery-and-opml-phase-2d-2)
+(a CORS change on the server only). Read-along, Audible backups and file moves
+arrive later.
 :::
 
 ## What it is for
diff --git a/docs-developers/bridge/podcasts.md b/docs-developers/bridge/podcasts.md
index 9f2bfb3f..3cc08adc 100644
--- a/docs-developers/bridge/podcasts.md
+++ b/docs-developers/bridge/podcasts.md
@@ -1,6 +1,6 @@
 ---
 title: "Podcasts"
-description: "Podcast jobs, on-demand fetch/status/Retry, discovery and OPML, the player (2d-1) and its discovery handoff (2d-2), queue prefetch, pinned generations, guarded downloads, retention, publication recovery, CHAP attachments and private feed secrets."
+description: "Podcast jobs, on-demand fetch/status/Retry, discovery and OPML, the player (2d-1) and its discovery and OPML screens (2d-2), queue prefetch, pinned generations, guarded downloads, retention, publication recovery, CHAP attachments and private feed secrets."
 ---
 
 ## Scope and ownership
@@ -29,8 +29,9 @@ intents, status/Retry routes and a bounded stream wait. Phase 2c-3 adds
 server-side [directory search and OPML import/export](#discovery-and-opml-transfer)
 with no Bridge change. Phase 2d-1 adds the [player](#player-phase-2d-1)
 (shows, show and episode pages, following, Home's New episodes, on-demand
-play) with no Bridge change; discovery, follow by URL and OPML in the player
-are [Phase 2d-2](#player-handoff-discovery-and-opml-phase-2d-2-not-implemented).
+play) with no Bridge change; Phase 2d-2 adds [discovery, follow by URL, OPML
+and Check for new episodes](#player-discovery-and-opml-phase-2d-2) to the
+player, with a CORS change on the server only.
 External chapters and transcripts arrive later.
 Players from **2.2.0** (`auth.PodcastPlayerMinVersion`), the admin console
 and `AudioSilo/dev` see podcast libraries; 2.1.x and older players, the
@@ -395,7 +396,7 @@ the optional abort `signal`:
 |---|---|
 | `podcastShows(libraryId)` | `GET /libraries/{id}/podcasts`, unwrapped to `PodcastShow[]` |
 | `podcastEpisodes(libraryId, {show, order, limit?, cursor?})` | `GET /libraries/{id}/podcasts/episodes`, a `PodcastEpisodePage` |
-| `myPodcasts()` | `GET /me/podcasts` (`requests` is unused until 2d-2) |
+| `myPodcasts()` | `GET /me/podcasts` (its `requests` are the follow requests [2d-2](#player-discovery-and-opml-phase-2d-2) shows) |
 | `followPodcast(libraryId, path)` | `POST /podcasts/follow` with exactly `{library_id, path}`; never `private` beside a path |
 | `unfollowPodcast(libraryId, path)` | `DELETE /podcasts/follow?library_id=&path=`, `204` |
 | `podcastFetchStatus(libraryId, path)` | `GET /libraries/{id}/podcasts/fetch?path=`, observation only |
@@ -409,8 +410,9 @@ and `retryAfterSeconds`: the `Retry-After` header when it reads as a
 non-negative number, else `fetch.retry_after_seconds`, else 2). A non-JSON 503
 from a proxy stays a plain `ApiError`. `API_ERROR_CODES` gains `module_off`,
 `bridge_unavailable`, `fetch_limit`, `identity_changed` and `show_not_found`.
-Cross-origin web dev can't read `Retry-After` ([CORS](../server/api/index.md#cors)),
-so the body's value is what it uses there.
+A cross-origin page reads `Retry-After` only from a server that exposes it
+([CORS](../server/api/index.md#cors), Phase 2d-2); from an older one the
+body's value is what it uses.
 
 **Hooks** (`src/api/hooks.ts`). Reads are core and never gated on `podcasts`:
 `usePodcastShows`, `usePodcastEpisodes` (an infinite query, 50 a page,
@@ -472,8 +474,9 @@ An episode never opens the end credits. Kids mode lists no podcast library
 
 Phase 2c-3 adds two server-only flows, with **no Bridge change**: directory
 search, whose results are followed through the existing follow by URL, and
-OPML import and export of subscription lists. Both are API only; the routes,
-shapes and error codes are in the
+OPML import and export of subscription lists. The player's screens for them
+are [Phase 2d-2](#player-discovery-and-opml-phase-2d-2) (the console has
+none); the routes, shapes and error codes are in the
 [API reference](../server/api/reference.md#podcast-discovery).
 
 - **Search runs on the server.** `internal/podcast/discovery` asks Apple's
@@ -504,114 +507,173 @@ shapes and error codes are in the
   follow, an `invalid` row in an import), before anything is queued. The
   canonical hash bytes and the Bridge's URL vectors are unchanged.
 
-### Player handoff: discovery and OPML (Phase 2d-2, not implemented)
+### Player: discovery and OPML (Phase 2d-2)
 
-The server side is implemented; **no player or console screen calls it yet**.
-Players from 2.2.0 pass the podcast client gate (Phase 2d-1) but have no
-search, follow-by-URL or OPML screen. These are proposed additions to the player's
-`src/api/{types,client,hooks}.ts`, mirroring the reviewed wire. Keep every
-new capability optional; every key inside a returned object is required,
-nulls included:
+Players from 2.2.0 search a directory, follow a feed by its address, import
+and export OPML lists and ask a followed show to check for new episodes. The
+screens are in [Frontend: Podcasts](../frontend/podcasts.md#finding-shows);
+this section is the wire mirror and the rules the player keeps. The only
+server change is CORS: an allowed origin may read `Retry-After` and the
+`X-OPML-*` counts and send `Range` ([CORS](../server/api/index.md#cors)). No
+Bridge, console or migration change.
+
+**Types** (`src/api/types.ts`). `Capabilities` gains the optional core flags
+`podcast_discovery` and `podcast_opml` (not `ModuleFlag` entries). Every key
+inside a returned object is always sent, nulls included:
 
 ```ts
 type PodcastDiscoveryProvider = 'itunes' | 'podcast_index';
-interface PodcastDiscoveryProviders {
-  providers: { id: PodcastDiscoveryProvider; available: boolean }[];
-}
-interface PodcastDiscoveryResult {
-  title: string;
-  author: string;
-  feed_url: string;
-  artwork_url: string | null; // relative: /api/v1/podcasts/discovery/artwork?id=<64 hex>
-  provider_ids: { itunes: string | null; podcast_index: string | null };
-  episode_count: number | null;
-  provider_url: string | null;
-}
-interface PodcastDiscoverySearch {
-  provider: PodcastDiscoveryProvider;
-  query: string;
-  country: string | null; // null for podcast_index
+type PodcastDiscoveryProviders = {
+  providers: { id: PodcastDiscoveryProvider | (string & {}); available: boolean }[];
+};
+type PodcastDiscoveryResult = {
+  title: string; author: string;
+  feed_url: string;               // normalized public address: what a follow sends
+  artwork_url: string | null;     // relative: /api/v1/podcasts/discovery/artwork?id=<64 hex>
+  provider_ids: { itunes: string | null; podcast_index: string | null }; // strings, they exceed 2^53
+  episode_count: number | null; provider_url: string | null;
+};
+type PodcastDiscoverySearch = {
+  provider: PodcastDiscoveryProvider; query: string;
+  country: string | null;         // null for podcast_index
   results: PodcastDiscoveryResult[];
-}
-type PodcastTransferCapabilities = {
-  podcast_discovery?: boolean;
-  podcast_opml?: boolean;
 };
-// Merge these optional flags into Capabilities. They are core flags,
-// not ModuleFlag entries.
+type PodcastCheckResult = { request: { id: number; state: string } }; // POST /podcasts/check 202
+type OpmlImportResult = { library_id: number; rows: OpmlImportRow[] };
+type OpmlExport = {               // client-side: the body and the X-OPML-* counts
+  text: string; exported: number | null;
+  omittedPrivate: number | null; omittedUnavailable: number | null;
+};
 ```
 
-Mirror `OpmlRowStatus`, `OpmlImportRow` and `OpmlImportResult` from the
-[import reference](../server/api/reference.md#post-apiv1podcastsopmlimport), which is their one
-written copy.
-
-What 2d-2 has to get right:
-
-- **Capability flags.** Treat an absent `podcast_discovery` or `podcast_opml`
-  as unsupported ([what they mean](../server/api/index.md#capability-flags---gate-your-features)).
-  Neither says the caller may use them: handle `403 kid_account`,
-  `403 demo_account`, `403 no_library_access` and `404 module_off` /
-  `discovery_off` from the routes.
-- **Provider selection.** Read `GET /podcasts/discovery/providers` and let the
-  person pick; send `provider=podcast_index` only when it is `available`
-  (otherwise `409 provider_unavailable`). There is no fallback and no merged
-  list, so never retry a failed search on the other provider silently. Send
-  `country` only for iTunes (`400 invalid_country` for Podcast Index); do not
-  derive it from `metadata.region`. Keep provider ids as strings (they exceed
-  2^53). Before building the UI, check each directory's current display,
-  attribution and quota terms; credit the provider and link `provider_url`.
-- **Artwork.** `artwork_url` is relative to the server. Load it through the
-  normal media-token helper (the route takes a session or API key as
-  `?token=`, nothing else), use a placeholder for `null`, a `404
-  artwork_not_found` (ids expire) or a `502`. The server fetches uncached
-  images only a few at a time, so a full results grid can get `429`/`503`
-  for some: load artwork lazily and retry those later rather than keeping the
-  placeholder. The existing CSP needs no change: images come only from the
-  server.
-- **Rate limits.** The per-person search budget is small
-  ([budgets](../server/api/reference.md#podcast-discovery)): search on submit, not while typing, and
-  reuse the held results when the query, provider, country and limit are
-  unchanged. Honour `Retry-After` on `429` and `503`; cross-origin web dev
-  cannot read it ([CORS](../server/api/index.md#cors)), so fall back to a
-  fixed wait.
-- **Following a result.** `POST /podcasts/follow` with `{library_id,
-  feed_url}`: `200 following` for a show the library has, `202 subscribing`
-  with a Request otherwise. The library must be one the person holds whole
-  and the Bridge must be online for a new feed.
-- **Import waves.** Send the file's bytes as the raw body with
-  `Content-Type: text/x-opml` (or `application/xml`), no compression, to
-  `POST /podcasts/opml/import?library_id=`. Keep the uploaded bytes locally
-  for the screen's life: the server keeps nothing. A `200` holds one row per
-  subscription; show them by `outline_index`. A long list answers `limited`
-  past the [wave](../server/api/reference.md#post-apiv1podcastsopmlimport). The player may re-submit
-  the same bytes automatically: poll
-  [`GET /me/podcasts`](../server/api/reference.md#podcast-read-routes) every few seconds only while a
-  row's request is still open, then upload again once those end and the import
-  budget allows (about one upload every 30 seconds; `429 opml_rate_limited`
-  and `503 opml_busy` carry `Retry-After`). Stop when no row is `limited`, or
-  when a wave admits nothing new (offer a manual retry). Treat `unavailable`
-  rows (`bridge_unavailable`, `library_not_writable`, `module_off`) as needing
-  the person or admin, not an automatic loop. A `503 request timed out` or a
-  dropped connection may leave earlier rows committed: re-uploading is safe.
-- **Per-row retry.** A `limited` or `unavailable` row is retried by a later
-  upload, a row in `error` with `privacy_conflict` after its open request
-  ends; `invalid` and `duplicate` rows never succeed by retrying. A queued
-  private row whose request later fails `request_expired` (server restart
-  before the claim) also recovers by uploading again.
-- **Export.** `GET /podcasts/opml/export` with the `Authorization` header
-  (no `?token=` link exists), then save or share the body as
-  `audiosilo-subscriptions.opml`. Read the counts from `X-OPML-Exported`,
-  `X-OPML-Omitted-Private` and `X-OPML-Omitted-Unavailable` and tell the person
-  when shows were left out: **private feeds are never exported**, for anyone,
-  and there is no option to include them. Cross-origin web dev cannot read
-  these headers ([CORS](../server/api/index.md#cors)); the served `/web`
-  player and native apps can. A list too large to export is
-  `413 opml_export_limit`, never a truncated file.
-
-Copy the shared goldens into the player's tests when 2d-2 starts: the server
-keeps them byte-identical in `internal/podcast/testdata/phase2c3/`
-(`providers/*-normalized.json`, `opml/duplicates-private-expected.json`,
-`opml/export-expected.opml`, `opml/export-expected-headers.json`, `wire.json`).
+`OpmlRowStatus` and `OpmlImportRow` mirror the
+[import reference](../server/api/reference.md#post-apiv1podcastsopmlimport),
+their one written copy.
+
+**Client** (`src/api/client.ts`):
+
+| Method | Request |
+|---|---|
+| `podcastDiscoveryProviders()` | `GET /podcasts/discovery/providers` |
+| `searchPodcastDirectory({q, provider, country?, limit?})` | `GET /podcasts/discovery/search`; `country` is sent only with `provider=itunes` |
+| `discoveryArtworkUrl(rel)` | no request: the artwork route rebuilt from the result's 64-hex `id` with the media token (`?id=&token=`); `null`, an absolute URL, another route or a bad id gives `null` (the placeholder) |
+| `followPodcastByUrl(libraryId, feedUrl, {private})` | `POST /podcasts/follow` with exactly `{library_id, feed_url}`, plus `private: true` only when set |
+| `checkPodcast(libraryId, path)` | `POST /podcasts/check` with exactly `{library_id, path}` |
+| `importOpml(libraryId, body)` | `POST /podcasts/opml/import?library_id=` with the raw bytes (a `Blob` on the web, a `Uint8Array` on a device; `send()`'s `raw` body), always `Content-Type: text/x-opml`, no compression, a timeout of at least 45 s (the client's own when longer; the server's import budget is 30 s) |
+| `exportOpml()` | `GET /podcasts/opml/export` with the `Authorization` header (no `?token=` link exists); the counts read through `Headers.get`, so Go's `X-Opml-*` spelling matches, and a missing or non-numeric one is `null` |
+
+`ApiError` gains an optional `retryAfterSeconds`: `Retry-After` when it
+reads as a non-negative number, on any status (a date, or a header the
+browser can't read, is absent). `API_ERROR_CODES` adds `privacy_conflict`,
+`too_many_requests`, `checked_recently`, `invalid_feed_url`,
+`no_library_access`, `not_podcast_library`, the discovery codes
+(`discovery_off`, `provider_unavailable`, `invalid_query`, `invalid_country`,
+`discovery_rate_limited`, `provider_rate_limited`, `discovery_busy`,
+`discovery_timeout`, `provider_rejected`, `discovery_unavailable`) and the
+OPML codes (`opml_rate_limited`, `opml_busy`, `opml_limit`, `invalid_opml`,
+`unsupported_opml_type`, `opml_export_limit`).
+
+**Hooks** (`src/api/hooks.ts`):
+
+- `usePodcastDiscoveryProviders` and `usePodcastSearch(params | null)` are
+  `useCapabilityQuery('podcast_discovery', ...)` with `staleTime` 15 minutes
+  (the server's own cache) and `retry: false`; `null` params ask nothing. Keys
+  `['discoveryProviders', cid]` and
+  `['discoverySearch', cid, provider, q, country, limit]`, so an unchanged
+  repeat reuses the held results.
+- `useFollowPodcastByUrl` and `useCheckPodcast` are
+  `useCapabilityMutation('podcasts', ...)`; `useExportOpml` is
+  `useCapabilityMutation('podcast_opml', ...)`. A `200 following` goes into
+  the cached show list (`storeFollowing`; the list is read again when it lacks
+  the show) and `['myPodcasts', cid]` is read again; a `202 subscribing`
+  request goes to the head of the cached follow requests (`storeAnswer`, so a
+  poll already in flight can't land over it).
+- `useFollowRequests(libraryId, {active})` selects one library's
+  `GET /me/podcasts` `requests`, open first then ended, newest first
+  (`libraryRequests` in `src/lib/podcast-requests.ts`). It reads again every
+  5 s (`FOLLOW_REQUEST_POLL_MS`) only while one of them is open (`queued`,
+  `claimed`, `running` or `needs_attention`: `isOpenRequest`, the Bridge
+  job's open states), its screen is focused (`active`) and the app is in the
+  foreground, so nothing polls once they have all ended. `myPodcastsQuery`
+  compares each answer with the last: a request it saw open that now reads
+  `done` reads its library's show list again, whichever screen asked.
+
+**The rules the player keeps:**
+
+- **Flags.** An absent `podcast_discovery` or `podcast_opml` reads as
+  unsupported. Adding shows (the page and its entry points) needs
+  `podcasts === true` and is never offered to a kid's account or the demo;
+  inside, Search needs `podcast_discovery`, Import needs `podcast_opml`, the
+  feed address is always there. Export needs `podcast_opml` and not the demo,
+  and works with the module off. Check for new episodes is for a followed
+  show under the same rule as adding. The flags don't describe the caller, so
+  the refusals (`kid_account`, `demo_account`, `no_library_access`,
+  `module_off`, `discovery_off`, `not_podcast_library`) still have their own
+  wording.
+- **Search on submit only**, never while typing: the text trimmed with its
+  whitespace runs collapsed (as the server cleans it) and at least two code
+  points, `limit` 20 sent explicitly. The same search again reuses the held
+  results; it is asked again only after it failed. Apple Podcasts unless
+  `podcast_index` is `available`, when a picker chooses; a failed search is
+  never retried on the other provider. `country` is the device locale's
+  `regionCode` (expo-localization) when it is two letters A-Z, for iTunes
+  only, never `metadata.region`; otherwise it is left out (the server's
+  default, US). The list is captioned with the provider ("Results from Apple
+  Podcasts") and each result links its `provider_url`. A `429` shows its
+  `Retry-After` wait when it has one.
+- **Artwork** loads only through the server's proxy (`discoveryArtworkUrl`),
+  lazily as the list windows rows in. An image can't see the status and the
+  route refuses any extra parameter (no cache buster), so a failed load (the
+  server fetches uncached images a few at a time: `429`/`503`) mounts the
+  image again with the same URL after 3, 10 and 30 seconds
+  (`artworkRetryDelay`, four tries in all), then keeps the placeholder (an
+  expired id is a `404` every time).
+- **Follow by address** checks the address first (http or https with a host,
+  at most 2,048 bytes), so a bad one sends nothing. A result's Follow is the
+  same call with its `feed_url`.
+- **Import waves** (`OpmlWaves`, `src/components/podcasts/opml-waves.ts`,
+  framework-free with its own timers; `useOpmlImport` keeps it, and the
+  picked bytes, for the Find shows page's life). A file over 1 MiB is refused
+  before any upload. Each upload's rows merge by `outline_index` (the latest
+  answer wins). No `limited` row left: `done`. Otherwise the next upload of
+  the same bytes waits until every request this import queued (`queued` and
+  `already_queued` rows' `request_id`) is no longer open in
+  `GET /me/podcasts` (absent counts as ended; read every 5 s), fewer than five
+  of the caller's requests are open, and 30 seconds have passed since the last
+  upload. `unavailable` rows never start a wave: a `done` import with some
+  left offers a manual Try again (`canRetryImport`), which uploads once more.
+  The panel reads each queued row's request live, so the import reads done
+  ("All done.") only once none is still being added. A wave that moves no row out
+  of `limited` stops as `stalled` (Try again). `429 opml_rate_limited` and
+  `503 opml_busy` wait their `Retry-After` (else 30 s and 2 s); five such
+  answers in a row stop it. Any other refusal stops as `failed` with its code,
+  and a network failure or a timeout as `failed` with none; Try again
+  re-uploads, which is safe (rows already done answer `already_following` or
+  `already_queued`). The controller holds its timers in the background and
+  looks again at once on the way back, checks `mayActFor` before each upload,
+  and sends nothing more after Stop or once the page is gone.
+- **Export** reads the counts from the `X-OPML-*` headers; a count that
+  reads `null` gives "Exported your shows", and `413 opml_export_limit` has
+  its own message. How it is saved:
+  [Entry points](../frontend/podcasts.md#entry-points).
+- **Check for new episodes** refreshes once after the `202`, with no polling,
+  since a check is not a follow request; `429 checked_recently` and
+  `bridge_unavailable` have their own wording. The button and its timer:
+  [Check for new episodes](../frontend/podcasts.md#check-for-new-episodes).
+- **Copy** never shows the server's English and never says "Bridge":
+  refusals read through `find-shows-model.ts`, and a failed request's
+  `error.code` through `requestReasonKey` (`podcast-model.ts`: `dns`,
+  `timeout`, `tls`, `network` could not reach the feed; `not_a_feed`,
+  `not_a_podcast`; `gone` and `http_*`; `request_expired` and
+  `feed_secret_missing` ask to follow again), all six locales.
+
+**Goldens.** The player keeps the server's
+`internal/podcast/testdata/phase2c3/` files it reads byte-identical in
+`src/testing/podcast-fixtures/phase2c3/` (`wire.json`,
+`providers/*-normalized.json`, `opml/duplicates-private-expected.json`,
+`opml/export-expected.opml`, `opml/export-expected-headers.json`,
+`opml/queue-cap.opml`), and `podcast-fixtures-2c3.test.ts` checks each one's
+SHA-256 against the copied `manifest.json`.
 
 ## Retention policy and deletion authority
 
diff --git a/docs-developers/contributing/documentation.md b/docs-developers/contributing/documentation.md
index 4c18de90..1bd931e3 100644
--- a/docs-developers/contributing/documentation.md
+++ b/docs-developers/contributing/documentation.md
@@ -92,8 +92,8 @@ mappings:
 | Community chapters (`internal/chapteralign`, `internal/chaptercheck`, `catalog/communitychapters.go`, the Chapters card's panel) | [server/community-chapters.md](../server/community-chapters.md) + the Community chapters section of `/users/admin/books` (and `/users/admin/health` for the Health rows) |
 | Auth, invites, shares | [server/auth-and-security.md](../server/auth-and-security.md) + `/users/admin/users-and-invites`, `/users/admin/sharing` |
 | The Bridge: the server's side (`auth/bridge.go`, `internal/bridge`, `handlers_bridge.go`, `handlers_bridge_estimate.go`, the `bridge` capability, the console's `features/bridge/`) or `audiosilo-bridge` (its config, images, compose example, mapping checks, job runner, page, the agent container and its credential hand-off, `sidecars.generate`, `sidecars.describe`, `sidecars.contribute`, `meta.correct`, the setup checklist, the Accounts tab and its GitHub sign-in) | [the Bridge developer pages](../bridge/index.md) (index, pairing and jobs, mappings, characters and recaps, the .audiosilo folder, the agent container, contributions, configuration, development) + the [reference](../server/api/reference.md#the-bridge) + [api/index.md](../server/api/index.md#capability-flags---gate-your-features) (the capability, the codes, the bridge token) + [auth-and-security.md](../server/auth-and-security.md#bridge-tokens) + [data-model.md](../server/data-model.md#the-bridge) + [backups-and-notifications.md](../server/backups-and-notifications.md#events) (the `bridge_job_*` events) + [web-ui.md](../server/web-ui.md) (the console's Settings > Bridge and the book page's Bridge parts) + the [cross-repo contract](../architecture/cross-repo-contract.md#16-the-bridge) (after the workspace `CROSS-REPO.md` §23) + `/users/admin/bridge`, `/users/admin/generating-characters-and-recaps`, `/users/getting-started/running-a-bridge` (its steps follow the setup checklist's order), `/users/getting-started/bridge-accounts` and `/users/community/contributing-from-your-server` + [meta/contributing-data.md](../meta/contributing-data.md#issues-filed-through-the-audiosilo-app) (what the Bridge files, and how meta routes it) + the `admin/settings-bridge*.png`, `admin/bridge-setup.png`, `admin/bridge-pair.png`, `admin/book-generate.png`, `admin/generate-dialog.png` and `admin/book-description.png` screenshots |
-| Podcasts: library kind, `internal/podcast`, catalog/handlers, the Bridge's `podcastjob`, `netguard`, feed/Fetch files, downloads, on-demand/status/Retry and queue prefetch, listener fetch limits, claim priority/reserved capacity, retention aggregates/policies, generations/ETags, publication journals, CHAP or root markers; directory search and OPML (`internal/podcast/{discovery,opml,quota}`, `follow.go`, `opmlimport.go`, `export.go`, `podcasts.discovery.enabled`, the Podcast Index variables) | [bridge/podcasts.md](../bridge/podcasts.md) (with its [discovery and OPML](../bridge/podcasts.md#discovery-and-opml-transfer) section, its [player](../bridge/podcasts.md#player-phase-2d-1) section and the 2d-2 handoff) + [server/modules.md](../server/modules.md), [configuration.md](../server/configuration.md#managed-modules-modules) (and its [podcast discovery](../server/configuration.md#podcast-discovery-podcastsdiscovery) section), [API reference](../server/api/reference.md#podcasts) (including admin storage and Bridge retention), [API flags](../server/api/index.md#capability-flags---gate-your-features), [data-model.md](../server/data-model.md#podcasts), [scanner.md](../server/scanner.md#podcast-libraries), [auth-and-security.md](../server/auth-and-security.md#podcast-visibility), [bridge/configuration.md](../bridge/configuration.md#podcasts), [attachments.md](../bridge/attachments.md#podcast-chap-attachments), [mappings.md](../bridge/mappings.md#podcast-libraries-the-marker), [pairing-and-jobs.md](../bridge/pairing-and-jobs.md#podcast-jobs), [bridge/index.md](../bridge/index.md), [cross-repo-contract.md](../architecture/cross-repo-contract.md#17-podcast-shows-feeds-and-client-visibility) + `/users/admin/podcasts`, `/users/admin/libraries`, `/users/admin/bridge`, `/users/admin/server#modules`, `/users/getting-started/running-a-bridge`, `/users/faq` (what a directory search sends) + `admin/libraries.png`, `admin/library-add.png`, `admin/library-add-podcasts.png`, `admin/library-edit.png` and `admin/settings-modules.png` |
-| The player's podcasts: `src/components/podcasts/`, `src/playback/episode-fetch.ts`, Home's New episodes (`new-episodes-*`, `use-new-episodes.ts`), the `shows` Library mode, `src/lib/library-kind.ts`, the podcast client gate (`auth.PodcastPlayerMinVersion`, `app.json` `expo.version`, `client-id.ts`), the gated whole-list replace (`catalog.GatedScopes`) | [frontend/podcasts.md](../frontend/podcasts.md) + [bridge/podcasts.md](../bridge/podcasts.md#player-phase-2d-1) (the wire and the controller's rules) + [auth-and-security.md](../server/auth-and-security.md#podcast-visibility) + the [reference](../server/api/reference.md#podcasts) (the gate, the replace rules) + [api/index.md](../server/api/index.md#client-identification-x-audiosilo-client) + the lines in [playback.md](../frontend/playback.md), [state-and-data.md](../frontend/state-and-data.md), [offline.md](../frontend/offline.md), [chromecast.md](../frontend/chromecast.md), [end-of-book.md](../frontend/end-of-book.md) and [kids-mode.md](../frontend/kids-mode.md) + `/users/listening/podcasts` (and the podcast lines in `browsing`, `up-next`, `end-of-book`, `offline-downloads`, `chromecast`, `kids-mode`, `mobile-apps`, `/users/troubleshooting`, `/users/admin/podcasts`) + the `web-player/library-shows.png`, `podcast-show.png`, `home-new-episodes.png`, `episode-fetching.png` and `phone-podcast-show.png` screenshots (the podcast seed in `run.sh`) |
+| Podcasts: library kind, `internal/podcast`, catalog/handlers, the Bridge's `podcastjob`, `netguard`, feed/Fetch files, downloads, on-demand/status/Retry and queue prefetch, listener fetch limits, claim priority/reserved capacity, retention aggregates/policies, generations/ETags, publication journals, CHAP or root markers; directory search and OPML (`internal/podcast/{discovery,opml,quota}`, `follow.go`, `opmlimport.go`, `export.go`, `podcasts.discovery.enabled`, the Podcast Index variables) | [bridge/podcasts.md](../bridge/podcasts.md) (with its [discovery and OPML](../bridge/podcasts.md#discovery-and-opml-transfer) section, its [player](../bridge/podcasts.md#player-phase-2d-1) and [player discovery and OPML](../bridge/podcasts.md#player-discovery-and-opml-phase-2d-2) sections) + [server/modules.md](../server/modules.md), [configuration.md](../server/configuration.md#managed-modules-modules) (and its [podcast discovery](../server/configuration.md#podcast-discovery-podcastsdiscovery) section), [API reference](../server/api/reference.md#podcasts) (including admin storage and Bridge retention), [API flags](../server/api/index.md#capability-flags---gate-your-features), [data-model.md](../server/data-model.md#podcasts), [scanner.md](../server/scanner.md#podcast-libraries), [auth-and-security.md](../server/auth-and-security.md#podcast-visibility), [bridge/configuration.md](../bridge/configuration.md#podcasts), [attachments.md](../bridge/attachments.md#podcast-chap-attachments), [mappings.md](../bridge/mappings.md#podcast-libraries-the-marker), [pairing-and-jobs.md](../bridge/pairing-and-jobs.md#podcast-jobs), [bridge/index.md](../bridge/index.md), [cross-repo-contract.md](../architecture/cross-repo-contract.md#17-podcast-shows-feeds-and-client-visibility) + `/users/admin/podcasts`, `/users/admin/libraries`, `/users/admin/bridge`, `/users/admin/server#modules`, `/users/getting-started/running-a-bridge`, `/users/faq` (what a directory search sends) + `admin/libraries.png`, `admin/library-add.png`, `admin/library-add-podcasts.png`, `admin/library-edit.png` and `admin/settings-modules.png` |
+| The player's podcasts: `src/components/podcasts/`, `src/playback/episode-fetch.ts`, Home's New episodes (`new-episodes-*`, `use-new-episodes.ts`), the `shows` Library mode, `src/lib/library-kind.ts`, the podcast client gate (`auth.PodcastPlayerMinVersion`, `app.json` `expo.version`, `client-id.ts`), the gated whole-list replace (`catalog.GatedScopes`); finding shows (`find-shows-*`, `directory-search.tsx`, `discovery-*`, `follow-by-url.tsx`, `follow-requests.tsx`, `opml-*`, `use-opml-import.ts`, `shows-actions.tsx`, `check-episodes-button.tsx`, `artwork-retry.ts`, `src/lib/podcast-requests.ts`, `findShowsHref`, the `podcast_discovery` / `podcast_opml` client methods and hooks), the server's CORS lists (`corsAllowHeaders`, `corsExposeHeaders`) | [frontend/podcasts.md](../frontend/podcasts.md) (and its [Finding shows](../frontend/podcasts.md#finding-shows)) + [bridge/podcasts.md](../bridge/podcasts.md#player-phase-2d-1) (the wire and the controller's rules; [discovery and OPML](../bridge/podcasts.md#player-discovery-and-opml-phase-2d-2) for 2d-2) + [api/index.md CORS](../server/api/index.md#cors) and [cross-repo-contract.md §12](../architecture/cross-repo-contract.md#12-cors-for-web-development) + [auth-and-security.md](../server/auth-and-security.md#podcast-visibility) + the [reference](../server/api/reference.md#podcasts) (the gate, the replace rules) + [api/index.md](../server/api/index.md#client-identification-x-audiosilo-client) + the lines in [playback.md](../frontend/playback.md), [state-and-data.md](../frontend/state-and-data.md), [offline.md](../frontend/offline.md), [chromecast.md](../frontend/chromecast.md), [end-of-book.md](../frontend/end-of-book.md) and [kids-mode.md](../frontend/kids-mode.md) + `/users/listening/podcasts` (and the podcast lines in `browsing`, `up-next`, `end-of-book`, `offline-downloads`, `chromecast`, `kids-mode`, `mobile-apps`, `/users/troubleshooting`, `/users/admin/podcasts`, `/users/admin/server#modules`, `/users/faq`) + the `web-player/library-shows.png`, `podcast-show.png`, `home-new-episodes.png`, `episode-fetching.png`, `phone-podcast-show.png`, `find-shows-search.png`, `find-shows-address.png`, `find-shows-import.png` and `phone-find-shows.png` screenshots (the podcast seed in `run.sh` and its `directory` fixture; Find shows' stand-in routes in `capture-web.mjs`) |
 | Managed modules: the server's `internal/modules` (its `Runner`, the `builtin` registry), `api/modules.go`, a `modules.<id>` setting, the console's Settings > Modules (`features/settings/modules-topic.tsx`), the player's `src/modules/` registry and slots | [server/modules.md](../server/modules.md) (+ the adding-a-module steps) + [configuration.md](../server/configuration.md#managed-modules-modules) (the key, the variable, the runtime table) + the [reference](../server/api/reference.md#get-apiv1adminmodules) (`GET /admin/modules`, the settings envelope's `modules`, the module's flag on `GET /server`, the module's Bridge jobs) + [api/index.md](../server/api/index.md#capability-flags---gate-your-features) (the flag, `module_off`, `kid_account`, `demo_account`) + [bridge/pairing-and-jobs.md](../bridge/pairing-and-jobs.md#jobs-of-a-managed-module) (the jobs a module owns, held while it is off) + [web-ui.md](../server/web-ui.md) + [frontend/state-and-data.md](../frontend/state-and-data.md#player-modules-srcmodules) + the [cross-repo contract](../architecture/cross-repo-contract.md#8-capability-flags-get-apiv1server) + `/users/admin/server#modules` (the console's Learn more link opens it: keep the heading) + `/users/admin/bridge#when-the-contributions-module-is-off` + the `admin/settings-modules.png` screenshot |
 | Chapterless books: the Bridge's `internal/chapterdetect`, `chapter_detecting`, the windows manifest, `chapters.detect`; the server's `metadata/chapterlist.go`, `catalog/generatedchapters.go`, the console's Detect chapters (`health/detect-chapters-dialog.tsx`) and the Chapters card's source control; the player's generated caption | [bridge/chapters.md](../bridge/chapters.md) + [bridge/attachments.md](../bridge/attachments.md#chaptersjson) + [bridge/pairing-and-jobs.md](../bridge/pairing-and-jobs.md#kinds-are-allow-listed-twice) (the kinds table) + [server/community-chapters.md](../server/community-chapters.md#generated-chapters) + the [reference](../server/api/reference.md#post-apiv1adminbridgejobs) (`chapters_source`, `chapter_choice`, `generated_chapters_fit`, the `409` codes) + [api/index.md](../server/api/index.md#capability-flags---gate-your-features) (the `chapters` feature, the codes) + [data-model.md](../server/data-model.md) + [backups-and-notifications.md](../server/backups-and-notifications.md#events) (`chapters_source` on the event) + [web-ui.md](../server/web-ui.md) (Health, the Chapters card) + [frontend/book-page.md](../frontend/book-page.md#the-chapters-tab) (the caption) + `/users/admin/generating-characters-and-recaps#books-without-chapters`, `/users/admin/health`, `/users/admin/books#chapters-found-in-the-narration`, `/users/listening/book-page#chapters` + the `admin/health-detect-chapters.png`, `admin/detect-chapters-dialog.png` and `admin/book-chapters-generated.png` screenshots |
 | Generated characters, recaps and descriptions: `.audiosilo/` (the server's `library/attachments.go`, `metadata/attachments.go`, `catalog/attachments.go`, `meta/generated.go`; the Bridge's `internal/generate`, `internal/pipeline/describe_stage.go`), the console's Description part (`describe-section.tsx`) or the player's generate action, mark and About (`src/components/bridge/`, `GeneratedMark`, `aboutContent`) | [bridge/attachments.md](../bridge/attachments.md) + [bridge/generating.md](../bridge/generating.md) + [server/scanner.md](../server/scanner.md#the-bridges-attachments) + the `/meta` [generated content](../server/api/reference.md#generated-content) + [frontend/book-page.md](../frontend/book-page.md#the-primary-action-and-the-action-row) (and its About) + `/users/admin/generating-characters-and-recaps`, `/users/listening/recaps-and-characters`, `/users/listening/book-page` (About) + the `admin/book-description.png` and `web-player/book-about-generated.png` screenshots |
diff --git a/docs-developers/frontend/podcasts.md b/docs-developers/frontend/podcasts.md
index d07cab61..f368a101 100644
--- a/docs-developers/frontend/podcasts.md
+++ b/docs-developers/frontend/podcasts.md
@@ -1,11 +1,12 @@
 ---
 title: Podcasts
-description: "The player's podcast views (Bridge Phase 2d-1): who sees them, the Shows library mode, the show and episode pages, Follow, Home's New episodes, the episode-fetch controller that plays an episode not on the server yet, and what episodes never do."
+description: "The player's podcast views (Bridge Phases 2d-1 and 2d-2): who sees them, the Shows library mode, the show and episode pages, Follow, Home's New episodes, the episode-fetch controller that plays an episode not on the server yet, finding shows (directory search, a feed address, OPML import and export, Check for new episodes), and what episodes never do."
 ---
 
 ## Scope
 
-Bridge Phase 2d-1 shows a server's podcast libraries in the player. The server
+Bridge Phase 2d-1 shows a server's podcast libraries in the player, and Phase
+2d-2 adds [finding shows](#finding-shows). The server
 lists a podcast library (`Library.kind === 'podcasts'`) only to a client that
 passes its [podcast gate](../server/auth-and-security.md#podcast-visibility):
 the player from **2.2.0** (`app.json` `expo.version`, sent as
@@ -19,13 +20,12 @@ unless a development build opts in with `EXPO_PUBLIC_IDENTIFY_CROSS_ORIGIN=1`
 
 The wire mirror (types, client methods, `PodcastFetchPendingError`, hooks and
 query keys) is documented once, with the server protocol it follows, in
-[Bridge podcasts: Player (Phase 2d-1)](../bridge/podcasts.md#player-phase-2d-1).
-This page covers the screens and the controller. The code is in
+[Bridge podcasts: Player (Phase 2d-1)](../bridge/podcasts.md#player-phase-2d-1)
+and [Player: discovery and OPML (Phase 2d-2)](../bridge/podcasts.md#player-discovery-and-opml-phase-2d-2).
+This page covers the screens and the controllers. The code is in
 `src/components/podcasts/`, `src/playback/episode-fetch.ts`,
-`src/components/home/{new-episodes-model,use-new-episodes,new-episodes-rail}.ts*`
-and `src/lib/library-kind.ts`. Discovery, follow by URL and OPML are
-[Phase 2d-2](../bridge/podcasts.md#player-handoff-discovery-and-opml-phase-2d-2-not-implemented)
-and not in the player.
+`src/components/home/{new-episodes-model,use-new-episodes,new-episodes-rail}.ts*`,
+`src/lib/library-kind.ts` and `src/lib/podcast-requests.ts`.
 
 ## Telling an episode from a book
 
@@ -55,6 +55,9 @@ for a whole list), and the `useIsPodcastLibrary` hook.
   `apiErrorKind` (`module_off`, `kid_account`, `demo_account`,
   `show_not_found`, which also refetches the shows), never the server's text.
 - The fetch status is `podcast_fetch`'s (`usePodcastFetchStatus`).
+- Finding shows, follow by address and Check for new episodes are the
+  module's too (`podcasts`), search is `podcast_discovery`'s and OPML
+  `podcast_opml`'s; see [Finding shows](#finding-shows).
 
 ## Surfaces
 
@@ -70,7 +73,9 @@ hooks there, so those book-only routes are never asked; the count is the
 number of shows. `library-picker.tsx` puts a `microphone` icon beside a
 podcast library.
 
-`PodcastShowsMode` (`shows-mode.tsx`) is an All / Following chip row with
+`PodcastShowsMode` (`shows-mode.tsx`) starts with its
+[actions](#entry-points) (Add shows, the More show actions menu and a line
+while shows are being added), then an All / Following chip row with
 counts over a cover grid of `ShowTile`s (`show-tile.tsx`: `BookCover` on the
 show's path with `cover_version`, the title, then `New episode {{when}}` when
 `latest_published` is in the last 14 days, else the author, and a "Private
@@ -86,8 +91,9 @@ in `BROWSE_PATHS`). `PodcastShowScreen` (`podcast-show-screen.tsx`) names the
 browser tab and renders:
 
 - the hero: cover, title, author, a collapsible description, the episode
-  count, the Private feed badge, `FollowButton`, and "Last check failed" when
-  `status.error` is set (no codes for listeners);
+  count, the Private feed badge, `FollowButton` and
+  [`CheckEpisodesButton`](#check-for-new-episodes), and "Last check failed"
+  when `status.error` is set (no codes for listeners);
 - the order control: `defaultEpisodeOrder(show)` is `oldest` for a `serial`
   show and `newest` otherwise; the segmented control writes `?order=`. The
   client never re-sorts: the server orders by published, then path;
@@ -203,6 +209,130 @@ Cancel or another start since then wins. A start that fails stops as `failed`.
   that is the existing "refusal is a pause" path, and the episode loads
   paused.
 
+## Finding shows
+
+Phase 2d-2 lets a listener add shows to a podcast library from the player:
+search a podcast directory, follow a feed by its address, import an OPML
+list from another app, export the shows they follow, and ask a followed show
+to check for new episodes. The wire rules (search on submit, artwork through
+the proxy, the import waves, export with the `Authorization` header) are in
+[Bridge podcasts](../bridge/podcasts.md#player-discovery-and-opml-phase-2d-2);
+this section covers the screens.
+
+### The page
+
+Route `src/app/(app)/(home,library,search,offline,me)/find-shows.tsx`, URL
+`/find-shows?connection=&library=[&section=search|address|import]`
+(`findShowsHref`, `parseFindShowsParams` in `src/lib/paths.ts`, `openFindShows`
+in `src/lib/open.ts`; `/find-shows` is in `BROWSE_PATHS`). `FindShowsScreen`
+(`find-shows-screen.tsx`) runs in `ContentScope`, so it is scoped to its own
+`?connection=` like the show page, and its title (page and browser tab) is
+**Add shows**.
+
+- **Access** is `useAddShowsAccess(cid)` (`shows-actions.tsx`): `kid` for a
+  kid's account, `demo` for the demo, `unknown` while `/server` isn't known,
+  then `allowed` only with `podcasts === true` (the module on and its Bridge
+  online), else `unavailable`. Anything but `allowed` is a sentence instead of
+  the page ("Ask a grown-up to add shows.", "The demo can't add shows.",
+  "Adding shows isn't available right now").
+- **Sections** come from the flags (`availableSections` in
+  `find-shows-model.ts`, in `FIND_SHOWS_SECTIONS` order): Search with
+  `podcast_discovery`, Feed address always, Import a list with `podcast_opml`. `resolveSection` takes
+  the link's `section` when offered, else the first; a `SegmentedControl`
+  (shown when more than one is offered) writes `?section=`.
+- The import (`useOpmlImport`) is held at page level, so it carries on while
+  another section shows and ends with the page (or a switch to another
+  connection or library).
+
+### The sections
+
+- **Search** (`directory-search.tsx`): one `FlatList` holding the page head,
+  the form (a provider `SegmentedControl` only when Podcast Index is
+  available, the field and Search), the results and, as its footer, the
+  follow requests. Too short a search shows "Type at least 2 characters." and
+  sends nothing. The caption `Results from {{provider}}` credits the
+  directory. A refusal reads through `searchErrorCopy` (with the
+  `Retry-After` seconds when known) above **Search again**.
+  `DiscoveryResultRow` (`discovery-result-row.tsx`) shows the artwork
+  (`DiscoveryArtwork`, `discovery-artwork.tsx`, the retry schedule in
+  `artwork-retry.ts`), title, author, episode count, `View on {{provider}}`
+  (`provider_url`, opened outside the app) and **Follow**, which becomes
+  **Adding** (a `202` request) or **Following** with **Open show** (a `200`).
+  An Adding result reads its request live (`useFollowRequests`, `requestEnd`
+  in `find-shows-model.ts`): ended `done` with a show it turns Following with
+  Open show, ended otherwise it shows **Couldn't add** beside Follow again.
+  The country is `deviceCountry()` (`discovery-country.ts`).
+- **Feed address** (`follow-by-url.tsx`): the address field with a hint, a
+  **Private feed** switch ("For a feed made just for you, like a paid or
+  member feed..."), **Follow**. `feedAddressProblem` refuses an empty, non
+  http(s) or over-2,048-byte address locally; a refusal from the server reads
+  through `followByUrlErrorKey`. A `200` says `You follow {{title}}.` with
+  Open show; a `202` says the show appears in Shows once it's ready.
+- **Follow requests** (`follow-requests.tsx`, under Search and Feed address):
+  "Shows being added", every open request then the ten newest ended ones,
+  each with its redacted feed label, its state (`requestStateKey`: Waiting for
+  its turn, Adding, Added, Couldn't add, Cancelled), the Private feed badge,
+  the reason for a failed one (`requestReasonKey`) and Open show once done. It
+  polls through `useFollowRequests` only while one is open and the page is
+  focused.
+- **Import a list** (`opml-import-panel.tsx`): an intro, **Choose a file**
+  (`pickOpml`: `opml-pick.web.ts` is a hidden file input accepting
+  `.opml,.xml,text/x-opml,text/xml,application/xml`, resolving null on its
+  `cancel` event; `opml-pick.ts` is expo-file-system's `File.pickFileAsync()`
+  with no type filter, since OPML has no system type on iOS, sending
+  `file.bytes()`), then the file name, the summary (`{{settled}} of {{total}} shows followed or being added`,
+  `importProgress`: duplicate and invalid rows
+  don't count), the status line (a countdown to the next batch, ticking with
+  `useNow` while the import runs), **Stop** while it runs, **Try again** once
+  it stopped, stalled or failed, or ended `done` with `unavailable` rows
+  (`canRetryImport`), and one row per subscription by
+  `outline_index` (`Entry {{index}}`, `importRowKey`: Following, Already
+  following, Being added, In the list twice, No usable feed address, Waiting
+  for the next batch, Can't be added right now, Couldn't add). The rows are
+  read live against the follow requests (`liveImportRows`): a queued row whose
+  request ended `done` reads Following, one that ended otherwise Couldn't
+  add. A `done` import's line is "The last shows are still being added."
+  while a row is still queued (`stillAdding`), then
+  `{{count}} shows can't be added right now. Try again later, or ask the person who runs your server.`
+  when `unavailable` rows remain (`unavailableRows`), else "All done.". A
+  row's Private feed badge shows only when it has a usable feed (not
+  `invalid` or `duplicate`, `feed` set), and a row with no label shows only
+  its entry and status. A file over 1 MiB or one that can't be read is a line
+  of its own, and nothing is sent.
+
+### Entry points
+
+- **Shows mode** (`shows-mode.tsx`) puts `ShowsActions` (`shows-actions.tsx`)
+  in the sub-nav row's end on tablet and desktop (`SubNavActions`, id
+  `shows-actions`) and above the grid on a phone: **Add shows** (when access
+  is `allowed`) and the **More show actions** menu with **Export my shows**
+  (`podcast_opml === true`, not the demo; it works with the module off, so it
+  isn't on the Find shows page). `FollowRequestsNotice` beside them reads
+  "Adding 2 shows" while this library's requests are open and opens the page.
+  A library with no shows gets an **Add shows** action in its empty state
+  ("Search a directory, paste a feed address or import a list from another
+  app.") when access is `allowed`.
+- **Export** (`opml-export.ts`, `useExportShows`) saves
+  `audiosilo-subscriptions.opml` through the Journal's `saveExport` (mime
+  `text/x-opml`, UTI `public.xml`), then toasts `exportToast`'s counts
+  ("Exported 3 shows", "1 private show left out. Private feeds are never
+  exported.", shows without a public address left out); a refusal is a toast
+  by `exportErrorKey`.
+
+### Check for new episodes
+
+`CheckEpisodesButton` (`check-episodes-button.tsx`) sits in the show page's
+hero beside Follow, only for a followed show and under `useAddShowsAccess`'s
+`allowed`. A `202` toasts "Checking for new episodes" and, 15 seconds later
+(`CHECK_REFRESH_MS`, the timer cleared on unmount), invalidates the show list
+and the show's episodes once. Refusals read through `checkErrorKey`
+("Checked less than a minute ago. Try again shortly." for
+`checked_recently`).
+
+All copy for these screens is under `podcasts.find.*`, `podcasts.import.*`,
+`podcasts.export.*`, `podcasts.check.*` and `podcasts.requests.*` in all six
+locales; none of it says "Bridge" or shows the server's English.
+
 ## What episodes never do
 
 - **Download** (decision 6.1). The downloads store refuses `book.episode` as
@@ -249,3 +379,22 @@ removal, `fetch_limit`, `identity_changed`); `start-book.test.ts` and
 `player-route.test.tsx` cover the choke point; `podcast-model.test.ts`,
 `library-modes.test.ts` and `new-episodes-model.test.ts` the rules; component
 tests cover the show page, rows, the panel and strip, the Library and Home.
+
+Finding shows (Phase 2d-2): the server's goldens are copied byte-identical
+into `src/testing/podcast-fixtures/phase2c3/` and read through
+`src/testing/podcast-fixtures-2c3.ts` (the list and the SHA-256 check:
+[Player: discovery and OPML](../bridge/podcasts.md#player-discovery-and-opml-phase-2d-2)). `client.test.ts` covers each new method's exact URL, body
+and headers and the refusal codes through `apiErrorKind` (with
+`retryAfterSeconds` read and absent); `hooks-podcasts.test.tsx` the search and
+provider queries, the follow and check mutations' cache writes and
+`useFollowRequests`' polling (only while open, stopping once all ended, the
+show list read again at `done`); `opml-waves.test.ts` drives the wave
+controller on fake timers (the queue-cap shape to `done`, `Retry-After`
+honoured, stalled, `unavailable` with no loop, a failed private request
+queued again by the next wave, stop and dispose sending nothing more,
+polling stopping, the background pause) and `use-opml-import.test.tsx` its
+hook; `find-shows-model.test.ts`, `podcast-requests.test.ts` and
+`paths.test.ts` the rules; component tests cover the page and its gating,
+the search and result rows, the artwork retry, the feed address, the follow
+requests, the import panel, the web picker, export, the Shows mode's actions
+and the check button.
diff --git a/docs-developers/server/api/index.md b/docs-developers/server/api/index.md
index 4942b589..bd8cf127 100644
--- a/docs-developers/server/api/index.md
+++ b/docs-developers/server/api/index.md
@@ -510,7 +510,9 @@ sent `false` otherwise. `podcast_opml` is always `true`: the server speaks the
 OPML import/export protocol, even offline or module-off (the import still
 needs the module, the export does not). Neither is a module flag, and neither
 describes the caller: grants, kid and demo refusals and the client gate are
-still answered by the routes. See
+still answered by the routes. The player (Phase 2d-2) offers its directory
+search only with `podcast_discovery` and OPML import and export only with
+`podcast_opml`. See
 [Podcast discovery](reference.md#podcast-discovery) and
 [OPML import and export](reference.md#opml-import-and-export).
 
@@ -567,23 +569,31 @@ CORS is a strict allow-list driven by `cors_origins` in the server config:
   the player served at `/web`) are unaffected.
 - **Listed origins:** an exact-match `Origin` gets
   `Access-Control-Allow-Origin: <that origin>` (plus `Vary: Origin`), methods
-  `GET, POST, PUT, PATCH, DELETE, OPTIONS`, headers
-  `Authorization, Content-Type, X-AudioSilo-Client`, and
-  a 600 s preflight cache. `OPTIONS` requests short-circuit with 204.
+  `GET, POST, PUT, PATCH, DELETE, OPTIONS`, request headers
+  `Authorization, Content-Type, X-AudioSilo-Client, Range`
+  (`Access-Control-Allow-Headers`), the exposed response headers
+  `Retry-After, X-OPML-Exported, X-OPML-Omitted-Private, X-OPML-Omitted-Unavailable`
+  (`Access-Control-Expose-Headers`, on every allowed response, not only
+  preflights), and a 600 s preflight cache. `OPTIONS` requests short-circuit
+  with 204.
 - **`"*"`:** allows any origin (the request's own `Origin` is echoed back).
 
 For local player development against a dev server, set
 `cors_origins: ["http://localhost:8081"]`.
 
-No `Access-Control-Expose-Headers` is sent, so a cross-origin page cannot read
-response headers such as `Retry-After` or the OPML export's `X-OPML-*` counts
-(the `/web` player and native apps are unaffected). The player falls back to
-the status's `retry_after_seconds` for `Retry-After`. Its episode probe sends
-`Range: bytes=0-0` with its token in `Authorization`, so cross-origin it is
-always preflighted. Browsers that safelist a single byte range leave `Range`
-out of the preflight's `Access-Control-Request-Headers`, so it passes;
-`Allow-Headers` does not list `Range` yet (planned with Phase 2d-2's CORS
-change), so a browser that doesn't safelist it fails the probe there.
+The two lists are the consts `corsAllowHeaders` and `corsExposeHeaders`
+(`internal/api/middleware.go`). `Range` is there for a script's fetch of a
+stream with the `Authorization` header: the player's episode probe sends
+`Range: bytes=0-0` with its token, so cross-origin it is always preflighted
+(an `<audio>` element's own seeks are no-cors and need nothing). The exposed
+headers are `Retry-After` where a route sends one (the discovery and OPML
+budgets, a busy transcode, an episode on its way; the general rate limit and
+the request timeout send none) and the OPML export's counts, so a
+cross-origin web player reads them as the `/web` player and native apps
+always could. A denied or absent origin, and a server with `cors_origins`
+unset, still gets no CORS header at all. An older server exposes nothing, so
+the player falls back to the body's `retry_after_seconds` for an episode
+fetch and reads the export counts as unknown.
 
 ## The contract is hand-mirrored
 
diff --git a/docs-developers/server/api/reference.md b/docs-developers/server/api/reference.md
index 7740ebe6..16bc49f4 100644
--- a/docs-developers/server/api/reference.md
+++ b/docs-developers/server/api/reference.md
@@ -1405,9 +1405,10 @@ sends a finished/failed notification. See [the Bridge implementation](../../brid
 *Session, adult, not demo; Podcasts module.* Directory search finds public
 shows by name; following one is the ordinary
 [`POST /podcasts/follow`](#podcast-actions) with `{library_id, feed_url}`
-(there is no provider-id follow and no new follow field). Nothing in the
-console or a released player calls these routes yet (the player's screens are
-[Phase 2d-2](../../bridge/podcasts.md#player-handoff-discovery-and-opml-phase-2d-2-not-implemented)).
+(there is no provider-id follow and no new follow field). The player's Add
+shows page calls them (players from 2.2.0,
+[Phase 2d-2](../../bridge/podcasts.md#player-discovery-and-opml-phase-2d-2));
+the console does not.
 
 | Route | Query | Success |
 |---|---|---|
@@ -1571,7 +1572,9 @@ fails.
 
 OPML is how podcast apps move subscription lists. The import follows each feed
 of an uploaded list as the caller; the export writes the caller's followed
-public shows. Both are API only for now.
+public shows. The player imports from its Add shows page and exports from the
+Shows library mode ([Phase 2d-2](../../bridge/podcasts.md#player-discovery-and-opml-phase-2d-2));
+the console has no screen for either.
 
 #### `POST /api/v1/podcasts/opml/import`
 
diff --git a/docs-users/admin/podcasts.md b/docs-users/admin/podcasts.md
index 2d8392b5..e46c7276 100644
--- a/docs-users/admin/podcasts.md
+++ b/docs-users/admin/podcasts.md
@@ -1,6 +1,6 @@
 ---
 title: "Podcasts"
-description: "Podcast libraries, episode downloads and per-show retention through the admin API, podcast search and OPML import/export, storage limits, private feeds, and which player apps show podcasts (2.2.0 and later)."
+description: "Podcast libraries, episode downloads and per-show retention through the admin API, podcast search and OPML import/export (in the player and the API), storage limits, private feeds, and which player apps show podcasts (2.2.0 and later)."
 ---
 
 ## What is available now
@@ -13,15 +13,16 @@ reads what the Bridge saves.
 :::info[Players 2.2.0 and later show podcasts]
 The player shows podcast libraries from **version 2.2.0**: the shows, each
 show's episodes, following, a New episodes shelf on Home and playing episodes,
-including ones the Bridge downloads when someone presses Play (see
-[Podcasts](../listening/podcasts.md) in the listening guide). **Older app
+including ones the Bridge downloads when someone presses Play. Listeners can
+also add shows themselves (directory search, a feed address, an OPML list from
+another app), export the shows they follow and ask a show to check for new
+episodes (see [Podcasts](../listening/podcasts.md) in the listening guide). **Older app
 builds don't show podcasts at all**, even to an admin: update the app. The web
 player your server serves is the one built into it, so it shows podcasts once
 the server is up to date.
 
-There is no follow-by-URL, search or import screen in the player or the console
-yet; following a new feed, checking feeds, searching podcast directories and
-OPML import and export are available through the
+The console has no screen for following shows, searching directories or OPML:
+use the player (signed in as yourself) or the
 [developer API](/developers/server/api/reference#podcasts).
 :::
 
@@ -30,8 +31,7 @@ when an admin requests one through the API, or when a compatible client asks
 to play an episode whose audio is missing. It also saves supported MP3 chapter
 markers, and it can
 [search podcast directories and import or export OPML subscription lists](#finding-shows-and-moving-subscriptions).
-External chapter files and transcripts arrive later. The player shows
-on-demand fetching; it does not offer search or OPML yet.
+External chapter files and transcripts arrive later.
 
 ## Set up a podcast library
 
@@ -185,10 +185,12 @@ choosing Archive.
 
 ## Following and feed checks
 
-Through the API, an adult with access to the whole podcast library can follow
-a feed by its URL. In the player (2.2.0 and later), anyone but a kid's account
-or the demo can follow a show already in the library from its page, while the
-module is on and the Bridge is online. Following a visible show already in the library is immediate;
+An adult with access to the whole podcast library can follow a feed by its
+URL, in the player's **Add shows** page or through the API. In the player
+(2.2.0 and later), anyone but a kid's account or the demo can follow a show
+already in the library from its page, add shows and press **Check for new
+episodes** on a show they follow, while the module is on and the Bridge is
+online. Following a visible show already in the library is immediate;
 a new feed waits for the Bridge to validate and save it. Following also lets
 the server schedule downloads selected by the show's policy. Each person can have
 at most five follow requests open at once. Kids and demo accounts cannot
@@ -211,10 +213,12 @@ badge) and episodes already on the server still play.
 ## Finding shows and moving subscriptions
 
 The server can search public podcast directories and read or write OPML, the
-file podcast apps use to move a list of subscriptions. Both are available
-through the [developer API](/developers/server/api/reference#podcast-discovery)
-for now; no screen in the console or the released apps uses them yet. Kids and
-demo accounts cannot search or import.
+file podcast apps use to move a list of subscriptions. Listeners use them from
+the player's **Add shows** page and the Shows **...** menu (see
+[Adding shows](../listening/podcasts.md#adding-shows)); they are also in the
+[developer API](/developers/server/api/reference#podcast-discovery). The
+console has no screen for them. Kids and demo accounts cannot search or
+import.
 
 ### Searching podcast directories
 
@@ -251,11 +255,12 @@ anything. Folders in the file are flattened; titles are ignored.
 requests, and each person can have at most five open at once. Shows already in
 the library are followed straight away and do not count. The rest of the list
 is reported as waiting: import the same file again once those requests finish,
-and the next five go ahead. Entries already followed are reported as such, so
-importing again is safe. Private feeds in the file are recognised
+and the next five go ahead (the player does this by itself while its import page
+is open). Entries already followed are reported as such, so importing again is
+safe. Private feeds in the file are recognised
 [as when following by URL](#private-feeds), but an import cannot mark any
-other feed private: follow such a members-only feed by URL through the API
-with `private` set.
+other feed private: follow such a members-only feed by its address with the
+player's **Private feed** switch on (or through the developer API, marking it private).
 
 Exporting writes every public show the person follows, across their podcast
 libraries, as an OPML file another app can import. It works while the module is
diff --git a/docs-users/admin/server.md b/docs-users/admin/server.md
index 78df9549..bbe38c7f 100644
--- a/docs-users/admin/server.md
+++ b/docs-users/admin/server.md
@@ -384,8 +384,9 @@ The modules today:
   to date, downloads episodes and checks retention. An admin sets retention
   per show [through the API](podcasts.md#downloads-and-retention) for now.
   It needs an online Bridge that supports podcasts. With it on, the server can
-  also [search podcast directories (no Bridge needed) and import OPML](podcasts.md#finding-shows-and-moving-subscriptions)
-  through the API; exporting OPML works with the module on or off.
+  also [search podcast directories (no Bridge needed) and import OPML](podcasts.md#finding-shows-and-moving-subscriptions),
+  which listeners use from the player's Add shows page; exporting OPML works
+  with the module on or off.
   Player apps from 2.2.0
   [show podcasts](podcasts.md#what-is-available-now); older ones don't. Turning the
   module off stops follows and feed/download/retention scheduling, keeping the
diff --git a/docs-users/listening/podcasts.md b/docs-users/listening/podcasts.md
index d35745ce..2388e9ca 100644
--- a/docs-users/listening/podcasts.md
+++ b/docs-users/listening/podcasts.md
@@ -1,6 +1,6 @@
 ---
 title: Podcasts
-description: "Listening to podcasts in the player: shows in the Library, a show's page and its episode order, following a show, New episodes on Home, playing an episode the server hasn't downloaded yet, private feeds, kids, and what episodes don't do yet."
+description: "Listening to podcasts in the player: shows in the Library, a show's page and its episode order, following a show, adding shows (directory search, a feed address, importing a list from another app), exporting your shows, checking for new episodes, New episodes on Home, playing an episode the server hasn't downloaded yet, private feeds, kids, and what episodes don't do yet."
 ---
 
 When your server has a podcast library, the player shows its podcasts beside your books: the
@@ -10,8 +10,9 @@ follow, and episodes that play like any book. Podcasts need the **AudioSilo app
 show podcasts at all; update it from the App Store or Google Play.
 
 Your admin sets podcasts up on the server: see [Podcasts](../admin/podcasts.md) in the admin
-guide. Adding a new show, searching podcast directories and importing a list from another podcast
-app aren't in the player yet; your admin can add shows for you.
+guide. You can [add shows](#adding-shows) yourself: search a podcast directory, paste a feed's
+address, or import the list of shows you follow in another podcast app. You can also
+[export the shows you follow](#exporting-your-shows) to take them elsewhere.
 
 ## Shows in the Library
 
@@ -27,8 +28,14 @@ one in the last 14 days, else who makes the show. A
 **Private feed** badge marks a [private show](#private-feeds). The chips at the top switch
 between **All** shows and the ones you're **Following**, with a count on each.
 
-A library with no shows says **No shows yet**: shows appear once someone follows them on your
-server. Tap a show to open its page.
+Above the grid are **Add shows** (see [Adding shows](#adding-shows)) and a **...** menu with
+[Export my shows](#exporting-your-shows); on a computer or tablet they sit at the end of the
+row with Shows and Folders. While shows you asked for are still being added, a line such as
+**Adding 2 shows** sits above the grid; tap it to see how they're getting on.
+
+A library with no shows says **No shows yet**, with an **Add shows** button when you can add
+them (otherwise shows appear once someone follows them on your server). Tap a show to open its
+page.
 
 ## A show's page
 
@@ -36,7 +43,8 @@ server. Tap a show to open its page.
 
 The top of the page has the show's cover, title and maker, its description (**Show more**
 opens the rest), how many episodes it has, the **Private feed** badge when it is one, and the
-[Follow button](#following-a-show). **Last check failed** means the server couldn't read the
+[Follow button](#following-a-show) and, for a show you follow,
+[Check for new episodes](#checking-for-new-episodes). **Last check failed** means the server couldn't read the
 show's feed the last time it looked; the episodes it already has still play.
 
 **Episode order.** A show that is told in order (a serial) lists its **oldest episode first**, so
@@ -84,6 +92,164 @@ can't follow shows.
 Unfollowing a [private feed](#private-feeds) asks first: the show disappears from your Library,
 and you'd need the feed's address to follow it again.
 
+## Adding shows
+
+**Add shows**, in a podcast library's Shows, opens a page for adding shows to that library. It
+has up to three sections at the top: **Search**, **Feed address** and **Import a list**. Your
+server decides which ones you get: **Feed address** is always there, while **Search** and
+**Import a list** need a server new enough to offer them, and your admin can turn search off.
+
+Adding a show needs the same as the Follow button: your admin has turned podcasts on and the
+server can download episodes right now. Otherwise **Add shows** isn't there, and the page says
+*"Adding shows isn't available right now"*. Kids' accounts and the demo can't add shows. To
+add a show, you need full access to the library (one shared with you only in part says
+*"You can add shows only to a library shared with you in full."*).
+
+Following a show the library already has is instant. A show that's new to the library has to
+be fetched by your server first, which takes a moment: you see it in
+[Shows being added](#shows-being-added) until it's ready.
+
+### Searching a podcast directory
+
+![Add shows on Search: results for "kitchen" from Apple Podcasts, one followed and one being added](/img/screenshots/web-player/find-shows-search.png)
+
+Type a show's name (at least two characters) and press **Search**. The player searches only when
+you press Search, not while you type. Results come from **Apple Podcasts**; when your admin
+has set up **Podcast Index** too, a switch above the field lets you pick which directory to
+search. The list says where its results came from, and each result has:
+
+- the show's artwork, name, maker and number of episodes;
+- **View on Apple Podcasts** (or **View on Podcast Index**), which opens the show's page on the
+  directory;
+- **Follow**. It turns into **Following** with **Open show** when the library already has the
+  show, or **Adding** when the server is fetching it. Once the server is done, **Adding**
+  turns into **Following** with **Open show**, or into **Couldn't add** with **Follow** back
+  to try again ([Shows being added](#shows-being-added) says why).
+
+Searching the same words again shows the same results without asking the directory again. Each
+person can search about ten times a minute: after that the page says *"You've searched a lot
+just now. Try again in 20 s."* (with the real wait). **No shows found** means the directory
+has nothing under those words; try others, or follow the show by its address.
+
+**What the directory sees.** The directory receives the words you searched for (and, for
+Apple, your device's country), and sees your server's address, not yours: the search and the
+artwork go through your server. Nothing about you, your libraries or your devices is sent. See
+[Searching podcast directories](../admin/podcasts.md#searching-podcast-directories) in the
+admin guide.
+
+![Add shows on a phone: the search results](/img/screenshots/web-player/phone-find-shows.png)
+
+### Following a feed by its address
+
+![Add shows on Feed address: an address typed in, Private feed on, and the shows being added](/img/screenshots/web-player/find-shows-address.png)
+
+Every podcast has a feed address (an RSS address, usually ending in `.xml` or `/rss`), shown on
+the show's website or in your podcast app's share or details menu. Paste it into **Feed
+address** and press **Follow**. The address must start with `http://` or `https://`; a
+mistyped one is caught before anything is sent.
+
+Turn on **Private feed** for a feed made just for you, such as a paid or members-only feed:
+only you see the show, and it's [never exported](#exporting-your-shows). Many private
+addresses are recognised as private by themselves; the switch is for the ones that aren't.
+
+If the library already has the show, the page says *"You follow The Slow Kitchen."* with
+**Open show**. Otherwise it says *"Adding the show. It appears in Shows once it's ready."*
+
+When it can't follow the address, the page says why:
+
+| Message | What it means |
+|---|---|
+| **That feed address can't be used. Check it and try again.** | The server can't use the address as it is. |
+| **Five shows are already being added. Try again once one is done.** | Each person can have five shows being added at once. |
+| **This feed is already being added with the other privacy setting. Wait for it to finish, then try again.** | You asked for the same feed with Private feed the other way a moment ago, and that one is still on its way. |
+| **Your server can't add new shows right now. Try again later.** | The part of your server that fetches podcasts is offline. Shows the library already has can still be followed. |
+| **Your server can't save shows to this library.** | Ask your admin. |
+
+### Shows being added
+
+Under **Search** and **Feed address**, **Shows being added** lists what you asked for in this
+library: the ones still on their way first, then the last few that finished. Each shows the
+feed's address (shortened, so a private address isn't on screen in full) and how it's doing:
+**Waiting for its turn**, **Adding**, **Added** (with **Open show**), **Couldn't add** or
+**Cancelled**. A show that couldn't be added says why:
+
+| Reason | What to do |
+|---|---|
+| **Couldn't reach the feed.** | The show's host didn't answer. Check the address, or try again later. |
+| **That address isn't a podcast feed.** | It's a web page or another kind of file; find the show's RSS feed address. |
+| **The feed isn't there any more.** | The show moved or ended. Look for its new address. |
+| **Follow the feed again to finish adding it.** | The server restarted before it got to it. Follow the address (or import the list) again. |
+| **Something went wrong adding it.** | Try again later, or ask your admin. |
+
+The list keeps itself up to date while the page is open, and a show appears in Shows as soon
+as it's added. Back in Shows, **Adding 2 shows** (say) is there while any are on their way.
+
+### Importing a list from another app
+
+![Add shows on Import a list: an import part way through, waiting before its next batch](/img/screenshots/web-player/find-shows-import.png)
+
+To bring the shows you follow in another podcast app, export them there as an **OPML** file
+(look for *Export subscriptions* or *Export OPML* in its settings), then choose **Import a
+list** > **Choose a file** and pick that file. The file can be up to 1 MB.
+
+The page then shows how far it has got (*"7 of 10 shows followed or being added"*) and one line
+per show in the list, by its place in the file (**Entry 4**, say):
+
+| Entry says | What it means |
+|---|---|
+| **Following** | The library had the show, so you follow it now. |
+| **Already following** | You followed it already. |
+| **Being added** | The server is fetching it (see [Shows being added](#shows-being-added)). It turns into **Following** once added, or **Couldn't add**. |
+| **Waiting for the next batch** | Still to come (see below). |
+| **In the list twice** | The same feed appears earlier in the file (its entry number is in brackets). |
+| **No usable feed address** | The entry has no address the server can use. |
+| **Can't be added right now** | The server can't fetch new shows at the moment; ask your admin. |
+| **Couldn't add** | Something else went wrong with this one. |
+
+**Long lists go in batches of five.** Your server adds at most five new shows for you at a time,
+so the rest of a long list waits. The player sends the next batch by itself once the shows
+being added are done and at least half a minute has passed: the page says *"Waiting for the
+shows being added before the next batch."* or *"Next batch in 12 s."* Once the last batch is
+sent it says *"The last shows are still being added."* until they're in, then **All done.**
+Shows the library already has don't wait for a batch.
+
+When some entries **Can't be added right now** (the part of your server that fetches podcasts
+is offline, say), the import doesn't keep retrying them by itself: the page says *"2 shows can't
+be added right now. Try again later, or ask the person who runs your server."* with **Try
+again**, which sends the list once more.
+
+- Keep the page open while it works (you can switch between its sections). Leaving the page,
+  or the app going to the background, pauses or ends the import; shows already added stay. To
+  carry on, choose the same file again: entries already done say so, and the rest go ahead.
+- **Stop** ends it (*"Stopped. Shows already added stay."*). **Try again** starts it again after
+  it stopped, for instance after *"The next batch couldn't start. Try again in a while."* or
+  *"Your server stayed busy. Try again later."*
+- Private feeds in the file are recognised as when you follow an address (such an entry has a
+  **Private feed** badge), but an import can't mark any other feed private: follow that one by its address with **Private feed** on.
+- *"That file isn't an OPML list."* means the file isn't one; *"That file is over 1 MB."* means
+  it's too big to send.
+
+## Exporting your shows
+
+In a podcast library's Shows, the **...** menu has **Export my shows**. It saves the shows you
+follow on this server, across all its podcast libraries, as **audiosilo-subscriptions.opml**,
+a file any podcast app can import: in the web player it downloads, and on a phone or tablet the
+share sheet opens so you can save or send it.
+
+A message then says how many shows it exported and what it left out. **Private feeds are never
+exported**, for anyone, admins included: their addresses work like passwords, and the server
+keeps no copy it could write out. Shows without a public address are left out too. The file
+holds only the shows, not your listening progress or anything else. Exporting works even
+while your admin has podcasts turned off; the demo can't export.
+
+## Checking for new episodes
+
+Your server checks the shows people follow by itself, more often for shows that publish often.
+To look now, press **Check for new episodes** on the page of a show you follow. The player says
+**Checking for new episodes** and shows anything new about 15 seconds later. A show can be checked
+once a minute: sooner, it says *"Checked less than a minute ago. Try again shortly."* The button
+is there only when [adding shows](#adding-shows) is, so not for kids' accounts or the demo.
+
 ## New episodes on Home
 
 ![Home's New episodes shelf: recent episodes from the shows you follow](/img/screenshots/web-player/home-new-episodes.png)
@@ -167,5 +333,3 @@ collection you share with a child. A kid's account can't follow shows. See
 - **Offline downloads.** Episodes can't be downloaded to your device, and automatic downloads and
   keeping the next books ready skip them. They stream from your server.
 - **Casting.** The Cast button doesn't appear while an episode plays.
-- **Finding new shows.** Following a new feed by its address, searching podcast directories and
-  importing or exporting a list of shows aren't in the player yet.
diff --git a/screenshots/README.md b/screenshots/README.md
index 03d7db19..b91adce4 100644
--- a/screenshots/README.md
+++ b/screenshots/README.md
@@ -357,6 +357,22 @@ library is deleted, the module turned off, the player session signed out and thi
 audit log and event feed rows deleted (sqlite3), so neither the connect shots nor the
 admin console's show any of it.
 
+The Add shows shots (`web-player/find-shows-search.png`, `find-shows-address.png`,
+`find-shows-import.png`, `phone-find-shows.png`) run in the same pass, last, each in a
+browser context of its own (the same signed-in storage). Every way in ends in a follow,
+which needs an online Bridge, and a search would reach Apple, so those contexts stand in
+for the server with Playwright routes (`routeFindShows` in `capture-web.mjs`): `/server`
+says `podcasts`, `podcast_discovery` and `podcast_opml`; the directory's providers,
+search and artwork answer from `fixtures/podcasts.json`'s `directory` (made-up shows, one
+of them the seeded The Slow Kitchen; `seed-podcasts.mjs` draws their artwork into
+`.cache/podcast-directory`, beside the podcast root, so the scan never sees it); a follow
+by address answers 200 following for a seeded show's feed and 202 with a new request for
+any other; `/me/podcasts` is the real answer with the pass's made-up follow requests (one
+being added, one that failed); and the OPML import answers one first wave (two
+following, five being added, a duplicate, an invalid entry and three waiting) while its
+five requests stay open, so the page holds on its "Waiting for the shows being added"
+line. Nothing is followed on the server and no request leaves the machine.
+
 The connect shots run last, in a fresh browser with nothing stored:
 `web-player/connect.png` types the server's own address and presses Continue (the probe
 card), then the run signs in as the **admin** with a username and password (a real
diff --git a/screenshots/capture-web.mjs b/screenshots/capture-web.mjs
index e1ff4f36..ae2d8d6e 100644
--- a/screenshots/capture-web.mjs
+++ b/screenshots/capture-web.mjs
@@ -11,7 +11,8 @@
 //   2. capture desktop, tablet and phone profiles into static/img/screenshots/web-player/,
 //   2b. podcasts: run.sh's seeded shows added as a podcast library through the admin API
 //      (the Podcasts module on, two shows followed by path), shot as the admin in a fresh
-//      browser (the episode fetch stood in for by routes), then removed again,
+//      browser (the episode fetch, and Find shows' Bridge and directory, stood in for by
+//      routes), then removed again,
 //   3. the household: three accounts made through the admin API (ADMIN_PASSWORD), and,
 //      as one of them, a collection and the kid household member through the player's
 //      own API (the grown-up member through the add dialog, or the API when only the
@@ -25,6 +26,7 @@ import https from 'node:https';
 import {mkdir} from 'node:fs/promises';
 import {existsSync, readFileSync, statSync} from 'node:fs';
 import {execFileSync} from 'node:child_process';
+import {createHash} from 'node:crypto';
 import {
   CACHE,
   DAY,
@@ -32,6 +34,7 @@ import {
   FIXTURES,
   HOUR,
   MIN,
+  PODCAST_DIRECTORY,
   addHousehold,
   apiClient,
   around,
@@ -40,6 +43,8 @@ import {
   pathQuery,
   shoot,
   sleep,
+  slug,
+  stamp,
   step,
   tid,
   wanted,
@@ -1004,10 +1009,13 @@ const PODCAST_SHOW = 'The Lantern Archive';
 const PODCAST_FETCH_SHOW = 'Field Notes at Dawn';
 const PHONE = {width: 430, height: 932};
 
-// The fixture's shows, each with its feed.json as run.sh wrote it.
+// The fixture's shows, each with its feed.json as run.sh wrote it, and its directory.
 function podcastFixture() {
-  const {shows} = JSON.parse(readFileSync(path.join(FIXTURES, 'podcasts.json'), 'utf8'));
-  return shows.map((s) => ({...s, feed: JSON.parse(readFileSync(path.join(PODCASTS_DIR, s.folder, 'feed.json'), 'utf8'))}));
+  const {shows, directory} = JSON.parse(readFileSync(path.join(FIXTURES, 'podcasts.json'), 'utf8'));
+  return {
+    shows: shows.map((s) => ({...s, feed: JSON.parse(readFileSync(path.join(PODCASTS_DIR, s.folder, 'feed.json'), 'utf8'))})),
+    directory,
+  };
 }
 
 // The newest id in a server feed table (sqlite3), so teardown removes only this pass's rows.
@@ -1016,7 +1024,7 @@ const lastId = (table) => Number(sqlite(`SELECT COALESCE(MAX(id), 0) FROM ${tabl
 async function provisionPodcasts(pod) {
   if (!ADMIN_PASSWORD) throw new Error('ADMIN_PASSWORD not set: no podcast library to add');
   if (!existsSync(PODCASTS_DIR)) throw new Error(`no seeded shows at ${PODCASTS_DIR} (run.sh section 2c)`);
-  pod.shows = podcastFixture();
+  Object.assign(pod, podcastFixture());
   pod.marks = {audit: lastId('audit_events'), events: lastId('server_events')};
   const {token} = await api(null, 'POST', '/auth/login', {username: 'admin', password: ADMIN_PASSWORD}, PODCAST_CLIENT);
   pod.admin = token;
@@ -1182,6 +1190,9 @@ async function capturePodcasts(pod) {
         await phone.close();
       }
     }
+
+    // Find shows, on contexts of their own (the stand-in answers stay there).
+    if (wanted(...Object.values(FIND_SHOTS))) await captureFindShows(ctx, pod, cid);
   } finally {
     // Sign this player session out again, whatever happened above.
     if (session) await api(session, 'POST', '/auth/logout').catch(() => {});
@@ -1189,9 +1200,226 @@ async function capturePodcasts(pod) {
   }
 }
 
-if (wanted(...Object.values(PODCAST_SHOTS))) {
+// ── Podcasts: Find shows (Bridge Phase 2d-2) ────────────────────────────────
+// Every way in ends in a follow, which needs an online Bridge, and a search would reach
+// Apple, so these shots stand in for the server on their own browser contexts with
+// Playwright routes. What each route answers: README.md (the Add shows shots).
+const FIND_SHOTS = {
+  search: 'web-player/find-shows-search.png',
+  address: 'web-player/find-shows-address.png',
+  import: 'web-player/find-shows-import.png',
+  phone: 'web-player/phone-find-shows.png',
+};
+const FIND_QUERY = 'kitchen';
+// A feed address as the server shows it in a request or an import row (its origin only).
+const feedLabel = (url) => url.replace(/^(https?:\/\/[^/]+).*$/, '$1/...');
+// The directory result standing for a seeded show (Follow answers 200 following) and the
+// first one that is new (Follow answers 202 with a request).
+const seededResult = (pod) => pod.directory.find((d) => d.folder);
+const newResult = (pod) => pod.directory.find((d) => !d.folder);
+
+// The made-up directory's results (the server's PodcastDiscoverySearch shape), and the
+// artwork behind each result's proxy id (read once; a missing file answers 404).
+function findShowsDirectory(pod) {
+  const art = new Map();
+  const results = pod.directory.map((d) => {
+    const name = slug(d.title);
+    const seeded = d.folder ? pod.shows.find((s) => s.folder === d.folder) : null;
+    const id = createHash('sha256').update(`directory:${name}`).digest('hex');
+    if (d.artwork !== false) {
+      const file = seeded ? path.join(PODCASTS_DIR, d.folder, 'cover.jpg') : path.join(PODCAST_DIRECTORY(PODCASTS_DIR), `${name}.jpg`);
+      if (existsSync(file)) art.set(id, readFileSync(file));
+    }
+    return {
+      title: d.title,
+      author: d.author,
+      feed_url: seeded ? seeded.feed.feed_url : `https://${d.host}/${name}.xml`,
+      artwork_url: d.artwork === false ? null : `/api/v1/podcasts/discovery/artwork?id=${id}`,
+      provider_ids: {itunes: d.itunes_id, podcast_index: null},
+      episode_count: d.episodes,
+      provider_url: `https://podcasts.apple.com/us/podcast/${name}/id${d.itunes_id}`,
+    };
+  });
+  return {results, art};
+}
+
+// Route the Find shows answers on `ctx` (see above). Returns the stand-in's state.
+async function routeFindShows(ctx, pod, stand) {
+  const origin = new URL(BASE).origin;
+  const at = (p) => (url) => url.origin === origin && url.pathname === `/api/v1${p}`;
+  const json = (route, status, body) => route.fulfill({status, contentType: 'application/json', body: JSON.stringify(body)});
+  await ctx.route(at('/server'), async (route) => {
+    const res = await route.fetch();
+    const info = await res.json();
+    info.capabilities = {...info.capabilities, podcasts: true, podcast_discovery: true, podcast_opml: true};
+    return route.fulfill({response: res, json: info});
+  });
+  await ctx.route(at('/podcasts/discovery/providers'), (route) =>
+    json(route, 200, {providers: [{id: 'itunes', available: true}, {id: 'podcast_index', available: false}]}),
+  );
+  await ctx.route(at('/podcasts/discovery/search'), (route) => {
+    const q = new URL(route.request().url()).searchParams;
+    return json(route, 200, {provider: 'itunes', query: q.get('q') ?? '', country: q.get('country') ?? 'US', results: stand.directory.results});
+  });
+  await ctx.route(at('/podcasts/discovery/artwork'), (route) => {
+    const body = stand.directory.art.get(new URL(route.request().url()).searchParams.get('id'));
+    if (!body) return json(route, 404, {error: 'artwork not found', code: 'artwork_not_found'});
+    return route.fulfill({status: 200, contentType: 'image/jpeg', body});
+  });
+  await ctx.route(at('/podcasts/follow'), (route) => {
+    if (route.request().method() !== 'POST') return route.continue();
+    const {feed_url: feedUrl, private: isPrivate} = route.request().postDataJSON() ?? {};
+    const seeded = pod.shows.find((s) => s.feed.feed_url === feedUrl);
+    if (seeded) {
+      const show = stand.shows.find((s) => s.path === seeded.folder);
+      return json(route, 200, {state: 'following', show: {...show, following: true}});
+    }
+    const request = stand.request(stand.nextId++, 'queued', feedLabel(feedUrl), 0, {private: isPrivate === true});
+    stand.requests.unshift(request);
+    return json(route, 202, {state: 'subscribing', request});
+  });
+  await ctx.route(at('/me/podcasts'), async (route) => {
+    const res = await route.fetch();
+    const mine = await res.json();
+    return route.fulfill({response: res, json: {...mine, requests: stand.requests}});
+  });
+  await ctx.route(at('/podcasts/opml/import'), (route) => {
+    // Once only, however often the page uploads (a repeat would list each request twice).
+    if (!stand.requests.includes(stand.importRequests[0])) stand.requests.unshift(...stand.importRequests);
+    return json(route, 200, {library_id: pod.library.id, rows: stand.importRows});
+  });
+}
+
+// The stand-in's state: the library's real shows (for a 200 follow), the follow requests
+// `/me/podcasts` lists (one being added and one that failed to start with), and the
+// import's first wave.
+async function findShowsStand(pod) {
+  const shows = (await api(pod.admin, 'GET', `/libraries/${pod.library.id}/podcasts`, undefined, PODCAST_CLIENT))?.shows ?? [];
+  const request = (id, state, feed, ago, extra = {}) => ({
+    id, library_id: pod.library.id, state, feed, private: false, show_path: null, error: null,
+    created_at: stamp(Date.now() - ago), updated_at: stamp(Date.now() - Math.max(0, ago - MIN)), ...extra,
+  });
+  const imported = [
+    ['feeds.marketday.example', 'queued'], ['audio.hillwalkers.example', 'queued'], ['rss.quietpages.example', 'queued'],
+    ['members.tidewater.example', 'queued', true], ['feeds.boatyard.example', 'running'],
+  ];
+  const importRequests = imported.map(([host, state, isPrivate], i) => request(101 + i, state, `https://${host}/...`, 20_000 - i * 1000, {private: !!isPrivate}));
+  const row = (outline_index, status, extra = {}) => ({
+    outline_index, status, feed: null, private: false, path: null, request_id: null, duplicate_of: null, error: null, ...extra,
+  });
+  const slow = pod.shows.find((s) => s.folder === seededResult(pod).folder);
+  const lantern = pod.shows.find((s) => s.folder === PODCAST_SHOW);
+  const importRows = [
+    row(2, 'followed', {feed: feedLabel(slow.feed.feed_url), path: slow.folder}),
+    row(3, 'already_following', {feed: feedLabel(lantern.feed.feed_url), path: lantern.folder}),
+    ...importRequests.map((r, i) => row(4 + i, 'queued', {feed: r.feed, private: r.private, request_id: r.id})),
+    row(9, 'duplicate', {feed: importRequests[0].feed, duplicate_of: 4}),
+    row(10, 'invalid', {error: {code: 'invalid_feed_url', message: 'invalid feed URL'}}),
+    ...['feeds.northlight.example', 'audio.cellarclub.example', 'rss.weekendwalks.example'].map((host, i) =>
+      row(12 + i, 'limited', {feed: `https://${host}/...`}),
+    ),
+  ];
+  return {
+    shows,
+    directory: findShowsDirectory(pod),
+    request,
+    nextId: 92,
+    requests: [
+      request(91, 'running', 'https://feeds.harbourlights.example/...', 4 * MIN),
+      request(88, 'failed', 'https://www.oldmill.example/...', 3 * HOUR, {error: {code: 'not_a_feed', message: 'not a podcast feed'}}),
+    ],
+    importRequests,
+    importRows,
+  };
+}
+
+// The OPML list the import shot chooses (the stand-in answers it, so only its name and
+// that it is OPML matter).
+const FIND_OPML = `<?xml version="1.0" encoding="UTF-8"?>
+<opml version="2.0"><head><title>My podcasts</title></head><body>
+<outline text="Food"><outline type="rss" text="The Slow Kitchen" xmlUrl="https://feeds.example.com/the-slow-kitchen.xml"/></outline>
+</body></opml>
+`;
+
+async function captureFindShows(ctx, pod, cid) {
+  const stand = await findShowsStand(pod);
+  const findUrl = (section) =>
+    `${BASE}find-shows?connection=${encodeURIComponent(cid)}&library=${pod.library.id}&section=${section}`;
+  // Search, follow two results (one the library has, one new), and wait for the rows.
+  const searchAndFollow = async (p, {follow}) => {
+    await p.goto(findUrl('search'), {waitUntil: 'networkidle', timeout: 45000});
+    await tid(p, 'directory-search-input').fill(FIND_QUERY);
+    await tid(p, 'directory-search-submit').click({timeout: 8000});
+    await firstVisible(p.getByTestId('discovery-result')).waitFor({timeout: 15000});
+    if (follow) {
+      await p.getByRole('button', {name: `Follow ${seededResult(pod).title}`}).click({timeout: 8000});
+      await firstVisible(p.getByRole('button', {name: 'Open show'})).waitFor({timeout: 15000});
+      await p.getByRole('button', {name: `Follow ${newResult(pod).title}`}).click({timeout: 8000});
+      await tid(p, 'discovery-result-adding').waitFor({timeout: 15000});
+    }
+    await sleep(2000); // the artwork
+  };
+  const desk = await sameDevice(ctx);
+  try {
+    await routeFindShows(desk, pod, stand);
+    const p = await desk.newPage();
+    if (wanted(FIND_SHOTS.search)) {
+      await step('podcasts: find shows search', async () => {
+        await searchAndFollow(p, {follow: true});
+        await p.mouse.move(0, 0);
+        await shoot(p, FIND_SHOTS.search);
+      });
+    }
+    if (wanted(FIND_SHOTS.address)) {
+      await step('podcasts: find shows address', async () => {
+        // The queued request the search shot's follow adds, when that shot didn't run.
+        if (!stand.requests.some((r) => r.state === 'queued')) {
+          const feed = feedLabel(stand.directory.results.find((r) => r.title === newResult(pod).title).feed_url);
+          stand.requests.unshift(stand.request(stand.nextId++, 'queued', feed, 0));
+        }
+        await p.goto(findUrl('address'), {waitUntil: 'networkidle', timeout: 45000});
+        await tid(p, 'follow-requests').waitFor({timeout: 15000});
+        await tid(p, 'feed-address').fill('https://members.example.net/rss/8f3a2c');
+        await tid(p, 'private-feed').click({timeout: 8000});
+        await sleep(SETTLE_MS);
+        await p.mouse.move(0, 0);
+        await shoot(p, FIND_SHOTS.address);
+      });
+    }
+    if (wanted(FIND_SHOTS.import)) {
+      await step('podcasts: find shows import', async () => {
+        await p.goto(findUrl('import'), {waitUntil: 'networkidle', timeout: 45000});
+        const chooser = p.waitForEvent('filechooser', {timeout: 15000});
+        await tid(p, 'opml-choose').click({timeout: 8000});
+        await (await chooser).setFiles({name: 'podcast-subscriptions.opml', mimeType: 'text/x-opml', buffer: Buffer.from(FIND_OPML)});
+        await tid(p, 'opml-summary').waitFor({timeout: 15000});
+        await p.getByText('Waiting for the shows being added', {exact: false}).waitFor({timeout: 15000});
+        await sleep(SETTLE_MS);
+        await p.mouse.move(0, 0);
+        await shoot(p, FIND_SHOTS.import);
+      });
+    }
+  } finally {
+    await desk.close();
+  }
+  if (wanted(FIND_SHOTS.phone)) {
+    const phone = await sameDevice(ctx, {viewport: PHONE});
+    try {
+      await routeFindShows(phone, pod, stand);
+      const p = await phone.newPage();
+      await step('podcasts: phone find shows', async () => {
+        await searchAndFollow(p, {follow: false});
+        await shoot(p, FIND_SHOTS.phone);
+      });
+    } finally {
+      await phone.close();
+    }
+  }
+}
+
+if (wanted(...Object.values(PODCAST_SHOTS), ...Object.values(FIND_SHOTS))) {
   console.log('== podcasts ==');
-  const pod = {admin: null, library: null, moduleOn: false, shows: [], marks: null};
+  const pod = {admin: null, library: null, moduleOn: false, shows: [], directory: [], marks: null};
   try {
     await step('provision podcasts', () => provisionPodcasts(pod));
     if (pod.library) await step('podcasts', () => capturePodcasts(pod));
diff --git a/screenshots/fixtures/podcasts.json b/screenshots/fixtures/podcasts.json
index 542781e9..707265d5 100644
--- a/screenshots/fixtures/podcasts.json
+++ b/screenshots/fixtures/podcasts.json
@@ -50,5 +50,14 @@
         {"title": "The patience of onions", "days_ago": 23, "minutes": 16, "description": "Caramelising slowly, properly, and the soup it becomes."}
       ]
     }
+  ],
+  "_directory_comment": "`directory` is a made-up podcast directory's answer for the Find shows shots (capture-web.mjs answers the search with it; README.md, the Add shows shots). seed-podcasts.mjs writes each entry's artwork (a gradient with its name, from `colors`) into the podcast-directory folder beside the podcast root, except `artwork: false` (no artwork: the placeholder). `folder` names a seeded show the result stands for (its feed address and cover); `host` is the feed's host for the others. All names here are invented.",
+  "directory": [
+    {"title": "The Slow Kitchen", "author": "Larder & Lamp", "folder": "The Slow Kitchen", "episodes": 3, "itunes_id": "1730041187"},
+    {"title": "The Kitchen Garden Hour", "author": "Allotment Wireless", "colors": ["0x1f3d1a", "0x6f9a3c"], "episodes": 128, "itunes_id": "1501873320", "host": "feeds.allotmentwireless.example"},
+    {"title": "Kitchen Table Physics", "author": "Two Mugs Media", "colors": ["0x1b2440", "0x4f6bd0"], "episodes": 56, "itunes_id": "1622950418", "host": "audio.twomugs.example"},
+    {"title": "Night Kitchen Radio", "author": "Late Shift Collective", "colors": ["0x2a1238", "0x8a3f8f"], "episodes": 212, "itunes_id": "1398201765", "host": "rss.lateshift.example"},
+    {"title": "Small Kitchen, Big Flavour", "author": "Pantry Press", "artwork": false, "episodes": 44, "itunes_id": "1688420093", "host": "feeds.pantrypress.example"},
+    {"title": "Notes from a Ship's Kitchen", "author": "Galley Stories", "colors": ["0x0f3b46", "0x3d8ea0"], "episodes": 18, "itunes_id": "1755310642", "host": "podcast.galleystories.example"}
   ]
 }
diff --git a/screenshots/lib.mjs b/screenshots/lib.mjs
index b5d4d98d..f1e285a2 100644
--- a/screenshots/lib.mjs
+++ b/screenshots/lib.mjs
@@ -19,6 +19,15 @@ export const MIN = 60_000;
 export const HOUR = 60 * MIN;
 export const DAY = 24 * HOUR;
 export const isoAgo = (ms) => new Date(Date.now() - ms).toISOString();
+// RFC 3339 without milliseconds (as the Bridge writes it), for the epoch time `ms`.
+export const stamp = (ms) => new Date(ms).toISOString().replace(/\.\d+Z$/, 'Z');
+
+// A name as a file or URL slug ("The Slow Kitchen" -> "the-slow-kitchen").
+export const slug = (s) => s.toLowerCase().replace(/[^a-z0-9]+/g, '-').replace(/^-|-$/g, '');
+
+// Where seed-podcasts.mjs writes the made-up directory's artwork for the podcast root
+// `root` (beside it, so the library scan never sees it).
+export const PODCAST_DIRECTORY = (root) => path.join(path.dirname(path.resolve(root)), 'podcast-directory');
 
 // A content path as the API's `?path=` query.
 export const pathQuery = (relPath) => `?path=${encodeURIComponent(relPath)}`;
diff --git a/screenshots/manifest.mjs b/screenshots/manifest.mjs
index 617138e6..d202ed87 100644
--- a/screenshots/manifest.mjs
+++ b/screenshots/manifest.mjs
@@ -72,11 +72,17 @@ export const SHOTS = [
   {file: 'web-player/player-cast.png', capture: 'web', title: 'Web player - Cast button', hint: 'the full player (book paused), clipped to the transport and the action row ending with the Cast button: an https page through a local proxy in Chromium, server with cast'},
   // Podcasts (capture-web.mjs's podcast pass: run.sh seeds three made-up shows, the pass adds
   // them as a podcast library, the admin follows two by path, no Bridge; see README.md)
-  {file: 'web-player/library-shows.png', capture: 'web', title: 'Web player - Shows', hint: 'Library > Shows on the podcast library (picked in the library picker): Shows and Folders in the sub-nav, the All / Following chips (3 and 2) and the cover grid of show tiles with their new-episode captions'},
+  {file: 'web-player/library-shows.png', capture: 'web', title: 'Web player - Shows', hint: 'Library > Shows on the podcast library (picked in the library picker): Shows and Folders in the sub-nav, the library picker and the More show actions menu (...: Export my shows; no Add shows, since no Bridge is online), the All / Following chips (3 and 2) and the cover grid of show tiles with their new-episode captions'},
   {file: 'web-player/podcast-show.png', capture: 'web', title: 'Web player - Show page', hint: "The Lantern Archive's show page (a serial show, followed): the cover hero with the Following badge (no Follow button: no Bridge is online), the episode count and order (oldest first), then the trailer and S1 E1-E4, Ready on your server but the newest, which isn't on the server (Not available now, its Play dimmed: no Bridge is online to fetch it)"},
   {file: 'web-player/home-new-episodes.png', capture: 'web', title: 'Web player - New episodes', hint: "the admin's Home scrolled to New episodes (From shows you follow, All shows): the followed shows' episodes of the last 14 days, newest first, with no trailer"},
   {file: 'web-player/episode-fetching.png', capture: 'web', title: 'Web player - Getting an episode', hint: "phone-width full player for an episode not on the server (Field Notes at Dawn's newest), started from its episode page: the cover, Getting this episode with how far it is (<received> of <total>) and its progress bar, Cancel (the server's fetch answers are stood in for by the capture, no Bridge runs)"},
   {file: 'web-player/phone-podcast-show.png', capture: 'web', title: 'Phone - Show page', hint: "phone-width show page of The Lantern Archive: the cover over the title and author, the Following badge, the description, the Newest first / Oldest first switch and the episode list from the trailer, the tab bar"},
+  // Find shows (Phase 2d-2): the same pass, its Bridge and directory stood in for by routes
+  // on their own browser context (README.md, the podcast shots)
+  {file: 'web-player/find-shows-search.png', capture: 'web', title: 'Web player - Add shows: Search', hint: "Add shows (/find-shows) on the Search section after searching \"kitchen\": the Search / Feed address / Import a list control, the search field, Results from Apple Podcasts, the made-up directory's results with their artwork (one placeholder), episode counts and View on Apple Podcasts links; The Slow Kitchen followed (Following, Open show) and The Kitchen Garden Hour Adding (Shows being added is below the fold)"},
+  {file: 'web-player/find-shows-address.png', capture: 'web', title: 'Web player - Add shows: Feed address', hint: 'the Feed address section: an address typed in, the Private feed switch on with its hint, Follow, then Shows being added: one queued (Waiting for its turn), one Adding, one that failed (Couldn\'t add, "That address isn\'t a podcast feed.")'},
+  {file: 'web-player/find-shows-import.png', capture: 'web', title: 'Web player - Add shows: Import a list', hint: 'the Import a list section mid-import: the intro, Choose another file (disabled while it runs), the file name, "7 of 10 shows followed or being added", "Waiting for the shows being added before the next batch.", Stop, and the first entries by their place in the list (Entry 2 Following, Entry 3 Already following, Entries 4-6 Being added; the rest, with a Private feed, In the list twice, No usable feed address and Waiting for the next batch, are below the fold)'},
+  {file: 'web-player/phone-find-shows.png', capture: 'web', title: 'Phone - Add shows', hint: 'phone-width Add shows on the Search section after searching "kitchen": the section control, the search field and button, Results from Apple Podcasts and the result rows with their artwork and Follow buttons, the tab bar'},
 
   // ── Admin console (admin-ui, desktop 1440x900 dark unless noted) + public server pages
   {file: 'admin/login.png', capture: 'admin', title: 'Admin - Sign in', hint: 'the console sign-in page, signed out'},
diff --git a/screenshots/seed-podcasts.mjs b/screenshots/seed-podcasts.mjs
index 30b8f095..bb51aa0a 100644
--- a/screenshots/seed-podcasts.mjs
+++ b/screenshots/seed-podcasts.mjs
@@ -4,6 +4,9 @@
 //   - feed.json (feed.json v1, as docs-developers/bridge/podcasts.md describes it), dated
 //     back from now, so the newest episodes are always within Home's 14 days,
 //   - cover.jpg (a gradient with the show's name, ffmpeg),
+//   - the made-up directory's artwork for the Find shows shots (the fixture's `directory`,
+//     one <slug>.jpg each but those with `artwork: false` or a seeded `folder`), into
+//     podcast-directory beside <root>, outside the library,
 //   - one short silent mp3 per episode (ffmpeg), each with the fetch pin a Bridge writes
 //     once it has the file (generation 1, sha256, bytes and duration read from that file),
 //     except the episodes marked `absent`: no file and no pin, so the server lists them
@@ -16,19 +19,16 @@ import {spawnSync} from 'node:child_process';
 import {existsSync, mkdirSync, readFileSync, rmSync, statSync, writeFileSync} from 'node:fs';
 import path from 'node:path';
 
-import {DAY, FIXTURES, HOUR, ffmpeg, silence} from './lib.mjs';
+import {DAY, FIXTURES, HOUR, PODCAST_DIRECTORY, ffmpeg, silence, slug, stamp} from './lib.mjs';
 
 const root = process.argv[2];
 if (!root) {
   console.error('usage: node seed-podcasts.mjs <root>');
   process.exit(1);
 }
-const {shows} = JSON.parse(readFileSync(path.join(FIXTURES, 'podcasts.json'), 'utf8'));
+const {shows, directory} = JSON.parse(readFileSync(path.join(FIXTURES, 'podcasts.json'), 'utf8'));
 
 const sha256 = (data) => createHash('sha256').update(data).digest('hex');
-const slug = (s) => s.toLowerCase().replace(/[^a-z0-9]+/g, '-').replace(/^-|-$/g, '');
-// RFC 3339 without milliseconds, as the Bridge writes it.
-const stamp = (ms) => new Date(ms).toISOString().replace(/\.\d+Z$/, 'Z');
 
 // A font for the covers' text (drawtext needs a file on macOS); without one the cover
 // is the gradient alone.
@@ -170,3 +170,11 @@ for (const show of shows) {
   writeFileSync(path.join(dir, 'feed.json'), JSON.stringify(feed, null, 2) + '\n');
 }
 console.log(`  ✓ ${shows.length} shows, ${files} episode files, ${absent} episodes not on the server`);
+
+// The directory's artwork (capture-web.mjs answers the artwork route with these files).
+const directoryDir = PODCAST_DIRECTORY(root);
+rmSync(directoryDir, {recursive: true, force: true});
+mkdirSync(directoryDir, {recursive: true});
+const drawn = directory.filter((d) => d.artwork !== false && !d.folder);
+for (const d of drawn) cover(path.join(directoryDir, `${slug(d.title)}.jpg`), d, directoryDir);
+console.log(`  ✓ ${drawn.length} directory artworks`);
diff --git a/static/img/screenshots/web-player/find-shows-address.png b/static/img/screenshots/web-player/find-shows-address.png
new file mode 100644
index 00000000..112d9e1a
Binary files /dev/null and b/static/img/screenshots/web-player/find-shows-address.png differ
diff --git a/static/img/screenshots/web-player/find-shows-import.png b/static/img/screenshots/web-player/find-shows-import.png
new file mode 100644
index 00000000..488878fe
Binary files /dev/null and b/static/img/screenshots/web-player/find-shows-import.png differ
diff --git a/static/img/screenshots/web-player/find-shows-search.png b/static/img/screenshots/web-player/find-shows-search.png
new file mode 100644
index 00000000..9a76db17
Binary files /dev/null and b/static/img/screenshots/web-player/find-shows-search.png differ
diff --git a/static/img/screenshots/web-player/library-shows.png b/static/img/screenshots/web-player/library-shows.png
index 49ce8392..882093b3 100644
Binary files a/static/img/screenshots/web-player/library-shows.png and b/static/img/screenshots/web-player/library-shows.png differ
diff --git a/static/img/screenshots/web-player/phone-find-shows.png b/static/img/screenshots/web-player/phone-find-shows.png
new file mode 100644
index 00000000..a8c6fb59
Binary files /dev/null and b/static/img/screenshots/web-player/phone-find-shows.png differ