Euterpe → SOTA, Industry-Leading DAW — Complete Remaining-Work Specification

ARR-1 Arrangement timeline UI component — P0 · L · 🔴 missing#

• What & why: Build a React/SVG component (ArrangementView.tsx) rendering horizontal timeline with tracks as rows, time ruler in beats/seconds, clips as draggable rectangles, playhead scrubber, visual grid. This is the missing canvas for clip placement.
• SOTA reference: Ableton Live Arrangement View, Logic Pro Arrange window, Pro Tools Edit window, Bitwig Arranger, Cubase Project window
• Depends on: TimelineViewport (exists in shell-runtime), clip data model (add to DawSession)
• Implementation notes: Create /src/components/daw/arrangement-view.tsx with: SVG canvas for time-grid, track rows, horizontal clip drag-drop using pointer events (React 18), playhead sync from transport.playheadSamples. Use a virtual scroll (height ~60px per track, max 100 visible) for performance. Ruler can reuse logic from automation-lane.tsx. Store visible time window (startSec, endSec, zoom level) in a React state slice. Integration: replace or augment daw-app.tsx main view toggle (piano-roll vs arrangement).

ARR-2 Arrangement data model (clips per track, placement) — P0 · L · 🟡 partial#

• What & why: Extend DawSession to include ArrangementTrack[] with AudioClip[] arrays. Each AudioClip: id, startBeat, lengthBeats, audioTrackId (sampler ref), gain, pan, fadeIn, fadeOut, muted. Replace per-track single-sampler model with clip-list. This enables multi-clip timeline.
• SOTA reference: Ableton Clip, Logic Arrange region, Pro Tools Edit window clip model, Cubase Arrangement Track
• Depends on: daw-session.ts reducer, types.ts, daw-controller.ts command generation
• Implementation notes: Add to types.ts: export interface AudioClip { id: string; startBeat: number; lengthBeats: number; sampleStartFrac: number; sampleRate: number; gain: number; pan: number; fadeInBeats: number; fadeOutBeats: number; muted: boolean; parentSampleId: string; } Then extend TrackState to have audioClips?: AudioClip[] (for audio tracks). Update daw-session reducer: case 'addAudioClip' creates new clip at playhead, case 'moveAudioClip' adjusts startBeat. The engine's per-track Sampler must be extended (dsp-graph/src/track.rs) to support a clip queue/scheduler instead of single playback; or build a higher-level clip scheduler in the engine that manages multiple samples per track (see per-clip scheduling gap).

ARR-3 Per-clip audio scheduling engine — P0 · L · 🔴 missing#

• What & why: Extend dsp-graph Engine to dispatch multi-clip playback per audio track: at each block, compute which clips overlap the playhead, trigger clip sample loads/playback. Currently Track::Sampler plays one sample; need ClipScheduler (per track) holding clip queue + offset math.
• SOTA reference: Ableton Engine clip playback, Pro Tools clip engine, Logic Arrange clip scheduling
• Depends on: Arrangement data model, dsp-graph refactor (track.rs, engine.rs)
• Implementation notes: In Rust libs/euterpe/audio-engine/crates/dsp-graph/src/track.rs, wrap the existing Sampler in a new ClipScheduler struct: pub struct ClipScheduler { clips: Vec<(f32 startBeat, f32 lenBeats, Sampler)>, activeClipIdx: usize, ... }. Implement advance(playhead_beat) to: 1) find overlapping clip(s) at playhead, 2) load sampler if clip changed, 3) compute clip-local offset (playhead - clip.startBeat), 4) render sampler at that offset. For polyphonic clips (multiple overlapping), sum their outputs. Add command t='setArrangementClips' to Engine.rs taking Vec and building the scheduler. See dsp-graph/src/clip.rs for inspiration (NoteClip does state reconciliation; adapt for audio). Critical: fades (fadeIn/fadeOut) must be applied per-clip when rendering.

ARR-13 Grid snap modes (beat/note/transient/magnetic) — P1 · S · 🟡 partial#

• What & why: Add snap mode selector in arrangement view (grid, beat, 1/16 note, transient, magnetic, off). Constrain clip placement, playhead, automation point placement to selected grid.
• SOTA reference: Pro Tools snapping modes, Logic snap to grid, Ableton warp snap, Bitwig snap settings
• Depends on: Arrangement view, transient detection
• Implementation notes: Add to DawSession: snapMode: 'off' | 'beat' | 'note' | 'transient' | 'magnetic' | '8th' | '16th'. In arrangement view, add a snap-mode dropdown next to zoom controls. Helper function snapToGrid(beat, mode, transients?, bpm?) → snapped beat. Apply in clip drag handlers, playhead scrub, automation-point move. For 'magnetic', define snap radius (e.g., 0.1 beat) and snap to nearest if within radius. Quick win: snap mode already partially exists in piano-roll.tsx (quantize logic); extract to shared snap.ts utility.

ARR-19 Non-destructive clip editing: undo clip-level edits, arrange-undo history — P1 · S · 🟡 partial#

• What & why: Full undo/redo for arrangement edits (clip move, resize, fade, etc.), separate from pattern edits. Preserve clip history so user can revert individual clip edits without losing session edits.
• SOTA reference: Ableton undo (session-wide), Logic undo (all edits), Pro Tools undo (step-by-step)
• Depends on: Arrangement data model, daw-session reducer (existing undo/redo)
• Implementation notes: Existing: daw-session.ts has undo/redo via reducer history. Extend to cover all ArrangementClip actions (setAudioClipPlacement, setAudioClipFade, setAudioClipGain, etc.). Ensure each action is traced into history stack. Test undo after clip move + fade edit → verify both are reversed. No new architecture needed; just ensure UI actions dispatch proper daw-session actions (not imperative DOM edits).

ARR-4 Ripple / roll / slip / slide edit modes — P1 · M · 🔴 missing#

• What & why: Implement four clip-edit modes in arrangement view: ripple (move clip → downstream shift), roll (resize clip end → adjacent auto-adjust), slip (move content offset without shifting), slide (move clip + linked automation). Add mode toggle buttons and drag-behavior branching.
• SOTA reference: Pro Tools Smart Tool, Ableton clip drag modifiers, Logic arrange
• Depends on: Arrangement timeline UI, arrangement data model
• Implementation notes: In ArrangementView.tsx, add state for editMode: 'move' | 'ripple' | 'roll' | 'slip' | 'slide'. On pointer-down on a clip, read editMode. On pointer-move: ripple = clip.startBeat += delta, then shiftDownstream(); roll = clip.lengthBeats += delta (and if next clip overlaps, nudge it); slip = clip.sampleStartFrac += deltaBeats (content offset, no placement change); slide = move + adjustAutomation(). Each mode reduces to different daw-session actions (setAudioClipPlacement, setAudioClipSampleOffset, etc.). Can start with ripple/roll as MVP.

ARR-7 Take lanes / comping — P1 · M · 🔴 missing#

• What & why: Per-audio-track, support multiple parallel takes (loop-recorded clips in stacked lanes). Show as N narrow lane subrows under each track. Provide swipe-select UI to toggle active take, and 'comp' action to merge selected regions from each take into one composite.
• SOTA reference: Logic Comp Editor, Pro Tools comp mode, Ableton Scene clips, Bitwig Lanes
• Depends on: Arrangement data model (extend to support take lanes), arrangement UI
• Implementation notes: Extend AudioClip to optionally link to a TakeLane: export interface TakeLane { id: string; name: string; takes: AudioClip[]; activeTakeIdx: number; }. Audio tracks store takeLanes?: TakeLane[]. In arrangement view, when user enables 'comp mode' on a track, expand track height and show N lane subrows (one per take). Swipe-select a region → dispatch setActiveTake(laneId, takeIdx) to switch which clip is auditioned. Comp action creates a new composite AudioClip selecting best region from each take. Recording flow (daw-app.tsx): when arm-record on an audio track in comp mode, create a new take (increment activeTakeIdx, append empty clip). MVP: no automation per-take; just clip selection.

ARR-8 Crossfades (audio-range fades & auto-crossfade) — P1 · M · 🔴 missing#

• What & why: Add fadeIn/fadeOut UI handles on clip edges (draggable, visual fade curve). Render as linear envelope atop waveform in arrangement view. When two clips overlap, auto-apply symmetric crossfade (±fade half the overlap, X-curve). Audition before commit.
• SOTA reference: Ableton clip fades, Logic arrange crossfade, Pro Tools crossfade editor, Bitwig crossfade lanes
• Depends on: Per-clip audio scheduling (apply envelope), arrangement view (drag handles)
• Implementation notes: AudioClip already has fadeInBeats, fadeOutBeats fields. In ClipScheduler.advance(), apply linear gain envelope: at clip start, ramp from 0 to 1 over fadeInBeats; at clip end, ramp from 1 to 0 over fadeOutBeats (use beat-local position). UI: in arrangement view, draw small drag handles on clip left/right edges (fade-in/out handles). On drag, update clip.fadeInBeats / fadeOutBeats, dispatch setAudioClipFade action. Auto-crossfade: if two clips on same track overlap, dispatch auto-set action that computes fade = min(clip1.endBeat - overlap_start, overlap_end - clip2.startBeat) / 2. Curve type: start with linear; optionally add X-curve (sqrt blend) for smoother audio.

ARR-11 Freeze & bounce-in-place — P1 · M · 🟡 partial#

• What & why: Freeze: offline render a track's clip chain (synth+effects), store as audio clip on same track, mute original, free DSP. Bounce: export selected clip region (or track) to stem file. Both require offline render + sample encoding.
• SOTA reference: Ableton Freeze, Logic Bounce, Pro Tools Consolidate, Bitwig Bounce Selection
• Depends on: Offline render (Engine.render_offline exists), Audio clip scheduling
• Implementation notes: Existing: Engine.render_offline() in dsp-graph/src/engine.rs and masterBounce() in daw-app.tsx. Extend to per-track: dispatch freezeTrack(trackId) → render track in isolation (all tracks muted except target), encode as WAV, create new AudioClip with result, swap track.source from synth/generator to sampler+clip. UI: right-click track header → Freeze. For bounce: selectClipRegion → bounce action → offline render that region (tempo/arrangement respect), export WAV. Can reuse existing masterBounce codepath but scoped to one track/region. Must handle: automation during offline render (ClipScheduler + track automation must play), master sends (render with or without master chain).

ARR-16 Waveform thumbnail rendering per clip in arrangement — P1 · M · 🔴 missing#

• What & why: Display mini waveform preview within each clip rectangle in arrangement view for quick visual navigation (peaks, quiet zones, transients). Render from existing sample buffer or compute on-demand.
• SOTA reference: Ableton Arrangement clip waveforms, Logic arrange, Pro Tools clip waveforms
• Depends on: Arrangement view, per-clip audio scheduling
• Implementation notes: In daw-app, when audio clip is loaded into sampler, cache the decoded Float32Array buffer. In arrangement view, when rendering clip rectangle, call drawWaveformMinimized (beat-indexed, downsample to pixel width). Reuse logic from WaveformView.tsx (peak binning, canvas rendering). Performance: memoize waveform thumbnails per clip ID; recompute only if sample changes. For fast scrolling, compute thumbnail async + cache.

ARR-10 Arrangement view markers & region labels — P2 · S · 🔴 missing#

• What & why: Add visual timeline markers (user-placed cues) and region labels to break song into named sections (intro, verse, chorus, bridge, etc.). Store as beat-indexed markers with color, label. Render as colored flags/sections on timeline ruler area.
• SOTA reference: Logic Markers, Ableton Locators, Pro Tools Memory Locations, Reaper Markers & Regions
• Depends on: Arrangement data model, arrangement view
• Implementation notes: Add to DawSession: markers?: Array<{ beat: number; name: string; color: string; region?: boolean; endBeat?: number; }>. In arrangement view, draw colored flag icons at marker beats (or colored sections if region=true). On click → edit name/color. Reducer actions: addMarker, updateMarker, deleteMarker. Quick-start: reuse theme colors from TRACK_COLORS palette. This is a low-effort, high-UX win for song structure navigation.

ARR-15 Smart clip selection & selection grouping — P2 · S · 🔴 missing#

• What & why: Select multiple clips, move/resize as group, delete, mute/solo, apply gain/pan offset. Grouping modes: by track, by time range, by effect.
• SOTA reference: Ableton clip multi-select, Logic Select/Deselect All, Pro Tools clip grouping
• Depends on: Arrangement view
• Implementation notes: Add to DawSession: selectedClipIds?: Set. In arrangement view, Shift+click clip → add to selection, Ctrl+drag → select range, Ctrl+A → select all on track. Drag selected group → move all together. Shift+click → deselect. Right-click selection → context menu (mute, solo, gain offset, delete). daw-session reducer: batchUpdateClips action. Quick MVP: just drag-to-move selected group.

ARR-20 Arrangement view keyboard shortcuts & workflow — P2 · S · 🔴 missing#

• What & why: Standard shortcuts: D (duplicate clip), Delete (remove), B (create region), Alt+drag (slip), Cmd+K (split clip), Q (quantize), etc. Optimized for fast producers/engineers.
• SOTA reference: Pro Tools standard shortcuts, Ableton Live, Logic keyboard commands
• Depends on: Arrangement view, command parser
• Implementation notes: In arrangement view component, add onKeyDown handler mapping standard producer shortcuts to dispatch actions. Examples: D + selected clip → duplicateClip; Delete → deleteSelectedClips; Cmd+K → splitClipAtPlayhead; Alt+right-arrow → nudge selected clips right by 1 beat. Can reuse/extend command-parser.ts (existing deterministic parser for LLM fallback). Organize shortcuts in a ~/.claude/keybindings.json style config (or built-in preset: 'ableton', 'logic', 'protools').

ARR-6 Transient detection & markers — P2 · M · 🔴 missing#

• What & why: Detect transient peaks in audio clip waveform (spectral flux or onset energy), store as beat-indexed markers per clip. Display as thin vertical lines on waveform. Enable snap-to-transient grid mode and warp-handle snapping.
• SOTA reference: Logic Flex Marker, Pro Tools Beat Detective, Ableton Warp Markers (auto), iZotope RX transient detection
• Depends on: Per-clip audio scheduling, arrangement view
• Implementation notes: Add transient detection to daw-app (or new module daw/transient-detection.ts): use onset-flux autocorrelation (existing in audio-analysis.ts detectTempo) or a simpler RMS-delta heuristic. Store result in AudioClip.transientBeats: number[]. In arrangement view, draw thin red/orange lines at those beat positions on the waveform thumbnail. Add grid mode 'transient' to snap/grid selector, which constrains clip placement/warp to transient positions. UI can auto-detect on clip load or offer a 'detect transients' button. Library: reuse Krumhansl / spectral code from audio-analysis.ts.

ARR-12 Groove extraction & templates — P2 · M · 🟡 partial#

• What & why: Extract timing/velocity signature from audio clip (or transcribed MIDI) → create groove template. Apply to other MIDI patterns. Store groove library (downloadable/shareable). This unlocks quantize-to-groove and humanize-from-groove workflows.
• SOTA reference: Ableton Groove Library, Logic Flex Pitch groove mapping, Pro Tools Groove Clips, iZotope Groove Agent
• Depends on: Per-clip transient detection, pattern transforms (existing humanizeClip, quantizeClip)
• Implementation notes: Build daw/groove-extraction.ts: given an audio clip + detected transients + transcribed notes (onset times), extract timing offsets (beat - detected onset) and velocity deltas. Store as GrooveTemplate { name, timingOffsets: number[], velocityOffsets: number[] }. Apply to a pattern: dispatch applyGrooveTemplate(trackId, templateId) → transform pattern by shifting note start times and velocities per groove. Can also extract from existing humanized MIDI patterns (invert to get the offsets applied). UI: separate Groove Library panel (load/save/share grooves), click 'extract' on a clip to auto-build, apply button in step-grid/piano-roll context menu. Integration with transcribe: auto-extract groove when transcribing audio (daw/transcribe.ts).

ARR-14 Per-clip gain/pan/send envelopes (Clip Envelopes) — P2 · M · 🔴 missing#

• What & why: Each audio clip can have its own gain/pan/send automation independent of track fader. Store as nested AutomationPoint[] in AudioClip. Render as layer on clip in arrangement view (optional detail toggle).
• SOTA reference: Ableton Clip Modulation/Envelopes, Logic Arrange Automation, Pro Tools Clip Automation, Bitwig Clip Automation
• Depends on: Arrangement data model, per-clip scheduling, automation rendering
• Implementation notes: Extend AudioClip: gainAutomation?: AutomationPoint[]; panAutomation?: PanPoint[]; sendAutomation?: SendPoint[]. In ClipScheduler.advance(), after computing final sample, apply clip automation (similar to track-level automation in session-rebuild.ts). UI: in arrangement view, click clip → detail panel showing clip envelopes (use automation-lane.tsx editor, scoped to clip). Starting point: just gain envelope; pan/send add later. Critical: automation times are beat-local to the clip (0 = clip start, lengthBeats = clip end), not absolute session beats.

ARR-5 Non-destructive audio warping / elastic time — P2 · L · 🔴 missing#

• What & why: Add per-clip audio-warp model: store beat-indexed warp markers (beat → sample offset) in each AudioClip. Render sampler with piecewise linear time-warping: between markers, interpolate playback rate to match warp curve. This allows Ableton-style time-stretch without re-encoding.
• SOTA reference: Ableton Audio Warp, Logic Flex Time, Pro Tools Time Shift, iZotope RX time-stretch, Melodyne
• Depends on: Per-clip audio scheduling, arrangement data model
• Implementation notes: Extend AudioClip interface: warpMarkers?: Array<{ beat: number, sampleOffset: number }>. In ClipScheduler.advance(), after computing clip-local beat position, look up warp markers: if beat is between two markers, linearly interpolate the playback rate (sample offset / beat delta). Sampler already supports set_rate() per-block, so apply the interpolated rate before process(). UI: in arrangement view, clicking on clip waveform can place warp handles (visual caret markers). Use a separate WarpEditor panel similar to automation-lane.tsx showing beat vs sample offset graph. Algorithm: piecewise linear time-warping (simple, CPU-light, Ableton-like). For deeper warping, add transient detection (see transient markers gap) to snap to detected peaks.

ARR-9 Tempo map & time-signature track — P2 · L · 🟡 partial#

• What & why: Global tempo envelope (beat-indexed tempo changes, not per-track). Add a TimeSignatureTrack with visual time-sig markers and adapt grid rendering. Currently only static tempo_bpm exists in Engine.
• SOTA reference: Ableton Tempo track, Logic Tempo track, Pro Tools Tempo Editor, Cubase Tempo track
• Depends on: Engine refactor (dsp-graph), arrangement view grid logic
• Implementation notes: Extend DawSession to include tempoMap?: Array<{ beat: number, bpm: number }> and timeSigTrack?: Array<{ beat: number, numerator: number, denominator: number }>. In daw-session reducer, case 'setTempoMap' clamps beats in order and updates. In Engine (dsp-graph/src/engine.rs), at each process() block, interpolate tempo from tempoMap by playhead beat (linear between points). This changes samples_per_beat per-block, affecting clip scheduling math (ClipScheduler must recompute clip-beat positions when tempo changes). In arrangement view, draw tempo curve as an overlay line and time-sig markers. Grid rendering must adapt: compute beat-width in pixels per time-sig, re-render rulers. Start with linear tempo interpolation (simple, Ableton-like). Full implementation also adjusts master EQ/comp automation beat positions (relative beat math).

ARR-17 VST/AU plugin hosting (instrument & effect plugins) — P3 · XL · 🔴 missing#

• What & why: Load third-party VST3/CLAP/AU plugins into insert rack (FX) or as track instruments. Manage plugin parameters, MIDI routing, audio I/O. Requires native bridge (Tauri sidecar) + plugin host abstraction.
• SOTA reference: Pro Tools AAX hosting, Bitwig Plugin Modular Engine, Cubase VST/AU, Reaper ReaJS, Studio One
• Depends on: Native runtime (Tauri sidecar bridge), plugin host abstraction layer
• Implementation notes: Out of scope for MVP, but architecture required: 1) Tauri sidecar child process running plugin host (e.g., vst-host Rust crate or JUCE framework). 2) IPC bridge over shared memory (audio buffers) + JSON control (parameters). 3) UI: plugin window in a web frame (or offscreen render + texture streaming). 4) Parameter automation: expose plugin params as automatable faders in insert-rack.tsx. Start with VST3 support (most modern); AU requires macOS-specific code. Complexity: plugin format specs, parameter persistence, crash isolation, CPU metering. Recommend deferring to Wave 3 (post-SOTA) unless plugin ecosystem is critical.

ARR-18 Spectral editing (frequency-domain waveform editing) — P3 · XL · 🔴 missing#

• What & why: Display STFT spectrogram per audio clip (frequency vs time). Enable brush-erase regions (isolate vocals, remove noise), frequency isolation, pitch/formant correction. This is a deep feature (Melodyne, iZotope RX level).
• SOTA reference: iZotope RX spectral editing, Melodyne pitch editor, Logic Flex Pitch
• Depends on: STFT computation, spectral UI canvas, real-time resynthesis
• Implementation notes: Build daw/spectral-editor.ts: compute STFT on audio clip load (or on-demand), store as sparse matrix (only peaks above noise floor). In arrangement view, toggle spectrogram overlay on clip waveform (frequency-color intensity map, waterfall style). UI: brush tool to paint masks (frequency regions to suppress). On playback, apply soft-masked STFT inverse (requires overlap-add, phase reconstruction). This is heavy R&D; start with read-only spectrogram view (visualization only), defer editing to Wave 3+.

MIDI-3 Per-note articulation & expression maps — P1 · M · 🔴 missing#

• What & why: Euterpe lacks articulation mapping (e.g., 'staccato', 'legato', 'sfz', 'tremolo'). SOTA (Cubase Expression Maps, Studio One Sound Variations) binds articulation symbols to MIDI CC/RPN sequences for sampled instruments. Euterpe has only a PolySynth, no articulation awareness. Missing: visual articulation editor, per-note articulation assignment (piano roll lane), MIDI channel routing for articulation (if multi-channel instrument), articulation symbol library.
• SOTA reference: Cubase Expression Maps (visual CC routing, per-note articulation coloring), Studio One Sound Variations (notation symbol → MIDI channel + CC sequence), Bitwig Note Grid (custom articulation via Note FX modules)
• Depends on: articulation symbol library (Unicode glyphs or SVG), piano-roll articulation lane component, MIDI export enhancement (emit CC sequences per articulation), synth instrument definition schema (which articulations supported)
• Implementation notes: Add ArticulationMap type: { name: string; ccSequences: { cc: number; value: number }[]; midiChannel?: number }. Store on synth track: articulationMaps: Map<string, ArticulationMap>. In piano-roll, add articulation-selector lane (dropdown per note cluster). In midi-export.ts, emit CC sequence before note-on. In synth-panel.tsx, add 'Articulation Maps' section with preset library (legato, staccato, sfz, tremolo, trill, etc.). Articulation UI via icon + label (e.g., staccato dot •, accent >).

MIDI-9 Chord track with chord symbol rendering & voicing presets — P1 · M · 🟡 partial#

• What & why: Euterpe has diatonic chord progression generation (chord-progressions.ts) and can place chords on a step grid. But lacks: visual chord symbol rendering on the timeline (e.g., 'Dm7', 'G7', 'Cmaj7'), chord voicing presets (closed, open, drop-2, drop-3), chord inversion selection, chord → melody/bass voice routing (comping). Ableton Live 12 has a dedicated Chord Track as a first-class track type.
• SOTA reference: Ableton Live 12 Chord Track (dedicated track, chord symbols, voicing control, harmonizes other clips), Logic Pro Chord Track (suggests chords, auto-harmonize), Hookpad (web-based, chord voicing + melody harmonization)
• Depends on: chord symbol rendering (SVG/Canvas), chord voicing library (closed, open, drop-2, drop-3, shell voicings), track type enhancement (add 'chord-track' to TrackKind enum), UI chord editor (chord symbol + voicing selector per cell)
• Implementation notes: Add ChordTrackKind to TrackKind enum. Create chord-track.tsx component (timeline view showing chord symbols, click-to-edit chord + voicing). Add voicingPresets library: { name: string; intervals: number[] }[] (e.g., closed = [0,4,7], drop-2 = [0,7,12,16]). In daw-session.ts, store chord track state: chords: { beat: number; symbol: string; voicing: string }[]. In clip harmonization, look up chord track to apply voicing. Render chord symbols with @euterpe/core symbolToMidi (already exists).

MIDI-7 MIDI effects chain (generative note randomizers, note repeat, step modulator) — P1 · L · 🟡 partial#

• What & why: Euterpe has arpeggiator only. SOTA DAWs (Bitwig, Ableton) include MIDI effect devices: randomizer (random pitch/velocity/duration within bounds), note repeat (stutter/repeat notes N times), step modulator (modulate any MIDI param per step grid), velocity shaper, transposer, scale enforcer. These transform note stream in real-time during playback/recording.
• SOTA reference: Bitwig Note Grid (Note FX modules: random, repeat, transposer, scale, arp), Ableton MIDI Effects (Arpeggiator, Random, Note Length, Scale, Velocity, Chord), Max for Live custom MIDI effects
• Depends on: MIDI effect architecture (pipeline of transformers), UI components per effect type, per-track MIDI FX chain state in TrackState, engine integration (PolySynth note-on/off interception)
• Implementation notes: Add MidiEffect type with: type: 'randomizer' | 'repeat' | 'transposer' | 'scale' | 'velocity' | 'chord'; params: Record<string, number>. In TrackState, add midiEffects: MidiEffect[] chain. In arp.rs, refactor as first MIDI FX module; after arp, chain other FX. Implement: RandomizerFx (pitch/velocity range), RepeatFx (repeat count + interval), TransposerFx (semitones), ScaleFx (snap to scale), VelocityFx (gain/curve), ChordFx (add harmony notes). In synth-panel.tsx, add MIDI FX Rack UI (add/delete/reorder, per-effect params). Engine: route live note-on/off through effect pipeline before PolySynth.

MIDI-1 MPE (MIDI Polyphonic Expression) per-note control layer — P1 · XL · 🔴 missing#

• What & why: Euterpe lacks multi-dimensional per-note expression editing. SOTA DAWs (Ableton Live 12, Bitwig, Logic) support 5 MPE dimensions: pitch bend, Y-axis/slide, pressure, velocity, release velocity. Currently Euterpe only stores velocity per note (ClipNote.velocity). Needs full MPE curve editor for each dimension, per-note pitch bend curves, aftertouch/pressure recording and playback, per-note timbre/filter modulation.
• SOTA reference: Ableton Live 12 (Note Expression tab, 5 curve types), Bitwig Studio (best-in-class MPE per-note control native), Logic Pro (Alchemy/ES2 MPE instruments)
• Depends on: ClipNote type expansion, piano-roll expression-lane component (SVG multitrack curve editor), MIDI storage format (encode/decode MPE data in export/import), AudioWorklet MIDI receiver for per-note CC/pitch-bend stream
• Implementation notes: Expand ClipNote interface: add optional mpeExpressions: { pitchBend: Curve[], pressure: Curve[], yAxis: Curve[], releaseVelocity: Curve[] }. Build piano-roll expression-lane.tsx (6-lane SVG: pitch, Y, pressure, velocity, release, timbre). In midi-export.ts, emit MIDI CC 0x06 (data entry) + RPN for per-note CC; in midi-import.ts, parse these. In AudioWorklet, route incoming CC 176-191 (channel CC) per note-on's MIDI channel. Reference: @euterpe/genesis melody-gen already models MelodyNote; extend to support expression curves.

MIDI-2 Notation & Score editing (with printable output) — P1 · XL · 🔴 missing#

• What & why: Euterpe has no score/notation view. SOTA DAWs (Logic Pro, Studio One 7, Cubase 14, Reaper) all support music notation editing, printing, and clef/time signature management. Euterpe piano roll is keyboard-centric, not staff-based. Missing: staff rendering, note-head style selection, time signature/key signature editing, tie/rest symbols, dynamic marks, articulation symbols (staccato, accent, marcato), playback-synchronized score navigation.
• SOTA reference: Logic Pro Score Editor (full music notation, staff rendering, MIDI ↔ notation parity), Reaper integrated notation mode (Alt 4), Studio One Pro 7 (Notion 6 engine integrated), Cubase (full notation with MIDI events coloring)
• Depends on: SVG/Canvas staff rendering library (or use Verovio JS for MusicXML standard), piano-roll refactor to unify two views (grid + staff), MIDI → MusicXML serialization, time signature/key signature state in NoteClipState, articulation symbol library (Unicode/SVG glyphs)
• Implementation notes: Create notation-view.tsx component using Verovio (open-source MusicXML renderer) or custom 5-line staff SVG. Map ClipNote → Note object in MusicXML schema. Store timeSignature/keySignature in NoteClipState. Add toggle between piano-roll and notation in piano-roll.tsx. For printing, render to PDF via headless browser or server-side tool. Articulation symbols (U+1D18A–1D1B9) as Unicode + fallback SVG. See @euterpe/score lib (exists but unused; video-analysis, fmod, wwise, not notation).

MIDI-4 Strum tool (chord articulation simulation) — P2 · S · 🔴 missing#

• What & why: FL Studio has an industry-leading Strum tool that offsets note timing + velocity within a chord to simulate guitar/string performance. Euterpe has no strum feature. Missing: strum direction (up/down), strum time (offset range), velocity envelope per note in chord, visual preview.
• SOTA reference: FL Studio Piano Roll Strum tool (Alt+S), configurable strum time + direction, offsets note start times + velocities for each note in a chord cluster
• Depends on: piano-roll context menu enhancement, strum configuration UI (direction, time), note clustering algorithm (detect chords by simultaneity/pitch proximity)
• Implementation notes: Add strumClip(notes: ClipNote[], config: StrumConfig) function in piano-roll-helpers.ts. StrumConfig = { direction: 'up' | 'down'; strumTimeMs: number }. Group notes by start time (±10ms threshold). For each group, sort by pitch and apply staggered start times (Δt per note) + optional velocity taper. Call from piano-roll context menu 'Strum'. Similar to humanizeClip pattern.

MIDI-5 Microtuning (MTS-ESP master, Scala .scl/.kbm file support) — P2 · M · 🔴 missing#

• What & why: Euterpe uses 12-TET (Western tuning) exclusively. No support for alternative tuning systems (just intonation, pythagorean, Arab microtonality, etc.). SOTA (Reaper, Bitwig, Surge XT) support MTS-ESP (master broadcasts tuning to plugins), Scala format (.scl = scale, .kbm = keyboard mapping), per-note MIDI 2.0 tuning RPN. Euterpe could benefit from: Scala file import/editor, MTS-ESP server capability, per-note tuning via MIDI RPN.
• SOTA reference: MTS-ESP open-source C++ library (any plugin can broadcast/receive tuning), Scala format (industry standard for alternate tunings), Reaper + Bitwig (full SYSEX/RPN support for tuning), Modartt Pianoteq (Scala support built-in)
• Depends on: Scala file parser (read .scl + .kbm format), MIDI RPN encoder/decoder for MIDI 2.0 tuning (RPN 0x0000 = pitch bend sensitivity, RPN 0x0002 = tuning), MTS-ESP C++ bridge (Tauri sidecar or FFI), synth engine per-note frequency override
• Implementation notes: Create @euterpe/tuning lib. Add ScalaFile type with pitches (cents per note) + keymap. In PolySynth (dsp-core), add per-note tuning offset in SynthVoice (detune semitones → cents). On DAW UI, add 'Tuning' panel: Scala file import, preset library (just intonation, 31-TET, etc.), toggle MTS-ESP master broadcast. In MIDI export, emit RPN sequences for tuning if target DAW supports.

MIDI-6 Advanced humanize/groove quantize (swing, offset, strength, randomization per-parameter) — P2 · M · 🟢 polish#

• What & why: Euterpe has basic humanizeClip (timing ±3% + velocity ±10% via seeded PRNG). SOTA (Pro Tools Groove Quantize, Logic quantize strength, Ableton swing) offers: swing parameter (timing offset for off-beats), offset amount (delay timing globally), quantize strength (0-100% snap to grid), per-parameter randomization (timing, velocity, duration), groove template transfer (copy feel from one track to another). Current implementation is minimal.
• SOTA reference: Pro Tools Groove Quantize (swing/offset/strength/random params, groove clipboard), Logic Quantize (grid, strength, swing, offset, note length), Ableton Live groove control
• Depends on: groove-clip.ts enhancement, groove templates (persist per-track groove preset), groove extraction (analyze existing clip to derive swing/offset params), UI controls for all params
• Implementation notes: Expand HumanizeOptions: { timing: number; velocity: number; duration?: number; swing?: number; offset?: number; strength?: number; seed: number }. Add grooveFromClip(notes: ClipNote[]) → GrooveTemplate function (analyze timing histogram for swing, offset; extract velocity pattern). In piano-roll context menu, add 'Humanize...' dialog with all params. Add groove preset library (stored per-track). MIDI groove extract/apply via MIDI CC 0x67 (Groove Coarse) + 0x68 (Groove Fine) if target supports.

MIDI-12 Quantize strength (percentage snap-to-grid) & quantize groove templates — P2 · M · 🟡 partial#

• What & why: Euterpe quantizeClip snaps 100% to grid. No strength parameter (e.g., 50% snap = halfway between original and quantized). No groove template support (capture groove from one clip, apply to another). Pro Tools, Logic, Ableton all have quantize strength + groove templates.
• SOTA reference: Pro Tools Quantize Strength slider (0-100%), Groove clipboard (copy/paste feel), Logic Quantize Strength + Swing, Ableton Quantize Amount dial
• Depends on: quantizeClip enhancement (strength param), groove template storage + persistence, groove extraction algorithm, UI quantize dialog
• Implementation notes: Expand quantizeClip signature: quantizeClip(notes: ClipNote[], grid: number, strength?: number): ClipNote[]. If strength < 1, interpolate: quantized + (original - quantized) * (1 - strength). Add GrooveTemplate type + storage in track state. Extract groove from clip: analyze timing histogram, quantize offset, velocity pattern → template. Piano-roll context menu: 'Quantize...' dialog (grid selector, strength slider), 'Capture Groove', 'Apply Groove' dropdown.

MIDI-18 MIDI learn & CC mapping (hardware controller → synth parameters) — P2 · M · 🔴 missing#

• What & why: Euterpe has Web MIDI input (hardware notes → synth recording). Missing: MIDI learn (click a parameter, twist hardware knob, auto-map CC to parameter), per-track CC assignment, CC curve editor (linear/exponential/steps response). Pro Tools, Ableton, all DAWs have this.
• SOTA reference: Ableton MIDI Map mode (click param, twist knob, CC assignment done), Logic Control Surface (hardware controller profile), Reaper MIDI Learn (CC mapping per parameter)
• Depends on: MIDI CC parser (already in web-midi.ts), CC → parameter mapping store, MIDI learn mode UI toggle, CC value curve (linear/exponential), real-time parameter update via CC
• Implementation notes: Add MidiCcMapping type: { cc: number; channel: number; paramPath: string; curve: 'linear' | 'exponential' | 'steps'; minVal: number; maxVal: number }. Store on track: midiMappings: MidiCcMapping[]. Add MIDI Learn button in synth-panel.tsx: click button, listen for next CC message, store mapping. In AudioWorklet, route incoming CC messages (status 0xB0-0xBF) to parameter update via mapping. See daw-controller.ts for engine command dispatch pattern.

MIDI-22 Import/export MusicXML and MIDI 2.0 UMP formats — P2 · M · 🔴 missing#

• What & why: Euterpe exports/imports SMF (Standard MIDI File 0/1 only). Missing: MusicXML export (standard for notation interchange), MIDI 2.0 UMP format support (future-proofing), CoolRiff format (some cloud DAWs use), compressed MIDI archive (stems + MIDI in one file).
• SOTA reference: MusicXML standard (musicxml.com, supported by Finale, Sibelius, Reaper, Dorico), MIDI 2.0 UMP (official MIDI standard, ratified 2023), Finaleio (MusicXML interchange), BandLab (cloud DAW, proprietary format + standard exports)
• Depends on: MusicXML schema (XML library), UMP encoder/decoder (MIDI 2.0), export dialog (choose format), clip → MusicXML converter (notes + time sig + key sig)
• Implementation notes: Add musicxml-export.ts: convert NoteClipState + key + time signature → MusicXML Document. Use lightweight XML builder. For UMP, create midi-2-0-export.ts with UMP packet encoder. In DAW export dialog, add format selector (SMF, MusicXML, UMP). Reference: musicxml-builder npm package or hand-roll schema.

MIDI-24 Quantization presets & groove quantize from audio reference — P2 · M · 🟡 partial#

• What & why: Euterpe quantizeClip is basic (snap to grid, no strength). Missing: preset library (swing-8ths, swing-16ths, triplet feel, jazz shuffle), groove extraction from audio clip (analyze audio drum/rhythm, apply groove to MIDI), groove library (save/load named grooves).
• SOTA reference: Pro Tools Groove Clipboard (save/load groove templates), iZotope RX (extract groove from audio), Peak Strip groove analyzer, Reaper groove quantize
• Depends on: grooveFromAudio(audioBuffer) → GrooveTemplate function (beat tracking, rhythm analysis), preset library (hardcoded or external JSON), groove storage/persistence, UI library manager
• Implementation notes: Add audio-groove-analysis.ts: use existing detectTempo logic, add beat/downbeat detection, compute swing/offset/randomness from beat times. grooveFromAudio(buffer) → GrooveTemplate. Create groove library (UI panel: save groove, load from preset). Presets: [{ name: 'Swing 8ths', swing: 0.33, offset: 0, strength: 1 }, ...]. Piano-roll context menu: 'Apply Groove...' dialog (preset selector or audio file upload for groove extraction).

MIDI-8 Polyphonic step modulation (per-voice parameter sequencing) — P2 · L · 🔴 missing#

• What & why: Bitwig Studio 5 introduced Steps modulator (increments output per new note played, enabling per-voice LFO/envelope sequencing). Euterpe lacks this: no per-voice automation or modulation sequencing. Only global automation lanes (6 lanes: volume, pan, cutoff, reverb, delay, master-gain) exist. Missing: per-voice parameter curve (pitch, filter, amplitude envelope per MIDI note), modulation sequence (e.g., LFO rate changes per note), voice-dependent parameter modulation.
• SOTA reference: Bitwig Studio 5 Steps modulator (output increments per note, use for per-voice LFO depth, delay feedback, etc.), Bitwig MSEG (multi-segment envelope per voice), polyphonic parameter automation (one curve per voice in a polyphonic track)
• Depends on: PolySynth per-voice envelope/LFO (already has per-voice ADSR; extend to per-voice automation), automation system (refactor from global to per-voice), UI automation-lane.tsx enhancement (voice selector, per-voice curve editing)
• Implementation notes: In PolySynth, add per-voice modulation sources (per-voice MSEG, per-voice LFO). In daw-session.ts, add per-voice automation alongside global automation. In automation-lane.tsx, add voice selector (voice 0-7). Render separate polyline per voice (color-coded). Engine: apply per-voice automation by voice index when triggering synth parameter changes. See dsp-core SynthVoice for envelope access.

MIDI-16 Drum sequencer (specialized step grid for drums with one-shot samples) — P2 · L · 🔴 missing#

• What & why: Euterpe step grid is pitch-based (13 rows = one octave). No specialized drum sequencer (drum rack on X-axis, one-shot samples on Y, like Ableton Drum Rack or FL Studio Drum Kit). Missing: kit selection, sample preview, swing per drum, individual drum muting/soloing, drum fills presets.
• SOTA reference: Ableton Drum Rack (track type, kit editing, individual chain per drum), FL Studio Drum Sequencer (specialized piano roll view), Logic Drum Editor, Maschine (NI, dedicated drum sequencer)
• Depends on: drum kit/sample library, specialized step grid UI (drum rack on Y-axis), one-shot sample triggering (no note duration), drum fill generation, per-drum swing/velocity/gate
• Implementation notes: Add 'drum' TrackKind (alongside 'synth', 'audio'). Create drum-sequencer.tsx: Y-axis = drum slots (16 or 32), X-axis = steps (16). Each drum slot = sample reference + MIDI note. Drums have fixed velocity + gate (not variable like pitched notes). Store: drumKit: { drums: { id: string; name: string; sampleUrl: string; midiNote: number }[] }. In engine, special handling for drum tracks (trigger sampler per drum note). UI: drum kit editor (add/remove drums, preview sample, pitch/decay control per drum).

MIDI-10 Scale highlight (done) + scale-relative note editing (partial) — P3 · S · 🟢 polish#

• What & why: Euterpe implements scale highlighting on piano roll (isNoteInScale check, black key styling). Good. But lacks: scale-relative degree entry (e.g., click scale degree 3 to place major-3rd of root), scale-relative notation in piano roll (show scale degree numbers instead of MIDI pitches), quantize-to-scale-degree snap (not just note snapping). Some DAWs show scale degrees on piano-roll labels.
• SOTA reference: Ableton Live 12 scale mode (highlights scale notes, snap-to-scale drag), FL Studio scale highlighting (unique implementation per reviews), Scaler 2 plugin (scale degree library, music theory UI)
• Depends on: piano-roll note label display (show degree or pitch name), scale-degree-to-MIDI mapping, quantize snap to scale degree
• Implementation notes: In piano-roll.tsx, add optional label display mode (toggleable): show scale degree (1–7) or MIDI note name. When scale lock is enabled, snap note insertion to scale degrees. Compute degree from pitch: degree = (pitch - rootMidi) % 12, map to scale intervals, render label. See scalePitchClasses(rootPc, scaleName) in scale-mode.ts.

MIDI-20 Note repeat / flam tool (rapid repeated/grace-note effect) — P3 · S · 🔴 missing#

• What & why: Euterpe lacks note repeat (one note click → multiple rapid repeats) and flam/grace note tools. These are expressive MIDI techniques. Missing: repeat count, repeat rate (tempo-synced note divisions), grace-note timing (fast note before main note), UI tool in piano roll.
• SOTA reference: Ableton MIDI Effect Note Length (clip note duration), iZotope plugins (flam/grace modules), Bitwig Note FX (note repeat generator)
• Depends on: noteRepeat(note: ClipNote, count: number, interval: number): ClipNote[] function, grace-note helper, piano-roll tool/context menu
• Implementation notes: Add noteRepeat(note: ClipNote, count: number, intervalBeats: number): ClipNote[] in piano-roll-helpers.ts. Creates N copies of note at tempo-synced intervals. Add gracenote(mainNote: ClipNote, timing: 'fast' | 'slow'): ClipNote[] (64th-note or 32nd-note before main note). Piano roll context menu: 'Add Repeat...' (count, interval) or 'Add Grace Note'.

MIDI-11 Note velocity editing & velocity ramp (beyond velocity rail) — P3 · M · 🟢 polish#

• What & why: Euterpe piano roll has a velocity rail (drag note right edge up/down to change velocity). Good basic feature. But lacks: velocity-range selector (select note cluster, set velocity bounds), velocity ramp (linear/exponential velocity change across notes), velocity curve editor (per-note velocity envelope over note duration), accent pattern (specific notes louder). Most DAWs support velocity editing; Euterpe's is minimal.
• SOTA reference: Logic Pro Piano Roll (velocity lane, velocity range, velocity ramp tool), Reaper MIDI Editor (velocity lane, adjust via mouse drag, ramp tool), Ableton (velocity dots/lines, drag to edit)
• Depends on: piano-roll context menu (velocity tools), velocity ramp function (linear/exponential interpolation), accent pattern presets
• Implementation notes: Add velocityRamp(notes: ClipNote[], startVel: number, endVel: number, curve: 'linear' | 'exponential'): ClipNote[] in piano-roll-helpers.ts. Add context menu 'Velocity Ramp...' (select notes, choose start/end vel + curve, apply). Add accent preset tool (select notes, apply accent pattern: every Nth note louder). UI: velocity-range slider in piano-roll controls, ramp direction buttons.

MIDI-15 Arpeggiator in piano roll (within clip, not live performance) — P3 · M · 🔴 missing#

• What & why: Euterpe arpeggiator is live only (arp.rs, wired to synth during playback). Ableton Live 12 allows creating arpeggios directly in the piano roll without recording. Missing: arpeggio generator that converts a held chord into a sequence of single notes within the piano roll (destructive edit), configurable arp pattern + timing.
• SOTA reference: Ableton Live 12 piano roll arpeggiator (generate arp pattern from chord, write into clip), FL Studio (arp within piano roll context)
• Depends on: arpeggiate(notes: ClipNote[], mode: ArpMode, rate: number, octaves: number): ClipNote[] function, piano-roll context menu (right-click chord cluster → 'Arpeggiate...'), arp preview visualization
• Implementation notes: Add arpeggiate() function in piano-roll-helpers.ts: given chord notes (simultaneous), generate sequence at given rate. Select a chord cluster in piano roll, context menu 'Arpeggiate...', dialog: mode (up/down/updown/random), rate (8ths, 16ths, triplets), octaves (1-4), gate. Convert chord to arp sequence, update clip notes. See arp.rs sequence() method for ordering logic.

MIDI-17 Ratchet & conditional probability per MIDI note — P3 · M · 🟡 partial#

• What & why: Euterpe step sequencer has per-step ratchet (patternRatchets in types.ts, probability already present). But no per-note ratchet in piano roll (MIDI clip). No conditional logic (e.g., 'play this note if previous step fired', 'humanize timing only if velocity > 0.5'). Advanced generative music uses note conditions for evolving patterns.
• SOTA reference: Elektron Analog/Digitakt sequencers (ratchet + conditions per note), Bitwig Grid (step conditions, note repeat), Pure Data (gen~ conditional logic)
• Depends on: ClipNote enhancement (add ratchet?: number, condition?: string), piano-roll per-note ratchet/condition UI, condition evaluator engine (run-time logic for conditional triggers)
• Implementation notes: Extend ClipNote: { ..., ratchet?: number, condition?: 'always' | 'if-prev-played' | 'if-velocity-gt-0.5' | ... }. In piano-roll note editor (right-click), add ratchet slider (2-8 repeats at fixed interval) and condition dropdown. In engine, on note-on, evaluate condition before triggering synth. For 'if-prev-played', check note-off of previous note in sequence.

MIDI-19 Clip-level time signature & tempo (sub-session tempo/meter) — P3 · M · 🔴 missing#

• What & why: Euterpe session has global tempo + 4/4 time signature (implicit). No per-clip time signature or tempo override. Missing: clip in 7/8 within 4/4 session, clip at 2x/0.5x session tempo (without time-stretch), polyrhythmic stacking. Some DAWs (Reaper, Live 11+) support clip-level time sig.
• SOTA reference: Reaper clip/take properties (tempo override, meter override), Ableton Live 11+ (warp markers for stretch, session → clip tempo independence)
• Depends on: NoteClipState enhancement (timeSignature?: string, tempoOverride?: number), engine playhead calculation (account for clip-local tempo/meter), UI clip properties panel
• Implementation notes: Extend NoteClipState: { ..., timeSignature?: '4/4' | '3/4' | '7/8' | ..., tempoOverride?: number }. In pattern sequencing (engine), compute clip playhead accounting for clip tempo/meter offset. In clip properties UI, add time signature selector and tempo multiplier slider (0.5x-2x). Requires refactoring of beat-to-sample calculations to be clip-aware.

MIDI-13 Generative melody device (real-time playable generator) — P3 · L · 🔴 missing#

• What & why: Euterpe has offline melody generation (generateMelodyFromChords wired in DAW, fillClip actions). Missing: real-time generative MIDI device (play notes, device generates harmonizing/complement melody in real-time during playback, like generative synths). Bitwig, Max, some artists use generative MIDI devices for live performance.
• SOTA reference: Max for Live generative MIDI patches, Bitwig Grid (modular composition engine, can generate MIDI), Reaktor (Native Instruments, generative synths), Orb Composer (web-based generative MIDI companion)
• Depends on: @euterpe/genesis real-time API (currently offline batch), streaming generation state machine, MIDI output from generator, UI generator device (mode, key, style selectors)
• Implementation notes: Create GenerativeMidiDevice type: { kind: 'generative'; style: string; key: string; density: number; mode: 'harmonic' | 'melodic'; enabled: boolean }. Add to InsertKind. Implement generator in MIDI effect pipeline: on each note-on, call genesis.generateHarmony(inputNote, context) → generated notes, emit as note-ons. In synth-panel.tsx, add 'Generative' device with preset library (harmony, melody, counter-melody, bass), style selector (pop, jazz, classical, etc.), density/key controls.

MIDI-14 MIDI 2.0 support (high-resolution CC, extended note properties) — P3 · L · 🔴 missing#

• What & why: MIDI 2.0 (ratified 2023) provides: 32-bit CC resolution (vs. 14-bit in MIDI 1.0), per-note CC (polyphonic aftertouch via new message types), registered per-note controllers, program change improvements. Euterpe currently uses MIDI 1.0 exclusively (7-bit note numbers, 7-bit CC values). No MIDI 2.0 support.
• SOTA reference: MIDI 2.0 spec (www.midi.org), Bitwig (announced MIDI 2.0 support exploration), Roli Seaboard / Expressive E controllers (MIDI 2.0 compatible hardware), DAWs: nascent support (Ableton, Cubase exploring)
• Depends on: MIDI 2.0 parser/emitter (decode/encode high-resolution CC + per-note CC messages), backward-compatibility layer (MIDI 1.0 translation), UI enhancement (show 32-bit CC in automation)
• Implementation notes: Create midi-2-0.ts module: decode/encode MIDI 2.0 UMP (Universal MIDI Packet) format. In midi-import.ts, detect MIDI 2.0 header and parse accordingly. In midi-export.ts, optionally emit MIDI 2.0 if target requests. Store per-note CC in ClipNote: perNoteCC?: { cc: number; value: number }[]. DAW adoption is still low; implement as optional/future feature. For now, provide fallback to MIDI 1.0 CC mapping.

MIDI-21 Polyphonic step modulation UI (per-voice LFO/envelope sequencing editor) — P3 · L · 🔴 missing#

• What & why: Related to gap #7 (polyphonic step modulation). Missing UI visualization: show 8 voices (columns) on step grid, each voice has its own LFO/envelope/modulation sequence. Bitwig Grid allows modulation sequencing; Euterpe has no UI for it yet.
• SOTA reference: Bitwig Grid (modulation per-voice sequencing), Elektron Rytm (per-track LFO/envelope sequencing), Grids plugin (step modulation UI)
• Depends on: PolySynth per-voice LFO/envelope (dsp-core enhancement), modulation-sequencer UI component (8-row grid showing per-voice modulation curves), state management for per-voice mod sequences
• Implementation notes: Create polyphonic-modulation-editor.tsx: 8 rows (voices) × 16 steps (timeline). Each cell shows LFO/envelope intensity per voice. Allow drawing curves per voice. Store: perVoiceModulation: { voiceId: number; lfoDepth: number[]; envAmp: number[] }[]. In PolySynth, apply per-voice modulation when triggering voice.

MIDI-23 Probabilistic note density & generative fill patterns (Markov chains for MIDI) — P3 · XL · 🔴 missing#

• What & why: Euterpe generates melodies from chords (simple rule-based). Missing: probabilistic melody generation using Markov chains or other stochastic models (note follows note with transition probabilities), generative fill patterns (auto-generate fills with peaks/tension/release), melodic contour models.
• SOTA reference: Magenta Melody RNN (TensorFlow, learns style from MIDI), MuseNet (OpenAI), Suno/Udio (full generative models), Hookpad (Markov harmonic model)
• Depends on: @euterpe/genesis enhancement (add Markov/probabilistic generation), training data (MIDI corpus), stochastic note sequencing, UI style/mood selectors
• Implementation notes: Implement MarkovMelodyGenerator in @euterpe/genesis: train on MIDI corpus (note → next-note transition probabilities, velocity correlations, duration patterns). Add generateMelodyMarkov(key, length, style, seed) function. In DAW: add 'Markov Fill' button in piano-roll, dialog: length, style (pop, jazz, funk, etc.), seed/randomness slider. Requires offline training or pre-trained model weights; consider integration with Magenta.js library (TensorFlow.js).

ENG-2 Sample-accurate automation (sub-sample precision) — P0 · M · 🟡 partial#

• What & why: Current automation lanes interpolate block-by-block (128-sample quantization = ~2.67ms at 48kHz). SOTA requires per-sample or fractional-sample precision for tight, sample-accurate parameter changes. Affects all automatable parameters (volume, pan, cutoff, send levels, master gain).
• SOTA reference: Ableton Live 12, Logic Pro 14, Cubase 14, Pro Tools 2025 all implement microsecond-accurate automation (essentially sample-accurate for all practical purposes); some (Pro Tools, Logic) use sub-sample internal representations
• Depends on: dsp-graph engine refactor (process() loop must accept per-sample parameter updates); automation-lane-helpers.ts updated to generate sub-block breakpoint samples
• Implementation notes: Modify dsp-graph Engine::process to accept optional per-sample automation arrays (in parallel with block-level commands). In automation-lane-helpers.ts, linearly interpolate breakpoints to 48kHz (per-sample) instead of per-block. Add a 'sub-sample mode' flag to automation lane config (toggle for CPU vs precision). For realtime WASM, upsampling automation may be CPU-prohibitive; use only for automation lanes on the critical path (master volume, track faders).

ENG-3 Plugin delay compensation (PDC) framework — P0 · L · 🔴 missing#

• What & why: No PDC system exists. Euterpe's insert effects (EQ, comp, reverb, delay) all have known latencies (delay has feedback delay line, reverb has comb filter ringbuffer), but no automatic delay compensation to zero latency. In multi-track sessions with variable-latency inserts, tracks drift out of phase. SOTA DAWs measure each plugin's latency and shift audio backward (look-ahead) or forward-delay other tracks to align them.
• SOTA reference: Pro Tools 2025 (extensive PDC network, sample-accurate), Cubase 14 (full PDC with look-ahead option), Logic Pro 14 (automatic per-plugin compensation), Bitwig Studio 5 (graph-based PDC)
• Depends on: Latency profiler (measure each effect node's delay in samples); per-track delay line or sample-shift logic; graph analysis pass to compute optimal delay alignment
• Implementation notes: Add a latency_samples() method to each effect node (EqNode, CompressorNode, ReverbNode, etc.). In Engine, after topology changes, run a graph pass to measure max latency and apply per-track pre-delay (shift audio backward in time via a ringbuffer). Store per-track shift amount in dB-level metadata. UI: display PDC status per track (ms shift applied). Start with a simple linear PDC (no look-ahead) that aligns all tracks to the slowest insert chain.

ENG-1 Native ASIO/CoreAudio driver layer (replace WebAudio) — P0 · XL · 🔴 missing#

• What & why: Euterpe is WebAudio-only, locked to browser audio stack. SOTA requires native audio drivers (ASIO on Windows, CoreAudio on macOS) for true latency control (<5ms, ideally <2ms). WebAudio has unpredictable buffering and cannot achieve pro-studio latency. Need a native audio bridge via Tauri + cpal/coreaudio Rust crate.
• SOTA reference: Ableton Live 12 (ASIO/CoreAudio), Pro Tools 2025 (ASIO/HDX, 1ms latency), Logic Pro 14 (CoreAudio 2–5ms), Reaper 7.x (ASIO/JACK ultra-low latency)
• Depends on: Tauri shell (already present); cpal Rust crate for audio I/O; RingBuffer for lock-free sample hand-off from native thread to WASM; latency measurement harness
• Implementation notes: Create /libs/euterpe/audio-engine/crates/dsp-native Rust crate wrapping cpal (cross-platform audio) + ringbuf (lock-free MPMC). Tauri-bridge the native thread via a single-producer channel (commands in, audio out). Modify dsp-wasm to optionally use dsp-native instead of AudioWorklet. Target: <5ms roundtrip latency on macOS (CoreAudio HAL directly). Desktop only (browser stays WebAudio).

ENG-6 Denormal number handling (flush-to-zero, subnormal silence) — P1 · S · 🔴 missing#

• What & why: No explicit denormal handling. When DSP produces numbers smaller than the smallest normal 32-bit float (~1e-38), the CPU incurs a performance penalty (denormal flush, CPU stall). SOTA DAWs explicitly flush denormals to zero to avoid the stall. In Reaper, disabling denormal handling causes measurable CPU spike.
• SOTA reference: Reaper, Pro Tools, Cubase, Logic all explicitly flush denormals (FTZ, DAZ on x86/ARM)
• Depends on: Platform detection (x86 vs ARM); Rust crate (e.g., denorm or manual asm for FTZ/DAZ flags)
• Implementation notes: In dsp-core lib.rs, add a module denormal with enable_flush_to_zero() function. On x86, set the FTZ (Flush To Zero) and DAZ (Denormals Are Zero) bits in the MXCSR register (or use a Rust library). On ARM, set the FZ bit in FPSCR. Call this once at Engine::new(). For WASM, denormal handling may not be available (browser sandboxing); note this limitation.

ENG-5 64-bit float internal DSP path — P1 · M · 🟡 partial#

• What & why: All DSP is f32 (32-bit). SOTA DAWs use f64 (64-bit) internally for precision (especially in long-tail computations like reverb, delay, meter integrators). Accumulating errors over 10+ minutes of recording can cause audible distortion in metering and spatial processing.
• SOTA reference: Pro Tools, Logic Pro, Cubase, Ableton Live, Reaper all use 64-bit internal float throughout
• Depends on: Full dsp-core refactor (all process() functions f32 → f64); meter integrators already use f64 (LoudnessMeter sum_sq: f64), so partially done
• Implementation notes: Convert all DSP primitives from f32 to f64 in dsp-core. Start with metering (already partway there), then filters (biquad, eq), dynamics (compressor, limiter), and time-domain effects (delay, reverb). Output stage: convert f64 → f32 for AudioContext (which is 32-bit). Benchmark latency impact (likely small on modern CPUs; f64 arithmetic is not that much slower than f32 in SIMD).

ENG-9 Advanced time-stretch algorithm (Élastique/Rubber-Band class) — P1 · L · 🟢 polish#

• What & why: Current WSOLA implementation is basic (no transient detection, phase vocoder artifacts on drums/percussive material). Élastique (zplane) and Rubber-Band (juce, open-source) are SOTA: preserve transients, high quality, no musical artifacts. Euterpe's WSOLA is suitable for pads/strings but poor for drums.
• SOTA reference: Logic Pro 14 (Élastique Tolérance Pro), Cubase 14 (Elastique), Ableton Live (Élastique Tolérance), Reaper (multiple algorithms including Rubber-Band class)
• Depends on: License a proprietary library (Élastique) OR integrate Rubber-Band (AGPL, open-source) OR implement transient-aware time-stretch from scratch
• Implementation notes: Option A: License Élastique from zplane (commercial API). Option B: Integrate librubberband (JUCE license; Reaper uses this). Option C: Add transient detection to WSOLA (detect onsets via spectral flux, preserve those frames). Start with Option C: modify timestretch.rs to detect percussive onsets (autocorrelation of STFT magnitude gradient), mark transient frames, and avoid placing WSOLA grains at transient boundaries. Benchmark quality vs Rubber-Band on drum loops.

ENG-4 Multicore graph scheduling & work stealing — P1 · XL · 🔴 missing#

• What & why: Engine processes linearly (single-threaded): iterates tracks, runs each insert chain sequentially. No parallelism. SOTA DAWs partition the graph and schedule independent subgraphs to threads (work-stealing schedulers). On an 8-core CPU, Euterpe does not parallelize.
• SOTA reference: Reaper 7.x (near-linear scaling to 32 threads via lock-free work stealing), Ableton Live 12 (multicore work-stealing scheduler), Pro Tools 2025 (Avid multicore dispatch)
• Depends on: Dependency graph analysis (topological sort of track + effect chain); lock-free job queue (e.g., rayon or crossbeam); WASM cannot use true OS threads (it has a JS event loop), so WASM build stays single-threaded; native desktop build can use multicore
• Implementation notes: Add an optional schedule_mode (SingleThread vs Parallel) to Engine. In Parallel mode, build a DAG of effect nodes and tracks, topologically sort, and dispatch to a rayon thread pool. Use a lock-free channel to feed results from one node to the next. For WASM, keep SingleThread mode (browser event loop). Desktop native build in dsp-native uses Parallel. Benchmark on 8-core vs single-core to verify speedup.

ENG-7 Disk-based audio streaming (large file support) — P1 · XL · 🔴 missing#

• What & why: Sampler loads entire audio file into memory (dsp-core Sampler: data: Vec<f32>). No streaming. A 10-minute stereo WAV at 48kHz = 46 MB, loading 10 such files = 460 MB RAM per session. SOTA DAWs stream from disk (ringbuffer window), keeping only a small cache in RAM. Sessions with 100+ audio files are infeasible with current architecture.
• SOTA reference: Reaper (handles 1000+ audio tracks via streaming), Pro Tools (disk streaming for media), Logic Pro (disk-based audio buffer), Cubase (efficient streaming layer)
• Depends on: Async file I/O layer (tokio::fs or similar); ringbuffer cache (recent samples in RAM); sample-accurate seeking; integration with dsp-graph's Sampler track
• Implementation notes: Create a new crate /libs/euterpe/audio-engine/crates/dsp-streaming with a StreamingSampler struct. Use tokio (async) or rayon (parallel) to load samples in a background thread into a ringbuffer (e.g., 2-second cache). Sampler.trigger() and Sampler.process() interact with the ringbuffer, not the full buffer. For web (WASM), fetch audio chunks via HTTP range requests (or IndexedDB cache). Desktop version uses native file I/O.

ENG-10 Constant-power stereo panning (not linear) — P2 · S · 🟢 polish#

• What & why: Current panning uses linear gain adjustment (mixer.rs pan_gains). Linear panning sounds unnatural (center sounds quieter). SOTA uses constant-power panning (sum of L² + R² is constant = perceived volume unchanged as you pan).
• SOTA reference: All SOTA DAWs use constant-power panning (mathematics: L = sin(θ), R = cos(θ) for panning angle θ)
• Depends on: None; pure math fix in mixer.rs
• Implementation notes: In mixer.rs pan_gains(pan: f32) function, replace the linear calculation with constant-power: pan is clamped to [−1, 1]. angle = (pan + 1) * π/4, left_gain = sin(angle), right_gain = cos(angle). Return (left_gain, right_gain). Unit test: verify that left_gain² + right_gain² ≈ 1.0 for all pan values.

ENG-12 True-peak metering (ITU R BS.1770, 3x oversampling) — P2 · S · 🟡 partial#

• What & why: Current LoudnessMeter uses ITU R BS.1770 weighting but no true-peak calculation (which requires 3x oversampling per ITU standard). Reported LUFS is accurate, but true-peak (inter-sample peaks) may exceed reported ceiling, causing clipping on streaming platforms.
• SOTA reference: Pro Tools 2025 (true-peak metering), Cubase 14, Logic Pro 14, Reaper all implement 3x oversampling for true-peak detection
• Depends on: 3x upsampling module (from oversampling work above); true-peak meter in dsp-core
• Implementation notes: Add TruePeakMeter to dsp-core/meter.rs. For each audio block, upsample to 3x (via polyphase filter or simple zero-insertion + low-pass). Find peak in the upsampled signal. Return as dBFS (relative to full scale 1.0). In Engine, tap the master output and run TruePeakMeter. Display true-peak in the meter UI (separate from digital peak).

ENG-13 Per-track and per-insert bypass/mute (with fade-out to prevent clicks) — P2 · S · 🟡 partial#

• What & why: Mute and bypass exist per-track but no fade-out envelope to prevent digital clicks/pops. Instant mute = DC offset change = audible click. SOTA DAWs ramp mute/bypass changes over a short envelope (~1–5ms).
• SOTA reference: All SOTA DAWs (automatic envelope on mute, bypass, parameter changes)
• Depends on: Per-track mute envelope state (target, current, ramp time)
• Implementation notes: In Track struct, add mute_env: f32 (current envelope level 0–1) and mute_target: bool (desired mute state). In process(), if mute_target != mute_active, ramp mute_env toward 0 or 1 over 5ms (240 samples at 48kHz). Multiply output by mute_env. Same for insert bypass. Test: verify no click on mute toggle.

ENG-8 Oversampling & anti-aliasing filters — P2 · M · 🔴 missing#

• What & why: No oversampling. Effect modules (waveshaper, bitcrusher, resampling in the sampler) operate at the base sample rate (48kHz), risking aliasing. SOTA DAWs offer 2x, 4x, 8x oversampling on effects and resampling, with matching decimation filters.
• SOTA reference: Ableton Live 12 (4x/8x oversampling), Cubase 14 (extensive oversampling options), Logic Pro 14 (convolver + resampling oversampling), all SOTA DAWs
• Depends on: Polyphase decimation filter design (Kaiser or similar); upsampling/downsampling modules; per-effect toggle for oversampling (CPU trade-off)
• Implementation notes: Add oversampling support to dsp-core: fn upsample(buf: &[f32], factor: usize) → Vec<f32> (zeros-between, then apply polyphase low-pass), and fn downsample(buf: &[f32], factor: usize) → Vec<f32> (low-pass, then drop). Wrap Waveshaper, BitCrusher, and Sampler.process() in an oversampling envelope (configurable 1x–8x). Sampler resampling uses oversampling to avoid aliasing on pitch-shifts. Add a master 'oversample mode' toggle in the UI (CPU trade-off).

ENG-11 Very large session scaling (300+ tracks, 1000+ plugins) — P2 · M · 🟡 partial#

• What & why: No testing or optimization for very large sessions. Euterpe's linear track iteration and per-track insert chains will degrade on 100+ tracks. Memory usage, CPU per-track, and UI responsiveness untested at scale.
• SOTA reference: Reaper (1000+ tracks), Pro Tools (500+ tracks with optimization), Cubase (300+ tracks typical)
• Depends on: Profiler (flame graph, allocation tracking); session-scaling benchmarks; track muting/disabling optimization
• Implementation notes: Create a test session with 300 tracks (all synth, all with a 5-insert chain). Measure: memory usage, process() time per block, UI render time. Profile with perf/flamegraph. Identify bottlenecks (likely: per-track insert iteration, master bus summing, metering). Optimize: use SIMD for summing (e.g., pack 8 floats and dot-product), lazy-evaluate muted tracks (skip entirely), batch meter updates. Goal: <10% CPU on a 2021 MacBook Pro for 300 tracks.

ENG-20 CPU load meter & per-track contribution visualization — P2 · M · 🔴 missing#

• What & why: No real-time CPU load reporting. Users cannot see which tracks/inserts consume the most CPU. SOTA DAWs display CPU % per track and overall, helping users optimize sessions.
• SOTA reference: Reaper (excellent CPU meter with per-track breakdown), Pro Tools (CPU meter), Cubase (CPU load display)
• Depends on: Timing instrumentation in Engine.process() (per-track + per-insert timing), metering snapshot to UI
• Implementation notes: In Engine, use std::time::Instant to measure process() time per-track and per-insert. Store as track_times: Vec<f32> (dB-scaled milliseconds per block). In meter snapshot, include per-track CPU contribution. UI: in mixer (track list), show a small CPU bar per track (% of total). In master metering, show overall CPU % of available thread budget.

ENG-21 MIDI learn / automation binding (hardware control) — P2 · M · 🟡 partial#

• What & why: Web MIDI is supported (input), but no MIDI learn system. Cannot bind a hardware knob to a parameter (no persistent mapping). Requires MIDI learn UI + binding storage in project JSON.
• SOTA reference: Ableton Live 12 (MIDI learn), Cubase (MIDI controller learn), Logic Pro (Environment MIDI learn), Reaper (MIDI learn wizard)
• Depends on: MIDI learn mode toggle; MIDI event capture on parameter click; binding storage in project; MIDI input dispatch to bound parameters
• Implementation notes: Add a 'learn' button per automatable parameter (in UI: hold Shift + click, or dedicated learn button). When active, listen to next MIDI CC (control change) message. Map CC → parameter. Store binding in daw-session state. On MIDI input, dispatch CC messages to bound parameters (no UI required, direct parameter update). UI: show small MIDI indicator next to learned parameter.

ENG-15 Loudness range (LRA) metering — P3 · S · 🔴 missing#

• What & why: Current metering includes LUFS (loudness) and peak, but no LRA (loudness range). LRA is useful for broadcast/cinema (measure dynamic range of a mix). ITU R BS.1770-4 includes LRA calculation.
• SOTA reference: Cubase 14, Reaper, Pro Tools (LRA measurement)
• Depends on: LRA computation (standard deviation of short-term loudness samples)
• Implementation notes: Add LraCalculator to dsp-core/meter.rs. Collect short-term LUFS samples (every 3 seconds per ITU). Compute percentile range (95th − 10th percentile). Return LRA in LU (loudness units). Display in meter UI.

ENG-17 Clip detection and soft-clipping on master output — P3 · S · 🟡 partial#

• What & why: Master limiter exists (brickwall), but no visual indication of clipping history or soft-clipping mode. Some users prefer soft clipping (rounded, musical) over brick-wall limiting (harsh, transparent). Cubase and others offer clipping mode selection.
• SOTA reference: Cubase (clip indicator, soft-clipping mode), Logic Pro (limiting + soft clip option), Reaper (multiple limiter types)
• Depends on: UI indicator for clipping events (in meter); optional soft-clipping mode in master limiter
• Implementation notes: In transport-bar.tsx, add a small red LED indicator for clipping (lights when gain_reduction from master limiter exceeds threshold). Add a toggle in master settings for 'soft clip' mode (uses tanh() instead of hard clamp in limiter). Implement soft clipping: out = tanh(in / (threshold + 1e-9)) * threshold.

ENG-14 Spectral metering with windowing options — P3 · M · 🟡 partial#

• What & why: Current spectrum visualization uses AnalyserNode FFT (one fixed window, one FFT size). SOTA DAWs offer multiple windows (Hann, Hamming, Blackman), variable FFT sizes (512–8192), and frequency scaling (linear vs log). Useful for precise frequency analysis and surgical EQ.
• SOTA reference: Reaper (Spectrum analyzer with window/size options), Cubase (multiple spectrum views), Logic Pro (Advanced Metering)
• Depends on: Windowing library (apodize, or manual Kaiser window generation); configurable FFT wrapper
• Implementation notes: In audio-visualizers.tsx SpectrumView, add dropdown controls for window (Hann, Blackman, etc.) and FFT size (512–8192). Use a FFT library (dft.js or fftjs) to compute custom FFTs with variable window. Store window choice in component state. Re-render spectrum on window change.

ENG-16 Automatic gain compensation on parameter changes (duck/swell) — P3 · M · 🔴 missing#

• What & why: No automatic gain compensation when users adjust insert parameters (e.g., boosting EQ by 12 dB increases output level). SOTA DAWs offer 'auto makeup gain' (e.g., a compressor automatically adjusts output to maintain perceived loudness). Less critical, but improves UX.
• SOTA reference: Ableton Live 12 (auto makeup gain option), Cubase (dynamic output level following),Logic Pro (parameter-linked gain adjustment)
• Depends on: Per-insert output level tracking (before/after filter response, before/after compressor output), optional auto makeup toggle
• Implementation notes: Add a 'auto makeup' toggle per insert effect. When on, measure the DC offset or RMS level change of the effect (e.g., EQ curve integral). Adjust the insert's output gain to compensate. For compressor, auto makeup is already built in (makeup_db parameter). For EQ, integrate the peaking EQ curve and adjust output gain by that dB amount.

ENG-19 Lookahead delay for smooth parameter automation curves — P3 · M · 🔴 missing#

• What & why: No lookahead buffer. Parameter changes (e.g., EQ, compressor threshold) take effect immediately (0 lookahead). This can cause audible zipper noise if the parameter is tuned during an attack. SOTA DAWs offer optional lookahead (e.g., 10–50ms) to smooth parameter changes.
• SOTA reference: Cubase (PDC lookahead), Pro Tools (lookahead compressor mode), Reaper (optional lookahead in many effects)
• Depends on: Per-effect lookahead buffer (delay line); lookahead duration parameter (ms); UI toggle
• Implementation notes: Add lookahead_ms field to each effect node. When a parameter changes, interpolate the change over lookahead_ms instead of applying instantly. Use a linear ADSR to ramp parameter over the lookahead window. UI: toggle 'lookahead' per effect, set duration (0–100ms).

ENG-18 Sidechain send infrastructure (per-track sidechain to arbitrary effects) — P3 · L · 🔴 missing#

• What & why: Only the master compressor has a sidechain (key track input). No per-track sidechain routing (cannot route track X's output to compress track Y, a common EDM technique). Requires a full sidechain bus/matrix system.
• SOTA reference: Cubase (sidechain matrix), Logic Pro (compressor sidechain input), Ableton Live (MIDI/audio sidechain), Reaper (flexible sidechain routing)
• Depends on: Graph-based sidechain bus system (separate from main audio bus); per-effect sidechain input selector; UI sidechain routing matrix
• Implementation notes: Add a sidechain send per track (parallel to the audio output). In Engine, create an N×M sidechain matrix (N tracks can feed M sidechain slots). Each insert effect can optionally accept a sidechain input. For compressor, add sidechain_source: Option<usize> (track index or −1 for main). Modify Engine.process() to pump sidechain sends into a sidechain bus before effects are processed. UI: sidechain routing dropdown per effect.

MIX-2 VCA Faders (Groups) — UI Surface & Engine Integration — P0 · M · 🟡 partial#

• What & why: Mixer spec defines VCA groups (createVCAGroup, setVCAFader, etc.) but never exposed in the DAW UI or integrated into the engine's gain calculation. VCA faders multiply per-channel faders and allow grouping-without-summing (essential for controlling multiple channels at once, e.g., all drum tracks with one fader).
• SOTA reference: Ableton Live 12 (mixer groups), Logic Pro 11 (arrange groups), Bitwig Studio 5 (VCA faders)
• Depends on: Mixer.spec implementation (done in theory), daw-session state extension, dsp-graph fader gain calculation
• Implementation notes: Add VCAGroupState to daw/types.ts (id, name, memberTrackIds[], faderDb, color, muted, soloed). Extend daw-session to handle createVCA, addTrackToVCA, setVCAFader actions. Create vca-groups-panel.tsx showing VCA strips and member list. Engine: in dsp-graph track processing, fetch VCA groups containing this track, sum their faderDb offsets into computeEffectiveFaderDb (logic already in mixer.spec line 1164–1179). Test: VCA fader change cascades to all member track gains.

MIX-1 Bus/Aux Architecture UI (Create, Assign, Edit) — P0 · L · 🔴 missing#

• What & why: Euterpe lacks a UI to create auxiliary buses, assign tracks to them, or configure per-bus insert chains and sends. The dsp-graph engine supports only fixed reverb/delay aux sends; true flexible aux buses require a routing architecture. Without this, users cannot group sounds for parallel processing (e.g., reverb returns, parallel compression bus, sub-mix groups).
• SOTA reference: Ableton Live 12 (aux tracks), Logic Pro (aux channel strips), Cubase 14 (group channels)
• Depends on: Routing matrix (5), DAW session state extension
• Implementation notes: Add BusState to daw/types.ts (id, name, inserts[], sendLevel, pan, gainDb). Extend daw-session reducer to handle addBus, removeBus, routeTrackToBus, setBusGain actions. Create buses-panel.tsx similar to channel-strip.tsx. Backend: extend dsp-graph Engine to instantiate per-bus mixer nodes, sum to master. Test: ensure track → bus → master signal path is correct.

MIX-3 Flexible Signal Routing Matrix (Patch Bay) — P0 · XL · 🟡 partial#

• What & why: Euterpe's routing is hardwired: tracks → inserts → fader/pan → sends to reverb+delay → master. No UI to route track A to bus B, or bus B to master sub, or create parallel chains. The routing matrix spec exists (createRoutingMatrix, connectRoutingPoints, wouldCreateFeedbackLoop in mixer.spec) but is never surfaced or integrated into the engine.
• SOTA reference: Bitwig Studio 5 (routing matrix, CV modulation), Reaper 7 (routing GUI), Cubase 14 (routing panel)
• Depends on: Mixer.spec routing implementation, bus architecture (1), VCA groups (2), DAW session state extension, dsp-graph multi-destination routing
• Implementation notes: Create RoutingMatrixState in daw/types.ts (points: Map<id, {name, type: 'channel-out'|'bus-in'|'bus-out', channels}>; connections: [{sourceId, destId, gain, enabled}]). Add routing-matrix-panel.tsx with visual patch-bay (canvas or SVG graph). Extend daw-session to handle connectRouting, setRoutingGain, deleteConnection. Engine: dsp-graph must evaluate routing at sample time (complex: requires topological sort of routing points to avoid feedback, multi-destination buffering, per-sample latency compensation). Start with simple routing (track → bus → master); defer multiband/complex splits to Wave 3.

MIX-5 Advanced Metering Suite (True-Peak, Correlation, Goniometer, Short/Momentary LUFS, Spectral Analyzer) — P1 · M · 🟡 partial#

• What & why: Euterpe has integrated LUFS + peak hold in the master meter, but lacks true-peak (ITU-R BS.1770-4 oversampled peak detection), correlation coefficient (mono compatibility check), goniometer (stereophonic phase plot), and multi-mode loudness metering (integrated vs short-term vs momentary). These are table-stakes for professional mixing and mastering workflows.
• SOTA reference: iZotope Ozone 12 (true-peak, correlation), Reaper (built-in LUFS + true-peak + correlation), Sonible smartmetering (real-time phase correlation)
• Depends on: DSP-core metering primitives, metering UI panel, daw-session meter state extension
• Implementation notes: Add to dsp-core/src/meter.rs: TruePeakMeter (oversample 4x, track peak in oversampled domain, unroll back to reported peak), CorrelationMeter (compute Pearson correlation coefficient L/R samples), Goniometer (plot L+R vs L−R in real-time, circular or lissajous display). Meter config: add mode enum (integrated/shortTerm/momentary), window lengths per ITU-R BS.1770-2. UI: extend master metering display to tabbed views (LUFS + peak + true-peak + correlation on one tab, spec analyzer on another, goniometer as interactive 2D plot). Test: true-peak anchor (0 dBFS sine at 997 Hz should read exactly 0 dBTP), correlation of mono source = +1.0, correlation of L/−R = −1.0.

MIX-6 Automation Modes (Read, Touch, Latch, Write, Trim) — P1 · M · 🔴 missing#

• What & why: Euterpe's automation is bare: breakpoints on a timeline, linear interpolation, playback. No modes: 'read' (playback only, don't record moves), 'touch' (playback until touched, then record), 'latch' (record and stay on touched value), 'write' (overwrite from touch point forward), 'trim' (scale curve by fader delta). Without these, real-time mixing and dynamic tweaking are cumbersome.
• SOTA reference: Ableton Live 12 (automation modes), Logic Pro 11 (automation touch/latch/write), Pro Tools 2024 (automation modes)
• Depends on: DAW session state (add AutomationMode per param), automation-lane.tsx UI, daw-controller playback logic
• Implementation notes: Add AutomationMode enum to daw/types.ts (read|touch|latch|write|trim). Extend TrackState: per-automation-lane mode property. UI: automation-lane.tsx header shows mode selector (dropdown). Logic: on fader/param touch, if mode=touch, switch lane to write until release; if mode=latch, stick on last touched value; if mode=trim, record fader delta and scale existing points. Playback: mode=read ignores live param input, just plays back curve. Implementation: modify daw-controller playback loop to respect per-lane mode during fader input event handling.

MIX-7 Per-Insert-Parameter Automation — P1 · M · 🔴 missing#

• What & why: Euterpe has 6 hard-coded automation lanes (volume, pan, cutoff, reverb-send, delay-send, master-gain). No way to automate arbitrary insert effect parameters (e.g., EQ band gain, compressor threshold, delay feedback). Professional workflows require this for dynamic effect tweaking.
• SOTA reference: Cubase 14 (parameter automation per insert), Bitwig Studio 5 (multi-target automation), Reaper 7 (parameter learn + automation)
• Depends on: Automation system redesign, insert state tracking, UI automation-lane-picker
• Implementation notes: Redesign automation storage: replace hardcoded volume/pan/cutoff lanes with a map of (paramId → AutomationPoints[]). ParamId format: e.g. 'track:0:insert:2:eq:band0:gain' (track id, insert index, parameter name). UI: add '+' button in automation-lane.tsx to pick a parameter (from current track's inserts or synth patch). Extend daw-session reducer to handle addAutomationLane(trackId, paramId) and track automation playback. Engine: at playback time, interpolate every automatable param and set it on the corresponding effect node.

MIX-8 Mix Snapshots / Recall / A/B Comparison — P1 · M · 🟡 partial#

• What & why: Mixer spec defines createMixerSnapshot/recallMixerSnapshot (mixer.spec.ts line 1367–1442) but the DAW never surfaces these. Users cannot save and recall a named mix state, nor A/B two mixes. Essential for non-destructive experimentation and client feedback loops.
• SOTA reference: Cubase 12+ (mixer snapshots), Mastering.studio (mix comparison), LANDR (session compare)
• Depends on: Mixer.spec implementation (done in theory), daw-session state extension, UI snapshots panel
• Implementation notes: Add SnaphotState to daw/types.ts (id, name, timestamp, trackGains[], trackPans[], trackSends[], masterGain, masterEq[], insertParams[]). Extend daw-session reducer to handle createSnapshot, recallSnapshot, deleteSnapshot, compareSnapshots (A/B). UI: create snapshots-panel.tsx showing list (save button, delete per snapshot, recall button, compare/A/B toggle). A/B UI: show A/B labels, fade slider to morph between them, or toggle button. Test: snapshot captures all mixer state; recall restores exactly.

MIX-9 Sidechain Routing UI & Per-Effect Sidechain — P1 · M · 🟡 partial#

• What & why: Master compressor sidechain is wired (master-eq-panel.tsx line 97–125: sidechainTrackId selector). But: (1) only master comp has sidechain, no way to sidechain inserts (e.g., EQ sidechain a vocal compressor from a kick track); (2) no sidechain filter UI (highpass, bandpass to isolate the sidechain key frequency).
• SOTA reference: Ableton Live 12 (sidechain picker per insert), Logic Pro 11 (sidechain routing per effect), Cubase 14 (sidechain filter)
• Depends on: Mixer.spec sidechain (createSidechainConfig, setSidechainFilter, applySidechainFilter already defined), insert state extension, insert UI update
• Implementation notes: Extend InsertState in daw/types.ts to include optional sidechainConfig (sourceTrackId, sourceType: 'pre-fader'|'post-fader', filterEnabled, filterFreq, filterQ, filterType). Update insert-rack.tsx to show sidechain picker (dropdown: none, track A, track B, …) when hovering/clicking insert. Add sidechain-filter-editor UI (freq/Q/type sliders, small panel in insert). Engine: dsp-graph effect nodes must accept sidechain input buffer; on process, fetch sidechain signal from source track, apply filter if enabled, feed to compressor/gate/EQ sidechain input. Test: sidechain'd compressor reduces gain when key track goes loud.

MIX-23 Master Chain Multiband Processing (Crossover, Per-Band Comp/EQ) — P1 · L · 🔴 missing#

• What & why: Master chain is single-band: EQ → comp → limiter on the full mix. No multiband crossover, no per-band compression (e.g., separate comp ratios for low, mid, high). Necessary for professional mastering.
• SOTA reference: iZotope Ozone 12 (multiband comp), Cubase 14 (multiband tools), Logic Pro 11 (adaptive limiter, vintage comp)
• Depends on: Multiband DSP (crossover filters + parallel band processing), master chain state extension, UI multiband control panel
• Implementation notes: Add MultibandCompressor to dsp-core: 3 or 4 bands (low, mid, high, or low/low-mid/mid-high/high), each with independent crossover freq, threshold, ratio, attack, release. Extend master state in daw-session (enable/disable, per-band parameters). UI: create multiband-panel.tsx (crossover freq sliders, per-band comp faders). Test: multiband comp reduces intersample peaks more effectively than single-band.

MIX-4 Surround & Immersive Audio (5.1, 7.1, Binaural, Atmos) — P1 · XL · 🔴 missing#

• What & why: Euterpe is stereo-only. The mixer spec includes calculateSurroundPan (5.1/7.1 math, line 325–350 in mixer.spec.ts) but the DAW has no UI, no audio I/O for surround, and no panning law options. No Dolby Atmos, binaural, or ambisonics support. Professional mixing increasingly demands surround and immersive for film/gaming/streaming.
• SOTA reference: Logic Pro 11 (surround mixing, Spatial Audio), Cubase 14 (5.1/7.1, Dolby Atmos), Nuendo 14 (immersive audio)
• Depends on: Audio engine surround DSP (biquad, pan gains for 5.1/7.1), DAW UI for surround panning, audio I/O multi-channel support
• Implementation notes: Phase 1 (5.1 basic): Add surround panning UI (angle/distance sliders + 5.1 speaker visualization). Extend channel-strip.tsx to switch between stereo and surround pan modes. Implement pan-law selector (linear, constant-power, surround-specific laws per ITU-R BS.775). Engine: create Surround5_1Pan DSP primitive in dsp-core, mirror speaker gains to output matrix. Audio I/O: extend AudioWorklet to support 6-channel output (L, R, C, Ls, Rs, LFE). Phase 2 (Atmos): implement Dolby Atmos metadata encoding (requires licensing/SDK; likely Wave 3+). Phase 3 (binaural): real-time HRIR convolution or ambisonics-to-binaural decoder.

MIX-22 VST/AU Plugin Hosting (Third-Party Effect Plugins) — P1 · XL · 🔴 missing#

• What & why: Euterpe's insert effects are all first-party DSP (EQ, comp, reverb, etc.). No way to load third-party VST, VST3, AU, or CLAP plugins. This limits customization and lock-in risk for power users.
• SOTA reference: Bitwig Studio 5 (VST3/CLAP hosting), Reaper 7 (VST/AU/CLAP), Ableton Live 12 (Max for Live, limited VST)
• Depends on: Native plugin host (Tauri child process or sidecar), plugin IPC bridge (shared memory or network), DAW session plugin state persistence
• Implementation notes: Complex multi-phase effort: (1) VST3/CLAP host library (vst-rs or clap-rs in Rust) integrated into Tauri backend; (2) plugin discovery (scan user plugin folders); (3) IPC: spawn plugin process, pass audio buffers over shared memory or network sockets, receive rendered audio; (4) UI: show available plugins in add-insert UI, parameter UI auto-generated from plugin descriptor; (5) state save/load (serialize plugin state). Phase 1: VST3 on macOS/Windows (defer Linux). Phase 2: AU on macOS. Defer to Wave 3+. High technical risk (plugin compatibility, stability, security).

MIX-17 Pan Law Selector & Equal-Power vs Linear Pan — P2 · S · 🟡 partial#

• What & why: Euterpe uses constant-power panning (hardcoded in dsp-graph pan_gains). No UI to switch pan law (linear, constant-power, compensated, 2.5dB attenuation law, etc.). Professional DAWs let users choose per workflow.
• SOTA reference: Cubase 14 (pan law selector), Logic Pro 11 (pan law options), Pro Tools 2024 (pan law per track)
• Depends on: Channel-strip.tsx UI, daw-session panLaw state per track
• Implementation notes: Add panLaw field to TrackState (constant-power|linear|compensated|db25). UI: small dropdown in channel-strip.tsx near pan knob. daw-session: new action setTrackPanLaw(trackId, panLaw). Engine: dsp-graph pan_gains function reads panLaw and computes gains accordingly. Test: constant-power center = 0.7071 each channel, linear = 0.5 each, compensated = 1.0 each.

MIX-11 Monitor Section (Cue Mix, Dim, Mono, Talkback) — P2 · M · 🔴 missing#

• What & why: Mixer spec defines createMonitorState, setMonitorLevel, toggleMonitorDim, toggleMonitorMono (mixer.spec.ts line 1192–1270) but never wired. Professional control rooms use a monitor section to: (1) route a separate mix to headphones (cue mix), (2) dim main output for critical listening, (3) fold to mono to check mono compatibility, (4) engage talkback mic to talk to performers. Essential for professional recording/mixing studios.
• SOTA reference: Pro Tools 2024 (monitor section), Cubase 14 (control room), Logic Pro 11 (listen stack)
• Depends on: Monitor DSP primitive (processMonitor already defined in spec), UI monitor panel, audio I/O headphone output routing
• Implementation notes: Create monitor-panel.tsx (source selector: main|cue, level slider −∞ to +12 dB, dim button + level, mono button, talkback toggle). daw-session: add monitorState with config. Engine: in dsp-graph, add a second output path for monitor mix (parallel to main master out). Logic: monitor mixes from a separate cue-send bus or direct main with optional transforms (dim = −20 dB gain, mono = L/R average). Audio I/O: extend AudioWorklet or Tauri audio output to support headphone port (difficult in browser; defer to native app or assumption that headphones are on separate hardware audio interface).

MIX-12 Mid/Side Processing UI & Decode/Encode — P2 · M · 🟡 partial#

• What & why: Master width fader collapses stereo to mono via M/S (0 = mono, 1 = normal, 2 = extra wide). But no UI to decode tracks to M/S for processing (e.g., EQ the mid differently from the sides, or use M/S reverb). Mixer spec has no M/S primitives; need to build them.
• SOTA reference: Bitwig Studio 5 (M/S processing), Reaper 7 (M/S encode/decode), iZotope Ozone 12 (M/S mode per effect)
• Depends on: DSP-core M/S encode/decode primitives (not yet defined), UI toggle per insert or track
• Implementation notes: Add to dsp-core: MidSideEncoder (L/R → M/S: mid = (L+R)/√2, side = (L−R)/√2) and MidSideDecoder (inverse). UI: add 'M/S mode' toggle to insert-rack inserts or channel-strip. When enabled, convert input to M/S, apply insert (now operates on mid and side channels separately), then convert back. Alternative: add dedicated M/S decoder insert that allows chaining two insert chains (one for mid, one for side). Test: M/S encode then decode recovers original L/R within numerical precision.

MIX-13 Correlation Meter & Phase Coherence Analysis — P2 · M · 🔴 missing#

• What & why: No visual correlation meter or phase-relationship analyzer in the metering suite. Correlation coefficient (−1 to +1) indicates mono compatibility: +1 = perfectly in phase (mono-safe), 0 = uncorrelated, −1 = inverted (mono cancellation). Essential for broadcast and streaming compliance.
• SOTA reference: iZotope RX, Sonible smartmetering, Nuendo (phase correlation meter)
• Depends on: Metering suite (4), CorrelationMeter DSP, metering UI
• Implementation notes: Add CorrelationMeter to dsp-core/src/meter.rs (compute Pearson correlation coefficient between L and R channels over a sliding window, e.g. 400ms). UI: add a correlation display in the master metering panel (gauge −1…+1, color-coded: red (−1) = problem, yellow (0) = uncorrelated, green (+1) = mono-safe). Include frequency-specific correlation (per band) for goniometer-like view. Test: stereo sine = +1, inverted sine = −1, independent noise = ~0.

MIX-14 Goniometer (Stereophonic Phase Plot) — P2 · M · 🔴 missing#

• What & why: No visual goniometer or Lissajous plot to see L/R phase relationships in real-time. A goniometer plots L+R (vertical) vs L−R (horizontal) as a scatterplot, revealing phase issues and stereo balance visually. Critical for mastering and surround mixing.
• SOTA reference: Nuendo 14, iZotope RX, Sonible smartmetering
• Depends on: Metering suite, real-time sample buffering, canvas/SVG visualization
• Implementation notes: Create Goniometer DSP in dsp-core (capture recent samples, compute mid = (L+R), side = (L−R), output as (mid, side) tuples). UI: create goniometer-view.tsx (canvas 2D plot, update at ~30 fps, scatter plot of (side, mid) points, with trails/fade, radial guides at ±45° for phase angles). Integrate into metering panel as a togglable view. Test: verify circular pattern at 0° (mono), diagonal at 45° (hard L), −45° (hard R), vertical line at 90° (hard inverted).

MIX-15 Spectral Analyzer with Frequency-Band Automation — P2 · M · 🟡 partial#

• What & why: Euterpe has SpectrumView (real-time FFT bars in sampler-panel.tsx) but it's visual-only and not integrated into metering/mixing workflow. No frequency-band-specific metering (e.g., separate LUFS per octave band), no spectrogram (frequency over time), no correlation meter per band.
• SOTA reference: iZotope Ozone 12, Reaper (spectrogram), LANDR (per-band analysis)
• Depends on: FFT metering, spectrogram visualization, multi-band analysis
• Implementation notes: Extend metering suite to compute per-band LUFS (octave or third-octave bands, standard ISO 1402-1). Create spectrogram-view.tsx (vertical time axis, horizontal frequency, intensity as color/height). Integrate spectrum analyzer into master metering panel as a persistent view. Add per-band loudness targets (allow different LUFS ceilings per band for mastering). Test: verify spectral distribution of test signals (pink noise, speech, music).

MIX-18 Send Types (Pre/Post Fader, Pre/Post Insert, Expression) & Send Automation — P2 · M · 🟡 partial#

• What & why: Euterpe has two fixed send busses (reverb, delay), both post-fader. No choice of pre vs post, no expression (dynamic) sends, no per-send pan, no per-send mute. Mixer spec defines these (addSend, setSendType line 42–48 in mixer.spec.ts) but never wired.
• SOTA reference: Ableton Live 12 (send types), Cubase 14 (send pre/post), Logic Pro 11 (send configuration)
• Depends on: Mixer.spec send architecture, daw-session state extension, UI send-config panel
• Implementation notes: Extend SendLevel in TrackState: replace {reverb: number, delay: number} with a list of Send objects {id, busId, level, type: 'pre-fader'|'post-fader'|'pre-insert', pan, muted, automationPoints[]}. UI: channel-strip.tsx 'add send' button opens send config (choose bus, select type, set initial level). daw-session: new actions addSend, removeSend, setSendLevel, setSendPan, setSendType. Engine: dsp-graph must track send input point (pre vs post) and route accordingly. Test: pre-fader send unaffected by fader, post-fader send affected.

MIX-20 Batch Normalization & Loudness Matching (Track Balancing UI Polish) — P2 · M · 🟢 polish#

• What & why: Mix-assistant auto-mix is functional but UI/UX is minimal: single 'Auto-Mix' button, no preview, no undo. Users should see before/after loudness, tweak suggestions before applying, and undo if unsatisfied.
• SOTA reference: LANDR (auto-mastering UX), Mastering.studio (preview before apply), Sonible dyna:sonic (assistant UI)
• Depends on: mix-assistant-bridge.ts, mix-report-panel.tsx UI redesign
• Implementation notes: Redesign mix-report-panel.tsx: (1) separate preview stage — show suggested gains/pans without applying, (2) per-track cards showing current/suggested LUFS, peak, pan, with delta highlights, (3) 'apply all' button with confirmation, (4) per-track 'accept' checkboxes to cherry-pick suggestions, (5) undo button to revert applied suggestions. A/B toggle to hear before/after. Add confidence scores to suggestions (e.g. 'low confidence' if track is very quiet). Test: preview → apply flow is non-destructive and reversible.

MIX-21 Reference-Track Import & Loudness/EQ Matching (Full Workflow) — P2 · M · 🟡 partial#

• What & why: Euterpe has reference-match.ts (octave-band EQ matching) wired into export, but no dedicated reference-import UI in the DAW. Users cannot load a reference track into a dedicated monitor channel, A/B against it in real-time, or apply tone-match interactively.
• SOTA reference: iZotope Ozone (Reference feature), LANDR (reference matching), Mastering.studio (reference loudness/tone)
• Depends on: reference-match.ts (already exists), UI reference-monitor panel, arrangement/audio-clip support (defer real-time reference playback to Wave 2)
• Implementation notes: Create reference-monitor.tsx UI: (1) file upload for reference track, (2) load → analyze button, (3) show reference spectrum vs current master spectrum (overlay in metering panel), (4) tone-match target: 'match to reference' button that suggests EQ moves (use reference-match.ts matchEq function), (5) LUFS comparison (reference LUFS vs current). Phase 1: reference is analyzed and stored (JSON), spectrum shown as read-only. Phase 2: real-time playback requires audio clip scheduling (Wave 2+). Test: reference analysis is accurate, EQ suggestions move master spectrum toward reference.

MIX-24 Loudness History Graph & Integrated vs Short-Term Tracking — P2 · M · 🔴 missing#

• What & why: Euterpe shows real-time LUFS (single number) but no history or trend. No integrated vs short-term loudness separation for mastering workflows. Ideal graph: X = time, Y = LUFS, separate lines for integrated/short/momentary.
• SOTA reference: iZotope RX, LANDR (loudness tracking), Mastering.studio (loudness graph)
• Depends on: Metering suite (4), history buffer, UI graph component
• Implementation notes: Extend LoudnessMeter in dsp-core to track integrated, short-term (3s window), and momentary (400ms) LUFS separately. UI: loudness-history-view.tsx (line graph, X = playhead time, Y = LUFS, three series: integrated/short/momentary in different colors). Store last 5 mins of data. Playback: update graph on each frame. Test: integrated monotonically increases, short-term wiggles, momentary noisier than both.

MIX-25 Track Grouping & Folder Tracks (Organization UI) — P2 · M · 🔴 missing#

• What & why: Euterpe track list is flat (all tracks at same level). No folder/group tracks to collapse/expand related tracks (e.g., 'drums', 'vocals', 'synths' as collapsible folders). Mixer becomes unwieldy at 20+ tracks.
• SOTA reference: Ableton Live 12 (groups), Logic Pro 11 (folders), Cubase 14 (folder stacks)
• Depends on: TrackState hierarchy extension, track-list UI tree view
• Implementation notes: Add parentTrackId?: number to TrackState to form a tree. UI: track-list.tsx becomes hierarchical (indent children, toggle arrows). daw-session: new actions createFolderTrack, assignTrackToFolder, unassignTrackFromFolder. Routing: folder tracks don't make sound themselves (or route child tracks to a hidden bus, summed in the folder). Test: collapsing a folder hides/shows children in the UI.

MIX-10 Clip-Gain Editing (Per-Clip Waveform-Based Gain) — P2 · L · 🔴 missing#

• What & why: Euterpe track faders apply gain uniformly across the track. No per-clip gain envelopes (e.g., boost the chorus outro, duck the intro). Waveform editing UIs (Piano roll for MIDI, but not audio clip gain). Necessary for audio tracks and comping workflows.
• SOTA reference: Reaper 7 (clip gain envelopes), Ableton Live 12 (audio clip gain), Pro Tools 2024 (clip-level gain)
• Depends on: Audio clip model (currently absent; Euterpe uses step patterns + note clips, no audio clips in arrangement), waveform-view enhancement, daw-session clip-gain state
• Implementation notes: Add AudioClipState to daw/types.ts (id, name, sourceId, startBeat, lengthBeats, gainDb, gainAutomation?: ClipGainPoint[]). Create clip-gain-editor.tsx (overlay on waveform-view with draggable gain envelope). daw-session: new actions setClipGain(trackId, clipId, gainDb), addClipGainPoint, moveClipGainPoint. Engine: at render time, interpolate clip gain curve and apply before summing to track output. Note: requires arrangement timeline and audio clip sequencing (Wave 2 feature); defer full implementation, but prepare data model now.

MIX-16 Control Surface Integration (MIDI Learn, OSC, Hardware Faders) — P2 · L · 🔴 missing#

• What & why: Euterpe DAW is keyboard/mouse only. No MIDI CC mapping, OSC support, or hardware control surface integration. Professional mixing studios use physical faders (Novation Launchpad, Ableton Push, etc.) for tactile real-time control.
• SOTA reference: Ableton Live 12 (MIDI mapping, Push integration), Reaper 7 (MIDI learn, OSC), Bitwig Studio 5 (Controller Mapper)
• Depends on: Web MIDI API (already used for note input in web-midi.ts), OSC.js library, daw-session parameter mapping
• Implementation notes: Phase 1 (MIDI CC Learn): add 'learn mode' button in a controls panel. On press, next MIDI CC received is mapped to the selected DAW parameter (fader, pan, insert param, etc.). Store mapping in daw-session. Playback: dispatch parameter changes when matching CC arrives. Phase 2 (OSC): add OSC server (Node.js socket in Tauri backend), map /euterpe/track/0/gain → setTrackGain action. Phase 3 (hardware): create preset files for popular surfaces (Push, Launchpad, etc.). Test: MIDI CC input → parameter moves, OSC endpoint receives values.

MIX-19 Smart Mixer State Auto-Save & Undo History Pruning — P3 · M · 🟡 partial#

• What & why: Euterpe undo/redo is memory-bound (reducer snapshots on disk). Long sessions with many undo states can exhaust memory. No automatic periodic backup of mixer state or incremental save.
• SOTA reference: Ableton Live 12 (undo limit), Logic Pro 11 (auto-save), Cubase 14 (auto-backup)
• Depends on: daw-session state management, storage/indexdb, undo history strategy
• Implementation notes: Implement LRU undo history (cap at, e.g., 100 snapshots; prune oldest when exceeded). Add periodic auto-save to IndexedDB (every 30 sec or on major action). UI: add 'saved' indicator in title bar, 'restore from backup' dialog on load if last session crashed. Test: revert old snapshots, verify no memory leak after 1000+ undo actions.

FX-11 VST3/CLAP plugin hosting via Tauri sidecar (desktop only) — P0 · XL · 🔴 missing#

• What & why: Feasibility: Moderate-to-High. Tauri already wraps the browser DAW. To host third-party VST3/CLAP plugins: 1) Spawn a sidecar native process (C++/Rust) that loads the plugin DLL/dylib; 2) Send audio + MIDI to sidecar via IPC (message queue or shared memory); 3) Receive processed audio + parameter feedback; 4) Display plugin GUI (either as native window inside Tauri WebView or as a separate window). Expect ~50-100ms latency due to IPC overhead (acceptable for mixing, not for tight monitoring). This is a 'Wave 2+' feature; see nih-plug wrapping in /libs/euterpe/instrument/ for plugin wrapping model.
• SOTA reference: Bitwig Studio (VST3/CLAP hosting, sandboxed processes); Cubase (VST3/CLAP in separate threads, shared memory); Reaper (VST hosting with minimal latency via process threading); Studio One (VST3/CLAP with visual GUI mapping)
• Depends on: Tauri sidecar infrastructure (bin/plugin-host native executable); nih-plug + VST3-sys + CLAP-sys to load plugins; IPC library (e.g., tauri-plugin-window or custom stdio JSON messages)
• Implementation notes: 1) Architecture: Create tools/euterpe-plugin-host/ Rust binary (sidecar) that: loads VST3/CLAP plugins from a path, provides JSON RPC API (load_plugin, process_block, set_param, get_param). 2) Audio I/O: Use audio-rs or cpal (cross-platform real-time audio). Sidecar reads audio from shared ringbuffer (lock-free FIFO, 2-sample latency if ideal), writes processed output back. 3) IPC: Use stdio JSON messages or named pipes (Tauri supports both). 4) Parameter Automation: Track plugin parameter ranges, expose to DAW as automation targets (same as insert FX). 5) GUI Hosting: Fork/embed native window (Windows: HWnd, macOS: NSWindow) inside Tauri WebView or open separate window. 6) Plugin Discovery: Scan standard VST3/CLAP paths (~/.vst3/, ~/Library/Audio/Plug-Ins/VST3/ on macOS). 7) Failure Modes: If plugin crashes, sidecar restarts gracefully; if IPC fails, audio mutes + error logged. 8) Testing: Sandbox test plugins (e.g., MDA plugins, open-source CLAP examples). 9) UI: Add Plugin Slot UI to track insert-rack (VST3/CLAP selector, parameter knobs generated from plugin metadata, generic FX window). 10) Performance Target: <100ms round-trip latency per block (acceptable for mixing, not for triggering drums). Estimate 6-12 weeks for MVP (load + process single plugin, basic GUI).

FX-17 Arrangement timeline (track lanes, clip placement, clip scheduling, loop regions) — P0 · XL · 🔴 missing#

• What & why: Currently, the DAW has a step sequencer (16-step pattern grid) or piano roll (notes), but no timeline view showing clips placed over time (e.g., Clip 1 at 0s-8s, Clip 2 at 8s-16s, pattern repeating). SOTA: all DAWs have arrangement view (horizontal timeline with tracks, clips placed at time positions, loop region selector). This is a major UI overhaul (new view mode, drag-and-drop clip placement, loop region control).
• SOTA reference: Logic Pro (timeline with clips, loop region at bottom); Ableton Live (timeline + session view mode switching); FL Studio (playlist with patterns); Bitwig (clip-based timeline); BandLab (web timeline with drag clips)
• Depends on: Requires new data model (clips with start/end beats, per-track clip list), new view (ArrangementView.tsx), playback scheduling (engine needs to track which clips are active per frame)
• Implementation notes: 1) Add Clip interface (id, trackId, pattern/noteClip reference, startBeat, lengthBeats, muted, color). 2) Add clips: Clip[] and loopRegion: {startBeat, lengthBeats} to DawSession. 3) Implement ArrangementView.tsx (SVG/canvas-based track lanes with clips as draggable blocks, loop region as a resizable bar at bottom). 4) Extend dsp-graph Engine to support clip scheduling (which pattern/clip is active at each beat, cross-fade at boundaries). 5) Update transport to jump-to-clip when clicked, auto-loop within loop region. 6) Update session-rebuild.ts to emit per-frame active-clip state. 7) Major work; estimate 6-8 weeks for MVP (visual arrangement + basic clip triggering).

FX-1 Wavetable synthesis engine (wired to DAW) — P1 · M · 🟡 partial#

• What & why: Add a multi-engine wavetable synth with wavetable morphing, oscillator position parameter, and visual wavetable editor. SOTA: Ableton Wavetable, Bitwig Wavetable, Cubase Wavetable all allow wavetable import/creation. Euterpe has synthesizeWavetable() stub in @euterpe/synth but it is never called from the DAW. Wire it as a new Track source (Source::Wavetable), add Wavetable patch state (wavetable position, osc count, mix), and provide a visual editor for wavetable morphing.
• SOTA reference: Ableton Live 12 Wavetable (morphing over 256-sample tables); Bitwig Wavetable (multi-engine with unison); Cubase Wavetable (wavetable import from user samples)
• Depends on: @euterpe/synth synthesizeWavetable function exists; needs React UI for wavetable editor and integration into daw-session.ts reducer
• Implementation notes: 1) Create WavetablePatch interface in daw/types.ts (position, oscillatorCount, mix, harmonics array). 2) Add Source::Wavetable to dsp-graph Track source enum. 3) Port synthesizeWavetable() from @euterpe/synth/src/traditional-synth/index.ts into a real-time WavetableNode in dsp-core (frame-based processing with phase accumulator). 4) Add WavetablePanel.tsx UI with slider for wavetable position (0-1), visual waveform display, and harmonic editor. 5) Wire it into session-rebuild.ts to emit setWavetableParams commands to the engine.

FX-5 Multi-zone sampler with key/velocity mapping — P1 · M · 🟢 polish#

• What & why: Current sampler is monolithic (1 sample, start position, loop/reverse). SOTA samplers (Logic Sampler, Cubase HALion, Ableton Sampler, FL Slicex) support multi-zone keymaps (assign different samples to MIDI key ranges + velocity ranges, with per-zone root key for pitch-correct playback). Implement SampleZone model with key-range, velocity-range, root-key, per-zone fade parameters.
• SOTA reference: Logic Pro Sampler (multi-zone, per-zone ADSR, pan, transposition); HALion (unlimited zones with per-zone tuning, loop points); Ableton Sampler (chains zones by key ranges, one-shot modes per zone)
• Depends on: Sampler.rs in dsp-core exists; needs zone selection logic on note-on
• Implementation notes: 1) Extend Sampler in dsp-core to support Vec with key/velocity matching on note-on. 2) Add SamplerPatch field zones: {keyRangeLow, keyRangeHigh, velocityLow, velocityHigh, samples, rootKey, oneShot, fadeIn, fadeOut}[]. 3) Create SamplerZoneEditor.tsx showing piano key range with zone blocks, velocity ranges below, drag-to-adjust bounds. 4) Support sample upload per zone or drag multi-zone SFZ/XML imports (read-only for MVP). 5) Implement pitch-correct playback (resample to note distance from root key).

FX-8 Macro knobs (per-track morphing controls for synth + FX) — P1 · M · 🔴 missing#

• What & why: Add N macro knobs per track (typically 8-16) that morph multiple synth/FX parameters simultaneously. Each macro binds to 1+ parameters with per-binding depth. Similar to FL Studio's 16 macro knobs, but in a simpler form. Allows users to create expressive, unified sound morphing without explicit modulation matrix. Light-weight alternative to full modulation matrix.
• SOTA reference: FL Studio macro knobs (16 per track, each can modulate unlimited parameters); Bitwig Grid macro controls; Cubase Smart Controls
• Depends on: Requires daw-session reducer + UI to define macro bindings; shares modulation infrastructure with modulation matrix
• Implementation notes: 1) Add MacroKnob interface (id, label, value: 0-1, bindings: {trackId, insertId, paramName, depth}[]). 2) Store 8 per-track macros in TrackState. 3) In session-rebuild, compute per-block macro value → apply to each binding with per-binding depth multiplier. 4) Create MacroKnobPanel.tsx with 8 sliders + binding editor (click binding UI to select target parameter + set depth). 5) Persist in project JSON.

FX-10 Effect and synth preset library (factory + user save/load) — P1 · M · 🔴 missing#

• What & why: No preset UI exists. Implement: 1) Factory preset browser (per-synth + per-FX, searchable, 20+ presets per device); 2) User save/load preset UI (save current patch, name it, load from browser); 3) Preset file format (JSON + metadata: author, tags, LUFS target). SOTA: Logic has 1000+ factory presets, FL Studio 5000+, Ableton Live 2000+. Euterpe has 0.
• SOTA reference: Logic Pro (1000+ presets, nested browser); FL Studio (5000+ presets, quick-load); Ableton Live (2000+ presets, tagging); Splice Sounds integration (search presets by tag/BPM)
• Depends on: Preset JSON schema + browser UI; no DSP changes required
• Implementation notes: 1) Create PresetFile interface (name, author, tags, description, synthesisType: 'poly-synth'|'wavetable'|..., patchData: SynthPatch|InsertState, lufsTarget?: number). 2) Implement PresetLibrary class (search, filter by type/tags, load/save). 3) Bundle ~20 factory presets per device type (e.g., 20 Polysynth presets, 20 EQ presets, 20 reverb presets) in public/presets/ JSON files. 4) Create PresetBrowser.tsx panel with search bar, tag filter, preview (play 2-bar loop with preset), Save/Load buttons. 5) On preset load, dispatch actions to set synth patch or FX params. 6) Store user presets in browser localStorage (indexed) or cloud (future). 7) Add metadata (author, creation date) to factory presets for transparency.

FX-2 FM synthesis engine (wired to DAW) — P1 · L · 🟡 partial#

• What & why: Add DX7-style FM synthesis (6 operators, 32 algorithms, per-operator ADSR, modulation index). Euterpe has synthesizeFM() stub with all 32 DX7 algorithms defined as constants (DX7_ALGORITHMS) but is never called. Implement real-time FM node and integrate into DAW track sources. This is industry-standard (Sytrus in FL, Operator in Ableton, Logic, Cubase).
• SOTA reference: FL Studio Sytrus (32 algorithms, visual algorithm editor); Ableton Operator (6-op DX7-style); Logic Retro Synth FM mode
• Depends on: @euterpe/synth DX7_ALGORITHMS constant exists; requires Rust DSP implementation (phase accumulators, per-operator envelopes, algorithm routing)
• Implementation notes: 1) Implement FmOperator struct in dsp-core (frequency ratio, amplitude envelope, phase accumulator, feedback) and FmSynthEngine with algorithm routing. 2) Create FMPatch interface (operators: [attack/decay/sustain/release, frequency-ratio, amplitude per op], algorithm: 1-32, modulation-index). 3) Add Source::FM to dsp-graph Track enum. 4) Create FMPanel.tsx with algorithm selector (visual diagrams), per-operator envelope controls (4x6 grid of ADSR sliders), modulation index slider. 5) Implement real-time FM processing in a FMNode with per-block operator synthesis and algorithm-based feedback/modulation.

FX-3 Granular synthesis engine (wired to DAW) — P1 · L · 🔴 missing#

• What & why: Wire @euterpe/synth synthesizeGranular() into the DAW as a Source::Granular track. Requires grain buffer, grain size (ms), density (grains/sec), scatter (randomness), playback position. Missing from Euterpe; SOTA apps (Cubase Padshop, Bitwig Sampler in granular mode, Logic Alchemy granular) make this a core instrument.
• SOTA reference: Cubase Padshop (dedicated granular synth); Bitwig Sampler (granular mode with grain controls); Logic Alchemy (granular engine + transposition, timbre)
• Depends on: @euterpe/synth synthesizeGranular() exists; needs real-time Rust implementation with frame-based grain windowing
• Implementation notes: 1) Implement GranularEngine in dsp-core with grain buffer, window function generator, and scatter timing. 2) Create GranularPatch (grain-size-ms, density, scatter, source-position, window-type: hanning/hamming/blackman). 3) Add Source::Granular to dsp-graph. 4) Create GranularPanel.tsx with grain size dial, density (grains/sec) slider, scatter randomness, waveform viewer of source buffer. 5) Implement real-time grain extraction + windowing via a GranularNode in dsp-graph/src/effect.rs, or fold it into a Source processor (cleaner). Use COLA-normalized overlapping windows to avoid artifacts.

FX-7 Modulation matrix (unlimited depth cross-parameter LFO/envelope/MIDI routing) — P1 · XL · 🔴 missing#

• What & why: Add a modulation matrix UI + backend supporting unlimited LFO/MIDI/envelope → FX parameter routings. Current Euterpe has 1 LFO per synth (on cutoff only) and 6 automation lanes (volume, pan, cutoff, 2x sends, master gain). SOTA (Bitwig Grid, Cubase modulation matrix, FL macro knobs) allow routing any control source to any parameter with depth/mode. Implement a visual modulation editor (drag source to target, set depth/curve/range).
• SOTA reference: Bitwig Studio Grid (unlimited modulation routing, visual patcher); Cubase modulation matrix (unlimited routings, per-slot range clipping); FL Studio macro knobs (16 per track, each morphs multiple FX parameters)
• Depends on: Requires daw-session reducer changes (store modulation mappings), dsp-graph updates (per-block LFO/envelope evaluation fed into parameter compute), and complex UI (visual patcher or matrix grid)
• Implementation notes: 1) Add ModulationRoute interface (sourceId: 'lfo'|'env'|'midi', sourceParam: string, targetTrackId, targetParamPath, depth: -1..1, curve: 'linear'|'exp'|'log', range: [min, max]). 2) Extend DawSession to hold modulation[] array. 3) In session-rebuild.ts, emit engine commands to set modulation routings (new EngineCommand type 'setModulation'). 4) Implement LFO/envelope evaluation per block in dsp-graph (stateful LFO with phase accumulator, per-voice envelope tracking). 5) Create ModulationMatrix.tsx as a 2D grid or visual patcher showing sources (columns) vs targets (rows), click-drag to create routes, right-click for depth/curve. 6) Support 50+ simultaneous modulation routes (practical limit for real-time).

FX-19 MIDI humanization and micro-timing adjustments — P2 · S · 🟢 polish#

• What & why: Pattern/clip notes have quantized (on-grid) timing. Add 'humanize' parameter to add random timing offsets (±swing, micro-timing offset per note) + velocity variation. SOTA: DAWs have humanization presets (swing 10%, micro-timing 5ms random, etc.). Euterpe has humanizeVelocities() in pattern-gen.ts but no micro-timing. Add randomTiming parameter to patterns, apply in engine.
• SOTA reference: Ableton Live (Humanize MIDI effect, parameter per aspect: timing, velocity, note length); Cubase (Humanize MIDI plugin); Logic (Arpache humanization); Quantize plug-in settings
• Depends on: humanizeVelocities() exists; needs timing offset logic in dsp-graph note triggering
• Implementation notes: 1) Add humanizationAmount: 0-1 to PatternState. 2) In dsp-graph note-trigger logic, apply random timing offset (±humanizationAmount * swing-range, e.g., ±50ms) per note. 3) Add humanization slider to step-grid UI. 4) Test against Ableton Live humanized patterns for feel similarity.

FX-4 Additive synthesis engine (wired to DAW) — P2 · M · 🔴 missing#

• What & why: Wire @euterpe/synth synthesizeAdditive() into DAW. Euterpe has stub with per-partial frequency/amplitude/phase. Add a visual harmonic editor showing partials as a spectrum, allow drag-and-drop editing of harmonic content. Low priority but rounds out synthesis suite.
• SOTA reference: Logic Alchemy (additive mode); specialized additive synths like Blue (Camel Audio, legacy); Harmor in FL Studio (harmonic re-synthesis via FFT analysis)
• Depends on: @euterpe/synth synthesizeAdditive() exists; needs Rust frame-based oscillator summation
• Implementation notes: 1) Create AdditivePatch (partials: {frequency, amplitude, phase}[]). 2) Implement AdditiveNode in dsp-graph that sums sinusoids per block. 3) Add AdditivePanel.tsx with visual harmonic spectrum editor (bars, drag-to-edit amplitudes, shift frequencies via transpose knob). 4) Support 10-32 harmonics per patch.

FX-6 Formant synthesis engine (vowel morphing) — P2 · M · 🔴 missing#

• What & why: Wire @euterpe/synth synthesizeFormant() and interpolateVowels() into DAW for vowel-morphed synthesis. Useful for vocal synthesis, vocal pads. Requires formant filter bank (3 resonances per vowel A/E/I/O/U, pre-computed Peterson-Barney data in @euterpe/synth already). Add joystick-style vowel morphing UI.
• SOTA reference: Logic Vocal Synth (includes formant vocoder); Sytrus in FL (formant operator mode); iZotope VocalSynth (formant shaping)
• Depends on: @euterpe/synth VOWEL_FORMANTS constant and synthesizeFormant() exist; needs real-time formant filter bank
• Implementation notes: 1) Create FormantPatch (vowel: 'A'|'E'|'I'|'O'|'U', fundamental-hz, morphing-x/y for vowel-blending). 2) Implement FormantNode in dsp-graph with three parallel bandpass biquads (F1, F2, F3 per vowel). 3) Extend glottal source generation (sawtooth) with formant filters applied per block. 4) Create FormantPanel.tsx with 5-button vowel selector or 2D morphing pad (X=vowel continuum, Y=open/close).

FX-13 Drum synthesis engine (kick/snare/tom/cymbal synthesis) — P2 · M · 🔴 missing#

• What & why: SOTA DAWs (Bitwig Drum Synth, Logic Drum Synth, FL Studio drum synths like Kick/Clap designer) include dedicated drum synthesis. Euterpe has 0. Implement basic synthesized drum kits: 1) Kick (sine + envelope, sub oscillator); 2) Snare (noise + HPF + envelope, transient shaper); 3) Tom (pitched noise, shortening pitch envelope); 4) Cymbal (filtered noise, metallic reverb tail). This rounds out a beginner-friendly device suite.
• SOTA reference: Bitwig Drum Synth (visual drum synthesis); Logic Drummer + Drum Synth; FL Studio Kick/Clap designer; Native Instruments Maschine (drum synth library)
• Depends on: Requires noise oscillator (already in Waveform::Noise), pitch envelope, transient shaping (already have TransientShaper)
• Implementation notes: 1) Create DrumPatch interface (drumType: 'kick'|'snare'|'tom'|'cymbal', pitch, decay, tone, amount parameters per type). 2) Implement drums in dsp-core/src/drum.rs with per-drum synthesis: kick = sine + sub osc + ADSR, snare = noise + HPF + ADSR + transient, etc. 3) Add Source::Drum to dsp-graph. 4) Create DrumPanel.tsx with drum-type selector + type-specific parameters. 5) Support 1-drum-per-track or multi-drum Drum Rack (future). 6) Test against Logic Drummer kick/snare/tom sounds for quality bar.

FX-15 Arpeggiator expansion (multi-mode, pattern sequencing, gate control) — P2 · M · 🟢 polish#

• What & why: Euterpe has basic arpeggiator (up/down/updown/random + octaves + gate). SOTA: Bitwig Grid, Cubase have complex arpeggios with pattern sequencing, chord memory, randomization per note. Extend Euterpe's arp to: 1) Pattern sequencing (custom note order, not just up/down); 2) Note probability (skip random notes); 3) Velocity curve (accent pattern); 4) Swing per arp step. Already wired but minimal.
• SOTA reference: Bitwig Arp (6 modes + chord memory); Cubase Arpache (pattern sequencing, polyrhythmic); Logic Arpeggiator (complex patterns, MIDI learn)
• Depends on: Arp.rs exists in dsp-graph; UI in daw-session.ts
• Implementation notes: 1) Extend ArpState (add patternSteps: number, velocityPattern: number[], probabilityPattern: number[], swingPattern: number[]). 2) Expand ArpPanel.tsx to show 16-step pattern editor (per-step selector for note offset, velocity, probability). 3) Modify dsp-graph Arp to apply per-step modulation (velocity swing, probability gating) on each note emission. 4) Allow saving arp patterns as presets.

FX-9 Additional built-in effects (saturator, dynamic EQ, spectral effects, vocoder, resonance shifter) — P2 · L · 🔴 missing#

• What & why: Current 10 effects are foundational but SOTA DAWs have 40-70. Add: Saturator (soft-clip with tone/drive/mix, like distortion but smoother), Dynamic EQ (per-band dynamic range expansion/compression), Spectral Gate (FFT-based noise gate), Spectral Delay (FFT-domain delay for inharmonic effects), Vocoder (STFT-based filtering via reference signal), Resonance Shifter (harmonic content shifter). These round out a professional effects suite.
• SOTA reference: Logic Pro (Spectral Gate, Spectral Resynthesizer, Vocoder, SubBass enhancer); iZotope Ozone (Dynamic EQ, Spectral Shaper); Cubase (Spectral Compressor, Spectral De-Esser); Valhalla supermassive (resynthesis-based reverb, inspiration for spectral effects)
• Depends on: Requires STFT (Short-Time Fourier Transform) + FFT for spectral effects; Saturator is pure DSP (1 line of code + 2 params); Vocoder needs envelope follower on reference input
• Implementation notes: 1) Saturator: Simple soft-clip (tanh or SOFTEN curve) with tone filter (single-pole LP to shape harmonics), add to dsp-core/src/waveshaper.rs variant. 2) Dynamic EQ: Implement BiquadCompressor (threshold, ratio, attack, release per band); 5-band version with independent dynamics. Store in dsp-core/src/eq.rs or new dynamic-eq.rs. 3) Spectral Gate: Implement STFT (Hanning-windowed FFT, 50% overlap, COLA-normalized), per-bin magnitude → threshold gate, inverse STFT. ~300 LOC in new src/spectral-gate.rs. 4) Spectral Delay: Implement frequency-dependent delay (low freqs delay more), via STFT + per-bin delay buffers. 5) Vocoder: STFT on both input + reference signal, freeze reference magnitudes + apply to input phases. 6) Resonance Shifter: STFT, shift bins up/down (preserving mag/phase), inverse STFT. 7) Add InsertKind variants, UI sliders in insert-rack.tsx, test against known-correct DSP (e.g., Saturator should smooth hard clipping artifacts).

FX-14 Sampler loop slicing and beat-grid snapping (Slicex-style) — P2 · L · 🔴 missing#

• What & why: Current sampler loads a single sample, can reverse/loop it, but cannot slice it into beats. SOTA samplers (FL Slicex, Ableton Sampler, Logic Sampler, Cubase Groove Agent) detect transients, auto-slice to grid, allow per-slice note mapping, time-stretch per slice. This is complex but essential for beat-based producers. Implement: 1) Transient detection (onset peaks in STFT energy); 2) Auto-slice to grid (16/32/64 slices); 3) Per-slice MIDI mapping (slice 0 = C1, slice 1 = C#1, etc.); 4) Time-stretch per slice (resampling, simple phase vocoder).
• SOTA reference: FL Studio Slicex (auto-detect, drag-to-adjust slices, per-slice time-stretch); Ableton Sampler (Complex Pro time-stretching, warp grid); Logic Sampler (Alchemy-like time-stretching); Cubase Groove Agent (audio-to-MIDI slicing)
• Depends on: Requires STFT/onset detection (similar to audio-analysis.ts spectral-flux autocorrelation logic); time-stretch is phase-vocoder (Euterpe has time_stretch primitive in dsp-core)
• Implementation notes: 1) Implement onset detection in audio-analysis.ts (spectral-flux + peak-picking, returns timestamps of transients). 2) Auto-slice function: divide sample by onset peaks, or to fixed grid (1/16 beat at current tempo). 3) Create SlicedSampler type with slices: {startSample, endSample, rootNote, timeStretchRatio}[]. 4) Extend sampler-panel.tsx to show waveform + slice markers (drag-to-adjust), per-slice note assignment, per-slice tempo knob. 5) On note-on, trigger the mapped slice; apply per-slice time-stretch if tempo changes. 6) Test with breakbeat samples (4 bars of drum break) — should auto-slice to 16 hits, play at original tempo when stretched to current BPM.

FX-18 Take comping (multi-take recording, lane selection, non-destructive comp) — P2 · L · 🔴 missing#

• What & why: Record 5 takes of a bass line, see all 5 in separate lanes, swipe across to select which take plays per region. SOTA: Logic Pro (comp track with auto-comp), Ableton Live (session view clips), Studio One (take lanes). Essential for live recording workflows. Requires: multi-take recording per track, lane display, crossfade blending.
• SOTA reference: Logic Pro (comp track, auto-comp via threshold); Studio One (take lanes with drag-to-select); Reaper (take lanes built-in); Pro Tools (comp playlists)
• Depends on: Requires recording infrastructure (clip-recorder.ts exists) + lane UI + crossfade blending logic
• Implementation notes: 1) Extend Clip to support takes: {clipId, takes: {takeId, audio/pattern}[]}. 2) Create TakeLane.tsx UI showing horizontally stacked waveforms, click-drag to select which take per region. 3) Implement cross-take crossfading (50ms fade at take boundary). 4) Extend recording (clip-recorder.ts) to append new takes to existing clip. 5) Persist takes in project JSON. Estimate 3-4 weeks MVP.

FX-12 Plugin GUI visual editor (Tauri desktop shell feature) — P3 · L · 🔴 missing#

• What & why: Once VST3/CLAP hosting exists, allow users to design custom plugin GUI layouts (drag-and-drop parameter widgets, reorder, resize). Similar to Studio One 7's 'Macro Control' feature or Cubase's 'Quick Controls'. This is a lower-priority enhancement on top of basic plugin hosting.
• SOTA reference: Studio One 7 (visual macro control design); Cubase (Quick Controls layout editor); Bitwig (Grid visual patcher for custom FX)
• Depends on: Requires VST3/CLAP hosting + parameter metadata extraction from plugins
• Implementation notes: 1) Create PluginGUILayout interface (slots: {paramId, x, y, width, height, widgetType: 'slider'|'knob'|'button'}[]). 2) Build PluginGUIEditor.tsx (drag-and-drop canvas, parameter inspector, layout save/load). 3) On plugin load, parse plugin parameter descriptors and auto-generate grid layout; user customizes. 4) Persist layout in project JSON. Low priority; only after hosting MVP works.

FX-16 Audio inpainting (context-aware fill/regeneration of waveform regions) — P3 · XL · 🔴 missing#

• What & why: DAW allows selecting a waveform region in sampler and regenerating it (AI-powered or harmonic-match based). Similar to iZotope RX 'Spectral Repair', but for creative use (replace silence with harmonic texture, extend resonance, etc.). This requires backend music generation (BFF) or on-device neural model. Mark as Wave 2+ (depends on MRT2 native deployment).
• SOTA reference: iZotope RX 'Spectral Repair' (hand-draw replacement); LANDR mastering suggestions (AI-based gain/EQ); Adobe Audition (content-aware fill for audio); future: audio-aware neural in-fill
• Depends on: Requires MRT2 native inference (sidecar bridge not yet deployed) or BFF audio generation endpoint (music-executor.ts exists but not integrated into DAW)
• Implementation notes: 1) Once MRT2 native works, add a 'Regenerate Selection' button to sampler panel. 2) Extract audio region to STFT, compute context from surrounding frames (spectrum, pitch, chroma), send to MRT2 + BFF for in-fill candidate. 3) Return regenerated audio, blend with original via crossfade. 4) Requires audio analysis + conditioning framework (MRT2 session controller exists in @euterpe/realtime-gen). 5) Low priority; only after core synths + VST hosting work.

AI-3 SOTA neural stem separation (Demucs/HT-Demucs/AudioShake bridge) — P0 · L · 🟢 polish#

• What & why: DAW currently uses classic HPSS (median-filter STFT) for harmonic/percussive split, ~10-15 dB lower quality than HT-Demucs (6-stem, ~0.5 dB error). SOTA stem separation libs exist as stubs (@euterpe/samples/stem-separation-sota has algorithms) but no provider integration (ONNX model loading, inference, phase-aware reconstruction).
• SOTA reference: HT-Demucs (2024, Facebook Research, 6-stem: vocals/drums/bass/other/piano/guitar, GPU ~5 sec per 5-min track, browser via ONNX.js or server), AudioShake (commercial, 8+ stems, <30s latency cloud), Moises (commercial, real-time steering on 4 stems).
• Depends on: SOTA stub (stem-separation-sota.ts), ONNX Runtime JS (web), or server-side inference (Flask/FastAPI), provider auth (Moises API key or self-hosted), sampler-panel.tsx split stems UI (ready to call new logic)
• Implementation notes: Choice A: Client-side ONNX. Download HT-Demucs v4 ONNX model (~350MB, cache), integrate onnxruntime-web into euterpe-studio-web. In sampler-panel 'Split Stems' button: pass mono/stereo PCM → stem-separation-sota.separateEightStems() stub → replace with real ONNX inference. Requires WASM offloading or Web Workers to avoid blocking UI. Choice B: Server-side. POST audio to BFF /v1/stems/separate (new route), invoke Moises API or local Demucs container, return 6 WAV stems, import each as a new audio track. Recommend B for MVP (single round-trip, no client WASM bloat). Add stem import flow in sampler-panel: 'Separate (SOTA)' → POST to BFF → poll for status → import 6 new tracks with names (vocals-lead, drums, bass, etc.).

AI-1 Cloud music generation import (Suno/Udio→track) — P1 · M · 🟡 partial#

• What & why: DAW can stream live MRT2 realtime generation into a track, but cannot enqueue async Suno/Udio jobs, poll for completion, download finished audio, and import as a new audio clip on a specified track. BFF music-executor exists but no DAW UI flow (enqueue dialog, job list, import button).
• SOTA reference: Suno v4 and Udio both expose async job queue; Splice and BeatStars integrate job polling + track import. SOTA allows user to hit 'generate' → wait → click 'import to track' with one-click workflow.
• Depends on: BFF music-executor.ts + music-provider-env.ts (exist), DAW UI (needs JobList + ImportClipDialog components), job polling poller (needs React hook), clip creation action (already wired)
• Implementation notes: Add /apps/euterpe-studio-web/src/components/daw/music-generation-dialog.tsx: enqueue Suno/Udio via BFF /v1/generation/jobs/music, poll /v1/generation/jobs/:jobId every 2s (exponential backoff), decode audio once complete (MP3/WAV), dispatch addAudioClip action with generated audio. Require OSHUN_MUSIC_PROVIDER_API_KEY env check in music-provider-env.ts. Add 'Generate Music' button to toolbar + track context menu.

AI-2 Realtime MRT2 audio composition (generator output → master mix) — P1 · M · 🟡 partial#

• What & why: Realtime generator streams audio into a hidden generator track but does NOT mix into the master bus during playback/export. Stream arrives at audioSink in generator-panel.tsx, mixed into track's output, but live generation audio is isolated. Must wire generator binary frames into the main AudioWorklet engine as a live source.
• SOTA reference: Suno/Udio realtime mode allows text/MIDI steering and live playback of the generated audio mixed with accompaniment. Splice Live Mix allows similar streaming composition.
• Depends on: realtime-mrt2.ts (pure state machine, ready), generator-panel.tsx (WebSocket + audio decode, ready), AudioWorklet bridge in @euterpe/audio-engine-web (needs new Source::RealtimeStream variant), engine dsp-graph (needs per-block live source scheduling)
• Implementation notes: In dsp-graph Engine, add Source::RealtimeStream { sampleRate, channels, readNextBlock() } alongside existing Synth/Sampler. generator-panel.tsx maintains a ring-buffer (2048 samples, stereo) of incoming MRT2 frames, readable by the engine on each block. Sync playhead to generator's stream clock via a monotonic frame counter. Export must skip realtime source or render it separately post-session (bake realtime into a new audio clip).

AI-8 Text-to-music generation (full prompt → DAW clip, not realtime) — P1 · M · 🟡 partial#

• What & why: Realtime MRT2 exists (5–30 sec live steering), but DAW lacks one-shot text-to-music (write prompt → generate full 30–120 sec track → import as clip). Suno/Udio backend stubs exist but prompt normalization + scheduling are missing.
• SOTA reference: Suno v4 (full track from prompt, 32 sec, quality A), Udio (90–120 sec, quality B+), Soundraw (open-form composition + stem separation).
• Depends on: text-to-music.ts module (prompt parsing, real), music-executor.ts (enqueue logic, exists), music-provider-env.ts (auth, exists), music-generation-dialog.tsx (UI, needs build), BFF job polling (needs async/await hook)
• Implementation notes: Wire text-to-music parsing into a 'Generate Track' dialog (separate from realtime generator panel). User enters prompt, selects key/tempo/duration, hits 'Generate'. Normalize prompt via @euterpe/genesis/text-to-music (enhance, extract key/tempo/energy). POST to /v1/generation/jobs/music { prompt, duration, key, tempo, callback_url }, poll /v1/generation/jobs/:jobId. On completion, download audio (MP3 or WAV), auto-create new audio clip + track, import. Add to UI: toolbar 'Generate' button or sidebar 'New Track > Generate from Text'.

AI-4 Polyphonic pitch correction (Melodyne-class) — P1 · XL · 🔴 missing#

• What & why: Euterpe has polyphonic transcription (spectral peak-picking → piano-roll clip), but no real-time or post-hoc pitch correction. SOTA tools (Melodyne, iZotope RX) offer formant-preserving polyphonic pitch-shift + time-scale with per-voice cent control. Needed for vocal/melodic track cleanup and arrangement without manual editing.
• SOTA reference: Melodyne (industry standard, real-time per-voice pitch/time, formant lock, $80–300), iZotope RX Advanced (spectral pitch-shift, vocal isolation, phase alignment), Celemony Melodyne ARA integration (DAW-native).
• Depends on: Voice transcription (spectralPolyphonic in audio-analysis.ts exists, tested), pitch correction algorithm (YIN-based refinement or ML model), audio backend (WASM or server), sampler-panel.tsx or new track-effects panel
• Implementation notes: Add @euterpe/vocal-processing/pitch-correction module. For each voiced frame, estimate cent deviation from target pitch (user-provided or auto-suggest nearest scale degree). Apply phase vocoder or PSOLA (Pitch Synchronous Overlap-Add) to shift without time-dragging. Client-side approach: WASM phase vocoder (complex, ~2KB WASM), server approach: POST audio chunk → Flask Librosa PSOLA → return corrected WAV. Start with monophonic mode (single voice per track) for MVP, extend to polyphonic via voice assignment. Wire into sampler-panel 'Tune' button or new track-effects menu.

AI-11 Arrangement timeline (clip placement, looping, per-clip automation) — P1 · XL · 🔴 missing#

• What & why: Euterpe's UI is piano-roll + step-grid only; no horizontal timeline view for multi-clip arrangement, pattern chaining per track, or clip-level scheduling (clip A at bar 1–4, clip B at bar 5–8). Core Engine supports pattern sequences and track mixing, but UI lacks visual representation.
• SOTA reference: Ableton Live (Session + Arrangement view, clip placement + follow-actions, looping), Logic Pro (piano-roll arranger, MIDI region stacking), FL Studio (pattern chain editor, clip slots), standard DAW feature.
• Depends on: daw-session.ts reducer (needs addClip, removeClip, moveClip, setClipLoops actions), daw-controller.ts (wired actions), new ArrangementView React component (timeline grid, SVG/Canvas clip rendering), track model extension (clips array per track instead of single pattern)
• Implementation notes: Redesign daw-session.ts Track model: { clips: Clip[] } where Clip = { id, startBar, lengthBars, sourceId, noteClip?, audioClip? }. ArrangementView.tsx: horizontal timeline (bars 1–N on x-axis), tracks on y-axis, draggable clip rectangles. Add arrange.ts helpers: clipAtBar, mergeClips, splitClip. MVP: no follow-actions or clip effects, just placement + looping + playhead follow. Estimated 3–4 weeks for pixel-perfect, accessible timeline.

AI-14 On-device neural inference bridge (Candle/ONNX/CoreML wiring) — P1 · XL · 🟡 partial#

• What & why: Euterpe's realtime-engine crates (mrt2-core, mrt2-engine, mrt2-native) exist with inference config + device capability discovery, but no live Candle/ONNX/MLX forward-pass bridge. WASM target is built but untested on real models. Desktop native runtime is nih-plug wrapped but not shipped/tested.
• SOTA reference: Apple CoreML (on-device GPU, Xcode build toolchain), Meta Candle (Rust, browser WASM), ONNX Runtime JS (web, CPU + WASM), TensorFlow Lite (mobile, lite models), Intel OpenVINO (x86, optimized FP16).
• Depends on: mrt2-core + mrt2-engine (Rust crates, ready), dsp-wasm target (ready), mrt2-native nih-plug (ready), AudioWorklet bridge (@euterpe/audio-engine-web), model weights (HF Hub or bundled)
• Implementation notes: For browser MVP: Download Magenta Realtime ONNX (~50MB, quantized), integrate onnxruntime-web into euterpe-studio-web bundle. Generator-panel.tsx: instead of WebSocket to BFF, invoke local ONNX forward pass in a Web Worker each block (encoder input = text tokens + MIDI notes + live audio conditioning). Streaming output to AudioWorklet sink. Latency: ~100–300 ms per 512-sample block (depends on device). For desktop (Tauri): Replace realtime-mrt2.ts WebSocket with native IPC to mrt2-native VST plugin (sidecar child process), share model weights via memory-mapped file, same conditioning input/output contract. Requires shipping model weights (~200–500MB download on first run). Start with server-side realtime (no on-device changes) as MVP, defer client-side inference to Wave 3.

AI-18 LLM copilot action validation (tool-use expansion beyond 23 types) — P2 · S · 🟢 polish#

• What & why: Copilot (copilot.ts) whitelists 23 DawAction types for tool-use safety, covering transport, track management, gain/pan, tempo. SOTA copilots (Logic Pro, Splice) expose 50+ actions (complex FX parameter tweaks, EQ band moves, pattern edits, automation). Euterpe is deliberately conservative but feels limited.
• SOTA reference: Logic Pro Smart Controls (user-defined macros bound to parameters), Splice Sound Assistant (parameter suggestions for 30+ plugins), BeatStars (broad copilot action support).
• Depends on: copilot.ts (23-type whitelist + validation), daw-session.ts (extend action union), Claude API (model already calls tool-use)
• Implementation notes: Audit copilot.ts COPILOT_ACTION_TYPES. Expand to 40+ types: setInsertFxParam { trackId, insertIndex, paramName, value }, setAutomationLane { trackId, laneType, breakpoints }, setPatternStep { trackId, patternIndex, stepIndex, note?, velocity?, probability? }. For each new type, add validation (min/max ranges, enum checks). Test with Claude Opus (4.5/4.6) on 10 sample prompts per action type. Document in COPILOT_SYSTEM_PROMPT. No schema change needed.

AI-9 Lyric/vocal production copilot (melody → lyrics + vocal arrangement) — P2 · M · 🔴 missing#

• What & why: Euterpe can generate melody from chords, but lacks lyric generation from melody shape or vocal arrangement suggestions (doubling, harmonies, octaves). Text-to-singing stub exists but not integrated with melody gen or vocal track workflow.
• SOTA reference: Splice (lyric suggestion from melody), Soundtrap/BeatStars (AI vocal arrangement), OpenAI Jukebox (melody + lyric conditioning, research).
• Depends on: genesis melody-gen (ready), text-to-singing.ts (stub), voice cloning (stub), vocal-processing (stubs)
• Implementation notes: Add UI flow: right-click melody clip → 'Generate Vocals'. Modal asks for style (whisper, rap, operatic, spoken) + gender + tone. Call @euterpe/genesis/text-to-singing with melody notes → lyric/phoneme hints (via rhyme dictionary + syllable meter). POST to BFF /v1/voice/generate { melody_notes, lyrics, style, voice_id } → render vocal audio clip on new vocal track. Requires voice model provider (ElevenLabs API or local RVC). Start with placeholder placeholder-voice (deterministic pitch-tracked hum) for MVP.

AI-13 Beat/sample generation from text (Splice/Soundraw-class) — P2 · M · 🔴 missing#

• What & why: Beat-gen and sample-gen stubs in @euterpe/samples exist but no provider integration. Text-to-music generates full tracks, but users want quick loop beds (4/8/16 bar drums + bass in key/tempo) without full track context.
• SOTA reference: Splice (AI loop bed generation from mood/key/BPM), Soundraw (Suno backend, loop generation + stem export), BeatStars (drum kit + bass generation).
• Depends on: beat-gen.ts and sample-gen.ts (stubs to replace or wrap), text-to-loop conditioning (stem-separation-sota.ts conditionTextToLoop is ready), music provider (Suno/Soundraw API), BFF /v1/loop/generate endpoint (needs build)
• Implementation notes: Add '+Generate Loop' context action on sampler track (or new button in sampler-panel). Modal: 'Loop Bed Generator' → input prompt (e.g., 'lo-fi hip hop drums + bass in Em, 100 BPM, 8 bars'), parse via conditionTextToLoop, POST to BFF /v1/loop/generate { conditioning, key, bpm, bars }, Suno/Soundraw API synthesizes, returns audio. Import as looping sample clip on track. Fallback: Splice Sound API if available (commercial access required).

AI-15 Format masters (per-platform LUFS + metadata tags) — P2 · M · 🔴 missing#

• What & why: Euterpe normalizes to LUFS target (−14 Spotify, −16 Apple, etc.) but does NOT export per-platform masters: no YouTube (−14 LUFS, limiting), no Apple Music (−16 LUFS + true-peak, metadata), no TikTok (−16 LUFS, short-form), no club (−6 LUFS, no limiter). Mastering-chain and format-masters stubs exist but not wired.
• SOTA reference: LANDR (auto-gen masters for 40+ platforms, metadata tags, auto-delivery), iZotope Ozone (mastering presets per platform, true-peak clamping), Splice (per-format masters on demand).
• Depends on: loudness-target.ts (LUFS presets exist), mastering.ts (normalizeToLufs, ready), format-masters.ts (stubs to build out), export UI (transport-bar.tsx or new export-dialog)
• Implementation notes: Extend loudness-target.ts with platform metadata: { platform: 'spotify' | 'youtube' | 'apple' | 'tiktok' | 'club', targetLufs, truePeakCeiling, limiterType, metadata: { copyright?, isrc?, iswc? } }. Export dialog → user selects platforms (checkbox list) → for each, apply platform-specific master chain (EQ for club bass boost, comp + limiter for YouTube), export to /exports/master_spotify.wav, /exports/master_youtube.wav, etc. Metadata: embed ID3/MP4 tags (ISRC, copyright, performer). Defer to Wave 2.

AI-19 Real-time polyphonic pitch analysis + F0 tracking (F0 per frame, not per-clip) — P2 · M · 🔴 missing#

• What & why: Audio-analysis.ts does key detection + monophonic transcription (peak-picking, polyphonic but summarized to one clip). No frame-by-frame F0 analysis for live pitch meter, vocal tuning, or per-frame MIDI extraction. Realtime polyphonic pitch needed for vocal rehearsal features.
• SOTA reference: Melodyne (real-time per-voice pitch tracking), iZotope RX (F0 analysis with confidence), Celemony Capytalk (real-time pitch meter for learning).
• Depends on: estimateF0.ts (@euterpe/transcribe, real autocorrelation, ready), audio-analysis.ts (extend to per-frame F0 + confidence), spectral-mert or librosa PYIN algorithm (for polyphonic F0), sampler-panel.tsx or new vocal-monitor component
• Implementation notes: Add analyzeF0Stream() to audio-analysis.ts: input PCM stream (or offline buffer), output stream of { frame, f0Hz, confidence } per 512-sample hop. Use YIN or PYIN (polyphonic, ~3–5ms per frame). Wire to a live pitch meter in sampler-panel (waveform + overlaid frequency curve, red for out-of-tune). On vocal track, expose 'Tuning Coach' button: shows real-time F0 vs. target pitch (from melody clip or manual entry), visual feedback (needle gauge).

AI-5 Spectral EQ with learning (Sonible/iZotope neural style) — P2 · L · 🟢 polish#

• What & why: DAW has fixed 5-band RBJ parametric EQ on master + per-track insert. SOTA (Sonible smart:EQ, iZotope Ozone 11+) learn from waveform shape, reference track, or user edits to auto-suggest band placement + gain. Euterpe has octave-band analysis (mix-assistant-bridge.ts) but no AI-driven EQ suggestions or dynamic EQ with frequency masking.
• SOTA reference: Sonible smart:EQ (ML waveform analysis → instant EQ suggestion per band), iZotope Assistant (reference match + spectral balancing), Splice Smart EQ (cross-track frequency masking hints).
• Depends on: @euterpe/master/frontier-mastering (matchEq exists for octave-band tone matching, reusable), master-eq-panel.tsx (SVG EQ editor, needs 'Auto' button logic), reference-match.ts (octave-band analysis, can be extended to 31-band per track)
• Implementation notes: Extend frontier-mastering.matchEq to accept per-track spectral profile (not just master vs reference). Add 'Auto-EQ' button in master-eq-panel: measure current spectrum, compare to Spotify loudness standard (flat bass −3dB, +3dB presence), suggest band moves in dB. Display suggestion as a tooltip or ghost trace on the EQ curve. For dynamic EQ, add a per-band toggle for 'sidechain' (compress other tracks at this band if this track is loud there).

AI-6 Dynamic EQ + frequency masking detection — P2 · L · 🔴 missing#

• What & why: Euterpe's insert chain has static Biquad EQ and Compressor separately; no frequency-aware dynamic EQ or inter-track masking detection. SOTA (Sonible smart:mix, Splice) detect when a bass track masks vocals and suggest band-specific cuts.
• SOTA reference: Sonible smart:mix (ML frequency masking detection per track pair), iZotope RX (spectral repair + dynamic EQ with sidechain frequency band selection), Fabfilter Pro-Q 3 (dynamic EQ, sidechain-aware, standard mixing tool).
• Depends on: mix-assistant-bridge.ts (per-track spectral analysis exists), insert-rack component (add DynamicEqNode if not present), Compressor module in dsp-core (extend to frequency-band sidechain)
• Implementation notes: Add DynamicEqNode to dsp-graph (per-band gain automation via sidechain). In mix-assistant-bridge, detect masking: for each track pair, measure spectral overlap in bass (20–250Hz) and presence (4–6kHz) bands. If track A's energy in a band >> track B's, suggest track B cut in that band. Expose as 'Fix Masking' action in mix-report-panel, user accepts to add DynamicEqNode to affected track's insert chain with pre-filled sidechain + band selection.

AI-10 Smart/semantic sample search (text + audio query) — P2 · L · 🟢 polish#

• What & why: SOTA stem-separation-sota.ts has searchSamples() and clusterSamples() (k-means + seeded embeddings) but no input: no embedded sample library, no audio encoder, no text-to-embedding bridge. Needed for quick sample browser in DAW (e.g., 'find bass loops in key of C minor, 120 BPM').
• SOTA reference: Sononym 3 (waveform shape neural search), Splice (multi-modal sample search + AI tagging), BeatPort/Loopmasters (ML-driven sample discovery).
• Depends on: searchSamples + clusterSamples (ready in stem-separation-sota.ts), embedding model (e.g., Meta EnCodec or Jina audio embeddings), sample metadata API (BPM, key, instrument, duration), sampler-panel.tsx or new sample-browser component
• Implementation notes: Add sample-browser.tsx component. User types prompt (e.g., 'lo-fi Rhodes in Em 100 BPM') → parse via conditionTextToLoop (text-to-loop.ts is ready). Query BFF /v1/samples/search { text_embedding, bpm, key, limit } → backend embeds text, searches embedded sample library (Firebase/Firestore index), returns top 10. User previews, drags to sampler track. Requires sample library onboarding (upload + batch embed samples via Meta EnCodec). Recommend starting with small curated set (100–1000 samples) for MVP.

AI-12 Voice cloning enrollment + streaming synthesis (ElevenLabs/RVC bridge) — P2 · L · 🟡 partial#

• What & why: Voice cloning scaffold exists (@euterpe/voice/voice-cloning.ts) with sample analysis, embeddings, fine-tuning stubs, but no DAW UI to record voice samples, enroll speaker, or synthesize melody to cloned voice. Text-to-singing stubs lack voice model provider integration.
• SOTA reference: ElevenLabs (instant voice cloning from 1 min sample, API streaming synthesis, natural prosody), RVC (community open-source, local fine-tuning, Discord bot), Bark (Suno, open, variable quality).
• Depends on: voice-cloning.ts (real analysis), text-to-singing.ts (stubs), voice-provider-env.ts (needs auth setup), sampler-panel.tsx or new vocal-track component, BFF /v1/voice/* endpoints (need scaffolding)
• Implementation notes: Add voice-enrollment flow to new vocal track creation: 'Record Voice Sample' → capture 60 sec mono audio → POST to BFF /v1/voice/enroll { audio, speaker_name } → backend extracts embeddings (via voice-cloning.ts), stores speaker_id. UI shows 'Voice enrolled: Alice'. Then, melody clip on vocal track + enrolled speaker_id → call /v1/voice/synthesize { melody_notes, lyrics, speaker_id, emotion } → stream audio. Requires ElevenLabs API key (BFF side) or self-hosted RVC (containerized sidecar). Recommend ElevenLabs for MVP (proven quality).

AI-21 Stem mastering (per-stem chain + stem export groups) — P2 · L · 🔴 missing#

• What & why: Format-masters and stem-mastering stubs exist but user cannot apply per-stem chains (separate master EQ/comp per stem group, e.g., all vocals → EQ + comp → exported as vocal_master.wav). Needed for professional workflow (send stems to mastering, they adjust each independently).
• SOTA reference: iZotope RX, Splice (stem mastering workflow), LANDR (stem-specific mastering options).
• Depends on: stem-mastering.ts (build out from stubs), export UI (multi-file export), dsp-graph Engine (can render any subset of tracks in isolation already)
• Implementation notes: Add stem-group concept to daw-session.ts: groupId on each track. In export dialog, user selects 'Export with Stem Mastering' → checkbox list of groups (drums, vocals, guitar, etc.). For each group, render offline, apply a dedicated master chain (user-defined: EQ + comp presets per group), export as group_name_master.wav. Derive group defaults from track names (regex-matched 'vocal' → vocal_group, etc.). UI: matrix of [group] × [EQ/comp bands] with sliders per group.

AI-7 Audio inpainting (waveform region regeneration) — P2 · XL · 🔴 missing#

• What & why: Euterpe has clip-level inpainting (regenerate MIDI region conditioned on surround), but no waveform inpainting (e.g., remove artifact, regenerate vocal breath, fill click in drum). Requires diffusion model (Stable Audio / Meta AudioSeal class) on audio samples, not MIDI.
• SOTA reference: Meta AudioSeal + Inpainting (diffusion, research), Splice (style transfer + inpainting on samples, commercial), Soundraw (diffusion-based SFX inpainting).
• Depends on: Diffusion inference backend (server or WASM), sampler-panel.tsx (waveform scrubber, drag to select region), audio decoding (existing PCM buffer)
• Implementation notes: Add 'Inpaint Selection' button in sampler-panel: user selects region on waveform, hits inpaint, POST to BFF /v1/audio/inpaint (audio buffer + mask region + context), server runs diffusion with surrounding frames as conditioning, returns inpainted audio, user auditions & replaces. Requires diffusion API access (Runway/Stability/meta-research) or self-hosted sidecar (Stable Diffusion Audio fork). Start as low-priority research task.

AI-17 nih-plug VST3/AU shipping (desktop plugin deployment) — P3 · L · 🟢 polish#

• What & why: mrt2-native is built as nih-plug wrapper (VST3/AU boilerplate) but never shipped, tested in live DAW, or integrated with plugin validation/signing. Euterpe Studio desktop (Tauri) does not expose plugin format or host plugins from other vendors.
• SOTA reference: iZotope, Sonible, Fabfilter all ship native plugins (VST3/AU/AAX) with automated CI/signing. Plugin Alliance offers plugin subscription model.
• Depends on: mrt2-native/src/plugin.rs (built, ready), nih-plugin build system (ready), codesigning (Apple Developer account), plugin validation (auval for AU, Pluginval for VST3)
• Implementation notes: Set up CI (GitHub Actions) to build VST3 + AU for macOS/Linux/Windows on each commit. Codesign AU bundles (Apple Developer cert). Run auval + Pluginval to validate format compliance. Package as .vst3 / .component bundles, upload to github releases. Add AU/VST3 to Euterpe Studio Tauri → user can drag-n-drop plugin into any DAW that supports AU/VST3. Test in Logic Pro, Ableton, Studio One. Deferred pending demand for plugin format (most users prefer in-DAW).

AI-16 Collaboration (link share + CRDT sync) — P3 · XL · 🔴 missing#

• What & why: Euterpe DAW is single-player (React reducer, local state, no server sync). @euterpe/collab has stubs for CRDT sync-engine but no wiring to daw-session.ts reducer or real-time WebSocket sync. Users cannot share live links or co-edit.
• SOTA reference: BandLab (free collab, browser, real-time co-edit via CRDT), Soundtrap (browser collaboration, limited real-time), Splice (project share + commenting, not live co-edit), Splice Live (realtime co-production).
• Depends on: collab sync-engine.ts (Yjs/Automerge scaffold), daw-session.ts (needs refactor to apply CRDT ops), BFF /v1/sessions/:sessionId endpoint (create, poll, apply ops, broadcast), WebSocket server (Fastify + ws), project persistence (Firebase/Postgres)
• Implementation notes: Integrate Yjs (open-source CRDT library). Wrap daw-session reducer: dispatch(action) → translateToYjs op → emit to BFF via WebSocket → broadcast to other clients → all clients apply same op → converge state. Undo/redo becomes tricky (Yjs has its own history). Requires backend changes: multi-client lock + op log, conflict resolution. Deferred to Wave 3+ (high complexity).

AI-20 Spatial audio mastering (Atmos/binaural rendering) — P3 · XL · 🔴 missing#

• What & why: Euterpe's master is stereo only (L/R mix + width collapse). SOTA mastering (Apple Music Spatial Audio, YouTube 360 Reality Audio) support surround (5.1.2 Atmos, binaural renderers). stem-separation-sota.ts has Atmos bed object definitions but no spatial rendering or Atmos-format export.
• SOTA reference: Apple Music Spatial Audio (Dolby Atmos, Dolby Surround, requires special encoder), YouTube 360RA (spatial audio metadata), Dolby Atmos Music (immersive mix at −18 LUFS integrated, object-based panning).
• Depends on: dsp-graph Engine (extend to 5.1.2 or Ambisonics output, not just stereo), master-chain spatializer (none), Dolby Atmos / Ambisonics encoder (commercial or research API), stem-separation-sota.ts Atmos routing (ready)
• Implementation notes: Low priority for MVP. Requires multichannel master output (6+ channels), spatial panning algorithms (VBAP, ambisonics), and commercial Dolby codec. Deferred to Wave 3+ unless demand from pro mixing users.

AI-22 Real-time effects plugin hosting (VST3/AU guest plugins) — P3 · XL · 🔴 missing#

• What & why: Euterpe's insert chain is hard-coded DSP (Biquad, Compressor, Delay, etc.), cannot host third-party VST3/AU plugins. Users want to insert Fabfilter Pro-Q, iZotope plugins, etc. on a track. Native plugin hosting is complex (child process audio I/O, parameter sync).
• SOTA reference: Ableton Live (Max for Live, Operator synth plugin support), Logic Pro (AAX hosting), Studio One (VST3 hosting), standard DAW feature for professionals.
• Depends on: Tauri plugin system (basic file I/O ready, needs extension), native VST3/AU loader (vst-rs, baseview, vizia), IPC for audio passing (shared memory ring buffers), dsp-graph Engine (socket for external plugin node)
• Implementation notes: Out of scope for initial release. Requires native plugin sandboxing, multi-threaded audio, and platform-specific testing (macOS AU, Windows VST3, Linux VST3). Deferred to Wave 4+ or use a plugin framework (reaper-rs, VCV Rack architecture).

UX-1 Resizable/Draggable Panel System — P0 · L · 🔴 missing#

• What & why: Euterpe's layout is a fixed flexbox grid (380px left sidebar + mixer + bottom sequencers). SOTA DAWs (Ableton, Reaper, Studio One, Bitwig) all support hot-swappable resizable panel dividers, floating windows, and save/restore layout presets. This is P0 UX infrastructure — users expect to scale piano roll vs mixer, hide/show panels, and recall named layouts. Currently: flex widths hardcoded; no divider handles; no layout persistence.
• SOTA reference: Ableton Live 12 (Inspector/Device/Mixer resize), Reaper (docker everywhere), FL Studio (Mixer height drag), Studio One (Arrange/Edit/Mix tabs with resizable panes), Bitwig (per-panel resize handles + layout templates)
• Depends on: React layout state (size/visibility per panel), localStorage/IndexedDB for layout presets, mouse/touch divider drag handlers
• Implementation notes: Introduce a LayoutManager hook (track panel widths/heights/visibility). Replace fixed 380px width with state-driven LayoutPanel wrapper. Add vertical/horizontal resize dividers (onPointerDown/Move/Up). Store layout JSON to localStorage per project. Panels: left-sidebar (synth/sampler/insert/automation), mixer (scrollable horiz), piano-roll (resizable), step-grid, generator. See: react-resizable-panels lib or custom Pointer Events solution (match existing piano-roll drag pattern). Files: new src/components/daw/layout-manager.tsx, update daw-app.tsx render tree.

UX-9 Arrangement Timeline (Clip-Based Sequencing & Scheduling) — P0 · XL · 🔴 missing#

• What & why: Euterpe's core engine supports per-track pattern sequencing (NoteClip, 16-step patterns) but the DAW has NO timeline view. SOTA DAWs (all of them) show a horizontal timeline with tracks as rows, clips placed at bar positions, resizable/draggable clips, per-clip editing, loop region, arrangement-mode switching. Users expect to compose multiple clips per track, schedule them in bars, and see a bird's-eye view of the entire song structure. Currently: only single-clip piano roll per track; no multi-clip view; no bar-level scheduling.
• SOTA reference: Ableton Live 12 (Session/Arrangement view switcher, clips on grid with bar positions), Logic Pro (Arrange window with regions), FL Studio (Playlist with clips), Reaper (Arrange view with automatic comping), Studio One (Arrange page with tracks and clips)
• Depends on: Data model: ClipState extended to include {trackId, startBar, lengthBars}. Session.clips array (global flat list). Engine: per-update, determine which clips are active at the current bar, play their patterns in sequence. UI: timeline SVG or canvas rendering (bar ruler, track rows, draggable/resizable clip blocks).
• Implementation notes: Introduce ArrangementSession layer above DawSession. ClipState gains {id, trackId, startBar, lengthBars, pattern}. DawSession.clips = global clip list (not per-track). Engine scheduler: at each update, compute activeClips for the current playhead beat, blend all active clips' patterns. UI: ArrangementView component (SVG grid: bars as columns, tracks as rows, clips as draggable/resizable blocks). Drag clip → move/snap-to-grid. Resize right edge → lengthen. Double-click → open piano roll for that clip. Shift-drag → copy clip. Delete key → remove clip. Zoom in/out (Cmd+scroll). Add clip button per track. Files: new src/daw/arrangement.ts (ClipState, arrangement types), src/components/daw/arrangement-view.tsx (main timeline component), update daw-session.ts actions (addClip, moveClip, deleteClip, resizeClip), update daw-app.tsx to render arrangement view conditionally (view mode: 'session' | 'arrangement').

UX-15 VST3/CLAP Plugin Hosting & Audio Unit (AU) Support — P0 · XL · 🔴 missing#

• What & why: Euterpe's insert chain is audio-engine-only (10 native effects: EQ, Compressor, etc.). SOTA DAWs (Reaper, Bitwig, Studio One, Cubase, Logic) host VST3/CLAP plugins, allowing users to load third-party instruments & effects. This is critical for professional producers. Euterpe has a nih-plug wrapper (mrt2-native) but it's not wired into the DAW.
• SOTA reference: Reaper (VST2/3/CLAP support, unlimited chains), Bitwig Studio 5 (VST3/CLAP native), Studio One (VST3/AU support), Cubase 14 (VST3/CLAP), Logic Pro (AU, Logic plugins)
• Depends on: Native plugin communication layer (Tauri IPC bridge to sidecar or native process). Plugin manifest & parameter discovery. GUI rendering (OSC-based or embedded HTML5). Insert chain refactoring.
• Implementation notes: Phase 1 (sidecar): Use Tauri native-invoke to spawn a subprocess handling plugin I/O via shared memory (ring buffers for audio, JSON RPC for param updates). Phase 2 (full VST3): Implement VST3 host API in Rust (vst3-rs crate); enumerate installed plugins; instantiate & manage lifecycle. Plugin parameter automation: map VST params to engine automation lanes. Render plugin GUI in WebView (if supported) or OSC control surface. Insert refactoring: InsertRack now holds {kind: 'native' | 'vst3', id, state}. Files: new src-tauri/plugin-host/lib.rs (VST3 hosting), update audio-engine-web to receive plugin parameter changes, refactor src/components/daw/insert-rack.tsx for VST UI.

UX-2 Comprehensive Undo History Tree Visualization — P1 · M · 🟢 polish#

• What & why: Euterpe has linear undo/redo (canUndo, canRedo flags; reducer-based replay). SOTA (Reaper, Studio One, Blender) expose history as a visual tree: branch on redo after undo, view past states, click any node to jump. Current: only Cmd/Ctrl+Z (linear). Users lose work if they undo, do something else, then want to recover the redo stack. This is P1 for pros.
• SOTA reference: Reaper (Edit → Undo history, tree view), Studio One (History panel, non-linear tree), Adobe products (History panel with thumbnail previews), Blender (full tree visualization)
• Depends on: daw-session.ts reducer (already tracks past/future); history tree data structure (breadcrumb chain with branching); new UI component
• Implementation notes: Extend DawSession to store full history tree (not just past/future arrays). Use a Node tree where each node = one action applied. Add HistoryPanel component (collapsible sidebar or modal) with tree visualization (SVG tree or hierarchical list). On redo after undo, branch the tree. Click any node to apply sequence of actions to reach that state. Render compact preview or action description per node. Files: daw-session.ts (add history tree structure), new src/components/daw/history-panel.tsx, daw-app.tsx (add panel toggle).

UX-3 Customizable Keyboard Shortcuts (with Chord Bindings) — P1 · M · 🟢 polish#

• What & why: Euterpe has hardcoded shortcuts (space=play, digits=track, Cmd+Z=undo). SOTA DAWs (Ableton, Logic, Reaper, Studio One) expose a Keyboard Settings panel listing all 100+ shortcuts with reassignable keys, chord support (Cmd+Shift+K), and context awareness (shortcuts differ per view). Currently: no rebinding UI; no chords; no per-context shortcuts.
• SOTA reference: Ableton Live 12 (Preferences → Keyboard), Logic Pro (Logic Pro → Settings → Key Commands), Reaper (Options → Show MIDI/OSC actions and options), Bitwig (Preferences → Keyboard, fully customizable)
• Depends on: Define all actionable commands (30+ types from DawAction enum). Keybinding config JSON schema. Keyboard event parser for chords (Cmd+Alt+Shift+K). UI for rebind.
• Implementation notes: Define command registry: {id, name, category, defaultKey, contexts}. Store keybindings in localStorage/IndexedDB as JSON. Update daw-app.tsx keyboard handler to look up bindings dynamically. Add KeyboardSettingsPanel (modal or sidebar): list all commands, click to rebind, press chord, validate no conflicts. Parse 'Cmd+Shift+K' notation. Support context-aware shortcuts (e.g., Cmd+U only works when a track is selected). Files: new src/daw/keybindings.ts (registry + parser), src/components/daw/keyboard-settings-panel.tsx, update daw-app.tsx useEffect keyboard handler.

UX-4 Full Command Palette (with Search & History) — P1 · M · 🟢 polish#

• What & why: Euterpe's CommandBar is good but partial: accepts natural language, falls back to deterministic parser. SOTA (VS Code, Figma, Ableton, Logic Remote) have searchable command palettes listing all 200+ actions, fuzzy-find by name/shortcut, recent commands, action groups. Currently: no browse mode; no search; no history; limited to natural-language input or parser.
• SOTA reference: VS Code (Cmd+Shift+P, 400+ commands, fuzzy search, keystroke count indicator), Figma (⌘ / menu, actions + artboard templates), Ableton Live 12 (Browser filters; not quite a palette but asset search), Logic Pro (Quick Help, limited action search)
• Depends on: Command registry (defined in keyboard-shortcuts item). Search algorithm (fuzzy match). History storage (localStorage). UI to render scrollable list.
• Implementation notes: Expand CommandBar to full palette: keep LLM fallback, but add explicit browse-mode (Cmd+K opens palette). Render all DawAction types + special actions (export, load project, etc.) as searchable rows (name + icon + shortcut + description). Fuzzy-search on text input. Show recent first, sorted by frequency. Persist clicked action counts to localStorage. Files: src/daw/command-registry.ts (all actions exported), update src/components/daw/command-bar.tsx to dual-mode (palette + traditional), add history tracking.

UX-6 Global Macro Control UI & Binding — P1 · M · 🔴 missing#

• What & why: SOTA DAWs expose 4–8 macro knobs at the top of the instrument/mixer that can be mapped to any parameter. Euterpe has no macro system. Macros are critical for live performance and preset design (e.g., single 'Brightness' knob controlling filter cutoff + resonance + reverb simultaneously).
• SOTA reference: Ableton Live 12 (Macro controls on Instrument Racks, default 8 faders with arbitrary mappings), Bitwig Studio 5 (Macro Control device, map to anything), Serum (on-screen macro knobs + modulation matrix)
• Depends on: Modulation matrix (previous item). Synth patch state expanded to store macro control definitions.
• Implementation notes: Add MacroControl[] (name, min, max, default, targets: {param, depth}[]) to SynthPatch. UI: expandable Macros section in SynthPanel or dedicated MacroPanel showing 8 faders + drag-and-drop mapping UI. Bind macro to a target via modal (select track/parameter/depth). Engine: read macro state, blend each target value by depth, apply in the synth voice. Files: daw/types.ts (add MacroControl), daw-session.ts (macro state), src/components/daw/macro-control-panel.tsx, update synth-panel.tsx.

UX-20 Cloud Generation Import (Suno/Udio Audio → Track) — P1 · M · 🟡 partial#

• What & why: Euterpe can generate music via realtime MRT2 (text/MIDI steering), but users cannot import generated audio from Suno, Udio, or other cloud services. SOTA AI-DAWs (Amper, Studioflow on Splice, Soundraw) integrate generation APIs and auto-import results into tracks. This is now table-stakes for AI-native tools.
• SOTA reference: Suno v4 (API for generation), Udio (generation API), Splice (cloud generation integration), BandLab (generation + import workflow), Soundraw (full integration in creative suite)
• Depends on: BFF music-executor.ts (already enqueues Suno/Udio). Jobs-route.ts status polling. UI for browsing completed generations.
• Implementation notes: Add GenerationHistoryPanel (sidebar or modal) listing all past Suno/Udio generations (queried from BFF). Click generation → download WAV + auto-import as new audio track. Alternatively, trigger generation inline: users input prompt → BFF enqueues → poll for completion → auto-load result. Files: update src/daw/daw-session.ts (add CloudGeneration history), src/components/daw/generation-history-panel.tsx, bridge BFF /generation/jobs endpoint to DAW UI, update daw-app.tsx.

UX-5 Modulation & Automation UX (LFO, Macro Controls, Mod Matrix) — P1 · L · 🟡 partial#

• What & why: Euterpe has automation lanes (6 fixed parameters: volume, pan, cutoff, reverb-send, delay-send, master-gain) with SVG polyline editing. SOTA DAWs support: (1) LFO modulation (sine/square/triangle/random at user-controlled rate), (2) Global macro controls (4–8 macro knobs that affect multiple parameters), (3) Modulation matrix (route LFO/macro/envelope to any parameter). Currently: no LFO; no macros; no matrix.
• SOTA reference: Ableton Live 12 (Macros on instruments + racks, map any knob to macro), Bitwig Studio 5 (Modulation panel with LFO, envelope, note expression, macro grid), Serum/Xfer (mod matrix paradigm), Logic Pro (Smart Controls, Automation modes)
• Depends on: DSP LFO node (Rust side); macro state in DawSession; UI for matrix. Engine already has ParametricEq, Compressor, etc. wired to per-track automation.
• Implementation notes: Audio engine: add LFO oscillator (sine, saw, square, tri, random, step) to dsp-core. DAW session: add MacroState per track (8 faders, each 0–1) + ModulationTarget enum (trackGain, trackPan, trackCutoff, trackQ, trackResonance, masterGain, masterWidth, etc.). UI: (1) Automation lane picker → also offer 'LFO 1–4' + 'Macro 1–8' as sources. (2) ModulationPanel: grid showing macro → target mappings (knobs to edit depth per target). (3) LFO panel: per-track select which LFO to use, edit wave/rate/depth. (4) Engine command bridge: postMessage macro state + LFO parameters to AudioWorklet, apply mix inside the processor. Files: dsp-core: lfo.rs, daw-session.ts (MacroState, LFOState), new src/components/daw/modulation-panel.tsx, src/components/daw/lfo-controls.tsx.

UX-10 Take Comping & Loop Recording UI — P1 · L · 🔴 missing#

• What & why: SOTA DAWs (Reaper, Logic Pro, Studio One, Pro Tools) support loop recording: record multiple takes in a loop region, then comp/select the best parts of each take to build a final composite. Euterpe supports recording (ClipRecorder) and quantization but NO loop-record mode or comping UI. This is critical for instrumental & vocal recording.
• SOTA reference: Reaper (Auto-Take mode: record multiple takes, toggle visibility, comp by lane), Logic Pro (Take Folders: record loop, create take folder, comp/select), Studio One (Take Layers: loop-record, comp in Arrange view), Pro Tools (Playlists and QuickPunch)
• Depends on: Recording infrastructure (already present). Multi-clip track representation. Per-track take management (array of clips per region).
• Implementation notes: Extend track recording: when in loop-record mode, each loop iteration creates a new 'Take' (clone of the clip). Store takes in a TakeLayer structure (clipId, takeIndex). UI: toggleable 'Takes' sidebar showing layer list (one row per take, toggle eye-icon to hide/show). Comp by clicking which take to 'arm' for playback at each bar position, or by dragging take regions end-to-end into the final comp clip. Files: daw-session.ts (TakeLayer structure, recording mode state), src/components/daw/take-layer-panel.tsx, update clip-recorder.ts to multi-take mode.

UX-7 Unified Asset/Sample/Preset Browser (with Semantic Search & Drag-Drop) — P1 · XL · 🔴 missing#

• What & why: SOTA DAWs (Ableton, FL Studio, Logic, Studio One, Splice integration) expose a comprehensive Browser: organized by category (drums, sounds, presets, loops), tagging, favorites, user collections, semantic search (e.g., 'bright pad'), drag-and-drop onto tracks/channels. Euterpe currently loads samples via file picker only; no preset browser; no built-in sample library; no search.
• SOTA reference: Ableton Live 12 (Browser panel: Factory Library organized by type/genre, drag-and-drop, search, Splice integration), FL Studio 21 (Browser with unlimited folders + user tagging), Logic Pro (Media Browser + Sample Library), Splice (semantic search over 200k+ samples, instant preview, drag to project)
• Depends on: Asset metadata schema (name, category, tags, description, preview-audio, thumbnail). Search backend (BM25 or semantic embedding if cloud-based). Drag-and-drop integration with existing loaders (loadSampleFile, etc.).
• Implementation notes: Scope 1: Minimal browser with file-system picker + local user collections (JSON with pointers to files). Scope 2 (SOTA): Cloud-hosted sample library (Splice API, or self-hosted Postgres + Meilisearch). BrowserPanel component (collapsible left sidebar or modal) with category tree (Drums/Synths/Loops/Presets/User) + search input (fuzzy match on name + tags). Preview on hover (play first 3 sec). Drag sample → track to load. Store user favorites/collections to localStorage. Files: new src/daw/asset-library.ts (schema + search), src/components/daw/browser-panel.tsx, update sampler-panel.tsx for drag-drop target, add Splice SDK bridge if needed.

UX-14 Contextual Help & Tooltip System — P2 · S · 🔴 missing#

• What & why: Euterpe has minimal help (command-bar hint). SOTA DAWs provide hover tooltips (e.g., 'Increase cutoff frequency'), context-aware sidebar help, keyboard shortcut callouts, and inspector panels explaining selected element. Users should be able to Cmd+? to get help on any UI element.
• SOTA reference: Logic Pro (Smart Help inspector), Ableton Live 12 (Operator device help panel, context-dependent), Figma (inspector panel + Cmd+? help), VS Code (inline hints, Cmd+I)
• Depends on: Help text database (JSON mapping element IDs to descriptions). Tooltip component.
• Implementation notes: Create HelpContext and useHelp hook. Define helpTexts object (elementId → description). Render floating tooltip on hover (200ms delay). Update all controls with data-help-id. Add HelpPanel (right sidebar, toggleable) showing detailed description of selected element. Cmd+? opens help toggle. Files: new src/daw/help-content.ts (helpTexts database), src/components/daw/help-tooltip.tsx, src/hooks/useHelp.ts, update all control components.

UX-8 Non-Destructive Sample Editing & Warp (Time-Stretch & Pitch-Shift) — P2 · M · 🟢 polish#

• What & why: Euterpe's sampler supports loop, reverse, start-position, and calls warpSample(factor, semitones) non-destructively (re-applies from original buffer). SOTA (Ableton, Logic, FL Studio, Studio One) show visual warp markers on the waveform, allowing users to place 'anchor points' and time-stretch sections or pitch-shift while keeping others unchanged. Currently: warp is parameter-based (global factor), not visual point-based.
• SOTA reference: Ableton Live 12 (Warp feature: place warp markers, stretch regions between them, re-timestamp), Logic Pro (Flex Time/Pitch), FL Studio (Time Stretching tool), Studio One (Musical Mode with visual markers)
• Depends on: WaveformView already renders and allows dragging start marker. Extend to allow placing/moving multiple warp markers.
• Implementation notes: Extend WaveformView to support warp mode toggle. In warp mode, allow clicking to place markers (beat time + original sample time). Dragging a marker stretches the region between it and the next marker (or end). Visual feedback: draw vertical lines + label with beat numbers. Render waveform with stretching applied. Store warp markers in track state (WarpMarker[] with originalSampleFrac, targetBeatOffset). Call engine's loadSampleWarped with computed per-sample time-mapping. Files: src/components/daw/audio-visualizers.tsx (add warp mode, marker rendering), daw-session.ts (add WarpMarker[], warpMarkers action), update sampler-panel.tsx UI for mode toggle.

UX-11 Touch, Pen, and Gesture Support (iPad/Mobile DAW) — P2 · M · 🟢 polish#

• What & why: Euterpe uses Pointer Events (good foundation), but has no multi-touch support (2-finger zoom, pinch-pan), pen-pressure detection, or touch-optimized UI (larger buttons, long-press menus, swipe gestures). SOTA (Logic Remote, Ableton's iPad app, Cubasis 3, BandLab) offer full touch workflows: pinch-zoom timeline, long-press for context menus, 2-finger pan, pen input for drawing automation.
• SOTA reference: Logic Remote (iPad control of Logic Pro), Ableton Link + hardware controller support, Cubasis 3 (full iPad DAW with touch optimization), BandLab (web-based, mobile-friendly UX)
• Depends on: Pointer Events already in place (piano-roll.tsx, automation-lane.tsx, audio-visualizers.tsx). Extend handlers for touch-specific: multi-touch pan/zoom, long-press (200ms), swipe (velocity tracking).
• Implementation notes: Create useMultiTouchGesture hook: track 2+ pointers, compute pinch distance + angle, detect long-press + swipe. Add to PianoRoll: pinch → zoom vertical (pitch range) or horizontal (time). ArrangementView: pinch-zoom bar ruler. AutomationLane: long-press point → context menu (delete, lock). SamplerPanel waveform: swipe left/right to jump. Increase button/touch-target size on mobile (use CSS media query for touch). Handle pen pressure if available (event.pressure). Files: new src/hooks/useMultiTouchGesture.ts, update piano-roll.tsx, automation-lane.tsx, arrangement-view.tsx.

UX-13 Onboarding Sequence & First-Run Experience — P2 · M · 🔴 missing#

• What & why: Euterpe shows only a startup overlay ('Click to start audio engine') and a command-bar hint string. SOTA DAWs (Logic Pro, Ableton, Studio One, Bitwig) feature: interactive walkthroughs (click elements on tour), template galleries (start with a blank project or guided intro song), contextual tooltips, video help, and tutorial projects. Critical for user retention, especially for music DAWs where entry barrier is high.
• SOTA reference: Logic Pro (interactive tips, tutorial sessions with pre-made songs), Ableton Live 12 (Welcome screen with Tutorial and Essentials), Studio One (PreSonus Hub with onboarding content), Bitwig Studio (Quick Start guide, preset manager)
• Depends on: UI for multi-step wizard (component library or custom). Project templates (JSON blueprints for skeleton songs). Video/image assets (can be deferred to link to external docs).
• Implementation notes: Create OnboardingFlow component (modal, full-screen, with step carousel). Steps: (1) Welcome + 30-sec video (or GIF), (2) Play/stop + Transport demo, (3) Add a track demo, (4) Click piano roll to add notes, (5) Run command bar demo, (6) Export WAV. Store 'has_completed_onboarding' in localStorage. Show on first launch. Add 'Start Tutorial' template button that creates a pre-made project with a few notes + effects already set up. Files: new src/components/daw/onboarding-wizard.tsx, src/daw/template-projects.ts (JSON blueprints), update daw-app.tsx to conditionally show wizard.

UX-16 Large-Project Performance UI & Optimization Hints — P2 · M · 🔴 missing#

• What & why: Euterpe works on moderately complex projects (16-track example), but there's no performance monitoring (CPU %, latency, buffer underrun warnings) or optimization UX (disable tracks, freeze tracks, render-in-place, offline-bounce optimizations). SOTA DAWs show CPU meter, track freeze buttons, and warnings when nearing limits.
• SOTA reference: Ableton Live 12 (CPU meter in transport, Freeze Track), Logic Pro (CPU usage per plugin, freeze regions), Reaper (performance indicators, frozen tracks), Pro Tools (CPU meter, track hibernation)
• Depends on: Engine performance telemetry (DSP processing time per block). Freeze/render infrastructure (offline render per track).
• Implementation notes: Add PerformanceMonitor in AudioEngine (track elapsed time per block, compute rolling CPU %). Stream CPU % to React. TransportBar shows CPU meter (green <50%, yellow 50–80%, red >80%). FreezeTrack action: render track offline, replace with audio clip (playback from render). DisableTrack action: skip DSP for that track. Offline export: use existing renderOffline but show progress bar + ETA. Files: src/@euterpe/audio-engine-web/audio-engine.ts (add perf metrics), update src/daw/daw-session.ts (add FrozenTrackState), src/components/daw/transport-bar.tsx (CPU meter), src/components/daw/performance-panel.tsx.

UX-17 Project Templates & Starter Songs — P2 · M · 🔴 missing#

• What & why: Users should be able to start from pre-made song templates (Minimal Loop, Pop Song, EDM Drop, etc.) rather than blank projects. This accelerates onboarding and showcases best practices. Ableton, FL Studio, Logic all include template projects.
• SOTA reference: Ableton Live 12 (template browser, Live Intro/Standard templates included), FL Studio (Starter projects with different genres), Logic Pro (template browser with 80+ styles)
• Depends on: Template JSON schema (DawSession serialization). UI for browsing and selecting templates.
• Implementation notes: Define 5–10 minimal templates (Blank, Minimal Loop, 4-Bar Loop, Pop Intro-Chorus, Ambient Pad, Drum Kit). Serialize as JSON in src/daw/template-projects.ts. Add TemplateSelector component (carousel or grid). 'New Project' button shows template dialog. Click template → hydrate session with its state. Store user's recent templates. Files: src/daw/template-projects.ts (templates as JSON), src/components/daw/template-selector.tsx, update daw-app.tsx newProject.

UX-19 Clip Slicing & Audio Quantization to Grid — P2 · M · 🟡 partial#

• What & why: SOTA DAWs (Ableton, Logic, Studio One, Reaper) auto-detect audio clip onsets and slice them to grid-aligned beats, allowing granular timing correction and re-sequencing of recorded takes. Euterpe has onset detection (audio-analysis.ts spectral-flux) but doesn't slice or grid-quantize audio clips.
• SOTA reference: Ableton Live 12 (Warp + Beat Detection), Logic Pro (Flex Time), Studio One (Musical Mode with beat detection), Reaper (Beat Detection in regions)
• Depends on: Onset detection (already present in audio-analysis.ts). Sampler-track slicing + clip boundaries.
• Implementation notes: Add 'Auto-Slice' button to SamplerPanel. Detect onsets (spectral-flux), slice buffer at those points. Create SlicedClip structure (regions with start/end sample index). Store in track state. UI: WaveformView shows slice lines, hover for timing info. Can retime clips by dragging slice boundaries. Export sliced regions as separate clips. Files: src/daw/slice-detection.ts (onset-based slicing), daw-session.ts (SlicedClip state), update sampler-panel.tsx.

UX-21 Audio Inpainting & Region Regeneration — P2 · M · 🟡 partial#

• What & why: SOTA AI tools (AIVA, Amper, Splice Stem, Moises) allow selecting a waveform region and regenerating/extending it conditioned on surrounding context. Euterpe's genesis has inpaintSection stub but it's not wired. This is critical for iterative composition.
• SOTA reference: AIVA (re-generate regions), Amper (continuation generation), LANDR Master (mastering region tweaking), BandLab (stem regeneration)
• Depends on: Audio inpainting model (neural network calling BFF or local ONNX). WaveformView region selection UI.
• Implementation notes: SamplerPanel: add 'Regenerate Region' button. Select start/end markers on waveform → send to BFF /inpaint endpoint (or local model). Receive regenerated WAV, blend/crossfade into original buffer. Update display. OR: for MIDI, use genesis.inpaintSection (already wired in clip-inpaint.ts) to regen a piano-roll region. Files: update sampler-panel.tsx (region selection + regen button), new src/daw/audio-inpaint.ts (BFF bridge), or wire existing src/daw/clip-inpaint.ts more prominently.

UX-12 Multi-Window & Multi-Monitor Support — P2 · L · 🔴 missing#

• What & why: Euterpe is a single-window Tauri app. SOTA DAWs (Reaper, Logic, FL Studio, Studio One) allow detaching panels to secondary windows (mixer on one monitor, arrange on another), saving multi-monitor layouts, and floating inspection windows. This is expected for pro users with large setups.
• SOTA reference: Reaper (floating dockers on any monitor), Logic Pro (secondary windows for Piano Roll, Mixer, etc.), FL Studio (detachable mixer/playlist), Studio One (multiple editor windows)
• Depends on: Tauri WindowLabel API for opening new windows. Layout manager (resizable panels item) to track per-window state. IPC (invoke/listen) to sync session state across windows.
• Implementation notes: Extend Tauri config to allow opening new windows. Add 'Detach' button on each panel (LayoutManager). Click → open new Tauri window with LayoutPanel for that single panel. Use Tauri event-listen to sync DawSession updates to all windows. Store multi-window layout (which panel on which window) to localStorage. Files: src-tauri/src/main.rs (window spawning logic), update LayoutManager to track windowLabel per panel, src/daw/multi-window-sync.ts (event listeners), update daw-app.tsx.

UX-18 Sample Library & Pack Management (Asset Collections) — P2 · L · 🔴 missing#

• What & why: SOTA DAWs and tools (Splice, Ableton Packs, FL Studio Content, Loopmasters) offer built-in or integrated sample/drum-kit/loop packs organized by category/BPM/key/genre. Users drag samples directly into projects. Euterpe has no built-in library and no pack manager.
• SOTA reference: Splice (200k+ samples, built-in browser with instant preview + download), Ableton Packs (genre-organized), FL Studio Content (integrated pack downloader), Loopmasters (royalty-free sample packs), iZotope RX (advanced audio restoration sample library)
• Depends on: Asset browser (previous item), cloud integration (Splice API or self-hosted), pack metadata (JSON list of samples + metadata).
• Implementation notes: Minimal version: curate 20–30 royalty-free drum kit + bass/synth sounds as JSON manifest + WAV files. Host in /public/samples. BrowserPanel loads manifest, displays packs, click → expand samples, drag → load to sampler. Full version: integrate Splice SDK (requires API key), stream samples on demand. Files: public/sample-packs/manifest.json (pack metadata), src/daw/sample-pack-loader.ts, update browser-panel.tsx.

UX-22 Collaboration & Real-Time Co-Editing (CRDT Sync) — P3 · XL · 🔴 missing#

• What & why: SOTA DAWs (Splice Collab, BandLab, Amper) support real-time multi-user editing with CRDT syncing, user cursors, and async commenting. Euterpe's collab lib has stub CRDT scaffolding but nothing is wired. This is P3 for solo creators but P1 for collaborative workflows.
• SOTA reference: Splice Collab (real-time sync, user cursors, version history), BandLab (cloud-based collab), Amper (multi-user session), YouTube Creation Studio (collab features)
• Depends on: CRDT engine (Yjs, Automerge, or custom). WebSocket server for sync. User identity & permissions. Conflict-free state merging.
• Implementation notes: Use Yjs for CRDT. Deploy WebSocket relay (Node.js or Rust sidecar). DawSession state → Yjs.Map/Array bindings. Every dispatch → Yjs update → broadcast to peers. Render user cursors (track selection, playhead position) per connected user. Comment/feedback lane (overlaid on timeline). Files: new src/daw/collab-session.ts (Yjs bindings), update daw-session.ts to accept remote updates, BFF collab-router.ts (WebSocket), src/components/daw/user-cursors-overlay.tsx.

REC-3 Punch-in/out with automatic crossfade at boundaries — P0 · M · 🔴 missing#

• What & why: Allow recording only within a defined bar region (punch start/end), overwriting the existing audio/notes without manual selection. Auto-crossfade (5-50ms fade-in/out) at punch boundaries to avoid clicks/pops. Currently unsupported; audio-capture.ts has no punch state machine.
• SOTA reference: Pro Tools (Punch mode + auto-crossfade), Logic (punch in/out with I/O buttons), Ableton (overlapping MIDI can coexist; audio auto-crossfades), Bitwig (punch-record in arranger)
• Depends on: TransportState extend with punchEnabled/punchStartBeat/punchEndBeat, RecordingSession record() method checks punch bounds, audio capture applies fade-in/out envelope, UI buttons in transport-bar.tsx
• Implementation notes: Add PunchState to TransportState (enabled, startBeat, endBeat). RecordingSession.record(block, playheadBeat) checks if playheadBeat ∈ [punchStart, punchEnd]; if out-of-range, return early (no capture). At punch boundaries: apply fade envelope (linear 0→1 at punchStart, 1→0 at punchEnd) to CaptureBuffer blocks. Transport UI: two text inputs ("Punch In: 1 1 1", "Punch Out: 2 1 1") or drag-markers on timeline ruler.

REC-1 Arrangement timeline with clip placement & bar/beat ruler — P0 · XL · 🔴 missing#

• What & why: Euterpe lacks a traditional DAW arranger view. Add a timeline UI component (ArrangementClip model: trackId, clipId, startBar, lengthBars, muted, color) to allow users to place note/audio clips across a bar-addressed timeline, drag-reorder, trim/extend clip boundaries, and view the entire song structure at a glance. This is the central workspace for > 80% of DAW users and required for any multi-take, multi-region session.
• SOTA reference: Ableton (timeline + scene matrix), Logic (arrange window with bar ruler), FL Studio (playlist with pattern placement), Pro Tools (edit/mix/arrange windows), Bitwig (arranger track)
• Depends on: Clip data model (note/audio clip with start/length), ArrangementTrackClip state, daw-session.ts reducer actions (addClip, deleteClip, moveClip, trimClip), ArrangementView React component (SVG/canvas timeline ruler, clip drag handles), engine clip scheduler (per-track clip playback order/crossfade), undo/redo for clip ops
• Implementation notes: Create ArrangementClip interface (trackId, clipId, startBar, endBar, muted, color, loopMode). Extend TrackState with clips: ArrangementClip[]. Add to daw-session.ts actions: addClipToTrack, removeClipFromTrack, moveClip, setClipMute, setClipColor, trimClipStart, trimClipEnd. ArrangementView (SVG timeline with beat ruler, clip rectangles, drag-to-move, resize handles at clip edges). Engine: extend setPattern/loadSample to accept clipStart/clipLength offsets into the pattern/sample buffer. For crossfading: add per-clip 10-100ms fade-in/out via automation breakpoints at clip boundaries.

REC-2 Take comping with loop-recording multi-lane display — P0 · XL · 🔴 missing#

• What & why: Enable users to record multiple takes over a loop region (punch-in/out markers) without destructive overwrite, then swipe/click to comp the best segment from each take. Currently audio-capture.ts records one take at a time into a sampler, losing previous takes. Requires: loop recording mode, per-lane take indexing, visual take stacking in a comp matrix, and comp selection (which take segment plays).
• SOTA reference: Logic (take folders + comp pane swipe-select), Pro Tools (playlists for comping), Ableton (loop-record leaves takes in clip), Studio One (take comping lanes)
• Depends on: RecordingSession extend to track multi-take history, ArrangementClip model for takes, loop-recording state machine, ComppingUI React component (lane stacking + swipe/click selection), engine multi-sample layer playback
• Implementation notes: Extend RecordingSession (audio-capture.ts) to record::loopMode with take array. On each loop cycle, append a new CaptureBuffer to takes[] rather than overwrite. Sampler: add takeIndex param to playback (which of the N takes to audition). ComppingUI: stacked take lanes (one per take, each showing waveform thumbnail), click region to select which take for that bar (highlight selected, mute others). Reduce to single take: export/finalize via take selection (comp matrix → merged audio WAV).

REC-7 Count-in (lead-in bars before record/play) — P1 · M · 🟡 partial#

• What & why: Play a configurable number of metronome bars (1/2/4) before transport starts recording or playhead jumps. Essential for performers to lock into tempo. Euterpe metronome UI exists but generates no audio and count-in is absent.
• SOTA reference: Logic (count-in checkbox + 1/2/4 bar selector), Pro Tools (Count Off pre-roll), Ableton (count-in in preferences, 1-4 bars), FL Studio (count bar displayed in piano roll)
• Depends on: TransportState extend countInBars (0/1/2/4), metronome audio generation (click tone per beat), LoopState for count-in region (0 to countInBars), transport reducer logic to arm count-in on record press
• Implementation notes: On play or record button press: if countInBars > 0, set transport loopRegion to [0, countInBars beats]. Generate click tone: 800Hz sine ~100ms per beat (or two-tone: 1kHz on downbeat, 800Hz on other beats). Mute main output during count-in (or send only to headphones if monitoring). After count-in region ends, playhead wraps to song start and main content plays. UI: settings dropdown or command-bar ('count-in 4 bars', 'count-in off').

REC-8 Input monitoring with software direct-out (headphone cue mix) — P1 · M · 🔴 missing#

• What & why: Allow performer to monitor live input (mic, instrument) alongside the mix, independently of main output. Low-latency (zero if possible), with separate gain/pan/effects send per input on the headphone cue bus. Currently unsupported; audio-capture.ts captures input silently into a buffer.
• SOTA reference: Pro Tools I/O (track input monitoring toggle + separate cue mix pre/post-fader), Logic (cue mixing with software output + direct mono input), Ableton (Monitor: In/Auto/Off per track), Bitwig (input monitor per-track), RME TotalMix (hardware control room with zero-latency input path)
• Depends on: InputMonitorState (trackId, monitorMode: 'off'|'in'|'auto'), audio-worklet bridge to split input stream into two paths (capture for recording, pass-through for monitoring), HeadphoneCueMix model (input level, pan, reverb-send, delay-send), transport UI for monitor mode selector
• Implementation notes: Add MediaStreamAudioSourceNode splitter in audio-capture.ts: one GainNode for capture (recording), one GainNode for direct-out (monitoring, ~5ms lookahead). MonitorGain state: 0..1 (scaled to dBFS). UI: three-way toggle per track (Off / In / Auto = in when not playing). Headphone output: input-monitor gain + sends to reverb/delay auxes. For true zero-latency, use ASIO native plugin path (mrt2-native plugin via Tauri sidecar, or browser WebAudio native I/O via Tauri bridge to system audio API).

REC-10 Metronome with configurable click audio and visual beat indication — P1 · M · 🟢 polish#

• What & why: Generate audible click sound (1kHz sine ~ 80ms per beat, optional double-click on downbeat) and optional visual beat light. Currently transport-bar.tsx has metronome toggle but no audio output.
• SOTA reference: Logic (click sound selector + volume knob), Pro Tools (click audio with pre/post-play/record options), Ableton (click in audio preferences), FL Studio (metro with drum sample or tone)
• Depends on: MetronomeState (enabled, volume, tone: 'click'|'cowbell'|'woodblock', downbeatTone), click audio generation in AudioWorklet, engine command setMetronome(enabled, bpm, beat), transport UI for metronome volume slider
• Implementation notes: In audio-engine-web.ts AudioWorklet processor: on each beat (playheadSamples % (sampleRate / (tempo / 60) / 4) == 0) generate a brief sine tone (1kHz @ 100ms downbeat, 0.8kHz @ 80ms other beats, gain 0.3 * metronomeVolume). OR use drum sample (kick for downbeat, hat for other beats). UI: transport-bar.tsx add metronome volume slider (0..100%), optional tone selector dropdown. Visual beat light: div#metronome-light that flashes (scale 1.2→1 over 100ms) on each beat.

REC-5 Looper / live-looping for real-time overdub recording — P1 · L · 🔴 missing#

• What & why: Enable live-performance layering: press/hold to record a loop (auto-quantized to bar), press again to layer, automatic undo/clear. Most essential for live performers and jam sessions. Euterpe lacks a dedicated looper UI or dedicated looper track type.
• SOTA reference: Boss RC series (hardware loopers), Ableton Looper plugin, Logic Looper (Max-based), VirtualLooper, BeatLive
• Depends on: LooperTrack source type (audio-engine-web), LooperUI React component (transport-like buttons: Record/Layer/Undo/Clear), RecordingSession extend for multi-layer buffer management, quantize-to-bar grid snapping
• Implementation notes: Add LooperTrack to TrackKind. LooperSession class: { layers: CaptureBuffer[], currentLayer, layerStartBeat, loopLengthBars }. UI: Record (hold = record until next bar boundary, quantized), Layer (overlay new recording), Undo (pop last layer), Clear (reset all). Engine: play all non-muted layers in parallel, auto-extend loopLengthBars if recording exceeds current length. For audio: downmix to mono, quantize to bar boundary (truncate/pad).

REC-6 Hardware MIDI controller integration: MIDI learn and surface mapping — P1 · L · 🔴 missing#

• What & why: Allow any MIDI CC or note to map to any DAW parameter (fader, knob, button, track mute, etc.). Support surface detection + auto-map for Ableton Push, Novation Launchpad, Mackie Control (MCU/HUI protocol). Currently web-midi.ts only decodes note-on/off; CC is ignored.
• SOTA reference: Ableton Push integration (30+ buttons/16 knobs, auto-detect + custom control script), Novation Launchpad (both grid clips + 8 faders per row), Mackie Control (MCU faders 1-8, rec-arm, mute, pan), NanoKontrol (9 faders + 9 knobs + transport), Push 3 (Touch Strip pitch-bend, MIDI note triggers, velocity-sensitive pads)
• Depends on: ControlMapping data model (ccNumber, channel, targetAction, minVal, maxVal), ControlMapStore (persist mappings as JSON), MIDI-learn UI mode (listen to next CC, confirm map), transport-bar + channel-strip parameter targets (knobs emit 'requestCCMap' on right-click), MidiLearnUI dialog, PresetSurfaces (hardcoded Push/Launchpad maps as fallback)
• Implementation notes: Extend web-midi.ts parseMidiMessage to return CC/pitchbend/aftertouch events. ControlManager class: { mappings: Map<ccNumber, Action>, learn() starts CC-listen mode, map(cc, action) stores mapping. On incoming CC: look up action, validate range, dispatch (e.g., setTrackGain with dB = minDb + (cc / 127) * (maxDb - minDb)). Surface detection: on connection, check sysex device ID or CC lane count (Push sends unique CC header). UI: Settings → MIDI Learn (button → listen, right-click any knob in channel-strip/transport to map, visual CC number display).

REC-4 Clip-launch / SESSION view with scenes and follow-actions — P1 · XL · 🔴 missing#

• What & why: Implement Ableton Live-style SESSION view: a matrix of scenes (rows) × clips (columns), where clicking a clip in a scene launches only that clip, and releasing stops it (one-shot) or loops it. Each scene is a named set of clip choices. Follow-actions define probability (e.g., 50% jump to next scene, 50% stay here). Currently Euterpe has only pattern sequencing and arrangement; no launch grid.
• SOTA reference: Ableton Live 12 (SESSION/ARRANGE mode toggle, scene triggering, follow-actions per-clip), Bitwig (clip-launch view as primary grid), Deluge (hardware clip grid)
• Depends on: Scene data model (name, clips: LaunchClip[]), LaunchClip (trackId, clipId, mode: 'one-shot'|'loop', followActions: { probability, action: 'next-scene'|'prev'|'stay'|'random' }), SessionLauncher state machine, SessionViewComponent (React grid of scene rows × track cols, clickable clip buttons), engine scene scheduler
• Implementation notes: Add Scene interface (id, name, clips: { trackId → clipId }). Add FollowAction (probability 0..1, targetScene or action). SessionLauncher class: on clipLaunch(sceneId, trackId) dispatch clips from scene, set mode (one-shot arms 1-shot timer; loop is infinite). SessionViewComponent: grid layout, scene name column, per-cell clip button (color, state indicator 'playing'/'stopped'). Default: 8 tracks × 8 scenes. Scene triggering: one-shot clips stop after natural length; follow-action timers fire at scene end.

REC-17 Looper quantization (snap recording boundaries to bar/beat grid) — P2 · S · 🔴 missing#

• What & why: Looper (if implemented) should auto-quantize recording start/end to nearest bar or beat. E.g., press Record at beat 2.3 → quantize to beat 3.0. Euterpe has quantizeBeat() in clip-recorder.ts; extend to looper.
• SOTA reference: Boss RC-500 looper (quantize mode toggle), Ableton Looper (quantize + fade time), hardware loopers (quantize grid sync)
• Depends on: LooperSession extend quantizeMode (off/'beat'/'bar'/'half-bar'), recordStart/recordEnd snap-to-grid logic
• Implementation notes: LooperSession.startRecord() records playhead beat; on stop, snap endBeat to quantizeMode grid. E.g., quantizeMode='bar': round endBeat down to bar (floor(endBeat)). Extend looperLength to nearest grid boundary. UI: dropdown in LooperUI (Off / Beat / Bar).

REC-9 Latency compensation and track delay alignment — P2 · M · 🔴 missing#

• What & why: Measure and compensate for system I/O latency + DSP plugin delay (convolver, reverb tails). Display per-track delay (samples) for manual alignment with hardware recordings. Critical for punch-in/loop-recording accuracy. Euterpe engine has no latency model.
• SOTA reference: Pro Tools (automatic input delay compensation, per-track delay slider in I/O window), Logic (Smart Tempo analysis + automatic sync), Bitwig (per-track delay compensation in mixer), Reaper (zero-latency monitoring mode + precise sample-count I/O alignment)
• Depends on: Engine latency reporting (measureLatency() via roundtrip test), TransportState add systemLatencySamples, TrackState add delayCompSamples, channel-strip UI slider (0-5000 samples), automatic latency detection (click generator → mic input → round-trip timer)
• Implementation notes: At startup: play a click, measure round-trip time to input via correlation. Store systemLatencySamples in transport state. Per-track delay slider in channel-strip (scale 0-5000 samples = 0-100ms @ 48kHz). On recording: shift playhead reference by (systemLatencySamples + trackDelayCompSamples) so recorded notes/audio align with engine clock. For plugin latency: DSP graph each plugin reports its delay; sum per-insert chain.

REC-11 Polyphonic MIDI recording with velocity/pitch/timing capture — P2 · M · 🟢 polish#

• What & why: ClipRecorder (clip-recorder.ts) captures polyphonic MIDI note-on/off with velocity. Currently wired into piano-roll for keyboard/MIDI input. Extend to capture all MIDI CC, pitch-bend, aftertouch, and per-note timing with microsecond precision (for humanization). Improve from 'quantized to beat grid' to 'capture raw, quantize optionally'.
• SOTA reference: Ableton (note recording with velocity, timing offset per-note), Logic (MIDI recording with all CC captured, flex-time for timing adjustment), Pro Tools (MIDI editing with raw timing display), Studio One (note-to-grid timing lane for per-note swing)
• Depends on: ClipNote extend with timingOffsetBeats (raw capture vs. quantized), ClipRecorder extend noteOn/noteOff to accept beatOffset (playheadBeat + microTiming), MIDI parser include CC/pitch/aftertouch, UI timing lane slider for per-note humanization
• Implementation notes: ClipNote interface add: timingOffsetBeats (−0.25..+0.25 = ±6th-note swing), ccData: { cc, value }[], pitchData: { beatOffset, cents }[]. On MIDI input: parseMidiMessage returns not just note-on/off but full event (status, cc, value, timestamp in μs). ClipRecorder.noteOn(pitch, velocity, beat, timingOffset) stores raw timing. On quantize: floor(beat + timingOffset) → new beat. UI: timing lane (per-note micro-timing inspector) + humanize slider (0–0.25 beats random ±).

REC-15 Clip automation recording (envelope capture during performance) — P2 · M · 🔴 missing#

• What & why: Record parameter changes in real-time (fader moves, knob tweaks, envelope mod) and store as automation curves per-clip. Currently automation-lane.tsx allows manual SVG editing; enable live capture during playback/record.
• SOTA reference: Logic (automation mode: read/write/touch/latch per-track parameter), Pro Tools (automation record with write/touch/latch modes), Ableton (MIDI CC map → automation curve on clip), Bitwig (per-track performance recording + modifier key automation), Studio One (automation track per-parameter)
• Depends on: AutomationWriteMode (off/write/touch/latch), transport UI mode selector, parameter touch detection (knob/fader mousedown = touch start, mouseup = touch end), automation curve recording during playback, clip-level automation vs. track-level (merge or separate?)
• Implementation notes: Add writeMode to transport state. On fader/knob input: if writeMode !== 'off', record breakpoint at current playhead beat. Touch mode: record while held, silence after release (last value holds). Write mode: record continuously on release. UI: dropdown (Off / Read / Write / Touch / Latch) in transport-bar. Automation data: per-track per-parameter (volumeAutomation, panAutomation, etc.) += breakpoint (beat, value). Merge clip + track automation: (clip envelope) * (track automation gain).

REC-16 Undo/redo for recording actions (take management, take comp selection) — P2 · M · 🟢 polish#

• What & why: Currently daw-session.ts reducer supports undo/redo for parameter edits and pattern changes. Extend to track comping selections, take deletions, take reordering. Ensure undo history survives audio bouncing and clip export.
• SOTA reference: Logic (undo/redo for take folder edits + comp selection), Pro Tools (undo/redo for playlist/take ops), Ableton (undo/redo for clip placement + comping)
• Depends on: UndoStack extend to track ComppingAction, TakeAction, extend daw-session.ts reducer to emit undo-able actions for take ops (selectComppedTake, deleteTake), UI undo/redo shortcut integration
• Implementation notes: Each take op (selectComppedTake(sceneId, trackId, takeIndex)) → daw-session reducer emits ({ type: 'takeComppedTake', ... } action) → undo stack pushes old state. On undo: restore prior take selection. Test: record 3 takes, comp selections, undo to restore take 1 comp, redo to restore take 3.

REC-12 Multi-track recording with synchronized live input across tracks — P2 · L · 🔴 missing#

• What & why: Record simultaneously into multiple tracks (e.g., drums on track 1, bass on track 2, synth on track 3) with sample-accurate sync. Currently audio-capture.ts arm/record targets a single track. Enable arming multiple tracks and recording all inputs in parallel to their respective captures.
• SOTA reference: Pro Tools (record to multiple tracks simultaneously via Destructive Record or playlist), Logic (record to single or bus), Ableton (no native multi-track record; users layer clips), Studio One (record multiple MIDI/audio tracks via selected input source routing)
• Depends on: RecordingSession extend armedTracks: Set, record() captures per-track via track-specific input source (if MultiTrack API available), or round-robin if single input (e.g., different MIDI channels per track), UI track-by-track arm buttons
• Implementation notes: RecordingSession.armTrack(trackId, inputSource) adds to armedTracks set. On record frame: for each armedTrack, downmix input if needed (MIDI by channel, audio by input device) and append to that track's CaptureBuffer. Requires per-track input routing in TrackState (inputSource: 'MIDI-ch-1'|'audio-device-1'|etc). UI: red 'arm' circle in channel-strip per-track toggles arm state for that track.

REC-14 Mackie Control Universal (MCU) and HUI protocol support — P2 · L · 🔴 missing#

• What & why: Decode/respond to Mackie Control protocol (fader motorized updates, button LED feedback, LCD display) and HUI (Eucon) protocol for console-style control. Enable using classic Mackie MCU, PreSonus Quantum, or other MCU-compatible surfaces without custom mapping.
• SOTA reference: Pro Tools MCU driver (factory support), Logic (Mackie Control + Eucon support), Bitwig (MCU protocol built-in), Reaper (MCU + HUI + Mackie-XT protocol)
• Depends on: Mackie MCU protocol parser (sysex + MIDI CC standard), HUI protocol parser, MidiLearnUI extend to list surface type (MCU/HUI) + surface slot (fader 1-8, rec button, etc.), feedback engine (write LED state, fader position back to surface)
• Implementation notes: Mackie protocol: sysex F0 00 00 66 05 [cmd] ... F7. Decode fader position (0xE0-0xE7 = 8 channels), button press (0x90 + note = button #), pan/select buttons. Map to DAW actions: E0 fader → setTrackGain, 50 (rec button) → toggleRecord, etc. Feedback: motorize faders by sending E0 after setTrackGain. LCD display: show track names (channel-strip UI). Surfaces config: load from JSON profile { 'fader-1': 'track-0-gain', 'button-rec': 'record-toggle' }.

REC-13 VST3 / CLAP plugin hosting (audio insert + MIDI side-chain) — P2 · XL · 🔴 missing#

• What & why: Host external VST3 or CLAP plugins as insert effects and send sources. Euterpe has a fixed 10-effect insert rack (EQ, comp, reverb, delay, etc.); VST/CLAP hosting would allow unlimited 3rd-party tools (e.g., iZotope Ozone, Serum, Soundtoys). Requires sandboxed plugin loader + audio/MIDI IPC.
• SOTA reference: Ableton Link (plugin standard, but not open VST yet; Max4Live scripting only), Logic (AU plugin hosting), Pro Tools (AAX plugin hosting), Bitwig (VST3 + CLAP hosting), Reaper (VST2/VST3/CLAP hosting + extensive scripting), Studio One (VST3 + ReWire), Juce PluginHost (reference VST3 multi-plugin host)
• Depends on: VST3/CLAP SDK integration (Juce or Steinberg SDK), native plugin loader (Tauri sidecar binary for Windows/Mac/Linux), audio IPC (shared-memory ring-buffer for sample I/O, or FFI for real-time constraints), MIDI sidechain routing, UI plugin selector dialog + per-plugin parameter automation UI, bypass per-plugin
• Implementation notes: Create VST3/CLAP host binary in Rust (Juce or vst3-rust binding). Tauri bridge: IPC protocol for load/init/process/set-param/get-param. Insert rack: add PluginInsert type (VST) alongside existing EQ/comp inserts. On per-block process: (1) convert engine samples to VST format, (2) send over IPC with MIDI events + CC params, (3) receive processed output, (4) mix into master. Fallback: sandboxing constraints may limit adoption on web (WASM VST subset or server-hosted plugin render). For shipping: negotiate plugin licensing per-vendor.

REC-19 Glide / portamento parameter with per-voice glide time — P3 · S · 🟢 polish#

• What & why: Euterpe synth has glideSec in SynthPatch (current state: daw-session.ts DEFAULT_PATCH.glideSec = 0). Ensure glide is wired to engine and works across note boundaries in polyphonic scenarios. Add UI slider in synth-panel for glide time (0-2 sec).
• SOTA reference: Ableton Wavetable (glide with glide mode: fixed/relative, per-voice), Logic ES2/Alchemy (glide time + mode), Juno-60 (portamento with 0-60 second ramp)
• Depends on: synth-panel.tsx add glide time slider UI, verify engine PolySynth applies glide (frequency ramp on note-on), per-voice glide target tracking
• Implementation notes: SynthPatch.glideSec is already defined. UI: add range slider 0-2 sec in synth-panel.tsx. Engine: PolySynth.noteOn(pitch) schedules frequency glide from currentFreq to newFreq over glideSec. Verify per-voice (not global) glide to avoid stuck pitches.

REC-20 Automation lane envelope / adsr-style preset buttons — P3 · S · 🔴 missing#

• What & why: Add quick automation presets: (1) fade-in (0→max over X beats), (2) fade-out (max→0 over X beats), (3) swell (0→max→0 envelope), (4) dip (max→0→max), (5) sustained ramp. UI: button row in automation-lane.tsx to apply preset to selected lane.
• SOTA reference: Logic (automation curve preset shapes), Pro Tools (automation commands with pre-canned envelopes), Ableton (MIDI envelope shapes for clip automation)
• Depends on: automationLanePresets: { name, factory: (startBeat, endBeat, maxValue) → AutomationPoint[] }, UI button row in automation-lane.tsx, keyboard shortcut to apply
• Implementation notes: Presets function: fadeIn(1, 4, 0, 12) → [{beat: 1, dB: 0}, {beat: 4, dB: 12}]. swell(1, 3, 5, 12) → [{beat: 1, dB: 0}, {beat: 3, dB: 12}, {beat: 5, dB: 0}]. UI: 5 buttons in automation-lane header, right-click to set time span. Test: select volume lane, click 'fade-in', confirm breakpoints appear.

REC-22 One-shot sample triggering with tail handling (reverb decay, delay repeats) — P3 · S · 🔴 missing#

• What & why: When a one-shot clip finishes playback, ensure reverb/delay tails ring out naturally (configurable tail time: 0-5 sec) instead of abrupt stop. Currently sampler has no tail model; uses natural sample length.
• SOTA reference: Logic (smart-tail handling for one-shot samples, determines tail from reverb send), Pro Tools (implicit tail from plugin latency), Bitwig (tail time setting per-sample clip)
• Depends on: ArrangementClip extend with tailMs (implicit tail from reverb-send time + reverb decay time), DSP graph extend sample playback to add silence after sample end for tailMs duration
• Implementation notes: Calculate tail: if sendReverb.room > 0 and sample is one-shot, add implicit tail (reverb decay time ~ room * 2 sec, up to 5 sec max). On clip end playhead: don't stop track immediately; let sends ring for tailMs. UI: one-shot clip inspector shows 'tail: 2.5 sec' calculated or user-override slider.

REC-18 Mixer snapshot / preset recall (song or session state save/load) — P3 · M · 🔴 missing#

• What & why: Save mixer state (all fader positions, mute/solo, insert configs, send levels, automation curves) as a named preset. Recall entire state in one click. Useful for switching between mixes, saving "before/after" for comparison, or multi-session management.
• SOTA reference: Ableton Mixer Snapshot, Logic Mixer Snapshots, Pro Tools AAA (Advanced Automation Archive), Bitwig (arrangement-level scene snapshot), Mackie MCU (fader memory banks)
• Depends on: MixerSnapshot interface (name, timestamp, dawSession partial snapshot with all track/master state), SnapshotManager (save/list/load/delete), UI modal with snapshot list, hotkey to recall snapshot
• Implementation notes: Snapshot is a partial DawSession { tracks: TrackState[], masterGainDb, masterEq, masterComp, ... }. Save: JSON file or localStorage. UI: top menu "Snapshots" → list of saved mixes (name + timestamp). Click to load, or keystroke to recall last N snapshots. Test: save "rough mix", adjust, load to restore.

REC-21 Sample-accurate crossfade at clip boundaries in arranger — P3 · M · 🔴 missing#

• What & why: When clips are adjacent in the arrangement, auto-insert a small fade-out/fade-in (5-100ms) to avoid clicks/pops. Currently clip placement has no crossfade model.
• SOTA reference: Pro Tools (auto-crossfade on adjacent clips, settable fade length), Logic (smart crossfade option per-clip), Bitwig (auto-crossfade toggle in preferences)
• Depends on: ArrangementClip extend with fadeInMs, fadeOutMs, dsp-graph extend clip playback to apply per-clip fades at start/end, UI slider in clip properties for fade time
• Implementation notes: On clip boundary: if nextClip.startBar == currentClip.endBar, apply fade-out to currentClip ending (final fadeOutMs) and fade-in to nextClip start (first fadeInMs). DSP: gain envelope (linear fade) on sample blocks at clip boundaries. Default 10ms. UI: clip context-menu "Fade Out" slider (1-500ms).

REC-23 Real-time binaural cue mixing for headphone performers — P3 · M · 🔴 missing#

• What & why: Provide a separate binaural cue mix (headphones-only output) with per-source panning and level independent of main stereo mix. Useful for live performers monitoring different mixes (drummer hears kick + snare loud, bassist hears kick + bass). Extends input-monitoring (#8) with cue-bus effects.
• SOTA reference: Pro Tools (cue mixing with independent pan/send levels), Logic (headphone cue bus with separate fader per send), RME TotalMix (hardware control room), Presonus StudioLive (cue mix per-channel)
• Depends on: CueMixState (per-track cuePan, cueGain, cueReverbSend, cueDelaySend), audio-worklet dual-output path (main + headphones/cue bus), transport UI or settings panel for cue mixing, headphone/cue output selection in browser audio
• Implementation notes: Add CueMix state parallel to main mix. Each track sends to both main and cue bus independently. Cue bus: separate reverb/delay tanks (or shared, based on design). Output routing: Web Audio DestinationNode for cue (requires user selecting 'headphones' output device, or dual-output hardware). UI: cue-mix fader column next to main fader column in channel-strip. Test: set cue gain for track 1 to +6dB while main is 0dB; verify only headphones hear louder.

COLLAB-9 Access control & granular permissions (role-based + resource-level) — P0 · M · 🟡 partial#

• What & why: Project-mgmt has RolePermissions (owner/admin/editor/viewer/guest with capabilities) and canPerformAction function, but never used in DAW or BFF. Add: (1) Enforce permissions on every mutation (track add, clip edit, delete, etc.). (2) Display-level: disable buttons for viewers (view-only), dim buttons for editors (no delete). (3) API-level: BFF checks user role before accepting mutations. (4) Permission presets (owner, editor, commenter, viewer per share link). (5) Invite dialog to add collaborators by email, assign role, set expiry. Pro Tools has limited (track-level lock). Pro Tools has track/edit permissions. Figma has role inheritance. This is critical for trust in shared sessions.
• SOTA reference: Pro Tools (track + edit permissions), Figma (role-based: owner/editor/viewer), Splice (implicit: owner only), BandLab (owner/collaborator/viewer roles), Google Workspace (editor/viewer/commenter)
• Depends on: Cloud project storage (project.ownerId, projectMembers[]), project-mgmt role-permission functions (already exist), daw-session auth context (identity-billing.ts has user context)
• Implementation notes: In daw-session.ts reducer, wrap every action (ADD_TRACK, ADD_CLIP, DELETE_TRACK, etc.) with a canPerformAction check using currentUser role + action capability. Return error if denied. In BFF, add auth middleware that checks projectId ownership + role. In DAW UI, create Members panel (transport bar "Members" button) → list collaborators, role badges, add/remove buttons (owner only). Add Invite dialog: email field + role dropdown → POST /api/projects/:projectId/invitations (from project-mgmt). Disable track/clip edit buttons if currentUser.role === 'viewer'. Show permission tooltips on hover ("Viewers cannot edit tracks").

COLLAB-1 Real-time WebSocket sync route & multiplayer state machine — P0 · L · 🔴 missing#

• What & why: Add a production WebSocket endpoint /api/collab/sync (or /generation/realtime/collab under BFF) that accepts and broadcasts CRDT sync operations. Server-side replica state (Yjs doc or Automerge doc) to handle incoming ops from multiple clients, compute OT transforms, broadcast converged state. No such endpoint exists; the sync-engine module is pure-algorithmic with no transport. Needed to go from single-user local JSON to multi-user cloud. Should include connection heartbeat, disconnect/rejoin recovery, conflict detection log.
• SOTA reference: Soundtrap/BandLab (real-time auto-sync), Yjs ecosystem (WebSocket provider + server state machine), Sesh (cloud sync API), Automerge server implementations (GitHub Automerge repo examples).
• Depends on: Existing sync-engine module, Yjs or Automerge library choice, WebSocket provider pattern (server-side CRDT host)
• Implementation notes: Create /apps/oshun/bff/src/routes/collab-sync-realtime.ts with Fastify/WebSocket. Use Yjs Y.Doc with y-websocket provider for proven production-grade CRDT + transport. Client (DAW) imports y-websocket or similar; server holds Y.Doc replica, broadcasts updates. On DAW side, add /apps/euterpe-studio-web/src/daw/collab-sync.ts that wraps Y.Doc mutations (track add = Y.Map mutation, note insert = Y.Array push, automation = Y.Map.observe). Per-track selective sync via TrackSyncConfig already in sync-engine; use it to filter which tracks sync. Latency compensation: apply local ops optimistically (confirmOptimistic in sync-engine), rollback on conflict. Test: spawn 2 browser tabs, edit same track concurrently, verify convergence.

COLLAB-2 Cloud project storage & retrieval (database + S3) — P0 · XL · 🔴 missing#

• What & why: Projects currently save locally as JSON + base64 audio. Add: (1) database schema (Postgres) for projects table (id, ownerId, name, description, createdAt, updatedAt, parentProjectId for branching, archivedAt); (2) S3/GCS bucket for audio blobs (sample library, rendered stems); (3) BFF endpoints POST /api/projects (create), GET /api/projects/:id (fetch full project + audio manifest), PUT /api/projects/:id (update + version bump), DELETE (soft-delete = archive). (4) DAW integration: serialize current daw-session state → JSON, POST to /api/projects (blob audio separately to S3). (5) Cloud load: GET /api/projects/:id → hydrate daw-session, fetch S3 audio URLs, resume playback. Currently no backend persistence at all for multi-user.
• SOTA reference: Splice Studio (unlimited version backup to cloud, integrates plugin), Pro Tools (cloud project metadata + tracks), BandLab/Soundtrap (entire project in cloud), Sesh (cloud render ingestion)
• Depends on: Database (Postgres), object storage (S3 or GCS), DAW session serialization already exists (daw-session.ts reducer), audio blob encoding (wav.ts)
• Implementation notes: Create /apps/oshun/bff/src/models/project.ts (Postgres schema + queries). Create /apps/oshun/bff/src/routes/projects-route.ts (POST/GET/PUT/DELETE). Add S3 presigned URL helpers in /apps/oshun/bff/src/adapters/s3.ts. On DAW side, create /apps/euterpe-studio-web/src/daw/cloud-persist.ts with functions saveProjectToCloud(session, projectId), loadProjectFromCloud(projectId). Hook into daw-session reducer: after every action, debounce (500ms) save-to-cloud. On app load, detect if rehydrating from cloud (URL param ?projectId=xxx) vs creating new. Handle audio blob streaming: don't embed 50MB base64 in JSON; instead POST audio chunks to S3, store S3 keys in project metadata.

COLLAB-4 Shareable links with expiry & granular permissions — P1 · M · 🔴 missing#

• What & why: File-sharing module has ShareLink, PermissionLevel, expiry logic, but it's never instantiated in DAW or backend. Add: (1) ShareLink creation UI button ("Share Project"). (2) Dialog with link generator, copy-to-clipboard, permission level selector (view-only, edit, comment). (3) Expiry date picker (default 7 days, or never). (4) Public URL (euterpe.app/share/abc123 redirects to rehydrate project in read-only or edit mode). (5) Backend validation: GET /api/share-links/:token checks expiry, returns project data + permissions. (6) Access control: mark project as shared, BFF returns SharedProject schema (same as Project but with visibility=public, permissions=[{userId: null, role: 'viewer'} for public links]). Frontend checks permission before allow editing. Splice/Pro Tools do this; Ableton does not.
• SOTA reference: Figma shareable links (permission levels), Splice Studio (timeline comments on shared links), Frame.io (approval links with expiry), Pro Tools (limited track-level sharing links)
• Depends on: Cloud project storage, file-sharing module (has the types, just need to wire), daw-session reducer (check permissions before mutation)
• Implementation notes: In /apps/oshun/bff/src/routes/share-links-route.ts: POST /api/share-links (create, return token + public URL), GET /api/share-links/:token (verify, return project + permissions). In DAW, add "Share" button to transport bar → dialog collects permission level + expiry → POST /api/share-links → show public URL. On app load, detect ?shareToken=xxx param → GET /api/share-links/xxx → hydrate project in read-only (or edit if permission='editor'). Restrict mutations based on currentUser permission via middleware (canPerformAction from project-mgmt already checks this).

COLLAB-5 Multi-user presence indicators & cursor positions — P1 · M · 🔴 missing#

• What & why: Sync-engine has UserPresence, CursorPosition, updateActivity, updateStatus, but no UI. Add: (1) Presence sidebar listing active collaborators (online/away/idle status, color avatar, last-seen time). (2) Per-track cursor indicators showing which track(s) each user is editing (caret on track name, colored highlight). (3) Selection cursors in piano-roll: when user A selects notes, user B sees a colored highlight box around them. (4) Activity badge (e.g., "Alice is recording" or "Bob is editing automation"). Soundtrap/BandLab show this; Splice does not (async). Pro Tools shows presence but limited to track locks.
• SOTA reference: Soundtrap (real-time presence), BandLab (collaborator list), Figma (cursor + selection cursors), Google Docs (presence sidebar)
• Depends on: WebSocket sync route, sync-engine presence functions (already exist), daw-session awareness of active users
• Implementation notes: In sync/WebSocket handler: on every client message, updateActivity(presence, 'editing-tracks'). Broadcast presence changes to all clients. On DAW, subscribe to presenceUpdates observable. Create /apps/euterpe-studio-web/src/components/daw/presence-sidebar.tsx: list presences, show color avatar, activity label. In track list, add presence indicator per track (colored dot if someone is editing). In piano-roll, render CursorPosition as colored overlay rect (user A's selection = light red, user B's = light blue). Use Y.Awareness (built into Yjs) to handle presence without extra sync; it's designed for this.

COLLAB-6 Inline comments on tracks, clips, and timeline regions — P1 · M · 🔴 missing#

• What & why: Project-mgmt has FileComment and AudioAnnotation (timestamped), but never wired. Add: (1) Right-click context menu on track/clip → "Add comment". (2) Comment panel opens with text input + @mention support. (3) Comments pinned to track-id or (trackId, clipId, startBeat, endBeat) ranges. (4) Comment thread shown in sidebar, resolved/unresolved status. (5) Notification when replied to. (6) Resolved comments collapse or hide. Splice has timeline comments; Pro Tools has track comments; Figma has frame comments. This is SOTA for async review.
• SOTA reference: Figma comments (frame-level, threads, resolved), Splice Studio (timeline comments), Pro Tools (track notes, limited), Frame.io (approval comments)
• Depends on: Cloud project storage (comments persist), daw-session track/clip IDs (already exist), notification system (in project-mgmt but not wired)
• Implementation notes: Extend daw-session.ts reducer with commentsState: CommentThread[]. Add comment creation action: ADD_COMMENT(trackId, clipId?, beat?, text, authorId). Store in Yjs Y.Map for real-time sync. In DAW UI, add right-click handler on track-header + clip → showCommentDialog. Show comment threads in sidebar (or floating panel). Mark resolved via UI toggle → updateComment action. Notify users when new comment on their track (via project-mgmt's notification system). Threads = Y.Array, observe for real-time updates.

COLLAB-8 Conflict resolution UI & automatic merge strategies — P1 · M · 🟡 partial#

• What & why: Sync-engine has resolveConflict(strategy: 'last-writer-wins' | 'merge' | 'manual') and MergeConflict type, but no UI prompt when conflicts occur. Add: (1) When a sync conflict is detected (OT transform failure or 3-way merge conflict), show a modal with: base value | ours value | theirs value, radio buttons to pick winner. (2) Auto-merge button for non-conflicting changes (both editors added different tracks → merge succeeds). (3) Conflict log in sidebar. (4) Undo full merge if user changes mind. Logic Pro has no conflict UI; Splice has none (async); Pro Tools has none. Bitwig planned. This is SOTA for true co-editing.
• SOTA reference: Git CLI (conflict markers + resolution), Figma (auto-merge on non-conflicting layers), Automerge docs (3-way merge with conflict reporting), Yjs examples (conflict-free by design, but document-level conflicts on manual edits still need UI)
• Depends on: Real-time sync route (to detect conflicts), threeWayMerge + resolveConflict functions (already implemented)
• Implementation notes: In sync/WebSocket handler, when OT transform or 3WM detects conflict: emit ConflictEvent to client. In DAW, subscribe to conflictEvents observable. Show modal: 3-column UI (base | ours | theirs) with radio select + auto-merge checkbox. On "Accept ours" click, apply ours locally + broadcast resolution. Log conflict in conflicts[] state. Show conflict log in sidebar with timestamp, author, path. Undo merge: revert to pre-merge snapshot (via branch/version history). Test with 2 clients editing same clip velocity concurrently.

COLLAB-10 Workspace & team management (projects, members, invitations) — P1 · M · 🔴 missing#

• What & why: Project-mgmt has createWorkspace, addMember, createInvitation, acceptInvitation, all with tests. But no DAW UI to create workspace, invite teammates, set team name/avatar/billing contact. Add: (1) Workspace settings page (top-level organization). (2) Members list with role assignment UI. (3) Invite teammates by email (send invite link via email with expiry). (4) Member status: active/invited/revoked. (5) Bulk import CSVs. (6) Billing seat management (tied to identity-billing). This is table-stakes for pro/team tier. Not SOTA but blocking serious adoption.
• SOTA reference: Figma Teams (workspace, member roles, billing seats), Slack (workspace, members, invitations), Pro Tools (Cloud Organization with seats), Splice (team accounts with seat management)
• Depends on: Cloud project storage (tie projects to workspace), identity-billing (team tier + seat entitlements), email service (SES or SendGrid for invites)
• Implementation notes: Create /apps/euterpe-studio-web/src/components/workspace-settings.tsx: form to edit workspace name, avatar, billing email. List members in table with role + remove buttons. Add "Invite teammate" button → modal collects email + role + expiry (7 days default) → POST /api/workspaces/:workspaceId/invitations. Send email via BFF handler with magic link (token embedded in URL). On link click, acceptInvitation action. Hook to identity-billing: team tier allows N seats, UI shows "X/5 seats used".

COLLAB-19 Offline-first sync with local IndexedDB + service worker — P1 · M · 🔴 missing#

• What & why: Currently, DAW is online-only (WebSocket sync). Offline editing should: (1) Queue mutations in IndexedDB. (2) Continue editing DAW (optimistic). (3) On reconnect, replay queued ops (rebaseQueue in sync-engine). (4) Service worker caches DAW UI + audio assets. (5) Show "offline mode" banner. (6) Sync status indicator (synced/syncing/offline/conflict). This is critical for mobile/unstable networks. Not SOTA (Figma does this; Ableton doesn't). Essential for Euterpe's web-first strategy.
• SOTA reference: Figma (offline + sync on reconnect), Google Docs (offline editing + sync), Notion (offline + sync), Yjs provider ecosystem (y-indexeddb for offline queue)
• Depends on: Real-time WebSocket sync, daw-session reducer, IndexedDB access, service worker registration
• Implementation notes: Create /apps/euterpe-studio-web/src/daw/offline-queue.ts. On every daw-session action, if offline, enqueue to IndexedDB (idb.openDB + store operations). Create service worker (src/sw.ts) that caches app shell (HTML, JS) + audio assets (small samples). On online event, dequeueOperation loop → transform against remote state (rebaseQueue) → POST sync ops → if conflict, show conflict resolution UI. Use navigator.onLine + 'online'/'offline' events. In daw-session, add syncStatus state (synced/syncing/offline/conflict). Show banner with status + retrying indicator.

COLLAB-21 Neural stem separation (SOTA models like Demucs/HTDemucs on device or cloud) — P1 · M · 🟢 polish#

• What & why: DAW uses classic HPSS (Fitzgerald 2010). SOTA is now neural: Demucs (4-source), HTDemucs (4-stem, better), MDX-Net (10+ sources). Cloud options: LALAL.AI (10 sources), AudioShake, RipX. Add: (1) Stem separation dropdown: Classic HPSS vs. Cloud HTDemucs. (2) If cloud, POST audio to /api/stem-separate with model choice → S3 return URLs. (3) Progress + ETA. (4) Model selection UI (sources: 4 vs. 10, speed/quality tradeoff). Current implementation: user perceives Euterpe's HPSS as outdated vs. BandLab/Soundtrap's cloud renders. Moving to neural closes gap.
• SOTA reference: Demucs (open-source, SOTA accuracy), HTDemucs (4-stem SOTA), LALAL.AI (10 sources, cloud), Splice (integration), AudioShake (cloud + licensing), iZotope RX12 (Music Rebalance with neural)
• Depends on: Cloud render infrastructure (above), ONNX Runtime or MLX sidecar for on-device, audio-streaming (for cloud upload), S3 for outputs
• Implementation notes: In sampler-panel.tsx, expand "Split stems" dropdown: "Classic HPSS" (current, local) | "Cloud HTDemucs" (4-stem, fast) | "Cloud Demucs" (4-source, slower) | "Cloud LALAL" (10 sources, premium). If cloud selected, POST /api/stem-separate { audioUrl, model } → BFF enqueues job. Download models from Hugging Face on first use (cache). For on-device: use onnx-runtime-web or MLX (Apple silicon) to run Demucs 4-stem locally (WASM, ~100MB model). Show model selector + quality/speed slider. Progress bar with ETA based on file size + model.

COLLAB-3 Project versioning, branching & merge UI — P1 · L · 🟡 partial#

• What & why: The sync-engine has createSnapshot, createBranch, advanceBranch, threeWayMerge, getSnapshotChain (all tested), but there is no UI to browse/checkout versions, create branches, or resolve merges. Add UI panels: (1) Version history sidebar (shows timeline of snapshots, author, timestamp, message). (2) Checkout button → restore snapshot to current working state. (3) Create branch dialog (from current snapshot). (4) Switch branch dropdown. (5) Merge dialog (if on branch, compare base/ours/theirs, show 3-way conflicts as red highlights on tracks/clips, allow manual resolve or auto-merge). Splice has comment-per-revision; Bitwig/Ableton do not expose versioning UI. This is a competitive feature.
• SOTA reference: Git (versioning, branching, merge paradigm — DAW analogue), Splice Studio (version comments), Adobe Versions (file versioning), Pro Tools (cloud archive but limited branching)
• Depends on: Cloud project storage (above), sync-engine snapshot/branch functions (already implemented), daw-session reducer integration
• Implementation notes: Create /apps/euterpe-studio-web/src/components/daw/version-history-panel.tsx: list snapshots, each with author avatar, timestamp, commit message input, checkout button. Store message in snapshot.label. Add branch selector dropdown in transport bar. Add "New Branch" button that calls createBranch(snapshotId). On branch switch, updateDawSession with snapshot.data. On merge, detect conflicts via threeWayMerge (path key), highlight conflicting track/clip in UI (red underline). Conflict resolution: left/right/ours/theirs buttons per conflict. Full merge workflow: 2 branches, git-style 3-way on merge button click.

COLLAB-18 Yjs or Automerge library integration (replace custom sync-engine where beneficial) — P1 · L · 🟡 partial#

• What & why: Euterpe's sync-engine is a good foundation (CRDT primitives, OT, conflict resolution) but custom-built. For production, Yjs (920K weekly downloads, 17K stars, proven in Figma-like apps) or Automerge (Git-like versioning, 600ms for 260K keystrokes) would reduce custom code and improve reliability. Evaluate: (1) Can Yjs replace sync-engine for track/clip mutations? (2) Can Automerge's change history replace version snapshots? (3) Hybrid: use Yjs for real-time sync (CRDT mutations) + Automerge for branching/merging (change-based history). This reduces risk and speeds rollout.
• SOTA reference: Yjs ecosystem (y-websocket, y-indexeddb, y-protocols), Automerge.js (change-based CRDT with Git-like history), Figma (likely Yjs-based per job descriptions), Notion (likely Yjs-based), Sesh (unknown, but cloud rendering first), Reddit collab projects (Yjs wins for speed, Automerge for UX).
• Depends on: None; this is an evaluation + potential refactor
• Implementation notes: Create an evaluation branch. Integrate yjs npm package. Refactor daw-session.ts to use Y.Map/Y.Array for tracks/clips/automation. Test concurrent edits (2 browser tabs). Benchmark sync-engine vs Y.Map latency. If Yjs wins, gradually migrate; keep sync-engine for fallback/offline. Alternatively, keep sync-engine for algorithmic tests but layer Yjs for transport. For branching, evaluate Automerge.Repo (change history) vs. manual snapshots. Decision criteria: code reduction, test coverage, team familiarity, upstream maintenance.

COLLAB-13 Notification system (desktop + in-app alerts) — P2 · S · 🔴 missing#

• What & why: Project-mgmt has Notification, createNotification, markAsRead, shouldNotify, createDefaultPreferences. Not wired. Add: (1) In-app toast/banner when user is mentioned in comment or invited to project. (2) Desktop notifications (Notification API) if focused on different tab. (3) Email digests (daily/weekly) for project activity. (4) Notification settings per project (mute, important only, etc.). This enables async review and keeps users engaged.
• SOTA reference: Slack (desktop + email notifications, mute settings), Figma (in-app comments + email), Notion (mention + activity digest)
• Depends on: Real-time sync (for notification trigger), email service (for digests), daw-session notification state
• Implementation notes: In daw-session, add notificationsState. On COMMENT_ADDED action with @mention, create notification. Subscribe to notificationsObservable in React component. Show toast via react-hot-toast or custom Toast component. For desktop notifications, request Notification permission and fire notification('You were mentioned by Alice'). For email digests, create a cron job in BFF that runs daily, queries activityLog for users' projects, sends email summary. Store NotificationPreferences per user in identity-billing table.

COLLAB-15 Project templates & team workflows (standardization) — P2 · S · 🟡 partial#

• What & why: Project-mgmt has ProjectTemplate, GENRE_TEMPLATES (pop, hiphop, edm, classical, country), createTemplate, getTemplatesByGenre, applyTemplate. Not wired to UI. Add: (1) Templates library in project creation wizard ("Start from template"). (2) Filter by genre. (3) Preview template (shows track layout, bpm, key, initial clips). (4) "Save as template" from current project. (5) Team templates (shared library per workspace). (6) Template versioning (template inherits all collab features). This improves team velocity.
• SOTA reference: Ableton Live packs (templates), Logic Pro templates, Splice Sounds (sample packs as templates), BandLab (genre templates)
• Depends on: Cloud project storage, project-mgmt template functions (exist)
• Implementation notes: In project creation flow, add "Browse templates" step. Query getTemplatesByGenre on genre selection. Show template preview (cards with track count, BPM, key, cover art). On selection, applyTemplate(project, template) → populate daw-session with template tracks/clips/settings. For saving template: "Save project as template" button in settings → calls createTemplate(project, genre, name) → stores in templates table. For team templates: workspace scope, visible to all members (vs. public templates).

COLLAB-12 Activity feed & audit log (who did what, when) — P2 · M · 🔴 missing#

• What & why: Project-mgmt has ActivityEvent, createActivity, filterActivities, getRecentActivities. Not wired. Add: (1) Activity sidebar showing events ("Alice added track 'Vocal'", "Bob set gain to -3dB", "Carol commented"). (2) Timestamps. (3) Ability to revert to a state before an event (undo for other users' changes). (4) Audit log download (CSV). (5) Filtering by user/action type/date range. This is critical for transparency and debugging collab issues. Not SOTA but expected by pros.
• SOTA reference: Google Workspace (activity log with detail + rollback), Figma (activity panel with user avatars + timestamps), Notion (comments + edit history), Pro Tools (implicit via version history)
• Depends on: Real-time sync (log every SyncOperation), daw-session action tracing (wrap every reducer action with createActivity call)
• Implementation notes: In daw-session.ts, on every action dispatch, call createActivity(eventType, userId, trackId?, details) to log to activityLog state. Broadcast via CRDT sync so all clients see the same feed. In DAW UI, add Activity sidebar panel showing recent events, sorted by timestamp desc. Events format: "@Alice added Track 'Vocals' (04:35pm)". Add revert button on events (if user is owner/admin) → jump to snapshot before that event. Save activity feed to cloud as project.activityLog, searchable in BFF.

COLLAB-14 Rights management & split sheets (legal collaboration) — P2 · M · 🟡 partial#

• What & why: Rights-mgmt module (fully implemented, 200+ LOC) includes split sheets, collaborator agreements, PRO registration, master/publishing splits, digital signatures, dispute resolution, sample clearance, blockchain verification. Never wired. Add: (1) Rights panel in project settings. (2) Create split sheet → list contributors + roles (composer, producer, engineer, featured artist, etc.). (3) Allocation % (auto-calculate or manual entry). (4) PRO info per contributor (ASCAP/BMI/SESAC). (5) Publishing/master split tracking. (6) E-signature flow for agreement. (7) Export for legal (PDF). (8) Dispute log (if 2 contributors claim >50% of same right). This is critical for monetization and legal clarity. Splice/BandLab do minimal (split tracking only); Euterpe can lead here.
• SOTA reference: DistroKid/CD Baby/Tunecore (split sheet at release), SoundExchange (split tracking), blockchain music initiatives (Audius, Verifi Media for rights provenance)
• Depends on: Cloud project storage (attach split sheet to project), rights-mgmt module (already has all algorithms), email service (for e-signature), PDF generation library
• Implementation notes: In DAW project settings, add "Rights & Splits" tab. Create split sheet from project members: query projectMembers → initialize SplitSheet with 100%/N default splits. Allow editing per-member % + role (from ROLE_INFO constants in rights-mgmt). Show publishing/master splits summary (read-only, calculated from role). Add button "Send for signature" → generate SignatureRequest → email each contributor with URL to sign. Store signatures in projectData. On export, include split sheet as PDF attachment (use pdfkit or similar). For blockchain: optional checkbox "register on chain" → hash split sheet + store on Arweave (via ArIO) for permanence.

COLLAB-16 Async approval workflows & sign-off (for releases) — P2 · M · 🔴 missing#

• What & why: Project-mgmt has ApprovalWorkflow, ApprovalStatus, createApproval, submitForApproval, startReview, approveStep, rejectStep, isFullyApproved. Not wired. Add: (1) Approval panel in project. (2) Define approval steps (artist → producer → engineer → label → release). (3) Submit for approval button → move to step 1. (4) Approver sees project, can comment/reject (with revision request). (5) If rejected, back to submitter + revision task auto-assigned. (6) Approval chain shows progress (step 1 ✓, step 2 ⧖, step 3 ✗). (7) Email notifications at each step. This is critical for label/studio workflows.
• SOTA reference: Frame.io (approval workflows with feedback), Adobe Creative Cloud (review + sign-off), Slack/Monday.com (generic approval boards)
• Depends on: Cloud project storage, project-mgmt approval functions (fully implemented), notification system, email service
• Implementation notes: In project settings, add "Approvals" tab. Create workflow: list approval step names + assignees. Submit for approval → POST /api/projects/:projectId/approvals with workflow definition. Each step sends notification to assignee. Approver can approve/reject via UI. If reject, create RevisionRequest (auto-assigned to original submitter) + revert approval status. Show approval progress bar with step indicators. On full approval (isFullyApproved), unlock release button.

COLLAB-20 Advanced stem mastering & format-specific masters (SOTA mastering pipeline) — P2 · M · 🟡 partial#

• What & why: Master-mgmt has frontier-mastering module (LUFS presets, reference-EQ matching, compressor). Not wired for stem mastering (separate master per stem: vocals, drums, bass, other) or format-specific masters (Spotify −14, Apple −16, YouTube −18, TikTok, Atmos). Add: (1) Stem mastering UI: select which stems to master separately. (2) Apply mastering chain per stem (EQ + comp + limiter + sat). (3) Format master presets: user selects Spotify/Apple/YouTube → applies platform-specific target + ceiling. (4) A/B comparison tool (before/after inline). (5) Export format masters as separate WAVs. This is high-ROI: stem mastering is SOTA in studios; format masters are expected by distributors.
• SOTA reference: LANDR (stem mastering + format masters), iZotope RX/Ozone (mastering reference + matching), Splice Studio (cloud mastering if available), Abbey Road Studios plugins (stem-aware mixing)
• Depends on: Frontier-mastering module (exists but stubs), dsp-graph multi-stem render capability, S3 for format export
• Implementation notes: In mastering.ts, expand from single master to stems[]: StemMaster[]. Each stem gets its own ChannelStrip (EQ, comp, limiter, saturation). Add UI: "Stem mastering" checkbox → select stems (vocals/drums/bass/other via stem-separation output). Each stem rendered separately via Engine.render(stem.source, ...). Apply format master presets: POST /api/master-format?format=spotify → server applies LUFS target + ceiling → stream back. In DAW, add "Export format masters" button → triggers cloud render for each platform (async jobs) → returns S3 URLs. A/B compare: toggle before/after visualizer (spectrum/loudness meter) side-by-side.

COLLAB-11 Video conferencing integration (WebRTC with DAW audio mixing) — P2 · L · 🔴 missing#

• What & why: Video-conf module (22KB, fully implemented with WebRTC, screen sharing, recording, virtual backgrounds) exists but is never instantiated. Add: (1) Video call button in collaboration panel. (2) WebRTC peer connection setup (STUN/TURN servers). (3) Participant grid (own cam, others' cams, screen share). (4) DAW audio mixing: collaborators hear the DAW mix + each other's voices (loopback capture of DAW output + WebRTC audio track). (5) Screen share of DAW timeline (for showing what you're working on). (6) Session recording (H.264 video + audio). (7) Breakout rooms for discussion. BandLab/Soundtrap have built-in video. Ableton/Logic do not. This is SOTA for async remote sessions.
• SOTA reference: Soundtrap/BandLab (video chat built-in), Splice/Discord integration (external), Whereby/Google Meet (generic video, not DAW-aware), Evercast (4K workspace streaming + video chat for mixing crews)
• Depends on: Video-conf module (already implemented), WebSocket sync route (piggyback on same connection or separate), STUN/TURN server config, audio context loopback (Web Audio API)
• Implementation notes: In DAW, add "Start call" button in collaboration sidebar. Call createVideoConfig() + createCallSession(). Instantiate WebRTC (RTCPeerConnection, RTCDataChannel for signaling). Use video-conf module for participant management. For DAW audio: get AudioContext destination node → create MediaStreamAudioDestinationNode → capture to getUserMedia stream → feed to WebRTC peer (addTrack). Collaborators add remote audio tracks. Screen share: use getDisplayMedia() to capture canvas/window. Show participant grid in overlay or sidebar. Handle nat traversal with STUN/TURN (config in video-conf.VideoConfig). Recording: use MediaRecorder API on output stream.

COLLAB-7 Cloud rendering of tracks/stems (offload to server) — P2 · XL · 🔴 missing#

• What & why: Euterpe renders offline locally via dsp-graph Engine.render (see audio-engine). For large sessions or CPU-constrained devices, should offload to cloud. Add: (1) BFF route POST /api/projects/:projectId/render (request: trackIds[], format, quality) → async job. (2) BFF spawns Euterpe engine instance server-side (Rust binary or WASM), renders specified tracks, returns S3 URL to WAV/MP3. (3) DAW UI checkbox "Render in cloud" before export. (4) Progress bar with ETA. This is a Wave 3+ feature but increasingly expected (Sesh touts <1min cloud render). Differentiator if combined with stem mastering.
• SOTA reference: Sesh (cloud render <1min + auto-mix), LANDR (cloud mastering), Soundtrap (implicit cloud render for generation), iZotope/LANDR (cloud analysis + rendering)
• Depends on: Cloud project storage, audio engine containerization (Rust dsp-graph as a headless service), job queue (async-job-engine in workflows lib exists but not wired), S3 for output blobs
• Implementation notes: Create /tools/euterpe-cloud-render/Dockerfile that wraps dsp-graph Rust binary as a microservice (listens on port 8888 for render requests). In BFF, add /api/projects/:projectId/render route that enqueues a job to the async-job-engine with project ID + track selection. Job handler spawns cloud-render container (via Docker, K8s, or Fargate), POSTs project data + track IDs, gets back S3 URL. Store job status in jobs table, poll from DAW. This is heavy engineering but high ROI for mobile/low-power users.

COLLAB-17 Project analytics & contribution tracking (heatmaps, metrics) — P3 · S · 🔴 missing#

• What & why: Project-mgmt has ProjectAnalytics, generateActivityHeatmap, calculateContributionBreakdown (all tested). Not wired. Add: (1) Analytics dashboard in project settings. (2) Contribution breakdown chart (% time per contributor). (3) Activity heatmap (calendar-style, darker = more activity on that day). (4) Metrics: lines of code equivalent (FLOC: features/clips added), edits per day, collaboration hours, conflict resolution rate. (5) Export metrics report. This helps teams understand workflow and validate remote collaboration ROI.
• SOTA reference: GitHub Insights (contribution heatmap, code frequency), Figma Analytics (file activity, collaborators), Git contributors, Spotify for Artists (release analytics)
• Depends on: Activity feed (above), activityLog persistence
• Implementation notes: In project settings, add "Analytics" tab. Query projectData.activityLog. Call generateActivityHeatmap(activityLog) → render calendar grid (CSS Grid, darker background = more events on that day). Call calculateContributionBreakdown(activityLog, members) → render pie/donut chart (% per member). Compute metrics from activityLog: lineCount (sum of FLOC per event), editsPerDay (events/day over last 30 days), collaborationHours (from presence start/end times), conflictRate (conflicts / total operations). Export as PDF or CSV.

IO-1 DAWproject Format Import/Export — P0 · L · 🔴 missing#

• What & why: Euterpe has zero DAWproject support, blocking seamless project interchange with Cubase 14, Studio One 7, Nuendo 14, Bitwig 5. DAWproject is now the industry standard for multi-DAW collaboration. Without it, Euterpe projects cannot be opened in other DAWs and vice versa.
• SOTA reference: Cubase 14, Studio One 7, Nuendo 14, Bitwig Studio 5 all ship DAWproject import/export (native format or co-format). Open standard at https://www.dawproject.com/.
• Depends on: Project model serialization (already exists in project-io.ts); XML ZIP writer; plugin state marshaling (exists in nih-plug plugin.rs).
• Implementation notes: Create /libs/euterpe/projects/src/dawproject-format/ with: (1) TypeScript DAWproject v1.0 ZIP container writer (jszip library), (2) XML serializer for hierarchy mapping Euterpe TrackState → DAWproject with <clip audio|midi> + children, (3) plugin state codec for VST3/CLAP preset .vstpreset/.clap-state roundtrip, (4) import parser (unzip + XML parse + restore), (5) unit tests round-tripping Euterpe → DAWproject → Euterpe. Map Euterpe inserts (10 FX types) to CLAP/VST3 plugin identifiers in metadata.

IO-4 VST3 / CLAP Plugin Hosting (External Plugin Loading) — P0 · XL · 🟢 polish#

• What & why: Euterpe ships Euterpe Instrument as a VST3/CLAP plugin but CANNOT host third-party plugins. Professional DAWs must host plugins; Euterpe's insert chain is hardcoded to 10 DSP types (EQ, comp, delay, etc.). Without plugin hosting, power users cannot integrate third-party synths, effects, or metering.
• SOTA reference: All SOTA DAWs host VST3 (Cubase, Pro Tools, Logic, FL Studio, Reaper, Bitwig, Studio One). CLAP adoption growing (FL Studio 21, Reaper, u-he, Surge). VST3 SDK open-source, CLAP SDK open-source.
• Depends on: IPC/child-process bridge (plugin sandbox), audio buffer pooling (zero-copy shared memory), parameter automation mapping, MIDI/note routing, preset state marshaling, UI threading (Windows native window embedding or web canvas fallback).
• Implementation notes: Build VST3/CLAP host in Tauri sidecar (/src-tauri/core/plugin-host.rs) using vst-rs or clap-host crate. (1) Spawn plugin process (macOS/Win/Linux native binary), communicate via IPC (sockets or shared memory), (2) host provides audio buffers + MIDI events + parameter snapshots each block, (3) plugin returns processed audio + state changes, (4) Euterpe track → PluginSlot array (reorderable), each slot loads plugin .vst3/.clap bundle by scan, (5) parameter UI: introspect plugin param count/ranges, auto-generate DAW-style control panel or embed plugin UI (VST3 IEditController / CLAP GUI), (6) automation: parameter snapshot per sample, interpolate between frames, (7) preset save/load via plugin state string, (8) CPU budget / multi-threaded rendering for realtime safety.

IO-10 Arrangement Timeline & Multi-Clip Scheduling — P0 · XL · 🔴 missing#

• What & why: Euterpe has tracks + patterns but NO arrangement timeline UI (clip placement on bars/measures, per-clip loop/mute/fade, multi-track timeline view). Every pattern plays globally (one pattern per bar across all tracks). Cannot build song structure (intro → verse → chorus → bridge → outro with per-section instrumentation).
• SOTA reference: All SOTA DAWs (Ableton, Logic, Pro Tools, FL, Reaper, Bitwig, Studio One) have arrangement timelines with clips, lane view, drag-to-schedule.
• Depends on: Clip model (NoteClip exists for patterns; need AudioClip), timeline view (new React component), engine scheduler (dsp-graph needs per-clip scheduling logic, currently plays all patterns in sequence).
• Implementation notes: Create /libs/euterpe/projects/src/arrangement/ with Arrangement model (clips indexed by (trackId, startBar, endBar), Clip union { NoteClip, AudioClip }, per-clip gain/pan/mute/fade). Update daw-session.ts to hold Arrangement (replaces global pattern chain). Implement /src/components/daw/arrangement-view.tsx: timeline grid (bars/beats), per-track lane, clip boxes (drag/resize/delete), meter ruler, snap grid. Update dsp-graph Engine to read clips from Arrangement and schedule per block (playhead in bar units, activate clips within playhead range). Add clip editor (right-click → edit, shows piano-roll scoped to clip bounds).

IO-5 Broadcast WAV (BWF) Export with iXML / Metadata — P1 · M · 🟡 partial#

• What & why: Euterpe exports raw WAV; no BEXT chunk (originator, origin time, loudness per EBU R128), no iXML (timeline, track markers, loudness metadata), no cue points. Post-production, archival, and broadcast workflows require full BWF v2 with metadata.
• SOTA reference: EBU-TECH 3285 (BWF v2, 2011+). Pro Tools, Adobe Audition, MediaArea BWFMetaEdit support native. 24-bit/48kHz WAV + BEXT is broadcast standard.
• Depends on: Audio export pipeline (exists, exports 24-bit WAV), loudness measurement (already integrated, using ITU R128).
• Implementation notes: Extend /src/daw/audio-engine-web/src/wav.ts + /src/daw/mastering.ts: (1) add BEXT chunk writer (descr, originator, originationTime ISO8601, originationTimeReference, cueSheet flag), (2) measure loudness (integrated LUFS, loudness range per R128), write loudness value to BEXT, (3) generate iXML chunk (timeline markers = Euterpe clips start/end, loudness per segment, track list), (4) optional cue points chunk (percussion transients or user markers), (5) UI: export dialog with BWF metadata fields (originator name, project code), (6) test: verify BEXT/iXML parseable by Adobe Audition / Pro Tools.

IO-16 Cloud Audio Import (Suno/Udio Stem Integration) — P1 · M · 🟡 partial#

• What & why: BFF has music-executor.ts + music-enqueue-executor.ts (Suno/Udio generation) but DAW has NO UI to import generated music as tracks/stems. Users must manually download, then load in sampler. Blocks seamless cloud-generation workflow.
• SOTA reference: Soundtrap (Spotify's web DAW) natively imports generated music. BandLab imports generation results. MIDI Agent (2026) integrates generation + stem export.
• Depends on: Music generation backend (exists: music-executor.ts), DAW UI (import panel), job tracking (jobs-route.ts exists).
• Implementation notes: Add /apps/euterpe-studio-web/src/components/daw/cloud-import-panel.tsx: (1) list pending/completed generation jobs (poll /jobs endpoint), (2) on job complete, show download → import options: 'Create new track with audio', 'Split stems → tracks' (if Suno/Udio returns stems), (3) import handler: add AudioClip to arrangement, auto-fit to timeline length, load sample into sampler track, (4) progress: SSE events update job status in real-time.

IO-2 AAF (Advanced Authoring Format) Export — P1 · L · 🔴 missing#

• What & why: Professional post-production (film/TV) workflows require AAF export. Euterpe cannot export to post-production pipelines. AAF replaces OMF and carries richer metadata (scene/take/timecode, multichannel audio, vendor-extensible plugin data).
• SOTA reference: Pro Tools 2024, Final Cut Pro, Adobe Premiere, Logic Pro all support AAF import/export. EBU AAF standard. OMF is legacy; AAF is modern standard.
• Depends on: Project model, timecode support (currently unsupported; Euterpe uses sample counts).
• Implementation notes: Create /libs/euterpe/projects/src/aaf-format/ with: (1) AAF XML/binary writer (libafaik Rust crate or hand-write LE binary format per SMPTE 378M spec), (2) map Euterpe tracks → AAF MobSlot (slots per track), audio clips → WAV file refs + AAFEssenceData, inserts → AAFOperationGroup (plugin chain), (3) timecode generation (convert samples @ 48kHz to SMPTE HH:MM:SS:FF), (4) test AAF import in Pro Tools/Final Cut.

IO-3 MIDI 2.0 Support (Polyphonic Expression, Per-Note CC, Extended Range) — P1 · L · 🔴 missing#

• What & why: Euterpe only handles MIDI 1.0 (7-bit CC, channel-wide aftertouch, fixed pitch bend range). MIDI 2.0 enables polyphonic aftertouch, per-note pitch/CC/velocity, 32-bit CCs, MPE support. Hardware (Korg Keystage MIDI 2.0, Seaboard) requires MIDI 2.0 for expressive input. DAWs (Logic Pro 12, Cubase, Studio One 7) already support.
• SOTA reference: Logic Pro 12 MIDI 2.0 Step Sequencer display, Cubase internal support, Korg Keystage official integration with Ableton Live 12 (MIDI 2.0 mode).
• Depends on: MIDI note data model (currently 7-bit velocity only), sequencer UI (piano roll, step grid), engine parameter mapping.
• Implementation notes: Extend /src/daw/midi-import.ts + /src/daw/midi-export.ts to support MIDI 2.0: (1) parse/emit 0xF0 32-bit SysEx MIDI 2.0 Universal messages (pitch per-note, CC per-note, poly aftertouch), (2) update NoteClip / MidiNoteEvent to carry per-note pitch bend, per-note CC curves, poly pressure, (3) update piano-roll.tsx to display pitch/CC per note (polyphonic lanes), (4) wire per-note CC into PolySynth voice parameters (per-voice pitch mod, per-voice cutoff, per-voice amp). MIDI 1.0 fallback (MPE on channel-per-voice).

IO-11 Take Recording & Comping (Loop Recording, Swipe Selection) — P1 · L · 🟡 partial#

• What & why: Euterpe has basic in-DAW recording (capture buffer, quantize) but no loop recording (punch-in/out, multiple takes in FIFO or dedicated lanes), no take comp (swipe between takes to build best composite).
• SOTA reference: Logic Pro, Ableton Live 12, Pro Tools all support loop recording to take lanes + comp mode. FL Studio, Bitwig, Studio One have similar.
• Depends on: Recording infrastructure (exists: clip-recorder.ts), UI for take lanes and comp mode.
• Implementation notes: Extend clip-recorder.ts: (1) loop-record mode (detect bar boundary, auto-punch on playhead loop, stack takes in dedicated array), (2) update piano-roll.tsx to show take lanes (one lane per take, play selection, mute others), (3) comp mode toggle: right-click clip → enter comp mode, click-to-draw swipe boundaries between takes (per bar), (4) consolidate comp selection to new clip when done, (5) take list UI (track metadata: take 1/2/3, timestamps, comment field).

IO-6 FLAC, ALAC, Opus Codec Support (Decode & Encode) — P2 · M · 🔴 missing#

• What & why: Euterpe only handles WAV/MP3. FLAC is the professional lossless standard (cross-platform), ALAC for Apple-only workflows, Opus for real-time/streaming (lower latency). Many artists provide stems/samples in FLAC; mastering tools export to these formats.
• SOTA reference: FLAC default on Android, Windows, Linux, all DAWs (REAPER, Audacity explicitly support). Opus recommended by Xiph.Org for speech/music real-time, 5–66ms latency. ALAC limited to Apple ecosystem.
• Depends on: WASM audio codec libraries (flac-wasm, opus-wasm, alac-wasm are available), audio engine pipeline (decoding happens in AudioWorklet, encoding in master bounce).
• Implementation notes: Add codec support via npm packages: (1) flac-wasm (decode/encode), opus-wasm (encode; decode via browser MSE if available), alac-wasm (decode), (2) extend audio-engine-web.ts AudioWorklet to load codec modules, (3) update sampler panel WAV load to try FLAC first, fallback WAV, (4) export UI: dropdown selector (WAV 16/24, FLAC 16/24, ALAC 16, Opus 128kbps), (5) test round-trips (FLAC → engine → FLAC unchanged).

IO-15 Stem Export Orchestration & Batch Processing — P2 · M · 🟡 partial#

• What & why: Euterpe exports stereo stems (harmonic/percussive + mid/side) manually. No batch export (one click → all stems + master to folder), no stem naming conventions, no orchestration API (automate 10-20 stem export jobs).
• SOTA reference: Professional mastering (LANDR, iZotope RX, Soundtrap) batch-export stems. Splice allows preset stem groups. Reaper can script batch export.
• Depends on: Stem separation (exists), export pipeline (WAV encode exists), batch queue infra (jobs-route.ts exists for music generation, extend for export).
• Implementation notes: Enhance /apps/euterpe-studio-web/src/daw/desktop-bridge.ts: (1) define StemExportConfig (stem list: vocals/drums/bass/keys/other, per-stem gain/EQ, naming pattern, format FLAC/WAV), (2) orchestrate offline render: per-stem, measure loudness, apply gain/EQ, export to zip, (3) batch queue in BFF /jobs route: POST /jobs/export-stems (project JSON, config), returns jobId, SSE progress, (4) UI: export dialog with preset templates (standard 5-way, spotify mastering, video post), custom stem builder (checkboxes).

IO-17 Audio Inpainting (In-DAW Region Regeneration) — P2 · M · 🟡 partial#

• What & why: @euterpe/genesis has inpaintSection stub (not wired). Euterpe copilot can only generate full new clips, not regenerate bars within existing audio/MIDI regions. Users cannot 'fix' a bad section without manual redo.
• SOTA reference: Stable Audio, LANDR inpainting, Adobe Firefly video inpaint. Conceptually similar to text/image inpainting: given context boundaries, fill middle conditioned on edges.
• Depends on: Inpainting library (exists: genesis inpaintSection for MIDI; audio inpainting needs backend), BFF provider (stubs exist but unimplemented).
• Implementation notes: Extend DAW UI: (1) waveform view → select region (drag marquee), right-click → 'Regenerate', (2) piano-roll → select note range + bar range, 'Regenerate MIDI', (3) send region + context to BFF /generation/inpaint endpoint (prompt optional), stream back new audio/MIDI, replace in place, (4) backend: call provider (Stable Audio or internal model if deployed), return audio/MIDI bytes, (5) UI: progress bar during inpaint.

IO-21 Format Masters (Genre-Specific Mastering Chains) — P2 · M · 🟡 partial#

• What & why: Master chain exists but is generic (EQ + comp + limiter). @euterpe/master/src/format-masters is a stub. No genre-specific templates (trap, EDM, hip-hop, classical, metal) with preset chain/settings.
• SOTA reference: LANDR (genre detection + mastering), iZotope Ozone (mastering assistant), Soundtrap (genre presets). Every modern mastering tool has genre templates.
• Depends on: Master DSP chain (exists), genre detection/inference (audio-analysis.ts has key/tempo; add spectral genre classifier), preset library.
• Implementation notes: Implement @euterpe/master/src/format-masters/: (1) define GenreTemplate (EQ bands, comp ratio/threshold, limiter ceil, send routing, automation), (2) genre classifier: run spectral analysis on master mix → infer genre (trained on Spotify genre tags), (3) UI: 'Suggest Master Chain' → analyze, show recommended genre + template, apply with slider to 'strength' (how aggressively to apply), (4) preset library (JSON): trap (heavy bass EQ, sidechain comp), EDM (wide stereo, bright mids), metal (thick bottom, sharp high-mid, tight comp).

IO-22 Stem Mastering (Per-Stem LUFS & EQ Presets) — P2 · M · 🔴 missing#

• What & why: @euterpe/master stubs for stem-mastering. Euterpe can export stems but no per-stem loudness targeting (vocal −16 LUFS, drum −10, bass −13, etc.) or tone-match templates.
• SOTA reference: iZotope Ozone has stem mastering mode. LANDR per-stem preset. Pro Tools mix rebalance (per-track loudness).
• Depends on: Per-stem analysis (loudness, EQ per stem), preset library.
• Implementation notes: Extend /src/daw/loudness-target.ts + mastering.ts: (1) define stem mastering profiles (e.g., 'vocals': −14 LUFS, normalize, light EQ boost 2–4 kHz for presence), (2) in export flow, if 'stem master' mode, apply per-category settings (detect category from track name + spectral fallback), (3) UI: export dialog → 'Stem Mastering' checkbox, shows per-stem targets in preview table.

IO-8 REST API for DAW Control & Orchestration — P2 · L · 🟡 partial#

• What & why: Euterpe's /api/copilot route is LLM-validated action dispatch only. No HTTP REST API for programmatic DAW control (e.g., create track, set gain, render, query state). Cloud workflows, multitrack batch processing, and third-party integrations require REST endpoints.
• SOTA reference: Reaper: ReaScript + OSC/HTTP named-pipe control. Ableton: scripting API + control protocol (ports for external tools). MIDI Agent (2026): REST for generation + stem export.
• Depends on: BFF app.ts (routes already registered), copilot action validation (exists), daw-controller command dispatch.
• Implementation notes: Extend /apps/oshun/bff/src/generation/: create /routes/euterpe-daw-control.ts with Fastify routes: GET /euterpe/daw/state (serialize + return session JSON), POST /euterpe/daw/action (batch DawAction[] dispatch), POST /euterpe/daw/render (async bounce with LUFS target), GET /euterpe/daw/analysis (key, tempo, loudness per track). Require API key (environment or OAuth). Return job IDs for long operations; WebSocket SSE for progress. OpenAPI schema (Swagger) for SDK generation.

IO-18 Voice Cloning & Vocal Processing — P2 · L · 🟡 partial#

• What & why: @euterpe/voice has frontier-voice, voice-cloning, tts, text-to-singing stubs. Not wired into DAW. Users cannot clone voice or apply professional vocal effects (pitch correction, formant shifting, de-esser tuned to voice).
• SOTA reference: ElevenLabs voice cloning API (11 Labs Studio, VST plugin). iZotope Voice Assistant (pitch correction + formant shift). Coqui TTS voice cloning.
• Depends on: Voice provider SDKs (ElevenLabs API, Coqui runtime), vocal processing DSP (pitch correction, formant, desser).
• Implementation notes: Add /apps/euterpe-studio-web/src/components/daw/vocal-panel.tsx: (1) voice cloning: record 30s sample, upload to ElevenLabs/Coqui, get voice ID, (2) text-to-singing: text + melody MIDI → singing audio (via provider), (3) vocal effects: pitch correct UI (semitone grid snap), formant shift slider, de-esser threshold/frequency, (4) track type: add 'vocal' source type with embedded cloned voice ID, (5) render: per-vocal-region apply effects, cache processed audio.

IO-7 ReaScript / Python Scripting API for DAW Automation — P2 · XL · 🔴 missing#

• What & why: Euterpe has no public scripting API. Reaper's ReaScript (Lua/Python/EEL, 169+ functions) and Ableton's Max for Live enable power users to automate workflows, build custom tools, and integrate with external systems. Euterpe's copilot is LLM-only; no programmatic access.
• SOTA reference: Reaper ReaScript (500+ exposed API functions), DAWZY (LLM-to-ReaScript mapper, 2026), Ableton Live Max for Live (Max 8 visual) + Python scripting. MIDI Agent (VST3) uses LLM + programmatic stem export.
• Depends on: API surface (exists partially: client-sdk.ts, copilot actions), JavaScript/TypeScript runtime in WASM or Node sidecar, action executor (daw-session reducer + daw-controller).
• Implementation notes: Implement /apps/euterpe-studio-web/src/scripting/ module: (1) define EuterpeScript language (TypeScript subset or Lua), expose 50+ API functions (track/clip/automation/transport/export control), (2) sandbox via WASM QuickJS or Node VM, (3) user-provided .eutscript files load from settings, executed on demand or scheduled, (4) REPL in dev tools + script editor UI, (5) events API (on-play, on-transport-change, on-param-change) for reactive scripts, (6) exports: WAV/stem batch, project mutation, analysis (loudness, key, etc.), (7) npm package for third-party library ecosystem. Alternatively: Python FFI via sidecar (like Total Reaper, 169+ Lua methods).

IO-13 Collaborative Real-Time Editing (CRDT Sync, Share-by-Link) — P2 · XL · 🟡 partial#

• What & why: Euterpe has collab stubs (@euterpe/collab, 9 subdirs including sync-engine.ts) but none are wired into the DAW. No multi-user editing, no share-by-link invite, no conflict-free merge (CRDT).
• SOTA reference: Splice Sessions, BandLab, Soundtrap all support cloud collab (real-time CRDT or operational transform). IRCAM's Opusroom uses CRDT. Ableton uses custom conflict resolution.
• Depends on: BFF project persistence, WebSocket signaling, CRDT library (Yjs, Automerge), conflict resolution for audio (chunk-based), RBAC (role-based access: owner/editor/viewer).
• Implementation notes: Wire /libs/euterpe/collab/ into DAW: (1) enable Yjs CRDT sync of DawSession state (track array, patterns, automation, master config) via BFF WebSocket, (2) use Yjs.Array for conflict-free multi-user edits, (3) per-user cursor/selection display (livekit or simple cursor protocol), (4) share-by-link: generate project link + invite code, JoinProject route returns hashed access token, (5) version lineage (fork history, branch per editor), (6) audio consensus: any user can re-render stems; store rendered audio as blob ref (content-addressed, shared), (7) RBAC: owner → add editors, editors → read+write+export, viewers → read-only.

IO-14 OMF (Open Media Framework) Import for Legacy Post-Production — P3 · M · 🔴 missing#

• What & why: OMF is deprecated (AAF replaced it), but legacy Avid Media Composer projects may export OMF. Zero support in Euterpe. Low priority but relevant for post-production handoff from older shops.
• SOTA reference: Pro Tools, Final Cut Pro, Adobe Premiere can open OMF. EBU standard (now legacy, AAF preferred). OMF limitations: no FX/VST data, limited metadata vs AAF.
• Depends on: AAF import (item above), OMF parser (open-source omf-tools available).
• Implementation notes: After AAF import: (1) create /libs/euterpe/projects/src/omf-format/ with OMF parser (C reference implementation or Rust SMPTE 426M spec), (2) map OMF Mob → Euterpe track, Slot → pattern, audio ref → WAV load, (3) note: OMF does not carry plugin state, so inserts will be lost; warn user, (4) test with sample legacy Avid .omf files.

IO-9 Splice / Loopmasters / Sample Marketplace Integration — P3 · L · 🔴 missing#

• What & why: Euterpe has no sample browser or marketplace integration. Splive's 6M+ samples (with AI natural-language search as of Feb 2026) are inaccessible. No way for users to discover, search, or import sample packs directly in the DAW.
• SOTA reference: Splice API (direct DAW browser integration, credits, AI search). Loopmasters API (REST pack catalog). Native Instruments Komplete subscription. ADSR Sounds marketplace.
• Depends on: Sample loading (exists: sampler-panel.tsx), Splice/Loopmasters SDK (third-party), file manager UI.
• Implementation notes: Add /apps/euterpe-studio-web/src/components/daw/sample-browser.tsx: (1) Splice API integration (OAuth flow, search endpoint, sample download), (2) Loopmasters REST API (search, pack listing), (3) browser UI: search input + natural-language hint ('dark ambient pad', 'punchy kick'), results grid with preview, drag-to-sampler, (4) local cache (.euterpe/samples/splice-cache/), (5) credits display + account linking. Alternatively: embed Splice web component if available.

IO-12 Final Cut XML & MXF Format Export — P3 · L · 🔴 missing#

• What & why: Film/video post-production uses Final Cut Pro XML + MXF wrapped media for multichannel audio interchange. Euterpe cannot export to these formats, blocking integration with video workflows.
• SOTA reference: Final Cut Pro 10.x native XML export. Avid Media Composer uses MXF. Adobe Premiere accepts Final Cut XML. iNews/Avid broadcasts require MXF.
• Depends on: Project timeline/arrangement (prerequisite: arrangement timeline, item above), MXF container spec (SMPTE 421M), Final Cut XML schema.
• Implementation notes: After arrangement timeline is built: (1) create /libs/euterpe/projects/src/final-cut-format/ with Final Cut XML writer (v7 schema), (2) map Euterpe tracks → , clips → , audio channels → AMA links (reference WAV/MOV), (3) optional MXF writer (libmxf Rust crate or hand-write per SMPTE 377M-2009), wrap multichannel audio + metadata, (4) test import in Final Cut Pro.

IO-19 Sample Generation & Beat Generation — P3 · L · 🔴 missing#

• What & why: @euterpe/samples has beat-gen, sample-gen stubs. No UI or wiring. Users cannot generate drum loops, one-shot samples, or fill gaps programmatically.
• SOTA reference: LANDR beat generator, Splice beat sync, Amper Music (beat gen), Magenta Drum Machine. Algoriddim Beat Snap Pro (MIDI pattern gen).
• Depends on: Generation backend (stubs exist), UI + prompt interface.
• Implementation notes: Add /apps/euterpe-studio-web/src/components/daw/beat-gen-panel.tsx: (1) genre/tempo/kit selector, (2) 'Generate Drums' → call BFF /generation/beat endpoint, return audio clip, (3) 'Generate One-Shot' (kick/snare/hat) → prompt text, return single sample, add to sampler, (4) batch: 'Generate 10 variations', each with different swing/velocity.

IO-20 On-Device Neural Inference (ONNX/Candle/MLX Bridge) — P3 · XL · 🟡 partial#

• What & why: MRT2 realtime generation is cloud-only (BFF endpoint). No on-device inference capability. Latency, privacy, and cost are blockers. @euterpe/realtime-engine stubs exist but not deployed.
• SOTA reference: Stable Audio local (ONNX.js), Magenta.js local models. MusicLM-compatible models (FLAX → MLX/ONNX). Apple Intelligence on-device. Suno local attempts (unsupported).
• Depends on: ONNX Runtime WASM or Rust binding, model quantization (FP16/INT8), MLX sidecar (macOS neural engine), Tauri child process.
• Implementation notes: Implement /tools/euterpe-mrt2-sidecar/ as Tauri spawned child: (1) download + cache ONNX-quantized MRT2 model (60–100 MB), (2) accept control envelopes via stdio JSON, (3) run inference on available hardware (Apple Neural Engine > GPU > CPU), (4) return audio frames, (5) fallback to cloud if on-device fails or unavailable. Or: WASM path (ort.js for ONNX Runtime, load model dynamically) for web browser + desktop.

PLAT-6 Full Accessibility Feature Parity (WCAG 2.2 AA/AAA for Motor, Hearing, Cognitive, Visual) — P0 · L · 🟡 partial#

• What & why: @euterpe/access library (visual, hearing, motor, cognitive modules) is mature spec but COMPLETELY unwired into DAW UI. Features like one-switch scanning, eye-tracking, voice commands, reduced-motion detection, color-blind modes, haptic feedback, audio captions are defined but not integrated into components.
• SOTA reference: Logic Pro (VoiceOver integration), Pro Tools (keyboard-only operation, screen-reader), WCAG 2.2 guidelines (Level AA = baseline for DAWs; AAA = luxury)
• Depends on: @euterpe/access is built; integration into React components requires modest wiring
• Implementation notes: Wire @euterpe/access into DAW components: (1) Read prefers-reduced-motion at app init, pass to all animation/transition CSS, (2) add color-blind mode toggle in theme panel (applies @euterpe/access.applyColorBlindFilter to theme colors), (3) add font-size preset selector (small/medium/large/extra-large) to theme, apply via CSS scale + rem multiplier, (4) add high-contrast mode toggle (already in theme.ts, enhance with @euterpe/access thresholds), (5) wire voice commands (Web Speech API + default voice actions: play/stop/mute/solo/undo) to daw-session dispatcher, (6) display live captions of transcribed audio (use transcribe.ts polyphonic output + time-align), (7) haptic feedback on drum triggers (navigator.vibrate() for tap feedback). Phase 1 (MVP): prefers-reduced-motion + color-blind + font-size + voice commands. Phase 2: eye-tracking (via third-party library like webgazer), one-switch scanning.

PLAT-7 Arrangement Timeline with Clip Placement & Multi-Track Editing — P0 · L · 🔴 missing#

• What & why: Euterpe has TimelineClip interface (id, track, startSec, endSec) and timeline renderer math, but NO ArrangementView component. Piano roll + step grid work on single clips only. Cannot drag clips across time, reorder, or loop sections. SOTA: all DAWs have arrange view with drag-place, loop, tempo changes.
• SOTA reference: Ableton Live (arrange + session views), Logic Pro (arrange window), Pro Tools (edit window), Bitwig (arrange view with clips)
• Depends on: daw-session.ts action types (need setClipPosition, setClipLength, deleteClip, duplicateClip), shell-runtime CullResult + viewport math
• Implementation notes: Add arrange timeline component: (1) ArrangementView (SVG canvas, horizontal time axis in seconds/bars, vertical track lanes), (2) render TimelineClips as draggable rectangles (x=startSecpx/sec, width=durationpx/sec), (3) drag-move logic (similar to piano-roll note dragging), (4) resize from right edge for clip duration, (5) snap-to-grid (beats, bars, 1/16), (6) loop-region highlight (different color, drag edges), (7) tempo/meter track at top (click to insert tempo change), (8) add clip button per track (spawns dialog for which source: synth/sampler/audio), (9) wired dispatch actions: setClipPosition, setClipLength, addClip, deleteClip. Start with clips only, no audio waveform rendering (cache that for Wave 3).

PLAT-2 Native Audio I/O Driver Support (ASIO/CoreAudio/ALSA/WASAPI) — P0 · XL · 🔴 missing#

• What & why: Euterpe is locked to Web Audio API (host-provided buffers). SOTA DAWs use native drivers for low-latency audio I/O (ASIO on Windows, CoreAudio on macOS, ALSA on Linux) + exclusive mode support. This is critical for live performance + low-latency recording.
• SOTA reference: Pro Tools, Reaper, Studio One, Logic Pro (CoreAudio exclusive), Bitwig (native I/O enumeration)
• Depends on: Tauri native runtime (sidecar architecture), audio-engine migration to Rust native thread, device enumeration via OS APIs
• Implementation notes: Requires major architectural shift: (1) Move dsp-graph from WebAssembly to native Rust (already exists, just needs deployment), (2) Tauri sidecar spawns audio-engine as child process (Rust binary), (3) Shared memory transport (Ring buffer via Tauri IPC + SharedArrayBuffer alternative), (4) ASIO wrapper via cpal/oboe crates for Windows/macOS/Linux device enumeration. Phase 1: macOS CoreAudio only (leverage cpal crate), Phase 2: ASIO (Windows-Audio-Session-API), Phase 3: ALSA (Linux). Estimate 12-16 weeks for Phase 1 alone.

PLAT-10 Reduced-Motion Media Query Support (prefers-reduced-motion) — P1 · S · 🟡 partial#

• What & why: @euterpe/access has ReducedMotionConfig spec but DAW UI does NOT check prefers-reduced-motion CSS media query. Animations in spectrum analyzer, playhead movement, clip dragging, and meter bounces are uncontrollable by motion-sensitive users.
• SOTA reference: WCAG 2.2 Success Criterion 2.3.3 (Animation from Interactions), prefers-reduced-motion best practices
• Depends on: @euterpe/access (already has config types), React useMediaQuery or manual window.matchMedia hook
• Implementation notes: Detect and respect prefers-reduced-motion: (1) Create a useReducedMotion hook (checks window.matchMedia('(prefers-reduced-motion: reduce)').matches), (2) conditionally disable animations: spectrum analyzer (set renderMode to static bars instead of bouncing), playhead (jump vs. scroll), note drag (snap vs. smooth drag preview), (3) pass reducedMotion config to all animation-using components via context or state, (4) test: set System Preferences → Accessibility → Display → Reduce Motion on macOS, verify animations stop, (5) document in a11y section of CLAUDE.md.

PLAT-17 High-Contrast Mode Polish (Ensure WCAG AAA on All Controls) — P1 · S · 🟢 polish#

• What & why: Euterpe has HIGH_CONTRAST theme token set (pure white/black, neon accent), but not all components verify contrast ratios. Meter displays, waveform rendering, automation curve visualization may fail AAA (7:1) in high-contrast mode.
• SOTA reference: WCAG 2.2 Level AAA (7:1 contrast for normal text, 4.5:1 for large text)
• Depends on: @euterpe/access (contrast checking utilities exist), theme.ts (HIGH_CONTRAST defined)
• Implementation notes: Audit high-contrast rendering: (1) use checkContrast() from @euterpe/access.visual to verify all text/icon combos in high-contrast mode, (2) for spectrum analyzer / waveform / automation curves: test visual clarity (no gray-on-gray, ensure clear separation), (3) test with actual high-contrast user (e.g., Windows 10 High Contrast theme). Add to CI: run axe-core contrast checks in high-contrast mode on all components. Document any AAA failures and plan mitigations.

PLAT-5 Offline PWA with Service Worker & OPFS Audio Storage — P1 · M · 🟡 partial#

• What & why: Euterpe has PWA manifest + precache spec but NO service-worker implementation and NO offline audio storage. SOTA: BandLab (offline draft creation + sync on reconnect), Soundtrap (browser IndexedDB), Suno (offline generation). Users cannot edit without network.
• SOTA reference: BandLab (offline-first sync), Soundtrap (localStorage + IndexedDB), Progressive Web App best practices (Workbox)
• Depends on: Service-worker setup in Next.js (via next-pwa or manual Workbox), OPFS File System Access API, IndexedDB for project metadata
• Implementation notes: Implement offline-first DAW: (1) Create a service-worker (workbox config or manual), (2) precache shell assets (HTML, CSS, JS bundles, WASM engine), (3) use OPFS (navigator.storage.getDirectory()) for large audio blobs (samples, exports), IndexedDB for project JSON metadata, (4) add sync queue for cloud operations (generation jobs, project uploads) with Sync API (or fallback to onOnline event), (5) offline indicator in UI (banner at top of DAW), (6) background sync badge when online. Test offline: disable network in DevTools, verify all DAW features work except cloud gen/export. Use Workbox for runtime caching (network-first for API calls, cache-first for assets).

PLAT-9 Screen Reader Full Integration (ARIA Live Regions, Semantic HTML Landmarks) — P1 · M · 🟡 partial#

• What & why: Euterpe has ARIA labels (30+) and srOnly helpers, but lacks live regions for continuous state changes (meter levels, playhead position, recording status, automation breakpoint edits). Piano roll, automation editor, and spectrum analyzer are mostly opaque to screen readers.
• SOTA reference: Pro Tools (screen-reader certified), WCAG 2.2 guidelines (ARIA live regions for real-time feedback)
• Depends on: daw-a11y.ts (existing helpers), React components (piano-roll.tsx, automation-lane.tsx, etc.)
• Implementation notes: Add live regions + semantic structure: (1) DAW main container role=main, (2) transport controls role=toolbar (already done), (3) add role=region aria-live=polite for: playhead position ("Playhead at 2:15"), meter summary (existing meterStatus helper, just needs live region), recording mode, automation changes, (4) wrap meter updates in live region with aria-atomic=true, (5) piano-roll describe-as role=treegrid with row/cell roles (allows arrow-key navigation), (6) add skip-to-main link at top of page (WCAG), (7) keyboard navigation: Tab through tracks, arrow keys through notes/breaks in piano roll, (8) test with NVDA (Windows), JAWS (Windows), VoiceOver (macOS). Write WCAG compliance audit using axe or wave tools.

PLAT-11 Keyboard-Only Operation Mode (Full DAW Editing without Mouse/Touch) — P1 · M · 🟡 partial#

• What & why: Euterpe supports some keyboard shortcuts (undo/redo, play/stop, menus) but piano roll, automation editor, and sampler waveform dragging are pointer-dependent. Pro Tools and Ableton allow full mixing/editing via keyboard + screen reader.
• SOTA reference: Pro Tools (keyboard-only mode), Ableton Live (every action has a shortcut)
• Depends on: daw-session action types (already exist), keyboard event handling in components
• Implementation notes: Implement keyboard-only editing for piano roll, automation, sampler: (1) Piano roll: Tab selects notes, arrow keys move/resize (up/down octave, left/right beat, Shift+arrow for duration), Backspace deletes, Enter adds at cursor, (2) automation lane: Tab selects breakpoints, arrow keys move (left/right time, up/down value), Delete removes, (3) sampler waveform: arrow keys adjust start position, (4) track selection: Ctrl/Cmd+[0-9] (switch tracks), (5) master fader: Shift+arrow to adjust dB, (6) metronome/solo/mute: Shift+M (mute track), Shift+S (solo), (7) test with screen reader (NVDA + arrow keys on piano roll must announce note pitch + beat position). Use aria-label + aria-current=step pattern for focus management.

PLAT-1 Control Surface Framework & Hardware Integration — P1 · L · 🔴 missing#

• What & why: Euterpe has no support for hardware control surfaces (Behringer X-Touch, Nektar Panorama, Novation Launchpad, PreSonus StudioLive, Mackie MCU, ICON, etc.). SOTA DAWs ship 50-200+ control-surface mappings. Euterpe needs a device driver abstraction layer + mapping system to bridge MIDI CC/note data to DAW parameters.
• SOTA reference: Ableton Live 12 (Rack, 50+ mappings), Pro Tools (HUI/Eucon), Bitwig (integration system with Elektron/Novation/Yamaha), Reaper (control surface API + ReaScript)
• Depends on: MIDI input system (partial; need per-CC parameter binding + learn mode), shell-runtime permission flow
• Implementation notes: Create @euterpe/control-surfaces library: (1) ControlSurfaceProfile interface (name, midiBindings: {ccNumber → paramPath}), (2) ControlSurfaceRegistry (auto-detect via USB VID/PID via navigator.usb or Tauri plugin), (3) per-device mapping UI (drag fader to parameter, auto-learn mode), (4) wired to daw-session.ts dispatcher for parameter automation. Start with 10 devices (Behringer BCF2000, X-Touch, Novation Launch, PreSonus Quantum for native Tauri). Use Tauri + USB plugin for native device enumeration on desktop.

PLAT-4 Responsive Mobile DAW UI (Touch-Optimized Layout) — P1 · XL · 🟡 partial#

• What & why: Euterpe has responsive layout spec (LayoutMode: desktop/tablet/mobile-review) but NO actual mobile UI implementation. Piano roll, automation, mixer, transport are desktop-only. SOTA DAWs (FL Studio Mobile, BandLab, Soundtrap, Ableton Link beta) offer touch-operable editing on tablets/phones.
• SOTA reference: FL Studio Mobile (iOS/Android full DAW), BandLab (browser DAW, responsive layout), Soundtrap (responsive, touch-friendly), Ableton Live (Link collab + browser control)
• Depends on: Pointer Events (already in piano-roll.tsx), responsive breakpoint resolution in shell-runtime.ts, viewport culling + LOD
• Implementation notes: Implement mobile-first component variants: (1) PianoRollMobile (zoomed-in view, larger row height, horizontal scroll for octave selector, bigger note handles), (2) MixerMobile (vert stack: master → tracks, collapsed send/insert UI, tap-to-expand), (3) TransportMobile (larger buttons, 4-row layout), (4) AutomationMobileLane (simplified curve editor or list view of breakpoints). Use CSS media queries + shell-runtime resolveLayout() to swap components. Test on iOS 15+ (iPad) + Android 10+ (phones/tablets). Phase 1: Tablet UI (iPad Pro 12.9"), Phase 2: Phone UI (iPhone 14 Pro). Start with read-only review mode, then add touch-editing.

PLAT-12 Audio Interface Auto-Detection & Device Enumeration (Web Audio Device List) — P2 · S · 🔴 missing#

• What & why: Euterpe does not enumerate audio input/output devices (microphones, audio interfaces, speakers). Web Audio + MIDI permissions are defined in shell-runtime but lack device-picker UI. Users cannot switch between inputs or select non-default audio interfaces.
• SOTA reference: Ableton Live (device selector in preferences), Pro Tools (interface selector), Reaper (input device list), Web Audio API best practices (navigator.mediaDevices.enumerateDevices)
• Depends on: Permission flow state machine (shell-runtime, partial), Web Audio + WebMIDI enumeration APIs
• Implementation notes: Add audio/input device selector: (1) Use navigator.mediaDevices.enumerateDevices() to list audio inputs (kind=audioinput), outputs (kind=audiooutput), MIDI (kind=midi), (2) create DeviceSelector component in transport bar or settings panel, (3) on selection, update audioContext.destination (for output) and mediaStream constraint (for input recording), (4) store preference in localStorage, apply on page reload, (5) listen for devicechange events (navigator.mediaDevices.ondevicechange) and update list, (6) handle permission denied (show recovery action from permission flow). Test on desktop (Mac/Windows) with multiple audio interfaces connected.

PLAT-14 Haptic Feedback for Motor Accessibility (Vibration on Drum Triggers, Metronome) — P2 · S · 🔴 missing#

• What & why: @euterpe/access defines HapticMapping for drum types (kick/snare/hat/etc.) but NO Web Vibration API integration. Motor-accessibility users (deaf-blind, profoundly deaf) cannot feel tempo or percussive hits without haptics.
• SOTA reference: iOS/Android DAW apps (vibration on tap), web games (Gamepad haptics), accessibility.w3.org (haptic feedback as assistive technique)
• Depends on: @euterpe/access (HapticMapping spec exists), navigator.vibrate() API, drum trigger events in dsp-graph
• Implementation notes: Integrate Web Vibration API: (1) on synth note-on (kick/snare detected via instrument name or sample), call navigator.vibrate([duration_ms]) or navigator.vibrate([on, off, on, ...]) pattern from HapticMapping, (2) metronome tick: navigator.vibrate(50) on beat 1 (accent), navigator.vibrate(30) on others, (3) add haptics toggle in settings (default off to avoid surprise), (4) test on mobile (touch-enabled devices support Vibration API), (5) graceful fallback: if no vibration support, no-op (desktop browsers mostly unsupported). Start with drums + metronome, extend to UI feedback (button press, slider change).

PLAT-21 Color-Blind Mode Selector UI (Protanopia/Deuteranopia/Tritanopia) — P2 · S · 🟡 partial#

• What & why: @euterpe/access defines COLOR_BLIND_PALETTES (protanopia/deuteranopia/tritanopia) + applyColorBlindFilter() but NO UI toggle or color-blind filter application to the DAW theme.
• SOTA reference: @euterpe/access specification, accessibility best practices (10% of males are color-blind)
• Depends on: @euterpe/access (fully implemented), theme.ts (mutable token object)
• Implementation notes: Add color-blind mode selector: (1) in theme panel, add dropdown: None / Protanopia / Deuteranopia / Tritanopia, (2) on selection, apply @euterpe/access.applyColorBlindFilter() to all theme colors (accent, danger, warn, etc.), redraw UI, (3) store in localStorage, apply on reload, (4) also apply to spectrum analyzer colors (low/mid/high), meter (green/yellow/red), (5) test with color-blind simulator (e.g., Color Brewer online tool). Add visual indicator when non-default mode active.

PLAT-3 Internationalization (i18n) & Localization — P2 · M · 🔴 missing#

• What & why: All DAW UI text is hard-coded English (no translation strings, no locale switching, no RTL support). SOTA DAWs ship 10-30 languages. Euterpe needs i18n infrastructure for user strings, audio metadata, UI labels.
• SOTA reference: Ableton Live (14 languages), Logic Pro (20+ languages), Pro Tools (10+ languages), FL Studio (15+ languages)
• Depends on: None (orthogonal); recommend doing early to avoid retrofitting
• Implementation notes: Integrate next-intl (Next.js i18n framework) or react-i18next: (1) Extract all DAW UI strings into JSON catalogs (en.json, es.json, de.json, fr.json, ja.json, zh.json, etc.), (2) wrap text labels in or t() calls, (3) add language-switcher to theme panel (stores preference in localStorage + server-side cookie), (4) detect OS locale via navigator.language as fallback. Start with 5 languages (EN, ES, DE, FR, JA). Use key-based namespaces (daw.transport.play, mixer.gain, etc.). Test with pseudo-localization (key expansion to detect untranslated strings).

PLAT-13 Keyboard Shortcut Customization (Profile Switching + Rebinding) — P2 · M · 🟡 partial#

• What & why: Euterpe supports hardcoded keyboard shortcuts + 3 preset profiles (Ableton/Logic/Pro Tools shortcut sets defined in shell-runtime/types.ts:366) but NO UI to customize or switch profiles. Users cannot rebind keys or choose presets.
• SOTA reference: Ableton Live (custom shortcut map export/import), Reaper (customizable shortcuts UI), Pro Tools (keyboard focus mode)
• Depends on: ShortcutSet union + ShortcutBinding types (already in shell-runtime.ts), localStorage for persistence
• Implementation notes: Implement keyboard-customization UI: (1) add Shortcuts panel in settings (shortcut list by category: transport, track, mixer, editing), (2) ShortcutProfileSelector dropdown (Ableton/Logic/Pro Tools) with instant apply, (3) each shortcut row shows current binding + 'rebind' button (click to arm rebinding state, next key combo captured), (4) validation: detect conflicts (warn if two actions share a chord), (5) export/import JSON profile, (6) reset to factory defaults button, (7) store chosen profile in localStorage + restore on reload, (8) dispatch shell-runtime ShortcutConflict detection on profile switch. MVP: profile switching only (no rebinding).

PLAT-19 Performance Profiling & Low-End Device Support (Mobile/Older Hardware) — P2 · M · 🔴 missing#

• What & why: Euterpe has no documented performance targets or optimization for low-end devices (older Android phones, budget tablets, Chromebooks with <2GB RAM). AudioWorklet at 512-sample blocks @ 48kHz is standard, but no dynamic downsampling, no LOD for 100+ tracks, no canvas rendering optimization.
• SOTA reference: BandLab (targets older Android 7+), Soundtrap (responsive to device capabilities), Bitwig (Layer 1-2 LOD in arrange), Reaper (CPU load indicator)
• Depends on: shell-runtime.ts LOD + CullResult (viewport culling defined, not used), dsp-graph engine (Rust is fast; ensure no bottlenecks in JS bridge)
• Implementation notes: Optimize for low-end devices: (1) add device-capability detection (navigator.deviceMemory, navigator.hardwareConcurrency), (2) LOD: when <2GB RAM or <2 cores, reduce spectrum analyzer resolution (32 bands → 16), disable waveform peak-bin rendering (use RMS average instead), cull arrange clips >500px off-screen, (3) arrange view: render only visible clips (viewport culling from shell-runtime CullResult), lazy-load track metadata, (4) add performance monitor UI (toggle via settings, shows FPS + audio worklet CPU %). Test on: Android Go Edition device, iPad 5th-gen (2GB RAM), old MacBook Air. Set target: 60 FPS, <10% audio engine CPU.

PLAT-18 Mobile-Responsive DAW for Tablet/iPad (Read-Write, Not Review-Only) — P2 · L · 🟡 partial#

• What & why: LayoutMode: mobile-review is READ-ONLY per spec. Mobile-write mode does not exist. SOTA: FL Studio Mobile, BandLab allow full editing on mobile.
• SOTA reference: FL Studio Mobile (full DAW on iOS/Android), BandLab (full arrange + edit on browser)
• Depends on: Mobile UI components (from #2 responsive-layout gap), touch MIDI input, responsive arrangement timeline
• Implementation notes: Extend mobile mode from read-only to edit mode: (1) add LayoutMode = 'mobile-write' (alongside mobile-review), (2) MobileDAWApp layout: 4-panel tabs (transport, tracks/piano, mixer/sends, settings) with slide-out navigation, (3) piano roll mobile: large touch targets, zoomed 2-octave window, horizontal scroll for time axis, (4) track add/delete: swipe to reveal buttons or long-press context menu, (5) touch MIDI keyboard: on-screen 2-octave chromatic keyboard (bottom slide-up), (6) test on iPad (landscape + portrait), iPhone (landscape only for editing). Phase 2 of mobile-ui work.

PLAT-8 VST3/CLAP Plugin Host (In-DAW VST/AU/CLAP Hosting) — P2 · XL · 🔴 missing#

• What & why: Euterpe can BE a VST3/CLAP plugin (nih-plug wrapper in realtime-engine/crates/mrt2-native), but cannot HOST external VST3/CLAP plugins. SOTA: all modern DAWs are VST3/CLAP hosts. Users need to load synths, effects, instruments from the ecosystem.
• SOTA reference: Pro Tools (AAX host), Ableton Live (VST/AU/Max for Live), Bitwig (VST3/CLAP host, extension marketplace), Reaper (VST/VST3/CLAP/AU host, thousands of plugins)
• Depends on: Native runtime (Tauri sidecar for plugin process isolation), plugin manifest/metadata loading, parameter automation bridge to daw-session.ts
• Implementation notes: Implement VST3/CLAP host (desktop only, no web): (1) Use vst3-sys + clap-sys (or clap-juce-extensions) to wrap external plugins in Rust, (2) Tauri child process per plugin instance (isolation + crash safety), (3) shared-memory ring buffers for audio I/O (JACK-like), (4) parameter automation: expose plugin parameters as insert-rack knobs + automation lanes, (5) plugin discovery: scan VST3 locations (/Library/Audio/Plug-Ins/VST3 on macOS, %PROGRAMFILES%/Common Files/VST3 on Windows), (6) UI: PluginInstanceComponent wraps plugin UI via Tauri webview child. Phase 1: VST3 only (Windows/macOS), Phase 2: CLAP. Estimate 16-20 weeks. Consider integrating clap-juce-extensions for a quick path to JUCE plugin support.

PLAT-15 Mono Audio Output Mode (for Hearing-Impaired Users & M/S Compatibility) — P3 · S · 🔴 missing#

• What & why: @euterpe/access.hearing defines MonoConfig (enabled, method: average/left-only/right-only, panPosition). SOTA: hearing-aid users often need mono compatibility. Euterpe mixes to stereo with no mono fallback.
• SOTA reference: @euterpe/access specification, hearing-aid telecoil mode support
• Depends on: dsp-graph master output (add mono downmix option), audio-engine-web AudioWorklet bridge
• Implementation notes: Add mono output option: (1) Master channel strip: add Mono toggle button, (2) when enabled, engine downmixes L/R stereo → L+R/2 (or left/right only), (3) backend: in dsp-graph Engine, add mono_output flag + downmix logic in final output stage, (4) store preference in localStorage, apply on session load, (5) display indicator in transport bar when mono is active. Simple toggle in master mixer, no need for separate UI.

PLAT-16 Captions & Music Description for Hearing Accessibility — P3 · M · 🔴 missing#

• What & why: @euterpe/access.hearing defines TimedCaption interface with music description types (instrument-entry, tempo-change, key-change, dynamics, mood, technique, climax). No caption generation or display in DAW.
• SOTA reference: YouTube auto-captions, audio-to-subtitle services (Rev, Descript), Suno v4 (caption generation for generated music)
• Depends on: Audio transcription library (WebASR or external API), DAW playback state (playhead sync)
• Implementation notes: Implement caption display + generation: (1) Caption track renderer (SVG timeline with TimedCaption bars at bottom of arrange view), (2) on playback, highlight current caption in live region (aria-live), (3) caption generation: integrate with transcribe.ts (polyphonic transcription) + extend to label instrument entry/key changes (use music theory analysis from @euterpe/theory + spectral analysis from RMS/spectrum), (4) or: ship as manual caption editor (UI to add/edit captions per clip). Start with manual captions (no auto-generation), display in a text overlay during playback.

PLAT-20 Video/Screen Recording Integration (Screencasts + VOD Export) — P3 · M · 🔴 missing#

• What & why: No video recording or screen-capture. SOTA: some DAWs export video timelines, or integrate OBS for streaming. Users cannot record their session as a video tutorial or stream to Twitch.
• SOTA reference: OBS Studio integration (plugin bridge), StreamLabs OBS, YouTube streaming via Web Recorder API
• Depends on: MediaRecorder API (browser), Tauri process bridge for OBS (optional)
• Implementation notes: Add screen recording (MVP): (1) Record button in transport bar (records canvas + audio using MediaRecorder + Canvas.captureStream()), (2) on stop, combine video + audio tracks, export as WebM/MP4, (3) no live preview (too heavy), just timeline scrubbing, (4) optional: OBS bridge via Tauri for advanced streaming (lower latency, more codecs). Estimate 4-6 weeks for MVP.

MASTER-2 Format-specific mastering chain UI (Spotify, Apple, YouTube, TikTok, etc.) — P0 · L · 🟢 polish#

• What & why: Build a 'Format Masters' export dialog offering pre-configured mastering chains per platform (Spotify -14 LUFS + Ogg pre-emphasis, Apple -16 LUFS + ADM option, YouTube -14 LUFS + presence boost, TikTok -11 LUFS + mobile optimization, Vinyl RIAA, CD dither, Broadcast EBU R128, Podcast -16 LUFS + compression). Currently format-masters.ts has all algorithms; no UI.
• SOTA reference: Ableton, Logic Pro, Cubase, Studio One, Reaper all support format-specific bounce settings or export templates. iZotope Ozone, LANDR, Mastering.studio offer platform-specific presets.
• Depends on: format-masters.ts (optimizeForSpotify, optimizeForAppleMusic, optimizeForYouTube, optimizeForShortForm, preasterForVinyl, masterForCd, masterForBroadcast, masterForPodcast all implemented); daw-app.tsx must call these functions on export
• Implementation notes: Create FormatMastersDialog component (React modal): radio buttons for format preset (Spotify / Apple / YouTube / TikTok / Vinyl / CD / Broadcast / Podcast). Display target LUFS, true-peak ceiling, sample rate, codec notes. 'Bounce with Format' button triggers offline render + format-specific processing + normalization + encodeWav(). Return mastered file with metadata (ICMT comment showing format + settings). Expose in Transport UI or Export menu. Reference: /libs/euterpe/master/src/format-masters/format-masters.ts lines 697–1096 (all algorithms ready).

MASTER-4 True-peak metering UI & visual limiter activity — P1 · S · 🟢 polish#

• What & why: Display true-peak ceiling (–0.3 dBTP) as a hard line on the master meter. Show limiter gain reduction in real-time (green bar if < 0.1 dB reduction, yellow if 0.1–3 dB, red if > 3 dB). Add 'Limiter Activity' percentage to mix report. Currently limitTruePeak() computes this; no visual feedback.
• SOTA reference: iZotope Insight 2, Youlean Loudness Meter, Pro L 3, all show true-peak line + limiter activity. Ableton, Logic, Cubase show peak reduction on fader.
• Depends on: Audio engine already tracks limitTruePeakDbtp and gainReductionDb (frontier-mastering.ts limitTruePeak); UI just needs to display it
• Implementation notes: Extend LoudnessMeterPanel: add true-peak line (red dashed horizontal at -0.3 dBTP). Add a 'Limiter' sub-gauge below main LUFS meter showing gain reduction % (0–100%). Wire to engine.meter.masterCompGr (already streamed in daw-app.tsx as part of MeterSnapshot). If limitTruePeakDbtp > targetLufs by > 0.2 dBTP, show warning tooltip 'True-peak limiting active'.

MASTER-17 Offline render progress UI with estimated time remaining — P1 · S · 🟡 partial#

• What & why: During long offline bounces (batch export, stem mastering), show real-time progress bar with sample count / total, estimated minutes remaining, CPU load %, and cancel button. Currently bounce is async but UI feedback is minimal.
• SOTA reference: All DAWs show bounce progress with ETA: Ableton, Logic Pro, Cubase, Reaper, Studio One.
• Depends on: Audio engine already supports offline render; UI needs progress callback wired from engine to React state
• Implementation notes: Add progress callback to AudioEngine.renderOffline(): engine emits 'bounce-progress' message with {requestId, samplesProcessed, totalSamples, samplesPerSecond}. React component (OfflineRenderProgressDialog) calculates ETA = (totalSamples - samplesProcessed) / samplesPerSecond. Show progress bar, ETA text, 'Cancel' button (which sends abort message to engine). Integrate into daw-app.tsx for bounce(), masterExport(), batch export flows. Reference: similar pattern exists for recording UI.

MASTER-1 Real-time loudness metering UI & compliance dashboard — P1 · M · 🟡 partial#

• What & why: Add a live LUFS meter to the master column showing integrated, short-term, momentary, loudness range, and true-peak. Display per-platform compliance (Spotify, Apple, YouTube, etc.) with pass/fail indicators. Currently metering logic exists in backend but no UI exposure.
• SOTA reference: Ableton (via Max for Live), Logic Pro (Channel Metering), Cubase (Loudness Meter), iZotope Insight 2, all DAWs ship native or plugin loudness metering. Pro Tools / Studio One require AAX/VST plugins.
• Depends on: Audio engine already computes BS.1770 loudness (meterBs1770 in frontier-mastering.ts); needs UI component in master-column.tsx
• Implementation notes: Create LoudnessMeterPanel component (React, canvas-based): display gauge for integrated LUFS, bar chart for short-term / momentary max, loudness range slider, true-peak readout. Wire to engine.meter (real-time snapshot) + analyzeBounce (offline render). Add compliance badges per platform: green if within ±1 LU, red otherwise. Show normalization gain needed. Reference: /apps/euterpe-studio-web/src/components/daw/mix-report-panel.tsx pattern.

MASTER-3 Batch / multi-format master export — P1 · M · 🔴 missing#

• What & why: Allow one-click export of 5–10 masters (Spotify, Apple, YouTube, TikTok, Vinyl, CD, Broadcast, Podcast, plus custom) in parallel or sequential render passes. Currently masterExport() bounces one master; batchExport() stub exists but not wired.
• SOTA reference: Reaper Batch Converter, Cubase bounce multiple formats, iZotope RX 8+ batch processing, LANDR auto-delivers to all platforms. FL Studio, Ableton support secondary output format on bounce.
• Depends on: FormatMastersDialog (above); audio engine renderOffline; format-masters.ts batchExport skeleton
• Implementation notes: Add 'Export All Formats' checkbox to export dialog. When checked, render offline once, apply each format-master in sequence (Spotify, Apple, YouTube, TikTok, Vinyl, CD, Broadcast, Podcast), output 8 WAV files with naming convention (e.g., euterpe-master-spotify.wav, euterpe-master-apple.wav, ...). Show progress bar. Allow user to select subset of formats via checklist. Implementation: in daw-app.tsx, add batchMasterExport() that loops format-masters.ts functions, collects results, triggers 8 downloads (browser) or Tauri nativeExportStems (desktop). Desktop: faster since bulk file write is native.

MASTER-7 Reference-track library & preset management — P1 · M · 🟡 partial#

• What & why: Build a curated library of 50–100 reference masters (10 per genre: pop, rock, hip-hop, electronic, jazz, classical, metal, r&b, country, ambient, plus podcast/broadcast samples). Allow one-click reference loading instead of manual file upload. Presets save octave-band profiles for genre-matched tone matching. Currently reference-match.ts requires manual upload each time.
• SOTA reference: iZotope Ozone, smart:EQ 4 ship with pre-loaded reference libraries. LANDR, Mastering.studio reference libraries. Spotify / Apple Music have public reference tracks. Soundtrap, BandLab offer preset libraries.
• Depends on: reference-match.ts already performs referenceMatchMaster(); UI needs to load pre-computed octave-band profiles + apply matching
• Implementation notes: Create ReferenceLibraryPanel component: genre selector (dropdown), track selector (list of 10 pre-loaded references per genre). Each reference pre-computed as octave-band profile (60–12000 Hz, 9 bands). User clicks a reference; octave-band analysis of current master is computed, matchEq() is called, resulting EQ moves displayed. 'Apply Reference Match' button applies peaking EQ chain. Store reference profiles in JSON (bundled in app or lazy-loaded). Include 5 certified reference masters per genre (e.g., Spotify Artist of the Month mixes). Reference implementation: /apps/euterpe-studio-web/src/components/daw/mix-report-panel.tsx can be extended to a tabbed 'Mixing Tools' panel with Reference Library tab.

MASTER-9 MP3, AAC, FLAC, Ogg Vorbis codec support & export — P1 · L · 🔴 missing#

• What & why: Add audio codec libraries (libmp3lame for MP3, fdk-aac for AAC, libflac, libvorbis) to export. Offer codec+bitrate options on export dialog (MP3 128–320 kbps, AAC 96–256 kbps, FLAC lossless, Ogg 96–320 kbps). Pre-apply codec-specific EQ (Ogg high-frequency boost, AAC presence cut) before encoding. Currently only WAV is supported.
• SOTA reference: All DAWs support multiple codecs: Ableton (MP3, AAC via plugins), Reaper (native MP3, AAC, FLAC, Ogg), Logic Pro (AAC, ALAC native), Cubase (MP3, AAC, FLAC, Ogg via plugins), Studio One (AAC, MP3). Streaming platforms default to AAC (Apple, Amazon, Spotify internal format).
• Depends on: Codec libraries must be compiled to WASM (browser) or bundled in Tauri (desktop). Browser approach: use ffmpeg.wasm or libmp3lame.js (asm.js); desktop: call native codecs via Tauri.
• Implementation notes: Desktop (Tauri): add Rust dependencies: mp3lame, fdk-aac, flac, ogg-vorbis. Create Tauri command export_with_codec(buffer, format, bitrate). Web: use ffmpeg.wasm (pre-compiled, ~100 MB on first load) or inline libmp3lame.js for MP3-only (smaller). Add format selector to export dialog: Radio group (WAV, MP3, AAC, FLAC, Ogg) + bitrate slider. Before encoding, apply codec pre-emphasis EQ (Ogg: +0.5 dB @ 12 kHz; AAC: -0.3 dB @ 250 Hz). Codec-specific bit depth: MP3/AAC/Ogg are lossy (output depth irrelevant), FLAC/WAV are lossless (preserve 24-bit). Implementation priority: MP3 + AAC first (covers 95% of use cases), FLAC + Ogg second.

MASTER-5 Dithering configuration & visualization — P2 · S · 🔴 missing#

• What & why: Expose dithering options (none, rectangular, triangular, shaped noise) for bit-depth reduction on export (CD 16-bit, or custom bit depths). Show before/after THD to illustrate dithering benefit. Currently applyDithering in format-masters.ts supports TPDF; needs UI.
• SOTA reference: Cubase, Reaper, Pro Tools offer dithering on export (TPDF, shaped noise, etc.). iZotope Ozone includes dithering. CD mastering standard mandates dithering (Red Book 44.1 kHz / 16-bit).
• Depends on: format-masters.ts applyDithering() ready; needs UI option in export dialog
• Implementation notes: In FormatMastersDialog (or a separate 'Advanced Export' section), add Dithering dropdown: (None, Rectangular PDF, Triangular PDF, Shaped Noise). Display note 'Dithering is recommended for 16-bit masters (CD, streaming)'. On export, if target bit depth < input bit depth, call applyDithering with selected type. Display a tooltip with THD comparison (e.g., 'Dithering reduces quantization noise from 0.3% THD to 0.05%').

MASTER-10 Loudness normalization presets beyond streaming (club, DJ, vinyl) — P2 · S · 🟢 polish#

• What & why: Add presets for non-streaming platforms: Club (-9 LUFS, aggressive limiting, 120+ BPM boost), DJ (-9 LUFS, no normalization, stereo wide), Vinyl (RIAA pre-emphasis, -16 dBFS RMS, groove excursion control), Broadcast (–23 LUFS EBU R128 / ATSC A/85). Currently presets exist in code but not all are exposed in UI.
• SOTA reference: iZotope Ozone, LANDR, Splice all offer club/DJ/vinyl-specific settings. Vinyl mastering is a specialist service (Bandcamp, Discogs link to vinyl pressing houses with integrated mastering).
• Depends on: loudness-target.ts allLoudnessPresets() already includes club, broadcast, atmos; format-masters.ts preasterForVinyl implemented; UI just needs to expose
• Implementation notes: Expand LUFS target selector in transport-bar.tsx to include Club (-9 LUFS, safe for peak compression), DJ (-9 LUFS, no normalization), Vinyl (opens VinylMasteringDialog), and Broadcast (opens BroadcastMasteringDialog). Clicking each opens a side panel with format-specific options (Club: enable aggression limiter, DJ: stereo width slider, Vinyl: RIAA toggle, side duration input, Broadcast: standard selector). Apply corresponding processing chain on bounce.

MASTER-14 Loudness target platform selector with custom presets — P2 · S · 🟢 polish#

• What & why: Expand transport-bar loudness selector: allow users to save custom loudness targets (e.g., 'MyLabel Standard -12.5 LUFS', 'Client Brief -15 LUFS'). Presets stored locally (IndexedDB / localStorage). Display last 5 used targets for quick access. Currently only hardcoded Spotify/Apple/YouTube/etc.
• SOTA reference: iZotope Ozone, LANDR, Splice all allow saving custom loudness targets. Pro Tools users create custom bounce presets. Reaper scripts allow preset management.
• Depends on: loudness-target.ts allLoudnessPresets() returns fixed list; UI needs to store + load custom presets from IndexedDB
• Implementation notes: Modify transport-bar.tsx LUFS selector: add '+' button to 'New Custom Preset' modal. Input: Preset name, LUFS target (number input), max true-peak dBTP (number input), save as default (checkbox). On save, persist to IndexedDB. Display custom presets in dropdown alongside standard ones (with a 'custom' badge). Allow delete (trash icon). Recent 5 targets shown at top of dropdown. Implementation: use IndexedDB (euterpe-studio-web/src/daw/daw-session.ts already manages session state; add preset slice).

MASTER-16 Audio codec pre-emphasis profiles (Ogg, AAC, MP3) — P2 · S · 🟡 partial#

• What & why: For each codec (Ogg Vorbis, AAC, MP3), pre-compute and apply frequency-domain pre-emphasis to compensate for codec artifacts. E.g., Ogg attenuates highs → boost @ 12 kHz before encode; AAC has phase distortion around 250 Hz → EQ before encode. Currently referenced in code but not applied on export.
• SOTA reference: iZotope Ozone (codec-aware EQ), LANDR (codec pre-emphasis applied during mastering), Spotify (publishes best practices for different codec settings).
• Depends on: format-masters.ts Spotify/YouTube/ShortForm functions already apply codec EQ (lines 714–729, 933–942, 1022–1051); just needs to be applied whenever those codecs are selected for export
• Implementation notes: Create a codecPreEmphasis() function mapping codec name → EQ curve (array of peaking bands). Call this on export after format master processing (before encoding). Example: optimizeForOgg() applies +0.5 dB @ 12 kHz (highShelf). Store presets in a map: { 'ogg-vorbis': [{freq: 12000, gain: 0.5, q: 0.7}], 'aac': [{freq: 250, gain: -0.3, q: 1.0}], ... }. Integrate into daw-app.tsx masterExport and batch export functions.

MASTER-6 Broadcast-spec metering & compliance checker (EBU R128, ATSC A/85, ARIB, OP-59) — P2 · M · 🟢 polish#

• What & why: Expose broadcast loudness standards (EBU R128 -23 LUFS, ATSC A/85 -24 LKFS, ARIB TR-B32 -23 LUFS, OP-59 -23 LUFS) in loudness target selector. Auto-check compliance: -23 ± 1 LU, momentary max ≤ -1 dBFS, loudness range ≤ 20 LU. Display compliance report before/after export. Currently masterForBroadcast stubs all checks; no UI.
• SOTA reference: Pro Tools + Avid Pro Limiter (AAX), Cubase Loudness Meter (K-modes, EBU R128), Studio One metering; LANDR, iZotope, Splice all support broadcast spec. Broadcast is required in EU/Japan/Australia; optional in US (CALM Act for TV only).
• Depends on: format-masters.ts masterForBroadcast, meterBs1770, compliance checks all implemented; UI needs to expose and collect results
• Implementation notes: Add 'Broadcast' option to Format Masters dialog. When selected, show standard selector (EBU R128 / ATSC A/85 / ARIB / OP-59). Display target LUFS, max momentary, max LRA, max true-peak per standard. On bounce, call masterForBroadcast, check compliance.passes flag, display compliance report (green checkmarks if pass, red X if fail, with measured vs. target). Save compliance report as metadata in WAV INFO chunk (e.g., ICMT 'Broadcast EBU R128: PASS').

MASTER-13 Broadcast loudness compliance checker & export report — P2 · M · 🟡 partial#

• What & why: Before exporting to broadcast-spec format, run compliance check: measure momentary max, short-term max, integrated loudness, loudness range, true-peak. Display visual report (green/red per check), save report as PDF/JSON attachment to WAV file. Used by broadcast engineers to validate before transmission.
• SOTA reference: Pro Tools + Avid Pro Limiter (compliance checklist), iZotope RX (loudness report export), Cubase (loudness meter dashboard), broadcast-specific tools (Telestream WFM8300, TC Electronic Clarity). All generate exportable compliance reports.
• Depends on: format-masters.ts masterForBroadcast already computes all checks (checkLoudnessCompliance); UI needs to collect results + display/export
• Implementation notes: Create ComplianceReportPanel (or modal after export): display results in a table (Check Name | Measured | Target | Status). Color-code rows: green if pass, red if fail. Include graphs: loudness over time (short-term LUFS line chart), momentary/integrated/range as bar chart. 'Export Report as PDF' button generates a compliance certificate (e.g., 'EBU R128 PASS / ATSC A/85 FAIL'). Store report in WAV metadata (ICMT chunk). Reference: /libs/euterpe/master/src/format-masters/format-masters.ts ComplianceResult + ComplianceCheck types (lines 22–25).

MASTER-18 Metadata & ISRC / metadata tagging for distribution — P2 · M · 🔴 missing#

• What & why: Build release metadata editor: title, artist, genre, release date, ISRC code (per-track), songwriter credits, composition date, copyright notices. Export metadata into WAV INFO chunks (ICMT, IART, IGNR, etc.) and prepare for distributor upload (DistroKid, TuneCore require ISRC). Currently only AI-content provenance label is embedded.
• SOTA reference: All distributors require: artist, title, ISRC, genre, release date. BandLab, SoundTrap, Splice all have metadata editors. Pro Tools, Logic, Cubase support ID3 / metadata export.
• Depends on: WAV metadata infrastructure already exists (WavMetadata in audio-engine-web/src/wav.ts); expand to include full INFO chunk support (ICMT, IART, IGNR, ISRC, ITRK, IKEY, IFRM, etc.)
• Implementation notes: Create MetadataPanel component: input fields for artist, title, genre, release date, ISRC (auto-generate if user clicks 'Generate'), songwriter, composition year, copyright. Save to IndexedDB as part of project state. On export, build full WavMetadata object with all fields, pass to encodeWav(). INFO chunk will include all metadata. Add 'Export Metadata as JSON' option for distributor uploads. Reference: ID3 spec for WAV (INFO chunk) at https://www.recordingconnection.com/wiki/WAV_file_format.

MASTER-8 Stem mastering workflow (per-stem isolation + processing + recombination) — P2 · L · 🟢 polish#

• What & why: Implement UI for stem mastering: track isolation (render drums, bass, vocals, music separately), apply per-stem processing (different EQ/compression per stem), then recombine with master limiter. Demonstrate masterStems() which accepts 4 stems + applies per-stem tonal/dynamics moves. Currently algorithm exists; no UI workflow.
• SOTA reference: LANDR stem mastering, professional mastering houses (individual stem EQ + compression before recombine), Moises stem separation + per-stem processing. Not standard in consumer DAWs but expected in pro mastering.
• Depends on: Audio engine track rendering (renderTrackOffline per track); frontier-mastering.masterStems; UI must orchestrate isolation + stem analysis + processing
• Implementation notes: Add 'Stem Mastering' button to master panel. Opens modal with 4 tabs: Drums, Bass, Vocals, Music. Per-tab: analyze rendered stem (measure LUFS, spectrum), display stem-specific suggestions (Drums: tighten lows, +1.5 dB high shelf; Bass: control sub, mono-sum; Vocals: +0.5 presence, -1 low shelf; Music: +1.2 width). Sliders for per-stem gain, low-shelf/high-shelf EQ, compression (on/off), width. 'Apply Stem Master' aggregates all stems, calls masterStems(stemLufs={...}, overrides={...}), renders final master. This is a Wave 2+ feature (requires track-by-track offline render performance optimization).

MASTER-15 Multi-track automation for mastering chain parameters — P2 · L · 🔴 missing#

• What & why: Allow automation of mastering EQ (per-band frequency/gain/Q), multiband compression (per-band threshold/ratio), limiter ceiling, and loudness target over time (e.g., gradual loudness raise during intro → verse → chorus). Currently automation only covers synth parameters (volume, pan, cutoff, sends); no mastering chain automation.
• SOTA reference: Pro Tools, Logic Pro, Cubase, Studio One all support full parameter automation (including plugin inserts). Ableton Live 12 (clip automation + track automation). iZotope Ozone, LANDR support time-based processing (not exposed in DAW but computed offline).
• Depends on: Audio engine dsp-graph tracks per-track automation; mastering chain is on master bus, so needs master-bus parameter automation (currently only master-gain automation exists)
• Implementation notes: Extend automation system to include master-bus (not just per-track). Add automation lanes for: master EQ band 1–5 (frequency, gain, Q each = 15 lanes), master multiband comp bands 1–3 (threshold, ratio = 6 lanes), master limiter ceiling (1 lane), master loudness target (1 lane). Render logic must interpolate these automation values at sample granularity and apply processing in real-time (or at offline-bounce time). Start with simple linear interpolation; add curve options later. This is a specialized feature (not for most users); mark as 'Advanced'.

MASTER-19 Loudness history / project loudness evolution graph — P3 · S · 🔴 missing#

• What & why: Track loudness measurements (integrated LUFS, true-peak, short-term max) at each save/bounce point, display as a graph over project timeline. Helps users see if their mastering is getting louder or quieter across iterations. Currently each bounce is analyzed independently; no historical tracking.
• SOTA reference: iZotope Insight 2 (loudness history within a session), LANDR (shows loudness trends), professional metering tools (Telestream WFM, TC Electronic Clarity).
• Depends on: Audio engine measures loudness on each bounce; UI must persist measurements to IndexedDB + display graph (using Chart.js or similar)
• Implementation notes: Create LoudnessHistoryChart component (Canvas or SVG line chart): X-axis = bounce timestamp, Y-axis = LUFS (integrated), overlay short-term max + true-peak as thin lines. Store each measurement in IndexedDB with timestamp + project ID. On each bounce, append new measurement. Display in a side panel in mix-report-panel.tsx or master-column.tsx. Allow user to inspect a past measurement (click on point, show details).

MASTER-12 Distribution platform integration (DistroKid, TuneCore API stubs) — P3 · M · 🔴 missing#

• What & why: Build placeholder UI for distribution workflow: artist enters API credentials (DistroKid, TuneCore if public API available), Euterpe generates release metadata (title, artist, genre, cover art, track list), sends WAV(s) to distributor, polls delivery status. Currently no distribution APIs integrated; manual file upload only.
• SOTA reference: LANDR, DistroKid, TuneCore, CD Baby all support direct upload + status tracking. BandLab integrates DistroKid. Soundtrap integrates direct release. Splice integrates sample distribution.
• Depends on: DistroKid API (unofficial or partnership); TuneCore REST API (undocumented); auth flow; webhook polling for delivery status
• Implementation notes: Create DistributionPanel component: artist input (name, email), release metadata (title, artist, genre, cover art, ISRC, track list). Distributor selector (DistroKid / TuneCore / Manual). If DistroKid selected, show 'Connect DistroKid' button → OAuth flow (if available) or API key input. 'Distribute' button triggers: (1) collect all format masters (Spotify, Apple, YouTube, etc.); (2) POST to distributor API with metadata + master WAV(s); (3) receive release ID; (4) poll distributor status endpoint every 30s; (5) display 'Pending', 'Delivered to Spotify', 'Delivered to Apple Music', etc. NOTE: DistroKid's official API is not public. This feature is Wave 3+ (post-launch); start with manual workflow + export guidance.

MASTER-11 Dolby Atmos ADM BWF authoring & export — P3 · XL · 🔴 missing#

• What & why: Build ADM (Audio Definition Model) Broadcast Wave File authoring: capture spatial metadata (object positions, bed channels), encode stereo fallback + spatial metadata into ADM BWF at 48 kHz / 24-bit, enforce -18 LUFS + -1 dBTP loudness limits. This is a Wave 3+ feature, requires Atmos encoder library and spatial UI.
• SOTA reference: Logic Pro 14 (native Dolby Atmos plug-in + ADM export to Apple Music), Nuendo 11+ (ADM authoring), professional mastering houses (Dolby-certified Atmos rooms). No mainstream DAWs ship native Dolby Atmos authoring; Logic is the exception.
• Depends on: Dolby Atmos encoder (proprietary, requires licensing). Spatial audio UI (3D positioning, object gains, metadata). ADM file format knowledge. Integration with audio engine (stem isolation + spatial object assignment).
• Implementation notes: This is a Wave 3+ differentiator. Would require: (1) licensing Dolby Atmos Music Renderer (costs $$$ and requires studio certification); (2) building a spatial mixer UI (3D scene, object drag-and-drop positioning); (3) exporting ADM BWF (existing libraries: libadm, sadm). Start with a stub: detect 5.1 surround input, warn 'Dolby Atmos requires professional certification and licensing—consider outsourcing to a mastering partner or using LANDR.' Link to Dolby professional support. Implement only if Euterpe targets music-industry professionals (not consumer producers).

RIGHTS-1 C2PA/Content-Credentials manifest generation & embedding on export — P0 · M · 🟢 polish#

• What & why: Euterpe's watermark-capture.ts has full C2PA schema (assertions, ingredients, claims, signing), but exports do NOT serialize a manifest into the WAV as RIFF chunk or external .c2pa.json sidecar. Leading tools (Lyria, YouTube Content ID) embed C2PA manifests; EU AI Act Art. 50 (eff. 2026-08-02) requires AI-disclosure; C2PA is the industry standard. Need to: capture generation metadata (provider, model, prompt, settings) at each generation point, build C2PA manifest on export, sign with Ed25519 key, embed in WAV or export as .c2pa.json, display manifest in export dialog.
• SOTA reference: Google Lyria (SynthID + C2PA), YouTube Content ID (manifest), C2PA spec (ISO/IEC 46002 draft)
• Depends on: Watermark-capture.ts (exists), Ed25519 signing key management, export UI enhancement
• Implementation notes: File: /libs/euterpe/provenance/src/watermark-capture/watermark-capture.ts (already has buildC2paManifest, signClaim, verifyManifest). Integrate into /apps/euterpe-studio-web/src/daw/mastering.ts export path: (1) capture metadata at each generation action (generatePattern, generateChords, etc.) into DawSession.provenanceLog, (2) on master export, call buildC2paManifest(provenanceLog), sign with stored Ed25519 key, (3) return as JSON sidecar + optional RIFF chunk. Add manifest preview in export dialog (MasterExportDialog.tsx).

RIGHTS-2 Watermark embedding on audio export — P0 · L · 🟢 polish#

• What & why: Euterpe's watermark-capture.ts has embedWatermark() + detectWatermark() + testWatermarkRobustness() (1376 LOC), but it is NEVER called during WAV export. Suno, Lyria, and ElevenLabs embed imperceptible watermarks (SynthID or proprietary). Watermarks survive compression, trimming, and resampling; are critical for ownership proof in disputes. Need to: embed watermark into the PCM during masterBounce(), include watermark metadata in C2PA manifest, provide detect/verify tool in separate analyzer panel.
• SOTA reference: Google SynthID (Lyria), Suno watermark, AudioShake watermark detection
• Depends on: Watermark-capture.ts (exists), FFT/phase-manipulation codec, C2PA manifest (P0 above)
• Implementation notes: File: /libs/euterpe/provenance/src/watermark-capture/watermark-capture.ts has embedWatermark(payload: WatermarkPayload, audioBuffer, sampleRate, robustness: 'low'|'medium'|'high') returning EmbeddedWatermark. Integrate into masterBounce() pipeline in /apps/euterpe-studio-web/src/daw/mastering.ts: (1) after applyMasteringProfile(), call embedWatermark() with generation session hash as payload, (2) measure robustness with testWatermarkRobustness() (add whitebox test on export), (3) include watermark confidence in C2PA manifest. Add WatermarkDetectorPanel.tsx to analyze watermark on imported audio (detect robustness, confidence, extraction payload).

RIGHTS-5 Pre-generation copyright & safety filtering UI — P1 · M · 🟢 polish#

• What & why: Copyright-safety.ts has scanCopyrightedPrompt(), melodySimilarityPreflight(), lyricSimilarityScan(), scoreStyleImitationRisk(), applyProtectedNameRules(), suggestPromptRewrite(). Zero integration with generative UI (melody-gen, generator-panel, music generation). Copyrighted prompts + protected artist names are NOT pre-filtered before sending to Suno/Udio/Lyria. Need to: (1) scan user prompts before generation (flag copyrighted works + high-risk styles), (2) auto-suggest rewritten prompt, (3) show risk score + explanation, (4) allow user override (with audit log).
• SOTA reference: OpenAI GPT image-gen safety filter, YouTube Content ID claim avoidance (artist-name blocking), Suno/Udio terms-of-service enforcement
• Depends on: Copyright-safety.ts (exists), generator-panel.tsx, realtime-mrt2.ts (for prompt steering), protected-work database (stub in copyright-safety.ts types)
• Implementation notes: File: /apps/euterpe-studio-web/src/daw/copyright-safety.ts (new utility file) + /apps/euterpe-studio-web/src/components/daw/generator-panel.tsx enhancement: (1) on text-prompt change in generator panel, call scanCopyrightedPrompt() (import from @euterpe/provenance) on debounce, (2) if riskScore > threshold or hit found, show SafetySummaryComponent (risk banner, suggested rewrite, override checkbox), (3) log override to session.auditLog for later compliance review, (4) disable generation button if critical hits unreviewed. Seed protected-work database in copyright-safety.ts types with Top-100 artists + canonical titles (Beatles, Drake, Taylor Swift, etc.); expand with DMCA/Sound Exchange protected list on startup.

RIGHTS-10 GDPR/CCPA data-deletion & retention workflow UI — P1 · M · 🔴 missing#

• What & why: Compliance-ops.ts has full GDPR/CCPA purge engine (DeletionPlan, RetentionRule, PurgeEvaluation). Zero UI. Producer cannot request data deletion, cannot see retention policies, cannot comply with DSAR requests. Need to: (1) add data-deletion request UI (DSAR export, right-to-be-forgotten), (2) show retention calendar (when data will auto-purge), (3) log deletion events for compliance audit.
• SOTA reference: Ethyca GDPR compliance tools, Osano DSAR automation, CCPA deletion workflows
• Depends on: Compliance-ops.ts (exists), user settings/account panel, BFF deletion route, audit-log persistence
• Implementation notes: Create /apps/euterpe-studio-web/src/components/account/compliance-settings.tsx: (1) add ComplianceSettings panel (in Account / Settings), (2) display data-retention summary (projects, samples, metadata, how long retained), (3) button 'Request Data Export' → calls evaluateDsarExport() → builds tar.gz of user data (projects, audio, metadata) → downloads + logs to compliance-ops audit trail, (4) button 'Request Deletion' → calls evaluateDeletionPlan() → marks data for purge (retention.deleteAfter = now + 30 days) → logs to audit trail. Requires BFF route POST /v1/compliance/dsar-export (builds bundle) and POST /v1/compliance/deletion-request (queues purge job with legal hold exemptions).

RIGHTS-13 Split-sheet validation & automatic royalty distribution — P1 · M · 🔴 missing#

• What & why: Rights-consent.ts has validateSplitSheet() + evaluateApprovalWorkflow(). Zero UI to manage splits. Producer must manually negotiate who gets paid what % offline, then manually pay collaborators (Venmo, PayPal, etc.). Need to: (1) add split-sheet editor in DAW (collaborators, %, roles), (2) validate completeness (100% allocated), (3) on export, embed splits into metadata, (4) on music distribution, auto-route royalties to split recipients via stablecoin L2 transfers.
• SOTA reference: Stem.is waterfall splits, BeatStars collaborator splits, Soundtrap collaboration splits, Splice revenue sharing
• Depends on: Rights-consent.ts (exists), split-sheet schema, DawSession persists splits, L2 stablecoin routing (optional, for auto-distribution)
• Implementation notes: Create /apps/euterpe-studio-web/src/components/daw/splits-panel.tsx + /apps/euterpe-studio-web/src/daw/split-sheet.ts: (1) add SplitsPanel component (sidebar or main area) listing collaborators: {name, email/wallet, role (producer/engineer/artist), percentage}, (2) add/remove collaborators, auto-sum to 100% validator, (3) persist to DawSession.splits[], (4) on master export, embed splits into C2PA manifest + WAV metadata, (5) on distribution, call automateSplitDistribution() if all collaborators have wallet addresses (requires opt-in); routes via L2 (Base cheapest) using issueLimitedDigitalAsset().waterfall. Start with manual split tracking (P1); auto-distribution is stretch goal (Phase 2).

RIGHTS-3 Rights clearance & licensing UI (sample, interpolation, cover, sync) — P1 · L · 🔴 missing#

• What & why: Rights-consent.ts exists with voice-consent, commercial-license, sample-clearance, split-sheet, territory-grant, approval-workflow. Zero DAW UI. Producer must manually verify samples (via Splice/BeatStars) and splits offline. Need to: (1) track imported samples/audio sources with clearance status (cleared, pending, blocked), (2) pre-export rights check (gate export if critical samples uncleared), (3) display territory-matched license (e.g., can export to US/GB, not China), (4) show royalty-split preview (who gets paid what %), (5) integrate with Splice/HookTheory APIs for sample-clearance lookups.
• SOTA reference: Splice sample-pack licensing, Stem.is split-sheet workflows, LANDR metadata tagging
• Depends on: Rights-consent.ts (exists), sample/audio import tracking, territory enum, split-sheet schema
• Implementation notes: Create /apps/euterpe-studio-web/src/components/daw/rights-panel.tsx: (1) add RightsState to DawSession (per-track clearance status + license territory), (2) on audio sample import, call rightsConsent.validateImportedAsset() (check ISRC/ISWC if available), (3) on export, call evaluateExportReadiness() (block if uncleared & destination territory conflicts), (4) display RightsPanelComponent listing: track name, sample source, clearance status (cleared/pending/unknown), license territory, royalty % per split-recipient. Add Splice API integration (optional) to query clearance status. Add territory selector in export dialog (default World/Worldwide, restrict based on license).

RIGHTS-4 Royalty tracking & splits display — P1 · L · 🔴 missing#

• What & why: Royalty-agent.ts has full statement reconciliation (Spotify/Apple/YouTube/Tidal, per-track, per-territory, per-revenue-type). Royalty-liquidity.ts has LDA/bond valuation, AMM swaps, L2 routing. Zero UI. Producer does not see: per-stream rates, historical trends, underpayment risks, split distribution. Need to: (1) add royalty-input panel (manually enter baseline rates from platforms), (2) display per-track royalty forecast (if 1M streams this year, earn ~USD X), (3) show splits preview (collaborators' %), (4) integrate with BFF to fetch real royalty statements (requires OAuth with Spotify/Apple), (5) show LDA valuation (if artist opts into Royal.io-style tokenization).
• SOTA reference: LANDR royalty estimation, Splice earnings dashboard, Royal.io LDA pricing, BeatStars collaborator splits
• Depends on: Royalty-agent.ts, royalty-liquidity.ts (both exist), BFF royalty-fetcher route, Spotify/Apple OAuth integration
• Implementation notes: Create /apps/euterpe-studio-web/src/components/daw/royalty-panel.tsx and /apps/euterpe-studio-web/src/daw/royalty-forecast.ts: (1) add RoyaltyState to DawSession (baseline rates per platform, forecastStreams, splits: {[creatorId]: {name, bps}}), (2) create RoyaltyForecastPanel: input baseline rates (Spotify USD 0.003–0.005 per stream default), per-platform toggle, stream-count slider, displays per-track + master royalty USD forecast, (3) add SplitsPanel: collaborators + percentage (persisted to project), (4) create royalty-fetch BFF route (GET /v1/royalty/statements?userId=X&platform=spotify&territoryCode=US) that calls Spotify/Apple APIs and returns reconciled RoyaltyLineItem[], (5) integrate into RoyaltyPanel to show actual vs. forecasted. Optional: call royalty-liquidity.issueLimitedDigitalAsset() on export to calculate LDA pricing & display to user.

RIGHTS-6 Training-data transparency & model-cards display — P2 · M · 🟡 partial#

• What & why: Watermark-capture.ts captures ModelMetadata (provider, modelId, modelVersion, watermarked flag). Zero UI to display what training data the model saw, licensing of training data, consent disclosures. EU AI Act Art. 50 requires transparency on training data. Need to: (1) fetch provider model-card (Lyria, Suno, Udio publish them), (2) display in provenance panel: training-data summary, consent status, license of training data, model capabilities/limitations.
• SOTA reference: Google Lyria model card, Hugging Face model cards (ML standard), EU AI Act training-data transparency requirements
• Depends on: Provider model-card APIs (not exposed by Suno/Udio; requires scraping or custom endpoint), watermark-capture.ts ModelMetadata (exists)
• Implementation notes: Create /apps/euterpe-studio-web/src/components/daw/model-transparency-panel.tsx: (1) add ProvenancePanel enhancement to show captureModelMetadata output (provider, modelId, modelVersion, watermarked), (2) create BFF route GET /v1/models/{provider}/{modelId}/card to fetch & cache provider model-cards (stub for Lyria, scrape for Suno/Udio or add mock responses), (3) display: training-data summary, license, consent attestations, model version release date, known limitations. Add to transport bar or separate sidebar.

RIGHTS-11 Provider watermark verification on import & generation — P2 · M · 🟢 polish#

• What & why: Provider-proofs.ts has complete provider-attestation structure (SynthID confidence scoring, Suno/Udio/Elevenlabs watermark validation). Zero integration with sample import or generation-result verification. Producer imports a track, doesn't know if it's been AI-modified or watermark-stripped. Need to: (1) on audio import, detect watermark (if present), display confidence, (2) on generation completion (Suno/Udio import), verify provider watermark attestation, (3) block import if watermark-stripped + origin uncertain.
• SOTA reference: Google SynthID detection, AudioShake watermark extraction, Suno attestation proof, YouTube Content ID verification
• Depends on: Provider-proofs.ts (exists), watermark-capture.detectWatermark(), sample-import UI, Suno/Udio API attestation endpoints
• Implementation notes: Enhance /apps/euterpe-studio-web/src/components/daw/sampler-panel.tsx: (1) on audio file load, call detectWatermark(audioBuffer) in background, (2) display WatermarkBadge: 'SynthID (confidence X%)' or 'Suno watermark detected', (3) if import origin is Suno/Udio, query provider API for attestation (POST /api/providers/suno/verify-output?outputId=X → returns proof), (4) display ProviderAttestationBadge, (5) on high-confidence AI-generated + watermark present, allow proceeds; on watermark-stripped + origin claimed, warn user ('watermark removed; unable to verify provenance'). Requires Suno/Udio API keys in BFF environment.

RIGHTS-12 Audit log & compliance dashboard (admin view) — P2 · M · 🔴 missing#

• What & why: Compliance-ops.ts has full audit-log implementation (AuditLogEntry, ChainVerification, tamper detection). Zero UI for workspace admin to view compliance event log, policy adherence, incident tracking, vendor risk. Need to: (1) add admin-only compliance dashboard (Workspace > Compliance), (2) display audit-log events (who generated what, when, via which provider, copyright hits, splits disputes), (3) show incident timeline, (4) vendor-risk matrix (which providers have watermark failures, etc.).
• SOTA reference: DataDog Audit Trail, Okta System Log, GitHub Audit Log, SOC 2 compliance dashboards
• Depends on: Compliance-ops.ts (exists), audit-log persistence in BFF (need DB schema), workspace admin role check
• Implementation notes: Create /apps/euterpe-studio-web/src/components/workspace/compliance-dashboard.tsx + BFF route GET /v1/admin/workspace/{workspaceId}/audit-log: (1) add ComplianceDashboard component (Workspace Settings > Compliance tab, admin-only), (2) fetch audit events from BFF (queryAuditLog(workspaceId, filters: {kind?, severity?, dateRange, provider?})) → AuditLogExport, (3) display timeline: event type (generation, copyright-hit, delete-request, provider-change), timestamp, user, details, (4) add IncidentTimeline (list of IncidentReports), (5) add VendorRiskMatrix table (each provider vs. control metrics: watermark-verified %, SynthID-detected %, uptime, DMCA-strikes). Requires audit-log schema in BFF DB (PostgreSQL table: audit_events with JSONB payload).

RIGHTS-15 Synthesized melody copyright detection (pre- & post-gen) — P2 · M · 🟡 partial#

• What & why: Copyright-safety.ts has melodySimilarityPreflight() (chroma histogram + interval contour + Jaccard shingle matching). Could detect if Euterpe-generated melody is too-similar to protected work. Zero integration with generation. Need to: (1) after generateMelodyFromChords() completes, scan result against protected-melody database, (2) show similarity score + matched work, (3) suggest variation if too-similar.
• SOTA reference: YouTube Content ID audio fingerprinting, Shazam fingerprinting, Musipedia melodic search, Melodycatcher similarity
• Depends on: Copyright-safety.ts melodySimilarityPreflight() (exists), generate-clip.ts, protected-melody database (seed in copyright-safety.ts types)
• Implementation notes: Enhance /apps/euterpe-studio-web/src/daw/generate-clip.ts: (1) after generateMelodyFromChords() produces noteClip, extract melodic contour (intervals + rhythm), (2) call postGenerationSimilarityScan(clip, protectedMelodies) from copyright-safety.ts, (3) if similarityScore > 0.85 for any protected work, show MelodySimilarityWarning in UI: 'Generated melody is XXX% similar to [Protected Work]; consider varyClipNotes() to differentiate', (4) user can click 'Regenerate Half' or 'Apply Variation' to diverge. Seed protected-melody database with: Beatles top-10, Taylor Swift catalog, Drake top-20, etc. Use musicbrainz.org + Genius API to enrich.

RIGHTS-17 Cross-border territory rights enforcement — P2 · M · 🟡 partial#

• What & why: Rights-consent.ts has evaluateTerritory() (region-specific policy, license compatibility). Music rights vary by territory (US mechanical rates differ from EU; sync rights require local societies). Zero UI to select export territories, no warning if license doesn't cover destination. Need to: (1) add territory selector on export (World/Worldwide vs. specific regions), (2) check license compatibility per territory, (3) show royalty-rate differences (Spotify US vs. EU vs. APAC), (4) block export to incompatible territories or warn user.
• SOTA reference: CISAC territory mapping, Spotify regional rate cards, PRS for Music (UK), ASCAP (US), SACEM (FR), territorial licensing enforcement
• Depends on: Rights-consent.ts evaluateTerritory() (exists), territory enum (ISO 3166-1), license schema with territory grants
• Implementation notes: Enhance /apps/euterpe-studio-web/src/components/daw/transport-bar.tsx export dialog: (1) add TerritorySelector (multi-select: default World; options: US, GB, DE, FR, JP, AU, CA, BR, MX, KR, CN, IN, ZA, WW), (2) on selection change, call evaluateTerritory(license, selectedTerritories) → EffectiveThresholds (royalty rates per territory), (3) display: 'Exporting to [territories]; average royalty rate USD 0.004/stream (US), EUR 0.003/stream (EU); estimated annual revenue 1M streams = USD X', (4) store territories in DawSession.exportTerritories, (5) embed in C2PA manifest. Optional: add regional rate-card fetcher from BFF (Spotify/Apple public rate data).

RIGHTS-9 Marketplace & distribution rights routing for generated content — P2 · L · 🔴 missing#

• What & why: No UI to license generated tracks for commercial use, resale, or exclusive distribution. Producer creates track, can export, but zero in-DAW path to: (1) post to SoundCloud/Bandcamp with auto-licensing, (2) set usage terms (CC-BY, CC-BY-SA, exclusive, commercial prohibited), (3) route to distribution platform (DistroKid, Tunecore, Mandolin), (4) collect royalties from downstream uses. Need to: (1) add license-picker on export (CC0, CC-BY, CC-BY-SA, CC-BY-NC, proprietary), (2) generate rights-assertion doc for distribution platform, (3) integrate DistroKid/Tunecore APIs for auto-upload, (4) display earnings dashboard.
• SOTA reference: BandLab licensing picker, Soundtrap distribution integration, SoundCloud Creator Fund, DistroKid API, Audius on-chain licensing
• Depends on: License schema (Creative Commons enums), distribution platform APIs (DistroKid, Tunecore, Mandolin, BandLab), earnings fetch from BFF
• Implementation notes: Create /apps/euterpe-studio-web/src/components/daw/distribution-panel.tsx + /apps/euterpe-studio-web/src/daw/distribution-router.ts: (1) on master export, add DistributionStep to export dialog: license picker (CC-BY default), artist/album name, upload destination (local file, SoundCloud, Spotify via DistroKid, etc.), (2) call distributeTrack(blob, metadata, license) → DistributionResult, (3) integrate DistroKid API via BFF route POST /v1/distribution/distrokid?accessToken=X, (4) add EarningsPanel to fetch earnings from /v1/earnings/summary (requires user OAuth with platforms). Start with SoundCloud + local export; expand to DistroKid + Spotify in Wave 2.

RIGHTS-14 Sample clearance API integration (Splice, HookTheory, Beatport) — P2 · L · 🔴 missing#

• What & why: Rights-consent.ts has advanceSampleClearance() state machine. Zero integration with clearance-lookup APIs. Producer must manually verify samples via Splice web UI (tedious, not DAW-native). Need to: (1) on audio sample import, look up ISRC/metadata in Splice/HookTheory, (2) auto-fetch clearance status (cleared, pending, requires manual review), (3) display in rights panel, (4) block export if critical sample is uncleared.
• SOTA reference: Splice sample-clearance API, BeatStars clearance checker, HookTheory API, AudioShake stem database
• Depends on: Splice/HookTheory/Beatport API keys, rights-consent.ts (exists), sample-import tracking
• Implementation notes: Create /apps/euterpe-studio-web/src/daw/sample-clearance.ts + enhance sampler-panel.tsx: (1) on audio file load, extract or prompt for ISRC/metadata, (2) call BFF route POST /v1/samples/lookup-clearance?isrc=X → returns SampleClearanceStatus (cleared/pending/unknown/blocked), (3) display in SamplerPanel or RightsPanel, (4) if uncleared + destination territory conflicts, block export (or allow with warning + audit log). Requires Splice API key (enterprise tier) in BFF environment; HookTheory free tier for metadata enrichment.

RIGHTS-7 On-chain work registration & blockchain rights registry integration — P2 · XL · 🔴 missing#

• What & why: Chain/rights-registry/index.ts has full schema (WorkRegistration, CreatorInfo, TimestampProof, AuthorshipAttestation, SampleTracking, CoverLicense, SyncLicense). Zero blockchain integration (no Solana/Ethereum/Polygon contract calls). Need to: (1) register work on-chain on export (with authorship multi-sig), (2) track samples + interpolations on-chain, (3) query on-chain registry to verify rights ownership before using samples in remixes.
• SOTA reference: Audius (Solana on-chain registry), Verifi Media smart contracts, Sound Protocol (music NFTs), Royal.io work registration
• Depends on: Chain/rights-registry.ts (exists), blockchain integration (ethers.js/solana.js), smart contract deployment, wallet connection UI
• Implementation notes: Create /apps/euterpe-studio-web/src/blockchain-bridge/: (1) add Solana/Polygon wallet connection (ape-ui or @solana/web3.js), (2) create smart contract (Rust/Move/Solidity) for work registration (call from BFF via relayer account to avoid per-user gas), (3) on master export, call registerWorkOnChain(title, creators[], contentHash, sampleOrigins[]) → returns blockNumber + txHash, (4) store txHash in DawSession.onChainProof, (5) add RegistryLookup panel to check ownership before importing external sample. Start with Solana (cheapest gas, faster finality); consider Polygon (EVM-compatible) as secondary. Requires legal review of smart contract & liability framework.

RIGHTS-8 Real-time royalty-split liquidity & AMM integration — P2 · XL · 🟡 partial#

• What & why: Royalty-liquidity.ts has complete AMM implementation (constant-product swaps, price-impact, slippage, secondary market order matching, waterfall splits, L2 routing on Base/Optimism/Polygon). Zero UI & zero blockchain integration. Producers cannot tokenize future royalty streams or sell/trade splits in real time. Need to: (1) allow producer to opt into Limited Digital Asset (LDA) issuance on export, (2) calculate fair-market price (DCF valuation of stream forecasts), (3) display swap UI (trade splits on AMM), (4) route payments across L2 networks (low gas).
• SOTA reference: Royal.io LDA tokenization, Stem.is waterfall splits, SongVest secondary market, constant-product AMM (Uniswap v2 model)
• Depends on: Royalty-liquidity.ts (exists), blockchain L2 routing (ethers.js for Base/Optimism/Polygon), USDC/EURC stablecoin integration, smart contract (waterfall escrow)
• Implementation notes: Create /apps/euterpe-studio-web/src/components/daw/royalty-liquidity-panel.tsx + /apps/euterpe-studio-web/src/blockchain-bridge/amm-router.ts: (1) on export, offer LDA issuance (checkbox), (2) call issueLimitedDigitalAsset() from royalty-liquidity.ts with forecast (DCF/NPV of streams), (3) display issue price per share + total offering size, (4) create LP contract on Base (cheapest) with initial liquidity, (5) add SwapPanel to buy/sell splits (call swapQuote() for price, route payment via L2). Requires smart contract for waterfall escrow + treasury integration. High complexity; consider phased rollout (Phase 1: LDA valuation display only, Phase 2: swap UI, Phase 3: on-chain routing).

RIGHTS-19 Training-data attribution & opt-out for new models — P3 · S · 🔴 missing#

• What & why: Euterpe's on-device melody-gen + genesis library are trained (implicitly) on MIDI corpus + music theory rules. Producer may not want their exported track used to train future AI models. Zero UI to opt out of model training, no attribution back to producer if their work is used. Need to: (1) add training-opt-out checkbox on export, (2) embed opt-out flag in C2PA manifest, (3) display attribution if available (e.g., 'this model was trained on 10K GPL-licensed tracks; your track contributed').
• SOTA reference: OpenAI training-data opt-out (GPT), Stability opt-out, Hugging Face dataset opt-out, CC-BY-NC license (prohibits derivative models)
• Depends on: C2PA manifest (P0 above), DawSession metadata, opt-out flag schema
• Implementation notes: Enhance export dialog: (1) add checkbox 'Allow this track to be used for training future AI models', default OFF (conservative), (2) on master export, add trainingOptOut: false/true to DawSession.provenanceLog, (3) embed in C2PA manifest, (4) future: add attribution UI (beta, not critical): 'This model was trained on N producer tracks; you earned USD X from training data licensing.' Requires future governance framework for model-training data licensing (not currently in scope).

RIGHTS-16 Lyric copyright scanning (if text-to-singing ever wired) — P3 · M · 🔴 missing#

• What & why: Copyright-safety.ts has lyricSimilarityScan() + scanCopyrightedPrompt(). Zero integration with voice/singing features (frontier-voice stubs). If Euterpe ever wires text-to-singing (e.g., via ElevenLabs TTS or frontier-voice), need to pre-screen lyrics for copyrighted content (song titles, artist names, protected phrases).
• SOTA reference: Genius API lyric copyright detection, Spotify forbidden-lyric filter, YouTube Content ID audio + lyric matching
• Depends on: Copyright-safety.ts (exists), text-to-singing UI (frontier-voice, not yet wired), ElevenLabs TTS integration
• Implementation notes: Placeholder for future text-to-singing feature. When frontier-voice or ElevenLabs TTS UI is built: (1) on lyric input (before synthesis), call scanCopyrightedPrompt() + lyricSimilarityScan() from copyright-safety.ts, (2) flag copyrighted content (artist names, song titles), (3) suggest lyric rewrite via suggestPromptRewrite(), (4) allow override with audit log. Requires Genius API (free tier) for lyric database + ElevenLabs voice-cloning opt-in.

RIGHTS-18 Incident reporting & escalation workflow (abuse, DMCA, unsafe generation) — P3 · M · 🔴 missing#

• What & why: Compliance-ops.ts has full IncidentPlaybook + EscalationTier system. Zero UI for workspace admins to file incidents (DMCA takedowns, unsafe generations, repeat infringers). Need to: (1) admin-only incident-creation UI, (2) escalation workflow (tier 1 warning → tier 2 account restriction → tier 3 platform ban), (3) evidence-collection automation.
• SOTA reference: GitHub Abuse Reporting, Discord Trust & Safety, YouTube Copyright Strike System, Stripe Radar incident logging
• Depends on: Compliance-ops.ts (exists), workspace admin role check, incident-log persistence in BFF
• Implementation notes: Create /apps/euterpe-studio-web/src/components/workspace/incident-report-panel.tsx + BFF route POST /v1/admin/incidents: (1) admin-only panel (Workspace > Compliance > Incidents), (2) form: incident kind (DMCA, unsafe-generation, repeat-infringer), severity (P1–P4), description, evidence (link to session, generation output), (3) call createIncidentReport() from compliance-ops.ts, (4) store in BFF, (5) auto-escalate if repeat offender (check audit log for prior incidents), (6) generate playbook steps (notify user, restrict platform, etc.). Requires incident-log schema in BFF DB.