midi-cli 0.1.0__tar.gz

midi_cli-0.1.0/.claude/settings.local.json

@@ -0,0 +1,42 @@
+{
+  "permissions": {
+    "allow": [
+      "Bash(gh issue:*)",
+      "Bash(git:*)",
+      "Bash(python3 -c \"import rtmidi; print\\(rtmidi.__version__\\)\")",
+      "Bash(python3 -c \"import sounddevice; print\\(sounddevice.__version__\\)\")",
+      "Bash(python3 -c \"import numpy; print\\(numpy.__version__\\)\")",
+      "WebFetch(domain:spotlightkid.github.io)",
+      "WebFetch(domain:python-sounddevice.readthedocs.io)",
+      "Bash(python3 -m venv .venv)",
+      "Bash(source .venv/bin/activate)",
+      "Bash(pip install:*)",
+      "Bash(chmod:*)",
+      "Bash(ls /Users/mb/code/midi-cli/*.py /Users/mb/code/midi-cli/src/**/*.py)",
+      "Bash(gh pr:*)",
+      "Bash(wc -l /Users/mb/code/midi-cli/src/**/*.rs /Users/mb/code/midi-cli/src/*.rs)",
+      "Bash(grep -E \"\\\\.\\(py|txt\\)$\")",
+      "Bash(git commit:*)",
+      "Bash(ambiguous\". Use explicit None check instead.:*)",
+      "Bash(gh repo:*)",
+      "Bash(wc -l /Users/mb/code/midi-cli/src/*.py /Users/mb/code/midi-cli/*.py)",
+      "Bash(python3 -m py_compile main.py)",
+      "Bash(python3:*)",
+      "Bash(/Users/mb/code/midi-cli/.venv/bin/python -c \"import midi_cli.state; import midi_cli.audio; import midi_cli.sampler; import midi_cli.ui; import midi_cli.midi; import midi_cli.app; print\\('All imports OK'\\)\")",
+      "Bash(/Users/mb/code/midi-cli/.venv/bin/pip list:*)",
+      "Bash(/Users/mb/code/midi-cli/.venv/bin/python -c \"\nimport midi_cli.state as st\nprint\\(f'state: {len\\(st.MODES\\)} modes, SAMPLE_RATE={st.SAMPLE_RATE}'\\)\nimport midi_cli.audio\nprint\\(f'audio: audio_callback, build_synth_envelope, trim_silence OK'\\)\nprint\\('All non-pyrubberband imports OK'\\)\n\")",
+      "Bash(uv run:*)",
+      "Bash(wc -l /Users/mb/code/midi-cli/midi_cli/*.py /Users/mb/code/midi-cli/main.py)",
+      "Bash(python -m py_compile midi_cli/state.py)",
+      "Bash(python -m py_compile midi_cli/sampler.py)",
+      "Bash(python -m py_compile midi_cli/midi.py)",
+      "Bash(python -m py_compile midi_cli/ui.py)",
+      "Bash(python -m py_compile midi_cli/app.py)",
+      "Bash(brew search:*)",
+      "Bash(brew info:*)",
+      "WebSearch",
+      "Bash(python:*)",
+      "Bash(ls:*)"
+    ]
+  }
+}

midi_cli-0.1.0/.gitignore

@@ -0,0 +1,9 @@
+__pycache__/
+*.pyc
+.venv/
+venv/
+*.egg-info/
+dist/
+build/
+samples/
+config.json

midi_cli-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 mnbpdx
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

midi_cli-0.1.0/PKG-INFO

@@ -0,0 +1,47 @@
+Metadata-Version: 2.4
+Name: midi-cli
+Version: 0.1.0
+Summary: A MIDI sampler and looper in your terminal
+Project-URL: Homepage, https://github.com/mnbpdx/midi-cli
+Project-URL: Repository, https://github.com/mnbpdx/midi-cli
+License: MIT
+License-File: LICENSE
+Classifier: Environment :: Console
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: MacOS
+Classifier: Topic :: Multimedia :: Sound/Audio
+Classifier: Topic :: Multimedia :: Sound/Audio :: MIDI
+Requires-Python: >=3.11
+Requires-Dist: numpy
+Requires-Dist: pyrubberband
+Requires-Dist: python-rtmidi
+Requires-Dist: sounddevice
+Description-Content-Type: text/markdown
+
+# midi-cli
+
+A little midi player in your terminal, tested in zsh on macOS.
+
+## Install
+
+```sh
+pipx install midi-cli
+```
+
+Or with pip:
+
+```sh
+pip install midi-cli
+```
+
+### For development
+
+```sh
+uv pip install -e .
+```
+
+## Usage
+
+```sh
+midi-cli
+```

midi_cli-0.1.0/README.md

@@ -0,0 +1,27 @@
+# midi-cli
+
+A little midi player in your terminal, tested in zsh on macOS.
+
+## Install
+
+```sh
+pipx install midi-cli
+```
+
+Or with pip:
+
+```sh
+pip install midi-cli
+```
+
+### For development
+
+```sh
+uv pip install -e .
+```
+
+## Usage
+
+```sh
+midi-cli
+```

midi_cli-0.1.0/main.py

@@ -0,0 +1,6 @@
+#!/usr/bin/env -S uv run --project .
+"""Thin wrapper so ./main.py keeps working."""
+from midi_cli.app import main
+
+if __name__ == "__main__":
+    main()

midi_cli-0.1.0/midi_cli/app.py

@@ -0,0 +1,179 @@
+import os
+import select
+import sys
+import termios
+import threading
+import tty
+
+import sounddevice as sd
+
+import midi_cli.state as st
+from midi_cli.audio import audio_callback
+from midi_cli.sampler import load_samples, load_pitch_offsets, save_sample, adjust_pitch, compute_chromatic_samples_async, execute_copy, stop_recording
+from midi_cli.midi import open_midi_input, trigger_keyboard_note, midi_callback
+from midi_cli.ui import draw_ui, reset_trim_state, reset_copy_state
+from midi_cli.loop import reset_loop_state, cycle_loop_state
+
+
+def main():
+    from midi_cli.config import run_setup_wizard
+    cfg = run_setup_wizard()
+    st.input_device = cfg.get("input_device")
+    st.output_device = cfg.get("output_device")
+    st.midi_port = cfg.get("midi_port")
+    sys.stdout.write("\033[2J\033[H")
+    sys.stdout.flush()
+
+    midi_in, port_name = open_midi_input(st.midi_port)
+    if midi_in is None:
+        st.keyboard_mock_mode = True
+    else:
+        st.ui_midi_port = port_name
+
+    load_samples()
+    load_pitch_offsets()
+
+    stream = sd.OutputStream(
+        samplerate=st.SAMPLE_RATE,
+        blocksize=st.BLOCK_SIZE,
+        channels=1,
+        callback=audio_callback,
+        device=st.output_device,
+    )
+    stream.start()
+
+    fd = sys.stdin.fileno()
+    old_settings = termios.tcgetattr(fd)
+    sys.stdout.write(st.HIDE_CURSOR)
+    sys.stdout.flush()
+
+    try:
+        tty.setraw(fd)
+        initialized = False
+        while True:
+            draw_ui(initialized)
+            initialized = True
+
+            ready, _, _ = select.select([fd], [], [], 0.05)
+            if ready:
+                ch = os.read(fd, 1).decode("utf-8", errors="replace")
+                if ch in ("q", "\x03"):  # q or Ctrl+C
+                    break
+                elif ch == "\r" and st.mode == "trim" and st.trim_selected_note is not None:
+                    if st.trim_step == 0:
+                        # Confirm start, advance to end adjustment
+                        st.trim_step = 1
+                        st.trim_loop_pos = st.trim_start
+                    else:
+                        # Confirm end, slice and save
+                        audio = st.samples[st.trim_selected_note][st.trim_start:st.trim_end]
+                        note = st.trim_selected_note
+                        save_sample(note, audio)
+                        # Recompute chromatic if this was the root
+                        if st.chromatic_root_note == note:
+                            compute_chromatic_samples_async(note)
+                        reset_trim_state()
+                elif ch == "\r" and st.mode == "copy" and st.copy_confirm_pending:
+                    execute_copy()
+                elif ch == "\t":  # Tab: next mode
+                    if st.mode == "record":
+                        st.keyboard_recording_notes.clear()
+                        if st.recording_note is not None:
+                            threading.Thread(target=stop_recording, args=(st.recording_note,), daemon=True).start()
+                    if st.mode == "trim":
+                        reset_trim_state()
+                    if st.mode == "copy":
+                        reset_copy_state()
+                    if st.mode == "loop":
+                        with st.voices_lock:
+                            reset_loop_state()
+                    st.mode = st.MODES[(st.MODES.index(st.mode) + 1) % len(st.MODES)]
+                    if st.mode == "chromatic":
+                        st.chromatic_selecting = st.chromatic_root_note is None
+                elif ch == "r" and st.mode == "chromatic" and not st.chromatic_selecting:
+                    st.chromatic_selecting = True
+                elif ch == "\x1b":  # escape sequence
+                    # Use select on fd with timeout to distinguish bare Escape from sequences
+                    esc_ready, _, _ = select.select([fd], [], [], 0.02)
+                    if not esc_ready:
+                        # Bare Escape
+                        if st.mode == "trim" and st.trim_selected_note is not None:
+                            reset_trim_state()
+                        elif st.mode == "copy" and (st.copy_source_note is not None or st.copy_confirm_pending):
+                            reset_copy_state()
+                        elif st.mode == "loop":
+                            with st.voices_lock:
+                                reset_loop_state()
+                    else:
+                        seq = os.read(fd, 2).decode("utf-8", errors="replace")
+                        if seq == "[Z":  # Shift+Tab: previous mode
+                            if st.mode == "record":
+                                st.keyboard_recording_notes.clear()
+                                if st.recording_note is not None:
+                                    threading.Thread(target=stop_recording, args=(st.recording_note,), daemon=True).start()
+                            if st.mode == "trim":
+                                reset_trim_state()
+                            if st.mode == "copy":
+                                reset_copy_state()
+                            if st.mode == "loop":
+                                with st.voices_lock:
+                                    reset_loop_state()
+                            st.mode = st.MODES[(st.MODES.index(st.mode) - 1) % len(st.MODES)]
+                            if st.mode == "chromatic":
+                                st.chromatic_selecting = st.chromatic_root_note is None
+                        elif st.mode == "trim" and st.trim_selected_note is not None:
+                            sample_len = len(st.samples[st.trim_selected_note])
+                            fine = max(1, sample_len // 1000)    # 0.1%
+                            coarse = max(1, sample_len // 100)   # 1%
+                            if st.trim_step == 0:
+                                if seq == "[D":    # Left: decrease start
+                                    st.trim_start = max(0, st.trim_start - fine)
+                                elif seq == "[C":  # Right: increase start
+                                    st.trim_start = min(st.trim_end - st.MIN_TRIM_SAMPLES, st.trim_start + fine)
+                                elif seq == "[B":  # Down: decrease start (coarse)
+                                    st.trim_start = max(0, st.trim_start - coarse)
+                                elif seq == "[A":  # Up: increase start (coarse)
+                                    st.trim_start = min(st.trim_end - st.MIN_TRIM_SAMPLES, st.trim_start + coarse)
+                            else:
+                                if seq == "[D":    # Left: decrease end
+                                    st.trim_end = max(st.trim_start + st.MIN_TRIM_SAMPLES, st.trim_end - fine)
+                                elif seq == "[C":  # Right: increase end
+                                    st.trim_end = min(sample_len, st.trim_end + fine)
+                                elif seq == "[B":  # Down: decrease end (coarse)
+                                    st.trim_end = max(st.trim_start + st.MIN_TRIM_SAMPLES, st.trim_end - coarse)
+                                elif seq == "[A":  # Up: increase end (coarse)
+                                    st.trim_end = min(sample_len, st.trim_end + coarse)
+                            st.trim_start = max(0, st.trim_start)
+                            st.trim_end = max(st.trim_start + st.MIN_TRIM_SAMPLES, st.trim_end)
+                        elif st.mode == "pitch" and st.pitch_selected_note is not None:
+                            if seq == "[A":    # Up: +1 semitone
+                                adjust_pitch(st.pitch_selected_note, 1, 0)
+                            elif seq == "[B":  # Down: -1 semitone
+                                adjust_pitch(st.pitch_selected_note, -1, 0)
+                            elif seq == "[C":  # Right: +10 cents
+                                adjust_pitch(st.pitch_selected_note, 0, st.CENTS_STEP)
+                            elif seq == "[D":  # Left: -10 cents
+                                adjust_pitch(st.pitch_selected_note, 0, -st.CENTS_STEP)
+                elif ch == 'l' and st.mode == "loop":
+                    with st.voices_lock:
+                        cycle_loop_state()
+                elif st.keyboard_mock_mode and ch in st.KEYBOARD_NOTE_MAP:
+                    trigger_keyboard_note(st.KEYBOARD_NOTE_MAP[ch])
+                elif st.keyboard_mock_mode and ch == '`':
+                    new_val = 0 if st.sustain else 127
+                    midi_callback(([0xB0, 64, new_val], 0), None)
+    except (KeyboardInterrupt, EOFError):
+        pass
+    finally:
+        termios.tcsetattr(fd, termios.TCSADRAIN, old_settings)
+        sys.stdout.write(st.SHOW_CURSOR)
+        sys.stdout.flush()
+        stream.stop()
+        stream.close()
+        if midi_in is not None:
+            midi_in.close_port()
+            midi_in.delete()
+
+
+if __name__ == "__main__":
+    main()

midi_cli-0.1.0/midi_cli/audio.py

@@ -0,0 +1,278 @@
+import numpy as np
+
+import midi_cli.state as st
+
+
+def build_synth_envelope(gain, releasing, faded_in, age, frames):
+    """Vectorized envelope: returns (gains_array, new_gain, new_age, new_faded_in)."""
+    idx = np.arange(frames)
+
+    if releasing:
+        gains = np.maximum(0.0, gain - st.FADE_OUT_STEP * (idx + 1))
+        new_gain = max(0.0, gain - st.FADE_OUT_STEP * frames)
+        return gains, new_gain, age, faded_in
+
+    if not faded_in:
+        # Fade-in with concurrent stage1 decay:
+        # Recurrence: g' = (g + FADE_IN_STEP) * STAGE1_DECAY
+        # We compute iteratively to find the clamp point, then switch to pure decay.
+        gains = np.empty(frames)
+        g = gain
+        clamp_idx = frames  # assume no clamp within block
+        for i in range(frames):
+            g = (g + st.FADE_IN_STEP) * st.STAGE1_DECAY
+            if g >= 1.0:
+                g = 1.0
+                clamp_idx = i
+                break
+            gains[i] = g
+
+        if clamp_idx < frames:
+            # Faded in at clamp_idx
+            gains[clamp_idx] = g
+            remaining = frames - clamp_idx - 1
+            if remaining > 0:
+                post_age = age + clamp_idx + 1
+                if post_age < st.STAGE1_SAMPLES:
+                    s1_left = st.STAGE1_SAMPLES - post_age
+                    if remaining <= s1_left:
+                        gains[clamp_idx + 1:] = g * st.STAGE1_DECAY ** (idx[:remaining] + 1)
+                    else:
+                        gains[clamp_idx + 1:clamp_idx + 1 + s1_left] = g * st.STAGE1_DECAY ** (idx[:s1_left] + 1)
+                        g_at_boundary = g * st.STAGE1_DECAY ** s1_left
+                        rest = remaining - s1_left
+                        gains[clamp_idx + 1 + s1_left:] = g_at_boundary * st.STAGE2_DECAY ** (idx[:rest] + 1)
+                else:
+                    gains[clamp_idx + 1:] = g * st.STAGE2_DECAY ** (idx[:remaining] + 1)
+            new_gain = gains[-1]
+            new_age = age + frames
+            return gains, new_gain, new_age, True
+        else:
+            # Still fading in at end of block
+            new_gain = g
+            new_age = age + frames
+            return gains, new_gain, new_age, False
+
+    # Already faded in — pure decay
+    if age >= st.STAGE1_SAMPLES:
+        # Pure stage2
+        gains = gain * st.STAGE2_DECAY ** (idx + 1)
+    elif age + frames <= st.STAGE1_SAMPLES:
+        # Pure stage1
+        gains = gain * st.STAGE1_DECAY ** (idx + 1)
+    else:
+        # Stage1 → stage2 boundary mid-block
+        s1_left = st.STAGE1_SAMPLES - age
+        gains = np.empty(frames)
+        gains[:s1_left] = gain * st.STAGE1_DECAY ** (idx[:s1_left] + 1)
+        g_at_boundary = gain * st.STAGE1_DECAY ** s1_left
+        s2_count = frames - s1_left
+        gains[s1_left:] = g_at_boundary * st.STAGE2_DECAY ** (idx[:s2_count] + 1)
+
+    new_gain = gains[-1]
+    new_age = age + frames
+    return gains, new_gain, new_age, faded_in
+
+
+def audio_callback(outdata, frames, time_info, status):
+    with st.voices_lock:
+        if st.mode == "trim" and st.trim_looping and st.trim_selected_note is not None:
+            sample_data = st.samples.get(st.trim_selected_note)
+            if sample_data is None or st.trim_end <= st.trim_start:
+                outdata[:] = 0
+                return
+            # Bounds-check loop pos
+            region_len = st.trim_end - st.trim_start
+            cycle_len = max(region_len, st.MIN_LOOP_PERIOD)
+            if st.trim_loop_pos < 0 or st.trim_loop_pos >= cycle_len:
+                st.trim_loop_pos = 0
+            mix = np.zeros(frames)
+            written = 0
+            while written < frames:
+                if st.trim_loop_pos < region_len:
+                    # Playing audio portion
+                    src_pos = st.trim_start + st.trim_loop_pos
+                    avail = region_len - st.trim_loop_pos
+                    n = min(frames - written, avail)
+                    mix[written:written + n] = sample_data[src_pos:src_pos + n]
+                    st.trim_loop_pos += n
+                    written += n
+                else:
+                    # Silence padding portion
+                    avail = cycle_len - st.trim_loop_pos
+                    n = min(frames - written, avail)
+                    # mix is already zeros
+                    st.trim_loop_pos += n
+                    written += n
+                if st.trim_loop_pos >= cycle_len:
+                    st.trim_loop_pos = 0
+            mix *= 0.25
+            np.clip(mix, -1.0, 1.0, out=mix)
+            outdata[:, 0] = mix
+            return
+
+        if st.mode == "loop":
+            mix = np.zeros(frames)
+
+            # Sample voice mixing (same logic as sample mode)
+            finished = []
+            for note, sv in st.sample_voices.items():
+                if note not in st.samples:
+                    finished.append(note)
+                    continue
+                pos = sv["pos"]
+                gain = sv["gain"]
+                releasing = sv["releasing"]
+                sample_data = st.samples[note]
+                remaining = len(sample_data) - pos
+                n = min(frames, remaining)
+                if n <= 0:
+                    finished.append(note)
+                    continue
+                buf = np.zeros(frames)
+                buf[:n] = sample_data[pos:pos + n] * gain
+                if releasing:
+                    fade_gains = np.maximum(0.0, gain - st.FADE_OUT_STEP * (np.arange(n) + 1))
+                    buf[:n] *= fade_gains
+                    gain = max(0.0, gain - st.FADE_OUT_STEP * n)
+                else:
+                    gain = min(1.0, gain + st.FADE_IN_STEP * n)
+                mix += buf
+                sv["pos"] = pos + n
+                sv["gain"] = gain
+                if (releasing and gain <= 0.0) or pos + n >= len(sample_data):
+                    finished.append(note)
+            for note in finished:
+                del st.sample_voices[note]
+
+            # Loop capture/playback
+            if st.loop_state == "recording":
+                st.loop_record_chunks.append(mix.copy())
+            elif st.loop_state in ("playing", "overdub") and st.loop_buffer is not None:
+                buf = st.loop_buffer
+                buf_len = len(buf)
+                loop_chunk = np.zeros(frames)
+                written = 0
+                pos = st.loop_pos
+                while written < frames:
+                    avail = buf_len - pos
+                    take = min(avail, frames - written)
+                    loop_chunk[written:written + take] = buf[pos:pos + take]
+                    if st.loop_state == "overdub":
+                        buf[pos:pos + take] += mix[written:written + take]
+                        np.clip(buf[pos:pos + take], -1.0, 1.0, out=buf[pos:pos + take])
+                    written += take
+                    pos = (pos + take) % buf_len
+                mix += loop_chunk
+                st.loop_pos = (st.loop_pos + frames) % buf_len
+
+            mix *= 0.25
+            np.clip(mix, -1.0, 1.0, out=mix)
+            outdata[:, 0] = mix
+            return
+
+        if st.mode in ("sample", "pitch", "chromatic", "trim"):
+            if not st.sample_voices:
+                outdata[:] = 0
+                return
+
+            mix = np.zeros(frames)
+            finished = []
+
+            for note, sv in st.sample_voices.items():
+                if st.mode == "chromatic":
+                    sample_data = st.chromatic_samples.get(note)
+                    if sample_data is None:
+                        finished.append(note)
+                        continue
+                else:
+                    if note not in st.samples:
+                        finished.append(note)
+                        continue
+                    ps = st.pitched_samples.get(note)
+                    sample_data = ps if ps is not None else st.samples.get(note)
+                pos = sv["pos"]
+                gain = sv["gain"]
+                releasing = sv["releasing"]
+
+                remaining = len(sample_data) - pos
+                n = min(frames, remaining)
+                if n <= 0:
+                    finished.append(note)
+                    continue
+
+                buf = np.zeros(frames)
+                buf[:n] = sample_data[pos:pos + n] * gain
+
+                if releasing:
+                    fade_gains = np.maximum(0.0, gain - st.FADE_OUT_STEP * (np.arange(n) + 1))
+                    buf[:n] *= fade_gains
+                    gain = max(0.0, gain - st.FADE_OUT_STEP * n)
+                else:
+                    gain = min(1.0, gain + st.FADE_IN_STEP * n)
+
+                mix += buf
+                sv["pos"] = pos + n
+                sv["gain"] = gain
+                if (releasing and gain <= 0.0) or pos + n >= len(sample_data):
+                    finished.append(note)
+
+            for note in finished:
+                del st.sample_voices[note]
+
+            mix *= 0.25
+            np.clip(mix, -1.0, 1.0, out=mix)
+            outdata[:, 0] = mix
+            return
+
+        # Synth mode
+        if not st.voices:
+            outdata[:] = 0
+            return
+
+        mix = np.zeros(frames)
+        finished = []
+
+        for note, v in st.voices.items():
+            freq = st.note_to_freq(note)
+            phase = v["phase"]
+            gain = v["gain"]
+            releasing = v["releasing"]
+            age = v["age"]
+            faded_in = v["faded_in"]
+
+            phase_step = 2.0 * np.pi * freq / st.SAMPLE_RATE
+            phases = phase + np.arange(frames) * phase_step
+            phase_matrix = phases[:, None] * st.H_MULTIPLIERS[None, :]
+            raw_signal = np.sin(phase_matrix) @ st.HARMONICS
+            gains, gain, age, faded_in = build_synth_envelope(gain, releasing, faded_in, age, frames)
+            buf = raw_signal * gains
+            phase = phases[-1] + phase_step
+
+            mix += buf
+            v["phase"] = phase % (2.0 * np.pi)
+            v["gain"] = gain
+            v["age"] = age
+            v["faded_in"] = faded_in
+            if (releasing and gain == 0.0) or gain < st.SILENCE_THRESHOLD:
+                finished.append(note)
+
+        for note in finished:
+            del st.voices[note]
+
+        mix *= 0.25  # fixed headroom (up to ~4 voices at full level)
+        np.clip(mix, -1.0, 1.0, out=mix)
+        outdata[:, 0] = mix
+
+
+def trim_silence(audio, threshold_db=-20):
+    """Trim leading and trailing silence from an audio array."""
+    threshold = 10 ** (threshold_db / 20.0)  # convert dB to linear
+    above = np.abs(audio) > threshold
+    if not np.any(above):
+        return audio  # all silence, return as-is
+    indices = np.where(above)[0]
+    pad = int(0.05 * st.SAMPLE_RATE)  # 50ms pad
+    start = max(indices[0] - pad, 0)
+    end = min(indices[-1] + 1 + pad, len(audio))
+    return audio[start:end]