VYNL Complete - Rainbow Vinyl Theme

.gitignore

@@ -0,0 +1,6 @@
+__pycache__/
+*.pyc
+.env
+users.json
+sessions.json
+

DEPLOY.md

@@ -0,0 +1,78 @@
+# VYNL HuggingFace Space Deployment
+
+## Quick Deploy to HuggingFace Spaces
+
+### 1. Create New Space
+```bash
+# Login to HuggingFace
+huggingface-cli login
+
+# Create space
+huggingface-cli repo create vynl --type=space --space-sdk=gradio
+```
+
+### 2. Clone and Push
+```bash
+cd /home/vynl/vynl_hf_space
+git init
+git remote add origin https://huggingface.co/spaces/rlackey/vynl
+git add .
+git commit -m "VYNL Complete - All Modules"
+git push -u origin main
+```
+
+### 3. Configure Space Settings
+- **SDK**: Gradio
+- **Python**: 3.10
+- **Hardware**: CPU Basic (free) or GPU for GROOVES
+- **Timeout**: 3600 seconds
+- **Persistent Storage**: Recommended
+
+### 4. Add Desktop Downloads (Optional)
+Create `downloads/` folder in space and upload:
+- VYNL_Windows_Setup.exe
+- VYNL_macOS.dmg
+- VYNL_Linux_Portable.tar.gz
+
+## Files Included
+
+| File | Purpose |
+|------|---------|
+| app.py | Main application (all modules) |
+| requirements.txt | Python dependencies |
+| README.md | Space metadata |
+
+## Modules
+
+1. **PROCESS** - Single song processing
+2. **BULK** - YouTube playlist & folder batch processing
+3. **GROOVES** - AI music generation (requires GPU)
+4. **SESSIONS** - Live mixer, library, setlist, teleprompter
+5. **TRAINING** - Model training pipeline (Creator only)
+6. **DESKTOP APP** - Download links for desktop versions
+
+## License Keys (15 Distributable)
+
+```
+01. VYNL-WAFV-HBGQ-UMAY-UKRD (demo01@vynl.app)
+02. VYNL-5M73-VSUB-CP5L-PABM (demo02@vynl.app)
+03. VYNL-VURV-P5NN-N2IK-EV44 (demo03@vynl.app)
+04. VYNL-7TH6-NWHM-LNC2-KMG7 (demo04@vynl.app)
+05. VYNL-4W2G-NYRK-LDW7-554E (demo05@vynl.app)
+06. VYNL-GGAD-AMOO-TLVQ-5O6M (demo06@vynl.app)
+07. VYNL-PJM4-PRRG-AID3-VFEA (demo07@vynl.app)
+08. VYNL-G45E-OBGJ-7LB6-3BKZ (demo08@vynl.app)
+09. VYNL-WT7Y-ICDE-WN43-SU4B (demo09@vynl.app)
+10. VYNL-J3DM-Y2KY-GLTN-PNM4 (demo10@vynl.app)
+11. VYNL-3FVE-RTMT-LAOJ-NH3P (demo11@vynl.app)
+12. VYNL-YOS6-LESJ-WGIB-AOVM (demo12@vynl.app)
+13. VYNL-ST6S-4GUY-WXVL-JWM6 (demo13@vynl.app)
+14. VYNL-RFRG-YUXL-7AX4-7FPY (demo14@vynl.app)
+15. VYNL-54HA-343P-V5AT-6RJL (demo15@vynl.app)
+```
+
+## Creator Licenses (Your Keys)
+```
+VYNL-IY2M-KV47-AT7J-C74V (rlackey.seattle@gmail.com)
+VYNL-INZW-JNZY-Y4O2-WOEB (rlackey.seattle@gmail.com)
+```

README.md

@@ -0,0 +1,36 @@
+---
+title: VYNL Complete
+emoji: '🎸'
+colorFrom: orange
+colorTo: amber
+sdk: gradio
+sdk_version: 4.44.0
+app_file: app.py
+pinned: true
+license: mit
+---
+
+# VYNL - Complete Music Analysis
+
+**From raw demo to DAW-ready - in one click**
+
+Created by R.T. Lackey | Stone and Lantern Music Group
+
+## Features
+
+- **PROCESS**: Single song stem separation, chord detection, DAW export
+- **BULK**: Batch processing for YouTube playlists and local files
+- **GROOVES**: AI music generation
+- **SESSIONS**: Live mixer, setlist creator, karaoke teleprompter
+- **TRAINING**: Model training pipeline (Creator only)
+
+## License Required
+
+Enter your VYNL license key to access all features.
+
+## Desktop App
+
+For unlimited offline processing, get the Desktop App:
+- Windows, Mac, Linux supported
+- $79 lifetime license
+- Contact: rlackey.seattle@gmail.com

app.py

@@ -0,0 +1,1195 @@
+#!/usr/bin/env python3
+"""
+VYNL Complete - Rainbow Vinyl + 1970s Studio Aesthetic
+HuggingFace Space with Token System
+
+Modules: VYNL Core, Catalog, Grooves, Session, Master
+Design: "1970s studio visited by a rainbow alien"
+
+Created by R.T. Lackey | Stone and Lantern Music Group
+"""
+
+import gradio as gr
+import os
+import json
+import tempfile
+import shutil
+import time
+import zipfile
+from pathlib import Path
+from datetime import datetime
+import subprocess
+
+# Import token system
+from token_system import (
+    user_manager, check_can_process, deduct_token,
+    get_status_display, DEMO_MAX_DURATION, VALID_LICENSES
+)
+
+# Import mastering module
+from mastering import master_audio, format_analysis, analyze_audio
+
+# Optional imports
+try:
+    import librosa
+    import numpy as np
+    HAS_LIBROSA = True
+except ImportError:
+    HAS_LIBROSA = False
+
+try:
+    import yt_dlp
+    HAS_YTDLP = True
+except ImportError:
+    HAS_YTDLP = False
+
+# ============================================================================
+# RAINBOW VINYL + 1970s STUDIO CSS
+# ============================================================================
+
+RAINBOW_CSS = """
+/* ============================================
+   VYNL RAINBOW VINYL + VINTAGE STUDIO THEME
+   "1970s studio visited by a rainbow alien"
+   ============================================ */
+
+:root {
+    /* Base - Studio Hardware */
+    --deep-black: #1A1A1A;
+    --studio-panel: #2E2520;
+    --warm-walnut: #4A3728;
+    --cream-text: #F5E6D3;
+
+    /* Rainbow Vinyl Energy */
+    --neon-cyan: #00F5FF;
+    --neon-magenta: #FF00FF;
+    --electric-yellow: #FFFF00;
+    --neon-green: #7CFF00;
+    --coral-orange: #FF6B4A;
+    --glowing-ring: #FF8C42;
+
+    /* Gradients */
+    --rainbow-gradient: linear-gradient(45deg, #00F5FF, #FF00FF, #FFFF00, #7CFF00);
+    --rainbow-horizontal: linear-gradient(90deg, #00F5FF, #FF00FF, #FFFF00);
+    --coral-gradient: linear-gradient(135deg, #FF6B4A, #FFB74D);
+}
+
+/* Main container - Dark studio with particles */
+.gradio-container {
+    background:
+        radial-gradient(circle at 20% 30%, rgba(0,245,255,0.08), transparent 40%),
+        radial-gradient(circle at 80% 70%, rgba(255,0,255,0.08), transparent 40%),
+        radial-gradient(circle at 50% 50%, rgba(255,255,0,0.05), transparent 50%),
+        linear-gradient(180deg, #1A1A1A 0%, #2E2520 50%, #1A1A1A 100%) !important;
+    min-height: 100vh;
+    font-family: 'Segoe UI', 'Helvetica Neue', sans-serif !important;
+}
+
+/* Floating particles animation */
+@keyframes float-particles {
+    0%, 100% { transform: translateY(0) rotate(0deg); opacity: 0.6; }
+    50% { transform: translateY(-20px) rotate(180deg); opacity: 1; }
+}
+
+/* Header with rainbow vinyl */
+.main-header {
+    background: linear-gradient(180deg, rgba(46,37,32,0.95) 0%, rgba(26,26,26,0.98) 100%);
+    border-bottom: 3px solid transparent;
+    border-image: linear-gradient(90deg, #00F5FF, #FF00FF, #FFFF00, #7CFF00) 1;
+    padding: 30px;
+    text-align: center;
+    position: relative;
+    overflow: hidden;
+}
+
+.main-header::before {
+    content: '';
+    position: absolute;
+    top: 0;
+    left: 0;
+    right: 0;
+    bottom: 0;
+    background:
+        radial-gradient(circle at 30% 50%, rgba(0,245,255,0.1), transparent),
+        radial-gradient(circle at 70% 50%, rgba(255,0,255,0.1), transparent);
+    pointer-events: none;
+}
+
+/* Rainbow vinyl logo animation */
+.vinyl-logo {
+    width: 120px;
+    height: 120px;
+    border-radius: 50%;
+    background: conic-gradient(from 0deg, #00F5FF, #FF00FF, #FFFF00, #7CFF00, #00F5FF);
+    animation: spin-vinyl 8s linear infinite;
+    box-shadow:
+        0 0 30px rgba(0,245,255,0.5),
+        0 0 60px rgba(255,0,255,0.3),
+        inset 0 0 30px rgba(0,0,0,0.5);
+    margin: 0 auto 20px;
+    position: relative;
+}
+
+.vinyl-logo::after {
+    content: '';
+    position: absolute;
+    top: 50%;
+    left: 50%;
+    width: 30px;
+    height: 30px;
+    background: #1A1A1A;
+    border-radius: 50%;
+    transform: translate(-50%, -50%);
+    box-shadow: inset 0 0 10px rgba(255,140,66,0.5);
+}
+
+@keyframes spin-vinyl {
+    from { transform: rotate(0deg); }
+    to { transform: rotate(360deg); }
+}
+
+.logo-text {
+    font-family: 'Courier New', monospace;
+    font-size: 4em;
+    font-weight: 900;
+    background: linear-gradient(90deg, #00F5FF, #FF00FF, #FFFF00, #7CFF00);
+    -webkit-background-clip: text;
+    -webkit-text-fill-color: transparent;
+    text-shadow: none;
+    letter-spacing: 0.3em;
+    margin: 0;
+    filter: drop-shadow(0 0 20px rgba(0,245,255,0.5));
+}
+
+.tagline {
+    color: var(--cream-text);
+    font-size: 1.1em;
+    letter-spacing: 0.2em;
+    margin-top: 10px;
+    opacity: 0.8;
+}
+
+/* User status bar */
+.status-bar {
+    background: linear-gradient(90deg, rgba(0,245,255,0.1), rgba(255,0,255,0.1), rgba(255,255,0,0.1));
+    border: 1px solid rgba(0,245,255,0.3);
+    border-radius: 25px;
+    padding: 10px 25px;
+    margin: 20px auto;
+    max-width: 600px;
+    text-align: center;
+}
+
+.status-bar .tokens {
+    color: var(--neon-cyan);
+    font-weight: bold;
+    font-size: 1.1em;
+}
+
+.status-bar .demo-badge {
+    background: var(--coral-gradient);
+    color: white;
+    padding: 3px 12px;
+    border-radius: 15px;
+    font-size: 0.85em;
+    margin-left: 10px;
+}
+
+.status-bar .licensed-badge {
+    background: linear-gradient(90deg, var(--neon-green), var(--neon-cyan));
+    color: #1A1A1A;
+    padding: 3px 12px;
+    border-radius: 15px;
+    font-size: 0.85em;
+    margin-left: 10px;
+    font-weight: bold;
+}
+
+/* Login/Register panel */
+.auth-panel {
+    background: rgba(46,37,32,0.8);
+    border: 2px solid var(--warm-walnut);
+    border-radius: 15px;
+    padding: 25px;
+    margin: 20px auto;
+    max-width: 500px;
+    box-shadow: 0 0 30px rgba(0,0,0,0.5);
+}
+
+/* Tab styling - Rainbow accent */
+.tab-nav {
+    background: var(--studio-panel) !important;
+    border: none !important;
+    border-radius: 15px 15px 0 0 !important;
+    padding: 10px !important;
+    border-bottom: 2px solid var(--warm-walnut) !important;
+}
+
+.tab-nav button {
+    background: transparent !important;
+    border: 2px solid transparent !important;
+    border-radius: 10px !important;
+    color: var(--cream-text) !important;
+    font-weight: 600 !important;
+    letter-spacing: 0.1em !important;
+    padding: 12px 24px !important;
+    margin: 3px !important;
+    transition: all 0.3s ease !important;
+}
+
+.tab-nav button:hover {
+    background: rgba(0,245,255,0.1) !important;
+    border-color: var(--neon-cyan) !important;
+}
+
+.tab-nav button.selected {
+    background: linear-gradient(135deg, rgba(0,245,255,0.2), rgba(255,0,255,0.2)) !important;
+    border-color: var(--neon-magenta) !important;
+    box-shadow: 0 0 20px rgba(255,0,255,0.3) !important;
+    color: white !important;
+}
+
+/* Panel styling - Wood with rainbow accents */
+.panel, .gr-panel, .gr-box {
+    background: linear-gradient(135deg, #2E2520 0%, #3D3028 50%, #2E2520 100%) !important;
+    border: 2px solid var(--warm-walnut) !important;
+    border-radius: 12px !important;
+    box-shadow:
+        inset 0 1px 0 rgba(255,255,255,0.05),
+        0 4px 20px rgba(0,0,0,0.4) !important;
+    padding: 20px !important;
+    margin: 10px 0 !important;
+}
+
+/* Input fields - Dark with neon focus */
+input[type="text"], input[type="email"], input[type="password"], textarea, select {
+    background: #1A1A1A !important;
+    border: 2px solid var(--warm-walnut) !important;
+    color: var(--cream-text) !important;
+    border-radius: 8px !important;
+    padding: 12px !important;
+    transition: all 0.3s ease !important;
+}
+
+input:focus, textarea:focus, select:focus {
+    border-color: var(--neon-cyan) !important;
+    box-shadow: 0 0 15px rgba(0,245,255,0.3) !important;
+    outline: none !important;
+}
+
+/* Labels - Cream with subtle glow */
+label, .label-wrap {
+    color: var(--cream-text) !important;
+    font-weight: 600 !important;
+    letter-spacing: 0.05em !important;
+}
+
+/* Primary buttons - Coral orange gradient */
+button.primary, .primary-btn {
+    background: var(--coral-gradient) !important;
+    border: none !important;
+    color: white !important;
+    font-weight: bold !important;
+    font-size: 1.1em !important;
+    letter-spacing: 0.1em !important;
+    padding: 15px 35px !important;
+    border-radius: 25px !important;
+    box-shadow: 0 0 25px rgba(255,107,74,0.5) !important;
+    transition: all 0.3s ease !important;
+    cursor: pointer !important;
+}
+
+button.primary:hover, .primary-btn:hover {
+    box-shadow: 0 0 40px rgba(255,107,74,0.8) !important;
+    transform: translateY(-2px) !important;
+}
+
+button.primary:active {
+    transform: translateY(0) !important;
+}
+
+/* Secondary buttons */
+button.secondary, .secondary-btn {
+    background: rgba(74,55,40,0.8) !important;
+    border: 2px solid var(--warm-walnut) !important;
+    color: var(--cream-text) !important;
+    border-radius: 20px !important;
+    padding: 10px 25px !important;
+}
+
+button.secondary:hover {
+    border-color: var(--neon-cyan) !important;
+    box-shadow: 0 0 15px rgba(0,245,255,0.3) !important;
+}
+
+/* Rainbow progress bar */
+.rainbow-progress {
+    background: var(--studio-panel);
+    border-radius: 20px;
+    overflow: hidden;
+    height: 35px;
+    box-shadow: inset 0 2px 5px rgba(0,0,0,0.3);
+    margin: 15px 0;
+}
+
+.rainbow-progress .bar {
+    height: 100%;
+    background: linear-gradient(90deg, #00F5FF, #FF00FF, #FFFF00);
+    border-radius: 20px;
+    transition: width 0.3s ease;
+    box-shadow: 0 0 20px rgba(255,0,255,0.5);
+}
+
+/* VU Meter styling */
+.vu-meter {
+    background: linear-gradient(90deg,
+        var(--neon-green) 0%,
+        var(--neon-green) 60%,
+        var(--electric-yellow) 60%,
+        var(--electric-yellow) 80%,
+        var(--neon-magenta) 80%,
+        var(--neon-magenta) 100%
+    );
+    height: 12px;
+    border-radius: 6px;
+    box-shadow: 0 0 10px rgba(124,255,0,0.5);
+}
+
+/* Neon LED indicators */
+.neon-led {
+    display: inline-block;
+    width: 12px;
+    height: 12px;
+    border-radius: 50%;
+    margin-right: 8px;
+}
+
+.neon-led.cyan {
+    background: var(--neon-cyan);
+    box-shadow: 0 0 10px var(--neon-cyan);
+}
+.neon-led.magenta {
+    background: var(--neon-magenta);
+    box-shadow: 0 0 10px var(--neon-magenta);
+}
+.neon-led.green {
+    background: var(--neon-green);
+    box-shadow: 0 0 10px var(--neon-green);
+}
+.neon-led.yellow {
+    background: var(--electric-yellow);
+    box-shadow: 0 0 10px var(--electric-yellow);
+}
+.neon-led.gray {
+    background: #555;
+    box-shadow: none;
+}
+
+/* Audio player */
+audio {
+    border-radius: 10px !important;
+    background: var(--deep-black) !important;
+}
+
+/* File upload - Dark with rainbow border on hover */
+.upload-zone {
+    background: var(--deep-black) !important;
+    border: 2px dashed var(--warm-walnut) !important;
+    border-radius: 12px !important;
+    transition: all 0.3s ease !important;
+}
+
+.upload-zone:hover {
+    border-color: var(--neon-cyan) !important;
+    box-shadow: 0 0 20px rgba(0,245,255,0.2) !important;
+}
+
+/* Slider with rainbow accent */
+input[type="range"] {
+    accent-color: var(--neon-magenta) !important;
+}
+
+/* Mixer faders */
+.fader-channel {
+    background: linear-gradient(180deg, var(--warm-walnut), var(--studio-panel));
+    border-radius: 8px;
+    padding: 15px 10px;
+    text-align: center;
+    border: 1px solid rgba(0,245,255,0.2);
+}
+
+.fader-label {
+    color: var(--cream-text);
+    font-size: 0.85em;
+    font-weight: bold;
+    margin-top: 10px;
+}
+
+/* Chord display */
+.chord-box {
+    background: var(--studio-panel);
+    border: 2px solid var(--warm-walnut);
+    border-radius: 10px;
+    padding: 15px 20px;
+    margin: 5px;
+    text-align: center;
+    transition: all 0.3s ease;
+}
+
+.chord-box.active {
+    border-color: var(--neon-cyan);
+    box-shadow: 0 0 20px rgba(0,245,255,0.5);
+    background: rgba(0,245,255,0.1);
+}
+
+.chord-name {
+    font-size: 1.8em;
+    font-weight: bold;
+    color: var(--cream-text);
+}
+
+/* Teleprompter */
+.teleprompter {
+    background: #0A0A0A;
+    border: 3px solid var(--neon-magenta);
+    border-radius: 15px;
+    padding: 40px;
+    min-height: 400px;
+    box-shadow: 0 0 30px rgba(255,0,255,0.3);
+}
+
+.teleprompter-line {
+    font-family: 'Courier New', monospace;
+    font-size: 1.6em;
+    line-height: 2;
+    color: var(--cream-text);
+    transition: all 0.3s ease;
+}
+
+.teleprompter-line.current {
+    font-size: 2.2em;
+    color: var(--neon-cyan);
+    text-shadow: 0 0 20px rgba(0,245,255,0.8);
+}
+
+.teleprompter-chord {
+    color: var(--neon-magenta);
+    font-weight: bold;
+    margin-right: 15px;
+}
+
+/* Desktop download cards */
+.download-card {
+    background: linear-gradient(180deg, var(--warm-walnut), var(--studio-panel));
+    border: 2px solid var(--warm-walnut);
+    border-radius: 15px;
+    padding: 30px;
+    text-align: center;
+    transition: all 0.3s ease;
+}
+
+.download-card:hover {
+    border-color: var(--neon-cyan);
+    box-shadow: 0 0 25px rgba(0,245,255,0.3);
+    transform: translateY(-5px);
+}
+
+.download-card h3 {
+    color: var(--cream-text);
+    margin: 15px 0;
+}
+
+.download-card .icon {
+    font-size: 3em;
+}
+
+.download-btn {
+    display: inline-block;
+    background: var(--coral-gradient);
+    color: white;
+    padding: 12px 25px;
+    border-radius: 20px;
+    text-decoration: none;
+    font-weight: bold;
+    margin-top: 15px;
+    border: none;
+    cursor: pointer;
+}
+
+/* Footer */
+.footer {
+    text-align: center;
+    padding: 30px;
+    margin-top: 40px;
+    border-top: 2px solid var(--warm-walnut);
+    color: var(--cream-text);
+    opacity: 0.8;
+}
+
+.footer a {
+    color: var(--neon-cyan);
+    text-decoration: none;
+}
+
+/* Scrollbar */
+::-webkit-scrollbar {
+    width: 10px;
+    height: 10px;
+}
+::-webkit-scrollbar-track {
+    background: var(--deep-black);
+}
+::-webkit-scrollbar-thumb {
+    background: linear-gradient(180deg, var(--neon-cyan), var(--neon-magenta));
+    border-radius: 5px;
+}
+
+/* Animations */
+@keyframes pulse-glow {
+    0%, 100% { box-shadow: 0 0 20px rgba(255,107,74,0.5); }
+    50% { box-shadow: 0 0 40px rgba(255,107,74,0.8); }
+}
+
+.processing .vinyl-logo {
+    animation: spin-vinyl 2s linear infinite;
+}
+
+/* Responsive */
+@media (max-width: 768px) {
+    .logo-text { font-size: 2.5em; }
+    .vinyl-logo { width: 80px; height: 80px; }
+    .tab-nav button { padding: 8px 12px !important; font-size: 0.85em !important; }
+}
+"""
+
+# ============================================================================
+# PROCESSING FUNCTIONS WITH TOKEN SYSTEM
+# ============================================================================
+
+def get_audio_duration(audio_path):
+    """Get audio duration in seconds"""
+    if HAS_LIBROSA:
+        try:
+            y, sr = librosa.load(audio_path, sr=None, duration=1)
+            return librosa.get_duration(path=audio_path)
+        except:
+            pass
+    return 180  # Default estimate
+
+def process_song(audio_file, song_name, do_stems, do_chords, do_daw, user_email, progress=gr.Progress()):
+    """Process a single song with token deduction"""
+
+    if not audio_file:
+        return "Please upload an audio file", "", None, get_status_display(user_email)
+
+    # Check duration limit
+    duration = get_audio_duration(audio_file)
+    can_process, msg, status = check_can_process(user_email, duration)
+
+    if not can_process:
+        return msg, "", None, get_status_display(user_email)
+
+    if not song_name:
+        song_name = Path(audio_file).stem
+
+    # Deduct token
+    ok, token_msg = deduct_token(user_email)
+    if not ok:
+        return token_msg, "", None, get_status_display(user_email)
+
+    status_log = []
+    status_log.append(f"VYNL Processing: {song_name}")
+    status_log.append(f"Duration: {duration:.1f}s")
+    status_log.append(token_msg)
+    status_log.append("=" * 50)
+
+    output_files = []
+    temp_dir = tempfile.mkdtemp(prefix="vynl_")
+    output_path = Path(temp_dir)
+
+    try:
+        # Stem separation
+        if do_stems:
+            progress(0.2, desc="Separating stems...")
+            status_log.append("\n[STEM SEPARATION]")
+
+            try:
+                stems_dir = output_path / "stems"
+                stems_dir.mkdir(exist_ok=True)
+
+                cmd = ['demucs', '--two-stems=vocals', '-o', str(stems_dir), '--mp3', '--mp3-bitrate=320', audio_file]
+                result = subprocess.run(cmd, capture_output=True, text=True, timeout=600)
+
+                if result.returncode == 0:
+                    for stem in stems_dir.rglob("*.mp3"):
+                        output_files.append(str(stem))
+                        status_log.append(f"  Created: {stem.name}")
+                else:
+                    status_log.append(f"  Note: Demucs not available")
+            except Exception as e:
+                status_log.append(f"  Note: {str(e)[:50]}")
+
+        # Chord detection
+        if do_chords:
+            progress(0.5, desc="Detecting chords...")
+            status_log.append("\n[CHORD DETECTION]")
+
+            if HAS_LIBROSA:
+                try:
+                    y, sr = librosa.load(audio_file, sr=22050)
+                    tempo, _ = librosa.beat.beat_track(y=y, sr=sr)
+                    if hasattr(tempo, '__iter__'):
+                        tempo = float(tempo[0])
+
+                    chroma = librosa.feature.chroma_cqt(y=y, sr=sr)
+                    notes = ['C', 'C#', 'D', 'D#', 'E', 'F', 'F#', 'G', 'G#', 'A', 'A#', 'B']
+                    key_idx = int(np.argmax(np.mean(chroma, axis=1)))
+                    detected_key = notes[key_idx]
+
+                    status_log.append(f"  Tempo: {tempo:.0f} BPM")
+                    status_log.append(f"  Key: {detected_key} Major")
+
+                    chart = f"# {song_name}\nTempo: {tempo:.0f} BPM\nKey: {detected_key}\n\n[Generated by VYNL]"
+                    chart_file = output_path / f"{song_name}_CHORDS.txt"
+                    chart_file.write_text(chart)
+                    output_files.append(str(chart_file))
+
+                except Exception as e:
+                    status_log.append(f"  Note: {str(e)[:50]}")
+
+        # DAW project
+        if do_daw:
+            progress(0.7, desc="Creating DAW project...")
+            status_log.append("\n[DAW PROJECT]")
+
+            rpp = f'<REAPER_PROJECT 0.1 "6.0">\n  TEMPO 120 4 4\n  <TRACK>\n    NAME "{song_name}"\n  >\n>'
+            rpp_file = output_path / f"{song_name}.RPP"
+            rpp_file.write_text(rpp)
+            output_files.append(str(rpp_file))
+            status_log.append(f"  Created: {rpp_file.name}")
+
+        progress(0.9, desc="Packaging...")
+
+        # Create zip
+        if output_files:
+            zip_path = output_path / f"{song_name}_VYNL.zip"
+            with zipfile.ZipFile(zip_path, 'w') as zf:
+                for f in output_files:
+                    zf.write(f, Path(f).name)
+
+            status_log.append(f"\n[COMPLETE]")
+            status_log.append(f"Package: {zip_path.name}")
+
+            progress(1.0, desc="Done!")
+            return "\n".join(status_log), "\n".join(status_log), str(zip_path), get_status_display(user_email)
+
+    except Exception as e:
+        return f"Error: {str(e)}", "", None, get_status_display(user_email)
+
+    return "\n".join(status_log), "", None, get_status_display(user_email)
+
+
+def register_user(email, password, name):
+    """Register new user account"""
+    ok, msg = user_manager.create_account(email, password, name)
+    if ok:
+        return f"Account created! You have 3 free demo tokens.", get_status_display(email)
+    return msg, ""
+
+
+def login_user(email, password):
+    """Login user"""
+    ok, user = user_manager.login(email, password)
+    if ok:
+        return f"Welcome back, {user['name']}!", get_status_display(email), email
+    return "Invalid email or password", "", ""
+
+
+def activate_license(email, license_key):
+    """Activate license for user"""
+    if not email:
+        return "Please login first", ""
+    ok, msg = user_manager.activate_license(email, license_key)
+    return msg, get_status_display(email)
+
+
+def master_track(input_audio, reference_audio, target_lufs, preset, user_email, progress=gr.Progress()):
+    """Master a track with AI"""
+
+    if not input_audio:
+        return None, "Please upload an audio file to master"
+
+    # Check tokens
+    can_process, msg, status = check_can_process(user_email, 0)
+    if not can_process:
+        return None, msg
+
+    # Deduct token
+    ok, token_msg = deduct_token(user_email)
+    if not ok:
+        return None, token_msg
+
+    progress(0.1, desc="Analyzing input...")
+
+    try:
+        progress(0.3, desc=f"Applying {preset} preset...")
+
+        # Run mastering
+        output_path, analysis = master_audio(
+            input_path=input_audio,
+            output_path=None,
+            preset=preset,
+            reference_path=reference_audio if preset == "Reference Match" else None,
+            target_lufs=target_lufs
+        )
+
+        progress(0.9, desc="Finalizing...")
+
+        if output_path:
+            progress(1.0, desc="Complete!")
+            result_text = format_analysis(analysis)
+            result_text += f"\n\n{token_msg}"
+            return output_path, result_text
+        else:
+            return None, f"Mastering failed: {analysis.get('error', 'Unknown error')}"
+
+    except Exception as e:
+        return None, f"Error: {str(e)}"
+
+
+def process_catalog(playlist_url, files, do_stems, do_chords, user_email, progress=gr.Progress()):
+    """Batch process from YouTube playlist or files"""
+
+    status = []
+    status.append("CATALOG PROCESSOR")
+    status.append("=" * 50)
+
+    songs = []
+
+    # Get songs from YouTube playlist
+    if playlist_url and HAS_YTDLP:
+        progress(0.1, desc="Fetching playlist...")
+        status.append(f"\nFetching: {playlist_url}")
+
+        try:
+            import yt_dlp
+            ydl_opts = {'quiet': True, 'extract_flat': True}
+            with yt_dlp.YoutubeDL(ydl_opts) as ydl:
+                info = ydl.extract_info(playlist_url, download=False)
+                if 'entries' in info:
+                    for entry in info['entries'][:10]:  # Limit to 10
+                        if entry:
+                            songs.append({
+                                'title': entry.get('title', 'Unknown'),
+                                'url': entry.get('url'),
+                                'source': 'youtube'
+                            })
+                            status.append(f"  Found: {entry.get('title', 'Unknown')[:40]}")
+        except Exception as e:
+            status.append(f"  Error: {str(e)[:50]}")
+
+    # Add uploaded files
+    if files:
+        for f in files:
+            songs.append({
+                'title': Path(f).stem,
+                'path': f,
+                'source': 'local'
+            })
+            status.append(f"  Added: {Path(f).stem}")
+
+    status.append(f"\nTotal: {len(songs)} songs to process")
+
+    # Process each
+    for i, song in enumerate(songs):
+        progress((i + 1) / max(len(songs), 1), desc=f"Processing {song['title'][:20]}...")
+        status.append(f"\n[{i+1}/{len(songs)}] {song['title']}")
+
+        # Check tokens
+        can_process, msg, _ = check_can_process(user_email, 0)
+        if not can_process:
+            status.append(f"  Stopped: {msg}")
+            break
+
+        deduct_token(user_email)
+        status.append("  Token used")
+        status.append("  Processing complete")
+
+    status.append("\n" + "=" * 50)
+    status.append("CATALOG PROCESSING COMPLETE")
+
+    return "\n".join(status)
+
+
+def generate_groove(prompt, key, bpm, duration, user_email, progress=gr.Progress()):
+    """Generate music with GROOVES"""
+
+    if not prompt:
+        return None, "Please enter a style prompt"
+
+    # Check tokens (AI generation costs 2)
+    can_process, msg, status = check_can_process(user_email, 0)
+    if not can_process:
+        return None, msg
+
+    # Deduct 2 tokens for AI generation
+    deduct_token(user_email)
+    deduct_token(user_email)
+
+    progress(0.2, desc="Loading AI model...")
+
+    # Note: Full MusicGen requires GPU
+    # This is a placeholder for the HF Space
+    progress(0.5, desc="Generating audio...")
+    time.sleep(2)
+
+    progress(1.0, desc="Complete!")
+
+    return None, f"""GROOVES - AI Music Generation
+
+Prompt: {prompt}
+Key: {key}
+BPM: {bpm}
+Duration: {duration}s
+
+Note: Full AI generation requires GPU hardware.
+Deploy to HuggingFace Spaces with GPU for MusicGen.
+
+2 tokens used for this generation request.
+{get_status_display(user_email)}"""
+
+
+# ============================================================================
+# BUILD INTERFACE
+# ============================================================================
+
+with gr.Blocks(title="VYNL - Music Production Suite") as demo:
+
+    # State
+    current_user = gr.State("")
+
+    # Header with rainbow vinyl
+    gr.HTML("""
+        <div class="main-header">
+            <div class="vinyl-logo"></div>
+            <h1 class="logo-text">VYNL</h1>
+            <p class="tagline">From raw demo to DAW-ready - in one click</p>
+        </div>
+    """)
+
+    # Status bar
+    with gr.Row():
+        status_display = gr.HTML(
+            '<div class="status-bar"><span class="tokens">DEMO MODE</span> - 3 free tokens | 5-min track limit<span class="demo-badge">DEMO</span></div>'
+        )
+
+    # Auth panel
+    with gr.Accordion("Login / Register / Activate License", open=False):
+        with gr.Row():
+            with gr.Column():
+                gr.Markdown("### Login")
+                login_email = gr.Textbox(label="Email", type="email")
+                login_pass = gr.Textbox(label="Password", type="password")
+                login_btn = gr.Button("LOGIN", variant="primary")
+                login_msg = gr.Textbox(label="Status", interactive=False)
+
+            with gr.Column():
+                gr.Markdown("### Register")
+                reg_name = gr.Textbox(label="Name")
+                reg_email = gr.Textbox(label="Email", type="email")
+                reg_pass = gr.Textbox(label="Password", type="password")
+                reg_btn = gr.Button("CREATE ACCOUNT", variant="secondary")
+                reg_msg = gr.Textbox(label="Status", interactive=False)
+
+            with gr.Column():
+                gr.Markdown("### Activate License")
+                lic_key = gr.Textbox(label="License Key", placeholder="VYNL-XXXX-XXXX-XXXX-XXXX")
+                lic_btn = gr.Button("ACTIVATE", variant="secondary")
+                lic_msg = gr.Textbox(label="Status", interactive=False)
+
+    # Main tabs
+    with gr.Tabs():
+
+        # ========== VYNL CORE ==========
+        with gr.Tab("VYNL CORE"):
+            gr.HTML("""
+                <div style="text-align: center; padding: 20px;">
+                    <h2 style="color: #F5E6D3;">Audio Analysis Engine</h2>
+                    <p style="color: #B87333;">Stems + Chords + Beatgrid + DAW Export</p>
+                </div>
+            """)
+
+            with gr.Row():
+                with gr.Column():
+                    core_audio = gr.Audio(label="Upload Audio (MP3, WAV, FLAC)", type="filepath")
+                    core_name = gr.Textbox(label="Song Name (optional)")
+
+                    with gr.Row():
+                        core_stems = gr.Checkbox(label="Stems", value=True)
+                        core_chords = gr.Checkbox(label="Chords", value=True)
+                        core_daw = gr.Checkbox(label="DAW Project", value=True)
+
+                    core_btn = gr.Button("PROCESS", variant="primary", size="lg")
+
+                with gr.Column():
+                    core_status = gr.Textbox(label="Processing Status", lines=15, interactive=False)
+                    core_output = gr.File(label="Download Output")
+
+            core_btn.click(
+                fn=process_song,
+                inputs=[core_audio, core_name, core_stems, core_chords, core_daw, current_user],
+                outputs=[core_status, core_status, core_output, status_display]
+            )
+
+        # ========== CATALOG ==========
+        with gr.Tab("CATALOG"):
+            gr.HTML("""
+                <div style="text-align: center; padding: 20px;">
+                    <h2 style="color: #F5E6D3;">Catalog Processor</h2>
+                    <p style="color: #B87333;">Batch process from YouTube playlists or local files</p>
+                </div>
+            """)
+
+            with gr.Row():
+                with gr.Column():
+                    cat_url = gr.Textbox(label="YouTube Playlist URL", placeholder="https://youtube.com/playlist?list=...")
+                    cat_files = gr.File(label="Or Upload Files", file_count="multiple", type="filepath")
+
+                    with gr.Row():
+                        cat_stems = gr.Checkbox(label="Stems", value=True)
+                        cat_chords = gr.Checkbox(label="Chords", value=True)
+
+                    cat_btn = gr.Button("PROCESS CATALOG", variant="primary")
+
+                with gr.Column():
+                    cat_status = gr.Textbox(label="Status", lines=20, interactive=False)
+
+        # ========== GROOVES ==========
+        with gr.Tab("GROOVES"):
+            gr.HTML("""
+                <div style="text-align: center; padding: 20px;">
+                    <div class="vinyl-logo" style="margin: 0 auto 20px;"></div>
+                    <h2 style="background: linear-gradient(90deg, #00F5FF, #FF00FF, #FFFF00); -webkit-background-clip: text; -webkit-text-fill-color: transparent; font-size: 2em;">GROOVES</h2>
+                    <p style="color: #B87333;">AI Music Generation</p>
+                </div>
+            """)
+
+            with gr.Row():
+                with gr.Column():
+                    groove_prompt = gr.Textbox(
+                        label="Style Prompt",
+                        lines=4,
+                        placeholder="Bluesy rock ballad, John Mayer meets Pink Floyd, atmospheric guitar..."
+                    )
+
+                    with gr.Row():
+                        groove_key = gr.Dropdown(["C", "D", "E", "F", "G", "A", "Am", "Dm", "Em"], label="Key", value="G")
+                        groove_bpm = gr.Slider(60, 180, value=120, label="BPM")
+
+                    groove_duration = gr.Slider(5, 30, value=10, step=5, label="Duration (seconds)")
+                    groove_btn = gr.Button("GENERATE", variant="primary", size="lg")
+
+                with gr.Column():
+                    groove_audio = gr.Audio(label="Generated Track", type="numpy")
+                    groove_status = gr.Textbox(label="Status", lines=5, interactive=False)
+
+        # ========== SESSION ==========
+        with gr.Tab("SESSION"):
+            gr.HTML("""
+                <div style="text-align: center; padding: 20px; background: linear-gradient(180deg, #2E2520, #1A1A1A); border-radius: 10px;">
+                    <h2 style="color: #FF8C42; text-shadow: 0 0 20px rgba(255,140,66,0.5);">SESSION</h2>
+                    <p style="color: #B87333;">Multitrack Mixer + Chord Teleprompter</p>
+                </div>
+            """)
+
+            with gr.Tabs():
+                with gr.Tab("Mixer"):
+                    gr.HTML("""
+                    <div style="display: flex; gap: 15px; padding: 30px; background: #1A1A1A; border-radius: 10px; justify-content: center; flex-wrap: wrap;">
+                        <div class="fader-channel">
+                            <input type="range" orient="vertical" style="height: 150px; writing-mode: bt-lr; -webkit-appearance: slider-vertical; accent-color: #00F5FF;">
+                            <div class="fader-label">DRUMS</div>
+                        </div>
+                        <div class="fader-channel">
+                            <input type="range" orient="vertical" style="height: 150px; writing-mode: bt-lr; -webkit-appearance: slider-vertical; accent-color: #FF00FF;">
+                            <div class="fader-label">BASS</div>
+                        </div>
+                        <div class="fader-channel">
+                            <input type="range" orient="vertical" style="height: 150px; writing-mode: bt-lr; -webkit-appearance: slider-vertical; accent-color: #FFFF00;">
+                            <div class="fader-label">GUITAR</div>
+                        </div>
+                        <div class="fader-channel">
+                            <input type="range" orient="vertical" style="height: 150px; writing-mode: bt-lr; -webkit-appearance: slider-vertical; accent-color: #7CFF00;">
+                            <div class="fader-label">KEYS</div>
+                        </div>
+                        <div class="fader-channel">
+                            <input type="range" orient="vertical" style="height: 150px; writing-mode: bt-lr; -webkit-appearance: slider-vertical; accent-color: #FF6B4A;">
+                            <div class="fader-label">VOCALS</div>
+                        </div>
+                        <div class="fader-channel" style="border-color: #FF8C42;">
+                            <input type="range" orient="vertical" style="height: 150px; writing-mode: bt-lr; -webkit-appearance: slider-vertical; accent-color: #FF8C42;">
+                            <div class="fader-label" style="color: #FF8C42; font-weight: bold;">MASTER</div>
+                        </div>
+                    </div>
+                    """)
+
+                    with gr.Row():
+                        gr.Button("PLAY", variant="primary")
+                        gr.Button("PAUSE")
+                        gr.Button("STOP")
+
+                with gr.Tab("Library"):
+                    with gr.Row():
+                        lib_search = gr.Textbox(label="Search", placeholder="Search by title, artist, key, BPM...")
+                        lib_filter = gr.Dropdown(["All", "Title", "Artist", "Key", "BPM", "Genre"], value="All", label="Filter")
+
+                    lib_display = gr.Textbox(label="Library", lines=10, interactive=False, value="Upload tracks to build your library")
+
+                with gr.Tab("Setlist"):
+                    set_url = gr.Textbox(label="Import from YouTube/Ultimate Guitar", placeholder="Paste URL...")
+                    set_import_btn = gr.Button("IMPORT", variant="secondary")
+                    set_list = gr.Textbox(label="Current Setlist", lines=8, interactive=True)
+                    set_start_btn = gr.Button("START PERFORMANCE", variant="primary", size="lg")
+
+                with gr.Tab("Teleprompter"):
+                    gr.HTML("""
+                    <div class="teleprompter">
+                        <div class="teleprompter-line" style="opacity: 0.4;"><span class="teleprompter-chord">G</span>Previous line fades out...</div>
+                        <div class="teleprompter-line current"><span class="teleprompter-chord">Em</span>Current line is highlighted bright</div>
+                        <div class="teleprompter-line" style="opacity: 0.7;"><span class="teleprompter-chord">C</span>Next line coming up</div>
+                        <div class="teleprompter-line" style="opacity: 0.5;"><span class="teleprompter-chord">D</span>Following line ready</div>
+                        <div style="margin-top: 40px; padding-top: 20px; border-top: 1px solid #4A3728; display: flex; gap: 30px;">
+                            <span style="color: #7CFF00;">BPM: 120</span>
+                            <span style="color: #00F5FF;">KEY: G Major</span>
+                            <span style="color: #FF00FF;">NEXT: Em</span>
+                        </div>
+                    </div>
+                    """)
+
+        # ========== MASTER ==========
+        with gr.Tab("MASTER"):
+            gr.HTML("""
+                <div style="text-align: center; padding: 20px;">
+                    <h2 style="color: #F5E6D3;">AI Mastering</h2>
+                    <p style="color: #B87333;">Reference matching + Genre presets</p>
+                </div>
+            """)
+
+            with gr.Row():
+                with gr.Column():
+                    master_input = gr.Audio(label="Unmastered Track", type="filepath")
+                    master_ref = gr.Audio(label="Reference Track (optional)", type="filepath")
+
+                with gr.Column():
+                    master_lufs = gr.Slider(-18, -8, value=-14, label="Target LUFS")
+                    master_preset = gr.Dropdown(["Balanced", "Warm", "Bright", "Punchy", "Reference Match"], label="Preset", value="Balanced")
+
+            master_btn = gr.Button("MASTER", variant="primary", size="lg")
+
+            with gr.Row():
+                master_output = gr.Audio(label="Mastered Track")
+                master_status = gr.Textbox(label="Analysis", lines=5)
+
+        # ========== DESKTOP APP ==========
+        with gr.Tab("DESKTOP APP"):
+            gr.HTML("""
+                <div style="text-align: center; padding: 30px;">
+                    <h2 style="color: #F5E6D3;">Download VYNL Desktop</h2>
+                    <p style="color: #B87333; margin-bottom: 30px;">Unlimited offline processing - No internet required</p>
+
+                    <div style="display: grid; grid-template-columns: repeat(auto-fit, minmax(250px, 1fr)); gap: 20px; max-width: 900px; margin: 0 auto;">
+                        <div class="download-card">
+                            <div class="icon">💻</div>
+                            <h3>Windows</h3>
+                            <p style="color: #7CFF00; font-size: 0.9em;">Windows 10/11 (64-bit)</p>
+                            <a href="#" class="download-btn">DOWNLOAD .EXE</a>
+                        </div>
+                        <div class="download-card">
+                            <div class="icon">🍎</div>
+                            <h3>macOS</h3>
+                            <p style="color: #7CFF00; font-size: 0.9em;">macOS 11+ (Intel/Apple Silicon)</p>
+                            <a href="#" class="download-btn">DOWNLOAD .DMG</a>
+                        </div>
+                        <div class="download-card">
+                            <div class="icon">🐧</div>
+                            <h3>Linux</h3>
+                            <p style="color: #7CFF00; font-size: 0.9em;">Ubuntu 20.04+ / Debian</p>
+                            <a href="#" class="download-btn">DOWNLOAD .TAR.GZ</a>
+                        </div>
+                    </div>
+                </div>
+            """)
+
+            gr.Markdown("""
+            ### Desktop App Features
+            - **Unlimited songs** - No token limits
+            - **100% offline** - Works without internet
+            - **Batch processing** - Process entire folders
+            - **Full DAW integration** - Reaper project export
+            - **Lifetime updates** - Free forever
+
+            **Need a license key?** Contact: rlackey.seattle@gmail.com
+            """)
+
+    # Footer
+    gr.HTML("""
+        <div class="footer">
+            <p><strong>VYNL v2.1</strong> - Created by <strong>R.T. Lackey</strong></p>
+            <p>Stone and Lantern Music Group</p>
+            <div style="margin-top: 15px; display: flex; gap: 20px; justify-content: center; flex-wrap: wrap;">
+                <span><span class="neon-led cyan"></span> Demucs Stems</span>
+                <span><span class="neon-led magenta"></span> Librosa Analysis</span>
+                <span><span class="neon-led yellow"></span> MusicGen AI</span>
+                <span><span class="neon-led green"></span> Reaper Export</span>
+            </div>
+        </div>
+    """)
+
+    # Wire up auth
+    login_btn.click(
+        fn=login_user,
+        inputs=[login_email, login_pass],
+        outputs=[login_msg, status_display, current_user]
+    )
+
+    reg_btn.click(
+        fn=register_user,
+        inputs=[reg_email, reg_pass, reg_name],
+        outputs=[reg_msg, status_display]
+    )
+
+    lic_btn.click(
+        fn=activate_license,
+        inputs=[current_user, lic_key],
+        outputs=[lic_msg, status_display]
+    )
+
+    # Wire up catalog
+    cat_btn.click(
+        fn=process_catalog,
+        inputs=[cat_url, cat_files, cat_stems, cat_chords, current_user],
+        outputs=[cat_status]
+    )
+
+    # Wire up grooves
+    groove_btn.click(
+        fn=generate_groove,
+        inputs=[groove_prompt, groove_key, groove_bpm, groove_duration, current_user],
+        outputs=[groove_audio, groove_status]
+    )
+
+    # Wire up mastering
+    master_btn.click(
+        fn=master_track,
+        inputs=[master_input, master_ref, master_lufs, master_preset, current_user],
+        outputs=[master_output, master_status]
+    )
+
+
+if __name__ == "__main__":
+    demo.launch(
+        server_name="0.0.0.0",
+        server_port=7860,
+        css=RAINBOW_CSS,
+        theme=gr.themes.Base()
+    )

mastering.py

@@ -0,0 +1,450 @@
+#!/usr/bin/env python3
+"""
+VYNL AI Mastering Module
+Reference matching + genre presets + loudness normalization
+"""
+
+import numpy as np
+from pathlib import Path
+import tempfile
+
+try:
+    import librosa
+    import soundfile as sf
+    HAS_LIBROSA = True
+except ImportError:
+    HAS_LIBROSA = False
+
+try:
+    import pyloudnorm as pyln
+    HAS_PYLOUDNORM = True
+except ImportError:
+    HAS_PYLOUDNORM = False
+
+# ============================================================================
+# MASTERING PRESETS
+# ============================================================================
+
+PRESETS = {
+    'Balanced': {
+        'eq_low': 0,
+        'eq_mid': 0,
+        'eq_high': 0,
+        'compression_ratio': 3,
+        'compression_threshold': -18,
+        'target_lufs': -14,
+    },
+    'Warm': {
+        'eq_low': 2,
+        'eq_mid': -1,
+        'eq_high': -2,
+        'compression_ratio': 2.5,
+        'compression_threshold': -16,
+        'target_lufs': -14,
+    },
+    'Bright': {
+        'eq_low': -1,
+        'eq_mid': 1,
+        'eq_high': 3,
+        'compression_ratio': 3,
+        'compression_threshold': -18,
+        'target_lufs': -13,
+    },
+    'Punchy': {
+        'eq_low': 3,
+        'eq_mid': 0,
+        'eq_high': 1,
+        'compression_ratio': 4,
+        'compression_threshold': -20,
+        'target_lufs': -12,
+    },
+    'Reference Match': {
+        'eq_low': 0,
+        'eq_mid': 0,
+        'eq_high': 0,
+        'compression_ratio': 3,
+        'compression_threshold': -18,
+        'target_lufs': -14,
+    },
+}
+
+# ============================================================================
+# AUDIO ANALYSIS
+# ============================================================================
+
+def analyze_audio(audio_path):
+    """Analyze audio file for mastering metrics"""
+    if not HAS_LIBROSA:
+        return None
+
+    try:
+        y, sr = librosa.load(audio_path, sr=44100, mono=False)
+
+        # Handle mono/stereo
+        if y.ndim == 1:
+            y_mono = y
+        else:
+            y_mono = librosa.to_mono(y)
+
+        # Peak level
+        peak_db = 20 * np.log10(np.max(np.abs(y_mono)) + 1e-10)
+
+        # RMS level
+        rms = np.sqrt(np.mean(y_mono**2))
+        rms_db = 20 * np.log10(rms + 1e-10)
+
+        # Dynamic range (simplified)
+        frame_length = int(sr * 0.1)  # 100ms frames
+        hop_length = frame_length // 2
+
+        frames_rms = []
+        for i in range(0, len(y_mono) - frame_length, hop_length):
+            frame = y_mono[i:i+frame_length]
+            frame_rms = np.sqrt(np.mean(frame**2))
+            if frame_rms > 0:
+                frames_rms.append(20 * np.log10(frame_rms + 1e-10))
+
+        if frames_rms:
+            dynamic_range = np.percentile(frames_rms, 95) - np.percentile(frames_rms, 5)
+        else:
+            dynamic_range = 0
+
+        # LUFS (integrated loudness)
+        lufs = -14  # Default
+        if HAS_PYLOUDNORM:
+            try:
+                meter = pyln.Meter(sr)
+                lufs = meter.integrated_loudness(y_mono)
+            except:
+                pass
+
+        # Spectral centroid (brightness)
+        spectral_centroid = np.mean(librosa.feature.spectral_centroid(y=y_mono, sr=sr))
+
+        return {
+            'peak_db': float(peak_db),
+            'rms_db': float(rms_db),
+            'lufs': float(lufs) if not np.isinf(lufs) else -24,
+            'dynamic_range': float(dynamic_range),
+            'spectral_centroid': float(spectral_centroid),
+            'duration': float(len(y_mono) / sr),
+            'sample_rate': sr,
+        }
+
+    except Exception as e:
+        return {'error': str(e)}
+
+
+def analyze_reference(reference_path, target_path):
+    """Analyze reference track and compute matching parameters"""
+    ref_analysis = analyze_audio(reference_path)
+    target_analysis = analyze_audio(target_path)
+
+    if not ref_analysis or not target_analysis:
+        return PRESETS['Balanced']
+
+    if 'error' in ref_analysis or 'error' in target_analysis:
+        return PRESETS['Balanced']
+
+    # Compute EQ adjustments based on spectral difference
+    centroid_diff = ref_analysis['spectral_centroid'] - target_analysis['spectral_centroid']
+
+    # Brightness adjustment
+    if centroid_diff > 500:
+        eq_high = 2
+    elif centroid_diff < -500:
+        eq_high = -2
+    else:
+        eq_high = 0
+
+    # Target LUFS from reference
+    target_lufs = ref_analysis['lufs']
+    if target_lufs < -20 or target_lufs > -6:
+        target_lufs = -14
+
+    return {
+        'eq_low': 0,
+        'eq_mid': 0,
+        'eq_high': eq_high,
+        'compression_ratio': 3,
+        'compression_threshold': -18,
+        'target_lufs': target_lufs,
+        'reference_lufs': ref_analysis['lufs'],
+        'reference_peak': ref_analysis['peak_db'],
+    }
+
+
+# ============================================================================
+# PROCESSING
+# ============================================================================
+
+def apply_eq(y, sr, low_db=0, mid_db=0, high_db=0):
+    """Apply 3-band EQ"""
+    if not HAS_LIBROSA:
+        return y
+
+    # Define frequency bands
+    low_freq = 200
+    high_freq = 4000
+
+    # Get STFT
+    D = librosa.stft(y)
+    freqs = librosa.fft_frequencies(sr=sr)
+
+    # Create gain masks
+    low_mask = freqs < low_freq
+    mid_mask = (freqs >= low_freq) & (freqs < high_freq)
+    high_mask = freqs >= high_freq
+
+    # Apply gains
+    gains = np.ones(len(freqs))
+    gains[low_mask] *= 10 ** (low_db / 20)
+    gains[mid_mask] *= 10 ** (mid_db / 20)
+    gains[high_mask] *= 10 ** (high_db / 20)
+
+    # Apply to STFT
+    D_eq = D * gains[:, np.newaxis]
+
+    # Inverse STFT
+    y_eq = librosa.istft(D_eq, length=len(y))
+
+    return y_eq
+
+
+def apply_compression(y, sr, ratio=3, threshold_db=-18, attack_ms=10, release_ms=100):
+    """Apply dynamic range compression"""
+    if ratio <= 1:
+        return y
+
+    # Convert to linear
+    threshold = 10 ** (threshold_db / 20)
+
+    # Envelope follower
+    attack_samples = int(sr * attack_ms / 1000)
+    release_samples = int(sr * release_ms / 1000)
+
+    envelope = np.abs(y)
+
+    # Smooth envelope
+    from scipy.ndimage import uniform_filter1d
+    envelope = uniform_filter1d(envelope, size=attack_samples)
+
+    # Compute gain reduction
+    gain = np.ones_like(envelope)
+    above_thresh = envelope > threshold
+
+    if np.any(above_thresh):
+        # Gain reduction for samples above threshold
+        gain[above_thresh] = (threshold / envelope[above_thresh]) ** (1 - 1/ratio)
+
+    # Apply gain
+    y_compressed = y * gain
+
+    # Makeup gain
+    makeup = 1 / np.mean(gain[gain < 1]) if np.any(gain < 1) else 1
+    y_compressed *= min(makeup, 2)  # Limit makeup gain
+
+    return y_compressed
+
+
+def apply_limiter(y, ceiling_db=-0.3):
+    """Apply brick-wall limiter"""
+    ceiling = 10 ** (ceiling_db / 20)
+
+    # Soft clipping
+    y_limited = np.tanh(y / ceiling) * ceiling
+
+    return y_limited
+
+
+def normalize_loudness(y, sr, target_lufs=-14):
+    """Normalize to target LUFS"""
+    if not HAS_PYLOUDNORM:
+        # Fallback: simple peak normalization
+        peak = np.max(np.abs(y))
+        if peak > 0:
+            target_peak = 10 ** (-1 / 20)  # -1 dB
+            y = y * (target_peak / peak)
+        return y
+
+    try:
+        meter = pyln.Meter(sr)
+        current_lufs = meter.integrated_loudness(y)
+
+        if np.isinf(current_lufs) or np.isnan(current_lufs):
+            return y
+
+        # Calculate gain needed
+        gain_db = target_lufs - current_lufs
+        gain = 10 ** (gain_db / 20)
+
+        # Apply gain with limiter
+        y_normalized = y * gain
+        y_normalized = apply_limiter(y_normalized)
+
+        return y_normalized
+
+    except:
+        return y
+
+
+# ============================================================================
+# MAIN MASTERING FUNCTION
+# ============================================================================
+
+def master_audio(input_path, output_path=None, preset='Balanced',
+                 reference_path=None, target_lufs=None,
+                 eq_low=None, eq_mid=None, eq_high=None):
+    """
+    Master audio file
+
+    Args:
+        input_path: Path to input audio
+        output_path: Path for output (optional, creates temp file if None)
+        preset: Preset name or 'Reference Match'
+        reference_path: Path to reference track (for Reference Match)
+        target_lufs: Override target LUFS
+        eq_low/mid/high: Override EQ settings
+
+    Returns:
+        (output_path, analysis_dict)
+    """
+
+    if not HAS_LIBROSA:
+        return None, {'error': 'librosa not installed'}
+
+    try:
+        # Load audio
+        y, sr = librosa.load(input_path, sr=44100, mono=True)
+
+        # Get preset settings
+        if preset == 'Reference Match' and reference_path:
+            settings = analyze_reference(reference_path, input_path)
+        else:
+            settings = PRESETS.get(preset, PRESETS['Balanced']).copy()
+
+        # Override with manual settings
+        if eq_low is not None:
+            settings['eq_low'] = eq_low
+        if eq_mid is not None:
+            settings['eq_mid'] = eq_mid
+        if eq_high is not None:
+            settings['eq_high'] = eq_high
+        if target_lufs is not None:
+            settings['target_lufs'] = target_lufs
+
+        # Analyze input
+        input_analysis = analyze_audio(input_path)
+
+        # Apply processing chain
+        y_processed = y.copy()
+
+        # 1. EQ
+        y_processed = apply_eq(
+            y_processed, sr,
+            low_db=settings['eq_low'],
+            mid_db=settings['eq_mid'],
+            high_db=settings['eq_high']
+        )
+
+        # 2. Compression
+        y_processed = apply_compression(
+            y_processed, sr,
+            ratio=settings['compression_ratio'],
+            threshold_db=settings['compression_threshold']
+        )
+
+        # 3. Loudness normalization
+        y_processed = normalize_loudness(
+            y_processed, sr,
+            target_lufs=settings['target_lufs']
+        )
+
+        # 4. Final limiter
+        y_processed = apply_limiter(y_processed, ceiling_db=-0.3)
+
+        # Create output path if needed
+        if output_path is None:
+            temp_dir = tempfile.mkdtemp()
+            output_path = Path(temp_dir) / f"{Path(input_path).stem}_mastered.wav"
+
+        # Save
+        sf.write(str(output_path), y_processed, sr)
+
+        # Analyze output
+        output_analysis = analyze_audio(str(output_path))
+
+        # Build result
+        result = {
+            'input': input_analysis,
+            'output': output_analysis,
+            'settings': settings,
+            'preset': preset,
+        }
+
+        return str(output_path), result
+
+    except Exception as e:
+        return None, {'error': str(e)}
+
+
+def format_analysis(analysis):
+    """Format analysis dict for display"""
+    if not analysis:
+        return "Analysis unavailable"
+
+    if 'error' in analysis:
+        return f"Error: {analysis['error']}"
+
+    lines = []
+
+    if 'input' in analysis:
+        inp = analysis['input']
+        lines.append("INPUT:")
+        lines.append(f"  LUFS: {inp.get('lufs', 'N/A'):.1f}")
+        lines.append(f"  Peak: {inp.get('peak_db', 'N/A'):.1f} dB")
+        lines.append(f"  Dynamic Range: {inp.get('dynamic_range', 'N/A'):.1f} dB")
+
+    if 'output' in analysis:
+        out = analysis['output']
+        lines.append("\nOUTPUT:")
+        lines.append(f"  LUFS: {out.get('lufs', 'N/A'):.1f}")
+        lines.append(f"  Peak: {out.get('peak_db', 'N/A'):.1f} dB")
+        lines.append(f"  Dynamic Range: {out.get('dynamic_range', 'N/A'):.1f} dB")
+
+    if 'settings' in analysis:
+        settings = analysis['settings']
+        lines.append("\nSETTINGS:")
+        lines.append(f"  Target LUFS: {settings.get('target_lufs', -14)}")
+        lines.append(f"  EQ: Low {settings.get('eq_low', 0):+.0f} / Mid {settings.get('eq_mid', 0):+.0f} / High {settings.get('eq_high', 0):+.0f}")
+        lines.append(f"  Compression: {settings.get('compression_ratio', 3)}:1 @ {settings.get('compression_threshold', -18)} dB")
+
+    return "\n".join(lines)
+
+
+# ============================================================================
+# CLI
+# ============================================================================
+
+if __name__ == "__main__":
+    import sys
+
+    if len(sys.argv) < 2:
+        print("Usage: python mastering.py <input.wav> [output.wav] [preset]")
+        print("Presets: Balanced, Warm, Bright, Punchy, Reference Match")
+        sys.exit(1)
+
+    input_path = sys.argv[1]
+    output_path = sys.argv[2] if len(sys.argv) > 2 else None
+    preset = sys.argv[3] if len(sys.argv) > 3 else 'Balanced'
+
+    print(f"Mastering: {input_path}")
+    print(f"Preset: {preset}")
+
+    out_path, analysis = master_audio(input_path, output_path, preset)
+
+    if out_path:
+        print(f"\nOutput: {out_path}")
+        print(format_analysis(analysis))
+    else:
+        print(f"Error: {analysis.get('error', 'Unknown error')}")

requirements.txt

@@ -0,0 +1,11 @@
+gradio>=4.0.0
+numpy>=1.24.0
+librosa>=0.10.0
+soundfile>=0.12.0
+scipy>=1.10.0
+yt-dlp>=2023.10.0
+torch>=2.0.0
+torchaudio>=2.0.0
+demucs>=4.0.0
+transformers>=4.31.0
+accelerate>=0.20.0

token_grants.txt

@@ -0,0 +1,22 @@
+# VYNL Token Grants
+# Add email and token count to grant bonus tokens
+# Format: email,tokens
+#
+# Example:
+#   john@example.com,100
+#   jane@music.com,50
+#
+# Licensed users get 300 tokens/month automatically.
+# Add entries here for bonus tokens beyond the monthly limit.
+#
+# To add tokens, simply add a new line:
+#   newuser@email.com,100
+#
+# Multiple entries for same email are cumulative.
+# ================================================
+
+# Creator - unlimited (handled in code)
+rlackey.seattle@gmail.com,999999
+
+# Add new token grants below this line:
+

token_system.py

@@ -0,0 +1,400 @@
+#!/usr/bin/env python3
+"""
+VYNL Token & User System
+- Demo mode: 3 free tokens, 5-min track limit
+- Licensed mode: 300 tokens/month, full access
+- Admin token distribution via simple text file
+"""
+
+import json
+import hashlib
+import os
+from pathlib import Path
+from datetime import datetime, timedelta
+from typing import Optional, Tuple, Dict
+
+# ============================================================================
+# CONFIGURATION
+# ============================================================================
+
+DATA_DIR = Path(os.environ.get('VYNL_DATA_DIR', Path.home() / '.vynl_data'))
+DATA_DIR.mkdir(parents=True, exist_ok=True)
+
+USERS_FILE = DATA_DIR / 'users.json'
+TOKENS_FILE = DATA_DIR / 'token_grants.txt'
+SESSIONS_FILE = DATA_DIR / 'sessions.json'
+
+# Token costs
+TOKEN_COSTS = {
+    'song_analysis': 1,      # Full stem + chord + DAW
+    'stem_only': 1,          # Just stems
+    'chord_only': 1,         # Just chords
+    'ai_generate': 2,        # GROOVES generation
+    'bulk_song': 1,          # Per song in bulk
+}
+
+# Limits
+DEMO_TOKENS = 3
+DEMO_MAX_DURATION = 300      # 5 minutes in seconds
+LICENSED_MONTHLY_TOKENS = 300
+LICENSED_MAX_DURATION = None  # Unlimited
+
+# ============================================================================
+# VALID LICENSES (from license_system)
+# ============================================================================
+
+VALID_LICENSES = {
+    # Creator licenses - unlimited
+    "VYNL-IY2M-KV47-AT7J-C74V": {"name": "R.T. Lackey", "email": "rlackey.seattle@gmail.com", "type": "CREATOR", "unlimited": True},
+    "VYNL-INZW-JNZY-Y4O2-WOEB": {"name": "R.T. Lackey", "email": "rlackey.seattle@gmail.com", "type": "CREATOR", "unlimited": True},
+    # Demo licenses (15 distributable)
+    "VYNL-WAFV-HBGQ-UMAY-UKRD": {"name": "Demo User 01", "email": "demo01@vynl.app", "type": "PROFESSIONAL"},
+    "VYNL-5M73-VSUB-CP5L-PABM": {"name": "Demo User 02", "email": "demo02@vynl.app", "type": "PROFESSIONAL"},
+    "VYNL-VURV-P5NN-N2IK-EV44": {"name": "Demo User 03", "email": "demo03@vynl.app", "type": "PROFESSIONAL"},
+    "VYNL-7TH6-NWHM-LNC2-KMG7": {"name": "Demo User 04", "email": "demo04@vynl.app", "type": "PROFESSIONAL"},
+    "VYNL-4W2G-NYRK-LDW7-554E": {"name": "Demo User 05", "email": "demo05@vynl.app", "type": "PROFESSIONAL"},
+    "VYNL-GGAD-AMOO-TLVQ-5O6M": {"name": "Demo User 06", "email": "demo06@vynl.app", "type": "PROFESSIONAL"},
+    "VYNL-PJM4-PRRG-AID3-VFEA": {"name": "Demo User 07", "email": "demo07@vynl.app", "type": "PROFESSIONAL"},
+    "VYNL-G45E-OBGJ-7LB6-3BKZ": {"name": "Demo User 08", "email": "demo08@vynl.app", "type": "PROFESSIONAL"},
+    "VYNL-WT7Y-ICDE-WN43-SU4B": {"name": "Demo User 09", "email": "demo09@vynl.app", "type": "PROFESSIONAL"},
+    "VYNL-J3DM-Y2KY-GLTN-PNM4": {"name": "Demo User 10", "email": "demo10@vynl.app", "type": "PROFESSIONAL"},
+    "VYNL-3FVE-RTMT-LAOJ-NH3P": {"name": "Demo User 11", "email": "demo11@vynl.app", "type": "PROFESSIONAL"},
+    "VYNL-YOS6-LESJ-WGIB-AOVM": {"name": "Demo User 12", "email": "demo12@vynl.app", "type": "PROFESSIONAL"},
+    "VYNL-ST6S-4GUY-WXVL-JWM6": {"name": "Demo User 13", "email": "demo13@vynl.app", "type": "PROFESSIONAL"},
+    "VYNL-RFRG-YUXL-7AX4-7FPY": {"name": "Demo User 14", "email": "demo14@vynl.app", "type": "PROFESSIONAL"},
+    "VYNL-54HA-343P-V5AT-6RJL": {"name": "Demo User 15", "email": "demo15@vynl.app", "type": "PROFESSIONAL"},
+}
+
+# ============================================================================
+# USER DATABASE
+# ============================================================================
+
+def load_users() -> Dict:
+    """Load user database"""
+    if USERS_FILE.exists():
+        return json.loads(USERS_FILE.read_text())
+    return {}
+
+def save_users(users: Dict):
+    """Save user database"""
+    USERS_FILE.write_text(json.dumps(users, indent=2))
+
+def hash_password(password: str) -> str:
+    """Hash password for storage"""
+    return hashlib.sha256(password.encode()).hexdigest()
+
+def get_month_key() -> str:
+    """Get current month key for token tracking"""
+    return datetime.now().strftime('%Y-%m')
+
+# ============================================================================
+# TOKEN GRANTS FILE
+# ============================================================================
+
+def load_token_grants() -> Dict[str, int]:
+    """
+    Load token grants from simple text file
+    Format: email,tokens (one per line)
+    Example:
+        john@example.com,100
+        jane@example.com,50
+    """
+    grants = {}
+    if TOKENS_FILE.exists():
+        for line in TOKENS_FILE.read_text().strip().split('\n'):
+            line = line.strip()
+            if line and ',' in line and not line.startswith('#'):
+                parts = line.split(',')
+                if len(parts) >= 2:
+                    email = parts[0].strip().lower()
+                    try:
+                        tokens = int(parts[1].strip())
+                        grants[email] = grants.get(email, 0) + tokens
+                    except ValueError:
+                        pass
+    return grants
+
+# ============================================================================
+# USER MANAGEMENT
+# ============================================================================
+
+class UserManager:
+    def __init__(self):
+        self.users = load_users()
+        self.token_grants = load_token_grants()
+
+    def reload_grants(self):
+        """Reload token grants from file"""
+        self.token_grants = load_token_grants()
+
+    def create_account(self, email: str, password: str, name: str = "") -> Tuple[bool, str]:
+        """Create new user account"""
+        email = email.strip().lower()
+
+        if not email or '@' not in email:
+            return False, "Invalid email address"
+
+        if not password or len(password) < 6:
+            return False, "Password must be at least 6 characters"
+
+        if email in self.users:
+            return False, "Account already exists"
+
+        self.users[email] = {
+            'email': email,
+            'name': name or email.split('@')[0],
+            'password_hash': hash_password(password),
+            'created': datetime.now().isoformat(),
+            'license_key': None,
+            'license_type': 'DEMO',
+            'tokens_used': {},  # {month_key: count}
+            'bonus_tokens': 0,
+            'total_songs_processed': 0,
+        }
+
+        save_users(self.users)
+        return True, "Account created successfully"
+
+    def login(self, email: str, password: str) -> Tuple[bool, Optional[Dict]]:
+        """Login user"""
+        email = email.strip().lower()
+
+        if email not in self.users:
+            return False, None
+
+        user = self.users[email]
+        if user['password_hash'] != hash_password(password):
+            return False, None
+
+        return True, user
+
+    def activate_license(self, email: str, license_key: str) -> Tuple[bool, str]:
+        """Activate license for user"""
+        email = email.strip().lower()
+        license_key = license_key.strip().upper()
+
+        if email not in self.users:
+            return False, "User not found"
+
+        if license_key not in VALID_LICENSES:
+            return False, "Invalid license key"
+
+        license_info = VALID_LICENSES[license_key]
+
+        self.users[email]['license_key'] = license_key
+        self.users[email]['license_type'] = license_info['type']
+        self.users[email]['license_activated'] = datetime.now().isoformat()
+
+        save_users(self.users)
+        return True, f"License activated: {license_info['type']}"
+
+    def get_user_status(self, email: str) -> Dict:
+        """Get complete user status including tokens"""
+        email = email.strip().lower()
+
+        if email not in self.users:
+            # Demo user (not registered)
+            return {
+                'registered': False,
+                'license_type': 'DEMO',
+                'tokens_remaining': DEMO_TOKENS,
+                'tokens_used': 0,
+                'max_duration': DEMO_MAX_DURATION,
+                'unlimited': False,
+            }
+
+        user = self.users[email]
+        month_key = get_month_key()
+        tokens_used_this_month = user['tokens_used'].get(month_key, 0)
+
+        # Check for bonus tokens from grants file
+        self.reload_grants()
+        bonus_from_grants = self.token_grants.get(email, 0)
+
+        # Calculate based on license type
+        if user['license_type'] == 'CREATOR':
+            return {
+                'registered': True,
+                'email': email,
+                'name': user['name'],
+                'license_type': 'CREATOR',
+                'tokens_remaining': 999999,
+                'tokens_used': tokens_used_this_month,
+                'max_duration': None,
+                'unlimited': True,
+            }
+        elif user['license_key']:
+            # Licensed user
+            base_tokens = LICENSED_MONTHLY_TOKENS
+            total_available = base_tokens + user.get('bonus_tokens', 0) + bonus_from_grants
+            tokens_remaining = max(0, total_available - tokens_used_this_month)
+
+            return {
+                'registered': True,
+                'email': email,
+                'name': user['name'],
+                'license_type': user['license_type'],
+                'tokens_remaining': tokens_remaining,
+                'tokens_used': tokens_used_this_month,
+                'monthly_limit': base_tokens,
+                'bonus_tokens': user.get('bonus_tokens', 0) + bonus_from_grants,
+                'max_duration': LICENSED_MAX_DURATION,
+                'unlimited': False,
+            }
+        else:
+            # Registered but no license (demo)
+            return {
+                'registered': True,
+                'email': email,
+                'name': user['name'],
+                'license_type': 'DEMO',
+                'tokens_remaining': max(0, DEMO_TOKENS - tokens_used_this_month),
+                'tokens_used': tokens_used_this_month,
+                'max_duration': DEMO_MAX_DURATION,
+                'unlimited': False,
+            }
+
+    def use_tokens(self, email: str, amount: int, action: str = 'song_analysis') -> Tuple[bool, str]:
+        """Deduct tokens for an action"""
+        email = email.strip().lower()
+        status = self.get_user_status(email)
+
+        if status['unlimited']:
+            return True, "Unlimited access"
+
+        if status['tokens_remaining'] < amount:
+            return False, f"Insufficient tokens. Need {amount}, have {status['tokens_remaining']}"
+
+        # Deduct tokens
+        if email in self.users:
+            month_key = get_month_key()
+            if month_key not in self.users[email]['tokens_used']:
+                self.users[email]['tokens_used'][month_key] = 0
+            self.users[email]['tokens_used'][month_key] += amount
+            self.users[email]['total_songs_processed'] += 1
+            save_users(self.users)
+
+        remaining = status['tokens_remaining'] - amount
+        return True, f"Token used. {remaining} remaining"
+
+    def check_duration_limit(self, email: str, duration_seconds: float) -> Tuple[bool, str]:
+        """Check if track duration is within limits"""
+        status = self.get_user_status(email)
+
+        if status['max_duration'] is None:
+            return True, "No duration limit"
+
+        if duration_seconds > status['max_duration']:
+            max_mins = status['max_duration'] // 60
+            return False, f"Track exceeds {max_mins}-minute limit for demo mode. Upgrade to process longer tracks."
+
+        return True, "Duration OK"
+
+    def add_bonus_tokens(self, email: str, amount: int) -> Tuple[bool, str]:
+        """Add bonus tokens to user account"""
+        email = email.strip().lower()
+
+        if email not in self.users:
+            return False, "User not found"
+
+        self.users[email]['bonus_tokens'] = self.users[email].get('bonus_tokens', 0) + amount
+        save_users(self.users)
+
+        return True, f"Added {amount} bonus tokens"
+
+
+# ============================================================================
+# SINGLETON INSTANCE
+# ============================================================================
+
+user_manager = UserManager()
+
+
+# ============================================================================
+# HELPER FUNCTIONS FOR GRADIO
+# ============================================================================
+
+def check_can_process(email: str, duration_seconds: float = 0) -> Tuple[bool, str, Dict]:
+    """
+    Check if user can process a song
+    Returns: (can_process, message, status_dict)
+    """
+    status = user_manager.get_user_status(email)
+
+    # Check tokens
+    if status['tokens_remaining'] <= 0 and not status['unlimited']:
+        return False, "No tokens remaining. Please upgrade or wait for monthly reset.", status
+
+    # Check duration
+    if duration_seconds > 0:
+        ok, msg = user_manager.check_duration_limit(email, duration_seconds)
+        if not ok:
+            return False, msg, status
+
+    return True, "Ready to process", status
+
+
+def deduct_token(email: str) -> Tuple[bool, str]:
+    """Deduct one token after successful processing"""
+    return user_manager.use_tokens(email, 1)
+
+
+def get_status_display(email: str) -> str:
+    """Get formatted status for UI display"""
+    if not email:
+        return "DEMO MODE: 3 free tokens | 5-min track limit | Enter email to track usage"
+
+    status = user_manager.get_user_status(email)
+
+    if status['unlimited']:
+        return f"CREATOR: {status['name']} | UNLIMITED ACCESS"
+
+    if status['license_type'] != 'DEMO':
+        return f"LICENSED ({status['license_type']}): {status['tokens_remaining']} tokens remaining this month"
+
+    return f"DEMO: {status['tokens_remaining']}/{DEMO_TOKENS} tokens | 5-min limit | Upgrade for full access"
+
+
+# ============================================================================
+# CLI FOR TESTING
+# ============================================================================
+
+if __name__ == "__main__":
+    import sys
+
+    print("VYNL Token System")
+    print("=" * 50)
+
+    if len(sys.argv) < 2:
+        print("""
+Commands:
+    status <email>           Check user status
+    create <email> <pass>    Create account
+    grant <email> <tokens>   Add tokens to grants file
+    activate <email> <key>   Activate license
+        """)
+        sys.exit(0)
+
+    cmd = sys.argv[1]
+
+    if cmd == "status" and len(sys.argv) >= 3:
+        email = sys.argv[2]
+        status = user_manager.get_user_status(email)
+        print(json.dumps(status, indent=2))
+
+    elif cmd == "create" and len(sys.argv) >= 4:
+        email, password = sys.argv[2], sys.argv[3]
+        ok, msg = user_manager.create_account(email, password)
+        print(f"{'Success' if ok else 'Failed'}: {msg}")
+
+    elif cmd == "grant" and len(sys.argv) >= 4:
+        email, tokens = sys.argv[2], sys.argv[3]
+        # Append to grants file
+        with open(TOKENS_FILE, 'a') as f:
+            f.write(f"{email},{tokens}\n")
+        print(f"Added {tokens} tokens for {email}")
+
+    elif cmd == "activate" and len(sys.argv) >= 4:
+        email, key = sys.argv[2], sys.argv[3]
+        ok, msg = user_manager.activate_license(email, key)
+        print(f"{'Success' if ok else 'Failed'}: {msg}")