From 89fe26c558a700f5941ad25f0568fa49242afc1c Mon Sep 17 00:00:00 2001
From: Claude <noreply@anthropic.com>
Date: Sat, 8 Aug 2026 23:21:19 +0000
Subject: [PATCH] feat(track-matcher): tracklist input, separators, and store
 search links
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Closes the Track Matcher row and the honest half of Store Links, per
`docs/lexicon/08-streaming.md`. Scoping for the rest of Epic 7 is recorded in
`GAPS.md` rather than guessed at.

Track Matcher:
- `.txt` and `.m3u8` through one reader, since an `.m3u8` is a text file whose
  non-track lines start with `#`. `#EXTINF` titles are preferred over the path
  lines beneath them — a path is a location, and matching by path is what
  Relocate is for.
- Selectable separator as the manual specifies rather than a guess: hyphen, en
  dash, em dash, `Title by Artist` (the one form where the sides swap), none, or
  custom. Mis-splitting produces confident wrong matches, not obvious failures.
- Numbered setlist indices stripped, because `1. Daft Punk` is not an artist and
  normalisation will not fix it. A digit alone is never an index — `99 Problems`
  and `1979` are titles — so it needs punctuation after it, or a leading `#`.
- `#` is ambiguous between the formats: directive in `.m3u8`, index in a
  hand-written list. Letters after it mean directive, digits mean index. Both of
  these came out of failing tests and both now have regression tests.
- Playlist creation from matches, wired to the existing command.

Store Links / onward search, as generated search URLs across Beatport,
Bandcamp, Discogs, Spotify, Tidal, SoundCloud and YouTube. This is the tedious
part of both features and it is honest: a search link claims nothing about
whether a track exists or what it costs. Price comparison and playlist push are
NOT built — both need a registered application and a per-user token per service
— and the UI says so rather than implying a comparison that is not happening.

Not built, with the reasons kept distinct in GAPS.md: Beatport catalog/cart,
Charts, Send To, SoundCloud playback and Track Discovery need credentials only
the account owner can obtain; streaming tracks and Transfer Streaming To Local
need a verified place to store a streaming reference, which `master.db` does not
appear to offer and which no real database is available here to check.

Parity: 62 done / 21 partial / 11 missing / 2 blocked / 16 deferred.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_011Gn43w2xFL3JRBRkMv3vRo
---
 apps/desktop/src-tauri/src/lib.rs             |  37 ++
 .../src/components/TrackMatcherView.test.tsx  | 185 ++++++++
 .../src/components/TrackMatcherView.tsx       | 203 ++++++++-
 apps/desktop/src/ipc.ts                       |  31 ++
 apps/desktop/src/types.ts                     |  37 ++
 crates/track-matcher/src/lib.rs               |   2 +
 crates/track-matcher/src/store_links.rs       | 257 +++++++++++
 crates/track-matcher/src/tracklist.rs         | 413 ++++++++++++++++++
 docs/JOURNAL.md                               |  54 +++
 docs/STATUS.md                                |  55 +++
 docs/lexicon/08-streaming.md                  |  35 +-
 docs/lexicon/GAPS.md                          |  51 +++
 docs/lexicon/PARITY.md                        |  21 +-
 13 files changed, 1357 insertions(+), 24 deletions(-)
 create mode 100644 crates/track-matcher/src/store_links.rs
 create mode 100644 crates/track-matcher/src/tracklist.rs

diff --git a/apps/desktop/src-tauri/src/lib.rs b/apps/desktop/src-tauri/src/lib.rs
index d61a0e9..44e9aac 100644
--- a/apps/desktop/src-tauri/src/lib.rs
+++ b/apps/desktop/src-tauri/src/lib.rs
@@ -2268,6 +2268,41 @@ fn parse_csv_for_matcher(
         .map_err(|e| e.to_string())
 }
 
+/// Read a pasted or uploaded `.txt` / `.m3u8` tracklist.
+///
+/// The CSV path stays separate (`parse_csv_for_matcher`) because CSV has
+/// columns to map and these formats do not — one entry per line, and a
+/// separator the user chooses rather than one we guess at. Per
+/// `docs/lexicon/08-streaming.md §Track Matcher`.
+#[tauri::command]
+fn parse_tracklist_for_matcher(
+    content: String,
+    separator: Option<track_matcher::tracklist::Separator>,
+) -> Result<Vec<track_matcher::MatchInput>, String> {
+    Ok(track_matcher::tracklist::parse(
+        &content,
+        &separator.unwrap_or_default(),
+    ))
+}
+
+/// Search URLs for entries the library did not have.
+///
+/// The honest half of Lexicon's onward-search and Store Links: constructing the
+/// right search URL per store, per track, so a DJ working through fifty
+/// unmatched request-list entries opens fifty right-first-time searches instead
+/// of typing fifty queries. **Price comparison and playlist push are not built**
+/// — both need a registered application and a per-user token for each service.
+/// See `docs/lexicon/08-streaming.md` and the Epic 7 note in `GAPS.md`.
+#[tauri::command]
+fn store_links_for_tracks(
+    tracks: Vec<MatchInputDto>,
+    stores: Vec<track_matcher::store_links::Store>,
+) -> Vec<track_matcher::store_links::TrackLinks> {
+    let pairs: Vec<(String, Option<String>)> =
+        tracks.into_iter().map(|t| (t.title, t.artist)).collect();
+    track_matcher::store_links::links_for(&pairs, &stores)
+}
+
 #[tauri::command]
 fn parse_csv_headers_for_matcher(content: String) -> Result<Vec<String>, String> {
     track_matcher::csv_input::parse_headers(&content).map_err(|e| e.to_string())
@@ -3181,6 +3216,8 @@ pub fn run() {
             sync_execute_accepted,
             match_tracks,
             parse_csv_for_matcher,
+            parse_tracklist_for_matcher,
+            store_links_for_tracks,
             parse_csv_headers_for_matcher,
             create_playlist_from_tracks,
             stage_track_delete,
diff --git a/apps/desktop/src/components/TrackMatcherView.test.tsx b/apps/desktop/src/components/TrackMatcherView.test.tsx
index b8d435d..a45d274 100644
--- a/apps/desktop/src/components/TrackMatcherView.test.tsx
+++ b/apps/desktop/src/components/TrackMatcherView.test.tsx
@@ -7,6 +7,8 @@ import {
   matchTracks,
   parseCsvForMatcher,
   parseCsvHeadersForMatcher,
+  parseTracklistForMatcher,
+  storeLinksForTracks,
 } from "../ipc";
 import { WithProviders } from "../test-utils/providers";
 
@@ -15,6 +17,8 @@ vi.mock("../ipc", () => ({
   createPlaylistFromTracks: vi.fn(),
   parseCsvForMatcher: vi.fn(),
   parseCsvHeadersForMatcher: vi.fn(),
+  parseTracklistForMatcher: vi.fn(),
+  storeLinksForTracks: vi.fn(),
 }));
 
 beforeEach(() => {
@@ -138,4 +142,185 @@ describe("TrackMatcherView", () => {
       ["t1"],
     );
   });
+
+  it("passes the chosen separator to parseTracklistForMatcher, which is what turns a raw tracklist into query candidates", async () => {
+    vi.mocked(parseTracklistForMatcher).mockResolvedValue([
+      { title: "Title", artist: "Artist" },
+    ]);
+    vi.mocked(matchTracks).mockResolvedValue([
+      {
+        input_title: "Title",
+        input_artist: "Artist",
+        track: { id: "t1", title: "Title", artist: "Artist" },
+        score: 1.0,
+        status: "Exact",
+      },
+    ]);
+    render_();
+    const sourceSelect = screen.getAllByRole("combobox")[0];
+    await userEvent.selectOptions(sourceSelect, "txt");
+    const separatorSelect = screen.getAllByRole("combobox")[1];
+    await userEvent.selectOptions(separatorSelect, "em_dash");
+    await userEvent.type(
+      screen.getByPlaceholderText(/split by the separator above/),
+      "Artist — Title",
+    );
+    await userEvent.click(screen.getByRole("button", { name: "Match" }));
+    expect(parseTracklistForMatcher).toHaveBeenCalledWith(
+      "Artist — Title",
+      "em_dash",
+    );
+  });
+
+  it("sends the typed delimiter as a Custom separator, because free-text splitting must not silently reinterpret it as one of the presets", async () => {
+    vi.mocked(parseTracklistForMatcher).mockResolvedValue([
+      { title: "Title", artist: "Artist" },
+    ]);
+    vi.mocked(matchTracks).mockResolvedValue([
+      {
+        input_title: "Title",
+        input_artist: "Artist",
+        track: { id: "t1", title: "Title", artist: "Artist" },
+        score: 1.0,
+        status: "Exact",
+      },
+    ]);
+    render_();
+    const sourceSelect = screen.getAllByRole("combobox")[0];
+    await userEvent.selectOptions(sourceSelect, "txt");
+    const separatorSelect = screen.getAllByRole("combobox")[1];
+    await userEvent.selectOptions(separatorSelect, "custom");
+    await userEvent.type(
+      screen.getByPlaceholderText(/Custom separator/),
+      "::",
+    );
+    await userEvent.type(
+      screen.getByPlaceholderText(/split by the separator above/),
+      "Artist::Title",
+    );
+    await userEvent.click(screen.getByRole("button", { name: "Match" }));
+    expect(parseTracklistForMatcher).toHaveBeenCalledWith("Artist::Title", {
+      custom: "::",
+    });
+  });
+
+  it("stages a playlist from only the exact and fuzzy hits, keeping unmatched rows out of a playlist that would otherwise misrepresent what was found", async () => {
+    vi.mocked(matchTracks).mockResolvedValue([
+      {
+        input_title: "A",
+        input_artist: null,
+        track: { id: "t1", title: "A", artist: null },
+        score: 1.0,
+        status: "Exact",
+      },
+      {
+        input_title: "B",
+        input_artist: null,
+        track: { id: "t2", title: "B", artist: null },
+        score: 0.8,
+        status: "Fuzzy",
+      },
+      {
+        input_title: "C",
+        input_artist: null,
+        track: null,
+        score: 0,
+        status: "Unmatched",
+      },
+    ]);
+    vi.mocked(createPlaylistFromTracks).mockResolvedValue("pl-new");
+    render_();
+    await userEvent.type(
+      screen.getByPlaceholderText(/Artist - Title/),
+      "A{enter}B{enter}C",
+    );
+    await userEvent.click(screen.getByRole("button", { name: "Match" }));
+    await screen.findByText(/2 \/ 3 tracks matched/);
+    await userEvent.click(
+      screen.getByRole("button", { name: /Create playlist/ }),
+    );
+    await userEvent.click(await screen.findByRole("button", { name: "OK" }));
+    expect(createPlaylistFromTracks).toHaveBeenCalledWith(
+      "/db",
+      "Imported (paste)",
+      ["t1", "t2"],
+    );
+  });
+
+  it("disables Create playlist when nothing matched, so there is nothing for the button to stage", async () => {
+    vi.mocked(matchTracks).mockResolvedValue([
+      {
+        input_title: "Lone Title",
+        input_artist: null,
+        track: null,
+        score: 0,
+        status: "Unmatched",
+      },
+    ]);
+    render_();
+    await userEvent.type(
+      screen.getByPlaceholderText(/Artist - Title/),
+      "Lone Title",
+    );
+    await userEvent.click(screen.getByRole("button", { name: "Match" }));
+    await screen.findByText(/0 \/ 1 tracks matched/);
+    expect(
+      screen.getByRole("button", { name: /Create playlist/ }),
+    ).toBeDisabled();
+  });
+
+  it("opens store search links in a new tab without granting the target page a window.opener reference back into the app", async () => {
+    vi.mocked(matchTracks).mockResolvedValue([
+      {
+        input_title: "Ghost Track",
+        input_artist: "Nobody",
+        track: null,
+        score: 0,
+        status: "Unmatched",
+      },
+    ]);
+    vi.mocked(storeLinksForTracks).mockResolvedValue([
+      {
+        title: "Ghost Track",
+        artist: "Nobody",
+        links: [["Beatport", "https://www.beatport.com/search?q=Ghost+Track"]],
+      },
+    ]);
+    render_();
+    await userEvent.type(
+      screen.getByPlaceholderText(/Artist - Title/),
+      "Nobody - Ghost Track",
+    );
+    await userEvent.click(screen.getByRole("button", { name: "Match" }));
+    await screen.findByText(/0 \/ 1 tracks matched/);
+    await userEvent.click(
+      screen.getByRole("button", { name: "Find store links" }),
+    );
+    const link = await screen.findByRole("link", { name: "Beatport" });
+    expect(link).toHaveAttribute("target", "_blank");
+    expect(link.getAttribute("rel")).toContain("noreferrer");
+    expect(storeLinksForTracks).toHaveBeenCalledWith(
+      [{ title: "Ghost Track", artist: "Nobody" }],
+      expect.arrayContaining(["beatport", "spotify"]),
+    );
+  });
+
+  it("tells the user these are search links only, since decks does not compare prices or push playlists without a registered per-user token", async () => {
+    vi.mocked(matchTracks).mockResolvedValue([
+      {
+        input_title: "Ghost Track",
+        input_artist: null,
+        track: null,
+        score: 0,
+        status: "Unmatched",
+      },
+    ]);
+    render_();
+    await userEvent.type(
+      screen.getByPlaceholderText(/Artist - Title/),
+      "Ghost Track",
+    );
+    await userEvent.click(screen.getByRole("button", { name: "Match" }));
+    expect(await screen.findByText(/Search links only/)).toBeInTheDocument();
+  });
 });
diff --git a/apps/desktop/src/components/TrackMatcherView.tsx b/apps/desktop/src/components/TrackMatcherView.tsx
index 6020457..ce24aad 100644
--- a/apps/desktop/src/components/TrackMatcherView.tsx
+++ b/apps/desktop/src/components/TrackMatcherView.tsx
@@ -4,9 +4,12 @@ import {
   matchTracks,
   parseCsvForMatcher,
   parseCsvHeadersForMatcher,
+  parseTracklistForMatcher,
+  storeLinksForTracks,
   type MatchInput,
   type MatchResult,
 } from "../ipc";
+import type { Separator, Store } from "../types";
 import { useDialog } from "../hooks/useDialog";
 import { readTextFile } from "../lib/read-file";
 import { useToast } from "./Toast";
@@ -18,12 +21,38 @@ interface Props {
 
 type Source = "paste" | "txt" | "csv";
 
+/**
+ * What the separator `<select>` shows vs. what goes over IPC. Kept as its
+ * own union rather than reusing `Separator` directly so "custom" can be a
+ * selectable state before the user has typed anything into the delimiter
+ * box — `Separator`'s `Custom` variant always carries a (possibly empty)
+ * string, which isn't a value this dropdown can represent on its own.
+ */
+type SeparatorKind = "hyphen" | "en_dash" | "em_dash" | "by" | "none" | "custom";
+
+/** Every storefront the backend knows how to build a search link for. There
+ *  is no per-store picker in this cut — Lexicon parity here is "give the user
+ *  somewhere to look", not curation, so asking them to opt stores in first
+ *  would be friction for no benefit. */
+const ALL_STORES: Store[] = [
+  "beatport",
+  "bandcamp",
+  "discogs",
+  "spotify",
+  "tidal",
+  "soundcloud",
+  "youtube",
+];
+
 export function TrackMatcherView({ libraryPath, onGoToSync }: Props) {
   const dialog = useDialog();
   const { toast } = useToast();
 
   const [source, setSource] = useState<Source>("paste");
   const [pasted, setPasted] = useState("");
+  const [txtText, setTxtText] = useState("");
+  const [separatorKind, setSeparatorKind] = useState<SeparatorKind>("hyphen");
+  const [customSeparator, setCustomSeparator] = useState("");
   const [csvText, setCsvText] = useState<string>("");
   const [csvHeaders, setCsvHeaders] = useState<string[]>([]);
   const [csvRowCount, setCsvRowCount] = useState<number>(0);
@@ -31,6 +60,10 @@ export function TrackMatcherView({ libraryPath, onGoToSync }: Props) {
   const [artistCol, setArtistCol] = useState<number>(-1);
   const [results, setResults] = useState<MatchResult[]>([]);
   const [matching, setMatching] = useState(false);
+  const [storeLinks, setStoreLinks] = useState<
+    { title: string; artist: string | null; links: [string, string][] }[]
+  >([]);
+  const [findingLinks, setFindingLinks] = useState(false);
 
   const matched = useMemo(
     () => results.filter((r) => r.track !== null),
@@ -40,6 +73,10 @@ export function TrackMatcherView({ libraryPath, onGoToSync }: Props) {
     () => matched.map((r) => r.track!.id),
     [matched],
   );
+  const unmatched = useMemo(
+    () => results.filter((r) => r.status === "Unmatched"),
+    [results],
+  );
 
   const parsePasted = (): MatchInput[] => {
     return pasted
@@ -56,12 +93,17 @@ export function TrackMatcherView({ libraryPath, onGoToSync }: Props) {
       });
   };
 
+  /** What the separator select actually sends. "custom" is a UI-only state
+   *  until this point — it becomes the `Custom` variant here, carrying
+   *  whatever the user typed (even empty, which the backend can reject on
+   *  its own rather than this component guessing what counts as valid). */
+  const separatorArg = (): Separator =>
+    separatorKind === "custom" ? { custom: customSeparator } : separatorKind;
+
   const onTxtUpload = async (e: React.ChangeEvent<HTMLInputElement>) => {
     const f = e.target.files?.[0];
     if (!f) return;
-    const text = await readTextFile(f);
-    setPasted(text);
-    setSource("paste");
+    setTxtText(await readTextFile(f));
   };
 
   const onCsvUpload = async (e: React.ChangeEvent<HTMLInputElement>) => {
@@ -111,6 +153,12 @@ export function TrackMatcherView({ libraryPath, onGoToSync }: Props) {
           csvHeaders[titleCol]!,
           artistCol >= 0 ? csvHeaders[artistCol] : undefined,
         );
+      } else if (source === "txt") {
+        if (!txtText.trim()) {
+          toast({ variant: "info", message: "Paste or upload a tracklist first." });
+          return;
+        }
+        inputs = await parseTracklistForMatcher(txtText, separatorArg());
       } else {
         inputs = parsePasted();
       }
@@ -120,6 +168,10 @@ export function TrackMatcherView({ libraryPath, onGoToSync }: Props) {
       }
       const res = await matchTracks(libraryPath, inputs);
       setResults(res);
+      // Stale store links point at the previous unmatched list by index —
+      // clearing them here is cheaper than trying to reconcile old links
+      // against a new match run.
+      setStoreLinks([]);
     } catch (e) {
       toast({ variant: "error", message: "Match failed", detail: String(e) });
     } finally {
@@ -133,7 +185,11 @@ export function TrackMatcherView({ libraryPath, onGoToSync }: Props) {
       title: "Playlist name",
       placeholder: "e.g. Spotify – Chill Vibes",
       defaultValue:
-        source === "csv" ? "Imported (CSV)" : "Imported (paste)",
+        source === "csv"
+          ? "Imported (CSV)"
+          : source === "txt"
+            ? "Imported (tracklist)"
+            : "Imported (paste)",
     });
     if (!name) return;
     await createPlaylistFromTracks(libraryPath, name, matchedIds);
@@ -146,11 +202,9 @@ export function TrackMatcherView({ libraryPath, onGoToSync }: Props) {
   };
 
   const doExportUnmatched = () => {
-    const lines = results
-      .filter((r) => r.status === "Unmatched")
-      .map((r) =>
-        r.input_artist ? `${r.input_artist} - ${r.input_title}` : r.input_title,
-      );
+    const lines = unmatched.map((r) =>
+      r.input_artist ? `${r.input_artist} - ${r.input_title}` : r.input_title,
+    );
     if (lines.length === 0) return;
     const blob = new Blob([lines.join("\n")], { type: "text/plain" });
     const url = URL.createObjectURL(blob);
@@ -163,6 +217,34 @@ export function TrackMatcherView({ libraryPath, onGoToSync }: Props) {
     URL.revokeObjectURL(url);
   };
 
+  /**
+   * Look up storefront search links for whatever is still unmatched. Fired
+   * on demand rather than after every match — most matches leave only a
+   * handful of stragglers, and firing seven store lookups per row on every
+   * Match click would be a lot of network noise for links most users won't
+   * click.
+   */
+  const doFindStoreLinks = async () => {
+    if (unmatched.length === 0) return;
+    setFindingLinks(true);
+    try {
+      const tracks = unmatched.map((r) => ({
+        title: r.input_title,
+        artist: r.input_artist,
+      }));
+      const links = await storeLinksForTracks(tracks, ALL_STORES);
+      setStoreLinks(links);
+    } catch (e) {
+      toast({
+        variant: "error",
+        message: "Store search failed",
+        detail: String(e),
+      });
+    } finally {
+      setFindingLinks(false);
+    }
+  };
+
   return (
     <div className="flex h-full flex-col bg-surface p-4 text-sm">
       <div className="mb-4 flex items-center justify-between">
@@ -185,11 +267,11 @@ export function TrackMatcherView({ libraryPath, onGoToSync }: Props) {
           className="rounded border border-edge bg-base px-2 py-1 text-ink"
         >
           <option value="paste">Paste / text</option>
-          <option value="txt">.txt upload</option>
+          <option value="txt">.txt / .m3u8 tracklist</option>
           <option value="csv">.csv upload</option>
         </select>
         {source === "txt" && (
-          <input type="file" accept=".txt" onChange={onTxtUpload} />
+          <input type="file" accept=".txt,.m3u8" onChange={onTxtUpload} />
         )}
         {source === "csv" && (
           <input type="file" accept=".csv" onChange={onCsvUpload} />
@@ -204,7 +286,7 @@ export function TrackMatcherView({ libraryPath, onGoToSync }: Props) {
         </button>
       </div>
 
-      {source !== "csv" && (
+      {source === "paste" && (
         <textarea
           value={pasted}
           onChange={(e) => setPasted(e.target.value)}
@@ -213,6 +295,43 @@ export function TrackMatcherView({ libraryPath, onGoToSync }: Props) {
         />
       )}
 
+      {source === "txt" && (
+        <div className="mb-3 space-y-2">
+          <div className="flex items-center gap-2">
+            <label className="text-xs uppercase tracking-wide text-ink-muted">
+              Separator
+            </label>
+            <select
+              value={separatorKind}
+              onChange={(e) => setSeparatorKind(e.target.value as SeparatorKind)}
+              className="rounded border border-edge bg-base px-2 py-1 text-ink"
+            >
+              <option value="hyphen">{" - "} (default)</option>
+              <option value="en_dash">{" – "} (en dash)</option>
+              <option value="em_dash">{" — "} (em dash)</option>
+              <option value="by">Title by Artist</option>
+              <option value="none">No separator (whole line is a title)</option>
+              <option value="custom">Custom…</option>
+            </select>
+            {separatorKind === "custom" && (
+              <input
+                type="text"
+                value={customSeparator}
+                onChange={(e) => setCustomSeparator(e.target.value)}
+                placeholder="Custom separator, e.g. ::"
+                className="rounded border border-edge bg-base px-2 py-1 text-ink"
+              />
+            )}
+          </div>
+          <textarea
+            value={txtText}
+            onChange={(e) => setTxtText(e.target.value)}
+            placeholder={"One per line, split by the separator above"}
+            className="h-32 w-full rounded border border-edge bg-base p-2 font-mono text-xs text-ink"
+          />
+        </div>
+      )}
+
       {source === "csv" && csvHeaders.length > 0 && (
         <div className="mb-3 flex gap-3 rounded border border-edge bg-base p-3">
           <label className="flex items-center gap-2 text-xs text-ink-muted">
@@ -263,7 +382,7 @@ export function TrackMatcherView({ libraryPath, onGoToSync }: Props) {
           <button
             onClick={doExportUnmatched}
             className="rounded bg-elevated px-2 py-1 text-ink hover:bg-edge"
-            disabled={results.every((r) => r.status !== "Unmatched")}
+            disabled={unmatched.length === 0}
           >
             Export unmatched
           </button>
@@ -314,6 +433,63 @@ export function TrackMatcherView({ libraryPath, onGoToSync }: Props) {
           </table>
         )}
       </div>
+
+      {unmatched.length > 0 && (
+        <div className="mt-3 rounded border border-edge bg-base p-3 text-xs">
+          <div className="mb-2 flex items-center justify-between gap-2">
+            <span className="font-medium text-ink">
+              {unmatched.length} unmatched — search other stores
+            </span>
+            <button
+              onClick={() => void doFindStoreLinks()}
+              disabled={findingLinks}
+              className="rounded bg-elevated px-2 py-1 text-ink hover:bg-edge disabled:opacity-50"
+            >
+              {findingLinks ? "Searching…" : "Find store links"}
+            </button>
+          </div>
+          {/* These are query-string search URLs, not a purchase or
+              playlist-push integration — either would need a registered
+              developer app plus a token scoped to this user, which is a
+              real setup burden this local-first tool has no business
+              asking for just to save someone a manual search. */}
+          <p className="mb-2 text-ink-muted">
+            Search links only — decks does not compare prices or push
+            playlists to a store. Both need a registered developer app and a
+            per-user token, so they open the store's search page for you to
+            take it from there.
+          </p>
+          {storeLinks.length > 0 && (
+            <ul className="space-y-1.5">
+              {unmatched.map((r, idx) => {
+                const entry = storeLinks[idx];
+                return (
+                  <li
+                    key={idx}
+                    className="flex flex-wrap items-center gap-x-2 gap-y-1"
+                  >
+                    <span className="text-ink">
+                      {r.input_artist ? `${r.input_artist} — ` : ""}
+                      {r.input_title}
+                    </span>
+                    {entry?.links.map(([label, url]) => (
+                      <a
+                        key={label}
+                        href={url}
+                        target="_blank"
+                        rel="noreferrer"
+                        className="text-accent underline"
+                      >
+                        {label}
+                      </a>
+                    ))}
+                  </li>
+                );
+              })}
+            </ul>
+          )}
+        </div>
+      )}
     </div>
   );
 }
@@ -323,4 +499,3 @@ function statusIcon(s: "Exact" | "Fuzzy" | "Unmatched") {
   if (s === "Fuzzy") return <span className="text-yellow-500">~</span>;
   return <span className="text-orange-500">—</span>;
 }
-
diff --git a/apps/desktop/src/ipc.ts b/apps/desktop/src/ipc.ts
index 897981c..4be216f 100644
--- a/apps/desktop/src/ipc.ts
+++ b/apps/desktop/src/ipc.ts
@@ -112,6 +112,9 @@ import type {
   EnrichPreview,
   EnrichRequest,
   TrackProposal,
+  Separator,
+  Store,
+  TrackLinks,
 } from "./types";
 import type {
   ChatMessage,
@@ -871,6 +874,34 @@ export async function parseCsvHeadersForMatcher(
   return invoke<string[]>("parse_csv_headers_for_matcher", { content });
 }
 
+/**
+ * Split a pasted or uploaded `.txt`/`.m3u8` tracklist into match candidates.
+ * `separator` is omitted rather than defaulted here so the Rust side's own
+ * default (hyphen) is the single source of truth for what "no separator
+ * chosen" means.
+ */
+export async function parseTracklistForMatcher(
+  content: string,
+  separator?: Separator,
+): Promise<MatchInput[]> {
+  return invoke<MatchInput[]>("parse_tracklist_for_matcher", {
+    content,
+    separator: separator ?? null,
+  });
+}
+
+/**
+ * Search-link URLs per store for a set of tracks — not a purchase or
+ * playlist-push integration, both of which need a registered app and a
+ * per-user token this local-first tool doesn't hold.
+ */
+export async function storeLinksForTracks(
+  tracks: { title: string; artist?: string | null }[],
+  stores: Store[],
+): Promise<TrackLinks[]> {
+  return invoke<TrackLinks[]>("store_links_for_tracks", { tracks, stores });
+}
+
 export async function createPlaylistFromTracks(
   libraryPath: string,
   name: string,
diff --git a/apps/desktop/src/types.ts b/apps/desktop/src/types.ts
index d551912..a29c087 100644
--- a/apps/desktop/src/types.ts
+++ b/apps/desktop/src/types.ts
@@ -1425,3 +1425,40 @@ export interface EnrichPreview {
   /** Provider failures, verbatim — one source being down is not "no match". */
   errors: string[];
 }
+
+// ── Track Matcher: tracklist parsing & onward search ────────────────────────
+
+/**
+ * Mirrors the Rust `Separator` enum. Serde's default for a unit variant is
+ * its bare snake_case name, but `Custom` carries a string, so it serialises
+ * as `{ custom: "..." }` instead — the two shapes can't be unified into one
+ * string type without lying to the backend about what it accepts.
+ */
+export type Separator =
+  | "hyphen"
+  | "en_dash"
+  | "em_dash"
+  | "by"
+  | "none"
+  | { custom: string };
+
+/** Storefronts the onward-search links can be built for. */
+export type Store =
+  | "beatport"
+  | "bandcamp"
+  | "discogs"
+  | "spotify"
+  | "tidal"
+  | "soundcloud"
+  | "youtube";
+
+/**
+ * Mirrors `track_matcher::TrackLinks`. `links` is a label/URL pair rather
+ * than a `Store`-keyed map because the backend already chose display labels
+ * (e.g. capitalisation) and there's nothing to gain by re-deriving them here.
+ */
+export interface TrackLinks {
+  title: string;
+  artist: string | null;
+  links: [string, string][];
+}
diff --git a/crates/track-matcher/src/lib.rs b/crates/track-matcher/src/lib.rs
index 9cfc324..8600e2f 100644
--- a/crates/track-matcher/src/lib.rs
+++ b/crates/track-matcher/src/lib.rs
@@ -5,6 +5,8 @@ use serde::Serialize;
 pub mod csv_import;
 pub mod csv_input;
 pub mod normalise;
+pub mod store_links;
+pub mod tracklist;
 
 #[derive(Debug, Clone)]
 pub struct MatchCandidate {
diff --git a/crates/track-matcher/src/store_links.rs b/crates/track-matcher/src/store_links.rs
new file mode 100644
index 0000000..0dea47f
--- /dev/null
+++ b/crates/track-matcher/src/store_links.rs
@@ -0,0 +1,257 @@
+//! Where to go and buy the ones you haven't got.
+//!
+//! Covers two Lexicon features as far as they can honestly be covered without
+//! credentials:
+//!
+//! - **Track Matcher → onward search** (`08-streaming.md §Track Matcher`):
+//!   "Unmatched entries can be sent onward to Spotify, Tidal or Beatport to
+//!   hunt down."
+//! - **Store Links** (`§Store Links`): "automates the tedious per-track search
+//!   across online stores".
+//!
+//! ## What this is not
+//!
+//! Lexicon's Store Links also does **price comparison**, and its Send To pushes
+//! a matched playlist into the service. Both need authenticated APIs — a
+//! registered application and a user token per service — and neither is built.
+//! What is built is the tedious part: constructing the correct search URL for
+//! each store, per track, so a DJ working through fifty unmatched request-list
+//! entries opens fifty right-first-time searches instead of typing fifty
+//! queries.
+//!
+//! That boundary is deliberate and worth stating plainly rather than shipping a
+//! half-authenticated client that fails at the first request. A search URL is
+//! **honest**: it makes no claim the track exists, no claim about price, and it
+//! cannot be wrong in a way that costs the user anything.
+
+use serde::{Deserialize, Serialize};
+
+/// A store or service an unmatched entry can be sent onward to.
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
+#[serde(rename_all = "snake_case")]
+pub enum Store {
+    Beatport,
+    Bandcamp,
+    Discogs,
+    Spotify,
+    Tidal,
+    SoundCloud,
+    /// Not a store, but the fastest way to identify a half-remembered request
+    /// before buying it anywhere.
+    YouTube,
+}
+
+impl Store {
+    pub fn label(&self) -> &'static str {
+        match self {
+            Store::Beatport => "Beatport",
+            Store::Bandcamp => "Bandcamp",
+            Store::Discogs => "Discogs",
+            Store::Spotify => "Spotify",
+            Store::Tidal => "Tidal",
+            Store::SoundCloud => "SoundCloud",
+            Store::YouTube => "YouTube",
+        }
+    }
+
+    /// The three the spec names for Track Matcher's onward search, plus the
+    /// stores a DJ actually buys from.
+    pub fn all() -> &'static [Store] {
+        &[
+            Store::Beatport,
+            Store::Bandcamp,
+            Store::Discogs,
+            Store::Spotify,
+            Store::Tidal,
+            Store::SoundCloud,
+            Store::YouTube,
+        ]
+    }
+}
+
+/// Percent-encode a query value.
+///
+/// Space becomes `%20` rather than `+`: `+` is only valid in
+/// `application/x-www-form-urlencoded`, and several of these stores put the
+/// query in a path segment where a literal `+` stays a plus sign and breaks the
+/// search.
+fn encode(s: &str) -> String {
+    let mut out = String::with_capacity(s.len() * 2);
+    for b in s.as_bytes() {
+        match b {
+            b'A'..=b'Z' | b'a'..=b'z' | b'0'..=b'9' | b'-' | b'_' | b'.' | b'~' => {
+                out.push(*b as char)
+            }
+            _ => out.push_str(&format!("%{b:02X}")),
+        }
+    }
+    out
+}
+
+/// The search text for a track: `Artist Title`, or just the title.
+///
+/// Plain words rather than a fielded query. Every one of these stores takes a
+/// free-text search, and the fielded syntaxes differ per store and change
+/// without notice — a query that silently stops matching is worse than one that
+/// is merely broad.
+pub fn search_terms(title: &str, artist: Option<&str>) -> String {
+    let title = title.trim();
+    match artist.map(str::trim).filter(|a| !a.is_empty()) {
+        Some(a) => format!("{a} {title}"),
+        None => title.to_string(),
+    }
+}
+
+/// A search URL for one track at one store.
+///
+/// Returns `None` for an empty title: a search URL with no query opens the
+/// store's front page, which looks like the feature working and is not.
+pub fn url(store: Store, title: &str, artist: Option<&str>) -> Option<String> {
+    let terms = search_terms(title, artist);
+    if terms.trim().is_empty() {
+        return None;
+    }
+    let q = encode(&terms);
+    Some(match store {
+        Store::Beatport => format!("https://www.beatport.com/search?q={q}"),
+        Store::Bandcamp => format!("https://bandcamp.com/search?q={q}"),
+        Store::Discogs => format!("https://www.discogs.com/search/?q={q}&type=release"),
+        Store::Spotify => format!("https://open.spotify.com/search/{q}"),
+        Store::Tidal => format!("https://listen.tidal.com/search?q={q}"),
+        Store::SoundCloud => format!("https://soundcloud.com/search?q={q}"),
+        Store::YouTube => format!("https://www.youtube.com/results?search_query={q}"),
+    })
+}
+
+/// One track's links across a set of stores.
+#[derive(Debug, Clone, PartialEq, Serialize)]
+pub struct TrackLinks {
+    pub title: String,
+    pub artist: Option<String>,
+    /// `(store label, url)`, in the order the stores were requested.
+    pub links: Vec<(String, String)>,
+}
+
+/// Build links for a list of tracks across a list of stores.
+pub fn links_for(tracks: &[(String, Option<String>)], stores: &[Store]) -> Vec<TrackLinks> {
+    tracks
+        .iter()
+        .map(|(title, artist)| TrackLinks {
+            title: title.clone(),
+            artist: artist.clone(),
+            links: stores
+                .iter()
+                .filter_map(|s| {
+                    url(*s, title, artist.as_deref()).map(|u| (s.label().to_string(), u))
+                })
+                .collect(),
+        })
+        .collect()
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn the_terms_are_artist_then_title() {
+        assert_eq!(
+            search_terms("Around the World", Some("Daft Punk")),
+            "Daft Punk Around the World"
+        );
+    }
+
+    #[test]
+    fn a_missing_artist_searches_the_title_alone() {
+        assert_eq!(search_terms("Windowlicker", None), "Windowlicker");
+        assert_eq!(search_terms("Windowlicker", Some("  ")), "Windowlicker");
+    }
+
+    #[test]
+    fn a_space_encodes_as_percent_20_not_plus() {
+        // Several of these put the query in a path segment, where a literal `+`
+        // stays a plus sign and breaks the search.
+        let u = url(Store::Spotify, "Around the World", Some("Daft Punk")).unwrap();
+        assert!(u.contains("%20"), "{u}");
+        assert!(!u.contains('+'), "{u}");
+    }
+
+    #[test]
+    fn special_characters_do_not_escape_the_query() {
+        // A title with `&` or `#` would otherwise truncate the URL or add a
+        // parameter the store never sees as part of the search.
+        let u = url(Store::Beatport, "Sex & Drugs #1", Some("A/B")).unwrap();
+        assert!(u.contains("%26"), "{u}");
+        assert!(u.contains("%23"), "{u}");
+        assert!(u.contains("%2F"), "{u}");
+        assert_eq!(u.matches('?').count(), 1, "{u}");
+    }
+
+    #[test]
+    fn every_store_produces_a_distinct_https_url() {
+        for s in Store::all() {
+            let u = url(*s, "Track", Some("Artist")).unwrap();
+            assert!(u.starts_with("https://"), "{s:?} -> {u}");
+        }
+        let all: Vec<String> = Store::all()
+            .iter()
+            .map(|s| url(*s, "T", Some("A")).unwrap())
+            .collect();
+        let mut deduped = all.clone();
+        deduped.sort();
+        deduped.dedup();
+        assert_eq!(deduped.len(), all.len(), "two stores share a URL");
+    }
+
+    #[test]
+    fn the_three_stores_the_spec_names_are_all_present() {
+        // "Unmatched entries can be sent onward to Spotify, Tidal or Beatport."
+        for s in [Store::Spotify, Store::Tidal, Store::Beatport] {
+            assert!(Store::all().contains(&s), "{s:?} missing");
+        }
+    }
+
+    #[test]
+    fn an_empty_title_yields_no_link_rather_than_a_front_page() {
+        // A query-less search URL opens the store's home page, which looks like
+        // the feature working and is not.
+        assert_eq!(url(Store::Beatport, "", None), None);
+        assert_eq!(url(Store::Beatport, "   ", Some("  ")), None);
+    }
+
+    #[test]
+    fn links_are_built_in_the_order_the_stores_were_asked_for() {
+        let tracks = vec![("T".to_string(), Some("A".to_string()))];
+        let got = links_for(&tracks, &[Store::Tidal, Store::Beatport]);
+        assert_eq!(got.len(), 1);
+        assert_eq!(
+            got[0]
+                .links
+                .iter()
+                .map(|(l, _)| l.as_str())
+                .collect::<Vec<_>>(),
+            vec!["Tidal", "Beatport"]
+        );
+    }
+
+    #[test]
+    fn a_track_with_no_usable_title_gets_an_empty_link_list_not_a_broken_one() {
+        let tracks = vec![("".to_string(), None)];
+        let got = links_for(&tracks, Store::all());
+        assert_eq!(got.len(), 1);
+        assert!(got[0].links.is_empty());
+    }
+
+    #[test]
+    fn no_store_url_carries_a_credential_or_an_api_host() {
+        // These are plain public search pages by design. An api. host here
+        // would mean somebody had started down the authenticated path without
+        // the token plumbing that requires.
+        for s in Store::all() {
+            let u = url(*s, "T", Some("A")).unwrap();
+            assert!(!u.contains("api."), "{s:?} -> {u}");
+            assert!(!u.contains("token"), "{s:?} -> {u}");
+            assert!(!u.contains("key="), "{s:?} -> {u}");
+        }
+    }
+}
diff --git a/crates/track-matcher/src/tracklist.rs b/crates/track-matcher/src/tracklist.rs
new file mode 100644
index 0000000..3f9ab26
--- /dev/null
+++ b/crates/track-matcher/src/tracklist.rs
@@ -0,0 +1,413 @@
+//! Reading a pasted or uploaded tracklist.
+//!
+//! Per `docs/lexicon/08-streaming.md §Track Matcher`: "Paste or upload a
+//! tracklist (`.txt` / `.m3u8`, one entry per line, selectable separator such
+//! as ` - `)". Aimed at wedding and event DJs working from a request list,
+//! which is why the input is whatever the client actually sent — a pasted
+//! email, an exported playlist, a numbered setlist off a forum.
+//!
+//! CSV already has its own path (`csv_input`, with a column-mapping UI). This
+//! module covers the two formats that have no columns to map: plain lines, and
+//! `.m3u8`.
+
+use serde::{Deserialize, Serialize};
+
+use crate::MatchInput;
+
+/// How a line separates artist from title.
+///
+/// The spec calls the separator *selectable* rather than guessed, and the
+/// reason shows up immediately in real lists: ` - ` is the common case, but a
+/// list written as `Artist – Title` (en dash) or `Title by Artist` is not
+/// unusual, and silently mis-splitting produces confident wrong matches rather
+/// than obvious failures.
+#[derive(Debug, Clone, Default, PartialEq, Eq, Serialize, Deserialize)]
+#[serde(rename_all = "snake_case")]
+pub enum Separator {
+    /// ` - `, the default.
+    #[default]
+    Hyphen,
+    /// ` – ` (en dash), which is what a copy-paste from a web page usually
+    /// carries.
+    EnDash,
+    /// ` — ` (em dash).
+    EmDash,
+    /// `Title by Artist` — reversed, and the one case where the order flips.
+    By,
+    /// Anything else the user types.
+    Custom(String),
+    /// No separator: the whole line is a title. The right answer for a list of
+    /// titles with no artists, where splitting on a hyphen inside a title
+    /// ("Re-Wired") would invent an artist.
+    None,
+}
+
+impl Separator {
+    /// The literal text to split on, and whether the artist comes second.
+    fn parts(&self) -> Option<(&str, bool)> {
+        match self {
+            Separator::Hyphen => Some((" - ", false)),
+            Separator::EnDash => Some((" – ", false)),
+            Separator::EmDash => Some((" — ", false)),
+            Separator::By => Some((" by ", true)),
+            Separator::Custom(s) if !s.is_empty() => Some((s.as_str(), false)),
+            Separator::Custom(_) | Separator::None => None,
+        }
+    }
+}
+
+/// Strip a leading list index: `1.`, `01)`, `3:`, `#3`.
+///
+/// Setlists arrive numbered far more often than not, and a leading `1.` makes
+/// the artist `1. Daft Punk`, which normalisation does not remove and which
+/// pushes a genuine match below the fuzzy threshold.
+///
+/// **A digit alone is never an index.** `99 Problems` and `1979` are titles,
+/// so the number has to be followed by punctuation — or introduced by `#`,
+/// which says "index" on its own and is the only form where a bare space is
+/// enough of a delimiter.
+fn strip_index(line: &str) -> &str {
+    let t = line.trim_start();
+    let hashed = t.starts_with('#');
+    let t = t.strip_prefix('#').unwrap_or(t);
+    let digits = t.chars().take_while(|c| c.is_ascii_digit()).count();
+    // More than three digits is a year or a title, not a position in a list.
+    if digits == 0 || digits > 3 {
+        return line.trim();
+    }
+    let rest = &t[digits..];
+    let stripped = rest
+        .strip_prefix('.')
+        .or_else(|| rest.strip_prefix(')'))
+        .or_else(|| rest.strip_prefix(':'))
+        // `#3 Artist - Title`: the hash already marked this as an index, so a
+        // space is delimiter enough. Without the hash it is not — that is what
+        // keeps "99 Problems" whole.
+        .or_else(|| (hashed && rest.starts_with(' ')).then_some(rest));
+    match stripped {
+        Some(r) if !r.trim().is_empty() => r.trim(),
+        _ => line.trim(),
+    }
+}
+
+/// Should this line be read as a track at all?
+///
+/// `.m3u8` is a superset of plain text: it is line-oriented with `#`-prefixed
+/// directives, so one reader handles both. `#EXTINF:` is the only directive
+/// carrying a title, and it is handled before this is called.
+///
+/// **`#` is ambiguous between the two formats** — it opens a directive in an
+/// `.m3u8` and a list index in a hand-written setlist (`#3 Daft Punk - ...`).
+/// What follows it settles the question: directives are always `#` plus
+/// letters, indices are always `#` plus a digit. Treating every `#` line as a
+/// directive silently swallowed hash-numbered entries.
+fn is_noise(line: &str) -> bool {
+    let t = line.trim();
+    if t.is_empty() {
+        return true;
+    }
+    match t.strip_prefix('#') {
+        // `#3` is an index, not a directive.
+        Some(rest) => !rest.starts_with(|c: char| c.is_ascii_digit()),
+        None => false,
+    }
+}
+
+/// The `Artist - Title` text out of an `#EXTINF` line.
+///
+/// The format is `#EXTINF:<seconds>,<title>` — everything after the *first*
+/// comma, because titles contain commas and the duration never does.
+fn extinf_title(line: &str) -> Option<&str> {
+    let rest = line.trim().strip_prefix("#EXTINF:")?;
+    let (_, title) = rest.split_once(',')?;
+    let title = title.trim();
+    (!title.is_empty()).then_some(title)
+}
+
+/// Parse a pasted or uploaded tracklist into match inputs.
+///
+/// Handles plain `.txt` and `.m3u8` with one reader, because an `.m3u8` is a
+/// text file whose non-track lines start with `#`. For `.m3u8` the `#EXTINF`
+/// title is preferred over the URL line beneath it: the URL is a file path,
+/// and matching a library by path is what the Relocate flow is for.
+pub fn parse(input: &str, separator: &Separator) -> Vec<MatchInput> {
+    let mut out = Vec::new();
+    let mut pending_extinf: Option<String> = None;
+
+    for line in input.lines() {
+        if let Some(t) = extinf_title(line) {
+            pending_extinf = Some(t.to_string());
+            continue;
+        }
+        if is_noise(line) {
+            continue;
+        }
+        // An `#EXTINF` names the track; the line beneath it is the location and
+        // is skipped, since it carries no better information than the title we
+        // already have.
+        let text = match pending_extinf.take() {
+            Some(t) => t,
+            None => line.to_string(),
+        };
+        if let Some(mi) = line_to_input(&text, separator) {
+            out.push(mi);
+        }
+    }
+
+    // A trailing `#EXTINF` with no location line beneath it still names a
+    // track, and dropping it would silently lose the last entry of a truncated
+    // file.
+    if let Some(t) = pending_extinf {
+        if let Some(mi) = line_to_input(&t, separator) {
+            out.push(mi);
+        }
+    }
+    out
+}
+
+fn line_to_input(text: &str, separator: &Separator) -> Option<MatchInput> {
+    let text = strip_index(text);
+    if text.is_empty() {
+        return None;
+    }
+    let Some((sep, reversed)) = separator.parts() else {
+        return Some(MatchInput {
+            title: text.to_string(),
+            artist: None,
+        });
+    };
+
+    // Only the first occurrence splits. A later one usually separates the title
+    // from a version suffix ("A - B (C - D Remix)"), and splitting there would
+    // put half the title in the artist field.
+    match text.split_once(sep) {
+        Some((a, b)) if !a.trim().is_empty() && !b.trim().is_empty() => {
+            let (artist, title) = if reversed { (b, a) } else { (a, b) };
+            Some(MatchInput {
+                title: title.trim().to_string(),
+                artist: Some(artist.trim().to_string()),
+            })
+        }
+        // The separator was not found, or one side was empty. Treating the
+        // whole line as a title beats inventing an empty artist — the matcher
+        // handles a title-only input, and a blank artist would drag the score
+        // down on every candidate.
+        _ => Some(MatchInput {
+            title: text.to_string(),
+            artist: None,
+        }),
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    fn titles(v: &[MatchInput]) -> Vec<(&str, Option<&str>)> {
+        v.iter()
+            .map(|m| (m.title.as_str(), m.artist.as_deref()))
+            .collect()
+    }
+
+    #[test]
+    fn a_plain_list_splits_on_the_default_separator() {
+        let got = parse(
+            "Daft Punk - Around the World\nAphex Twin - Windowlicker",
+            &Separator::Hyphen,
+        );
+        assert_eq!(
+            titles(&got),
+            vec![
+                ("Around the World", Some("Daft Punk")),
+                ("Windowlicker", Some("Aphex Twin")),
+            ]
+        );
+    }
+
+    #[test]
+    fn blank_lines_are_skipped() {
+        let got = parse("A - B\n\n\n C - D \n", &Separator::Hyphen);
+        assert_eq!(got.len(), 2);
+    }
+
+    #[test]
+    fn a_numbered_setlist_does_not_put_the_number_in_the_artist() {
+        // Request lists arrive numbered far more often than not, and "1. Daft
+        // Punk" is not an artist normalisation will fix.
+        let got = parse(
+            "1. Daft Punk - Around the World\n02) A - B\n#3 C - D",
+            &Separator::Hyphen,
+        );
+        assert_eq!(
+            titles(&got),
+            vec![
+                ("Around the World", Some("Daft Punk")),
+                ("B", Some("A")),
+                ("D", Some("C")),
+            ]
+        );
+    }
+
+    #[test]
+    fn a_title_that_begins_with_a_number_keeps_it() {
+        // "1979" and "99 Problems" are titles, not list indices.
+        let got = parse("The Smashing Pumpkins - 1979", &Separator::Hyphen);
+        assert_eq!(titles(&got), vec![("1979", Some("The Smashing Pumpkins"))]);
+        let got = parse("1979", &Separator::None);
+        assert_eq!(titles(&got), vec![("1979", None)]);
+    }
+
+    #[test]
+    fn a_bare_number_never_counts_as_an_index() {
+        // "99 Problems" is a title. Only punctuation after the digits, or a
+        // leading `#`, makes a number a list position.
+        let got = parse("Jay-Z - 99 Problems", &Separator::Hyphen);
+        assert_eq!(titles(&got), vec![("99 Problems", Some("Jay-Z"))]);
+        let got = parse("99 Problems", &Separator::None);
+        assert_eq!(titles(&got), vec![("99 Problems", None)]);
+    }
+
+    #[test]
+    fn a_four_digit_index_is_not_an_index() {
+        // Guards the strip against eating a year-like title.
+        let got = parse("2001. A Space Odyssey", &Separator::None);
+        assert_eq!(titles(&got), vec![("2001. A Space Odyssey", None)]);
+    }
+
+    #[test]
+    fn only_the_first_separator_splits() {
+        // A later one usually separates title from version, and splitting there
+        // would put half the title in the artist field.
+        let got = parse("A - B - C Remix", &Separator::Hyphen);
+        assert_eq!(titles(&got), vec![("B - C Remix", Some("A"))]);
+    }
+
+    #[test]
+    fn an_en_dash_list_needs_the_en_dash_separator() {
+        // What a copy-paste off a web page usually carries. With the default
+        // separator the line has no split, and falls back to a title.
+        let line = "Daft Punk – Around the World";
+        assert_eq!(titles(&parse(line, &Separator::Hyphen)), vec![(line, None)]);
+        assert_eq!(
+            titles(&parse(line, &Separator::EnDash)),
+            vec![("Around the World", Some("Daft Punk"))]
+        );
+    }
+
+    #[test]
+    fn the_by_separator_reverses_the_order() {
+        // "Title by Artist" is the one form where the sides swap.
+        let got = parse("Around the World by Daft Punk", &Separator::By);
+        assert_eq!(titles(&got), vec![("Around the World", Some("Daft Punk"))]);
+    }
+
+    #[test]
+    fn a_custom_separator_is_honoured() {
+        let got = parse(
+            "Daft Punk :: Around the World",
+            &Separator::Custom(" :: ".into()),
+        );
+        assert_eq!(titles(&got), vec![("Around the World", Some("Daft Punk"))]);
+    }
+
+    #[test]
+    fn an_empty_custom_separator_behaves_as_none_rather_than_splitting_everywhere() {
+        let got = parse("A - B", &Separator::Custom(String::new()));
+        assert_eq!(titles(&got), vec![("A - B", None)]);
+    }
+
+    #[test]
+    fn the_none_separator_keeps_hyphenated_titles_whole() {
+        // A list of titles with no artists: splitting "Re-Wired" would invent
+        // an artist and lose the match.
+        let got = parse("Re-Wired\nWindowlicker", &Separator::None);
+        assert_eq!(
+            titles(&got),
+            vec![("Re-Wired", None), ("Windowlicker", None)]
+        );
+    }
+
+    #[test]
+    fn a_line_with_an_empty_side_is_read_as_a_title() {
+        // An empty artist would drag the score down against every candidate.
+        let got = parse(" - Around the World", &Separator::Hyphen);
+        assert_eq!(titles(&got), vec![("- Around the World", None)]);
+    }
+
+    #[test]
+    fn an_m3u8_uses_its_extinf_titles_and_ignores_the_paths() {
+        // The path is a location; matching a library by path is what Relocate
+        // is for. The title is the information worth matching on.
+        let m3u = "#EXTM3U\n\
+                   #EXTINF:222,Daft Punk - Around the World\n\
+                   /Users/dj/Music/track1.mp3\n\
+                   #EXTINF:333,Aphex Twin - Windowlicker\n\
+                   D:\\Music\\track2.mp3\n";
+        assert_eq!(
+            titles(&parse(m3u, &Separator::Hyphen)),
+            vec![
+                ("Around the World", Some("Daft Punk")),
+                ("Windowlicker", Some("Aphex Twin")),
+            ]
+        );
+    }
+
+    #[test]
+    fn an_extinf_title_containing_a_comma_survives() {
+        // Split on the *first* comma only — the duration never contains one,
+        // and titles frequently do.
+        let m3u = "#EXTINF:222,Tyler, The Creator - Earfquake\n/m/a.mp3";
+        assert_eq!(
+            titles(&parse(m3u, &Separator::Hyphen)),
+            vec![("Earfquake", Some("Tyler, The Creator"))]
+        );
+    }
+
+    #[test]
+    fn a_truncated_m3u8_does_not_lose_its_last_entry() {
+        let m3u = "#EXTM3U\n#EXTINF:222,A - B\n/m/a.mp3\n#EXTINF:333,C - D";
+        assert_eq!(titles(&parse(m3u, &Separator::Hyphen)).len(), 2);
+    }
+
+    #[test]
+    fn an_m3u_with_no_extinf_lines_falls_back_to_its_paths() {
+        // A bare `.m3u` is just a list of locations. Reading them as text is
+        // better than reading nothing, and the matcher normalises filenames
+        // reasonably well.
+        let m3u = "#EXTM3U\nDaft Punk - Around the World.mp3";
+        assert_eq!(
+            titles(&parse(m3u, &Separator::Hyphen)),
+            vec![("Around the World.mp3", Some("Daft Punk"))]
+        );
+    }
+
+    #[test]
+    fn a_hash_numbered_entry_is_an_index_not_a_directive() {
+        // `#` opens a directive in an .m3u8 and a list index in a hand-written
+        // setlist. What follows it settles which: letters mean directive,
+        // digits mean index. Treating every `#` line as a directive silently
+        // swallowed these.
+        let got = parse("#EXTM3U\n#3 C - D\n# a comment", &Separator::Hyphen);
+        assert_eq!(titles(&got), vec![("D", Some("C"))]);
+    }
+
+    #[test]
+    fn directive_lines_never_become_tracks() {
+        let m3u = "#EXTM3U\n#PLAYLIST:My Set\n#EXTVLCOPT:whatever\nA - B";
+        assert_eq!(
+            titles(&parse(m3u, &Separator::Hyphen)),
+            vec![("B", Some("A"))]
+        );
+    }
+
+    #[test]
+    fn an_empty_input_yields_nothing_rather_than_one_blank_entry() {
+        assert!(parse("", &Separator::Hyphen).is_empty());
+        assert!(parse("\n\n  \n", &Separator::Hyphen).is_empty());
+    }
+
+    #[test]
+    fn the_default_separator_is_the_one_the_spec_names() {
+        assert_eq!(Separator::default(), Separator::Hyphen);
+    }
+}
diff --git a/docs/JOURNAL.md b/docs/JOURNAL.md
index 22a27a0..4d3797a 100644
--- a/docs/JOURNAL.md
+++ b/docs/JOURNAL.md
@@ -3105,3 +3105,57 @@ with the reason.
 
 ### Parity
 61 done / 21 partial / 12 missing / 2 blocked / 16 deferred. Epic 7 streaming next.
+
+## Session — 2026-08-08 — Epic 7: scoping, then the credential-free half
+
+### Plan
+"Integrate all the ones you can." Scope first, build second — the risk with an instruction like
+that is promising seven rows and delivering four half-authenticated clients nobody can turn on.
+
+### The scoping, which was the real work
+Three buckets, not two:
+
+1. **Needs nothing** — Track Matcher's `.m3u8` / separator / playlist-creation gaps, and onward
+   search + Store Links *as generated search URLs*. Built.
+2. **Needs a registered app + per-user token** — Beatport catalog/cart/purchase, Charts, Send To,
+   SoundCloud playback, Track Discovery, price comparison. Not built; it is an account action with
+   terms attached and belongs to the owner.
+3. **Needs a verified place to put a streaming reference** — streaming tracks, Transfer Streaming
+   To Local. This is the one worth flagging: it needs *no API*, the spec's own claim is that the
+   reference survives even when the audio can't be played, and it is still unbuildable here because
+   `master.db` models no streaming columns in the synthetic schema and no real one is available.
+   Storing it in the cache would make it decks-only and defeat the point.
+
+### Decisions
+- **A search URL is the honest form of Store Links.** It claims nothing about existence or price
+  and cannot be wrong in a way that costs the user anything. Half-authenticating a store client
+  would fail at the first request and look like a bug rather than a boundary.
+- **`%20`, not `+`.** Several of these stores put the query in a path segment where a literal `+`
+  stays a plus sign and breaks the search.
+- **One reader for `.txt` and `.m3u8`**, since an `.m3u8` is a text file whose non-track lines
+  start with `#`. `#EXTINF` titles beat the path lines beneath them.
+- **Separator selectable, not guessed** — the spec says so, and mis-splitting produces confident
+  wrong matches rather than obvious failures.
+
+### Two bugs my own tests found
+`#3 C - D` was swallowed: I had `is_noise` treat every `#` line as an m3u8 directive, which is true
+for `.m3u8` and false for a hand-written setlist. Resolved on what follows the `#` — letters mean
+directive, digits mean index.
+
+Fixing that then broke `99 Problems`, because allowing a bare space after digits made the number an
+index. Resolved by letting only the `#` license a space delimiter; without it, punctuation is
+required. Both cases now have regression tests naming the tension.
+
+### The process fix
+`rust-toolchain.toml` pins `stable` = 1.97.1 on CI; this container had 1.94.1. Every local "clippy
+clean" this session was a weaker claim than the gate, and #45 failed on both platforms for a lint I
+could not see. Installed current stable; the definition of done now runs against it. Carrying two
+toolchains filled the disk — `cargo clean` plus removing the old one freed 31 GB.
+
+### Verification
+`cargo +stable fmt --check`, `cargo +stable test --workspace`, `cargo +stable clippy --workspace
+--all-targets -D warnings` (clean incl. `decks-desktop`), `pnpm test` (837), `pnpm typecheck`,
+`pnpm lint`, `pnpm e2e` (59).
+
+### Parity
+62 done / 21 partial / 11 missing / 2 blocked / 16 deferred.
diff --git a/docs/STATUS.md b/docs/STATUS.md
index e903179..1af5aec 100644
--- a/docs/STATUS.md
+++ b/docs/STATUS.md
@@ -1,5 +1,60 @@
 # Status
 
+## 2026-08-08 — Epic 7, scoped honestly: Track Matcher done, store links built, the rest named
+
+The instruction was "integrate all the ones you can". The useful part of this session was working
+out what **can** actually means, and writing the boundary down so it can be argued with rather than
+merely asserted. `GAPS.md` §Epic 7 has the full table.
+
+**Built, because it needs no account:**
+
+Track Matcher is now **done**. `.txt` and `.m3u8` read by one reader — an `.m3u8` is a text file
+whose non-track lines start with `#` — preferring `#EXTINF` titles over the paths beneath them,
+because a path is a location and matching a library by path is what Relocate is for. The separator
+is *selectable* as the manual specifies rather than guessed: hyphen, en dash, em dash,
+`Title by Artist` (the one form where the sides swap), none, or custom. Matches become a playlist
+through the `create_playlist_from_tracks` that already existed.
+
+Two things real request lists forced, neither in the manual. **Numbered indices are stripped** —
+`1. Daft Punk - ...` otherwise makes the artist `1. Daft Punk`, which normalisation does not remove
+and which pushes a genuine match under the fuzzy threshold. But a digit alone is never an index:
+`99 Problems` and `1979` are titles, so the number must be followed by punctuation or introduced by
+`#`. And **`#` is ambiguous** between the two formats — a directive in `.m3u8`, a list index in a
+hand-written setlist. Letters after it mean directive, digits mean index.
+
+Both of those came out of tests failing, not out of foresight. The first version swallowed every
+`#`-prefixed line as a directive and lost `#3 C - D` entirely; the fix for that then ate the number
+in `99 Problems` until the hash was made to license the bare-space delimiter.
+
+**Store Links and onward search are built as generated search URLs.** Constructing the right search
+URL per store per track is the tedious part of both features, across Beatport, Bandcamp, Discogs,
+Spotify, Tidal, SoundCloud and YouTube. A search link is *honest*: it claims nothing about whether
+the track exists or what it costs, and cannot be wrong in a way that costs the user anything. The
+UI says plainly that this is search-only, rather than implying a comparison that is not happening.
+
+**Not built, and the two reasons are different.**
+
+Beatport catalog / cart / purchase-replacement, Charts, Send To, SoundCloud playback and Track
+Discovery all need **a registered application and a per-user token per service**. That is an
+account action with terms attached, so it is the owner's to take. Once an app exists the client work
+is small — the keychain plumbing already exists (ADR-0016).
+
+Streaming tracks and Transfer Streaming To Local are blocked on something else: **there is nowhere
+verified to store a streaming reference.** The spec's most valuable claim here needs no API at all —
+"conversion is supported for all sources, even those that can't be played", the reference surviving
+when the audio doesn't. It is unbuilt because `decks` is Rekordbox-first and read-only on
+`master.db`, the synthetic schema models no streaming columns, and no real `master.db` is available
+here. Putting the reference in the local cache would make it decks-only, which defeats the one
+guarantee the feature exists to give. `GAPS.md` carries the one `sqlite3` command that settles it.
+
+**A process fix that matters more than any of the above.** `rust-toolchain.toml` pins `stable`,
+which is 1.97.1 on CI, while this container's image shipped 1.94.1 — so every "clippy is clean" this
+session had been checked against an older lint set than the gate, and #45 failed on both platforms
+for a lint I could not see. Installed the current stable and now run the whole definition of done
+against it. Two lints since: `while_let_loop` and a derivable `Default`.
+
+Parity: **62 done / 21 partial / 11 missing / 2 blocked / 16 deferred.**
+
 ## 2026-08-08 — Enrichment: MusicBrainz by default, Discogs opt-in
 
 `crates/enrichment` was a ten-line placeholder and the last large `missing` row. It is now a real
diff --git a/docs/lexicon/08-streaming.md b/docs/lexicon/08-streaming.md
index 4e4a7a5..5ef93ca 100644
--- a/docs/lexicon/08-streaming.md
+++ b/docs/lexicon/08-streaming.md
@@ -62,7 +62,18 @@ library.
 *What it does* — Given a chart or a list, automates the tedious per-track search across online
 stores to find where each track can be bought, with price comparison.
 
-*decks status* — **missing.** *Epic* — **7**.
+*decks status* — **partial.** `track_matcher::store_links` generates the correct search URL per
+track for Beatport, Bandcamp, Discogs, Spotify, Tidal, SoundCloud and YouTube — the three the
+manual names for onward search, plus the stores a DJ actually buys from. That is the tedious part,
+and it is honest: a search link claims nothing about whether the track exists or what it costs, and
+cannot be wrong in a way that costs the user anything.
+
+**Price comparison is not built**, and neither is anything else needing an authenticated store API.
+Doing it properly means a registered application and a per-user token per store — an account action
+with terms attached. The UI says plainly that these are search links only, rather than implying a
+comparison that is not happening.
+
+*Epic* — **7**.
 
 ---
 
@@ -84,8 +95,26 @@ or Beatport** to hunt down. Aimed squarely at wedding and event DJs working from
 *decks status* — **partial, and solid.** `crates/track-matcher` does normalisation (strip `feat.`,
 strip `(Original Mix)`/`(Extended)`/`(Radio Edit)`), exact match on normalised artist+title, then
 token-sort Levenshtein ≥ 85, returning `exact` / `fuzzy` / `unmatched` with a confidence score.
-CSV parsing moved to the Rust backend (`parse_csv_for_matcher`) with a column-mapping UI. Missing:
-`.m3u8` input, configurable separator, playlist creation from results, and all onward-search.
+CSV parsing moved to the Rust backend (`parse_csv_for_matcher`) with a column-mapping UI.
+
+**Now done.** `tracklist::parse` reads `.txt` and `.m3u8` with one reader — an `.m3u8` is a text
+file whose non-track lines start with `#` — preferring `#EXTINF` titles over the path lines beneath
+them, because a path is a location and matching a library by path is what Relocate is for. The
+separator is *selectable* as the manual specifies, not guessed: hyphen, en dash, em dash,
+`Title by Artist` (the one form where the sides swap), none, or custom. Matches become a playlist
+via the existing `create_playlist_from_tracks`.
+
+Two things real request lists forced, neither in the manual:
+
+- **Numbered indices are stripped.** `1. Daft Punk - ...` otherwise makes the artist `1. Daft Punk`,
+  which normalisation does not remove and which pushes a genuine match under the fuzzy threshold.
+  A digit alone is never an index, though — `99 Problems` and `1979` are titles — so the number
+  must be followed by punctuation, or introduced by `#`.
+- **`#` is ambiguous** between the two formats: a directive in `.m3u8`, a list index in a
+  hand-written setlist. What follows settles it — letters mean directive, digits mean index.
+
+Onward search is built as **generated store search URLs** (see §Store Links). The
+push-to-service half is not; it needs a registered application and a per-user token per service.
 
 *Epic* — **7**.
 
diff --git a/docs/lexicon/GAPS.md b/docs/lexicon/GAPS.md
index d4dc869..1bccf30 100644
--- a/docs/lexicon/GAPS.md
+++ b/docs/lexicon/GAPS.md
@@ -107,6 +107,57 @@ Compare the shape against `musicbrainz::parse_search`'s expectations — `record
 `artist-credit[].name` / `.joinphrase`, `tags[].name` / `.count`, `releases[].date`,
 `releases[].label-info[].label.name`. The equivalents for Discogs are in `discogs::parse_search`.
 
+### Epic 7 streaming: what needs credentials only the account owner can obtain
+
+The instruction was "integrate all the ones you can". This records precisely what "can" turned out
+to mean, so the boundary is arguable rather than merely asserted.
+
+**Built — needs no account:**
+
+- Track Matcher's `.txt` / `.m3u8` input, the selectable separator, and playlist creation from
+  results. These were always plain parsing and staging; nothing external is involved.
+- **Onward search and Store Links, as generated search URLs.** Constructing the right search URL
+  per store per track is the tedious part of both features, and a search URL is *honest*: it makes
+  no claim the track exists, no claim about price, and it cannot be wrong in a way that costs the
+  user anything.
+
+**Not built — blocked on a registered application and a per-user token:**
+
+| Feature | What it needs |
+|---|---|
+| Beatport catalog, cart, purchase replacement | Beatport API app + OAuth user token |
+| Charts | Beatport API app |
+| Store Links *price comparison* | per-store authenticated APIs |
+| Send To (Spotify / Tidal / Beatport) | write scopes on each service |
+| SoundCloud playback of streaming tracks | SoundCloud API app + OAuth |
+| Track Discovery | a catalog to recommend from, i.e. one of the above |
+
+Registering these applications is an account action with terms attached, so it is the project
+owner's to take, not something an agent should do on their behalf. Once an app exists for a
+service, the client work is small — the token plumbing already exists (`get_api_key` /
+`set_api_key`, keychain-backed, as used for Discogs in ADR-0016).
+
+**Not built — blocked on something else entirely: the streaming-track data model.**
+
+`08-streaming.md §Streaming tracks` says conversion of streaming references between DJ apps is
+supported "for all sources, even those that can't be played" — the reference survives when the
+audio does not. That is the most valuable part and it needs *no* API. It is unbuilt because
+**there is nowhere verified to put it.** `decks` is Rekordbox-first and read-only on `master.db`,
+the synthetic schema in `crates/rekordbox-db/src/sql/schema.sql` models no streaming columns, and
+no real `master.db` is available here to see what Rekordbox 7 actually uses. Storing the reference
+in `cache.sqlite3` instead would make it a decks-only concept that never reaches Rekordbox, which
+is exactly the promise the feature is supposed to keep.
+
+**The unblocking check**, on a machine with Rekordbox 7 installed:
+
+```sh
+# against a *copy* of a real master.db, read-only
+sqlite3 master-copy.db ".schema djmdContent" | grep -iE 'stream|service|web|link|uuid'
+```
+
+If Rekordbox models streaming tracks in `djmdContent` (or a sibling table), the column names decide
+the design and the feature becomes ordinary work. Until then it would be built against a guess.
+
 ## Open questions for the project owner
 
 1. **Camelot vs Open Key.** Lexicon avoids Camelot for licensing reasons and ships Open Key.
diff --git a/docs/lexicon/PARITY.md b/docs/lexicon/PARITY.md
index 92dca4b..aeb2c3f 100644
--- a/docs/lexicon/PARITY.md
+++ b/docs/lexicon/PARITY.md
@@ -22,10 +22,10 @@ regardless of how much of Lexicon they represent.
 | Files | 7 | 4 | 0 | 0 | 0 |
 | Health | 3 | 1 | 0 | 0 | 0 |
 | Recipes & editing | 7 | 1 | 1 | 0 | 0 |
-| Streaming | 1 | 1 | 7 | 0 | 0 |
+| Streaming | 2 | 1 | 6 | 0 | 0 |
 | History & backup | 3 | 0 | 0 | 0 | 2 |
 | Extensibility | 0 | 0 | 0 | 0 | 3 |
-| **Total** | **61** | **21** | **12** | **2** | **16** |
+| **Total** | **62** | **21** | **11** | **2** | **16** |
 
 The shape of the work: library *hygiene*, *editing* and *set preparation* are broadly covered.
 What is thin is *automation* — nothing runs unprompted except auto-analyse — and *enrichment*,
@@ -180,11 +180,18 @@ withdrawn in 2024 (ADR-0012), with Popularity uncomputable locally under any cir
 | Feature | Status | Notes | Epic |
 |---|---|---|---|
 | Share / export (CSV, M3U, HTML/PDF, quick copy) | **done** | `crates/share`, in Playlist Tools. CSV formula injection defused; M3U reports the pathless tracks it could not carry; HTML self-contained, PDF via the browser. Header drag-to-reorder not done — the picker orders by tick order | 6 |
-| Track Matcher | partial | No `.m3u8`, no separator choice, no playlist creation, no onward search | 7 |
-
-Everything else is **missing** and belongs to **Epic 7**: Beatport / Beatsource / Tidal /
-SoundCloud sources, Beatport catalog + cart + purchase-replacement, Charts, Store Links, Track
-Discovery, Send To, Transfer Streaming To Local.
+| Track Matcher | **done** | `.txt` / `.m3u8` input (one reader, `#EXTINF` titles preferred over paths), selectable separator (hyphen / en dash / em dash / `by` / none / custom), numbered-setlist indices stripped, playlist creation from matches, and onward search as generated store URLs | 7 |
+
+| Store Links | partial | Search URLs generated per track across Beatport, Bandcamp, Discogs, Spotify, Tidal, SoundCloud and YouTube — the tedious part, and honest: a search link claims nothing. **Price comparison needs authenticated store APIs** and is not built | 7 |
+
+Everything else is **missing** and belongs to **Epic 7**. `GAPS.md` §Epic 7 records exactly why,
+and the split matters: Beatport catalog / cart / purchase-replacement, Charts, Send To, SoundCloud
+playback and Track Discovery are blocked on **a registered application and a per-user token per
+service** — an account action with terms attached, so the project owner's to take. Streaming
+tracks and Transfer Streaming To Local are blocked on something different: **there is nowhere
+verified to store a streaming reference.** `master.db` models no streaming columns in the synthetic
+schema and no real one is available here, and putting the reference in the local cache would make
+it decks-only — which defeats the one guarantee the feature exists to give.
 
 ## History & backup — `09-history-backup.md`