Upload sAI.png

.gitattributes

@@ -0,0 +1,36 @@
+*.7z filter=lfs diff=lfs merge=lfs -text
+*.arrow filter=lfs diff=lfs merge=lfs -text
+*.bin filter=lfs diff=lfs merge=lfs -text
+*.bz2 filter=lfs diff=lfs merge=lfs -text
+*.ckpt filter=lfs diff=lfs merge=lfs -text
+*.ftz filter=lfs diff=lfs merge=lfs -text
+*.gz filter=lfs diff=lfs merge=lfs -text
+*.h5 filter=lfs diff=lfs merge=lfs -text
+*.joblib filter=lfs diff=lfs merge=lfs -text
+*.lfs.* filter=lfs diff=lfs merge=lfs -text
+*.mlmodel filter=lfs diff=lfs merge=lfs -text
+*.model filter=lfs diff=lfs merge=lfs -text
+*.msgpack filter=lfs diff=lfs merge=lfs -text
+*.npy filter=lfs diff=lfs merge=lfs -text
+*.npz filter=lfs diff=lfs merge=lfs -text
+*.onnx filter=lfs diff=lfs merge=lfs -text
+*.ot filter=lfs diff=lfs merge=lfs -text
+*.parquet filter=lfs diff=lfs merge=lfs -text
+*.pb filter=lfs diff=lfs merge=lfs -text
+*.pickle filter=lfs diff=lfs merge=lfs -text
+*.pkl filter=lfs diff=lfs merge=lfs -text
+*.pt filter=lfs diff=lfs merge=lfs -text
+*.pth filter=lfs diff=lfs merge=lfs -text
+*.rar filter=lfs diff=lfs merge=lfs -text
+*.safetensors filter=lfs diff=lfs merge=lfs -text
+saved_model/**/* filter=lfs diff=lfs merge=lfs -text
+*.tar.* filter=lfs diff=lfs merge=lfs -text
+*.tar filter=lfs diff=lfs merge=lfs -text
+*.tflite filter=lfs diff=lfs merge=lfs -text
+*.tgz filter=lfs diff=lfs merge=lfs -text
+*.wasm filter=lfs diff=lfs merge=lfs -text
+*.xz filter=lfs diff=lfs merge=lfs -text
+*.zip filter=lfs diff=lfs merge=lfs -text
+*.zst filter=lfs diff=lfs merge=lfs -text
+*tfevents* filter=lfs diff=lfs merge=lfs -text
+sAI.png filter=lfs diff=lfs merge=lfs -text

.github/workflows/sync-to-hf.yml

@@ -1,20 +0,0 @@
-name: Sync to Hugging Face Spaces
-on:
-  push:
-    branches: [main]
-
-jobs:
-  sync:
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v4
-        with:
-          fetch-depth: 0
-          lfs: true
-      - name: Push to HuggingFace
-        env:
-          HF_TOKEN: ${{ secrets.HF_TOKEN }}
-        run: |
-          git remote add hf https://AnimalMonk:$HF_TOKEN@huggingface.co/spaces/AnimalMonk/audio-mastering-suite || true
-          git fetch hf || true
-          git push hf main:main --force

.gitignore

@@ -1,6 +0,0 @@
-__pycache__/
-*.pyc
-*.wav
-nul
-ANALOG_SCHEMATIC.pdf
-sAI.png

CHANGELOG.md

@@ -1,292 +1,5 @@
 # Changelog — Audio Mastering Suite
 
-## v4.2.1 — 2026-03-20
-
-### Super AI — Slider Overflow Fix
-- **Super AI no longer maps parameters back to UI sliders** — The full parametric params (6-band EQ with arbitrary frequencies, per-band compression) exceed the slider ranges (e.g. bass freq slider max 100 Hz, but AI might use 249 Hz). Sliders now stay untouched after Super AI runs. Full settings are displayed in the DSP Settings table and Applied Settings report.
-
-### Gemini Reliability
-- **3-retry logic with escalating delays** — On 503 errors, waits 10s, 20s, 30s between retries before failing. Timeout increased to 120s per call.
-- **15-second cooldown between Gemini calls** — Prevents rapid-fire API calls in Auto Master (4 calls) and Super AI (5 calls)
-- **GeminiUnavailableError** — Clear error message shown to user: "This is an issue with Google's AI servers, not with StudioAI." Process aborts without consuming a usage credit.
-- **Usage credits only consumed on success** — `_check_ai_key(consume=True)` only called after all passes complete successfully
-
-### Memory Management
-- **gc.collect() at start of each run** — Frees previous run's data before starting a new Auto Master or Super AI. No mid-pipeline garbage collection (was causing issues).
-
-### GitHub → HuggingFace Auto-Deploy
-- **GitHub Action workflow** — Every push to `main` auto-syncs to HuggingFace Spaces. Binary files (PDF, PNG) excluded from git and uploaded directly to HF.
-
----
-
-## v4.2 — 2026-03-20
-
-### Super AI — 6-Band Parametric EQ
-- **Expanded from 4 to 6 parametric EQ bands** — AI now has 6 independently configurable bands (peak/low_shelf/high_shelf with freq, gain, Q). Provides room for both tonal shaping and surgical notch cuts without trade-offs
-- **Updated all prompts, clamp functions, DSP loops, and display reports** to handle bands 5 and 6
-
-### Super AI — Bass Protection Prompts
-- **"HEAVY, UNCONSTRAINED BASS" directive** — AI is now explicitly instructed to prioritize additive EQ for bass weight, never over-compress <200 Hz, and default low-band compressor to bypass (ratio 1:1) on low-crest-factor material
-- **Crest factor check between passes** — If crest factor in <200 Hz range decreases between passes, AI must back off low-band compression
-- **Sidechain emulation note** — AI treats low-band compressor as if it has a 100 Hz HPF on its sidechain detector (slow attack / low ratio to preserve kick transients)
-- **HPF frequency cap** — Must stay at or below 25 Hz for bass-heavy material
-- **"LESS IS MORE" philosophy** — AI instructed to use the minimum processing needed, every parameter must have a reason, gentle moves preferred
-
-### Super AI — Tighter Parameter Clamps
-- **EQ gain clamped to ±6 dB** (was ±12 dB) — prevents overly aggressive EQ moves
-- **Compression threshold clamped to -20 dB minimum** (was -40 dB) — prevents always-on compression
-- **Compression ratio clamped to 4.0:1 maximum** (was 20.0:1) — prevents brick-wall limiting behavior
-
-### DSP Settings Table
-- **DSP settings now displayed side-by-side with Loudness Statistics** — New `dsp_display` Markdown component in a `gr.Row()` shows all applied parameters (HPF, EQ bands, crossovers, per-band compression, stereo width) next to the LUFS/true peak table
-- **Works for all modes** — Manual mastering, Auto Master, and Super AI all populate the DSP table
-
-### AI Context Clearing
-- **Analysis history cleared on each Auto Master / Super AI run** — `analysis_history_state` is reset to `[]` on the first yield, preventing previous test runs from influencing new mastering sessions
-
-### Unkey API Key Validation
-- **Replaced hardcoded AI_ACCESS_KEY with Unkey API verification** — `_check_ai_key()` now validates against Unkey's v2 API with per-key rate limiting and tier-based master counts
-- **Usage tracking** — Each AI operation decrements the key's `remaining` count; keys with 0 remaining are rejected with a "limit reached" message
-- **Tier metadata** — Keys store tier (starter/pro/studio), email, and Stripe customer ID
-
-### Pricing Page (new HF Space)
-- **New `AnimalMonk/studio-ai-pricing` Space** — Pure HTML/FastAPI pricing page with Stripe Payment Links for Starter ($9/10 masters), Pro ($24/30 masters), and Studio ($49/100 masters)
-- **Stripe webhook integration** — `checkout.session.completed` creates Unkey API keys automatically with tier-appropriate rate limits
-- **Success page** — Post-purchase redirect displays the API key with copy button
-- **Key lookup** — Email-based key recovery searches Unkey by email metadata
-- **Resend email integration** — API key delivered via email on purchase (pending domain verification)
-
-### Schematic PDF — Pages 4 & 5
-- **Page 4: Super AI 5-Pass Workflow** — Visual diagram of the iterative refinement loop, full parametric parameter table with ranges, fixed vs AI-controlled stages
-- **Page 5: AI Prompting Philosophy** — Mastering philosophy, tonal direction (warm + enhanced bass), true peak guidance (soft goal), compare pass guidelines, final report structure
-- **Version bumped to v4.1** in PDF title
-
----
-
-## v3.9 — 2026-03-18
-
-### Maximizer Removed
-- **Removed iterative gain + brick-wall limiter loop** — The maximizer was designed to push true peak into the -1.0 to -0.1 dBTP range by iteratively boosting gain, limiting peaks, and re-normalizing. In practice, this created a dynamics death spiral: each iteration crushed crest factor further, producing a flat "sausage" waveform with no dynamics — while still failing to push true peak into range on already-compressed source material
-- **`_maximize()` function deleted** from `dsp.py`, `Limiter` import removed
-- **Removed from both `master_audio()` and `master_audio_full()` pipelines**
-
-### Super AI Prompt Updates
-- **True peak is now a soft goal, not a hard constraint** — The -1.0 to -0.1 dBTP range is ideal but the AI is explicitly told NOT to over-compress or crush dynamics to achieve it
-- **Added source material awareness** — Prompts now explain that heavily limited source material (Suno, Udio, AI-generated tracks) has low crest factor, and when normalized to streaming LUFS targets the true peak will naturally land well below -1.0 dBTP — this is correct and expected
-- **Tonal direction added to all Super AI prompts** — Slightly warm overall tone (low-mid richness 200-500 Hz, smooth non-harsh highs) with slightly enhanced bass response
-- **Maximizer references removed** from signal flow documentation in all prompts
-
-### Signal Flow (both pipelines)
-```
-Pre-Gain Drop (-18 LUFS) → HPF → EQ → Multiband Compression (3-band) → Stereo Width → LUFS Normalization → Soft Clipper → True Peak Ceiling → Output
-```
-
----
-
-## v3.8 — 2026-03-18
-
-### Super AI (beta)
-- **New "Super AI (beta)" button** — 5-pass AI mastering with full parametric control. The AI controls every parameter in the signal chain: 4-band parametric EQ (peak/low_shelf/high_shelf with configurable freq, gain, Q), per-band multiband compression (independent threshold, ratio, attack, release), adjustable crossover frequencies, HPF frequency, and stereo width
-- **`master_audio_full()`** — New DSP function accepting granular per-band parameters instead of slider values
-- **5-pass workflow:** (1) AI analyzes raw audio → full settings → master, (2-4) AI compares and makes small incremental adjustments → re-master, (5) Final quality report only
-- **Session-persistent history** — AI maintains full context across all 5 passes to prevent oscillation
-- **Safety clamps** in both `_clamp_super_params()` (analysis) and `master_audio_full()` (DSP) prevent dangerous parameter values
-
-### Soft Clipper & True Peak Ceiling
-- **Piecewise tanh soft clipper** added as safety net — knee at 2 dB below -0.1 dBTP ceiling, linear below knee, tanh saturation above
-- **True peak ceiling** at -0.1 dBTP — scales signal down if residual inter-sample peaks exceed ceiling after 4x oversampled measurement (ITU-R BS.1770)
-
----
-
-## v3.7 — 2026-03-11
-
-### Auto Master
-- **New "Auto Master" button** — One-click iterative AI mastering loop: AI Recommend → Master → AI Compare with revised values → Re-master → AI Compare → Re-master → Final AI Compare report. 3 mastering passes, 4 Gemini API calls, ~2 minutes
-- **`compare_master_structured()`** — New analysis function that returns both a markdown comparison report and structured JSON slider values, enabling the auto-master loop to apply AI-suggested adjustments automatically
-- **`_clamp_settings()` / `_strip_json()` helpers** — Extracted shared utilities from `recommend_settings()` for reuse by the new structured compare function
-
-### UI Improvements
-- **AI Compare button hidden until mastered** — Now starts invisible and appears alongside the Download button only after mastering completes
-- **AI comparison report moved above mastered playback** — Report text displays above the audio player for better reading flow
-- **AI Reasoning display moved below upload** — AI Recommend analysis text now appears directly below the file upload block
-- **Browser password autofill disabled** on the AI Access Key field to prevent the password manager from covering the Preset dropdown
-
----
-
-## v3.6 — 2026-03-11
-
-### Signal Flow Reorder — Compression Before Stereo Width
-- **Multiband compression moved before stereo width** — Industry research (iZotope, Waves, FabFilter, Bob Katz, Berklee) shows ~90% consensus: dynamics processing should see the EQ'd signal without M/S side-channel energy affecting per-band behaviour. Stereo width now operates on the dynamically settled signal for stable, predictable imaging
-- **New signal flow:** `Pre-Gain Drop (-18 LUFS) → HPF 15 Hz → EQ → Multiband Compression (3-band) → Stereo Width → LUFS Normalization → Output`
-- **Old signal flow:** `... → EQ → Stereo Width → Multiband Compression → LUFS Normalization → Output`
-
-### Updated Files
-- **`dsp.py`** — Stage 3 = Multiband Compression, Stage 4 = Stereo Width (was reversed)
-- **`analysis.py`** — AI signal flow prompts updated to match new stage order
-- **`build_schematic.py`** — Schematic page layout, gear rack table, and signal flow diagram all updated; version bumped to v3.6
-- **`ANALOG_SCHEMATIC.pdf`** — Regenerated with correct stage ordering
-
-### UI Layout Rearrangement
-- **"Apply AI Settings" button moved above "Master It!"** — One-click AI settings are now immediately visible before mastering
-- **"AI Compare Original vs Master" button moved** to the old "Apply AI Settings" location (below sliders, above playback)
-- **AI comparison report text** now displays directly below its trigger button
-
----
-
-## v3.5.1 — 2026-03-11
-
-### Bug Fix
-- **AI Recommend "markdown string" fix** — Gemini was returning the JSON template placeholder `"markdown string"` literally instead of generating actual analysis. Updated the prompt template with an explicit example and instruction not to return it verbatim
-
-### Schematic PDF v3.5
-- **ANALOG_SCHEMATIC.pdf regenerated** with multiband compression architecture:
-  - Stage 4 now shows 3-band compressor with crossover sub-box, per-band parameter columns, and color-coded bands
-  - Gear rack table updated: 3U SSL G384 / Manley Vari-Mu / Maselec MLA-3 (was 2U single-band)
-  - Signal flow diagram updated: "Multiband Comp (3-Band)" replaces "Comp"
-  - Total rack space: 9U (was 8U)
-- **`build_schematic.py` included** in repo for reproducible PDF generation
-
----
-
-## v3.5 — 2026-03-11
-
-### Multiband Compression
-- **3-band multiband compression replaces single-band** — Signal is split at 200 Hz and 4 kHz using Linkwitz-Riley 4th-order crossovers (zero-phase, perfect reconstruction)
-- **Per-band parameter curves** tuned to industry mastering best practices:
-  - **Low (< 200 Hz):** Firmest control, slow 80 ms attack (kick punch-through), ratio 1.2:1 → 2.5:1, threshold -16 → -24 dB
-  - **Mid (200 Hz – 4 kHz):** Lightest touch (vocal/instrument preservation), 30 ms attack, ratio 1.1:1 → 2.0:1, threshold -14 → -22 dB
-  - **High (> 4 kHz):** Barely compresses (harsh transient taming only), fast 10 ms attack, ratio 1.05:1 → 1.5:1, threshold -12 → -18 dB
-- **Same single slider (0-100)** — No UI changes. Same true bypass at slider = 0. Slider drives all three bands in parallel
-- **No makeup gain** — LUFS normalization handles output level (unchanged)
-
-### AI Prompt Updates
-- **Signal flow description updated** to reflect multiband architecture with per-band parameter ranges
-- **AI comparison report now shows per-band compression parameters** (low/mid/high threshold, ratio, attack, release)
-- **AI prompts updated** with full signal flow context including crossover frequencies and band-specific behavior
-
-### Technical
-- `linkwitz_riley_crossover()` made public in `stereo.py` (was private `_linkwitz_riley_crossover()`)
-- New `map_multiband_compression()` function in `dsp.py`
-- Old `map_compression()` retained as deprecated for backward compatibility
-- No new pip dependencies — uses existing scipy + pedalboard
-
-### Updated Signal Flow
-```
-Pre-Gain Drop (-18 LUFS) → HPF 15 Hz → EQ → Stereo Width → Multiband Compression (3-band) → LUFS Normalization → Output
-```
-
----
-
-## v3.4 — 2026-03-11
-
-### Filter & Compression Fixes
-- **HPF lowered from 20 Hz to 15 Hz** — Old 20 Hz cutoff caused ~0.6 dB loss at 35 Hz. New 15 Hz cutoff is negligible above 35 Hz (-0.1 dB) while still cleaning subsonic rumble
-- **LPF at 20 kHz removed** — Was rolling off -1.2 dB at 15 kHz, fighting the 10 kHz high shelf in the air zone and muddying HF shaping. Source audio is already band-limited by sample rate (Nyquist)
-- **Compressor now bypasses at slider = 0** — Previously ran a 1.1:1 ratio compressor even at zero. Now truly bypasses when compression slider is at 0
-
-### Spectrum Visualization Overhaul
-- **Level-aligned spectral comparison** — Mastered spectrum is aligned to the original's average level (100 Hz – 10 kHz passband), so the plot compares spectral *shape* instead of absolute loudness
-- **Processing difference trace** — New green Δ dB subplot shows exactly what the mastering chain changed at each frequency (flat at 0 = no change, negative = cut, positive = boost)
-- **Fixed false sub-bass loss display** — Old plot showed absolute levels, making the uniform loudness difference (e.g. -9 → -14 LUFS) look like disproportionate bass loss
-
-### Updated Signal Flow
-```
-Pre-Gain Drop (-18 LUFS) → HPF 15 Hz → EQ → Stereo Width → Compression → LUFS Normalization → Output
-```
-
----
-
-## v3.3 — 2026-03-10
-
-### AI Analysis (Gemini Pro 3.1)
-- **AI Recommend button** — Analyzes uploaded audio (spectral profile, dynamics, stereo field) and recommends optimal mastering settings via Google Gemini Pro 3.1
-- **Apply AI Settings** — One-click button to populate all 7 sliders with AI-recommended values
-- **Post-master AI report** — After mastering, Gemini compares original vs mastered audio and provides a quality assessment with actionable feedback
-- **Audio feature extraction** — New `analysis.py` module: spectral centroid, spectral rolloff, 6-band energy distribution, crest factor, dynamic range, stereo correlation
-- **Graceful degradation** — If `GOOGLE_API_KEY` is not set, AI features show a helpful message instead of crashing
-
-### Premium Access Key
-- **AI features gated behind access key** — Users must enter a valid access key to use AI Recommend and post-master AI report
-- Premium prompt directs users to the StudioAI Discord for access
-- Access key validated against `AI_ACCESS_KEY` HF Space secret
-
-### Technical
-- **Gemini REST API** — Uses direct HTTP calls instead of the `google-generativeai` SDK (avoids 200 MB grpcio/protobuf dependency)
-- No new pip dependencies — uses `requests` bundled with Gradio
-
----
-
-## v3.2 — 2026-03-04
-
-### Genre Expansion
-- **6 new presets added:** Indie / Alt-Rock (Organic & Glued), R&B / Soul (Silky & Smooth), Lo-Fi / Chillhop (Dusty & Narrow), Jazz (Live & Dynamic), Reggae / Dub (Heavy Sound System), Synthwave / Retrowave (Analog & Driving)
-- Total preset count: **14 genres**
-
-### Limiter Removed
-- **Removed Pedalboard safety limiter** — JUCE-based Limiter was applying automatic makeup gain, pushing output ~4 dB above the target LUFS (e.g. -10 LUFS when targeting -14). Signal flow now ends cleanly at LUFS normalization.
-- Removed limiter gain reduction from stats display
-
-### UI Fixes
-- **Bass frequency slider expanded** — Range changed from 50–60 Hz to **40–100 Hz** to support genres like Reggae (80 Hz bass targeting)
-- **Highs slider label corrected** — Changed from "Highs (6 kHz)" to "Highs (10 kHz)" to match the actual HighShelfFilter frequency
-
-### Updated Signal Flow
-```
-Pre-Gain Drop (-18 LUFS) → HPF/LPF → EQ → Stereo Width → Compression → LUFS Normalization → Output
-```
-
----
-
-## v3.1 — 2026-03-03
-
-### Research-Backed Preset Audit
-All 8 presets audited against industry mastering best practices (iZotope, Waves, Sound On Sound, Mastering The Mix, Sage Audio, Nail The Mix, Attack Magazine, EDMProd, VI-Control).
-
-- **Vintage Analog:** bass_freq_hz 50→80 Hz (80 Hz = warmth/body, 50 Hz = sub-rumble)
-- **Hard Rock / Metal:** highs_db 1.0→0.5 (reduce harshness risk in fizz zone), bass_freq_hz 55→60 (kick thump sweet spot)
-- **Acoustic & Vocal:** Renamed "Transparent" → "Clear & Present", mid_boost_db 1.5→1.0 (was most aggressive mid boost of any preset)
-- **Hip-Hop / Boom Bap:** lows_db +0.5→-0.5 (cut low-mids, not boost — boom bap dips at 150 Hz), highs_db 0.0→-0.5 (rolled-off highs for signature lo-fi grit)
-- **Cinematic / Orchestral:** stereo_width 130→110 (research warns against aggressive wideners on orchestral), lows_db 1.0→0.5 (orchestral EQ moves should be 0.25-0.5 dB)
-- **New presets added:** Hip-Hop / Boom Bap (Punch & Grit), Cinematic / Orchestral (Dynamic & Wide)
-
-### EQ: High Shelf Raised to 10 kHz
-- **HighShelfFilter moved from 6 kHz to 10 kHz** — Research across all genres identifies 10-15 kHz as the "air" zone. The old 6 kHz shelf targeted upper-midrange presence/brightness instead of true air, and risked adding harshness in the 6-10 kHz fizz zone (especially problematic for metal and orchestral strings).
-
-### Stereo Width: Frequency-Selective M/S
-- **Bass below 200 Hz now stays untouched** — Added a Linkwitz-Riley 4th-order crossover at 200 Hz. Width adjustment (M/S encoding) applies only above the crossover. This keeps the low end tight and phase-coherent on club mono-sub systems and small speakers, matching the universal industry recommendation of "mono bass, wide highs."
-
----
-
-## v3.0 — 2026-03-03
-
-### Gain Staging Overhaul
-- **Pre-gain drop to -18 LUFS** — Hot inputs (e.g. Suno at -9 LUFS) are normalized to -18 LUFS before any processing, preventing EQ boosts from clipping the working audio
-- **Removed makeup gain** — LUFS normalization at the end handles volume; compressor makeup gain was redundant and caused cascading gain issues
-- **Removed auto-gain reduction stage** — No longer needed with the pre-gain architecture
-- **Simplified signal flow:** Pre-Gain Drop → Filters → EQ → Stereo Width → Compression → LUFS Normalize → Safety Limiter
-
-### Compression Recalibration
-- **Thresholds recalibrated for -18 LUFS working level** — Range changed from -6→-14 dB to **-14→-22 dB** so compression engages properly at the new internal level
-- **Ratio range tightened** — 1.1:1 → 2.5:1 (was 1:1 → 4:1) for safer mastering glue
-- **Attack fixed at 30 ms** (was 15 ms) to let transients breathe
-- **Release now variable** — 250 ms (less compression) → 100 ms (more compression)
-
-### Preset Retuning
-- All 5 original presets retuned with new compression values calibrated for the -18 LUFS working level
-- **New preset: Deep Ambient (Immersive & Sustained)** — Low compression (20), wide stereo (125%), air boost, sub-bass focus
-
-### UI & Visualization
-- **Download button moved** — Now appears directly under the Mastered playback box instead of at the bottom
-- **Spectrum plot height** — Matched to waveform plot height (8x4)
-- **Spectrum x-axis labels** — Changed from exponent notation to "10 Hz", "100 Hz", "1 kHz", "10 kHz"
-- **Logo & Discord link** — Added base64-embedded sAI logo with Discord.gg/StudioAI link in header
-
-### Statistics
-- Removed auto-gain reduction from stats display (no longer exists)
-- Gain staging table now shows only limiter gain reduction
-
----
-
 ## v2.3 — 2026-03-01
 
 ### Cleanup & HF Spaces Deployment

PRESETS_IMPROVEMENTS.md

@@ -1,407 +0,0 @@
-# Code Improvement Suggestions for presets.py
-
-## Overview
-The `presets.py` file contains audio mastering presets with good documentation but has several opportunities for refactoring, optimization, and better practices.
-
----
-
-## 1. **Data Validation & Type Safety**
-
-### Issue
-No validation of preset values. Invalid values could cause runtime errors in the audio processing pipeline.
-
-### Current Code
-```python
-PRESETS = {
-    "Modern Pop (Bright & Wide)": {
-        "compression": 80,
-        "stereo_width": 115,
-    },
-}
-```
-
-### Recommendation
-Add a `PresetConfig` dataclass or TypedDict with validation:
-
-```python
-from dataclasses import dataclass
-from typing import TypedDict, Optional, Literal
-
-class PresetConfig(TypedDict):
-    """Type definition for preset configuration."""
-    lows_db: float
-    mid_boost_db: float
-    highs_db: float
-    bass_boost_db: float
-    bass_freq_hz: int
-    compression: int  # 0-100
-    stereo_width: int  # 0-200
-
-@dataclass
-class AudioPreset:
-    """Validated audio preset with constraints."""
-    name: str
-    config: Optional[PresetConfig]
-    
-    def __post_init__(self):
-        if self.config is None:
-            return
-        
-        # Validate ranges
-        assert 0 <= self.config["compression"] <= 100, "Compression must be 0-100"
-        assert 0 <= self.config["stereo_width"] <= 200, "Stereo width must be 0-200"
-        assert 20 <= self.config["bass_freq_hz"] <= 200, "Bass freq must be 20-200 Hz"
-        assert -12 <= self.config["lows_db"] <= 12, "dB values must be -12 to +12"
-```
-
-**Benefits:**
-- Type hints enable IDE autocomplete and catch errors early
-- Runtime validation prevents invalid audio processing
-- Self-documenting code
-
----
-
-## 2. **Extract Magic Numbers to Constants**
-
-### Issue
-Hardcoded values (compression ranges, frequency limits, dB ranges) scattered throughout.
-
-### Current Code
-```python
-"compression": 80,        # Ratio ~2.2:1, Rel 130ms
-"stereo_width": 115,
-```
-
-### Recommendation
-```python
-# At the top of the file
-class AudioConstraints:
-    """Valid ranges for audio parameters."""
-    COMPRESSION_MIN = 0
-    COMPRESSION_MAX = 100
-    STEREO_WIDTH_MIN = 0
-    STEREO_WIDTH_MAX = 200
-    BASS_FREQ_MIN_HZ = 20
-    BASS_FREQ_MAX_HZ = 200
-    DB_MIN = -12
-    DB_MAX = 12
-
-# Then use in validation
-assert AudioConstraints.COMPRESSION_MIN <= config["compression"] <= AudioConstraints.COMPRESSION_MAX
-```
-
-**Benefits:**
-- Single source of truth for constraints
-- Easier to maintain and update limits
-- Self-documenting
-
----
-
-## 3. **Separate Metadata from Configuration**
-
-### Issue
-Comments explaining compression ratios and release times are mixed with data. This metadata should be structured.
-
-### Current Code
-```python
-"compression": 80,        # Ratio ~2.2:1, Rel 130ms (Snappy, cohesive glue)
-"stereo_width": 115,
-```
-
-### Recommendation
-```python
-PRESETS_METADATA = {
-    "Modern Pop (Bright & Wide)": {
-        "description": "Bright, punchy, and wide stereo field",
-        "use_cases": ["Pop", "Dance", "Electronic"],
-        "compression_details": {
-            "value": 80,
-            "ratio": "~2.2:1",
-            "release_ms": 130,
-            "character": "Snappy, cohesive glue"
-        },
-        "stereo_width_details": {
-            "value": 115,
-            "character": "Keeps the band feeling 'in the room'"
-        }
-    }
-}
-
-PRESETS = {
-    "-- None --": None,
-    "Modern Pop (Bright & Wide)": {
-        "lows_db": 0.0,
-        "mid_boost_db": 1.0,
-        "highs_db": 1.5,
-        "bass_boost_db": 1.0,
-        "bass_freq_hz": 60,
-        "compression": 80,
-        "stereo_width": 115,
-    },
-}
-```
-
-**Benefits:**
-- Cleaner data structure
-- Metadata can be used for UI tooltips/help
-- Easier to maintain documentation separately
-
----
-
-## 4. **Create a Preset Factory/Builder Pattern**
-
-### Issue
-Repetitive dictionary creation with potential for inconsistency.
-
-### Recommendation
-```python
-def create_preset(
-    lows_db: float,
-    mid_boost_db: float,
-    highs_db: float,
-    bass_boost_db: float,
-    bass_freq_hz: int,
-    compression: int,
-    stereo_width: int,
-) -> PresetConfig:
-    """Factory function to create and validate presets."""
-    config: PresetConfig = {
-        "lows_db": lows_db,
-        "mid_boost_db": mid_boost_db,
-        "highs_db": highs_db,
-        "bass_boost_db": bass_boost_db,
-        "bass_freq_hz": bass_freq_hz,
-        "compression": compression,
-        "stereo_width": stereo_width,
-    }
-    
-    # Validation happens here
-    AudioPreset("temp", config)  # Triggers __post_init__ validation
-    return config
-
-PRESETS = {
-    "-- None --": None,
-    "Modern Pop (Bright & Wide)": create_preset(
-        lows_db=0.0,
-        mid_boost_db=1.0,
-        highs_db=1.5,
-        bass_boost_db=1.0,
-        bass_freq_hz=60,
-        compression=80,
-        stereo_width=115,
-    ),
-}
-```
-
-**Benefits:**
-- Automatic validation on creation
-- Consistent structure
-- Easier to refactor later
-
----
-
-## 5. **Add Preset Lookup & Utility Functions**
-
-### Issue
-No helper functions to work with presets programmatically.
-
-### Recommendation
-```python
-def get_preset(name: str) -> Optional[PresetConfig]:
-    """Retrieve a preset by name."""
-    return PRESETS.get(name)
-
-def list_presets() -> list[str]:
-    """Get all available preset names."""
-    return [name for name in PRESETS.keys() if name != "-- None --"]
-
-def get_preset_info(name: str) -> dict:
-    """Get preset with metadata."""
-    if name not in PRESETS:
-        raise ValueError(f"Preset '{name}' not found")
-    
-    return {
-        "name": name,
-        "config": PRESETS[name],
-        "metadata": PRESETS_METADATA.get(name, {})
-    }
-```
-
-**Benefits:**
-- Encapsulation
-- Easier to test
-- Prevents direct dictionary access errors
-
----
-
-## 6. **Add Documentation & Docstrings**
-
-### Issue
-Module-level documentation is minimal.
-
-### Recommendation
-```python
-"""Preset definitions for the audio mastering suite.
-
-This module contains predefined audio mastering configurations optimized for
-different music genres and production styles. Each preset includes:
-- EQ settings (lows, mids, highs)
-- Bass boost parameters
-- Compression settings
-- Stereo width
-
-Presets are validated on load to ensure all values are within acceptable ranges.
-
-Example:
-    >>> preset = get_preset("Modern Pop (Bright & Wide)")
-    >>> if preset:
-    ...     apply_mastering(audio, preset)
-"""
-```
-
----
-
-## 7. **Consider Configuration File Format**
-
-### Issue
-Hardcoding presets in Python limits flexibility.
-
-### Recommendation
-Consider supporting JSON/YAML for easier editing:
-
-```python
-import json
-from pathlib import Path
-
-def load_presets_from_file(filepath: Path) -> dict:
-    """Load presets from JSON file."""
-    with open(filepath) as f:
-        return json.load(f)
-
-# presets.json
-{
-    "Modern Pop (Bright & Wide)": {
-        "lows_db": 0.0,
-        "mid_boost_db": 1.0,
-        ...
-    }
-}
-```
-
-**Benefits:**
-- Users can create custom presets without code changes
-- Easier to share presets
-- Decouples data from code
-
----
-
-## 8. **Add Preset Comparison & Diff Utilities**
-
-### Issue
-No way to compare presets or understand differences.
-
-### Recommendation
-```python
-def compare_presets(name1: str, name2: str) -> dict:
-    """Compare two presets and show differences."""
-    p1 = get_preset(name1)
-    p2 = get_preset(name2)
-    
-    if not p1 or not p2:
-        raise ValueError("One or both presets not found")
-    
-    differences = {}
-    for key in p1.keys():
-        if p1[key] != p2[key]:
-            differences[key] = {
-                "preset1": p1[key],
-                "preset2": p2[key],
-                "delta": p1[key] - p2[key]
-            }
-    
-    return differences
-```
-
----
-
-## 9. **Add Preset Versioning & Changelog**
-
-### Issue
-No way to track preset changes over time.
-
-### Recommendation
-```python
-PRESET_VERSION = "1.0.0"
-
-PRESET_CHANGELOG = {
-    "1.0.0": "Initial release with 8 genre presets",
-    "1.1.0": "Adjusted compression ratios for better transparency",
-}
-```
-
----
-
-## 10. **Specific Improvement for the Snippet**
-
-The specific code snippet you provided:
-```python
-"compression": 45,        # Moderate glue. Holds the band together without crushing dynamics.
-"stereo_width": 105,      # Keeps the band feeling "in the room"
-```
-
-### Improvements:
-
-1. **Extract comment metadata:**
-   ```python
-   "compression": 45,
-   "stereo_width": 105,
-   ```
-   With metadata stored separately:
-   ```python
-   "compression_details": {
-       "value": 45,
-       "character": "Moderate glue. Holds the band together without crushing dynamics."
-   }
-   ```
-
-2. **Add inline type hints in docstring:**
-   ```python
-   """
-   Preset configuration with validated audio parameters.
-   
-   compression (int): 0-100, where higher = more aggressive glue
-   stereo_width (int): 0-200, where 100 = mono, 200 = maximum width
-   """
-   ```
-
-3. **Consider semantic naming:**
-   ```python
-   # Instead of generic "compression", consider:
-   "compression_amount": 45,  # More explicit
-   "stereo_width_percent": 105,  # Clearer units
-   ```
-
----
-
-## Summary of Recommendations (Priority Order)
-
-| Priority | Recommendation | Impact |
-|----------|---|---|
-| **High** | Add type hints & validation | Prevents runtime errors |
-| **High** | Extract magic numbers to constants | Maintainability |
-| **Medium** | Add utility functions | Usability |
-| **Medium** | Separate metadata from config | Code clarity |
-| **Low** | Support external config files | Flexibility |
-| **Low** | Add comparison utilities | Developer experience |
-
----
-
-## Implementation Roadmap
-
-1. **Phase 1:** Add TypedDict/dataclass with validation
-2. **Phase 2:** Extract constants and add utility functions
-3. **Phase 3:** Separate metadata into dedicated structure
-4. **Phase 4:** Add comprehensive docstrings
-5. **Phase 5:** Consider external config file support
-
-

README.md

@@ -26,25 +26,25 @@ A web-based audio mastering tool built with Gradio and Spotify's Pedalboard DSP
 
 - **3-Band EQ** - Lows (200 Hz shelf), Mids (1.2 kHz peak), Highs (6 kHz shelf), each +/-3 dB
 - **Bass Boost** - Sub-bass enhancement (0-3 dB) with adjustable frequency (50-60 Hz)
-- **Compression** - Mastering glue calibrated for -18 LUFS working level (ratio 1.1:1-2.5:1, threshold -14 to -22 dB)
-- **Limiter** - Safety brick-wall at -1 dB ceiling to catch stray transients
+- **Compression** - Variable ratio (1:1 to 4:1) and threshold (-12 to -18 dB)
+- **Limiter** - Brick-wall at -1 dB with auto-gain reduction to keep limiter work under 4 dB
 - **Stereo Width** - M/S matrix stereo image control (80%-150%)
-- **LUFS Targeting** - Post-chain normalization to streaming (-14) or CD (-11) standards
-- **Pre-Gain Normalization** - Hot inputs (e.g. Suno at -9 LUFS) are dropped to -18 LUFS before processing to prevent EQ clipping
-- **Genre Presets** - Modern Pop, Vintage Analog, Heavy Trap/EDM, Hard Rock/Metal, Acoustic & Vocal, Deep Ambient
+- **LUFS Targeting** - Strict post-chain normalization to streaming (-14) or CD (-11) standards
+- **Genre Presets** - Modern Pop, Vintage Analog, Heavy Trap/EDM, Hard Rock/Metal, Acoustic & Vocal
 - **Visualization** - Before/after waveform and spectrum comparison
-- **Statistics** - Original vs mastered LUFS, true peak, limiter gain reduction
+- **Statistics** - Original vs mastered LUFS, true peak, gain staging metrics
 
 ## Signal Flow
 
 ```
-Pre-Gain Drop (normalize to -18 LUFS)
-  -> HPF 20 Hz + LPF 20 kHz (12 dB/oct)
+HPF 20 Hz + LPF 20 kHz (12 dB/oct)
   -> EQ (Bass Boost, Lows, Highs, Mids)
   -> Stereo Width (M/S processing)
-  -> Compression (no makeup gain)
-  -> Target LUFS Normalization (pyloudnorm)
-  -> Safety Limiter (-1 dB ceiling)
+  -> Compression + Makeup Gain
+  -> Auto Gain Reduction (caps limiter at 4 dB)
+  -> Limiter (-1 dB ceiling)
+  -> LUFS Normalization (pyloudnorm)
+  -> Safety Limiter (if true peaks exceed ceiling)
 ```
 
 ## Usage

analysis.py

@@ -1,1194 +0,0 @@
-# Build: 2026-03-21T15:25:58.145163+00:00
-"""AI-powered audio analysis using Gemini Pro — feature extraction and recommendations."""
-
-import json
-import os
-import numpy as np
-from scipy.signal import welch
-
-
-# ---------------------------------------------------------------------------
-# Audio feature extraction
-# ---------------------------------------------------------------------------
-
-_BANDS = [
-    ("Sub-bass", 20, 60),
-    ("Bass", 60, 250),
-    ("Low-Mids", 250, 500),
-    ("Mids", 500, 2000),
-    ("Upper-Mids", 2000, 6000),
-    ("Highs", 6000, 20000),
-]
-
-
-def extract_features(audio, sample_rate):
-    """Extract audio features for AI analysis (basic — used by Auto Master).
-
-    Args:
-        audio: numpy array, shape (samples,) or (samples, channels).
-        sample_rate: int.
-
-    Returns:
-        dict with spectral, dynamic, and stereo measurements.
-    """
-    # Convert to mono for spectral analysis
-    if audio.ndim == 2:
-        mono = audio.mean(axis=1)
-    else:
-        mono = audio
-
-    # --- Spectral analysis via Welch ---
-    nperseg = min(8192, len(mono))
-    freqs, psd = welch(mono, fs=sample_rate, nperseg=nperseg)
-
-    # Spectral centroid
-    total_energy = np.sum(psd)
-    if total_energy > 0:
-        spectral_centroid = float(np.sum(freqs * psd) / total_energy)
-    else:
-        spectral_centroid = 0.0
-
-    # Spectral rolloff (85%)
-    cumulative = np.cumsum(psd)
-    if total_energy > 0:
-        rolloff_idx = np.searchsorted(cumulative, 0.85 * total_energy)
-        spectral_rolloff = float(freqs[min(rolloff_idx, len(freqs) - 1)])
-    else:
-        spectral_rolloff = 0.0
-
-    # Band energy distribution (dB) — use float() to avoid numpy float32
-    band_energy = {}
-    for name, lo, hi in _BANDS:
-        mask = (freqs >= lo) & (freqs < hi)
-        band_rms = float(np.sqrt(np.mean(psd[mask]))) if np.any(mask) else 0.0
-        if band_rms > 0:
-            band_energy[name] = round(20.0 * np.log10(band_rms), 1)
-        else:
-            band_energy[name] = -100.0
-
-    # --- Dynamics (cast to Python float for JSON serialization) ---
-    rms = float(np.sqrt(np.mean(mono ** 2)))
-    peak = float(np.max(np.abs(mono)))
-
-    rms_db = round(20.0 * np.log10(rms), 1) if rms > 0 else -100.0
-    peak_db = round(20.0 * np.log10(peak), 1) if peak > 0 else -100.0
-    crest_factor = round(peak_db - rms_db, 1)
-    dynamic_range = crest_factor  # simplified: same as crest factor for full-file
-
-    # --- Stereo correlation ---
-    is_mono = audio.ndim == 1 or audio.shape[1] == 1
-    if not is_mono:
-        left = audio[:, 0]
-        right = audio[:, 1]
-        correlation = np.corrcoef(left, right)[0, 1]
-        stereo_correlation = round(float(correlation), 3)
-    else:
-        stereo_correlation = None
-
-    # --- Loudness (reuse existing functions, lazy import) ---
-    from loudness import measure_loudness, measure_true_peak
-    lufs = measure_loudness(audio, sample_rate)
-    true_peak = measure_true_peak(audio, sample_rate)
-
-    return {
-        "spectral_centroid_hz": round(float(spectral_centroid), 1),
-        "spectral_rolloff_hz": round(float(spectral_rolloff), 1),
-        "band_energy": band_energy,
-        "rms_db": float(rms_db),
-        "peak_db": float(peak_db),
-        "crest_factor_db": float(crest_factor),
-        "dynamic_range_db": float(dynamic_range),
-        "stereo_correlation": stereo_correlation,
-        "lufs": round(float(lufs), 1) if not np.isinf(lufs) else -100.0,
-        "true_peak_dbtp": float(true_peak),
-        "is_mono": is_mono,
-    }
-
-
-# ---------------------------------------------------------------------------
-# Detailed feature extraction — Super AI mode
-# ---------------------------------------------------------------------------
-
-# 24 analysis bands for fine-grained spectral view
-_DETAIL_BANDS = [
-    ("20-40",    20,    40),
-    ("40-60",    40,    60),
-    ("60-100",   60,   100),
-    ("100-150", 100,   150),
-    ("150-200", 150,   200),
-    ("200-300", 200,   300),
-    ("300-400", 300,   400),
-    ("400-600", 400,   600),
-    ("600-800", 600,   800),
-    ("800-1k",  800,  1000),
-    ("1k-1.5k", 1000, 1500),
-    ("1.5k-2k", 1500, 2000),
-    ("2k-3k",   2000, 3000),
-    ("3k-4k",   3000, 4000),
-    ("4k-5k",   4000, 5000),
-    ("5k-6k",   5000, 6000),
-    ("6k-8k",   6000, 8000),
-    ("8k-10k",  8000, 10000),
-    ("10k-12k", 10000, 12000),
-    ("12k-16k", 12000, 16000),
-    ("16k-20k", 16000, 20000),
-]
-
-# 3 compression bands matching the DSP crossover defaults
-_COMP_BANDS = [
-    ("low",  20,  200),
-    ("mid",  200, 4000),
-    ("high", 4000, 20000),
-]
-
-
-def extract_features_detailed(audio, sample_rate):
-    """Extract rich spectral + dynamic features for Super AI mode.
-
-    Builds on extract_features() and adds:
-      - 24-band spectral profile (fine-grained EQ map)
-      - Spectral peak/resonance detection (top problematic frequencies)
-      - Per-compression-band dynamics (RMS, peak, crest factor)
-      - Spectral flatness (tonal vs noisy character)
-      - Spectral tilt (bass-heavy vs bright)
-      - Short-time dynamic variation (verse vs chorus energy)
-      - Per-band stereo correlation
-
-    All numpy — runs in milliseconds on CPU.
-    """
-    from scipy.signal import find_peaks
-
-    base = extract_features(audio, sample_rate)
-
-    if audio.ndim == 2:
-        mono = audio.mean(axis=1)
-    else:
-        mono = audio
-
-    # --- High-resolution spectral analysis ---
-    nperseg = min(16384, len(mono))
-    freqs, psd = welch(mono, fs=sample_rate, nperseg=nperseg)
-
-    # 24-band spectral profile (dB)
-    spectral_profile = {}
-    for name, lo, hi in _DETAIL_BANDS:
-        mask = (freqs >= lo) & (freqs < hi)
-        if np.any(mask):
-            band_rms = float(np.sqrt(np.mean(psd[mask])))
-            spectral_profile[name] = round(20.0 * np.log10(max(band_rms, 1e-12)), 1)
-        else:
-            spectral_profile[name] = -100.0
-
-    # --- Spectral peaks / resonances ---
-    # Smooth the PSD, find prominent peaks
-    psd_db = 10.0 * np.log10(np.maximum(psd, 1e-20))
-    # Use a wider window for smoothing to avoid noise peaks
-    kernel_size = min(31, len(psd_db) // 4)
-    if kernel_size % 2 == 0:
-        kernel_size += 1
-    if kernel_size >= 3:
-        kernel = np.ones(kernel_size) / kernel_size
-        psd_smooth = np.convolve(psd_db, kernel, mode="same")
-    else:
-        psd_smooth = psd_db
-
-    # Find peaks that stand out above the smoothed curve
-    prominence_threshold = 3.0  # at least 3 dB above neighbors
-    peak_indices, peak_props = find_peaks(
-        psd_db,
-        prominence=prominence_threshold,
-        distance=max(1, int(50 / (freqs[1] - freqs[0])))  # at least 50 Hz apart
-    )
-
-    # Sort by prominence and take top 8
-    if len(peak_indices) > 0:
-        prominences = peak_props["prominences"]
-        top_idx = np.argsort(prominences)[::-1][:8]
-        resonances = []
-        for idx in top_idx:
-            pi = peak_indices[idx]
-            if freqs[pi] >= 30:  # skip sub-bass noise
-                resonances.append({
-                    "freq_hz": round(float(freqs[pi]), 1),
-                    "level_db": round(float(psd_db[pi]), 1),
-                    "prominence_db": round(float(prominences[idx]), 1),
-                })
-    else:
-        resonances = []
-
-    # --- Spectral flatness (Wiener entropy) ---
-    # 1.0 = white noise, 0.0 = pure tone
-    psd_pos = psd[psd > 0]
-    if len(psd_pos) > 0:
-        geo_mean = np.exp(np.mean(np.log(psd_pos)))
-        arith_mean = np.mean(psd_pos)
-        spectral_flatness = round(float(geo_mean / arith_mean), 4)
-    else:
-        spectral_flatness = 0.0
-
-    # --- Spectral tilt (slope of energy across frequency) ---
-    # Negative = bass-heavy, positive = bright
-    if len(freqs) > 1 and np.any(psd > 0):
-        log_freqs = np.log10(np.maximum(freqs[1:], 1.0))  # skip DC
-        log_psd = 10.0 * np.log10(np.maximum(psd[1:], 1e-20))
-        coeffs = np.polyfit(log_freqs, log_psd, 1)
-        spectral_tilt = round(float(coeffs[0]), 2)  # dB/decade
-    else:
-        spectral_tilt = 0.0
-
-    # --- Per-compression-band dynamics ---
-    comp_band_dynamics = {}
-    for name, lo, hi in _COMP_BANDS:
-        mask = (freqs >= lo) & (freqs < hi)
-        if np.any(mask):
-            band_psd = psd[mask]
-            band_rms = float(np.sqrt(np.mean(band_psd)))
-            band_peak = float(np.sqrt(np.max(band_psd)))
-            rms_db = round(20.0 * np.log10(max(band_rms, 1e-12)), 1)
-            peak_db = round(20.0 * np.log10(max(band_peak, 1e-12)), 1)
-            comp_band_dynamics[name] = {
-                "rms_db": rms_db,
-                "peak_db": peak_db,
-                "crest_db": round(peak_db - rms_db, 1),
-            }
-        else:
-            comp_band_dynamics[name] = {"rms_db": -100.0, "peak_db": -100.0, "crest_db": 0.0}
-
-    # --- Short-time dynamic variation ---
-    # Split audio into ~4-second chunks and measure RMS of each
-    chunk_samples = int(4.0 * sample_rate)
-    n_chunks = max(1, len(mono) // chunk_samples)
-    chunk_rms_list = []
-    for i in range(n_chunks):
-        chunk = mono[i * chunk_samples : (i + 1) * chunk_samples]
-        c_rms = float(np.sqrt(np.mean(chunk ** 2)))
-        if c_rms > 0:
-            chunk_rms_list.append(20.0 * np.log10(c_rms))
-        else:
-            chunk_rms_list.append(-100.0)
-
-    if len(chunk_rms_list) > 1:
-        chunk_arr = np.array(chunk_rms_list)
-        dynamic_variation = {
-            "min_rms_db": round(float(np.min(chunk_arr)), 1),
-            "max_rms_db": round(float(np.max(chunk_arr)), 1),
-            "range_db": round(float(np.max(chunk_arr) - np.min(chunk_arr)), 1),
-            "std_db": round(float(np.std(chunk_arr)), 2),
-            "n_chunks": n_chunks,
-        }
-    else:
-        dynamic_variation = {
-            "min_rms_db": chunk_rms_list[0] if chunk_rms_list else -100.0,
-            "max_rms_db": chunk_rms_list[0] if chunk_rms_list else -100.0,
-            "range_db": 0.0, "std_db": 0.0, "n_chunks": 1,
-        }
-
-    # --- Per-band stereo correlation ---
-    is_mono = audio.ndim == 1 or audio.shape[1] == 1
-    stereo_band_corr = {}
-    if not is_mono:
-        from scipy.signal import butter, sosfilt
-
-        left = audio[:, 0].astype(np.float64)
-        right = audio[:, 1].astype(np.float64)
-
-        band_edges = [(20, 200), (200, 2000), (2000, 8000), (8000, min(20000, sample_rate // 2 - 1))]
-        band_names = ["low", "low_mid", "high_mid", "high"]
-
-        for bname, lo, hi in zip(band_names, *zip(*band_edges)):
-            try:
-                sos = butter(4, [lo, hi], btype="band", fs=sample_rate, output="sos")
-                l_filt = sosfilt(sos, left)
-                r_filt = sosfilt(sos, right)
-                corr = np.corrcoef(l_filt, r_filt)[0, 1]
-                stereo_band_corr[bname] = round(float(corr), 3)
-            except Exception:
-                stereo_band_corr[bname] = None
-
-    # --- Merge into base features ---
-    base["spectral_profile_24band"] = spectral_profile
-    base["resonances"] = resonances
-    base["spectral_flatness"] = spectral_flatness
-    base["spectral_tilt_db_per_decade"] = spectral_tilt
-    base["comp_band_dynamics"] = comp_band_dynamics
-    base["dynamic_variation"] = dynamic_variation
-    base["stereo_band_correlation"] = stereo_band_corr if not is_mono else None
-
-    return base
-
-
-# ---------------------------------------------------------------------------
-# Gemini API wrapper
-# ---------------------------------------------------------------------------
-
-class GeminiUnavailableError(Exception):
-    """Raised when Gemini API is unavailable after retries."""
-    pass
-
-
-def _call_gemini(system_prompt, user_prompt):
-    """Call Gemini 2.5 Pro via OpenRouter (preferred) or Google direct API.
-
-    Uses OPENROUTER_API_KEY if set, otherwise falls back to GOOGLE_API_KEY.
-    Retries up to 3 times on server errors (5xx) with escalating delays.
-    Raises GeminiUnavailableError on persistent failure.
-    """
-    import time
-    import requests as _requests
-
-    openrouter_key = os.environ.get("OPENROUTER_API_KEY")
-    google_key = os.environ.get("GOOGLE_API_KEY")
-
-    if not openrouter_key and not google_key:
-        return None
-
-    if openrouter_key:
-        # OpenRouter — OpenAI-compatible format
-        url = "https://openrouter.ai/api/v1/chat/completions"
-        headers = {
-            "Authorization": f"Bearer {openrouter_key}",
-            "Content-Type": "application/json",
-        }
-        payload = {
-            "model": "google/gemini-2.5-pro",
-            "messages": [
-                {"role": "system", "content": system_prompt},
-                {"role": "user", "content": user_prompt},
-            ],
-        }
-
-        def _parse_response(data):
-            return data["choices"][0]["message"]["content"]
-    else:
-        # Google direct API
-        url = (
-            "https://generativelanguage.googleapis.com/v1beta/models/"
-            f"gemini-2.5-pro:generateContent?key={google_key}"
-        )
-        headers = {"Content-Type": "application/json"}
-        payload = {
-            "system_instruction": {"parts": [{"text": system_prompt}]},
-            "contents": [{"role": "user", "parts": [{"text": user_prompt}]}],
-        }
-
-        def _parse_response(data):
-            return data["candidates"][0]["content"]["parts"][0]["text"]
-
-    last_error = None
-    retry_delays = [10, 20, 30]  # 3 retries: wait 10s, 20s, 30s
-    for attempt in range(4):  # initial + 3 retries
-        try:
-            resp = _requests.post(url, headers=headers, json=payload, timeout=120)
-            resp.raise_for_status()
-            data = resp.json()
-            return _parse_response(data)
-        except _requests.exceptions.HTTPError as e:
-            last_error = e
-            status = getattr(resp, "status_code", 0)
-            if status >= 500 and attempt < 3:
-                time.sleep(retry_delays[attempt])
-                continue
-            break
-        except Exception as e:
-            last_error = e
-            if attempt == 0:
-                time.sleep(5)
-                continue
-            break
-
-    provider = "OpenRouter" if openrouter_key else "Google Gemini"
-    raise GeminiUnavailableError(
-        f"**{provider} is temporarily unavailable.**\n\n"
-        "This is an issue with the AI provider's servers, not with StudioAI.\n\n"
-        "Please try again in a few minutes. If the problem persists, "
-        "try again in a few hours.\n\n"
-        "No usage credit was consumed for this attempt.\n\n"
-        f"*Technical details: {last_error}*"
-    )
-
-
-# ---------------------------------------------------------------------------
-# Phase 1: AI-recommended settings
-# ---------------------------------------------------------------------------
-
-_SIGNAL_FLOW = """
-SIGNAL FLOW (fixed processing order):
-1. PRE-GAIN DROP — Input is normalized to -18 LUFS internal working level (stepped attenuator). This prevents EQ clipping on hot masters.
-2. HPF 15 Hz — Always-on 2nd-order Butterworth high-pass filter (12 dB/oct). Subsonic cleanup only; -3 dB at 15 Hz, negligible loss above 35 Hz. There is NO low-pass filter — source is band-limited by sample rate (Nyquist).
-3. 4-BAND PARAMETRIC EQ (user-adjustable):
-   - Bass Boost: Peak filter (Q=2.0), variable center 40-100 Hz, range 0 to +3.0 dB, step 0.5 dB
-   - Lows: Low shelf at 200 Hz (Q=1.0), range -3.0 to +3.0 dB, step 0.5 dB
-   - Highs: High shelf at 10 kHz (Q=0.7, gentle slope), range -3.0 to +3.0 dB, step 0.5 dB — this is the "air" band, no LPF to fight it
-   - Mids: Peak filter at 1.2 kHz (Q=1.0, wide bell), range -3.0 to +3.0 dB, step 0.1 dB
-4. MULTIBAND COMPRESSION — 3-band dynamics processing (no makeup gain):
-   - Placed before stereo width so the compressor sees EQ'd audio without M/S side-channel energy affecting per-band behaviour.
-   - Two Linkwitz-Riley 4th-order crossovers split the signal at 200 Hz and 4 kHz.
-   - LOGARITHMIC SLIDER CURVE: The 0-100 slider uses a quadratic (t²) mapping — the bottom half of the slider (0-50) covers the transparent-to-light range, while aggressive compression is concentrated in the top 30% (70-100). This gives fine control in the musical "sweet spot."
-   - LOW band (< 200 Hz): Firmest control. Attack scales 80→20ms (lets kick breathe at low settings, catches bass transients at high). Ratio 1.2:1→3.0:1, threshold -16→-24 dB, release 200→120ms.
-   - MID band (200 Hz – 4 kHz): Musical peak control. Attack scales 30→10ms (transparent at low settings, tames snare/vocal peaks at high). Ratio 1.1:1→2.5:1, threshold -14→-24 dB, release 150→100ms.
-   - HIGH band (> 4 kHz): Transient control. Attack scales 10→3ms (light de-essing at low, catches cymbal/click transients at high). Ratio 1.05:1→2.0:1, threshold -12→-22 dB, release 80→40ms.
-   - TRUE BYPASS when slider = 0 (no compressor in chain at all).
-   - Higher compression values actively reduce the crest factor (peak-to-loudness ratio), which allows LUFS normalization to push louder without the true peak ceiling pulling level back down.
-   - Bands are summed back to full-range after compression. No makeup gain — LUFS normalization handles level.
-5. STEREO WIDTH — Frequency-selective M/S matrix (after dynamics for stable imaging):
-   - Linkwitz-Riley 4th-order crossover at 200 Hz splits signal into low band and high band
-   - Low band (< 200 Hz): untouched — keeps bass mono-safe
-   - High band (≥ 200 Hz): M/S encode → width scaling → M/S decode
-   - Energy-preserving: mid_scale = sqrt(2/(1+w²)), side_scale = w × mid_scale
-   - Range: 80% (narrow) to 150% (wide). 100% = no change. Clip protection after summing.
-6. LUFS NORMALIZATION — Measures integrated loudness (ITU-R BS.1770-4, K-weighted, gated) and applies uniform linear gain to hit the target LUFS exactly. Targets: -14 (streaming), -11 (CD), or custom.
-7. SOFT CLIPPER — Piecewise tanh saturation after LUFS normalization. A knee sits 2 dB below the -0.1 dBTP ceiling. Everything below the knee is perfectly linear (zero processing). Only the tips of peaks above the knee are shaped with a tanh curve that asymptotes to the ceiling. This is NOT a limiter — it's analog-style waveshaping that typically affects only the top 1-2 dB of the loudest transients. LUFS is preserved (transient tips contribute almost nothing to integrated loudness) while true-peak is reduced significantly.
-8. TRUE PEAK CEILING (safety net) — After the soft clipper, the true peak (4x oversampled, ITU-R BS.1770) is measured. If any residual inter-sample peaks still exceed -0.1 dBTP, the entire signal is scaled down by exactly the overshoot. This rarely engages thanks to the soft clipper, but guarantees compliance.
-"""
-
-_RECOMMEND_SYSTEM = f"""You are an expert audio mastering engineer. Analyze the audio measurements below and recommend optimal mastering settings for this tool.
-
-{_SIGNAL_FLOW}
-
-AVAILABLE CONTROLS (these are the ONLY parameters you can recommend):
-- lows_db: Low shelf at 200 Hz, -3.0 to +3.0 dB
-- mid_boost_db: Peak at 1.2 kHz (Q=1.0), -3.0 to +3.0 dB
-- highs_db: High shelf at 10 kHz (Q=0.7), -3.0 to +3.0 dB
-- bass_boost_db: Peak (Q=2.0), 0 to +3.0 dB
-- bass_freq_hz: Center freq for bass boost, 40-100 Hz
-- compression: 0 (bypass/off) to 100 (heavy). 0 = true bypass (no processing)
-- stereo_width: 80-150%. 100 = no change. Only affects frequencies above 200 Hz.
-
-IMPORTANT CONTEXT:
-- The 15 Hz HPF is always active and cannot be adjusted — do not try to compensate for it.
-- There is no LPF, so the 10 kHz high shelf has full authority over the air band with no interference.
-- LUFS normalization at the end restores loudness automatically — do not worry about overall level, focus on spectral balance and dynamics.
-- TRUE PEAK CEILING: A -0.1 dBTP ceiling is enforced after LUFS normalization. If the audio has a high crest factor (large peaks relative to loudness), the ceiling will pull the final level below the target LUFS. To allow the track to hit the target LUFS, recommend enough compression to reduce the crest factor. Look at the crest_factor_db measurement — values above ~10 dB suggest compression in the 40-70 range; above ~14 dB may need 60-85.
-- The compression slider uses a LOGARITHMIC (quadratic) curve. Slider values 0-50 cover subtle/transparent compression. Values 50-75 are moderate. Values 75-100 are aggressive. Recommend accordingly — a slider value of 30 is very light, 50 is moderate, 70+ is firm.
-- If the audio already sounds well-balanced, recommend conservative or zero settings. Not everything needs processing.
-
-Return ONLY a valid JSON object with these exact keys. The "reasoning" field must contain your actual markdown explanation (3-5 bullet points explaining why you chose these values):
-{{
-  "lows_db": number,
-  "mid_boost_db": number,
-  "highs_db": number,
-  "bass_boost_db": number,
-  "bass_freq_hz": integer,
-  "compression": integer,
-  "stereo_width": integer,
-  "reasoning": "### AI Analysis\\n- **Lows:** reason for lows_db choice\\n- **Highs:** reason for highs_db choice\\n- ... (write your actual analysis here, do NOT return this template literally)"
-}}
-
-Keep values within the valid ranges. Be conservative — subtle moves are better than aggressive ones."""
-
-
-def _clamp_settings(d):
-    """Clamp AI-returned slider values to valid ranges in-place and return *d*."""
-    d["lows_db"] = max(-3.0, min(3.0, float(d.get("lows_db", 0))))
-    d["mid_boost_db"] = max(-3.0, min(3.0, float(d.get("mid_boost_db", 0))))
-    d["highs_db"] = max(-3.0, min(3.0, float(d.get("highs_db", 0))))
-    d["bass_boost_db"] = max(0, min(3.0, float(d.get("bass_boost_db", 0))))
-    d["bass_freq_hz"] = max(40, min(100, int(d.get("bass_freq_hz", 60))))
-    d["compression"] = max(0, min(100, int(d.get("compression", 50))))
-    d["stereo_width"] = max(80, min(150, int(d.get("stereo_width", 100))))
-    return d
-
-
-def _strip_json(text):
-    """Strip markdown code fences from a JSON response and parse it."""
-    text = text.strip()
-    if text.startswith("```"):
-        lines = text.split("\n")
-        text = "\n".join(lines[1:-1])
-    return json.loads(text)
-
-
-def recommend_settings(audio_path):
-    """Analyze raw audio and return AI-recommended mastering settings.
-
-    Args:
-        audio_path: path to the uploaded audio file.
-
-    Returns:
-        dict with recommended slider values and reasoning markdown,
-        or None if AI is unavailable.
-    """
-    from dsp import load_audio
-    audio, sr = load_audio(audio_path)
-    features = extract_features(audio, sr)
-
-    user_prompt = f"""Analyze this audio and recommend mastering settings:
-
-**Audio Measurements:**
-- Integrated Loudness: {features['lufs']} LUFS
-- True Peak: {features['true_peak_dbtp']} dBTP
-- RMS Level: {features['rms_db']} dB
-- Crest Factor: {features['crest_factor_db']} dB
-- Spectral Centroid: {features['spectral_centroid_hz']} Hz
-- Spectral Rolloff (85%): {features['spectral_rolloff_hz']} Hz
-- Stereo Correlation: {features['stereo_correlation'] if features['stereo_correlation'] is not None else 'N/A (mono)'}
-- Mono: {features['is_mono']}
-
-**Band Energy (dB):**
-{chr(10).join(f'- {k}: {v} dB' for k, v in features['band_energy'].items())}
-
-Return the JSON object with recommended settings."""
-
-    response = _call_gemini(_RECOMMEND_SYSTEM, user_prompt)
-    if response is None:
-        return None
-
-    # Parse JSON from response (Gemini may wrap it in markdown code fence)
-    try:
-        result = _strip_json(response)
-        _clamp_settings(result)
-
-        if "reasoning" not in result:
-            result["reasoning"] = "*No explanation provided.*"
-
-        return result
-    except (json.JSONDecodeError, KeyError, TypeError):
-        return {"reasoning": response, "parse_error": True}
-
-
-# ---------------------------------------------------------------------------
-# Phase 2: Post-master comparison report
-# ---------------------------------------------------------------------------
-
-_COMPARE_SYSTEM = f"""You are an expert audio mastering engineer reviewing a completed master. You are evaluating the output of a specific mastering tool with the following architecture:
-
-{_SIGNAL_FLOW}
-
-IMPORTANT — When assessing the master:
-- The 15 Hz HPF is always active. Any sub-bass roll-off below ~30 Hz is intentional subsonic cleanup, NOT a problem. Do not flag it.
-- There is no LPF. The full spectrum above the HPF is passed through, so the 10 kHz high shelf has full authority over the air band.
-- LUFS normalization is the final stage — it applies uniform linear gain. Loudness differences between original and mastered are intentional (target LUFS). Focus on spectral shape and dynamics, not absolute level.
-- Compression at slider=0 means TRUE BYPASS (compressor was not in the chain at all). Do not comment on compression characteristics if it was bypassed.
-- Stereo width only affects frequencies above 200 Hz (Linkwitz-Riley crossover). Bass mono-compatibility is always preserved.
-- When suggesting improvements, ONLY recommend changes to the 7 available controls (lows_db, mid_boost_db, highs_db, bass_boost_db, bass_freq_hz, compression 0-100, stereo_width 80-150%). Do not suggest changes the tool cannot make (e.g., adjusting per-band attack times, changing crossover frequencies, changing the HPF frequency). The multiband compression is automatic — the user only controls the single 0-100 slider.
-- TRUE PEAK CEILING: If the mastered true peak is at -0.1 dBTP and the LUFS is below target, the peak ceiling pulled the level down. The fix is more compression (higher slider value) to reduce crest factor, NOT removing the ceiling. Mention this trade-off when relevant.
-- The compression slider uses a LOGARITHMIC (quadratic) curve: 0-50 = subtle/transparent, 50-75 = moderate, 75-100 = aggressive. Factor this into your slider recommendations.
-
-Format your response as markdown with these sections:
-### Overall Assessment
-(1-2 sentences — was the mastering effective for the material?)
-
-### What Worked Well
-(bullet points referencing specific measurement changes)
-
-### Suggested Improvements
-(bullet points with specific slider value recommendations using the 7 available controls. If the master is good, say so — not every master needs changes.)
-
-### Technical Notes
-(any concerns about dynamics, phase coherence, or frequency balance that the available controls could address)
-
-Be concise and specific. Reference actual measurement deltas between original and mastered."""
-
-
-def compare_master(original, mastered, sample_rate, settings_dict, history=None):
-    """Compare original vs mastered audio and return AI quality report.
-
-    Args:
-        original: numpy array of original audio.
-        mastered: numpy array of mastered audio.
-        sample_rate: int.
-        settings_dict: dict with the mastering settings that were applied.
-        history: list of dicts from previous analyses (optional).
-
-    Returns:
-        str: markdown-formatted comparison report, or fallback message.
-    """
-    orig_features = extract_features(original, sample_rate)
-    mast_features = extract_features(mastered, sample_rate)
-
-    # Build the multiband compression details from slider value
-    from dsp import map_multiband_compression
-    comp_val = settings_dict.get("compression", 50)
-    band_params = map_multiband_compression(comp_val)
-
-    def _fmt_band(params):
-        return (f"threshold {params[0]:.1f} dB, ratio {params[1]:.2f}:1, "
-                f"attack {params[2]:.0f} ms, release {params[3]:.0f} ms")
-
-    history_text = _format_history(history or [])
-
-    user_prompt = f"""Compare the original and mastered audio:
-
-**ORIGINAL Audio:**
-- Loudness: {orig_features['lufs']} LUFS | True Peak: {orig_features['true_peak_dbtp']} dBTP
-- RMS: {orig_features['rms_db']} dB | Crest Factor: {orig_features['crest_factor_db']} dB
-- Spectral Centroid: {orig_features['spectral_centroid_hz']} Hz | Rolloff: {orig_features['spectral_rolloff_hz']} Hz
-- Stereo Correlation: {orig_features['stereo_correlation'] if orig_features['stereo_correlation'] is not None else 'N/A (mono)'}
-- Band Energy: {json.dumps(orig_features['band_energy'])}
-
-**MASTERED Audio:**
-- Loudness: {mast_features['lufs']} LUFS | True Peak: {mast_features['true_peak_dbtp']} dBTP
-- RMS: {mast_features['rms_db']} dB | Crest Factor: {mast_features['crest_factor_db']} dB
-- Spectral Centroid: {mast_features['spectral_centroid_hz']} Hz | Rolloff: {mast_features['spectral_rolloff_hz']} Hz
-- Stereo Correlation: {mast_features['stereo_correlation'] if mast_features['stereo_correlation'] is not None else 'N/A (mono)'}
-- Band Energy: {json.dumps(mast_features['band_energy'])}
-
-**Settings Applied:**
-- Lows (200 Hz shelf): {settings_dict.get('lows_db', 0)} dB
-- Mids (1.2 kHz peak): {settings_dict.get('mid_boost_db', 0)} dB
-- Highs (10 kHz shelf): {settings_dict.get('highs_db', 0)} dB
-- Bass Boost: {settings_dict.get('bass_boost_db', 0)} dB @ {settings_dict.get('bass_freq_hz', 60)} Hz
-- Compression: slider {comp_val}/100 (multiband, 3 bands)
-  - Low (< 200 Hz): {_fmt_band(band_params['low'])}
-  - Mid (200 Hz-4 kHz): {_fmt_band(band_params['mid'])}
-  - High (> 4 kHz): {_fmt_band(band_params['high'])}
-- Stereo Width: {settings_dict.get('stereo_width', 100)}%
-- Target LUFS: {settings_dict.get('target_lufs', -14)}{history_text}"""
-
-    response = _call_gemini(_COMPARE_SYSTEM, user_prompt)
-    if response is None:
-        return "*Set GOOGLE_API_KEY to enable AI comparison report.*"
-    return response
-
-
-# ---------------------------------------------------------------------------
-# Phase 3: Structured comparison (for Auto Master loop)
-# ---------------------------------------------------------------------------
-
-_COMPARE_STRUCTURED_SYSTEM = f"""You are an expert audio mastering engineer reviewing a completed master. You are evaluating the output of a specific mastering tool with the following architecture:
-
-{_SIGNAL_FLOW}
-
-IMPORTANT — When assessing the master:
-- The 15 Hz HPF is always active. Any sub-bass roll-off below ~30 Hz is intentional subsonic cleanup, NOT a problem. Do not flag it.
-- There is no LPF. The full spectrum above the HPF is passed through, so the 10 kHz high shelf has full authority over the air band.
-- LUFS normalization is the final stage — it applies uniform linear gain. Loudness differences between original and mastered are intentional (target LUFS). Focus on spectral shape and dynamics, not absolute level.
-- Compression at slider=0 means TRUE BYPASS (compressor was not in the chain at all). Do not comment on compression characteristics if it was bypassed.
-- Stereo width only affects frequencies above 200 Hz (Linkwitz-Riley crossover). Bass mono-compatibility is always preserved.
-- When suggesting improvements, ONLY recommend changes to the 7 available controls. Do not suggest changes the tool cannot make (e.g., adjusting per-band attack times, changing crossover frequencies, changing the HPF frequency). The multiband compression is automatic — the user only controls the single 0-100 slider.
-- TRUE PEAK CEILING: If the mastered true peak is at -0.1 dBTP and the LUFS is below target, the peak ceiling pulled the level down. The fix is more compression (higher slider value) to reduce crest factor, NOT removing the ceiling. Adjust your revised compression value accordingly.
-- The compression slider uses a LOGARITHMIC (quadratic) curve: 0-50 = subtle/transparent, 50-75 = moderate, 75-100 = aggressive. Factor this into your slider recommendations.
-
-Return ONLY a valid JSON object (no markdown fences, no extra text) with these exact keys:
-{{
-  "lows_db": <number, -3.0 to +3.0>,
-  "mid_boost_db": <number, -3.0 to +3.0>,
-  "highs_db": <number, -3.0 to +3.0>,
-  "bass_boost_db": <number, 0 to +3.0>,
-  "bass_freq_hz": <integer, 40 to 100>,
-  "compression": <integer, 0 to 100>,
-  "stereo_width": <integer, 80 to 150>,
-  "report": "<your full markdown comparison report here — Overall Assessment, What Worked Well, Suggested Improvements, Technical Notes>"
-}}
-
-The numeric values should be your REVISED recommended settings for a re-master based on what you hear in the measurements.
-The "report" field should contain the full markdown analysis.
-Be concise and specific. Reference actual measurement deltas.
-
-Do NOT return the template above literally — fill in your actual analysis and values."""
-
-
-def _format_history(history):
-    """Format analysis history for inclusion in prompts."""
-    if not history:
-        return ""
-    lines = ["\n\n**PREVIOUS ANALYSIS HISTORY** (oldest first — use this to avoid recommending settings that already failed or oscillating between values):"]
-    for i, entry in enumerate(history, 1):
-        lines.append(f"\n--- Pass {i} ---")
-        lines.append(f"Settings tried: {json.dumps({k: v for k, v in entry.get('settings', {}).items() if k != 'target_lufs'})}")
-        lines.append(f"Result: LUFS={entry.get('lufs', '?')}, True Peak={entry.get('true_peak', '?')} dBTP, Crest Factor={entry.get('crest_factor', '?')} dB")
-        if entry.get("summary"):
-            lines.append(f"AI assessment: {entry['summary']}")
-    lines.append("\nIMPORTANT: Do NOT oscillate. If a previous pass moved a setting in one direction and it helped, continue refining in that direction. If it didn't help, try a DIFFERENT approach rather than reverting to a value that was already tried.")
-    return "\n".join(lines)
-
-
-def compare_master_structured(original, mastered, sample_rate, settings_dict,
-                              history=None):
-    """Compare original vs mastered and return structured values + report.
-
-    Same analysis as compare_master() but returns a dict with revised slider
-    values and a markdown report, for use in the Auto Master loop.
-
-    Args:
-        history: list of dicts from previous analyses (optional). Each entry
-                 has keys: settings, lufs, true_peak, crest_factor, summary.
-
-    Returns:
-        dict with keys: lows_db, mid_boost_db, highs_db, bass_boost_db,
-        bass_freq_hz, compression, stereo_width, report.
-        On parse error: {"report": raw_text, "parse_error": True}.
-        On API failure: None.
-    """
-    orig_features = extract_features(original, sample_rate)
-    mast_features = extract_features(mastered, sample_rate)
-
-    from dsp import map_multiband_compression
-    comp_val = settings_dict.get("compression", 50)
-    band_params = map_multiband_compression(comp_val)
-
-    def _fmt_band(params):
-        return (f"threshold {params[0]:.1f} dB, ratio {params[1]:.2f}:1, "
-                f"attack {params[2]:.0f} ms, release {params[3]:.0f} ms")
-
-    history_text = _format_history(history or [])
-
-    user_prompt = f"""Compare the original and mastered audio and return your revised settings as JSON:
-
-**ORIGINAL Audio:**
-- Loudness: {orig_features['lufs']} LUFS | True Peak: {orig_features['true_peak_dbtp']} dBTP
-- RMS: {orig_features['rms_db']} dB | Crest Factor: {orig_features['crest_factor_db']} dB
-- Spectral Centroid: {orig_features['spectral_centroid_hz']} Hz | Rolloff: {orig_features['spectral_rolloff_hz']} Hz
-- Stereo Correlation: {orig_features['stereo_correlation'] if orig_features['stereo_correlation'] is not None else 'N/A (mono)'}
-- Band Energy: {json.dumps(orig_features['band_energy'])}
-
-**MASTERED Audio:**
-- Loudness: {mast_features['lufs']} LUFS | True Peak: {mast_features['true_peak_dbtp']} dBTP
-- RMS: {mast_features['rms_db']} dB | Crest Factor: {mast_features['crest_factor_db']} dB
-- Spectral Centroid: {mast_features['spectral_centroid_hz']} Hz | Rolloff: {mast_features['spectral_rolloff_hz']} Hz
-- Stereo Correlation: {mast_features['stereo_correlation'] if mast_features['stereo_correlation'] is not None else 'N/A (mono)'}
-- Band Energy: {json.dumps(mast_features['band_energy'])}
-
-**Settings Applied:**
-- Lows (200 Hz shelf): {settings_dict.get('lows_db', 0)} dB
-- Mids (1.2 kHz peak): {settings_dict.get('mid_boost_db', 0)} dB
-- Highs (10 kHz shelf): {settings_dict.get('highs_db', 0)} dB
-- Bass Boost: {settings_dict.get('bass_boost_db', 0)} dB @ {settings_dict.get('bass_freq_hz', 60)} Hz
-- Compression: slider {comp_val}/100 (multiband, 3 bands)
-  - Low (< 200 Hz): {_fmt_band(band_params['low'])}
-  - Mid (200 Hz-4 kHz): {_fmt_band(band_params['mid'])}
-  - High (> 4 kHz): {_fmt_band(band_params['high'])}
-- Stereo Width: {settings_dict.get('stereo_width', 100)}%
-- Target LUFS: {settings_dict.get('target_lufs', -14)}{history_text}
-
-Return the JSON object with your revised settings and comparison report."""
-
-    response = _call_gemini(_COMPARE_STRUCTURED_SYSTEM, user_prompt)
-    if response is None:
-        return None
-
-    try:
-        result = _strip_json(response)
-        _clamp_settings(result)
-        if "report" not in result:
-            result["report"] = "*No report provided.*"
-        return result
-    except (json.JSONDecodeError, KeyError, TypeError):
-        return {"report": response, "parse_error": True}
-
-
-# ---------------------------------------------------------------------------
-# Super AI mode — full parametric control
-# ---------------------------------------------------------------------------
-
-_SUPER_SIGNAL_FLOW = """
-AUDIO ANALYSIS DATA YOU RECEIVE:
-You will receive detailed measurements for each audio file, including:
-- Standard: LUFS, true peak, RMS, crest factor, spectral centroid, spectral rolloff, stereo correlation
-- 24-Band Spectral Profile: Fine-grained energy (dB) across 21 frequency bands from 20 Hz to 20 kHz.
-  USE THIS to make precise EQ decisions — you can see exactly where energy buildups, dips, and imbalances are.
-- Spectral Resonances: Top 8 most prominent spectral peaks with frequency, level, and prominence (dB above neighbors).
-  USE THIS to identify harsh or ringing frequencies that need surgical EQ cuts.
-- Spectral Flatness: 0.0 = pure tonal, 1.0 = white noise. Tells you how tonal vs noisy the material is.
-- Spectral Tilt: dB/decade slope. Negative = bass-heavy, positive = bright. Guides overall tonal balance decisions.
-- Per-Compression-Band Dynamics: RMS, peak, and crest factor for each of the 3 compression bands (low/mid/high).
-  USE THIS to set compression thresholds and ratios per band — you can see which bands need taming.
-- Dynamic Variation: Min/max/range/std of RMS across 4-second chunks of the track.
-  Tells you how much the track varies (quiet verse vs loud chorus). High range = preserve dynamics. Low range = already compressed.
-- Per-Band Stereo Correlation: Correlation for low, low-mid, high-mid, and high frequency bands.
-  USE THIS to make stereo width decisions — low correlation = wide, high = narrow/mono.
-
-SIGNAL FLOW (fixed processing order — you control ALL parameters):
-1. PRE-GAIN DROP — Input is normalized to -18 LUFS (automatic, not adjustable).
-2. HIGH-PASS FILTER — Adjustable cutoff (10-80 Hz). Default 15 Hz, 12 dB/oct Butterworth.
-3. 6-BAND FULLY PARAMETRIC EQ — Each band is independently configurable:
-   - band1 through band6: type (peak/low_shelf/high_shelf), frequency (20-20000 Hz), gain (-6 to +6 dB), Q (0.1-10.0)
-   You can use any combination of shelf and peak filters at any frequency. The normal UI locks these to fixed frequencies and ±3 dB — you are NOT limited to that. You have full parametric EQ control.
-   Set gain_db to 0 on any band you don't need — unused bands are bypassed automatically.
-4. MULTIBAND COMPRESSION — 3-band dynamics with per-band control:
-   - crossover_low: adjustable crossover frequency for low/mid split (default 200 Hz)
-   - crossover_high: adjustable crossover frequency for mid/high split (default 4000 Hz)
-   - Each band (low, mid, high) has independently adjustable: threshold (-20 to 0 dB), ratio (1.0-20.0), attack_ms (0.1-200 ms), release_ms (10-500 ms)
-   - Ratio 1.0 = bypass for that band
-   - No makeup gain — LUFS normalization restores level.
-5. STEREO WIDTH — M/S matrix, frequency-selective (crossover at 200 Hz, bass stays mono). Range 80-150%.
-6. LUFS NORMALIZATION — Automatic to target LUFS (fixed by user, DO NOT change).
-7. SOFT CLIPPER — Piecewise tanh saturation, knee 2 dB below -0.1 dBTP ceiling. Always active. Linear below knee, tanh above. This is a safety net — NOT a creative tool.
-8. TRUE PEAK CEILING — Safety net at -0.1 dBTP. Scales signal down if residual peaks exceed ceiling.
-
-CONSTRAINTS (DO NOT VIOLATE):
-- Target LUFS is fixed by the user. Do not change it.
-- The soft clipper and true peak ceiling must remain as-is (automatic safety nets).
-- You cannot add new processing stages — only adjust the parameters described above.
-
-TRUE PEAK GUIDANCE (IMPORTANT):
-- True peak between -1.0 and -0.1 dBTP is the IDEAL goal, but it is NOT always achievable.
-- Source material that is already heavily limited or compressed (e.g., AI-generated tracks from Suno, Udio, etc.) has a very low crest factor (peak-to-loudness ratio). When such material is normalized DOWN to a streaming LUFS target (e.g., -14 LUFS), the true peak will naturally drop well below -1.0 dBTP. This is correct and expected behavior.
-- DO NOT over-compress or crush dynamics to try to force the true peak higher. Dynamics preservation is MORE important than hitting a specific true peak number.
-- If the source material has a low crest factor, acknowledge this in your analysis and accept the true peak wherever it naturally lands after LUFS normalization.
-- Only use compression for tonal shaping and dynamic control — NEVER to artificially raise the true peak.
-"""
-
-_SUPER_RECOMMEND_SYSTEM = f"""You are a world-class audio mastering engineer with decades of experience. You have FULL control over every parameter in the mastering chain. Analyze the audio measurements and recommend optimal settings.
-
-{_SUPER_SIGNAL_FLOW}
-
-MASTERING PHILOSOPHY:
-- LESS IS MORE. A great master sounds like a better version of the original, not a different song.
-- Most EQ moves should be ±1 to ±2 dB. Moves beyond ±3 dB are RARE and require strong justification.
-- If the source audio already sounds good in a frequency range, LEAVE IT ALONE. Do not EQ for the sake of EQ.
-- Use surgical EQ moves — small cuts are often more effective than boosts.
-- Compression thresholds should be set so compression only engages on peaks, NOT constantly. A threshold of -35 dB or lower means the compressor is always compressing — that destroys dynamics. Typical mastering thresholds are -15 to -8 dB.
-- Match compression to the genre and dynamic character of the material.
-- Preserve the artist's intent — enhance, don't transform.
-- True peak between -1.0 and -0.1 dBTP is ideal, but do NOT sacrifice dynamics to achieve it. If the source is already heavily compressed, the true peak may land below -1.0 dBTP at the target LUFS — that is acceptable.
-
-TONAL DIRECTION (apply to all masters):
-- Aim for a slightly WARM overall tone — a SUBTLE richness in the low-mids (200-500 Hz) and smooth, non-harsh highs. This means maybe +0.5 to +1.5 dB shelf, NOT +3 dB or more.
-- High shelf boosts above +1.5 dB will make the master sound harsh and brittle — avoid this.
-
-HEAVY, UNCONSTRAINED BASS — Protect low-end punch and transient impact (40-100 Hz) at all costs:
-- Rule 1: Prioritize additive EQ (Band 1/Band 2) for bass weight. DO NOT cut any frequencies below 150 Hz with EQ. The HPF already handles rumble removal. Any EQ band targeting frequencies below 150 Hz should have POSITIVE gain (boost) or be bypassed (0 dB). Cutting sub-bass removes the punch and weight from the track.
-- Rule 2: DO NOT over-compress the < 200 Hz band. If the source crest factor is already low, default the Low-Band Compressor to BYPASS (Ratio 1:1) or use a very slow attack (>60 ms) so the kick drum transient escapes untouched.
-- Rule 3: The sub-bass should feel physical, anchored, and wide open.
-- Rule 4: HPF cutoff must stay at or below 25 Hz for bass-heavy material. Only raise it above 30 Hz if measurements show significant rumble below 20 Hz.
-
-Return ONLY a valid JSON object with this exact structure (no markdown fences):
-{{
-  "hpf_freq": <float, 10-80>,
-  "eq": {{
-    "band1": {{"type": "<peak|low_shelf|high_shelf>", "freq": <float Hz>, "gain_db": <float>, "q": <float>}},
-    "band2": {{"type": "<peak|low_shelf|high_shelf>", "freq": <float Hz>, "gain_db": <float>, "q": <float>}},
-    "band3": {{"type": "<peak|low_shelf|high_shelf>", "freq": <float Hz>, "gain_db": <float>, "q": <float>}},
-    "band4": {{"type": "<peak|low_shelf|high_shelf>", "freq": <float Hz>, "gain_db": <float>, "q": <float>}},
-    "band5": {{"type": "<peak|low_shelf|high_shelf>", "freq": <float Hz>, "gain_db": <float>, "q": <float>}},
-    "band6": {{"type": "<peak|low_shelf|high_shelf>", "freq": <float Hz>, "gain_db": <float>, "q": <float>}}
-  }},
-  "compression": {{
-    "low": {{"threshold": <float dB>, "ratio": <float>, "attack_ms": <float>, "release_ms": <float>}},
-    "mid": {{"threshold": <float dB>, "ratio": <float>, "attack_ms": <float>, "release_ms": <float>}},
-    "high": {{"threshold": <float dB>, "ratio": <float>, "attack_ms": <float>, "release_ms": <float>}}
-  }},
-  "crossover_low": <float Hz>,
-  "crossover_high": <float Hz>,
-  "stereo_width": <int, 80-150>,
-  "reasoning": "### AI Analysis\\n- **EQ:** reason for EQ choices\\n- **Dynamics:** reason for compression settings\\n- **Stereo:** reason for width choice\\n(write your ACTUAL analysis — do NOT return this template literally)"
-}}
-
-Be musical and intentional. Every parameter should have a reason."""
-
-_SUPER_COMPARE_SYSTEM = f"""You are a world-class audio mastering engineer reviewing a completed master. You have FULL control over every parameter and can make surgical adjustments.
-
-{_SUPER_SIGNAL_FLOW}
-
-REVIEW GUIDELINES:
-- Compare original vs mastered measurements carefully.
-- Make VERY SMALL adjustments — typically ±0.5 dB EQ tweaks or 1-2 dB threshold changes. If you changed a parameter by more than ±1 dB on the previous pass, do NOT change it again unless the measurements clearly show a problem.
-- If something sounds good, LEAVE IT ALONE. The best revision is often the smallest one.
-- Compression thresholds should be -15 to -8 dB for mastering. If you see a threshold below -20 dB, raise it — that compressor is over-compressing.
-- Focus on what the measurements tell you: spectral balance, dynamics, stereo image.
-- True peak between -1.0 and -0.1 dBTP is ideal, but do NOT over-compress to force it. If the source has a low crest factor, accept the true peak wherever it lands naturally.
-- LUFS target is fixed — do not try to change it.
-- Reference the previous analysis history to avoid oscillating between settings.
-- Each revision should be a refinement, not a reset. Aim for 1-2 parameter changes per pass, not 5+.
-
-TONAL DIRECTION (maintain across all revisions):
-- The master should have a slightly WARM overall tone — SUBTLE richness in the low-mids (200-500 Hz) and smooth, non-harsh highs. Avoid clinical or brittle sound.
-- High shelf boosts above +1.5 dB will make the master harsh — pull them back if present.
-
-HEAVY, UNCONSTRAINED BASS — Protect low-end punch and transient impact (40-100 Hz) at all costs:
-- Rule 1: Prioritize additive EQ (Band 1/Band 2) for bass weight. DO NOT cut any frequencies below 150 Hz with EQ. If a previous pass cut sub-bass, UNDO that cut (set gain to 0 or positive). Cutting sub-bass removes punch and weight.
-- Rule 2: DO NOT over-compress the < 200 Hz band. If the source crest factor is already low, default the Low-Band Compressor to BYPASS (Ratio 1:1) or use a very slow attack (>60 ms) so the kick drum transient escapes untouched.
-- Rule 3: The sub-bass should feel physical, anchored, and wide open.
-- Rule 4: HPF cutoff must stay at or below 25 Hz for bass-heavy material. Only raise it above 30 Hz if measurements show significant rumble below 20 Hz.
-
-CREST FACTOR CHECK (passes 2-4):
-- If the crest factor in the < 200 Hz range decreases between passes, you have over-compressed the kick drum. BACK OFF the Low-Band compressor ratio or lengthen the attack time. Do not lose the punch.
-- Sidechain Emulation: Treat the Low-Band compressor as if it has a 100 Hz HPF on its sidechain detector. Do not let sustained sub-bass notes clamp down on the rhythmic transients.
-
-Return ONLY a valid JSON object with this exact structure (no markdown fences):
-{{
-  "hpf_freq": <float, 10-80>,
-  "eq": {{
-    "band1": {{"type": "<peak|low_shelf|high_shelf>", "freq": <float Hz>, "gain_db": <float>, "q": <float>}},
-    "band2": {{"type": "<peak|low_shelf|high_shelf>", "freq": <float Hz>, "gain_db": <float>, "q": <float>}},
-    "band3": {{"type": "<peak|low_shelf|high_shelf>", "freq": <float Hz>, "gain_db": <float>, "q": <float>}},
-    "band4": {{"type": "<peak|low_shelf|high_shelf>", "freq": <float Hz>, "gain_db": <float>, "q": <float>}},
-    "band5": {{"type": "<peak|low_shelf|high_shelf>", "freq": <float Hz>, "gain_db": <float>, "q": <float>}},
-    "band6": {{"type": "<peak|low_shelf|high_shelf>", "freq": <float Hz>, "gain_db": <float>, "q": <float>}}
-  }},
-  "compression": {{
-    "low": {{"threshold": <float dB>, "ratio": <float>, "attack_ms": <float>, "release_ms": <float>}},
-    "mid": {{"threshold": <float dB>, "ratio": <float>, "attack_ms": <float>, "release_ms": <float>}},
-    "high": {{"threshold": <float dB>, "ratio": <float>, "attack_ms": <float>, "release_ms": <float>}}
-  }},
-  "crossover_low": <float Hz>,
-  "crossover_high": <float Hz>,
-  "stereo_width": <int, 80-150>,
-  "report": "<your full markdown comparison report — Overall Assessment, What Worked Well, Suggested Improvements, Technical Notes>"
-}}
-
-The numeric values should be your REVISED settings for a re-master. Make small, targeted adjustments.
-The "report" field must contain your actual markdown analysis."""
-
-_SUPER_FINAL_REPORT_SYSTEM = f"""You are a world-class audio mastering engineer writing a final quality report. You are evaluating whether a master meets professional distribution standards.
-
-{_SUPER_SIGNAL_FLOW}
-
-TONAL DIRECTION (evaluate against these goals):
-- The desired outcome is a slightly WARM overall tone with smooth, non-harsh highs.
-- HEAVY, UNCONSTRAINED BASS — the low end (40-100 Hz) should feel physical, punchy, and anchored. Evaluate whether the kick drum transients survived the compression stage. If sub-bass was cut by EQ or crushed by compression, flag it as a failure.
-- HPF should be at or below 25 Hz for bass-heavy material.
-- Evaluate whether the final master achieves this tonal character.
-
-Write a comprehensive final report in markdown format covering:
-
-### Overall Assessment
-(Was the mastering effective? Does it meet professional standards? Does it achieve the desired warm tone with enhanced bass?)
-
-### Spectral Balance
-(Evaluate frequency balance — low end warmth, midrange richness, high end smoothness)
-
-### Dynamics & Loudness
-(LUFS, true peak compliance, crest factor, dynamic range preservation)
-
-### Stereo Image
-(Width, mono compatibility, balance)
-
-### Processing Summary
-(What the mastering chain did — EQ moves, compression character, etc.)
-
-### Verdict
-(Pass/fail for streaming distribution. Any remaining concerns?)
-
-Be specific. Reference actual measurements. This is the FINAL report — no suggestions for changes, just an honest evaluation of the finished master."""
-
-
-def _clamp_super_params(d):
-    """Clamp Super AI parameters to safe ranges."""
-    d["hpf_freq"] = max(10.0, min(80.0, float(d.get("hpf_freq", 15.0))))
-    d["stereo_width"] = max(80, min(150, int(d.get("stereo_width", 100))))
-    d["crossover_low"] = max(80.0, min(500.0, float(d.get("crossover_low", 200.0))))
-    d["crossover_high"] = max(1000.0, min(10000.0, float(d.get("crossover_high", 4000.0))))
-
-    eq = d.get("eq", {})
-    for bk in ("band1", "band2", "band3", "band4", "band5", "band6"):
-        band = eq.get(bk, {})
-        band["freq"] = max(20.0, min(20000.0, float(band.get("freq", 1000))))
-        band["gain_db"] = max(-6.0, min(6.0, float(band.get("gain_db", 0))))
-        band["q"] = max(0.1, min(10.0, float(band.get("q", 1.0))))
-        if band.get("type") not in ("peak", "low_shelf", "high_shelf"):
-            band["type"] = "peak"
-        eq[bk] = band
-    d["eq"] = eq
-
-    comp = d.get("compression", {})
-    for bk in ("low", "mid", "high"):
-        bp = comp.get(bk, {})
-        bp["threshold"] = max(-20.0, min(0.0, float(bp.get("threshold", -14.0))))
-        bp["ratio"] = max(1.0, min(20.0, float(bp.get("ratio", 1.0))))
-        bp["attack_ms"] = max(0.1, min(200.0, float(bp.get("attack_ms", 30.0))))
-        bp["release_ms"] = max(10.0, min(500.0, float(bp.get("release_ms", 150.0))))
-        comp[bk] = bp
-    d["compression"] = comp
-
-    return d
-
-
-def _format_super_settings(params):
-    """Format Super AI parameters into readable text for prompts."""
-    eq = params.get("eq", {})
-    comp = params.get("compression", {})
-    lines = [
-        f"- HPF: {params.get('hpf_freq', 15)} Hz",
-    ]
-    for bk in ("band1", "band2", "band3", "band4", "band5", "band6"):
-        b = eq.get(bk, {})
-        if abs(b.get("gain_db", 0)) < 0.01:
-            lines.append(f"- EQ {bk}: bypassed (0 dB)")
-        else:
-            lines.append(f"- EQ {bk}: {b.get('type','peak')} @ {b.get('freq',1000)} Hz, "
-                         f"{b.get('gain_db',0):+.1f} dB, Q={b.get('q',1.0):.2f}")
-    lines.append(f"- Crossovers: {params.get('crossover_low', 200)} Hz / {params.get('crossover_high', 4000)} Hz")
-    for bk in ("low", "mid", "high"):
-        bp = comp.get(bk, {})
-        lines.append(f"- Comp {bk}: threshold {bp.get('threshold',-14):.1f} dB, "
-                     f"ratio {bp.get('ratio',1.0):.2f}:1, "
-                     f"attack {bp.get('attack_ms',30):.1f} ms, "
-                     f"release {bp.get('release_ms',150):.1f} ms")
-    lines.append(f"- Stereo Width: {params.get('stereo_width', 100)}%")
-    return "\n".join(lines)
-
-
-def _format_detailed_features(features, label="Audio"):
-    """Format detailed features from extract_features_detailed() for prompts."""
-    lines = [
-        f"**{label} — Core Measurements:**",
-        f"- Loudness: {features['lufs']} LUFS | True Peak: {features['true_peak_dbtp']} dBTP",
-        f"- RMS: {features['rms_db']} dB | Crest Factor: {features['crest_factor_db']} dB",
-        f"- Spectral Centroid: {features['spectral_centroid_hz']} Hz | Rolloff: {features['spectral_rolloff_hz']} Hz",
-        f"- Spectral Flatness: {features.get('spectral_flatness', 'N/A')} (0=tonal, 1=noise)",
-        f"- Spectral Tilt: {features.get('spectral_tilt_db_per_decade', 'N/A')} dB/decade (negative=bass-heavy, positive=bright)",
-        f"- Stereo Correlation: {features['stereo_correlation'] if features['stereo_correlation'] is not None else 'N/A (mono)'}",
-    ]
-
-    # 24-band spectral profile
-    profile = features.get("spectral_profile_24band")
-    if profile:
-        lines.append(f"\n**{label} — 24-Band Spectral Profile (dB):**")
-        for band, val in profile.items():
-            bar = "█" * max(0, int((val + 60) / 2)) if val > -60 else ""
-            lines.append(f"  {band:>8s}: {val:>7.1f} dB  {bar}")
-
-    # Resonances
-    resonances = features.get("resonances", [])
-    if resonances:
-        lines.append(f"\n**{label} — Spectral Resonances (peaks above neighbors):**")
-        for r in resonances:
-            lines.append(f"  {r['freq_hz']:>8.1f} Hz: {r['level_db']:+.1f} dB "
-                         f"(prominence: {r['prominence_db']:.1f} dB)")
-
-    # Per-compression-band dynamics
-    cbd = features.get("comp_band_dynamics")
-    if cbd:
-        lines.append(f"\n**{label} — Per-Compression-Band Dynamics:**")
-        for band_name in ("low", "mid", "high"):
-            bd = cbd.get(band_name, {})
-            lines.append(f"  {band_name:>4s}: RMS {bd.get('rms_db', '?')} dB, "
-                         f"Peak {bd.get('peak_db', '?')} dB, "
-                         f"Crest {bd.get('crest_db', '?')} dB")
-
-    # Dynamic variation
-    dv = features.get("dynamic_variation")
-    if dv:
-        lines.append(f"\n**{label} — Dynamic Variation (4-sec chunks, {dv.get('n_chunks', '?')} chunks):**")
-        lines.append(f"  RMS range: {dv.get('min_rms_db', '?')} to {dv.get('max_rms_db', '?')} dB "
-                     f"(span: {dv.get('range_db', '?')} dB, σ: {dv.get('std_db', '?')} dB)")
-
-    # Per-band stereo correlation
-    sbc = features.get("stereo_band_correlation")
-    if sbc:
-        lines.append(f"\n**{label} — Per-Band Stereo Correlation:**")
-        for band_name in ("low", "low_mid", "high_mid", "high"):
-            val = sbc.get(band_name)
-            lines.append(f"  {band_name:>8s}: {val if val is not None else 'N/A'}")
-
-    # Original 6-band energy for backward compat
-    lines.append(f"\n**{label} — 6-Band Energy Summary:**")
-    for k, v in features.get("band_energy", {}).items():
-        lines.append(f"  {k}: {v} dB")
-
-    return "\n".join(lines)
-
-
-def _format_super_history(history):
-    """Format Super AI analysis history for prompts."""
-    if not history:
-        return ""
-    lines = ["\n\n**PREVIOUS ANALYSIS HISTORY** (use this to avoid oscillating — refine, don't reset):"]
-    for i, entry in enumerate(history, 1):
-        lines.append(f"\n--- Pass {i} ---")
-        lines.append(f"Settings:\n{_format_super_settings(entry.get('params', {}))}")
-        lines.append(f"Result: LUFS={entry.get('lufs', '?')}, True Peak={entry.get('true_peak', '?')} dBTP, "
-                     f"Crest Factor={entry.get('crest_factor', '?')} dB")
-        if entry.get("summary"):
-            lines.append(f"AI assessment: {entry['summary']}")
-    lines.append("\nIMPORTANT: Do NOT oscillate. Refine incrementally. If a setting helped, keep it and fine-tune. "
-                 "If it didn't help, try a DIFFERENT approach rather than reverting.")
-    return "\n".join(lines)
-
-
-def super_ai_recommend(audio_path):
-    """Analyze raw audio and return full-parametric AI mastering settings.
-
-    Returns:
-        dict with full parameter set + reasoning, or None.
-    """
-    from dsp import load_audio
-    audio, sr = load_audio(audio_path)
-    features = extract_features_detailed(audio, sr)
-
-    user_prompt = f"""Analyze this audio and recommend full mastering parameters:
-
-{_format_detailed_features(features, "INPUT")}
-
-Return the JSON object with your recommended full parameter set.
-Use the 24-band spectral profile to make precise EQ decisions.
-Use the resonances to identify frequencies that need surgical cuts.
-Use the per-band dynamics to set compression thresholds and ratios.
-Use the dynamic variation to decide how aggressively to compress."""
-
-    response = _call_gemini(_SUPER_RECOMMEND_SYSTEM, user_prompt)
-    if response is None:
-        return None
-
-    try:
-        result = _strip_json(response)
-        _clamp_super_params(result)
-        if "reasoning" not in result:
-            result["reasoning"] = "*No explanation provided.*"
-        return result
-    except (json.JSONDecodeError, KeyError, TypeError):
-        return {"reasoning": response, "parse_error": True}
-
-
-def super_ai_compare(original, mastered, sample_rate, params, target_lufs,
-                     history=None):
-    """Compare original vs mastered with full-parametric revision.
-
-    Returns:
-        dict with revised full params + report, or None.
-    """
-    orig_features = extract_features_detailed(original, sample_rate)
-    mast_features = extract_features_detailed(mastered, sample_rate)
-    history_text = _format_super_history(history or [])
-
-    user_prompt = f"""Compare original vs mastered audio and return revised full parameters:
-
-{_format_detailed_features(orig_features, "ORIGINAL")}
-
-{_format_detailed_features(mast_features, "MASTERED")}
-
-**Settings Applied:**
-{_format_super_settings(params)}
-- Target LUFS: {target_lufs}{history_text}
-
-Return the JSON with your REVISED full parameter set and comparison report.
-Make SMALL, incremental adjustments — refine what's working, fix what isn't.
-Compare the 24-band profiles to see exactly where the EQ moved things.
-Compare per-band dynamics to evaluate compression effectiveness.
-Check if resonances were tamed or if new ones were introduced."""
-
-    response = _call_gemini(_SUPER_COMPARE_SYSTEM, user_prompt)
-    if response is None:
-        return None
-
-    try:
-        result = _strip_json(response)
-        _clamp_super_params(result)
-        if "report" not in result:
-            result["report"] = "*No report provided.*"
-        return result
-    except (json.JSONDecodeError, KeyError, TypeError):
-        return {"report": response, "parse_error": True}
-
-
-def super_ai_final_report(original, mastered, sample_rate, params, target_lufs,
-                          history=None):
-    """Generate a final quality assessment report (no new settings).
-
-    Returns:
-        str: markdown report.
-    """
-    orig_features = extract_features_detailed(original, sample_rate)
-    mast_features = extract_features_detailed(mastered, sample_rate)
-    history_text = _format_super_history(history or [])
-
-    user_prompt = f"""Write a final mastering quality report for this completed master:
-
-{_format_detailed_features(orig_features, "ORIGINAL")}
-
-{_format_detailed_features(mast_features, "MASTERED")}
-
-**Final Settings Applied:**
-{_format_super_settings(params)}
-- Target LUFS: {target_lufs}{history_text}
-
-Write the final quality report. No suggestions — just an honest assessment of whether this master meets professional standards.
-Reference specific frequency bands and measurements from the detailed analysis above."""
-
-    response = _call_gemini(_SUPER_FINAL_REPORT_SYSTEM, user_prompt)
-    if response is None:
-        return "*AI final report unavailable.*"
-    return response
-# v4.2

app.py

@@ -1,233 +1,15 @@
 """Audio Mastering Suite — Gradio web application."""
 
-import os
-import gc
-import time
 import gradio as gr
-from analysis import GeminiUnavailableError
-from dsp import master_audio, master_audio_full
+from dsp import master_audio
 from presets import PRESETS
 from visualization import plot_waveform_comparison, plot_spectrum_comparison
-# Lazy-imported inside callbacks to avoid slowing app startup
-# from analysis import recommend_settings, compare_master
-
-
-_PRICING_URL = "https://huggingface.co/spaces/AnimalMonk/studio-ai-pricing"
-
-
-def _dsp_settings_md(dsp):
-    """Format actual DSP parameters as a markdown table."""
-    if not dsp:
-        return ""
-
-    lines = [
-        "### DSP Settings",
-        "| Parameter | Value |",
-        "|---|---|",
-        f"| **HPF** | {dsp.get('hpf_freq', 15):.0f} Hz |",
-    ]
-
-    # EQ — could be list (manual) or dict with band1-4 (super)
-    eq = dsp.get("eq", {})
-    if isinstance(eq, list):
-        for i, e in enumerate(eq):
-            lines.append(
-                f"| **EQ {i+1}** | {e.get('type','peak')} @ "
-                f"{e.get('freq',1000):.0f} Hz, {e.get('gain_db',0):+.1f} dB, "
-                f"Q={e.get('q',1.0):.2f} |"
-            )
-        if not eq:
-            lines.append("| **EQ** | flat (no adjustments) |")
-    else:
-        for bk in ("band1", "band2", "band3", "band4", "band5", "band6"):
-            b = eq.get(bk, {})
-            g = b.get("gain_db", 0)
-            if abs(g) < 0.01:
-                lines.append(f"| **EQ {bk}** | bypassed |")
-            else:
-                lines.append(
-                    f"| **EQ {bk}** | {b.get('type','peak')} @ "
-                    f"{b.get('freq',1000):.0f} Hz, {g:+.1f} dB, "
-                    f"Q={b.get('q',1.0):.2f} |"
-                )
-
-    # Crossovers
-    if "crossover_low" in dsp:
-        lines.append(
-            f"| **Crossovers** | {dsp.get('crossover_low',200):.0f} / "
-            f"{dsp.get('crossover_high',4000):.0f} Hz |"
-        )
-
-    # Compression
-    comp = dsp.get("compression", {})
-    if comp:
-        for bk in ("low", "mid", "high"):
-            bp = comp.get(bk, {})
-            r = bp.get("ratio", 1.0)
-            if r <= 1.0:
-                lines.append(f"| **Comp {bk}** | bypassed |")
-            else:
-                lines.append(
-                    f"| **Comp {bk}** | {bp.get('threshold',-14):.0f} dB, "
-                    f"{r:.1f}:1, atk {bp.get('attack_ms',30):.0f} ms, "
-                    f"rel {bp.get('release_ms',150):.0f} ms |"
-                )
-    else:
-        lines.append("| **Compression** | bypassed |")
-
-    lines.append(f"| **Stereo Width** | {dsp.get('stereo_width', 100)}% |")
-    return "\n".join(lines)
-
-_PREMIUM_MSG = (
-    "**AI features require a StudioAI API key.**\n\n"
-    f"**[Get an API Key]({_PRICING_URL})** — plans start at $9/month.\n\n"
-    "*Manual mastering is always free.*"
-)
-
-
-def _check_ai_key(user_key, consume=False):
-    """Validate user-provided AI access key via Unkey.
-
-    Args:
-        user_key: The key string from the user.
-        consume: If True, decrement one usage credit. If False, just validate
-                 without consuming (cost=0).
-
-    Returns:
-        (valid: bool, error_msg: str, remaining: int|None)
-    """
-    if not user_key:
-        return (False, _PREMIUM_MSG, None)
-    key = user_key.strip()
-
-    # Legacy key support (transition period)
-    for env_var in ("AI_ACCESS_KEY", "AI_ACCESS_KEY_2"):
-        expected = os.environ.get(env_var, "")
-        if expected and key == expected.strip():
-            return (True, "", None)  # legacy keys — no usage limit
-
-    # Unkey verification — checks key validity and rate limits
-    unkey_api_id = os.environ.get("UNKEY_API_ID", "")
-    if not unkey_api_id:
-        # Unkey not configured — fall back to rejecting unknown keys
-        return (False, _PREMIUM_MSG, None)
-
-    try:
-        import requests as _req
-        unkey_root = os.environ.get("UNKEY_ROOT_KEY", "")
-        auth_headers = {
-            "Content-Type": "application/json",
-            "Authorization": f"Bearer {unkey_root}",
-        }
-        cost = 1 if consume else 0
-
-        # Try with rate limits first (subscription keys with monthly_masters)
-        resp = _req.post(
-            "https://api.unkey.com/v2/keys.verifyKey",
-            headers=auth_headers,
-            json={"key": key, "ratelimits": [{"name": "monthly_masters", "cost": cost}]},
-            timeout=5,
-        )
-
-        # If rate limit doesn't exist on this key, Unkey returns 412.
-        # Fall back to credits-only verification.
-        if resp.status_code == 412:
-            resp = _req.post(
-                "https://api.unkey.com/v2/keys.verifyKey",
-                headers=auth_headers,
-                json={"key": key},
-                timeout=5,
-            )
-
-        data = resp.json()
-    except Exception:
-        return (True, "", None)  # fail open on network error
-
-    result = data.get("data", data)
-
-    if not result.get("valid", False):
-        code = result.get("code", "UNKNOWN")
-        msgs = {
-            "NOT_FOUND": f"Invalid API key. [Get one here]({_PRICING_URL}).",
-            "RATE_LIMITED": (
-                "You've used all your AI masters this month.\n\n"
-                f"[Upgrade your plan]({_PRICING_URL}) for more."
-            ),
-            "USAGE_EXCEEDED": (
-                "You've used all your AI masters this month.\n\n"
-                f"[Upgrade your plan]({_PRICING_URL}) for more."
-            ),
-            "DISABLED": "Your API key has been disabled. Contact support.",
-            "EXPIRED": f"Your subscription has expired. [Renew here]({_PRICING_URL}).",
-        }
-        return (False, msgs.get(code, f"Key validation failed ({code})."), 0)
-
-    # Check remaining from either rate limits or credits
-    remaining = None
-    ratelimits = result.get("ratelimits", [])
-    for rl in ratelimits:
-        if rl.get("name") == "monthly_masters":
-            remaining = rl.get("remaining")
-            break
-    if remaining is None:
-        remaining = result.get("credits", result.get("remaining"))
-
-    return (True, "", remaining)
 
 
 # ---------------------------------------------------------------------------
 # Callbacks
 # ---------------------------------------------------------------------------
 
-def check_key_status(user_key):
-    """Check key validity and remaining uses without consuming one."""
-    if not user_key or not user_key.strip():
-        return ""
-    key = user_key.strip()
-
-    # Legacy keys
-    for env_var in ("AI_ACCESS_KEY", "AI_ACCESS_KEY_2"):
-        expected = os.environ.get(env_var, "")
-        if expected and key == expected.strip():
-            return "**Key valid** — unlimited uses (legacy key)"
-
-    unkey_api_id = os.environ.get("UNKEY_API_ID", "")
-    if not unkey_api_id:
-        return ""
-
-    try:
-        import requests as _req
-        resp = _req.post(
-            "https://api.unkey.com/v2/keys.verifyKey",
-            headers={"Authorization": f"Bearer {os.environ.get('UNKEY_ROOT_KEY', '')}"},
-            json={"key": key, "ratelimits": [{"name": "monthly_masters", "cost": 0}]},
-            timeout=5,
-        )
-        data = resp.json()
-        result = data.get("data", data)
-    except Exception:
-        return ""
-
-    if not result.get("valid", False):
-        code = result.get("code", "UNKNOWN")
-        if code == "NOT_FOUND":
-            return f"**Invalid key.** [Get one here]({_PRICING_URL})"
-        elif code in ("RATE_LIMITED", "USAGE_EXCEEDED"):
-            return "**No masters remaining this month.** [Upgrade]({_PRICING_URL})"
-        elif code == "DISABLED":
-            return "**Key disabled.** Contact support."
-        return f"**Key error:** {code}"
-
-    tier = result.get("meta", {}).get("tier", "unknown")
-    ratelimits = result.get("ratelimits", [])
-    for rl in ratelimits:
-        if rl.get("name") == "monthly_masters":
-            remaining = rl.get("remaining", "?")
-            limit = rl.get("limit", "?")
-            return f"**{tier.capitalize()}** — {remaining}/{limit} AI masters remaining this month"
-    return f"**{tier.capitalize()}** — key valid"
-
-
 def apply_preset(preset_name):
     """Update all sliders when a preset is selected."""
     if preset_name == "-- None --" or preset_name not in PRESETS or PRESETS[preset_name] is None:
@@ -253,77 +35,6 @@ def toggle_custom_lufs(target_choice):
     return gr.update(visible=(target_choice == "Custom"))
 
 
-def _lock_btns():
-    """Return 6 gr.Button updates to disable all AI/action buttons."""
-    return tuple(gr.Button(interactive=False) for _ in range(6))
-
-
-def _unlock_btns():
-    """Return 6 gr.Button updates to re-enable all AI/action buttons."""
-    return tuple(gr.Button(interactive=True) for _ in range(6))
-
-
-def ai_recommend(audio_path, ai_access_key):
-    """Analyze raw audio and return AI-recommended settings + reasoning.
-
-    Yields 14 values: 7 sliders + ai_values_state + ai_reasoning_display + 5 buttons.
-    """
-    _skip = gr.Slider()
-    _no_change = (_skip, _skip, _skip, _skip, _skip, _skip, _skip, {})
-
-    valid, err, _remaining = _check_ai_key(ai_access_key)
-    if not valid:
-        yield (*_no_change, err, *_unlock_btns())
-        return
-
-    if audio_path is None:
-        raise gr.Error("Please upload an audio file first.")
-
-    # Immediate feedback
-    yield (*_no_change, "# \u26a0\ufe0f AI WORKING \u2014 PLEASE WAIT\n\n---\n\n### \u23f3 Analyzing audio with Gemini\u2026\n*This takes 15-30 seconds.*",
-        *_lock_btns(),
-    )
-
-    from analysis import recommend_settings
-    result = recommend_settings(audio_path)
-
-    if result is None:
-        yield (*_no_change, "*Set GOOGLE_API_KEY to enable AI recommendations.*", *_unlock_btns())
-        return
-
-    if result.get("parse_error"):
-        yield (*_no_change, result.get("reasoning", "*Could not parse AI response.*"), *_unlock_btns())
-        return
-
-    yield (
-        gr.Slider(label=f"Lows (200 Hz)  |  AI: {result['lows_db']:+.1f} dB"),
-        gr.Slider(label=f"Mids (1.2 kHz)  |  AI: {result['mid_boost_db']:+.1f} dB"),
-        gr.Slider(label=f"Highs (10 kHz)  |  AI: {result['highs_db']:+.1f} dB"),
-        gr.Slider(label=f"Bass Boost (dB)  |  AI: {result['bass_boost_db']:.1f} dB"),
-        gr.Slider(label=f"Bass Freq (Hz)  |  AI: {result['bass_freq_hz']} Hz"),
-        gr.Slider(label=f"Compression  |  AI: {result['compression']}"),
-        gr.Slider(label=f"Stereo Width (%)  |  AI: {result['stereo_width']}%"),
-        result,
-        result.get("reasoning", ""),
-        *_unlock_btns(),
-    )
-
-
-def apply_ai(ai_values):
-    """Populate sliders with AI-recommended values, reset labels."""
-    if not ai_values:
-        raise gr.Error("No AI recommendations yet. Click 'AI Recommend' first.")
-    return (
-        gr.Slider(value=ai_values["lows_db"], label="Lows (200 Hz)"),
-        gr.Slider(value=ai_values["mid_boost_db"], label="Mids (1.2 kHz)"),
-        gr.Slider(value=ai_values["highs_db"], label="Highs (10 kHz)"),
-        gr.Slider(value=ai_values["bass_boost_db"], label="Bass Boost (dB)"),
-        gr.Slider(value=ai_values["bass_freq_hz"], label="Bass Boost Frequency (Hz)"),
-        gr.Slider(value=ai_values["compression"], label="Compression:  Less  <->  More"),
-        gr.Slider(value=ai_values["stereo_width"], label="Stereo Width (%)"),
-    )
-
-
 def process(audio_path, lows_db, mid_boost_db, highs_db, bass_boost_db, bass_freq_hz,
             comp_val, width, target_choice, custom_lufs):
     """Run the mastering pipeline and return all outputs."""
@@ -338,650 +49,40 @@ def process(audio_path, lows_db, mid_boost_db, highs_db, bass_boost_db, bass_fre
     else:
         target = float(custom_lufs)
 
+    # Master (limiter hardcoded to -1 dB)
     output_path, original, mastered, sr, stats = master_audio(
         audio_path, lows_db, mid_boost_db, highs_db, bass_boost_db, bass_freq_hz,
-        comp_val, width, target,
+        comp_val, -1.0, width, target,
     )
 
     # Plots
     waveform_fig = plot_waveform_comparison(original, mastered, sr)
     spectrum_fig = plot_spectrum_comparison(original, mastered, sr)
 
-    # Stats markdown (split into two for side-by-side display)
+    # Stats markdown
     mono_note = "\n\n*Input is mono — stereo width adjustment was skipped.*" if stats["mono"] else ""
-    dsp_md = _dsp_settings_md(stats.get("dsp", {}))
+    warning_note = f"\n\n**Warning:** {stats['warning']}" if stats.get("warning") else ""
     stats_md = (
         "### Loudness Statistics\n"
         "| | LUFS | True Peak (dBTP) |\n"
         "|---|---|---|\n"
         f"| **Original** | {stats['orig_lufs']:.1f} | {stats['orig_peak']:.1f} |\n"
         f"| **Mastered** | {stats['mast_lufs']:.1f} | {stats['mast_peak']:.1f} |\n\n"
-        f"{mono_note}"
+        "### Gain Staging\n"
+        "| Metric | dB |\n"
+        "|---|---|\n"
+        f"| Auto Gain Reduction | {stats['auto_gain_reduction']:.1f} |\n"
+        f"| Limiter Gain Reduction | {stats['limiter_gain_reduction']:.1f} |"
+        f"{mono_note}{warning_note}"
     )
 
-    # Store data for on-demand AI comparison
-    master_data = {
-        "original": original,
-        "mastered": mastered,
-        "sr": sr,
-        "settings": {
-            "lows_db": lows_db,
-            "mid_boost_db": mid_boost_db,
-            "highs_db": highs_db,
-            "bass_boost_db": bass_boost_db,
-            "bass_freq_hz": bass_freq_hz,
-            "compression": comp_val,
-            "stereo_width": width,
-            "target_lufs": target,
-        },
-    }
-
     return (
         output_path,
         waveform_fig, spectrum_fig,
-        dsp_md, stats_md,
-        gr.Button("AI Compare Original vs Master", variant="secondary", visible=True),
+        stats_md,
         gr.DownloadButton("Download Mastered File", value=output_path, visible=True),
-        master_data,
-        "",
-    )
-
-
-def _slider_updates(values):
-    """Return 7 gr.Slider updates from a settings dict."""
-    return (
-        gr.Slider(value=values["lows_db"]),
-        gr.Slider(value=values["mid_boost_db"]),
-        gr.Slider(value=values["highs_db"]),
-        gr.Slider(value=values["bass_boost_db"]),
-        gr.Slider(value=values["bass_freq_hz"]),
-        gr.Slider(value=values["compression"]),
-        gr.Slider(value=values["stereo_width"]),
-    )
-
-_NO_SLIDER_CHANGE = tuple(gr.update() for _ in range(7))
-
-
-def _make_history_entry(settings_dict, mast_features, summary=""):
-    """Build a history entry dict for analysis context."""
-    return {
-        "settings": {k: v for k, v in settings_dict.items() if k != "target_lufs"},
-        "lufs": mast_features.get("lufs", "?"),
-        "true_peak": mast_features.get("true_peak_dbtp", "?"),
-        "crest_factor": mast_features.get("crest_factor_db", "?"),
-        "summary": summary,
-    }
-
-
-def ai_compare(master_data, ai_access_key, history):
-    """Run AI comparison report on demand (costs Gemini tokens).
-
-    Yields 15 values: 7 sliders + ai_values_state + ai_report_display
-                      + analysis_history_state + 5 buttons.
-    """
-    SKIP = gr.update()
-    valid, err, _remaining = _check_ai_key(ai_access_key)
-    if not valid:
-        yield (
-            *_NO_SLIDER_CHANGE,
-            SKIP,
-            err,
-            SKIP,  # history unchanged
-            *_unlock_btns(),
-        )
-        return
-
-    if not master_data:
-        raise gr.Error("Master a track first, then click AI Compare.")
-
-    # Immediate feedback -- lock buttons + prominent indicator
-    yield (
-        *_NO_SLIDER_CHANGE,
-        SKIP,
-        "# \u26a0\ufe0f AI WORKING \u2014 PLEASE WAIT\n\n---\n\n### \u23f3 Comparing original vs master\u2026\n*This takes 15-30 seconds.*",
-        SKIP,  # history unchanged
-        *_lock_btns(),
-    )
-    try:
-        from analysis import compare_master_structured, extract_features
-        result = compare_master_structured(
-            master_data["original"],
-            master_data["mastered"],
-            master_data["sr"],
-            master_data["settings"],
-            history=history,
-        )
-        if result is None or result.get("parse_error"):
-            report = result.get("report", "*AI comparison unavailable.*") if result else "*AI unavailable.*"
-            yield (
-                *_NO_SLIDER_CHANGE,
-                SKIP,
-                "---\n### AI Post-Master Analysis\n" + report,
-                SKIP,  # history unchanged
-                *_unlock_btns(),
-            )
-        else:
-            report = result.get("report", "*No report provided.*")
-            # Add this analysis to history
-            mast_features = extract_features(master_data["mastered"], master_data["sr"])
-            new_history = list(history) + [_make_history_entry(
-                master_data["settings"], mast_features,
-                summary=report[:200] if report else "",
-            )]
-            yield (
-                *_slider_updates(result),
-                result,
-                "---\n### AI Post-Master Analysis\n" + report,
-                new_history,
-                *_unlock_btns(),
-            )
-    except Exception as e:
-        yield (
-            *_NO_SLIDER_CHANGE,
-            SKIP,
-            f"---\n### AI Post-Master Analysis\n*AI comparison unavailable: {e}*",
-            SKIP,  # history unchanged
-            *_unlock_btns(),
-        )
-
-def auto_master(audio_path, ai_access_key, target_choice, custom_lufs):
-    """Iterative AI-driven mastering loop (generator).
-
-    Flow: AI Recommend → Master → AI Compare (×3 with revisions).
-    Yields progress to 24 outputs at each step (17 + 5 lockable buttons + history + dsp).
-    """
-    gc.collect()  # Free any previous run's data before starting
-    SKIP = gr.update()
-    _SLIDER_KEYS = ("lows_db", "mid_boost_db", "highs_db",
-                    "bass_boost_db", "bass_freq_hz", "compression", "stereo_width")
-
-    def _yield_progress(progress, sliders=None, ai_vals=SKIP,
-                        audio=SKIP, wf=SKIP, sp=SKIP, dsp=SKIP, stats=SKIP,
-                        cmp_btn=SKIP, dl=SKIP, mdata=SKIP, report=SKIP,
-                        btns=None, history=SKIP):
-        """Build the 24-element tuple for each yield."""
-        s = sliders or (SKIP,) * 7
-        b = btns or (SKIP,) * 5
-        return (*s, ai_vals, progress,
-                audio, wf, sp, dsp, stats, cmp_btn, dl, mdata, report, *b, history)
-
-    def _slider_updates(vals):
-        """Return 7 gr.Slider updates from a values dict."""
-        return (
-            gr.Slider(value=vals["lows_db"]),
-            gr.Slider(value=vals["mid_boost_db"]),
-            gr.Slider(value=vals["highs_db"]),
-            gr.Slider(value=vals["bass_boost_db"]),
-            gr.Slider(value=vals["bass_freq_hz"]),
-            gr.Slider(value=vals["compression"]),
-            gr.Slider(value=vals["stereo_width"]),
-        )
-
-    # --- Validation ---
-    valid, err, _remaining = _check_ai_key(ai_access_key)
-    if not valid:
-        yield _yield_progress(
-            err,
-            btns=tuple(gr.Button(interactive=True) for _ in range(5)),
-        )
-        return
-
-    if audio_path is None:
-        raise gr.Error("Please upload an audio file first.")
-
-    if not os.path.exists(audio_path):
-        raise gr.Error("Audio file not found — please re-upload your file.")
-
-    # Resolve target LUFS
-    if target_choice == "-14 (Streaming)":
-        target = -14.0
-    elif target_choice == "-11 (CD)":
-        target = -11.0
-    else:
-        target = float(custom_lufs)
-
-    # === STEP 1: AI Recommend ===
-    P = "## \U0001f3db Auto Master\n\n"  # progress lines (clean, no analysis text)
-    P += "**Pass 1 of 3**\n\n"
-    P += "\u23f3 *Analyzing audio with Gemini...*"
-    yield _yield_progress(P, history=[])
-
-    from analysis import recommend_settings, compare_master_structured, compare_master, extract_features
-    loop_history = []  # accumulate history across passes
-    try:
-        result = recommend_settings(audio_path)
-    except GeminiUnavailableError as e:
-        yield _yield_progress(
-            str(e),
-            btns=tuple(gr.Button(interactive=True) for _ in range(5)),
-        )
-        return
-
-    if result is None:
-        yield _yield_progress("*Set GOOGLE_API_KEY to enable AI recommendations.*")
-        return
-    if result.get("parse_error"):
-        yield _yield_progress(result.get("reasoning", "*Could not parse AI response.*"))
-        return
-
-    values = {k: result[k] for k in _SLIDER_KEYS}
-
-    P += "\n\n\u2705 AI recommended initial settings"
-    P += "\n\n\u23f3 *Mastering with initial settings...*"
-    yield _yield_progress(P, sliders=_slider_updates(values), ai_vals=values)
-
-    # === STEP 2: Master pass 1 ===
-    output_path, original, mastered, sr, stats = master_audio(
-        audio_path,
-        values["lows_db"], values["mid_boost_db"], values["highs_db"],
-        values["bass_boost_db"], values["bass_freq_hz"],
-        values["compression"], values["stereo_width"], target,
     )
 
-    P += "\n\n\u2705 Pass 1 mastered"
-    P += "\n\n\u23f3 *Waiting before next AI call...*"
-    yield _yield_progress(P)
-    time.sleep(15)
-
-    P += "\n\n\u23f3 *AI analyzing master and recommending adjustments...*"
-    yield _yield_progress(P)
-
-    # === STEP 3: AI Compare (structured) — iteration 1 ===
-    settings_dict = {**values, "target_lufs": target}
-    mast_feat = extract_features(mastered, sr)
-    loop_history.append(_make_history_entry(settings_dict, mast_feat, "Pass 1 initial"))
-    try:
-        result2 = compare_master_structured(original, mastered, sr, settings_dict,
-                                            history=loop_history)
-    except GeminiUnavailableError as e:
-        yield _yield_progress(
-            str(e),
-            btns=tuple(gr.Button(interactive=True) for _ in range(5)),
-        )
-        return
-
-    if result2 is None or result2.get("parse_error"):
-        P += "\n\n\u26a0\ufe0f Could not parse AI adjustments \u2014 keeping current settings"
-    else:
-        values = {k: result2[k] for k in _SLIDER_KEYS}
-        P += "\n\n\u2705 AI suggested adjustments applied"
-    del result2
-
-    P += "\n\n---\n\n**Pass 2 of 3**\n\n"
-    P += "\u23f3 *Re-mastering with revised settings...*"
-    yield _yield_progress(P, sliders=_slider_updates(values), ai_vals=values)
-
-    # === STEP 4: Master pass 2 ===
-    output_path, original, mastered, sr, stats = master_audio(
-        audio_path,
-        values["lows_db"], values["mid_boost_db"], values["highs_db"],
-        values["bass_boost_db"], values["bass_freq_hz"],
-        values["compression"], values["stereo_width"], target,
-    )
-
-    P += "\n\n\u2705 Pass 2 mastered"
-    P += "\n\n\u23f3 *Waiting before next AI call...*"
-    yield _yield_progress(P)
-    time.sleep(15)
-
-    P += "\n\n\u23f3 *AI analyzing and recommending final adjustments...*"
-    yield _yield_progress(P)
-
-    # === STEP 5: AI Compare (structured) — iteration 2 ===
-    settings_dict = {**values, "target_lufs": target}
-    mast_feat = extract_features(mastered, sr)
-    loop_history.append(_make_history_entry(settings_dict, mast_feat, "Pass 2"))
-    try:
-        result3 = compare_master_structured(original, mastered, sr, settings_dict,
-                                            history=loop_history)
-    except GeminiUnavailableError as e:
-        yield _yield_progress(
-            str(e),
-            btns=tuple(gr.Button(interactive=True) for _ in range(5)),
-        )
-        return
-
-    if result3 is None or result3.get("parse_error"):
-        P += "\n\n\u26a0\ufe0f Could not parse AI adjustments \u2014 keeping current settings"
-    else:
-        values = {k: result3[k] for k in _SLIDER_KEYS}
-        P += "\n\n\u2705 AI suggested final adjustments applied"
-    del result3
-
-    P += "\n\n---\n\n**Pass 3 of 3**\n\n"
-    P += "\u23f3 *Final mastering pass...*"
-    yield _yield_progress(P, sliders=_slider_updates(values), ai_vals=values)
-
-    # === STEP 6: Master pass 3 (final) ===
-    output_path, original, mastered, sr, stats = master_audio(
-        audio_path,
-        values["lows_db"], values["mid_boost_db"], values["highs_db"],
-        values["bass_boost_db"], values["bass_freq_hz"],
-        values["compression"], values["stereo_width"], target,
-    )
-
-    P += "\n\n\u2705 Final master complete"
-    P += "\n\n\u23f3 *Waiting before final AI call...*"
-    yield _yield_progress(P)
-    time.sleep(15)
-
-    P += "\n\n\u23f3 *Running final AI analysis...*"
-    yield _yield_progress(P)
-
-    # === STEP 7: Final AI Compare (markdown only) ===
-    mast_feat = extract_features(mastered, sr)
-    loop_history.append(_make_history_entry({**values, "target_lufs": target}, mast_feat, "Pass 3 final"))
-    try:
-        final_report = compare_master(
-            original, mastered, sr, {**values, "target_lufs": target},
-            history=loop_history,
-        )
-    except GeminiUnavailableError as e:
-        # Final report is non-critical — mastering is done
-        final_report = str(e)
-    except Exception as e:
-        final_report = f"*AI comparison unavailable: {e}*"
-
-    # Generate plots and stats
-    waveform_fig = plot_waveform_comparison(original, mastered, sr)
-    spectrum_fig = plot_spectrum_comparison(original, mastered, sr)
-
-    mono_note = "\n\n*Input is mono \u2014 stereo width adjustment was skipped.*" if stats["mono"] else ""
-    dsp_md = _dsp_settings_md(stats.get("dsp", {}))
-    stats_md = (
-        "### Loudness Statistics\n"
-        "| | LUFS | True Peak (dBTP) |\n"
-        "|---|---|---|\n"
-        f"| **Original** | {stats['orig_lufs']:.1f} | {stats['orig_peak']:.1f} |\n"
-        f"| **Mastered** | {stats['mast_lufs']:.1f} | {stats['mast_peak']:.1f} |\n\n"
-        f"{mono_note}"
-    )
-
-    master_data = {
-        "original": original,
-        "mastered": mastered,
-        "sr": sr,
-        "settings": {**values, "target_lufs": target},
-    }
-
-    # Consume one usage credit now that mastering succeeded
-    _check_ai_key(ai_access_key, consume=True)
-
-    P += "\n\n\u2705 **Auto Master complete!** 3 passes, 4 AI analyses."
-
-    yield (
-        gr.Slider(value=values["lows_db"], label="Lows (200 Hz)"),
-        gr.Slider(value=values["mid_boost_db"], label="Mids (1.2 kHz)"),
-        gr.Slider(value=values["highs_db"], label="Highs (10 kHz)"),
-        gr.Slider(value=values["bass_boost_db"], label="Bass Boost (dB)"),
-        gr.Slider(value=values["bass_freq_hz"], label="Bass Boost Frequency (Hz)"),
-        gr.Slider(value=values["compression"], label="Compression:  Less  <->  More"),
-        gr.Slider(value=values["stereo_width"], label="Stereo Width (%)"),
-        values,                                              # ai_values_state
-        P,                                                   # ai_reasoning_display
-        output_path,                                         # ab_player
-        waveform_fig,                                        # waveform_plot
-        spectrum_fig,                                        # spectrum_plot
-        dsp_md,                                              # dsp_display
-        stats_md,                                            # stats_display
-        gr.Button("AI Compare Original vs Master",
-                  variant="secondary", visible=True),        # ai_compare_btn
-        gr.DownloadButton("Download Mastered File",
-                          value=output_path, visible=True),  # download_file
-        master_data,                                         # master_data_state
-        "---\n### AI Post-Master Analysis\n" + final_report, # ai_report_display
-        gr.Button(interactive=True),                         # master_btn
-        gr.Button(interactive=True),                         # apply_ai_btn
-        gr.Button(interactive=True),                         # ai_recommend_btn
-        gr.Button(interactive=True),                         # auto_master_btn
-        gr.Button(interactive=True),                         # super_ai_btn
-        loop_history,                                        # analysis_history_state
-    )
-
-
-def super_ai_master(audio_path, ai_access_key, target_choice, custom_lufs):
-    """Super AI mastering loop with full parametric control (generator).
-
-    Flow:
-        Pass 1: AI analyzes raw audio → full-parametric settings → master
-        Pass 2: AI compares + adjusts ALL params (small moves) → master
-        Pass 3: Same as pass 2
-        Pass 4: Same as pass 2
-        Pass 5: Final AI compare — report only, no suggestions.
-
-    Yields progress to 24 outputs at each step (17 + 5 lockable buttons + history + dsp).
-    """
-    gc.collect()  # Free any previous run's data before starting
-    SKIP = gr.update()
-
-    def _yield_progress(progress, sliders=None, ai_vals=SKIP,
-                        audio=SKIP, wf=SKIP, sp=SKIP, dsp=SKIP, stats=SKIP,
-                        cmp_btn=SKIP, dl=SKIP, mdata=SKIP, report=SKIP,
-                        btns=None, history=SKIP):
-        """Build the 24-element tuple for each yield."""
-        s = sliders or (SKIP,) * 7
-        b = btns or (SKIP,) * 5
-        return (*s, ai_vals, progress,
-                audio, wf, sp, dsp, stats, cmp_btn, dl, mdata, report, *b, history)
-
-    # --- Validation ---
-    valid, err, _remaining = _check_ai_key(ai_access_key)
-    if not valid:
-        yield _yield_progress(
-            err,
-            btns=tuple(gr.Button(interactive=True) for _ in range(5)),
-        )
-        return
-
-    if audio_path is None:
-        raise gr.Error("Please upload an audio file first.")
-
-    if not os.path.exists(audio_path):
-        raise gr.Error("Audio file not found — please re-upload your file.")
-
-    # Resolve target LUFS
-    if target_choice == "-14 (Streaming)":
-        target = -14.0
-    elif target_choice == "-11 (CD)":
-        target = -11.0
-    else:
-        target = float(custom_lufs)
-
-    # === PASS 1: AI full-parametric recommendation ===
-    P = "## \U0001f9e0 Super AI Master (beta)\n\n"
-    P += "**Pass 1 of 5** — AI analyzing audio with full parametric control\n\n"
-    P += "\u23f3 *Deep analysis with Gemini...*"
-    yield _yield_progress(P, history=[])
-
-    from analysis import (super_ai_recommend, super_ai_compare,
-                          super_ai_final_report, extract_features)
-
-    loop_history = []
-    try:
-        result = super_ai_recommend(audio_path)
-    except GeminiUnavailableError as e:
-        yield _yield_progress(
-            str(e),
-            btns=tuple(gr.Button(interactive=True) for _ in range(5)),
-        )
-        return
-
-    if result is None:
-        yield _yield_progress("*Set GOOGLE_API_KEY to enable AI recommendations.*")
-        return
-    if result.get("parse_error"):
-        yield _yield_progress(result.get("reasoning", "*Could not parse AI response.*"))
-        return
-
-    # Extract the full parameter set (everything except reasoning)
-    params = {k: v for k, v in result.items() if k != "reasoning"}
-
-    P += "\n\n\u2705 AI recommended initial settings"
-    P += "\n\n\u23f3 *Mastering with full parametric settings...*"
-    yield _yield_progress(P)
-
-    # Master pass 1
-    output_path, original, mastered, sr, stats = master_audio_full(
-        audio_path, params, target,
-    )
-
-    mast_feat = extract_features(mastered, sr)
-    loop_history.append({
-        "params": params,
-        "lufs": mast_feat.get("lufs", "?"),
-        "true_peak": mast_feat.get("true_peak_dbtp", "?"),
-        "crest_factor": mast_feat.get("crest_factor_db", "?"),
-        "summary": "Pass 1 initial recommendation",
-    })
-
-    P += "\n\n\u2705 Pass 1 mastered"
-
-    # === PASSES 2-4: AI compare + adjust + master ===
-    for pass_num in range(2, 5):
-        P += f"\n\n---\n\n**Pass {pass_num} of 5** — AI comparing and refining\n\n"
-        P += "\u23f3 *Waiting before next AI call...*"
-        yield _yield_progress(P)
-        time.sleep(15)
-
-        P += "\n\n\u23f3 *AI analyzing master and adjusting parameters...*"
-        yield _yield_progress(P)
-
-        try:
-            result_cmp = super_ai_compare(
-                original, mastered, sr, params, target,
-                history=loop_history,
-            )
-        except GeminiUnavailableError as e:
-            yield _yield_progress(
-                str(e),
-                btns=tuple(gr.Button(interactive=True) for _ in range(5)),
-            )
-            return
-
-        if result_cmp is None or result_cmp.get("parse_error"):
-            P += "\n\n\u26a0\ufe0f Could not parse AI adjustments — keeping current settings"
-        else:
-            params = {k: v for k, v in result_cmp.items() if k != "report"}
-            P += "\n\n\u2705 AI adjustments applied"
-
-        P += f"\n\n\u23f3 *Re-mastering pass {pass_num}...*"
-        yield _yield_progress(P)
-
-        output_path, original, mastered, sr, stats = master_audio_full(
-            audio_path, params, target,
-        )
-
-        mast_feat = extract_features(mastered, sr)
-        report_snippet = ""
-        if result_cmp and not result_cmp.get("parse_error"):
-            report_snippet = result_cmp.get("report", "")[:200]
-        loop_history.append({
-            "params": params,
-            "lufs": mast_feat.get("lufs", "?"),
-            "true_peak": mast_feat.get("true_peak_dbtp", "?"),
-            "crest_factor": mast_feat.get("crest_factor_db", "?"),
-            "summary": f"Pass {pass_num}: {report_snippet}",
-        })
-
-        P += f"\n\n\u2705 Pass {pass_num} mastered"
-
-    # === PASS 5: Final report only ===
-    P += "\n\n---\n\n**Pass 5 of 5** — Final quality assessment\n\n"
-    P += "\u23f3 *Waiting before final AI call...*"
-    yield _yield_progress(P)
-    time.sleep(15)
-
-    P += "\n\n\u23f3 *Running final AI evaluation...*"
-    yield _yield_progress(P)
-
-    try:
-        final_report = super_ai_final_report(
-            original, mastered, sr, params, target,
-            history=loop_history,
-        )
-    except GeminiUnavailableError as e:
-        # Pass 5 is report-only — mastering is done, so we can still
-        # show results even if the report fails. Don't abort here.
-        final_report = str(e)
-    except Exception as e:
-        final_report = f"*AI final report unavailable: {e}*"
-
-    # Generate plots and stats
-    waveform_fig = plot_waveform_comparison(original, mastered, sr)
-    spectrum_fig = plot_spectrum_comparison(original, mastered, sr)
-
-    mono_note = "\n\n*Input is mono — stereo width adjustment was skipped.*" if stats["mono"] else ""
-    dsp_md = _dsp_settings_md(stats.get("dsp", {}))
-    stats_md = (
-        "### Loudness Statistics\n"
-        "| | LUFS | True Peak (dBTP) |\n"
-        "|---|---|---|\n"
-        f"| **Original** | {stats['orig_lufs']:.1f} | {stats['orig_peak']:.1f} |\n"
-        f"| **Mastered** | {stats['mast_lufs']:.1f} | {stats['mast_peak']:.1f} |\n\n"
-        f"{mono_note}"
-    )
-
-    # Super AI uses full parametric — don't map back to sliders
-    # (sliders have fixed ranges that can't represent the full parameter space)
-    master_data = {
-        "original": original,
-        "mastered": mastered,
-        "sr": sr,
-        "settings": {"target_lufs": target},
-    }
-
-    # Consume one usage credit now that mastering succeeded
-    _check_ai_key(ai_access_key, consume=True)
-
-    P += "\n\n\u2705 **Super AI Master complete!** 5 passes, full parametric control."
-
-    # Build the full settings report for display
-    eq = params.get("eq", {})
-    comp = params.get("compression", {})
-    settings_report = "---\n### Super AI — Applied Settings\n"
-    settings_report += f"**HPF:** {params.get('hpf_freq', 15)} Hz\n\n"
-    settings_report += "**EQ:**\n"
-    for bk in ("band1", "band2", "band3", "band4", "band5", "band6"):
-        b = eq.get(bk, {})
-        if abs(b.get("gain_db", 0)) < 0.01:
-            settings_report += f"- {bk}: bypassed\n"
-        else:
-            settings_report += (f"- {bk}: {b.get('type','peak')} @ {b.get('freq',1000):.0f} Hz, "
-                                f"{b.get('gain_db',0):+.1f} dB, Q={b.get('q',1.0):.2f}\n")
-    settings_report += f"\n**Crossovers:** {params.get('crossover_low', 200)} / {params.get('crossover_high', 4000)} Hz\n\n"
-    settings_report += "**Compression:**\n"
-    for bk in ("low", "mid", "high"):
-        bp = comp.get(bk, {})
-        settings_report += (f"- {bk}: threshold {bp.get('threshold',-14):.1f} dB, "
-                            f"ratio {bp.get('ratio',1.0):.1f}:1, "
-                            f"attack {bp.get('attack_ms',30):.1f} ms, "
-                            f"release {bp.get('release_ms',150):.1f} ms\n")
-    settings_report += f"\n**Stereo Width:** {params.get('stereo_width', 100)}%\n\n"
-
-    # Final yield — Super AI doesn't update sliders (params exceed slider ranges)
-    SKIP = gr.update()
-    yield (
-        SKIP, SKIP, SKIP, SKIP, SKIP, SKIP, SKIP,                   # leave sliders unchanged
-        {},                                                          # ai_values_state
-        P,                                                       # ai_reasoning_display
-        output_path,                                             # ab_player
-        waveform_fig,                                            # waveform_plot
-        spectrum_fig,                                            # spectrum_plot
-        dsp_md,                                                  # dsp_display
-        stats_md,                                                # stats_display
-        gr.Button("AI Compare Original vs Master",
-                  variant="secondary", visible=True),            # ai_compare_btn
-        gr.DownloadButton("Download Mastered File",
-                          value=output_path, visible=True),      # download_file
-        master_data,                                             # master_data_state
-        settings_report + "---\n### AI Final Report\n" + final_report,  # ai_report_display
-        gr.Button(interactive=True),                             # master_btn
-        gr.Button(interactive=True),                             # apply_ai_btn
-        gr.Button(interactive=True),                             # ai_recommend_btn
-        gr.Button(interactive=True),                             # auto_master_btn
-        gr.Button(interactive=True),                             # super_ai_btn
-        loop_history,                                            # analysis_history_state
-    )
 
 
 # ---------------------------------------------------------------------------
@@ -989,33 +90,15 @@ def super_ai_master(audio_path, ai_access_key, target_choice, custom_lufs):
 # ---------------------------------------------------------------------------
 
 with gr.Blocks(title="Audio Mastering Suite", theme=gr.themes.Soft()) as demo:
-    gr.HTML(
-        '<div style="display:flex;align-items:center;gap:16px;">'
-        '<img src="data:image/png;base64,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" alt="s.AI logo" style="height:80px;border-radius:12px;">'
-        '<div>'
-        '<h1 style="margin:0;">Audio Mastering Suite</h1>'
-        '<p style="margin:4px 0 0 0;font-size:0.9em;">by AnimalMonk &nbsp;|&nbsp; '
-        '<a href="https://discord.gg/StudioAI" target="_blank">Join us on Discord</a></p>'
-        '</div></div>'
-    )
+    gr.Markdown("# Audio Mastering Suite\n##### by AnimalMonk")
 
-    # --- Preset, AI Recommend & Target LUFS ---
+    # --- Preset & Target LUFS (side by side) ---
     with gr.Row():
         preset_dropdown = gr.Dropdown(
             label="Preset",
             choices=list(PRESETS.keys()),
             value="-- None --",
         )
-        ai_access_input = gr.Textbox(
-            label="AI Access Key",
-            placeholder="Enter key to unlock AI",
-            type="password",
-            scale=1,
-            autofocus=False,
-            elem_id="ai-access-key",
-        )
-        ai_recommend_btn = gr.Button("AI Recommend", variant="secondary")
-        auto_master_btn = gr.Button("Auto Master", variant="primary")
         target_dropdown = gr.Dropdown(
             label="Target LUFS",
             choices=["-14 (Streaming)", "-11 (CD)", "Custom"],
@@ -1027,31 +110,8 @@ with gr.Blocks(title="Audio Mastering Suite", theme=gr.themes.Soft()) as demo:
             visible=False,
         )
 
-    super_ai_btn = gr.Button("\U0001f9e0 Super AI (beta)", variant="primary", size="lg")
-
-    key_status_display = gr.Markdown("")
-
-    gr.HTML(
-        f'<p style="margin:0;font-size:14px;color:#ccc;">'
-        f'<a href="{_PRICING_URL}" target="_blank" rel="noopener" '
-        f'style="color:#7c6cf0;font-weight:bold;text-decoration:underline;">'
-        f'Get an API Key</a>'
-        f' &mdash; plans start at $9/month. '
-        f'<em>Manual mastering is always free.</em></p>'
-    )
-
-    # Disable browser password autofill on the AI key field
-    gr.HTML("""<script>
-    document.addEventListener('DOMContentLoaded', function() {
-        var el = document.querySelector('#ai-access-key input');
-        if (el) { el.autocomplete = 'off'; el.setAttribute('autocomplete', 'off'); }
-    });
-    // Gradio may render late — retry after a short delay
-    setTimeout(function() {
-        var el = document.querySelector('#ai-access-key input');
-        if (el) { el.autocomplete = 'off'; el.setAttribute('autocomplete', 'off'); }
-    }, 1500);
-    </script>""", visible=False)
+    # --- Master button ---
+    master_btn = gr.Button("Master It!", variant="primary", size="lg")
 
     # --- Upload (full width) ---
     audio_input = gr.Audio(
@@ -1060,12 +120,6 @@ with gr.Blocks(title="Audio Mastering Suite", theme=gr.themes.Soft()) as demo:
         sources=["upload"],
     )
 
-    # --- AI Recommendations (below upload) ---
-    ai_reasoning_display = gr.Markdown(value="", visible=True)
-
-    # --- Apply AI Recommended Settings (below AI reasoning) ---
-    apply_ai_btn = gr.Button("Apply AI Recommended Settings", variant="secondary")
-
     # --- Control sliders ---
     with gr.Row():
         lows_slider = gr.Slider(
@@ -1077,7 +131,7 @@ with gr.Blocks(title="Audio Mastering Suite", theme=gr.themes.Soft()) as demo:
             minimum=-3.0, maximum=3.0, value=0.0, step=0.1,
         )
         highs_slider = gr.Slider(
-            label="Highs (10 kHz)",
+            label="Highs (6 kHz)",
             minimum=-3.0, maximum=3.0, value=0.0, step=0.1,
         )
 
@@ -1089,7 +143,7 @@ with gr.Blocks(title="Audio Mastering Suite", theme=gr.themes.Soft()) as demo:
             )
             bass_freq_slider = gr.Slider(
                 label="Bass Boost Frequency (Hz)",
-                minimum=40, maximum=100, value=60, step=1,
+                minimum=50, maximum=60, value=55, step=1,
             )
         with gr.Column():
             comp_slider = gr.Slider(
@@ -1101,30 +155,16 @@ with gr.Blocks(title="Audio Mastering Suite", theme=gr.themes.Soft()) as demo:
                 minimum=80, maximum=150, value=100, step=1,
             )
 
-    # --- State for AI values, master data, and analysis history ---
-    master_data_state = gr.State({})
-    ai_values_state = gr.State({})
-    analysis_history_state = gr.State([])
-
-    # --- Master button ---
-    master_btn = gr.Button("Master It!", variant="primary", size="lg")
-
-    # --- AI Post-Master Comparison (above playback) ---
-    ai_report_display = gr.Markdown(value="", visible=True, label="AI Analysis")
-
     # --- Playback ---
     ab_player = gr.Audio(label="Mastered", interactive=False)
-    ai_compare_btn = gr.Button("AI Compare Original vs Master", variant="secondary", visible=False)
-    download_file = gr.DownloadButton("Download Mastered File", visible=False)
 
     # --- Visualization ---
     with gr.Row():
         waveform_plot = gr.Plot(label="Waveform Comparison")
         spectrum_plot = gr.Plot(label="Spectrum Comparison")
 
-    with gr.Row():
-        dsp_display = gr.Markdown()
-        stats_display = gr.Markdown()
+    stats_display = gr.Markdown()
+    download_file = gr.DownloadButton("Download Mastered File", visible=False)
 
     # --- Event wiring ---
     preset_dropdown.change(
@@ -1141,36 +181,6 @@ with gr.Blocks(title="Audio Mastering Suite", theme=gr.themes.Soft()) as demo:
         outputs=[custom_lufs_input],
     )
 
-    ai_access_input.change(
-        check_key_status,
-        inputs=[ai_access_input],
-        outputs=[key_status_display],
-    )
-
-    ai_recommend_btn.click(
-        ai_recommend,
-        inputs=[audio_input, ai_access_input],
-        outputs=[
-            lows_slider, mid_boost_slider, highs_slider,
-            bass_boost_slider, bass_freq_slider,
-            comp_slider, width_slider,
-            ai_values_state,
-            ai_reasoning_display,
-            master_btn, apply_ai_btn, ai_recommend_btn,
-            auto_master_btn, ai_compare_btn, super_ai_btn,
-        ],
-    )
-
-    apply_ai_btn.click(
-        apply_ai,
-        inputs=[ai_values_state],
-        outputs=[
-            lows_slider, mid_boost_slider, highs_slider,
-            bass_boost_slider, bass_freq_slider,
-            comp_slider, width_slider,
-        ],
-    )
-
     master_btn.click(
         process,
         inputs=[
@@ -1182,72 +192,11 @@ with gr.Blocks(title="Audio Mastering Suite", theme=gr.themes.Soft()) as demo:
         outputs=[
             ab_player,
             waveform_plot, spectrum_plot,
-            dsp_display, stats_display,
-            ai_compare_btn, download_file,
-            master_data_state,
-            ai_report_display,
-        ],
-    )
-
-    ai_compare_btn.click(
-        ai_compare,
-        inputs=[master_data_state, ai_access_input, analysis_history_state],
-        outputs=[
-            lows_slider, mid_boost_slider, highs_slider,
-            bass_boost_slider, bass_freq_slider,
-            comp_slider, width_slider,
-            ai_values_state,
-            ai_report_display,
-            analysis_history_state,
-            master_btn, apply_ai_btn, ai_recommend_btn,
-            auto_master_btn, ai_compare_btn, super_ai_btn,
-        ],
-    )
-
-    auto_master_btn.click(
-        auto_master,
-        inputs=[audio_input, ai_access_input, target_dropdown, custom_lufs_input],
-        outputs=[
-            lows_slider, mid_boost_slider, highs_slider,
-            bass_boost_slider, bass_freq_slider,
-            comp_slider, width_slider,
-            ai_values_state,
-            ai_reasoning_display,
-            ab_player,
-            waveform_plot, spectrum_plot,
-            dsp_display, stats_display,
-            ai_compare_btn, download_file,
-            master_data_state,
-            ai_report_display,
-            master_btn, apply_ai_btn, ai_recommend_btn,
-            auto_master_btn, super_ai_btn,
-            analysis_history_state,
+            stats_display, download_file,
         ],
     )
 
-    super_ai_btn.click(
-        super_ai_master,
-        inputs=[audio_input, ai_access_input, target_dropdown, custom_lufs_input],
-        outputs=[
-            lows_slider, mid_boost_slider, highs_slider,
-            bass_boost_slider, bass_freq_slider,
-            comp_slider, width_slider,
-            ai_values_state,
-            ai_reasoning_display,
-            ab_player,
-            waveform_plot, spectrum_plot,
-            dsp_display, stats_display,
-            ai_compare_btn, download_file,
-            master_data_state,
-            ai_report_display,
-            master_btn, apply_ai_btn, ai_recommend_btn,
-            auto_master_btn, super_ai_btn,
-            analysis_history_state,
-        ],
-    )
 
 
 if __name__ == "__main__":
-    import os as _os
-    _os.environ["GRADIO_ANALYTICS_ENABLED"] = "False"
-    demo.launch(server_name="0.0.0.0", server_port=7860, share=False, ssr_mode=False)
+    demo.launch()

build_schematic.py

@@ -1,1064 +0,0 @@
-"""Generate ANALOG_SCHEMATIC.pdf v4.2 — clean graphical layout."""
-
-import os
-from reportlab.lib.pagesizes import letter
-from reportlab.lib.units import inch
-from reportlab.lib.colors import HexColor, black, white
-from reportlab.pdfgen import canvas
-from reportlab.pdfbase import pdfmetrics
-from reportlab.pdfbase.ttfonts import TTFont
-
-# ── Fonts ──────────────────────────────────────────────────────────────────
-FONT_DIR = os.path.join(os.environ.get("WINDIR", r"C:\Windows"), "Fonts")
-for name, filename in [
-    ("Cal", "calibri.ttf"),
-    ("CalB", "calibrib.ttf"),
-    ("CalI", "calibrii.ttf"),
-    ("Con", "consola.ttf"),
-]:
-    path = os.path.join(FONT_DIR, filename)
-    if os.path.exists(path):
-        pdfmetrics.registerFont(TTFont(name, path))
-
-BODY = "Cal"
-BOLD = "CalB"
-ITALIC = "CalI"
-MONO = "Con"
-
-# ── Colors ─────────────────────────────────────────────────────────────────
-BG_DARK   = HexColor("#1a1a2e")
-BG_STAGE  = HexColor("#f4f4f8")
-BG_SUB    = HexColor("#ffffff")
-ACCENT    = HexColor("#3a6ea5")
-ACCENT2   = HexColor("#6b4c9a")
-BORDER    = HexColor("#cccccc")
-TEXT_DARK  = HexColor("#1a1a1a")
-TEXT_MID   = HexColor("#555555")
-TEXT_LIGHT = HexColor("#999999")
-ARROW_CLR  = HexColor("#3a6ea5")
-WARM_RED   = HexColor("#b5442d")
-WARM_ORANGE = HexColor("#c47a20")
-
-OUTPUT = "ANALOG_SCHEMATIC.pdf"
-W, H = letter
-M = 0.6 * inch  # margin
-
-# ── Drawing helpers ────────────────────────────────────────────────────────
-
-def draw_arrow_down(c, x, y_top, y_bot, color=ARROW_CLR):
-    """Draw a downward arrow from y_top to y_bot at x."""
-    c.setStrokeColor(color)
-    c.setLineWidth(1.5)
-    c.line(x, y_top, x, y_bot + 6)
-    # arrowhead
-    c.setFillColor(color)
-    p = c.beginPath()
-    p.moveTo(x, y_bot)
-    p.lineTo(x - 4, y_bot + 8)
-    p.lineTo(x + 4, y_bot + 8)
-    p.close()
-    c.drawPath(p, fill=1, stroke=0)
-
-
-def stage_box(c, x, y, w, h, title, content_fn, stage_num=None):
-    """Draw a rounded stage box with title bar and call content_fn for body."""
-    r = 6
-    # Shadow
-    c.setFillColor(HexColor("#e0e0e0"))
-    c.roundRect(x + 2, y - 2, w, h, r, fill=1, stroke=0)
-    # Main box
-    c.setFillColor(BG_STAGE)
-    c.setStrokeColor(BORDER)
-    c.setLineWidth(0.75)
-    c.roundRect(x, y, w, h, r, fill=1, stroke=1)
-    # Title bar
-    title_h = 22
-    c.setFillColor(ACCENT)
-    c.roundRect(x, y + h - title_h, w, title_h, r, fill=1, stroke=0)
-    # Fix bottom corners of title bar
-    c.rect(x, y + h - title_h, w, r, fill=1, stroke=0)
-    # Title text
-    c.setFillColor(white)
-    c.setFont(BOLD, 10)
-    label = f"STAGE {stage_num}: {title}" if stage_num else title
-    c.drawString(x + 10, y + h - 16, label)
-    # Body area
-    if content_fn:
-        content_fn(c, x + 10, y + h - title_h - 6, w - 20)
-
-
-def sub_box(c, x, y, w, h, title=None, color=None):
-    """Draw a smaller inner box. Returns (x, y) of content start."""
-    c.setFillColor(color or BG_SUB)
-    c.setStrokeColor(HexColor("#dddddd"))
-    c.setLineWidth(0.5)
-    c.roundRect(x, y, w, h, 4, fill=1, stroke=1)
-    if title:
-        c.setFillColor(TEXT_DARK)
-        c.setFont(BOLD, 8.5)
-        c.drawString(x + 6, y + h - 12, title)
-        return x + 6, y + h - 24
-    return x + 6, y + h - 12
-
-
-def text(c, x, y, s, font=None, size=8.5, color=None):
-    """Draw a string, return y below it."""
-    c.setFillColor(color or TEXT_DARK)
-    c.setFont(font or BODY, size)
-    c.drawString(x, y, s)
-    return y - size - 2
-
-
-def text_pair(c, x, y, label, value, lw=120):
-    """Draw a bold label + normal value on the same line."""
-    c.setFillColor(TEXT_DARK)
-    c.setFont(BOLD, 8)
-    c.drawString(x, y, label)
-    c.setFont(BODY, 8)
-    c.drawString(x + lw, y, value)
-    return y - 12
-
-
-def equiv(c, x, y, gear):
-    """Draw an 'Equivalent:' line in italic."""
-    c.setFillColor(TEXT_MID)
-    c.setFont(ITALIC, 7.5)
-    c.drawString(x, y, f"Analog equivalent: {gear}")
-    return y - 10
-
-
-# ══════════════════════════════════════════════════════════════════════════
-# PAGE 1
-# ══════════════════════════════════════════════════════════════════════════
-
-def page1(c):
-    # ── Title banner ──────────────────────────────────────────────────
-    bh = 52
-    c.setFillColor(BG_DARK)
-    c.rect(0, H - bh, W, bh, fill=1, stroke=0)
-    c.setFillColor(white)
-    c.setFont(BOLD, 16)
-    c.drawCentredString(W / 2, H - 24, "s.AI AUDIO MASTERING SUITE")
-    c.setFont(BODY, 10)
-    c.setFillColor(HexColor("#aaaacc"))
-    c.drawCentredString(W / 2, H - 42, "Analog Signal Flow Schematic  \u2022  v4.2  \u2022  Stereo")
-
-    # ── I/O labels ────────────────────────────────────────────────────
-    top_y = H - bh - 18
-    c.setFillColor(TEXT_MID)
-    c.setFont(MONO, 7.5)
-    c.drawString(M, top_y, "INPUT:  L/R  XLR Balanced  +4 dBu")
-    c.drawRightString(W - M, top_y, "OUTPUT:  L/R  XLR Balanced  +4 dBu  \u2022  24-bit WAV")
-
-    # ── Stage 1: Input Gain ───────────────────────────────────────────
-    s1_y = H - bh - 38
-    s1_h = 100
-    s1_x = M
-    s1_w = W - 2 * M
-
-    def s1_body(c, x, y, w):
-        y = text(c, x, y, "Stepped attenuator (resistor ladder, Elma gold-contact switch)", BODY, 8.5)
-        y -= 4
-        y = text(c, x, y, "Normalizes input to -18 LUFS internal working level.", BODY, 8.5)
-        y = text(c, x, y, "Prevents EQ stage clipping on hot masters (e.g. Suno at -9 LUFS).", BODY, 8.5)
-        y -= 4
-        y = text(c, x, y, "Stepped positions:  -3  /  -6  /  -9  /  -12  /  -15  /  -18 dB", MONO, 7.5, TEXT_MID)
-        y -= 4
-        y = equiv(c, x, y, "Dangerous Music Liaison  /  Crookwood M1")
-
-    stage_box(c, s1_x, s1_y - s1_h, s1_w, s1_h, "INPUT GAIN", s1_body, 1)
-
-    # Arrow
-    arr_x = W / 2
-    draw_arrow_down(c, arr_x, s1_y - s1_h, s1_y - s1_h - 22)
-
-    # ── Stage 2: Subsonic Filter + EQ ─────────────────────────────────
-    s2_y = s1_y - s1_h - 24
-    s2_h = 380
-    s2_x = M
-    s2_w = W - 2 * M
-
-    def s2_body(c, x, y, w):
-        # HPF sub-box
-        hpf_h = 72
-        hpf_x = x
-        hpf_w = w
-        bx, by = sub_box(c, hpf_x, y - hpf_h, hpf_w, hpf_h, "HPF 15 Hz")
-        by = text(c, bx, by, "2nd-order Butterworth (12 dB/oct)  \u2022  Passive LC network", BODY, 8)
-        by -= 2
-        by = text(c, bx, by, "-3 dB at 15 Hz, negligible loss above 35 Hz (-0.1 dB)", BODY, 8)
-        by -= 2
-        by = text(c, bx, by, "LPF removed in v3.4 \u2014 source band-limited by sample rate;", BODY, 8, TEXT_MID)
-        by = text(c, bx, by, "old 20 kHz LPF fought the 10 kHz high shelf in the air zone", BODY, 8, TEXT_MID)
-        by -= 2
-        equiv(c, bx, by, "Sontec MEP-250A filter section")
-
-        y = y - hpf_h - 6
-        draw_arrow_down(c, x + w / 2, y + 4, y - 10)
-        y -= 14
-
-        # EQ sub-box
-        eq_h = 258
-        bx, by = sub_box(c, x, y - eq_h, w, eq_h, "6-BAND PARAMETRIC EQ")
-        by = text(c, bx, by, "Discrete Class-A op-amps, inductorless gyrator topology", ITALIC, 7.5, TEXT_MID)
-        by -= 6
-
-        bands = [
-            ("BAND 1: BASS BOOST", "PeakFilter  \u2022  Q = 2.0  \u2022  40\u2013100 Hz",
-             "Narrow peak, 0 to +3 dB  \u2022  Twin-T notch / gyrator",
-             "Pultec EQP-1A low-end boost"),
-            ("BAND 2: LOWS SHELF", "LowShelf  \u2022  Q = 1.0  \u2022  200 Hz",
-             "Broad shelf below 200 Hz, \u00b13 dB  \u2022  RC shelf network",
-             "Manley Massive Passive low band"),
-            ("BAND 3: HIGHS SHELF", "HighShelf  \u2022  Q = 0.7  \u2022  10 kHz",
-             "Broad shelf above 10 kHz (\"Air\" band), \u00b13 dB  \u2022  Gentle slope",
-             "Maselec MEA-2 air band"),
-            ("BAND 4: MIDS PEAK", "PeakFilter  \u2022  Q = 1.0  \u2022  1.2 kHz",
-             "Wide bell centered at 1.2 kHz, \u00b13 dB  \u2022  Gyrator parametric",
-             "GML 8200  /  Sontec MEP-250A"),
-        ]
-
-        for i, (name, params, desc, eq_gear) in enumerate(bands):
-            band_h = 46
-            band_y = by - band_h
-            band_color = HexColor("#f0f4fa") if i % 2 == 0 else HexColor("#faf0f4")
-            c.setFillColor(band_color)
-            c.roundRect(bx - 2, band_y, w - 12, band_h, 3, fill=1, stroke=0)
-            ty = band_y + band_h - 12
-            ty = text(c, bx + 2, ty, name, BOLD, 8)
-            ty = text(c, bx + 2, ty, params, MONO, 7, TEXT_MID)
-            ty = text(c, bx + 2, ty, desc, BODY, 7.5)
-            equiv(c, bx + 2, ty, eq_gear)
-
-            by = band_y - 4
-
-    stage_box(c, s2_x, s2_y - s2_h, s2_w, s2_h, "SUBSONIC FILTER + EQ SECTION", s2_body, 2)
-
-    # Arrow to page 2
-    draw_arrow_down(c, arr_x, s2_y - s2_h, s2_y - s2_h - 18)
-    c.setFillColor(TEXT_LIGHT)
-    c.setFont(ITALIC, 7.5)
-    c.drawCentredString(arr_x, s2_y - s2_h - 28, "continued on next page")
-
-
-# ══════════════════════════════════════════════════════════════════════════
-# PAGE 2
-# ══════════════════════════════════════════════════════════════════════════
-
-def page2(c):
-    arr_x = W / 2
-
-    # ── Stage 3: Multiband Compressor ────────────────────────────────
-    s3_y = H - 28
-    s3_h = 370
-    s3_x = M
-    s3_w = W - 2 * M
-
-    def s3_body(c, x, y, w):
-        # Slider curve note
-        y = text(c, x, y, "LOGARITHMIC SLIDER CURVE:  t = (slider / 100)\u00b2  \u2014  "
-                 "bottom half (0\u201350) is transparent-to-light, aggressive in top 30% (70\u2013100)",
-                 BOLD, 7.5, WARM_RED)
-        y -= 4
-
-        # Crossover sub-box
-        xo_h = 38
-        bx, by = sub_box(c, x, y - xo_h, w, xo_h,
-                          "LINKWITZ-RILEY CROSSOVERS  (4th-order, 200 Hz + 4 kHz)")
-        by = text(c, bx, by, "Two cascaded 2nd-order Butterworth filters per split  "
-                  "\u2022  Zero-phase  \u2022  Perfect reconstruction", BODY, 7.5)
-        y = y - xo_h - 6
-
-        # 3-band columns
-        col_w = (w - 30) / 3
-        band_data = [
-            ("LOW BAND  (< 200 Hz)", ACCENT2, [
-                ("Threshold:", "-16  \u2500  -24 dB"),
-                ("Ratio:", "1.2:1  \u2500  3.0:1"),
-                ("Attack:", "80  \u2500  20 ms"),
-                ("Release:", "200  \u2500  120 ms"),
-            ], "Firmest control \u2014 attack scales\ndown to catch kick/bass transients",
-               "SSL G384 Bus Comp (low band)"),
-            ("MID BAND  (200 Hz \u2013 4 kHz)", ACCENT, [
-                ("Threshold:", "-14  \u2500  -24 dB"),
-                ("Ratio:", "1.1:1  \u2500  2.5:1"),
-                ("Attack:", "30  \u2500  10 ms"),
-                ("Release:", "150  \u2500  100 ms"),
-            ], "Musical peak control \u2014 attack\ncatches snare/vocal peaks at high comp",
-               "Manley Vari-Mu (mid band)"),
-            ("HIGH BAND  (> 4 kHz)", HexColor("#2a7a5a"), [
-                ("Threshold:", "-12  \u2500  -22 dB"),
-                ("Ratio:", "1.05:1  \u2500  2.0:1"),
-                ("Attack:", "10  \u2500  3 ms"),
-                ("Release:", "80  \u2500  40 ms"),
-            ], "Transient control \u2014 fast attack\ntames cymbal/click transients",
-               "Maselec MLA-3 (high band)"),
-        ]
-
-        band_h = 155
-        for i, (title, color, params, desc, gear) in enumerate(band_data):
-            bx_col = x + i * (col_w + 15)
-            # Band box
-            c.setFillColor(HexColor("#f8f8fc") if i % 2 == 0 else HexColor("#faf8f0"))
-            c.setStrokeColor(HexColor("#dddddd"))
-            c.setLineWidth(0.5)
-            c.roundRect(bx_col, y - band_h, col_w, band_h, 4, fill=1, stroke=1)
-            # Band title
-            c.setFillColor(color)
-            c.roundRect(bx_col, y - 16, col_w, 16, 4, fill=1, stroke=0)
-            c.rect(bx_col, y - 16, col_w, 4, fill=1, stroke=0)
-            c.setFillColor(white)
-            c.setFont(BOLD, 7.5)
-            c.drawCentredString(bx_col + col_w / 2, y - 12, title)
-            # Parameters
-            py = y - 28
-            for label, val in params:
-                c.setFillColor(TEXT_DARK)
-                c.setFont(BOLD, 7)
-                c.drawString(bx_col + 6, py, label)
-                c.setFont(MONO, 7)
-                c.drawString(bx_col + 58, py, val)
-                py -= 11
-            # Description
-            py -= 4
-            c.setFillColor(TEXT_MID)
-            c.setFont(ITALIC, 7)
-            for dl in desc.split("\n"):
-                c.drawString(bx_col + 6, py, dl)
-                py -= 9
-            # Gear equiv
-            py -= 2
-            c.setFont(ITALIC, 6.5)
-            c.drawString(bx_col + 6, py, f"Equiv: {gear}")
-
-        y = y - band_h - 8
-
-        # VCA topology note
-        y = text(c, x, y, "VCA topology  \u2022  RMS sidechain  \u2022  "
-                 "No makeup gain \u2014 LUFS normalization restores output level",
-                 BODY, 7.5, TEXT_MID)
-        y -= 2
-        # All parameters scale note
-        y = text(c, x, y, "All parameters (including attack) scale with slider position via quadratic curve",
-                 BOLD, 7.5, WARM_ORANGE)
-        y -= 4
-        # Bypass note
-        c.setFillColor(HexColor("#cc4444"))
-        c.setFont(BOLD, 8.5)
-        c.drawString(x, y, "TRUE BYPASS when slider = 0  (no processing)")
-        y -= 12
-        equiv(c, x, y, "SSL G384  /  Manley Vari-Mu  /  Maselec MLA-3  (3-band)")
-
-    stage_box(c, s3_x, s3_y - s3_h, s3_w, s3_h, "MULTIBAND COMPRESSOR  (3-Band)", s3_body, 3)
-
-    draw_arrow_down(c, arr_x, s3_y - s3_h, s3_y - s3_h - 20)
-
-    # ── Stage 4: Stereo Width ─────────────────────────────────────────
-    s4_y = s3_y - s3_h - 22
-    s4_h = 330
-    s4_x = M
-    s4_w = W - 2 * M
-
-    def s4_body(c, x, y, w):
-        # Crossover
-        cx_h = 48
-        bx, by = sub_box(c, x, y - cx_h, w, cx_h, "LINKWITZ-RILEY CROSSOVER  (4th-order, 200 Hz)")
-        by = text(c, bx, by, "Two cascaded 2nd-order Butterworth filters", BODY, 8)
-        by -= 2
-        equiv(c, bx, by, "Rane AC 22B active crossover")
-
-        y = y - cx_h - 6
-
-        # Split into two columns
-        col_w = (w - 20) / 2
-        left_x = x
-        right_x = x + col_w + 20
-
-        # LOW BAND label
-        c.setFillColor(ACCENT2)
-        c.setFont(BOLD, 8)
-        c.drawCentredString(left_x + col_w / 2, y - 10, "LOW BAND  (< 200 Hz)")
-        c.setFillColor(TEXT_MID)
-        c.setFont(BODY, 7.5)
-        c.drawCentredString(left_x + col_w / 2, y - 22, "Untouched \u2014 mono-safe bass")
-
-        # HIGH BAND label
-        c.setFillColor(ACCENT)
-        c.setFont(BOLD, 8)
-        c.drawCentredString(right_x + col_w / 2, y - 10, "HIGH BAND  (\u2265 200 Hz)")
-
-        y -= 30
-
-        # M/S boxes on the right
-        ms_blocks = [
-            ("M/S ENCODE", "Mid = (L + R) / 2\nSide = (L \u2212 R) / 2",
-             "Resistor summing matrix (matched 0.1% precision)"),
-            ("WIDTH CONTROL", "Mid  \u00d7  mid_scale\nSide \u00d7  side_scale",
-             "Energy-preserving: mid_scale = \u221a(2/(1+w\u00b2))   Range: 80\u2013150%"),
-            ("M/S DECODE", "L = Mid + Side\nR = Mid \u2212 Side",
-             "Resistor summing matrix"),
-        ]
-
-        for i, (name, formulas, desc) in enumerate(ms_blocks):
-            bh = 52
-            bx2, by2 = sub_box(c, right_x, y - bh, col_w, bh, name)
-            for line in formulas.split("\n"):
-                by2 = text(c, bx2, by2, line, MONO, 7.5, TEXT_MID)
-            text(c, bx2, by2, desc, BODY, 7, TEXT_MID)
-            if i < 2:
-                draw_arrow_down(c, right_x + col_w / 2, y - bh, y - bh - 10)
-            y = y - bh - 14
-
-        # Summing
-        y -= 6
-        c.setStrokeColor(ACCENT)
-        c.setLineWidth(1)
-        c.line(left_x + col_w / 2, y + 70, left_x + col_w / 2, y + 10)  # low band vertical
-        c.line(left_x + col_w / 2, y + 10, right_x + col_w / 2, y + 10)  # horizontal join
-        c.line(right_x + col_w / 2, y + 30, right_x + col_w / 2, y + 10)
-        # Plus symbol
-        cx = (left_x + col_w / 2 + right_x + col_w / 2) / 2
-        c.setFont(BOLD, 12)
-        c.setFillColor(ACCENT)
-        c.drawCentredString(cx, y + 6, "+")
-
-        draw_arrow_down(c, cx, y + 4, y - 8)
-        y -= 10
-        c.setFillColor(TEXT_MID)
-        c.setFont(BODY, 7.5)
-        c.drawCentredString(cx, y - 4, "Summing amp  (clip protection if peak > 1.0)")
-        equiv(c, x, y - 18, "Brainworx bx_control V2")
-
-    stage_box(c, s4_x, s4_y - s4_h, s4_w, s4_h, "STEREO WIDTH \u2014 FREQUENCY-SELECTIVE M/S MATRIX", s4_body, 4)
-
-    draw_arrow_down(c, arr_x, s4_y - s4_h, s4_y - s4_h - 18)
-    c.setFillColor(TEXT_LIGHT)
-    c.setFont(ITALIC, 7.5)
-    c.drawCentredString(arr_x, s4_y - s4_h - 28, "continued on next page")
-
-
-# ══════════════════════════════════════════════════════════════════════════
-# PAGE 3
-# ══════════════════════════════════════════════════════════════════════════
-
-def page3(c):
-    arr_x = W / 2
-
-    # ── Stage 5: LUFS Normalization ──────────────────────────────────
-    s5_y = H - 28
-    s5_h = 130
-    s5_x = M
-    s5_w = W - 2 * M
-
-    def s5_body(c, x, y, w):
-        col_w = (w - 20) / 2
-
-        # LUFS Meter
-        bh = 52
-        bx, by = sub_box(c, x, y - bh, col_w, bh, "LUFS METER  (ITU-R BS.1770)")
-        by = text(c, bx, by, "Integrated loudness measurement", BODY, 8)
-        by -= 2
-        by = text(c, bx, by, "K-weighted, gated per BS.1770-4", MONO, 7, TEXT_MID)
-
-        # Output Gain Trim
-        rx = x + col_w + 20
-        bx2, by2 = sub_box(c, rx, y - bh, col_w, bh, "OUTPUT GAIN TRIM")
-        by2 = text(c, bx2, by2, "Stepped relay attenuator", BODY, 8)
-        by2 = text(c, bx2, by2, "Applies gain delta to hit target LUFS exactly", BODY, 8)
-        by2 -= 2
-        by2 = text(c, bx2, by2, "Targets:  -14 (Streaming)  /  -11 (CD)  /  Custom", MONO, 7, TEXT_MID)
-
-        # Arrow between them
-        c.setStrokeColor(ACCENT)
-        c.setLineWidth(1.5)
-        mid_y = y - bh / 2
-        c.line(x + col_w + 2, mid_y, rx - 2, mid_y)
-        c.setFillColor(ACCENT)
-        p = c.beginPath()
-        p.moveTo(rx - 2, mid_y)
-        p.lineTo(rx - 10, mid_y + 4)
-        p.lineTo(rx - 10, mid_y - 4)
-        p.close()
-        c.drawPath(p, fill=1, stroke=0)
-
-        y -= bh + 8
-        equiv(c, x, y, "Dorrough 40-A loudness meter  +  Dangerous Music Monitor ST")
-
-    stage_box(c, s5_x, s5_y - s5_h, s5_w, s5_h, "OUTPUT LEVEL \u2014 LUFS NORMALIZATION", s5_body, 5)
-
-    draw_arrow_down(c, arr_x, s5_y - s5_h, s5_y - s5_h - 18)
-
-    # ── Stage 6: Soft Clipper ────────────────────────────────────────
-    s6_y = s5_y - s5_h - 20
-    s6_h = 155
-    s6_x = M
-    s6_w = W - 2 * M
-
-    def s6_body(c, x, y, w):
-        y = text(c, x, y, "Piecewise tanh saturation \u2014 analog-style waveshaping (NOT a limiter)", BOLD, 8.5)
-        y -= 4
-
-        col_w = (w - 20) / 2
-
-        # Left: How it works
-        bh = 80
-        bx, by = sub_box(c, x, y - bh, col_w, bh, "TRANSFER FUNCTION")
-        by = text(c, bx, by, "Ceiling:  -0.1 dBTP  (linear \u2248 0.9885)", MONO, 7, TEXT_MID)
-        by = text(c, bx, by, "Knee:  2 dB below ceiling", MONO, 7, TEXT_MID)
-        by -= 4
-        by = text(c, bx, by, "Below knee: perfectly linear (zero processing)", BODY, 7.5)
-        by = text(c, bx, by, "Above knee: tanh(excess / headroom) \u2192 asymptotes to ceiling", BODY, 7.5)
-        by -= 2
-        by = text(c, bx, by, "Only affects top 1\u20132 dB of loudest transient tips", BOLD, 7, WARM_RED)
-
-        # Right: Behavior
-        rx = x + col_w + 20
-        bx2, by2 = sub_box(c, rx, y - bh, col_w, bh, "BEHAVIOR")
-        by2 = text(c, bx2, by2, "Shaves peak tips without reducing LUFS", BODY, 7.5)
-        by2 = text(c, bx2, by2, "Allows normalization to reach target loudness", BODY, 7.5)
-        by2 -= 4
-        by2 = text(c, bx2, by2, "Reduces crest factor by 1\u20132 dB on hot material", MONO, 7, TEXT_MID)
-        by2 = text(c, bx2, by2, "Transparent on well-mixed sources", MONO, 7, TEXT_MID)
-        by2 -= 2
-        by2 = text(c, bx2, by2, "Always active (no bypass needed \u2014 linear below knee)", BOLD, 7, WARM_ORANGE)
-
-        y -= bh + 8
-        equiv(c, x, y, "Kush Omega N  /  Thermionic Culture Vulture (gentle saturation mode)")
-
-    stage_box(c, s6_x, s6_y - s6_h, s6_w, s6_h, "SOFT CLIPPER \u2014 PIECEWISE TANH SATURATION", s6_body, 6)
-
-    draw_arrow_down(c, arr_x, s6_y - s6_h, s6_y - s6_h - 18)
-
-    # ── Stage 7: True Peak Ceiling ───────────────────────────────────
-    s7_y = s6_y - s6_h - 20
-    s7_h = 105
-    s7_x = M
-    s7_w = W - 2 * M
-
-    def s7_body(c, x, y, w):
-        y = text(c, x, y, "Safety net \u2014 catches any residual inter-sample peaks the soft clipper didn't fully tame",
-                 BODY, 8.5)
-        y -= 4
-        y = text(c, x, y, "Measures true peak via 4x oversampling per ITU-R BS.1770", MONO, 7.5, TEXT_MID)
-        y = text(c, x, y, "If true peak > -0.1 dBTP:  scales entire signal down by overshoot amount", MONO, 7.5, TEXT_MID)
-        y -= 4
-        y = text(c, x, y, "Rarely engages thanks to soft clipper \u2014 typically < 0.1 dB correction", BODY, 8)
-        y -= 4
-        c.setFillColor(HexColor("#cc4444"))
-        c.setFont(BOLD, 8)
-        c.drawString(x, y, "GUARANTEES:  True peak \u2264 -0.1 dBTP on all output")
-        y -= 12
-        equiv(c, x, y, "Dorrough 40-A peak meter  +  relay attenuator")
-
-    stage_box(c, s7_x, s7_y - s7_h, s7_w, s7_h, "TRUE PEAK CEILING  (-0.1 dBTP)", s7_body, 7)
-
-    draw_arrow_down(c, arr_x, s7_y - s7_h, s7_y - s7_h - 18)
-
-    # Output file box
-    out_y = s7_y - s7_h - 20
-    out_w = 140
-    out_h = 30
-    out_x = arr_x - out_w / 2
-    c.setFillColor(BG_DARK)
-    c.roundRect(out_x, out_y - out_h, out_w, out_h, 6, fill=1, stroke=0)
-    c.setFillColor(white)
-    c.setFont(BOLD, 10)
-    c.drawCentredString(arr_x, out_y - 19, "24-bit WAV")
-
-    # ── Gear Rack Table ───────────────────────────────────────────────
-    table_y = out_y - out_h - 30
-    c.setFillColor(BG_DARK)
-    c.setFont(BOLD, 11)
-    c.drawString(M, table_y, "ANALOG GEAR RACK EQUIVALENT")
-    table_y -= 6
-
-    # Table
-    c.setStrokeColor(BORDER)
-    c.setLineWidth(0.5)
-
-    rows = [
-        ("1U", "Dangerous Music Liaison", "Input gain / level matching"),
-        ("2U", "Sontec MEP-250A", "HPF + 6-band parametric EQ"),
-        ("3U", "SSL G384 / Manley Vari-Mu / Maselec MLA-3", "3-band multiband compression, bypass at 0"),
-        ("1U", "Rane AC 22B", "Linkwitz-Riley crossover (200 Hz)"),
-        ("1U", "Brainworx bx_control V2", "M/S encode / width / decode"),
-        ("1U", "Dorrough 40-A + Dangerous ST", "LUFS metering + output gain trim"),
-        ("1U", "Kush Omega N", "Piecewise tanh soft clipper (-0.1 dBTP ceiling)"),
-        ("--", "Dorrough 40-A (peak section)", "True peak ceiling / safety net"),
-    ]
-
-    col_x = [M, M + 30, M + 230]
-    row_h = 16
-    table_w = W - 2 * M
-
-    # Header
-    c.setFillColor(ACCENT)
-    c.rect(M, table_y - row_h, table_w, row_h, fill=1, stroke=0)
-    c.setFillColor(white)
-    c.setFont(BOLD, 7.5)
-    c.drawString(col_x[0] + 4, table_y - 12, "SIZE")
-    c.drawString(col_x[1] + 4, table_y - 12, "UNIT")
-    c.drawString(col_x[2] + 4, table_y - 12, "FUNCTION")
-    table_y -= row_h
-
-    for i, (size, unit, func) in enumerate(rows):
-        bg = HexColor("#f8f8fc") if i % 2 == 0 else white
-        c.setFillColor(bg)
-        c.rect(M, table_y - row_h, table_w, row_h, fill=1, stroke=0)
-        c.setStrokeColor(HexColor("#eeeeee"))
-        c.line(M, table_y - row_h, M + table_w, table_y - row_h)
-        c.setFillColor(TEXT_DARK)
-        c.setFont(BOLD, 7.5)
-        c.drawString(col_x[0] + 4, table_y - 12, size)
-        c.setFont(BODY, 7.5)
-        c.drawString(col_x[1] + 4, table_y - 12, unit)
-        c.setFont(BODY, 7.5)
-        c.drawString(col_x[2] + 4, table_y - 12, func)
-        table_y -= row_h
-
-    # Total row
-    c.setFillColor(BG_DARK)
-    c.rect(M, table_y - row_h, table_w, row_h, fill=1, stroke=0)
-    c.setFillColor(white)
-    c.setFont(BOLD, 8)
-    c.drawString(col_x[0] + 4, table_y - 12, "10U")
-    c.drawString(col_x[1] + 4, table_y - 12, "Total rack space")
-
-    # ── Signal flow summary ───────────────────────────────────────────
-    table_y -= row_h + 20
-    c.setFillColor(TEXT_MID)
-    c.setFont(BOLD, 8)
-    c.drawCentredString(W / 2, table_y, "SIGNAL FLOW")
-
-    table_y -= 14
-    flow_parts = [
-        "Pre-Gain\nDrop\n(-18 LUFS)",
-        "HPF\n15 Hz",
-        "EQ\n6-Band",
-        "Multiband\nComp\n(3-Band)",
-        "Stereo\nWidth\n(M/S)",
-        "LUFS\nNormalize",
-        "Soft\nClipper",
-        "True Peak\nCeiling",
-        "Output",
-    ]
-
-    total_w = W - 2 * M
-    box_w = 56
-    gap = (total_w - len(flow_parts) * box_w) / (len(flow_parts) - 1)
-    bx_start = M
-
-    for i, part in enumerate(flow_parts):
-        bx = bx_start + i * (box_w + gap)
-        bh = 36
-
-        if i == len(flow_parts) - 1:
-            c.setFillColor(BG_DARK)
-        elif i == 6:  # Soft Clipper
-            c.setFillColor(WARM_RED)
-        elif i == 7:  # True Peak Ceiling
-            c.setFillColor(WARM_ORANGE)
-        else:
-            c.setFillColor(ACCENT if i % 2 == 0 else ACCENT2)
-        c.roundRect(bx, table_y - bh, box_w, bh, 4, fill=1, stroke=0)
-
-        c.setFillColor(white)
-        c.setFont(BOLD, 6.5)
-        lines = part.split("\n")
-        line_y = table_y - 9 - (len(lines) - 1) * 4
-        for line in lines:
-            c.drawCentredString(bx + box_w / 2, line_y, line)
-            line_y -= 8
-
-        # Arrow between boxes
-        if i < len(flow_parts) - 1:
-            ax1 = bx + box_w + 1
-            ax2 = bx + box_w + gap - 1
-            ay = table_y - bh / 2
-            c.setStrokeColor(TEXT_MID)
-            c.setLineWidth(1)
-            c.line(ax1, ay, ax2 - 5, ay)
-            c.setFillColor(TEXT_MID)
-            p = c.beginPath()
-            p.moveTo(ax2, ay)
-            p.lineTo(ax2 - 5, ay + 3)
-            p.lineTo(ax2 - 5, ay - 3)
-            p.close()
-            c.drawPath(p, fill=1, stroke=0)
-
-
-# ══════════════════════════════════════════════════════════════════════════
-# PAGE 4 — Super AI (beta) Workflow
-# ══════════════════════════════════════════════════════════════════════════
-
-SUPER_GREEN = HexColor("#1a7a3a")
-SUPER_BLUE  = HexColor("#2a5a9a")
-SUPER_GOLD  = HexColor("#8a6d1b")
-
-def page4(c):
-    arr_x = W / 2
-
-    # ── Title banner ──────────────────────────────────────────────────
-    bh = 52
-    c.setFillColor(BG_DARK)
-    c.rect(0, H - bh, W, bh, fill=1, stroke=0)
-    c.setFillColor(white)
-    c.setFont(BOLD, 16)
-    c.drawCentredString(W / 2, H - 24, "SUPER AI (BETA) — 5-PASS MASTERING WORKFLOW")
-    c.setFont(BODY, 10)
-    c.setFillColor(HexColor("#aaaacc"))
-    c.drawCentredString(W / 2, H - 42,
-                        "Full Parametric AI Control  •  Gemini 2.5 Pro  •  v4.2")
-
-    # ── 5-Pass Flow Diagram ───────────────────────────────────────────
-    flow_y = H - bh - 18
-    c.setFillColor(TEXT_DARK)
-    c.setFont(BOLD, 11)
-    c.drawString(M, flow_y, "5-PASS ITERATIVE REFINEMENT LOOP")
-    flow_y -= 8
-
-    passes = [
-        ("PASS 1", "AI ANALYZE → MASTER",
-         "AI analyzes raw audio measurements (spectral profile, dynamics,\n"
-         "stereo field, crest factor). Returns full parametric settings.\n"
-         "DSP chain processes audio with AI-chosen parameters.",
-         SUPER_GREEN),
-        ("PASS 2", "AI COMPARE → REVISE → RE-MASTER",
-         "AI compares original vs mastered measurements. Makes SMALL\n"
-         "incremental adjustments to all parameters. Re-masters with\n"
-         "revised settings. Full history context prevents oscillation.",
-         SUPER_BLUE),
-        ("PASS 3", "AI COMPARE → REVISE → RE-MASTER",
-         "Same as Pass 2. Further refinement. AI references all prior\n"
-         "passes to avoid reverting previous improvements.",
-         SUPER_BLUE),
-        ("PASS 4", "AI COMPARE → REVISE → RE-MASTER",
-         "Same as Pass 2–3. Final adjustment pass. AI makes the\n"
-         "smallest, most surgical changes at this stage.",
-         SUPER_BLUE),
-        ("PASS 5", "FINAL REPORT (NO CHANGES)",
-         "AI compares final master against original. Writes a quality\n"
-         "report covering spectral balance, dynamics, stereo image,\n"
-         "and streaming compliance. No parameter changes — report only.",
-         SUPER_GOLD),
-    ]
-
-    box_h = 60
-    gap = 6
-    for i, (label, title, desc, color) in enumerate(passes):
-        bx = M
-        by = flow_y - (i * (box_h + gap + 14))
-        bw = W - 2 * M
-
-        # Pass number badge
-        badge_w = 52
-        c.setFillColor(color)
-        c.roundRect(bx, by - box_h, badge_w, box_h, 4, fill=1, stroke=0)
-        c.setFillColor(white)
-        c.setFont(BOLD, 9)
-        c.drawCentredString(bx + badge_w / 2, by - box_h / 2 + 4, label)
-
-        # Content box
-        cx = bx + badge_w + 6
-        cw = bw - badge_w - 6
-        c.setFillColor(BG_STAGE)
-        c.setStrokeColor(BORDER)
-        c.setLineWidth(0.5)
-        c.roundRect(cx, by - box_h, cw, box_h, 4, fill=1, stroke=1)
-
-        # Title
-        c.setFillColor(color)
-        c.setFont(BOLD, 9)
-        c.drawString(cx + 8, by - 14, title)
-
-        # Description
-        c.setFillColor(TEXT_MID)
-        c.setFont(BODY, 7.5)
-        desc_y = by - 26
-        for line in desc.strip().split("\n"):
-            c.drawString(cx + 8, desc_y, line.strip())
-            desc_y -= 10
-
-        # Arrow between passes
-        if i < len(passes) - 1:
-            draw_arrow_down(c, bx + badge_w / 2, by - box_h,
-                            by - box_h - gap - 12)
-
-        flow_y = by  # track for next section
-
-    # ── AI-Controlled Parameters ──────────────────────────────────────
-    param_y = flow_y - box_h - gap - 30
-    param_h = 300
-    param_x = M
-    param_w = W - 2 * M
-
-    def param_body(c, x, y, w):
-        col_w = (w - 16) / 2
-
-        # LEFT COLUMN — EQ + HPF
-        left_x = x
-        y_left = y
-
-        # HPF
-        y_left = text(c, left_x, y_left, "HIGH-PASS FILTER", BOLD, 8.5, ACCENT)
-        y_left = text(c, left_x, y_left, "Cutoff:  10 – 80 Hz  (default 15 Hz)", MONO, 7, TEXT_MID)
-        y_left = text(c, left_x, y_left, "12 dB/oct Butterworth", BODY, 7.5)
-        y_left -= 6
-
-        # EQ
-        y_left = text(c, left_x, y_left, "6-BAND FULLY PARAMETRIC EQ", BOLD, 8.5, ACCENT)
-        y_left = text(c, left_x, y_left, "Each band independently configurable:", BODY, 7.5)
-        y_left -= 2
-        eq_params = [
-            ("Type:", "peak  /  low_shelf  /  high_shelf"),
-            ("Frequency:", "20 – 20,000 Hz"),
-            ("Gain:", "-6 to +6 dB"),
-            ("Q:", "0.1 – 10.0"),
-        ]
-        for label, val in eq_params:
-            c.setFillColor(TEXT_DARK)
-            c.setFont(BOLD, 7)
-            c.drawString(left_x + 8, y_left, label)
-            c.setFont(MONO, 7)
-            c.drawString(left_x + 75, y_left, val)
-            y_left -= 10
-        y_left -= 2
-        y_left = text(c, left_x, y_left, "Not limited to UI ±3 dB — full ±6 dB range", BOLD, 7, WARM_RED)
-        y_left -= 6
-
-        # Stereo
-        y_left = text(c, left_x, y_left, "STEREO WIDTH", BOLD, 8.5, ACCENT)
-        y_left = text(c, left_x, y_left, "Range:  80 – 150%  (M/S matrix)", MONO, 7, TEXT_MID)
-        y_left = text(c, left_x, y_left, "Crossover at 200 Hz (fixed) — bass stays mono", BODY, 7.5)
-
-        # RIGHT COLUMN — Compression + Crossovers
-        right_x = x + col_w + 16
-        y_right = y
-
-        y_right = text(c, right_x, y_right, "MULTIBAND COMPRESSION (3-band)", BOLD, 8.5, ACCENT2)
-        y_right = text(c, right_x, y_right, "Per-band independent control:", BODY, 7.5)
-        y_right -= 2
-
-        comp_params = [
-            ("Threshold:", "-20 to 0 dB"),
-            ("Ratio:", "1.0 – 4.0  (1.0 = bypass)"),
-            ("Attack:", "0.1 – 200 ms"),
-            ("Release:", "10 – 500 ms"),
-        ]
-        for label, val in comp_params:
-            c.setFillColor(TEXT_DARK)
-            c.setFont(BOLD, 7)
-            c.drawString(right_x + 8, y_right, label)
-            c.setFont(MONO, 7)
-            c.drawString(right_x + 75, y_right, val)
-            y_right -= 10
-        y_right -= 2
-        y_right = text(c, right_x, y_right,
-                       "No makeup gain — LUFS normalization restores level",
-                       BODY, 7.5, TEXT_MID)
-        y_right -= 8
-
-        y_right = text(c, right_x, y_right, "CROSSOVER FREQUENCIES", BOLD, 8.5, ACCENT2)
-        y_right = text(c, right_x, y_right, "Low/Mid split:   80 – 500 Hz  (default 200 Hz)", MONO, 7, TEXT_MID)
-        y_right = text(c, right_x, y_right, "Mid/High split:  1,000 – 10,000 Hz  (default 4 kHz)", MONO, 7, TEXT_MID)
-        y_right = text(c, right_x, y_right, "Linkwitz-Riley 4th-order (zero-phase, perfect reconstruction)", BODY, 7.5)
-        y_right -= 8
-
-        # Fixed stages note
-        y_right = text(c, right_x, y_right, "FIXED (NOT AI-CONTROLLED):", BOLD, 8.5, WARM_RED)
-        y_right = text(c, right_x, y_right, "• Pre-gain drop to -18 LUFS", BODY, 7.5)
-        y_right = text(c, right_x, y_right, "• LUFS target (set by user)", BODY, 7.5)
-        y_right = text(c, right_x, y_right, "• Soft clipper (-0.1 dBTP ceiling)", BODY, 7.5)
-        y_right = text(c, right_x, y_right, "• True peak ceiling (-0.1 dBTP)", BODY, 7.5)
-        y_right = text(c, right_x, y_right, "• Stereo width crossover (200 Hz)", BODY, 7.5)
-
-    stage_box(c, param_x, param_y - param_h, param_w, param_h,
-              "AI-CONTROLLED PARAMETERS — FULL PARAMETRIC RANGE", param_body)
-
-
-def page5(c):
-    """Page 5: AI Prompting Instructions & Philosophy."""
-    arr_x = W / 2
-
-    # ── Title banner ──────────────────────────────────────────────────
-    bh = 52
-    c.setFillColor(BG_DARK)
-    c.rect(0, H - bh, W, bh, fill=1, stroke=0)
-    c.setFillColor(white)
-    c.setFont(BOLD, 16)
-    c.drawCentredString(W / 2, H - 24, "SUPER AI — PROMPTING PHILOSOPHY")
-    c.setFont(BODY, 10)
-    c.setFillColor(HexColor("#aaaacc"))
-    c.drawCentredString(W / 2, H - 42,
-                        "AI Mastering Engineer Instructions  •  v4.2")
-
-    y = H - bh - 24
-
-    # ── Mastering Philosophy ──────────────────────────────────────────
-    phil_h = 118
-    def phil_body(c, x, y, w):
-        points = [
-            "Listen to what the audio NEEDS, not what sounds impressive on paper.",
-            "Use surgical EQ moves — small cuts are often more effective than boosts.",
-            "Match compression to the genre and dynamic character of the material.",
-            "Preserve the artist's intent — enhance, don't transform.",
-            "Be musical and intentional. Every parameter should have a reason.",
-            "LESS IS MORE — use the minimum processing needed. Gentle moves preferred.",
-        ]
-        for pt in points:
-            c.setFillColor(ACCENT)
-            c.setFont(BOLD, 8)
-            c.drawString(x, y, "•")
-            c.setFillColor(TEXT_DARK)
-            c.setFont(BODY, 8)
-            c.drawString(x + 12, y, pt)
-            y -= 14
-        y -= 4
-        c.setFillColor(TEXT_MID)
-        c.setFont(ITALIC, 7.5)
-        c.drawString(x, y, "The AI receives spectral centroid, rolloff, 6-band energy distribution, "
-                     "crest factor, dynamic range, and stereo correlation.")
-
-    stage_box(c, M, y - phil_h, W - 2 * M, phil_h, "MASTERING PHILOSOPHY", phil_body)
-    y -= phil_h + 20
-
-    # ── Tonal Direction ───────────────────────────────────────────────
-    tone_h = 100
-    def tone_body(c, x, y, w):
-        col_w = (w - 20) / 2
-
-        # Warm
-        bh = 52
-        bx, by = sub_box(c, x, y - bh, col_w, bh, "SLIGHTLY WARM TONE")
-        by = text(c, bx, by, "Favor gentle richness in the low-mids (200–500 Hz)", BODY, 8)
-        by = text(c, bx, by, "Smooth, non-harsh highs — avoid clinical or brittle sound", BODY, 8)
-        by -= 2
-        text(c, bx, by, "Think: Neve console warmth, not Pultec mud", ITALIC, 7, TEXT_MID)
-
-        # Bass
-        rx = x + col_w + 20
-        bx2, by2 = sub_box(c, rx, y - bh, col_w, bh, "HEAVY, UNCONSTRAINED BASS")
-        by2 = text(c, bx2, by2, "Protect low-end punch and transients (40-100 Hz)", BODY, 8)
-        by2 = text(c, bx2, by2, "DO NOT over-compress <200 Hz. HPF max 25 Hz.", BODY, 8)
-        by2 -= 2
-        text(c, bx2, by2, "Sub-bass should feel physical, anchored, wide open", ITALIC, 7, TEXT_MID)
-
-    stage_box(c, M, y - tone_h, W - 2 * M, tone_h,
-              "TONAL DIRECTION (applied to all masters)", tone_body)
-    y -= tone_h + 20
-
-    # ── True Peak Guidance ────────────────────────────────────────────
-    tp_h = 148
-    def tp_body(c, x, y, w):
-        y = text(c, x, y, "IDEAL GOAL:  True peak between -1.0 and -0.1 dBTP", BOLD, 9, SUPER_GREEN)
-        y -= 6
-        y = text(c, x, y, "However, this is a SOFT GOAL — not a hard constraint.", BOLD, 8.5, TEXT_DARK)
-        y -= 6
-
-        points = [
-            ("Source awareness:", "AI-generated tracks (Suno, Udio, etc.) are already heavily "
-             "limited with very low crest factor."),
-            ("Expected behavior:", "When normalized DOWN to a streaming LUFS target (e.g. -14), "
-             "the true peak will naturally drop well below -1.0 dBTP. This is correct."),
-            ("Dynamics > True peak:", "DO NOT over-compress or crush dynamics to force the true "
-             "peak higher. Dynamics preservation is MORE important."),
-            ("Compression purpose:", "Use compression for tonal shaping and dynamic control — "
-             "NEVER to artificially raise the true peak."),
-        ]
-        for label, desc in points:
-            c.setFillColor(WARM_RED)
-            c.setFont(BOLD, 7.5)
-            c.drawString(x, y, label)
-            c.setFillColor(TEXT_DARK)
-            c.setFont(BODY, 7.5)
-            c.drawString(x + 100, y, desc)
-            y -= 20
-
-    stage_box(c, M, y - tp_h, W - 2 * M, tp_h,
-              "TRUE PEAK GUIDANCE", tp_body)
-    y -= tp_h + 20
-
-    # ── Review Guidelines (Compare Passes) ────────────────────────────
-    rev_h = 118
-    def rev_body(c, x, y, w):
-        points = [
-            "Compare original vs mastered measurements carefully.",
-            "Make SMALL, incremental adjustments — do not overhaul settings that are working.",
-            "If something sounds good, leave it alone.",
-            "Reference the previous analysis history to avoid oscillating between settings.",
-            "Each revision should be a refinement, not a reset.",
-            "LUFS target is fixed — do not try to change it.",
-        ]
-        for pt in points:
-            c.setFillColor(ACCENT2)
-            c.setFont(BOLD, 8)
-            c.drawString(x, y, "•")
-            c.setFillColor(TEXT_DARK)
-            c.setFont(BODY, 8)
-            c.drawString(x + 12, y, pt)
-            y -= 14
-
-    stage_box(c, M, y - rev_h, W - 2 * M, rev_h,
-              "COMPARE PASS GUIDELINES (Passes 2–4)", rev_body)
-    y -= rev_h + 20
-
-    # ── Final Report ──────────────────────────────────────────────────
-    rep_h = 118
-    def rep_body(c, x, y, w):
-        y = text(c, x, y, "Pass 5 produces a comprehensive quality report — NO parameter changes.",
-                 BOLD, 8.5, TEXT_DARK)
-        y -= 6
-        sections = [
-            ("Overall Assessment:", "Mastering effectiveness, professional standards, tonal goals met?"),
-            ("Spectral Balance:", "Low end warmth, midrange richness, high end smoothness"),
-            ("Dynamics & Loudness:", "LUFS compliance, true peak, crest factor, dynamic range"),
-            ("Stereo Image:", "Width, mono compatibility, balance"),
-            ("Processing Summary:", "What the chain did — EQ moves, compression character"),
-            ("Verdict:", "Pass/fail for streaming distribution"),
-        ]
-        for label, desc in sections:
-            c.setFillColor(SUPER_GOLD)
-            c.setFont(BOLD, 7.5)
-            c.drawString(x, y, label)
-            c.setFillColor(TEXT_MID)
-            c.setFont(BODY, 7.5)
-            c.drawString(x + 130, y, desc)
-            y -= 12
-
-    stage_box(c, M, y - rep_h, W - 2 * M, rep_h,
-              "FINAL REPORT STRUCTURE (Pass 5)", rep_body)
-
-    # ── Footer ────────────────────────────────────────────────────────
-    c.setFillColor(TEXT_LIGHT)
-    c.setFont(ITALIC, 7)
-    c.drawCentredString(W / 2, M - 10,
-                        "AI engine: Google Gemini 2.5 Pro  •  5 API calls per master  •  "
-                        "Session-persistent history prevents oscillation")
-
-
-# ══════════════════════════════════════════════════════════════════════════
-# BUILD
-# ══════════════════════════════════════════════════════════════════════════
-
-def build():
-    c = canvas.Canvas(OUTPUT, pagesize=letter)
-    c.setTitle("s.AI Audio Mastering Suite \u2014 Analog Signal Flow Schematic v4.2")
-    c.setAuthor("StudioAI")
-
-    page1(c)
-    c.showPage()
-    page2(c)
-    c.showPage()
-    page3(c)
-    c.showPage()
-    page4(c)
-    c.showPage()
-    page5(c)
-    c.showPage()
-
-    c.save()
-    print(f"Created {OUTPUT}")
-
-
-if __name__ == "__main__":
-    build()

dsp.py

@@ -3,14 +3,14 @@
 import tempfile
 import numpy as np
 from pedalboard import (
-    Pedalboard, Compressor,
+    Pedalboard, Compressor, Gain, Limiter,
     LowShelfFilter, HighShelfFilter, PeakFilter,
-    HighpassFilter,
+    HighpassFilter, LowpassFilter,
 )
 from pedalboard.io import ReadableAudioFile
 import soundfile as sf
 
-from stereo import apply_stereo_width, linkwitz_riley_crossover
+from stereo import apply_stereo_width
 from loudness import measure_loudness, measure_true_peak, normalize_to_lufs
 
 
@@ -18,85 +18,28 @@ from loudness import measure_loudness, measure_true_peak, normalize_to_lufs
 # Slider-to-parameter mappings
 # ---------------------------------------------------------------------------
 
-# DEPRECATED — Retained for backward compat. Use map_multiband_compression().
 def map_compression(comp_value):
-    """Map compression slider (0 less to 100 more) to safe mastering glue params.
-    Calibrated for a -18 LUFS internal working level.
+    """Map compression slider (0 less to 100 more) to compressor params.
 
     Returns (threshold_db, ratio, attack_ms, release_ms).
     """
     t = comp_value / 100.0  # 0.0 (less) → 1.0 (more)
 
-    # Threshold: -14.0 dB (less) → -22.0 dB (more)
-    threshold_db = -14.0 + t * (-8.0)
+    # Threshold: -12.0 dB (less) → -18.0 dB (more)
+    threshold_db = -12.0 + t * (-18.0 - (-12.0))
 
-    # Ratio: 1.1:1 (less) → 2.5:1 (more)
-    ratio = 1.1 + t * 1.4
+    # Ratio: 1:1 (less) → 4:1 (more)
+    ratio = 1.0 + t * 3.0
 
-    # Attack: 30 ms (Fixed - lets transients breathe)
-    attack_ms = 30.0
+    # Attack: 15 ms (fixed)
+    attack_ms = 15.0
 
-    # Release: 250 ms (slow/smooth for acoustic) → 100 ms (fast/punchy for EDM/Pop)
-    release_ms = 250.0 + t * (-150.0)
+    # Release: 120 ms (fixed)
+    release_ms = 120.0
 
     return threshold_db, ratio, attack_ms, release_ms
 
 
-# ---------------------------------------------------------------------------
-# Multiband compression parameter curves (v3.5)
-# ---------------------------------------------------------------------------
-
-# Crossover frequencies for 3-band split
-_MB_CROSS_LOW = 200.0    # Hz — below this is "Low" band
-_MB_CROSS_HIGH = 4000.0  # Hz — above this is "High" band
-
-
-def map_multiband_compression(comp_value):
-    """Map compression slider (0-100) to per-band mastering parameters.
-
-    Three bands tuned to industry best practices:
-      Low  (< 200 Hz)   — Firmest control, slow attack lets kick punch through
-      Mid  (200 Hz-4 kHz) — Lightest touch, preserve vocals/instruments
-      High (> 4 kHz)     — Barely compresses, fast attack tames harsh transients
-
-    Each band returns (threshold_db, ratio, attack_ms, release_ms).
-    All curves calibrated for -18 LUFS internal working level.
-
-    Returns dict: {"low": (...), "mid": (...), "high": (...)}.
-    """
-    # Logarithmic curve: bottom half of slider stays in transparent range,
-    # top half ramps into aggressive territory.  t² gives ~50% of slider
-    # travel before reaching 25% of parameter range.
-    t = (comp_value / 100.0) ** 2  # 0→0, 50→0.25, 70→0.49, 100→1.0
-
-    # --- Low band (< 200 Hz): Firmest control ---
-    # Attack scales down so higher values catch kick/bass transients
-    low_threshold = -16.0 + t * (-8.0)       # -16 → -24 dB
-    low_ratio     = 1.2  + t * 1.8           # 1.2:1 → 3.0:1
-    low_attack    = 80.0 + t * (-60.0)       # 80 → 20 ms (grabs transients at high comp)
-    low_release   = 200.0 + t * (-80.0)      # 200 → 120 ms
-
-    # --- Mid band (200 Hz – 4 kHz): Musical peak control ---
-    # Attack scales from transparent to transient-taming
-    mid_threshold = -14.0 + t * (-10.0)      # -14 → -24 dB
-    mid_ratio     = 1.1  + t * 1.4           # 1.1:1 → 2.5:1
-    mid_attack    = 30.0 + t * (-20.0)       # 30 → 10 ms (catches snare/vocal peaks)
-    mid_release   = 150.0 + t * (-50.0)      # 150 → 100 ms (avoids pumping)
-
-    # --- High band (> 4 kHz): Transient control ---
-    # Already fast, gets faster and more aggressive
-    high_threshold = -12.0 + t * (-10.0)     # -12 → -22 dB
-    high_ratio     = 1.05 + t * 0.95         # 1.05:1 → 2.0:1
-    high_attack    = 10.0 + t * (-7.0)       # 10 → 3 ms (catches cymbal/click transients)
-    high_release   = 80.0 + t * (-40.0)      # 80 → 40 ms
-
-    return {
-        "low":  (low_threshold, low_ratio, low_attack, low_release),
-        "mid":  (mid_threshold, mid_ratio, mid_attack, mid_release),
-        "high": (high_threshold, high_ratio, high_attack, high_release),
-    }
-
-
 # ---------------------------------------------------------------------------
 # Audio I/O
 # ---------------------------------------------------------------------------
@@ -124,15 +67,17 @@ def save_audio(audio, sample_rate):
 # ---------------------------------------------------------------------------
 
 def master_audio(input_path, lows_db, mid_boost_db, highs_db, bass_boost_db,
-                 bass_freq_hz, comp_value, stereo_width, target_lufs):
+                 bass_freq_hz, comp_value, limiter_ceiling, stereo_width, target_lufs):
     """Run the full mastering chain.
 
     Signal flow:
-        1. Pre-gain drop to -18 LUFS (internal headroom)
-        2. HPF 15 Hz (12 dB/oct) + EQ (bass boost, lows shelf, highs shelf, mid peak)
-        3. Multiband compression (3-band: <200 Hz, 200-4k Hz, >4k Hz; no makeup gain)
-        4. Stereo width (frequency-selective M/S processing)
-        5. Target LUFS normalization
+        1. HPF 20 Hz + LPF 20 kHz (12 dB/oct each)
+        2. EQ (bass boost, lows shelf, highs shelf, mid peak)
+        3. Stereo width (M/S processing — before dynamics)
+        4. Compression + makeup gain
+        5. LUFS normalization (single gain adjustment)
+        6. Auto-reduce if limiter would work > 4 dB
+        7. Final limiter (single pass)
 
     Returns:
         (output_path, original_audio, mastered_audio, sample_rate, stats)
@@ -144,27 +89,14 @@ def master_audio(input_path, lows_db, mid_boost_db, highs_db, bass_boost_db,
     orig_lufs = measure_loudness(original, sample_rate)
     orig_peak = measure_true_peak(original, sample_rate)
 
-    # --- Stage 1: Pre-gain drop — create internal headroom ---
-    # Normalize hot inputs (e.g. Suno at -9 LUFS) down to -18 LUFS
-    # so EQ boosts don't clip the working audio.
-    internal_target = -18.0
-    if not np.isinf(orig_lufs):
-        processed = normalize_to_lufs(
-            audio, sample_rate, orig_lufs, internal_target
-        ).astype(np.float32)
-    else:
-        processed = audio.copy()
-
-    # --- Stage 2: Filtering & EQ ---
+    # --- Stage 1: Filtering & EQ ---
     eq_effects = []
 
-    # Single HPF at 15 Hz (12 dB/oct) — subsonic cleanup
-    # -3 dB at 15 Hz, negligible loss above 35 Hz
-    eq_effects.append(HighpassFilter(cutoff_frequency_hz=15.0))
+    # Single HPF at 20 Hz (12 dB/oct)
+    eq_effects.append(HighpassFilter(cutoff_frequency_hz=20.0))
 
-    # LPF removed — source audio is already band-limited by sample rate
-    # (Nyquist), and the 20 kHz LPF was fighting the 10 kHz high shelf
-    # in the air zone (10-20 kHz), muddying HF shaping.
+    # Single LPF at 20 kHz (12 dB/oct)
+    eq_effects.append(LowpassFilter(cutoff_frequency_hz=20000.0))
 
     # Bass boost (user controls gain and frequency)
     if bass_boost_db > 0:
@@ -179,10 +111,10 @@ def master_audio(input_path, lows_db, mid_boost_db, highs_db, bass_boost_db,
         eq_effects.append(LowShelfFilter(
             cutoff_frequency_hz=200.0, gain_db=float(lows_db), q=1.0))
 
-    # Highs shelf (10 kHz — targets "air" zone, avoids 6-10 kHz harshness)
+    # Highs shelf
     if highs_db != 0:
         eq_effects.append(HighShelfFilter(
-            cutoff_frequency_hz=10000.0, gain_db=float(highs_db), q=0.7))
+            cutoff_frequency_hz=6000.0, gain_db=float(highs_db), q=0.7))
 
     # Mid boost/cut (Q=1.0 for wider, more musical presence)
     if mid_boost_db != 0:
@@ -193,295 +125,68 @@ def master_audio(input_path, lows_db, mid_boost_db, highs_db, bass_boost_db,
         ))
 
     eq_board = Pedalboard(eq_effects)
-    processed = eq_board(processed.T, sample_rate).T
-
-    # --- Stage 3: Multiband Compression (NO makeup gain — LUFS normalize handles it) ---
-    # Compression before stereo width so the compressor sees the EQ'd signal
-    # without M/S side-channel energy affecting per-band behaviour.
-    # 3-band split: Low (< 200 Hz), Mid (200 Hz – 4 kHz), High (> 4 kHz)
-    # Per-band parameter curves tuned to industry mastering best practices.
-    # TRUE BYPASS when slider = 0.
-    if comp_value > 0:
-        band_params = map_multiband_compression(comp_value)
-
-        # Split into 3 bands using two LR4 crossovers
-        low_band, upper = linkwitz_riley_crossover(
-            processed, sample_rate, _MB_CROSS_LOW,
-        )
-        mid_band, high_band = linkwitz_riley_crossover(
-            upper, sample_rate, _MB_CROSS_HIGH,
-        )
-
-        # Compress each band independently
-        compressed_bands = []
-        for band_audio, band_key in [
-            (low_band, "low"), (mid_band, "mid"), (high_band, "high"),
-        ]:
-            threshold, ratio, attack, release = band_params[band_key]
-            comp_board = Pedalboard([Compressor(
-                threshold_db=threshold,
-                ratio=ratio,
-                attack_ms=attack,
-                release_ms=release,
-            )])
-            compressed_bands.append(
-                comp_board(band_audio.T, sample_rate).T
-            )
-
-        # Recombine (perfect reconstruction from LR4 subtraction method)
-        processed = compressed_bands[0] + compressed_bands[1] + compressed_bands[2]
-
-    # --- Stage 4: Stereo width (after dynamics — imaging on settled signal) ---
-    processed = apply_stereo_width(processed, stereo_width, sample_rate)
-
-    # --- Stage 5: Target LUFS push ---
-    pre_norm_lufs = measure_loudness(processed, sample_rate)
-    if not np.isinf(pre_norm_lufs):
-        processed = normalize_to_lufs(
-            processed, sample_rate, pre_norm_lufs, target_lufs
-        ).astype(np.float32)
-
-    # --- Stage 6: Soft clipper (piecewise tanh saturation) ---
-    # Perfectly linear below the knee; only the tips of peaks above it are
-    # shaped with a tanh curve that asymptotes to the ceiling.  The knee
-    # sits 2 dB below the ceiling so only the loudest transient tips are
-    # affected — the vast majority of the signal passes through untouched.
-    ceiling_lin = 10.0 ** (-0.1 / 20.0)    # -0.1 dBTP in linear ≈ 0.9885
-    peak_lin = np.max(np.abs(processed))
-    if peak_lin > ceiling_lin:
-        knee_lin = ceiling_lin * 10.0 ** (-2.0 / 20.0)  # 2 dB below ceiling
-        headroom = ceiling_lin - knee_lin
-        abs_p = np.abs(processed)
-        above = abs_p > knee_lin
-        if np.any(above):
-            excess = abs_p[above] - knee_lin
-            clipped = knee_lin + headroom * np.tanh(excess / headroom)
-            processed[above] = (np.sign(processed[above]) * clipped).astype(np.float32)
-
-    # --- Stage 7: True peak ceiling (-0.1 dBTP) — safety net ---
-    # The soft clipper handles 99% of cases; this catches any residual
-    # inter-sample peaks that tanh didn't fully tame.
-    ceiling_dbtp = -0.1
-    tp = measure_true_peak(processed, sample_rate)
-    if tp > ceiling_dbtp:
-        overshoot_db = tp - ceiling_dbtp
-        processed = (processed * 10.0 ** (-overshoot_db / 20.0)).astype(np.float32)
-
-    # --- Final measurements ---
-    mast_lufs = measure_loudness(processed, sample_rate)
-    mast_peak = measure_true_peak(processed, sample_rate)
-
-    is_mono = original.ndim == 1 or original.shape[1] == 1
-
-    # Build actual DSP params used
-    dsp_params = {
-        "hpf_freq": 15.0,
-        "eq": [],
-        "stereo_width": stereo_width,
-    }
-    if bass_boost_db > 0:
-        dsp_params["eq"].append({"type": "peak", "freq": float(bass_freq_hz),
-                                  "gain_db": float(bass_boost_db), "q": 2.0})
-    if lows_db != 0:
-        dsp_params["eq"].append({"type": "low_shelf", "freq": 200.0,
-                                  "gain_db": float(lows_db), "q": 1.0})
-    if highs_db != 0:
-        dsp_params["eq"].append({"type": "high_shelf", "freq": 10000.0,
-                                  "gain_db": float(highs_db), "q": 0.7})
-    if mid_boost_db != 0:
-        dsp_params["eq"].append({"type": "peak", "freq": 1200.0,
-                                  "gain_db": float(mid_boost_db), "q": 1.0})
-    if comp_value > 0:
-        bp = map_multiband_compression(comp_value)
-        dsp_params["compression"] = {}
-        for bk in ("low", "mid", "high"):
-            t, r, a, rel = bp[bk]
-            dsp_params["compression"][bk] = {
-                "threshold": t, "ratio": r, "attack_ms": a, "release_ms": rel,
-            }
-        dsp_params["crossover_low"] = _MB_CROSS_LOW
-        dsp_params["crossover_high"] = _MB_CROSS_HIGH
-
-    stats = {
-        "orig_lufs": orig_lufs,
-        "orig_peak": orig_peak,
-        "mast_lufs": mast_lufs,
-        "mast_peak": mast_peak,
-        "mono": is_mono,
-        "dsp": dsp_params,
-    }
-
-    output_path = save_audio(processed, sample_rate)
-    return output_path, original, processed, sample_rate, stats
-
-
-# ---------------------------------------------------------------------------
-# Full-parameter mastering pipeline (Super AI mode)
-# ---------------------------------------------------------------------------
-
-def master_audio_full(input_path, params, target_lufs):
-    """Run the full mastering chain with granular per-band control.
-
-    Unlike master_audio() which maps a single compression slider (0-100) to
-    per-band parameters, this function accepts ALL parameters directly —
-    including per-band EQ frequencies, Q values, and per-band compression
-    settings.  This enables the AI to fine-tune every knob.
-
-    Args:
-        input_path: path to audio file.
-        params: dict with keys:
-            hpf_freq: float — high-pass filter cutoff in Hz (default 15)
-            eq: dict with band1..band6, each:
-                type: "peak" | "low_shelf" | "high_shelf"
-                freq: float Hz
-                gain_db: float dB
-                q: float Q factor
-            compression: dict with "low", "mid", "high", each:
-                threshold: float dB
-                ratio: float
-                attack_ms: float ms
-                release_ms: float ms
-            crossover_low: float Hz (default 200)
-            crossover_high: float Hz (default 4000)
-            stereo_width: int 80-150
-        target_lufs: float
-
-    Returns:
-        (output_path, original_audio, mastered_audio, sample_rate, stats)
-    """
-    audio, sample_rate = load_audio(input_path)
-    original = audio.copy()
-
-    # --- Measure original loudness ---
-    orig_lufs = measure_loudness(original, sample_rate)
-    orig_peak = measure_true_peak(original, sample_rate)
-
-    # --- Stage 1: Pre-gain drop — create internal headroom ---
-    internal_target = -18.0
-    if not np.isinf(orig_lufs):
-        processed = normalize_to_lufs(
-            audio, sample_rate, orig_lufs, internal_target
-        ).astype(np.float32)
+    processed = eq_board(audio.T, sample_rate).T
+
+    # --- Stage 2: Stereo width (before dynamics to catch peak changes) ---
+    processed = apply_stereo_width(processed, stereo_width)
+
+    # --- Stage 3: Compression + Makeup Gain ---
+    threshold, ratio, attack, release = map_compression(comp_value)
+
+    comp_effects = []
+    comp_effects.append(Compressor(
+        threshold_db=threshold,
+        ratio=ratio,
+        attack_ms=attack,
+        release_ms=release,
+    ))
+
+    # Makeup gain (estimated from compression amount)
+    if ratio > 1.0:
+        makeup_db = abs(threshold) * (1.0 - 1.0 / ratio) * 0.4
+        makeup_db = min(makeup_db, 12.0)
     else:
-        processed = audio.copy()
-
-    # --- Stage 2: Filtering & EQ (full parametric) ---
-    eq_effects = []
-
-    # HPF (AI-controllable frequency)
-    hpf_freq = float(params.get("hpf_freq", 15.0))
-    hpf_freq = max(10.0, min(80.0, hpf_freq))  # safety clamp
-    eq_effects.append(HighpassFilter(cutoff_frequency_hz=hpf_freq))
-
-    # 6-band parametric EQ — each band fully configurable
-    eq_config = params.get("eq", {})
-    for band_key in ("band1", "band2", "band3", "band4", "band5", "band6"):
-        band = eq_config.get(band_key, {})
-        gain = float(band.get("gain_db", 0))
-        if abs(gain) < 0.01:
-            continue  # skip bands with no gain
-        freq = float(band.get("freq", 1000))
-        q = float(band.get("q", 1.0))
-        btype = band.get("type", "peak")
-
-        # Safety clamps
-        freq = max(20.0, min(20000.0, freq))
-        q = max(0.1, min(10.0, q))
-        gain = max(-12.0, min(12.0, gain))
-
-        if btype == "low_shelf":
-            eq_effects.append(LowShelfFilter(
-                cutoff_frequency_hz=freq, gain_db=gain, q=q))
-        elif btype == "high_shelf":
-            eq_effects.append(HighShelfFilter(
-                cutoff_frequency_hz=freq, gain_db=gain, q=q))
-        else:  # "peak"
-            eq_effects.append(PeakFilter(
-                cutoff_frequency_hz=freq, gain_db=gain, q=q))
-
-    eq_board = Pedalboard(eq_effects)
-    processed = eq_board(processed.T, sample_rate).T
-
-    # --- Stage 3: Multiband Compression (direct per-band params) ---
-    comp_config = params.get("compression", {})
-    has_comp = any(
-        comp_config.get(k, {}).get("ratio", 1.0) > 1.0
-        for k in ("low", "mid", "high")
-    )
-
-    if has_comp:
-        xo_low = float(params.get("crossover_low", 200.0))
-        xo_high = float(params.get("crossover_high", 4000.0))
-
-        # Split into 3 bands
-        low_band, upper = linkwitz_riley_crossover(
-            processed, sample_rate, xo_low,
-        )
-        mid_band, high_band = linkwitz_riley_crossover(
-            upper, sample_rate, xo_high,
-        )
-
-        compressed_bands = []
-        for band_audio, band_key in [
-            (low_band, "low"), (mid_band, "mid"), (high_band, "high"),
-        ]:
-            bp = comp_config.get(band_key, {})
-            threshold = float(bp.get("threshold", -14.0))
-            ratio = float(bp.get("ratio", 1.0))
-            attack = float(bp.get("attack_ms", 30.0))
-            release = float(bp.get("release_ms", 150.0))
-
-            # Safety clamps
-            threshold = max(-40.0, min(0.0, threshold))
-            ratio = max(1.0, min(20.0, ratio))
-            attack = max(0.1, min(200.0, attack))
-            release = max(10.0, min(500.0, release))
-
-            if ratio > 1.0:
-                comp_board = Pedalboard([Compressor(
-                    threshold_db=threshold,
-                    ratio=ratio,
-                    attack_ms=attack,
-                    release_ms=release,
-                )])
-                compressed_bands.append(
-                    comp_board(band_audio.T, sample_rate).T
-                )
-            else:
-                compressed_bands.append(band_audio)
-
-        processed = compressed_bands[0] + compressed_bands[1] + compressed_bands[2]
-
-    # --- Stage 4: Stereo width ---
-    stereo_width = int(params.get("stereo_width", 100))
-    processed = apply_stereo_width(processed, stereo_width, sample_rate)
-
-    # --- Stage 5: Target LUFS push ---
+        makeup_db = 0.0
+    comp_effects.append(Gain(gain_db=makeup_db))
+
+    comp_board = Pedalboard(comp_effects)
+    processed = comp_board(processed.T, sample_rate).T
+
+    # --- Stage 4: Auto-reduce gain to keep limiter under 4 dB reduction ---
+    pre_limiter_peak = measure_true_peak(processed, sample_rate)
+    would_reduce = max(pre_limiter_peak - limiter_ceiling, 0.0)
+    auto_gain_reduction = 0.0
+    max_limiter_reduction = 4.0
+
+    if would_reduce > max_limiter_reduction:
+        auto_gain_reduction = would_reduce - max_limiter_reduction
+        reduction_board = Pedalboard([Gain(gain_db=-auto_gain_reduction)])
+        processed = reduction_board(processed.T, sample_rate).T
+
+    # --- Stage 5: Limiter ---
+    # Measure actual peak going into limiter (after auto-reduce)
+    limiter_input_peak = measure_true_peak(processed, sample_rate)
+    limiter_gain_reduction = max(limiter_input_peak - limiter_ceiling, 0.0)
+
+    limiter_board = Pedalboard([
+        Limiter(threshold_db=limiter_ceiling, release_ms=100.0)
+    ])
+    processed = limiter_board(processed.T, sample_rate).T
+
+    # --- Stage 6: Strict LUFS normalization (post-processing) ---
     pre_norm_lufs = measure_loudness(processed, sample_rate)
     if not np.isinf(pre_norm_lufs):
         processed = normalize_to_lufs(
             processed, sample_rate, pre_norm_lufs, target_lufs
         ).astype(np.float32)
 
-    # --- Stage 6: Soft clipper (piecewise tanh saturation) ---
-    ceiling_lin = 10.0 ** (-0.1 / 20.0)
-    peak_lin = np.max(np.abs(processed))
-    if peak_lin > ceiling_lin:
-        knee_lin = ceiling_lin * 10.0 ** (-2.0 / 20.0)
-        headroom = ceiling_lin - knee_lin
-        abs_p = np.abs(processed)
-        above = abs_p > knee_lin
-        if np.any(above):
-            excess = abs_p[above] - knee_lin
-            clipped = knee_lin + headroom * np.tanh(excess / headroom)
-            processed[above] = (np.sign(processed[above]) * clipped).astype(np.float32)
-
-    # --- Stage 7: True peak ceiling (-0.1 dBTP) — safety net ---
-    ceiling_dbtp = -0.1
-    tp = measure_true_peak(processed, sample_rate)
-    if tp > ceiling_dbtp:
-        overshoot_db = tp - ceiling_dbtp
-        processed = (processed * 10.0 ** (-overshoot_db / 20.0)).astype(np.float32)
+    # --- Stage 7: Safety catch — limiter for stray true peaks ---
+    post_norm_peak = measure_true_peak(processed, sample_rate)
+    if post_norm_peak > limiter_ceiling:
+        safety_limiter = Pedalboard([
+            Limiter(threshold_db=limiter_ceiling, release_ms=100.0)
+        ])
+        processed = safety_limiter(processed.T, sample_rate).T
 
     # --- Final measurements ---
     mast_lufs = measure_loudness(processed, sample_rate)
@@ -489,13 +194,20 @@ def master_audio_full(input_path, params, target_lufs):
 
     is_mono = original.ndim == 1 or original.shape[1] == 1
 
+    # Warning if auto gain reduction exceeded 2 dB
+    warning = ""
+    if auto_gain_reduction > 2.0:
+        warning = "Consider reducing EQ and Bass Boost settings and try again"
+
     stats = {
         "orig_lufs": orig_lufs,
         "orig_peak": orig_peak,
         "mast_lufs": mast_lufs,
         "mast_peak": mast_peak,
         "mono": is_mono,
-        "dsp": params,
+        "auto_gain_reduction": auto_gain_reduction,
+        "limiter_gain_reduction": limiter_gain_reduction,
+        "warning": warning,
     }
 
     output_path = save_audio(processed, sample_rate)

launch.bat

@@ -1,21 +0,0 @@
-@echo off
-title StudioAI Audio Mastering Suite - Local
-echo Starting StudioAI Audio Mastering Suite...
-echo.
-
-set GOOGLE_API_KEY=AIzaSyCgdP4-cAnLwbNikVz04u-al4px4LzTGFM
-set AI_ACCESS_KEY=StudioAI#!mastering41
-set "AI_ACCESS_KEY_2=OFiOIFJdoheio&474Fieu"
-set UNKEY_API_ID=api_pNZfzVKBwVEx
-set UNKEY_ROOT_KEY=unkey_3ZFmunwPRAvA5hrobow6UKGa
-
-cd /d "%~dp0"
-
-:loop
-echo.
-echo [%date% %time%] Launching...
-python app.py
-echo.
-echo [%date% %time%] Process exited. Restarting in 3 seconds...
-timeout /t 3 /nobreak >nul
-goto loop

presets.py

@@ -4,142 +4,52 @@ PRESETS = {
     "-- None --": None,
 
     "Modern Pop (Bright & Wide)": {
-        "lows_db": 0.0,
+        "lows_db": 0.5,
         "mid_boost_db": 1.0,
-        "highs_db": 1.5,
+        "highs_db": 2.0,
         "bass_boost_db": 1.0,
         "bass_freq_hz": 60,
-        "compression": 80,        # Ratio ~2.2:1, Rel 130ms (Snappy, cohesive glue)
+        "compression": 60,
         "stereo_width": 115,
     },
 
     "Vintage Analog (Warm & Intimate)": {
-        "lows_db": 1.0,
+        "lows_db": 2.0,
         "mid_boost_db": 0.0,
         "highs_db": -1.5,
-        "bass_boost_db": 1.0,
-        "bass_freq_hz": 80,       # 80Hz = warmth/body (not 50Hz sub-rumble)
-        "compression": 50,        # Ratio 1.8:1, Rel 175ms (Smooth, optical feel)
+        "bass_boost_db": 1.5,
+        "bass_freq_hz": 50,
+        "compression": 40,
         "stereo_width": 95,
     },
 
     "Heavy Trap / EDM (Aggressive Bass)": {
-        "lows_db": 0.0,
+        "lows_db": 1.0,
         "mid_boost_db": -0.5,
         "highs_db": 1.0,
-        "bass_boost_db": 2.0,
-        "bass_freq_hz": 50,
-        "compression": 100,       # Ratio 2.5:1, Rel 100ms (Max safe bounce)
+        "bass_boost_db": 3.0,
+        "bass_freq_hz": 55,
+        "compression": 85,
         "stereo_width": 125,
     },
 
     "Hard Rock / Metal (Punch & Bite)": {
         "lows_db": -0.5,
-        "mid_boost_db": 1.0,
-        "highs_db": 0.5,          # Reduced — 6-10kHz is the harshness/fizz zone for high-gain guitars
+        "mid_boost_db": 1.5,
+        "highs_db": 1.0,
         "bass_boost_db": 1.5,
-        "bass_freq_hz": 60,       # 60Hz = kick thump sweet spot
-        "compression": 90,        # Ratio ~2.3:1, Rel 115ms (Tight transient recovery)
+        "bass_freq_hz": 60,
+        "compression": 70,
         "stereo_width": 110,
     },
 
-    "Acoustic & Vocal (Clear & Present)": {
+    "Acoustic & Vocal (Transparent)": {
         "lows_db": -0.5,
-        "mid_boost_db": 1.0,      # Reduced from 1.5 — less coloration, more transparent
+        "mid_boost_db": 1.5,
         "highs_db": 1.0,
         "bass_boost_db": 0.0,
         "bass_freq_hz": 55,
-        "compression": 30,        # Ratio 1.5:1, Rel 205ms (Invisible leveling)
-        "stereo_width": 100,
-    },
-
-    "Deep Ambient (Immersive & Sustained)": {
-        "lows_db": -1.0,          # Cut the mud to let the sub-bass breathe
-        "mid_boost_db": 0.0,      # Flat mids to keep the soundscape distant
-        "highs_db": 1.5,          # Boost the 'Air' for shimmering reverb tails
-        "bass_boost_db": 1.0,     # Gentle lift to the existing heavy pad
-        "bass_freq_hz": 50,       # Focus the weight low (Dread Zone/Gravity)
-        "compression": 20,        # Low ratio, slow release. Invisible leveling, no pumping.
-        "stereo_width": 125,      # Extra wide to wrap the sound around the listener
-    },
-
-    "Hip-Hop / Boom Bap (Punch & Grit)": {
-        "lows_db": -0.5,          # Cut low-mids for clarity — boom bap dips around 150Hz
-        "mid_boost_db": 1.0,      # Bring the rapper's vocal right to the front
-        "highs_db": -0.5,         # Rolled-off highs for signature lo-fi/vinyl grit
-        "bass_boost_db": 1.5,     # Add weight...
-        "bass_freq_hz": 60,       # ...but at 60Hz to emphasize the 'thump' of the kick, not the sub-rumble
-        "compression": 75,        # Snappy compression to make the drums knock
-        "stereo_width": 100,      # Keep the beat dead center for maximum impact
-    },
-
-    "Cinematic / Orchestral (Dynamic & Wide)": {
-        "lows_db": 0.5,           # Gentle weight for cellos/basses (0.5 dB — orchestral moves are subtle)
-        "mid_boost_db": -0.5,     # Scoop slightly to push the orchestra "back" into the room
-        "highs_db": 0.5,          # Subtle air for the strings and brass
-        "bass_boost_db": 0.0,     # Let the natural low-end breathe without artificial boosting
-        "bass_freq_hz": 50,
-        "compression": 0,         # ZERO compression. Preserve all natural dynamic swells and drops.
-        "stereo_width": 110,      # Subtle widening — research warns against aggressive wideners on orchestral
-    },
-    
-   "Indie / Alt-Rock (Organic & Glued)": {
-        "lows_db": 0.5,           # Gentle body for the bass guitar
-        "mid_boost_db": 0.5,      # Subtle push for guitars and vocal presence
-        "highs_db": 0.5,          # Just a kiss of air for the cymbals
-        "bass_boost_db": 0.5,     # A very light touch on the kick fundamental
-        "bass_freq_hz": 60,
-        "compression": 45,        # Moderate glue. Holds the band together without crushing dynamics.
-        "stereo_width": 105,      # Keeps the band feeling "in the room"
-    },
-
-    "R&B / Soul (Silky & Smooth)": {
-        "lows_db": 0.5,           # Warm low-mid body without mud
-        "mid_boost_db": 1.0,      # Smooth, intimate vocal presence
-        "highs_db": 0.5,          # Silky top end, not overly bright or harsh
-        "bass_boost_db": 1.0,     # Round, deep, controlled bass
-        "bass_freq_hz": 60,
-        "compression": 55,        # Medium glue, smooth recovery for vocals
-        "stereo_width": 105,      # Natural, immersive width
-    },
-
-    "Lo-Fi / Chillhop (Dusty & Narrow)": {
-        "lows_db": 1.5,           # Thick, warm midrange for sample texture
-        "mid_boost_db": 0.0,
-        "highs_db": -2.5,         # Aggressively rolled off for tape/vinyl aesthetic
-        "bass_boost_db": 1.0,     # Warm, blunt kick thud
-        "bass_freq_hz": 60,
-        "compression": 35,        # Gentle, optical-style leveling
-        "stereo_width": 90,       # Narrow width emulating vintage samplers
-    },
-
-    "Jazz (Live & Dynamic)": {
-        "lows_db": -0.5,          # Keep mud away from upright bass/piano overlap
-        "mid_boost_db": 1.0,      # Bring horns and brushwork forward into the room
-        "highs_db": 0.5,          # Natural acoustic air
-        "bass_boost_db": 0.0,     # Zero artificial sub-bass; rely on the recording
-        "bass_freq_hz": 60,
-        "compression": 10,        # Almost zero compression; absolute dynamic preservation
-        "stereo_width": 100,      # True to the physical room
-    },
-
-    "Reggae / Dub (Heavy Sound System)": {
-        "lows_db": 1.0,           # Thick low-mids for the rhythm section
-        "mid_boost_db": -1.0,     # Scooped mids to make room for massive bass and tape delays
-        "highs_db": 0.5,          # Slice through for hi-hats and echoes
-        "bass_boost_db": 2.5,     # Massive sound-system weight
-        "bass_freq_hz": 80,       # Targeted directly at the classic reggae bassline fundamental
-        "compression": 85,        # Heavy pumping to lock in the off-beat groove
-        "stereo_width": 115,      # Wide space for panning delays
-    },
-
-    "Synthwave / Retrowave (Analog & Driving)": {
-        "lows_db": 1.0,           # Thick low-mids for analog synth body
-        "mid_boost_db": -0.5,     # Slight scoop to carve out room for the kick and snare
-        "highs_db": 1.5,          # Crisp, shimmering highs for 80s synth leads and hi-hats
-        "bass_boost_db": 1.5,     # Driving, relentless synth-bass weight
-        "bass_freq_hz": 60,       # Targeted at the punch of the Linndrum/707 kick
-        "compression": 75,        # Heavy, driving glue to keep the grid tight and relentless
-        "stereo_width": 120,      # Wide and cinematic, like a neon highway
+        "compression": 15,
+        "stereo_width": 105,
     },
-}
+}

stereo.py

@@ -1,44 +1,14 @@
-"""Mid/Side stereo width processing with frequency-selective crossover."""
+"""Mid/Side stereo width processing."""
 
 import numpy as np
-from scipy.signal import butter, sosfiltfilt
 
 
-# Crossover frequency: bass below this stays mono, width applies above
-_CROSSOVER_HZ = 200.0
-
-
-def linkwitz_riley_crossover(audio, sample_rate, crossover_hz):
-    """Split audio into low and high bands using a Linkwitz-Riley 4th-order
-    crossover (two cascaded 2nd-order Butterworth filters).
-
-    Returns (low_band, high_band) each with the same shape as audio.
-    """
-    nyquist = sample_rate / 2.0
-    # Clamp to valid range for the filter
-    freq = min(crossover_hz, nyquist * 0.95)
-
-    sos = butter(2, freq, btype='low', fs=sample_rate, output='sos')
-
-    # Linkwitz-Riley = two passes of Butterworth (sosfiltfilt = forward+backward
-    # = zero-phase, effectively 4th-order LR behaviour)
-    low = sosfiltfilt(sos, audio, axis=0).astype(np.float32)
-    high = (audio - low).astype(np.float32)
-
-    return low, high
-
-
-def apply_stereo_width(audio, width_percent, sample_rate=44100):
-    """Apply stereo width adjustment using frequency-selective M/S encoding.
-
-    Bass below 200 Hz stays mono-preserving (no width change) to keep
-    the low end tight and phase-coherent on club/mono systems.
-    Width adjustment applies only to frequencies above the crossover.
+def apply_stereo_width(audio, width_percent):
+    """Apply stereo width adjustment using M/S encoding.
 
     Args:
         audio: numpy array of shape (samples, 2), float32.
         width_percent: 80 to 150. 100 = no change.
-        sample_rate: int, sample rate for crossover filter.
 
     Returns:
         numpy array of shape (samples, 2), float32.
@@ -48,19 +18,12 @@ def apply_stereo_width(audio, width_percent, sample_rate=44100):
 
     width_factor = width_percent / 100.0
 
-    # If width is unity, skip all processing
-    if width_factor == 1.0:
-        return audio
+    left = audio[:, 0]
+    right = audio[:, 1]
 
-    # Split into low (< 200 Hz) and high (>= 200 Hz) bands
-    low, high = linkwitz_riley_crossover(audio, sample_rate, _CROSSOVER_HZ)
-
-    # Apply M/S width to HIGH band only
-    left_h = high[:, 0]
-    right_h = high[:, 1]
-
-    mid = (left_h + right_h) / 2.0
-    side = (left_h - right_h) / 2.0
+    # Encode to M/S
+    mid = (left + right) / 2.0
+    side = (left - right) / 2.0
 
     # Energy-preserving scaling
     mid_scale = np.sqrt(2.0 / (1.0 + width_factor ** 2))
@@ -69,13 +32,11 @@ def apply_stereo_width(audio, width_percent, sample_rate=44100):
     mid_out = mid * mid_scale
     side_out = side * side_scale
 
+    # Decode back to L/R
     left_out = mid_out + side_out
     right_out = mid_out - side_out
 
-    high_widened = np.column_stack([left_out, right_out])
-
-    # Recombine: untouched low band + widened high band
-    result = low + high_widened
+    result = np.column_stack([left_out, right_out])
 
     # Prevent clipping from width expansion
     peak = np.max(np.abs(result))

visualization.py

@@ -54,17 +54,11 @@ def plot_waveform_comparison(original, mastered, sample_rate):
 
 
 def plot_spectrum_comparison(original, mastered, sample_rate):
-    """Create a frequency spectrum comparison with shape-normalized overlay
-    and a difference trace showing the processing's spectral impact.
-
-    The mastered spectrum is level-aligned to the original so the plot
-    compares spectral *shape*, not overall loudness (LUFS stats handle that).
+    """Create an overlaid frequency spectrum comparison.
 
     Returns a matplotlib Figure.
     """
-    fig, (ax_spec, ax_diff) = plt.subplots(
-        2, 1, figsize=(8, 5), height_ratios=[3, 1], sharex=True,
-    )
+    fig, ax = plt.subplots(1, 1, figsize=(8, 3))
 
     orig_mono = _to_mono(original)
     mast_mono = _to_mono(mastered)
@@ -88,38 +82,15 @@ def plot_spectrum_comparison(original, mastered, sample_rate):
     freqs_o, spec_o = avg_spectrum(orig_mono, n_fft, sample_rate)
     freqs_m, spec_m = avg_spectrum(mast_mono, n_fft, sample_rate)
 
-    # --- Level-align mastered to original (remove overall loudness diff) ---
-    # Use only the passband (100 Hz – 10 kHz) for alignment so the HPF/LPF
-    # roll-offs at the extremes don't skew the offset.
-    passband = (freqs_o >= 100) & (freqs_o <= 10000)
-    level_offset = np.mean(spec_o[passband]) - np.mean(spec_m[passband])
-    spec_m_aligned = spec_m + level_offset
-
-    # --- Top: overlaid spectra (shape comparison) ---
-    ax_spec.plot(freqs_o, spec_o, color="#4a90d9", alpha=0.7, linewidth=1,
-                 label="Original")
-    ax_spec.plot(freqs_m, spec_m_aligned, color="#d94a4a", alpha=0.7,
-                 linewidth=1, label="Mastered (level-aligned)")
-    ax_spec.set_ylabel("Magnitude (dB)")
-    ax_spec.set_title("Spectral Shape Comparison")
-    ax_spec.legend(loc="upper right", fontsize=8)
-    ax_spec.grid(True, alpha=0.3)
-
-    # --- Bottom: difference (mastered − original) ---
-    diff = spec_m_aligned - spec_o
-    ax_diff.plot(freqs_o, diff, color="#2ca02c", linewidth=1)
-    ax_diff.axhline(0, color="gray", linewidth=0.5, linestyle="--")
-    ax_diff.set_ylabel("Δ dB")
-    ax_diff.set_xlabel("Frequency")
-    ax_diff.set_title("Processing Difference (Mastered − Original)", fontsize=9)
-    ax_diff.set_ylim(-6, 6)
-    ax_diff.grid(True, alpha=0.3)
-
-    # Shared x-axis settings
-    ax_diff.set_xscale("log")
-    ax_diff.set_xlim(20, sample_rate / 2)
-    ax_diff.set_xticks([10, 100, 1000, 10000])
-    ax_diff.set_xticklabels(["10 Hz", "100 Hz", "1 kHz", "10 kHz"])
+    ax.plot(freqs_o, spec_o, color="#4a90d9", alpha=0.7, linewidth=1, label="Original")
+    ax.plot(freqs_m, spec_m, color="#d94a4a", alpha=0.7, linewidth=1, label="Mastered")
+    ax.set_xscale("log")
+    ax.set_xlim(20, sample_rate / 2)
+    ax.set_xlabel("Frequency (Hz)")
+    ax.set_ylabel("Magnitude (dB)")
+    ax.set_title("Frequency Spectrum Comparison")
+    ax.legend()
+    ax.grid(True, alpha=0.3)
 
     plt.tight_layout()
     return fig