From 22f92ccc66cb62f805cc19eb6b2e616ed317e580 Mon Sep 17 00:00:00 2001
From: ChrisBeWithYou <chris@rifflarr.local>
Date: Sat, 4 Jul 2026 00:22:38 -0500
Subject: [PATCH 01/11] feat(editor): unified create modal with first-class
 Blank (audio-only)

The create modal labelled its Guitar Pro / EOF XML inputs "optional" but
hard-disabled Create unless one was picked, and its blank-chart options
(initial arrangement + drum tab) were never wired up -- so an audio-only
feedpak could only be made via a separate "New Sloppak" dialog.

Add an explicit Blank / Guitar Pro / EOF XML mode picker (Blank default):
- Blank shows the initial-arrangement toggle (Lead/Rhythm/Bass) + a drum-tab
  option, enables Create on audio + title + artist, routes to the existing
  create_sloppak backend, and opens the new feedpak in the editor.
- GP / EOF keep their import flows; only the active mode's section shows.
- The "New" chooser's entries now open this one unified modal (Blank / GP
  mode) instead of a parallel dialog.
- Rename the toolbar's "Build Song" button to "Build feedpak".

The Create-button enable logic is factored into a pure _createGateOpen()
covered by tests/create_gate.test.js (per-mode enable). screen.js parses
clean; all 13 JS suites pass.

Deferred (backend work / follow-ups): Keys/Drums-as-arrangement + extended
tunings; removing the now-unreferenced standalone New-Sloppak dialog; the
editor-header trim.

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>
---
 CHANGELOG.md              |  17 ++++
 screen.html               |  26 ++++--
 screen.js                 | 169 +++++++++++++++++++++++++++++++++++---
 tests/create_gate.test.js |  66 +++++++++++++++
 4 files changed, 257 insertions(+), 21 deletions(-)
 create mode 100644 tests/create_gate.test.js

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 19b3d8d0..67cd8ad4 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -23,6 +23,23 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
   "fret" no longer reads as an arbitrary number. Tests:
   `tests/anchor_authoring.test.js` (full-set promotion on click + on add-new,
   undo-restores-fallback, idempotent-when-authored).
+- **Create a song from audio alone — "New…" no longer forces a Guitar Pro / EOF
+  file.** The create modal labelled its Guitar Pro and EOF XML inputs *optional*
+  but hard-disabled the Create button unless one was picked, and its
+  blank-chart options (initial arrangement + drum tab) were never wired up — so
+  an audio-only feedpak could only be made through a second, separate "New
+  Sloppak" dialog. The modal now leads with an explicit **Blank / Guitar Pro /
+  EOF XML** mode picker (Blank is the default): Blank shows the initial-
+  arrangement toggle (Lead / Rhythm / Bass) + a drum-tab option and enables
+  Create on audio + title + artist, routing to the existing `create_sloppak`
+  backend and opening the new feedpak straight in the editor; the GP and EOF
+  modes keep their import flows. The "New" chooser's entries now open this one
+  unified modal (in Blank / GP mode) instead of a parallel dialog, and the
+  toolbar's **Build Song** button is renamed **Build feedpak**. Tests:
+  `tests/create_gate.test.js` (per-mode Create-button enable logic). Keys /
+  Drums-as-arrangement and extended tunings still need `create_sloppak` backend
+  work (tracked separately); the now-unreferenced standalone New-Sloppak dialog
+  can be removed in a follow-up.
 
 ### Changed
 - **The audio lane now draws a real waveform.** It previously showed a
diff --git a/screen.html b/screen.html
index 7e3c8562..ec742008 100644
--- a/screen.html
+++ b/screen.html
@@ -23,7 +23,7 @@
         <button id="editor-create-btn" onclick="editorShowCreateModal()" class="px-3 py-1 bg-green-800 hover:bg-green-700 rounded text-xs font-medium" title="Start a new song">New…</button>
         <button id="editor-save-btn" onclick="editorSave()" class="px-3 py-1 bg-accent hover:bg-accent-light rounded text-xs font-medium" disabled>Save</button>
         <button id="editor-replace-audio-btn" onclick="editorShowReplaceAudioModal()" class="px-3 py-1 bg-dark-600 hover:bg-dark-500 rounded text-xs font-medium hidden" title="Replace the audio track">Replace Audio</button>
-        <button id="editor-build-btn" onclick="editorBuild()" class="px-3 py-1 bg-purple-800 hover:bg-purple-700 rounded text-xs font-medium hidden">Build Song</button>
+        <button id="editor-build-btn" onclick="editorBuild()" class="px-3 py-1 bg-purple-800 hover:bg-purple-700 rounded text-xs font-medium hidden" title="Assemble the finished .feedpak package">Build feedpak</button>
         <button id="editor-add-drums-btn" onclick="editorShowAddDrumsModal()" class="px-3 py-1 bg-red-900 hover:bg-red-800 rounded text-xs font-medium hidden">+ Drums</button>
         <button id="editor-add-keys-btn" onclick="editorShowAddKeysModal()" class="px-3 py-1 bg-indigo-900 hover:bg-indigo-800 rounded text-xs font-medium hidden">+ Keys</button>
         <button id="editor-import-guitar-btn" onclick="editorShowImportGuitarModal()" class="px-3 py-1 bg-blue-900 hover:bg-blue-800 rounded text-xs font-medium hidden" title="Import a guitar or bass track from a Guitar Pro file — add it or replace an existing arrangement">+ Guitar/Bass</button>
@@ -165,17 +165,27 @@
         </div>
         <div class="p-4 space-y-4">
 
-            <!-- Step 1: Guitar Pro file -->
+            <!-- How to start: Blank is first-class (audio only); GP / EOF import a chart. -->
             <div>
-                <label class="text-xs font-medium text-gray-400 mb-1 block">Guitar Pro File <span id="editor-create-gp-opt" class="text-gray-600">(.gp3/.gp4/.gp5/.gpx/.gp — optional)</span></label>
+                <div class="aud-seg-wrap" role="tablist" aria-label="How to start the new song">
+                    <button type="button" onclick="editorSetCreateMode('blank')" id="editor-create-mode-blank-btn" class="aud-seg is-active">Blank</button>
+                    <button type="button" onclick="editorSetCreateMode('gp')" id="editor-create-mode-gp-btn" class="aud-seg">Guitar Pro</button>
+                    <button type="button" onclick="editorSetCreateMode('eof')" id="editor-create-mode-eof-btn" class="aud-seg">EOF XML</button>
+                </div>
+                <p id="editor-create-mode-hint" class="text-[11px] text-gray-600 mt-1"></p>
+            </div>
+
+            <!-- Guitar Pro file (GP mode) -->
+            <div id="editor-create-mode-gp" class="create-mode-sec hidden">
+                <label class="text-xs font-medium text-gray-400 mb-1 block">Guitar Pro File <span id="editor-create-gp-opt" class="text-gray-600">(.gp3/.gp4/.gp5/.gpx/.gp)</span></label>
                 <input type="file" id="editor-create-gp" accept=".gp3,.gp4,.gp5,.gpx,.gp"
                     onchange="editorGPFileSelected(this)"
                     class="w-full text-xs text-gray-400 file:mr-3 file:py-1 file:px-3 file:rounded file:border-0 file:text-xs file:bg-dark-600 file:text-gray-300 hover:file:bg-dark-500">
             </div>
 
-            <!-- Step 1 (alt): import EOF (Editor on Fire) arrangement XML -->
-            <div>
-                <label class="text-xs font-medium text-gray-400 mb-1 block">EOF Arrangement XML <span class="text-gray-600">(.xml — one or more; optional)</span></label>
+            <!-- EOF (Editor on Fire) arrangement XML (EOF mode) -->
+            <div id="editor-create-mode-eof" class="create-mode-sec hidden">
+                <label class="text-xs font-medium text-gray-400 mb-1 block">EOF Arrangement XML <span class="text-gray-600">(.xml — one or more)</span></label>
                 <input type="file" id="editor-create-eof" accept=".xml" multiple
                     onchange="editorEofFilesSelected(this)"
                     class="w-full text-xs text-gray-400 file:mr-3 file:py-1 file:px-3 file:rounded file:border-0 file:text-xs file:bg-dark-600 file:text-gray-300 hover:file:bg-dark-500">
@@ -189,8 +199,8 @@
                 </div>
             </div>
 
-            <!-- Blank-chart options (Sloppak with no Guitar Pro file) -->
-            <div id="editor-create-blank-opts" class="hidden space-y-2">
+            <!-- Blank-chart options (audio-only feedpak; Blank mode) -->
+            <div id="editor-create-blank-opts" class="create-mode-sec hidden space-y-2">
                 <div>
                     <label class="text-xs font-medium text-gray-400 mb-1 block">Initial Arrangement</label>
                     <div id="editor-create-arr-buttons" class="flex gap-1"></div>
diff --git a/screen.js b/screen.js
index 461ffde3..b6e5799b 100644
--- a/screen.js
+++ b/screen.js
@@ -5508,16 +5508,16 @@ window.editorShowNewFormatPicker = () => {
         return b;
     };
     inner.appendChild(mkBtn(
-        '🎵  Sloppak',
-        'Audio + chart with drum tab and stems available from the start. '
-        + 'Best for new songs.',
-        () => window.editorShowCreateSloppakModal(),
+        '🎵  Blank — start from audio',
+        'Audio + an empty arrangement (drum tab optional). Chart it yourself '
+        + 'in the editor. No Guitar Pro / XML needed.',
+        () => { window.editorShowCreateModal(); window.editorSetCreateMode('blank'); },
     ));
     inner.appendChild(mkBtn(
         '🎸  Import from Guitar Pro',
-        'Build a chart from a Guitar Pro file (.gp3–.gp8). Audio and '
-        + 'arrangements are imported and saved as a native .sloppak.',
-        () => window.editorShowCreateModal(),
+        'Build a chart from a Guitar Pro file (.gp3–.gp8), saved as a native '
+        + '.feedpak.',
+        () => { window.editorShowCreateModal(); window.editorSetCreateMode('gp'); },
     ));
 
     const cancel = document.createElement('div');
@@ -5547,6 +5547,7 @@ window.editorShowCreateModal = () => {
     // gp8AudioMode / autoSyncAudioUrl / lastSync can't leak into this one
     // (which would apply the previous song's audio/offset to a new import).
     createState = {
+        mode: 'blank', initialArr: 'Lead',
         gpPath: null, tracks: null, audioUrl: null, audioMode: 'file', artPath: null,
         previewPath: null, eofFiles: null,
         gp8AudioMode: 'none', autoSyncAudioUrl: null, lastSync: null,
@@ -5575,6 +5576,8 @@ window.editorShowCreateModal = () => {
     const _refineStatus = document.getElementById('editor-refine-status');
     if (_refineStatus) _refineStatus.textContent = '';
     editorSetAudioMode('file');
+    _populateCreateArrButtons();
+    editorSetCreateMode('blank');
 };
 
 window.editorHideCreateModal = () => {
@@ -6009,12 +6012,96 @@ async function uploadCreateAudio() {
     return true;
 }
 
-function updateCreateButton() {
-    const hasGP = !!createState.gpPath;
-    const hasEof = !!(createState.eofFiles && createState.eofFiles.length);
-    document.getElementById('editor-create-go').disabled = !(hasGP || hasEof);
+// Pure gate — given the create-modal state + which inputs are filled, decide
+// whether the Create/Import button should be enabled. DOM-free so it can be
+// unit-tested (tests/create_gate.test.js).
+//   blank: audio-only feedpak -> backend needs audio + title + artist.
+//   gp/eof: enabled once a source file is chosen (title/artist come from it or
+//   the details fields), preserving the pre-mode-picker behaviour.
+function _createGateOpen(state, flags) {
+    if (!state || !flags) return false;
+    switch (state.mode) {
+        case 'blank': return !!(flags.hasAudio && flags.hasTitle && flags.hasArtist);
+        case 'gp':    return !!state.gpPath;
+        case 'eof':   return !!(state.eofFiles && state.eofFiles.length);
+        default:      return false;
+    }
+}
+
+function _createHasAudioInput() {
+    if (createState.audioMode === 'youtube') {
+        return !!((document.getElementById('editor-create-yt-url')?.value) || '').trim();
+    }
+    return !!(document.getElementById('editor-create-audio')?.files || []).length
+        || !!createState.audioUrl;
 }
 
+function updateCreateButton() {
+    const open = _createGateOpen(createState, {
+        hasTitle: !!((document.getElementById('editor-create-title')?.value) || '').trim(),
+        hasArtist: !!((document.getElementById('editor-create-artist')?.value) || '').trim(),
+        hasAudio: _createHasAudioInput(),
+    });
+    const btn = document.getElementById('editor-create-go');
+    if (btn) btn.disabled = !open;
+}
+
+// Populate the Blank-mode "Initial Arrangement" toggle. Lead / Rhythm / Bass are
+// the arrangements the create_sloppak backend accepts today; Keys/Drums-as-arr
+// + extended tunings need backend work (tracked separately). The drum-tab
+// checkbox beside it covers a drum chart.
+function _populateCreateArrButtons() {
+    const wrap = document.getElementById('editor-create-arr-buttons');
+    if (!wrap) return;
+    wrap.replaceChildren();
+    const choices = ['Lead', 'Rhythm', 'Bass'];
+    if (!choices.includes(createState.initialArr)) createState.initialArr = 'Lead';
+    for (const name of choices) {
+        const b = document.createElement('button');
+        b.type = 'button';
+        b.dataset.arr = name;
+        b.textContent = name;
+        b.className = 'px-2 py-1 rounded text-xs font-medium '
+            + (name === createState.initialArr
+                ? 'bg-accent text-white'
+                : 'bg-dark-600 text-gray-300 hover:bg-dark-500');
+        b.onclick = () => { createState.initialArr = name; _populateCreateArrButtons(); };
+        wrap.appendChild(b);
+    }
+}
+
+// Switch the create modal between Blank (audio-only) / Guitar Pro / EOF XML:
+// show only that mode's section, clear the other modes' picked files (so a
+// leftover can't route editorDoCreate the wrong way), and re-label the action.
+window.editorSetCreateMode = (mode) => {
+    if (!['blank', 'gp', 'eof'].includes(mode)) mode = 'blank';
+    createState.mode = mode;
+    if (mode !== 'gp') { createState.gpPath = null; createState.tracks = null; }
+    if (mode !== 'eof') { createState.eofFiles = null; }
+    document.getElementById('editor-create-tracks')?.classList.add('hidden');
+    document.querySelectorAll('#editor-create-modal .create-mode-sec').forEach((el) => {
+        const secMode = el.id === 'editor-create-mode-gp' ? 'gp'
+            : el.id === 'editor-create-mode-eof' ? 'eof'
+            : 'blank'; // editor-create-blank-opts
+        el.classList.toggle('hidden', secMode !== mode);
+    });
+    for (const m of ['blank', 'gp', 'eof']) {
+        document.getElementById(`editor-create-mode-${m}-btn`)
+            ?.classList.toggle('is-active', m === mode);
+    }
+    const hint = document.getElementById('editor-create-mode-hint');
+    if (hint) {
+        hint.textContent = mode === 'blank'
+            ? 'Start from audio — pick an instrument below and chart it in the editor. No Guitar Pro / XML needed.'
+            : mode === 'gp'
+                ? 'Import a chart from a Guitar Pro file (.gp3–.gp8).'
+                : 'Import one or more EOF (Editor on Fire) arrangement XML files.';
+    }
+    const go = document.getElementById('editor-create-go');
+    if (go) go.textContent = mode === 'blank' ? 'Create from Audio' : 'Import & Open in Editor';
+    updateCreateButton();
+};
+
 // Wire up input change events for enabling the create button. Changing the
 // Step 2 audio inputs also invalidates a cached upload URL — otherwise
 // editorDoCreate() skips re-upload (it only uploads when audioUrl is unset)
@@ -6030,6 +6117,10 @@ document.addEventListener('input', (e) => {
         createState.audioUrl = null;
         updateCreateButton();
     }
+    // Blank mode also gates on title/artist — re-check as the user types.
+    if (e.target.id === 'editor-create-title' || e.target.id === 'editor-create-artist') {
+        updateCreateButton();
+    }
 });
 
 
@@ -6105,7 +6196,59 @@ window.editorRefineSync = async () => {
     }
 };
 
+// Blank-mode create: no Guitar Pro / EOF chart — just audio + metadata + an
+// empty initial arrangement (Lead/Rhythm/Bass) and an optional drum tab. POSTs
+// to create_sloppak (which already accepts an audio_url + blank arrangement)
+// and opens the freshly-written feedpak via the normal load path.
+async function _editorDoBlankCreate() {
+    const status = document.getElementById('editor-create-status');
+    const btn = document.getElementById('editor-create-go');
+    const title = ((document.getElementById('editor-create-title')?.value) || '').trim();
+    const artist = ((document.getElementById('editor-create-artist')?.value) || '').trim();
+    if (!title || !artist) {
+        if (status) status.textContent = 'Title and artist are required.';
+        return;
+    }
+    if (btn) btn.disabled = true;
+    if (!createState.audioUrl) {
+        if (status) status.textContent = 'Uploading audio…';
+        const ok = await uploadCreateAudio();
+        if (!ok) { if (btn) btn.disabled = false; return; }
+    }
+    const meta = {
+        title, artist,
+        album: ((document.getElementById('editor-create-album')?.value) || '').trim(),
+        year: ((document.getElementById('editor-create-year')?.value) || '').trim(),
+        initial_arrangement: createState.initialArr || 'Lead',
+        init_drum_tab: !!document.getElementById('editor-create-drum-tab')?.checked,
+        audio_url: createState.audioUrl,
+    };
+    const fd = new FormData();
+    fd.append('metadata', JSON.stringify(meta));
+    if (status) status.textContent = 'Building feedpak…';
+    try {
+        const resp = await fetch('/api/plugins/editor/create_sloppak', { method: 'POST', body: fd });
+        const data = await resp.json();
+        if (!resp.ok || !data.success) {
+            if (status) status.textContent = 'Error: ' + (data.error || resp.statusText);
+            if (btn) btn.disabled = false;
+            return;
+        }
+        editorHideCreateModal();
+        if (typeof _kickLibraryRescan === 'function') _kickLibraryRescan();
+        await loadCDLC(data.filename);
+    } catch (e) {
+        if (status) status.textContent = 'Failed: ' + e.message;
+        if (btn) btn.disabled = false;
+    }
+}
+
 window.editorDoCreate = async () => {
+    // Blank mode: audio + metadata -> create_sloppak (no GP/EOF chart import).
+    if (createState.mode === 'blank') {
+        await _editorDoBlankCreate();
+        return;
+    }
     // EOF arrangement-XML import takes priority when XML files are selected.
     if (createState.eofFiles && createState.eofFiles.length) {
         await _editorDoEofCreate();
@@ -6326,7 +6469,7 @@ window.editorApplyCreateResult = async (data) => {
 
     if (data.audio_url) await loadAudio(data.audio_url);
     draw();
-    setStatus('Imported — edit notes then click Build Song');
+    setStatus('Imported — edit notes then click Build feedpak');
 };
 
 // EOF arrangement XML(s) selected — just record them. The shared "Import & Open"
@@ -6621,7 +6764,7 @@ window.editorApplyReplaceAudio = async () => {
         const HINTS = {
             none:    'Audio replaced',
             save:    'Audio replaced (Save to persist to .sloppak)',
-            build:   'Audio replaced (will persist on next Build Song)',
+            build:   'Audio replaced (will persist on next Build feedpak)',
             rebuild: "Audio replaced (playback only — archive won't be repacked)",
         };
         editorHideReplaceAudioModal();
diff --git a/tests/create_gate.test.js b/tests/create_gate.test.js
new file mode 100644
index 00000000..e59d616a
--- /dev/null
+++ b/tests/create_gate.test.js
@@ -0,0 +1,66 @@
+'use strict';
+/*
+ * Create-modal gate — the Create/Import button enable logic per mode
+ * (Blank / Guitar Pro / EOF XML). Blank is audio-only and must enable on
+ * audio + title + artist (the create_sloppak backend's requirements); GP and
+ * EOF enable once a source file is picked. Brace-extracts the real pure gate
+ * from screen.js (a single browser IIFE) so there's no drift.
+ *
+ * Run: node tests/create_gate.test.js
+ */
+const fs = require('fs');
+const path = require('path');
+const assert = require('assert');
+const src = fs.readFileSync(path.join(__dirname, '..', 'screen.js'), 'utf8');
+
+function extractFn(name) {
+    const start = src.indexOf('function ' + name + '(');
+    if (start < 0) throw new Error('not found: ' + name);
+    const open = src.indexOf('{', start);
+    let depth = 0;
+    for (let i = open; i < src.length; i++) {
+        if (src[i] === '{') depth++;
+        else if (src[i] === '}') { depth--; if (depth === 0) return src.slice(start, i + 1); }
+    }
+    throw new Error('unbalanced: ' + name);
+}
+const _createGateOpen = new Function(
+    '"use strict";' + extractFn('_createGateOpen') + '\nreturn _createGateOpen;')();
+
+let pass = 0, fail = 0;
+function t(name, fn) {
+    try { fn(); pass++; console.log('  ok   ' + name); }
+    catch (e) { fail++; console.error('  FAIL ' + name + ': ' + e.message); }
+}
+const inp = (o = {}) => ({ hasTitle: false, hasArtist: false, hasAudio: false, ...o });
+
+t('blank: enabled only with audio + title + artist', () => {
+    assert.strictEqual(_createGateOpen({ mode: 'blank' }, inp({ hasAudio: true, hasTitle: true, hasArtist: true })), true);
+    assert.strictEqual(_createGateOpen({ mode: 'blank' }, inp({ hasTitle: true, hasArtist: true })), false);   // no audio
+    assert.strictEqual(_createGateOpen({ mode: 'blank' }, inp({ hasAudio: true, hasArtist: true })), false);   // no title
+    assert.strictEqual(_createGateOpen({ mode: 'blank' }, inp({ hasAudio: true, hasTitle: true })), false);    // no artist
+});
+
+t('blank: does not depend on a GP/EOF file', () => {
+    assert.strictEqual(_createGateOpen({ mode: 'blank', gpPath: '/x.gp', eofFiles: [{}] }, inp()), false);
+    assert.strictEqual(_createGateOpen({ mode: 'blank', gpPath: '/x.gp' }, inp({ hasAudio: true, hasTitle: true, hasArtist: true })), true);
+});
+
+t('gp: enabled once a GP file is chosen', () => {
+    assert.strictEqual(_createGateOpen({ mode: 'gp', gpPath: '/song.gp' }, inp()), true);
+    assert.strictEqual(_createGateOpen({ mode: 'gp', gpPath: null }, inp({ hasAudio: true, hasTitle: true, hasArtist: true })), false);
+});
+
+t('eof: enabled once XML file(s) chosen', () => {
+    assert.strictEqual(_createGateOpen({ mode: 'eof', eofFiles: [{}] }, inp()), true);
+    assert.strictEqual(_createGateOpen({ mode: 'eof', eofFiles: [] }, inp({ hasAudio: true, hasTitle: true, hasArtist: true })), false);
+    assert.strictEqual(_createGateOpen({ mode: 'eof', eofFiles: null }, inp()), false);
+});
+
+t('defensive: null state / unknown mode -> disabled', () => {
+    assert.strictEqual(_createGateOpen(null, inp({ hasAudio: true, hasTitle: true, hasArtist: true })), false);
+    assert.strictEqual(_createGateOpen({ mode: 'wat' }, inp({ hasAudio: true, hasTitle: true, hasArtist: true })), false);
+});
+
+console.log(`\n${pass} passed, ${fail} failed`);
+process.exit(fail ? 1 : 0);

From c16b994c1b797d05fc6336bb354bd726ec6446b0 Mon Sep 17 00:00:00 2001
From: ChrisBeWithYou <chris@rifflarr.local>
Date: Sat, 4 Jul 2026 01:19:33 -0500
Subject: [PATCH 02/11] =?UTF-8?q?feat(editor):=20extended-range=20create?=
 =?UTF-8?q?=20=E2=80=94=20accept=20tuning=204-8=20(spec=205.2)?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

PR-A of the onboarding charrette train. create_sloppak hard-capped the
initial arrangement's tuning to length 4|6, which feedpak-spec 5.2
forbids ("Readers MUST NOT hard-code length 6") -- so 7/8-string guitars
and 5/6-string basses could only be made via the save-as path, not at
the source, and imported extended-range tunings risked coercion.

Backend: range-check tuning length 4-8 (default 4 for Bass, 6 otherwise);
the writer already derives string count from the tuning array length.
Frontend: a Strings picker in Blank mode (guitar 6/7/8, bass 4/5/6) that
sends a standard tuning array of the chosen length.

Verified against the running backend: create_sloppak now accepts a
7-string Lead and 5-string Bass tuning (previously 400) and rejects
out-of-range (9) with the spec-cited error. screen.js parses; all
editor JS suites pass.

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>
---
 routes.py   | 24 ++++++++++++++----------
 screen.html |  6 +++++-
 screen.js   | 47 +++++++++++++++++++++++++++++++++++++++++++++--
 3 files changed, 64 insertions(+), 13 deletions(-)

diff --git a/routes.py b/routes.py
index 412f4cd1..262def87 100644
--- a/routes.py
+++ b/routes.py
@@ -3521,12 +3521,14 @@ def _str_field(name: str, default: str = "") -> str | None:
                 400,
             )
 
-        # Strict length per chosen arrangement. Bass = 4 strings, the
-        # rest = 6. Reject anything else (1, 7, 20, …) so a malformed
-        # client can't accidentally request an extended-range or
-        # truncated arrangement through this entry point. (Extended-
-        # range support exists via the save-as-sloppak path, not here.)
-        expected_strings = 4 if arr_name == "Bass" else 6
+        # String count is derived from the tuning array. feedpak-spec §5.2
+        # models tuning length 4–8 and explicitly says Readers MUST NOT
+        # hard-code 6, so range-check instead of pinning 4|6 — this lets
+        # extended-range guitars (7/8-string) and 5/6-string basses be created
+        # at the source, not only through the save-as path. Absent tuning ->
+        # a sensible default per role (Bass = 4, guitar roles = 6).
+        _MIN_STRINGS, _MAX_STRINGS = 4, 8
+        default_strings = 4 if arr_name == "Bass" else 6
         tuning_in = meta_in.get("tuning")
 
         def _is_int(v) -> bool:
@@ -3535,8 +3537,9 @@ def _is_int(v) -> bool:
             return isinstance(v, int) and not isinstance(v, bool)
 
         if tuning_in is None:
-            tuning = [0] * expected_strings
-        elif isinstance(tuning_in, list) and len(tuning_in) == expected_strings:
+            tuning = [0] * default_strings
+        elif (isinstance(tuning_in, list)
+                and _MIN_STRINGS <= len(tuning_in) <= _MAX_STRINGS):
             if not all(_is_int(t) for t in tuning_in):
                 return JSONResponse(
                     {"error": "tuning entries must be integers (no floats or booleans)"},
@@ -3546,8 +3549,9 @@ def _is_int(v) -> bool:
         else:
             return JSONResponse(
                 {"error": (
-                    f"tuning must be a list of {expected_strings} ints "
-                    f"for an initial '{arr_name}' arrangement"
+                    f"tuning must be a list of {_MIN_STRINGS}-{_MAX_STRINGS} ints "
+                    f"(feedpak-spec §5.2), or omitted for a default "
+                    f"{default_strings}-string '{arr_name}'"
                 )},
                 400,
             )
diff --git a/screen.html b/screen.html
index ec742008..48fdb7dd 100644
--- a/screen.html
+++ b/screen.html
@@ -204,7 +204,11 @@
                 <div>
                     <label class="text-xs font-medium text-gray-400 mb-1 block">Initial Arrangement</label>
                     <div id="editor-create-arr-buttons" class="flex gap-1"></div>
-                    <p class="text-[11px] text-gray-600 mt-1">Default tuning is E standard (Bass: 4 strings). Adjust later from the editor toolbar.</p>
+                </div>
+                <div>
+                    <label class="text-xs font-medium text-gray-400 mb-1 block">Strings</label>
+                    <div id="editor-create-strings-buttons" class="flex gap-1"></div>
+                    <p class="text-[11px] text-gray-600 mt-1">Standard tuning for the chosen string count — fine-tune later from the editor toolbar.</p>
                 </div>
                 <label class="flex items-center gap-2 cursor-pointer">
                     <input type="checkbox" id="editor-create-drum-tab" checked class="cursor-pointer">
diff --git a/screen.js b/screen.js
index b6e5799b..262ed638 100644
--- a/screen.js
+++ b/screen.js
@@ -5547,7 +5547,7 @@ window.editorShowCreateModal = () => {
     // gp8AudioMode / autoSyncAudioUrl / lastSync can't leak into this one
     // (which would apply the previous song's audio/offset to a new import).
     createState = {
-        mode: 'blank', initialArr: 'Lead',
+        mode: 'blank', initialArr: 'Lead', stringCount: 6,
         gpPath: null, tracks: null, audioUrl: null, audioMode: 'file', artPath: null,
         previewPath: null, eofFiles: null,
         gp8AudioMode: 'none', autoSyncAudioUrl: null, lastSync: null,
@@ -5577,6 +5577,7 @@ window.editorShowCreateModal = () => {
     if (_refineStatus) _refineStatus.textContent = '';
     editorSetAudioMode('file');
     _populateCreateArrButtons();
+    _populateStringCountButtons();
     editorSetCreateMode('blank');
 };
 
@@ -6050,6 +6051,13 @@ function updateCreateButton() {
 // the arrangements the create_sloppak backend accepts today; Keys/Drums-as-arr
 // + extended tunings need backend work (tracked separately). The drum-tab
 // checkbox beside it covers a drum chart.
+// String-count options per role — feedpak-spec §5.2 allows tuning length 4-8.
+// Guitar roles offer 6/7/8; Bass offers 4/5/6. The create route derives the
+// arrangement's string count from the length of the tuning array we send.
+function _createRoleStringOptions(role) {
+    return role === 'Bass' ? [4, 5, 6] : [6, 7, 8];
+}
+
 function _populateCreateArrButtons() {
     const wrap = document.getElementById('editor-create-arr-buttons');
     if (!wrap) return;
@@ -6065,7 +6073,33 @@ function _populateCreateArrButtons() {
             + (name === createState.initialArr
                 ? 'bg-accent text-white'
                 : 'bg-dark-600 text-gray-300 hover:bg-dark-500');
-        b.onclick = () => { createState.initialArr = name; _populateCreateArrButtons(); };
+        b.onclick = () => {
+            createState.initialArr = name;
+            // Re-scope string count to the new role's options.
+            const opts = _createRoleStringOptions(name);
+            if (!opts.includes(createState.stringCount)) createState.stringCount = opts[0];
+            _populateCreateArrButtons();
+            _populateStringCountButtons();
+        };
+        wrap.appendChild(b);
+    }
+}
+
+function _populateStringCountButtons() {
+    const wrap = document.getElementById('editor-create-strings-buttons');
+    if (!wrap) return;
+    wrap.replaceChildren();
+    const opts = _createRoleStringOptions(createState.initialArr);
+    if (!opts.includes(createState.stringCount)) createState.stringCount = opts[0];
+    for (const n of opts) {
+        const b = document.createElement('button');
+        b.type = 'button';
+        b.textContent = n + '-string';
+        b.className = 'px-2 py-1 rounded text-xs font-medium '
+            + (n === createState.stringCount
+                ? 'bg-accent text-white'
+                : 'bg-dark-600 text-gray-300 hover:bg-dark-500');
+        b.onclick = () => { createState.stringCount = n; _populateStringCountButtons(); };
         wrap.appendChild(b);
     }
 }
@@ -6220,6 +6254,15 @@ async function _editorDoBlankCreate() {
         album: ((document.getElementById('editor-create-album')?.value) || '').trim(),
         year: ((document.getElementById('editor-create-year')?.value) || '').trim(),
         initial_arrangement: createState.initialArr || 'Lead',
+        // The tuning array's LENGTH sets the arrangement's string count
+        // (feedpak-spec §5.2). All-zero offsets = standard tuning for that
+        // count; alt/drop tunings are a fine-tune step in the editor.
+        tuning: new Array(
+            (Number.isInteger(createState.stringCount)
+                && createState.stringCount >= 4 && createState.stringCount <= 8)
+                ? createState.stringCount
+                : (createState.initialArr === 'Bass' ? 4 : 6),
+        ).fill(0),
         init_drum_tab: !!document.getElementById('editor-create-drum-tab')?.checked,
         audio_url: createState.audioUrl,
     };

From ddbed34037459013a1972ce7168e9b25248c7fc1 Mon Sep 17 00:00:00 2001
From: ChrisBeWithYou <chris@rifflarr.local>
Date: Sat, 4 Jul 2026 01:37:24 -0500
Subject: [PATCH 03/11] =?UTF-8?q?feat(editor):=20roster=20=E2=80=94=20add?=
 =?UTF-8?q?=20Keys=20+=20Drums;=20fix=20Bass=20string=20default?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Extends the create roster beyond fretted roles. Keys and Drums are
name-recognized by the editor (KEYS_PATTERN / ^drums), so a "Keys"
arrangement opens in piano-roll and a "Drums" arrangement in drum mode.

Backend (create_sloppak): accept initial_arrangement Keys/Drums; branch
the tuning/capo validation to fretted only (Keys/Drums carry no strings);
Keys arrangements get the spec `type: piano`; a Drums pack always seeds
its drum_tab. Verified against the running backend -- Keys/Drums accepted,
Vocals rejected, extended-range fretted unchanged.

Frontend: full roster (Lead/Rhythm, Bass, Keys, Drums) with the string-
count picker hidden for Keys/Drums; Vocals shown but DISABLED with an
honest tooltip -- the editor has no vocals edit mode yet, so offering it
would create a pack you can't edit.

Bass string-default bug: switching to Bass kept the guitar default of 6
(6 is a valid bass count, so the keep-if-valid reset didn't fire) -- now
resets to the role default (Bass 4, guitar 6).

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>
---
 routes.py   | 91 ++++++++++++++++++++++++++++++-----------------------
 screen.html |  6 ++--
 screen.js   | 67 ++++++++++++++++++++++++++++-----------
 3 files changed, 102 insertions(+), 62 deletions(-)

diff --git a/routes.py b/routes.py
index 262def87..a171d965 100644
--- a/routes.py
+++ b/routes.py
@@ -3515,57 +3515,60 @@ def _str_field(name: str, default: str = "") -> str | None:
             )
         if not arr_name:
             arr_name = "Lead"
-        if arr_name not in ("Lead", "Rhythm", "Bass"):
+        # Fretted roles carry a tuning/string-count; Keys (piano-roll) and
+        # Drums (drum_tab) do not. The editor selects its mode from the
+        # arrangement NAME (KEYS_PATTERN / ^drums), so the name is load-bearing.
+        _FRETTED = ("Lead", "Rhythm", "Bass")
+        if arr_name not in _FRETTED + ("Keys", "Drums"):
             return JSONResponse(
-                {"error": "initial_arrangement must be Lead, Rhythm, or Bass"},
+                {"error": "initial_arrangement must be Lead, Rhythm, Bass, Keys, or Drums"},
                 400,
             )
-
-        # String count is derived from the tuning array. feedpak-spec §5.2
-        # models tuning length 4–8 and explicitly says Readers MUST NOT
-        # hard-code 6, so range-check instead of pinning 4|6 — this lets
-        # extended-range guitars (7/8-string) and 5/6-string basses be created
-        # at the source, not only through the save-as path. Absent tuning ->
-        # a sensible default per role (Bass = 4, guitar roles = 6).
-        _MIN_STRINGS, _MAX_STRINGS = 4, 8
-        default_strings = 4 if arr_name == "Bass" else 6
-        tuning_in = meta_in.get("tuning")
+        is_fretted = arr_name in _FRETTED
 
         def _is_int(v) -> bool:
             # bool is a subclass of int in Python; treat True/False as
             # invalid here so a `True → 1` doesn't slip past.
             return isinstance(v, int) and not isinstance(v, bool)
 
-        if tuning_in is None:
-            tuning = [0] * default_strings
-        elif (isinstance(tuning_in, list)
-                and _MIN_STRINGS <= len(tuning_in) <= _MAX_STRINGS):
-            if not all(_is_int(t) for t in tuning_in):
+        if is_fretted:
+            # String count is derived from the tuning array. feedpak-spec §5.2
+            # models tuning length 4–8 and explicitly says Readers MUST NOT
+            # hard-code 6, so range-check instead of pinning 4|6 — this lets
+            # extended-range guitars (7/8-string) and 5/6-string basses be
+            # created at the source. Absent -> a sensible per-role default.
+            _MIN_STRINGS, _MAX_STRINGS = 4, 8
+            default_strings = 4 if arr_name == "Bass" else 6
+            tuning_in = meta_in.get("tuning")
+            if tuning_in is None:
+                tuning = [0] * default_strings
+            elif (isinstance(tuning_in, list)
+                    and _MIN_STRINGS <= len(tuning_in) <= _MAX_STRINGS):
+                if not all(_is_int(t) for t in tuning_in):
+                    return JSONResponse(
+                        {"error": "tuning entries must be integers (no floats or booleans)"},
+                        400,
+                    )
+                tuning = list(tuning_in)
+            else:
                 return JSONResponse(
-                    {"error": "tuning entries must be integers (no floats or booleans)"},
+                    {"error": (
+                        f"tuning must be a list of {_MIN_STRINGS}-{_MAX_STRINGS} ints "
+                        f"(feedpak-spec §5.2), or omitted for a default "
+                        f"{default_strings}-string '{arr_name}'"
+                    )},
                     400,
                 )
-            tuning = list(tuning_in)
+            capo_raw = meta_in.get("capo", 0)
+            if not _is_int(capo_raw):
+                return JSONResponse({"error": "capo must be an integer"}, 400)
+            if capo_raw < 0:
+                return JSONResponse({"error": "capo must be non-negative"}, 400)
+            capo = capo_raw
         else:
-            return JSONResponse(
-                {"error": (
-                    f"tuning must be a list of {_MIN_STRINGS}-{_MAX_STRINGS} ints "
-                    f"(feedpak-spec §5.2), or omitted for a default "
-                    f"{default_strings}-string '{arr_name}'"
-                )},
-                400,
-            )
-
-        capo_raw = meta_in.get("capo", 0)
-        if not _is_int(capo_raw):
-            return JSONResponse(
-                {"error": "capo must be an integer"}, 400,
-            )
-        if capo_raw < 0:
-            return JSONResponse(
-                {"error": "capo must be non-negative"}, 400,
-            )
-        capo = capo_raw
+            # Keys / Drums have no strings — no tuning, no capo.
+            tuning = []
+            capo = 0
 
         # Strict bool check — client JSON-derived; the string "false"
         # would otherwise become truthy and silently enable drum_tab.
@@ -3575,6 +3578,9 @@ def _is_int(v) -> bool:
                 {"error": "init_drum_tab must be a boolean"}, 400,
             )
         init_drums = init_drums_raw
+        # A Drums pack IS its drum tab — always seed it, regardless of the flag.
+        if arr_name == "Drums":
+            init_drums = True
 
         dlc_dir = get_dlc_dir()
         if not dlc_dir:
@@ -3726,14 +3732,19 @@ def _truncate_utf8(s: str, max_bytes: int) -> str:
                     )
 
             # Build the minimal in-memory shapes _write_sloppak_pak expects.
-            arrangements_data = [{
+            # Keys carry the spec `type: piano`; fretted/drums don't. All three
+            # open in the right editor mode by NAME (KEYS_PATTERN / ^drums).
+            arr_entry = {
                 "name": arr_name,
                 "tuning": tuning,
                 "capo": capo,
                 "notes": [],
                 "chords": [],
                 "chord_templates": [],
-            }]
+            }
+            if arr_name == "Keys":
+                arr_entry["type"] = "piano"
+            arrangements_data = [arr_entry]
             # Seed a minimal one-measure 4/4 @ 120 BPM grid (downbeat +
             # three sub-beats + next downbeat = 5 beats). The Tempo Map
             # editor bails when beats.length < 2 ("No beat grid…"), so
diff --git a/screen.html b/screen.html
index 48fdb7dd..8bcc313d 100644
--- a/screen.html
+++ b/screen.html
@@ -203,11 +203,11 @@
             <div id="editor-create-blank-opts" class="create-mode-sec hidden space-y-2">
                 <div>
                     <label class="text-xs font-medium text-gray-400 mb-1 block">Initial Arrangement</label>
-                    <div id="editor-create-arr-buttons" class="flex gap-1"></div>
+                    <div id="editor-create-arr-buttons" class="flex flex-wrap gap-1"></div>
                 </div>
-                <div>
+                <div id="editor-create-strings-row">
                     <label class="text-xs font-medium text-gray-400 mb-1 block">Strings</label>
-                    <div id="editor-create-strings-buttons" class="flex gap-1"></div>
+                    <div id="editor-create-strings-buttons" class="flex flex-wrap gap-1"></div>
                     <p class="text-[11px] text-gray-600 mt-1">Standard tuning for the chosen string count — fine-tune later from the editor toolbar.</p>
                 </div>
                 <label class="flex items-center gap-2 cursor-pointer">
diff --git a/screen.js b/screen.js
index 262ed638..fbfacc16 100644
--- a/screen.js
+++ b/screen.js
@@ -6051,44 +6051,73 @@ function updateCreateButton() {
 // the arrangements the create_sloppak backend accepts today; Keys/Drums-as-arr
 // + extended tunings need backend work (tracked separately). The drum-tab
 // checkbox beside it covers a drum chart.
+// Fretted roles carry a string count + tuning; Keys (piano-roll) and Drums
+// (drum tab) don't. The editor opens each in the right mode by the arrangement
+// NAME (KEYS_PATTERN / ^drums), which the create route sets from initialArr.
+const _FRETTED_ROLES = ['Lead', 'Rhythm', 'Bass'];
+function _isFrettedRole(role) { return _FRETTED_ROLES.includes(role); }
+
 // String-count options per role — feedpak-spec §5.2 allows tuning length 4-8.
-// Guitar roles offer 6/7/8; Bass offers 4/5/6. The create route derives the
-// arrangement's string count from the length of the tuning array we send.
+// Guitar roles offer 6/7/8; Bass offers 4/5/6.
 function _createRoleStringOptions(role) {
     return role === 'Bass' ? [4, 5, 6] : [6, 7, 8];
 }
+function _createRoleDefaultStrings(role) {
+    return role === 'Bass' ? 4 : 6;
+}
 
 function _populateCreateArrButtons() {
     const wrap = document.getElementById('editor-create-arr-buttons');
     if (!wrap) return;
     wrap.replaceChildren();
-    const choices = ['Lead', 'Rhythm', 'Bass'];
-    if (!choices.includes(createState.initialArr)) createState.initialArr = 'Lead';
-    for (const name of choices) {
+    // Functional roster + Vocals shown-but-disabled: the editor has no vocals
+    // edit mode yet, so offering it would create a pack you can't edit — an
+    // honest "coming" rung rather than a false one.
+    const roster = [
+        { name: 'Lead' }, { name: 'Rhythm' }, { name: 'Bass' },
+        { name: 'Keys' }, { name: 'Drums' },
+        { name: 'Vocals', disabled: true,
+          title: 'Vocals editing is coming — the editor has no vocals mode yet.' },
+    ];
+    const enabled = roster.filter(r => !r.disabled).map(r => r.name);
+    if (!enabled.includes(createState.initialArr)) createState.initialArr = 'Lead';
+    for (const r of roster) {
         const b = document.createElement('button');
         b.type = 'button';
-        b.dataset.arr = name;
-        b.textContent = name;
-        b.className = 'px-2 py-1 rounded text-xs font-medium '
-            + (name === createState.initialArr
-                ? 'bg-accent text-white'
-                : 'bg-dark-600 text-gray-300 hover:bg-dark-500');
-        b.onclick = () => {
-            createState.initialArr = name;
-            // Re-scope string count to the new role's options.
-            const opts = _createRoleStringOptions(name);
-            if (!opts.includes(createState.stringCount)) createState.stringCount = opts[0];
-            _populateCreateArrButtons();
-            _populateStringCountButtons();
-        };
+        b.dataset.arr = r.name;
+        b.textContent = r.name;
+        if (r.title) b.title = r.title;
+        if (r.disabled) {
+            b.disabled = true;
+            b.className = 'px-2 py-1 rounded text-xs font-medium bg-dark-700 text-gray-600 cursor-not-allowed';
+        } else {
+            b.className = 'px-2 py-1 rounded text-xs font-medium '
+                + (r.name === createState.initialArr
+                    ? 'bg-accent text-white'
+                    : 'bg-dark-600 text-gray-300 hover:bg-dark-500');
+            b.onclick = () => {
+                createState.initialArr = r.name;
+                // Reset to the role's DEFAULT string count for a fresh fretted
+                // pick (Bass 4, guitar 6); Keys/Drums have none.
+                if (_isFrettedRole(r.name)) {
+                    createState.stringCount = _createRoleDefaultStrings(r.name);
+                }
+                _populateCreateArrButtons();
+                _populateStringCountButtons();
+            };
+        }
         wrap.appendChild(b);
     }
 }
 
 function _populateStringCountButtons() {
+    const row = document.getElementById('editor-create-strings-row');
     const wrap = document.getElementById('editor-create-strings-buttons');
+    // Hide the whole Strings row for Keys/Drums (no strings).
+    if (row) row.classList.toggle('hidden', !_isFrettedRole(createState.initialArr));
     if (!wrap) return;
     wrap.replaceChildren();
+    if (!_isFrettedRole(createState.initialArr)) return;
     const opts = _createRoleStringOptions(createState.initialArr);
     if (!opts.includes(createState.stringCount)) createState.stringCount = opts[0];
     for (const n of opts) {

From 0e2fc931a782587f5317dcbe38517b8f9923ed7b Mon Sep 17 00:00:00 2001
From: ChrisBeWithYou <chris@rifflarr.local>
Date: Sat, 4 Jul 2026 05:23:56 -0500
Subject: [PATCH 04/11] feat(editor): Create New Arrangement redesign
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

A ground-up rework of the "New…" create flow (was "Create New custom song"),
built + tested iteratively on the :8000 testbed.

Onboarding / entry
- Entering the Song Editor with nothing loaded shows a Load / Create landing.
- Load is now a file browser rooted at the DLC/library folder (new backend
  POST /browse, single directory level, containment-guarded) with recursive
  search; opens on the folder instead of a blank "type to search" prompt.

Create New Arrangement modal (two-column, wider)
- "What are you arranging?" — click-to-add + drag-to-reorder instrument roster
  (Vocals / Lead / Rhythm / Keys / Bass / Drums); no string counts (set in the
  editor). Multi-arrangement create; Vocals seeds a lyrics side-file.
- Draft-now, audio-later: create with just a title (audio + artist optional);
  backend writes an audio-less draft the editor can open.
- Content Import — one staged, role-capped file list (1 master audio, 1 chart,
  MIDI info row) that no longer drops one file when you add another; Guitar Pro
  audio auto-syncs to a staged master track in one click.
- Spec-complete manifest metadata (album_artist, track, disc, genres, ISRC,
  MBID, language, authors) + non-destructive GP-metadata autofill.
- MusicBrainz "Match" popup: structured Artist+Title query (no more junk
  single-field search), and re-ranks candidates by how close each length is to
  the staged master audio (studio vs live/extended) with a "≈ your audio" tag.
- Album art promoted to a preview; preview clip auto-generated from the master
  audio (manual upload removed).
- GP track picker: drums recolored from alarming red to a neutral role pill
  (Drums amber / Keys indigo / Bass sky / Guitar muted) — it's a role, not a
  warning.

Backend (routes.py): create_sloppak multi-arrangement + full metadata +
audio-less drafts + lyrics/drum seeds; upload-audio returns duration; auto
preview generation (create + replace-audio); folder-browse endpoint.

Tests: create_gate.test.js updated; full editor JS suite green.

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>
---
 routes.py                 |  628 ++++++++++++++------
 screen.html               |  257 +++++----
 screen.js                 | 1134 +++++++++++++++++++++++++++++--------
 tests/create_gate.test.js |   48 +-
 4 files changed, 1543 insertions(+), 524 deletions(-)

diff --git a/routes.py b/routes.py
index a171d965..4b135926 100644
--- a/routes.py
+++ b/routes.py
@@ -2536,6 +2536,54 @@ def _name_meta(full: Path) -> tuple:
         files.sort(key=lambda x: x["filename"])
         return files
 
+    @app.post("/api/plugins/editor/browse")
+    async def browse_dlc(data: dict):
+        """List ONE directory level inside the DLC/song-library folder so the
+        Load dialog can act as a file browser rooted at the library. `path` is a
+        DLC-relative POSIX subpath ("" = the library root). Returns the absolute
+        root (for display), the current relative path + its parent, the
+        subfolders, and the loadable feedpak/sloppak files at this level."""
+        dlc_dir = get_dlc_dir()
+        if not dlc_dir or not dlc_dir.exists():
+            return JSONResponse({"error": "DLC folder not configured"}, 400)
+        root = dlc_dir.resolve()
+        rel = str((data or {}).get("path") or "").strip().replace("\\", "/").strip("/")
+        target = (root / rel).resolve() if rel else root
+        # Containment — never list outside the library.
+        try:
+            target.relative_to(root)
+        except ValueError:
+            return JSONResponse({"error": "forbidden"}, 403)
+        if not target.is_dir():
+            target, rel = root, ""
+        _FORMATS = {".feedpak": "sloppak", ".sloppak": "sloppak"}
+        dirs: list = []
+        files: list = []
+        try:
+            entries = sorted(target.iterdir(), key=lambda p: p.name.lower())
+        except OSError:
+            entries = []
+        for entry in entries:
+            ext = entry.suffix.lower()
+            try:
+                erel = entry.relative_to(root).as_posix()
+            except ValueError:
+                continue
+            if entry.is_dir():
+                if ext in (".feedpak", ".sloppak"):
+                    # Authoring-form package dir — a loadable "file", not a folder.
+                    files.append({"filename": erel, "name": entry.name, "format": "sloppak"})
+                else:
+                    dirs.append({"name": entry.name, "path": erel})
+            elif entry.is_file() and ext in _FORMATS:
+                files.append({"filename": erel, "name": entry.name, "format": _FORMATS[ext]})
+        parent = None
+        if rel:
+            p = Path(rel).parent.as_posix()
+            parent = "" if p == "." else p
+        return {"root": str(root), "cwd": rel, "parent": parent,
+                "dirs": dirs, "files": files}
+
     # ── Load a custom song for editing ──────────────────────────────────────────
 
     @app.post("/api/plugins/editor/load")
@@ -3465,8 +3513,10 @@ async def create_sloppak(
         if audio_url is not None and not isinstance(audio_url, str):
             return JSONResponse({"error": "audio_url must be a string"}, 400)
         audio_url = (audio_url or "").strip()
-        if audio is None and not audio_url:
-            return JSONResponse({"error": "audio file or audio_url required"}, 400)
+        # Draft-now, audio-later: audio is OPTIONAL. With neither an upload nor a
+        # pre-uploaded audio_url we still create a work-in-progress pack (empty
+        # `stems: []`); the author supplies real audio later via Replace Audio.
+        has_audio = audio is not None or bool(audio_url)
 
         # Optional album art, passed as a storage path returned by
         # /upload-art. Validate containment under STORAGE_DIR before
@@ -3505,82 +3555,90 @@ def _str_field(name: str, default: str = "") -> str | None:
             return JSONResponse({"error": "artist must be a string"}, 400)
         if not title:
             return JSONResponse({"error": "title required"}, 400)
-        if not artist:
-            return JSONResponse({"error": "artist required"}, 400)
-
-        arr_name = _str_field("initial_arrangement", "Lead")
-        if arr_name is None:
+        # Artist is OPTIONAL for a draft — only the title is required to create a
+        # work-in-progress pack. `artist` may be "" here (written through as-is).
+
+        # Optional "Authored by" credit(s) -> manifest `authors:` (feedpak is an
+        # open format; credit whoever makes the file, don't gate on it). Accept a
+        # single string (the modal's one text field; users comma/newline-separate
+        # names) OR a list. Normalize to a de-duped list of trimmed strings.
+        authors_in = meta_in.get("authors")
+        if isinstance(authors_in, str):
+            authors_in = re.split(r"[,\n]", authors_in)
+        authors: list[str] = []
+        if isinstance(authors_in, list):
+            _seen_auth: set[str] = set()
+            for _a in authors_in:
+                if isinstance(_a, str) and _a.strip() and _a.strip() not in _seen_auth:
+                    _seen_auth.add(_a.strip())
+                    authors.append(_a.strip())
+        elif authors_in is not None:
             return JSONResponse(
-                {"error": "initial_arrangement must be a string"}, 400,
+                {"error": "authors must be a string or a list of strings"}, 400,
             )
-        if not arr_name:
-            arr_name = "Lead"
-        # Fretted roles carry a tuning/string-count; Keys (piano-roll) and
-        # Drums (drum_tab) do not. The editor selects its mode from the
-        # arrangement NAME (KEYS_PATTERN / ^drums), so the name is load-bearing.
-        _FRETTED = ("Lead", "Rhythm", "Bass")
-        if arr_name not in _FRETTED + ("Keys", "Drums"):
-            return JSONResponse(
-                {"error": "initial_arrangement must be Lead, Rhythm, Bass, Keys, or Drums"},
-                400,
-            )
-        is_fretted = arr_name in _FRETTED
 
         def _is_int(v) -> bool:
-            # bool is a subclass of int in Python; treat True/False as
-            # invalid here so a `True → 1` doesn't slip past.
+            # bool is a subclass of int in Python; treat True/False as invalid
+            # so a `True → 1` doesn't slip past int fields (track/disc).
             return isinstance(v, int) and not isinstance(v, bool)
 
-        if is_fretted:
-            # String count is derived from the tuning array. feedpak-spec §5.2
-            # models tuning length 4–8 and explicitly says Readers MUST NOT
-            # hard-code 6, so range-check instead of pinning 4|6 — this lets
-            # extended-range guitars (7/8-string) and 5/6-string basses be
-            # created at the source. Absent -> a sensible per-role default.
-            _MIN_STRINGS, _MAX_STRINGS = 4, 8
-            default_strings = 4 if arr_name == "Bass" else 6
-            tuning_in = meta_in.get("tuning")
-            if tuning_in is None:
-                tuning = [0] * default_strings
-            elif (isinstance(tuning_in, list)
-                    and _MIN_STRINGS <= len(tuning_in) <= _MAX_STRINGS):
-                if not all(_is_int(t) for t in tuning_in):
-                    return JSONResponse(
-                        {"error": "tuning entries must be integers (no floats or booleans)"},
-                        400,
-                    )
-                tuning = list(tuning_in)
-            else:
+        # Roster of arrangements to seed ("What are you arranging?"). The modal
+        # sends `arrangements`: the list of canonical role names the user dragged
+        # in. Back-compat: a single `initial_arrangement` string is still
+        # accepted. Roles map to editor modes by NAME — Lead/Rhythm/Bass →
+        # fretted, Keys → piano-roll (type:piano), Drums → drum_tab. Vocals is
+        # NOT an arrangement (feedpak models it as side-files); it seeds an empty
+        # lyrics track and needs at least one instrument alongside it, since the
+        # spec requires a non-empty arrangements list. String counts are NOT
+        # chosen here — fretted roles get a default standard tuning (Bass 4,
+        # guitar 6) and the editor extends the range (up to 9-string guitar /
+        # 6-string bass) after creation.
+        _FRETTED = ("Lead", "Rhythm", "Bass")
+        _INSTRUMENTS = _FRETTED + ("Keys", "Drums")
+        _ALL_ROLES = _INSTRUMENTS + ("Vocals",)
+        _ROLE_ALIASES = {
+            "Lead Guitar": "Lead", "Rhythm Guitar": "Rhythm",
+            "Bass Guitar": "Bass", "Piano": "Keys", "Keyboard": "Keys",
+            "Vocal": "Vocals", "Voice": "Vocals",
+        }
+
+        roster_in = meta_in.get("arrangements")
+        if roster_in is None:
+            single = _str_field("initial_arrangement", "Lead") or "Lead"
+            roster_in = [single]
+        if not isinstance(roster_in, list) or not roster_in:
+            return JSONResponse(
+                {"error": "arrangements must be a non-empty list of roles"}, 400,
+            )
+        roster: list[str] = []
+        for _r in roster_in:
+            if not isinstance(_r, str):
+                return JSONResponse(
+                    {"error": "each arrangement role must be a string"}, 400,
+                )
+            _r = _ROLE_ALIASES.get(_r.strip(), _r.strip())
+            if _r not in _ALL_ROLES:
                 return JSONResponse(
                     {"error": (
-                        f"tuning must be a list of {_MIN_STRINGS}-{_MAX_STRINGS} ints "
-                        f"(feedpak-spec §5.2), or omitted for a default "
-                        f"{default_strings}-string '{arr_name}'"
+                        f"unknown arrangement role '{_r}' — expected one of "
+                        f"{', '.join(_ALL_ROLES)}"
                     )},
                     400,
                 )
-            capo_raw = meta_in.get("capo", 0)
-            if not _is_int(capo_raw):
-                return JSONResponse({"error": "capo must be an integer"}, 400)
-            if capo_raw < 0:
-                return JSONResponse({"error": "capo must be non-negative"}, 400)
-            capo = capo_raw
-        else:
-            # Keys / Drums have no strings — no tuning, no capo.
-            tuning = []
-            capo = 0
-
-        # Strict bool check — client JSON-derived; the string "false"
-        # would otherwise become truthy and silently enable drum_tab.
-        init_drums_raw = meta_in.get("init_drum_tab", True)
-        if not isinstance(init_drums_raw, bool):
+            if _r not in roster:
+                roster.append(_r)
+        want_vocals = "Vocals" in roster
+        instrument_roster = [r for r in roster if r in _INSTRUMENTS]
+        if not instrument_roster:
             return JSONResponse(
-                {"error": "init_drum_tab must be a boolean"}, 400,
+                {"error": (
+                    "select at least one instrument to chart "
+                    "(Lead, Rhythm, Bass, Keys, or Drums)"
+                )},
+                400,
             )
-        init_drums = init_drums_raw
-        # A Drums pack IS its drum tab — always seed it, regardless of the flag.
-        if arr_name == "Drums":
-            init_drums = True
+        # A Drums arrangement IS its drum tab — seed one iff Drums is selected.
+        init_drums = "Drums" in instrument_roster
 
         dlc_dir = get_dlc_dir()
         if not dlc_dir:
@@ -3602,12 +3660,14 @@ def _truncate_utf8(s: str, max_bytes: int) -> str:
         safe_a = _truncate_utf8(
             re.sub(r'[<>:"/\\|?*]', "_", artist), _MAX_FILENAME_PART_BYTES,
         ).rstrip(". ")
-        if not safe_t or not safe_a:
+        if not safe_t:
             return JSONResponse(
-                {"error": "title and artist must contain non-blank characters"},
+                {"error": "title must contain non-blank characters"},
                 400,
             )
-        new_filename = f"{safe_t}_{safe_a}.feedpak"
+        # Artist may be blank on a draft (or sanitise to empty) — fall back to a
+        # title-only filename rather than an ugly trailing-underscore name.
+        new_filename = f"{safe_t}_{safe_a}.feedpak" if safe_a else f"{safe_t}.feedpak"
         output_path = (dlc_dir / new_filename).resolve()
         # Containment check — the sanitiser above strips path separators,
         # but defend against a `.. .. ..` -style title that somehow
@@ -3656,6 +3716,9 @@ def _truncate_utf8(s: str, max_bytes: int) -> str:
                 ".mp3", ".wav", ".flac", ".m4a", ".ogg", ".opus",
                 ".aac", ".aiff", ".wma",
             }
+            # Stays None when no audio is supplied (draft-now): the encode block
+            # below is guarded on it and `ogg_path` stays None.
+            in_ext = None
             if audio is not None:
                 _raw_ext = Path(audio.filename or "audio").suffix.lower()
                 in_ext = _raw_ext if _raw_ext in _KNOWN_AUDIO_EXTS else ".bin"
@@ -3670,7 +3733,7 @@ def _truncate_utf8(s: str, max_bytes: int) -> str:
                         if not chunk:
                             break
                         dst.write(chunk)
-            else:
+            elif audio_url:
                 # Pre-uploaded audio: resolve the storage URL to a local
                 # file (validates containment) and copy it into the temp
                 # dir so the re-encode path below is identical to the
@@ -3685,66 +3748,78 @@ def _truncate_utf8(s: str, max_bytes: int) -> str:
                 in_path = upload_dir / f"upload{in_ext}"
                 shutil.copy2(resolved_audio, in_path)
 
-            ogg_path = upload_dir / "audio.ogg"
-            if in_ext == ".ogg":
-                # Rename instead of copy — both paths live in the same
-                # upload_dir (deleted at the end), so duplicating the
-                # bytes just doubles peak temp disk for nothing.
-                in_path.rename(ogg_path)
-                # Same min-size sanity check the re-encode branch
-                # enforces — a 0-byte / truncated .ogg would otherwise
-                # produce a sloppak that fails on first open.
-                if (not ogg_path.exists()
-                        or ogg_path.stat().st_size < 100):
-                    return JSONResponse(
-                        {"error": "uploaded .ogg is empty or too small to play"},
-                        400,
-                    )
-            else:
-                from lib.audio import _ffmpeg_cmd, _ffmpeg_wav_to_ogg
-                ffmpeg = _ffmpeg_cmd()
-                if not ffmpeg:
-                    return JSONResponse(
-                        {"error": "ffmpeg not available — can't re-encode audio"},
-                        500,
-                    )
-                try:
-                    r = await asyncio.get_event_loop().run_in_executor(
-                        None, _ffmpeg_wav_to_ogg, ffmpeg, in_path, ogg_path,
-                    )
-                except Exception:
-                    # str(e) on subprocess / OSError commonly embeds the
-                    # ffmpeg cmd line and absolute paths — log it
-                    # server-side and return a generic message.
-                    import logging as _log
-                    _log.getLogger("slopsmith.plugin.editor").exception(
-                        "create_sloppak: ffmpeg re-encode raised",
-                    )
-                    return JSONResponse(
-                        {"error": "audio re-encode failed — see server logs"},
-                        400,
-                    )
-                if (r.returncode != 0 or not ogg_path.exists()
-                        or ogg_path.stat().st_size < 100):
-                    return JSONResponse(
-                        {"error": "ffmpeg failed to decode the uploaded audio"},
-                        400,
-                    )
+            # None → no audio supplied: skip encode, leave ogg_path None so the
+            # write emits an empty `stems: []` draft.
+            ogg_path = None
+            if in_ext is not None:
+                ogg_path = upload_dir / "audio.ogg"
+                if in_ext == ".ogg":
+                    # Rename instead of copy — both paths live in the same
+                    # upload_dir (deleted at the end), so duplicating the
+                    # bytes just doubles peak temp disk for nothing.
+                    in_path.rename(ogg_path)
+                    # Same min-size sanity check the re-encode branch
+                    # enforces — a 0-byte / truncated .ogg would otherwise
+                    # produce a sloppak that fails on first open.
+                    if (not ogg_path.exists()
+                            or ogg_path.stat().st_size < 100):
+                        return JSONResponse(
+                            {"error": "uploaded .ogg is empty or too small to play"},
+                            400,
+                        )
+                else:
+                    from lib.audio import _ffmpeg_cmd, _ffmpeg_wav_to_ogg
+                    ffmpeg = _ffmpeg_cmd()
+                    if not ffmpeg:
+                        return JSONResponse(
+                            {"error": "ffmpeg not available — can't re-encode audio"},
+                            500,
+                        )
+                    try:
+                        r = await asyncio.get_event_loop().run_in_executor(
+                            None, _ffmpeg_wav_to_ogg, ffmpeg, in_path, ogg_path,
+                        )
+                    except Exception:
+                        # str(e) on subprocess / OSError commonly embeds the
+                        # ffmpeg cmd line and absolute paths — log it
+                        # server-side and return a generic message.
+                        import logging as _log
+                        _log.getLogger("slopsmith.plugin.editor").exception(
+                            "create_sloppak: ffmpeg re-encode raised",
+                        )
+                        return JSONResponse(
+                            {"error": "audio re-encode failed — see server logs"},
+                            400,
+                        )
+                    if (r.returncode != 0 or not ogg_path.exists()
+                            or ogg_path.stat().st_size < 100):
+                        return JSONResponse(
+                            {"error": "ffmpeg failed to decode the uploaded audio"},
+                            400,
+                        )
 
-            # Build the minimal in-memory shapes _write_sloppak_pak expects.
-            # Keys carry the spec `type: piano`; fretted/drums don't. All three
-            # open in the right editor mode by NAME (KEYS_PATTERN / ^drums).
-            arr_entry = {
-                "name": arr_name,
-                "tuning": tuning,
-                "capo": capo,
-                "notes": [],
-                "chords": [],
-                "chord_templates": [],
-            }
-            if arr_name == "Keys":
-                arr_entry["type"] = "piano"
-            arrangements_data = [arr_entry]
+            # Build one in-memory arrangement per instrument role in the roster.
+            # Fretted roles carry a default standard tuning (Bass 4 strings,
+            # guitar 6 — the editor extends the count after creation); Keys
+            # carries the spec `type: piano`; Drums opens the drum lane by name.
+            # Each opens in the right editor mode by NAME (KEYS_PATTERN / ^drums).
+            def _default_tuning(role: str) -> list:
+                if role in _FRETTED:
+                    return [0] * (4 if role == "Bass" else 6)
+                return []
+            arrangements_data = []
+            for _role in instrument_roster:
+                _arr = {
+                    "name": _role,
+                    "tuning": _default_tuning(_role),
+                    "capo": 0,
+                    "notes": [],
+                    "chords": [],
+                    "chord_templates": [],
+                }
+                if _role == "Keys":
+                    _arr["type"] = "piano"
+                arrangements_data.append(_arr)
             # Seed a minimal one-measure 4/4 @ 120 BPM grid (downbeat +
             # three sub-beats + next downbeat = 5 beats). The Tempo Map
             # editor bails when beats.length < 2 ("No beat grid…"), so
@@ -3783,12 +3858,78 @@ def _truncate_utf8(s: str, max_bytes: int) -> str:
                 return JSONResponse(
                     {"error": "year must be a number or string"}, 400,
                 )
+            # ── Spec-complete manifest metadata (feedpak §5.1) ──
+            # Every field is OPTIONAL and written through only when present.
+            def _opt_str(name):
+                v = meta_in.get(name)
+                if v is None:
+                    return ""
+                if not isinstance(v, str):
+                    raise ValueError(f"{name} must be a string")
+                return v.strip()
+
+            def _opt_int(name):
+                v = meta_in.get(name)
+                if v in (None, ""):
+                    return None
+                if isinstance(v, str) and v.strip().lstrip("-").isdigit():
+                    return int(v.strip())
+                if _is_int(v):
+                    return v
+                raise ValueError(f"{name} must be an integer")
+
+            try:
+                album_artist = _opt_str("album_artist")
+                language = _opt_str("language")
+                mbid = _opt_str("mbid").lower()
+                # ISRC: the bare 12-char code — strip the display hyphens/spaces
+                # and upper-case (feedpak §5.1). Not hard-rejected on length so a
+                # partial draft entry is tolerated.
+                isrc = re.sub(r"[\s-]", "", _opt_str("isrc")).upper()
+                track_no = _opt_int("track")
+                disc_no = _opt_int("disc")
+            except ValueError as _e:
+                return JSONResponse({"error": str(_e)}, 400)
+
+            # genres: accept a list OR a comma/newline string; normalise to a
+            # de-duped list of trimmed strings (most-specific first).
+            genres_in = meta_in.get("genres")
+            if isinstance(genres_in, str):
+                genres_in = re.split(r"[,\n]", genres_in)
+            genres: list[str] = []
+            if isinstance(genres_in, list):
+                _seen_g: set[str] = set()
+                for _g in genres_in:
+                    if isinstance(_g, str) and _g.strip() and _g.strip() not in _seen_g:
+                        _seen_g.add(_g.strip())
+                        genres.append(_g.strip())
+            elif genres_in is not None:
+                return JSONResponse(
+                    {"error": "genres must be a string or a list of strings"}, 400,
+                )
+
             meta_out = {
                 "title": title,
                 "artist": artist,
                 "album": album_raw,
                 "year": year_raw,
             }
+            if authors:
+                meta_out["authors"] = authors
+            if album_artist:
+                meta_out["album_artist"] = album_artist
+            if track_no is not None:
+                meta_out["track"] = track_no
+            if disc_no is not None:
+                meta_out["disc"] = disc_no
+            if genres:
+                meta_out["genres"] = genres
+            if mbid:
+                meta_out["mbid"] = mbid
+            if isrc:
+                meta_out["isrc"] = isrc
+            if language:
+                meta_out["language"] = language
 
             drum_tab: dict | None = None
             if init_drums:
@@ -3800,6 +3941,11 @@ def _truncate_utf8(s: str, max_bytes: int) -> str:
                     "hits": [],
                 }
 
+            # Vocals in the roster seeds an EMPTY lyrics track (feedpak models
+            # vocals as side-files, not an arrangement). An empty list is a valid
+            # lyrics.json — the author fills syllables in later.
+            lyrics_seed: list | None = [] if want_vocals else None
+
             # Probe the actual audio duration so the sloppak's
             # manifest.duration reflects the song, not the 2-second
             # placeholder beat grid. Best-effort: if the probe fails
@@ -3811,7 +3957,7 @@ def _truncate_utf8(s: str, max_bytes: int) -> str:
                 ffprobe = _bundled_or_path("ffprobe") or shutil.which("ffprobe")
             except Exception:
                 ffprobe = shutil.which("ffprobe")
-            if ffprobe:
+            if ffprobe and ogg_path is not None:
                 try:
                     pr = await asyncio.get_event_loop().run_in_executor(
                         None,
@@ -3831,8 +3977,15 @@ def _truncate_utf8(s: str, max_bytes: int) -> str:
                     audio_duration = None
 
             def _do_write():
+                # Auto-generate the hover-to-listen preview from the master audio
+                # (no manual upload) — best-effort; absent for audio-less drafts.
+                preview_clip = ""
+                if ogg_path is not None:
+                    _pv = _make_preview_clip(Path(ogg_path), upload_dir)
+                    if _pv:
+                        preview_clip = str(_pv)
                 return _write_sloppak_pak(
-                    audio_file=str(ogg_path),
+                    audio_file=(str(ogg_path) if ogg_path is not None else ""),
                     art_path=art_path,
                     arrangements_data=arrangements_data,
                     beats=beats,
@@ -3840,6 +3993,8 @@ def _do_write():
                     meta=meta_out,
                     output_path=output_path,
                     drum_tab=drum_tab,
+                    lyrics=lyrics_seed,
+                    preview_path=preview_clip,
                     fail_if_exists=True,
                     duration_override=audio_duration,
                 )
@@ -3936,11 +4091,17 @@ async def upload_audio(file: UploadFile = File(...)):
             dest = STORAGE_DIR / f"editor_audio_{audio_id}{out_path.suffix.lower()}"
             shutil.copy2(out_path, dest)
             shutil.rmtree(out_path.parent, ignore_errors=True)
-            return {"audio_url": f"{STORAGE_URL}/{dest.name}"}
+            _dur = await asyncio.get_event_loop().run_in_executor(
+                None, _probe_audio_duration, dest)
+            return {"audio_url": f"{STORAGE_URL}/{dest.name}", "duration": _dur}
 
         dest = STORAGE_DIR / f"editor_audio_{audio_id}{ext}"
         dest.write_bytes(content)
-        return {"audio_url": f"{STORAGE_URL}/editor_audio_{audio_id}{ext}"}
+        # Duration lets the create modal's MusicBrainz "Match" rank candidates by
+        # how close their length is to this master audio (the studio-vs-live tell).
+        _dur = await asyncio.get_event_loop().run_in_executor(
+            None, _probe_audio_duration, dest)
+        return {"audio_url": f"{STORAGE_URL}/editor_audio_{audio_id}{ext}", "duration": _dur}
 
     # ── Download audio from YouTube ──────────────────────────────────
 
@@ -4067,6 +4228,11 @@ async def replace_audio(data: dict):
                 manifest = dict(session["sloppak_state"].get("manifest") or {})
                 rel = f"stems/{dest.name}"
                 manifest["stems"] = [{"id": "full", "file": rel}]
+                # Regenerate the auto preview from the new master audio so a draft
+                # that had no audio at create (and thus no preview) gets one now.
+                _pv = _make_preview_clip(dest, source_dir)
+                if _pv and _pv.exists():
+                    manifest["preview"] = _pv.name
                 (source_dir / "manifest.yaml").write_text(
                     yaml.safe_dump(manifest, sort_keys=False, allow_unicode=True),
                     encoding="utf-8",
@@ -4142,9 +4308,30 @@ def _detect_embedded():
             None, _detect_embedded
         )
 
+        # Song metadata for non-destructive autofill of the create modal's
+        # Title / Artist / Album fields (convert-gp reads those same fields, so
+        # this just saves retyping). Best-effort — a parse failure returns blanks
+        # and the modal simply falls back to the filename-derived title.
+        def _gp_song_meta():
+            try:
+                import guitarpro
+                song = guitarpro.parse(gp_path)
+                return {
+                    "title": (getattr(song, "title", "") or "").strip(),
+                    "artist": (getattr(song, "artist", "") or "").strip(),
+                    "album": (getattr(song, "album", "") or "").strip(),
+                }
+            except Exception:
+                return {"title": "", "artist": "", "album": ""}
+
+        song_meta = await asyncio.get_event_loop().run_in_executor(
+            None, _gp_song_meta
+        )
+
         return {"gp_path": gp_path, "tracks": tracks,
                 "has_embedded_audio": has_audio,
-                "sync_point_count": sync_count}
+                "sync_point_count": sync_count,
+                "song": song_meta}
 
 
 
@@ -5679,10 +5866,77 @@ def _build_sloppak():
 
     # ── Helpers ──────────────────────────────────────────────────────────
 
+    def _probe_audio_duration(path) -> "float | None":
+        """Best-effort audio duration in seconds via ffprobe (None on failure)."""
+        try:
+            from lib.audio import _bundled_or_path
+            ffprobe = _bundled_or_path("ffprobe") or shutil.which("ffprobe")
+        except Exception:
+            ffprobe = shutil.which("ffprobe")
+        if not ffprobe:
+            return None
+        try:
+            pr = subprocess.run(
+                [ffprobe, "-v", "error", "-show_entries", "format=duration",
+                 "-of", "csv=p=0", str(path)],
+                capture_output=True, timeout=15,
+            )
+            if pr.returncode == 0:
+                return round(float(pr.stdout.strip()), 3)
+        except Exception:
+            pass
+        return None
+
+    def _make_preview_clip(src: "Path", out_dir: "Path",
+                           clip_seconds: float = 28.0) -> "Path | None":
+        """Auto-generate a short hover-to-listen preview from the master audio —
+        an OGG snippet starting ~20% into the song (past most intros). Best-effort:
+        returns None if ffmpeg is unavailable or the source is missing/too short.
+        Replaces the old manual "Preview Clip" upload."""
+        try:
+            from lib.audio import _ffmpeg_cmd
+            ffmpeg = _ffmpeg_cmd()
+        except Exception:
+            ffmpeg = None
+        if not ffmpeg or not src or not Path(src).exists():
+            return None
+        start, dur = 0.0, None
+        try:
+            from lib.audio import _bundled_or_path
+            ffprobe = _bundled_or_path("ffprobe") or shutil.which("ffprobe")
+        except Exception:
+            ffprobe = shutil.which("ffprobe")
+        if ffprobe:
+            try:
+                pr = subprocess.run(
+                    [ffprobe, "-v", "error", "-show_entries", "format=duration",
+                     "-of", "csv=p=0", str(src)],
+                    capture_output=True, timeout=15,
+                )
+                if pr.returncode == 0:
+                    dur = float(pr.stdout.strip())
+            except Exception:
+                dur = None
+        if dur and dur > clip_seconds + 2:
+            start = max(0.0, min(dur * 0.2, dur - clip_seconds))
+        out = out_dir / "preview.ogg"
+        try:
+            subprocess.run(
+                [ffmpeg, "-y", "-ss", str(round(start, 3)), "-t", str(clip_seconds),
+                 "-i", str(src), "-vn", "-c:a", "libvorbis", "-q:a", "4", str(out)],
+                capture_output=True, timeout=60,
+            )
+        except Exception:
+            return None
+        if out.exists() and out.stat().st_size > 100:
+            return out
+        return None
+
     def _write_sloppak_pak(*, audio_file: str, art_path: str,
                           arrangements_data: list, beats: list, sections: list,
                           meta: dict, output_path: Path,
                           drum_tab: dict | None = None,
+                          lyrics: list | None = None,
                           preview_path: str = "",
                           fail_if_exists: bool = False,
                           duration_override: float | None = None) -> str:
@@ -5700,7 +5954,11 @@ def _write_sloppak_pak(*, audio_file: str, art_path: str,
         path writes drum_tab via its own staging logic, not through
         this helper.
         """
-        if not audio_file or not Path(audio_file).exists():
+        # Draft-now packs carry no audio (audio_file == ""): emit an empty
+        # `stems: []` the author fills in later via Replace Audio. A NON-empty
+        # audio_file that doesn't resolve is still a real error.
+        _has_audio = bool(audio_file)
+        if _has_audio and not Path(audio_file).exists():
             raise RuntimeError("No audio file available for sloppak write")
         # Sloppak supports a packed-zip form (foo.sloppak file) and an
         # authoring directory form (foo.sloppak/ tree). Replacing a
@@ -5734,35 +5992,38 @@ def _write_sloppak_pak(*, audio_file: str, art_path: str,
             # it `audio.ogg` here meant those consumers couldn't find the mix.
             # Transcode to OGG when the source isn't already OGG so playback
             # works regardless of the uploaded audio format.
-            audio_ext = Path(audio_file).suffix.lower()
-            if audio_ext == ".ogg":
-                stem_filename = "full.ogg"
-                shutil.copy2(audio_file, stems_dir / stem_filename)
-            else:
-                # Try to transcode to the conventional `full.ogg` so on-create
-                # stem separation can find the source mix.
-                try:
-                    from lib.audio import _ffmpeg_cmd, _ffmpeg_wav_to_ogg
-                    _ff = _ffmpeg_cmd()
-                except Exception:
-                    _ff = None
-                _ogg_dest = stems_dir / "full.ogg"
-                _ok = False
-                if _ff:
-                    _r = _ffmpeg_wav_to_ogg(_ff, Path(audio_file), _ogg_dest)
-                    _ok = (_r.returncode == 0 and _ogg_dest.exists()
-                           and _ogg_dest.stat().st_size >= 100)
-                if _ok:
+            # No audio (draft): stem_filename stays None -> manifest `stems: []`.
+            stem_filename = None
+            if _has_audio:
+                audio_ext = Path(audio_file).suffix.lower()
+                if audio_ext == ".ogg":
                     stem_filename = "full.ogg"
-                else:
-                    # ffmpeg unavailable or transcode failed — keep the source
-                    # under its REAL extension (and point the manifest at it)
-                    # rather than writing mislabeled bytes to a `.ogg` name,
-                    # which would break decode/playback. Stem-split (which keys
-                    # on full.ogg) is best-effort and simply won't run here.
-                    _ogg_dest.unlink(missing_ok=True)
-                    stem_filename = f"full{audio_ext}"
                     shutil.copy2(audio_file, stems_dir / stem_filename)
+                else:
+                    # Try to transcode to the conventional `full.ogg` so on-create
+                    # stem separation can find the source mix.
+                    try:
+                        from lib.audio import _ffmpeg_cmd, _ffmpeg_wav_to_ogg
+                        _ff = _ffmpeg_cmd()
+                    except Exception:
+                        _ff = None
+                    _ogg_dest = stems_dir / "full.ogg"
+                    _ok = False
+                    if _ff:
+                        _r = _ffmpeg_wav_to_ogg(_ff, Path(audio_file), _ogg_dest)
+                        _ok = (_r.returncode == 0 and _ogg_dest.exists()
+                               and _ogg_dest.stat().st_size >= 100)
+                    if _ok:
+                        stem_filename = "full.ogg"
+                    else:
+                        # ffmpeg unavailable or transcode failed — keep the source
+                        # under its REAL extension (and point the manifest at it)
+                        # rather than writing mislabeled bytes to a `.ogg` name,
+                        # which would break decode/playback. Stem-split (which keys
+                        # on full.ogg) is best-effort and simply won't run here.
+                        _ogg_dest.unlink(missing_ok=True)
+                        stem_filename = f"full{audio_ext}"
+                        shutil.copy2(audio_file, stems_dir / stem_filename)
 
             used_ids: set[str] = set()
             manifest_arrangements = []
@@ -5865,13 +6126,41 @@ def _write_sloppak_pak(*, audio_file: str, art_path: str,
                 # `id: "full"` matches the convention the editor's load
                 # path and replace-audio path already use; sloppak
                 # readers prefer that id when picking the default stem.
-                "stems": [
-                    {"id": "full", "file": f"stems/{stem_filename}"},
-                ],
+                # Draft packs (no audio yet) carry an empty stems list — the
+                # loader tolerates it (audio_url resolves to null) and Replace
+                # Audio fills it in later.
+                "stems": (
+                    [{"id": "full", "file": f"stems/{stem_filename}"}]
+                    if stem_filename else []
+                ),
                 "arrangements": manifest_arrangements,
             }
             if year:
                 manifest["year"] = year
+            # Optional author credits (feedpak `authors:` array). Written only
+            # when non-empty so packs without credits stay byte-identical.
+            _authors = meta.get("authors")
+            if isinstance(_authors, list):
+                _authors = [str(a).strip() for a in _authors if str(a).strip()]
+                if _authors:
+                    manifest["authors"] = _authors
+
+            # Spec-complete optional metadata (feedpak §5.1) — written only when
+            # present so packs without them stay minimal. String scalars,
+            # int scalars (track/disc), and the genres list.
+            for _mk in ("album_artist", "mbid", "isrc", "language"):
+                _mv = meta.get(_mk)
+                if isinstance(_mv, str) and _mv.strip():
+                    manifest[_mk] = _mv.strip()
+            for _mk in ("track", "disc"):
+                _mv = meta.get(_mk)
+                if isinstance(_mv, int) and not isinstance(_mv, bool):
+                    manifest[_mk] = _mv
+            _genres = meta.get("genres")
+            if isinstance(_genres, list):
+                _genres = [str(g).strip() for g in _genres if str(g).strip()]
+                if _genres:
+                    manifest["genres"] = _genres
 
             if art_path and Path(art_path).exists():
                 cover_ext = Path(art_path).suffix.lower() or ".jpg"
@@ -5908,6 +6197,17 @@ def _write_sloppak_pak(*, audio_file: str, art_path: str,
                 )
                 manifest["drum_tab"] = "drum_tab.json"
 
+            # Vocals seed: an empty (or authored) lyrics track. feedpak §7.1
+            # lyrics.json is a flat array of syllables — an empty array is a
+            # valid, empty track the author fills in later.
+            if isinstance(lyrics, list):
+                (staging / "lyrics.json").write_text(
+                    json.dumps(lyrics, separators=(",", ":")),
+                    encoding="utf-8",
+                )
+                manifest["lyrics"] = "lyrics.json"
+                manifest["lyrics_source"] = "authored"
+
             (staging / "manifest.yaml").write_text(
                 yaml.safe_dump(manifest, sort_keys=False, allow_unicode=True),
                 encoding="utf-8",
diff --git a/screen.html b/screen.html
index 8bcc313d..cfe1d31a 100644
--- a/screen.html
+++ b/screen.html
@@ -125,17 +125,21 @@
 
 <!-- Load modal -->
 <div id="editor-load-modal" class="hidden absolute inset-0 z-50 flex items-center justify-center" style="background:rgba(0,0,0,0.7)">
-    <div class="bg-dark-700 rounded-xl border border-gray-700 w-full max-w-md max-h-[70vh] flex flex-col">
+    <div class="bg-dark-700 rounded-xl border border-gray-700 w-full max-w-lg max-h-[75vh] flex flex-col">
         <div class="flex items-center justify-between px-4 py-3 border-b border-gray-700">
-            <span class="text-sm font-medium">Load custom song</span>
+            <span class="text-sm font-medium">Load a feedpak</span>
             <button onclick="editorHideLoadModal()" class="text-gray-500 hover:text-white">&times;</button>
         </div>
+        <div class="px-4 pt-3 pb-1">
+            <div class="text-[11px] text-gray-500 mb-1">Song library folder</div>
+            <div id="editor-load-path" title="" class="text-xs text-gray-400 bg-dark-800 border border-gray-700 rounded px-2 py-1 truncate">—</div>
+        </div>
         <div class="px-4 py-2">
-            <input id="editor-load-search" type="text" placeholder="Search by song, artist, or filename..." oninput="editorFilterSongs(this.value)"
+            <input id="editor-load-search" type="text" placeholder="Search all folders by song, artist, or filename…" oninput="editorFilterSongs(this.value)"
                 class="w-full bg-dark-800 border border-gray-700 rounded px-3 py-1.5 text-sm text-gray-300 outline-none focus:border-accent/50">
         </div>
         <div id="editor-load-list" class="flex-1 overflow-y-auto px-2 pb-2">
-            <div class="text-xs text-gray-500 p-2">Loading...</div>
+            <div class="text-xs text-gray-500 p-2">Loading…</div>
         </div>
     </div>
 </div>
@@ -158,64 +162,68 @@
 
 <!-- Create custom song modal -->
 <div id="editor-create-modal" class="hidden absolute inset-0 z-50 flex items-center justify-center" style="background:rgba(0,0,0,0.7)">
-    <div class="bg-dark-700 rounded-xl border border-gray-700 w-full max-w-lg max-h-[85vh] flex flex-col overflow-y-auto">
+    <div class="bg-dark-700 rounded-xl border border-gray-700 w-full max-w-4xl max-h-[85vh] flex flex-col overflow-y-auto">
         <div class="flex items-center justify-between px-4 py-3 border-b border-gray-700 shrink-0">
-            <span class="text-sm font-medium">Create New custom song</span>
+            <span class="text-sm font-medium">Create New Arrangement</span>
             <button onclick="editorHideCreateModal()" class="text-gray-500 hover:text-white">&times;</button>
         </div>
-        <div class="p-4 space-y-4">
-
-            <!-- How to start: Blank is first-class (audio only); GP / EOF import a chart. -->
-            <div>
-                <div class="aud-seg-wrap" role="tablist" aria-label="How to start the new song">
-                    <button type="button" onclick="editorSetCreateMode('blank')" id="editor-create-mode-blank-btn" class="aud-seg is-active">Blank</button>
-                    <button type="button" onclick="editorSetCreateMode('gp')" id="editor-create-mode-gp-btn" class="aud-seg">Guitar Pro</button>
-                    <button type="button" onclick="editorSetCreateMode('eof')" id="editor-create-mode-eof-btn" class="aud-seg">EOF XML</button>
-                </div>
-                <p id="editor-create-mode-hint" class="text-[11px] text-gray-600 mt-1"></p>
-            </div>
+        <div class="p-4">
+
+            <!-- One menu: pick a roster ("What are you arranging?"), optionally
+                 import a chart/audio, fill in details. editorDoCreate() routes on
+                 what you give it. Only a title + one instrument are required. -->
+            <p class="text-[11px] text-gray-500">
+                Pick what you're arranging and give it a <span class="text-gray-300">title</span> — everything else is optional.
+                Import a chart or audio to start from, or build from scratch and add content later.
+            </p>
 
-            <!-- Guitar Pro file (GP mode) -->
-            <div id="editor-create-mode-gp" class="create-mode-sec hidden">
-                <label class="text-xs font-medium text-gray-400 mb-1 block">Guitar Pro File <span id="editor-create-gp-opt" class="text-gray-600">(.gp3/.gp4/.gp5/.gpx/.gp)</span></label>
-                <input type="file" id="editor-create-gp" accept=".gp3,.gp4,.gp5,.gpx,.gp"
-                    onchange="editorGPFileSelected(this)"
-                    class="w-full text-xs text-gray-400 file:mr-3 file:py-1 file:px-3 file:rounded file:border-0 file:text-xs file:bg-dark-600 file:text-gray-300 hover:file:bg-dark-500">
+            <!-- Two columns so the modal is wide, not tall: LEFT = where the chart
+                 comes from, RIGHT = audio + song details. Full-width Create below. -->
+            <div class="grid grid-cols-2 gap-4 mt-4 items-start">
+
+              <!-- ===== LEFT: chart source ===== -->
+              <div class="space-y-4">
+
+            <!-- What are you arranging? — click to add a role, drag chips to
+                 reorder. No string counts here (set in the editor: 6-string
+                 covers up to 9-string guitar, 4-string bass up to 6). -->
+            <div class="space-y-2 rounded-lg border border-gray-800 p-3">
+                <div class="text-xs font-semibold text-gray-300">What are you arranging?</div>
+                <p class="text-[11px] text-gray-600">Click to add. Drag the chips below to reorder.</p>
+                <div id="editor-create-roster-palette" class="flex flex-wrap gap-1"></div>
+                <div class="text-[11px] text-gray-500 pt-1">Your arrangements <span class="text-gray-600">(drag to reorder)</span>:</div>
+                <div id="editor-create-roster-selected" style="min-height:40px" class="flex flex-wrap gap-1 bg-dark-800 rounded p-2"></div>
+                <p id="editor-create-roster-hint" class="text-[11px] text-gray-600"></p>
             </div>
 
-            <!-- EOF (Editor on Fire) arrangement XML (EOF mode) -->
-            <div id="editor-create-mode-eof" class="create-mode-sec hidden">
-                <label class="text-xs font-medium text-gray-400 mb-1 block">EOF Arrangement XML <span class="text-gray-600">(.xml — one or more)</span></label>
-                <input type="file" id="editor-create-eof" accept=".xml" multiple
-                    onchange="editorEofFilesSelected(this)"
-                    class="w-full text-xs text-gray-400 file:mr-3 file:py-1 file:px-3 file:rounded file:border-0 file:text-xs file:bg-dark-600 file:text-gray-300 hover:file:bg-dark-500">
-                <p class="text-[11px] text-gray-600 mt-1">Select the EOF arrangement file(s), then set the audio, art, preview and details below and click Import.</p>
+            <!-- Content Import — one browse for every format feedBack reads. -->
+            <div class="space-y-2 rounded-lg border border-gray-800 p-3">
+                <div class="text-xs font-semibold text-gray-300">Content Import <span class="text-gray-600 font-normal">— optional</span></div>
+                <p class="text-[11px] text-gray-600">Add a master audio track and/or a chart to start from — you can add both. feedBack accepts <span class="text-gray-400">audio</span> (MP3/WAV/FLAC/OGG/M4A), <span class="text-gray-400">Guitar Pro</span> (.gp3–.gp8), <span class="text-gray-400">MIDI</span> (.mid), and <span class="text-gray-400">EOF/RS arrangement XML</span>. PowerTab &amp; MusicXML are coming.</p>
+                <!-- Staged files (rendered by renderStaged): the honesty surface -->
+                <div id="editor-create-staged" class="space-y-1"></div>
+                <!-- Hidden multi-file input, driven by the styled "+ Add file" label -->
+                <label for="editor-create-import"
+                    class="inline-block cursor-pointer px-2 py-1 rounded text-xs font-medium bg-dark-600 text-gray-300 hover:bg-dark-500">+ Add file(s)</label>
+                <input type="file" id="editor-create-import" multiple class="hidden"
+                    accept=".mp3,.wav,.flac,.ogg,.m4a,.opus,.aac,.wem,.gp3,.gp4,.gp5,.gpx,.gp,.mid,.midi,.xml"
+                    onchange="editorContentImportSelected(this)">
+                <div class="flex items-center gap-2">
+                    <span class="text-[11px] text-gray-600 shrink-0">or paste a YouTube URL</span>
+                    <input type="text" id="editor-create-yt-url" placeholder="https://youtube.com/watch?v=..."
+                        oninput="editorYtUrlInput()"
+                        class="flex-1 bg-dark-800 border border-gray-700 rounded px-2 py-1 text-xs text-gray-300 outline-none focus:border-accent/50">
+                </div>
+                <div id="editor-create-import-status" class="text-[11px] text-gray-500"></div>
             </div>
 
-            <!-- Track selection (shown after GP upload) -->
+            <!-- Track selection (shown after a Guitar Pro import) -->
             <div id="editor-create-tracks" class="hidden">
                 <label class="text-xs font-medium text-gray-400 mb-1 block">Select Tracks</label>
                 <div id="editor-create-track-list" class="space-y-1 max-h-32 overflow-y-auto bg-dark-800 rounded p-2">
                 </div>
             </div>
 
-            <!-- Blank-chart options (audio-only feedpak; Blank mode) -->
-            <div id="editor-create-blank-opts" class="create-mode-sec hidden space-y-2">
-                <div>
-                    <label class="text-xs font-medium text-gray-400 mb-1 block">Initial Arrangement</label>
-                    <div id="editor-create-arr-buttons" class="flex flex-wrap gap-1"></div>
-                </div>
-                <div id="editor-create-strings-row">
-                    <label class="text-xs font-medium text-gray-400 mb-1 block">Strings</label>
-                    <div id="editor-create-strings-buttons" class="flex flex-wrap gap-1"></div>
-                    <p class="text-[11px] text-gray-600 mt-1">Standard tuning for the chosen string count — fine-tune later from the editor toolbar.</p>
-                </div>
-                <label class="flex items-center gap-2 cursor-pointer">
-                    <input type="checkbox" id="editor-create-drum-tab" checked class="cursor-pointer">
-                    <span class="text-sm">Also start an empty drum tab</span>
-                </label>
-            </div>
-
             <!-- GP8 embedded audio banner (shown only when GP8 file has embedded audio) -->
             <div id="editor-gp8-audio-banner" class="hidden rounded-lg border border-accent/30 bg-accent/5 p-3">
                 <div class="flex items-start gap-2">
@@ -255,73 +263,120 @@
                 </div>
             </div>
 
-            <!-- Step 2: Audio source -->
-            <div>
-                <label class="text-xs font-medium text-gray-400 mb-1 block">Audio Source</label>
-                <div class="aud-seg-wrap" role="tablist" aria-label="Audio source">
-                    <button onclick="editorSetAudioMode('file')" id="editor-audio-mode-file"
-                        class="aud-seg is-active">Upload File</button>
-                    <button onclick="editorSetAudioMode('youtube')" id="editor-audio-mode-yt"
-                        class="aud-seg">YouTube URL</button>
-                </div>
-                <!-- File upload -->
-                <div id="editor-audio-file-input">
-                    <input type="file" id="editor-create-audio" accept=".wem,.ogg,.flac,.mp3,.wav,.m4a,.opus"
-                        class="w-full text-xs text-gray-400 file:mr-3 file:py-1 file:px-3 file:rounded file:border-0 file:text-xs file:bg-dark-600 file:text-gray-300 hover:file:bg-dark-500">
-                </div>
-                <!-- YouTube URL -->
-                <div id="editor-audio-yt-input" class="hidden">
-                    <input type="text" id="editor-create-yt-url" placeholder="https://youtube.com/watch?v=..."
-                        class="w-full bg-dark-800 border border-gray-700 rounded px-3 py-1.5 text-sm text-gray-300 outline-none focus:border-accent/50">
+              </div><!-- /LEFT column -->
+
+              <!-- ===== RIGHT: album art + song details ===== -->
+              <div class="space-y-4">
+
+            <!-- Album Art — promoted to a proper preview + browse on the wide side. -->
+            <div class="rounded-lg border border-gray-800 p-3">
+                <div class="text-xs font-semibold text-gray-300 mb-2">Album Art <span class="text-gray-600 font-normal">— optional</span></div>
+                <div class="flex items-center gap-3">
+                    <div id="editor-create-art-preview" style="width:5.5rem;height:5.5rem;background-size:cover;background-position:center"
+                        class="rounded bg-dark-800 border border-gray-700 flex items-center justify-center text-gray-600 text-[10px] text-center shrink-0 overflow-hidden">No art yet</div>
+                    <div class="flex-1">
+                        <input type="file" id="editor-create-art" accept=".png,.jpg,.jpeg,.dds"
+                            onchange="editorCreateArtSelected(this)"
+                            class="w-full text-xs text-gray-400 file:mr-3 file:py-1 file:px-3 file:rounded file:border-0 file:text-xs file:bg-dark-600 file:text-gray-300 hover:file:bg-dark-500">
+                        <p class="text-[11px] text-gray-600 mt-1">PNG or JPG. Shown in the library and player.</p>
+                    </div>
                 </div>
-                <div id="editor-audio-status" class="text-xs text-gray-500 mt-1"></div>
             </div>
 
-            <!-- Step 3: Metadata -->
-            <div class="grid grid-cols-2 gap-3">
-                <div>
-                    <label class="text-xs text-gray-500">Title</label>
-                    <input type="text" id="editor-create-title" placeholder="Song Title"
-                        class="w-full bg-dark-800 border border-gray-700 rounded px-2 py-1 text-xs text-gray-300 outline-none">
-                </div>
-                <div>
-                    <label class="text-xs text-gray-500">Artist</label>
-                    <input type="text" id="editor-create-artist" placeholder="Artist Name"
-                        class="w-full bg-dark-800 border border-gray-700 rounded px-2 py-1 text-xs text-gray-300 outline-none">
-                </div>
-                <div>
-                    <label class="text-xs text-gray-500">Album</label>
-                    <input type="text" id="editor-create-album" placeholder="Album"
-                        class="w-full bg-dark-800 border border-gray-700 rounded px-2 py-1 text-xs text-gray-300 outline-none">
+            <!-- Song details — the manifest metadata the feedpak spec models (§5.1). -->
+            <div class="rounded-lg border border-gray-800 p-3 space-y-2">
+                <div class="text-xs font-semibold text-gray-300">Song details</div>
+                <div id="editor-create-autofill-note" class="text-[11px] text-accent"></div>
+                <div class="grid grid-cols-2 gap-2">
+                    <div>
+                        <label class="text-xs text-gray-500">Title <span class="text-gray-600">(required)</span></label>
+                        <input type="text" id="editor-create-title" placeholder="Song title"
+                            class="w-full bg-dark-800 border border-gray-700 rounded px-2 py-1 text-xs text-gray-300 outline-none">
+                    </div>
+                    <div>
+                        <label class="text-xs text-gray-500">Artist</label>
+                        <input type="text" id="editor-create-artist" placeholder="Performing artist"
+                            class="w-full bg-dark-800 border border-gray-700 rounded px-2 py-1 text-xs text-gray-300 outline-none">
+                    </div>
+                    <div>
+                        <label class="text-xs text-gray-500">Album</label>
+                        <input type="text" id="editor-create-album" placeholder="Album"
+                            class="w-full bg-dark-800 border border-gray-700 rounded px-2 py-1 text-xs text-gray-300 outline-none">
+                    </div>
+                    <div>
+                        <label class="text-xs text-gray-500">Album artist</label>
+                        <input type="text" id="editor-create-album-artist" placeholder="For compilations"
+                            class="w-full bg-dark-800 border border-gray-700 rounded px-2 py-1 text-xs text-gray-300 outline-none">
+                    </div>
+                    <div>
+                        <label class="text-xs text-gray-500">Year</label>
+                        <input type="text" id="editor-create-year" placeholder="2024" inputmode="numeric"
+                            class="w-full bg-dark-800 border border-gray-700 rounded px-2 py-1 text-xs text-gray-300 outline-none">
+                    </div>
+                    <div class="grid grid-cols-2 gap-2">
+                        <div>
+                            <label class="text-xs text-gray-500">Track #</label>
+                            <input type="text" id="editor-create-track" placeholder="1" inputmode="numeric"
+                                class="w-full bg-dark-800 border border-gray-700 rounded px-2 py-1 text-xs text-gray-300 outline-none">
+                        </div>
+                        <div>
+                            <label class="text-xs text-gray-500">Disc #</label>
+                            <input type="text" id="editor-create-disc" placeholder="1" inputmode="numeric"
+                                class="w-full bg-dark-800 border border-gray-700 rounded px-2 py-1 text-xs text-gray-300 outline-none">
+                        </div>
+                    </div>
+                    <div>
+                        <label class="text-xs text-gray-500">Genre(s)</label>
+                        <input type="text" id="editor-create-genre" placeholder="Rock, Metal"
+                            class="w-full bg-dark-800 border border-gray-700 rounded px-2 py-1 text-xs text-gray-300 outline-none">
+                    </div>
+                    <div>
+                        <label class="text-xs text-gray-500">Language</label>
+                        <input type="text" id="editor-create-language" placeholder="en"
+                            class="w-full bg-dark-800 border border-gray-700 rounded px-2 py-1 text-xs text-gray-300 outline-none">
+                    </div>
+                    <div>
+                        <label class="text-xs text-gray-500">ISRC</label>
+                        <input type="text" id="editor-create-isrc" placeholder="USABC2400001"
+                            class="w-full bg-dark-800 border border-gray-700 rounded px-2 py-1 text-xs text-gray-300 outline-none">
+                    </div>
+                    <div>
+                        <label class="text-xs text-gray-500">MusicBrainz ID</label>
+                        <input type="text" id="editor-create-mbid" placeholder="recording MBID"
+                            class="w-full bg-dark-800 border border-gray-700 rounded px-2 py-1 text-xs text-gray-300 outline-none">
+                    </div>
                 </div>
                 <div>
-                    <label class="text-xs text-gray-500">Year</label>
-                    <input type="text" id="editor-create-year" placeholder="2024"
+                    <label class="text-xs text-gray-500">Chart author(s)</label>
+                    <input type="text" id="editor-create-authors" placeholder="Who charted this — separate names with commas"
                         class="w-full bg-dark-800 border border-gray-700 rounded px-2 py-1 text-xs text-gray-300 outline-none">
+                    <p class="text-[11px] text-gray-600 mt-1">Credited in the feedpak (spec <span class="text-gray-500">authors</span>) — distinct from the performing artist.</p>
                 </div>
             </div>
 
-            <!-- Album art -->
-            <div>
-                <label class="text-xs text-gray-500">Album Art (optional)</label>
-                <input type="file" id="editor-create-art" accept=".png,.jpg,.jpeg,.dds"
-                    class="w-full text-xs text-gray-400 file:mr-3 file:py-1 file:px-3 file:rounded file:border-0 file:text-xs file:bg-dark-600 file:text-gray-300 hover:file:bg-dark-500">
+            <!-- MusicBrainz match — scan-first: uses the Title/Artist already on
+                 the form; the popup lets you refine the query + pick a record. -->
+            <div class="rounded-lg border border-gray-800 p-3">
+                <div class="flex items-center justify-between gap-2">
+                    <div>
+                        <div class="text-xs font-semibold text-gray-300">Match metadata</div>
+                        <p class="text-[11px] text-gray-600">Look this song up on MusicBrainz and fill the details.</p>
+                    </div>
+                    <button type="button" id="editor-create-mb-btn" onclick="editorMbMatch()"
+                        class="px-2 py-1 rounded text-xs font-medium bg-dark-600 text-gray-300 hover:bg-dark-500 disabled:opacity-50 disabled:cursor-not-allowed shrink-0">Match…</button>
+                </div>
+                <div id="editor-create-mb-hint" class="text-[11px] text-gray-600 mt-1"></div>
             </div>
 
-            <!-- Preview clip -->
-            <div>
-                <label class="text-xs text-gray-500">Preview Clip (optional)</label>
-                <input type="file" id="editor-create-preview" accept=".wem,.ogg,.flac,.mp3,.wav,.m4a,.opus"
-                    class="w-full text-xs text-gray-400 file:mr-3 file:py-1 file:px-3 file:rounded file:border-0 file:text-xs file:bg-dark-600 file:text-gray-300 hover:file:bg-dark-500">
-                <p class="text-[11px] text-gray-600 mt-1">Baked into the .sloppak when you Build. Plays on hover in the library only if the Song Preview plugin is installed.</p>
-            </div>
+            <!-- Create button — works for import (GP/EOF) and from-scratch alike -->
+              </div><!-- /RIGHT column -->
+            </div><!-- /two-column grid -->
 
-            <!-- Import button -->
             <button onclick="editorDoCreate()" id="editor-create-go"
-                class="w-full px-4 py-2 bg-green-700 hover:bg-green-600 rounded-lg text-sm font-medium disabled:opacity-50 disabled:cursor-not-allowed" disabled>
-                Import & Open in Editor
+                class="w-full px-4 py-2 bg-green-700 hover:bg-green-600 rounded-lg text-sm font-medium disabled:opacity-50 disabled:cursor-not-allowed mt-4" disabled>
+                Create &amp; Open in Editor
             </button>
-            <div id="editor-create-status" class="text-xs text-gray-500"></div>
+            <div id="editor-create-status" class="text-xs text-gray-500 mt-2"></div>
         </div>
     </div>
 </div>
diff --git a/screen.js b/screen.js
index fbfacc16..0ee2ccd8 100644
--- a/screen.js
+++ b/screen.js
@@ -3735,8 +3735,12 @@ function updateArrangementSelector() {
 async function showLoadModal() {
     const modal = document.getElementById('editor-load-modal');
     modal.classList.remove('hidden');
-    document.getElementById('editor-load-search').value = '';
+    const search = document.getElementById('editor-load-search');
+    if (search) search.value = '';
 
+    // Preload the flat list ONCE for recursive search (best-effort). The default
+    // view is the folder browser below; typing in the search box searches across
+    // every folder using this list.
     if (!S.songsList) {
         try {
             S.songsList = await fetch('/api/plugins/editor/songs').then(r => r.json());
@@ -3744,14 +3748,81 @@ async function showLoadModal() {
             S.songsList = [];
         }
     }
-    // Don't dump the whole library on open — it can be thousands of rows.
-    // Show a prompt and populate results as the user types (see filterSongs).
-    // If the library is empty / the fetch failed, fall through to the
-    // existing "No custom song files found" empty state instead of telling the user
-    // to search for something that isn't there.
-    if (S.songsList && S.songsList.length) renderSongPrompt();
-    else renderSongList(S.songsList || []);
-    document.getElementById('editor-load-search').focus();
+    // Open as a file browser rooted at the DLC / song-library folder.
+    await _editorBrowse('');
+    if (search) search.focus();
+}
+
+// Fetch + render one directory level of the library. `path` is a DLC-relative
+// POSIX subpath ("" = the library root).
+async function _editorBrowse(path) {
+    S.loadCwd = path || '';
+    const list = document.getElementById('editor-load-list');
+    let data;
+    try {
+        data = await fetch('/api/plugins/editor/browse', {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json' },
+            body: JSON.stringify({ path: S.loadCwd }),
+        }).then(r => r.json());
+    } catch {
+        data = { error: 'Could not read the library folder' };
+    }
+    if (!data || data.error) {
+        if (list) list.innerHTML = '<div class="text-xs text-gray-500 p-2">'
+            + _editorEscHtml((data && data.error) || 'Error') + '</div>';
+        return;
+    }
+    S.loadCwd = data.cwd || '';
+    S.loadParent = data.parent;
+    _editorSetLoadPath(data.root, data.cwd);
+    renderBrowse(data);
+}
+
+// Show the absolute folder path (root + current subpath), using whichever
+// separator the OS root hints at so it reads like a real path on Windows/*nix.
+function _editorSetLoadPath(root, cwd) {
+    const el = document.getElementById('editor-load-path');
+    if (!el) return;
+    const sep = String(root).includes('\\') ? '\\' : '/';
+    const full = cwd
+        ? String(root).replace(/[\\/]+$/, '') + sep + String(cwd).replace(/\//g, sep)
+        : String(root);
+    el.textContent = full;
+    el.title = full;
+}
+
+// Render an up-row (when not at root) + subfolders + loadable feedpaks.
+function renderBrowse(data) {
+    const list = document.getElementById('editor-load-list');
+    if (!list) return;
+    list.replaceChildren();
+    const row = (icon, text, onClick, badge) => {
+        const b = document.createElement('button');
+        b.className = 'w-full text-left px-3 py-1.5 text-xs text-gray-300 hover:bg-dark-500 rounded flex items-center gap-2';
+        const ic = document.createElement('span'); ic.className = 'shrink-0'; ic.textContent = icon;
+        const lb = document.createElement('span'); lb.className = 'flex-1 truncate'; lb.textContent = text;
+        b.appendChild(ic); b.appendChild(lb);
+        if (badge) {
+            const bd = document.createElement('span');
+            bd.className = 'px-1.5 py-0.5 rounded text-[10px] uppercase tracking-wide bg-green-900/40 text-green-300';
+            bd.textContent = badge;
+            b.appendChild(bd);
+        }
+        b.addEventListener('click', onClick);
+        list.appendChild(b);
+    };
+    if (data.cwd) row('⬆', '.. (up one folder)', () => _editorBrowse(data.parent || ''));
+    for (const d of (data.dirs || [])) row('📁', d.name, () => _editorBrowse(d.path));
+    for (const f of (data.files || [])) row('🎵', f.name, () => editorLoadFile(f.filename), f.format);
+    if (!(data.dirs || []).length && !(data.files || []).length) {
+        const empty = document.createElement('div');
+        empty.className = 'text-xs text-gray-500 p-2';
+        empty.textContent = data.cwd
+            ? 'This folder is empty.'
+            : 'No feedpaks in your library folder yet — use New… to create one.';
+        list.appendChild(empty);
+    }
 }
 
 // Empty/initial state for the load list: prompt to search rather than
@@ -3859,11 +3930,10 @@ function renderSongList(files) {
 }
 
 function filterSongs(q) {
-    if (!S.songsList) return;
     const query = (q || '').trim().toLowerCase();
-    // Empty query → show the prompt (or the empty state if there's nothing
-    // to search) instead of the entire library.
-    if (!query) { if (S.songsList.length) renderSongPrompt(); else renderSongList([]); return; }
+    // Empty query → back to the folder browser (rooted where the user last was).
+    if (!query) { _editorBrowse(S.loadCwd || ''); return; }
+    if (!S.songsList) return;
     const list = _normalizeSongList(S.songsList);
     // Match song name, artist, OR raw filename so users can search either way.
     const filtered = list.filter(f =>
@@ -5542,43 +5612,108 @@ window.editorShowNewFormatPicker = () => {
     inner.querySelector('button')?.focus();
 };
 
+// ════════════════════════════════════════════════════════════════════
+// Entry landing — shown when you open the Song Editor with nothing loaded:
+// Load an existing feedpak, or Create New. (The toolbar Load / New… buttons
+// remain for use once you're already inside.)
+// ════════════════════════════════════════════════════════════════════
+window.editorShowStartLanding = () => {
+    document.getElementById('editor-start-landing')?.remove();
+    const modal = document.createElement('div');
+    modal.id = 'editor-start-landing';
+    modal.className = 'fixed inset-0 bg-black/70 z-50 flex items-center justify-center';
+    const inner = document.createElement('div');
+    inner.className = 'bg-dark-800 border border-gray-700 rounded-xl p-6 max-w-md w-full mx-4';
+    const h = document.createElement('h3');
+    h.className = 'text-lg font-semibold mb-1';
+    h.textContent = 'Song Editor';
+    const sub = document.createElement('p');
+    sub.className = 'text-xs text-gray-400 mb-4';
+    sub.textContent = 'Open an existing feedpak to edit, or start a new arrangement.';
+    inner.appendChild(h); inner.appendChild(sub);
+    const mk = (label, blurb, onClick) => {
+        const b = document.createElement('button');
+        b.type = 'button';
+        b.className = 'w-full text-left p-3 mb-2 bg-dark-700 hover:bg-dark-600 rounded border border-gray-700';
+        const t = document.createElement('div'); t.className = 'font-medium text-sm'; t.textContent = label;
+        const p = document.createElement('div'); p.className = 'text-xs text-gray-400 mt-1'; p.textContent = blurb;
+        b.appendChild(t); b.appendChild(p);
+        b.onclick = () => { modal.remove(); onClick(); };
+        return b;
+    };
+    inner.appendChild(mk('📂  Load…',
+        'Browse your song library and open a feedpak to edit.',
+        () => window.editorShowLoadModal()));
+    inner.appendChild(mk('✨  Create New',
+        'Pick what you’re arranging, import a chart or audio, add details.',
+        () => window.editorShowCreateModal()));
+    const cancel = document.createElement('div'); cancel.className = 'flex justify-end mt-2';
+    const cb = document.createElement('button');
+    cb.type = 'button';
+    cb.className = 'px-3 py-1 bg-dark-700 hover:bg-dark-600 rounded text-xs text-gray-400';
+    cb.textContent = 'Not now';
+    cb.onclick = () => modal.remove();
+    cancel.appendChild(cb); inner.appendChild(cancel);
+    modal.appendChild(inner);
+    if (typeof _installModalKeyboard === 'function') {
+        _installModalKeyboard(modal, inner, () => modal.remove());
+    }
+    document.body.appendChild(modal);
+    inner.querySelector('button')?.focus();
+};
+
+// Show the landing only on a genuinely empty editor — nothing loaded, no
+// create session, and no create/load modal already open.
+function _editorMaybeShowStartLanding() {
+    const loaded = !!(typeof S !== 'undefined' && S && (S.filename || S.sessionId
+        || (Array.isArray(S.arrangements) && S.arrangements.length)));
+    if (loaded) return;
+    if (document.getElementById('editor-start-landing')) return;
+    const createHidden = document.getElementById('editor-create-modal')?.classList.contains('hidden');
+    const loadHidden = document.getElementById('editor-load-modal')?.classList.contains('hidden');
+    if (createHidden === false || loadHidden === false) return;   // a modal is open
+    window.editorShowStartLanding();
+}
+
 window.editorShowCreateModal = () => {
-    // Include the GP-audio-sync fields so a prior import session's
-    // gp8AudioMode / autoSyncAudioUrl / lastSync can't leak into this one
-    // (which would apply the previous song's audio/offset to a new import).
+    // Fresh state each open so a prior session (roster / audio / gp8AudioMode /
+    // autoSyncAudioUrl / lastSync) can't leak in. Default roster: one Lead
+    // Guitar arrangement, so the modal is immediately creatable with a title.
     createState = {
-        mode: 'blank', initialArr: 'Lead', stringCount: 6,
-        gpPath: null, tracks: null, audioUrl: null, audioMode: 'file', artPath: null,
-        previewPath: null, eofFiles: null,
-        gp8AudioMode: 'none', autoSyncAudioUrl: null, lastSync: null,
+        mode: 'blank',
+        roster: ['Lead'],
+        gpPath: null, tracks: null, gpName: null, gpHasEmbedded: false, gpSyncCount: 0,
+        eofFiles: null, eofName: null,
+        audioUrl: null, audioName: null, audioDuration: null, midiInfo: null,
+        artPath: null, previewPath: null,
+        gp8AudioMode: 'none', autoSyncAudioUrl: null, lastSync: null, autoSyncCoupled: false,
     };
-    document.getElementById('editor-create-modal').classList.remove('hidden');
-    document.getElementById('editor-create-tracks').classList.add('hidden');
-    document.getElementById('editor-create-go').disabled = true;
-    document.getElementById('editor-create-status').textContent = '';
-    document.getElementById('editor-audio-status').textContent = '';
-    document.getElementById('editor-create-gp').value = '';
-    document.getElementById('editor-create-audio').value = '';
-    document.getElementById('editor-create-yt-url').value = '';
-    const _eofIn = document.getElementById('editor-create-eof'); if (_eofIn) _eofIn.value = '';
-    const _pvIn = document.getElementById('editor-create-preview'); if (_pvIn) _pvIn.value = '';
-    document.getElementById('editor-create-title').value = '';
-    document.getElementById('editor-create-artist').value = '';
-    document.getElementById('editor-create-album').value = '';
-    document.getElementById('editor-create-year').value = '';
-    // Reset the GP8/auto-sync UI so stale banner/section/refine state from a
-    // previous session isn't shown before a file is chosen.
-    document.getElementById('editor-gp8-audio-banner')?.classList.add('hidden');
-    document.getElementById('editor-autosync-section')?.classList.add('hidden');
-    document.getElementById('editor-refine-row')?.classList.add('hidden');
-    const _gas = document.getElementById('editor-autosync-status');
-    if (_gas) _gas.textContent = '';
-    const _refineStatus = document.getElementById('editor-refine-status');
-    if (_refineStatus) _refineStatus.textContent = '';
-    editorSetAudioMode('file');
-    _populateCreateArrButtons();
-    _populateStringCountButtons();
-    editorSetCreateMode('blank');
+    const setVal = (id) => { const el = document.getElementById(id); if (el) el.value = ''; };
+    const setTxt = (id) => { const el = document.getElementById(id); if (el) el.textContent = ''; };
+    const hide = (id) => document.getElementById(id)?.classList.add('hidden');
+    document.getElementById('editor-create-modal')?.classList.remove('hidden');
+    hide('editor-create-tracks');
+    const go = document.getElementById('editor-create-go'); if (go) go.disabled = true;
+    setTxt('editor-create-status');
+    setTxt('editor-create-import-status');
+    setTxt('editor-create-roster-hint');
+    [
+        'editor-create-import', 'editor-create-yt-url', 'editor-create-art',
+        'editor-create-title', 'editor-create-artist', 'editor-create-album', 'editor-create-album-artist',
+        'editor-create-year', 'editor-create-track', 'editor-create-disc', 'editor-create-genre',
+        'editor-create-language', 'editor-create-isrc', 'editor-create-mbid', 'editor-create-authors',
+    ].forEach(setVal);
+    const artPrev = document.getElementById('editor-create-art-preview');
+    if (artPrev) { artPrev.style.backgroundImage = ''; artPrev.textContent = 'No art yet'; }
+    // Reset the GP8/auto-sync UI so stale banner/section/refine state isn't shown.
+    hide('editor-gp8-audio-banner'); hide('editor-autosync-section'); hide('editor-refine-row');
+    setTxt('editor-autosync-status'); setTxt('editor-refine-status');
+    setTxt('editor-create-autofill-note');
+    _populateRosterPalette();
+    _renderRosterSelected();
+    renderStaged();
+    _syncYtFieldState();
+    updateCreateButton();
 };
 
 window.editorHideCreateModal = () => {
@@ -5871,93 +6006,131 @@ window.editorShowCreateSloppakModal = () => {
     titleInput.focus();
 };
 
-window.editorSetAudioMode = (mode) => {
-    createState.audioMode = mode;
-    document.getElementById('editor-audio-file-input').classList.toggle('hidden', mode !== 'file');
-    document.getElementById('editor-audio-yt-input').classList.toggle('hidden', mode !== 'youtube');
-    document.getElementById('editor-audio-mode-file').classList.toggle('is-active', mode === 'file');
-    document.getElementById('editor-audio-mode-yt').classList.toggle('is-active', mode === 'youtube');
-};
-
-window.editorGPFileSelected = async (input) => {
-    if (!input.files.length) return;
-    const file = input.files[0];
-    const status = document.getElementById('editor-create-status');
-    status.textContent = 'Uploading Guitar Pro file...';
-
+// Retired: the Upload File / YouTube toggle was removed — audio now arrives via
+// the single Content Import browse (or the YouTube field beside it). Kept as a
+// harmless no-op so any stray caller can't throw.
+window.editorSetAudioMode = () => {};
+
+// Upload + stage ONE Guitar Pro file into the single chart slot. Does NOT touch
+// the master-audio slot — the two are independent now (fixes the "audio falls
+// off" bug). Autofills Title/Artist/Album from the chart's own metadata.
+async function _stageGpFile(file) {
+    const iStatus = document.getElementById('editor-create-import-status');
+    if (iStatus) iStatus.textContent = 'Reading Guitar Pro file…';
     const form = new FormData();
     form.append('file', file);
-
     try {
         const resp = await fetch('/api/plugins/editor/import-gp', { method: 'POST', body: form });
         const data = await resp.json();
-        if (data.error) { status.textContent = 'Error: ' + data.error; return; }
-
+        if (data.error) { if (iStatus) iStatus.textContent = 'Error: ' + data.error; return; }
         createState.gpPath = data.gp_path;
         createState.tracks = data.tracks;
+        createState.gpName = file.name;
+        createState.gpHasEmbedded = !!data.has_embedded_audio;
+        createState.gpSyncCount = data.sync_point_count || 0;
+        createState.mode = 'gp';
+        // Chart slot is exclusive — a GP replaces any EOF pick. Audio untouched.
+        createState.eofFiles = null;
 
-        // Show track list
         const listEl = document.getElementById('editor-create-track-list');
-        listEl.innerHTML = data.tracks.map(t => {
+        if (listEl) listEl.innerHTML = data.tracks.map(t => {
             const isDrums = !!(t.is_drums || t.is_percussion);
-            const badge = isDrums ? ' (drums)'
-                : t.is_piano ? ' (keys)'
-                : '';
+            // Role tag (not a warning): drums used to render red, which read as
+            // an error. Each row now self-labels with a coloured role pill —
+            // amber Drums / indigo Keys / sky Bass / muted Guitar — so no legend
+            // is needed. Inline styles: core Tailwind lacks the /opacity variants.
+            const role = isDrums ? { t: 'Drums', s: 'background:rgba(245,158,11,0.16);color:#fcd34d' }
+                : t.is_piano ? { t: 'Keys', s: 'background:rgba(129,140,248,0.18);color:#c7d2fe' }
+                : t.is_bass ? { t: 'Bass', s: 'background:rgba(56,189,248,0.16);color:#7dd3fc' }
+                : { t: 'Guitar', s: 'background:#2c3040;color:#9aa0ad' };
             const disabled = t.notes === 0;
             const safeName = _editorEscHtml(t.name);
-            return `<label class="flex items-center gap-2 text-xs text-gray-300 py-0.5">
+            return `<label class="flex items-center gap-2 text-xs py-0.5">
                 <input type="checkbox" value="${t.index}" checked
                     class="accent-accent" ${disabled ? 'disabled' : ''}>
-                <span class="${isDrums ? 'text-red-300' : t.is_piano ? 'text-indigo-300' : ''}">${safeName}</span>
-                <span class="text-gray-600">${Number(t.strings) || 0}str, ${Number(t.notes) || 0} notes${badge}</span>
+                <span class="text-gray-300 flex-1" style="overflow:hidden;text-overflow:ellipsis;white-space:nowrap">${safeName}</span>
+                <span class="px-1.5 py-0.5 rounded text-[10px] font-medium" style="${role.s}">${role.t}</span>
+                <span class="text-gray-600 shrink-0">${Number(t.strings) || 0}str · ${Number(t.notes) || 0} notes</span>
             </label>`;
         }).join('');
-        document.getElementById('editor-create-tracks').classList.remove('hidden');
-
-        // Auto-fill title from filename
-        const stem = file.name.replace(/\.(gp[345x]?|gpx)$/i, '');
-        if (!document.getElementById('editor-create-title').value) {
-            document.getElementById('editor-create-title').value = stem;
-        }
+        document.getElementById('editor-create-tracks')?.classList.remove('hidden');
 
-        // Show/hide GP8 embedded audio banner and auto-sync section
-        const _banner = document.getElementById('editor-gp8-audio-banner');
-        const _syncSec = document.getElementById('editor-autosync-section');
-        createState.gp8AudioMode = 'none';
-        createState.autoSyncAudioUrl = null;
-        // Clear any sync result from a previously-selected GP file in this same
-        // modal, so editorDoCreate() doesn't seed a stale audio_offset (from the
-        // old file) into the conversion of this new one. Also hide the refine
-        // row, which only applies to a live sync result.
+        // Reset any prior sync result, then derive the GP audio UI + autofill.
         createState.lastSync = null;
-        const _refineRow = document.getElementById('editor-refine-row');
-        if (_refineRow) _refineRow.classList.add('hidden');
-        // Also reset the auto-sync UI: clear the status text (so it doesn't
-        // still read "ready" against empty state) and the file input value (so
-        // re-selecting the same audio file fires a fresh change event).
+        document.getElementById('editor-refine-row')?.classList.add('hidden');
         const _asStatus = document.getElementById('editor-autosync-status');
         if (_asStatus) _asStatus.textContent = '';
         const _asInput = document.getElementById('editor-autosync-audio');
         if (_asInput) _asInput.value = '';
-        if (data.has_embedded_audio) {
-            document.getElementById('editor-gp8-sync-count').textContent = data.sync_point_count || 0;
-            if (_banner) _banner.classList.remove('hidden');
-            if (_syncSec) _syncSec.classList.add('hidden');
-            editorSetGP8AudioMode('embedded');
-        } else {
-            if (_banner) _banner.classList.add('hidden');
-            // Show auto-sync section for ALL GP formats — gp_autosync works on GP3-GP8
-            if (_syncSec) _syncSec.classList.remove('hidden');
-            createState.gp8AudioMode = 'none';
-        }
-
-        status.textContent = `Parsed: ${data.tracks.length} tracks found`;
+        const _syncCount = document.getElementById('editor-gp8-sync-count');
+        if (_syncCount) _syncCount.textContent = createState.gpSyncCount;
+        _refreshGpAudioUI();
+        _applyGpAutofill(data.song);
+        if (iStatus) iStatus.textContent = `Guitar Pro chart added — ${data.tracks.length} tracks.`;
         updateCreateButton();
     } catch (e) {
-        status.textContent = 'Upload failed: ' + e.message;
+        if (iStatus) iStatus.textContent = 'Upload failed: ' + e.message;
     }
+}
+
+// Back-compat wrapper (accepts the input element).
+window.editorGPFileSelected = async (input) => {
+    const f = input && input.files && input.files[0];
+    if (f) await _stageGpFile(f);
 };
 
+// Derive the GP audio UI from (chart present, master audio present, embedded).
+// FORK A: a staged master audio, when present, IS the auto-sync source — so we
+// hide the redundant embedded banner + manual autosync section and align the
+// chart to that audio at Create.
+function _refreshGpAudioUI() {
+    const banner = document.getElementById('editor-gp8-audio-banner');
+    const syncSec = document.getElementById('editor-autosync-section');
+    if (!createState.gpPath) {
+        banner?.classList.add('hidden'); syncSec?.classList.add('hidden');
+        return;
+    }
+    if (createState.audioUrl) {
+        // Coupled: the staged master audio is the alignment source (Fork A) — one
+        // click at Create runs the sync + convert with no separate audio step.
+        createState.gp8AudioMode = 'autosync';
+        createState.autoSyncAudioUrl = createState.audioUrl;
+        createState.autoSyncCoupled = true;
+        createState.lastSync = null;
+        banner?.classList.add('hidden'); syncSec?.classList.add('hidden');
+    } else if (createState.gpHasEmbedded) {
+        createState.autoSyncCoupled = false;
+        if (banner) banner.classList.remove('hidden');
+        editorSetGP8AudioMode('embedded');   // sets mode + button styles + hides syncSec
+        createState.autoSyncAudioUrl = null;
+    } else {
+        createState.autoSyncCoupled = false;
+        createState.gp8AudioMode = 'none';
+        createState.autoSyncAudioUrl = null;
+        banner?.classList.add('hidden');
+        syncSec?.classList.remove('hidden');
+    }
+}
+
+// Non-destructive autofill of Title/Artist/Album from an imported chart's own
+// metadata — fills only EMPTY fields, with a one-time note. Editing any of them
+// dismisses the note (see the input listener).
+function _applyGpAutofill(song) {
+    if (!song) return;
+    const filled = [];
+    const fill = (id, val, label) => {
+        const el = document.getElementById(id);
+        if (val && el && !el.value.trim()) { el.value = val; filled.push(label); }
+    };
+    fill('editor-create-title', song.title, 'Title');
+    fill('editor-create-artist', song.artist, 'Artist');
+    fill('editor-create-album', song.album, 'Album');
+    const note = document.getElementById('editor-create-autofill-note');
+    if (note) note.textContent = filled.length
+        ? 'Filled ' + filled.join(', ') + ' from the imported chart — edit anything.' : '';
+    updateCreateButton();
+}
+
 // Shared upload helper for the Create modal and the Replace Audio modal.
 // Returns the new audio URL on success or null on missing input / failure.
 // The caller is responsible for any "missing input" UX (the helper returns
@@ -6002,39 +6175,42 @@ async function _uploadAudioForMode({ mode, ytInputId, fileInputId, statusEl }) {
 }
 
 async function uploadCreateAudio() {
+    // Audio FILES upload on selection (Content Import → createState.audioUrl).
+    // Here we only resolve a pasted YouTube URL when no file audio is set yet.
+    if (createState.audioUrl) return true;
+    const yt = ((document.getElementById('editor-create-yt-url')?.value) || '').trim();
+    if (!yt) return false;
     const url = await _uploadAudioForMode({
-        mode: createState.audioMode,
+        mode: 'youtube',
         ytInputId: 'editor-create-yt-url',
-        fileInputId: 'editor-create-audio',
-        statusEl: document.getElementById('editor-audio-status'),
+        fileInputId: 'editor-create-import',
+        statusEl: document.getElementById('editor-create-import-status')
+            || document.getElementById('editor-create-status'),
     });
     if (!url) return false;
     createState.audioUrl = url;
     return true;
 }
 
-// Pure gate — given the create-modal state + which inputs are filled, decide
-// whether the Create/Import button should be enabled. DOM-free so it can be
-// unit-tested (tests/create_gate.test.js).
-//   blank: audio-only feedpak -> backend needs audio + title + artist.
-//   gp/eof: enabled once a source file is chosen (title/artist come from it or
-//   the details fields), preserving the pre-mode-picker behaviour.
+// Pure gate — INPUT-DRIVEN so it can be unit-tested (tests/create_gate.test.js).
+// A picked Guitar Pro file wins, then EOF XML arrangement(s). Otherwise it's a
+// from-scratch create, which needs a title AND at least one instrument in the
+// roster (Vocals alone can't stand — the spec requires a non-empty arrangements
+// list). Audio + artist stay optional (draft-now, audio-later).
 function _createGateOpen(state, flags) {
     if (!state || !flags) return false;
-    switch (state.mode) {
-        case 'blank': return !!(flags.hasAudio && flags.hasTitle && flags.hasArtist);
-        case 'gp':    return !!state.gpPath;
-        case 'eof':   return !!(state.eofFiles && state.eofFiles.length);
-        default:      return false;
-    }
+    if (state.gpPath) return true;
+    if (state.eofFiles && state.eofFiles.length) return true;
+    var instruments = ['Lead', 'Rhythm', 'Keys', 'Bass', 'Drums'];
+    var hasInstrument = !!(state.roster && state.roster.some(function (r) {
+        return instruments.indexOf(r) >= 0;
+    }));
+    return !!(flags.hasTitle && hasInstrument);
 }
 
 function _createHasAudioInput() {
-    if (createState.audioMode === 'youtube') {
-        return !!((document.getElementById('editor-create-yt-url')?.value) || '').trim();
-    }
-    return !!(document.getElementById('editor-create-audio')?.files || []).length
-        || !!createState.audioUrl;
+    if (createState.audioUrl) return true;
+    return !!((document.getElementById('editor-create-yt-url')?.value) || '').trim();
 }
 
 function updateCreateButton() {
@@ -6045,6 +6221,7 @@ function updateCreateButton() {
     });
     const btn = document.getElementById('editor-create-go');
     if (btn) btn.disabled = !open;
+    if (typeof _updateMbButton === 'function') _updateMbButton();
 }
 
 // Populate the Blank-mode "Initial Arrangement" toggle. Lead / Rhythm / Bass are
@@ -6066,6 +6243,502 @@ function _createRoleDefaultStrings(role) {
     return role === 'Bass' ? 4 : 6;
 }
 
+// ════════════════════════════════════════════════════════════════════
+// Roster — "What are you arranging?" Click a palette chip to add a role;
+// drag the selected chips to reorder. Backend canonical names: Vocals,
+// Lead, Rhythm, Keys, Bass, Drums (create_sloppak maps display labels too).
+// ════════════════════════════════════════════════════════════════════
+const _CREATE_ROSTER = [
+    { id: 'Vocals', label: 'Vocals' },
+    { id: 'Lead', label: 'Lead Guitar' },
+    { id: 'Rhythm', label: 'Rhythm Guitar' },
+    { id: 'Keys', label: 'Keys' },
+    { id: 'Bass', label: 'Bass Guitar' },
+    { id: 'Drums', label: 'Drums' },
+];
+const _CREATE_INSTRUMENTS = ['Lead', 'Rhythm', 'Keys', 'Bass', 'Drums'];
+function _rosterLabel(id) {
+    const r = _CREATE_ROSTER.find((x) => x.id === id);
+    return r ? r.label : id;
+}
+
+function _populateRosterPalette() {
+    const wrap = document.getElementById('editor-create-roster-palette');
+    if (!wrap) return;
+    wrap.replaceChildren();
+    for (const r of _CREATE_ROSTER) {
+        const inSel = createState.roster.includes(r.id);
+        const b = document.createElement('button');
+        b.type = 'button';
+        b.textContent = (inSel ? '✓ ' : '+ ') + r.label;
+        b.className = 'px-2 py-1 rounded text-xs font-medium '
+            + (inSel ? 'bg-accent text-white' : 'bg-dark-600 text-gray-300 hover:bg-dark-500');
+        b.onclick = () => _toggleRosterRole(r.id);
+        wrap.appendChild(b);
+    }
+}
+
+function _toggleRosterRole(id) {
+    const i = createState.roster.indexOf(id);
+    if (i >= 0) createState.roster.splice(i, 1);
+    else createState.roster.push(id);
+    _populateRosterPalette();
+    _renderRosterSelected();
+    updateCreateButton();
+}
+
+let _rosterDragFrom = null;
+function _renderRosterSelected() {
+    const wrap = document.getElementById('editor-create-roster-selected');
+    if (!wrap) return;
+    wrap.replaceChildren();
+    if (!createState.roster.length) {
+        const p = document.createElement('span');
+        p.className = 'text-[11px] text-gray-600';
+        p.textContent = 'Nothing yet — click an instrument above.';
+        wrap.appendChild(p);
+    }
+    createState.roster.forEach((id, idx) => {
+        const chip = document.createElement('span');
+        chip.draggable = true;
+        chip.className = 'inline-flex items-center gap-1 px-2 py-1 rounded text-xs font-medium bg-dark-600 text-gray-200 cursor-move';
+        const name = document.createElement('span');
+        name.textContent = _rosterLabel(id);
+        chip.appendChild(name);
+        const x = document.createElement('button');
+        x.type = 'button';
+        x.textContent = '✕';
+        x.className = 'text-gray-500 hover:text-white';
+        x.onclick = (e) => { e.stopPropagation(); _toggleRosterRole(id); };
+        chip.appendChild(x);
+        chip.addEventListener('dragstart', () => { _rosterDragFrom = idx; });
+        chip.addEventListener('dragover', (e) => e.preventDefault());
+        chip.addEventListener('drop', (e) => {
+            e.preventDefault();
+            if (_rosterDragFrom === null || _rosterDragFrom === idx) return;
+            const arr = createState.roster;
+            const [moved] = arr.splice(_rosterDragFrom, 1);
+            arr.splice(idx, 0, moved);
+            _rosterDragFrom = null;
+            _renderRosterSelected();
+        });
+        wrap.appendChild(chip);
+    });
+    const hint = document.getElementById('editor-create-roster-hint');
+    if (hint) {
+        const hasInstrument = createState.roster.some((r) => _CREATE_INSTRUMENTS.includes(r));
+        const hasVocals = createState.roster.includes('Vocals');
+        hint.textContent = (hasVocals && !hasInstrument)
+            ? 'Vocals adds a lyrics track — add at least one instrument to chart against.'
+            : (hasVocals ? 'Vocals seeds an empty lyrics track (a full vocals editor is coming).' : '');
+    }
+}
+
+// Single "Content Import" browse — route by extension to the right importer.
+// Single "Content Import" browse — now MULTI-file and role-routed. Each file is
+// staged into its role slot (1 master audio, 1 chart, MIDI as an info row)
+// WITHOUT clearing the other role. That's the whole fix for "the audio falls off
+// when I then add a Guitar Pro file."
+const _IMPORT_AUDIO = ['.mp3', '.wav', '.flac', '.ogg', '.m4a', '.opus', '.aac', '.wem'];
+const _IMPORT_GP = ['.gp3', '.gp4', '.gp5', '.gpx', '.gp'];
+const _extOf = (f) => (f.name.match(/\.[^.]+$/) || [''])[0].toLowerCase();
+
+window.editorContentImportSelected = async (input) => {
+    const files = [...(input.files || [])];
+    if (!files.length) return;
+    const status = document.getElementById('editor-create-import-status');
+    const audioFiles = files.filter((f) => _IMPORT_AUDIO.includes(_extOf(f)));
+    const gpFiles = files.filter((f) => _IMPORT_GP.includes(_extOf(f)));
+    const xmlFiles = files.filter((f) => _extOf(f) === '.xml');
+    const midiFiles = files.filter((f) => ['.mid', '.midi'].includes(_extOf(f)));
+    const unknown = files.filter((f) => ![..._IMPORT_AUDIO, ..._IMPORT_GP, '.xml', '.mid', '.midi'].includes(_extOf(f)));
+
+    // Chart slot (exclusive): a Guitar Pro file wins over RS/EOF XML if both are
+    // added together. Stage the chart BEFORE the audio so the coupling sees it.
+    if (gpFiles.length) {
+        await _stageGpFile(gpFiles[0]);
+        if (xmlFiles.length && status) status.textContent += ' (RS XML ignored — one chart source per song.)';
+    } else if (xmlFiles.length) {
+        _stageEofFiles(xmlFiles);
+    }
+    // Master-audio slot (one master track for now; stems later).
+    if (audioFiles.length) {
+        await _stageAudio(audioFiles[0]);
+        if (audioFiles.length > 1 && status) {
+            status.textContent = 'One master track for now — used "' + audioFiles[0].name
+                + '". (Multiple stems are coming.)';
+        }
+    }
+    if (midiFiles.length) _stageMidi(midiFiles);
+    if (unknown.length && status) {
+        status.textContent = 'Skipped unsupported: ' + unknown.map((f) => f.name).join(', ')
+            + ' (PowerTab & MusicXML are coming).';
+    }
+    // The staged list is now the source of truth — clear the input so re-adding
+    // the same file fires a fresh change and the input never "shows" one file.
+    input.value = '';
+    renderStaged();
+    updateCreateButton();
+};
+
+// Upload + stage the master audio track. Never touches the chart slot; couples
+// into GP auto-sync (via _refreshGpAudioUI) when a chart is present.
+async function _stageAudio(file) {
+    const iStatus = document.getElementById('editor-create-import-status');
+    if (iStatus) iStatus.textContent = 'Uploading audio…';
+    createState.audioUrl = null;
+    createState.audioName = null;
+    createState.audioDuration = null;
+    const form = new FormData();
+    form.append('file', file);
+    let url = null, dur = null;
+    try {
+        const resp = await fetch('/api/plugins/editor/upload-audio', { method: 'POST', body: form });
+        const data = await resp.json();
+        if (data && data.audio_url) { url = data.audio_url; dur = data.duration; }
+        else if (data && data.error && iStatus) iStatus.textContent = 'Error: ' + data.error;
+    } catch (e) {
+        if (iStatus) iStatus.textContent = 'Upload failed: ' + e.message;
+    }
+    if (url) {
+        createState.audioUrl = url;
+        createState.audioName = file.name;
+        createState.audioDuration = (Number(dur) > 0) ? Number(dur) : null;
+        const titleEl = document.getElementById('editor-create-title');
+        if (titleEl && !titleEl.value.trim()) titleEl.value = file.name.replace(/\.[^.]+$/, '');
+        if (iStatus) iStatus.textContent = 'Master audio added.';
+    }
+    _refreshGpAudioUI();       // couple into GP auto-sync if a chart is present
+    _syncYtFieldState();
+}
+
+function _stageEofFiles(xmls) {
+    createState.eofFiles = xmls.length ? xmls : null;
+    createState.eofName = xmls.length === 1 ? xmls[0].name : (xmls.length + ' XML files');
+    createState.mode = 'eof';
+    // Chart slot is exclusive — EOF replaces GP. Audio untouched.
+    createState.gpPath = null; createState.tracks = null; createState.gpName = null;
+    document.getElementById('editor-create-tracks')?.classList.add('hidden');
+    _refreshGpAudioUI();       // no gpPath → hides GP audio UI
+    const iStatus = document.getElementById('editor-create-import-status');
+    if (iStatus) iStatus.textContent = createState.eofName + ' added as the chart.';
+}
+
+function _stageMidi(files) {
+    createState.midiInfo = files.length === 1 ? files[0].name : (files.length + ' MIDI files');
+    const iStatus = document.getElementById('editor-create-import-status');
+    if (iStatus) iStatus.textContent = 'MIDI added — after Create, add Keys / Drums from it in the editor (+Keys / +Drums).';
+}
+
+// Grey the YouTube field while a master-audio FILE is staged (file wins).
+function _syncYtFieldState() {
+    const yt = document.getElementById('editor-create-yt-url');
+    if (!yt) return;
+    const hasFileAudio = !!(createState.audioUrl && createState.audioName);
+    yt.disabled = hasFileAudio;
+    yt.style.opacity = hasFileAudio ? '0.5' : '';
+    yt.title = hasFileAudio ? 'Using the audio file you added — remove it to use a URL instead' : '';
+}
+
+// Render the staged file rows (audio master / chart / MIDI info), each with a
+// role chip + remove ✕. This is the honesty surface.
+function renderStaged() {
+    const wrap = document.getElementById('editor-create-staged');
+    if (!wrap) return;
+    wrap.replaceChildren();
+    const ytVal = ((document.getElementById('editor-create-yt-url')?.value) || '').trim();
+    const rows = [];
+    if (createState.audioUrl && createState.audioName) {
+        rows.push({ role: 'audio', chip: 'Master audio', chipStyle: 'background:rgba(64,128,224,0.18);color:#8fbaff',
+            name: createState.audioName, detail: createState.gpPath ? 'aligns the chart' : '' });
+    } else if (ytVal) {
+        rows.push({ role: 'yt', chip: 'Master audio · YouTube', chipStyle: 'background:rgba(64,128,224,0.18);color:#8fbaff',
+            name: ytVal, detail: createState.gpPath ? 'aligns the chart' : '' });
+    }
+    if (createState.gpPath) {
+        rows.push({ role: 'chart', chip: 'Chart · Guitar Pro', chipStyle: 'background:rgba(129,140,248,0.20);color:#c7d2fe',
+            name: createState.gpName || 'Guitar Pro file', detail: createState.tracks ? (createState.tracks.length + ' tracks') : '' });
+    } else if (createState.eofFiles && createState.eofFiles.length) {
+        rows.push({ role: 'chart', chip: 'Chart · RS XML', chipStyle: 'background:rgba(129,140,248,0.20);color:#c7d2fe',
+            name: createState.eofName || 'RS/EOF XML', detail: '' });
+    }
+    if (createState.midiInfo) {
+        rows.push({ role: 'midi', chip: 'MIDI · adds after create', chipCls: 'bg-dark-600 text-gray-400',
+            name: createState.midiInfo, detail: '' });
+    }
+    if (!rows.length) {
+        const hint = document.createElement('div');
+        hint.className = 'text-[11px] text-gray-600';
+        hint.textContent = 'Nothing added yet — audio and/or a chart are optional.';
+        wrap.appendChild(hint);
+        return;
+    }
+    for (const r of rows) {
+        const row = document.createElement('div');
+        row.className = 'flex items-center gap-2 bg-dark-800 rounded px-2 py-1 text-xs';
+        const chip = document.createElement('span');
+        chip.className = 'px-1.5 py-0.5 rounded text-[10px] font-medium shrink-0 ' + (r.chipCls || '');
+        if (r.chipStyle) chip.style.cssText = r.chipStyle;
+        chip.textContent = r.chip;
+        row.appendChild(chip);
+        const name = document.createElement('span');
+        name.className = 'text-gray-300 flex-1';
+        name.style.cssText = 'overflow:hidden;text-overflow:ellipsis;white-space:nowrap';
+        name.textContent = r.name;
+        row.appendChild(name);
+        if (r.detail) {
+            const d = document.createElement('span');
+            d.className = 'text-gray-600 shrink-0';
+            d.textContent = r.detail;
+            row.appendChild(d);
+        }
+        const x = document.createElement('button');
+        x.type = 'button';
+        x.className = 'text-gray-500 hover:text-white shrink-0';
+        x.textContent = '✕';
+        x.title = 'Remove';
+        x.onclick = () => editorStagedRemove(r.role);
+        row.appendChild(x);
+        wrap.appendChild(row);
+    }
+    // Honest one-liner: the preview clip is auto-made from the master audio (no
+    // upload). Shown only when there IS a master audio to make it from.
+    const hasMaster = !!(createState.audioUrl && createState.audioName)
+        || !!((document.getElementById('editor-create-yt-url')?.value) || '').trim();
+    if (hasMaster) {
+        const pv = document.createElement('div');
+        pv.className = 'text-[11px] text-gray-600';
+        pv.textContent = 'Preview clip: auto-made from your master audio.';
+        wrap.appendChild(pv);
+    }
+}
+
+window.editorStagedRemove = (role) => {
+    if (role === 'audio') {
+        createState.audioUrl = null; createState.audioName = null; createState.audioDuration = null;
+        _refreshGpAudioUI();        // un-couple: restore embedded/manual GP audio UI
+        _syncYtFieldState();
+    } else if (role === 'yt') {
+        const yt = document.getElementById('editor-create-yt-url'); if (yt) yt.value = '';
+        _syncYtFieldState();
+    } else if (role === 'chart') {
+        createState.gpPath = null; createState.tracks = null; createState.eofFiles = null;
+        createState.gpName = null; createState.eofName = null; createState.gpHasEmbedded = false;
+        createState.lastSync = null; createState.autoSyncAudioUrl = null;
+        document.getElementById('editor-create-tracks')?.classList.add('hidden');
+        _refreshGpAudioUI();        // no gpPath → hides GP audio UI
+    } else if (role === 'midi') {
+        createState.midiInfo = null;
+    }
+    const iStatus = document.getElementById('editor-create-import-status');
+    if (iStatus) iStatus.textContent = '';
+    renderStaged();
+    updateCreateButton();
+};
+
+window.editorYtUrlInput = () => {
+    // A YouTube URL is an alternative audio source (resolved at Create). It
+    // doesn't gate the button (audio is optional) but should show in the list.
+    _syncYtFieldState();
+    renderStaged();
+    updateCreateButton();
+};
+
+// ════════════════════════════════════════════════════════════════════
+// MusicBrainz "Match…" — scan-first: uses the Title/Artist already on the form,
+// opens a popup with an editable query + candidate list, and fills the details
+// on pick. Reuses core's same-origin, rate-limited GET /api/enrichment/search.
+// ════════════════════════════════════════════════════════════════════
+function _cval(id) { return ((document.getElementById(id)?.value) || '').trim(); }
+
+function _updateMbButton() {
+    const btn = document.getElementById('editor-create-mb-btn');
+    const hint = document.getElementById('editor-create-mb-hint');
+    if (!btn) return;
+    const has = !!(_cval('editor-create-title') || _cval('editor-create-artist'));
+    btn.disabled = !has;
+    if (hint) hint.textContent = has ? '' : 'Add a title or artist to match.';
+}
+
+window.editorMbMatch = () => {
+    _editorMbOpenPopup(_cval('editor-create-title'), _cval('editor-create-artist'));
+};
+
+function _editorMbOpenPopup(title, artist) {
+    document.getElementById('editor-mb-popup')?.remove();
+    const modal = document.createElement('div');
+    modal.id = 'editor-mb-popup';
+    modal.className = 'fixed inset-0 bg-black/70 z-50 flex items-center justify-center';
+    const inner = document.createElement('div');
+    inner.className = 'bg-dark-800 border border-gray-700 rounded-xl w-full max-w-md mx-4 flex flex-col';
+    inner.style.maxHeight = '75vh';
+    const head = document.createElement('div');
+    head.className = 'flex items-center justify-between px-4 py-3 border-b border-gray-700';
+    const h = document.createElement('span'); h.className = 'text-sm font-medium'; h.textContent = 'Match on MusicBrainz';
+    const close = document.createElement('button'); close.type = 'button'; close.className = 'text-gray-500 hover:text-white'; close.textContent = '×';
+    close.onclick = () => modal.remove();
+    head.appendChild(h); head.appendChild(close); inner.appendChild(head);
+    // STRUCTURED Artist + Title fields — MusicBrainz's recording search is built
+    // for these; cramming both into one fuzzy field returns junk (or nothing).
+    const qrow = document.createElement('div');
+    qrow.className = 'flex items-center gap-2 px-4 py-2 border-b border-gray-700';
+    const mk = (ph, val) => {
+        const i = document.createElement('input');
+        i.type = 'text'; i.placeholder = ph; i.value = val || '';
+        i.className = 'flex-1 min-w-0 bg-dark-900 border border-gray-700 rounded px-2 py-1 text-xs text-gray-300 outline-none focus:border-accent/50';
+        return i;
+    };
+    const aIn = mk('Artist', artist);
+    const tIn = mk('Title', title);
+    const go = document.createElement('button');
+    go.type = 'button'; go.className = 'px-2 py-1 rounded text-xs font-medium bg-dark-600 text-gray-300 hover:bg-dark-500 shrink-0';
+    go.textContent = 'Search';
+    qrow.appendChild(aIn); qrow.appendChild(tIn); qrow.appendChild(go); inner.appendChild(qrow);
+    const results = document.createElement('div');
+    results.id = 'editor-mb-results';
+    results.className = 'flex-1 overflow-y-auto p-2 space-y-1';
+    inner.appendChild(results);
+    modal.appendChild(inner);
+    if (typeof _installModalKeyboard === 'function') _installModalKeyboard(modal, inner, () => modal.remove());
+    document.body.appendChild(modal);
+    const run = () => _editorMbRunSearch(aIn.value.trim(), tIn.value.trim(), results);
+    go.onclick = run;
+    const onEnter = (e) => { if (e.key === 'Enter') { e.preventDefault(); run(); } };
+    aIn.addEventListener('keydown', onEnter); tIn.addEventListener('keydown', onEnter);
+    run();
+}
+
+// Blend our match score with a duration-to-staged-audio bonus. The master audio
+// IS the version the user wants to chart, so a length match is a strong signal
+// that separates the studio take from live/extended cuts.
+function _mbRankKey(c, dur) {
+    let k = Number(c.score) || 0;
+    if (dur > 0 && Number(c.duration)) {
+        const diff = Math.abs(Number(c.duration) - dur);
+        if (diff <= 4) k += 0.5;
+        else if (diff <= 12) k += 0.2;
+        else k -= Math.min(diff, 120) / 400;
+    }
+    return k;
+}
+
+async function _editorMbRunSearch(artist, title, resultsEl) {
+    if (!resultsEl) return;
+    resultsEl.replaceChildren();
+    if (!artist && !title) { _mbMsg(resultsEl, 'Enter an artist or title to search.'); return; }
+    _mbMsg(resultsEl, 'Searching MusicBrainz…');
+    const params = new URLSearchParams();
+    if (artist) params.set('artist', artist);
+    if (title) params.set('title', title);
+    params.set('limit', '15');
+    let data = null, status = 0;
+    try {
+        const resp = await fetch('/api/enrichment/search?' + params.toString());
+        status = resp.status;
+        data = await resp.json().catch(() => null);
+    } catch (_) { data = null; }
+    resultsEl.replaceChildren();
+    if (status === 429) { _mbMsg(resultsEl, 'MusicBrainz is busy — try again in a moment.'); return; }
+    if (status === 503 || (data && data.error)) { _mbMsg(resultsEl, "Couldn't reach MusicBrainz. Enter details manually."); return; }
+    let cands = (data && data.candidates) || [];
+    if (!cands.length) { _mbMsg(resultsEl, 'No matches — refine the artist/title and try again.'); return; }
+    // #2 — re-rank by closeness of each candidate's length to the staged audio.
+    const dur = Number(createState.audioDuration) || 0;
+    let bestIdx = -1;
+    if (dur > 0) {
+        cands = cands.slice().sort((a, b) => _mbRankKey(b, dur) - _mbRankKey(a, dur));
+        let bestDiff = Infinity;
+        cands.forEach((c, i) => {
+            const d = Math.abs((Number(c.duration) || 1e9) - dur);
+            if (d <= 4 && d < bestDiff) { bestDiff = d; bestIdx = i; }
+        });
+    }
+    cands.forEach((c, i) => resultsEl.appendChild(_editorMbRow(c, i === 0, i === bestIdx)));
+}
+
+function _mbMsg(el, text) {
+    const d = document.createElement('div'); d.className = 'text-xs text-gray-500 p-2'; d.textContent = text; el.appendChild(d);
+}
+
+function _mbDur(sec) {
+    const s = Number(sec); if (!s || s <= 0) return '';
+    const m = Math.floor(s / 60), r = Math.round(s % 60);
+    return m + ':' + String(r).padStart(2, '0');
+}
+
+function _editorMbRow(c, focus, matchesAudio) {
+    const b = document.createElement('button');
+    b.type = 'button';
+    b.className = 'w-full text-left px-2 py-1.5 rounded hover:bg-dark-600 flex items-center gap-2';
+    const col = document.createElement('span'); col.className = 'flex-1'; col.style.minWidth = '0';
+    const t = document.createElement('span'); t.className = 'text-xs text-gray-200 block';
+    t.style.cssText = 'overflow:hidden;text-overflow:ellipsis;white-space:nowrap'; t.textContent = c.title || '(untitled)';
+    const sub = document.createElement('span'); sub.className = 'text-[11px] text-gray-500 block';
+    sub.style.cssText = 'overflow:hidden;text-overflow:ellipsis;white-space:nowrap';
+    sub.textContent = [c.artist, c.album, c.year, _mbDur(c.duration)].filter(Boolean).join(' · ');
+    col.appendChild(t); col.appendChild(sub); b.appendChild(col);
+    // "≈ your audio" tag — this candidate's length matches the staged master.
+    if (matchesAudio) {
+        const m = document.createElement('span');
+        m.className = 'px-1.5 py-0.5 rounded text-[10px] font-medium shrink-0';
+        m.style.cssText = 'background:rgba(64,128,224,0.18);color:#8fbaff';
+        m.textContent = '≈ your audio';
+        b.appendChild(m);
+    }
+    // Confidence pill — green only when earned.
+    let score = Number(c.mb_score) || 0; if (score <= 1) score = Math.round(score * 100);
+    const pill = document.createElement('span');
+    pill.className = 'px-1.5 py-0.5 rounded text-[10px] font-medium shrink-0';
+    if (score >= 90) { pill.textContent = 'High'; pill.style.cssText = 'background:rgba(22,163,74,0.22);color:#86efac'; }
+    else if (score >= 60) { pill.textContent = 'Good'; pill.style.cssText = 'background:rgba(245,158,11,0.16);color:#fcd34d'; }
+    else { pill.textContent = 'Low'; pill.style.cssText = 'background:#2c3040;color:#9aa0ad'; }
+    b.appendChild(pill);
+    b.onclick = () => _editorMbApply(c);
+    if (focus) setTimeout(() => { try { b.focus(); } catch (_) {} }, 0);
+    return b;
+}
+
+function _editorMbApply(c) {
+    // Explicit pick = overwrite (deferring to a stale filename-title would be
+    // wrong). Only set fields MB actually has; leave the rest untouched.
+    const set = (id, v) => { const el = document.getElementById(id); if (el && v != null && String(v).trim() !== '') el.value = String(v).trim(); };
+    set('editor-create-title', c.title);
+    set('editor-create-artist', c.artist);
+    set('editor-create-album', c.album);
+    set('editor-create-year', c.year);
+    set('editor-create-isrc', c.isrc);
+    set('editor-create-mbid', c.recording_id);
+    if (Array.isArray(c.genres) && c.genres.length) set('editor-create-genre', c.genres.join(', '));
+    const note = document.getElementById('editor-create-autofill-note');
+    if (note) note.textContent = 'Filled from MusicBrainz — edit anything.';
+    document.getElementById('editor-mb-popup')?.remove();
+    _updateMbButton();
+    updateCreateButton();
+}
+
+// Album art: preview locally + upload to get an art_path baked into create.
+window.editorCreateArtSelected = async (input) => {
+    const file = input.files && input.files[0];
+    const prev = document.getElementById('editor-create-art-preview');
+    if (!file) {
+        createState.artPath = null;
+        if (prev) { prev.style.backgroundImage = ''; prev.textContent = 'No art yet'; }
+        return;
+    }
+    try {
+        const rd = new FileReader();
+        rd.onload = () => { if (prev) { prev.style.backgroundImage = 'url("' + rd.result + '")'; prev.textContent = ''; } };
+        rd.readAsDataURL(file);
+    } catch (_) { /* preview is best-effort */ }
+    const form = new FormData();
+    form.append('file', file);
+    try {
+        const resp = await fetch('/api/plugins/editor/upload-art', { method: 'POST', body: form });
+        const data = await resp.json();
+        if (data && data.art_path) createState.artPath = data.art_path;
+    } catch (_) { /* art just won't be baked if the upload fails */ }
+};
+
 function _populateCreateArrButtons() {
     const wrap = document.getElementById('editor-create-arr-buttons');
     if (!wrap) return;
@@ -6133,35 +6806,15 @@ function _populateStringCountButtons() {
     }
 }
 
-// Switch the create modal between Blank (audio-only) / Guitar Pro / EOF XML:
-// show only that mode's section, clear the other modes' picked files (so a
-// leftover can't route editorDoCreate the wrong way), and re-label the action.
+// The Blank/Guitar Pro/EOF segmented toggle was removed — the create modal is
+// now one menu with every option visible, and editorDoCreate() routes on what
+// the user provided. `createState.mode` is still tracked (derived from file
+// selection in editorGPFileSelected / editorEofFilesSelected) for any callers
+// that pass an explicit mode; this setter just records it and re-gates. It no
+// longer hides sections or re-labels the button.
 window.editorSetCreateMode = (mode) => {
     if (!['blank', 'gp', 'eof'].includes(mode)) mode = 'blank';
     createState.mode = mode;
-    if (mode !== 'gp') { createState.gpPath = null; createState.tracks = null; }
-    if (mode !== 'eof') { createState.eofFiles = null; }
-    document.getElementById('editor-create-tracks')?.classList.add('hidden');
-    document.querySelectorAll('#editor-create-modal .create-mode-sec').forEach((el) => {
-        const secMode = el.id === 'editor-create-mode-gp' ? 'gp'
-            : el.id === 'editor-create-mode-eof' ? 'eof'
-            : 'blank'; // editor-create-blank-opts
-        el.classList.toggle('hidden', secMode !== mode);
-    });
-    for (const m of ['blank', 'gp', 'eof']) {
-        document.getElementById(`editor-create-mode-${m}-btn`)
-            ?.classList.toggle('is-active', m === mode);
-    }
-    const hint = document.getElementById('editor-create-mode-hint');
-    if (hint) {
-        hint.textContent = mode === 'blank'
-            ? 'Start from audio — pick an instrument below and chart it in the editor. No Guitar Pro / XML needed.'
-            : mode === 'gp'
-                ? 'Import a chart from a Guitar Pro file (.gp3–.gp8).'
-                : 'Import one or more EOF (Editor on Fire) arrangement XML files.';
-    }
-    const go = document.getElementById('editor-create-go');
-    if (go) go.textContent = mode === 'blank' ? 'Create from Audio' : 'Import & Open in Editor';
     updateCreateButton();
 };
 
@@ -6169,20 +6822,15 @@ window.editorSetCreateMode = (mode) => {
 // Step 2 audio inputs also invalidates a cached upload URL — otherwise
 // editorDoCreate() skips re-upload (it only uploads when audioUrl is unset)
 // and reuses the previously-selected file/URL.
-document.addEventListener('change', (e) => {
-    if (e.target.id === 'editor-create-audio') {
-        createState.audioUrl = null;
-        updateCreateButton();
-    }
-});
 document.addEventListener('input', (e) => {
-    if (e.target.id === 'editor-create-yt-url') {
-        createState.audioUrl = null;
-        updateCreateButton();
-    }
-    // Blank mode also gates on title/artist — re-check as the user types.
-    if (e.target.id === 'editor-create-title' || e.target.id === 'editor-create-artist') {
-        updateCreateButton();
+    const id = e.target && e.target.id;
+    // The from-scratch gate depends on the title; the Match button on title OR
+    // artist. updateCreateButton re-checks both (it calls _updateMbButton).
+    if (id === 'editor-create-title' || id === 'editor-create-artist') updateCreateButton();
+    // Editing an autofilled field dismisses the one-time autofill note.
+    if (id === 'editor-create-title' || id === 'editor-create-artist' || id === 'editor-create-album') {
+        const note = document.getElementById('editor-create-autofill-note');
+        if (note) note.textContent = '';
     }
 });
 
@@ -6266,35 +6914,46 @@ window.editorRefineSync = async () => {
 async function _editorDoBlankCreate() {
     const status = document.getElementById('editor-create-status');
     const btn = document.getElementById('editor-create-go');
-    const title = ((document.getElementById('editor-create-title')?.value) || '').trim();
-    const artist = ((document.getElementById('editor-create-artist')?.value) || '').trim();
-    if (!title || !artist) {
-        if (status) status.textContent = 'Title and artist are required.';
+    const val = (id) => ((document.getElementById(id)?.value) || '').trim();
+    const title = val('editor-create-title');
+    if (!title) {
+        if (status) status.textContent = 'A title is required.';
+        if (btn) btn.disabled = false;
+        return;
+    }
+    const roster = (createState.roster || []).slice();
+    if (!roster.some((r) => _CREATE_INSTRUMENTS.includes(r))) {
+        if (status) status.textContent = 'Add at least one instrument to arrange (Lead, Rhythm, Bass, Keys, or Drums).';
         return;
     }
     if (btn) btn.disabled = true;
-    if (!createState.audioUrl) {
+    // Audio is optional (draft-now, audio-later): only resolve a pasted YouTube
+    // URL here — file audio uploaded already on selection. With none, we create
+    // an audio-less draft and the author adds audio later via Replace Audio.
+    if (!createState.audioUrl && _createHasAudioInput()) {
         if (status) status.textContent = 'Uploading audio…';
         const ok = await uploadCreateAudio();
         if (!ok) { if (btn) btn.disabled = false; return; }
     }
     const meta = {
-        title, artist,
-        album: ((document.getElementById('editor-create-album')?.value) || '').trim(),
-        year: ((document.getElementById('editor-create-year')?.value) || '').trim(),
-        initial_arrangement: createState.initialArr || 'Lead',
-        // The tuning array's LENGTH sets the arrangement's string count
-        // (feedpak-spec §5.2). All-zero offsets = standard tuning for that
-        // count; alt/drop tunings are a fine-tune step in the editor.
-        tuning: new Array(
-            (Number.isInteger(createState.stringCount)
-                && createState.stringCount >= 4 && createState.stringCount <= 8)
-                ? createState.stringCount
-                : (createState.initialArr === 'Bass' ? 4 : 6),
-        ).fill(0),
-        init_drum_tab: !!document.getElementById('editor-create-drum-tab')?.checked,
+        title,
+        artist: val('editor-create-artist'),
+        album: val('editor-create-album'),
+        album_artist: val('editor-create-album-artist'),
+        year: val('editor-create-year'),
+        track: val('editor-create-track'),
+        disc: val('editor-create-disc'),
+        genres: val('editor-create-genre'),
+        language: val('editor-create-language'),
+        isrc: val('editor-create-isrc'),
+        mbid: val('editor-create-mbid'),
+        // Open-format author credit -> manifest authors[]. Blank is fine.
+        authors: val('editor-create-authors'),
+        // Roster of arrangements the user dragged in ("What are you arranging?").
+        arrangements: roster,
         audio_url: createState.audioUrl,
     };
+    if (createState.artPath) meta.art_path = createState.artPath;
     const fd = new FormData();
     fd.append('metadata', JSON.stringify(meta));
     if (status) status.textContent = 'Building feedpak…';
@@ -6316,17 +6975,17 @@ async function _editorDoBlankCreate() {
 }
 
 window.editorDoCreate = async () => {
-    // Blank mode: audio + metadata -> create_sloppak (no GP/EOF chart import).
-    if (createState.mode === 'blank') {
-        await _editorDoBlankCreate();
-        return;
-    }
-    // EOF arrangement-XML import takes priority when XML files are selected.
-    if (createState.eofFiles && createState.eofFiles.length) {
-        await _editorDoEofCreate();
+    // One menu, no mode toggle — route on what was provided: a Guitar Pro file
+    // wins, then EOF XML arrangement(s), else a from-scratch (draft) create
+    // (only a title is required; audio + artist are optional).
+    if (!createState.gpPath) {
+        if (createState.eofFiles && createState.eofFiles.length) {
+            await _editorDoEofCreate();
+        } else {
+            await _editorDoBlankCreate();
+        }
         return;
     }
-    if (!createState.gpPath) return;
     const status = document.getElementById('editor-create-status');
     const btn = document.getElementById('editor-create-go');
     btn.disabled = true;
@@ -6344,11 +7003,9 @@ window.editorDoCreate = async () => {
     // stale/invalid Step-2 value must not block (or be downloaded for) the
     // import.
     if (_gpAudioMode !== 'embedded' && _gpAudioMode !== 'autosync') {
-        const hasAudioInput = createState.audioMode === 'youtube'
-            ? !!document.getElementById('editor-create-yt-url').value.trim()
-            : !!(document.getElementById('editor-create-audio').files || []).length;
-
-        if (hasAudioInput && !createState.audioUrl) {
+        // Audio (a Content Import file already uploaded, or a pasted YouTube URL)
+        // is optional for a GP import; attach it when present.
+        if (_createHasAudioInput() && !createState.audioUrl) {
             const ok = await uploadCreateAudio();
             if (!ok) { btn.disabled = false; return; }
         }
@@ -6389,22 +7046,25 @@ window.editorDoCreate = async () => {
             if (syncData.ok) {
                 _autoSyncOffset = syncData.audio_offset;
                 createState.lastSync = syncData;
-                // Show refine row and pause — let user optionally refine
-                // before clicking Import again to proceed to conversion.
-                const _refineRow = document.getElementById('editor-refine-row');
-                if (_refineRow) _refineRow.classList.remove('hidden');
-                const _goBtn = document.getElementById('editor-create-go');
-                if (_goBtn) _goBtn.textContent = 'Import & Open in Editor';
-                status.textContent = `✓ Synced: ${syncData.sync_point_count} points, offset ${(_autoSyncOffset ?? 0).toFixed(3)}s — optionally refine below, then click Import.`;
-                // Re-enable Import button so user can click again to convert
-                if (_goBtn) {
-                    _goBtn.disabled = false;
-                    _goBtn.removeAttribute('aria-disabled');
-                    _goBtn.focus();
-                }
-                // Store offset and return — user clicks Import again to convert
                 createState.lastSync.audio_offset = _autoSyncOffset;
-                return;
+                if (!createState.autoSyncCoupled) {
+                    // MANUAL autosync: show refine row and pause for a second
+                    // click. The COUPLED master-audio flow (Fork A) skips this
+                    // and falls straight through to convert — one click.
+                    const _refineRow = document.getElementById('editor-refine-row');
+                    if (_refineRow) _refineRow.classList.remove('hidden');
+                    const _goBtn = document.getElementById('editor-create-go');
+                    if (_goBtn) _goBtn.textContent = 'Import & Open in Editor';
+                    status.textContent = `✓ Synced: ${syncData.sync_point_count} points, offset ${(_autoSyncOffset ?? 0).toFixed(3)}s — optionally refine below, then click Import.`;
+                    if (_goBtn) {
+                        _goBtn.disabled = false;
+                        _goBtn.removeAttribute('aria-disabled');
+                        _goBtn.focus();
+                    }
+                    return;
+                }
+                status.textContent = `✓ Aligned to your audio (offset ${(_autoSyncOffset ?? 0).toFixed(3)}s) — building…`;
+                // fall through to convert
             } else {
                 // Explicit auto-sync was requested but failed — don't silently
                 // import a misaligned chart at offset 0. Stop and let the user
@@ -6549,10 +7209,21 @@ window.editorApplyCreateResult = async (data) => {
 window.editorEofFilesSelected = (input) => {
     const xmls = [...(input.files || [])].filter(f => /\.xml$/i.test(f.name));
     createState.eofFiles = xmls.length ? xmls : null;
+    if (xmls.length) {
+        createState.mode = 'eof';
+        // One import source at a time: picking EOF XML clears any GP pick.
+        createState.gpPath = null;
+        createState.tracks = null;
+        const _gpInput = document.getElementById('editor-create-gp');
+        if (_gpInput) _gpInput.value = '';
+        document.getElementById('editor-create-tracks')?.classList.add('hidden');
+    } else if (!createState.gpPath) {
+        createState.mode = 'blank';
+    }
     updateCreateButton();
     const st = document.getElementById('editor-create-status');
     if (st) st.textContent = xmls.length
-        ? `${xmls.length} EOF arrangement file(s) selected — set audio/art/preview, then Import.`
+        ? `${xmls.length} EOF arrangement file(s) selected — set audio/details, then Create.`
         : '';
 };
 
@@ -6566,10 +7237,7 @@ async function _editorDoEofCreate() {
     try {
         // Audio is optional for EOF (the chart opens regardless), but upload it
         // when supplied so the editor can play in sync.
-        const hasAudioFile = !!(document.getElementById('editor-create-audio').files || []).length;
-        const hasYt = createState.audioMode === 'youtube'
-            && !!document.getElementById('editor-create-yt-url').value.trim();
-        if (!createState.audioUrl && (hasAudioFile || hasYt)) {
+        if (!createState.audioUrl && _createHasAudioInput()) {
             status.textContent = 'Uploading audio…';
             await uploadCreateAudio();   // sets createState.audioUrl on success
         }
@@ -6685,17 +7353,8 @@ window.editorBuild = async () => {
         } catch (_) {}
     }
 
-    // Upload preview clip if selected (baked into the .sloppak as preview.<ext>)
-    const previewInput = document.getElementById('editor-create-preview');
-    if (previewInput && previewInput.files && previewInput.files.length && !createState.previewPath) {
-        const form = new FormData();
-        form.append('file', previewInput.files[0]);
-        try {
-            const r = await fetch('/api/plugins/editor/upload-preview', { method: 'POST', body: form });
-            const d = await r.json();
-            if (d.preview_path) createState.previewPath = d.preview_path;
-        } catch (_) {}
-    }
+    // Preview clips are now auto-generated server-side from the master audio —
+    // no manual upload. (See _make_preview_clip in routes.py.)
 
     try {
         const resp = await fetch('/api/plugins/editor/build', {
@@ -6942,15 +7601,21 @@ function init() {
     resizeCanvas();
     window.addEventListener('resize', resizeCanvas);
 
-    // Observe screen visibility for resize
+    // Observe screen visibility for resize + the entry landing.
     const obs = new MutationObserver(() => {
         const screen = document.getElementById('plugin-editor');
         if (screen && screen.classList.contains('active')) {
             setTimeout(resizeCanvas, 50);
+            // Entering the Song Editor with nothing loaded → offer Load / Create.
+            setTimeout(_editorMaybeShowStartLanding, 80);
         }
     });
     const screen = document.getElementById('plugin-editor');
     if (screen) obs.observe(screen, { attributes: true, attributeFilter: ['class'] });
+    // Also cover the case where the editor screen is already active at init().
+    if (screen && screen.classList.contains('active')) {
+        setTimeout(_editorMaybeShowStartLanding, 120);
+    }
 
     draw();
 }
@@ -7097,9 +7762,10 @@ window.editorDrumsFileSelected = async (input) => {
             const safeName = _editorEscHtml(t.name);
             const checked = i === 0 ? 'checked' : '';
             return `<label class="flex items-center gap-2 text-xs text-gray-300 py-0.5">
-                <input type="radio" name="drums-track" value="${Number.isFinite(Number(t.index)) ? Number(t.index) : 0}" ${checked} class="accent-red-500">
-                <span class="text-red-300">${safeName}</span>
-                <span class="text-gray-600">${Number(t.notes) || 0} notes</span>
+                <input type="radio" name="drums-track" value="${Number.isFinite(Number(t.index)) ? Number(t.index) : 0}" ${checked} class="accent-accent">
+                <span class="text-gray-300 flex-1">${safeName}</span>
+                <span class="px-1.5 py-0.5 rounded text-[10px] font-medium shrink-0" style="background:rgba(245,158,11,0.16);color:#fcd34d">Drums</span>
+                <span class="text-gray-600 shrink-0">${Number(t.notes) || 0} notes</span>
             </label>`;
         }).join('');
         document.getElementById('editor-add-drums-tracks').classList.remove('hidden');
diff --git a/tests/create_gate.test.js b/tests/create_gate.test.js
index e59d616a..ff819121 100644
--- a/tests/create_gate.test.js
+++ b/tests/create_gate.test.js
@@ -1,10 +1,11 @@
 'use strict';
 /*
- * Create-modal gate — the Create/Import button enable logic per mode
- * (Blank / Guitar Pro / EOF XML). Blank is audio-only and must enable on
- * audio + title + artist (the create_sloppak backend's requirements); GP and
- * EOF enable once a source file is picked. Brace-extracts the real pure gate
- * from screen.js (a single browser IIFE) so there's no drift.
+ * Create-modal gate — the Create button enable logic. The modal is now ONE menu
+ * with no Blank/Guitar Pro/EOF mode toggle: the gate is INPUT-DRIVEN. A picked
+ * Guitar Pro file enables it, then EOF XML arrangement(s); otherwise it's a
+ * from-scratch DRAFT create, which needs only a title (audio + artist optional —
+ * draft-now, audio-later). Brace-extracts the real pure gate from screen.js (a
+ * single browser IIFE) so there's no drift.
  *
  * Run: node tests/create_gate.test.js
  */
@@ -34,32 +35,29 @@ function t(name, fn) {
 }
 const inp = (o = {}) => ({ hasTitle: false, hasArtist: false, hasAudio: false, ...o });
 
-t('blank: enabled only with audio + title + artist', () => {
-    assert.strictEqual(_createGateOpen({ mode: 'blank' }, inp({ hasAudio: true, hasTitle: true, hasArtist: true })), true);
-    assert.strictEqual(_createGateOpen({ mode: 'blank' }, inp({ hasTitle: true, hasArtist: true })), false);   // no audio
-    assert.strictEqual(_createGateOpen({ mode: 'blank' }, inp({ hasAudio: true, hasArtist: true })), false);   // no title
-    assert.strictEqual(_createGateOpen({ mode: 'blank' }, inp({ hasAudio: true, hasTitle: true })), false);    // no artist
+t('from-scratch: needs a title AND at least one instrument in the roster', () => {
+    assert.strictEqual(_createGateOpen({ roster: ['Lead'] }, inp({ hasTitle: true })), true);
+    assert.strictEqual(_createGateOpen({ roster: ['Lead'] }, inp()), false);                        // no title
+    assert.strictEqual(_createGateOpen({ roster: [] }, inp({ hasTitle: true })), false);            // no instrument
+    assert.strictEqual(_createGateOpen({ roster: ['Vocals'] }, inp({ hasTitle: true })), false);    // Vocals alone
+    assert.strictEqual(_createGateOpen({ roster: ['Vocals', 'Keys'] }, inp({ hasTitle: true })), true);
+    assert.strictEqual(_createGateOpen({ roster: ['Drums'] }, inp({ hasTitle: true })), true);
 });
 
-t('blank: does not depend on a GP/EOF file', () => {
-    assert.strictEqual(_createGateOpen({ mode: 'blank', gpPath: '/x.gp', eofFiles: [{}] }, inp()), false);
-    assert.strictEqual(_createGateOpen({ mode: 'blank', gpPath: '/x.gp' }, inp({ hasAudio: true, hasTitle: true, hasArtist: true })), true);
+t('gp file wins regardless of roster/title', () => {
+    assert.strictEqual(_createGateOpen({ gpPath: '/song.gp', roster: [] }, inp()), true);
+    assert.strictEqual(_createGateOpen({ gpPath: null, roster: [] }, inp({ hasTitle: true })), false);
 });
 
-t('gp: enabled once a GP file is chosen', () => {
-    assert.strictEqual(_createGateOpen({ mode: 'gp', gpPath: '/song.gp' }, inp()), true);
-    assert.strictEqual(_createGateOpen({ mode: 'gp', gpPath: null }, inp({ hasAudio: true, hasTitle: true, hasArtist: true })), false);
+t('eof file(s) win regardless of roster/title', () => {
+    assert.strictEqual(_createGateOpen({ eofFiles: [{}], roster: [] }, inp()), true);
+    assert.strictEqual(_createGateOpen({ eofFiles: [], roster: ['Lead'] }, inp({ hasTitle: true })), true); // empty list -> roster+title
+    assert.strictEqual(_createGateOpen({ eofFiles: null, roster: [] }, inp()), false);
 });
 
-t('eof: enabled once XML file(s) chosen', () => {
-    assert.strictEqual(_createGateOpen({ mode: 'eof', eofFiles: [{}] }, inp()), true);
-    assert.strictEqual(_createGateOpen({ mode: 'eof', eofFiles: [] }, inp({ hasAudio: true, hasTitle: true, hasArtist: true })), false);
-    assert.strictEqual(_createGateOpen({ mode: 'eof', eofFiles: null }, inp()), false);
-});
-
-t('defensive: null state / unknown mode -> disabled', () => {
-    assert.strictEqual(_createGateOpen(null, inp({ hasAudio: true, hasTitle: true, hasArtist: true })), false);
-    assert.strictEqual(_createGateOpen({ mode: 'wat' }, inp({ hasAudio: true, hasTitle: true, hasArtist: true })), false);
+t('defensive: null state / null flags -> disabled', () => {
+    assert.strictEqual(_createGateOpen(null, inp({ hasTitle: true })), false);
+    assert.strictEqual(_createGateOpen({ roster: ['Lead'] }, null), false);
 });
 
 console.log(`\n${pass} passed, ${fail} failed`);

From 4ffa3f72f253391d7648171b43fc0763469b886f Mon Sep 17 00:00:00 2001
From: ChrisBeWithYou <chris@rifflarr.local>
Date: Sat, 4 Jul 2026 05:53:49 -0500
Subject: [PATCH 05/11] feat(editor): album-art picker from the Cover Art
 Archive
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Cover art lives in the Cover Art Archive (CAA), keyed by RELEASE MBID — which
the create modal's MusicBrainz "Match" already carries (candidate.release_id).
A "Find cover…" button next to the album-art file input opens a Plex-style grid
of covers for the song's releases; click one to bake it into the pack.

- routes.py: GET /caa-cover/{release_id} (server-side CAA front-500 fetch,
  cached under STORAGE_DIR, FileResponse; 404 when a release has no art so the
  grid can hide the tile — dodges browser CORS and gives us the bytes) and
  POST /use-caa-cover → an art_path create_sloppak bakes like an upload.
  release_id is regex-validated before URL interpolation.
- screen.*: "Find cover…" button; editorArtSearch popup — prefilled artist/title,
  reuses /api/enrichment/search for candidate release MBIDs, one tile per unique
  release (same-origin <img>, onerror-hidden), pick → art_path + preview.

Verified on :8000: real covers returned per release, 404s hidden, art_path baked.
---
 routes.py   |  64 ++++++++++++++++++++++++++
 screen.html |  16 ++++---
 screen.js   | 129 ++++++++++++++++++++++++++++++++++++++++++++++++++++
 3 files changed, 203 insertions(+), 6 deletions(-)

diff --git a/routes.py b/routes.py
index 4b135926..ce7abe0c 100644
--- a/routes.py
+++ b/routes.py
@@ -4052,6 +4052,70 @@ async def upload_art(file: UploadFile = File(...)):
         dest.write_bytes(content)
         return {"art_path": str(dest)}
 
+    # ── Cover Art Archive — album-art picker from a MusicBrainz release ─────
+    # Cover art lives in the Cover Art Archive (CAA), keyed by RELEASE MBID —
+    # which the create modal's MusicBrainz "Match" already carries (a candidate's
+    # `release_id`). Fetched server-side (dodges browser CORS + gives us the
+    # bytes to bake into the pack) and cached under STORAGE_DIR.
+    _CAA_ID_RE = re.compile(r"^[0-9a-fA-F-]{1,64}$")
+    _CAA_MAX_BYTES = 10 * 1024 * 1024
+    _CAA_UA = "feedBack-editor/1.0 ( https://github.com/got-feedback/feedBack )"
+
+    def _caa_fetch_front(release_id: str, size: int = 500):
+        """Front cover (size px) for a release MBID from coverartarchive.org, or
+        None when the release has no art / on any error. `release_id` is
+        regex-validated by callers before it reaches this URL."""
+        import urllib.request
+        url = f"https://coverartarchive.org/release/{release_id}/front-{size}"
+        try:
+            req = urllib.request.Request(url, headers={"User-Agent": _CAA_UA})
+            with urllib.request.urlopen(req, timeout=10) as resp:
+                if getattr(resp, "status", 200) != 200:
+                    return None
+                data = resp.read(_CAA_MAX_BYTES + 1)
+        except Exception:
+            return None
+        if not data or len(data) > _CAA_MAX_BYTES or len(data) < 100:
+            return None
+        return data
+
+    async def _caa_cached(release_id: str):
+        """Cached cover file for the release (fetch + cache on first use), or
+        None when there's no art."""
+        dest = STORAGE_DIR / f"caa_{release_id}.jpg"
+        if dest.exists() and dest.stat().st_size > 100:
+            return dest
+        data = await asyncio.get_event_loop().run_in_executor(
+            None, _caa_fetch_front, release_id)
+        if data is None:
+            return None
+        dest.write_bytes(data)
+        return dest
+
+    @app.get("/api/plugins/editor/caa-cover/{release_id}")
+    async def caa_cover(release_id: str):
+        """Serve the CAA front cover for a release MBID (cached). 404 when the
+        release has no art — the picker hides those tiles. Same-origin, so the
+        grid's <img> loads under the app's CSP without an external host."""
+        if not _CAA_ID_RE.match(release_id or ""):
+            return JSONResponse({"error": "invalid release_id"}, 400)
+        dest = await _caa_cached(release_id)
+        if dest is None:
+            return JSONResponse({"error": "no cover art"}, 404)
+        return FileResponse(dest, media_type="image/jpeg")
+
+    @app.post("/api/plugins/editor/use-caa-cover")
+    async def use_caa_cover(data: dict):
+        """Pick a CAA cover as the pack's album art: fetch/cache it and return an
+        art_path under STORAGE_DIR that create_sloppak bakes in like an upload."""
+        release_id = str((data or {}).get("release_id") or "")
+        if not _CAA_ID_RE.match(release_id):
+            return JSONResponse({"error": "invalid release_id"}, 400)
+        dest = await _caa_cached(release_id)
+        if dest is None:
+            return JSONResponse({"error": "no cover art"}, 404)
+        return {"art_path": str(dest)}
+
     # ── Upload hover-preview clip ──────────────────────────────────────
     @app.post("/api/plugins/editor/upload-preview")
     async def upload_preview(file: UploadFile = File(...)):
diff --git a/screen.html b/screen.html
index cfe1d31a..42e3a4e2 100644
--- a/screen.html
+++ b/screen.html
@@ -268,17 +268,21 @@
               <!-- ===== RIGHT: album art + song details ===== -->
               <div class="space-y-4">
 
-            <!-- Album Art — promoted to a proper preview + browse on the wide side. -->
+            <!-- Album Art — upload a file OR pick a cover from the Cover Art Archive. -->
             <div class="rounded-lg border border-gray-800 p-3">
                 <div class="text-xs font-semibold text-gray-300 mb-2">Album Art <span class="text-gray-600 font-normal">— optional</span></div>
                 <div class="flex items-center gap-3">
                     <div id="editor-create-art-preview" style="width:5.5rem;height:5.5rem;background-size:cover;background-position:center"
                         class="rounded bg-dark-800 border border-gray-700 flex items-center justify-center text-gray-600 text-[10px] text-center shrink-0 overflow-hidden">No art yet</div>
-                    <div class="flex-1">
-                        <input type="file" id="editor-create-art" accept=".png,.jpg,.jpeg,.dds"
-                            onchange="editorCreateArtSelected(this)"
-                            class="w-full text-xs text-gray-400 file:mr-3 file:py-1 file:px-3 file:rounded file:border-0 file:text-xs file:bg-dark-600 file:text-gray-300 hover:file:bg-dark-500">
-                        <p class="text-[11px] text-gray-600 mt-1">PNG or JPG. Shown in the library and player.</p>
+                    <div class="flex-1 min-w-0">
+                        <div class="flex items-center gap-2">
+                            <input type="file" id="editor-create-art" accept=".png,.jpg,.jpeg,.dds"
+                                onchange="editorCreateArtSelected(this)"
+                                class="flex-1 min-w-0 text-xs text-gray-400 file:mr-2 file:py-1 file:px-2 file:rounded file:border-0 file:text-xs file:bg-dark-600 file:text-gray-300 hover:file:bg-dark-500">
+                            <button type="button" onclick="editorArtSearch()"
+                                class="px-2 py-1 rounded text-xs font-medium bg-dark-600 text-gray-300 hover:bg-dark-500 shrink-0">Find cover…</button>
+                        </div>
+                        <p class="text-[11px] text-gray-600 mt-1">Upload a file, or find a cover from MusicBrainz.</p>
                     </div>
                 </div>
             </div>
diff --git a/screen.js b/screen.js
index 0ee2ccd8..abad8d4d 100644
--- a/screen.js
+++ b/screen.js
@@ -6739,6 +6739,135 @@ window.editorCreateArtSelected = async (input) => {
     } catch (_) { /* art just won't be baked if the upload fails */ }
 };
 
+// ════════════════════════════════════════════════════════════════════
+// Album-art picker — a Plex-style grid of covers from the Cover Art Archive.
+// Reuses the MusicBrainz search to get candidate release MBIDs, then shows one
+// tile per release's CAA front cover (served same-origin via the editor plugin,
+// so it loads under the app's CSP). Pick one → baked as the pack's art.
+// ════════════════════════════════════════════════════════════════════
+window.editorArtSearch = () => {
+    _editorArtOpenPopup(_cval('editor-create-artist'), _cval('editor-create-title'));
+};
+
+function _editorArtOpenPopup(artist, title) {
+    document.getElementById('editor-art-popup')?.remove();
+    const modal = document.createElement('div');
+    modal.id = 'editor-art-popup';
+    modal.className = 'fixed inset-0 bg-black/70 z-50 flex items-center justify-center';
+    const inner = document.createElement('div');
+    inner.className = 'bg-dark-800 border border-gray-700 rounded-xl w-full max-w-lg mx-4 flex flex-col';
+    inner.style.maxHeight = '80vh';
+    const head = document.createElement('div');
+    head.className = 'flex items-center justify-between px-4 py-3 border-b border-gray-700';
+    const h = document.createElement('span'); h.className = 'text-sm font-medium'; h.textContent = 'Choose album art';
+    const close = document.createElement('button'); close.type = 'button'; close.className = 'text-gray-500 hover:text-white'; close.textContent = '×';
+    close.onclick = () => modal.remove();
+    head.appendChild(h); head.appendChild(close); inner.appendChild(head);
+    const qrow = document.createElement('div');
+    qrow.className = 'flex items-center gap-2 px-4 py-2 border-b border-gray-700';
+    const mk = (ph, val) => {
+        const i = document.createElement('input');
+        i.type = 'text'; i.placeholder = ph; i.value = val || '';
+        i.className = 'flex-1 min-w-0 bg-dark-900 border border-gray-700 rounded px-2 py-1 text-xs text-gray-300 outline-none focus:border-accent/50';
+        return i;
+    };
+    const aIn = mk('Artist', artist);
+    const tIn = mk('Title', title);
+    const go = document.createElement('button');
+    go.type = 'button'; go.className = 'px-2 py-1 rounded text-xs font-medium bg-dark-600 text-gray-300 hover:bg-dark-500 shrink-0';
+    go.textContent = 'Search';
+    qrow.appendChild(aIn); qrow.appendChild(tIn); qrow.appendChild(go); inner.appendChild(qrow);
+    const grid = document.createElement('div');
+    grid.id = 'editor-art-grid';
+    grid.className = 'flex-1 overflow-y-auto p-3';
+    grid.style.cssText = 'display:grid;grid-template-columns:repeat(3,1fr);gap:8px;';
+    inner.appendChild(grid);
+    modal.appendChild(inner);
+    if (typeof _installModalKeyboard === 'function') _installModalKeyboard(modal, inner, () => modal.remove());
+    document.body.appendChild(modal);
+    const run = () => _editorArtRunSearch(aIn.value.trim(), tIn.value.trim(), grid);
+    go.onclick = run;
+    const onEnter = (e) => { if (e.key === 'Enter') { e.preventDefault(); run(); } };
+    aIn.addEventListener('keydown', onEnter); tIn.addEventListener('keydown', onEnter);
+    run();
+}
+
+function _editorArtMsg(grid, text) {
+    const d = document.createElement('div');
+    d.className = 'text-xs text-gray-500 p-2';
+    d.style.gridColumn = '1 / -1';
+    d.textContent = text;
+    grid.appendChild(d);
+}
+
+async function _editorArtRunSearch(artist, title, grid) {
+    grid.replaceChildren();
+    if (!artist && !title) { _editorArtMsg(grid, 'Enter an artist or title.'); return; }
+    _editorArtMsg(grid, 'Searching for covers…');
+    const params = new URLSearchParams();
+    if (artist) params.set('artist', artist);
+    if (title) params.set('title', title);
+    params.set('limit', '20');
+    let data = null;
+    try {
+        const resp = await fetch('/api/enrichment/search?' + params.toString());
+        data = await resp.json().catch(() => null);
+    } catch (_) { data = null; }
+    grid.replaceChildren();
+    const cands = (data && data.candidates) || [];
+    // One tile per unique release (a release MBID = one CAA cover).
+    const seen = new Set(); const rels = [];
+    for (const c of cands) {
+        const rid = c && c.release_id;
+        if (rid && !seen.has(rid)) { seen.add(rid); rels.push({ id: rid, label: c.album || c.title || '' }); }
+    }
+    if (!rels.length) { _editorArtMsg(grid, 'No covers found — refine the artist/title.'); return; }
+    const hint = document.createElement('div');
+    hint.className = 'text-[11px] text-gray-600 pb-1'; hint.style.gridColumn = '1 / -1';
+    hint.textContent = 'Covers with no art are hidden. Click one to use it.';
+    grid.appendChild(hint);
+    for (const r of rels) grid.appendChild(_editorArtTile(r));
+}
+
+function _editorArtTile(r) {
+    const btn = document.createElement('button');
+    btn.type = 'button';
+    btn.className = 'rounded overflow-hidden border border-gray-700 hover:border-accent bg-dark-900 text-left';
+    btn.style.cssText = 'display:flex;flex-direction:column;';
+    const img = document.createElement('img');
+    img.src = '/api/plugins/editor/caa-cover/' + encodeURIComponent(r.id);
+    img.alt = r.label;
+    img.loading = 'lazy';
+    img.style.cssText = 'width:100%;aspect-ratio:1/1;object-fit:cover;display:block;background:#15161c;';
+    // 404 (no art for this release) → hide the whole tile.
+    img.onerror = () => { btn.style.display = 'none'; };
+    const cap = document.createElement('span');
+    cap.className = 'text-[10px] text-gray-400 px-1 py-0.5';
+    cap.style.cssText = 'overflow:hidden;text-overflow:ellipsis;white-space:nowrap;';
+    cap.textContent = r.label;
+    btn.appendChild(img); btn.appendChild(cap);
+    btn.onclick = () => _editorPickCaaCover(r.id);
+    return btn;
+}
+
+async function _editorPickCaaCover(release_id) {
+    try {
+        const resp = await fetch('/api/plugins/editor/use-caa-cover', {
+            method: 'POST', headers: { 'Content-Type': 'application/json' },
+            body: JSON.stringify({ release_id }),
+        });
+        const data = await resp.json().catch(() => null);
+        if (!resp.ok || !data || !data.art_path) return;
+        createState.artPath = data.art_path;
+        const prev = document.getElementById('editor-create-art-preview');
+        if (prev) {
+            prev.style.backgroundImage = 'url("/api/plugins/editor/caa-cover/' + encodeURIComponent(release_id) + '")';
+            prev.textContent = '';
+        }
+    } catch (_) { /* leave art unset on failure */ }
+    document.getElementById('editor-art-popup')?.remove();
+}
+
 function _populateCreateArrButtons() {
     const wrap = document.getElementById('editor-create-arr-buttons');
     if (!wrap) return;

From f595d693b0e1376aedb94c177421ff71db0ef309 Mon Sep 17 00:00:00 2001
From: ChrisBeWithYou <chris@rifflarr.local>
Date: Sat, 4 Jul 2026 06:04:12 -0500
Subject: [PATCH 06/11] fix(editor): album-centric cover picker (canonical
 cover first)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

The art picker reused the RECORDING search, so it inherited the same "dozens of
comp/reissue versions" problem — random covers instead of the canonical album.
Album art is a property of the ALBUM, so search MusicBrainz RELEASE-GROUPS, which
(unlike recording releases) carry reliable Album vs Live/Compilation typing.

- routes.py: GET /cover-search?artist=&query= → release-group search, studio
  album first (primary Album, no Live/Compilation secondary type), earliest.
  caa-cover/use-caa-cover gain a release-group mode (?group=1) since CAA also
  serves release-group front art.
- screen.*: the picker's second field is now "Album (or song)", prefilled from
  the Album field (filled by a MusicBrainz Match) or the title; tiles come from
  cover-search (canonical first), with the recording-release covers as a
  fallback for non-title-track songs searched art-first.

This fixes "art search shows random covers" and makes art-first work: verified
AC/DC "Highway to Hell" returns the 1979 studio album cover as the first tile.
---
 routes.py | 104 ++++++++++++++++++++++++++++++++++++++++++------------
 screen.js |  84 +++++++++++++++++++++++++++----------------
 2 files changed, 135 insertions(+), 53 deletions(-)

diff --git a/routes.py b/routes.py
index ce7abe0c..77e9b66a 100644
--- a/routes.py
+++ b/routes.py
@@ -4061,12 +4061,16 @@ async def upload_art(file: UploadFile = File(...)):
     _CAA_MAX_BYTES = 10 * 1024 * 1024
     _CAA_UA = "feedBack-editor/1.0 ( https://github.com/got-feedback/feedBack )"
 
-    def _caa_fetch_front(release_id: str, size: int = 500):
-        """Front cover (size px) for a release MBID from coverartarchive.org, or
-        None when the release has no art / on any error. `release_id` is
-        regex-validated by callers before it reaches this URL."""
+    _CAA_SECONDARY_SKIP = {"live", "compilation", "remix", "dj-mix",
+                           "mixtape/street", "demo", "interview", "audiobook",
+                           "spokenword"}
+
+    def _caa_fetch_front(cover_id: str, size: int = 500, kind: str = "release"):
+        """Front cover (size px) for a MusicBrainz `kind` ('release' or
+        'release-group') from coverartarchive.org, or None when there's no art /
+        on any error. `cover_id` is regex-validated by callers before the URL."""
         import urllib.request
-        url = f"https://coverartarchive.org/release/{release_id}/front-{size}"
+        url = f"https://coverartarchive.org/{kind}/{cover_id}/front-{size}"
         try:
             req = urllib.request.Request(url, headers={"User-Agent": _CAA_UA})
             with urllib.request.urlopen(req, timeout=10) as resp:
@@ -4079,27 +4083,27 @@ def _caa_fetch_front(release_id: str, size: int = 500):
             return None
         return data
 
-    async def _caa_cached(release_id: str):
-        """Cached cover file for the release (fetch + cache on first use), or
-        None when there's no art."""
-        dest = STORAGE_DIR / f"caa_{release_id}.jpg"
+    async def _caa_cached(cover_id: str, kind: str = "release"):
+        """Cached cover file (fetch + cache on first use), or None when no art."""
+        tag = "rg_" if kind == "release-group" else ""
+        dest = STORAGE_DIR / f"caa_{tag}{cover_id}.jpg"
         if dest.exists() and dest.stat().st_size > 100:
             return dest
         data = await asyncio.get_event_loop().run_in_executor(
-            None, _caa_fetch_front, release_id)
+            None, _caa_fetch_front, cover_id, 500, kind)
         if data is None:
             return None
         dest.write_bytes(data)
         return dest
 
-    @app.get("/api/plugins/editor/caa-cover/{release_id}")
-    async def caa_cover(release_id: str):
-        """Serve the CAA front cover for a release MBID (cached). 404 when the
-        release has no art — the picker hides those tiles. Same-origin, so the
-        grid's <img> loads under the app's CSP without an external host."""
-        if not _CAA_ID_RE.match(release_id or ""):
-            return JSONResponse({"error": "invalid release_id"}, 400)
-        dest = await _caa_cached(release_id)
+    @app.get("/api/plugins/editor/caa-cover/{cover_id}")
+    async def caa_cover(cover_id: str, group: int = 0):
+        """Serve the CAA front cover for a release (or release-group when
+        ?group=1), cached. 404 when there's no art — the picker hides the tile.
+        Same-origin so it loads under the app's CSP without an external host."""
+        if not _CAA_ID_RE.match(cover_id or ""):
+            return JSONResponse({"error": "invalid id"}, 400)
+        dest = await _caa_cached(cover_id, "release-group" if group else "release")
         if dest is None:
             return JSONResponse({"error": "no cover art"}, 404)
         return FileResponse(dest, media_type="image/jpeg")
@@ -4108,14 +4112,70 @@ async def caa_cover(release_id: str):
     async def use_caa_cover(data: dict):
         """Pick a CAA cover as the pack's album art: fetch/cache it and return an
         art_path under STORAGE_DIR that create_sloppak bakes in like an upload."""
-        release_id = str((data or {}).get("release_id") or "")
-        if not _CAA_ID_RE.match(release_id):
-            return JSONResponse({"error": "invalid release_id"}, 400)
-        dest = await _caa_cached(release_id)
+        cover_id = str((data or {}).get("release_id") or "")
+        kind = "release-group" if (data or {}).get("group") else "release"
+        if not _CAA_ID_RE.match(cover_id):
+            return JSONResponse({"error": "invalid id"}, 400)
+        dest = await _caa_cached(cover_id, kind)
         if dest is None:
             return JSONResponse({"error": "no cover art"}, 404)
         return {"art_path": str(dest)}
 
+    # Album-centric cover search. MusicBrainz RELEASE-GROUPS carry reliable Album
+    # vs Live/Compilation typing (unlike recording releases), so searching them by
+    # artist + album/title and preferring the studio album surfaces the CANONICAL
+    # cover first — the fix for "art search shows random comp covers". Works
+    # art-first for title-tracks; for other songs, fill the Album (or run Match).
+    def _mb_release_group_covers(artist: str, query: str) -> list:
+        """Release-group search → [{id, title, year, studio}] studio-albums first."""
+        import urllib.request
+        import urllib.parse
+
+        def _phrase(s):
+            return s.replace("\\", "\\\\").replace('"', '\\"')
+
+        parts = []
+        if query:
+            parts.append('releasegroup:"%s"' % _phrase(query))
+        if artist:
+            parts.append('artist:"%s"' % _phrase(artist))
+        if not parts:
+            return []
+        url = ("https://musicbrainz.org/ws/2/release-group?"
+               + urllib.parse.urlencode(
+                   {"query": " AND ".join(parts), "fmt": "json", "limit": 15}))
+        try:
+            req = urllib.request.Request(url, headers={"User-Agent": _CAA_UA})
+            with urllib.request.urlopen(req, timeout=15) as resp:
+                body = json.loads(resp.read().decode("utf-8", "replace"))
+        except Exception:
+            return []
+        out = []
+        for rg in (body.get("release-groups") or []):
+            if not isinstance(rg, dict) or not rg.get("id"):
+                continue
+            secs = {str(s).lower() for s in (rg.get("secondary-types") or [])}
+            studio = (str(rg.get("primary-type", "")).lower() == "album"
+                      and not (secs & _CAA_SECONDARY_SKIP))
+            out.append({
+                "id": str(rg["id"]),
+                "title": str(rg.get("title", "") or ""),
+                "year": str(rg.get("first-release-date", "") or "")[:4],
+                "studio": studio,
+            })
+        out.sort(key=lambda g: (0 if g["studio"] else 1, g["year"] or "9999"))
+        return out
+
+    @app.get("/api/plugins/editor/cover-search")
+    async def cover_search(artist: str = "", query: str = ""):
+        """Album-centric cover candidates (release-groups) for the art picker.
+        `query` is the ALBUM (best) or the song title. Studio album first."""
+        if not (artist.strip() or query.strip()):
+            return {"covers": []}
+        covers = await asyncio.get_event_loop().run_in_executor(
+            None, _mb_release_group_covers, artist.strip(), query.strip())
+        return {"covers": covers}
+
     # ── Upload hover-preview clip ──────────────────────────────────────
     @app.post("/api/plugins/editor/upload-preview")
     async def upload_preview(file: UploadFile = File(...)):
diff --git a/screen.js b/screen.js
index abad8d4d..477b0908 100644
--- a/screen.js
+++ b/screen.js
@@ -6746,10 +6746,15 @@ window.editorCreateArtSelected = async (input) => {
 // so it loads under the app's CSP). Pick one → baked as the pack's art.
 // ════════════════════════════════════════════════════════════════════
 window.editorArtSearch = () => {
-    _editorArtOpenPopup(_cval('editor-create-artist'), _cval('editor-create-title'));
+    // Art is an ALBUM property, so search by the album when we know it (filled by
+    // a MusicBrainz Match, or typed) — falling back to the title. This is why
+    // Match-first works: it fills the album, which pins the canonical cover.
+    const album = _cval('editor-create-album');
+    const title = _cval('editor-create-title');
+    _editorArtOpenPopup(_cval('editor-create-artist'), album || title);
 };
 
-function _editorArtOpenPopup(artist, title) {
+function _editorArtOpenPopup(artist, query) {
     document.getElementById('editor-art-popup')?.remove();
     const modal = document.createElement('div');
     modal.id = 'editor-art-popup';
@@ -6772,7 +6777,7 @@ function _editorArtOpenPopup(artist, title) {
         return i;
     };
     const aIn = mk('Artist', artist);
-    const tIn = mk('Title', title);
+    const tIn = mk('Album (or song)', query);
     const go = document.createElement('button');
     go.type = 'button'; go.className = 'px-2 py-1 rounded text-xs font-medium bg-dark-600 text-gray-300 hover:bg-dark-500 shrink-0';
     go.textContent = 'Search';
@@ -6800,43 +6805,59 @@ function _editorArtMsg(grid, text) {
     grid.appendChild(d);
 }
 
-async function _editorArtRunSearch(artist, title, grid) {
+async function _editorArtRunSearch(artist, query, grid) {
     grid.replaceChildren();
-    if (!artist && !title) { _editorArtMsg(grid, 'Enter an artist or title.'); return; }
+    if (!artist && !query) { _editorArtMsg(grid, 'Enter an artist and album (or song).'); return; }
     _editorArtMsg(grid, 'Searching for covers…');
-    const params = new URLSearchParams();
-    if (artist) params.set('artist', artist);
-    if (title) params.set('title', title);
-    params.set('limit', '20');
-    let data = null;
+    // ALBUM-centric: MusicBrainz release-groups reliably tell studio Album from
+    // Live/Compilation, so the canonical album cover comes first.
+    let tiles = [];
     try {
-        const resp = await fetch('/api/enrichment/search?' + params.toString());
-        data = await resp.json().catch(() => null);
-    } catch (_) { data = null; }
+        const p = new URLSearchParams();
+        if (artist) p.set('artist', artist);
+        if (query) p.set('query', query);
+        const r = await fetch('/api/plugins/editor/cover-search?' + p.toString());
+        const d = await r.json().catch(() => null);
+        tiles = ((d && d.covers) || []).map(c => ({
+            id: c.id, group: true, studio: c.studio,
+            label: c.year ? (c.title + ' (' + c.year + ')') : c.title,
+        }));
+    } catch (_) { /* fall through to the recording-based fallback */ }
+    // Fallback (e.g. a non-title-track searched art-first with no album): the
+    // recording search's per-release covers — less canonical, but something.
+    if (!tiles.length) {
+        try {
+            const p2 = new URLSearchParams();
+            if (artist) p2.set('artist', artist);
+            if (query) p2.set('title', query);
+            p2.set('limit', '15');
+            const r2 = await fetch('/api/enrichment/search?' + p2.toString());
+            const d2 = await r2.json().catch(() => null);
+            const seen = new Set();
+            for (const c of ((d2 && d2.candidates) || [])) {
+                const rid = c && c.release_id;
+                if (rid && !seen.has(rid)) { seen.add(rid); tiles.push({ id: rid, group: false, label: c.album || c.title || '' }); }
+            }
+        } catch (_) { /* nothing else to try */ }
+    }
     grid.replaceChildren();
-    const cands = (data && data.candidates) || [];
-    // One tile per unique release (a release MBID = one CAA cover).
-    const seen = new Set(); const rels = [];
-    for (const c of cands) {
-        const rid = c && c.release_id;
-        if (rid && !seen.has(rid)) { seen.add(rid); rels.push({ id: rid, label: c.album || c.title || '' }); }
-    }
-    if (!rels.length) { _editorArtMsg(grid, 'No covers found — refine the artist/title.'); return; }
+    if (!tiles.length) { _editorArtMsg(grid, 'No covers found — add the album name, or run Match first.'); return; }
     const hint = document.createElement('div');
     hint.className = 'text-[11px] text-gray-600 pb-1'; hint.style.gridColumn = '1 / -1';
-    hint.textContent = 'Covers with no art are hidden. Click one to use it.';
+    hint.textContent = 'Studio album first · covers with no art are hidden · click to use.';
     grid.appendChild(hint);
-    for (const r of rels) grid.appendChild(_editorArtTile(r));
+    for (const t of tiles) grid.appendChild(_editorArtTile(t));
 }
 
-function _editorArtTile(r) {
+function _editorArtTile(t) {
     const btn = document.createElement('button');
     btn.type = 'button';
     btn.className = 'rounded overflow-hidden border border-gray-700 hover:border-accent bg-dark-900 text-left';
     btn.style.cssText = 'display:flex;flex-direction:column;';
+    const q = t.group ? '?group=1' : '';
     const img = document.createElement('img');
-    img.src = '/api/plugins/editor/caa-cover/' + encodeURIComponent(r.id);
-    img.alt = r.label;
+    img.src = '/api/plugins/editor/caa-cover/' + encodeURIComponent(t.id) + q;
+    img.alt = t.label;
     img.loading = 'lazy';
     img.style.cssText = 'width:100%;aspect-ratio:1/1;object-fit:cover;display:block;background:#15161c;';
     // 404 (no art for this release) → hide the whole tile.
@@ -6844,24 +6865,25 @@ function _editorArtTile(r) {
     const cap = document.createElement('span');
     cap.className = 'text-[10px] text-gray-400 px-1 py-0.5';
     cap.style.cssText = 'overflow:hidden;text-overflow:ellipsis;white-space:nowrap;';
-    cap.textContent = r.label;
+    cap.textContent = t.label;
     btn.appendChild(img); btn.appendChild(cap);
-    btn.onclick = () => _editorPickCaaCover(r.id);
+    btn.onclick = () => _editorPickCaaCover(t.id, t.group);
     return btn;
 }
 
-async function _editorPickCaaCover(release_id) {
+async function _editorPickCaaCover(id, group) {
+    const q = group ? '?group=1' : '';
     try {
         const resp = await fetch('/api/plugins/editor/use-caa-cover', {
             method: 'POST', headers: { 'Content-Type': 'application/json' },
-            body: JSON.stringify({ release_id }),
+            body: JSON.stringify({ release_id: id, group: !!group }),
         });
         const data = await resp.json().catch(() => null);
         if (!resp.ok || !data || !data.art_path) return;
         createState.artPath = data.art_path;
         const prev = document.getElementById('editor-create-art-preview');
         if (prev) {
-            prev.style.backgroundImage = 'url("/api/plugins/editor/caa-cover/' + encodeURIComponent(release_id) + '")';
+            prev.style.backgroundImage = 'url("/api/plugins/editor/caa-cover/' + encodeURIComponent(id) + q + '")';
             prev.textContent = '';
         }
     } catch (_) { /* leave art unset on failure */ }

From 989665fdbda4121d3aea94f9c0579d69fb5e42d9 Mon Sep 17 00:00:00 2001
From: ChrisBeWithYou <chris@rifflarr.local>
Date: Sat, 4 Jul 2026 06:12:03 -0500
Subject: [PATCH 07/11] fix(editor): MusicBrainz Match fetches the full 25
 candidates
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

A non-title-track studio recording can sit well down MusicBrainz's flat list
(dozens of comp/reissue takes score identically), so a small limit dropped it
entirely and the duration re-rank had nothing to promote. Fetch the max (25) and
pass the staged audio's duration. Marginal — MB's search order is
non-deterministic, so text matching still can't reliably surface the canonical
non-title-track recording; audio fingerprinting (AcoustID) is the real fix.
---
 screen.js | 11 ++++++++++-
 1 file changed, 10 insertions(+), 1 deletion(-)

diff --git a/screen.js b/screen.js
index 477b0908..2eeb4f8a 100644
--- a/screen.js
+++ b/screen.js
@@ -6630,7 +6630,16 @@ async function _editorMbRunSearch(artist, title, resultsEl) {
     const params = new URLSearchParams();
     if (artist) params.set('artist', artist);
     if (title) params.set('title', title);
-    params.set('limit', '15');
+    // Fetch the max (25): a non-title-track studio recording can sit well down
+    // MusicBrainz's flat list (dozens of comp/reissue takes score identically),
+    // so a small limit drops it entirely and the duration re-rank has nothing to
+    // promote. Verified: Judas Priest "Living After Midnight" — the 1980 British
+    // Steel take is absent at 15 but present (and #1 after duration) at 25.
+    params.set('limit', '25');
+    // Pass the staged master audio's length so the server can corroborate too
+    // (harmless if the core doesn't consume it; the client re-rank below is the
+    // load-bearing path today).
+    if (Number(createState.audioDuration) > 0) params.set('duration', String(Math.round(createState.audioDuration)));
     let data = null, status = 0;
     try {
         const resp = await fetch('/api/enrichment/search?' + params.toString());

From 36ccf08bb6f1880c917d28ce175dfa5feb97a0d4 Mon Sep 17 00:00:00 2001
From: ChrisBeWithYou <chris@rifflarr.local>
Date: Sat, 4 Jul 2026 07:50:24 -0500
Subject: [PATCH 08/11] feat(editor): "Identify from audio" in the create modal
 (AcoustID fingerprint)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Add an "Identify from audio…" button beside Match: it re-POSTs the staged master
audio to core /api/enrichment/identify and fills the exact recording, reusing the
MB result rows + apply path (identify returns the same candidate shape). Track
the staged File so the bytes can be re-uploaded (core can't read our stored copy).

Self-serve: when AcoustID is off (412 needs_setup), the popup expands an inline
"enable + paste your key" form (application-key guidance + a register link) that
saves to core settings and re-runs — no separate settings screen. A saved-but-
rejected key (503) offers "Change AcoustID key" so it never dead-ends. Autofill
note reflects the real source (fingerprint vs MusicBrainz).
---
 screen.html |  11 ++--
 screen.js   | 142 +++++++++++++++++++++++++++++++++++++++++++++++++++-
 2 files changed, 148 insertions(+), 5 deletions(-)

diff --git a/screen.html b/screen.html
index 42e3a4e2..f6f719c6 100644
--- a/screen.html
+++ b/screen.html
@@ -364,10 +364,15 @@
                 <div class="flex items-center justify-between gap-2">
                     <div>
                         <div class="text-xs font-semibold text-gray-300">Match metadata</div>
-                        <p class="text-[11px] text-gray-600">Look this song up on MusicBrainz and fill the details.</p>
+                        <p class="text-[11px] text-gray-600">Look this song up on MusicBrainz, or identify the exact recording from your audio.</p>
+                    </div>
+                    <div class="flex items-center gap-1.5 shrink-0">
+                        <button type="button" id="editor-create-identify-btn" onclick="editorIdentifyAudio()" disabled
+                            title="Identify the exact recording by fingerprinting your master audio"
+                            class="px-2 py-1 rounded text-xs font-medium bg-dark-600 text-gray-300 hover:bg-dark-500 disabled:opacity-50 disabled:cursor-not-allowed">Identify from audio…</button>
+                        <button type="button" id="editor-create-mb-btn" onclick="editorMbMatch()"
+                            class="px-2 py-1 rounded text-xs font-medium bg-dark-600 text-gray-300 hover:bg-dark-500 disabled:opacity-50 disabled:cursor-not-allowed">Match…</button>
                     </div>
-                    <button type="button" id="editor-create-mb-btn" onclick="editorMbMatch()"
-                        class="px-2 py-1 rounded text-xs font-medium bg-dark-600 text-gray-300 hover:bg-dark-500 disabled:opacity-50 disabled:cursor-not-allowed shrink-0">Match…</button>
                 </div>
                 <div id="editor-create-mb-hint" class="text-[11px] text-gray-600 mt-1"></div>
             </div>
diff --git a/screen.js b/screen.js
index 2eeb4f8a..a19e3726 100644
--- a/screen.js
+++ b/screen.js
@@ -5684,7 +5684,7 @@ window.editorShowCreateModal = () => {
         roster: ['Lead'],
         gpPath: null, tracks: null, gpName: null, gpHasEmbedded: false, gpSyncCount: 0,
         eofFiles: null, eofName: null,
-        audioUrl: null, audioName: null, audioDuration: null, midiInfo: null,
+        audioUrl: null, audioName: null, audioDuration: null, audioFile: null, midiInfo: null,
         artPath: null, previewPath: null,
         gp8AudioMode: 'none', autoSyncAudioUrl: null, lastSync: null, autoSyncCoupled: false,
     };
@@ -5714,6 +5714,7 @@ window.editorShowCreateModal = () => {
     renderStaged();
     _syncYtFieldState();
     updateCreateButton();
+    _updateIdentifyButton();   // disabled until a master track is staged
 };
 
 window.editorHideCreateModal = () => {
@@ -6389,6 +6390,7 @@ async function _stageAudio(file) {
     createState.audioUrl = null;
     createState.audioName = null;
     createState.audioDuration = null;
+    createState.audioFile = null;
     const form = new FormData();
     form.append('file', file);
     let url = null, dur = null;
@@ -6404,12 +6406,16 @@ async function _stageAudio(file) {
         createState.audioUrl = url;
         createState.audioName = file.name;
         createState.audioDuration = (Number(dur) > 0) ? Number(dur) : null;
+        // Keep the File itself so "Identify from audio" can re-POST the raw bytes
+        // to core /identify (cross-plugin: the core can't read our stored copy).
+        createState.audioFile = file;
         const titleEl = document.getElementById('editor-create-title');
         if (titleEl && !titleEl.value.trim()) titleEl.value = file.name.replace(/\.[^.]+$/, '');
         if (iStatus) iStatus.textContent = 'Master audio added.';
     }
     _refreshGpAudioUI();       // couple into GP auto-sync if a chart is present
     _syncYtFieldState();
+    _updateIdentifyButton();
 }
 
 function _stageEofFiles(xmls) {
@@ -6516,8 +6522,10 @@ function renderStaged() {
 window.editorStagedRemove = (role) => {
     if (role === 'audio') {
         createState.audioUrl = null; createState.audioName = null; createState.audioDuration = null;
+        createState.audioFile = null;
         _refreshGpAudioUI();        // un-couple: restore embedded/manual GP audio UI
         _syncYtFieldState();
+        _updateIdentifyButton();
     } else if (role === 'yt') {
         const yt = document.getElementById('editor-create-yt-url'); if (yt) yt.value = '';
         _syncYtFieldState();
@@ -6564,6 +6572,134 @@ window.editorMbMatch = () => {
     _editorMbOpenPopup(_cval('editor-create-title'), _cval('editor-create-artist'));
 };
 
+// "Identify from audio" is enabled once a master track is staged — it fingerprints
+// THAT file, so it doesn't need a title/artist (that's the whole point: it's the
+// reliable path when you don't know the metadata yet).
+function _updateIdentifyButton() {
+    const btn = document.getElementById('editor-create-identify-btn');
+    if (!btn) return;
+    const has = !!createState.audioFile;
+    btn.disabled = !has;
+    btn.title = has
+        ? 'Identify the exact recording by fingerprinting your master audio'
+        : 'Add master audio first to identify by fingerprint';
+}
+
+// Fingerprint the staged master audio → the EXACT MusicBrainz recording (AcoustID).
+// Reliable where text search can't be (comp/live takes tie in MusicBrainz). The
+// endpoint returns candidates in the SAME shape as /search, so the popup reuses
+// the MB row + apply renderers.
+window.editorIdentifyAudio = async () => {
+    if (!createState.audioFile) return;
+    document.getElementById('editor-mb-popup')?.remove();
+    const modal = document.createElement('div');
+    modal.id = 'editor-mb-popup';
+    modal.className = 'fixed inset-0 bg-black/70 z-50 flex items-center justify-center';
+    const inner = document.createElement('div');
+    inner.className = 'bg-dark-800 border border-gray-700 rounded-xl w-full max-w-md mx-4 flex flex-col';
+    inner.style.maxHeight = '75vh';
+    const head = document.createElement('div');
+    head.className = 'flex items-center justify-between px-4 py-3 border-b border-gray-700';
+    const h = document.createElement('span'); h.className = 'text-sm font-medium'; h.textContent = 'Identify from audio';
+    const close = document.createElement('button'); close.type = 'button'; close.className = 'text-gray-500 hover:text-white'; close.textContent = '×';
+    close.onclick = () => modal.remove();
+    head.appendChild(h); head.appendChild(close); inner.appendChild(head);
+    const results = document.createElement('div');
+    results.id = 'editor-mb-results';
+    results.className = 'flex-1 overflow-y-auto p-2 space-y-1';
+    inner.appendChild(results);
+    modal.appendChild(inner);
+    if (typeof _installModalKeyboard === 'function') _installModalKeyboard(modal, inner, () => modal.remove());
+    document.body.appendChild(modal);
+    _mbMsg(results, 'Fingerprinting your audio…');
+    const form = new FormData();
+    form.append('file', createState.audioFile);
+    let data = null, status = 0;
+    try {
+        const resp = await fetch('/api/enrichment/identify', { method: 'POST', body: form });
+        status = resp.status;
+        data = await resp.json().catch(() => null);
+    } catch (_) { data = null; }
+    results.replaceChildren();
+    // 412 = not set up (opt-in off / no key). Expand an inline enable + key form
+    // right here (self-serve) — never fake a hit, and no separate settings trip.
+    if (status === 412 || (data && data.needs_setup)) {
+        _editorRenderAcoustidSetup(results);
+        return;
+    }
+    if (status === 503) {
+        // 503 here is usually a rejected key (AcoustID 400) or a transient
+        // outage. Either way, let the user re-enter the key — don't dead-end.
+        results.replaceChildren();
+        const wrap = document.createElement('div'); wrap.className = 'p-3 space-y-2';
+        const m = document.createElement('p'); m.className = 'text-xs text-gray-400';
+        m.textContent = "Couldn't identify — the AcoustID key was rejected, or the service is "
+            + "unreachable. Check the key (use your application's API key, not your account key), "
+            + "or try again.";
+        const change = document.createElement('button');
+        change.type = 'button';
+        change.className = 'px-3 py-1.5 rounded text-xs font-medium bg-dark-600 text-gray-200 hover:bg-dark-500';
+        change.textContent = 'Change AcoustID key';
+        change.onclick = () => _editorRenderAcoustidSetup(results);
+        wrap.appendChild(m); wrap.appendChild(change); results.appendChild(wrap);
+        return;
+    }
+    if (status === 429) { _mbMsg(results, 'AcoustID is busy — try again in a moment.'); return; }
+    if (!data || data.error) { _mbMsg(results, "Couldn't identify this audio — try the text Match instead."); return; }
+    const cands = data.candidates || [];
+    if (!cands.length) { _mbMsg(results, 'No fingerprint match found — try the text Match instead.'); return; }
+    // A fingerprint hit IS this recording, so flag the top row as matching the
+    // audio and focus it; the user confirms by clicking.
+    cands.forEach((c, i) => results.appendChild(_editorMbRow(c, i === 0, i === 0)));
+};
+
+// Inline "turn on audio identification" form, shown in the Identify popup when
+// AcoustID is off / keyless (the 412 needs_setup state). Saves the user's own
+// free key to core settings, then re-runs the fingerprint — self-serve, no
+// separate settings screen (that UI is part of the library-metadata work).
+function _editorRenderAcoustidSetup(el) {
+    el.replaceChildren();
+    const wrap = document.createElement('div'); wrap.className = 'p-3 space-y-2';
+    const msg = document.createElement('p'); msg.className = 'text-xs text-gray-400';
+    msg.textContent = 'Audio identification reads the recording itself — far more reliable than text '
+        + 'search for picking the exact version. It needs your own free AcoustID key (one-time).';
+    const link = document.createElement('a');
+    link.href = 'https://acoustid.org/new-application'; link.target = '_blank'; link.rel = 'noopener';
+    link.className = 'text-xs text-blue-400 hover:underline block';
+    link.textContent = 'Register an application for a free key →';
+    const hint = document.createElement('p'); hint.className = 'text-[11px] text-gray-600';
+    hint.textContent = "Use the application's API key (from acoustid.org/my-applications) — not your account's user key.";
+    const key = document.createElement('input');
+    key.type = 'text'; key.placeholder = 'Paste your AcoustID API key';
+    key.className = 'w-full bg-dark-900 border border-gray-700 rounded px-2 py-1 text-xs text-gray-300 outline-none focus:border-accent/50';
+    const err = document.createElement('div'); err.className = 'text-[11px] text-red-400';
+    const go = document.createElement('button');
+    go.type = 'button'; go.className = 'px-3 py-1.5 rounded text-xs font-medium text-white';
+    go.style.background = '#2563eb'; go.textContent = 'Enable & identify';
+    const submit = async () => {
+        const k = key.value.trim();
+        if (!k) { err.textContent = 'Paste your key first.'; return; }
+        go.disabled = true; err.textContent = ''; go.textContent = 'Saving…';
+        let ok = false;
+        try {
+            const r = await fetch('/api/settings', {
+                method: 'POST', headers: { 'Content-Type': 'application/json' },
+                body: JSON.stringify({ acoustid_enabled: true, acoustid_api_key: k }),
+            });
+            const d = await r.json().catch(() => null);
+            ok = r.ok && !(d && d.error);
+            if (!ok && d && d.error) err.textContent = d.error;
+        } catch (_) {}
+        if (ok) { window.editorIdentifyAudio(); }   // re-open + run the fingerprint
+        else { go.disabled = false; go.textContent = 'Enable & identify'; if (!err.textContent) err.textContent = "Couldn't save the key."; }
+    };
+    go.onclick = submit;
+    key.addEventListener('keydown', (e) => { if (e.key === 'Enter') { e.preventDefault(); submit(); } });
+    wrap.appendChild(msg); wrap.appendChild(link); wrap.appendChild(hint); wrap.appendChild(key); wrap.appendChild(err); wrap.appendChild(go);
+    el.appendChild(wrap);
+    setTimeout(() => { try { key.focus(); } catch (_) {} }, 0);
+}
+
 function _editorMbOpenPopup(title, artist) {
     document.getElementById('editor-mb-popup')?.remove();
     const modal = document.createElement('div');
@@ -6719,7 +6855,9 @@ function _editorMbApply(c) {
     set('editor-create-mbid', c.recording_id);
     if (Array.isArray(c.genres) && c.genres.length) set('editor-create-genre', c.genres.join(', '));
     const note = document.getElementById('editor-create-autofill-note');
-    if (note) note.textContent = 'Filled from MusicBrainz — edit anything.';
+    if (note) note.textContent = (c.source === 'acoustid')
+        ? 'Filled from an audio fingerprint (AcoustID) — edit anything.'
+        : 'Filled from MusicBrainz — edit anything.';
     document.getElementById('editor-mb-popup')?.remove();
     _updateMbButton();
     updateCreateButton();

From e9eee1260b92a59602a17026b52ea0c1821f6120 Mon Sep 17 00:00:00 2001
From: "Claude Opus 4.8 (1M context)" <noreply@anthropic.com>
Date: Sat, 4 Jul 2026 22:15:20 +0200
Subject: [PATCH 09/11] fix(editor): couple a pasted YouTube URL into GP
 autosync at Create
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

File master audio couples into the GP autosync path on selection (via
_refreshGpAudioUI), but a pasted YouTube URL only resolves at Create time, so
gp8AudioMode stayed 'none' and the chart was attached to the downloaded audio
UNALIGNED (no autosync run). After resolving the URL, re-derive the GP audio
UI and recompute the mode so the autosync path runs — matching file-audio
behavior. Embedded-audio GPs are unaffected (that branch is guarded and still
deliberately ignores a user URL).

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>
---
 screen.js | 11 ++++++++++-
 1 file changed, 10 insertions(+), 1 deletion(-)

diff --git a/screen.js b/screen.js
index a19e3726..a54efbf0 100644
--- a/screen.js
+++ b/screen.js
@@ -7292,7 +7292,7 @@ window.editorDoCreate = async () => {
     // manual-audio path — the auto-sync uploader provides createState
     // .autoSyncAudioUrl for both. Normalise so the offset/audio_url/skip logic
     // below doesn't treat a not-yet-flipped 'upload' as a no-audio import.
-    const _gpAudioMode = (createState.gp8AudioMode === 'upload')
+    let _gpAudioMode = (createState.gp8AudioMode === 'upload')
         ? 'autosync' : (createState.gp8AudioMode || 'none');
 
     // Upload/download the Step-2 audio first — but only in modes where it's the
@@ -7306,6 +7306,15 @@ window.editorDoCreate = async () => {
         if (_createHasAudioInput() && !createState.audioUrl) {
             const ok = await uploadCreateAudio();
             if (!ok) { btn.disabled = false; return; }
+            // A pasted YouTube URL is master audio just like a staged file — but
+            // file audio couples into autosync on selection (via
+            // _refreshGpAudioUI), while a URL only resolves here at Create. Now
+            // that it's resolved, re-derive the GP audio UI so the chart
+            // auto-syncs to it, and recompute the mode so the autosync path
+            // below runs — otherwise the audio is attached UNALIGNED.
+            _refreshGpAudioUI();
+            _gpAudioMode = (createState.gp8AudioMode === 'upload')
+                ? 'autosync' : (createState.gp8AudioMode || 'none');
         }
     }
 

From 21bf3b8f357bc411a5f46c4c96b22f37ae3d8e5f Mon Sep 17 00:00:00 2001
From: "Claude Opus 4.8 (1M context)" <noreply@anthropic.com>
Date: Sat, 4 Jul 2026 22:22:41 +0200
Subject: [PATCH 10/11] fix(editor): honor legacy init_drum_tab in create
 back-compat path

The rework computed init_drums solely from whether the roster contains
'Drums', ignoring the legacy 'init_drum_tab' flag. A back-compat caller sending
{initial_arrangement: 'Lead', init_drum_tab: true} (default was True) no longer
got its drum tab. Translate the legacy flag into the roster (append 'Drums')
so the old single-arrangement + drum-tab contract is preserved; the new
roster-based path is unaffected.

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>
---
 routes.py | 9 +++++++++
 1 file changed, 9 insertions(+)

diff --git a/routes.py b/routes.py
index 77e9b66a..bee1d9d7 100644
--- a/routes.py
+++ b/routes.py
@@ -3604,8 +3604,17 @@ def _is_int(v) -> bool:
 
         roster_in = meta_in.get("arrangements")
         if roster_in is None:
+            # Legacy shape: `initial_arrangement` (single role) + `init_drum_tab`
+            # (bool, default True). Translate both into the roster so an older
+            # client still gets its requested drum tab — in the new model a
+            # "Drums" role IS the drum tab (see init_drums below).
             single = _str_field("initial_arrangement", "Lead") or "Lead"
             roster_in = [single]
+            legacy_drums = meta_in.get("init_drum_tab", True)
+            if not isinstance(legacy_drums, bool):
+                return JSONResponse({"error": "init_drum_tab must be a boolean"}, 400)
+            if legacy_drums:
+                roster_in.append("Drums")
         if not isinstance(roster_in, list) or not roster_in:
             return JSONResponse(
                 {"error": "arrangements must be a non-empty list of roles"}, 400,

From 323e68eaf64a615a3cc2c05704f9fbf9742d22b0 Mon Sep 17 00:00:00 2001
From: "Claude Opus 4.8 (1M context)" <noreply@anthropic.com>
Date: Sun, 5 Jul 2026 00:10:33 +0200
Subject: [PATCH 11/11] feat(editor): persist spec-complete metadata on GP/EOF
 imports
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

The create modal collects album_artist / track / disc / genres / language /
isrc / mbid / authors for every flow, but only blank-create wrote them —
a Guitar Pro or EOF import silently dropped them (convert-gp / import-xml-project
kept only title/artist/album/year on the session). _write_sloppak_pak already
writes all these fields from its meta dict and /build merges session.metadata,
so the only gap was routing them in.

New lenient normalizer _extended_manifest_meta() coerces the modal's raw strings
into the shapes the manifest writer expects (track/disc → int, genres/authors →
deduped lists, isrc stripped+upper, mbid lower). convert-gp reads them from its
JSON body; import-xml-project takes one extended_meta JSON form field; both
merge the result into session.metadata so /build persists it. Frontend sends the
fields via a shared _createExtendedMeta() helper.

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>
---
 routes.py                 | 67 +++++++++++++++++++++++++++++++++++++++
 screen.js                 | 22 +++++++++++++
 tests/test_arr_to_data.py | 34 +++++++++++++++++++-
 3 files changed, 122 insertions(+), 1 deletion(-)

diff --git a/routes.py b/routes.py
index bee1d9d7..ea0abe16 100644
--- a/routes.py
+++ b/routes.py
@@ -1090,6 +1090,58 @@ def _guide_tones_wire(tones):
             if isinstance(v, int) and not isinstance(v, bool) and 0 <= v <= 11]
 
 
+def _extended_manifest_meta(src) -> dict:
+    """Normalize the spec-complete optional manifest fields (album_artist, track,
+    disc, genres, isrc, mbid, language, authors) from a create/import request
+    into the shapes `_write_sloppak_pak` expects — so a Guitar Pro / EOF import
+    persists the same metadata the blank-create path does (these fields are shown
+    for every create flow but were previously written only for blank projects).
+    Lenient: a malformed field is skipped, not an error (secondary to the import).
+    """
+    if not isinstance(src, dict):
+        return {}
+    out: dict = {}
+
+    def _s(name):
+        v = src.get(name)
+        return v.strip() if isinstance(v, str) else ""
+
+    for _k in ("album_artist", "language"):
+        if _s(_k):
+            out[_k] = _s(_k)
+    if _s("mbid"):
+        out["mbid"] = _s("mbid").lower()
+    if _s("isrc"):
+        out["isrc"] = re.sub(r"[\s-]", "", _s("isrc")).upper()
+    for _k in ("track", "disc"):
+        v = src.get(_k)
+        if isinstance(v, bool):
+            continue
+        if isinstance(v, int):
+            out[_k] = v
+        elif isinstance(v, str) and v.strip().lstrip("-").isdigit():
+            out[_k] = int(v.strip())
+
+    def _list(name):
+        v = src.get(name)
+        if isinstance(v, str):
+            v = re.split(r"[,\n]", v)
+        items, seen = [], set()
+        if isinstance(v, list):
+            for it in v:
+                s = str(it).strip() if it is not None else ""
+                if s and s not in seen:
+                    seen.add(s)
+                    items.append(s)
+        return items
+
+    for _k in ("genres", "authors"):
+        vals = _list(_k)
+        if vals:
+            out[_k] = vals
+    return out
+
+
 def _safe_float(v, default=0.0):
     """Best-effort float coercion; returns `default` for bad input."""
     if v is None:
@@ -4989,6 +5041,9 @@ def _convert():
             "metadata": {
                 "title": title, "artist": artist,
                 "album": album, "year": year,
+                # Spec-complete metadata typed in the create modal is merged into
+                # the session so /build persists it too (not just blank projects).
+                **_extended_manifest_meta(data),
             },
             "last_touched": time.time(),
         }
@@ -5072,6 +5127,7 @@ async def import_xml_project(
         artist: str = Form(""),
         album: str = Form(""),
         year: str = Form(""),
+        extended_meta: str = Form(""),
     ):
         """Import EOF (Editor on Fire) arrangement XML into a create session.
 
@@ -5087,6 +5143,13 @@ async def import_xml_project(
         """
         from lib.song import load_song as _load_arrangement_dir
 
+        # Spec-complete metadata arrives as one JSON form field so we don't need
+        # eight more Form() params; a malformed blob is tolerated (just ignored).
+        try:
+            _ext_meta = json.loads(extended_meta) if extended_meta.strip() else {}
+        except (ValueError, TypeError):
+            _ext_meta = {}
+
         tmp = tempfile.mkdtemp(prefix="slopsmith_xmlproj_")
         try:
             xml_count = 0
@@ -5184,6 +5247,10 @@ def _load():
                 "metadata": {
                     "title": song.title, "artist": song.artist,
                     "album": song.album, "year": song.year,
+                    # Spec-complete metadata from the create modal (a JSON blob
+                    # form field) is merged so /build persists it, matching the
+                    # blank-create and GP-import paths.
+                    **_extended_manifest_meta(_ext_meta),
                 },
                 "last_touched": time.time(),
             }
diff --git a/screen.js b/screen.js
index a54efbf0..84d6c96c 100644
--- a/screen.js
+++ b/screen.js
@@ -6214,6 +6214,24 @@ function _createHasAudioInput() {
     return !!((document.getElementById('editor-create-yt-url')?.value) || '').trim();
 }
 
+// The spec-complete metadata typed in the create modal, so a Guitar Pro / EOF
+// import carries the same fields the blank-create path sends (the backend
+// normalizes + persists them at Build). Values are raw strings; the server
+// coerces track/disc to ints and genres/authors to lists.
+function _createExtendedMeta() {
+    const v = (id) => ((document.getElementById(id)?.value) || '').trim();
+    return {
+        album_artist: v('editor-create-album-artist'),
+        track: v('editor-create-track'),
+        disc: v('editor-create-disc'),
+        genres: v('editor-create-genre'),
+        language: v('editor-create-language'),
+        isrc: v('editor-create-isrc'),
+        mbid: v('editor-create-mbid'),
+        authors: v('editor-create-authors'),
+    };
+}
+
 function updateCreateButton() {
     const open = _createGateOpen(createState, {
         hasTitle: !!((document.getElementById('editor-create-title')?.value) || '').trim(),
@@ -7425,6 +7443,8 @@ window.editorDoCreate = async () => {
                 artist: document.getElementById('editor-create-artist').value || 'Unknown',
                 album: document.getElementById('editor-create-album').value || '',
                 year: document.getElementById('editor-create-year').value || '',
+                // Spec-complete metadata → persisted into the session for Build.
+                ..._createExtendedMeta(),
             }),
         });
         const data = await resp.json();
@@ -7557,6 +7577,8 @@ async function _editorDoEofCreate() {
         form.append('artist', document.getElementById('editor-create-artist').value || '');
         form.append('album', document.getElementById('editor-create-album').value || '');
         form.append('year', document.getElementById('editor-create-year').value || '');
+        // Spec-complete metadata as one JSON blob → persisted into the session.
+        form.append('extended_meta', JSON.stringify(_createExtendedMeta()));
 
         const resp = await fetch('/api/plugins/editor/import-xml-project',
             { method: 'POST', body: form });
diff --git a/tests/test_arr_to_data.py b/tests/test_arr_to_data.py
index d5907cf7..1a2c9148 100644
--- a/tests/test_arr_to_data.py
+++ b/tests/test_arr_to_data.py
@@ -6,7 +6,12 @@
 """
 from types import SimpleNamespace
 
-from routes import _NOTE_TECH_BOOL_FIELDS, _NOTE_TECH_FIELDS, _arr_to_data
+from routes import (
+    _NOTE_TECH_BOOL_FIELDS,
+    _NOTE_TECH_FIELDS,
+    _arr_to_data,
+    _extended_manifest_meta,
+)
 
 
 def _tech_defaults(**kw):
@@ -41,6 +46,33 @@ def _tech_defaults(**kw):
     return base
 
 
+def test_extended_manifest_meta_normalizes_import_fields():
+    """The GP/EOF import paths run the modal's spec-complete fields through this
+    into exactly the shapes `_write_sloppak_pak` writes, so a chart import keeps
+    the same metadata a blank project does."""
+    out = _extended_manifest_meta({
+        "album_artist": "  Various Artists ",
+        "track": "3", "disc": 2,
+        "genres": "Rock, Metal, Rock",       # string + dup
+        "isrc": "us-abc-24-00001",           # hyphenated / lower
+        "mbid": "ABC-DEF",                   # upper
+        "language": "en",
+        "authors": "me, you, me",            # string + dup
+    })
+    assert out == {
+        "album_artist": "Various Artists",
+        "track": 3, "disc": 2,
+        "genres": ["Rock", "Metal"],
+        "isrc": "USABC2400001",
+        "mbid": "abc-def",
+        "language": "en",
+        "authors": ["me", "you"],
+    }
+    # Lenient: malformed / empty fields are dropped, never an error.
+    assert _extended_manifest_meta({"track": "x", "genres": "", "disc": True}) == {}
+    assert _extended_manifest_meta(None) == {}
+
+
 def _note(**kw):
     base = dict(time=1.23456, string=0, fret=5, sustain=0.5)
     base.update(_tech_defaults())