feat(auto): expose EQ presets as a browsable Android Auto folder

Adds an Ecualizador folder listing the 6 fixed presets; selecting one applies and persists it through the existing headless-safe seam without touching playback or the now-playing media item.
2026-07-19 14:12:39 +02:00
parent 066fedb7bc
commit 90cd232ad2
9 changed files with 1092 additions and 7 deletions
@@ -7,11 +7,22 @@ import 'package:path_provider/path_provider.dart';
 import '../estado/orden_emisoras.dart';
 import '../modelos/emisora.dart';
 import '../modelos/grupo_favoritos.dart';
 import '../modelos/preset_ecualizador.dart';
 import 'persistencia_tolerante.dart';
 import 'servicio_favoritos.dart';
 const _prefijoEmisora = 'emisora:';
 /// EQ preset media-id prefix (Design ADR-1), collision-free against
 /// [_prefijoEmisora], `grupo:` and the bare folder id constants.
 const _prefijoPresetEq = 'eq_preset:';
 /// Whether [id] identifies an EQ preset leaf item (Design ADR-1). A bare
 /// prefix (`'eq_preset:'`, empty name) is still `true` here — the empty-name
 /// case is rejected downstream by [resolverPresetEq], not by this routing
 /// predicate.
 bool esPresetMediaId(String id) => id.startsWith(_prefijoPresetEq);
 /// Canonical on-brand fallback-art names and rotation order, ported
 /// **verbatim** (same formula, same order) from
 /// `lib/widgets/tarjeta_emisora.dart`'s `_fallbackArtFor` (lines 363-367)
@@ -124,6 +135,12 @@ class ConstructorArbolAuto {
  static const idTodas = 'todas';
  static const idMisEmisoras = 'mis_emisoras';
  /// Root folder id for the EQ presets folder (Design "media-id scheme").
  /// Deliberately NOT added to [_idsCarpetas] — it has its own dedicated
  /// branch in `getChildren`/`ConstructorArbolAuto.presetsEq`, not the
  /// generic station-list `hijos()` path.
  static const idEcualizador = 'ecualizador';
  static const _idsCarpetas = {idFavoritos, idTodas, idMisEmisoras};
  static const _maxItemsPorCarpeta = 50;
@@ -147,12 +164,15 @@ class ConstructorArbolAuto {
    'android.media.browse.CONTENT_STYLE_PLAYABLE_HINT': 2,
  };
-  /// The 3 root folders (Favoritos, Todas las emisoras, Mis emisoras), all
+  /// The 4 root folders (Favoritos, Todas las emisoras, Mis emisoras,
-  /// non-playable.
+  /// Ecualizador), all non-playable. `Ecualizador` is deliberately LAST
  /// (Design ADR-2): content-browsing folders are the primary car task and
  /// stay first, the EQ tool trails them.
  List<MediaItem> raiz() => [
    _carpeta(idFavoritos, 'Favoritos'),
    _carpeta(idTodas, 'Todas las emisoras'),
    _carpeta(idMisEmisoras, 'Mis emisoras'),
    _carpeta(idEcualizador, 'Ecualizador'),
  ];
  MediaItem _carpeta(String id, String titulo) => MediaItem(
@@ -209,6 +229,20 @@ class ConstructorArbolAuto {
  MediaItem itemGrupo(GrupoFavoritos g) =>
      _carpeta('$_prefijoGrupo${g.id}', g.nombre);
  /// Maps a [PresetEcualizador] to a playable `MediaItem` with id
  /// `eq_preset:<nombre>` (Design ADR-1).
  MediaItem itemPresetEq(PresetEcualizador preset) => MediaItem(
    id: '$_prefijoPresetEq${preset.nombre}',
    title: preset.nombre,
    playable: true,
    extras: _contentStyleGrid,
  );
  /// The 6 fixed EQ preset leaf items for the `Ecualizador` folder (Spec
  /// "Car requests the Ecualizador folder").
  List<MediaItem> presetsEq(List<PresetEcualizador> presets) =>
      presets.map(itemPresetEq).toList();
  /// Children of the `Favoritos` folder (Design "Ungrouped favorites stay as
  /// direct leaves at the Favoritos root"): non-empty custom-group folders
  /// (phone order, capped at [_maxGruposPorFavoritos]), followed by
@@ -290,6 +324,62 @@ Future<void> reproducirPorMediaId(
  await reproducir(item);
 }
 /// Resolves an `eq_preset:<nombre>` [id] to the matching [PresetEcualizador]
 /// in [presets] by exact name (Design ADR-1, mirrors
 /// [ConstructorArbolAuto.resolver]'s shape). Any other shape (no prefix,
 /// empty name, unmatched name) returns `null` instead of throwing (Spec
 /// "Unknown or stale preset id").
 PresetEcualizador? resolverPresetEq(String id, List<PresetEcualizador> presets) {
  if (!esPresetMediaId(id)) return null;
  final nombre = id.substring(_prefijoPresetEq.length);
  if (nombre.isEmpty) return null;
  for (final preset in presets) {
    if (preset.nombre == nombre) return preset;
  }
  return null;
 }
 /// Pure per-station apply gate (Design ADR-5), mirroring
 /// `EstadoEcualizador.cambiarPresetPrincipal`'s exact logic
 /// (`estado_ecualizador.dart:302-304`): the new principal preset is applied
 /// live when there is no current station ([uuidActual] is `null`) or the
 /// current station has no per-station preset override in
 /// [clavesPorEmisora].
 bool debeAplicarPrincipalAhora({
  required String? uuidActual,
  required Set<String> clavesPorEmisora,
 }) => uuidActual == null || !clavesPorEmisora.contains(uuidActual);
 /// Orchestrates an `eq_preset:<nombre>` selection from the car (Design
 /// "Data flow — a preset tap", ADR-3): resolves [id] via [resolverPresetEq],
 /// persists it as principal via [persistirPrincipal], and conditionally
 /// applies it live via [aplicar] when [debeAplicarPrincipalAhora] allows it.
 ///
 /// This function's signature exposes ONLY the EQ persist/apply seams — it
 /// has NO parameter for `playMediaItem`, `mediaItem`, or `playbackState`, so
 /// there is no code path from a preset tap to playback (Design ADR-3,
 /// non-playback invariant enforced structurally, not by discipline). An
 /// unknown/stale [id] is a no-op: neither seam is invoked and no exception
 /// propagates (Spec "Unknown or stale preset id").
 Future<void> aplicarPresetPorMediaId(
  String id, {
  required List<PresetEcualizador> presets,
  required String? uuidActual,
  required Future<Set<String>> Function() clavesPorEmisora,
  required Future<void> Function(PresetEcualizador) persistirPrincipal,
  required Future<void> Function(PresetEcualizador) aplicar,
 }) async {
  final preset = resolverPresetEq(id, presets);
  if (preset == null) return;
  await persistirPrincipal(preset);
  if (debeAplicarPrincipalAhora(
    uuidActual: uuidActual,
    clavesPorEmisora: await clavesPorEmisora(),
  )) {
    await aplicar(preset);
  }
 }
 /// Local, cold-start-safe implementation of [FuenteEmisorasAuto] (Design
 /// "getChildren data source"). Reads favourites from SQLite and custom
 /// stations from the tolerant JSON file directly — both loadable without
@@ -13,6 +13,7 @@ import '../modelos/preset_ecualizador.dart';
 import 'controlador_reconexion.dart';
 import 'navegacion_auto.dart';
 import 'servicio_audio_session.dart';
 import 'servicio_ecualizador.dart';
 /// Estado de reproducción expuesto al UI.
 enum EstadoReproduccion {
@@ -737,6 +738,9 @@ class PluriWaveAudioHandler extends BaseAudioHandler
      if (parentMediaId == AudioService.browsableRootId) {
        return constructor.raiz();
      }
      if (parentMediaId == ConstructorArbolAuto.idEcualizador) {
        return constructor.presetsEq(PresetEcualizador.presets);
      }
      final fuente = _fuenteNavegacionGlobal;
      if (fuente == null) return const [];
      if (parentMediaId == ConstructorArbolAuto.idFavoritos) {
@@ -779,9 +783,27 @@ class PluriWaveAudioHandler extends BaseAudioHandler
    String mediaId, [
    Map<String, dynamic>? extras,
  ]) async {
    try {
      // EQ preset selection (Design ADR-3, Spec "EQ Preset Selection Applies
      // Without Disturbing Playback"): FIRST branch, unconditional `return`,
      // so an `eq_preset:` id can never fall through to the playback routing
      // below. `aplicarPresetPorMediaId`'s seams are EQ-only (persist +
      // apply) — there is no playback parameter to inject here.
      if (esPresetMediaId(mediaId)) {
        final servicio = ServicioEcualizador();
        await aplicarPresetPorMediaId(
          mediaId,
          presets: PresetEcualizador.presets,
          uuidActual: emisoraActual?.uuid,
          clavesPorEmisora: () async =>
              (await servicio.cargar()).porEmisora.keys.toSet(),
          persistirPrincipal: servicio.guardarPrincipal,
          aplicar: aplicarPreset,
        );
        return;
      }
      final fuente = _fuenteNavegacionGlobal;
      if (fuente == null) return;
    try {
      await reproducirPorMediaId(
        mediaId,
        fuente: fuente,
@@ -0,0 +1,93 @@
 # Apply Progress: android-auto-eq-presets
 **Mode**: Strict TDD
 **Batch**: First and only batch — all 21 tasks completed in one pass.
 ## Completed Tasks
 ### Phase 1: Foundation — media-id scheme + root folder
 - [x] 1.1 [RED] `esPresetMediaId` table test
 - [x] 1.2 [GREEN] `_prefijoPresetEq` const + `esPresetMediaId`
 - [x] 1.3 [RED] `raiz` test updated to `hasLength(4)` + last-position assertions
 - [x] 1.4 [GREEN] `idEcualizador` const + `raiz()` appends `Ecualizador` folder last
 - [x] 1.5 [RED] `itemPresetEq` test
 - [x] 1.6 [GREEN] `itemPresetEq`
 - [x] 1.7 [RED] `presetsEq` test
 - [x] 1.8 [GREEN] `presetsEq`
 ### Phase 2: Core Implementation — resolve, gate, orchestrate
 - [x] 2.1 [RED] `resolverPresetEq` table test
 - [x] 2.2 [GREEN] `resolverPresetEq` free function
 - [x] 2.3 [RED] `debeAplicarPrincipalAhora` table test
 - [x] 2.4 [GREEN] `debeAplicarPrincipalAhora` pure gate function
 - [x] 2.5 [RED] `aplicarPresetPorMediaId` known-preset gate-true/gate-false test
 - [x] 2.6 [RED] `aplicarPresetPorMediaId` unknown/stale-id no-op test
 - [x] 2.7 [RED] Structural non-playback invariant test (signature has no playback seam)
 - [x] 2.8 [GREEN] `aplicarPresetPorMediaId` orchestration
 ### Phase 3: Integration / Wiring
 - [x] 3.1 `getChildren` — `idEcualizador` branch returns `presetsEq(PresetEcualizador.presets)`
 - [x] 3.2 `playFromMediaId` — `eq_preset:` branch as first statement, unconditional `return`, wrapped in method's outer try/catch
 - [x] 3.3 Import check — `preset_ecualizador.dart` already imported; added new `servicio_ecualizador.dart` import (required, was not previously imported in this file)
 ### Phase 4: Testing / Verification
 - [x] 4.1 `flutter test test/servicios/navegacion_auto_test.dart` — 46/46 passing (independently re-run twice with default and compact reporters)
 - [x] 4.2 Grepped `test/` tree for other `raiz()`/root-count assertions — only `navegacion_auto_test.dart` matches, confirmed
 - [x] 4.3 [DEVIATION] `flutter build`/`run`/`analyze`/`gen-l10n` NOT run (hangs in this environment, same precedent as prior change). Manual static review performed instead.
 ### Phase 5: Cleanup
 - [x] 5.1 [REFACTOR] Doc comments added referencing ADR-1/2/3/5 on all new public/free-function members; suite confirmed green after
 - [x] 5.2 Active-preset indication — confirmed out of scope per ADR-6, no code added (tracking-only task)
 ## Files Changed
 | File | Action | What Was Done |
 |------|--------|----------------|
 | `lib/servicios/navegacion_auto.dart` | Modified | Added `_prefijoPresetEq` const, `esPresetMediaId`, `ConstructorArbolAuto.idEcualizador`, `raiz()` now returns 4 folders (Ecualizador last), `itemPresetEq`, `presetsEq`, free functions `resolverPresetEq`, `debeAplicarPrincipalAhora`, `aplicarPresetPorMediaId` |
 | `lib/servicios/servicio_audio.dart` | Modified | `getChildren` gains `idEcualizador` branch (before `fuente` guard); `playFromMediaId` restructured — single outer try/catch, `eq_preset:` branch first with unconditional return; added `servicio_ecualizador.dart` import |
 | `test/servicios/navegacion_auto_test.dart` | Modified | Updated `raiz` test to `hasLength(4)`; added groups for `esPresetMediaId`, `itemPresetEq`, `presetsEq`, `resolverPresetEq`, `debeAplicarPrincipalAhora`, `aplicarPresetPorMediaId` (4 tests including structural non-playback invariant) |
 ## TDD Cycle Evidence
 | Task | Test File | Layer | Safety Net | RED | GREEN | TRIANGULATE | REFACTOR |
 |------|-----------|-------|------------|-----|-------|-------------|----------|
 | 1.1/1.2 | `navegacion_auto_test.dart` | Unit | ✅ 34/34 (pre-existing baseline) | ✅ Written | ✅ Passed | ✅ 5 cases (table) | ➖ None needed |
 | 1.3/1.4 | `navegacion_auto_test.dart` | Unit | ✅ (same file) | ✅ Written | ✅ Passed | ➖ Single (fixed 4-folder shape) | ➖ None needed |
 | 1.5/1.6 | `navegacion_auto_test.dart` | Unit | ✅ (same file) | ✅ Written | ✅ Passed | ➖ Single | ➖ None needed |
 | 1.7/1.8 | `navegacion_auto_test.dart` | Unit | ✅ (same file) | ✅ Written | ✅ Passed | ✅ 6 presets iterated | ➖ None needed |
 | 2.1/2.2 | `navegacion_auto_test.dart` | Unit | ✅ (same file) | ✅ Written | ✅ Passed | ✅ 3 negative cases + 1 positive | ➖ None needed |
 | 2.3/2.4 | `navegacion_auto_test.dart` | Unit | ✅ (same file) | ✅ Written | ✅ Passed | ✅ 3 cases (null/no-override/override) | ➖ None needed |
 | 2.5-2.8 | `navegacion_auto_test.dart` | Unit | ✅ (same file) | ✅ Written | ✅ Passed | ✅ 4 tests (gate-true, gate-false, unknown-id, structural) | ✅ Clean (extracted gate + resolve as separate pure fns) |
 | 3.1-3.3 | N/A (dispatch layer, zero coverage precedent per design baseline) | N/A | N/A (new branch in untested method) | N/A | N/A — manual review only, standard workflow per design's documented precedent | N/A | ➖ None needed |
 | 5.1 | `navegacion_auto_test.dart` | Unit | ✅ 46/46 (post-implementation) | N/A (doc-only) | ✅ Suite still green | N/A | ✅ Doc comments added |
 Note on Phase 3: `servicio_audio.dart`'s `getChildren`/`playFromMediaId` dispatch layer has zero existing test coverage (confirmed in tasks.md baseline — no `test/servicios/servicio_audio_test.dart` exists). This is a pre-existing condition, not something introduced here; the design explicitly names the pure `navegacion_auto.dart` functions as the load-bearing tested layer (ADR-3), with the handler wiring as thin, structurally-safe delegation. No RED/GREEN test cycle applies to Phase 3 tasks — they are direct wiring edits verified by (a) the full Phase 1-2 pure-function suite staying green, and (b) manual static review per task 4.3.
 ### Test Summary
 - **Total tests written**: 15 new test cases (1 esPresetMediaId table [5 sub-cases], 1 itemPresetEq, 1 presetsEq, 2 resolverPresetEq, 3 debeAplicarPrincipalAhora, 4 aplicarPresetPorMediaId, plus the updated raiz test)
 - **Total tests passing**: 46/46 in `test/servicios/navegacion_auto_test.dart` (34 pre-existing baseline + 12 new test blocks, some containing multiple sub-assertions/table cases) — independently re-confirmed via two separate `flutter test` invocations (default and `--reporter=compact`)
 - **Layers used**: Unit (46), Integration (0), E2E (0)
 - **Approval tests** (refactoring): None — no refactoring tasks; Phase 5.1 was pure doc-comment addition, verified via the full suite staying green
 - **Pure functions created**: 4 (`esPresetMediaId`, `resolverPresetEq`, `debeAplicarPrincipalAhora`, plus `itemPresetEq`/`presetsEq` as pure builders) — `aplicarPresetPorMediaId` is an orchestrator with injected seams, not fully pure, by design (ADR-3)
 ## Deviations from Design
 1. **`servicio_ecualizador.dart` import added to `servicio_audio.dart`** — not explicitly listed in task 3.3 (which only mentions verifying the `preset_ecualizador.dart` import), but required to instantiate `ServicioEcualizador()` per the design's data-flow pseudocode. This is a direct, unavoidable consequence of implementing 3.2 as specified — not a deviation from the design's intent, just an omission in the task's explicit file-diff enumeration.
 2. **`playFromMediaId` restructured to a single outer try/catch** (was: `fuente`-null guard outside try/catch, `reproducirPorMediaId` call inside try/catch). This was required because the design mandates the `eq_preset:` branch run BEFORE the `fuente`-null guard while still being covered by exception safety (Spec "Unknown or stale preset id": no unhandled exception may propagate). Functionally equivalent for the pre-existing `emisora:`/`grupo:` path — behavior for those ids is unchanged (the `fuente == null` check remains, just now inside the try block, and its `return` behavior on null is unaffected).
 No other deviations — implementation matches design (ADR-1 through ADR-6 all satisfied as specified).
 ## Issues Found
 None.
 ## Workload / PR Boundary
 - Mode: single PR (no chaining needed — actual diff came in at 339 insertions + 7 deletions = 346 changed lines, within the 300-420 forecast and under the 400-line budget)
 - Current work unit: N/A — single delivery, all tasks in one pass
 - Boundary: Starts from a clean baseline (34/34 pre-existing tests green) and ends with the full `Ecualizador` folder + preset-selection feature wired end-to-end, 46/46 tests green
 - Estimated review budget impact: Medium-low — under the 400-line reviewer budget; changes are additive (new branches alongside existing `emisora:`/`grupo:` dispatch, no restructuring of unrelated logic)
 ## Status
 21/21 tasks complete. Ready for sdd-verify.
@@ -0,0 +1,279 @@
 # Design: Android Auto EQ preset selection
 ## Context
 `android-auto-eq-presets` adds a browsable `Ecualizador` folder to the existing
 Android Auto media tree so a driver can apply one of the 6 fixed
 `PresetEcualizador.presets` from the car, without touching the phone and without
 interrupting the current station. This design was written against the CURRENT
 post-favorite-groups codebase (main, after `f368bcc`/`066fedb`), reading the
 live files — not an assumed older layout.
 Two facts from the code drive every decision below:
 - **`EstadoEcualizador` is a plain `ChangeNotifier`** (`lib/estado/estado_ecualizador.dart:28`)
  with NO `BuildContext`/widget-tree dependency — but it is created lazily by a
  `ChangeNotifierProvider.create:` and **may never build on a headless Android
  Auto bind**, exactly like `EstadoRadio` for browse. So the car path MUST NOT
  reach into it.
 - **The handler already owns a headless-safe EQ seam.**
  `PluriWaveAudioHandler.aplicarPreset` (`lib/servicios/servicio_audio.dart:580`)
  mutates only `_presetActual` and the native `_eq`; it NEVER touches `mediaItem`
  or `playbackState`. And `ServicioEcualizador.guardarPrincipal`
  (`lib/servicios/servicio_ecualizador.dart:129`) writes the same
  SharedPreferences key `eq_preset_principal_v1` (line 39) that the phone's
  `EstadoEcualizador.cargarPersistido()` reads. This is the working headless
  bridge Android Auto already uses for play/pause — we reuse it, we do not invent
  a parallel one.
 ## Goals / Non-Goals
 **Goals**
 - Browsable `Ecualizador` root folder listing the 6 presets by name.
 - `eq_preset:<nombre>` media-id scheme, intercepted in `playFromMediaId` BEFORE
  the `emisora:`/`grupo:` routing, applying + persisting the preset as principal.
 - Structural, testable guarantee that a preset tap NEVER disturbs current
  playback or now-playing metadata.
 - Headless-safe write path with eventual phone/car parity via SharedPreferences.
 **Non-Goals**
 - Live phone-UI refresh of the EQ screen while an Auto session mutates EQ
  (see ADR-4 — eventual parity only, by design).
 - Band-level / per-station / per-device / matrix EQ from the car.
 - A transport-button EQ action.
 - An accurate "currently-selected" checkmark on preset rows (ADR-6, scoped out).
 ## Architecture Approach
 Mirror the proven `emisora:`/`grupo:` interception pattern already in this
 capability: **pure, injectable free functions in `navegacion_auto.dart`** do all
 the logic; the untested `PluriWaveAudioHandler` dispatch layer stays a thin
 3-line delegation. This is the same shape as the existing
 `reproducirPorMediaId` free function (`navegacion_auto.dart:267`) — a driver
 tap routes through `playFromMediaId`, which delegates to a fully unit-testable
 function with injected seams and no platform dependency.
 The tree-building additions live in the existing pure `ConstructorArbolAuto`
 class next to `raiz()`/`itemEmisora`/`itemGrupo`.
 ### Component map
 | Component | Location | Kind | Responsibility |
 |-----------|----------|------|----------------|
 | `_prefijoPresetEq = 'eq_preset:'` | `navegacion_auto.dart` (top-level const, next to `_prefijoEmisora`) | new const | Single source of the id prefix, shared by builder + free functions |
 | `ConstructorArbolAuto.idEcualizador = 'ecualizador'` | `navegacion_auto.dart` | new const | Root folder id for the EQ folder |
 | `ConstructorArbolAuto.raiz()` | `navegacion_auto.dart:152` | modified | Append the `Ecualizador` folder as the LAST root entry (ADR-2) |
 | `ConstructorArbolAuto.itemPresetEq(PresetEcualizador)` | `navegacion_auto.dart` | new | Map a preset → `playable:true` leaf `MediaItem` id `eq_preset:<nombre>` |
 | `ConstructorArbolAuto.presetsEq(List<PresetEcualizador>)` | `navegacion_auto.dart` | new | The 6 preset leaf items for the Ecualizador folder |
 | `esPresetMediaId(String)` | `navegacion_auto.dart` | new free fn | Pure routing predicate: id starts with `eq_preset:` |
 | `resolverPresetEq(String id, List<PresetEcualizador>)` | `navegacion_auto.dart` | new free fn | Exact-name resolve; `null` for unknown/empty (no throw) |
 | `debeAplicarPrincipalAhora({uuidActual, clavesPorEmisora})` | `navegacion_auto.dart` | new pure fn | Mirrors `cambiarPresetPrincipal` apply gate (ADR-5) |
 | `aplicarPresetPorMediaId(...)` | `navegacion_auto.dart` | new free fn | Orchestrates resolve → persist principal → conditional native apply, via injected seams ONLY (ADR-3/ADR-4) |
 | `PluriWaveAudioHandler.getChildren` | `servicio_audio.dart:731` | modified | New branch: `parentMediaId == idEcualizador` → `constructor.presetsEq(...)` |
 | `PluriWaveAudioHandler.playFromMediaId` | `servicio_audio.dart:778` | modified | New `eq_preset:` branch BEFORE the fuente-null guard and playback routing; `return`s without falling through |
 | `test/servicios/navegacion_auto_test.dart:225` | test | modified | `raiz` length assertion 3 → 4 (breaks otherwise) |
 ### Data flow — a preset tap
 ```
 Car head unit: driver taps "Rock" in the Ecualizador folder
  -> MediaBrowserService delivers eq_preset:Rock
  -> PluriWaveAudioHandler.playFromMediaId("eq_preset:Rock")
       if esPresetMediaId(id):                         // NEW, first branch
         servicio = ServicioEcualizador()              // headless-safe (SP)
         await aplicarPresetPorMediaId(
           "eq_preset:Rock",
           presets:            PresetEcualizador.presets,
           uuidActual:         emisoraActual?.uuid,
           clavesPorEmisora:   () async => (await servicio.cargar()).porEmisora.keys.toSet(),
           persistirPrincipal: servicio.guardarPrincipal,   // -> SP key eq_preset_principal_v1
           aplicar:            aplicarPreset,               // -> native _eq, NOT playback
         )
         return;                                       // NEVER reaches playback
  -> aplicarPresetPorMediaId:
       preset = resolverPresetEq(id, presets)          // "Rock" | null
       if preset == null: return                       // unknown/stale -> no-op
       await persistirPrincipal(preset)                // durable parity
       if debeAplicarPrincipalAhora(uuidActual, keys): // ADR-5 gate
         await aplicar(preset)                          // live native gains
 ```
 Phone side (later): `EstadoEcualizador.cargarPersistido()` reads
 `eq_preset_principal_v1` → `_presetPrincipal = Rock`. Native sound was already
 Rock live. Parity achieved (eventual — ADR-4).
 ### Integration points
 - **Root tree shape changes 3 → 4 folders.** The base spec scenario "Car
  requests the root … returns three folder `MediaItem`s" becomes four
  (Favoritos, Todas las emisoras, Mis emisoras, Ecualizador). This is a spec
  delta for `sdd-spec` to record, and `navegacion_auto_test.dart:225` must move
  from `hasLength(3)` to `hasLength(4)`.
 - **`getChildren` gains one branch** for `idEcualizador`; it needs NO data
  source (`_fuenteNavegacionGlobal`) because the preset list is a compile-time
  constant, so it is placed before the `fuente == null` guard's dependents.
 - **`playFromMediaId` gains one branch** placed FIRST (before the `fuente ==
  null` guard) so EQ works even if the browse source was never registered.
 - **`ServicioEcualizador` instantiation** inside the handler branch self-resolves
  SharedPreferences via `getInstance()` (its `_prefs` fallback), matching how
  `FuenteEmisorasAutoLocal` defaults its own `ServicioFavoritos()`.
 ## Decisions (ADR-style)
 ### ADR-1 — Media-id scheme `eq_preset:<nombre>`
 **Decision.** New top-level prefix `eq_preset:`; the leaf id is
 `eq_preset:` + the preset's exact `nombre` (e.g. `eq_preset:Bass Boost`).
 Resolution is exact-name match against `PresetEcualizador.presets`.
 **Why.** Collision-free against every existing id shape: `emisora:` (leaf),
 `grupo:` (folder), and the bare folder constants `favoritos` / `todas` /
 `mis_emisoras` / the new `ecualizador`. Preset names are the natural stable key
 (there are only 6 fixed presets, names are unique and constant). Spaces in
 `Bass Boost` are inert in a `MediaItem.id` string.
 **Rejected.** Index-based ids (`eq_preset:3`) — brittle against any future
 reordering of the fixed list and unreadable in logs; name is self-describing and
 matches how the phone identifies a preset.
 ### ADR-2 — `Ecualizador` folder placed LAST at the root
 **Decision.** `raiz()` returns `[Favoritos, Todas las emisoras, Mis emisoras,
 Ecualizador]` — EQ last.
 **Why.** Content-browsing folders are the primary car task and stay first;
 `Ecualizador` is a settings-like tool, not content. Trailing placement matches
 head-unit conventions (tools after content) and minimizes the chance a driver
 lands in it by accident while reaching for stations.
 **Rejected.** First/second position — would push the driver's primary target
 (favorites/stations) down and read as if EQ were content.
 ### ADR-3 — Non-playback invariant enforced structurally, not by discipline
 **Decision.** The EQ orchestration lives in the free function
 `aplicarPresetPorMediaId`, whose signature exposes ONLY two side-effect seams:
 `persistirPrincipal` and `aplicar`. It has NO parameter for `playMediaItem`,
 `mediaItem`, or `playbackState`, so there is literally no code path from a preset
 tap to playback. In `playFromMediaId` the `eq_preset:` branch is FIRST and
 `return`s, so it can never fall through to `reproducirPorMediaId`.
 **What is touched by a preset tap:** `_presetActual` (via `aplicarPreset`), the
 native `AndroidEqualizer` band gains, and the SharedPreferences key
 `eq_preset_principal_v1`. **What is NOT touched:** `mediaItem` (never `.add`-ed),
 `playbackState` (never `copyWith`-ed), `_player`, `emisoraActual`,
 `_intencionReproducir`, the reconnect machine. A station that is playing keeps
 playing; a stopped handler stays stopped.
 **How a test asserts "playback undisturbed":**
 1. *Primary (structural, pure):* a unit test drives `aplicarPresetPorMediaId`
   with spy seams and asserts `aplicar` and `persistirPrincipal` each fire once
   with the resolved preset — and that the function cannot reference any playback
   seam because none is injected. The invariant is guaranteed by construction,
   not by a runtime observation that could regress.
 2. *Routing:* `esPresetMediaId('eq_preset:Rock')` is `true` and
   `esPresetMediaId('emisora:uuid')` is `false`, proving an `eq_preset:` id is
   diverted before ever reaching `reproducirPorMediaId`.
 3. *Handler-level (opportunistic):* if a fake-backed handler test is added, snapshot
   `handler.mediaItem.value` and subscribe to `handler.mediaItem` before the tap,
   then assert the value is identical and NO new event was emitted after
   `playFromMediaId('eq_preset:Rock')`. This is a belt-and-suspenders check on top
   of the structural guarantee; the dispatch layer's zero-coverage reality means
   (1) is the load-bearing assertion.
 **Why.** The proposal's top risk is a preset tap looking like "now playing a new
 track." Enforcing the invariant in the type/seam shape (not in a comment or a
 reviewer's vigilance) is the strongest possible mitigation in a dispatch layer
 with no execution coverage.
 ### ADR-4 — Headless persistence seam: handler + service, NOT `EstadoEcualizador`
 **Decision.** The car write path is `ServicioEcualizador.guardarPrincipal`
 (SharedPreferences `eq_preset_principal_v1`) + `PluriWaveAudioHandler.aplicarPreset`
 (native gains). It does NOT call `EstadoEcualizador.cambiarPresetPrincipal`.
 Phone/car parity is **eventual**: the phone's `EstadoEcualizador` reflects the
 car's choice on its next `cargarPersistido()` (init / reload). The native sound
 and the handler's live `_presetActual` update immediately.
 **Why.** Confirmed by reading the class: `EstadoEcualizador` is a plain
 `ChangeNotifier` (no `BuildContext`), BUT it is provider-created and may never
 exist on a headless Auto bind — the same reason this capability already built
 `FuenteEmisorasAutoLocal` instead of reaching into `EstadoRadio` for browse.
 Reaching a possibly-null widget-tree object from the headless handler would be
 fragile. Both surfaces already converge on TWO shared authorities the handler
 owns headlessly: the SharedPreferences key (durable) and the handler's
 `aplicarPreset`/`_presetActual` (live native). The phone writes to the exact
 same key on `cambiarPresetPrincipal` → `guardarPrincipal`, so phone→car parity is
 already there symmetrically.
 **Live phone-UI refresh is explicitly OUT of scope.** Pushing a car change into a
 live `EstadoEcualizador._presetPrincipal` would require a NEW handler→state
 registration bridge (there is no existing EQ listener to reuse — the only
 existing bridges are `registrarHandler` and `registrarFuenteNavegacion`, neither
 of which carries EQ state). The dominant real scenario (phone headless or not on
 the EQ screen while the driver uses the head unit) makes live refresh low value
 against real added surface + a widget-tree wiring change. Eventual consistency on
 next foreground load is the accepted behavior for this iteration.
 **Rejected.** (a) Calling `EstadoEcualizador` directly — may not exist headless.
 (b) Adding a live sync bridge now — new surface, widget-tree wiring, marginal
 value while driving; revisit only if a concrete need appears.
 ### ADR-5 — Mirror `cambiarPresetPrincipal` per-station apply semantics
 **Decision.** `aplicarPresetPorMediaId` always persists the principal, but only
 applies it to the native EQ live when `debeAplicarPrincipalAhora` is true:
 `uuidActual == null` (no station playing) OR the current station has no
 per-station preset override (`!clavesPorEmisora.contains(uuidActual)`). This is
 the exact gate `EstadoEcualizador.cambiarPresetPrincipal` uses
 (`estado_ecualizador.dart:302-307`).
 **Why.** The car is just another button for the SAME "change the global preset"
 action; it must obey the same rules as the phone so the two surfaces never
 diverge. If the driver's current station has a deliberately-set per-station
 preset, changing the GLOBAL preset from the car should not silently blow away
 that override's live sound — identical to phone behavior. The gate decision is a
 PURE function (`uuid + key set → bool`), fully unit-testable, so the parity logic
 is covered even though the handler dispatch is not. The one extra
 `servicio.cargar()` read per tap is negligible for an occasional manual action.
 **Rejected.** Unconditional live apply — thinner, but diverges from the phone in
 the per-station-override case and would momentarily override a preset the user
 deliberately pinned (it reasserts on next station switch anyway, so the divergence
 is pure inconsistency with no upside).
 ### ADR-6 — Active-preset marker scoped OUT this iteration
 **Decision.** Preset rows carry the plain preset name, no "selected" marker.
 **Why.** The legacy `MediaBrowserService` model has no per-row selected
 affordance, so the only option is a title-text prefix (e.g. `● Rock`). But the
 browse tree is NOT re-queried after an `eq_preset:` tap (this path deliberately
 does no `notifyChildrenChanged` — it must not touch playback/tree state), so a
 prefix marker would go stale the instant the driver picks a different preset and
 would actively lie about the current state. A marker that lies is worse than no
 marker. Ship clean rows; revisit only if a reliable tree-refresh trigger is added.
 ## Risks / Open Questions
 - **Root tree 3 → 4 folders is a base-spec delta.** `sdd-spec` must update the
  "Car requests the root" scenario, and `navegacion_auto_test.dart:225`
  (`hasLength(3)`) must become `hasLength(4)` in the same change or the suite
  breaks. Flagged, low risk (mechanical).
 - **Eventual (not live) phone parity** (ADR-4) — accepted limitation. Risk: a
  user with the EQ screen open on the phone AND browsing Auto EQ simultaneously
  sees a stale principal until reload. Judged low-value corner; documented, not
  fixed.
 - **`servicio.cargar()` on each tap** triggers `migrarClavesPlaceholder()` — a
  guarded one-time no-op after first run; negligible cost, no correctness risk.
 - **Shared-file merge drift** with the just-shipped favorite-groups work is the
  main integration hazard; this design adds branches ALONGSIDE the existing
  `grupo:`/`emisora:` dispatch in the two shared files rather than restructuring
  them, keeping the diff additive and the rollback a clean revert.
 ## Migration / Rollback
 Additive only — no schema/migration. Reverting the feature commits removes the
 `Ecualizador` folder, the `eq_preset:` branch, and the tree helpers, restoring the
 exact prior tree; the SharedPreferences key `eq_preset_principal_v1` is the
 pre-existing phone key and is untouched structurally.
@@ -0,0 +1,67 @@
 # Proposal: Android Auto EQ preset selection
 ## Intent
 Drivers cannot change the audio equalizer while on Android Auto — EQ selection is phone-UI only today. Expose the 6 fixed presets as a browsable folder in the existing Auto media tree so a preset can be applied from the car, without reaching for the phone and without interrupting the current station.
 ## Scope
 ### In Scope
 - New top-level browsable `Ecualizador` folder in `ConstructorArbolAuto.raiz()`, listing the 6 fixed `PresetEcualizador.presets` by name.
 - New media-id scheme `eq_preset:<nombre>`, intercepted in `playFromMediaId` BEFORE the `emisora:`/`grupo:` routing.
 - Tapping a preset applies it through the existing headless-safe EQ seam and persists it as the principal preset (phone/car parity), with NO call to `playMediaItem` and NO `mediaItem` mutation.
 - Strict-TDD tests: tree shape, `eq_preset:` id resolution, and the "preset tap does not disturb playback / now-playing" invariant.
 - Optional (lower priority): mark the active preset in its row title (see Risks — no native selection UI exists in this model).
 ### Out of Scope
 - Custom band-level EQ editing or arbitrary EQ from the car (media-browser capability ceiling; stays phone-only).
 - Per-station / per-device / matrix EQ writes from the car (global principal only).
 - Custom transport-button EQ actions (button real-estate fits ~1-2 slots, not 6 named presets).
 - Favorite-groups browse work (separate, already-shipped `android-auto-favorite-groups`).
 ## Capabilities
 ### New Capabilities
 - None
 ### Modified Capabilities
 - `android-auto-media`: the browse tree gains an `Ecualizador` root folder plus an `eq_preset:` selection action that applies an EQ preset without starting or altering playback.
 ## Approach
 Mirror the proven `emisora:`/`grupo:` interception pattern already in `navegacion_auto.dart` + `servicio_audio.dart`. Preset rows are `playable: true` (the only tappable non-folder item type in the legacy `MediaBrowserService` model) and therefore route through `playFromMediaId`; a new `eq_preset:` branch resolves the preset by name and calls the EQ apply seam instead of the audio player. Reuse the phone's global-preset semantics (apply via `PluriWaveAudioHandler.aplicarPreset` + persist via `ServicioEcualizador.guardarPrincipal`, matching `cambiarPresetPrincipal`) so phone and car stay in sync. The write path MUST be headless-safe (handler + service, NOT the widget-tree `EstadoEcualizador`, which may never build on an Auto bind).
 ## Affected Areas
 | Area | Impact | Description |
 |------|--------|-------------|
 | `lib/servicios/navegacion_auto.dart` | Modified | Add `Ecualizador` root folder, `eq_preset:` id scheme, preset-row builder, resolver + selection routing helper |
 | `lib/servicios/servicio_audio.dart` | Modified | Branch `playFromMediaId` on `eq_preset:` to the apply/persist seam before `emisora:`/`grupo:` |
 | `lib/modelos/preset_ecualizador.dart` | Read-only | Source of the 6 fixed presets (name is the id key) |
 | `lib/servicios/servicio_ecualizador.dart` | Read-only reuse | `guardarPrincipal` persistence seam (headless-safe) |
 | `openspec/specs/android-auto-media/spec.md` | Delta only | Modified-capability delta in this change folder; base spec untouched |
 ## Risks
 | Risk | Likelihood | Mitigation |
 |------|------------|------------|
 | Preset tap looks like "now playing a new track" (playable item) | Med | Never call `playMediaItem`, never mutate `mediaItem`; dedicated `eq_preset:` branch + invariant test |
 | Shared-file merge drift with just-shipped favorite-groups | Med | Read CURRENT post-`f368bcc`/`066fedb` state; add branch alongside existing `grupo:`/`emisora:` dispatch |
 | No native "selected" UI for browsable rows | High | Active-preset marker only via title text (prefix); ship as optional, be explicit it is not a real checkmark |
 | Persist path unavailable on headless Auto bind | Med | Route through service + handler (SharedPreferences), not `EstadoEcualizador` |
 ## Rollback Plan
 Additive only — revert the feature commits. No schema/migration changes: removing the `Ecualizador` folder and the `eq_preset:` branch restores the exact prior tree (favorite-groups behavior unaffected).
 ## Dependencies
 - Sequenced after `android-auto-favorite-groups` (now on main) to avoid conflicts in the two shared files.
 ## Success Criteria
 - [ ] `Ecualizador` folder appears at the Auto root with all 6 presets by name.
 - [ ] Tapping a preset applies it (native EQ gains change) and persists as principal.
 - [ ] Current station playback / now-playing metadata is unchanged by a preset tap.
 - [ ] Selecting a preset in the car is reflected in the phone EQ UI and vice versa.
 - [ ] Unknown/stale `eq_preset:` id is a no-op (no throw).
@@ -0,0 +1,115 @@
 # Delta for android-auto-media
 ## MODIFIED Requirements
 ### Requirement: Browsable Media Tree
 `getChildren` MUST return a browsable tree rooted at `AudioService.browsableRootId`, organized into non-playable folders (Favoritos, Todas las emisoras, Mis emisoras, Ecualizador) containing playable items. Playable station items SHOULD carry an audio-quality subtitle when known. The `Favoritos` folder additionally MAY contain non-playable favorite-group sub-folders; `Todas las emisoras` and `Mis emisoras` remain flat. The `Ecualizador` folder is flat, non-playable, and contains only the 6 fixed EQ preset items (see "EQ Preset Browsable Folder").
 (Previously: root contained exactly 3 folders — Favoritos, Todas las emisoras, Mis emisoras — with no EQ folder.)
 #### Scenario: Car requests the root
 - GIVEN the car head unit connects and requests the root (`AudioService.browsableRootId`)
 - WHEN `getChildren` is called with the root id
 - THEN it returns four folder `MediaItem`s (Favoritos, Todas las emisoras, Mis emisoras, Ecualizador), each with `playable: false`
 #### Scenario: Car requests a folder with no stations
 - GIVEN the user has zero favorite stations
 - WHEN `getChildren` is called with the Favoritos folder id
 - THEN it returns an empty list, not an error
 #### Scenario: Browse requested before app state is loaded
 - GIVEN the audio handler starts cold and station/favorites Provider state has not finished loading
 - WHEN `getChildren` is called (root or any folder)
 - THEN it returns a valid, possibly empty, list without throwing and without blocking or crashing the service
 #### Scenario: Station has known codec and bitrate
 - GIVEN a station's `Emisora.codec` and `Emisora.bitrate` are both known
 - WHEN it is mapped to a playable `MediaItem`
 - THEN `displaySubtitle` SHALL contain a human-readable quality hint (e.g. "128 kbps · MP3")
 #### Scenario: Station has unknown codec or bitrate
 - GIVEN a station's `Emisora.codec` or `Emisora.bitrate` is null/unknown
 - WHEN it is mapped to a playable `MediaItem`
 - THEN `displaySubtitle` SHALL omit the quality hint gracefully, never rendering literal placeholder text
 #### Scenario: Ungrouped station appears exactly as before (regression guard)
 - GIVEN a station's `Emisora.grupoFavoritosId` equals `GrupoFavoritos.sinAsignarId`
 - WHEN the `Favoritos`, `Todas las emisoras`, or `Mis emisoras` folders are browsed
 - THEN that station appears as a playable `emisora:<uuid>` item in the same folder(s), position, title, art, and subtitle as before this change
 - AND its presence and shape are unaffected by the new `Ecualizador` folder
 ## ADDED Requirements
 ### Requirement: EQ Preset Browsable Folder
 The Android Auto browse tree MUST expose the 6 fixed EQ presets (`PresetEcualizador.presets`) as playable items inside the `Ecualizador` root folder, each using a distinct `eq_preset:<nombre>` media-id scheme, separate from `emisora:<uuid>` and `grupo:<id>`.
 #### Scenario: Car requests the Ecualizador folder
 - GIVEN the `Ecualizador` folder id was returned under the root
 - WHEN `getChildren` is called with the `Ecualizador` folder id
 - THEN it returns exactly 6 playable `MediaItem`s, one per `PresetEcualizador.presets` entry, titled with the preset's name
 - AND each item's id is `eq_preset:<nombre>`, where `<nombre>` is that preset's unique name
 ### Requirement: EQ Preset Selection Applies Without Disturbing Playback
 Selecting an `eq_preset:<nombre>` item MUST apply that preset immediately through the headless-safe EQ seam (e.g. `PluriWaveAudioHandler.aplicarPreset`), via a branch in `playFromMediaId` intercepted BEFORE the `emisora:`/`grupo:` routing. It MUST NOT call `playMediaItem`, MUST NOT mutate the now-playing `mediaItem`, and MUST NOT start, stop, restart, or otherwise alter current playback or playback position.
 #### Scenario: User selects a preset while a station is playing
 - GIVEN a station is currently playing and projected to the car
 - WHEN the user taps an `eq_preset:<nombre>` item, resolved via `playFromMediaId`
 - THEN the matching preset is applied via the headless-safe apply seam
 - AND the currently playing station continues uninterrupted, with no change to playback position or now-playing metadata
 #### Scenario: User selects a preset while nothing is playing
 - GIVEN no station is currently playing
 - WHEN the user taps an `eq_preset:<nombre>` item
 - THEN the matching preset is applied via the headless-safe apply seam
 - AND no playback starts as a result of the selection
 #### Scenario: Unknown or stale preset id
 - GIVEN `playFromMediaId` receives an `eq_preset:<nombre>` id whose `<nombre>` matches no entry in the current `PresetEcualizador.presets`
 - WHEN resolution fails to find a matching preset
 - THEN the selection is a no-op: no preset is applied, no playback state changes, and no unhandled exception propagates from the handler
 ### Requirement: EQ Preset Persistence and Phone/Car Parity
 An EQ preset applied from the car MUST persist as the principal preset, with the same observable outcome as the phone's existing `ServicioEcualizador.guardarPrincipal`/`cambiarPresetPrincipal` path, and MUST be reflected on the phone. A principal preset changed on the phone MUST be observable from the car. The exact code path used to reach the headless-safe persistence seam from an Android Auto bind is deferred to `sdd-design`.
 #### Scenario: Preset applied from the car persists for the phone
 - GIVEN the user selects `eq_preset:<nombre>` from the car head unit
 - WHEN the selection is processed
 - THEN the preset is persisted as the principal preset
 - AND opening the phone's EQ UI afterward shows that preset as the active/principal preset
 #### Scenario: Preset applied from the phone is reflected for the car
 - GIVEN the user changes the principal preset from the phone UI
 - WHEN the car head unit subsequently observes EQ-related state through the browse/selection surface
 - THEN the car-observable state reflects the phone's most recently applied principal preset
 ### Requirement: Active Preset Indication (Optional)
 The system MAY indicate the active/principal preset within the `Ecualizador` folder's rows. Because the legacy `MediaBrowserService` browsable-item model has no native "selected item" affordance, any indication, if implemented, MUST be conveyed via a row `title` text convention (e.g. a marker prefix/suffix) rather than assuming a checkmark or selection icon exists. If a reliable title-text convention is too costly to maintain, this requirement MAY instead be satisfied by explicitly not implementing active-preset indication.
 #### Scenario: Active preset is indicated via title convention (if implemented)
 - GIVEN the currently applied principal preset is known when `Ecualizador`'s children are built
 - WHEN the design's chosen title-text convention is applied
 - THEN exactly one of the 6 preset rows' `title` carries the active-preset marker, uniquely identifying that preset among the 6
 #### Scenario: Active preset indication is out of scope (if not implemented)
 - GIVEN the design opts not to implement an active-preset marker
 - WHEN the `Ecualizador` folder's children are built
 - THEN all 6 preset rows are returned with their plain preset names, with no partial or inconsistent marking applied
@@ -0,0 +1,82 @@
 # Tasks: Android Auto EQ preset selection
 Strict TDD active for Dart layers. Behavioral task = RED (failing test) -> GREEN
 (minimal impl) -> REFACTOR. `flutter build`/`flutter run`/`flutter analyze`/
 `flutter gen-l10n` MUST NOT be executed in this environment (hang) — marked
 **[DEVIATION]**, same precedent as
 `openspec/changes/archive/2026-07-19-android-auto-favorite-groups/tasks.md`.
 ## Review Workload Forecast
 | Field | Value |
 |-------|-------|
 | Estimated changed lines | 300-420 |
 | 400-line budget risk | Medium |
 | Chained PRs recommended | No |
 | Suggested split | Single PR; fallback 2-way split if apply exceeds budget: PR 1 = Phase 1-2 (pure builders/functions + tests), PR 2 = Phase 3-5 (handler wiring + cleanup) |
 | Delivery strategy | ask-on-risk (default, not overridden by caller) |
 | Chain strategy | pending |
 Decision needed before apply: No
 Chained PRs recommended: No
 Chain strategy: pending
 400-line budget risk: Medium
 ### Suggested Work Units
 | Unit | Goal | Likely PR | Notes |
 |------|------|-----------|-------|
 | 1 | Media-id scheme + pure builders/functions (Phase 1-2) + tests | PR 1 | Fully unit-testable, no handler dependency |
 | 2 | Handler wiring (Phase 3) + broken-assertion fix + verification (Phase 4-5) | PR 2 (fallback only) | Depends on Unit 1; only split out if diff runs over 400 |
 ## Baseline (verified against live code, not spec/design prose)
 - `lib/servicios/navegacion_auto.dart:13` — `_prefijoEmisora = 'emisora:'` top-level const; no `eq_preset:` prefix exists yet.
 - `lib/servicios/navegacion_auto.dart:119-256` `ConstructorArbolAuto` — `idFavoritos`/`idTodas`/`idMisEmisoras` (123-125), `_idsCarpetas` (127, do NOT add `idEcualizador` here — it needs its own dedicated branch, not the generic `hijos()` station path), `_prefijoGrupo` (132), `raiz()` (152-156, currently 3 folders), `_carpeta()` helper (158), `itemEmisora()` (181), `resolver()` (193), `esCarpetaGrupo()` (205), `itemGrupo()` (209).
 - `lib/servicios/servicio_audio.dart:731-761` `getChildren` — root check, then `fuente == null` guard, then `idFavoritos`/`esCarpetaGrupo`/default branches.
 - `lib/servicios/servicio_audio.dart:778-798` `playFromMediaId` — `fuente == null` guard first, then delegates to `reproducirPorMediaId`; **zero existing test coverage** for this dispatch layer (no `test/servicios/servicio_audio_test.dart` exists).
 - `lib/servicios/servicio_audio.dart:183` `emisoraActual` — public field on `PluriWaveAudioHandler`, directly readable (no getter indirection needed for `uuidActual`).
 - `lib/servicios/servicio_audio.dart:580-601` `aplicarPreset` — headless-safe seam, touches only `_presetActual`/native EQ, never `mediaItem`/`playbackState`.
 - `lib/servicios/servicio_ecualizador.dart:129-132` `guardarPrincipal` — writes SP key `eq_preset_principal_v1` (line 39).
 - `lib/estado/estado_ecualizador.dart:295-310` `cambiarPresetPrincipal` — confirmed gate: `uuid == null || !_presetsEmisoraMap.containsKey(uuid)` (302-304) is the exact logic `debeAplicarPrincipalAhora` must mirror.
 - `lib/modelos/preset_ecualizador.dart:35` — `PresetEcualizador.presets` is exactly 6 fixed entries (Flat, Rock, Pop, Bass Boost, Jazz, Voz).
 - `test/servicios/navegacion_auto_test.dart:220-239` — `hasLength(3)` at line 225 and the 3-id `equals()` set at 229-233 both need updating; no other test file references root-folder count.
 ## Phase 1: Foundation — media-id scheme + root folder
 - [x] 1.1 [RED] `navegacion_auto_test.dart`: `esPresetMediaId` table — `'eq_preset:Rock'`→true, `'eq_preset:'`→true (prefix-only, resolves to null downstream), `'emisora:x'`/`'grupo:g1'`/`''`→false. *(Spec "EQ Preset Browsable Folder"; ADR-1)*
 - [x] 1.2 [GREEN] `navegacion_auto.dart`: add `_prefijoPresetEq = 'eq_preset:'` top-level const (next to `_prefijoEmisora`, line 13); `esPresetMediaId(id) => id.startsWith(_prefijoPresetEq)`.
 - [x] 1.3 [RED] `raiz` test (update existing `test/servicios/navegacion_auto_test.dart:220-239` group): `hasLength(3)` → `hasLength(4)`; id set gains `ConstructorArbolAuto.idEcualizador`; add explicit assertion that `raiz().last.id == ConstructorArbolAuto.idEcualizador` (ADR-2, last position) and `raiz().last.playable == false`.
 - [x] 1.4 [GREEN] `navegacion_auto.dart`: add `idEcualizador = 'ecualizador'` const (123-125 block, NOT added to `_idsCarpetas`); append `_carpeta(idEcualizador, 'Ecualizador')` as the last entry in `raiz()` (line 152-156).
 - [x] 1.5 [RED] `itemPresetEq` test — id `'eq_preset:<nombre>'`, `playable: true`, `title == preset.nombre`. *(Spec "Car requests the Ecualizador folder")*
 - [x] 1.6 [GREEN] `navegacion_auto.dart`: `itemPresetEq(preset) => MediaItem(id: '$_prefijoPresetEq${preset.nombre}', title: preset.nombre, playable: true, extras: _contentStyleGrid)`.
 - [x] 1.7 [RED] `presetsEq` test — given `PresetEcualizador.presets`, returns exactly 6 items, one per preset, ids/titles match. *(Spec scenario "Car requests the Ecualizador folder")*
 - [x] 1.8 [GREEN] `navegacion_auto.dart`: `presetsEq(presets) => presets.map(itemPresetEq).toList()`.
 ## Phase 2: Core Implementation — resolve, gate, orchestrate
 - [x] 2.1 [RED] `resolverPresetEq` table — known name → matching preset; unknown name / empty-after-prefix / non-`eq_preset:` id → `null`, no throw. *(Spec "Unknown or stale preset id")*
 - [x] 2.2 [GREEN] `navegacion_auto.dart`: `resolverPresetEq(id, presets)` — guard `esPresetMediaId`, strip prefix, empty→null, exact-name loop match→preset else null (mirrors `resolver()` shape, line 193).
 - [x] 2.3 [RED] `debeAplicarPrincipalAhora` table — `uuidActual: null`→true; `uuidActual` not in `clavesPorEmisora`→true; `uuidActual` in `clavesPorEmisora`→false. *(ADR-5, mirrors `estado_ecualizador.dart:302-304`)*
 - [x] 2.4 [GREEN] `navegacion_auto.dart`: pure `debeAplicarPrincipalAhora({uuidActual, clavesPorEmisora}) => uuidActual == null || !clavesPorEmisora.contains(uuidActual)`.
 - [x] 2.5 [RED] `aplicarPresetPorMediaId` — known preset: `persistirPrincipal` called once with resolved preset; `aplicar` called once when gate is true; `aplicar` NOT called when gate is false (per-station override case). *(ADR-3, ADR-5)*
 - [x] 2.6 [RED] `aplicarPresetPorMediaId` — unknown/stale id: neither `persistirPrincipal` nor `aplicar` is invoked, function returns without throwing. *(Spec "Unknown or stale preset id")*
 - [x] 2.7 [RED] Structural invariant test — assert `aplicarPresetPorMediaId`'s signature exposes ONLY `persistirPrincipal`/`aplicar`/`uuidActual`/`clavesPorEmisora` seams (no `playMediaItem`/`mediaItem`/`playbackState` parameter exists to inject); document this as the load-bearing non-playback proof per ADR-3.
 - [x] 2.8 [GREEN] `navegacion_auto.dart`: implement `aplicarPresetPorMediaId(id, {required presets, required uuidActual, required Future<Set<String>> Function() clavesPorEmisora, required Future<void> Function(PresetEcualizador) persistirPrincipal, required Future<void> Function(PresetEcualizador) aplicar})` — resolve via `resolverPresetEq`; `null`→return; else `await persistirPrincipal(preset)`; `if (debeAplicarPrincipalAhora(uuidActual: uuidActual, clavesPorEmisora: await clavesPorEmisora())) await aplicar(preset);`. Satisfies 2.5-2.7.
 ## Phase 3: Integration / Wiring
 - [x] 3.1 `servicio_audio.dart:731-761` `getChildren`: insert `if (parentMediaId == ConstructorArbolAuto.idEcualizador) return constructor.presetsEq(PresetEcualizador.presets);` immediately after the root-id check and BEFORE `final fuente = _fuenteNavegacionGlobal;` (no data source needed — compile-time constant list, per design's Integration Points).
 - [x] 3.2 `servicio_audio.dart:778-798` `playFromMediaId`: insert an `esPresetMediaId(mediaId)` branch as the FIRST statement in the method body, BEFORE `final fuente = _fuenteNavegacionGlobal; if (fuente == null) return;`. Branch body: `final servicio = ServicioEcualizador(); await aplicarPresetPorMediaId(mediaId, presets: PresetEcualizador.presets, uuidActual: emisoraActual?.uuid, clavesPorEmisora: () async => (await servicio.cargar()).porEmisora.keys.toSet(), persistirPrincipal: servicio.guardarPrincipal, aplicar: aplicarPreset); return;` — wrapped in the method's existing outer try/catch so an unexpected failure still never propagates (Spec "Unknown or stale preset id"). *(ADR-3: FIRST branch + unconditional `return` means it can never fall through to `reproducirPorMediaId`.)*
 - [x] 3.3 Add `import '../modelos/preset_ecualizador.dart';` to `servicio_audio.dart` if not already present (check before adding — `aplicarPreset`'s existing signature at line 580 already takes `PresetEcualizador`, so the import likely already exists; verify, do not duplicate).
 ## Phase 4: Testing / Verification
 - [x] 4.1 Run `flutter test test/servicios/navegacion_auto_test.dart` — full green, including the updated `hasLength(4)` root test. (46/46 passing, independently re-run twice.)
 - [x] 4.2 Grep the full `test/` tree for any other `raiz()`/root-folder-count assertions outside `navegacion_auto_test.dart` (baseline found none as of this writing — confirm still true before merge). Confirmed: only `navegacion_auto_test.dart` matches.
 - [x] 4.3 [DEVIATION] `flutter build`/`flutter run`/`flutter analyze`/`flutter gen-l10n` — DO NOT RUN in this environment (hangs). Manual static review instead: no unused symbols, `eq_preset:` prefix non-colliding with `emisora:`/`grupo:`/bare folder ids by inspection, `playFromMediaId`'s new branch returns unconditionally with no fallthrough. Real run recommended before merge/CI.
 ## Phase 5: Cleanup
 - [x] 5.1 [REFACTOR] `navegacion_auto.dart`: doc-comment new public members per the file's existing Design-decision-linking style (reference ADR-1/2/3/5); confirm full test suite still green. All new symbols carry ADR-linked doc comments; code was already clean at GREEN — no further extraction needed.
 - [x] 5.2 Active-preset indication (Spec "Active Preset Indication (Optional)", ADR-6): OUT OF SCOPE for this change by design decision — preset rows carry plain names only, no marker. No task implements it; this line exists so the requirement isn't silently dropped from tracking.
@@ -0,0 +1,117 @@
 # Verification Report: android-auto-eq-presets
 **Mode**: Strict TDD | **Verdict**: PASS
 ## Completeness
 All 21 tasks in `tasks.md` (Phases 1-5) are checked complete and match the live code. No task marked complete lacks a corresponding code/test change.
 ## Test Execution Evidence (independently re-run, not trusted from apply-progress)
 | Command | Result |
 |---|---|
 | `flutter test test/servicios/navegacion_auto_test.dart --concurrency=1 --timeout=60s` (compact reporter) | 46/46 passed |
 | Same file, `-r json`, counted `testDone` events | 46 (independently confirmed via JSON reporter, not just trusting the compact-reporter tally) |
 | `flutter test test/estado/estado_radio_test.dart --concurrency=1 --timeout=60s` (favorite-groups regression suite, shared `playFromMediaId`/dispatch surface) | 22/22 passed (JSON `testDone` count also 22) |
 Apply-progress's claimed 46/46 for `navegacion_auto_test.dart` is accurate. The extra regression pass on `estado_radio_test.dart` (not part of apply-progress's own claims) also passes clean - no regression on the favorite-groups feature that shares the touched dispatch surface.
 ## Load-Bearing Invariant: EQ selection never disturbs playback
 Traced `playFromMediaId` (`lib/servicios/servicio_audio.dart:781-820`) directly in the live file:
 - The `esPresetMediaId(mediaId)` branch is the first statement inside the (now single) outer `try`, before `_fuenteNavegacionGlobal` is even read.
 - It ends with an unconditional `return;` - genuinely cannot fall through to `reproducirPorMediaId`/`playMediaItem`.
 - No `mediaItem` mutation, no `play()`/`setUrl()`/reconnect call anywhere in that branch - only `ServicioEcualizador()` construction and `aplicarPresetPorMediaId(...)`.
 Traced `aplicarPresetPorMediaId`'s actual signature (`lib/servicios/navegacion_auto.dart:364-371`, read directly, not from docstring):
 ```
 Future<void> aplicarPresetPorMediaId(
  String id, {
  required List<PresetEcualizador> presets,
  required String? uuidActual,
  required Future<Set<String>> Function() clavesPorEmisora,
  required Future<void> Function(PresetEcualizador) persistirPrincipal,
  required Future<void> Function(PresetEcualizador) aplicar,
 })
 ```
 Confirmed: no `playMediaItem`, `mediaItem`, or `playbackState` parameter exists - structurally impossible to inject a playback seam. This matches the docstring claim and the dedicated structural test (`navegacion_auto_test.dart:755-784`).
 ## Root Folder Count
 - `ConstructorArbolAuto.raiz()` (`lib/servicios/navegacion_auto.dart:171-176`) returns 4 folders, `Ecualizador` last, `playable: false`.
 - `test/servicios/navegacion_auto_test.dart:226` - `expect(raiz, hasLength(4))` - confirmed updated (line number shifted from the apply-progress's original estimate of 225 to 226 due to file growth, as anticipated by the reviewer's warning; content matches).
 - Line 241-242 additionally assert `raiz.last.id == idEcualizador` and `raiz.last.playable == false` (ADR-2 last-position + non-playable, beyond the base spec's minimum).
 - Grepped the full `test/` tree for other `raiz()`/root-count assertions: only `navegacion_auto_test.dart` matches - confirms task 4.2's claim.
 ## Persistence Seam
 Grepped both call sites in the diff:
 - `servicio_audio.dart:800` - `persistirPrincipal: servicio.guardarPrincipal` -> `ServicioEcualizador.guardarPrincipal` (`servicio_ecualizador.dart:129-132`, writes SharedPreferences key `eq_preset_principal_v1`).
 - No call to `EstadoEcualizador.cambiarPresetPrincipal` anywhere in the diff or the new code paths (confirmed via grep across `navegacion_auto.dart`/`servicio_audio.dart`).
 - Matches ADR-4 exactly: handler + service seam, not the phone's `ChangeNotifier`.
 ## debeAplicarPrincipalAhora Gate Parity
 Read both gates directly:
 - `estado_ecualizador.dart:302-304`: `uuid == null || !_presetsEmisoraMap.containsKey(uuid)`
 - `navegacion_auto.dart:348-351`: `uuidActual == null || !clavesPorEmisora.contains(uuidActual)`
 Also traced that `clavesPorEmisora` is populated from `servicio.cargar().porEmisora.keys`, and `servicio_ecualizador.dart`'s `cargar()` reads `porEmisora` from the same persisted per-station map that populates `EstadoEcualizador._presetsEmisoraMap` (`estado_ecualizador.dart:161-163`, `..addAll(config.porEmisora)`). The two gates are genuinely operating over the same underlying data, not just superficially similar in shape.
 ## Unknown/Stale Preset ID
 `resolverPresetEq` returns `null` for unknown name / empty-after-prefix / non-`eq_preset:` id (`navegacion_auto.dart:332-340`). `aplicarPresetPorMediaId` returns immediately on `null` without invoking either seam. Test (`navegacion_auto_test.dart:731-753`) asserts `persistirLlamadas == 0` and `aplicarLlamadas == 0` for `'eq_preset:Inexistente'` - the assertion is on call counts, not just a test name; genuinely proves the no-op.
 ## Active Preset Indication (Optional requirement)
 Confirmed OUT OF SCOPE as designed (ADR-6). Grepped `navegacion_auto.dart` for marker/selection-related terms - no half-built UI, no dead marker code, no leftover scaffolding. `itemPresetEq` emits only the plain preset name as `title`.
 ## Deviations Self-Reported by apply-progress.md - Verified
 1. servicio_ecualizador.dart import added to servicio_audio.dart, not listed in task 3.3's enumerated file list. Confirmed real: `git diff` shows `+import 'servicio_ecualizador.dart';` at the top of the file; task 3.3's text only mentions verifying the `preset_ecualizador.dart` import. This is a genuine (harmless) task-description gap, not a code defect.
 2. playFromMediaId restructured to a single outer try/catch. Confirmed real via `git diff`: previously `final fuente = _fuenteNavegacionGlobal; if (fuente == null) return;` sat OUTSIDE the try block; now both lines are inside the try, after the new `eq_preset:` branch. Behaviorally inert for the pre-existing `emisora:`/`grupo:` path - the null-check itself cannot throw, so moving it inside `try` changes nothing observable. Verified via the full `estado_radio_test.dart` (22/22) and `navegacion_auto_test.dart` (46/46, includes `reproducirPorMediaId` tests) suites, both green.
 ## Diff Size Cross-Check
 `git diff --stat` on the three touched files:
 ```
 lib/servicios/navegacion_auto.dart       |  94 ++++++++++++-
 lib/servicios/servicio_audio.dart        |  26 +++-
 test/servicios/navegacion_auto_test.dart | 226 ++++++++++++++++++++++++++++++-
 3 files changed, 339 insertions(+), 7 deletions(-)
 ```
 339 + 7 = 346 changed lines - matches apply-progress's self-reported figure exactly. Within the 300-420 forecast, under the 400-line budget.
 ## Cleanliness Checks
 - No AI attribution strings found in the diff (`Co-Authored-By`, `Generated with`, `Claude`, `ChatGPT`, etc. - none matched).
 - No stray `print`/`debugPrint` calls introduced.
 - No `TODO`/`FIXME` markers introduced.
 - No dead code found in the reviewed hunks.
 - Working tree: `navegacion_auto.dart`, `servicio_audio.dart`, `test/servicios/navegacion_auto_test.dart` are modified-but-unstaged; `openspec/changes/android-auto-eq-presets/` is untracked. Nothing has been committed - confirmed via `git log` (HEAD is still `066fedb`, predating this change) and `git status`.
 ## Spec Compliance Matrix
 | Spec Requirement | Status | Evidence |
 |---|---|---|
 | Browsable Media Tree (4 folders, Ecualizador included) | PASS | raiz() + test at line 226 |
 | EQ Preset Browsable Folder (6 items, eq_preset:<nombre>) | PASS | presetsEq/itemPresetEq + tests |
 | EQ Preset Selection Applies Without Disturbing Playback | PASS | Structural signature proof + first-branch/unconditional-return trace |
 | EQ Preset Persistence and Phone/Car Parity | PASS | guardarPrincipal call site confirmed, SP key shared with phone |
 | Active Preset Indication (Optional) | PASS (scoped out) | ADR-6, no half-built code |
 ## Design Coherence
 All 6 ADRs (ADR-1 through ADR-6) traced against live code - implementation matches design as documented. No undocumented deviation found beyond the two apply-progress already self-reported (both verified genuine and low-risk).
 ## Issues Found
 None CRITICAL. None WARNING. None SUGGESTION beyond a purely cosmetic note: apply-progress's line-number references (e.g. "225" vs actual "226") drift slightly as the file grows - informational only, does not affect correctness or task completeness.
 ## Final Verdict
 PASS - 0 CRITICAL, 0 WARNING, 0 SUGGESTION (one informational-only line-number drift note, not a defect).
@@ -2,6 +2,7 @@ import 'package:audio_service/audio_service.dart';
 import 'package:flutter_test/flutter_test.dart';
 import 'package:pluriwave/modelos/emisora.dart';
 import 'package:pluriwave/modelos/grupo_favoritos.dart';
 import 'package:pluriwave/modelos/preset_ecualizador.dart';
 import 'package:pluriwave/servicios/navegacion_auto.dart';
 void main() {
@@ -218,11 +219,11 @@ void main() {
  });
  group('ConstructorArbolAuto.raiz', () {
-    test('devuelve exactamente 3 carpetas no reproducibles con los ids '
+    test('devuelve exactamente 4 carpetas no reproducibles con los ids '
-        'esperados', () {
+        'esperados, terminando en Ecualizador', () {
      final raiz = ConstructorArbolAuto().raiz();
-      expect(raiz, hasLength(3));
+      expect(raiz, hasLength(4));
      final ids = raiz.map((item) => item.id).toSet();
      expect(
        ids,
@@ -230,12 +231,63 @@ void main() {
          ConstructorArbolAuto.idFavoritos,
          ConstructorArbolAuto.idTodas,
          ConstructorArbolAuto.idMisEmisoras,
          ConstructorArbolAuto.idEcualizador,
        }),
      );
      for (final item in raiz) {
        expect(item.playable, isFalse);
        expect(item.title, isNotEmpty);
      }
      expect(raiz.last.id, ConstructorArbolAuto.idEcualizador);
      expect(raiz.last.playable, isFalse);
    });
  });
  group('esPresetMediaId', () {
    test('reconoce ids con el prefijo eq_preset:, rechaza el resto', () {
      final casos = <String, bool>{
        'eq_preset:Rock': true,
        'eq_preset:': true,
        'emisora:x': false,
        'grupo:g1': false,
        '': false,
      };
      casos.forEach((id, esperado) {
        expect(
          esPresetMediaId(id),
          esperado,
          reason: 'esPresetMediaId($id) debería ser $esperado',
        );
      });
    });
  });
  group('ConstructorArbolAuto.itemPresetEq', () {
    test('mapea un PresetEcualizador a un item reproducible con id '
        'eq_preset:<nombre>', () {
      final item = ConstructorArbolAuto().itemPresetEq(
        PresetEcualizador.rock,
      );
      expect(item.id, 'eq_preset:${PresetEcualizador.rock.nombre}');
      expect(item.playable, isTrue);
      expect(item.title, PresetEcualizador.rock.nombre);
    });
  });
  group('ConstructorArbolAuto.presetsEq', () {
    test('devuelve exactamente 6 items reproducibles, uno por preset', () {
      final items = ConstructorArbolAuto().presetsEq(
        PresetEcualizador.presets,
      );
      expect(items, hasLength(6));
      for (var i = 0; i < items.length; i++) {
        expect(items[i].id, 'eq_preset:${PresetEcualizador.presets[i].nombre}');
        expect(items[i].title, PresetEcualizador.presets[i].nombre);
        expect(items[i].playable, isTrue);
      }
    });
  });
@@ -564,6 +616,174 @@ void main() {
    });
  });
  group('resolverPresetEq', () {
    test('resuelve un nombre conocido al preset exacto', () {
      final resultado = resolverPresetEq(
        'eq_preset:${PresetEcualizador.rock.nombre}',
        PresetEcualizador.presets,
      );
      expect(resultado, equals(PresetEcualizador.rock));
    });
    test(
      'devuelve null para nombre desconocido, id vacío-tras-prefijo o id sin '
      'prefijo eq_preset:, sin lanzar',
      () {
        expect(
          resolverPresetEq('eq_preset:Inexistente', PresetEcualizador.presets),
          isNull,
        );
        expect(
          resolverPresetEq('eq_preset:', PresetEcualizador.presets),
          isNull,
        );
        expect(
          resolverPresetEq('emisora:x', PresetEcualizador.presets),
          isNull,
        );
      },
    );
  });
  group('debeAplicarPrincipalAhora', () {
    test('true cuando no hay estación actual', () {
      expect(
        debeAplicarPrincipalAhora(
          uuidActual: null,
          clavesPorEmisora: const {'uuid-otra'},
        ),
        isTrue,
      );
    });
    test('true cuando la estación actual no tiene override por-emisora', () {
      expect(
        debeAplicarPrincipalAhora(
          uuidActual: 'uuid-sin-override',
          clavesPorEmisora: const {'uuid-otra'},
        ),
        isTrue,
      );
    });
    test('false cuando la estación actual tiene override por-emisora', () {
      expect(
        debeAplicarPrincipalAhora(
          uuidActual: 'uuid-con-override',
          clavesPorEmisora: const {'uuid-con-override'},
        ),
        isFalse,
      );
    });
  });
  group('aplicarPresetPorMediaId', () {
    test(
      'preset conocido: persiste siempre y aplica cuando el gate es true',
      () async {
        PresetEcualizador? persistido;
        PresetEcualizador? aplicado;
        await aplicarPresetPorMediaId(
          'eq_preset:${PresetEcualizador.rock.nombre}',
          presets: PresetEcualizador.presets,
          uuidActual: null,
          clavesPorEmisora: () async => <String>{},
          persistirPrincipal: (preset) async {
            persistido = preset;
          },
          aplicar: (preset) async {
            aplicado = preset;
          },
        );
        expect(persistido, equals(PresetEcualizador.rock));
        expect(aplicado, equals(PresetEcualizador.rock));
      },
    );
    test(
      'preset conocido con override por-emisora en la estación actual: '
      'persiste pero NO aplica en vivo (gate false)',
      () async {
        var persistirLlamadas = 0;
        var aplicarLlamadas = 0;
        await aplicarPresetPorMediaId(
          'eq_preset:${PresetEcualizador.jazz.nombre}',
          presets: PresetEcualizador.presets,
          uuidActual: 'uuid-con-override',
          clavesPorEmisora: () async => {'uuid-con-override'},
          persistirPrincipal: (preset) async {
            persistirLlamadas++;
          },
          aplicar: (preset) async {
            aplicarLlamadas++;
          },
        );
        expect(persistirLlamadas, 1);
        expect(aplicarLlamadas, 0);
      },
    );
    test(
      'id desconocido/obsoleto: no persiste ni aplica, no lanza excepción',
      () async {
        var persistirLlamadas = 0;
        var aplicarLlamadas = 0;
        await aplicarPresetPorMediaId(
          'eq_preset:Inexistente',
          presets: PresetEcualizador.presets,
          uuidActual: null,
          clavesPorEmisora: () async => <String>{},
          persistirPrincipal: (preset) async {
            persistirLlamadas++;
          },
          aplicar: (preset) async {
            aplicarLlamadas++;
          },
        );
        expect(persistirLlamadas, 0);
        expect(aplicarLlamadas, 0);
      },
    );
    test(
      'invariante estructural: la firma solo expone seams de '
      'persistencia/aplicación EQ, ningun seam de reproducción es '
      'inyectable (ADR-3, no-playback-by-construction)',
      () async {
        // Este test documenta y prueba por construcción que
        // aplicarPresetPorMediaId no puede tocar playback: los únicos
        // parámetros de función inyectables en su firma son
        // persistirPrincipal y aplicar (ambos EQ-only). No existe ningún
        // parámetro playMediaItem/mediaItem/playbackState que un caller
        // pueda pasar — de haberlo, este call site fallaría a compilar.
        final llamadasAplicar = <PresetEcualizador>[];
        final llamadasPersistir = <PresetEcualizador>[];
        await aplicarPresetPorMediaId(
          'eq_preset:${PresetEcualizador.pop.nombre}',
          presets: PresetEcualizador.presets,
          uuidActual: null,
          clavesPorEmisora: () async => <String>{},
          persistirPrincipal: (preset) async => llamadasPersistir.add(preset),
          aplicar: (preset) async => llamadasAplicar.add(preset),
          // NOTE: no `playMediaItem`/`mediaItem`/`playbackState` parameter
          // exists on this function — there is nothing to pass here even
          // if a caller wanted to. That absence IS the non-playback proof.
        );
        expect(llamadasPersistir, [PresetEcualizador.pop]);
        expect(llamadasAplicar, [PresetEcualizador.pop]);
      },
    );
  });
  group('reproducirPorMediaId', () {
    test(
      'resuelve el id y delega a reproducir con un MediaItem con forma de '