From 2e6f3f9f0d2c365168f933b32a517694c62b8c1f Mon Sep 17 00:00:00 2001
From: YoGo9 <162524691+YoGo9@users.noreply.github.com>
Date: Tue, 15 Sep 2026 14:03:43 -0400
Subject: [PATCH 1/2] Update user script for batch adding recording aliases

---
 BatchAddRecordingAliases.user.js | 641 +++++++++++++++++++++++++------
 1 file changed, 520 insertions(+), 121 deletions(-)

diff --git a/BatchAddRecordingAliases.user.js b/BatchAddRecordingAliases.user.js
index b353a52..9102aba 100644
--- a/BatchAddRecordingAliases.user.js
+++ b/BatchAddRecordingAliases.user.js
@@ -4,15 +4,15 @@
  * MIT License
  */
 
-/* global $ helper edits sidebar requests GM_info aliases */
+/* global $ helper edits requests aliases */
 'use strict';
 
 // ==UserScript==
 // @name         Batch Add Recording Aliases from another Release
 // @namespace    YoGo9
 // @author       YoGo9
-// @version      12/26/25
-// @description  Paste a source release URL/MBID; copy its track titles as recording aliases on the current (target) release's recordings.
+// @version      2026.09.15
+// @description  Copy track titles from another MusicBrainz release to recording aliases on the current release.
 // @homepage     https://github.com/YoGo9/Scripts
 // @updateURL    https://raw.githubusercontent.com/YoGo9/Scripts/main/BatchAddRecordingAliases.user.js
 // @downloadURL  https://raw.githubusercontent.com/YoGo9/Scripts/main/BatchAddRecordingAliases.user.js
@@ -23,13 +23,11 @@
 // @grant        GM_info
 // @run-at       document-end
 // ==/UserScript==
-'use strict';
 
 if (!/^\/release\/[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i.test(location.pathname)) {
   return;
 }
 
-
 (function () {
   const HOST = location.origin;
   const WS_HOST = 'https://musicbrainz.org';
@@ -51,18 +49,26 @@ if (!/^\/release\/[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/
 
   async function wsRelease(releaseMbid) {
     const url = `${WS_HOST}/ws/2/release/${releaseMbid}?inc=recordings+media&fmt=json`;
-    const r = await fetch(url, { headers: { Accept: 'application/json' } });
-    if (!r.ok) throw new Error(`WS fetch failed ${r.status} for release ${releaseMbid}`);
+    const r = await fetch(url, {
+      headers: { Accept: 'application/json' },
+    });
+
+    if (!r.ok) {
+      throw new Error(`MusicBrainz returned HTTP ${r.status}`);
+    }
+
     return r.json();
   }
 
   function flattenTracks(releaseJson) {
     const out = [];
+
     for (const medium of (releaseJson.media || [])) {
-      const mPos = medium.position;
+      const mediumPosition = medium.position;
+
       for (const track of (medium.tracks || [])) {
         out.push({
-          mediumPosition: mPos,
+          mediumPosition,
           trackPosition: track.position,
           trackTitle: track.title,
           recordingMbid: track.recording?.id || null,
@@ -70,130 +76,423 @@ if (!/^\/release\/[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/
         });
       }
     }
+
     return out;
   }
 
   function mapByRecording(tracks) {
-    const m = new Map();
-    for (const t of tracks) {
-      if (t.recordingMbid) m.set(t.recordingMbid, t.trackTitle);
+    const map = new Map();
+
+    for (const track of tracks) {
+      if (track.recordingMbid) {
+        map.set(track.recordingMbid, track.trackTitle);
+      }
     }
-    return m;
+
+    return map;
   }
 
   function mapByPosition(tracks) {
-    const m = new Map();
-    for (const t of tracks) {
-      m.set(`${t.mediumPosition}-${t.trackPosition}`, t.trackTitle);
+    const map = new Map();
+
+    for (const track of tracks) {
+      map.set(
+        `${track.mediumPosition}-${track.trackPosition}`,
+        track.trackTitle
+      );
     }
-    return m;
+
+    return map;
   }
 
-  function esc(s) {
-    return String(s ?? '').replace(/[&<>"']/g, c => (
-      { '&': '&amp;', '<': '&lt;', '>': '&gt;', '"': '&quot;', "'": '&#39;' }[c]
-    ));
+  function esc(value) {
+    return String(value ?? '').replace(/[&<>"']/g, char => ({
+      '&': '&amp;',
+      '<': '&lt;',
+      '>': '&gt;',
+      '"': '&quot;',
+      "'": '&#39;',
+    })[char]);
   }
 
   function editNote(sourceReleaseUrl) {
     return `Batch Add Recording Alias from release ${sourceReleaseUrl}`;
   }
 
-  function injectUI() {
-    const box = document.createElement('div');
-    box.style.border = '1px solid #ccc';
-    box.style.padding = '10px';
-    box.style.margin = '10px 0';
-    box.style.background = '#fff';
+  function injectStyles() {
+    const style = document.createElement('style');
+
+    style.textContent = `
+      #yomo-alias-launch {
+        margin-left: .5em;
+        white-space: nowrap;
+      }
+
+      #yomo-alias-panel {
+        display: none;
+        margin: 8px 0 12px;
+        padding: 8px 10px;
+        border: 1px solid #d8d8d8;
+        background: #fafafa;
+        font-size: 13px;
+      }
+
+      #yomo-alias-panel.yomo-open {
+        display: block;
+      }
+
+      #yomo-alias-panel .yomo-line {
+        display: flex;
+        align-items: center;
+        gap: 7px;
+        flex-wrap: wrap;
+      }
+
+      #yomo-alias-panel .yomo-line + .yomo-line {
+        margin-top: 6px;
+      }
+
+      #yomo-src {
+        flex: 1 1 420px;
+        min-width: 220px;
+        max-width: 720px;
+      }
+
+      #yomo-locale {
+        width: 54px;
+      }
+
+      #yomo-summary {
+        min-height: 18px;
+        margin-top: 6px;
+      }
+
+      #yomo-summary.yomo-error,
+      .yomo-row-error {
+        color: #a40000;
+      }
+
+      #yomo-summary.yomo-warning {
+        color: #9a6700;
+      }
+
+      #yomo-actions {
+        margin-left: auto;
+      }
+
+      #yomo-table-wrap {
+        display: none;
+        margin-top: 6px;
+        max-height: 330px;
+        overflow: auto;
+        border-top: 1px solid #ddd;
+      }
+
+      #yomo-table-wrap.yomo-visible {
+        display: block;
+      }
+
+      #yomo-table {
+        width: 100%;
+        margin-top: 5px;
+      }
+
+      #yomo-table th,
+      #yomo-table td {
+        padding: 3px 5px;
+        vertical-align: top;
+      }
+
+      #yomo-table th:first-child,
+      #yomo-table td:first-child {
+        width: 24px;
+        text-align: center;
+      }
+
+      #yomo-table .yomo-disc,
+      #yomo-table .yomo-track {
+        width: 44px;
+        white-space: nowrap;
+      }
+
+      #yomo-table .yomo-recording {
+        width: 43%;
+      }
+
+      #yomo-table .yomo-alias {
+        width: 43%;
+      }
+
+      #yomo-table tr.yomo-done {
+        opacity: .55;
+      }
+
+      #yomo-table tr.yomo-failed {
+        background: #fff2f2;
+      }
+
+      .yomo-row-error {
+        margin-top: 2px;
+        font-size: 11px;
+      }
+
+      #yomo-type-wrap select {
+        max-width: 145px;
+      }
+
+      @media (max-width: 700px) {
+        #yomo-actions {
+          margin-left: 0;
+        }
+
+        #yomo-alias-panel {
+          padding: 7px;
+        }
 
-    box.innerHTML = `
-      <div style="display:flex; gap:8px; align-items:center; flex-wrap:wrap;">
-        <span style="font-weight:600;">Copy track titles → recording aliases</span>
+        #yomo-table .yomo-recording,
+        #yomo-table .yomo-alias {
+          width: auto;
+        }
+      }
+    `;
 
-        <input id="yomo-src" style="width:520px; max-width:100%;" placeholder="Paste SOURCE release URL or MBID">
+    document.head.appendChild(style);
+  }
 
-        <label style="display:flex; gap:6px; align-items:center;">
-          Type:
+  function findTabs() {
+    return (
+      document.querySelector('#content ul.tabs') ||
+      document.querySelector('ul.tabs')
+    );
+  }
+
+  function injectLauncherAndPanel() {
+    injectStyles();
+
+    const tabs = findTabs();
+    const content = document.querySelector('#content') || document.body;
+
+    const launch = document.createElement('button');
+    launch.id = 'yomo-alias-launch';
+    launch.type = 'button';
+    launch.textContent = 'Recording aliases';
+
+    let panelAnchor;
+
+    if (tabs) {
+      const li = document.createElement('li');
+      li.style.float = 'right';
+      li.style.marginLeft = '6px';
+      li.appendChild(launch);
+      tabs.appendChild(li);
+      panelAnchor = tabs;
+    } else {
+      const fallback = document.createElement('div');
+      fallback.style.textAlign = 'right';
+      fallback.style.margin = '4px 0';
+      fallback.appendChild(launch);
+      content.prepend(fallback);
+      panelAnchor = fallback;
+    }
+
+    const panel = document.createElement('div');
+    panel.id = 'yomo-alias-panel';
+
+    panel.innerHTML = `
+      <div class="yomo-line">
+        <strong>Source release</strong>
+        <input
+          id="yomo-src"
+          type="text"
+          placeholder="MusicBrainz release URL or MBID"
+          autocomplete="off"
+        >
+        <button id="yomo-preview" type="button">Preview</button>
+      </div>
+
+      <div class="yomo-line">
+        <label>
+          Type
           <span id="yomo-type-wrap">${aliases.type}</span>
         </label>
 
-        <label style="display:flex; gap:6px; align-items:center;">
-          Locale:
-          <input id="yomo-locale" style="width:70px;" value="en">
+        <label>
+          Locale
+          <input id="yomo-locale" type="text" value="en">
         </label>
 
-        <label style="display:flex; gap:6px; align-items:center;">
+        <label>
           <input id="yomo-primary" type="checkbox">
-          Primary
+          Primary for locale
         </label>
 
-        <button id="yomo-preview" type="button">Preview</button>
-        <button id="yomo-submit" type="button" disabled>Submit</button>
+        <span id="yomo-actions">
+          <button id="yomo-submit" type="button" disabled>Submit selected</button>
+        </span>
       </div>
 
-      <div id="yomo-status" style="margin-top:8px; white-space:pre-wrap;"></div>
-      <div id="yomo-table" style="margin-top:8px; max-height:320px; overflow:auto;"></div>
+      <div id="yomo-summary"></div>
+      <div id="yomo-table-wrap"></div>
     `;
 
-    (document.querySelector('#content') || document.body).prepend(box);
+    panelAnchor.insertAdjacentElement('afterend', panel);
+
+    const typeSelect = panel.querySelector('#yomo-type-wrap select');
+    if (typeSelect) {
+      typeSelect.id = 'yomo-type';
+    }
+
+    launch.addEventListener('click', () => {
+      const open = panel.classList.toggle('yomo-open');
+      launch.textContent = open ? 'Recording aliases ▴' : 'Recording aliases';
+    });
+
+    return { launch, panel };
+  }
 
-    // Ensure the select has a stable ID we can read
-    const typeSel = box.querySelector('#yomo-type-wrap select');
-    if (typeSel) typeSel.id = 'yomo-type';
+  function setSummary(message, kind = '') {
+    const el = document.getElementById('yomo-summary');
+    if (!el) return;
 
-    return box;
+    el.className = '';
+    if (kind) el.classList.add(`yomo-${kind}`);
+    el.textContent = message || '';
   }
 
-  function setStatus(msg) {
-    const el = document.getElementById('yomo-status');
-    if (el) el.textContent = msg;
+  function selectedIndexes() {
+    return Array.from(
+      document.querySelectorAll('#yomo-table tbody input.yomo-row-check:checked')
+    ).map(input => Number(input.dataset.idx));
+  }
+
+  function updateSubmitButton() {
+    const button = document.getElementById('yomo-submit');
+    if (!button) return;
+
+    const count = selectedIndexes().length;
+    button.disabled = count === 0;
+    button.textContent = count ? `Submit selected (${count})` : 'Submit selected';
   }
 
   function render(rows) {
-    const wrap = document.getElementById('yomo-table');
+    const wrap = document.getElementById('yomo-table-wrap');
     if (!wrap) return;
 
+    if (!rows.length) {
+      wrap.classList.remove('yomo-visible');
+      wrap.innerHTML = '';
+      updateSubmitButton();
+      return;
+    }
+
     wrap.innerHTML = `
-      <table class="tbl" style="width:100%;">
+      <table id="yomo-table" class="tbl">
         <thead>
           <tr>
-            <th>Medium</th>
-            <th>#</th>
-            <th>Recording</th>
-            <th>Alias</th>
-            <th>Status</th>
+            <th>
+              <input
+                id="yomo-check-all"
+                type="checkbox"
+                checked
+                title="Select all"
+              >
+            </th>
+            <th class="yomo-disc">Disc</th>
+            <th class="yomo-track">Track</th>
+            <th class="yomo-recording">Recording</th>
+            <th class="yomo-alias">Alias to add</th>
           </tr>
         </thead>
+
         <tbody>
-          ${rows.map((r, i) => `
-            <tr data-idx="${i}">
-              <td>${esc(r.mediumPosition)}</td>
-              <td>${esc(r.trackPosition)}</td>
+          ${rows.map((row, index) => `
+            <tr data-idx="${index}">
               <td>
-                <a href="${HOST}/recording/${r.recordingMbid}" target="_blank" rel="noreferrer noopener">
-                  ${esc(r.recordingTitle || '(recording)')}
-                </a>
-                <div style="opacity:.65; font-size:11px;">${esc(r.recordingMbid)}</div>
+                <input
+                  class="yomo-row-check"
+                  type="checkbox"
+                  data-idx="${index}"
+                  checked
+                >
+              </td>
+
+              <td class="yomo-disc">${esc(row.mediumPosition)}</td>
+              <td class="yomo-track">${esc(row.trackPosition)}</td>
+
+              <td class="yomo-recording">
+                <a
+                  href="${HOST}/recording/${esc(row.recordingMbid)}"
+                  target="_blank"
+                  rel="noreferrer noopener"
+                >${esc(row.recordingTitle || '(recording)')}</a>
+              </td>
+
+              <td class="yomo-alias">
+                <span>${esc(row.aliasName)}</span>
+                <div class="yomo-row-error"></div>
               </td>
-              <td>${esc(r.aliasName)}</td>
-              <td class="st" title="${esc(r.matchType)}"></td>
             </tr>
           `).join('')}
         </tbody>
       </table>
     `;
+
+    wrap.classList.add('yomo-visible');
+
+    const checkAll = wrap.querySelector('#yomo-check-all');
+    const rowChecks = Array.from(
+      wrap.querySelectorAll('input.yomo-row-check')
+    );
+
+    checkAll.addEventListener('change', () => {
+      for (const checkbox of rowChecks) {
+        if (!checkbox.disabled) {
+          checkbox.checked = checkAll.checked;
+        }
+      }
+      updateSubmitButton();
+    });
+
+    for (const checkbox of rowChecks) {
+      checkbox.addEventListener('change', () => {
+        const activeChecks = rowChecks.filter(cb => !cb.disabled);
+        const checkedCount = activeChecks.filter(cb => cb.checked).length;
+
+        checkAll.checked =
+          activeChecks.length > 0 &&
+          checkedCount === activeChecks.length;
+
+        checkAll.indeterminate =
+          checkedCount > 0 &&
+          checkedCount < activeChecks.length;
+
+        updateSubmitButton();
+      });
+    }
+
+    updateSubmitButton();
   }
 
-  function submitOneAlias({ recordingMbid, aliasName, locale, primary, typeId, sourceUrl }, onOk, onFail) {
+  function submitOneAlias(
+    {
+      recordingMbid,
+      aliasName,
+      locale,
+      primary,
+      typeId,
+      sourceUrl,
+    },
+    onOk,
+    onFail
+  ) {
     const postData = {
       name: edits.encodeName(aliasName),
       sort_name: edits.encodeName(aliasName),
-      locale: locale,
+      locale,
       primary_for_locale: primary ? 1 : 0,
       edit_note: editNote(sourceUrl),
     };
 
-    // Only send type_id if the user selected one (blank means default)
     if (typeId) {
       postData.type_id = typeId;
     }
@@ -208,96 +507,176 @@ if (!/^\/release\/[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/
 
   async function buildRows(sourceInput) {
     const srcMbid = parseReleaseMbid(sourceInput);
-    if (!srcMbid) throw new Error('Could not parse SOURCE release MBID from input.');
+
+    if (!srcMbid) {
+      throw new Error('Could not read a source release MBID.');
+    }
 
     const tgtMbid = currentReleaseMbid();
-    if (!tgtMbid) throw new Error('Could not parse TARGET release MBID from current page.');
 
-    const srcUrlNormalized = sourceInput.trim().startsWith('http')
+    if (!tgtMbid) {
+      throw new Error('Could not read the current release MBID.');
+    }
+
+    const sourceUrl = sourceInput.trim().startsWith('http')
       ? sourceInput.trim()
       : `${HOST}/release/${srcMbid}`;
 
-    setStatus('Fetching releases from WS…');
-    const [src, tgt] = await Promise.all([wsRelease(srcMbid), wsRelease(tgtMbid)]);
+    const [sourceRelease, targetRelease] = await Promise.all([
+      wsRelease(srcMbid),
+      wsRelease(tgtMbid),
+    ]);
 
-    const srcTracks = flattenTracks(src);
-    const tgtTracks = flattenTracks(tgt);
+    const sourceTracks = flattenTracks(sourceRelease);
+    const targetTracks = flattenTracks(targetRelease);
 
-    const byRec = mapByRecording(srcTracks);
-    const byPos = mapByPosition(srcTracks);
+    const byRecording = mapByRecording(sourceTracks);
+    const byPosition = mapByPosition(sourceTracks);
 
     const rows = [];
-    for (const t of tgtTracks) {
-      if (!t.recordingMbid) continue;
+    let unmatched = 0;
 
-      let aliasName = byRec.get(t.recordingMbid);
+    for (const track of targetTracks) {
+      if (!track.recordingMbid) {
+        unmatched += 1;
+        continue;
+      }
+
+      let aliasName = byRecording.get(track.recordingMbid);
       let matchType = 'recording';
 
-      // Fallback if recordings differ (not ideal but better than nothing)
       if (!aliasName) {
-        aliasName = byPos.get(`${t.mediumPosition}-${t.trackPosition}`);
+        aliasName = byPosition.get(
+          `${track.mediumPosition}-${track.trackPosition}`
+        );
         matchType = aliasName ? 'position' : 'none';
       }
 
-      if (!aliasName) continue;
+      if (!aliasName) {
+        unmatched += 1;
+        continue;
+      }
 
       rows.push({
-        mediumPosition: t.mediumPosition,
-        trackPosition: t.trackPosition,
-        recordingMbid: t.recordingMbid,
-        recordingTitle: t.recordingTitle,
+        mediumPosition: track.mediumPosition,
+        trackPosition: track.trackPosition,
+        recordingMbid: track.recordingMbid,
+        recordingTitle: track.recordingTitle,
         aliasName,
         matchType,
-        sourceUrl: srcUrlNormalized,
+        sourceUrl,
       });
     }
 
-    return rows;
+    return {
+      rows,
+      unmatched,
+      targetCount: targetTracks.length,
+    };
   }
 
   function run() {
     if (!helper.isUserLoggedIn()) return;
 
-    const ui = injectUI();
-    let lastRows = null;
+    const { panel } = injectLauncherAndPanel();
+
+    let lastRows = [];
+
+    panel.querySelector('#yomo-preview').addEventListener('click', async () => {
+      const previewButton = panel.querySelector('#yomo-preview');
+      const submitButton = panel.querySelector('#yomo-submit');
 
-    ui.querySelector('#yomo-preview').addEventListener('click', async () => {
       try {
-        const srcInput = ui.querySelector('#yomo-src').value;
-        lastRows = await buildRows(srcInput);
+        previewButton.disabled = true;
+        submitButton.disabled = true;
+
+        setSummary('Loading…');
+
+        const sourceInput = panel.querySelector('#yomo-src').value;
+        const result = await buildRows(sourceInput);
 
-        setStatus(`Preview ready. ${lastRows.length} aliases found to add.`);
+        lastRows = result.rows;
         render(lastRows);
 
-        ui.querySelector('#yomo-submit').disabled = lastRows.length === 0;
-      } catch (e) {
-        console.error(e);
-        setStatus(`Preview failed: ${e.message}`);
+        if (!lastRows.length) {
+          setSummary('No matching aliases found.', 'warning');
+          return;
+        }
+
+        if (result.unmatched) {
+          setSummary(
+            `${lastRows.length} aliases found. ${result.unmatched} track${result.unmatched === 1 ? '' : 's'} could not be matched.`,
+            'warning'
+          );
+        } else {
+          setSummary(`${lastRows.length} aliases found.`);
+        }
+
+        updateSubmitButton();
+      } catch (error) {
+        console.error(error);
+        lastRows = [];
+        render([]);
+        setSummary(error.message || 'Preview failed.', 'error');
+      } finally {
+        previewButton.disabled = false;
       }
     });
 
-    ui.querySelector('#yomo-submit').addEventListener('click', async () => {
-      if (!lastRows || !lastRows.length) return;
+    panel.querySelector('#yomo-submit').addEventListener('click', () => {
+      if (!lastRows.length) return;
+
+      const indexes = selectedIndexes();
+      if (!indexes.length) return;
+
+      const locale =
+        (panel.querySelector('#yomo-locale').value || 'en').trim() || 'en';
 
-      const locale = (ui.querySelector('#yomo-locale').value || 'en').trim() || 'en';
-      const primary = !!ui.querySelector('#yomo-primary').checked;
+      const primary = !!panel.querySelector('#yomo-primary').checked;
+      const typeId = panel.querySelector('#yomo-type')?.value || '';
 
-      const typeId = ui.querySelector('#yomo-type')?.value || '';
+      const submitButton = panel.querySelector('#yomo-submit');
+      const previewButton = panel.querySelector('#yomo-preview');
 
-      setStatus(`Submitting ${lastRows.length} alias edits…`);
-      const trs = Array.from(document.querySelectorAll('#yomo-table tbody tr'));
+      submitButton.disabled = true;
+      previewButton.disabled = true;
+
+      let position = 0;
+      let successCount = 0;
+      let failedCount = 0;
 
-      // Send sequentially to be gentle
-      let i = 0;
       const next = () => {
-        if (i >= lastRows.length) {
-          setStatus('Done.');
+        if (position >= indexes.length) {
+          previewButton.disabled = false;
+          updateSubmitButton();
+
+          if (failedCount) {
+            setSummary(
+              `Finished: ${successCount} added, ${failedCount} failed.`,
+              'error'
+            );
+          } else {
+            setSummary(`Done. ${successCount} aliases added.`);
+          }
+
           return;
         }
 
-        const row = lastRows[i];
-        const st = trs[i]?.querySelector('.st');
-        if (st) st.textContent = 'Sending…';
+        const rowIndex = indexes[position];
+        const row = lastRows[rowIndex];
+        const tr = document.querySelector(
+          `#yomo-table tbody tr[data-idx="${rowIndex}"]`
+        );
+        const checkbox = tr?.querySelector('.yomo-row-check');
+        const errorEl = tr?.querySelector('.yomo-row-error');
+
+        if (errorEl) {
+          errorEl.textContent = '';
+        }
+
+        setSummary(
+          `Submitting ${position + 1} of ${indexes.length}…`
+        );
 
         submitOneAlias(
           {
@@ -308,14 +687,34 @@ if (!/^\/release\/[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/
             typeId,
             sourceUrl: row.sourceUrl,
           },
-          (xhr) => {
-            if (st) st.textContent = `OK (HTTP ${xhr.status})`;
-            i += 1;
+          () => {
+            successCount += 1;
+
+            if (tr) {
+              tr.classList.add('yomo-done');
+              tr.classList.remove('yomo-failed');
+            }
+
+            if (checkbox) {
+              checkbox.checked = false;
+              checkbox.disabled = true;
+            }
+
+            position += 1;
             setTimeout(next, 400);
           },
-          (xhr) => {
-            if (st) st.textContent = `Error (HTTP ${xhr.status})`;
-            i += 1;
+          xhr => {
+            failedCount += 1;
+
+            if (tr) {
+              tr.classList.add('yomo-failed');
+            }
+
+            if (errorEl) {
+              errorEl.textContent = `Error: HTTP ${xhr.status}`;
+            }
+
+            position += 1;
             setTimeout(next, 400);
           }
         );

From 15736a7f952affb20d6544bf1dc4c00eba2dfccd Mon Sep 17 00:00:00 2001
From: YoGo9 <162524691+YoGo9@users.noreply.github.com>
Date: Tue, 15 Sep 2026 15:31:22 -0400
Subject: [PATCH 2/2] Update CopyRecordingsFromRelease.user.js

---
 CopyRecordingsFromRelease.user.js | 1013 ++++++++++++++++++++++-------
 1 file changed, 775 insertions(+), 238 deletions(-)

diff --git a/CopyRecordingsFromRelease.user.js b/CopyRecordingsFromRelease.user.js
index 482bbfe..0b88aef 100644
--- a/CopyRecordingsFromRelease.user.js
+++ b/CopyRecordingsFromRelease.user.js
@@ -1,8 +1,8 @@
 // ==UserScript==
 // @name         MB: Copy Recordings From Release
 // @namespace    https://github.com/YoGo9
-// @version      7/15/2026
-// @description  On the Recordings tab of the release editor, paste a release/medium MBID or URL to auto-assign recordings by track position. Supports copying a single medium (e.g. one disc of a box set). Also suggests existing releases from the same release group.
+// @version      2026.09.15
+// @description  Copy recording assignments from another MusicBrainz release or medium. Includes release-group suggestions.
 // @author       YoGo9
 // @homepage     https://github.com/YoGo9/Scripts
 // @updateURL    https://raw.githubusercontent.com/YoGo9/Scripts/main/CopyRecordingsFromRelease.user.js
@@ -15,202 +15,669 @@
 (function () {
     'use strict';
 
-    const MBID_RE        = /[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}/i;
-    const MEDIUM_URL_RE  = /\/medium\/([0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12})/i;
+    const MBID_RE = /[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}/i;
+    const MEDIUM_URL_RE = /\/medium\/([0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12})/i;
     const RELEASE_DISC_RE = /\/release\/([0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12})\/disc\/(\d+)/i;
+    const EDIT_RELEASE_RE = /\/release\/([0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12})\/edit/i;
 
-    // ── UI injection ──────────────────────────────────────────────────────────
+    const WS_MIN_INTERVAL_MS = 1100;
+    let lastWsRequestAt = 0;
+    let wsQueue = Promise.resolve();
+
+    let suggestionRequestId = 0;
+    let watchedRelease = null;
+    let releaseGroupSubscription = null;
+    let lastLoadedRgGid = null;
+    let cachedRgGid = null;
+    let cachedReleases = [];
+
+    function sleep(ms) {
+        return new Promise(resolve => setTimeout(resolve, ms));
+    }
+
+    function wsFetchJson(url) {
+        const task = wsQueue.then(async function () {
+            const elapsed = Date.now() - lastWsRequestAt;
+            if (elapsed < WS_MIN_INTERVAL_MS) {
+                await sleep(WS_MIN_INTERVAL_MS - elapsed);
+            }
+
+            lastWsRequestAt = Date.now();
+
+            const response = await fetch(url, {
+                headers: { Accept: 'application/json' },
+                credentials: 'same-origin',
+            });
+
+            if (!response.ok) {
+                throw new Error('HTTP ' + response.status);
+            }
+
+            return response.json();
+        });
+
+        wsQueue = task.catch(function () {});
+        return task;
+    }
+
+    function escapeHtml(value) {
+        return String(value ?? '').replace(/[&<>"']/g, function (char) {
+            return {
+                '&': '&amp;',
+                '<': '&lt;',
+                '>': '&gt;',
+                '"': '&quot;',
+                "'": '&#39;',
+            }[char];
+        });
+    }
+
+    function injectStyles() {
+        if (document.getElementById('cfr-styles')) return;
+
+        const style = document.createElement('style');
+        style.id = 'cfr-styles';
+        style.textContent = `
+            #cfr-widget {
+                margin: 12px 0 0;
+                padding: 9px 10px;
+                border: 1px solid rgba(127,127,127,.32);
+                border-radius: 4px;
+                background: rgba(127,127,127,.045);
+                color: inherit;
+                font-size: 13px;
+                clear: both;
+            }
+
+            #cfr-widget * {
+                box-sizing: border-box;
+            }
+
+            #cfr-widget .cfr-title {
+                margin-bottom: 7px;
+                font-weight: bold;
+            }
+
+            #cfr-widget .cfr-rg-header {
+                display: flex;
+                align-items: center;
+                gap: 8px;
+                margin-bottom: 5px;
+            }
+
+            #cfr-widget .cfr-rg-title {
+                font-weight: bold;
+                font-size: 12px;
+            }
+
+            #cfr-widget .cfr-rg-state {
+                opacity: .68;
+                font-size: 12px;
+            }
+
+            #cfr-refresh {
+                margin-left: auto;
+            }
+
+            #cfr-suggestions {
+                display: none;
+                margin-bottom: 9px;
+            }
+
+            #cfr-suggestions.cfr-visible {
+                display: block;
+            }
+
+            #cfr-suggestion-list {
+                display: grid;
+                gap: 3px;
+                max-height: 290px;
+                overflow: auto;
+            }
+
+            #cfr-widget .cfr-release {
+                display: flex;
+                align-items: center;
+                gap: 8px;
+                padding: 5px 6px;
+                border: 1px solid rgba(127,127,127,.22);
+                border-radius: 3px;
+                background: rgba(127,127,127,.025);
+            }
+
+            #cfr-widget .cfr-release-info {
+                min-width: 0;
+                flex: 1 1 auto;
+            }
+
+            #cfr-widget .cfr-release-title {
+                font-weight: bold;
+                line-height: 1.3;
+            }
+
+            #cfr-widget .cfr-release-meta {
+                margin-top: 1px;
+                opacity: .72;
+                font-size: 11px;
+                line-height: 1.35;
+            }
+
+            #cfr-widget .cfr-layout {
+                flex: 0 0 auto;
+                font-size: 11px;
+                white-space: nowrap;
+                opacity: .72;
+            }
+
+            #cfr-widget .cfr-layout.cfr-same {
+                opacity: 1;
+            }
+
+            #cfr-widget .cfr-copy-button {
+                flex: 0 0 auto;
+                margin: 0;
+                white-space: nowrap;
+            }
+
+            #cfr-widget .cfr-manual {
+                display: flex;
+                align-items: center;
+                gap: 6px;
+                flex-wrap: wrap;
+                padding-top: 8px;
+                border-top: 1px solid rgba(127,127,127,.18);
+            }
+
+            #cfr-input {
+                flex: 1 1 420px;
+                min-width: 220px;
+            }
+
+            #cfr-target-chooser {
+                display: none;
+                margin-top: 8px;
+            }
+
+            #cfr-target-chooser.cfr-visible {
+                display: block;
+            }
+
+            #cfr-widget .cfr-target-title {
+                margin-bottom: 4px;
+                font-weight: bold;
+                font-size: 12px;
+            }
+
+            #cfr-widget .cfr-target-button {
+                display: block;
+                width: 100%;
+                margin: 0 0 3px;
+                text-align: left;
+            }
+
+            #cfr-status {
+                min-height: 18px;
+                margin-top: 6px;
+                opacity: .78;
+            }
+
+            #cfr-status.cfr-error {
+                color: #a40000;
+                opacity: 1;
+            }
+
+            #cfr-status.cfr-success {
+                color: #087a08;
+                opacity: 1;
+            }
+
+            @media (prefers-color-scheme: dark) {
+                #cfr-widget {
+                    border-color: rgba(220,220,220,.25);
+                    background: rgba(255,255,255,.025);
+                }
+
+                #cfr-widget .cfr-release {
+                    border-color: rgba(220,220,220,.16);
+                    background: rgba(255,255,255,.02);
+                }
+
+                #cfr-widget .cfr-manual {
+                    border-top-color: rgba(220,220,220,.14);
+                }
+
+                #cfr-status.cfr-error {
+                    color: #ff9b9b;
+                }
+
+                #cfr-status.cfr-success {
+                    color: #8fd58f;
+                }
+            }
+
+            @media (max-width: 720px) {
+                #cfr-widget .cfr-release {
+                    align-items: flex-start;
+                    flex-wrap: wrap;
+                }
+
+                #cfr-widget .cfr-release-info {
+                    flex-basis: calc(100% - 95px);
+                }
+
+                #cfr-widget .cfr-layout {
+                    margin-left: 0;
+                }
+            }
+        `;
+
+        document.head.appendChild(style);
+    }
 
     function injectUI() {
         if (document.getElementById('cfr-widget')) return;
+
         const anchor = document.querySelector('.changes');
         if (!anchor) return;
 
+        injectStyles();
+
         const wrapper = document.createElement('div');
         wrapper.id = 'cfr-widget';
-        wrapper.style.cssText = 'margin:12px 0 0 0;padding:10px 12px;background:#f0f4ff;border:1px solid #99a8d0;border-radius:4px;font-size:13px;clear:both;';
-
-        wrapper.innerHTML =
-            '<strong style="display:block;margin-bottom:6px;">&#x1F4CB; Copy recordings from another release or medium</strong>' +
-            // Suggestions section (hidden until populated)
-            '<div id="cfr-suggestions" style="display:none;margin-bottom:8px;">' +
-                '<div style="margin-bottom:4px;font-weight:bold;font-size:12px;color:#444;">Releases in this release group:</div>' +
-                '<div id="cfr-suggestion-list"></div>' +
-            '</div>' +
-            // Manual paste section
-            '<div style="display:flex;gap:6px;align-items:center;flex-wrap:wrap;">' +
-                '<input id="cfr-input" type="text" placeholder="Or paste a release/medium MBID or URL\u2026"' +
-                ' style="flex:1;min-width:220px;padding:4px 6px;font-size:13px;border:1px solid #aaa;border-radius:3px;" />' +
-                '<button id="cfr-btn" type="button"' +
-                ' style="padding:4px 10px;font-size:13px;cursor:pointer;border-radius:3px;border:1px solid #888;background:#e8eaf0;">' +
-                'Apply</button>' +
-            '</div>' +
-            // Target-medium chooser (hidden until needed)
-            '<div id="cfr-target-chooser" style="display:none;margin-top:8px;"></div>' +
-            '<div id="cfr-status" style="margin-top:5px;min-height:16px;font-style:italic;color:#555;"></div>';
+        wrapper.innerHTML = `
+            <div class="cfr-title">Copy recordings from another release or medium</div>
+
+            <div id="cfr-suggestions">
+                <div class="cfr-rg-header">
+                    <span id="cfr-rg-title" class="cfr-rg-title">Releases in this release group</span>
+                    <span id="cfr-rg-state" class="cfr-rg-state"></span>
+                    <button id="cfr-refresh" class="styled-button" type="button">Refresh</button>
+                </div>
+                <div id="cfr-suggestion-list"></div>
+            </div>
+
+            <div class="cfr-manual">
+                <input id="cfr-input" type="text" placeholder="Paste a release/medium MBID or URL…" autocomplete="off">
+                <button id="cfr-btn" class="styled-button" type="button">Apply</button>
+            </div>
+
+            <div id="cfr-target-chooser"></div>
+            <div id="cfr-status" role="status" aria-live="polite"></div>
+        `;
 
         anchor.appendChild(wrapper);
 
-        document.getElementById('cfr-btn').addEventListener('click', onApplyFromInput);
-        document.getElementById('cfr-input').addEventListener('keydown', function (e) {
-            if (e.key === 'Enter') onApplyFromInput();
+        wrapper.querySelector('#cfr-btn').addEventListener('click', onApplyFromInput);
+        wrapper.querySelector('#cfr-input').addEventListener('keydown', function (event) {
+            if (event.key === 'Enter') {
+                event.preventDefault();
+                onApplyFromInput();
+            }
+        });
+
+        wrapper.querySelector('#cfr-refresh').addEventListener('click', function () {
+            loadRGSuggestions(true);
         });
 
-        // Try to load RG suggestions
-        loadRGSuggestions();
+        setupReleaseGroupWatcher();
     }
 
-    // ── Release group suggestions ─────────────────────────────────────────────
+    function currentEditedReleaseMbid() {
+        const match = location.pathname.match(EDIT_RELEASE_RE);
+        return match ? match[1].toLowerCase() : null;
+    }
 
-    function loadRGSuggestions() {
-        var vm = getReleaseEditorVM();
-        if (!vm) return;
+    function getTargetLayout() {
+        const vm = getReleaseEditorVM();
+        if (!vm) return [];
 
-        var release = vm.rootField.release();
-        if (!release) return;
+        const release = vm.rootField.release();
+        if (!release) return [];
 
-        var rg = release.releaseGroup();
-        var rgGid = rg && rg.gid;
-        if (!rgGid) {
-            // RG may not be set yet; subscribe and retry once
-            release.releaseGroup.subscribe(function (newRG) {
-                if (newRG && newRG.gid) fetchAndRenderSuggestions(newRG.gid);
-            });
+        return release.mediums().map(function (medium) {
+            return medium.tracks().length;
+        });
+    }
+
+    function getSourceLayout(release) {
+        return (release.media || []).map(function (medium) {
+            return Number(medium['track-count'] || 0);
+        });
+    }
+
+    function layoutsEqual(a, b) {
+        return a.length === b.length && a.every(function (value, index) {
+            return value === b[index];
+        });
+    }
+
+    function formatLayout(layout) {
+        return layout.filter(Boolean).join(' + ');
+    }
+
+    function setupReleaseGroupWatcher() {
+        const vm = getReleaseEditorVM();
+        if (!vm) {
+            setTimeout(setupReleaseGroupWatcher, 250);
             return;
         }
 
-        fetchAndRenderSuggestions(rgGid);
+        const release = vm.rootField.release();
+        if (!release || typeof release.releaseGroup !== 'function') {
+            setTimeout(setupReleaseGroupWatcher, 250);
+            return;
+        }
+
+        if (release === watchedRelease) {
+            if (!lastLoadedRgGid) loadRGSuggestions(false);
+            return;
+        }
+
+        if (releaseGroupSubscription && typeof releaseGroupSubscription.dispose === 'function') {
+            releaseGroupSubscription.dispose();
+        }
+
+        watchedRelease = release;
+        releaseGroupSubscription = release.releaseGroup.subscribe(function (newRg) {
+            const newGid = newRg && newRg.gid ? newRg.gid : null;
+            if (newGid !== lastLoadedRgGid) {
+                loadRGSuggestions(false);
+            }
+        });
+
+        loadRGSuggestions(false);
     }
 
-    function fetchAndRenderSuggestions(rgGid) {
-        var url = '/ws/2/release?release-group=' + rgGid + '&inc=artist-credits+media+labels+release-groups&fmt=json';
-        fetch(url)
-            .then(function (r) { return r.ok ? r.json() : Promise.reject('HTTP ' + r.status); })
-            .then(function (data) {
-                var releases = (data.releases || []);
-                if (!releases.length) return;
-                renderSuggestions(releases);
-            })
-            .catch(function (e) { console.warn('[CFR] RG fetch failed:', e); });
+    function getCurrentReleaseGroupGid() {
+        const vm = getReleaseEditorVM();
+        if (!vm) return null;
+
+        const release = vm.rootField.release();
+        if (!release || typeof release.releaseGroup !== 'function') return null;
+
+        const rg = release.releaseGroup();
+        return rg && rg.gid ? rg.gid : null;
     }
 
-    function renderSuggestions(releases) {
-        var list = document.getElementById('cfr-suggestion-list');
-        var section = document.getElementById('cfr-suggestions');
-        if (!list || !section) return;
+    function clearSuggestions(message) {
+        const section = document.getElementById('cfr-suggestions');
+        const list = document.getElementById('cfr-suggestion-list');
+        const title = document.getElementById('cfr-rg-title');
+        const state = document.getElementById('cfr-rg-state');
+
+        if (list) list.innerHTML = '';
+        if (title) title.textContent = 'Releases in this release group';
+        if (state) state.textContent = message || '';
+        if (section) section.classList.remove('cfr-visible');
+    }
+
+    async function loadRGSuggestions(force) {
+        const rgGid = getCurrentReleaseGroupGid();
+
+        if (!rgGid) {
+            lastLoadedRgGid = null;
+            cachedRgGid = null;
+            cachedReleases = [];
+            clearSuggestions();
+            return;
+        }
+
+        if (!force && rgGid === lastLoadedRgGid) {
+            if (cachedRgGid === rgGid) {
+                showSuggestionResults(cachedReleases);
+            }
+            return;
+        }
+
+        lastLoadedRgGid = rgGid;
+        const requestId = ++suggestionRequestId;
+
+        const section = document.getElementById('cfr-suggestions');
+        const list = document.getElementById('cfr-suggestion-list');
+        const title = document.getElementById('cfr-rg-title');
+        const state = document.getElementById('cfr-rg-state');
+        const refresh = document.getElementById('cfr-refresh');
 
+        if (!section || !list || !title || !state || !refresh) return;
+
+        section.classList.add('cfr-visible');
         list.innerHTML = '';
+        title.textContent = 'Releases in this release group';
+        state.textContent = 'Loading…';
+        refresh.disabled = true;
 
-        releases.forEach(function (rel) {
-            var mbid = rel.id;
-            var title = rel.title || '(untitled)';
-
-            // Build a human-readable descriptor: format · tracks · date · country
-            var media = rel.media || [];
-            var formats = [];
-            var trackCounts = [];
-            media.forEach(function (m) {
-                if (m.format) formats.push(m.format);
-                if (m['track-count']) trackCounts.push(m['track-count']);
-            });
-            var formatStr = formats.length ? formats.join('+') : '';
-            var trackStr = trackCounts.length ? trackCounts.join('+') + ' tracks' : '';
-
-            var events = rel['release-events'] || [];
-            var dates = events.map(function (e) { return e.date; }).filter(Boolean);
-            var countries = [];
-            events.forEach(function (e) {
-                var codes = e.area && e.area['iso-3166-1-codes'];
-                if (codes) codes.forEach(function (c) { countries.push(c); });
-            });
-            var dateStr = dates.length ? dates[0] : '';
-            var countryStr = [...new Set(countries)].join(', ');
+        try {
+            const releases = [];
+            const seen = new Set();
+            let offset = 0;
+            let total = null;
 
-            var meta = [formatStr, trackStr, dateStr, countryStr].filter(Boolean).join(' · ');
+            while (total === null || offset < total) {
+                if (requestId !== suggestionRequestId) return;
 
-            var btn = document.createElement('button');
-            btn.type = 'button';
-            btn.style.cssText = 'display:block;width:100%;text-align:left;margin-bottom:3px;padding:4px 7px;font-size:12px;cursor:pointer;border:1px solid #bbb;border-radius:3px;background:#fff;';
-            btn.innerHTML = '<strong>' + escapeHtml(title) + '</strong>' +
-                (meta ? ' <span style="color:#666;font-weight:normal;">' + escapeHtml(meta) + '</span>' : '');
+                const url = '/ws/2/release?release-group=' + encodeURIComponent(rgGid) +
+                    '&inc=artist-credits+media+labels+release-groups&fmt=json&limit=100&offset=' + offset;
 
-            btn.addEventListener('click', function () {
-                applyFromMBID(mbid);
-            });
-            list.appendChild(btn);
-        });
+                const data = await wsFetchJson(url);
+                if (requestId !== suggestionRequestId) return;
+
+                const page = data.releases || [];
+                if (total === null) {
+                    total = Number(data['release-count'] ?? page.length);
+                }
+
+                for (const release of page) {
+                    if (release.id && !seen.has(release.id)) {
+                        seen.add(release.id);
+                        releases.push(release);
+                    }
+                }
+
+                offset += page.length;
+                state.textContent = total > page.length
+                    ? Math.min(offset, total) + ' / ' + total
+                    : 'Loading…';
 
-        section.style.display = 'block';
+                if (!page.length) break;
+            }
+
+            if (requestId !== suggestionRequestId) return;
+
+            const currentMbid = currentEditedReleaseMbid();
+            const filtered = currentMbid
+                ? releases.filter(function (release) {
+                    return String(release.id || '').toLowerCase() !== currentMbid;
+                })
+                : releases;
+
+            cachedRgGid = rgGid;
+            cachedReleases = filtered;
+            showSuggestionResults(filtered);
+        } catch (error) {
+            if (requestId !== suggestionRequestId) return;
+            console.warn('[CFR] RG fetch failed:', error);
+            list.innerHTML = '';
+            state.textContent = 'Could not load releases.';
+        } finally {
+            if (requestId === suggestionRequestId) {
+                refresh.disabled = false;
+            }
+        }
     }
 
-    function escapeHtml(s) {
-        return String(s).replace(/&/g,'&amp;').replace(/</g,'&lt;').replace(/>/g,'&gt;').replace(/"/g,'&quot;');
+    function showSuggestionResults(releases) {
+        const section = document.getElementById('cfr-suggestions');
+        const title = document.getElementById('cfr-rg-title');
+        const state = document.getElementById('cfr-rg-state');
+
+        if (section) section.classList.add('cfr-visible');
+        if (title) title.textContent = 'Releases in this release group (' + releases.length + ')';
+        if (state) state.textContent = '';
+        renderSuggestions(releases);
     }
 
-    // ── Apply from manual input ───────────────────────────────────────────────
+    function releaseMeta(release) {
+        const media = release.media || [];
+        const formats = [];
+        const trackCounts = [];
+
+        for (const medium of media) {
+            if (medium.format) formats.push(medium.format);
+            if (medium['track-count']) trackCounts.push(medium['track-count']);
+        }
+
+        const formatStr = formats.length ? formats.join(' + ') : '';
+        const trackStr = trackCounts.length ? trackCounts.join(' + ') + ' tracks' : '';
+
+        const events = release['release-events'] || [];
+        const dates = events.map(function (event) { return event.date; }).filter(Boolean);
+        const countries = [];
+
+        for (const event of events) {
+            const codes = event.area && event.area['iso-3166-1-codes'];
+            if (codes) {
+                for (const code of codes) countries.push(code);
+            }
+        }
+
+        const labelBits = [];
+        for (const info of (release['label-info'] || [])) {
+            const name = info.label && info.label.name ? info.label.name : '';
+            const cat = info['catalog-number'] || '';
+            const bit = [name, cat].filter(Boolean).join(' ');
+            if (bit) labelBits.push(bit);
+        }
+
+        return [
+            formatStr,
+            trackStr,
+            dates[0] || '',
+            [...new Set(countries)].join(', '),
+            [...new Set(labelBits)].join(' / '),
+        ].filter(Boolean).join(' · ');
+    }
+
+    function renderSuggestions(releases) {
+        const list = document.getElementById('cfr-suggestion-list');
+        if (!list) return;
+
+        list.innerHTML = '';
+
+        if (!releases.length) {
+            list.textContent = 'No other releases found.';
+            return;
+        }
+
+        const targetLayout = getTargetLayout();
+
+        for (const release of releases) {
+            const sourceLayout = getSourceLayout(release);
+            const sameLayout = targetLayout.length > 0 && layoutsEqual(sourceLayout, targetLayout);
+
+            const row = document.createElement('div');
+            row.className = 'cfr-release';
+
+            const info = document.createElement('div');
+            info.className = 'cfr-release-info';
+            info.innerHTML =
+                '<div class="cfr-release-title">' + escapeHtml(release.title || '(untitled)') + '</div>' +
+                '<div class="cfr-release-meta">' + escapeHtml(releaseMeta(release)) + '</div>';
+
+            const layout = document.createElement('span');
+            layout.className = 'cfr-layout' + (sameLayout ? ' cfr-same' : '');
+            layout.textContent = sameLayout
+                ? 'same layout'
+                : (formatLayout(sourceLayout) ? formatLayout(sourceLayout) : 'different layout');
+
+            const button = document.createElement('button');
+            button.type = 'button';
+            button.className = 'styled-button cfr-copy-button';
+            button.textContent = 'Copy recordings';
+            button.addEventListener('click', function () {
+                applyFromMBID(release.id);
+            });
+
+            row.appendChild(info);
+            row.appendChild(layout);
+            row.appendChild(button);
+            list.appendChild(row);
+        }
+    }
 
     function onApplyFromInput() {
         clearTargetChooser();
-        var raw = (document.getElementById('cfr-input') || {}).value;
-        if (!raw || !raw.trim()) { setStatus('Please paste a release or medium MBID or URL.', '#a00'); return; }
-        raw = raw.trim();
 
-        // 1) Medium permalink: /medium/{mbid}
-        var mediumMatch = raw.match(MEDIUM_URL_RE);
+        const input = document.getElementById('cfr-input');
+        const raw = input ? input.value.trim() : '';
+
+        if (!raw) {
+            setStatus('Paste a release or medium MBID or URL.', 'error');
+            return;
+        }
+
+        const mediumMatch = raw.match(MEDIUM_URL_RE);
         if (mediumMatch) {
             resolveMediumAndApply(mediumMatch[1]);
             return;
         }
 
-        // 2) Release disc view: /release/{mbid}/disc/{n}
-        var discMatch = raw.match(RELEASE_DISC_RE);
+        const discMatch = raw.match(RELEASE_DISC_RE);
         if (discMatch) {
             applyFromMBID(discMatch[1], parseInt(discMatch[2], 10));
             return;
         }
 
-        // 3) Plain release MBID or release URL
-        var match = raw.match(MBID_RE);
-        if (!match) { setStatus('Could not find a valid MBID in the input.', '#a00'); return; }
+        const match = raw.match(MBID_RE);
+        if (!match) {
+            setStatus('Could not find a valid MBID in the input.', 'error');
+            return;
+        }
+
         applyFromMBID(match[0]);
     }
 
-    // ── Medium MBID resolution ────────────────────────────────────────────────
-    // There is no /ws/2/medium endpoint, but /medium/{mbid} on the website
-    // redirects (same-origin) to /release/{release-mbid}/disc/{position},
-    // so we follow the redirect and parse the final URL.
-
     function resolveMediumAndApply(mediumMbid) {
-        setStatus('Resolving medium ' + mediumMbid + '\u2026');
+        setStatus('Resolving medium…');
+
         fetch('/medium/' + mediumMbid, { redirect: 'follow' })
-            .then(function (r) {
-                if (!r.ok) throw new Error('HTTP ' + r.status);
-                var finalUrl = r.url || '';
-                var discMatch = finalUrl.match(RELEASE_DISC_RE);
+            .then(function (response) {
+                if (!response.ok) throw new Error('HTTP ' + response.status);
+
+                const finalUrl = response.url || '';
+                const discMatch = finalUrl.match(RELEASE_DISC_RE);
+
                 if (discMatch) {
-                    return { releaseMbid: discMatch[1], mediumPos: parseInt(discMatch[2], 10) };
+                    return {
+                        releaseMbid: discMatch[1],
+                        mediumPos: parseInt(discMatch[2], 10),
+                    };
                 }
-                // Fallback: redirect landed on a plain release URL (e.g. single-medium
-                // release, or fragment-based anchor was stripped). Try #disc{n} fragment,
-                // else assume medium 1.
-                var relMatch = finalUrl.match(/\/release\/([0-9a-f-]{36})/i);
-                if (!relMatch) throw new Error('Could not resolve medium to a release (landed on ' + finalUrl + ')');
-                var fragMatch = finalUrl.match(/#disc(\d+)/i);
-                return { releaseMbid: relMatch[1], mediumPos: fragMatch ? parseInt(fragMatch[1], 10) : 1 };
+
+                const releaseMatch = finalUrl.match(/\/release\/([0-9a-f-]{36})/i);
+                if (!releaseMatch) {
+                    throw new Error('Could not resolve medium to a release.');
+                }
+
+                const fragmentMatch = finalUrl.match(/#disc(\d+)/i);
+                return {
+                    releaseMbid: releaseMatch[1],
+                    mediumPos: fragmentMatch ? parseInt(fragmentMatch[1], 10) : 1,
+                };
             })
             .then(function (info) {
                 applyFromMBID(info.releaseMbid, info.mediumPos);
             })
-            .catch(function (err) { setStatus('Error resolving medium: ' + err.message, '#a00'); });
+            .catch(function (error) {
+                setStatus('Error resolving medium: ' + error.message, 'error');
+            });
     }
 
     function applyFromMBID(mbid, sourceMediumPos) {
-        setStatus('Fetching release ' + mbid + (sourceMediumPos ? ' (medium ' + sourceMediumPos + ')' : '') + '\u2026');
-        fetch('/ws/2/release/' + mbid + '?inc=recordings+artist-credits&fmt=json')
-            .then(function (r) {
-                if (!r.ok) throw new Error('HTTP ' + r.status);
-                return r.json();
-            })
+        setStatus('Fetching release…');
+
+        const url = '/ws/2/release/' + mbid + '?inc=recordings+artist-credits&fmt=json';
+
+        wsFetchJson(url)
             .then(function (data) {
                 if (sourceMediumPos) {
                     applyRecordingsFromMedium(data, sourceMediumPos);
@@ -218,36 +685,46 @@
                     applyRecordings(data);
                 }
             })
-            .catch(function (err) { setStatus('Error fetching release: ' + err.message, '#a00'); });
+            .catch(function (error) {
+                setStatus('Error fetching release: ' + error.message, 'error');
+            });
     }
 
-    // ── Helpers ───────────────────────────────────────────────────────────────
+    function setStatus(message, kind) {
+        const element = document.getElementById('cfr-status');
+        if (!element) return;
 
-    function setStatus(msg, color) {
-        var el = document.getElementById('cfr-status');
-        if (el) { el.textContent = msg; el.style.color = color || '#555'; }
+        element.className = '';
+        if (kind) element.classList.add('cfr-' + kind);
+        element.textContent = message || '';
     }
 
     function clearTargetChooser() {
-        var el = document.getElementById('cfr-target-chooser');
-        if (el) { el.style.display = 'none'; el.innerHTML = ''; }
+        const chooser = document.getElementById('cfr-target-chooser');
+        if (!chooser) return;
+
+        chooser.classList.remove('cfr-visible');
+        chooser.innerHTML = '';
     }
 
     function buildRecordingEntity(recData) {
-        var names = (recData['artist-credit'] || [])
-            .filter(function (ac) { return ac && typeof ac === 'object' && ac.artist; })
-            .map(function (ac) {
+        const names = (recData['artist-credit'] || [])
+            .filter(function (credit) {
+                return credit && typeof credit === 'object' && credit.artist;
+            })
+            .map(function (credit) {
                 return {
-                    name: ac.name || ac.artist.name || '',
-                    joinPhrase: ac.joinphrase || '',
+                    name: credit.name || credit.artist.name || '',
+                    joinPhrase: credit.joinphrase || '',
                     artist: {
-                        gid: ac.artist.id,
-                        name: ac.artist.name || '',
-                        sortName: ac.artist['sort-name'] || '',
+                        gid: credit.artist.id,
+                        name: credit.artist.name || '',
+                        sortName: credit.artist['sort-name'] || '',
                         entityType: 'artist',
                     },
                 };
             });
+
         return MB.entity({
             gid: recData.id,
             name: recData.title,
@@ -257,176 +734,236 @@
     }
 
     function assignToTracks(tracks, trackMapByPos) {
-        var applied = 0, skipped = 0, notFound = 0;
+        let applied = 0;
+        let skipped = 0;
+        let notFound = 0;
+
         tracks.forEach(function (track) {
-            var recData = trackMapByPos.get(track.position());
-            if (!recData) { notFound++; return; }
-            if (track.hasExistingRecording() && track.recording() && track.recording().gid === recData.id) {
-                skipped++; return;
+            const recData = trackMapByPos.get(track.position());
+
+            if (!recData) {
+                notFound += 1;
+                return;
             }
+
+            if (
+                track.hasExistingRecording() &&
+                track.recording() &&
+                track.recording().gid === recData.id
+            ) {
+                skipped += 1;
+                return;
+            }
+
             try {
                 track.recording(buildRecordingEntity(recData));
-                applied++;
-            } catch (e) {
-                console.error('[CFR] Error on track', track.position(), e);
-                notFound++;
+                applied += 1;
+            } catch (error) {
+                console.error('[CFR] Error on track', track.position(), error);
+                notFound += 1;
             }
         });
+
         return { applied: applied, skipped: skipped, notFound: notFound };
     }
 
-    function reportResult(res, suffix) {
-        var color = res.applied > 0 ? '#007700' : '#a00';
-        setStatus('Done: ' + res.applied + ' applied, ' + res.skipped + ' already set, ' +
-                  res.notFound + ' not matched' + (suffix ? ' ' + suffix : '') + '.', color);
-    }
+    function reportResult(result, suffix) {
+        const message =
+            'Done: ' + result.applied + ' applied, ' +
+            result.skipped + ' already set, ' +
+            result.notFound + ' not matched' +
+            (suffix ? ' ' + suffix : '') + '.';
 
-    // ── Apply recordings (whole release, medium:track position match) ────────
+        setStatus(message, result.applied > 0 ? 'success' : '');
+    }
 
     function applyRecordings(releaseData) {
-        var trackMap = new Map();
+        const trackMap = new Map();
+
         (releaseData.media || []).forEach(function (medium) {
-            var medPos = medium.position;
+            const mediumPos = medium.position;
+
             (medium.tracks || []).forEach(function (track) {
                 if (track.recording) {
-                    trackMap.set(medPos + ':' + track.position, track.recording);
+                    trackMap.set(mediumPos + ':' + track.position, track.recording);
                 }
             });
         });
 
-        if (!trackMap.size) { setStatus('No recordings found in that release.', '#a00'); return; }
+        if (!trackMap.size) {
+            setStatus('No recordings found in that release.', 'error');
+            return;
+        }
 
-        var vm = getReleaseEditorVM();
-        if (!vm) { setStatus('Could not access the release editor view-model.', '#a00'); return; }
+        const vm = getReleaseEditorVM();
+        if (!vm) {
+            setStatus('Could not access the release editor.', 'error');
+            return;
+        }
 
-        var release = vm.rootField.release();
-        if (!release) { setStatus('No release loaded in editor.', '#a00'); return; }
+        const release = vm.rootField.release();
+        if (!release) {
+            setStatus('No release loaded in editor.', 'error');
+            return;
+        }
 
-        var total = { applied: 0, skipped: 0, notFound: 0 };
+        const total = { applied: 0, skipped: 0, notFound: 0 };
 
         release.mediums().forEach(function (medium) {
-            var medPos = medium.position();
-            var perMedium = new Map();
-            trackMap.forEach(function (rec, key) {
-                var parts = key.split(':');
-                if (parseInt(parts[0], 10) === medPos) perMedium.set(parseInt(parts[1], 10), rec);
+            const mediumPos = medium.position();
+            const perMedium = new Map();
+
+            trackMap.forEach(function (recording, key) {
+                const parts = key.split(':');
+                if (parseInt(parts[0], 10) === mediumPos) {
+                    perMedium.set(parseInt(parts[1], 10), recording);
+                }
             });
-            var res = assignToTracks(medium.tracks(), perMedium);
-            total.applied += res.applied;
-            total.skipped += res.skipped;
-            total.notFound += res.notFound;
+
+            const result = assignToTracks(medium.tracks(), perMedium);
+            total.applied += result.applied;
+            total.skipped += result.skipped;
+            total.notFound += result.notFound;
         });
 
         reportResult(total);
     }
 
-    // ── Apply recordings from a single source medium ─────────────────────────
-
     function applyRecordingsFromMedium(releaseData, sourceMediumPos) {
-        var sourceMedium = (releaseData.media || []).find(function (m) {
-            return m.position === sourceMediumPos;
+        const sourceMedium = (releaseData.media || []).find(function (medium) {
+            return medium.position === sourceMediumPos;
         });
+
         if (!sourceMedium) {
-            setStatus('Medium ' + sourceMediumPos + ' not found on that release.', '#a00');
+            setStatus('Medium ' + sourceMediumPos + ' not found on that release.', 'error');
             return;
         }
 
-        var trackMap = new Map();
+        const trackMap = new Map();
         (sourceMedium.tracks || []).forEach(function (track) {
-            if (track.recording) trackMap.set(track.position, track.recording);
+            if (track.recording) {
+                trackMap.set(track.position, track.recording);
+            }
         });
 
         if (!trackMap.size) {
-            setStatus('No recordings found on that medium.', '#a00');
+            setStatus('No recordings found on that medium.', 'error');
             return;
         }
 
-        var vm = getReleaseEditorVM();
-        if (!vm) { setStatus('Could not access the release editor view-model.', '#a00'); return; }
+        const vm = getReleaseEditorVM();
+        if (!vm) {
+            setStatus('Could not access the release editor.', 'error');
+            return;
+        }
 
-        var release = vm.rootField.release();
-        if (!release) { setStatus('No release loaded in editor.', '#a00'); return; }
+        const release = vm.rootField.release();
+        if (!release) {
+            setStatus('No release loaded in editor.', 'error');
+            return;
+        }
 
-        var targetMediums = release.mediums();
-        var sourceLabel = 'medium ' + sourceMediumPos +
-            (sourceMedium.title ? ' \u201C' + sourceMedium.title + '\u201D' : '') +
+        const targetMediums = release.mediums();
+        const sourceLabel =
+            'medium ' + sourceMediumPos +
+            (sourceMedium.title ? ' “' + sourceMedium.title + '”' : '') +
             ' (' + trackMap.size + ' tracks)';
 
-        // One target medium: just apply.
         if (targetMediums.length === 1) {
-            reportResult(assignToTracks(targetMediums[0].tracks(), trackMap), 'from source ' + sourceLabel);
+            reportResult(
+                assignToTracks(targetMediums[0].tracks(), trackMap),
+                'from source ' + sourceLabel
+            );
             return;
         }
 
-        // Multiple target mediums: if exactly one has a matching track count, use it.
-        var matching = targetMediums.filter(function (m) {
-            return m.tracks().length === trackMap.size;
+        const matching = targetMediums.filter(function (medium) {
+            return medium.tracks().length === trackMap.size;
         });
+
         if (matching.length === 1) {
-            var res = assignToTracks(matching[0].tracks(), trackMap);
-            reportResult(res, 'from source ' + sourceLabel + ' \u2192 target medium ' + matching[0].position());
+            const result = assignToTracks(matching[0].tracks(), trackMap);
+            reportResult(
+                result,
+                'from source ' + sourceLabel + ' → target medium ' + matching[0].position()
+            );
             return;
         }
 
-        // Ambiguous: let the user pick the target medium.
         renderTargetChooser(targetMediums, trackMap, sourceLabel);
     }
 
     function renderTargetChooser(targetMediums, trackMap, sourceLabel) {
-        var chooser = document.getElementById('cfr-target-chooser');
+        const chooser = document.getElementById('cfr-target-chooser');
         if (!chooser) return;
+
         chooser.innerHTML =
-            '<div style="margin-bottom:4px;font-weight:bold;font-size:12px;color:#444;">' +
-            'Source ' + escapeHtml(sourceLabel) + ' \u2014 apply to which medium of this release?</div>';
-
-        targetMediums.forEach(function (m) {
-            var btn = document.createElement('button');
-            btn.type = 'button';
-            btn.style.cssText = 'display:block;width:100%;text-align:left;margin-bottom:3px;padding:4px 7px;font-size:12px;cursor:pointer;border:1px solid #bbb;border-radius:3px;background:#fff;';
-            var name = m.name && m.name() ? ' \u201C' + m.name() + '\u201D' : '';
-            btn.textContent = 'Medium ' + m.position() + name + ' \u00B7 ' + m.tracks().length + ' tracks';
-            btn.addEventListener('click', function () {
+            '<div class="cfr-target-title">Source ' + escapeHtml(sourceLabel) +
+            ' — apply to which medium of this release?</div>';
+
+        targetMediums.forEach(function (medium) {
+            const button = document.createElement('button');
+            button.type = 'button';
+            button.className = 'styled-button cfr-target-button';
+
+            const name = medium.name && medium.name() ? ' “' + medium.name() + '”' : '';
+            button.textContent =
+                'Medium ' + medium.position() + name + ' · ' + medium.tracks().length + ' tracks';
+
+            button.addEventListener('click', function () {
                 clearTargetChooser();
-                reportResult(assignToTracks(m.tracks(), trackMap),
-                             'from source ' + sourceLabel + ' \u2192 target medium ' + m.position());
+                reportResult(
+                    assignToTracks(medium.tracks(), trackMap),
+                    'from source ' + sourceLabel + ' → target medium ' + medium.position()
+                );
             });
-            chooser.appendChild(btn);
+
+            chooser.appendChild(button);
         });
 
-        chooser.style.display = 'block';
-        setStatus('Choose a target medium above.', '#555');
+        chooser.classList.add('cfr-visible');
+        setStatus('Choose a target medium above.');
     }
 
-    // ── Access the KO view-model ──────────────────────────────────────────────
-
     function getReleaseEditorVM() {
         try {
-            if (window.MB && window.MB.releaseEditor && window.MB.releaseEditor.rootField)
+            if (window.MB && window.MB.releaseEditor && window.MB.releaseEditor.rootField) {
                 return window.MB.releaseEditor;
-            if (window.MB && window.MB._releaseEditor && window.MB._releaseEditor.rootField)
+            }
+
+            if (window.MB && window.MB._releaseEditor && window.MB._releaseEditor.rootField) {
                 return window.MB._releaseEditor;
-            var changesDiv = document.querySelector('.changes[data-bind]');
-            if (changesDiv) {
-                var ctx = ko.contextFor(changesDiv);
-                if (ctx && ctx.$root && ctx.$root.rootField) return ctx.$root;
-                if (ctx && ctx.$parents) {
-                    for (var i = 0; i < ctx.$parents.length; i++) {
-                        if (ctx.$parents[i] && ctx.$parents[i].rootField) return ctx.$parents[i];
+            }
+
+            const changesDiv = document.querySelector('.changes[data-bind]');
+            if (changesDiv && window.ko) {
+                const context = ko.contextFor(changesDiv);
+
+                if (context && context.$root && context.$root.rootField) {
+                    return context.$root;
+                }
+
+                if (context && context.$parents) {
+                    for (let i = 0; i < context.$parents.length; i += 1) {
+                        if (context.$parents[i] && context.$parents[i].rootField) {
+                            return context.$parents[i];
+                        }
                     }
                 }
             }
-        } catch (e) { console.error('[CFR] getReleaseEditorVM error:', e); }
+        } catch (error) {
+            console.error('[CFR] getReleaseEditorVM error:', error);
+        }
+
         return null;
     }
 
-    // ── Tab-change observer ───────────────────────────────────────────────────
-
-    var observer = new MutationObserver(function () {
-        if (!document.getElementById('cfr-widget')) injectUI();
+    const observer = new MutationObserver(function () {
+        if (!document.getElementById('cfr-widget')) {
+            injectUI();
+        }
     });
-    observer.observe(document.body, { childList: true, subtree: true });
 
+    observer.observe(document.body, { childList: true, subtree: true });
     injectUI();
-
 })();
-