MIDI, Instrument, and Editor Rebuild Plan

100% Acceptance-Matrix Completion Plan - 2026-05-11

For this recovery, "100%" means every documented Studio13 MIDI acceptance-matrix workflow passes with evidence. It does not mean cloning every REAPER, Cubase, or openDAW feature. REAPER arrange editing, Cubase Key Editor workflows, and openDAW editor architecture remain the reference targets, but Studio13 ships only the workflows explicitly recorded in midi_editor_reference_matrix.md.

Completion rules:

midi_editor_reference_matrix.md is the source of truth for MIDI editor completion.
Every matrix row must include a reference artifact, current Studio13 behavior, required Studio13 behavior, frontend owner, backend owner when applicable, automated test, browser/manual acceptance test, and status.
Phase 4, Phase 5, Phase 7, and Phase 9 remain reopened until browser/WebView screenshots, pointer QA, automated tests, and explicit acceptance notes exist for every row in their area.
Store-only tests cannot prove pointer behavior. Timeline and piano-roll gesture acceptance requires real browser/WebView pointer input.
Prior checked boxes under historical Phase 4, Phase 5, Phase 7, and Phase 9 are partial implementation evidence only. They are not completion claims after this recovery reset.

100% completion phases:

Completed acceptance evidence:

Active Implementation Slice - 2026-05-14

Detached MIDI Editor and Pop-Out Reliability Plan:

Findings captured before implementation:

The first detached window is slow because a fresh WebView currently boots the frontend shell and hydrates its session. The warm-shell fix must create at most one hidden MIDI editor shell while the bottom/docked editor is open, then reuse it for pop-out.
Detached MIDI and mixer windows currently receive lower-frequency transport samples than the main window, which explains laggy or apparently behind playheads. They need shared transport commands plus local visual interpolation from native samples.
Detached ruler seek currently updates local editor state before the main timeline reliably receives the stopped-position update. Ruler seek must go through the shared seek path.
Dock crashes are likely caused by native close reason loss and WebView teardown while the frontend expects a dock transition. The main midiEditorWindowClosed handler must branch on the preserved reason.
Same-track clip movement is conceptually source-time safe because notes remain relative to the MIDI source, but detached sessions must refresh from the current clip.startTime.
Cross-track clip movement is not safe while sessions store stale trackId; merges must resolve by current clipId location in the main store.

Required verification for this slice:

Unit coverage for warm-shell lifecycle, transport fields excluded from MIDI snapshots, same-track and cross-track clip movement, stale detached snapshot merge prevention, deleted/incompatible clip invalidation, dock-vs-close reasons, detached undo/redo delegation, and loop-boundary hover cursor.
Browser/CDP coverage for repeated pop-out/dock without crash, detached playhead smoothness/alignment, detached ruler seek updating the main timeline, main Stop stopping detached visuals, edited clip sideways/cross-track movement, detached Ctrl+Z/Ctrl+Y, loop/source hover cursor, and proof that many MIDI clips do not create many hidden warm shells.
Before manual testing, run the latest code through cmake --build build --config Debug; the user will test with python build.py dev --run, so no Codex-started Vite/browser process should be left running.

Recovery Status - 2026-05-11

This plan has been reopened as a recovery/rebuild tracker. The previous automated implementation pass did not meet hands-on acceptance: MIDI timeline clips cannot be reliably moved, resized, slipped, or loop-extended in the real UI, the piano roll still reads as an old prompt-heavy editor rather than a polished DAW key editor, and the prior test pass did not cover browser/WebView pointer behavior or visual quality.

midi_editor_reference_matrix.md is now a required companion deliverable before additional editor work is marked complete. It must document the REAPER arrange and Cubase Key Editor behaviors we are copying conceptually, Studio13's current behavior, the required Studio13 behavior, the owner area, and the acceptance test.

Research correction, 2026-05-11: visual research must show the actual DAW editor surfaces, not vendor websites or documentation chrome. The accepted local evidence is now captured in qa/midi-editor/2026-05-11/research/actual/, including REAPER MIDI editor/user-guide screenshots, Cubase Pro 15 Key Editor/controller-display screenshots, and openDAW source-file references. Future piano-roll/timeline work must cite those artifacts or new actual editor captures before claiming parity.

Superseded completion claims:

Phase 4 timeline editing is reopened until real browser/WebView drag, resize, slip, loop-extension, split, duplicate, context, and undo acceptance passes.
Phase 5 piano roll is reopened until the editor is rebuilt into a polished DAW-grade layout with reliable note tools, inspector, multi-item editing, and browser-tested interactions.
Phase 7 controller lanes are reopened until controller lane rows, lane management, transforms, pitchbend ranges, and undoable editing are usable without prompt-driven workflows.
Phase 9 QA is reopened until automated tests are backed by browser/WebView interaction QA, screenshots, and manual REAPER/Cubase workflow acceptance.

Summary

Rebuild Studio13 MIDI around a reliable DAW-grade signal path and editor model, using REAPER, Cubase, and openDAW as behavior references. Direct openDAW code copying is avoided by default because openDAW is AGPLv3; we will reimplement the concepts and UX patterns in Studio13's existing JUCE + React architecture.

This file is the execution tracker. Each phase is marked done only after implementation and verification for that phase pass.

Research sources:

Cubase Quantize Panel and musical-grid options: https://www.steinberg.help/r/cubase-pro/15.0/en/cubase_nuendo/topics/quantizing_midi_audio/quantizing_quantize_panel_c.html and https://www.steinberg.help/r/cubase-pro/15.0/en/cubase_nuendo/topics/quantizing_midi_audio/quantizing_quantizing_panel_options_musical_grid_r.html
Cubase controller, velocity, pitchbend, line-tool behavior: https://www.steinberg.help/r/cubase-pro/15.0/en/cubase_nuendo/topics/midi_editors/midi_editors_controller_lanes_adding_t.html, https://www.steinberg.help/r/cubase-pro/15.0/en/cubase_nuendo/topics/midi_editors/midi_editors_velocity_events_editing_t.html, https://www.steinberg.help/r/cubase-pro/15.0/en/cubase_nuendo/topics/midi_editors/midi_editors_pitchbend_controller_lanes_r.html, https://www.steinberg.help/r/cubase-pro/15.0/en/cubase_nuendo/topics/midi_editors/midi_editor_line_tool_modes_r.html
REAPER latest guide page and PDF: https://www.reaper.fm/userguide.php and https://www.reaper.fm/userguide/ReaperUserGuide772.pdf
openDAW reference: https://github.com/andremichelle/openDAW
User-provided REAPER MIDI workflow video: https://www.youtube.com/watch?v=Z4tfTzwlwyw. Direct transcript/video fetch may be blocked in the tool environment; when blocked, record that in midi_editor_reference_matrix.md and use visible/manual notes plus the related Reapertips MIDI editor workflow page.

Key Changes

Replace the current flat MIDI clip/event scheduler with a canonical MIDI source model: MIDI item start/duration, source start, source length, loop enabled, loop offset, visible item window, note events, CC events, pitchbend events, channel data, muted/locked state, probability, velocity variance, and undo snapshots.
Implement REAPER-style timeline MIDI items: resize-left trims/slips source, resize-right extends item, expansion beyond source loops by default, loop boundaries/notches are visible, and piano roll can edit source length separately from item length.
Implement Cubase-style Key Editor behavior: double-click MIDI item opens piano roll, note insert/move/resize/split/glue/mute/delete, acoustic preview, multi-note selection, selected-note inspector, scale guides, pitch quantize to scale, and active/editable/visible multi-item editing.
Implement controller lanes for Velocity, Note-Off Velocity, Velocity Variance, Pitchbend, Modulation CC1, Expression CC11, Sustain CC64, Program/Bank, Aftertouch, Poly Pressure, and arbitrary 7-bit/14-bit CCs.
Controller lanes support Cubase/REAPER editing: add/remove lanes, lane presets, draw single events, paint sweeps, line/parabola/sine/triangle/square tools, step vs ramp/curve interpolation, curve handles, scale/tilt/compress/stretch selection editor, LFO generation, thinning/reducing dense CC data, copy/paste between lanes, and per-lane height controls.
Pitchbend lane supports bipolar display, MIDI value mode, semitone/cents display, per-track pitchbend range up/down, linked/unlinked range, semitone grid, snap pitchbend events to semitone grid, and correct 14-bit MIDI pitch wheel serialization.
Quantize supports Cubase and REAPER workflows: quantize note starts, note ends, note lengths, starts + ends, fixed lengths, soft/iterative strength, swing, tuplets, catch range, safe range/non-quantize zone, rough/randomize, move related controllers with notes, reset/unquantize, freeze quantize, groove presets, input quantize, and "quantize using last settings."
Add humanize and performance tools: timing humanize, velocity humanize, velocity scale/compress/tilt, legato, remove overlaps, note length clamp, transpose/octave actions, step input, MIDI panic, chase note/CC/program/pitchbend on playback seek, and all-notes-off on stop/mute/delete/type change.
Rebuild the MIDI signal path contract: project load and track creation must atomically sync backend track id, type, instrument, MIDI input/output, track FX, MIDI clips, controller data, and scheduler diagnostics before playback can report success.
Fix saved MIDI projects going silent by explicitly syncing loaded midiClips to setTrackMIDIClips, restoring backend track type before arm/monitor state, restoring MIDI routing, and validating scheduledMIDIClipCount / scheduledMIDIEventCount after load.
Fix loud crack on adding MIDI/instrument tracks by adding an atomic backend track creation/config bridge, preventing default-audio half-initialized tracks from entering the realtime graph, clearing buffers, resetting plugin state, suppressing hardware input until type/routing sync completes, and sending all-notes-off/all-sound-off during transitions.
Add openDAW-equivalent concepts where useful: loopable note regions, note chance/play count/velocity/cent metadata, MIDI Output device, SoundFont/basic sampler path, built-in MIDI FX for Arpeggio, Pitch, Velocity, Time/Groove, and a scriptable MIDI transform foundation.

Phases

Recovery Rebuild Checklist

Create and maintain midi_editor_reference_matrix.md with REAPER arrange, Cubase Key Editor, Reapertips/video, openDAW visual reference, current Studio13 gaps, required behavior, owner area, and acceptance tests.
Replace the MIDI clip interaction path with a shared audio/MIDI timeline gesture path that does not lose state on global mouseup and commits one undoable command per completed gesture.
Browser-test MIDI clip select, move, snap move, copy-drag, left resize/source slip, right resize/loop expansion, Alt-slip, split, duplicate, delete, context actions, and Ctrl+Z/Ctrl+Y. 2026-05-12 partial pass: browser/CDP pointer QA verified MIDI item select, Ctrl multi-select, move with undo/redo, snap move, compatible cross-track move to an instrument track with undo/redo, compatible cross-track copy-drag with undo/redo, incompatible audio-target suppression, ghost MIDI-track creation with undo/redo, right-edge loop resize with undo/redo, left trim/source slip with backend-visible source-window serialization and undo/redo, Alt-slip with backend-visible source-window serialization and undo/redo, same-track copy-drag with undo/redo, split with undo/redo, context duplicate/delete with undo/redo, prompt-free repeat dialog with undo/redo, keyboard Ctrl+D duplicate with undo/redo, keyboard Delete with undo/redo, app-level Ctrl+Z undo, app-level Ctrl+Y redo, mute-tool click with undo/redo, context lock with undo/redo, locked-item move suppression, source-offset reset with undo/redo, source-length-to-item with undo/redo, source-length-to-content with undo/redo, custom source-length dialog with undo/redo, backend bridge payload serialization after a loop-resize, and native render proof for a combined resolved MIDI payload. Manual acceptance remains open.
Rebuild the piano roll into a polished Cubase-style key editor surface with tool strip, grid, piano keyboard, note inspector, controller lane stack, and status/readout strip. 2026-05-12 partial pass: shell, stateless visible toolbar/info-line/status-strip/inspector-summary/note-inspector/controller-lane/lane-editor/pitchbend component splits, lane stack controls, lane hit testing, shared stage capture for grid/note/loop/controller/velocity targets, MIDI note-model/pitch-scale/lane-mapping/velocity-color/tool-registry helper extraction, note drag undo/redo, draw/erase/resize/split/glue/mute/velocity undo-redo QA, range select, active/reference multi-item browser QA with isolated undo/redo, inspector pitch/start/length/metadata full-chain undo-redo and batch undo-redo QA, velocity-lane direct and ramp/undo-redo QA, CC#1/CC#74 controller direct/ramp/step/curve/parabola/transform/compress/stretch/thin/copy/clear/paste/cross-lane-paste/LFO browser QA, 14-bit CC edit QA, pitchbend line/direct snap QA, program/channel pressure/poly pressure lane QA, lane hide/add/configure QA, pitchbend range-control undo/redo QA, project save/reload QA, MIDI FX/chance/variance backend-bound render/export-input QA, MIDI FX header-to-FX-panel placement QA, native backend chase/render/freeze/export/combined-render QA, and viewport screenshot QA are implemented; remaining gap is complete DAW workflow parity.
Replace prompt-based piano-roll MIDI/controller transforms with popovers, menus, numeric inputs, segmented controls, sliders, lane menus, and icon buttons.
Capture screenshots and manual acceptance notes before marking reopened phases complete. 2026-05-12 automated screenshots/reports live under qa/midi-editor/2026-05-12/implementation/; manual acceptance notes remain open.

Piano Roll Recovery Completion Slice - 2026-05-11

Implementation target for the next acceptance slice:

Replace the old toolbar-first piano roll with a Cubase-style Key Editor shell: icon tool strip, editor grid, persistent right inspector, controller lane stack, and status/readout strip.
Add frontend editor state for expanded tools, visible lane rows, active lane selection, lane heights, interpolation, and lane presets.
Route note metadata editing through the inspector, including batch edits for velocity, channel, release velocity, chance, variance, play count, and cent offset.
Formalize note/grid/lane hit testing and gesture session classification so pointer behavior can be browser-tested instead of inferred from store-only tests.
Keep reopened Phase 5 and Phase 7 incomplete until browser/WebView screenshots and manual interaction checks pass.

Completed Sub-Items

Phase 1 regression fixtures:

Native MIDI scheduler fixture for scheduled notes, CC, pitchbend, program change, channel pressure, finite output, and no audio spike on plain MIDI tracks.
Native fallback instrument fixture for finite nonzero instrument-track audio without a plugin.
Frontend saved-project reload schedule-repair fixture for missing backend MIDI clips/events.
Native add-track first-block silence fixture for newly added MIDI and instrument tracks.
Saved-project reload playback fixture.
Dedicated add-track crack/spike fixture while audio callback is active.

Phase 2 signal path:

Atomic backend track creation with explicit audio/midi/instrument type.
Project-load MIDI clip resync and scheduler mismatch repair.
Expanded MIDI diagnostics with scheduled clip/event counts, routing, devices, and fallback instrument state.
MIDI panic/all-notes-off/all-sound-off/reset-controller handling.
MIDI chase for notes, CC, pitchbend, pressure, and program state.
Compact per-track MIDI output routing UI.
Offline render/freeze MIDI parity validation.
Crack/spike harness and threshold reporting.

Phase 3 MIDI source model:

Source length/source start/loop offset/loop length metadata for MIDI clips.
Legacy source-length inference for old projects.
Backend serialization respects visible item windows and loop expansion.
Full deterministic saved-project migration test matrix.

Phase 4 timeline editing:

Live resize preview with one undoable commit per drag gesture.
REAPER-style loop expansion preservation and loop-notch rendering.
MIDI slip editing and source-window context actions.
More loop/trim edge-case regressions.

Phase 5 Piano Roll:

Note add/move/resize/delete, source-length extension, velocity editing, range editing, and step input.
Pitchbend lane draw/edit and pitchbend semitone grid/snap.
Multi-clip ghost rendering groundwork.
Single-note inspector for pitch, start, length, and velocity edits.
Editable/visible multi-item editing controls.
Deeper scale/chord assistant polish.

Phase 6 quantize/humanize:

Quantize starts, ends, starts+ends, length, fixed length, strength, swing, randomize, and move related controllers.
MIDI input quantize for completed recordings.
Quantize using last MIDI settings.
Reset/unquantize and freeze quantize for MIDI clips with undoable quantize backups.
Humanize timing and velocity, velocity set/scale/randomize, legato, mute, transpose, invert, reverse, mirror.
Tuplet quantize, catch range, and safe/non-quantize zones.
Groove presets.

Phase 7 controller lanes:

Phase 8 instrument tracks:

Built-in fallback Studio13 Basic Synth for instrument tracks with no plugin.
Fallback synth exposed in track header, channel strip, FX chain, and diagnostics.
Per-track MIDI output device selection.
MIDI FX: arpeggiator, pitch, velocity, time/groove, exposed through the track FX panel instead of compact TCP buttons.
SoundFont/basic sampler support and instrument render/freeze QA.

Test Plan

Frontend Vitest: MIDI migration, clip serialization, loop expansion, timeline hit/resize behavior, quantize algorithms, controller lane editing, project load resync, undo/redo grouping.
Browser/WebView QA: create or load MIDI clips and verify actual pointer gestures for select, move, snap, copy-drag, left/right resize, slip edit, loop extension, split, duplicate, undo, and redo.
C++/headless tests: setTrackMIDIClips scheduling, loop expansion, note/CC/pitchbend chase, all-notes-off, MIDI output routing, instrument render, freeze, and no duplicate track IDs.
Integration fixtures: save a project with MIDI clips + instrument + CC/pitchbend, reload it, assert backend diagnostics show scheduled MIDI events and render contains non-silent output.
Crack regression: add MIDI and instrument tracks while audio callback is active and assert no non-finite samples, no oversized transient, no stale reusable buffer leakage, and no hardware input read before type sync.
Manual acceptance: reproduce REAPER resize/loop behavior, Cubase quantize panel behavior, velocity lane editing, modulation drawing, pitchbend snapping, project reload playback, and add-track silence.

Assumptions

Studio13 may replace the current MIDI implementation completely, but unrelated user changes in the dirty worktree must not be reverted.
Direct AGPL openDAW code copying is not the default; implementation will copy concepts and UX behavior unless the project explicitly accepts AGPL obligations.
MIDI and instrument reliability is higher priority than preserving the current broken MIDI editor internals.
Existing known TypeScript errors outside the touched MIDI path are not blockers, but no new MIDI-related TypeScript errors should be introduced.
Automated QA alone is not complete for this feature; browser/WebView pointer QA, screenshots, and subjective DAW feel remain required acceptance gates.

Phase Log

2026-05-14: Completed the Detached MIDI Editor and Pop-Out Reliability slice. Native MIDI editor windows now preserve close reasons (dock, close, appQuit, warm-shell disposal); docking hides/reuses the session shell instead of destroying the session; the main window prewarms only the current docked MIDI editor session; detached snapshots exclude currentTime/isPlaying; detached transport/ruler/hotkey commands route to the main/native authority; detached and mixer windows use shared 60fps transport interpolation; MIDI clip moves update open editor sessions by clipId; stale detached snapshots merge into the clip's current track instead of resurrecting old-track data; deleted MIDI clips close their editor sessions; detached clip-data snapshots create main undo/redo entries; and loop/source boundaries expose a horizontal resize cursor. Verification passed: npx tsc --noEmit, full npx vitest run (31 files / 170 tests), node --check tools/midi-editor-acceptance-harness.mjs, focused browser/CDP app-midi-multi-session in qa/midi-editor/2026-05-14/detached-midi-reliability-focused-final, full browser/CDP --scenario all in qa/midi-editor/2026-05-14/detached-midi-reliability-all-final, npm run build, and cmake --build build --config Debug after the frontend build so the Debug app output contains the latest packaged frontend. The temporary Vite server used for browser QA was stopped before handoff.
2026-05-13: Fixed a MIDI recording visibility regression introduced by the multi-session editor sync. Detached editor snapshots now merge only the session clip into the main window track instead of replacing the whole track, and main-window transport is no longer overwritten by stale detached snapshots while recording. Added focused regression coverage proving a live MIDI recording item appears at record start and a completed backend MIDI recording is appended to track.midiClips on stop. Verification passed: npx vitest run src/__tests__/midiRecordingTransport.test.ts src/__tests__/midiEditorSessions.test.ts, node --check tools/midi-editor-acceptance-harness.mjs, and browser/CDP node tools/midi-editor-acceptance-harness.mjs --scenario app-midi-recording-visibility --out qa/midi-editor/2026-05-13/recording-visibility.
2026-05-13: Fixed the hardware MIDI input default that could make Komplete M32/Komplete Kontrol style recording appear to do nothing. The track input selector now says All Inputs instead of No Device; frontend record start opens every available MIDI input for armed MIDI/instrument tracks using that empty-input mode; and the C++ record-start path opens the explicit track input or all available inputs before starting the in-memory MIDI recorder. Verification passed: focused midiRecordingTransport.test.ts and node --check tools/midi-editor-acceptance-harness.mjs.
2026-05-13: Fixed MIDI-only recording where a freshly added/armed MIDI track could fail unless an audio track was also armed. Record start now forces backend track/type/arm/input sync for all armed tracks before recording starts, and native MIDI recorder start time is initialized immediately from the transport position. Verification passed: focused midiRecordingTransport.test.ts, browser/CDP app-midi-recording-visibility in qa/midi-editor/2026-05-13/recording-midi-only-sync, npx tsc --noEmit, full npx vitest run (31 files / 166 tests), npm run build, and cmake --build build --config Debug.
2026-05-13: Completed the Multi-Session MIDI Editor and Timeline Parity pass. Replaced singleton Piano Roll state with MidiEditorSession routing, kept one docked editor while opening additional clips in detached session windows, added session-aware native MIDI editor window callbacks/snapshots, retitled docked/windowed headers to Track Name - Clip Name, renamed the toolbar action to Pop Out, added MIDI ruler playhead continuity and ruler-click seek, and made piano-key drag audition pointer-captured with cleanup note-offs. Verification passed: npx tsc --noEmit, full npx vitest run (30 files / 163 tests), node --check tools/midi-editor-acceptance-harness.mjs, focused browser/CDP app-midi-multi-session and app-docked-piano-focus, full browser/CDP node tools/midi-editor-acceptance-harness.mjs --scenario all --out qa/midi-editor/2026-05-13/multi-session-all-final, npm run build, and cmake --build build --config Debug. The temporary Vite server used for browser QA was stopped before handoff.
2026-05-13: Completed the Piano Roll parity/usability pass requested after REAPER comparison and manual review. Restored piano keys inside the TCP-width left area while keeping the note grid aligned under the arrange timeline, added a compact ruler, visible grid scrollbars, 85% lower-zone resize cap, single selected controller lane rendering with a header lane selector, visible Quantize/Q controls, draggable source loop end markers, tooltip/aria coverage for the touched controls, and a native detached midiEditor window role with active-clip snapshot sync. Verification passed: npx tsc --noEmit, full npx vitest run (29 files / 157 tests), node --check tools/midi-editor-acceptance-harness.mjs, focused browser/CDP app-docked-piano-focus, piano-visual-viewports, piano-source-header, piano-controller-lane, piano-cc-direct, piano-pitchbend-direct, piano-tools, piano-range, piano-audition-insert, full node tools/midi-editor-acceptance-harness.mjs --scenario all --out qa/midi-editor/2026-05-13/piano-parity-pass-all, npm run build, and cmake --build build --config Debug. The temporary Vite server used for browser QA was stopped before handoff.
2026-05-12: Completed code-review cleanup for the MIDI/instrument implementation slice. Added /qa/ to .gitignore so generated browser screenshots, reports, native regression JSON, and research captures stay local instead of entering git. Replaced the instrument-track sampler root-note window.prompt with an in-app numeric dialog and extended midi-fx-placement to verify the dialog flow does not call window.prompt. Fixed instrument plugin remove/undo so instrument tracks remain instrument tracks and continue using the fallback synth path after a plugin is removed. Added store regressions for instrument plugin load undo and remove undo/redo. Verification passed: node --check tools/midi-editor-acceptance-harness.mjs, npx tsc --noEmit, full npx vitest run (28 files / 153 tests), focused midi-fx-placement, full browser/CDP node tools/midi-editor-acceptance-harness.mjs --scenario all --out qa/midi-editor/2026-05-12/implementation with 32 scenarios, and cmake --build build --config Debug.
2026-05-12: Addressed manual TCP parity feedback for MIDI/instrument tracks. Removed the always-visible Arp/Pit/Vel/Tim MIDI FX buttons from TrackHeader and moved MIDIFXControls into the normal track FX chain panel so the header stays closer to REAPER/Cubase track controls while MIDI FX remains available. Added browser/CDP midi-fx-placement acceptance to verify the header has no MIDI FX mini-buttons and the FX panel exposes them. Verification passed: node --check tools/midi-editor-acceptance-harness.mjs, npx tsc --noEmit, full npx vitest run (28 files / 151 tests), focused midi-fx-placement, focused midi-fx-controls, and full node tools/midi-editor-acceptance-harness.mjs --scenario all --out qa/midi-editor/2026-05-12/implementation with 32 scenarios.
2026-05-12: Strengthened midi-fx-placement after manual App retest feedback. The scenario now checks both the standalone TrackHeader fixture and the actual App TCP with one MIDI track plus one instrument track; both rows must omit Arp/Pit/Vel/Tim, while the FX panel still exposes MIDI FX. Verification passed: node --check tools/midi-editor-acceptance-harness.mjs and node tools/midi-editor-acceptance-harness.mjs --scenario midi-fx-placement --out qa/midi-editor/2026-05-12/header-recheck-app.
2026-05-12: Tightened python build.py dev --run freshness after the same retest feedback. Vite is now launched with --strictPort on 127.0.0.1, so an old server on port 5173 cannot silently satisfy the readiness check while a new Vite process moves to another port. Verification passed: python -m py_compile build.py.
2026-05-12: Completed the final automated QA pass for the current MIDI editor implementation slice before manual acceptance. Verification passed: npx tsc --noEmit, full npx vitest run (28 files / 151 tests), npm run build (passed with existing Vite chunk/dynamic-import warnings only), cmake --build build --config Debug, native headless build/OpenStudio_artefacts/Debug/OpenStudio.exe --automated-regression-headless --report qa/midi-editor/2026-05-12/implementation/native-automated-regression.json with overallPass=true, node --check tools/midi-editor-acceptance-harness.mjs, and full browser/CDP node tools/midi-editor-acceptance-harness.mjs --scenario all --out qa/midi-editor/2026-05-12/implementation with 31 scenarios. Reopened acceptance phases remain open only because midi_editor_reference_matrix.md requires explicit manual REAPER/Cubase acceptance notes before rows become accepted.
2026-05-13: Tightened manual-test handoff rules after stale packaged UI was seen during manual retest. The attempted build.py/MainComponent.cpp dev-server fallback guard was reverted as too broad for this feature work. The standing rule is documented in AGENTS.md and WORKFLOWS.md: before manual testing, complete cmake --build build --config Debug, make sure latest assets are current when packaged fallback could be used, require no pre-running server from the user, and stop any Codex-started Vite/npm/browser harness processes.
2026-05-13: Completed the Piano Roll layout/alignment/source-length control slice requested after manual UI review. The FX panel MIDI FX strip now uses .fx-midi-section spacing aligned with loaded FX cards. The docked Piano Roll left sidebar sits under the TCP at exactly tcpWidth, the editor canvas starts after the same 6px timeline divider, container ResizeObserver updates canvas height when the lower zone grows, sidebar wheel scrolling is isolated from grid scrolling, and horizontal Piano Roll geometry now follows arrange pixelsPerSecond/scrollX in project-time coordinates. Added visible source controls for active clip name, source length, item length, Source = Item, Source = Content, and Loop; source edits use undoable setMIDIClipSourceWindow() and preserve events beyond the shortened source end. Verification passed: npx tsc --noEmit, full npx vitest run (29 files / 156 tests), focused browser scenarios app-docked-piano-focus, piano-visual-viewports, piano-source-header, piano-navigation-tools, midi-fx-placement, full node tools/midi-editor-acceptance-harness.mjs --scenario all --out qa/midi-editor/2026-05-13/piano-layout-source, and cmake --build build --config Debug.
2026-05-12: Completed the remaining Piano Roll inspector component split. Controller lane rows/add controls now live in stateless frontend/src/components/PianoRollControllerLaneSection.tsx, lane selection/CC14/poly-pressure/line/LFO/transform/copy/paste/clear controls live in frontend/src/components/PianoRollLaneEditorSection.tsx, and pitchbend range/snap controls live in frontend/src/components/PianoRollPitchBendSection.tsx; the parent keeps state, command, and undo-bound callbacks. Added frontend/src/__tests__/pianoRollLaneInspectorSections.test.ts using server-side React rendering for lane rows, add controls, lane editor commands, poly-pressure note selection, and pitchbend fields. Verification passed: npx tsc --noEmit, focused npx vitest run src/__tests__/pianoRollLaneInspectorSections.test.ts src/__tests__/pianoRollInspectorSections.test.ts src/__tests__/pianoRollLanes.test.ts, node --check tools/midi-editor-acceptance-harness.mjs, focused browser piano-lane-management, piano-controller-lane, piano-cc-direct, piano-pitchbend-direct, and piano-advanced-lanes, full npx vitest run (28 files / 151 tests), and full node tools/midi-editor-acceptance-harness.mjs --scenario all --out qa/midi-editor/2026-05-12/implementation with 31 scenarios.
2026-05-12: Started the Piano Roll inspector split. The top inspector summary now lives in stateless frontend/src/components/PianoRollInspectorSummary.tsx, and the note-selection editor section now lives in stateless frontend/src/components/PianoRollNoteInspectorSection.tsx, keeping note pitch/start/length/velocity/channel/release/chance/variance/play-count/cent-offset handlers in the parent. Added frontend/src/__tests__/pianoRollInspectorSections.test.ts using server-side React rendering for summary fallbacks, selected-note fields, and the empty-selection hint. Verification passed: npx tsc --noEmit, focused npx vitest run src/__tests__/pianoRollInspectorSections.test.ts src/__tests__/pianoRollInfoLine.test.ts src/__tests__/pianoRollStatusStrip.test.ts, node --check tools/midi-editor-acceptance-harness.mjs, focused browser piano-inspector, piano-visual-viewports, and piano-note-metadata-lanes, full npx vitest run (27 files / 147 tests), and full node tools/midi-editor-acceptance-harness.mjs --scenario all --out qa/midi-editor/2026-05-12/implementation with 31 scenarios.
2026-05-12: Split the Piano Roll editor-pane status strip out of PianoRoll.tsx into stateless frontend/src/components/PianoRollStatusStrip.tsx, covering Tool, Snap, Cursor, Source, and Lane display fields while reusing the tested tool registry for labels. Added frontend/src/__tests__/pianoRollStatusStrip.test.ts using server-side React rendering to assert field values, order, and empty-cursor formatting. Verification passed: npx tsc --noEmit, focused npx vitest run src/__tests__/pianoRollStatusStrip.test.ts src/__tests__/pianoRollInfoLine.test.ts, node --check tools/midi-editor-acceptance-harness.mjs, focused browser piano-visual-viewports, piano-navigation-tools, and piano-basic, full npx vitest run (26 files / 144 tests), and full node tools/midi-editor-acceptance-harness.mjs --scenario all --out qa/midi-editor/2026-05-12/implementation with 31 scenarios.
2026-05-12: Split the visible Piano Roll info/readout row out of PianoRoll.tsx into stateless frontend/src/components/PianoRollInfoLine.tsx, covering Type, Start, Length, Value, Channel, Chance, Lane, and Curve display fields. Added frontend/src/__tests__/pianoRollInfoLine.test.ts using server-side React rendering to assert the field order and aria label. Verification passed: npx tsc --noEmit, focused npx vitest run src/__tests__/pianoRollInfoLine.test.ts src/__tests__/pianoRollTools.test.ts, node --check tools/midi-editor-acceptance-harness.mjs, focused browser piano-visual-viewports, piano-inspector, and piano-basic, full npx vitest run (25 files / 142 tests), and full node tools/midi-editor-acceptance-harness.mjs --scenario all --out qa/midi-editor/2026-05-12/implementation with 31 scenarios.
2026-05-12: Split the visible Piano Roll key strip out of PianoRoll.tsx into stateless frontend/src/components/PianoRollToolbar.tsx, keeping the store subscriptions and DAW editing commands in the parent while the component owns the tool buttons, scale controls, zoom slider, audition/insert velocity controls, step input controls, clip selector, and ghost/reference toggles. Verification passed: npx tsc --noEmit, focused npx vitest run src/__tests__/pianoRollTools.test.ts src/__tests__/pianoRollInteraction.test.ts, node --check tools/midi-editor-acceptance-harness.mjs, focused browser piano-tools, piano-navigation-tools, piano-audition-insert, and piano-basic, full npx vitest run (24 files / 141 tests), and full node tools/midi-editor-acceptance-harness.mjs --scenario all --out qa/midi-editor/2026-05-12/implementation with 31 scenarios.
2026-05-12: Strengthened explicit piano-roll capture targets. handleStageMouseDown() now dispatches controller, controller-node, velocity-lane, grid, note, and loop-boundary starts from the shared hitTestPianoRoll() target instead of falling back to raw y/x checks; range selection now explicitly starts from grid, note, or loop-boundary targets. The first full browser pass caught a piano-range regression at the source loop boundary, which was fixed and rerun. Verification passed: npx tsc --noEmit, focused npx vitest run src/__tests__/pianoRollInteraction.test.ts, focused browser piano-range, piano-tools, piano-navigation-tools, piano-cc-direct, and piano-note-metadata-lanes, full npx vitest run (24 files / 141 tests), node --check tools/midi-editor-acceptance-harness.mjs, and full node tools/midi-editor-acceptance-harness.mjs --scenario all --out qa/midi-editor/2026-05-12/implementation with 31 scenarios.
2026-05-12: Extracted piano-roll tool-strip definitions from PianoRoll.tsx into frontend/src/utils/pianoRollTools.ts, keeping tool order, labels, shortcuts, and icon components in a tested registry. Added pianoRollTools.test.ts. Verification passed: npx tsc --noEmit, focused npx vitest run src/__tests__/pianoRollTools.test.ts src/__tests__/pianoRollVelocity.test.ts src/__tests__/pianoRollInteraction.test.ts, focused browser piano-basic, piano-tools, and piano-navigation-tools, full npx vitest run (24 files / 141 tests), node --check tools/midi-editor-acceptance-harness.mjs, and full node tools/midi-editor-acceptance-harness.mjs --scenario all --out qa/midi-editor/2026-05-12/implementation with 31 scenarios.
2026-05-12: Extracted piano-roll velocity color helpers from PianoRoll.tsx into frontend/src/utils/pianoRollVelocity.ts, covering the note fill heat gradient and thresholded note outline colors. Added pianoRollVelocity.test.ts. Verification passed: npx tsc --noEmit, focused npx vitest run src/__tests__/pianoRollVelocity.test.ts src/__tests__/pianoRollPitch.test.ts src/__tests__/pianoRollLanes.test.ts, focused browser piano-basic, focused browser piano-tools and piano-velocity-line after rerunning solo to avoid CDP contention, full npx vitest run (23 files / 139 tests), node --check tools/midi-editor-acceptance-harness.mjs, and full node tools/midi-editor-acceptance-harness.mjs --scenario all --out qa/midi-editor/2026-05-12/implementation with 31 scenarios.
2026-05-12: Extracted piano-roll lane sentinel and mapping helpers from PianoRoll.tsx into frontend/src/utils/pianoRollLanes.ts, including special negative lane IDs, CC presets, scalar MIDI event lane mapping/naming, and note-metadata lane mapping. Added pianoRollLanes.test.ts. Verification passed: npx tsc --noEmit, focused npx vitest run src/__tests__/pianoRollLanes.test.ts src/__tests__/pianoRollPitch.test.ts, focused browser piano-advanced-lanes, focused browser piano-note-metadata-lanes (after rerunning solo to avoid CDP contention), full npx vitest run (22 files / 137 tests), node --check tools/midi-editor-acceptance-harness.mjs, and full node tools/midi-editor-acceptance-harness.mjs --scenario all --out qa/midi-editor/2026-05-12/implementation with 31 scenarios.
2026-05-12: Extracted piano-roll pitch and scale helpers from PianoRoll.tsx into frontend/src/utils/pianoRollPitch.ts, including note names, scale display names, MIDI pitch label formatting, and scale-guide membership. Added pianoRollPitch.test.ts. Verification passed: npx tsc --noEmit, focused npx vitest run src/__tests__/pianoRollPitch.test.ts src/__tests__/midiNotes.test.ts, focused browser piano-basic, focused browser piano-visual-viewports (after rerunning solo to avoid CDP contention), full npx vitest run (21 files / 134 tests), node --check tools/midi-editor-acceptance-harness.mjs, and full node tools/midi-editor-acceptance-harness.mjs --scenario all --out qa/midi-editor/2026-05-12/implementation with 31 scenarios.
2026-05-12: Continued the piano-roll architecture extraction. PianoRoll.tsx now reuses frontend/src/utils/midiNotes.ts for note IDs, event sorting, note-pair parsing, and selected-note drag rebuilds with audition-pair output instead of keeping duplicated note-model logic locally. Focused utility coverage now asserts rebuilt audition-pair identity. Verification passed: npx tsc --noEmit, focused npx vitest run src/__tests__/midiNotes.test.ts src/__tests__/pianoRollInteraction.test.ts, focused browser piano-basic, focused browser piano-tools, full npx vitest run (20 files / 132 tests), node --check tools/midi-editor-acceptance-harness.mjs, and full node tools/midi-editor-acceptance-harness.mjs --scenario all --out qa/midi-editor/2026-05-12/implementation with 31 scenarios.
2026-05-12: Began the next piano-roll architecture extraction. Note-metadata lane helpers for value display, lane metadata, and note event mutation moved from PianoRoll.tsx into frontend/src/utils/midiNotes.ts, with focused utility coverage added in midiNotes.test.ts. Verification passed: npx tsc --noEmit, focused npx vitest run src/__tests__/midiNotes.test.ts, full npx vitest run (20 files / 132 tests), focused piano-note-metadata-lanes, focused piano-controller-lane, node --check tools/midi-editor-acceptance-harness.mjs, and full node tools/midi-editor-acceptance-harness.mjs --scenario all --out qa/midi-editor/2026-05-12/implementation with 31 scenarios.
2026-05-12: Strengthened piano inspector history acceptance. piano-inspector now verifies the full single-note inspector sequence for pitch, start, length, velocity, channel, note-off velocity, chance, velocity variance, play count, and cent offset can be undone back to the original MIDI note state and redone back to the edited state exactly before the mixed multi-note batch-velocity undo/redo check. Verification passed: node --check tools/midi-editor-acceptance-harness.mjs, focused piano-inspector, npx tsc --noEmit, full npx vitest run (20 files / 131 tests), and full node tools/midi-editor-acceptance-harness.mjs --scenario all --out qa/midi-editor/2026-05-12/implementation with 31 scenarios.
2026-05-12: Strengthened controller-lane workflow history acceptance. piano-controller-lane now verifies curve generation, value/time transform, stretch transform, thinning, cross-lane paste, clear, same-lane paste, and sine LFO generation each undo to the prior CC state and redo to the edited state. Verification passed: node --check tools/midi-editor-acceptance-harness.mjs, npx tsc --noEmit, full npx vitest run (20 files / 131 tests), focused piano-controller-lane, and full node tools/midi-editor-acceptance-harness.mjs --scenario all --out qa/midi-editor/2026-05-12/implementation with 31 scenarios.
2026-05-12: Strengthened timeline ghost-track drop acceptance. timeline-drop-targets now verifies dragging a MIDI item into the ghost lane creates a new MIDI track and moves the item, undo removes the ghost track and restores the clip to the source track, and redo recreates the compatible MIDI target and move. Verification passed: node --check tools/midi-editor-acceptance-harness.mjs, npx tsc --noEmit, full npx vitest run (20 files / 131 tests), focused timeline-drop-targets, and full node tools/midi-editor-acceptance-harness.mjs --scenario all --out qa/midi-editor/2026-05-12/implementation with 31 scenarios.
2026-05-12: Strengthened advanced lane generated-event history acceptance. piano-advanced-lanes now verifies pitchbend line, 14-bit CC line, program line, bank MSB/LSB lines, channel pressure line, and poly pressure line each undo to the prior generated-event state and redo to the generated state before backend-bound serialization is checked. Verification passed: node --check tools/midi-editor-acceptance-harness.mjs, npx tsc --noEmit, full npx vitest run (20 files / 131 tests), focused piano-advanced-lanes, and full node tools/midi-editor-acceptance-harness.mjs --scenario all --out qa/midi-editor/2026-05-12/implementation with 31 scenarios.
2026-05-12: Strengthened note metadata lane undo/redo acceptance. piano-note-metadata-lanes now verifies note-off velocity, chance/probability, and velocity-variance direct lane drags each undo and redo exactly across their MIDI metadata fields. Verification passed: node --check tools/midi-editor-acceptance-harness.mjs, npx tsc --noEmit, full npx vitest run (20 files / 131 tests), focused piano-note-metadata-lanes, and full node tools/midi-editor-acceptance-harness.mjs --scenario all --out qa/midi-editor/2026-05-12/implementation with 31 scenarios.
2026-05-12: Strengthened direct controller lane redo acceptance. piano-cc-direct now verifies CC#1 and arbitrary CC#74 direct pointer draws undo exactly and redo exactly while preserving backend-bound serialization, and piano-pitchbend-direct now verifies direct snapped pitchbend drawing redoes exactly after undo. Verification passed: node --check tools/midi-editor-acceptance-harness.mjs, npx tsc --noEmit, full npx vitest run (20 files / 131 tests), focused piano-cc-direct and piano-pitchbend-direct, and full node tools/midi-editor-acceptance-harness.mjs --scenario all --out qa/midi-editor/2026-05-12/implementation with 31 scenarios.
2026-05-12: Strengthened Piano Roll lane-management pitchbend range history acceptance. piano-lane-management now verifies linked toggle undo/redo, linked range edit undo/redo, unlinked toggle undo/redo, and unlinked down-range edit undo/redo around the pitchbend range controls. Verification passed: node --check tools/midi-editor-acceptance-harness.mjs, npx tsc --noEmit, full npx vitest run (20 files / 131 tests), focused piano-lane-management, and full node tools/midi-editor-acceptance-harness.mjs --scenario all --out qa/midi-editor/2026-05-12/implementation with 31 scenarios.
2026-05-12: Strengthened Piano Roll insert/audition history acceptance. piano-audition-insert now verifies insert-velocity note drawing with audition enabled undo/redoes the inserted note, and drawing while audition is disabled undo/redoes the inserted note without emitting preview calls. Verification passed: node --check tools/midi-editor-acceptance-harness.mjs, npx tsc --noEmit, full npx vitest run (20 files / 131 tests), focused piano-audition-insert, and full node tools/midi-editor-acceptance-harness.mjs --scenario all --out qa/midi-editor/2026-05-12/implementation with 31 scenarios.
2026-05-12: Strengthened active/reference multi-item Piano Roll history acceptance. piano-multi-item now verifies undo/redo of the first active clip drag restores/reapplies only that clip while preserving the reference item, then verifies undo/redo of the switched active reference clip drag preserves the previously edited clip. Verification passed: node --check tools/midi-editor-acceptance-harness.mjs, npx tsc --noEmit, full npx vitest run (20 files / 131 tests), focused piano-multi-item, and full node tools/midi-editor-acceptance-harness.mjs --scenario all --out qa/midi-editor/2026-05-12/implementation with 31 scenarios.
2026-05-12: Strengthened Piano Roll tool history acceptance. piano-tools now verifies draw, erase, note resize, split, glue, mute, and velocity-lane edits each undo back to the previous note-pair state and redo to the edited state inside one live browser session. Verification passed: node --check tools/midi-editor-acceptance-harness.mjs, npx tsc --noEmit, full npx vitest run (20 files / 131 tests), focused piano-tools, and full node tools/midi-editor-acceptance-harness.mjs --scenario all --out qa/midi-editor/2026-05-12/implementation with 31 scenarios.
2026-05-12: Strengthened Piano Roll basic note-drag history acceptance. piano-basic now verifies a real note drag changes the selected note start, undo restores the original note start/duration, and redo reapplies the moved start while preserving duration. Verification passed: node --check tools/midi-editor-acceptance-harness.mjs, npx tsc --noEmit, full npx vitest run (20 files / 131 tests), focused piano-basic, and full node tools/midi-editor-acceptance-harness.mjs --scenario all --out qa/midi-editor/2026-05-12/implementation with 31 scenarios.
2026-05-12: Strengthened MIDI FX history acceptance. midi-fx-controls now verifies prompt-free pitch, velocity, and time/groove edits undo and redo the midiEffects list exactly before rechecking backend-bound resolved MIDI serialization. Verification passed: node --check tools/midi-editor-acceptance-harness.mjs, npx tsc --noEmit, full npx vitest run (20 files / 131 tests), focused midi-fx-controls, and full node tools/midi-editor-acceptance-harness.mjs --scenario all --out qa/midi-editor/2026-05-12/implementation with 31 scenarios.
2026-05-12: Strengthened basic timeline move/resize history acceptance. timeline-basic now verifies body-drag undo/redo restores/reapplies MIDI item start/duration and right-edge resize undo/redo restores/reapplies the loop extension. Verification passed: node --check tools/midi-editor-acceptance-harness.mjs, npx tsc --noEmit, full npx vitest run (20 files / 131 tests), focused timeline-basic, and full node tools/midi-editor-acceptance-harness.mjs --scenario all --out qa/midi-editor/2026-05-12/implementation with 31 scenarios.
2026-05-12: Strengthened keyboard and source-context history acceptance. timeline-keyboard-actions now verifies Ctrl+D duplicate undo/redo and Delete undo/redo through real key events, while timeline-source-context verifies reset source offset, source length=item/content, and custom source length undo/redo. Verification passed: node --check tools/midi-editor-acceptance-harness.mjs, npx tsc --noEmit, full npx vitest run (20 files / 131 tests), focused timeline-keyboard-actions and timeline-source-context, and full node tools/midi-editor-acceptance-harness.mjs --scenario all --out qa/midi-editor/2026-05-12/implementation with 31 scenarios.
2026-05-12: Strengthened timeline action history acceptance. timeline-actions now verifies mute-tool undo/redo, context lock undo/redo while still proving locked MIDI items cannot move, and prompt-free repeat-dialog undo/redo. Verification passed: node --check tools/midi-editor-acceptance-harness.mjs, npx tsc --noEmit, full npx vitest run (20 files / 131 tests), focused timeline-actions, and full node tools/midi-editor-acceptance-harness.mjs --scenario all --out qa/midi-editor/2026-05-12/implementation with 31 scenarios.
2026-05-12: Strengthened split and context-action timeline history acceptance. timeline-arrange now verifies same-track copy-drag undo/redo, split-tool undo/redo, context duplicate undo/redo, and context delete undo/redo through real browser gestures and context menus. Verification passed: node --check tools/midi-editor-acceptance-harness.mjs, npx tsc --noEmit, full npx vitest run (20 files / 131 tests), focused timeline-arrange, and full node tools/midi-editor-acceptance-harness.mjs --scenario all --out qa/midi-editor/2026-05-12/implementation with 31 scenarios.
2026-05-12: Strengthened Alt-slip source-window timeline acceptance. timeline-arrange now verifies Alt-drag changes only MIDI source offset, backend sync payload matches serializeMIDIClipsForBackend, serialized events stay inside the visible item window, slipped note content starts at item time 0, and undo/redo restores/reapplies the slip. Verification passed: node --check tools/midi-editor-acceptance-harness.mjs, npx tsc --noEmit, full npx vitest run (20 files / 131 tests), focused timeline-arrange, and full node tools/midi-editor-acceptance-harness.mjs --scenario all --out qa/midi-editor/2026-05-12/implementation with 31 scenarios.
2026-05-12: Strengthened left-trim/source-slip timeline acceptance. timeline-arrange now verifies left-edge trim source-slips the MIDI item, backend sync payload matches serializeMIDIClipsForBackend, serialized events stay inside the visible item window, slipped note/pitchbend content starts at item time 0, loop-resolved content remains after the slipped window, and undo/redo restores/reapplies the trim. Verification passed: node --check tools/midi-editor-acceptance-harness.mjs, npx tsc --noEmit, full npx vitest run (20 files / 131 tests), focused timeline-arrange, and full node tools/midi-editor-acceptance-harness.mjs --scenario all --out qa/midi-editor/2026-05-12/implementation with 31 scenarios.
2026-05-12: Strengthened REAPER-style timeline cross-track acceptance. timeline-cross-track now verifies compatible MIDI-to-instrument move undo/redo and compatible Control-drag copy to an instrument track, including original item preservation, undo removing only the copied item, and redo restoring it. Verification passed: node --check tools/midi-editor-acceptance-harness.mjs, npx tsc --noEmit, full npx vitest run (20 files / 131 tests), focused timeline-cross-track, and full node tools/midi-editor-acceptance-harness.mjs --scenario all --out qa/midi-editor/2026-05-12/implementation with 31 scenarios.
2026-05-12: Completed program/bank automated proof for bank select. piano-advanced-lanes now drives the visible Lane Editor to generate CC#0 Bank MSB and CC#32 Bank LSB lines with screenshots and verifies backend-bound serialization; midi-project-persistence verifies bank select survives save/reload and backend sync; midi-export-payload verifies export payload parity for bank select; native midi_pitchbend_chase_fixture and midi_export_fixture now assert bank MSB/LSB chase/export in qa/midi-editor/2026-05-12/implementation/native-automated-regression.json. Verification passed: node --check tools/midi-editor-acceptance-harness.mjs, npx tsc --noEmit, full npx vitest run (20 files / 131 tests), C++ Debug build, native headless regression, focused browser scenarios, and full node tools/midi-editor-acceptance-harness.mjs --scenario all --out qa/midi-editor/2026-05-12/implementation with 31 scenarios.
2026-05-12: Completed Piano Roll navigation-tool browser coverage and fixed pan tool behavior. Pan now uses a ref-backed drag session so immediate Konva pointer moves scroll the editor reliably; piano-navigation-tools verifies zoom, pan, and controller line-dialog activation through real pointer input against a long editable source window. Verification passed: npx tsc --noEmit, full npx vitest run (20 files / 131 tests), focused piano-navigation-tools, and full node tools/midi-editor-acceptance-harness.mjs --scenario all --out qa/midi-editor/2026-05-12/implementation.
2026-05-12: Moved Piano Roll from a blocking modal into a resizable docked lower zone and added arrange-click active item retargeting while preserving selected MIDI item groups. Added app-docked-piano-focus browser/CDP QA, which seeds the real App shell with two selected MIDI items, verifies the docked editor is below a clickable timeline, clicks selected arrange clips in both directions, and asserts the active Piano Roll clip changes without clearing selection. Verification passed: npx tsc --noEmit, full npx vitest run (20 files / 131 tests), focused app-docked-piano-focus, and full node tools/midi-editor-acceptance-harness.mjs --scenario all --out qa/midi-editor/2026-05-12/implementation.
2026-05-12: Added compact Piano Roll insert velocity and audition controls. Draw, step input, and context-menu insertion now use the configured insert velocity, and the audition toggle stops/suppresses preview MIDI calls when disabled. Added piano-audition-insert browser/CDP QA, which patches nativeBridge.sendMidiNote, sets velocity through the visible input, draws notes with audition enabled/disabled, verifies balanced note-on/note-off calls and disabled-preview suppression, and captures screenshots. Verification passed: npx tsc --noEmit, full npx vitest run (20 files / 131 tests), focused piano-audition-insert, and full node tools/midi-editor-acceptance-harness.mjs --scenario all --out qa/midi-editor/2026-05-12/implementation.
2026-05-11: Fixed and covered MIDI export paths. Project MIDI export now uses serializeMIDIClipsForBackend() so source windows, MIDI FX, probability/variance decisions, CC lanes, pitchbend, program, pressure, channels, and release velocity are included in export payloads. The native WebView exportMIDIFile bridge now accepts the frontend's two-argument clip-export shape as well as the older five-argument backend helper. Added native exportProjectMIDI() and midi_export_fixture, which writes and re-reads a .mid file and verifies note/noteOff, CC1/CC33, pitchbend, program change, channel pressure, and poly pressure. Added midi-export-payload browser QA to verify frontend export payload parity. Verification passed: C++ Debug build, native headless suite exit code 0, focused midi-export-payload, and full browser harness.
2026-05-11: Strengthened midi-fx-controls browser QA into a backend-bound render-input test. The scenario now seeds a MIDI clip, drives the visible pitch/velocity/time MIDI FX dialogs, intercepts nativeBridge.setTrackMIDIClips, and verifies the payload matches serializeMIDIClipsForBackend() with pitch-shifted notes, velocity scaling/offset, time/swing offsets on notes and CC, probability-0 note filtering, and deterministic velocity variance across repeated serialization. Focused verification passed: node --check tools/midi-editor-acceptance-harness.mjs and node tools/midi-editor-acceptance-harness.mjs --scenario midi-fx-controls --out qa/midi-editor/2026-05-11/implementation.
2026-05-11: Added a native headless automated regression entry point: OpenStudio.exe --automated-regression-headless --report .... The C++ suite now runs without opening the app window and writes qa/midi-editor/2026-05-11/implementation/native-automated-regression.json. New/strengthened coverage includes exact pitchbend/program/CC/channel-pressure/active-note chase at sample zero, render/freeze with non-centered pitchbend through the fallback instrument path, saved MIDI playback with pitchbend, and add-track first-callback spike detection. This also fixed a real render bug where fallback instrument tracks were incorrectly sent through the simple audio-clip render loop, plus a first-callback spike risk from uncleared newly allocated send/sidechain buffers. Verification passed: C++ Debug build and native headless suite exit code 0.
2026-05-11: Added midi-project-persistence browser QA. The scenario patches the NativeBridge file/project methods in-page, saves a real project JSON through saveProject(true), reloads it through loadProject(), and verifies MIDI FX, sampler/SoundFont, instrument state, source-window metadata, pitchbend ranges, note probability/play-count/variance/cent metadata, note-off release velocity, pitchbend, program/channel pressure/poly pressure, CC14, CC74 parabola interpolation, and load-time backend sync repair payloads survive. Verification passed: npx tsc --noEmit, full npx vitest run, and full node tools/midi-editor-acceptance-harness.mjs --scenario all --out qa/midi-editor/2026-05-11/implementation.
2026-05-11: Added piano-cc-direct browser QA. The scenario draws directly in the visible CC#1 lane, switches the same lane to arbitrary CC#74 and draws again, verifies both drawn controller sets are emitted into serializeMIDIClipsForBackend(), captures before/after screenshots, and verifies undo restores the original controller event lists exactly. Verification passed: npx tsc --noEmit, full npx vitest run, and full node tools/midi-editor-acceptance-harness.mjs --scenario all --out qa/midi-editor/2026-05-11/implementation.
2026-05-11: Added explicit Parabola controller-line mode and piano-controller-shapes browser QA. The scenario audits window.prompt call count, generates CC#1 ramp, step, and parabola lines through visible dialogs, captures screenshots, and verifies undo/redo restores and reapplies each generated shape exactly. Verification passed: npx tsc --noEmit, full npx vitest run, and full node tools/midi-editor-acceptance-harness.mjs --scenario all --out qa/midi-editor/2026-05-11/implementation.
2026-05-11: Expanded inspector/controller E2E coverage. piano-inspector now verifies visible pitch/start/length edits, metadata edits, mixed multi-note inspector state, batch velocity, and undo/redo; new piano-velocity-line verifies velocity-lane ramp generation and undo/redo; piano-controller-lane now verifies controller compression/stretch transforms plus cross-lane paste with undo/redo. Verification passed: npx tsc --noEmit, full npx vitest run, and full browser/CDP --scenario all with 28 passing scenarios.
2026-05-11: Added piano-pitchbend-direct browser QA. The scenario enables pitchbend semitone snap, draws directly in the visible pitchbend lane with real pointer events, verifies snapped +7 semitone bend events are emitted into serializeMIDIClipsForBackend(), captures before/after screenshots, and verifies undo restores the original pitchbend event list exactly. Verification passed: npx tsc --noEmit, full npx vitest run, and full node tools/midi-editor-acceptance-harness.mjs --scenario all --out qa/midi-editor/2026-05-11/implementation.
2026-05-11: Added direct note metadata controller lanes for note-off velocity, chance/probability, and velocity variance. PianoRoll now maps those lane rows to editable note-aligned bars, prevents stale controller-drag sessions from mutating data after mouse release, adds prompt-free lane add buttons, and commits each pointer drag through one undoable MIDI event command. Added piano-note-metadata-lanes browser/CDP QA with screenshots; it verifies note-off velocity 42->118, chance 92%->10%, velocity variance 7->114, and undo restoring variance to 7 exactly. Verification passed: npx tsc --noEmit, full npx vitest run, and full node tools/midi-editor-acceptance-harness.mjs --scenario all --out qa/midi-editor/2026-05-11/implementation.
2026-05-11: Added piano-visual-viewports browser QA. The harness captures the piano-roll shell at 1440x900, 1280x720, 1024x720, and 1024x560 short-zone sizes, and asserts the key strip, info line, editor pane, inspector, lane stack, and lane rows are present without page overflow or editor/inspector overlap. Latest --scenario all and full npx vitest run pass.
2026-05-11: Added piano-advanced-lanes browser QA. The scenario drives the visible controller-lane inspector to generate pitchbend line events, 14-bit CC#1/33 MSB/LSB pairs, program change events, channel pressure events, and note-specific poly pressure events, then verifies serializeMIDIClipsForBackend() emits those backend-bound event types. Latest --scenario all, npx tsc --noEmit, and full npx vitest run pass. Native chase/render/export sanity is now covered by the headless C++ suite; manual Cubase acceptance remains open for these lanes.
2026-05-11: Added native midi_combined_project_render_fixture to the headless C++ regression suite. The fixture parses a combined instrument/external-MIDI project payload, verifies program, CC14, pitchbend, channel pressure, poly pressure, note-on, and release-velocity note-off events in the scheduler, then renders a real WAV and asserts the output is readable, finite, and non-silent. Verification passed: cmake --build build --config Debug and OpenStudio.exe --automated-regression-headless --report qa/midi-editor/2026-05-11/implementation/native-automated-regression.json.
2026-05-11: Replaced MIDIFXControls pitch/velocity/time window.prompt flows with a compact numeric dialog and added midi-fx-controls browser QA. The scenario edits pitch semitones, velocity scale/offset, and time swing/offset through the visible controls, then verifies track.midiEffects state and undo availability. Latest --scenario all, npx tsc --noEmit, and full npx vitest run pass.
2026-05-11: Added piano-multi-item browser QA and made the standalone PianoRoll harness follow the store's active MIDI clip instead of a fixed prop. The scenario renders an active clip plus one reference clip, drags the active note while proving the reference note is unchanged, clicks a reference note to switch the active editable item, then drags the newly active note while proving the original item is unchanged. Latest --scenario all pass includes active/reference multi-item screenshots.
2026-05-11: Replaced the timeline Repeat Clip... context-menu window.prompt with an in-app numeric dialog and expanded timeline-actions browser QA to repeat a MIDI item twice through that dialog. The focused scenario and latest full --scenario all browser/CDP run passed; Timeline.tsx and PianoRoll.tsx now have no window.prompt/prompt() usages.
2026-05-11: Added timeline-backend-payload browser QA. The harness now performs a real right-edge loop resize, forces syncMIDITrackToBackend, captures the exact bridge payload, and asserts it matches serializeMIDIClipsForBackend while preserving visible-window bounds, loop-resolved events, event channels, note-off release velocity, pitchbend, CC, probability, velocity variance, and play-count metadata. Latest --scenario all pass includes this backend-payload proof; remaining timeline gate is backend playback/manual REAPER acceptance.
2026-05-11: Added app-shortcuts browser QA and registered Ctrl+Y as a redo alias. The harness now uses the real app shell/global shortcut dispatcher, creates an undoable MIDI source-length edit, sends real Ctrl+Z and Ctrl+Y key events, and verifies source/loop length undo/redo state transitions with screenshots.
2026-05-11: Replaced the MIDI Set Source Length... context-menu window.prompt with an in-app numeric dialog and expanded timeline-source-context browser QA to apply a custom 3.25s source length through that dialog. The action now has CDP proof for source/loop length updates and undo availability without a prompt-based workflow.
2026-05-11: Expanded timeline-source-context browser QA to cover Source Length = Content. The context-menu action now has CDP proof that a MIDI item with a longer source window can set sourceLength and loopLength to the actual MIDI event content end while preserving undo availability.
2026-05-11: Added timeline-keyboard-actions browser QA. The harness now sends actual key events into the timeline and verifies Ctrl+D duplicates the selected MIDI item, Delete removes the selected item, screenshots are captured, and undo availability is updated. Global Ctrl+Z/Ctrl+Y WebView routing remains open because the standalone Timeline harness does not include the app-level shortcut dispatcher.
2026-05-11: Added timeline-drop-targets browser QA and repaired ghost-track hit detection. Timeline drag hit testing now treats pointer positions below the arranged track content as the ghost-track drop zone instead of clamping to the last real track. Browser/CDP QA verifies MIDI drops onto audio tracks stay on the original MIDI track, and dragging below the track list creates a new MIDI track and moves the item there with undo available.
2026-05-11: Added timeline-selection browser QA and fixed a real Ctrl-click regression. Ctrl-click on a MIDI item was entering copy-on-drag mode and could duplicate or clear selection even without movement; finalizeTimelineClipGesture now ignores copy gestures below a 4px movement threshold, and MIDI clip mousedown defers selection while copy-on-drag is pending so the click handler can perform Ctrl multi-select. timeline-selection now verifies single select and Ctrl multi-select screenshots.
2026-05-11: Added piano-lane-management browser QA. The harness now verifies hiding a visible CC#1 lane does not delete CC data, adding a 14-bit CC#1/33 lane makes it active, lane height/interpolation controls persist in editor state, and linked/unlinked pitchbend range inspector controls update track state through undoable store actions. Phase 7 remains reopened for manual Cubase acceptance.
2026-05-11: Added piano-controller-lane browser QA. The harness now opens the real PianoRoll inspector, selects the CC#1 lane, generates a curve, applies a visible transform, thins dense controller data, copies/clears/pastes the lane, and generates a sine LFO without prompt dialogs. Scenario screenshots are saved under qa/midi-editor/2026-05-11/implementation/. Phase 7 remains reopened for manual Cubase acceptance.
2026-05-11: Marked Phase A0, A1, and A2 complete. Expanded tools/midi-editor-acceptance-harness.mjs with timeline-snap-undo and timeline-source-context; latest --scenario all pass verifies snap move, undo, redo, reset source offset, and source-length-to-item in addition to the prior timeline/piano-roll coverage. Added completed acceptance evidence checkboxes while keeping reopened Phase 4, 5, 7, and 9 open until the remaining matrix rows have browser, backend, screenshot, and manual acceptance proof.
2026-05-11: Expanded tools/midi-editor-acceptance-harness.mjs with piano-tools; latest --scenario all pass verifies piano-roll draw, erase, note resize, split, glue, mute, and velocity-lane editing with screenshots. Phase 5 remains reopened because range selection, line/curve tools, active/ghost multi-item editing, visual polish, persistence, render/freeze, and manual Cubase acceptance remain open.
2026-05-11: Fixed piano-roll split/glue correctness. The split tool now removes the original note by matching note/channel/timestamps instead of relying on object identity, and the glue tool now merges selected same-pitch/channel fragments into one undoable note instead of acting as plain legato. Updated piano-tools browser QA to assert split leaves no original long note and glue restores one merged note. Verification passed: npx tsc --noEmit, full npx vitest run, and node tools/midi-editor-acceptance-harness.mjs --scenario all --out qa/midi-editor/2026-05-11/implementation.
2026-05-11: Added piano-range browser QA to verify range-selection creates a MIDI edit range and selects notes through real pointer drag. Latest --scenario all browser/CDP harness pass includes piano-range; Phase 5 remains open for line/curve tools, multi-lane controller workflows, active/ghost multi-item editing, visual polish, persistence, render/freeze, and manual Cubase acceptance.
2026-05-11: Expanded reusable browser/CDP MIDI acceptance harness at tools/midi-editor-acceptance-harness.mjs. Current --scenario all coverage seeds standalone Timeline and PianoRoll fixtures through the live Vite app, performs real pointer/menu/input gestures, captures before/after screenshots, and asserts state deltas plus undo availability for MIDI item move, snap move, compatible cross-track move to an instrument track, right-edge resize, left trim/source slip, Alt-slip, copy-drag, split, context duplicate/delete, mute-tool click, context lock, locked-item move suppression, source-offset reset, source-length-to-item, piano-roll note drag, and inspector edits for velocity, channel, note-off velocity, chance, velocity variance, play count, and cent offset. Latest run passed and wrote qa/midi-editor/2026-05-11/implementation/midi-editor-acceptance-report.json. Remaining matrix gaps include select/multi-select screenshots, incompatible/ghost-track moves, source-length-content/custom source-length UI, lane transforms, persistence, render/freeze, and manual acceptance coverage.
2026-05-11: Added the 100% Acceptance-Matrix Completion Plan. "100%" is now defined as every documented Studio13 acceptance-matrix row passing with automated, browser/WebView, screenshot, and manual acceptance evidence; it is not literal cloning of every REAPER/Cubase/openDAW feature. Reopened phases remain open until the matrix rows in their area pass.
2026-05-11: DAW-level recovery implementation checkpoint. Added shared timeline gesture math in frontend/src/utils/timelineClipGestures.ts, routed audio and MIDI arrange item drag/resize through the same finalizer, removed dead legacy drag-end blocks, and added browser/CDP pointer QA showing a MIDI item move changed start time from 1.000s to 1.545s with undo available and right-edge resize extended a looped item from 2.000s to 2.727s with undo available. Added piano-roll hit geometry for lane headers, lane resize handles, controller nodes, and loop boundaries; added lane-resize handling, per-lane interpolation controls, loop-boundary rendering, and browser/CDP note-drag QA showing a note start moved from 0.000s to 0.375s with undo available. Captured implementation screenshots in qa/midi-editor/2026-05-11/implementation/. Verification passed: npx tsc --noEmit, full npx vitest run (131 tests), and cmake --build build --config Debug.
2026-05-11: Recovery initiated. Prior completion claims for timeline editing, piano roll, controller lanes, and final QA are superseded by user acceptance feedback. Added requirement for midi_editor_reference_matrix.md and browser/WebView interaction QA before reopened phases can be marked done again.
2026-05-11: Recovery implementation slice started. Added midi_editor_reference_matrix.md; repaired timeline drag-state handling so global mouseup no longer cancels Konva clip gesture commits; added gesture snapshots so timeline clip moves can be committed as one undoable command; added clearer MIDI item handles/selected affordances/source-slip readout; moved controller line/LFO/thin/transform workflows to modal-driven input instead of the primary prompt workflow; refreshed piano-roll toolbar/dialog styling. Frontend npx tsc --noEmit and full npx vitest run passed. Reopened phases remain open until browser/WebView pointer QA and manual REAPER/Cubase acceptance pass.
2026-05-10: Phase 0 done. Plan file created and execution started with Phase 2 reliability work before larger editor rebuild.
2026-05-10: Phase 2 in progress. Added initial backend track type creation, project save/load MIDI routing resync, instrument state round-trip, pitchbend value serialization, looped MIDI clip backend expansion, quantize-with-related-controller movement, MIDI note/CC/pitchbend/program chase after seeks/schedule changes, all-notes-off on MIDI type/schedule changes, piano-roll pitchbend lane drawing, and focused MIDI regressions. Phase 2 remains open until the full signal-path and crack harness are complete.
2026-05-10: Phase 3 in progress. Added MIDI source-loop length inference/migration, timeline resize preservation of original MIDI source length, loop-notch rendering on expanded MIDI items, and piano-roll editing against the source loop length rather than the visible repeated item.
2026-05-10: Phase 2 in progress. Added user-facing MIDI Panic command/menu item/shortcut and expanded panic output to include sustain-off, all-sound-off, reset-controllers, all-notes-off, and pitchbend center per channel.
2026-05-10: Phase 3/5 in progress. Added explicit MIDI source metadata (sourceLength, sourceStart, loopEnabled, loopOffset) for new/recorded/step MIDI clips, made piano-roll note/CC/pitchbend edits extend source length instead of clipping at the old item edge, kept looped visible item duration stable when source length grows, and added undo regressions for source-length extension.
2026-05-10: Phase 4 in progress. Changed timeline audio/MIDI resize drags to preview live and commit through one undoable resize action on drag end, matching REAPER-style single gesture undo behavior.
2026-05-10: Phase 2 in progress. Expanded native MIDI diagnostics with scheduler totals, per-track MIDI routing/type/instrument fields, MIDI device lists, and a project-load verification pass that repairs any frontend/backend MIDI clip-event schedule mismatch after loading saved projects.
2026-05-10: Phase 6 in progress. Expanded piano-roll quantize toward Cubase behavior with starts, ends, starts+ends, length/fixed-length, strength, swing, randomize, and move-controllers options; added regressions for related controller movement, end quantize, and fixed-length quantize.
2026-05-10: Phase 1 in progress. Added a native automated MIDI scheduler fixture inside runAutomatedRegressionSuite() that creates a temporary MIDI track, schedules note/CC/pitchbend data, processes a silent block, asserts scheduled/built event counts, checks finite samples, and verifies no audio spike from a plain MIDI track.
2026-05-10: Phase 7 in progress. Added shared controller-lane helpers for 14-bit pitchbend semitone conversion/snap plus generated line/LFO events, added pitchbend range and semitone snap controls in the piano roll, rendered pitchbend semitone grid lines, and added controller line/sine/triangle LFO generation through the transform menu with undoable commits.
2026-05-10: Phase 7 in progress. Added controller-data thinning/reduction for CC and pitchbend lanes, including cents-based pitchbend tolerance, undoable commits, and regression coverage for preserving endpoints and important bends.
2026-05-10: Phase 8 in progress. Added a quiet built-in fallback synth for instrument tracks with no restored instrument plugin, surfaced fallbackInstrumentActive in MIDI/audio diagnostics, and added a native regression fixture that verifies an instrument track can render finite nonzero audio from scheduled MIDI without a plugin.
2026-05-10: Phase 8 in progress. Exposed the fallback synth in the track header, channel strip, and FX chain UI as Studio13 Basic Synth so instrument tracks no longer look empty/silent when they are using the built-in fallback source.
2026-05-10: Phase 6 in progress. Added MIDI input quantize preferences (enable, grid, strength) and applied them to completed recorded MIDI clips with note-duration preservation and related controller/pitchbend movement.
2026-05-10: Phase 7 in progress. Added arbitrary CC lane selection plus 14-bit CC MSB/LSB mode for CC0-31, including combined 14-bit display, draw/upsert, line/LFO generation, thinning, and split/combine regression coverage.
2026-05-10: Phase 2/8 in progress. Added compact per-track MIDI output selection beside MIDI input/channel selection and narrowed the MIDI device selector store subscription to avoid full-store re-renders.
2026-05-10: Verification checkpoint. cmake --build build --config Debug passed; npx tsc --noEmit passed; focused Vitest MIDI/timeline suite passed (midiControllerLanes, midiNotes, midiClipStoreActions, timelineClipHitTest).
2026-05-10: Phase 6/7 in progress. Added "MIDI quantize using last settings" to the store/action registry/piano-roll transform menu with regression coverage, and expanded controller LFO generation UI to square and saw up/down shapes.
2026-05-10: Phase 6 in progress. Added MIDI reset/unquantize and freeze-quantize actions with clip-level quantize backups, undo/redo support, piano-roll transform menu entries, command registry entries, and store regressions.
2026-05-10: Phase 7 in progress. Added controller lane copy/paste in the piano-roll transform menu, normalizing copied values so curves can move between 7-bit CC, 14-bit CC, and pitchbend lanes while preserving shape.
2026-05-10: Phase 7 in progress. Added program-change and channel-pressure lanes to the piano roll controller workflow, including draw/generate/thin/copy/paste support, scheduler parsing, MIDI export parsing, and regression coverage.
2026-05-10: Verification checkpoint. cmake --build build --config Debug passed; npx tsc --noEmit passed; focused Vitest MIDI/timeline suite passed with 29 tests.
2026-05-10: Phase 1/2 in progress. Added a saved-project reload regression that forces a backend MIDI schedule mismatch and asserts load-time repair resends serialized clips plus MIDI panic, then added a native first-block silence fixture for new MIDI/instrument tracks.
2026-05-10: Verification checkpoint. cmake --build build --config Debug passed; npx tsc --noEmit passed; focused Vitest MIDI/timeline/project-load suite passed with 30 tests.
2026-05-10: Phase 6 in progress. Added explicit tuplet quantize divisions plus Cubase-style catch range and safe-zone options to MIDI quantize, surfaced them in the piano-roll quantize dialog, and covered them with store regressions.
2026-05-10: Verification checkpoint. npx tsc --noEmit passed; focused Vitest MIDI/timeline/project-load suite passed with 31 tests.
2026-05-10: Phase 6 done. Added groove presets for straight, light/heavy swing, laid-back 16, and push 16 quantize targets, persisted them in last quantize settings, exposed them in the piano-roll quantize dialog, and added regression coverage.
2026-05-10: Verification checkpoint. npx tsc --noEmit passed; focused Vitest MIDI/timeline/project-load suite passed with 31 tests after Phase 6 completion.
2026-05-10: Phase 1 done. Added native engine-callback fixtures for saved-project MIDI reload playback through an instrument track fallback synth and for add-track no-spike/no-nonfinite behavior on MIDI and instrument tracks immediately inside the audio callback.
2026-05-10: Verification checkpoint. cmake --build build --config Debug passed warning-clean after Phase 1 fixture completion.
2026-05-10: Phase 2 done. Fixed MIDI/instrument track freeze range detection by using scheduled MIDI clips when no audio clips exist, then added native MIDI render/freeze validation that asserts both exported render and frozen track output are readable, finite, and non-silent.
2026-05-10: Verification checkpoint. cmake --build build --config Debug passed; npx tsc --noEmit passed; focused Vitest MIDI/timeline/project-load suite passed with 31 tests after Phase 2 completion.
2026-05-10: Phase 4 in progress. Extended Alt-drag slip editing to MIDI clips, including live preview and undoable commit with backend MIDI resync, and added MIDI source-window context actions for offset reset and source-length edits.
2026-05-10: Verification checkpoint. npx tsc --noEmit passed; focused Vitest MIDI/timeline/project-load suite passed with 32 tests after MIDI slip/source-window work.
2026-05-10: Phase 4 done. Added trim/loop-expansion edge-case regressions to ensure MIDI source and loop length metadata survives left trims, undo, and right-edge loop expansion.
2026-05-10: Verification checkpoint. npx tsc --noEmit passed; focused Vitest MIDI/timeline/project-load suite passed with 33 tests after Phase 4 completion.
2026-05-10: Phase 3 done. Added deterministic migration coverage for legacy MIDI clips missing source/loop metadata, explicit loop-only clips, and explicit source-only clips.
2026-05-10: Verification checkpoint. npx tsc --noEmit passed; focused Vitest MIDI/timeline/project-load suite passed with 34 tests after Phase 3 completion.
2026-05-10: Phase 7 in progress. Added bank-select CC0/CC32 lane presets and added poly-pressure event serialization plus backend scheduling/export parsing.
2026-05-10: Verification checkpoint. cmake --build build --config Debug passed; npx tsc --noEmit passed; focused Vitest MIDI/timeline/project-load suite passed with 34 tests after bank/poly-pressure backend work.
2026-05-10: Phase 5 in progress. Added a piano-roll single-note inspector for direct numeric pitch, start, length, and velocity edits using the existing undoable MIDI note actions.
2026-05-10: Verification checkpoint. npx tsc --noEmit passed; focused Vitest MIDI/timeline/project-load suite passed with 34 tests after note inspector work.
2026-05-10: Phase 7 in progress. Added velocity and controller lane height controls to the piano roll and made lane hit-testing/rendering use the adjustable heights.
2026-05-10: Verification checkpoint. npx tsc --noEmit passed; focused Vitest MIDI/timeline/project-load suite passed with 34 tests after lane-height controls.
2026-05-10: Phase 5 in progress. Added piano-roll multi-item controls for active MIDI clip selection, selected-clip reference visibility, ghost-note visibility, and click-to-focus editing from colored reference notes.
2026-05-10: Verification checkpoint. npx tsc --noEmit passed; focused Vitest MIDI/timeline/project-load suite passed with 34 tests after multi-item controls.
2026-05-10: Phase 5 done. Added undoable snap-selected-notes-to-scale from the active piano-roll root/scale, added a diatonic triad chord insert mode, exposed the scale snap through toolbar/transform/action registry, and covered both behaviors with store regressions.
2026-05-10: Verification checkpoint. npx tsc --noEmit passed; focused Vitest MIDI/timeline/project-load suite passed with 36 tests after Phase 5 completion.
2026-05-10: Phase 7 done. Added note-specific poly-pressure lane editing in the piano roll, made controller dots act as editable curve handles, and added a clear-current-lane control for removing controller/pitchbend/pressure data from the active edit range while arbitrary CC selection remains the lane-add path.
2026-05-10: Verification checkpoint. npx tsc --noEmit passed; focused Vitest MIDI/timeline/project-load suite passed with 36 tests after Phase 7 completion.
2026-05-10: Phase 8 in progress. Added track-level MIDI FX for arpeggiator, pitch transpose, velocity scaling/offset, and time/groove swing/offset; effects are applied during MIDI backend serialization so playback, reload repair, render, and freeze receive the transformed event stream. Initially added compact TCP controls and undoable setTrackMIDIEffects; TCP placement was later revised to the track FX panel on 2026-05-12 after manual DAW-parity feedback.
2026-05-10: Verification checkpoint. npx tsc --noEmit passed; focused Vitest MIDI/timeline/project-load suite passed with 39 tests after MIDI FX serialization and controls.
2026-05-10: Verification checkpoint. cmake --build build --config Debug passed after the MIDI FX/frontend integration work.
2026-05-10: Phase 8 done. Added a built-in basic sampler path for instrument tracks with no plugin: the backend loads an audio sample into an immutable realtime-safe sample buffer, maps it chromatically from a root MIDI note, uses it instead of the sine fallback, persists/restores the sample path/root note through project load, exposes load/clear controls in the TCP, and reports sampler state in MIDI/audio diagnostics.
2026-05-10: Verification checkpoint. npx tsc --noEmit passed; focused Vitest MIDI/timeline/project-load suite passed with 40 tests; cmake --build build --config Debug passed after basic sampler support.
2026-05-10: Phase 9 done. Completed final automated QA for the MIDI/instrument pass: full frontend Vitest suite passed with 112 tests, production frontend build passed, TypeScript passed, focused MIDI/timeline/project-load suite passed with 40 tests, and C++ Debug build passed. Vite emitted existing chunk/dynamic-import size warnings, not build failures.

FilesExpand file tree

midi_instrument_editor_feat_plan.md

Latest commit

History