feat: stabilize focus playback and add mp3 export

Author: topchyan

CHANGELOG.md

@@ -6,6 +6,24 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+### Added
+- Export: MP3 export via external `TiMidity++ -> FFmpeg (libmp3lame)` pipeline (`File -> Export -> MP3…`) with runtime availability checks.
+- Settings: configurable paths for MP3 toolchain binaries (`MP3 export: TiMidity++ path`, `MP3 export: FFmpeg path`) with PATH auto-detection fallback.
+
+### Changed
+- Linux portal save dialogs: enabled filename-preserving defaults for export/save flows so suggested names are applied consistently.
+- MIDI input popover wording clarified (`Preview volume (input + typing)`, `MIDI preview ms`) to match actual behavior.
+
+### Fixed
+- Focus playback muting: voice muting now applies at parsed-symbol level, remains deterministic in multi-voice tunes, and correctly supports muting `V:1` (including implicit first-voice mapping when explicit `V:1` is missing/malformed).
+- Focus playback robustness: fixed no-sound failures caused by muted-voice preprocessing edge cases.
+- Typing note preview: inline field directives like `[P:...]` / `[K:...]` / `[V:...]` no longer trigger note preview.
+- Preview loudness consistency: MIDI-input preview and typing preview volume are now synchronized (UI + persisted settings), removing mismatched perceived loudness.
+- Export dialogs: hardened MusicXML save dialog error handling and aligned suggested-name behavior across MusicXML/MIDI/MP3/PDF/settings export.
+
+### Tests
+- Focus playback harness extended for muted-voice invariance and first-voice fallback (`V:1` implicit mapping).
+- Note preview harness extended with regression coverage for inline field suppression (`[P:...]` should not sound).
 
 
 ## [0.32.3] - 2026-02-14

devtools/focus_playback_harness/run_tests.js

@@ -640,14 +640,6 @@ function normalizeVoiceIdToken(value) {
   return head ? String(head).trim() : "";
 }
 
-function isLikelyMusicBodyLine(line) {
-  const trimmed = String(line || "").trim();
-  if (!trimmed) return false;
-  if (trimmed.startsWith("%") || /^%%/.test(trimmed)) return false;
-  if (/^[A-Za-z][A-Za-z0-9_-]*\s*:/.test(trimmed)) return false;
-  return /[A-Ga-gxzZ]/.test(trimmed) || /[|]/.test(trimmed);
-}
-
 function parseMutedVoiceSetting(value) {
   const raw = String(value || "").trim();
   if (!raw) return [];
@@ -662,53 +654,82 @@ function parseMutedVoiceSetting(value) {
   return out;
 }
 
-function stripMutedVoicesForPlayback(text, mutedVoices) {
-  const muted = mutedVoices && typeof mutedVoices === "object"
-    ? Object.entries(mutedVoices)
-      .filter(([, v]) => Boolean(v))
-      .map(([k]) => normalizeVoiceIdToken(k))
-      .filter(Boolean)
-    : [];
-  if (!muted.length) return text;
-  if (/\[V\s*:/i.test(text)) return String(text || "");
-  const mutedSet = new Set(muted);
-  const lines = String(text || "").split(/\r\n|\n|\r/);
-  let inBody = false;
-  let currentVoice = null;
-  let firstVoiceId = null;
-  const registerFirstVoice = (id) => {
-    if (firstVoiceId) return;
-    firstVoiceId = String(id || "").trim() || "1";
-    if (mutedSet.has("1")) mutedSet.add(firstVoiceId);
-  };
-  const out = [];
-  for (const line of lines) {
-    const trimmed = line.trim();
-    if (!inBody && /^K:/.test(trimmed)) {
-      inBody = true;
-      out.push(line);
-      continue;
-    }
-    if (!inBody) {
-      out.push(line);
-      continue;
-    }
-    const voiceLine = line.match(/^\s*V\s*:\s*(.*)$/i);
-    if (voiceLine) {
-      currentVoice = normalizeVoiceIdToken(voiceLine[1]) || "1";
-      registerFirstVoice(currentVoice);
-      if (mutedSet.has(currentVoice)) continue;
-      out.push(line);
-      continue;
+function resolveEffectiveMutedVoiceIds(mutedVoiceIds, firstPlayableVoiceId) {
+  const ids = Array.isArray(mutedVoiceIds) ? mutedVoiceIds.map((v) => normalizeVoiceIdToken(v)).filter(Boolean) : [];
+  if (!ids.length) return [];
+  const firstId = normalizeVoiceIdToken(firstPlayableVoiceId);
+  const set = new Set(ids);
+  if (set.has("1") && firstId) set.add(firstId);
+  return Array.from(set);
+}
+
+function getFirstPlayableVoiceIdFromTuneRoot(firstSymbol) {
+  let s = firstSymbol || null;
+  let guard = 0;
+  while (s && s.ts_prev && guard < 200000) {
+    s = s.ts_prev;
+    guard += 1;
+  }
+  guard = 0;
+  while (s && guard < 200000) {
+    const pv = s.p_v || null;
+    const id = pv && pv.id != null ? String(pv.id) : "";
+    const upper = id.toUpperCase();
+    if (id && upper !== "_DRUM" && upper !== "_CHORD" && upper !== "_BEATS") return id;
+    s = s.ts_next;
+    guard += 1;
+  }
+  return "";
+}
+
+function applyMutedVoicesToTuneRoot(firstSymbol, mutedVoiceIds) {
+  const mutedSet = new Set(Array.isArray(mutedVoiceIds) ? mutedVoiceIds.map((v) => String(v)) : []);
+  if (!firstSymbol || !mutedSet.size) return false;
+  let s = firstSymbol;
+  let guard = 0;
+  while (s && s.ts_prev && guard < 200000) {
+    s = s.ts_prev;
+    guard += 1;
+  }
+  let changed = false;
+  guard = 0;
+  while (s && guard < 400000) {
+    const pv = s.p_v || null;
+    const id = pv && pv.id != null ? String(pv.id) : "";
+    if (id && mutedSet.has(id)) {
+      s.noplay = true;
+      changed = true;
+      if (Array.isArray(s.notes)) {
+        for (const note of s.notes) {
+          if (note && typeof note === "object") note.noplay = true;
+        }
+      }
     }
-    if (!currentVoice && isLikelyMusicBodyLine(line)) {
-      currentVoice = "1";
-      registerFirstVoice(currentVoice);
+    s = s.ts_next;
+    guard += 1;
+  }
+  return changed;
+}
+
+function countPlayableByVoice(firstSymbol) {
+  const out = new Map();
+  let s = firstSymbol;
+  let guard = 0;
+  while (s && s.ts_prev && guard < 200000) {
+    s = s.ts_prev;
+    guard += 1;
+  }
+  guard = 0;
+  while (s && guard < 400000) {
+    const playable = !s.noplay && Number.isFinite(s.dur) && s.dur > 0;
+    if (playable) {
+      const id = (s.p_v && s.p_v.id != null) ? String(s.p_v.id) : "";
+      if (id) out.set(id, (out.get(id) || 0) + 1);
     }
-    if (currentVoice && mutedSet.has(currentVoice)) continue;
-    out.push(line);
+    s = s.ts_next;
+    guard += 1;
   }
-  return out.join("\n");
+  return out;
 }
 
 function shiftByNumberMap(byNumber, renderOffset) {
@@ -948,19 +969,31 @@ async function main() {
     process.exitCode = 1;
   }
 
-  // Muted voices parsing / filtering regression tests.
+  // Muted voices parsing / symbol-level muting regression tests.
   try {
     const ids = parseMutedVoiceSetting("2, 3  2");
     assert(ids.length === 2 && ids[0] === "2" && ids[1] === "3", "parseMutedVoiceSetting should dedupe");
 
-    const muted23 = stripMutedVoicesForPlayback(tuneText, { "2": true, "3": true });
-    assert(/\nV:1\b/.test(`\n${muted23}`), "muted 2,3 should keep V:1");
-    assert(!/\nV:2\b/.test(`\n${muted23}`), "muted 2,3 should remove V:2");
-    assert(!/\nV:3\b/.test(`\n${muted23}`), "muted 2,3 should remove V:3");
-
-    const muted1 = stripMutedVoicesForPlayback(tuneText, { "1": true });
-    assert(!/\nV:1\b/.test(`\n${muted1}`), "muted 1 should remove V:1");
-    assert(/\nV:2\b/.test(`\n${muted1}`), "muted 1 should keep V:2");
+    const baseRoot = parseTuneWithAbc2svg(tuneText);
+    const baseCounts = countPlayableByVoice(baseRoot);
+    assert((baseCounts.get("1") || 0) > 0, "fixture must contain playable V:1 symbols");
+    assert((baseCounts.get("2") || 0) > 0, "fixture must contain playable V:2 symbols");
+
+    const mutedV1Root = parseTuneWithAbc2svg(tuneText);
+    const firstId = getFirstPlayableVoiceIdFromTuneRoot(mutedV1Root);
+    const effectiveMuteV1 = resolveEffectiveMutedVoiceIds(["1"], firstId);
+    const changedV1 = applyMutedVoicesToTuneRoot(mutedV1Root, effectiveMuteV1);
+    assert(changedV1, "muted V:1 should modify tune symbols");
+    const afterV1 = countPlayableByVoice(mutedV1Root);
+    assert((afterV1.get("1") || 0) === 0, "muted V:1 must silence voice 1");
+    assert((afterV1.get("2") || 0) > 0, "muted V:1 must keep voice 2 playable");
+
+    const mutedV2Root = parseTuneWithAbc2svg(tuneText);
+    const changedV2 = applyMutedVoicesToTuneRoot(mutedV2Root, ["2"]);
+    assert(changedV2, "muted V:2 should modify tune symbols");
+    const afterV2 = countPlayableByVoice(mutedV2Root);
+    assert((afterV2.get("2") || 0) === 0, "muted V:2 must silence voice 2");
+    assert((afterV2.get("1") || 0) > 0, "muted V:2 must keep voice 1 playable");
 
     const implicitVoiceText = [
       "X:1",
@@ -972,9 +1005,13 @@ async function main() {
       "V:2",
       "A2 B2 | c2 d2 |",
     ].join("\n");
-    const implicitMuted1 = stripMutedVoicesForPlayback(implicitVoiceText, { "1": true });
-    assert(!/D2 E2/.test(implicitMuted1), "implicit V:1 content must be muted when voice 1 is muted");
-    assert(/V:2/.test(implicitMuted1), "implicit V:1 mute should keep explicit V:2");
+    const implicitRoot = parseTuneWithAbc2svg(implicitVoiceText);
+    const implicitFirst = getFirstPlayableVoiceIdFromTuneRoot(implicitRoot);
+    const implicitEffective = resolveEffectiveMutedVoiceIds(["1"], implicitFirst);
+    assert(implicitEffective.includes(implicitFirst), "implicit/malformed V:1 should map to de-facto first voice");
+    applyMutedVoicesToTuneRoot(implicitRoot, implicitEffective);
+    const implicitAfter = countPlayableByVoice(implicitRoot);
+    assert((implicitAfter.get("2") || 0) > 0, "implicit V:1 mute should keep explicit V:2 playable");
 
     const malformedVoiceText = [
       "X:1",
@@ -987,12 +1024,16 @@ async function main() {
       "V:2",
       "A2 B2 | c2 d2 |",
     ].join("\n");
-    const malformedMuted1 = stripMutedVoicesForPlayback(malformedVoiceText, { "1": true });
-    assert(!/D2 E2/.test(malformedMuted1), "malformed V: should still be treated as de-facto V:1");
-    assert(/V:2/.test(malformedMuted1), "malformed V: mute should keep explicit V:2");
-    console.log("% PASS TEST 13: Muted voices (including implicit/malformed V:1) behave correctly");
+    const malformedRoot = parseTuneWithAbc2svg(malformedVoiceText);
+    const malformedFirst = getFirstPlayableVoiceIdFromTuneRoot(malformedRoot);
+    const malformedEffective = resolveEffectiveMutedVoiceIds(["1"], malformedFirst);
+    assert(malformedEffective.includes(malformedFirst), "malformed V: should still map mute 1 to de-facto first voice");
+    applyMutedVoicesToTuneRoot(malformedRoot, malformedEffective);
+    const malformedAfter = countPlayableByVoice(malformedRoot);
+    assert((malformedAfter.get("2") || 0) > 0, "malformed V: mute should keep explicit V:2 playable");
+    console.log("% PASS TEST 13: Muted voices (including V:1 and implicit/malformed V:1) behave correctly");
   } catch (e) {
-    console.log("% FAIL TEST 13: Muted voices (including implicit/malformed V:1) behave correctly");
+    console.log("% FAIL TEST 13: Muted voices (including V:1 and implicit/malformed V:1) behave correctly");
     String(e && e.message ? e.message : e).split(/\r\n|\n|\r/).forEach((line) => console.log(`% ${line}`));
     process.exitCode = 1;
   }

devtools/note_preview_harness/run_tests.mjs

@@ -1,5 +1,6 @@
 import {
   findCompletedNoteTokenBeforePosition,
+  isRangeInsideInlineField,
   parseAbcNoteToken,
   parseHeadersNear,
 } from "../../src/renderer/note_preview/abc_note_parse.mjs";
@@ -64,6 +65,15 @@ function run() {
   const micro = parseAbcNoteToken("^3c", ctx, { lengthMode: "typed", skipMicrotones: true });
   assert(micro === null, "microtonal-like token should be skipped when skipMicrotones=true");
 
+  assert(
+    isRangeInsideInlineField("[P:A] C D", 3, 4) === true,
+    "note-like letters inside [P:...] must not be previewed",
+  );
+  assert(
+    isRangeInsideInlineField("[K:D] C D", 6, 7) === false,
+    "musical tokens outside inline fields should remain previewable",
+  );
+
   console.log("[note_preview_harness] OK");
 }
 

src/main/index.js

@@ -466,7 +466,7 @@ function prepareDialogParent(senderOrEvent, reason) {
   return parent;
 }
 
-function getDialogDefaultPath({ suggestedName, suggestedDir, suggestedPath, directoryOnly } = {}) {
+function getDialogDefaultPath({ suggestedName, suggestedDir, suggestedPath, directoryOnly, preferFileNameOnPortal = false } = {}) {
   const normalizeFsPath = (value) => {
     const raw = String(value || "").trim();
     if (!raw) return "";
@@ -492,7 +492,7 @@ function getDialogDefaultPath({ suggestedName, suggestedDir, suggestedPath, dire
   const fileName = String(suggestedName || "").trim() || explicitPathBase;
   // Linux portal dialogs often ignore defaultPath when a filename is included.
   // Prefer a directory default there to keep navigation stable.
-  if (portalLikelyActive && baseDir) return baseDir;
+  if (portalLikelyActive && baseDir && !preferFileNameOnPortal) return baseDir;
   if (baseDir && fileName) return path.join(baseDir, fileName);
   if (baseDir) return baseDir;
   if (explicitPathAbs) return explicitPathAbs;
@@ -554,6 +554,7 @@ function showSaveDialog(suggestedName, suggestedDir, senderOrEvent) {
   const defaultPath = getDialogDefaultPath({
     suggestedName: defaultName,
     suggestedDir,
+    preferFileNameOnPortal: true,
   });
   const ext = path.extname(defaultName || "").replace(/^\./, "").trim().toLowerCase();
   const filters = (() => {
@@ -1106,6 +1107,8 @@ function applySettingsPatch(patch, { persistToSettingsFile = true } = {}) {
     Object.prototype.hasOwnProperty.call(patch, "makamToolsEnabled")
     || Object.prototype.hasOwnProperty.call(patch, "studyToolsEnabled")
     || Object.prototype.hasOwnProperty.call(patch, "payloadModeEnabled")
+    || Object.prototype.hasOwnProperty.call(patch, "mp3ExportTimidityPath")
+    || Object.prototype.hasOwnProperty.call(patch, "mp3ExportFfmpegPath")
   )) {
     refreshMenu();
   }