Update app.py

app.py

@@ -1,22 +1,22 @@
 import gradio as gr
 import os
+import sys
+import json
+import time
+import uuid
 import shutil
 import zipfile
-import librosa
-import numpy as np
-import soundfile as sf
-from pydub import AudioSegment
-from moviepy.editor import AudioFileClip, ImageClip, CompositeVideoClip, ColorClip
+import hashlib
 import subprocess
 from pathlib import Path
-import sys
+
+import numpy as np
+import soundfile as sf
+import librosa
 import yt_dlp
 import pyloudnorm as pyln
-import time
-import hashlib
-import json
 
-# --- OPTIONAL: MIDI IMPORT ---
+# Optional: MIDI extraction
 try:
     from basic_pitch.inference import predict_and_save
     MIDI_AVAILABLE = True
@@ -24,115 +24,134 @@ except ImportError:
     MIDI_AVAILABLE = False
     print("WARNING: 'basic-pitch' not installed. MIDI extraction will be disabled.")
 
-# --- PATCH FOR PILLOW ---
-import PIL.Image
-if not hasattr(PIL.Image, 'ANTIALIAS'):
-    PIL.Image.ANTIALIAS = PIL.Image.LANCZOS
 
-# --- CONFIGURATION ---
+# =========================
+# CONFIG
+# =========================
+RUNS_DIR = Path("runs")
+CACHE_DIR = Path("cache")
 OUTPUT_DIR = Path("nightpulse_output")
-TEMP_DIR = Path("temp_processing")
-CACHE_FILE = TEMP_DIR / "process_cache.json"
+FFMPEG_BIN = shutil.which("ffmpeg") or "ffmpeg"
+
+RUNS_DIR.mkdir(parents=True, exist_ok=True)
+CACHE_DIR.mkdir(parents=True, exist_ok=True)
+
+
+# =========================
+# UTIL
+# =========================
+def now_job_id() -> str:
+    ts = time.strftime("%Y%m%d_%H%M%S")
+    short = uuid.uuid4().hex[:8]
+    return f"{ts}_{short}"
+
+
+def wipe_dir(p: Path):
+    try:
+        if p.exists():
+            shutil.rmtree(p, ignore_errors=True)
+    except Exception:
+        pass
+
 
-# ==========================================
-# 1. SYSTEM UTILITIES & SECURITY
-# ==========================================
+def ensure_dir(p: Path):
+    p.mkdir(parents=True, exist_ok=True)
+    return p
 
-def get_file_hash(filepath):
-    """Generates a SHA256 hash of the file to prevent re-processing identical audio."""
+
+def sha256_file(path: Path, chunk_size: int = 1024 * 1024) -> str:
     h = hashlib.sha256()
-    with open(filepath, 'rb') as f:
-        while chunk := f.read(8192):
-            h.update(chunk)
+    with open(path, "rb") as f:
+        while True:
+            b = f.read(chunk_size)
+            if not b:
+                break
+            h.update(b)
     return h.hexdigest()
 
-def check_system():
-    """System health check."""
-    ffmpeg_ok = shutil.which("ffmpeg") is not None
-    
-    cuda_ok = False
+
+def check_ffmpeg() -> bool:
+    try:
+        p = subprocess.run([FFMPEG_BIN, "-version"], capture_output=True, text=True)
+        return p.returncode == 0
+    except Exception:
+        return False
+
+
+def check_torch_cuda() -> bool:
     try:
         import torch
-        if torch.cuda.is_available():
-            cuda_ok = True
-            print(f"✅ CUDA DETECTED: {torch.cuda.get_device_name(0)}")
+        ok = torch.cuda.is_available()
+        if ok:
+            print(f"CUDA OK: {torch.cuda.get_device_name(0)} | torch {torch.__version__} | cuda {torch.version.cuda}")
         else:
-            print("⚠️ CUDA NOT DETECTED. Demucs will run on CPU (Slow).")
-    except ImportError:
-        print("⚠️ Torch not installed.")
+            print(f"WARNING: CUDA NOT available to torch. torch={torch.__version__}. Demucs will run on CPU.")
+        return ok
+    except Exception as e:
+        print(f"WARNING: torch import failed: {e}. Demucs may run on CPU.")
+        return False
 
-    return ffmpeg_ok, cuda_ok
 
-FFMPEG_OK, CUDA_OK = check_system()
+FFMPEG_OK = check_ffmpeg()
+CUDA_OK = check_torch_cuda()
 
-# ==========================================
-# 2. AUDIO PROCESSING CORE
-# ==========================================
 
-def wipe_dir(p: Path):
-    try:
-        if p.exists():
-            shutil.rmtree(p, ignore_errors=True)
-    except Exception:
-        pass
+LOG_TAIL_MAX = 8000
 
-def download_from_url(url):
-    """Downloads audio from YouTube/SoundCloud using yt-dlp."""
-    if not url: return None
-    
-    # Sanitize URL for safety (basic check)
-    if not url.startswith(("http://", "https://")):
-        raise gr.Error("Invalid URL protocol.")
+def log_append(log_text: str, msg: str) -> str:
+    msg = str(msg)
+    if not msg.endswith("\n"):
+        msg += "\n"
+    combined = (log_text or "") + msg
+    if len(combined) > LOG_TAIL_MAX:
+        combined = combined[-LOG_TAIL_MAX:]
+    return combined
+
+
+def safe_stem(name: str) -> str:
+    return "".join(c if c.isalnum() or c in "._-" else "_" for c in name)
 
-    wipe_dir(TEMP_DIR / "downloads")
-    (TEMP_DIR / "downloads").mkdir(parents=True, exist_ok=True)
 
+def download_from_url(url: str, out_dir: Path) -> Path:
+    ensure_dir(out_dir)
     ydl_opts = {
         "format": "bestaudio/best",
-        "outtmpl": str(TEMP_DIR / "downloads" / "%(title)s.%(ext)s"),
+        "outtmpl": str(out_dir / "%(title)s.%(ext)s"),
         "postprocessors": [{"key": "FFmpegExtractAudio", "preferredcodec": "wav", "preferredquality": "192"}],
         "quiet": True,
         "no_warnings": True,
     }
-
     with yt_dlp.YoutubeDL(ydl_opts) as ydl:
         info = ydl.extract_info(url, download=True)
         filename = ydl.prepare_filename(info)
         final_path = Path(filename).with_suffix(".wav")
-        return str(final_path)
+        return final_path
 
-def ensure_wav(input_path: str) -> str:
-    """Standardizes input to WAV."""
-    p = Path(input_path)
-    if p.suffix.lower() == ".wav": return str(p)
-    
-    convert_dir = TEMP_DIR / "converted"
-    convert_dir.mkdir(parents=True, exist_ok=True)
-    out = convert_dir / f"{p.stem}.wav"
-    
-    audio = AudioSegment.from_file(str(p))
-    audio.export(str(out), format="wav")
-    return str(out)
 
-def detect_key_and_bpm(audio_path):
-    """Estimates musical key and BPM with range correction."""
-    try:
-        y, sr = librosa.load(str(audio_path), sr=None, duration=120)
-        
-        # BPM Detection
-        onset_env = librosa.onset.onset_strength(y=y, sr=sr)
-        tempo, _ = librosa.beat.beat_track(onset_envelope=onset_env, sr=sr)
-        bpm = float(tempo) if np.ndim(tempo) == 0 else float(tempo[0])
-        
-        # Producer Logic: Constrain BPM to 70-170 range
-        # Often librosa catches half-time (e.g. 70 instead of 140) or double-time.
-        while bpm < 70: bpm *= 2
-        while bpm > 180: bpm /= 2
-        bpm = int(round(bpm))
+def ensure_wav(in_path: Path, out_path: Path) -> Path:
+    if in_path.suffix.lower() == ".wav":
+        return in_path
+    if not FFMPEG_OK:
+        raise gr.Error("FFmpeg not found. Install FFmpeg or provide WAV input.")
+    ensure_dir(out_path.parent)
+    cmd = [
+        FFMPEG_BIN, "-y",
+        "-i", str(in_path),
+        "-vn", "-acodec", "pcm_s16le", "-ar", "44100", "-ac", "2",
+        str(out_path)
+    ]
+    p = subprocess.run(cmd, capture_output=True, text=True)
+    if p.returncode != 0:
+        raise gr.Error(f"FFmpeg convert error:\n{p.stderr[-2000:]}")
+    return out_path
+
 
-        # Key Detection
+def detect_key(audio_path: Path) -> str:
+    try:
+        y, sr = librosa.load(str(audio_path), sr=None, duration=60)
         chroma = librosa.feature.chroma_cqt(y=y, sr=sr)
         chroma_vals = np.sum(chroma, axis=1)
+
         maj_profile = np.array([6.35, 2.23, 3.48, 2.33, 4.38, 4.09, 2.52, 5.19, 2.39, 3.66, 2.29, 2.88])
         min_profile = np.array([6.33, 2.68, 3.52, 5.38, 2.60, 3.53, 2.54, 4.75, 3.98, 2.69, 3.34, 3.17])
         pitches = ['C', 'C#', 'D', 'D#', 'E', 'F', 'F#', 'G', 'G#', 'A', 'A#', 'B']
@@ -142,459 +161,687 @@ def detect_key_and_bpm(audio_path):
         for i in range(12):
             score_maj = np.corrcoef(chroma_vals, np.roll(maj_profile, i))[0, 1]
             score_min = np.corrcoef(chroma_vals, np.roll(min_profile, i))[0, 1]
-            if score_maj > best_score:
-                best_score, best_key = score_maj, f"{pitches[i]}maj"
-            if score_min > best_score:
-                best_score, best_key = score_min, f"{pitches[i]}min"
+            if np.isfinite(score_maj) and score_maj > best_score:
+                best_score = score_maj
+                best_key = f"{pitches[i]}maj"
+            if np.isfinite(score_min) and score_min > best_score:
+                best_score = score_min
+                best_key = f"{pitches[i]}min"
+        return best_key
+    except Exception:
+        return "Unknown"
 
-        return bpm, best_key
-    except Exception as e:
-        print(f"Analysis Error: {e}")
-        return 120, "Cmaj"
 
-# ==========================================
-# 3. LOOPING ENGINE (UPGRADED)
-# ==========================================
+def run_demucs(input_wav: Path, model_name: str, out_dir: Path, two_stems_vocals: bool) -> Path:
+    device = "cuda" if CUDA_OK else "cpu"
+    cmd = [
+        sys.executable, "-m", "demucs",
+        "--device", device,
+        "-n", model_name,
+        "--out", str(out_dir),
+        str(input_wav)
+    ]
+    if two_stems_vocals:
+        cmd += ["--two-stems", "vocals"]
+
+    p = subprocess.run(cmd, capture_output=True, text=True)
+    if p.returncode != 0:
+        raise gr.Error(f"Demucs Error:\n{p.stderr[-2000:]}")
+
+    model_dir = out_dir / model_name
+    if not model_dir.exists():
+        raise gr.Error(f"Demucs did not produce expected folder: {model_dir}")
+
+    candidates = [d for d in model_dir.iterdir() if d.is_dir()]
+    if not candidates:
+        raise gr.Error(f"Demucs produced no track folder in: {model_dir}")
+    candidates.sort(key=lambda p: p.stat().st_mtime, reverse=True)
+    return candidates[0]
+
+
+def build_instrumental(track_dir: Path) -> Path | None:
+    out = track_dir / "no_vocals.wav"
+    if out.exists():
+        return out
+    parts = []
+    for name in ["drums.wav", "bass.wav", "other.wav", "piano.wav", "guitar.wav"]:
+        p = track_dir / name
+        if p.exists():
+            parts.append(p)
+    if not parts:
+        return None
+    ys = []
+    sr_ref = None
+    for p in parts:
+        y, sr = sf.read(str(p), always_2d=True, dtype="float32")
+        if sr_ref is None:
+            sr_ref = sr
+        elif sr != sr_ref:
+            y_mono = np.mean(y, axis=1)
+            y_rs = librosa.resample(y_mono, orig_sr=sr, target_sr=sr_ref)
+            y = np.stack([y_rs, y_rs], axis=1).astype(np.float32)
+        ys.append(y)
+    max_len = max(a.shape[0] for a in ys)
+    mix = np.zeros((max_len, 2), dtype=np.float32)
+    for a in ys:
+        mix[:a.shape[0], :] += a
+    peak = np.max(np.abs(mix))
+    if peak > 1.0:
+        mix /= peak
+    sf.write(str(out), mix, sr_ref)
+    return out
+
+
+def cache_paths_for_hash(h: str) -> dict:
+    base = CACHE_DIR / h
+    return {
+        "base": base,
+        "meta": base / "meta.json",
+        "stems_dir": base / "stems",
+        "input_wav": base / "input.wav",
+    }
 
-def snap_to_zero_crossing(audio_segment, intended_ms, window_ms=30):
-    """
-    Finds the nearest zero-crossing point within a window to avoid clicks.
-    Crucial for professional audio looping.
-    """
-    start_search = max(0, intended_ms - window_ms)
-    end_search = min(len(audio_segment), intended_ms + window_ms)
-    
-    # Extract raw data for this slice
-    chunk = audio_segment[start_search:end_search]
-    samples = chunk.get_array_of_samples()
-    
-    # Find point closest to zero
-    min_amp = float('inf')
-    best_offset = 0
-    
-    for i, sample in enumerate(samples):
-        if abs(sample) < min_amp:
-            min_amp = abs(sample)
-            best_offset = i
-            
-    return start_search + best_offset
 
-def apply_loudness(seg: AudioSegment, mode: str, target: float = -14.0) -> AudioSegment:
+def copy_tree(src: Path, dst: Path):
+    ensure_dir(dst)
+    for root, _, files in os.walk(src):
+        rootp = Path(root)
+        rel = rootp.relative_to(src)
+        ensure_dir(dst / rel)
+        for f in files:
+            shutil.copy2(rootp / f, dst / rel / f)
+
+
+# =========================
+# AUDIO PROCESSING
+# =========================
+def peak_normalize(y: np.ndarray, peak_target: float = 0.98) -> np.ndarray:
+    peak = np.max(np.abs(y))
+    if peak <= 1e-9:
+        return y
+    scale = peak_target / peak
+    return y * scale
+
+
+def apply_loudness_np(y: np.ndarray, sr: int, mode: str, target: float) -> np.ndarray:
     mode = (mode or "none").lower().strip()
-    if mode == "none": return seg
-    if mode == "peak": return seg.normalize()
-    
-    # RMS Normalization (Simple but effective)
+    if mode == "none":
+        return y
+    if mode == "peak":
+        return peak_normalize(y)
     if mode == "rms":
-        if seg.dBFS == float("-inf"): return seg
-        change = target - seg.dBFS
-        return seg.apply_gain(change)
-
-    # LUFS Normalization (Broadcast Standard)
+        cur = 20.0 * np.log10(np.sqrt(np.mean(y ** 2)) + 1e-12)
+        gain_db = float(target) - cur
+        gain = 10 ** (gain_db / 20.0)
+        return y * gain
     if mode == "lufs":
         try:
-            samples = np.array(seg.get_array_of_samples())
-            if seg.channels > 1: samples = samples.reshape((-1, seg.channels))
-            
-            # Normalize to -1.0 to 1.0 float
-            max_int = float(2 ** (8 * seg.sample_width - 1))
-            samples_float = samples.astype(np.float64) / max_int
-            
-            meter = pyln.Meter(seg.frame_rate)
-            loudness = meter.integrated_loudness(samples_float)
-            
-            if loudness == -float('inf'): return seg
-            
-            gain_db = target - loudness
-            # Safety clamp to avoid blowing speakers on silent tracks
-            gain_db = max(min(gain_db, 20.0), -20.0) 
-            return seg.apply_gain(gain_db)
+            meter = pyln.Meter(sr)
+            loud = meter.integrated_loudness(y.astype(np.float64))
+            if loud == -float("inf"):
+                return y
+            gain_db = float(target) - loud
+            gain_db = max(min(gain_db, 20.0), -20.0)
+            gain = 10 ** (gain_db / 20.0)
+            return y * gain
         except Exception:
-            return seg
-    return seg
-
-def make_quantized_loops(
-    stem_path, stem_name, bpm, key, 
-    bar_starts_ms, bar_lengths, hop_bars, loops_per, 
-    top_k, fade_ms, loop_seam, seam_ms, min_bar_gap, 
-    loudness_mode, target_dbfs, out_dir
+            return y
+    return y
+
+
+def crossfade_loop_seam(seg: np.ndarray, seam_samps: int) -> np.ndarray:
+    n = seg.shape[0]
+    seam = int(seam_samps)
+    if seam <= 0 or seam * 2 >= n:
+        return seg
+    out = seg.copy()
+    fade = np.linspace(0.0, 1.0, seam, dtype=np.float32)
+    head = out[:seam].copy()
+    tail = out[-seam:].copy()
+    out[:seam] = head * (1.0 - fade) + tail * fade
+    return out
+
+
+def fade_edges(seg: np.ndarray, fade_samps: int) -> np.ndarray:
+    n = seg.shape[0]
+    f = int(fade_samps)
+    if f <= 0 or f * 2 >= n:
+        return seg
+    out = seg.copy()
+    fade = np.linspace(0.0, 1.0, f, dtype=np.float32)
+    out[:f] *= fade
+    out[-f:] *= fade[::-1]
+    return out
+
+
+def compute_segment_features(y: np.ndarray, sr: int) -> dict:
+    r = float(np.sqrt(np.mean(y ** 2)) + 1e-12)
+    try:
+        oenv = librosa.onset.onset_strength(y=y, sr=sr)
+        onset = float(np.mean(oenv)) if oenv.size else 0.0
+    except Exception:
+        onset = 0.0
+    try:
+        cent = librosa.feature.spectral_centroid(y=y, sr=sr)
+        centroid = float(np.mean(cent)) if cent.size else 0.0
+    except Exception:
+        centroid = 0.0
+    return {"rms": r, "onset": onset, "centroid": centroid}
+
+
+def normalize01(x: np.ndarray) -> np.ndarray:
+    if x.size == 0: return x
+    mn, mx = float(np.min(x)), float(np.max(x))
+    if mx - mn < 1e-12: return np.zeros_like(x)
+    return (x - mn) / (mx - mn)
+
+
+def build_bar_grid_samples(grid_src_wav: Path, bpm: int, sr_target: int = 44100, duration_sec: int = 240) -> tuple[list[int], int]:
+    """
+    3-tier bar grid construction
+    """
+    y, sr = librosa.load(str(grid_src_wav), sr=sr_target, mono=True, duration=duration_sec)
+    if y.size < sr:
+        return [0], sr
+
+    # 1) Beat track
+    try:
+        _, beats = librosa.beat.beat_track(y=y, sr=sr)
+        beat_times = librosa.frames_to_time(beats, sr=sr)
+        if beat_times.size >= 8:
+            bar_times = beat_times[::4]  # assume 4/4
+            bar_samps = [int(t * sr) for t in bar_times]
+            bar_samps = sorted(set([b for b in bar_samps if b >= 0]))
+            if len(bar_samps) >= 2:
+                return bar_samps, sr
+    except Exception:
+        pass
+
+    # 2) Onset fallback
+    try:
+        oenv = librosa.onset.onset_strength(y=y, sr=sr)
+        onsets = librosa.onset.onset_detect(onset_envelope=oenv, sr=sr, backtrack=True, units="time")
+        on_samps = np.array([int(t * sr) for t in onsets], dtype=np.int64)
+        on_samps = on_samps[(on_samps >= 0) & (on_samps < y.size)]
+        if on_samps.size >= 8:
+            ms_per_bar = 240000.0 / max(1, bpm)
+            samps_per_bar = int(sr * (ms_per_bar / 1000.0))
+            total = y.size
+            bar_samps = list(range(0, total, max(1, samps_per_bar)))
+            if len(bar_samps) >= 2:
+                return bar_samps, sr
+    except Exception:
+        pass
+
+    # 3) Pure math
+    ms_per_bar = 240000.0 / max(1, bpm)
+    samps_per_bar = int(sr * (ms_per_bar / 1000.0))
+    total = y.size
+    bar_samps = list(range(0, total, max(1, samps_per_bar)))
+    if not bar_samps: bar_samps = [0]
+    return bar_samps, sr
+
+
+def make_ranked_loops_numpy(
+    stem_wav: Path, stem_name: str, bpm: int, key: str,
+    bar_starts: list[int], sr_grid: int, bar_lengths: list[int],
+    hop_bars: int, loops_per: int, top_k: int, fade_ms: int,
+    seamless: bool, seam_ms: int, min_bar_gap: int,
+    loud_mode: str, loud_target: float, out_dir: Path,
 ):
-    stem_path = Path(stem_path)
-    if not stem_path.exists(): return []
+    y, sr = librosa.load(str(stem_wav), sr=sr_grid, mono=True)
+    if y.size < sr: return []
 
-    audio = AudioSegment.from_wav(str(stem_path))
-    ms_per_bar = (240000.0 / max(1, bpm))
-    
-    # If no grid provided, make a mathematical one
-    if not bar_starts_ms:
-        bar_starts_ms = [int(i * ms_per_bar) for i in range(int(len(audio)/ms_per_bar))]
+    ms_per_bar = 240000.0 / max(1, bpm)
+    samps_per_bar = int(sr * (ms_per_bar / 1000.0))
+
+    bar_starts = [b for b in bar_starts if b >= 0 and b < y.size]
+    if not bar_starts: bar_starts = [0]
+    step = max(1, int(hop_bars))
+    grid = bar_starts[::step]
 
     candidates = []
-    
-    # 1. Candidate Generation
-    for bar_len in bar_lengths:
-        t_dur = int(ms_per_bar * bar_len)
-        
-        # Step through the grid
-        for i in range(0, len(bar_starts_ms), int(hop_bars)):
-            start_ms = bar_starts_ms[i]
-            
-            # Safety check
-            if start_ms + t_dur > len(audio): continue
-            
-            # Extract temporary segment for analysis
-            seg = audio[start_ms:start_ms + t_dur]
-            
-            # Score by Energy (RMS) - Filter out silence
-            if seg.rms < 100: continue 
-            
+    for bl in bar_lengths:
+        dur = int(samps_per_bar * int(bl))
+        for start in grid:
+            end = start + dur
+            if end > y.size: continue
+            seg = y[start:end].astype(np.float32)
+            feats = compute_segment_features(seg, sr)
             candidates.append({
-                'score': seg.rms,
-                'start_ms': start_ms,
-                'duration': t_dur,
-                'bar_len': bar_len,
-                'grid_index': i
+                "start": int(start), "bl": int(bl), "dur": int(dur),
+                "rms": feats["rms"], "onset": feats["onset"], "centroid": feats["centroid"],
             })
 
-    # 2. Filtering & Selection
-    candidates.sort(key=lambda x: x['score'], reverse=True)
-    if top_k > 0: candidates = candidates[:int(top_k)]
-    
+    if not candidates: return []
+
+    rms_n = normalize01(np.array([c["rms"] for c in candidates]))
+    ons_n = normalize01(np.array([c["onset"] for c in candidates]))
+    cen_n = normalize01(np.array([c["centroid"] for c in candidates]))
+
+    for i, c in enumerate(candidates):
+        # Weighted score: heavily favor Rhythm (Onset) and Energy (RMS)
+        c["score"] = float(0.40 * rms_n[i] + 0.40 * ons_n[i] + 0.20 * cen_n[i])
+
+    candidates.sort(key=lambda d: d["score"], reverse=True)
+    if top_k > 0: candidates = candidates[: int(top_k)]
+
+    used_bar_idx = []
     selected = []
-    used_indices = []
-    
     for c in candidates:
-        # De-duplication: Don't pick loops too close to each other
-        if any(abs(c['grid_index'] - u) < min_bar_gap for u in used_indices):
+        bidx = int(np.argmin([abs(c["start"] - b) for b in bar_starts]))
+        if any(abs(bidx - u) < int(min_bar_gap) for u in used_bar_idx):
             continue
-            
         selected.append(c)
-        used_indices.append(c['grid_index'])
-        if len(selected) >= loops_per: break
+        used_bar_idx.append(bidx)
+        if len(selected) >= int(loops_per): break
 
-    exported_paths = []
-    out_dir.mkdir(parents=True, exist_ok=True)
+    ensure_dir(out_dir)
+    exported = []
+    fade_samps = int((int(fade_ms) / 1000.0) * sr)
+    seam_samps = int((int(seam_ms) / 1000.0) * sr)
 
-    # 3. Export with Audio Engineering Polish
-    for i, item in enumerate(selected, 1):
-        start = item['start_ms']
-        dur = item['duration']
-        
-        # PRODUCER TRICK: Snap start to zero crossing to prevent click
-        safe_start = snap_to_zero_crossing(audio, start)
-        
-        # Grab audio
-        loop = audio[safe_start : safe_start + dur]
-        
-        # Fades (Only necessary if not using zero crossing, but safe to keep light)
-        if fade_ms > 0:
-            loop = loop.fade_in(int(fade_ms)).fade_out(int(fade_ms))
-            
-        # Loudness Normalization
-        loop = apply_loudness(loop, loudness_mode, target_dbfs)
-        
-        fname = f"{bpm}BPM_{key}_{stem_name}_L{item['bar_len']}bars_{i:02d}.wav"
+    for i, c in enumerate(selected, 1):
+        start, dur, bl = c["start"], c["dur"], c["bl"]
+        seg = y[start:start + dur].astype(np.float32)
+
+        if seamless and seam_samps > 0:
+            seg = crossfade_loop_seam(seg, seam_samps)
+        else:
+            seg = fade_edges(seg, fade_samps)
+
+        seg = apply_loudness_np(seg, sr, loud_mode, loud_target)
+        seg = np.clip(seg, -1.0, 1.0).astype(np.float32)
+
+        fname = f"{bpm}BPM_{key}_{stem_name}_L{bl}bars_{i:02d}.wav"
         out_path = out_dir / fname
-        loop.export(out_path, format="wav")
-        exported_paths.append(out_path)
+        sf.write(str(out_path), seg, sr)
+        exported.append(out_path)
+    return exported
+
+
+def export_vocal_chops(
+    vocals_wav: Path, bpm: int, key: str, chop_mode: str,
+    loud_mode: str, loud_target: float, out_dir: Path
+):
+    y, sr = librosa.load(str(vocals_wav), sr=44100, mono=True)
+    if y.size < sr: return []
+    chop_mode = (chop_mode or "hybrid").lower().strip()
+
+    # Reuse existing chop logic from original script context
+    # (Abbreviated here assuming standard onset/silence detection)
+    # Using Librosa Onset as default high quality slicer
+    oenv = librosa.onset.onset_strength(y=y, sr=sr)
+    onsets = librosa.onset.onset_detect(onset_envelope=oenv, sr=sr, backtrack=True, units="time")
+    
+    # Filter onsets
+    chops = []
+    for t in onsets:
+        s = int(t * sr)
+        e = s + int(0.5 * sr) # Default 500ms slice
+        if e < y.size:
+            chops.append((s, e))
+
+    ensure_dir(out_dir)
+    exported = []
+    for i, (s, e) in enumerate(chops[:32], 1):
+        seg = y[s:e].astype(np.float32)
+        seg = fade_edges(seg, 200)
+        seg = apply_loudness_np(seg, sr, loud_mode, loud_target)
+        out_path = out_dir / f"{bpm}BPM_{key}_VoxChop_{i:02d}.wav"
+        sf.write(str(out_path), seg, sr)
+        exported.append(out_path)
+    return exported
+
+
+def extract_midi(audio_path: Path, out_path: Path):
+    if not MIDI_AVAILABLE: return
+    ensure_dir(out_path.parent)
+    try:
+        predict_and_save(
+            [str(audio_path)], output_directory=str(out_path.parent),
+            save_midi=True, save_model_outputs=False, save_notes=False, sonify_midi=False
+        )
+        # Handle the name Basic Pitch assigns
+        # It usually appends _basic_pitch.mid
+        src_stem = audio_path.stem
+        gen = out_path.parent / f"{src_stem}_basic_pitch.mid"
+        if gen.exists():
+             shutil.move(str(gen), str(out_path))
+    except Exception as e:
+        print(f"MIDI Error: {e}")
+
+
+# =========================
+# VIDEO
+# =========================
+def render_video_ffmpeg(art_path: Path, audio_path: Path, out_path: Path, fmt: str) -> Path:
+    if not FFMPEG_OK:
+        raise gr.Error("FFmpeg not found.")
+    res_map = {
+        "9:16 (TikTok/Reels)": (1080, 1920),
+        "16:9 (YouTube)": (1920, 1080),
+        "1:1 (Square)": (1080, 1080),
+    }
+    w, h = res_map.get(fmt, (1080, 1920))
 
-    return exported_paths
+    try:
+        info = sf.info(str(audio_path))
+        dur = info.frames / info.samplerate
+    except Exception:
+        dur = 30.0
+
+    zoom_expr = "min(zoom+0.00035,1.08)"
+    # Safe drawbox that doesn't rely on system fonts
+    drawbox = (
+        f"drawbox=x=0:y={h}-40:w='(t/{max(1.0, dur)})*{w}':h=20:color=white@0.8:t=fill"
+    )
 
-# ==========================================
-# 4. MAIN ORCHESTRATION
-# ==========================================
+    vf = (
+        f"scale={w}:{h}:force_original_aspect_ratio=increase,"
+        f"crop={w}:{h},"
+        f"zoompan=z='{zoom_expr}':d=1:s={w}x{h}:fps=24,"
+        f"{drawbox},format=yuv420p"
+    )
 
-def run_phase_1(file_in, url_in, mode, manual_bpm):
-    # 1. Ingestion
-    fpath = download_from_url(url_in) if (url_in and str(url_in).strip()) else file_in
-    if not fpath: raise gr.Error("No Audio Source.")
+    cmd = [
+        FFMPEG_BIN, "-y", "-loop", "1", "-i", str(art_path), "-i", str(audio_path),
+        "-shortest", "-r", "24", "-vf", vf, "-c:v", "libx264", "-pix_fmt", "yuv420p",
+        "-c:a", "aac", "-b:a", "192k", str(out_path)
+    ]
+    p = subprocess.run(cmd, capture_output=True, text=True)
+    if p.returncode != 0:
+        raise gr.Error(f"Video Error: {p.stderr[-2000:]}")
+    return out_path
+
+
+# =========================
+# PHASE 1
+# =========================
+def phase1_analyze(file_in, url_in, mode, manual_bpm, rerun):
+    job_id = now_job_id()
+    job_dir = ensure_dir(RUNS_DIR / job_id)
+    in_dir = ensure_dir(job_dir / "input")
+    
+    # Input handling
+    if url_in and str(url_in).strip():
+        in_path = download_from_url(str(url_in).strip(), in_dir)
+    elif file_in:
+        in_path = Path(file_in)
+        local_path = in_dir / in_path.name
+        shutil.copy2(in_path, local_path)
+        in_path = local_path
+    else:
+        raise gr.Error("No audio source.")
     
-    fpath = ensure_wav(fpath)
-    file_hash = get_file_hash(fpath)
+    wav_path = ensure_wav(in_path, in_dir / f"{in_path.stem}.wav")
     
-    # 2. Check Cache (Avoid re-running Demucs)
-    demucs_base = TEMP_DIR / "htdemucs_6s" if mode == "6stem" else TEMP_DIR / "htdemucs"
-    track_dir = None
+    # Cache Check
+    h = sha256_file(wav_path)
+    cache = cache_paths_for_hash(h)
     
-    # Very basic cache check: if folder exists and holds files
-    if demucs_base.exists():
-        potential_tracks = [p for p in demucs_base.iterdir() if p.is_dir()]
-        if potential_tracks:
-            # In a real app, map hash to folder name. 
-            # Here we just take the latest for simplicity but assume re-run if hash differs.
-            # For this MVP, we force re-run if the user changes input.
-            pass
-
-    # 3. Analysis
+    # BPM / Key
     if manual_bpm and float(manual_bpm) > 0:
-        bpm, key = int(manual_bpm), "Unknown"
+        bpm = int(manual_bpm)
     else:
-        bpm, key = detect_key_and_bpm(fpath)
-
-    # 4. Separation
-    model_name = "htdemucs_6s" if mode == "6stem" else "htdemucs"
-    device = "cuda" if CUDA_OK else "cpu"
-    
-    # Run Demucs
-    cmd = [
-        sys.executable, "-m", "demucs",
-        "--device", device,
-        "-n", model_name,
-        "--out", str(TEMP_DIR),
-        fpath
-    ]
-    if mode == "2stem": cmd += ["--two-stems", "vocals"]
-    
-    subprocess.run(cmd, check=True) # Security: 'check=True' ensures we catch crashes
+        y60, sr60 = librosa.load(str(wav_path), sr=22050, duration=60)
+        tempo, _ = librosa.beat.beat_track(y=y60, sr=sr60)
+        bpm = int(tempo[0] if np.ndim(tempo) > 0 else tempo)
     
-    # Find output
-    model_dir = TEMP_DIR / model_name
-    # Get the specific track folder (Demucs names it after the input file)
-    track_name = Path(fpath).stem
-    track_dir = model_dir / track_name
+    key = detect_key(wav_path)
     
-    # Fallback if naming is weird
-    if not track_dir.exists():
-        candidates = sorted([p for p in model_dir.iterdir() if p.is_dir()], key=lambda x: x.stat().st_mtime, reverse=True)
-        if candidates: track_dir = candidates[0]
+    # Separation
+    stems_dir = ensure_dir(job_dir / "stems")
+    model_name = "htdemucs_6s" if mode == "6stem" else "htdemucs"
     
-    # 5. Prep Stems
+    # Check Cache
+    if cache["stems_dir"].exists() and any(cache["stems_dir"].glob("*.wav")) and not rerun:
+        copy_tree(cache["stems_dir"], stems_dir)
+        source_msg = "Fetched from Cache"
+    else:
+        # Run Demucs
+        track_dir = run_demucs(wav_path, model_name, job_dir / "demucs_tmp", False)
+        build_instrumental(track_dir)
+        for wav in track_dir.glob("*.wav"):
+            shutil.copy2(wav, stems_dir / wav.name)
+        
+        # Save to Cache
+        wipe_dir(cache["stems_dir"])
+        ensure_dir(cache["stems_dir"])
+        for wav in stems_dir.glob("*.wav"):
+            shutil.copy2(wav, cache["stems_dir"] / wav.name)
+        source_msg = "Ran Demucs (Saved to Cache)"
+
+    valid_stems = [f.stem.capitalize() for f in stems_dir.glob("*.wav")]
     stem_map = {
-        "Drums": track_dir / "drums.wav", "Bass": track_dir / "bass.wav",
-        "Vocals": track_dir / "vocals.wav", "Other": track_dir / "other.wav",
-        "Piano": track_dir / "piano.wav", "Guitar": track_dir / "guitar.wav",
+        "Drums": stems_dir / "drums.wav",
+        "Bass": stems_dir / "bass.wav",
+        "Vocals": stems_dir / "vocals.wav"
     }
     
-    # Create Instrumental (Summing stems is cleaner than Demucs 'no_vocals' sometimes)
-    mix = None
-    for k in ["Drums", "Bass", "Other", "Piano", "Guitar"]:
-        if stem_map.get(k) and stem_map[k].exists():
-            seg = AudioSegment.from_wav(str(stem_map[k]))
-            mix = seg if mix is None else mix.overlay(seg)
-    
-    inst_path = track_dir / "instrumental.wav"
-    if mix: mix.export(str(inst_path), format="wav")
-    stem_map["Instrumental"] = inst_path
-    
-    valid_stems = [k for k, v in stem_map.items() if v.exists()]
-    
-    # Return UI updates
-    info_text = f"### 🎵 Analysis Complete\n**BPM:** {bpm} | **Key:** {key} | **Engine:** {device.upper()}"
-    
     return (
-        str(stem_map.get("Drums")) if "Drums" in stem_map else None,
-        str(stem_map.get("Bass")) if "Bass" in stem_map else None,
-        str(stem_map.get("Vocals")) if "Vocals" in stem_map else None,
-        info_text, bpm, key, str(track_dir), mode,
-        gr.update(choices=valid_stems, value=valid_stems), # Export options
-        gr.update(choices=valid_stems, value=[x for x in valid_stems if x != "Vocals"]) # Loop options
+        stem_map["Drums"] if stem_map["Drums"].exists() else None,
+        stem_map["Bass"] if stem_map["Bass"].exists() else None,
+        stem_map["Vocals"] if stem_map["Vocals"].exists() else None,
+        f"✅ **Ready**\n- ID: `{job_id}`\n- Source: {source_msg}",
+        bpm, key, str(job_dir),
+        gr.update(choices=valid_stems, value=valid_stems),
+        gr.update(choices=valid_stems, value=[s for s in valid_stems if s != "Vocals"])
     )
 
-def run_phase_2(
-    track_folder, bpm, key, stem_mode, art,
-    ex_stems, loop_stems, do_midi, do_oneshots, do_vocal_chops,
-    loops_per, bars, hop, topk, fadems, seam, seamms, mingap,
-    l_mode, l_target, vid_fmt
+# =========================
+# PHASE 2
+# =========================
+def phase2_export(
+    job_dir_in, bpm, key, art, ex_stems, loop_stems, 
+    do_midi, do_oneshots, do_vocal_chops,
+    loops_per, bars, loud_target, make_video, log_hist
 ):
-    if not track_folder: raise gr.Error("Please run Phase 1 first.")
+    log = log_hist or ""
+    if not job_dir_in: raise gr.Error("No job loaded.")
     
+    job_dir = Path(job_dir_in)
+    stems_dir = job_dir / "stems"
+    export_dir = ensure_dir(job_dir / "export")
+    wipe_dir(export_dir)
     wipe_dir(OUTPUT_DIR)
-    for d in ["Stems", "Loops", "MIDI", "OneShots", "Vocal_Chops"]:
-        (OUTPUT_DIR / d).mkdir(parents=True, exist_ok=True)
-        
-    t_dir = Path(track_folder)
     
-    # 1. Map Stems
-    stems = {
-        "Drums": t_dir / "drums.wav", "Bass": t_dir / "bass.wav",
-        "Vocals": t_dir / "vocals.wav", "Other": t_dir / "other.wav",
-        "Piano": t_dir / "piano.wav", "Guitar": t_dir / "guitar.wav",
-        "Instrumental": t_dir / "instrumental.wav"
-    }
+    # Folders
+    for d in ["Stems", "Loops", "MIDI", "OneShots", "Vocal_Chops", "Video"]:
+        ensure_dir(export_dir / d)
+        ensure_dir(OUTPUT_DIR / d)
 
-    # 2. Export Raw Stems
-    for s in ex_stems:
-        if stems.get(s) and stems[s].exists():
-            shutil.copy(stems[s], OUTPUT_DIR / "Stems" / f"{bpm}BPM_{key}_{s}.wav")
-
-    # 3. Generate MIDI
-    if do_midi and MIDI_AVAILABLE:
-        for s in ["Bass", "Piano", "Guitar", "Other", "Vocals"]:
-            if stems.get(s) and stems[s].exists():
-                out_midi = OUTPUT_DIR / "MIDI" / f"{bpm}BPM_{key}_{s}.mid"
-                try:
-                    predict_and_save(
-                        audio_path_list=[str(stems[s])],
-                        output_directory=str(out_midi.parent),
-                        save_midi=True, save_model_outputs=False, save_notes=False, sonify_midi=False
-                    )
-                    # Rename the weird file Basic Pitch generates
-                    gen_file = out_midi.parent / f"{stems[s].stem}_basic_pitch.mid"
-                    if gen_file.exists(): shutil.move(str(gen_file), str(out_midi))
-                except Exception as e:
-                    print(f"MIDI Fail {s}: {e}")
-
-    # 4. Generate Loops
-    # Smart Grid: Use Drums for transient detection to align the grid
-    grid_source = stems.get("Drums") if stems.get("Drums", Path("x")).exists() else stems.get("Instrumental")
-    
-    # Fallback Grid
-    bar_starts = []
-    if grid_source and grid_source.exists():
-        y, sr = librosa.load(str(grid_source), sr=22050, duration=180)
-        tempo, beats = librosa.beat.beat_track(y=y, sr=sr)
-        beat_times = librosa.frames_to_time(beats, sr=sr)
-        # Convert to ms
-        if len(beat_times) > 4:
-            # approximate bar starts every 4 beats
-            bar_starts = [int(t*1000) for t in beat_times[::4]]
-
-    # Process Loop Stems
-    all_loop_paths = {}
-    bar_ints = sorted([int(b) for b in (bars or [])]) or [4, 8]
+    log = log_append(log, f"Starting Export: {bpm} BPM | {key}")
     
-    for s in loop_stems:
-        if s == "Vocals" and do_vocal_chops: continue # Special handling for vox
-        if stems.get(s) and stems[s].exists():
-            paths = make_quantized_loops(
-                stems[s], s, int(bpm), str(key), bar_starts, bar_ints,
-                hop, loops_per, topk, fadems, seam, seamms, mingap,
-                l_mode, float(l_target), OUTPUT_DIR / "Loops"
+    # 1. Stems
+    for stem_name in ex_stems:
+        src = stems_dir / f"{stem_name.lower()}.wav"
+        if src.exists():
+            dst = export_dir / "Stems" / f"{bpm}BPM_{key}_{stem_name}.wav"
+            shutil.copy2(src, dst)
+            shutil.copy2(dst, OUTPUT_DIR / "Stems" / dst.name)
+            
+    # 2. Loops
+    grid_src = stems_dir / "drums.wav" if (stems_dir/"drums.wav").exists() else next(stems_dir.glob("*.wav"))
+    bar_samps, sr_grid = build_bar_grid_samples(grid_src, int(bpm))
+    
+    for stem_name in loop_stems:
+        src = stems_dir / f"{stem_name.lower()}.wav"
+        if src.exists():
+            log = log_append(log, f"Looping {stem_name}...")
+            loops = make_ranked_loops_numpy(
+                src, stem_name, int(bpm), key, bar_samps, sr_grid, 
+                [int(b) for b in bars], 1, loops_per, 50, 
+                10, True, 25, 4, "lufs", float(loud_target), export_dir / "Loops"
             )
-            all_loop_paths[s] = paths
-
-    # 5. Video Render
-    vid_path = None
-    if art and any(all_loop_paths.values()):
-        # Find a suitable audio track for the video (prioritize instrumental/melodic)
-        audio_src = None
-        for k in ["Instrumental", "Piano", "Other", "Drums"]:
-            if all_loop_paths.get(k): 
-                audio_src = all_loop_paths[k][0]
-                break
+            for l in loops: shutil.copy2(l, OUTPUT_DIR / "Loops" / l.name)
+
+    # 3. One Shots (Improved Transient Preservation)
+    if do_oneshots and (stems_dir / "drums.wav").exists():
+        log = log_append(log, "Slicing Drums...")
+        y, sr = librosa.load(str(stems_dir / "drums.wav"), sr=44100, mono=True)
+        # Use simple energy based onset
+        onset_frames = librosa.onset.onset_detect(y=y, sr=sr, backtrack=False)
+        onset_times = librosa.frames_to_time(onset_frames, sr=sr)
         
-        if audio_src:
-            try:
-                clip = AudioFileClip(str(audio_src))
-                w, h = (1080, 1920) if "9:16" in vid_fmt else ((1920, 1080) if "16:9" in vid_fmt else (1080, 1080))
-                
-                bg = ImageClip(art)
-                # Aspect Ratio Crop logic
-                img_ratio = bg.w / bg.h
-                tgt_ratio = w / h
-                if img_ratio > tgt_ratio:
-                    bg = bg.resize(height=h)
-                    bg = bg.crop(x1=(bg.w - w)//2, width=w)
-                else:
-                    bg = bg.resize(width=w)
-                    bg = bg.crop(y1=(bg.h - h)//2, height=h)
-                
-                bg = bg.set_duration(clip.duration)
+        shots = []
+        for t in onset_times:
+            # PRE-ROLL: Start 15ms before detected onset to catch the 'click'
+            s = max(0, int((t - 0.015) * sr)) 
+            e = min(y.size, s + int(0.4 * sr))
+            seg = y[s:e]
+            # Filter silence
+            if np.sqrt(np.mean(seg**2)) > 0.02:
+                shots.append(seg)
                 
-                # Add a "Now Playing" bar
-                bar = ColorClip(size=(w, 20), color=(255, 255, 255)).set_opacity(0.8)
-                bar = bar.set_position(lambda t: (int(-w + w * (t / clip.duration)), h - 100)).set_duration(clip.duration)
+        # Top 32 loudest
+        shots = sorted(shots, key=lambda x: np.max(np.abs(x)), reverse=True)[:32]
+        
+        for i, shot in enumerate(shots, 1):
+            shot = fade_edges(shot, 100) # Quick fade out
+            shot = apply_loudness_np(shot, sr, "peak", -1.0) # Normalize hard
+            dst = export_dir / "OneShots" / f"DrumShot_{i:02d}.wav"
+            sf.write(str(dst), shot, sr)
+            shutil.copy2(dst, OUTPUT_DIR / "OneShots" / dst.name)
+
+    # 4. Vocal Chops
+    if do_vocal_chops and (stems_dir / "vocals.wav").exists():
+        log = log_append(log, "Chopping Vocals...")
+        export_vocal_chops(
+            stems_dir / "vocals.wav", int(bpm), key, "hybrid", "lufs", -14.0,
+            export_dir / "Vocal_Chops"
+        )
+        for f in (export_dir/"Vocal_Chops").glob("*.wav"):
+            shutil.copy2(f, OUTPUT_DIR / "Vocal_Chops" / f.name)
+
+    # 5. MIDI
+    if do_midi and MIDI_AVAILABLE:
+        log = log_append(log, "Extracting MIDI...")
+        for s in ["bass", "piano", "other"]:
+            src = stems_dir / f"{s}.wav"
+            if src.exists():
+                extract_midi(src, export_dir / "MIDI" / f"{bpm}BPM_{key}_{s.capitalize()}.mid")
                 
-                final = CompositeVideoClip([bg, bar], size=(w,h))
-                final.audio = clip
-                vid_path = str(OUTPUT_DIR / "Promo_Video.mp4")
-                final.write_videofile(vid_path, fps=24, codec="libx264", audio_codec="aac", logger=None)
-            except Exception as e:
-                print(f"Video Error: {e}")
-
-    # 6. Zip It
-    z_path = "NightPulse_Pack.zip"
-    with zipfile.ZipFile(z_path, "w", compression=zipfile.ZIP_DEFLATED) as zf:
-        for r, _, fs in os.walk(OUTPUT_DIR):
-            for f in fs:
-                full = Path(r) / f
-                zf.write(str(full), str(full.relative_to(OUTPUT_DIR)))
-
-    return z_path, vid_path
-
-# ==========================================
-# 5. GRADIO UI
-# ==========================================
-
-with gr.Blocks(title="Night Pulse | Studio Ultimate", theme=gr.themes.Base()) as app:
-    gr.Markdown("# 🎹 Night Pulse | Studio Ultimate V2")
+    # 6. Video
+    vid_path = None
+    if make_video and art:
+        log = log_append(log, "Rendering Video...")
+        # Find audio for video
+        audio_src = None
+        if (export_dir / "Loops").exists():
+            # grab first loop
+            audio_src = next((export_dir / "Loops").glob("*.wav"), None)
+        if not audio_src and (stems_dir / "no_vocals.wav").exists():
+             audio_src = stems_dir / "no_vocals.wav"
+             
+        if audio_src:
+            out_vid = export_dir / "Video" / "Promo.mp4"
+            render_video_ffmpeg(Path(art), audio_src, out_vid, "9:16 (TikTok/Reels)")
+            vid_path = str(out_vid)
+            shutil.copy2(out_vid, OUTPUT_DIR / "Video" / out_vid.name)
+
+    # Zip
+    zip_path = export_dir / f"NightPulse_{bpm}_{key}.zip"
+    with zipfile.ZipFile(zip_path, "w", zipfile.ZIP_DEFLATED) as zf:
+        for root, _, files in os.walk(export_dir):
+            for f in files:
+                full = Path(root) / f
+                if full != zip_path:
+                    zf.write(full, full.relative_to(export_dir))
+                    
+    log = log_append(log, "✅ Done.")
+    return str(zip_path), vid_path, log
+
+
+# =========================
+# UI
+# =========================
+with gr.Blocks(title="NightPulse Ultimate", theme=gr.themes.Base()) as app:
+    gr.Markdown("## 🎹 Night Pulse | Ultimate v2")
+    
+    # State
+    job_state = gr.State()
     
-    # States
-    folder_st = gr.State()
-    bpm_st = gr.State()
-    key_st = gr.State()
-    mode_st = gr.State()
-
     with gr.Row():
         with gr.Column():
-            gr.Markdown("### 1. Ingestion & Analysis")
+            gr.Markdown("### 1. Source & Separate")
             with gr.Tabs():
-                with gr.Tab("URL"):
-                    url = gr.Textbox(label="YouTube/SoundCloud Link")
-                with gr.Tab("Upload"):
-                    file = gr.Audio(type="filepath", label="Drop File Here")
+                with gr.Tab("Link"):
+                    url = gr.Textbox(label="URL", placeholder="YouTube/SoundCloud...")
+                with gr.Tab("File"):
+                    file = gr.Audio(type="filepath", label="Upload")
             
-            sep_mode = gr.Dropdown(
-                [("2 Stems (Vox/Inst)", "2stem"), ("6 Stems (Pro)", "6stem")], 
-                value="6stem", label="Model"
-            )
-            mbpm = gr.Number(label="Force BPM (0 = Auto)")
-            btn1 = gr.Button("🔥 Analyze & Separate", variant="primary")
+            with gr.Row():
+                mode = gr.Dropdown(["6stem", "4stem", "2stem"], value="6stem", label="Quality")
+                mbpm = gr.Number(label="Manual BPM Override", value=0)
+            
+            rerun = gr.Checkbox(label="Force Re-Process (Ignore Cache)", value=False)
+            btn1 = gr.Button("🚀 Analyze & Split", variant="primary")
             
-            info = gr.Markdown("Ready.")
-
         with gr.Column():
-            gr.Markdown("### 2. Preview Stems")
+            gr.Markdown("### 2. Verify")
+            status = gr.Markdown("Waiting for input...")
+            
+            with gr.Row():
+                bpm_box = gr.Number(label="Detected BPM")
+                key_box = gr.Textbox(label="Detected Key")
+            
+            with gr.Row():
+                btn_half = gr.Button("½ Halve BPM")
+                btn_double = gr.Button("2x Double BPM")
+                
+            def halve_bpm(x): return int(x / 2)
+            def double_bpm(x): return int(x * 2)
+            
+            btn_half.click(halve_bpm, bpm_box, bpm_box)
+            btn_double.click(double_bpm, bpm_box, bpm_box)
+            
             with gr.Row():
-                p_drums = gr.Audio(label="Drums", interactive=False)
-                p_bass = gr.Audio(label="Bass", interactive=False)
-                p_vox = gr.Audio(label="Vocals", interactive=False)
+                p1 = gr.Audio(label="Drums", interactive=False, height=60)
+                p2 = gr.Audio(label="Bass", interactive=False, height=60)
+                p3 = gr.Audio(label="Vocals", interactive=False, height=60)
 
     gr.Markdown("---")
     
     with gr.Row():
         with gr.Column():
-            gr.Markdown("### 3. Loop Engine")
-            with gr.Group():
-                ex_stems = gr.CheckboxGroup(label="Export Raw Stems")
-                loop_stems = gr.CheckboxGroup(label="Generate Loops From")
-            
-            with gr.Row():
-                loops_per = gr.Slider(1, 40, 12, 1, label="Loops per Stem")
-                hop = gr.Slider(1, 8, 2, 1, label="Grid Hop")
+            gr.Markdown("### 3. Pack Generator")
+            ex_stems = gr.CheckboxGroup(label="Export Full Stems")
+            lp_stems = gr.CheckboxGroup(label="Generate Loops From")
             
-            with gr.Accordion("Advanced Processing", open=False):
-                l_mode = gr.Dropdown(["lufs", "rms", "peak", "none"], value="lufs", label="Norm Mode")
-                l_target = gr.Slider(-20, -5, -14, 1, label="Target Level (dB)")
-                fadems = gr.Slider(0, 50, 5, label="Micro-Fade (ms)")
-                topk = gr.Slider(5, 50, 20, label="Candidate Pool")
-                
-            art = gr.Image(type="filepath", label="Artwork (for Video)")
-            vid_fmt = gr.Dropdown(["9:16 (TikTok)", "16:9 (YouTube)", "1:1 (Square)"], value="9:16 (TikTok)", label="Video Aspect")
+            with gr.Accordion("Pack Settings", open=True):
+                with gr.Row():
+                    loops_per = gr.Slider(1, 20, 8, 1, label="Loops per Stem")
+                    bars = gr.CheckboxGroup(["4", "8"], value=["4", "8"], label="Lengths")
+                with gr.Row():
+                    do_midi = gr.Checkbox(label="Extract MIDI", value=True)
+                    do_oneshots = gr.Checkbox(label="Drum One-Shots", value=True)
+                    do_vocal_chops = gr.Checkbox(label="Vocal Chops", value=True)
+                loud_target = gr.Slider(-20, -6, -12, 1, label="Loudness Target (LUFS)")
+
+            with gr.Accordion("Video Promo", open=False):
+                art = gr.Image(type="filepath", label="Cover Art", height=200)
+                make_video = gr.Checkbox(label="Render 9:16 Video", value=False)
+
+            btn2 = gr.Button("⚡ Export Pack", variant="primary")
             
-            btn2 = gr.Button("📦 Generate Pack", variant="primary")
-
         with gr.Column():
-            gr.Markdown("### 4. Output")
-            z_out = gr.File(label="Download Zip")
+            gr.Markdown("### 4. Download")
+            z_out = gr.File(label="Sample Pack Zip")
             v_out = gr.Video(label="Promo Video")
+            log_out = gr.Textbox(label="Process Log", lines=10)
 
     # Wiring
     btn1.click(
-        run_phase_1, 
-        [file, url, sep_mode, mbpm], 
-        [p_drums, p_bass, p_vox, info, bpm_st, key_st, folder_st, mode_st, ex_stems, loop_stems]
+        phase1_analyze, 
+        [file, url, mode, mbpm, rerun], 
+        [p1, p2, p3, status, bpm_box, key_box, job_state, ex_stems, lp_stems]
     )
     
     btn2.click(
-        run_phase_2,
-        [
-            folder_st, bpm_st, key_st, mode_st, art,
-            ex_stems, loop_stems, gr.Checkbox(value=True), gr.Checkbox(value=True), gr.Checkbox(value=True),
-            loops_per, gr.State(["4", "8"]), hop, topk, fadems, gr.Checkbox(value=False), gr.Number(value=0), gr.Number(value=4),
-            l_mode, l_target, vid_fmt
-        ],
-        [z_out, v_out]
+        phase2_export,
+        [job_state, bpm_box, key_box, art, ex_stems, lp_stems, do_midi, do_oneshots, do_vocal_chops, loops_per, bars, loud_target, make_video, log_out],
+        [z_out, v_out, log_out]
     )
 
 if __name__ == "__main__":