@audiofool/moondog 0.1.0

package/src/surfaces/cli/taste-profile-model.mjs

@@ -0,0 +1,306 @@
+import { sanitizeTerminalText } from "./format-output.mjs";
+
+const MAX_ITEMS_PER_SOURCE = 10;
+
+function items(value) {
+  return Array.isArray(value) ? value.slice(0, MAX_ITEMS_PER_SOURCE) : [];
+}
+
+function inline(value) {
+  return typeof value === "string"
+    ? sanitizeTerminalText(value).replace(/\s+/gu, " ").trim()
+    : "";
+}
+
+function identity(value) {
+  return inline(value).normalize("NFKC").toLocaleLowerCase("und");
+}
+
+function identifier(value) {
+  return typeof value === "string" && value.trim() && value.length <= 128 &&
+    value === inline(value) ? value : undefined;
+}
+
+function count(value) {
+  return Number.isSafeInteger(value) && value >= 0
+    ? value.toLocaleString("en-US")
+    : undefined;
+}
+
+function amount(value) {
+  return Number.isFinite(value) && value >= 0
+    ? value.toLocaleString("en-US", { maximumFractionDigits: 1 })
+    : undefined;
+}
+
+function date(value) {
+  return typeof value === "string" && /^\d{4}-\d{2}-\d{2}/u.test(value) &&
+    Number.isFinite(Date.parse(value)) ? inline(value).slice(0, 10) : "";
+}
+
+function targetFor(item, kind) {
+  const label = kind === "artist" ? item?.name ?? item?.label : item?.label;
+  if (!inline(label) || !["artist", "track"].includes(kind)) return null;
+  if (kind === "track" && !inline(item?.artist_credit)) return null;
+  return {
+    entityType: kind,
+    label,
+    ...(kind === "track" ? { artistCredit: item.artist_credit } : {}),
+  };
+}
+
+function subjectKey(target) {
+  return JSON.stringify([
+    target.entityType,
+    identity(target.label),
+    ...(target.entityType === "track" ? [identity(target.artistCredit)] : []),
+  ]);
+}
+
+function plural(value, one, many = `${one}s`) {
+  return `${count(value)} ${value === 1 ? one : many}`;
+}
+
+function itemMetrics(item) {
+  const values = [];
+  const known = (field) => count(item?.[field]) !== undefined;
+  if (known("play_count")) values.push(plural(item.play_count, "play"));
+  if (known("engaged_play_count") && item.engaged_play_count !== item.play_count) {
+    values.push(`${count(item.engaged_play_count)} heard properly`);
+  }
+  if (known("distinct_tracks")) values.push(plural(item.distinct_tracks, "track"));
+  if (known("explicit_skips") && item.explicit_skips > 0) values.push(`skipped ${plural(item.explicit_skips, "time")}`);
+  if (known("playlist_count")) values.push(`on ${plural(item.playlist_count, "playlist")}`);
+  if (known("quiet_days")) values.push(`quiet for ${plural(item.quiet_days, "day")}`);
+  if (known("return_count")) values.push(`came back ${item.return_count === 1 ? "once" : `${count(item.return_count)} times`}`);
+  if (known("longest_gap_days")) values.push(`longest time away ${plural(item.longest_gap_days, "day")}`);
+  if (known("maximum_consecutive_plays")) values.push(`up to ${count(item.maximum_consecutive_plays)} in a row`);
+  if (known("burst_count") && item.burst_count > 1) values.push(`${count(item.burst_count)} separate runs`);
+  const minutes = amount(item?.listening_minutes);
+  if (minutes !== undefined) values.push(`${minutes} min`);
+  const lastPlayed = date(item?.last_played_at);
+  if (lastPlayed) values.push(`last played ${lastPlayed}`);
+  if (Number.isFinite(item?.confidence) && item.confidence >= 0 && item.confidence <= 1) {
+    values.push(`${Math.round(item.confidence * 100)}% sure`);
+  }
+  return values;
+}
+
+function overview(profile) {
+  const coverage = profile?.coverage ?? {};
+  const lines = [];
+  const durationUnavailable = coverage.effective_listening_events > 0 && coverage.events_with_played_duration === 0;
+  const listening = [
+    [count(coverage.effective_listening_events), coverage.effective_listening_events === 1 ? "play" : "plays"],
+    [durationUnavailable ? undefined : amount(coverage.listening_hours), "h"],
+    [count(coverage.listening_tracks), coverage.listening_tracks === 1 ? "track" : "tracks"],
+  ].filter(([value]) => value !== undefined).map(([value, label]) => `${value} ${label}`);
+  if (durationUnavailable) listening.push("listening time unknown");
+  if (listening.length && !(coverage.effective_listening_events === 0 && (coverage.tracks_observed > 0 || coverage.collection_tracks > 0))) {
+    lines.push(listening.join(" · "));
+  }
+  if (Number.isSafeInteger(coverage.tracks_observed) && coverage.tracks_observed > 0) {
+    const loved = count(coverage.loved_or_favorited);
+    lines.push(`Apple Music library: ${plural(coverage.tracks_observed, "track")}${
+      loved === undefined ? "" : ` · ${loved} loved`
+    }`);
+  }
+  const source = profile?.listening_source ?? {};
+  const collections = items(coverage.collection_sources).filter((collection) => collection.tracks > 0);
+  if (collections.length > 1) lines.push(`${count(coverage.collection_tracks)} songs across ${collections.length} services`);
+  for (const collection of collections) {
+    if (collection.tracks > 0) lines.push(`${inline(collection.label)}: ${plural(collection.tracks, "song")}`);
+  }
+  const providers = items(source.providers).map(inline).filter(Boolean).map((provider) => ({
+    spotify: "Spotify",
+    listenbrainz: "ListenBrainz",
+    lastfm: "Last.fm",
+    apple_music: "Apple Music",
+    youtube_music: "YouTube Music",
+  })[provider] ?? provider);
+  const earliest = date(source.listening_range?.earliest);
+  const latest = date(source.listening_range?.latest);
+  const range = earliest && latest ? `${earliest} to ${latest}` : earliest || latest;
+  if (providers.length || range) {
+    lines.push([providers.length ? `${providers.join(", ")} history` : "History", range]
+      .filter(Boolean).join(" · "));
+  }
+  const captured = date(profile?.source?.captured_at);
+  if (captured) lines.push(`Library as of ${captured}`);
+  const active = count(coverage.active_listener_assertions);
+  if (coverage.active_listener_assertions > 0) lines.push(`${plural(coverage.active_listener_assertions, "choice")} you've made`);
+  return lines;
+}
+
+const sourceNames = {
+  "Apple Music library preference": "In your Apple Music library",
+  "Apple Music aggregate play count": "Apple Music play count",
+};
+
+function explicitKind(item) {
+  if (["artist", "track"].includes(item?.entity_type)) return item.entity_type;
+  if (item?.track_ref_id || item?.track_ref?.track_ref_id) return "track";
+  if (inline(item?.name) && !item?.artist_credit) return "artist";
+  return null;
+}
+
+/** Build a private, bounded review view from structured profile evidence. */
+export function buildTasteProfileModel(profile = {}) {
+  const metrics = (item) => itemMetrics(profile.coverage?.events_with_played_duration === 0
+    ? { ...item, listening_minutes: undefined } : item);
+  const subjects = new Map();
+  const seenDetails = new Map();
+  const assertions = profile?.listener_assertions ?? {};
+  const behavior = profile?.listening_behavior ?? {};
+  const curated = profile?.curated_preferences ?? {};
+
+  function add(item, kind, source, detail, { assertion = false } = {}) {
+    const target = targetFor(item, kind);
+    if (!target) return;
+    const key = subjectKey(target);
+    let subject = subjects.get(key);
+    if (!subject) {
+      subject = {
+        key,
+        label: inline(target.label),
+        subtitle: kind === "track" ? inline(target.artistCredit) : "Artist",
+        kind,
+        detailLines: [],
+        target,
+        evidence: [],
+      };
+      subjects.set(key, subject);
+      seenDetails.set(key, new Set());
+    }
+    const evidenceId = identifier(item?.evidence_id);
+    if (evidenceId && !subject.evidence.some((evidence) => evidence.id === evidenceId)) {
+      subject.evidence.push({ id: evidenceId, source: inline(source) });
+      subject.evidenceId ??= evidenceId;
+    }
+    if (assertion && ["like", "avoid"].includes(item?.stance) && !subject.stance) {
+      subject.stance = item.stance;
+      const correctionId = identifier(item.correction_id);
+      if (correctionId) subject.correctionId = correctionId;
+    }
+    const line = inline(detail);
+    if (line && !seenDetails.get(key).has(line)) {
+      subject.detailLines.push(line);
+      seenDetails.get(key).add(line);
+    }
+  }
+
+  const activeAssertions = [
+    ...items(assertions.active),
+    ...items(assertions.preferences),
+    ...items(assertions.avoids),
+  ];
+  const seenAssertions = new Set();
+  for (const item of activeAssertions) {
+    if (!["like", "avoid"].includes(item?.stance)) continue;
+    const target = targetFor(item, item.entity_type);
+    if (!target) continue;
+    const key = subjectKey(target);
+    if (seenAssertions.has(key)) continue;
+    seenAssertions.add(key);
+    const when = date(item.asserted_at);
+    const note = inline(item.note);
+    add(item, item.entity_type, "Your choice", `You said: ${
+      item.stance === "like" ? "I like this" : "keep this out"
+    }${when ? ` · ${when}` : ""}${note ? ` · "${note}"` : ""}`, { assertion: true });
+  }
+
+  const recentDays = count(behavior.context?.recent_window_days);
+  const recentSource = recentDays ? `Lately (last ${recentDays} days)` : "Lately";
+  for (const [field, kind, source] of [
+    ["repeat_tracks", "track", "Most played"],
+    ["enduring_artists", "artist", "Across the years"],
+    ["recent_tracks", "track", recentSource],
+    ["recent_artists", "artist", recentSource],
+    ["rediscovery_tracks", "track", "Gone quiet"],
+    ["historical_return_tracks", "track", "Came back"],
+    ["back_to_back_tracks", "track", "Played in a row"],
+  ]) {
+    for (const item of items(behavior[field])) {
+      const details = metrics(item);
+      add(item, kind, source, `${source}${details.length ? `: ${details.join(" · ")}` : ""}`);
+    }
+  }
+  for (const item of items(behavior.time_capsule_tracks)) {
+    const year = count(item?.capsule_year);
+    const details = metrics({
+      play_count: item?.year_play_count,
+      engaged_play_count: item?.year_engaged_play_count,
+      listening_minutes: item?.year_listening_minutes,
+      explicit_skips: item?.year_explicit_skips,
+    });
+    add(item, "track", "Song of the year", `${year ? `Your song of ${item.capsule_year}` : "Song of the year"}${
+      details.length ? `: ${details.join(" · ")}` : ""
+    }`);
+  }
+  for (const [field, kind, source] of [
+    ["saved_tracks", "track", "Saved in your Spotify library"],
+    ["playlist_anchors", "track", "On your Spotify playlists"],
+    ["followed_artists", "artist", "Followed on Spotify"],
+  ]) {
+    for (const item of items(curated[field])) {
+      const details = metrics(item);
+      const label = source.replace("Spotify", inline(item.source_label) || "Spotify");
+      add(item, kind, label, `${label}${details.length ? `: ${details.join(" · ")}` : ""}`);
+    }
+  }
+  for (const item of items(curated.avoids)) {
+    const target = targetFor(item, item?.entity_type);
+    if (target && !seenAssertions.has(subjectKey(target))) {
+      add(item, item.entity_type, "Disliked in your music service", "You disliked this in your music service. You can still change it here.");
+    }
+  }
+  for (const [field, kind] of [["artists", "artist"], ["tracks", "track"]]) {
+    for (const item of items(profile?.provider_signals?.[field])) {
+      const rank = count(item?.best_rank);
+      const details = [...(rank ? [`best at #${rank}`] : []), ...metrics(item)];
+      add(item, kind, "Service top list", `In your service's top list${details.length ? `: ${details.join(" · ")}` : ""}`);
+    }
+  }
+  for (const [field, fallback] of [["strong_preferences", "From your library"], ["familiarity", "Familiar from your library"]]) {
+    for (const item of items(profile?.[field])) {
+      const kind = explicitKind(item);
+      if (!kind) continue;
+      const target = targetFor(item, kind);
+      if (!target) continue;
+      const existing = subjects.get(subjectKey(target));
+      if (item.evidence_id && existing?.evidence.some((evidence) => evidence.id === item.evidence_id)) continue;
+      const source = sourceNames[inline(item.source)] ?? (inline(item.source) || fallback);
+      const observed = date(item.observed_at);
+      const details = [inline(item.signal).replace(/,? non-computed rating/u, ", rated"), ...metrics(item), ...(observed ? [`as of ${observed}`] : [])].filter(Boolean);
+      add(item, kind, source, `${source}${details.length ? `: ${details.join(" · ")}` : ""}`);
+    }
+  }
+  for (const item of items(profile?.artist_facets)) {
+    const target = targetFor(item, "artist");
+    if (!target) continue;
+    const existing = subjects.get(subjectKey(target));
+    if (item.evidence_id && existing?.evidence.some((evidence) => evidence.id === item.evidence_id)) continue;
+    add(item, "artist", "Through a track", "Shows up through one of their tracks.");
+  }
+
+  for (const subject of subjects.values()) {
+    if (subject.kind !== "track") continue;
+    const artist = subjects.get(subjectKey({ entityType: "artist", label: subject.target.artistCredit }));
+    if (artist?.stance !== "avoid") continue;
+    subject.detailLines.unshift(`You asked me to keep ${artist.label} out.${
+      subject.stance === "like" ? " That still applies, even though you like this track." : ""
+    }`);
+    if (artist.evidenceId && !subject.evidence.some((evidence) => evidence.id === artist.evidenceId)) {
+      subject.evidence.push({ id: artist.evidenceId, source: "Your choice for the artist" });
+    }
+  }
+
+  return {
+    summaryLines: overview(profile),
+    subjects: [...subjects.values()],
+    emptyLines: [
+      "Nothing to look at yet.",
+      "Import your history or library and it will show up here.",
+    ],
+  };
+}

package/src/surfaces/cli/taste-profile-view.mjs

@@ -0,0 +1,272 @@
+import { stripVTControlCharacters } from "node:util";
+import {
+  Input,
+  getKeybindings,
+  matchesKey,
+  truncateToWidth,
+  visibleWidth,
+  wrapTextWithAnsi,
+} from "@earendil-works/pi-tui";
+
+import { sanitizeTerminalText } from "./format-output.mjs";
+
+const categories = [
+  { id: "all", label: "All" },
+  { id: "track", label: "Tracks" },
+  { id: "artist", label: "Artists" },
+  { id: "choices", label: "Your choices" },
+];
+
+function clean(value) {
+  return sanitizeTerminalText(stripVTControlCharacters(String(value ?? ""))).replaceAll("\t", "    ");
+}
+
+function inline(value) { return clean(value).replace(/\s+/gu, " ").trim(); }
+
+function fit(value, width) {
+  const clipped = truncateToWidth(value, Math.max(1, width), "");
+  return clipped + " ".repeat(Math.max(0, width - visibleWidth(clipped)));
+}
+
+function paint(value, width, theme) {
+  const line = fit(value, width);
+  // Only remove SGR styling in plain mode; Pi's cursor marker positions the IME.
+  return theme.plain ? line.replace(/\u001b\[[\d;:]*m/g, "") : theme.background(theme.text(line));
+}
+
+function ends(left, right, width) {
+  const tailWidth = visibleWidth(right);
+  if (tailWidth + 3 >= width) return truncateToWidth(left, width, "");
+  const head = truncateToWidth(left, width - tailWidth - 2, "");
+  return head + " ".repeat(width - visibleWidth(head) - tailWidth) + right;
+}
+
+function stanceLabel(subject) {
+  return subject?.stance === "like" ? "You like this" : subject?.stance === "avoid" ? "You asked me to keep this out" : "";
+}
+
+/** A terminal-native, searchable profile with a live reading beside its subjects. */
+export class TasteProfileView {
+  constructor({ model, getTheme, getRows }) {
+    this.getTheme = getTheme;
+    this.getRows = getRows;
+    this.input = new Input();
+    this.category = "all";
+    this.query = "";
+    this.selectedKey = undefined;
+    this.detailOffset = 0;
+    this.detailPageSize = 1;
+    this.detailMaxOffset = 0;
+    this.pasteActive = false;
+    this.pasteTail = "";
+    this.onSelect = undefined;
+    this.onClose = undefined;
+    this.onRefresh = undefined;
+    this.onReport = undefined;
+    this.setModel(model);
+  }
+
+  get focused() { return this.input.focused; }
+  set focused(value) { this.input.focused = value; }
+
+  invalidate() { this.input.invalidate(); }
+
+  setModel(model) {
+    this.model = model ?? {};
+    const subjects = Array.isArray(this.model.subjects) ? this.model.subjects : [];
+    this.entries = subjects.filter((subject) => subject && typeof subject === "object").map((subject) => ({
+      subject,
+      search: [subject.label, subject.subtitle, subject.kind, stanceLabel(subject), ...(subject.detailLines ?? [])]
+        .map(inline).join(" ").toLowerCase(),
+    }));
+    this.filterSubjects();
+  }
+
+  filterSubjects() {
+    const tokens = inline(this.query).toLowerCase().split(/\s+/u).filter(Boolean);
+    this.filtered = this.entries.filter(({ subject, search }) => {
+      const categoryMatches = this.category === "all" || this.category === subject.kind ||
+        (this.category === "choices" && ["like", "avoid"].includes(subject.stance));
+      return categoryMatches && tokens.every((token) => search.includes(token));
+    }).map(({ subject }) => subject);
+    if (!this.filtered.some((subject) => subject.key === this.selectedKey)) {
+      this.selectedKey = this.filtered[0]?.key;
+      this.detailOffset = 0;
+    }
+  }
+
+  getSelectedItem() {
+    return this.filtered.find((subject) => subject.key === this.selectedKey) ?? null;
+  }
+
+  updateInput(data) {
+    const previous = this.input.getValue();
+    this.input.handleInput(data);
+    if (previous !== this.input.getValue()) {
+      this.query = this.input.getValue();
+      this.filterSubjects();
+    }
+  }
+
+  handleInput(data) {
+    if (data.includes("\x1b[200~")) this.pasteActive = true;
+    if (this.pasteActive) {
+      this.updateInput(data);
+      const paste = this.pasteTail + data;
+      this.pasteActive = !paste.includes("\x1b[201~");
+      this.pasteTail = this.pasteActive ? paste.slice(-5) : "";
+      return;
+    }
+    const keys = getKeybindings();
+    if (keys.matches(data, "tui.select.cancel")) { this.onClose?.(); return; }
+    if (matchesKey(data, "ctrl+r")) { this.onRefresh?.(); return; }
+    if (matchesKey(data, "ctrl+o")) { this.onReport?.(); return; }
+    if (matchesKey(data, "tab") || matchesKey(data, "shift+tab")) {
+      const index = categories.findIndex((category) => category.id === this.category);
+      this.category = categories[(index + (matchesKey(data, "shift+tab") ? -1 : 1) + categories.length) % categories.length].id;
+      this.filterSubjects();
+      this.detailOffset = 0;
+      return;
+    }
+    if (keys.matches(data, "tui.select.up") || keys.matches(data, "tui.select.down")) {
+      if (this.filtered.length) {
+        const index = this.filtered.findIndex((subject) => subject.key === this.selectedKey);
+        this.selectedKey = this.filtered[(index + (keys.matches(data, "tui.select.up") ? -1 : 1) + this.filtered.length) % this.filtered.length].key;
+        this.detailOffset = 0;
+      }
+      return;
+    }
+    if (keys.matches(data, "tui.select.confirm")) {
+      const selected = this.getSelectedItem();
+      if (selected) this.onSelect?.(selected);
+      return;
+    }
+    if (keys.matches(data, "tui.select.pageUp") || keys.matches(data, "tui.select.pageDown")) {
+      const direction = keys.matches(data, "tui.select.pageUp") ? -1 : 1;
+      this.detailOffset = Math.max(0, Math.min(this.detailMaxOffset, this.detailOffset + direction * Math.max(1, this.detailPageSize - 1)));
+      return;
+    }
+    this.updateInput(data);
+  }
+
+  renderCategories(width, theme) {
+    if (width < 34) {
+      const label = categories.find((category) => category.id === this.category)?.label ?? "All";
+      return theme.bold(`‹ ${label} ›`) + (width >= 24 ? theme.faint("  tab change") : "");
+    }
+    return categories.map(({ id, label }) => {
+      const text = width < 38 && id === "choices" ? "Choices" : label;
+      return id === this.category ? theme.inverse(theme.bold(` ${text} `)) : theme.muted(text);
+    }).join(width >= 34 ? "  " : " ");
+  }
+
+  renderList(width, height, theme, { compact = false } = {}) {
+    if (height <= 0) return [];
+    const lineHeight = compact ? 1 : 2;
+    const capacity = Math.max(1, Math.floor(height / lineHeight));
+    const selectedIndex = this.filtered.findIndex((subject) => subject.key === this.selectedKey);
+    const start = Math.max(0, Math.min(selectedIndex - Math.floor(capacity / 2), this.filtered.length - capacity));
+    const lines = [];
+    for (const subject of this.filtered.slice(start, start + capacity)) {
+      const selected = subject.key === this.selectedKey;
+      const marker = selected ? "› " : "  ";
+      const label = inline(subject.label) || (subject.kind === "artist" ? "Artist" : "Track");
+      const stance = subject.stance === "like" ? "+" : subject.stance === "avoid" ? "−" : "";
+      const main = ends(marker + label, stance, width);
+      lines.push(selected ? theme.inverse(theme.bold(fit(main, width))) : theme.text(main));
+      if (!compact && lines.length < height) lines.push(theme.muted(`  ${inline(subject.subtitle) || (subject.kind === "artist" ? "Artist" : "Track")}`));
+    }
+    return Array.from({ length: height }, (_, index) => lines[index] ?? "");
+  }
+
+  renderDetail(width, height, theme) {
+    if (height <= 0) return [];
+    const subject = this.getSelectedItem();
+    if (!subject) return Array(height).fill("");
+    const heading = theme.bold(inline(subject.label) || "Selected");
+    const subtitle = inline(subject.subtitle);
+    const stance = stanceLabel(subject);
+    const prefix = [heading];
+    if (subtitle && height >= 4) prefix.push(theme.muted(subtitle));
+    if (stance && height >= 6) prefix.push(theme.accent(stance));
+    if (height >= 8) prefix.push("");
+    const sourceLines = Array.isArray(subject.detailLines) && subject.detailLines.length
+      ? subject.detailLines
+      : ["Nothing more to show for this one yet."];
+    const detail = sourceLines.flatMap((line) => wrapTextWithAnsi(clean(line), Math.max(1, width)));
+    const available = Math.max(0, height - prefix.length);
+    const scrolls = detail.length > available;
+    const contentHeight = Math.max(0, available - (scrolls && available >= 2 ? 1 : 0));
+    this.detailPageSize = Math.max(1, contentHeight);
+    this.detailMaxOffset = Math.max(0, detail.length - contentHeight);
+    this.detailOffset = Math.min(this.detailOffset, this.detailMaxOffset);
+    const visible = detail.slice(this.detailOffset, this.detailOffset + contentHeight).map(theme.text);
+    const lines = [...prefix, ...visible];
+    if (scrolls && available >= 2) {
+      const range = `${this.detailOffset + 1}–${Math.min(detail.length, this.detailOffset + contentHeight)}/${detail.length}`;
+      lines.push(theme.faint(ends("PgUp/PgDn to scroll", range, width)));
+    }
+    return Array.from({ length: height }, (_, index) => lines[index] ?? "");
+  }
+
+  renderEmpty(width, height, theme) {
+    this.detailOffset = 0;
+    this.detailMaxOffset = 0;
+    const filtered = this.entries.length > 0;
+    const lines = filtered
+      ? ["Nothing matches that.", "", "Try fewer words, or press Tab for another list."]
+      : (Array.isArray(this.model.emptyLines) && this.model.emptyLines.length
+        ? this.model.emptyLines
+        : ["Nothing to look at yet.", "", "Import your history or library and it will show up here."]);
+    const wrapped = lines.flatMap((line) => wrapTextWithAnsi(clean(line), width));
+    return Array.from({ length: height }, (_, index) => index === 0
+      ? theme.bold(wrapped[index] ?? "") : theme.muted(wrapped[index] ?? ""));
+  }
+
+  render(width) {
+    const columns = Math.max(1, Math.floor(width));
+    const requestedRows = Number(this.getRows());
+    const height = Number.isFinite(requestedRows) ? Math.max(0, Math.floor(requestedRows)) : 0;
+    if (!height) return [];
+    const theme = this.getTheme();
+    const inset = columns >= 8 ? 1 : 0;
+    const inner = Math.max(1, columns - inset * 2);
+    const position = this.filtered.findIndex((subject) => subject.key === this.selectedKey) + 1;
+    const count = `${Math.max(0, position)}/${this.filtered.length}`;
+    const heading = theme.bold(inner >= 24 + count.length ? "Your listening profile" : "Your profile");
+    const lines = [ends(heading, theme.muted(count), inner)];
+    if (height >= 10) {
+      const summaries = Array.isArray(this.model.summaryLines) ? this.model.summaryLines : [];
+      const maxSummary = height >= 22 ? 2 : 1;
+      lines.push(...summaries.slice(0, maxSummary).map((line) => theme.muted(inline(line))));
+    }
+    if (height >= 5) lines.push(inner >= 76
+      ? ends(this.renderCategories(inner, theme), theme.faint("Ctrl+R refresh · Ctrl+O report"), inner)
+      : this.renderCategories(inner, theme));
+    if (height >= 2) {
+      const searchLabel = inner >= 26 ? theme.faint("Search ") : "";
+      lines.push(searchLabel + this.input.render(Math.max(1, inner - visibleWidth(searchLabel)))[0]);
+    }
+    if (height >= 7) lines.push(theme.faint("─".repeat(inner)));
+    const remaining = Math.max(0, height - lines.length);
+    if (!this.filtered.length) {
+      lines.push(...this.renderEmpty(inner, remaining, theme));
+    } else if (columns >= 90 && remaining >= 7) {
+      const leftWidth = Math.max(24, Math.floor((inner - 3) * 0.42));
+      const rightWidth = Math.max(1, inner - leftWidth - 3);
+      const list = this.renderList(leftWidth, remaining, theme);
+      const detail = this.renderDetail(rightWidth, remaining, theme);
+      for (let row = 0; row < remaining; row += 1) {
+        lines.push(fit(list[row], leftWidth) + theme.faint(" │ ") + fit(detail[row], rightWidth));
+      }
+    } else if (remaining >= 6) {
+      const listHeight = Math.max(2, Math.min(5, Math.floor(remaining * 0.32)));
+      lines.push(...this.renderList(inner, listHeight, theme, { compact: true }));
+      lines.push(theme.faint("─".repeat(inner)));
+      lines.push(...this.renderDetail(inner, remaining - listHeight - 1, theme));
+    } else {
+      lines.push(...this.renderList(inner, remaining, theme, { compact: true }));
+    }
+    return Array.from({ length: height }, (_, index) => paint(" ".repeat(inset) + (lines[index] ?? ""), columns, theme));
+  }
+}