Upload 6 files

public/example_page.md

@@ -0,0 +1,22 @@
+<!-- docs/example_page.md -->
+# GhostAI Music Generator — Quick Links
+
+- **MusicGen Large (Meta):** https://huggingface.co/facebook/musicgen-large  
+- **GhostAI assets & scripts:**  
+  - Repo hub: https://huggingface.co/ghostai1/GHOSTSONAFB  
+  - Stable 12GB build (example): https://huggingface.co/ghostai1/GHOSTSONAFB/blob/main/STABLE12gb3060.py  
+  - 30s large script: https://huggingface.co/ghostai1/GHOSTSONAFB/blob/main/stable12gblg30sec.py
+
+## Notes
+- GPU: CUDA-capable, 12GB+ VRAM recommended.
+- The app exposes an API on `:8555`:
+  - `GET /genres` — list available presets from `prompts.ini`
+  - `GET /prompt/{name}` — generate a prompt string (query params: `bpm`, `drum_beat`, `synthesizer`, `rhythmic_steps`, `bass_style`, `guitar_style`)
+  - **Aliases from INI** (examples):
+    - `/set_classic_rock_prompt` → Metallica
+    - `/set_nirvana_grunge_prompt` → Nirvana
+    - `/set_pearl_jam_grunge_prompt` → Pearl Jam
+    - `/set_soundgarden_grunge_prompt` → Soundgarden
+    - `/set_foo_fighters_prompt` → Foo Fighters
+    - `/set_star_wars_prompt` → Cinematic Star Wars-style orchestral
+  - `POST /render` — render an MP3. Body includes `instrumental_prompt` and optional overrides (duration, temperature, etc.).

public/prompts.ini

@@ -0,0 +1,66 @@
+# prompts.ini
+# Centralized prompt knobs for buttons + API aliases
+# Add/adjust sections; the app auto-loads buttons and endpoints.
+
+[metallica]
+bpm_min=90
+bpm_max=140
+drum_beat=standard rock,techno kick
+synthesizer=none
+rhythmic_steps=steady steps,complex steps
+bass_style=deep bass,melodic bass
+guitar_style=distorted
+api_name=/set_classic_rock_prompt
+
+[nirvana]
+bpm_min=100
+bpm_max=130
+drum_beat=standard rock
+synthesizer=none
+rhythmic_steps=steady steps
+bass_style=deep bass
+guitar_style=distorted,clean
+api_name=/set_nirvana_grunge_prompt
+
+[pearl_jam]
+bpm_min=100
+bpm_max=140
+drum_beat=standard rock
+synthesizer=none
+rhythmic_steps=steady steps,syncopated steps
+bass_style=melodic bass
+guitar_style=clean,distorted
+api_name=/set_pearl_jam_grunge_prompt
+
+[soundgarden]
+bpm_min=90
+bpm_max=130
+drum_beat=standard rock
+synthesizer=none
+rhythmic_steps=complex steps
+bass_style=deep bass
+guitar_style=distorted
+api_name=/set_soundgarden_grunge_prompt
+
+[foo_fighters]
+bpm_min=110
+bpm_max=150
+drum_beat=standard rock
+synthesizer=none
+rhythmic_steps=steady steps
+bass_style=melodic bass
+guitar_style=distorted,clean
+api_name=/set_foo_fighters_prompt
+
+# New: Cinematic / Star Wars-inspired classical
+# Optional 'styles' enhances descriptive tags for orchestral color.
+[star_wars_classical]
+bpm_min=84
+bpm_max=126
+drum_beat=orchestral percussion
+synthesizer=none
+rhythmic_steps=steady steps,complex steps
+bass_style=contrabass ostinato
+guitar_style=none
+styles=heroic brass,sweeping strings,soaring horns,timpani rolls,choir pads
+api_name=/set_star_wars_prompt

public/publicapi.py

@@ -0,0 +1,988 @@
+# app.py
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+
+import os
+import sys
+import gc
+import re
+import json
+import time
+import math
+import mmap
+import torch
+import random
+import logging
+import warnings
+import traceback
+import subprocess
+import tempfile
+import numpy as np
+import torchaudio
+import gradio as gr
+import gradio_client.utils
+import configparser
+from pydub import AudioSegment
+from datetime import datetime
+from pathlib import Path
+from typing import Optional, Tuple, Dict, Any, List
+from torch.cuda.amp import autocast
+
+from fastapi import FastAPI, HTTPException, Query
+from fastapi.middleware.cors import CORSMiddleware
+from pydantic import BaseModel
+import uvicorn
+import threading
+from logging.handlers import RotatingFileHandler
+
+# ======================================================================================
+# RUNTIME, LOGGING, PATCHES
+# ======================================================================================
+
+_original_get_type = gradio_client.utils.get_type
+def _patched_get_type(schema):
+    if isinstance(schema, bool):
+        return "boolean"
+    return _original_get_type(schema)
+gradio_client.utils.get_type = _patched_get_type
+
+warnings.filterwarnings("ignore")
+os.environ["PYTORCH_CUDA_ALLOC_CONF"] = "max_split_size_mb:128"
+torch.backends.cudnn.benchmark = False
+torch.backends.cudnn.deterministic = True
+
+LOG_DIR = "logs"
+MP3_DIR = "mp3"
+os.makedirs(LOG_DIR, exist_ok=True)
+os.makedirs(MP3_DIR, exist_ok=True)
+
+LOG_FILE = os.path.join(LOG_DIR, "ghostai_musicgen.log")
+logger = logging.getLogger("ghostai-musicgen")
+logger.setLevel(logging.DEBUG)
+logger.handlers = []  # prevent duplicate handlers on hot-reload
+
+file_handler = RotatingFileHandler(
+    LOG_FILE,
+    maxBytes=5 * 1024 * 1024,  # 5 MB cap
+    backupCount=0,             # single file only; truncate on rollover
+    encoding="utf-8",
+    delay=True
+)
+file_handler.setFormatter(logging.Formatter("%(asctime)s [%(levelname)s] %(message)s"))
+stdout_handler = logging.StreamHandler(sys.stdout)
+stdout_handler.setFormatter(logging.Formatter("%(asctime)s [%(levelname)s] %(message)s"))
+logger.addHandler(file_handler)
+logger.addHandler(stdout_handler)
+
+DEVICE = "cuda" if torch.cuda.is_available() else "cpu"
+if DEVICE != "cuda":
+    logger.error("CUDA GPU is required. Exiting.")
+    sys.exit(1)
+logger.info(f"GPU: {torch.cuda.get_device_name(0)}")
+
+# ======================================================================================
+# SETTINGS PERSISTENCE
+# ======================================================================================
+
+SETTINGS_FILE = "settings.json"
+PROMPTS_INI = "prompts.ini"
+STYLES_CSS = "styles.css"
+
+DEFAULT_SETTINGS: Dict[str, Any] = {
+    "cfg_scale": 5.8,
+    "top_k": 250,
+    "top_p": 0.95,
+    "temperature": 0.90,
+    "total_duration": 60,
+    "bpm": 120,
+    "drum_beat": "none",
+    "synthesizer": "none",
+    "rhythmic_steps": "none",
+    "bass_style": "none",
+    "guitar_style": "none",
+    "target_volume": -23.0,
+    "preset": "default",
+    "max_steps": 1500,
+    "bitrate": "192k",
+    "output_sample_rate": "48000",
+    "bit_depth": "16",
+    "instrumental_prompt": ""
+}
+
+def load_settings() -> Dict[str, Any]:
+    try:
+        if os.path.exists(SETTINGS_FILE):
+            with open(SETTINGS_FILE, "r") as f:
+                data = json.load(f)
+            for k, v in DEFAULT_SETTINGS.items():
+                data.setdefault(k, v)
+            logger.info(f"Loaded settings from {SETTINGS_FILE}")
+            return data
+    except Exception as e:
+        logger.error(f"Settings load failed: {e}")
+    return DEFAULT_SETTINGS.copy()
+
+def save_settings(s: Dict[str, Any]) -> None:
+    try:
+        with open(SETTINGS_FILE, "w") as f:
+            json.dump(s, f, indent=2)
+        logger.info(f"Saved settings to {SETTINGS_FILE}")
+    except Exception as e:
+        logger.error(f"Settings save failed: {e}")
+
+SETTINGS = load_settings()
+
+# ======================================================================================
+# PROMPT CONFIG (prompts.ini)
+# ======================================================================================
+
+def _csv_list(s: str) -> List[str]:
+    if not s or s.strip().lower() == "none":
+        return []
+    return [x.strip() for x in s.split(",") if x.strip()]
+
+PROMPT_CFG = configparser.ConfigParser()
+if not os.path.exists(PROMPTS_INI):
+    PROMPT_CFG["metallica"] = {
+        "bpm_min": "90", "bpm_max": "140",
+        "drum_beat": "standard rock,techno kick",
+        "synthesizer": "none",
+        "rhythmic_steps": "steady steps,complex steps",
+        "bass_style": "deep bass,melodic bass",
+        "guitar_style": "distorted",
+        "api_name": "/set_classic_rock_prompt"
+    }
+    with open(PROMPTS_INI, "w") as f:
+        PROMPT_CFG.write(f)
+PROMPT_CFG.read(PROMPTS_INI)
+
+def list_genres() -> List[str]:
+    return PROMPT_CFG.sections()
+
+def get_api_aliases() -> Dict[str, str]:
+    out = {}
+    for sec in PROMPT_CFG.sections():
+        api_name = PROMPT_CFG.get(sec, "api_name", fallback="").strip()
+        if api_name:
+            out[api_name] = sec
+    return out
+
+def _humanize(name: str) -> str:
+    return name.replace("_", " ").title()
+
+def build_prompt_from_section(
+    section: str,
+    bpm: Optional[int] = None,
+    drum_beat: Optional[str] = None,
+    synthesizer: Optional[str] = None,
+    rhythmic_steps: Optional[str] = None,
+    bass_style: Optional[str] = None,
+    guitar_style: Optional[str] = None
+) -> str:
+    if section not in PROMPT_CFG:
+        return f"Instrumental track at 120 BPM."
+    cfg = PROMPT_CFG[section]
+    bpm_min = cfg.getint("bpm_min", fallback=100)
+    bpm_max = cfg.getint("bpm_max", fallback=130)
+    bpm = bpm if bpm else random.randint(bpm_min, bpm_max)
+    bpm = max(bpm_min, min(bpm_max, bpm))
+
+    def pick(value: Optional[str], pool_key: str) -> str:
+        pool = _csv_list(cfg.get(pool_key, fallback=""))
+        if not pool:
+            return "" if (not value or value == "none") else f", {value}"
+        if (not value) or value == "none" or value not in pool:
+            choice = random.choice(pool)
+            return "" if choice == "none" else f", {choice}"
+        return f", {value}"
+
+    drum   = pick(drum_beat, "drum_beat")
+    synth  = pick(synthesizer, "synthesizer")
+    steps  = pick(rhythmic_steps, "rhythmic_steps")
+    bass   = pick(bass_style, "bass_style")
+    guitar = pick(guitar_style, "guitar_style")
+
+    styles_csv = cfg.get("styles", fallback="").strip()
+    styles_str = ""
+    if styles_csv:
+        styles = _csv_list(styles_csv)
+        if styles:
+            styles_str = ", " + ", ".join(styles)
+
+    label = _humanize(section)
+    if "star_wars" in section or "classical" in section:
+        return (
+            f"Cinematic orchestral score{styles_str}{drum}{synth}{steps}{bass}{guitar}, "
+            f"space-opera energy, sweeping strings, heroic brass, bold timpani at {bpm} BPM."
+        )
+    return (
+        f"Instrumental {label}{guitar}{bass}{drum}{synth}{steps} at {bpm} BPM, "
+        f"dynamic sections (intro/verse/chorus), cohesive song flow."
+    )
+
+# ======================================================================================
+# VRAM / DISK / CLEANUP
+# ======================================================================================
+
+def clean_memory() -> Optional[float]:
+    try:
+        torch.cuda.empty_cache()
+        gc.collect()
+        torch.cuda.ipc_collect()
+        torch.cuda.synchronize()
+        return torch.cuda.memory_allocated() / 1024**2
+    except Exception as e:
+        logger.error(f"clean_memory failed: {e}")
+        return None
+
+def check_vram():
+    try:
+        r = subprocess.run(
+            ['nvidia-smi', '--query-gpu=memory.used,memory.total', '--format=csv'],
+            capture_output=True, text=True
+        )
+        lines = r.stdout.splitlines()
+        if len(lines) > 1:
+            used_mb, total_mb = map(int, re.findall(r'\d+', lines[1]))
+            free_mb = total_mb - used_mb
+            logger.info(f"VRAM: used {used_mb} MiB | free {free_mb} MiB | total {total_mb} MiB")
+            return free_mb
+    except Exception as e:
+        logger.error(f"check_vram failed: {e}")
+    return None
+
+def check_disk_space(path=".") -> bool:
+    try:
+        stat = os.statvfs(path)
+        free_gb = stat.f_bavail * stat.f_frsize / (1024**3)
+        if free_gb < 1.0:
+            logger.warning(f"Low disk space: {free_gb:.2f} GB")
+        return free_gb >= 1.0
+    except Exception as e:
+        logger.error(f"Disk space check failed: {e}")
+        return False
+
+# ======================================================================================
+# MODEL LOAD
+# ======================================================================================
+
+try:
+    from audiocraft.models import MusicGen
+except Exception as e:
+    logger.error("audiocraft is required. pip install audiocraft")
+    raise
+
+def load_model():
+    free_vram = check_vram()
+    if free_vram is not None and free_vram < 5000:
+        logger.warning("Low free VRAM; consider closing other GPU apps.")
+    clean_memory()
+    local_model_path = "./models/musicgen-large"
+    if not os.path.exists(local_model_path):
+        logger.error(f"Missing weights at {local_model_path}")
+        sys.exit(1)
+    logger.info("Loading MusicGen (large)...")
+    with autocast(dtype=torch.float16):
+        model = MusicGen.get_pretrained(local_model_path, device=DEVICE)
+    model.set_generation_params(duration=30, two_step_cfg=False)
+    logger.info("MusicGen loaded.")
+    return model
+
+musicgen_model = load_model()
+
+# ======================================================================================
+# AUDIO DSP
+# ======================================================================================
+
+def ensure_stereo(seg: AudioSegment, sample_rate=48000, sample_width=2) -> AudioSegment:
+    try:
+        if seg.channels != 2:
+            seg = seg.set_channels(2)
+        if seg.frame_rate != sample_rate:
+            seg = seg.set_frame_rate(sample_rate)
+        return seg
+    except Exception:
+        return seg
+
+def calculate_rms(seg: AudioSegment) -> float:
+    try:
+        samples = np.array(seg.get_array_of_samples(), dtype=np.float32)
+        return float(np.sqrt(np.mean(samples**2)))
+    except Exception:
+        return 0.0
+
+def hard_limit(seg: AudioSegment, limit_db=-3.0, sample_rate=48000) -> AudioSegment:
+    try:
+        seg = ensure_stereo(seg, sample_rate, seg.sample_width)
+        limit = 10 ** (limit_db / 20.0) * (2**23 if seg.sample_width == 3 else 32767)
+        x = np.array(seg.get_array_of_samples(), dtype=np.float32)
+        x = np.clip(x, -limit, limit).astype(np.int32 if seg.sample_width == 3 else np.int16)
+        if len(x) % 2 != 0:
+            x = x[:-1]
+        return AudioSegment(x.tobytes(), frame_rate=sample_rate, sample_width=seg.sample_width, channels=2)
+    except Exception:
+        return seg
+
+def rms_normalize(seg: AudioSegment, target_rms_db=-23.0, peak_limit_db=-3.0, sample_rate=48000) -> AudioSegment:
+    try:
+        seg = ensure_stereo(seg, sample_rate, seg.sample_width)
+        target = 10 ** (target_rms_db / 20) * (2**23 if seg.sample_width == 3 else 32767)
+        current = calculate_rms(seg)
+        if current > 0:
+            gain = target / current
+            seg = seg.apply_gain(20 * np.log10(max(gain, 1e-6)))
+        seg = hard_limit(seg, limit_db=peak_limit_db, sample_rate=sample_rate)
+        return seg
+    except Exception:
+        return seg
+
+def balance_stereo(seg: AudioSegment, noise_threshold=-40, sample_rate=48000) -> AudioSegment:
+    try:
+        seg = ensure_stereo(seg, sample_rate, seg.sample_width)
+        x = np.array(seg.get_array_of_samples(), dtype=np.float32)
+        stereo = x.reshape(-1, 2)
+        db = 20 * np.log10(np.abs(stereo) + 1e-10)
+        mask = db > noise_threshold
+        stereo = stereo * mask
+        L, R = stereo[:, 0], stereo[:, 1]
+        l_rms = np.sqrt(np.mean(L[L != 0] ** 2)) if np.any(L != 0) else 0
+        r_rms = np.sqrt(np.mean(R[R != 0] ** 2)) if np.any(R != 0) else 0
+        if l_rms > 0 and r_rms > 0:
+            avg = (l_rms + r_rms) / 2
+            stereo[:, 0] *= (avg / l_rms)
+            stereo[:, 1] *= (avg / r_rms)
+        out = stereo.flatten().astype(np.int32 if seg.sample_width == 3 else np.int16)
+        if len(out) % 2 != 0:
+            out = out[:-1]
+        return AudioSegment(out.tobytes(), frame_rate=sample_rate, sample_width=seg.sample_width, channels=2)
+    except Exception:
+        return seg
+
+def apply_noise_gate(seg: AudioSegment, threshold_db=-80, sample_rate=48000) -> AudioSegment:
+    try:
+        seg = ensure_stereo(seg, sample_rate, seg.sample_width)
+        x = np.array(seg.get_array_of_samples(), dtype=np.float32)
+        stereo = x.reshape(-1, 2)
+        for _ in range(2):
+            db = 20 * np.log10(np.abs(stereo) + 1e-10)
+            mask = db > threshold_db
+            stereo = stereo * mask
+        out = stereo.flatten().astype(np.int32 if seg.sample_width == 3 else np.int16)
+        if len(out) % 2 != 0:
+            out = out[:-1]
+        return AudioSegment(out.tobytes(), frame_rate=sample_rate, sample_width=seg.sample_width, channels=2)
+    except Exception:
+        return seg
+
+def apply_eq(seg: AudioSegment, sample_rate=48000) -> AudioSegment:
+    try:
+        seg = ensure_stereo(seg, sample_rate, seg.sample_width)
+        seg = seg.high_pass_filter(20).low_pass_filter(8000)
+        seg = seg - 3
+        seg = seg - 3
+        seg = seg - 10
+        return seg
+    except Exception:
+        return seg
+
+def apply_fade(seg: AudioSegment, fade_in_ms=500, fade_out_ms=800) -> AudioSegment:
+    try:
+        seg = ensure_stereo(seg, seg.frame_rate, seg.sample_width)
+        return seg.fade_in(fade_in_ms).fade_out(fade_out_ms)
+    except Exception:
+        return seg
+
+def _export_tensor_to_segment(audio: torch.Tensor, sr: int, bit_depth: int) -> Optional[AudioSegment]:
+    tmp = tempfile.NamedTemporaryFile(delete=False, suffix=".wav")
+    tmp_path = tmp.name
+    tmp.close()
+    try:
+        torchaudio.save(tmp_path, audio, sr, bits_per_sample=bit_depth)
+        with open(tmp_path, "rb") as f:
+            mm = mmap.mmap(f.fileno(), 0, access=mmap.ACCESS_READ)
+            seg = AudioSegment.from_wav(tmp_path)
+            mm.close()
+        return seg
+    except Exception as e:
+        logger.error(f"export tensor -> segment failed: {e}")
+        return None
+    finally:
+        try:
+            if os.path.exists(tmp_path): os.unlink(tmp_path)
+        except OSError:
+            pass
+
+def _crossfade(seg_a: AudioSegment, seg_b: AudioSegment, overlap_ms: int, sr: int, bit_depth: int) -> AudioSegment:
+    try:
+        seg_a = ensure_stereo(seg_a, sr, seg_a.sample_width)
+        seg_b = ensure_stereo(seg_b, sr, seg_b.sample_width)
+        if overlap_ms <= 0 or len(seg_a) < overlap_ms or len(seg_b) < overlap_ms:
+            return seg_a + seg_b
+
+        with tempfile.NamedTemporaryFile(delete=False, suffix=".wav") as a_wav, \
+             tempfile.NamedTemporaryFile(delete=False, suffix=".wav") as b_wav, \
+             tempfile.NamedTemporaryFile(delete=False, suffix=".wav") as cf_wav:
+            a_path = a_wav.name
+            b_path = b_wav.name
+            cf_path = cf_wav.name
+
+        seg_a[-overlap_ms:].export(a_path, format="wav")
+        seg_b[:overlap_ms].export(b_path, format="wav")
+        a, sr_a = torchaudio.load(a_path)
+        b, sr_b = torchaudio.load(b_path)
+        if sr_a != sr:
+            a = torchaudio.functional.resample(a, sr_a, sr, lowpass_filter_width=64)
+        if sr_b != sr:
+            b = torchaudio.functional.resample(b, sr_b, sr, lowpass_filter_width=64)
+        n = min(a.shape[1], b.shape[1])
+        n = n - (n % 2)
+        if n <= 0:
+            for p in (a_path, b_path, cf_path):
+                try:
+                    if os.path.exists(p): os.unlink(p)
+                except OSError:
+                    pass
+            return seg_a + seg_b
+        aw = a[:, :n].to(torch.float32)
+        bw = b[:, :n].to(torch.float32)
+        hann = torch.hann_window(n, periodic=False)
+        out = (aw * hann.flip(0) + bw * hann).clamp(-1.0, 1.0)
+        scale = (2**23 if bit_depth == 24 else 32767)
+        out_i = (out * scale).to(torch.int32 if bit_depth == 24 else torch.int16)
+        torchaudio.save(cf_path, out_i, sr, bits_per_sample=bit_depth)
+        blended = AudioSegment.from_wav(cf_path)
+        res = seg_a[:-overlap_ms] + blended + seg_b[overlap_ms:]
+        for p in (a_path, b_path, cf_path):
+            try:
+                if os.path.exists(p): os.unlink(p)
+            except OSError:
+                pass
+        return res
+    except Exception as e:
+        logger.error(f"crossfade failed: {e}")
+        return seg_a + seg_b
+
+# ======================================================================================
+# GENERATION (30s chunks -> seamless)
+# ======================================================================================
+
+def generate_music(
+    instrumental_prompt: str,
+    cfg_scale: float,
+    top_k: int,
+    top_p: float,
+    temperature: float,
+    total_duration: int,
+    bpm: int,
+    drum_beat: str,
+    synthesizer: str,
+    rhythmic_steps: str,
+    bass_style: str,
+    guitar_style: str,
+    target_volume: float,
+    preset: str,
+    max_steps_ignored: str,
+    vram_status_text: str,
+    bitrate: str,
+    output_sample_rate: str,
+    bit_depth: str
+) -> Tuple[Optional[str], str, str]:
+    if not instrumental_prompt or not instrumental_prompt.strip():
+        return None, "⚠️ Enter a valid prompt.", vram_status_text
+
+    try:
+        out_sr = int(output_sample_rate)
+        bit_depth_int = int(bit_depth)
+        sample_width = 3 if bit_depth_int == 24 else 2
+    except Exception:
+        return None, "❌ Invalid output SR or bit depth.", vram_status_text
+
+    if not check_disk_space("."):
+        return None, "⚠️ Low disk space (<1GB).", vram_status_text
+
+    CHUNK = 30
+    total_duration = max(30, min(int(total_duration), 180))
+    chunks = math.ceil(total_duration / CHUNK)
+    PROCESS_SR = 48000
+    OVERLAP = 0.20
+
+    musicgen_model.set_generation_params(
+        duration=CHUNK,
+        use_sampling=True,
+        top_k=int(top_k),
+        top_p=float(top_p),
+        temperature=float(temperature),
+        cfg_coef=float(cfg_scale),
+        two_step_cfg=False,
+    )
+
+    vram_status_text = f"Start VRAM: {torch.cuda.memory_allocated() / 1024**2:.2f} MB"
+    segments: List[AudioSegment] = []
+
+    seed = random.randint(0, 2**31 - 1)
+    random.seed(seed); np.random.seed(seed)
+    torch.manual_seed(seed); torch.cuda.manual_seed_all(seed)
+
+    for i in range(chunks):
+        part = i + 1
+        dur = CHUNK if (i < chunks - 1) else (total_duration - CHUNK * (chunks - 1) or CHUNK)
+        logger.info(f"Generating chunk {part}/{chunks} ({dur}s)")
+        chunk_prompt = instrumental_prompt
+
+        try:
+            with torch.no_grad():
+                with autocast(dtype=torch.float16):
+                    clean_memory()
+                    if i == 0:
+                        audio = musicgen_model.generate([chunk_prompt], progress=True)[0].cpu()
+                    else:
+                        prev = segments[-1]
+                        prev = apply_noise_gate(prev, -80, PROCESS_SR)
+                        prev = balance_stereo(prev, -40, PROCESS_SR)
+                        with tempfile.NamedTemporaryFile(delete=False, suffix=".wav") as tprev:
+                            prev_path = tprev.name
+                        prev.export(prev_path, format="wav")
+                        tail, sr_prev = torchaudio.load(prev_path)
+                        if sr_prev != PROCESS_SR:
+                            tail = torchaudio.functional.resample(tail, sr_prev, PROCESS_SR, lowpass_filter_width=64)
+                        if tail.shape[0] != 2:
+                            tail = tail.repeat(2, 1)[:, :tail.shape[1]]
+                        try:
+                            os.unlink(prev_path)
+                        except OSError:
+                            pass
+                        tail = tail.to(DEVICE)[:, -int(PROCESS_SR * OVERLAP):]
+                        audio = musicgen_model.generate_continuation(
+                            prompt=tail,
+                            prompt_sample_rate=PROCESS_SR,
+                            descriptions=[chunk_prompt],
+                            progress=True
+                        )[0].cpu()
+                    clean_memory()
+        except Exception as e:
+            logger.error(f"Chunk {part} generation failed: {e}")
+            return None, f"❌ Failed to generate chunk {part}: {e}", vram_status_text
+
+        try:
+            if audio.shape[0] != 2:
+                audio = audio.repeat(2, 1)[:, :audio.shape[1]]
+            audio = audio.to(torch.float32)
+            audio = torchaudio.functional.resample(audio, 32000, PROCESS_SR, lowpass_filter_width=64)
+            seg = _export_tensor_to_segment(audio, PROCESS_SR, bit_depth_int)
+            if seg is None:
+                return None, f"❌ Audio conversion failed (chunk {part}).", vram_status_text
+            seg = ensure_stereo(seg, PROCESS_SR, sample_width)
+            seg = seg - 15
+            seg = apply_noise_gate(seg, -80, PROCESS_SR)
+            seg = balance_stereo(seg, -40, PROCESS_SR)
+            seg = rms_normalize(seg, target_rms_db=target_volume, peak_limit_db=-3.0, sample_rate=PROCESS_SR)
+            seg = apply_eq(seg, PROCESS_SR)
+            seg = seg[:dur * 1000]
+            segments.append(seg)
+            del audio
+            vram_status_text = f"VRAM after chunk {part}: {torch.cuda.memory_allocated() / 1024**2:.2f} MB"
+        except Exception as e:
+            logger.error(f"Post-process failed (chunk {part}): {e}")
+            return None, f"❌ Processing error (chunk {part}).", vram_status_text
+
+    if not segments:
+        return None, "❌ No audio generated.", vram_status_text
+
+    logger.info("Combining chunks...")
+    out = segments[0]
+    overlap_ms = int(OVERLAP * 1000)
+    for k in range(1, len(segments)):
+        out = _crossfade(out, segments[k], overlap_ms, PROCESS_SR, bit_depth_int)
+
+    out = out[:total_duration * 1000]
+    out = apply_noise_gate(out, -80, PROCESS_SR)
+    out = balance_stereo(out, -40, PROCESS_SR)
+    out = rms_normalize(out, target_rms_db=target_volume, peak_limit_db=-3.0, sample_rate=PROCESS_SR)
+    out = apply_eq(out, PROCESS_SR)
+    out = apply_fade(out, 500, 800)
+    out = (out - 10).set_frame_rate(out_sr)
+
+    mp3_path = os.path.join(MP3_DIR, f"ghostai_music_{int(time.time())}.mp3")
+    try:
+        clean_memory()
+        out.export(mp3_path, format="mp3", bitrate=bitrate, tags={"title": "GhostAI Instrumental", "artist": "GhostAI"})
+    except Exception as e:
+        logger.error(f"MP3 export failed: {e}")
+        fb = os.path.join(MP3_DIR, f"ghostai_music_fallback_{int(time.time())}.mp3")
+        try:
+            out.export(fb, format="mp3", bitrate="128k")
+            mp3_path = fb
+        except Exception as ee:
+            return None, f"❌ Export failed: {ee}", vram_status_text
+
+    vram_status_text = f"Final VRAM: {torch.cuda.memory_allocated() / 1024**2:.2f} MB"
+    return mp3_path, "✅ Done! Seamless unified track rendered.", vram_status_text
+
+def generate_music_wrapper(*args):
+    try:
+        return generate_music(*args)
+    finally:
+        clean_memory()
+
+# ======================================================================================
+# FASTAPI — Status + Settings + Prompts + Render
+# ======================================================================================
+
+class RenderRequest(BaseModel):
+    instrumental_prompt: str
+    cfg_scale: Optional[float] = None
+    top_k: Optional[int] = None
+    top_p: Optional[float] = None
+    temperature: Optional[float] = None
+    total_duration: Optional[int] = None
+    bpm: Optional[int] = None
+    drum_beat: Optional[str] = None
+    synthesizer: Optional[str] = None
+    rhythmic_steps: Optional[str] = None
+    bass_style: Optional[str] = None
+    guitar_style: Optional[str] = None
+    target_volume: Optional[float] = None
+    preset: Optional[str] = None
+    max_steps: Optional[int] = None
+    bitrate: Optional[str] = None
+    output_sample_rate: Optional[str] = None
+    bit_depth: Optional[str] = None
+
+class SettingsUpdate(BaseModel):
+    settings: Dict[str, Any]
+
+BUSY_LOCK = threading.Lock()
+BUSY_FLAG = False
+CURRENT_JOB: Dict[str, Any] = {"id": None, "start": None}
+
+def set_busy(val: bool, job_id: Optional[str] = None):
+    global BUSY_FLAG, CURRENT_JOB
+    with BUSY_LOCK:
+        BUSY_FLAG = val
+        if val:
+            CURRENT_JOB["id"] = job_id or f"job_{int(time.time())}"
+            CURRENT_JOB["start"] = time.time()
+        else:
+            CURRENT_JOB["id"] = None
+            CURRENT_JOB["start"] = None
+
+def is_busy() -> bool:
+    with BUSY_LOCK:
+        return BUSY_FLAG
+
+def job_elapsed() -> float:
+    with BUSY_LOCK:
+        if CURRENT_JOB["start"] is None:
+            return 0.0
+        return time.time() - CURRENT_JOB["start"]
+
+fastapp = FastAPI(title="GhostAI Music Server", version="1.2")
+fastapp.add_middleware(
+    CORSMiddleware, allow_origins=["*"], allow_credentials=True, allow_methods=["*"], allow_headers=["*"]
+)
+
+@fastapp.get("/health")
+def health():
+    return {"ok": True, "ts": int(time.time())}
+
+@fastapp.get("/status")
+def status():
+    return {"busy": is_busy(), "job_id": CURRENT_JOB["id"], "elapsed": job_elapsed()}
+
+@fastapp.get("/config")
+def get_config():
+    return {"defaults": SETTINGS}
+
+@fastapp.post("/settings")
+def set_settings(payload: SettingsUpdate):
+    try:
+        s = SETTINGS.copy()
+        s.update(payload.settings or {})
+        save_settings(s)
+        for k, v in s.items():
+            SETTINGS[k] = v
+        return {"ok": True, "saved": s}
+    except Exception as e:
+        raise HTTPException(status_code=400, detail=str(e))
+
+@fastapp.get("/genres")
+def api_genres():
+    return {"genres": list_genres()}
+
+@fastapp.post("/reload_prompts")
+def api_reload_prompts():
+    try:
+        PROMPT_CFG.read(PROMPTS_INI)
+        return {"ok": True, "genres": list_genres(), "aliases": get_api_aliases()}
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))
+
+@fastapp.get("/prompt/{name}")
+def api_prompt(
+    name: str,
+    bpm: Optional[int] = Query(None),
+    drum_beat: Optional[str] = Query(None),
+    synthesizer: Optional[str] = Query(None),
+    rhythmic_steps: Optional[str] = Query(None),
+    bass_style: Optional[str] = Query(None),
+    guitar_style: Optional[str] = Query(None),
+):
+    if name not in PROMPT_CFG:
+        raise HTTPException(status_code=404, detail=f"Unknown genre '{name}'.")
+    prompt = build_prompt_from_section(name, bpm, drum_beat, synthesizer, rhythmic_steps, bass_style, guitar_style)
+    return {"name": name, "prompt": prompt}
+
+@fastapp.post("/render")
+def render(req: RenderRequest):
+    if is_busy():
+        raise HTTPException(status_code=409, detail="Server busy")
+    job_id = f"render_{int(time.time())}"
+    set_busy(True, job_id)
+    try:
+        s = SETTINGS.copy()
+        for k, v in req.dict().items():
+            if v is not None:
+                s[k] = v
+        mp3, msg, vram = generate_music(
+            s.get("instrumental_prompt", req.instrumental_prompt),
+            float(s.get("cfg_scale", DEFAULT_SETTINGS["cfg_scale"])),
+            int(s.get("top_k", DEFAULT_SETTINGS["top_k"])),
+            float(s.get("top_p", DEFAULT_SETTINGS["top_p"])),
+            float(s.get("temperature", DEFAULT_SETTINGS["temperature"])),
+            int(s.get("total_duration", DEFAULT_SETTINGS["total_duration"])),
+            int(s.get("bpm", DEFAULT_SETTINGS["bpm"])),
+            str(s.get("drum_beat", DEFAULT_SETTINGS["drum_beat"])),
+            str(s.get("synthesizer", DEFAULT_SETTINGS["synthesizer"])),
+            str(s.get("rhythmic_steps", DEFAULT_SETTINGS["rhythmic_steps"])),
+            str(s.get("bass_style", DEFAULT_SETTINGS["bass_style"])),
+            str(s.get("guitar_style", DEFAULT_SETTINGS["guitar_style"])),
+            float(s.get("target_volume", DEFAULT_SETTINGS["target_volume"])),
+            str(s.get("preset", DEFAULT_SETTINGS["preset"])),
+            str(s.get("max_steps", DEFAULT_SETTINGS["max_steps"])),
+            "",
+            str(s.get("bitrate", DEFAULT_SETTINGS["bitrate"])),
+            str(s.get("output_sample_rate", DEFAULT_SETTINGS["output_sample_rate"])),
+            str(s.get("bit_depth", DEFAULT_SETTINGS["bit_depth"]))
+        )
+        if not mp3:
+            raise HTTPException(status_code=500, detail=msg)
+        return {"ok": True, "job_id": job_id, "path": mp3, "status": msg, "vram": vram}
+    finally:
+        set_busy(False, None)
+
+for path, sec in get_api_aliases().items():
+    def _factory(section_name: str):
+        def _endpoint(
+            bpm: Optional[int] = Query(None),
+            drum_beat: Optional[str] = Query(None),
+            synthesizer: Optional[str] = Query(None),
+            rhythmic_steps: Optional[str] = Query(None),
+            bass_style: Optional[str] = Query(None),
+            guitar_style: Optional[str] = Query(None),
+        ):
+            prompt = build_prompt_from_section(section_name, bpm, drum_beat, synthesizer, rhythmic_steps, bass_style, guitar_style)
+            return {"name": section_name, "prompt": prompt}
+        return _endpoint
+    fastapp.add_api_route(path, _factory(sec), methods=["GET"])
+
+def _start_fastapi():
+    uvicorn.run(fastapp, host="0.0.0.0", port=8555, log_level="info")
+
+api_thread = threading.Thread(target=_start_fastapi, daemon=True)
+api_thread.start()
+logger.info("FastAPI server on http://0.0.0.0:8555")
+
+# ======================================================================================
+# GRADIO UI
+# ======================================================================================
+
+def get_latest_log():
+    try:
+        if not os.path.exists(LOG_FILE):
+            return "No log file found."
+        with open(LOG_FILE, "r", encoding="utf-8", errors="ignore") as f:
+            return f.read()
+    except Exception as e:
+        return f"Error reading log file: {e}"
+
+css_text = Path(STYLES_CSS).read_text(encoding="utf-8") if os.path.exists(STYLES_CSS) else ""
+
+logger.info("Building Gradio UI...")
+with gr.Blocks(css=css_text, analytics_enabled=False, title="GhostAI Music Generator") as demo:
+    gr.Markdown("# 🎵 GhostAI Music Generator")
+    gr.Markdown("Create instrumental tracks with fixed 30s chunking and seamless merges. Accessibility-first UI.")
+
+    with gr.Row():
+        with gr.Column():
+            instrumental_prompt = gr.Textbox(
+                label="Instrumental Prompt",
+                placeholder="Type your prompt or click a Genre button below",
+                lines=4,
+                value=SETTINGS.get("instrumental_prompt", ""),
+            )
+
+            genre_buttons = []
+            genre_sections = list_genres()
+            with gr.Group():
+                gr.Markdown("### Genres (from prompts.ini)")
+                for i in range(0, len(genre_sections), 4):
+                    with gr.Row():
+                        for sec in genre_sections[i:i+4]:
+                            btn = gr.Button(_humanize(sec))
+                            genre_buttons.append((btn, sec))
+
+            with gr.Group():
+                gr.Markdown("### Generation Settings")
+                cfg_scale = gr.Slider(1.0, 10.0, step=0.1, value=float(SETTINGS.get("cfg_scale", 5.8)), label="CFG Scale")
+                top_k = gr.Slider(10, 500, step=10, value=int(SETTINGS.get("top_k", 250)), label="Top-K")
+                top_p = gr.Slider(0.0, 1.0, step=0.01, value=float(SETTINGS.get("top_p", 0.95)), label="Top-P")
+                temperature = gr.Slider(0.1, 2.0, step=0.01, value=float(SETTINGS.get("temperature", 0.90)), label="Temperature")
+                total_duration = gr.Dropdown(choices=[30, 60, 90, 120, 180], value=int(SETTINGS.get("total_duration", 60)), label="Song Length (seconds)")
+
+                bpm = gr.Slider(60, 180, step=1, value=int(SETTINGS.get("bpm", 120)), label="Tempo (BPM)")
+                drum_beat = gr.Dropdown(choices=["none", "standard rock", "techno kick", "funk groove", "jazz swing", "orchestral percussion"], value=str(SETTINGS.get("drum_beat", "none")), label="Drum Beat")
+                synthesizer = gr.Dropdown(choices=["none", "analog synth", "digital pad", "arpeggiated synth", "strings", "brass", "choir"], value=str(SETTINGS.get("synthesizer", "none")), label="Synthesizer / Section")
+                rhythmic_steps = gr.Dropdown(choices=["none", "steady steps", "syncopated steps", "complex steps"], value=str(SETTINGS.get("rhythmic_steps", "none")), label="Rhythmic Steps")
+                bass_style = gr.Dropdown(choices=["none", "slap bass", "deep bass", "melodic bass", "contrabass ostinato"], value=str(SETTINGS.get("bass_style", "none")), label="Bass Style")
+                guitar_style = gr.Dropdown(choices=["none", "distorted", "clean", "jangle"], value=str(SETTINGS.get("guitar_style", "none")), label="Guitar Style")
+
+                target_volume = gr.Slider(-30.0, -20.0, step=0.5, value=float(SETTINGS.get("target_volume", -23.0)), label="Target Loudness (dBFS RMS)")
+                preset = gr.Dropdown(choices=["default", "rock", "techno", "grunge", "indie", "funk_rock"], value=str(SETTINGS.get("preset", "default")), label="Preset")
+                max_steps = gr.Dropdown(choices=[1000, 1200, 1300, 1500], value=int(SETTINGS.get("max_steps", 1500)), label="Max Steps (info)")
+                bitrate_state = gr.State(value=str(SETTINGS.get("bitrate", "192k")))
+                sample_rate_state = gr.State(value=str(SETTINGS.get("output_sample_rate", "48000")))
+                bit_depth_state = gr.State(value=str(SETTINGS.get("bit_depth", "16")))
+
+                with gr.Row():
+                    br128 = gr.Button("Bitrate 128k")
+                    br192 = gr.Button("Bitrate 192k")
+                    br320 = gr.Button("Bitrate 320k")
+                with gr.Row():
+                    sr22 = gr.Button("SR 22.05k")
+                    sr44 = gr.Button("SR 44.1k")
+                    sr48 = gr.Button("SR 48k")
+                with gr.Row():
+                    bd16 = gr.Button("16-bit")
+                    bd24 = gr.Button("24-bit")
+
+                gen_btn = gr.Button("Generate Music 🚀")
+                clr_btn = gr.Button("Clear 🧹")
+                save_btn = gr.Button("Save Settings 💾")
+                load_btn = gr.Button("Load Settings 📂")
+                reset_btn = gr.Button("Reset Defaults ♻️")
+
+        with gr.Column():
+            gr.Markdown("### Output")
+            out_audio = gr.Audio(label="Generated Track (saved in ./mp3)", type="filepath")
+            status_box = gr.Textbox(label="Status", interactive=False)
+            vram_box = gr.Textbox(label="VRAM Usage", interactive=False, value="")
+            log_btn = gr.Button("View Log 📋")
+            log_output = gr.Textbox(label="Log Contents", lines=18, interactive=False)
+
+    def on_genre_click(sec, bpm_v, drum_v, synth_v, steps_v, bass_v, guitar_v):
+        return build_prompt_from_section(sec, bpm_v, drum_v, synth_v, steps_v, bass_v, guitar_v)
+
+    for btn, sec in genre_buttons:
+        btn.click(
+            on_genre_click,
+            inputs=[gr.State(sec), bpm, drum_beat, synthesizer, rhythmic_steps, bass_style, guitar_style],
+            outputs=instrumental_prompt
+        )
+
+    br128.click(lambda: "128k", outputs=bitrate_state)
+    br192.click(lambda: "192k", outputs=bitrate_state)
+    br320.click(lambda: "320k", outputs=bitrate_state)
+    sr22.click(lambda: "22050", outputs=sample_rate_state)
+    sr44.click(lambda: "44100", outputs=sample_rate_state)
+    sr48.click(lambda: "48000", outputs=sample_rate_state)
+    bd16.click(lambda: "16", outputs=bit_depth_state)
+    bd24.click(lambda: "24", outputs=bit_depth_state)
+
+    gen_btn.click(
+        generate_music_wrapper,
+        inputs=[
+            instrumental_prompt, cfg_scale, top_k, top_p, temperature, total_duration, bpm,
+            drum_beat, synthesizer, rhythmic_steps, bass_style, guitar_style,
+            target_volume, preset, max_steps, vram_box, bitrate_state, sample_rate_state, bit_depth_state
+        ],
+        outputs=[out_audio, status_box, vram_box]
+    )
+
+    def clear_inputs():
+        s = DEFAULT_SETTINGS.copy()
+        return (
+            s["instrumental_prompt"], s["cfg_scale"], s["top_k"], s["top_p"], s["temperature"],
+            s["total_duration"], s["bpm"], s["drum_beat"], s["synthesizer"], s["rhythmic_steps"],
+            s["bass_style"], s["guitar_style"], s["target_volume"], s["preset"], s["max_steps"],
+            s["bitrate"], s["output_sample_rate"], s["bit_depth"]
+        )
+    clr_btn.click(
+        clear_inputs,
+        outputs=[
+            instrumental_prompt, cfg_scale, top_k, top_p, temperature, total_duration, bpm,
+            drum_beat, synthesizer, rhythmic_steps, bass_style, guitar_style, target_volume,
+            preset, max_steps, bitrate_state, sample_rate_state, bit_depth_state
+        ]
+    )
+
+    def _save_action(ip, cs, tk, tp, tt, dur, bpm_v, d, s, rs, b, g, tv, pr, ms, br, sr, bd):
+        data = {
+            "instrumental_prompt": ip, "cfg_scale": float(cs), "top_k": int(tk), "top_p": float(tp),
+            "temperature": float(tt), "total_duration": int(dur), "bpm": int(bpm_v),
+            "drum_beat": str(d), "synthesizer": str(s), "rhythmic_steps": str(rs),
+            "bass_style": str(b), "guitar_style": str(g), "target_volume": float(tv),
+            "preset": str(pr), "max_steps": int(ms), "bitrate": str(br),
+            "output_sample_rate": str(sr), "bit_depth": str(bd)
+        }
+        save_settings(data)
+        for k, v in data.items(): SETTINGS[k] = v
+        return "✅ Settings saved."
+    save_btn.click(
+        _save_action,
+        inputs=[instrumental_prompt, cfg_scale, top_k, top_p, temperature, total_duration, bpm,
+                drum_beat, synthesizer, rhythmic_steps, bass_style, guitar_style, target_volume,
+                preset, max_steps, bitrate_state, sample_rate_state, bit_depth_state],
+        outputs=status_box
+    )
+
+    def _load_action():
+        s = load_settings()
+        for k, v in s.items(): SETTINGS[k] = v
+        return (
+            s["instrumental_prompt"], s["cfg_scale"], s["top_k"], s["top_p"], s["temperature"],
+            s["total_duration"], s["bpm"], s["drum_beat"], s["synthesizer"], s["rhythmic_steps"],
+            s["bass_style"], s["guitar_style"], s["target_volume"], s["preset"], s["max_steps"],
+            s["bitrate"], s["output_sample_rate"], s["bit_depth"],
+            "✅ Settings loaded."
+        )
+    load_btn.click(_load_action,
+        outputs=[instrumental_prompt, cfg_scale, top_k, top_p, temperature, total_duration, bpm,
+                 drum_beat, synthesizer, rhythmic_steps, bass_style, guitar_style, target_volume,
+                 preset, max_steps, bitrate_state, sample_rate_state, bit_depth_state, status_box]
+    )
+
+    def _reset_action():
+        s = DEFAULT_SETTINGS.copy()
+        save_settings(s)
+        for k, v in s.items(): SETTINGS[k] = v
+        return (
+            s["instrumental_prompt"], s["cfg_scale"], s["top_k"], s["top_p"], s["temperature"],
+            s["total_duration"], s["bpm"], s["drum_beat"], s["synthesizer"], s["rhythmic_steps"],
+            s["bass_style"], s["guitar_style"], s["target_volume"], s["preset"], s["max_steps"],
+            s["bitrate"], s["output_sample_rate"], s["bit_depth"], "✅ Defaults restored."
+        )
+    reset_btn.click(_reset_action,
+        outputs=[instrumental_prompt, cfg_scale, top_k, top_p, temperature, total_duration, bpm,
+                 drum_beat, synthesizer, rhythmic_steps, bass_style, guitar_style, target_volume,
+                 preset, max_steps, bitrate_state, sample_rate_state, bit_depth_state, status_box]
+    )
+
+    log_btn.click(get_latest_log, outputs=log_output)
+
+logger.info("Launching Gradio UI at http://0.0.0.0:9999 ...")
+try:
+    demo.launch(server_name="0.0.0.0", server_port=9999, share=False, inbrowser=False, show_error=True)
+except Exception as e:
+    logger.error(f"Gradio launch failed: {e}")
+    logger.error(traceback.format_exc())
+    sys.exit(1)

public/settings.json

@@ -0,0 +1,20 @@
+{
+  "instrumental_prompt": "Instrumental alternative rock by Red Hot Chili Peppers, energetic guitar riffs, funky slap bass, standard rock drums with funk fills, funk-rock energy at 126 BPM, dynamic intro and expressive verse.",
+  "cfg_scale": 5.8,
+  "top_k": 250,
+  "top_p": 0.95,
+  "temperature": 0.9,
+  "total_duration": 60,
+  "bpm": 120,
+  "drum_beat": "none",
+  "synthesizer": "none",
+  "rhythmic_steps": "none",
+  "bass_style": "deep bass",
+  "guitar_style": "jangle",
+  "target_volume": -23.0,
+  "preset": "default",
+  "max_steps": 1500,
+  "bitrate": "192k",
+  "output_sample_rate": "48000",
+  "bit_depth": "16"
+}

public/stablebeta.py

@@ -0,0 +1,1151 @@
+import os
+import torch
+import torchaudio
+import psutil
+import time
+import sys
+import numpy as np
+import gc
+import gradio as gr
+from pydub import AudioSegment
+import soundfile as sf
+import pyloudnorm as pyln
+from audiocraft.models import MusicGen
+from torch.amp import autocast
+import json
+import configparser
+import random
+import string
+import uvicorn
+from fastapi import FastAPI, HTTPException
+from fastapi.responses import FileResponse
+from pydantic import BaseModel
+import multiprocessing
+import re
+import datetime
+import warnings
+
+# ==============================
+# Warnings & Multiprocessing
+# ==============================
+warnings.filterwarnings("ignore", category=UserWarning)
+multiprocessing.set_start_method('spawn', force=True)
+
+# ==============================
+# CUDA / PyTorch Runtime Settings
+# ==============================
+os.environ["TORCH_NN_UTILS_LOG_LEVEL"] = "0"
+os.environ["CUDA_LAUNCH_BLOCKING"] = "1"
+os.environ["CUDA_MODULE_LOADING"] = "LAZY"
+os.environ["TORCH_USE_CUDA_DSA"] = "1"
+# Stronger allocator settings to reduce fragmentation and avoid small splits
+os.environ["PYTORCH_CUDA_ALLOC_CONF"] = "max_split_size_mb:128,garbage_collection_threshold:0.8,expandable_segments:True"
+# Support a range of architectures (Turing/Ampere/Ada)
+os.environ["TORCH_CUDA_ARCH_LIST"] = "7.5;8.0;8.6;8.9"
+
+# Prefer TF32 on Ampere+ (perf) — also helps allocator behavior
+try:
+    torch.backends.cuda.matmul.allow_tf32 = True
+    torch.backends.cudnn.benchmark = True
+except Exception:
+    pass
+
+# ==============================
+# Version / Device Checks
+# ==============================
+def _parse_version_triplet(s: str):
+    m = re.findall(r"\d+", s)
+    m = [int(x) for x in m[:3]]
+    while len(m) < 3:
+        m.append(0)
+    return tuple(m)
+
+if _parse_version_triplet(torch.__version__) < (2, 0, 0):
+    print(f"ERROR: PyTorch {torch.__version__} incompatible. Need >=2.0.0.")
+    sys.exit(1)
+
+device = "cuda" if torch.cuda.is_available() else "cpu"
+if device != "cuda":
+    print("ERROR: CUDA required. CPU disabled.")
+    sys.exit(1)
+
+cc_major, cc_minor = torch.cuda.get_device_capability(0)
+if cc_major < 7:
+    print(f"ERROR: GPU Compute Capability {torch.cuda.get_device_capability(0)} unsupported. Need >=7.0.")
+    sys.exit(1)
+
+gpu_name = torch.cuda.get_device_name(0)
+print(f"Using GPU: {gpu_name} (CUDA {torch.version.cuda}, Compute Capability {(cc_major, cc_minor)})")
+
+# Choose autocast dtype based on hardware support
+try:
+    bf16_supported = torch.cuda.is_bf16_supported()
+except Exception:
+    bf16_supported = False
+AUTOCAST_DTYPE = torch.bfloat16 if bf16_supported and cc_major >= 8 else torch.float16
+
+# ==============================
+# Resource Monitoring
+# ==============================
+def print_resource_usage(stage: str):
+    try:
+        alloc = torch.cuda.memory_allocated() / (1024 ** 3)
+        reserved = torch.cuda.memory_reserved() / (1024 ** 3)
+    except Exception:
+        alloc, reserved = 0.0, 0.0
+    print(f"--- {stage} ---")
+    print(f"GPU Memory: {alloc:.2f} GB allocated, {reserved:.2f} GB reserved")
+    print(f"CPU: {psutil.cpu_percent()}% | Memory: {psutil.virtual_memory().percent}%")
+    print("---------------")
+
+# ==============================
+# Output & Metadata
+# ==============================
+output_dir = "mp3"
+os.makedirs(output_dir, exist_ok=True)
+metadata_file = os.path.join(output_dir, "songs_metadata.json")
+api_status = "idle"
+
+# ==============================
+# Prompt Variables
+# ==============================
+prompt_variables = {
+    'style': [
+        'epic', 'gritty', 'smooth', 'lush', 'raw', 'intimate', 'driving', 'moody',
+        'psychedelic', 'uplifting', 'melancholic', 'aggressive', 'dreamy', 'retro',
+        'futuristic', 'energetic', 'brooding', 'euphoric', 'jazzy', 'cinematic',
+        'somber', 'triumphant', 'mystical', 'grunge', 'ethereal'
+    ],
+    'key': ['C major', 'D major', 'E minor', 'F minor', 'G major', 'A minor', 'B-flat major', 'G minor', 'D minor', 'F major'],
+    'bpm': [80, 90, 100, 110, 120, 124, 128, 130, 140, 150, 160, 170, 180],
+    'time_signature': ['4/4', '3/4', '6/8'],
+    'guitar_style': [
+        'raw distorted', 'melodic', 'fuzzy', 'crisp', 'jangly', 'clean', 'twangy',
+        'shimmering', 'grunge', 'bluesy', 'slide', 'wah-infused', 'chunky'
+    ],
+    'bass_style': [
+        'punchy', 'deep', 'groovy', 'melodic', 'throbbing', 'slappy', 'funky',
+        'walking', 'booming', 'resonant', 'subtle'
+    ],
+    'drum_style': [
+        'dynamic', 'minimal', 'hard-hitting', 'swinging', 'polyrhythmic', 'brushed',
+        'tight', 'loose', 'electronic', 'acoustic', 'retro', 'punchy'
+    ],
+    'drum_feature': [
+        'heavy snare', 'crisp cymbals', 'tight kicks', 'syncopated hits', 'rolling toms',
+        'ghost notes', 'blast beats'
+    ],
+    'organ_style': [
+        'subtle Hammond', 'swirling', 'warm Leslie', 'church', 'gritty', 'vintage',
+        'moody'
+    ],
+    'synth_style': [
+        'atmospheric', 'bright', 'eerie', 'soaring', 'chopped', 'arpeggiated',
+        'pulsing', 'glitchy', 'analog', 'digital', 'layered'
+    ],
+    'vocal_style': [
+        'chopped', 'soulful', 'haunting', 'melodic', 'harmonized', 'layered',
+        'ethereal', 'gruff', 'breathy'
+    ],
+    'hihat_style': [
+        'crisp', 'swinging', 'rapid', 'shuffling', 'open', 'tight', 'stuttered'
+    ],
+    'pad_style': [
+        'evolving', 'ambient', 'lush', 'dark', 'shimmering', 'warm', 'icy'
+    ],
+    'kick_style': [
+        'deep', 'four-on-the-floor', 'subtle', 'punchy', 'booming', 'clicky'
+    ],
+    'lead_style': [
+        'fluid', 'intricate', 'soaring', 'expressive', 'virtuosic', 'minimalist',
+        'bluesy', 'lyrical'
+    ],
+    'lead_instrument': [
+        'saxophone', 'trumpet', 'guitar', 'flute', 'violin', 'clarinet', 'trombone'
+    ],
+    'piano_style': [
+        'expressive Rhodes', 'rapid', 'smooth', 'dramatic', 'stride', 'ambient',
+        'classical', 'jazzy', 'sparse'
+    ],
+    'keyboard_style': [
+        'ornate', 'delicate', 'virtuosic', 'minimal', 'retro', 'spacey'
+    ],
+    'string_style': [
+        'sweeping', 'delicate', 'dramatic', 'lush', 'pizzicato', 'staccato',
+        'sustained'
+    ],
+    'brass_style': [
+        'bold', 'heroic', 'muted', 'fanfare', 'jazzy', 'smooth'
+    ],
+    'woodwind_style': [
+        'subtle', 'fluttering', 'melodic', 'airy', 'reedy', 'expressive'
+    ],
+    'flute_style': [
+        'fluttering', 'ornate', 'airy', 'breathy', 'trilling'
+    ],
+    'horn_style': [
+        'heroic', 'bold', 'soaring', 'mellow', 'stinging'
+    ],
+    'choir_style': [
+        'mystical', 'ethereal', 'dramatic', 'angelic', 'epic', 'somber'
+    ],
+    'sample_style': [
+        'jazzy', 'soulful', 'gritty', 'cinematic', 'vinyl', 'lo-fi', 'retro'
+    ],
+    'scratch_style': [
+        'crackling vinyl', 'sharp', 'rhythmic', 'chopped', 'transform'
+    ],
+    'snare_style': [
+        'crisp', 'booming', 'tight', 'snappy', 'rimshot', 'layered'
+    ],
+    'breakdown_style': [
+        'euphoric', 'stripped-down', 'intense', 'ambient', 'glitchy', 'dramatic'
+    ],
+    'intro_bars': [4, 8, 16],
+    'verse_bars': [8, 16, 32],
+    'chorus_bars': [8, 16],
+    'bridge_bars': [4, 8, 16],
+    'outro_bars': [8, 16],
+    'build_bars': [8, 16, 32],
+    'drop_bars': [16, 32],
+    'main_bars': [16, 32],
+    'breakdown_bars': [8, 16],
+    'head_bars': [16, 32],
+    'solo_bars': [8, 16, 32],
+    'fugue_bars': [16, 32],
+    'coda_bars': [8, 16],
+    'theme_bars': [16, 32],
+    'development_bars': [16, 32],
+    'climax_bars': [8, 16],
+    'groove_bars': [16, 32],
+    'vibe': [
+        'raw', 'energetic', 'melancholic', 'hypnotic', 'soulful', 'intimate',
+        'virtuosic', 'elegant', 'cinematic', 'gritty', 'nostalgic', 'dark',
+        'uplifting', 'bittersweet', 'heroic', 'dreamy', 'aggressive', 'relaxed',
+        'futuristic', 'retro', 'mystical', 'triumphant'
+    ],
+    'production_style': [
+        'lo-fi', 'warm analog', 'clean digital', 'lush', 'crisp acoustic',
+        'polished pop', 'grand orchestral', 'grunge', 'minimalist', 'industrial',
+        'vintage'
+    ]
+}
+
+# ==============================
+# Default INI Creation
+# ==============================
+def create_default_genre_prompts_ini(ini_path):
+    default_config = configparser.ConfigParser()
+    default_config['Prompts'] = {
+        'nirvana': '{style} grunge with {guitar_style} guitar, {bass_style} bass, {drum_style} drums, {vibe} vibe in {key} at {bpm} BPM',
+        'classic_rock': '{style} classic rock with {guitar_style} guitar, {bass_style} bass, {drum_style} drums, {vibe} vibe in {key} at {bpm} BPM',
+        'detroit_techno': '{style} techno with {synth_style} synths, {kick_style} kick, {hihat_style} hi-hats, {vibe} vibe at {bpm} BPM',
+        'smooth_jazz': '{style} jazz with {piano_style} piano, {bass_style} bass, {drum_style} drums, {vibe} vibe in {key} at {bpm} BPM',
+        'alternative_rock': '{style} alternative rock with {guitar_style} guitar, {bass_style} bass, {drum_style} drums in {key} at {bpm} BPM',
+        'deep_house': '{style} deep house with {synth_style} synths, {kick_style} kick, {vibe} vibe at {bpm} BPM',
+        'bebop_jazz': '{style} bebop jazz with {piano_style} piano, {bass_style} bass, {drum_style} drums in {key} at {bpm} BPM',
+        'baroque_classical': '{style} baroque classical with {string_style} strings, {keyboard_style} harpsichord in {key} at {bpm} BPM',
+        'romantic_classical': '{style} romantic classical with {string_style} strings, {piano_style} piano in {key} at {bpm} BPM',
+        'boom_bap_hiphop': '{style} boom bap hip-hop with {sample_style} samples, {drum_style} drums, {scratch_style} scratches at {bpm} BPM',
+        'trap_hiphop': '{style} trap hip-hop with {synth_style} synths, {kick_style} kick, {snare_style} snare at {bpm} BPM',
+        'pop_rock': '{style} pop rock with {guitar_style} guitar, {bass_style} bass, {drum_style} drums in {key} at {bpm} BPM',
+        'fusion_jazz': '{style} fusion jazz with {piano_style} piano, {guitar_style} guitar, {drum_style} drums in {key} at {bpm} BPM',
+        'edm': '{style} EDM with {synth_style} synths, {kick_style} kick, {vibe} vibe at {bpm} BPM',
+        'indie_folk': '{style} indie folk with {guitar_style} guitar, {vocal_style} vocals, {drum_style} drums in {key} at {bpm} BPM',
+        'star_wars': '{style} epic orchestral with {brass_style} brass, {string_style} strings, {vibe} vibe in {key} at {bpm} BPM',
+        'star_wars_classical': '{style} classical orchestral with {string_style} strings, {horn_style} horns in {key} at {bpm} BPM',
+        'wutang': '{style} hip-hop with {sample_style} samples, {drum_style} drums, {scratch_style} scratches at {bpm} BPM',
+        'milesdavis': '{style} jazz with {lead_instrument} lead, {piano_style} piano, {bass_style} bass in {key} at {bpm} BPM'
+    }
+    default_config['BandNames'] = {
+        'nirvana': 'Nirvana, Soundgarden',
+        'classic_rock': 'Led Zeppelin, The Rolling Stones',
+        'detroit_techno': 'Underground Resistance, Jeff Mills',
+        'smooth_jazz': 'Pat Metheny, George Benson',
+        'alternative_rock': 'Radiohead, Smashing Pumpkins',
+        'deep_house': 'Moodymann, Theo Parrish',
+        'bebop_jazz': 'Charlie Parker, Dizzy Gillespie',
+        'baroque_classical': 'Bach, Vivaldi',
+        'romantic_classical': 'Chopin, Liszt',
+        'boom_bap_hiphop': 'A Tribe Called Quest, Pete Rock',
+        'trap_hiphop': 'Future, Metro Boomin',
+        'pop_rock': 'Coldplay, The Killers',
+        'fusion_jazz': 'Weather Report, Herbie Hancock',
+        'edm': 'Deadmau5, Skrillex',
+        'indie_folk': 'Fleet Foxes, Bon Iver',
+        'star_wars': 'John Williams',
+        'star_wars_classical': 'John Williams',
+        'wutang': 'Wu-Tang Clan',
+        'milesdavis': 'Miles Davis'
+    }
+    with open(ini_path, 'w') as f:
+        default_config.write(f)
+    print(f"Created default {ini_path}")
+
+# ==============================
+# CSS Load
+# ==============================
+css_path = "style.css"
+try:
+    if not os.path.exists(css_path):
+        print(f"ERROR: {css_path} not found. Please create style.css with the required CSS content.")
+        sys.exit(1)
+    with open(css_path, 'r') as f:
+        css = f.read()
+except Exception as e:
+    print(f"ERROR: Failed to read {css_path}: {e}. Please ensure style.css exists and is readable.")
+    sys.exit(1)
+
+# ==============================
+# INI Load
+# ==============================
+config = configparser.ConfigParser()
+ini_path = "genre_prompts.ini"
+try:
+    if not os.path.exists(ini_path):
+        print(f"WARNING: {ini_path} not found. Creating default INI file.")
+        create_default_genre_prompts_ini(ini_path)
+    config.read(ini_path)
+    if 'Prompts' not in config.sections() or 'BandNames' not in config.sections():
+        print(f"WARNING: Invalid {ini_path}. Creating default INI file.")
+        create_default_genre_prompts_ini(ini_path)
+        config.read(ini_path)
+except Exception as e:
+    print(f"ERROR: Failed to read {ini_path}: {e}. Creating default INI file.")
+    create_default_genre_prompts_ini(ini_path)
+    config.read(ini_path)
+
+# ==============================
+# Model Load with Fallback
+# ==============================
+def load_musicgen_with_fallback():
+    model_paths = [
+        os.getenv("MUSICGEN_MODEL_PATH_LARGE", "/home/ubuntu/musicpack/models/musicgen-large"),
+        os.getenv("MUSICGEN_MODEL_PATH_MEDIUM", "/home/ubuntu/musicpack/models/musicgen-medium"),
+        os.getenv("MUSICGEN_MODEL_PATH_SMALL", "/home/ubuntu/musicpack/models/musicgen-small"),
+    ]
+    model_names = ["large", "medium", "small"]
+
+    last_error = None
+    for path, name in zip(model_paths, model_names):
+        if not path:
+            continue
+        if not os.path.exists(path):
+            print(f"NOTE: Model path not found: {path} (skipping {name})")
+            continue
+        try:
+            print(f"Loading MusicGen {name} model from {path} ...")
+            torch.cuda.empty_cache()
+            gc.collect()
+            with autocast('cuda', dtype=AUTOCAST_DTYPE):
+                mdl = MusicGen.get_pretrained(path, device=device)
+            print(f"Loaded MusicGen {name}. Sample rate: {mdl.sample_rate}Hz")
+            return mdl, name
+        except RuntimeError as e:
+            last_error = e
+            print(f"WARNING: Failed to load {name} model due to: {e}")
+            torch.cuda.empty_cache()
+            gc.collect()
+            continue
+        except Exception as e:
+            last_error = e
+            print(f"WARNING: Failed to load {name} model due to: {e}")
+            torch.cuda.empty_cache()
+            gc.collect()
+            continue
+    if last_error:
+        print(f"ERROR: All model loads failed. Last error: {last_error}")
+    raise SystemExit(1)
+
+try:
+    musicgen_model, loaded_model_name = load_musicgen_with_fallback()
+    # Conservative defaults; can be overridden per-call
+    musicgen_model.set_generation_params(
+        duration=10,
+        use_sampling=True,
+        top_k=50,
+        top_p=0.0,
+        temperature=0.8,
+        cfg_coef=3.0,
+        two_step_cfg=False
+    )
+    sample_rate = musicgen_model.sample_rate
+    print(f"Model active: {loaded_model_name}. Sample rate: {sample_rate}Hz")
+except SystemExit:
+    sys.exit(1)
+
+# ==============================
+# Audio Processing Helpers
+# ==============================
+def apply_eq(segment):
+    segment = segment.high_pass_filter(60)
+    segment = segment.low_pass_filter(12000)
+    segment = segment - 2.0
+    return segment
+
+def apply_limiter(segment, max_db=-6.0, target_lufs=-16.0):
+    samples = np.array(segment.get_array_of_samples(), dtype=np.float32) / (2**15)
+    if segment.channels == 2:
+        samples = samples.reshape(-1, 2)
+    meter = pyln.Meter(segment.frame_rate)
+    loudness = meter.integrated_loudness(samples)
+    normalized_samples = pyln.normalize.loudness(samples, loudness, target_lufs)
+    if np.max(np.abs(normalized_samples)) > (10 ** (max_db / 20)):
+        normalized_samples *= (10 ** (max_db / 20)) / np.max(np.abs(normalized_samples))
+    normalized_samples = (normalized_samples * (2**15)).astype(np.int16)
+    segment = AudioSegment(
+        normalized_samples.tobytes(),
+        frame_rate=segment.frame_rate,
+        sample_width=2,
+        channels=segment.channels
+    )
+    del samples, normalized_samples
+    gc.collect()
+    return segment
+
+def apply_fade(segment, fade_in_duration=1000, fade_out_duration=1000):
+    segment = segment.fade_in(fade_in_duration)
+    segment = segment.fade_out(fade_out_duration)
+    return segment
+
+# ==============================
+# Names & Metadata
+# ==============================
+made_up_names = [
+    'blazepulse', 'shadowrift', 'neonquest', 'thunderclash', 'stargroove',
+    'mysticvibe', 'ironspark', 'ghostsurge', 'velvetstorm', 'crimsonrush',
+    'duskblitz', 'solarflame', 'nightdrift', 'frostsaga', 'emberwave',
+    'coolriff', 'wildpulse', 'echoslash', 'moontide', 'skydive'
+]
+
+def extract_song_keyword(prompt):
+    if not prompt:
+        return random.choice(made_up_names)
+    words = re.findall(r'\b\w+\b', prompt.lower())
+    for word in words:
+        if len(word) <= 15 and word.isalnum():
+            return word
+    return random.choice(made_up_names)
+
+def generate_unique_title(existing_titles, genre, song_keyword, style):
+    letters = string.ascii_uppercase
+    numbers = string.digits
+    max_attempts = 100
+    attempt = 0
+    while attempt < max_attempts:
+        title_base = f"{random.choice(letters)}{random.choice(numbers)}"
+        band_names = config['BandNames'].get(genre, "nirvana").split(',')
+        band_name = random.choice([name.strip() for name in band_names])
+        existing_count = sum(1 for t in existing_titles if t.startswith(title_base) and song_keyword in t and style in t and band_name in t)
+        if existing_count == 0:
+            return title_base, band_name
+        suffix = f"{random.choice(letters)}{random.choice(numbers)}".lower()
+        title_base = f"{title_base}_{suffix}"
+        attempt += 1
+    raise ValueError("Failed to generate unique title after maximum attempts")
+
+def update_metadata_storage(metadata):
+    try:
+        songs_metadata = []
+        if os.path.exists(metadata_file):
+            with open(metadata_file, 'r') as f:
+                songs_metadata = json.load(f)
+        songs_metadata.append({
+            "title": metadata["title"],
+            "filename": metadata["filename"],
+            "prompt": metadata.get("prompt", ""),
+            "duration": metadata.get("duration", 30),
+            "volume_db": metadata.get("volume_db", -24.0),
+            "target_lufs": metadata.get("target_lufs", -16.0),
+            "timestamp": metadata.get("timestamp", datetime.datetime.now().strftime("%Y%m%d_%H%M%S")),
+            "file_path": metadata.get("file_path", ""),
+            "sample_rate": metadata.get("sample_rate", musicgen_model.sample_rate),
+            "style": metadata.get("style", ""),
+            "band_name": metadata.get("band_name", ""),
+            "chunk_index": metadata.get("chunk_index", 0)
+        })
+        with open(metadata_file, 'w') as f:
+            json.dump(songs_metadata, f, indent=4)
+    except Exception as e:
+        print(f"ERROR: Failed to update metadata storage: {e}")
+
+def load_renders():
+    if not os.path.exists(metadata_file):
+        return [], "No renders found."
+    try:
+        with open(metadata_file, 'r') as f:
+            songs_metadata = json.load(f)
+        renders = [
+            {
+                "Title": entry["title"],
+                "Filename": entry["filename"],
+                "Prompt": entry["prompt"],
+                "Duration (s)": entry["duration"],
+                "Timestamp": entry["timestamp"],
+                "Audio": entry["file_path"],
+                "Download": f'<a href="/get-song/{entry["filename"]}" download><button class="download-btn" aria-label="Download {entry["title"]}">⬇️</button></a>',
+                "Chunk": entry["chunk_index"]
+            }
+            for entry in songs_metadata
+        ]
+        return renders, "Renders loaded successfully."
+    except Exception as e:
+        return [], f"Error loading renders: {e}"
+
+# ==============================
+# Prompt Builder
+# ==============================
+def get_genre_prompt(genre):
+    base_prompt = config['Prompts'].get(genre, "")
+    if not base_prompt:
+        base_prompt = "{style} grunge with {guitar_style} guitar, {bass_style} bass, {drum_style} drums, {vibe} vibe in {key} at {bpm} BPM"
+    prompt_dict = {
+        'style': random.choice(prompt_variables['style']),
+        'key': random.choice(prompt_variables['key']),
+        'bpm': random.choice(prompt_variables['bpm']),
+        'time_signature': random.choice(prompt_variables['time_signature']),
+        'guitar_style': random.choice(prompt_variables['guitar_style']),
+        'bass_style': random.choice(prompt_variables['bass_style']),
+        'drum_style': random.choice(prompt_variables['drum_style']),
+        'drum_feature': random.choice(prompt_variables['drum_feature']),
+        'organ_style': random.choice(prompt_variables['organ_style']),
+        'synth_style': random.choice(prompt_variables['synth_style']),
+        'vocal_style': random.choice(prompt_variables['vocal_style']),
+        'hihat_style': random.choice(prompt_variables['hihat_style']),
+        'pad_style': random.choice(prompt_variables['pad_style']),
+        'kick_style': random.choice(prompt_variables['kick_style']),
+        'lead_style': random.choice(prompt_variables['lead_style']),
+        'lead_instrument': random.choice(prompt_variables['lead_instrument']),
+        'piano_style': random.choice(prompt_variables['piano_style']),
+        'keyboard_style': random.choice(prompt_variables['keyboard_style']),
+        'string_style': random.choice(prompt_variables['string_style']),
+        'brass_style': random.choice(prompt_variables['brass_style']),
+        'woodwind_style': random.choice(prompt_variables['woodwind_style']),
+        'flute_style': random.choice(prompt_variables['flute_style']),
+        'horn_style': random.choice(prompt_variables['horn_style']),
+        'choir_style': random.choice(prompt_variables['choir_style']),
+        'sample_style': random.choice(prompt_variables['sample_style']),
+        'scratch_style': random.choice(prompt_variables['scratch_style']),
+        'snare_style': random.choice(prompt_variables['snare_style']),
+        'breakdown_style': random.choice(prompt_variables['breakdown_style']),
+        'intro_bars': random.choice(prompt_variables['intro_bars']),
+        'verse_bars': random.choice(prompt_variables['verse_bars']),
+        'chorus_bars': random.choice(prompt_variables['chorus_bars']),
+        'bridge_bars': random.choice(prompt_variables['bridge_bars']),
+        'outro_bars': random.choice(prompt_variables['outro_bars']),
+        'build_bars': random.choice(prompt_variables['build_bars']),
+        'drop_bars': random.choice(prompt_variables['drop_bars']),
+        'main_bars': random.choice(prompt_variables['main_bars']),
+        'breakdown_bars': random.choice(prompt_variables['breakdown_bars']),
+        'head_bars': random.choice(prompt_variables['head_bars']),
+        'solo_bars': random.choice(prompt_variables['solo_bars']),
+        'fugue_bars': random.choice(prompt_variables['fugue_bars']),
+        'coda_bars': random.choice(prompt_variables['coda_bars']),
+        'theme_bars': random.choice(prompt_variables['theme_bars']),
+        'development_bars': random.choice(prompt_variables['development_bars']),
+        'climax_bars': random.choice(prompt_variables['climax_bars']),
+        'groove_bars': random.choice(prompt_variables['groove_bars']),
+        'vibe': random.choice(prompt_variables['vibe']),
+        'production_style': random.choice(prompt_variables['production_style'])
+    }
+    try:
+        formatted_prompt = base_prompt.format(**prompt_dict)
+        words = re.findall(r'\b\w+\b', formatted_prompt.lower())
+        val_list = []
+        for k, v in prompt_variables.items():
+            if isinstance(v, list):
+                val_list.extend(v)
+        if not any(word in val_list for word in words):
+            formatted_prompt = f"{prompt_dict['style']} music with {prompt_dict['guitar_style']} guitar, {prompt_dict['bass_style']} bass, {prompt_dict['drum_style']} drums in {prompt_dict['key']} at {prompt_dict['bpm']} BPM"
+    except KeyError:
+        formatted_prompt = f"{prompt_dict['style']} music with {prompt_dict['guitar_style']} guitar, {prompt_dict['bass_style']} bass, {prompt_dict['drum_style']} drums in {prompt_dict['key']} at {prompt_dict['bpm']} BPM"
+    return formatted_prompt, prompt_dict['style']
+
+# ==============================
+# Adaptive Chunk Generation (OOM-safe)
+# ==============================
+def generate_chunk_oom_safe(model, text_prompt, continuation_prompt, cfg_scale, top_k, top_p, temperature, target_duration):
+    durations_to_try = [target_duration, 20, 15, 12, 10, 8, 6, 4, 3, 2]
+    for dur in durations_to_try:
+        try:
+            torch.cuda.synchronize()
+            torch.cuda.empty_cache()
+            model.set_generation_params(
+                duration=dur,
+                use_sampling=True,
+                top_k=int(top_k),
+                top_p=float(top_p),
+                temperature=float(temperature),
+                cfg_coef=float(cfg_scale),
+                two_step_cfg=False
+            )
+            with torch.no_grad():
+                with autocast('cuda', dtype=AUTOCAST_DTYPE):
+                    if continuation_prompt is None:
+                        # progress=False lowers overhead
+                        audio_chunk = model.generate([text_prompt], progress=False)[0]
+                    else:
+                        audio_chunk = model.generate_continuation(
+                            continuation_prompt, model.sample_rate, [text_prompt], progress=False
+                        )[0]
+            return audio_chunk, dur
+        except RuntimeError as e:
+            msg = str(e).lower()
+            if "out of memory" in msg or "cuda error" in msg:
+                print(f"OOM at duration {dur}s — retrying with smaller chunk...")
+                torch.cuda.empty_cache()
+                gc.collect()
+                continue
+            else:
+                raise
+    raise RuntimeError("Failed to generate audio chunk without CUDA OOM.")
+
+# ==============================
+# Generation
+# ==============================
+def generate_music(instrumental_prompt: str, cfg_scale: float, top_k: int, top_p: float, temperature: float, total_duration: int, volume_db: float, genre: str = None):
+    global musicgen_model
+    global api_status
+    api_status = "rendering"
+
+    if not instrumental_prompt.strip() and not genre:
+        instrumental_prompt, style = get_genre_prompt("nirvana")
+    elif not instrumental_prompt.strip():
+        instrumental_prompt, style = get_genre_prompt(genre)
+    else:
+        words = re.findall(r'\b\w+\b', instrumental_prompt.lower())
+        val_list = []
+        for k, v in prompt_variables.items():
+            if isinstance(v, list):
+                val_list.extend(v)
+        if not any(word in val_list for word in words):
+            instrumental_prompt, style = get_genre_prompt("nirvana")
+        else:
+            ek = extract_song_keyword(instrumental_prompt)
+            style = ek if ek in prompt_variables['style'] else random.choice(prompt_variables['style'])
+    
+    try:
+        start_time = time.time()
+        base_chunk_target = 30  # target; adaptive OOM-safe will shrink if needed
+        total_duration = max(total_duration, 30)
+        remaining = total_duration
+        audio_chunks = []
+        chunk_paths = []
+        continuation_prompt = None
+        chunk_index = 0
+
+        # Titles
+        existing_titles = []
+        if os.path.exists(metadata_file):
+            with open(metadata_file, 'r') as f:
+                songs_metadata = json.load(f)
+                existing_titles = [entry["title"] for entry in songs_metadata]
+        song_keyword = extract_song_keyword(instrumental_prompt)
+        title_base, band_name = generate_unique_title(existing_titles, genre if genre else "nirvana", song_keyword, style)
+
+        # Loop until we render total_duration seconds with adaptive chunks
+        while remaining > 0:
+            target = min(base_chunk_target, remaining)
+            print_resource_usage(f"Before Chunk {chunk_index + 1}")
+            try:
+                audio_chunk, actual_dur = generate_chunk_oom_safe(
+                    musicgen_model, instrumental_prompt, continuation_prompt, cfg_scale, top_k, top_p, temperature, target
+                )
+                audio_chunk = audio_chunk.cpu().to(dtype=torch.float32)
+                if audio_chunk.dim() == 1:
+                    audio_chunk = torch.stack([audio_chunk, audio_chunk], dim=0)
+                elif audio_chunk.dim() == 2 and audio_chunk.shape[0] == 1:
+                    audio_chunk = torch.cat([audio_chunk, audio_chunk], dim=0)
+                elif audio_chunk.dim() == 2 and audio_chunk.shape[0] != 2:
+                    audio_chunk = audio_chunk[:1, :]
+                    audio_chunk = torch.cat([audio_chunk, audio_chunk], dim=0)
+                elif audio_chunk.dim() > 2:
+                    audio_chunk = audio_chunk.view(2, -1)
+                if audio_chunk.shape[0] != 2:
+                    raise ValueError(f"Expected stereo audio with shape (2, samples), got {audio_chunk.shape}")
+
+                # Update continuation prompt (use up to last 2 seconds if available)
+                samples_per_second = musicgen_model.sample_rate
+                tail_sec = 2
+                tail_samples = min(int(tail_sec * samples_per_second), audio_chunk.shape[1] - 1 if audio_chunk.shape[1] > 1 else 1)
+                if tail_samples > 0:
+                    continuation_prompt = audio_chunk[:, -tail_samples:].cpu()
+                else:
+                    continuation_prompt = None
+
+                # Save to temp wav and convert
+                temp_wav_path = os.path.join(output_dir, f"temp_{random.randint(100, 999)}_{chunk_index}.wav")
+                try:
+                    torchaudio.save(temp_wav_path, audio_chunk, musicgen_model.sample_rate, bits_per_sample=16)
+                    final_segment = AudioSegment.from_wav(temp_wav_path)
+                finally:
+                    if os.path.exists(temp_wav_path):
+                        os.remove(temp_wav_path)
+                del audio_chunk
+                gc.collect()
+
+                # Post FX
+                print(f"Post-processing chunk {chunk_index + 1} (duration ~{actual_dur}s)...")
+                final_segment = apply_eq(final_segment)
+                final_segment = apply_limiter(final_segment, max_db=volume_db, target_lufs=-16.0)
+                if chunk_index == 0:
+                    final_segment = final_segment.fade_in(1000)
+                # if last chunk, fade out will be added after loop when combining; also safe to fade here if remaining-actual_dur==0
+                if remaining - actual_dur <= 0:
+                    final_segment = final_segment.fade_out(1000)
+
+                # Export
+                mp3_filename = f"{title_base.lower()}_{song_keyword}_{style}_{band_name}_chunk{chunk_index + 1}.mp3"
+                mp3_path = os.path.join(output_dir, mp3_filename)
+                final_segment.export(
+                    mp3_path,
+                    format="mp3",
+                    bitrate="64k",
+                    tags={"title": f"{title_base}_Chunk{chunk_index + 1}", "artist": "GhostAI"}
+                )
+                print(f"Saved chunk {chunk_index + 1} to {mp3_path}")
+                audio_chunks.append(final_segment)
+                chunk_paths.append(mp3_path)
+
+                # Metadata
+                metadata = {
+                    "title": f"{title_base}_Chunk{chunk_index + 1}",
+                    "filename": mp3_filename,
+                    "prompt": instrumental_prompt,
+                    "duration": actual_dur,
+                    "volume_db": volume_db,
+                    "target_lufs": -16.0,
+                    "timestamp": datetime.datetime.now().strftime("%Y%m%d_%H%M%S"),
+                    "file_path": mp3_path,
+                    "sample_rate": musicgen_model.sample_rate,
+                    "style": style,
+                    "band_name": band_name,
+                    "chunk_index": chunk_index + 1
+                }
+                update_metadata_storage(metadata)
+
+                chunk_index += 1
+                remaining -= actual_dur
+                torch.cuda.empty_cache()
+                gc.collect()
+                print_resource_usage(f"After Chunk {chunk_index}")
+            except Exception as e:
+                print(f"ERROR: Failed to process chunk {chunk_index + 1}: {e}")
+                api_status = "idle"
+                raise
+
+        # Combine chunks if more than one
+        if len(audio_chunks) > 1:
+            combined_segment = audio_chunks[0]
+            for segment in audio_chunks[1:]:
+                combined_segment = combined_segment.append(segment, crossfade=500)
+            combined_mp3_filename = f"{title_base.lower()}_{song_keyword}_{style}_{band_name}_combined.mp3"
+            combined_mp3_path = os.path.join(output_dir, combined_mp3_filename)
+            combined_segment.export(
+                combined_mp3_path,
+                format="mp3",
+                bitrate="64k",
+                tags={"title": title_base, "artist": "GhostAI"}
+            )
+            print(f"Saved combined audio to {combined_mp3_path}")
+            metadata = {
+                "title": title_base,
+                "filename": combined_mp3_filename,
+                "prompt": instrumental_prompt,
+                "duration": total_duration,
+                "volume_db": volume_db,
+                "target_lufs": -16.0,
+                "timestamp": datetime.datetime.now().strftime("%Y%m%d_%H%M%S"),
+                "file_path": combined_mp3_path,
+                "sample_rate": musicgen_model.sample_rate,
+                "style": style,
+                "band_name": band_name,
+                "chunk_index": 0
+            }
+            update_metadata_storage(metadata)
+            del combined_segment, audio_chunks
+            gc.collect()
+            api_status = "idle"
+            return combined_mp3_path, "✅ Done!", False, gr.update(value=load_renders()[0])
+        else:
+            # Single chunk only
+            print(f"Saved metadata to {metadata_file}")
+            del audio_chunks
+            gc.collect()
+            api_status = "idle"
+            return chunk_paths[0], "✅ Done!", False, gr.update(value=load_renders()[0])
+
+    except Exception as e:
+        print(f"❌ Failed: {e}")
+        api_status = "idle"
+        return None, f"❌ Failed: {e}", False, gr.update(value=load_renders()[0])
+    finally:
+        torch.cuda.synchronize()
+        torch.cuda.empty_cache()
+        gc.collect()
+
+def clear_inputs():
+    return "", 3.0, 50, 0.0, 0.8, 30, -24.0, False
+
+def show_render_wheel():
+    return True
+
+def set_genre_prompt(genre: str):
+    prompt, _ = get_genre_prompt(genre)
+    return prompt
+
+# ==============================
+# Gradio UI
+# ==============================
+with gr.Blocks(css=css) as demo:
+    gr.Markdown("""
+        <div class="header-container" role="banner" aria-label="GhostAI Music Generator">
+            <h1>GhostAI Music Generator</h1>
+            <p>Create Professional Instrumental Tracks</p>
+        </div>
+    """)
+    with gr.Tabs():
+        with gr.Tab("Generate", id="generate"):
+            with gr.Column(elem_classes="input-container"):
+                gr.Markdown("### Instrumental Prompt")
+                instrumental_prompt = gr.Textbox(
+                    label="Instrumental Prompt",
+                    placeholder="Select a genre or enter a custom prompt (e.g., 'coolriff grunge')",
+                    lines=4,
+                    elem_classes="textbox"
+                )
+                with gr.Row(elem_classes="genre-buttons"):
+                    classic_rock_btn = gr.Button("Classic Rock", elem_classes="genre-btn")
+                    alternative_rock_btn = gr.Button("Alternative Rock", elem_classes="genre-btn")
+                    detroit_techno_btn = gr.Button("Detroit Techno", elem_classes="genre-btn")
+                    deep_house_btn = gr.Button("Deep House", elem_classes="genre-btn")
+                    smooth_jazz_btn = gr.Button("Smooth Jazz", elem_classes="genre-btn")
+                    bebop_jazz_btn = gr.Button("Bebop Jazz", elem_classes="genre-btn")
+                    baroque_classical_btn = gr.Button("Baroque Classical", elem_classes="genre-btn")
+                    romantic_classical_btn = gr.Button("Romantic Classical", elem_classes="genre-btn")
+                    boom_bap_hiphop_btn = gr.Button("Boom Bap Hip-Hop", elem_classes="genre-btn")
+                    trap_hiphop_btn = gr.Button("Trap Hip-Hop", elem_classes="genre-btn")
+                    pop_rock_btn = gr.Button("Pop Rock", elem_classes="genre-btn")
+                    fusion_jazz_btn = gr.Button("Fusion Jazz", elem_classes="genre-btn")
+                    edm_btn = gr.Button("EDM", elem_classes="genre-btn")
+                    indie_folk_btn = gr.Button("Indie Folk", elem_classes="genre-btn")
+                    star_wars_btn = gr.Button("Star Wars Epic", elem_classes="genre-btn")
+                    star_wars_classical_btn = gr.Button("Star Wars Classical", elem_classes="genre-btn")
+                    nirvana_btn = gr.Button("Nirvana", elem_classes="genre-btn")
+                    wutang_btn = gr.Button("Wu-Tang", elem_classes="genre-btn")
+                    milesdavis_btn = gr.Button("Miles Davis", elem_classes="genre-btn")
+            with gr.Column(elem_classes="settings-container"):
+                gr.Markdown("### Generation Settings")
+                cfg_scale = gr.Slider(
+                    label="Guidance Scale (CFG)",
+                    minimum=1.0,
+                    maximum=10.0,
+                    value=3.0,
+                    step=0.1
+                )
+                top_k = gr.Slider(
+                    label="Top-K Sampling",
+                    minimum=10,
+                    maximum=500,
+                    value=50,
+                    step=10
+                )
+                top_p = gr.Slider(
+                    label="Top-P Sampling",
+                    minimum=0.0,
+                    maximum=1.0,
+                    value=0.0,
+                    step=0.1
+                )
+                temperature = gr.Slider(
+                    label="Temperature",
+                    minimum=0.1,
+                    maximum=2.0,
+                    value=0.8,
+                    step=0.1
+                )
+                total_duration = gr.Slider(
+                    label="Duration (seconds)",
+                    minimum=30,
+                    maximum=300,
+                    value=30,
+                    step=10
+                )
+                volume_db = gr.Slider(
+                    label="Output Volume (dBFS)",
+                    minimum=-30.0,
+                    maximum=0.0,
+                    value=-24.0,
+                    step=0.1
+                )
+                with gr.Row(elem_classes="action-buttons"):
+                    gen_btn = gr.Button("Generate Music")
+                    clr_btn = gr.Button("Clear Inputs")
+            with gr.Column(elem_classes="output-container"):
+                gr.Markdown("### Output")
+                render_wheel = gr.HTML('<div class="render-wheel" aria-live="polite">Generating...</div>', label="Rendering Status")
+                render_state = gr.State(value=False)
+                out_audio = gr.Audio(label="Generated Track", type="filepath", interactive=True, elem_classes="audio-container")
+                status = gr.Textbox(label="Status", interactive=False)
+        with gr.Tab("Renders", id="renders"):
+            with gr.Column(elem_classes="renders-container"):
+                gr.Markdown("### Browse Renders")
+                renders_table = gr.DataFrame(
+                    headers=["Title", "Filename", "Prompt", "Duration (s)", "Timestamp", "Audio", "Download", "Chunk"],
+                    datatype=["str", "str", "str", "number", "str", "audio", "html", "number"],
+                    interactive=False,
+                    value=load_renders()[0],
+                    elem_classes="renders-table"
+                )
+                renders_status = gr.Textbox(label="Renders Status", interactive=False, value=load_renders()[1])
+
+    # Button bindings
+    classic_rock_btn.click(set_genre_prompt, inputs=[gr.State(value="classic_rock")], outputs=[instrumental_prompt])
+    alternative_rock_btn.click(set_genre_prompt, inputs=[gr.State(value="alternative_rock")], outputs=[instrumental_prompt])
+    detroit_techno_btn.click(set_genre_prompt, inputs=[gr.State(value="detroit_techno")], outputs=[instrumental_prompt])
+    deep_house_btn.click(set_genre_prompt, inputs=[gr.State(value="deep_house")], outputs=[instrumental_prompt])
+    smooth_jazz_btn.click(set_genre_prompt, inputs=[gr.State(value="smooth_jazz")], outputs=[instrumental_prompt])
+    bebop_jazz_btn.click(set_genre_prompt, inputs=[gr.State(value="bebop_jazz")], outputs=[instrumental_prompt])
+    baroque_classical_btn.click(set_genre_prompt, inputs=[gr.State(value="baroque_classical")], outputs=[instrumental_prompt])
+    romantic_classical_btn.click(set_genre_prompt, inputs=[gr.State(value="romantic_classical")], outputs=[instrumental_prompt])
+    boom_bap_hiphop_btn.click(set_genre_prompt, inputs=[gr.State(value="boom_bap_hiphop")], outputs=[instrumental_prompt])
+    trap_hiphop_btn.click(set_genre_prompt, inputs=[gr.State(value="trap_hiphop")], outputs=[instrumental_prompt])
+    pop_rock_btn.click(set_genre_prompt, inputs=[gr.State(value="pop_rock")], outputs=[instrumental_prompt])
+    fusion_jazz_btn.click(set_genre_prompt, inputs=[gr.State(value="fusion_jazz")], outputs=[instrumental_prompt])
+    edm_btn.click(set_genre_prompt, inputs=[gr.State(value="edm")], outputs=[instrumental_prompt])
+    indie_folk_btn.click(set_genre_prompt, inputs=[gr.State(value="indie_folk")], outputs=[instrumental_prompt])
+    star_wars_btn.click(set_genre_prompt, inputs=[gr.State(value="star_wars")], outputs=[instrumental_prompt])
+    star_wars_classical_btn.click(set_genre_prompt, inputs=[gr.State(value="star_wars_classical")], outputs=[instrumental_prompt])
+    nirvana_btn.click(set_genre_prompt, inputs=[gr.State(value="nirvana")], outputs=[instrumental_prompt])
+    wutang_btn.click(set_genre_prompt, inputs=[gr.State(value="wutang")], outputs=[instrumental_prompt])
+    milesdavis_btn.click(set_genre_prompt, inputs=[gr.State(value="milesdavis")], outputs=[instrumental_prompt])
+    gen_btn.click(
+        fn=show_render_wheel,
+        inputs=None,
+        outputs=[render_state],
+    ).then(
+        fn=generate_music,
+        inputs=[instrumental_prompt, cfg_scale, top_k, top_p, temperature, total_duration, volume_db, gr.State(None)],
+        outputs=[out_audio, status, render_state, renders_table],
+        show_progress="full"
+    )
+    clr_btn.click(
+        fn=clear_inputs,
+        inputs=None,
+        outputs=[instrumental_prompt, cfg_scale, top_k, top_p, temperature, total_duration, volume_db, render_state]
+    )
+
+# ==============================
+# FastAPI
+# ==============================
+app = FastAPI()
+
+class MusicRequest(BaseModel):
+    prompt: str = None
+    duration: int = 30
+    volume_db: float = -24.0
+    genre: str = None
+
+@app.get("/prompts/")
+async def get_prompts():
+    global api_status
+    try:
+        prompts = list(config['Prompts'].keys())
+        return {"status": api_status, "prompts": prompts}
+    except Exception as e:
+        print(f"Error fetching prompts: {e}")
+        raise HTTPException(status_code=500, detail=f"Error fetching prompts: {e}")
+
+@app.post("/generate-music/")
+async def api_generate_music(request: MusicRequest):
+    global api_status
+    api_status = "rendering"
+    try:
+        instrumental_prompt = (
+            get_genre_prompt(request.genre)[0] if request.genre else
+            request.prompt if request.prompt else
+            get_genre_prompt("nirvana")[0]
+        )
+        style = (
+            get_genre_prompt(request.genre)[1] if request.genre else
+            extract_song_keyword(request.prompt) if request.prompt and extract_song_keyword(request.prompt) in prompt_variables['style'] else
+            get_genre_prompt("nirvana")[1]
+        )
+        if not instrumental_prompt.strip():
+            api_status = "idle"
+            raise HTTPException(status_code=400, detail="Invalid prompt or genre")
+
+        total_duration = max(request.duration, 30)
+        remaining = total_duration
+        audio_chunks = []
+        chunk_paths = []
+        continuation_prompt = None
+        chunk_index = 0
+
+        existing_titles = []
+        if os.path.exists(metadata_file):
+            with open(metadata_file, 'r') as f:
+                songs_metadata = json.load(f)
+                existing_titles = [entry["title"] for entry in songs_metadata]
+        song_keyword = extract_song_keyword(request.prompt if request.prompt else instrumental_prompt)
+        title_base, band_name = generate_unique_title(existing_titles, request.genre if request.genre else "nirvana", song_keyword, style)
+
+        while remaining > 0:
+            target = min(30, remaining)
+            print_resource_usage(f"Before API Chunk {chunk_index + 1}")
+            try:
+                audio_chunk, actual_dur = generate_chunk_oom_safe(
+                    musicgen_model, instrumental_prompt, continuation_prompt, 3.0, 50, 0.0, 0.8, target
+                )
+                audio_chunk = audio_chunk.cpu().to(dtype=torch.float32)
+                if audio_chunk.dim() == 1:
+                    audio_chunk = torch.stack([audio_chunk, audio_chunk], dim=0)
+                elif audio_chunk.dim() == 2 and audio_chunk.shape[0] == 1:
+                    audio_chunk = torch.cat([audio_chunk, audio_chunk], dim=0)
+                elif audio_chunk.dim() == 2 and audio_chunk.shape[0] != 2:
+                    audio_chunk = audio_chunk[:1, :]
+                    audio_chunk = torch.cat([audio_chunk, audio_chunk], dim=0)
+                elif audio_chunk.dim() > 2:
+                    audio_chunk = audio_chunk.view(2, -1)
+                if audio_chunk.shape[0] != 2:
+                    raise ValueError(f"Expected stereo audio with shape (2, samples), got {audio_chunk.shape}")
+
+                samples_per_second = musicgen_model.sample_rate
+                tail_sec = 2
+                tail_samples = min(int(tail_sec * samples_per_second), audio_chunk.shape[1] - 1 if audio_chunk.shape[1] > 1 else 1)
+                continuation_prompt = audio_chunk[:, -tail_samples:].cpu() if tail_samples > 0 else None
+
+                temp_wav_path = os.path.join(output_dir, f"temp_{random.randint(100, 999)}_{chunk_index}.wav")
+                try:
+                    torchaudio.save(temp_wav_path, audio_chunk, musicgen_model.sample_rate, bits_per_sample=16)
+                    final_segment = AudioSegment.from_wav(temp_wav_path)
+                finally:
+                    if os.path.exists(temp_wav_path):
+                        os.remove(temp_wav_path)
+                del audio_chunk
+                gc.collect()
+
+                final_segment = apply_eq(final_segment)
+                final_segment = apply_limiter(final_segment, max_db=request.volume_db, target_lufs=-16.0)
+                if chunk_index == 0:
+                    final_segment = final_segment.fade_in(1000)
+                if remaining - actual_dur <= 0:
+                    final_segment = final_segment.fade_out(1000)
+
+                mp3_filename = f"{title_base.lower()}_{song_keyword}_{style}_{band_name}_chunk{chunk_index + 1}.mp3"
+                mp3_path = os.path.join(output_dir, mp3_filename)
+                final_segment.export(
+                    mp3_path,
+                    format="mp3",
+                    bitrate="64k",
+                    tags={"title": f"{title_base}_Chunk{chunk_index + 1}", "artist": "GhostAI"}
+                )
+                print(f"Saved API chunk {chunk_index + 1} to {mp3_path}")
+                audio_chunks.append(final_segment)
+                chunk_paths.append(mp3_path)
+
+                metadata = {
+                    "title": f"{title_base}_Chunk{chunk_index + 1}",
+                    "filename": mp3_filename,
+                    "prompt": instrumental_prompt,
+                    "duration": actual_dur,
+                    "volume_db": request.volume_db,
+                    "target_lufs": -16.0,
+                    "timestamp": datetime.datetime.now().strftime("%Y%m%d_%H%M%S"),
+                    "file_path": mp3_path,
+                    "sample_rate": musicgen_model.sample_rate,
+                    "style": style,
+                    "band_name": band_name,
+                    "chunk_index": chunk_index + 1
+                }
+                update_metadata_storage(metadata)
+
+                chunk_index += 1
+                remaining -= actual_dur
+                torch.cuda.empty_cache()
+                gc.collect()
+                print_resource_usage(f"After API Chunk {chunk_index}")
+            except Exception as e:
+                print(f"ERROR: Failed to process API chunk {chunk_index + 1}: {e}")
+                api_status = "idle"
+                raise
+
+        if len(audio_chunks) > 1:
+            combined_segment = audio_chunks[0]
+            for segment in audio_chunks[1:]:
+                combined_segment = combined_segment.append(segment, crossfade=500)
+            combined_mp3_filename = f"{title_base.lower()}_{song_keyword}_{style}_{band_name}_combined.mp3"
+            combined_mp3_path = os.path.join(output_dir, combined_mp3_filename)
+            combined_segment.export(
+                combined_mp3_path,
+                format="mp3",
+                bitrate="64k",
+                tags={"title": title_base, "artist": "GhostAI"}
+            )
+            print(f"Saved combined audio to {combined_mp3_path}")
+            metadata = {
+                "title": title_base,
+                "filename": combined_mp3_filename,
+                "prompt": instrumental_prompt,
+                "duration": total_duration,
+                "volume_db": request.volume_db,
+                "target_lufs": -16.0,
+                "timestamp": datetime.datetime.now().strftime("%Y%m%d_%H%M%S"),
+                "file_path": combined_mp3_path,
+                "sample_rate": musicgen_model.sample_rate,
+                "style": style,
+                "band_name": band_name,
+                "chunk_index": 0
+            }
+            update_metadata_storage(metadata)
+            del combined_segment, audio_chunks
+            gc.collect()
+            api_status = "idle"
+            return FileResponse(combined_mp3_path, media_type="audio/mpeg")
+        else:
+            print(f"Saved metadata to {metadata_file}")
+            del audio_chunks
+            gc.collect()
+            api_status = "idle"
+            return FileResponse(chunk_paths[0], media_type="audio/mpeg")
+    except Exception as e:
+        print(f"Error generating music: {e}")
+        api_status = "idle"
+        raise HTTPException(status_code=500, detail=f"Error generating music: {e}")
+    finally:
+        torch.cuda.synchronize()
+        torch.cuda.empty_cache()
+        gc.collect()
+
+@app.get("/get-song/{filename}")
+async def get_song(filename: str):
+    global api_status
+    file_path = os.path.join(output_dir, filename)
+    if not os.path.exists(file_path):
+        print(f"Error: Song file {filename} not found")
+        raise HTTPException(status_code=404, detail="Song file not found")
+    print(f"Serving file: {filename}")
+    return FileResponse(file_path, media_type="audio/mpeg", filename=filename)
+
+@app.get("/status/")
+async def get_status():
+    global api_status
+    return {"status": api_status}
+
+def run_fastapi():
+    uvicorn.run(app, host="0.0.0.0", port=8000)
+
+# ==============================
+# Main
+# ==============================
+if __name__ == "__main__":
+    fastapi_process = multiprocessing.Process(target=run_fastapi)
+    fastapi_process.start()
+    try:
+        demo.launch(server_name="0.0.0.0", server_port=9999, share=False, inbrowser=True, show_error=True)
+    except Exception as e:
+        print(f"ERROR: Failed to launch Gradio: {e}")
+        fastapi_process.terminate()
+        sys.exit(1)
+    finally:
+        fastapi_process.terminate()

public/styles.css

@@ -0,0 +1,58 @@
+/* styles.css */
+/* High-contrast, accessible theme (no inline HTML in Python). ADA-focused: focus rings, large targets, readable contrast. */
+
+:root { color-scheme: dark; }
+
+* { box-sizing: border-box; }
+
+body, .gradio-container {
+  background: #0B0B0D !important;
+  color: #FFFFFF !important;
+  font-family: ui-sans-serif, system-ui, -apple-system, Segoe UI, Roboto, Helvetica, Arial, "Apple Color Emoji","Segoe UI Emoji";
+  line-height: 1.4;
+}
+
+h1, h2, h3, h4, h5, h6, label, p, span {
+  color: #FFFFFF !important;
+}
+
+.block, .panel, .wrap, .tabs, .tabitem, .form, .group {
+  background: #0B0B0D !important;
+}
+
+input, textarea, select {
+  background: #15151A !important;
+  color: #FFFFFF !important;
+  border: 1px solid #2B2B33 !important;
+  border-radius: 10px !important;
+  padding: 10px 12px !important;
+}
+
+button {
+  background: #1F6FEB !important;
+  color: #FFFFFF !important;
+  border: 2px solid transparent !important;
+  border-radius: 10px !important;
+  padding: 12px 14px !important;
+  font-weight: 700 !important;
+  min-height: 44px; /* touch target */
+}
+
+button:hover { background: #2D7BFF !important; }
+button:focus { outline: 3px solid #00C853 !important; outline-offset: 2px; }
+
+.group > * + * { margin-top: 8px; }
+.row { gap: 8px; }
+
+.audio-wrap, .audio-display, .output-html {
+  border: 1px solid #2B2B33 !important;
+  border-radius: 10px !important;
+}
+
+.slider > input[type="range"] { accent-color: #FFD600 !important; }
+
+/* Large labels for readability */
+label { font-size: 16px !important; font-weight: 700 !important; }
+
+/* Subtle card border around control groups */
+.group { border: 1px solid #2B2B33; border-radius: 12px; padding: 12px; }