Save apply timeline preset button config to yaml

Author: SpoddyCoder

.cursor/rules/live-tuning-ui.mdc

@@ -52,7 +52,7 @@ Below overlay, **Render: POST FX** (`RowKind.RENDER_POST_FX_HEADER`) is always p
 
 **Section lock** (overlay, post-FX, timeline, and layer tracks share one mechanism in [cleave/viz/row_semantics.py](cleave/viz/row_semantics.py)): persisted `locked` on `RenderOverlayConfig` / `RenderPostFxConfig` / `TimelineConfig` and the matching runtimes. **l** on `RENDER_OVERLAY_HEADER`, `RENDER_POST_FX_HEADER`, `RENDER_TIMELINE_HEADER` (or `TRACK_HEADER`) toggles it and draws a red `LOCK_ICON` on the header. When locked: the header still expands/opens and expandable child headers stay navigable, but value and action children are drawn in `LOCKED` and skipped in navigation (`section_locked(state, desc)` with `row_navigable_when_section_locked` / `row_blocked_by_section_lock`); **Ctrl** enable/disable is refused while solo stays allowed. `section_locked` accepts either a `TuningViewState` (tracks / `render_timeline`) or a `TuningSession` (layers / `timeline`). In preset curation mode, `section_locked` always returns false (lock icon, `LOCKED` coloring, navigation skip, and mutation blocks are all ignored) so layer browse and **f** / **b** / **r** stay available.
 
-Below post-FX, **Render: TIMELINE** (`RowKind.RENDER_TIMELINE_HEADER`) is always present. This row is a **panel anchor** (not an expandable section): the timeline strip is hosted separately ([cleave/viz/timeline_overlay.py](cleave/viz/timeline_overlay.py)), not as `RowLayout` children. Eye semantics match post-FX (no solo in v1). **Ctrl+Right** / **Ctrl+Left** sets `session.timeline.enabled`; **Right** opens the timeline strip without entering the submenu; **Left** closes it. **t** toggles the strip: when closed, opens and enters the submenu on row 0; when open, closes and returns focus to this header. Expand arrow reflects `session.timeline.panel_open` (▼ when open). Disable closes the strip; **Right** / **t** can still open it while disabled (same expand-while-disabled semantics as layer and other render headers). State: `RenderTimelineBlock` / `TimelineRuntime` on session ([cleave/viz/session.py](cleave/viz/session.py)). `enabled` and `locked` persist via config snapshot; `panel_open` is UI-only. When the strip is open, main-panel children under **Render: TIMELINE** are: song markers (expandable; marker items and **snap to song markers** when expanded), beat / bar grid (expandable; placement snap, bar grid, bar phase, snap to grid), timeline fades (expandable; song markers and standard cues each with enabled/disabled and fade in/out duration when enabled), timeline preset (expandable; character, crescendo, density, and **apply timeline preset** when expanded), and reset timeline. **snap to song markers** is a green action row inside the song markers section (last row after marker items; Enter opens proximity then layer-scope choice modals). **snap to grid** is a green action row under beat / bar grid (Enter opens BEATS / BARS / CANCEL). When the timeline is locked, those children are blocked and skipped in navigation (expandable headers stay navigable), and the strip stays openable and seekable (Seek Left/Right); Space still toggles transport play/pause (session-only preview), but arm, record, override, number-key visibility, and Ctrl+Space record stay blocked ([cleave/viz/timeline_controls.py](cleave/viz/timeline_controls.py)); preset/snap/phase controllers also refuse while locked. **l** on the timeline header is refused while `timeline.recording` is true.
+Below post-FX, **Render: TIMELINE** (`RowKind.RENDER_TIMELINE_HEADER`) is always present. This row is a **panel anchor** (not an expandable section): the timeline strip is hosted separately ([cleave/viz/timeline_overlay.py](cleave/viz/timeline_overlay.py)), not as `RowLayout` children. Eye semantics match post-FX (no solo in v1). **Ctrl+Right** / **Ctrl+Left** sets `session.timeline.enabled`; **Right** opens the timeline strip without entering the submenu; **Left** closes it. **t** toggles the strip: when closed, opens and enters the submenu on row 0; when open, closes and returns focus to this header. Expand arrow reflects `session.timeline.panel_open` (▼ when open). Disable closes the strip; **Right** / **t** can still open it while disabled (same expand-while-disabled semantics as layer and other render headers). State: `RenderTimelineBlock` / `TimelineRuntime` on session ([cleave/viz/session.py](cleave/viz/session.py)). `enabled` and `locked` persist via config snapshot; staged timeline preset character / crescendo / density persist under `timeline.preset`; `panel_open` is UI-only. When the strip is open, main-panel children under **Render: TIMELINE** are: song markers (expandable; marker items and **snap to song markers** when expanded), beat / bar grid (expandable; placement snap, bar grid, bar phase, snap to grid), timeline fades (expandable; song markers and standard cues each with enabled/disabled and fade in/out duration when enabled), timeline preset (expandable; character, crescendo, density, and **apply timeline preset** when expanded), and reset timeline. **snap to song markers** is a green action row inside the song markers section (last row after marker items; Enter opens proximity then layer-scope choice modals). **snap to grid** is a green action row under beat / bar grid (Enter opens BEATS / BARS / CANCEL). When the timeline is locked, those children are blocked and skipped in navigation (expandable headers stay navigable), and the strip stays openable and seekable (Seek Left/Right); Space still toggles transport play/pause (session-only preview), but arm, record, override, number-key visibility, and Ctrl+Space record stay blocked ([cleave/viz/timeline_controls.py](cleave/viz/timeline_controls.py)); preset/snap/phase controllers also refuse while locked. **l** on the timeline header is refused while `timeline.recording` is true.
 
 ## Timeline panel
 

cleave/config.py

@@ -102,6 +102,12 @@
     require_non_negative_number,
 )
 from cleave.timeline import TimelineLane
+from cleave.timeline_presets.characters import DEFAULT_TIMELINE_PRESET_KIND
+from cleave.timeline_presets.crescendo import CrescendoTarget
+from cleave.timeline_presets.density import (
+    DEFAULT_TIMELINE_PRESET_DENSITY,
+    TimelinePresetDensity,
+)
 
 VIZ_CONFIG_FILENAME = "cleave-viz.yaml"
 
@@ -247,13 +253,23 @@ class TimelineFadesConfig:
     standard: TimelineFadeGroupConfig = field(default_factory=TimelineFadeGroupConfig)
 
 
+@dataclass(frozen=True)
+class TimelinePresetConfig:
+    """Staged character / crescendo / density for the timeline preset action."""
+
+    character: str = DEFAULT_TIMELINE_PRESET_KIND
+    crescendo: CrescendoTarget | None = None
+    density: TimelinePresetDensity = DEFAULT_TIMELINE_PRESET_DENSITY
+
+
 @dataclass(frozen=True)
 class TimelineConfig:
     enabled: bool
     lanes: dict[str, TimelineLane]
     locked: bool = False
     fades: TimelineFadesConfig = field(default_factory=TimelineFadesConfig)
     placement_snap: TimelinePlacementSnap = DEFAULT_TIMELINE_PLACEMENT_SNAP
+    preset: TimelinePresetConfig = field(default_factory=TimelinePresetConfig)
 
 
 @dataclass

cleave/config_schema.py

@@ -14,6 +14,16 @@
 from cleave.effects.registry import validate_effect_entry
 from cleave.extract import STEM_SOURCES, StemSource
 from cleave.timeline import SlotCue, TimelineLane, canonicalize
+from cleave.timeline_presets.characters import (
+    DEFAULT_TIMELINE_PRESET_KIND,
+    TIMELINE_PRESET_KIND_OPTIONS,
+)
+from cleave.timeline_presets.crescendo import CrescendoTarget
+from cleave.timeline_presets.density import (
+    DEFAULT_TIMELINE_PRESET_DENSITY,
+    TIMELINE_PRESET_DENSITY_OPTIONS,
+    TimelinePresetDensity,
+)
 
 # --- Editor defaults ---
 
@@ -329,6 +339,32 @@ def parse_timeline_placement_snap(raw: Any, label: str) -> TimelinePlacementSnap
         raise ValueError(f"{label} must be one of: {allowed}")
     return value  # type: ignore[return-value]
 
+
+def parse_timeline_preset_character(raw: Any, label: str) -> str:
+    value = str(raw)
+    if value not in TIMELINE_PRESET_KIND_OPTIONS:
+        allowed = ", ".join(TIMELINE_PRESET_KIND_OPTIONS)
+        raise ValueError(f"{label} must be one of: {allowed}")
+    return value
+
+
+def parse_timeline_preset_crescendo(raw: Any, label: str) -> CrescendoTarget | None:
+    if raw is None:
+        return None
+    value = str(raw)
+    if value not in ("last", "penultimate"):
+        raise ValueError(f"{label} must be one of: last, penultimate, or null")
+    return value  # type: ignore[return-value]
+
+
+def parse_timeline_preset_density(raw: Any, label: str) -> TimelinePresetDensity:
+    value = str(raw)
+    if value not in TIMELINE_PRESET_DENSITY_OPTIONS:
+        allowed = ", ".join(TIMELINE_PRESET_DENSITY_OPTIONS)
+        raise ValueError(f"{label} must be one of: {allowed}")
+    return value  # type: ignore[return-value]
+
+
 FieldSource = Literal["cfg", "session", "both"]
 T = TypeVar("T")
 
@@ -1922,6 +1958,28 @@ def _parse_timeline_fade_group(raw: Any, label: str) -> Any:
     )
 
 
+def _parse_timeline_preset(raw: Any) -> Any:
+    from cleave.config import TimelinePresetConfig
+
+    if raw is None:
+        return TimelinePresetConfig()
+    preset_map = as_mapping(raw, "timeline.preset")
+    return TimelinePresetConfig(
+        character=parse_timeline_preset_character(
+            preset_map.get("character", DEFAULT_TIMELINE_PRESET_KIND),
+            "timeline.preset.character",
+        ),
+        crescendo=parse_timeline_preset_crescendo(
+            preset_map.get("crescendo"),
+            "timeline.preset.crescendo",
+        ),
+        density=parse_timeline_preset_density(
+            preset_map.get("density", DEFAULT_TIMELINE_PRESET_DENSITY),
+            "timeline.preset.density",
+        ),
+    )
+
+
 def parse_timeline_section(data: dict[str, Any], ctx: ParseCtx) -> Any | None:
     from cleave.config import TimelineConfig, TimelineFadesConfig
 
@@ -1950,6 +2008,7 @@ def parse_timeline_section(data: dict[str, Any], ctx: ParseCtx) -> Any | None:
                 "timeline.fades.standard",
             ),
         )
+    preset = _parse_timeline_preset(timeline_map.get("preset"))
     # Legacy timeline.cues is ignored (clean break; no migration).
     lanes_raw = timeline_map.get("lanes")
     if lanes_raw is None:
@@ -1959,6 +2018,7 @@ def parse_timeline_section(data: dict[str, Any], ctx: ParseCtx) -> Any | None:
             locked=locked,
             fades=fades,
             placement_snap=placement_snap,
+            preset=preset,
         )
     lanes_map = as_mapping(lanes_raw, "timeline.lanes")
     if ctx.layer_slots is None:
@@ -2008,6 +2068,7 @@ def parse_timeline_section(data: dict[str, Any], ctx: ParseCtx) -> Any | None:
         locked=locked,
         fades=fades,
         placement_snap=placement_snap,
+        preset=preset,
     )
 
 
@@ -2029,6 +2090,11 @@ def persist_timeline(ctx: PersistCtx) -> dict[str, Any]:
             "song_markers": _persist_timeline_fade_group(runtime.song_marker_fades),
             "standard": _persist_timeline_fade_group(runtime.standard_cue_fades),
         },
+        "preset": {
+            "character": runtime.timeline_preset_kind,
+            "crescendo": runtime.timeline_preset_crescendo,
+            "density": runtime.timeline_preset_density,
+        },
     }
     lanes_out: dict[str, Any] = {}
     for slot in sorted(runtime.lanes):

cleave/timeline_presets/density.py

@@ -1,4 +1,4 @@
-"""Session-only stack-density staging for timeline presets."""
+"""Stack-density staging for timeline presets (persisted under timeline.preset)."""
 
 from __future__ import annotations
 

cleave/viz/session.py

@@ -352,6 +352,14 @@ def timeline_runtime_from_cfg(cfg: CleaveConfig) -> TimelineRuntime:
         if timeline is None
         else timeline.placement_snap
     )
+    preset = None if timeline is None else timeline.preset
+    preset_kind = (
+        DEFAULT_TIMELINE_PRESET_KIND if preset is None else preset.character
+    )
+    preset_crescendo = None if preset is None else preset.crescendo
+    preset_density = (
+        DEFAULT_TIMELINE_PRESET_DENSITY if preset is None else preset.density
+    )
     lanes: dict[str, TimelineLane] = {}
     for slot in cfg.layer_z_order:
         if slot in source_lanes:
@@ -364,12 +372,18 @@ def timeline_runtime_from_cfg(cfg: CleaveConfig) -> TimelineRuntime:
             locked=locked,
             lanes=lanes,
             placement_snap=placement_snap,
+            timeline_preset_kind=preset_kind,
+            timeline_preset_crescendo=preset_crescendo,
+            timeline_preset_density=preset_density,
         )
     return TimelineRuntime(
         enabled=enabled,
         locked=locked,
         lanes=lanes,
         placement_snap=placement_snap,
+        timeline_preset_kind=preset_kind,
+        timeline_preset_crescendo=preset_crescendo,
+        timeline_preset_density=preset_density,
         song_marker_fades=_fade_group_runtime_from_cfg(fades.song_markers),
         standard_cue_fades=_fade_group_runtime_from_cfg(fades.standard),
     )

tests/cleave/test_config.py

@@ -22,6 +22,7 @@
     TimelineConfig,
     TimelineFadeGroupConfig,
     TimelineFadesConfig,
+    TimelinePresetConfig,
     EditorConfig,
     clamp_beat_sensitivity,
     clamp_effect_pct,
@@ -1043,6 +1044,7 @@ def test_parse_timeline_defaults_enabled_true() -> None:
     assert timeline.locked is False
     assert timeline.fades == TimelineFadesConfig()
     assert timeline.placement_snap == "beat"
+    assert timeline.preset == TimelinePresetConfig()
 
 
 def test_parse_timeline_reads_fades() -> None:
@@ -1167,6 +1169,76 @@ def test_persist_timeline_placement_snap_round_trip() -> None:
     assert round_trip.placement_snap == "bar"
 
 
+def test_persist_timeline_preset_round_trip() -> None:
+    from cleave.viz.session import TimelineRuntime
+
+    session = TuningSession(
+        layer_z_order=list(DEFAULT_LAYER_SLOTS),
+        timeline=TimelineRuntime(
+            enabled=True,
+            timeline_preset_kind="arc",
+            timeline_preset_crescendo="penultimate",
+            timeline_preset_density="very dense",
+        ),
+    )
+    cfg = CleaveConfig(
+        paths=PathsConfig(preset_root=Path("/tmp"), texture_paths=()),
+        layers={},
+        editor=EditorConfig(),
+        config_path=Path("/tmp/cleave-viz.yaml"),
+        user_config_path=Path("/tmp/user.yaml"),
+        layer_z_order=list(DEFAULT_LAYER_SLOTS),
+    )
+    payload = persist_timeline(PersistCtx(cfg=cfg, session=session, cfg_dir=None))
+    assert payload["preset"] == {
+        "character": "arc",
+        "crescendo": "penultimate",
+        "density": "very dense",
+    }
+    round_trip = parse_timeline_section(
+        {"timeline": payload},
+        _timeline_parse_ctx(),
+    )
+    assert round_trip is not None
+    assert round_trip.preset == TimelinePresetConfig(
+        character="arc",
+        crescendo="penultimate",
+        density="very dense",
+    )
+
+
+def test_parse_timeline_reads_preset() -> None:
+    timeline = parse_timeline_section(
+        {
+            "timeline": {
+                "preset": {
+                    "character": "pulse",
+                    "crescendo": "last",
+                    "density": "sparse",
+                }
+            }
+        },
+        _timeline_parse_ctx(),
+    )
+    assert timeline is not None
+    assert timeline.preset == TimelinePresetConfig(
+        character="pulse",
+        crescendo="last",
+        density="sparse",
+    )
+
+
+def test_parse_timeline_preset_null_crescendo() -> None:
+    timeline = parse_timeline_section(
+        {"timeline": {"preset": {"character": "dialogue", "crescendo": None}}},
+        _timeline_parse_ctx(),
+    )
+    assert timeline is not None
+    assert timeline.preset.character == "dialogue"
+    assert timeline.preset.crescendo is None
+    assert timeline.preset.density == "normal"
+
+
 def test_parse_timeline_rejects_invalid_placement_snap() -> None:
     with pytest.raises(ValueError, match="placement_snap"):
         parse_timeline_section(
@@ -1175,6 +1247,22 @@ def test_parse_timeline_rejects_invalid_placement_snap() -> None:
         )
 
 
+def test_parse_timeline_rejects_invalid_preset_character() -> None:
+    with pytest.raises(ValueError, match="character"):
+        parse_timeline_section(
+            {"timeline": {"preset": {"character": "waltz"}}},
+            _timeline_parse_ctx(),
+        )
+
+
+def test_parse_timeline_rejects_invalid_preset_density() -> None:
+    with pytest.raises(ValueError, match="density"):
+        parse_timeline_section(
+            {"timeline": {"preset": {"density": "extreme"}}},
+            _timeline_parse_ctx(),
+        )
+
+
 def test_parse_timeline_reads_locked() -> None:
     timeline = parse_timeline_section(
         {"timeline": {"enabled": True, "locked": True}},

tests/cleave/test_config_snapshot.py

@@ -1043,9 +1043,49 @@ def test_write_session_snapshot_persists_timeline_disabled_without_cues(
                 "fade_out": 2.0,
             },
         },
+        "preset": {
+            "character": "breathing",
+            "crescendo": None,
+            "density": "normal",
+        },
     }
 
 
+def test_write_session_snapshot_round_trips_timeline_preset(tmp_path: Path) -> None:
+    cfg, session, out_path = _snapshot_fixture(tmp_path)
+    session.timeline.timeline_preset_kind = "arc"
+    session.timeline.timeline_preset_crescendo = "last"
+    session.timeline.timeline_preset_density = "dense"
+    write_session_snapshot(out_path, cfg=cfg, session=session)
+
+    data = yaml.safe_load(out_path.read_text(encoding="utf-8"))
+    assert data["timeline"]["preset"] == {
+        "character": "arc",
+        "crescendo": "last",
+        "density": "dense",
+    }
+
+    timeline = parse_timeline_section(
+        data,
+        ParseCtx(layer_slots=tuple(cfg.layer_z_order)),
+    )
+    assert timeline is not None
+    playlists = _round_trip_playlists(cfg.paths.preset_root)
+    cfg_with_timeline = CleaveConfig(
+        paths=cfg.paths,
+        layers=cfg.layers,
+        editor=cfg.editor,
+        config_path=out_path,
+        user_config_path=cfg.user_config_path,
+        render=cfg.render,
+        timeline=timeline,
+    )
+    session2 = session_from_cfg(cfg_with_timeline, playlists)
+    assert session2.timeline.timeline_preset_kind == "arc"
+    assert session2.timeline.timeline_preset_crescendo == "last"
+    assert session2.timeline.timeline_preset_density == "dense"
+
+
 def _round_trip_preset_dirs(root: Path) -> Path:
     preset_root = root / "presets"
     make_preset_dirs(preset_root)