UI refactor

app.py

@@ -78,6 +78,36 @@ ALL_SIGNAL_LABELS = {
 }
 ALL_SIGNAL_CHOICES = [(ALL_SIGNAL_LABELS[s], s) for s in ALL_SIGNALS]
 
+# A value for the coverage picker that means "every signal", so that turning the
+# lot on or off is the same two buttons as turning one on or off. Sentinel-
+# prefixed because it shares a dropdown with real signal names and is passed to
+# the same handler; nothing in ALL_SIGNALS can ever start with "~".
+COV_ALL = "~all"
+COV_ALL_LABEL = "All signals"
+
+# Edit's one picker: the shapeable curves, then the three edits that are not
+# curves. All four write conditioning for the same window and none of them makes
+# a sound — what differs is the controls each needs, so they share a selector
+# that reveals the right ones (see the editor block in build_app). Sentinel-
+# prefixed for the same reason COV_ALL is: they travel through handlers that
+# also take real signal names.
+EDIT_KEY, EDIT_MORPH, EDIT_TEXT = "~key", "~morph", "~text"
+EDIT_SPECIALS = (EDIT_KEY, EDIT_MORPH, EDIT_TEXT)
+EDIT_SPECIAL_CHOICES = [("key", EDIT_KEY),
+                        ("style — morph toward a preset", EDIT_MORPH),
+                        ("style — from text", EDIT_TEXT)]
+EDIT_TARGETS = ([(SIGNAL_LABELS[s], s) for s in EDITABLE_SIGNALS]
+                + EDIT_SPECIAL_CHOICES)
+_EDIT_ACTIONS = {EDIT_KEY: "Set key",
+                 EDIT_MORPH: "Morph style",
+                 EDIT_TEXT: "Set style from text"}
+
+
+def _edit_action(target: str) -> str:
+    """The Apply button's label for a target. Every curve shares one label
+    because for a curve the shape dropdown is the verb, not the signal."""
+    return _EDIT_ACTIONS.get(target, "Apply shape")
+
 # The third tab is a lab bench rather than a feature: which model stage, the two
 # history knobs whose right value is still an open question, and the A/B between
 # the two guidance compositions. Off on a public Space, on with SHOW_TESTING=1.
@@ -988,9 +1018,10 @@ def _simple_status(msg: str) -> str:
     # edit report from controls Generate does not have; the latter is bookkeeping
     # about a track the listener can already hear, so it says nothing.
     return out("" if head.startswith(
-        ("Continued", "Fast-forwarded", "Regenerated", "Rendered", "Applied",
-         "Set ", "Morphed", "Coverage", "Varied", "Undo", "Seeded",
-         "Extracted", "Unconditional")) else head)
+        ("Continued", "Fast-forwarded", "Regenerated", "Rewrote", "Rendered",
+         "Applied", "Replaced", "Added", "Set ", "Style set", "Morphed",
+         "Turned", "Coverage", "Undo", "Seeded", "Extracted",
+         "Unconditional")) else head)
 
 
 def _coverage_table(track: Track) -> str:
@@ -1018,9 +1049,9 @@ def _coverage_table(track: Track) -> str:
     for s in sigs:
         n_on = int(np.count_nonzero(np.asarray(c.active[s], dtype=bool)))
         if n_on == T:
-            state = "🟩 **on** — following the curve"
+            state = "🟩 **on**"
         elif n_on == 0:
-            state = "⬜ off — free"
+            state = "⬜ off"
         else:
             state = f"🟨 partial — on for {n_on} of {T}"
         rows.append(f"| {ALL_SIGNAL_LABELS[s]} | {state} |")
@@ -1133,7 +1164,6 @@ def _preview_figure(track, signal, start, end, shape, mode, wave, *pvals):
 def build_app(backend: ModelBackend | None = None) -> gr.Blocks:
     backend = backend or MockBackend()
     presets = backend.list_presets()
-    signal_choices = [(SIGNAL_LABELS[s], s) for s in EDITABLE_SIGNALS]
 
     with gr.Blocks(title="Conditioning Composer") as demo:
         gr.HTML(_PLOT_CSS, elem_classes="style-inject")
@@ -1227,14 +1257,15 @@ def build_app(backend: ModelBackend | None = None) -> gr.Blocks:
             # GENERATE
             # =================================================================
             with gr.Tab("Generate"):
+                # Starting a track and extending one were two halves of one tab
+                # and are two different sittings: you start once, then spend the
+                # session on **Continue**. Nothing here makes a sound on this
+                # tab -- the player is on Continue, which is where you go next.
                 gr.Markdown(
-                    "Pick something to start from, press play, and let it keep "
-                    "writing. When you have something you like, go to **Edit** "
-                    "and take 24 measures of it apart — the track carries "
-                    "across.")
+                    "Pick something to start from, then hear it and keep it "
+                    "going on **Continue**.")
                 with gr.Row():
                     with gr.Column(scale=1):
-                        gr.Markdown("### 1 · Start from")
                         s_preset = gr.Dropdown(presets, value=presets[0],
                                                label="A real song")
                         s_preset_btn = gr.Button("Start from this song",
@@ -1252,12 +1283,23 @@ def build_app(backend: ModelBackend | None = None) -> gr.Blocks:
                                  "it.")
                         s_text_btn = gr.Button("Start from this description")
 
+                        # Last, because it applies to all three entry points
+                        # above rather than to any one of them, and because it
+                        # is the control you change least.
+                        s_seed = gr.Number(
+                            value=0, label="Seed", precision=0,
+                            info="Where the music starts from: the same seed "
+                                 "and the same settings open the same way. "
+                                 "Change it for a different take of the same "
+                                 "idea.")
+
+                    with gr.Column(scale=1):
                         # ---- tempo ------------------------------------------
-                        # Directly under the description, because that is the
-                        # pairing: a song and an upload arrive with a measured
-                        # tempo, a description says nothing about tempo at all
-                        # and takes whatever this block says. Adjacency is the
-                        # whole explanation, which is why there is no longer a
+                        # Beside the entry points, because that is the pairing:
+                        # a song and an upload arrive with a measured tempo, a
+                        # description says nothing about tempo at all and takes
+                        # whatever this block says. Adjacency is the whole
+                        # explanation, which is why there is no longer a
                         # paragraph making it. The preview is live and works
                         # with no track loaded -- dial the curve in BEFORE
                         # generating, which is the whole reason it is up here.
@@ -1286,18 +1328,18 @@ def build_app(backend: ModelBackend | None = None) -> gr.Blocks:
                             "decode time, so it is never ignored, even with "
                             "every signal off.</sub>")
 
-                        # Last, because it applies to all three entry points
-                        # above rather than to any one of them, and because it
-                        # is the control you change least.
-                        s_seed = gr.Number(
-                            value=0, label="Seed", precision=0,
-                            info="Where the music starts from: the same seed "
-                                 "and the same settings open the same way. "
-                                 "Change it for a different take of the same "
-                                 "idea.")
-
-                    with gr.Column(scale=2):
-                        gr.Markdown("### 2 · Listen")
+            # =================================================================
+            # CONTINUE
+            # =================================================================
+            # Extending a track, and hearing it. One section, not two, because
+            # the three buttons at the bottom are the same operation at three
+            # lengths -- eight measures, a leg, or until you stop it -- and all
+            # of them read the controls above them. Splitting "continue" from
+            # "radio" would put those controls under one heading and silently
+            # apply them to the other.
+            with gr.Tab("Continue"):
+                with gr.Row():
+                    with gr.Column(scale=1):
                         s_audio = gr.Audio(label="Current track",
                                            type="filepath", interactive=False)
                         # The radio's player lives HERE, in the same slot as the
@@ -1322,13 +1364,6 @@ def build_app(backend: ModelBackend | None = None) -> gr.Blocks:
                         # hear.
                         s_summary = gr.Markdown(visible=False)
 
-                        # One section, not two, because the three buttons at the
-                        # bottom of it are the same operation at three lengths --
-                        # eight measures, a leg, or until you stop it -- and all
-                        # of them read the controls above them. Splitting
-                        # "continue" from "radio" would put those controls under
-                        # one heading and silently apply them to the other.
-                        gr.Markdown("### 3 · Keep it going")
                         # One control for every way the style can move, because
                         # in the backend they are one choice: the typed steer,
                         # the two walks and style-off are exclusive branches of
@@ -1455,7 +1490,8 @@ def build_app(backend: ModelBackend | None = None) -> gr.Blocks:
                                                    scale=1)
                         s_status = gr.Markdown()
 
-                        # Open by default: "how it moves" is the section above
+                    with gr.Column(scale=1):
+                        # Open by default: "how it moves" is the column beside
                         # it, and this is the only place that answers whether
                         # the mode you picked is doing anything. Updated on
                         # every press and at every leg boundary of a live
@@ -1633,28 +1669,19 @@ def build_app(backend: ModelBackend | None = None) -> gr.Blocks:
                         # Turning a signal off over PART of a song is still
                         # reachable, and correctly: seat the window there and
                         # edit it as its own window.
-                        gr.Markdown(
-                            "### Conditioning coverage\n"
-                            f"On or off for **all {N_CHUNKS} measures the model "
-                            "is reading**. Where a signal is off the model "
-                            "invents it instead of following the curve; "
-                            "everything off is unconditional generation.\n\n"
-                            "<sub>Whole window only: this checkpoint never saw "
-                            "a signal that was on for some measures and off for "
-                            "others. To free one over part of a song, move the "
-                            "selection there and do it a window at a "
-                            "time.</sub>")
+                        gr.Markdown("### Conditioning coverage")
                         coverage_tbl = gr.Markdown()
-                        cov_signal = gr.Dropdown(ALL_SIGNAL_CHOICES,
-                                                 value=ALL_SIGNALS[0],
-                                                 label="signal")
+                        # "All signals" is an entry in the picker rather than a
+                        # second pair of buttons. Four buttons where two would
+                        # do, and the two extra ones were the same verb again
+                        # with a different scope -- scope is what the dropdown
+                        # above them is for.
+                        cov_signal = gr.Dropdown(
+                            [(COV_ALL_LABEL, COV_ALL)] + ALL_SIGNAL_CHOICES,
+                            value=COV_ALL, label="signal")
                         with gr.Row():
-                            cov_on = gr.Button("Turn ON (condition)",
-                                               variant="primary")
-                            cov_off = gr.Button("Turn OFF (free)")
-                        with gr.Row():
-                            cov_all_off = gr.Button("All OFF (unconditional)")
-                            cov_all_on = gr.Button("All ON")
+                            cov_on = gr.Button("On", variant="primary")
+                            cov_off = gr.Button("Off")
 
             # =================================================================
             # EDIT
@@ -1703,90 +1730,95 @@ def build_app(backend: ModelBackend | None = None) -> gr.Blocks:
                                  "training's *_cfg*). Higher = stronger "
                                  "adherence to the conditioning, but can "
                                  "distort.")
-                        vary_seed = gr.Number(value=2, label="Variation seed",
-                                              precision=0)
-                        vary_btn = gr.Button("↻ Vary (new noise)")
-                        gr.Markdown(
-                            "<sub>*Vary* rewrites the whole window from the "
-                            "same conditioning with different noise — a second "
-                            "take, not an edit.</sub>")
 
-                # ---- editors ------------------------------------------------
-                with gr.Row():
-                    with gr.Column():
-                        gr.Markdown("### Shape a signal over a region")
-                        signal_dd = gr.Dropdown(
-                            signal_choices, value=EDITABLE_SIGNALS[0],
-                            label="conditioning signal")
-                        with gr.Row():
-                            ed_start = gr.Slider(0, N_CHUNKS - 1, value=0,
-                                                 step=1,
-                                                 label="from measure (in window)")
-                            ed_end = gr.Slider(1, N_CHUNKS, value=N_CHUNKS,
-                                               step=1,
-                                               label="to measure (in window)")
-                        shape_dd = gr.Dropdown(SHAPES, value=SHAPES[0],
-                                               label="shape")
-                        shape_help = gr.Markdown(f"*{SHAPE_HELP[SHAPES[0]]}*")
-                        # generic parameter slots (relabelled per shape)
-                        pslots = [gr.Number(value=0.0, label=f"p{i}",
-                                            visible=False)
-                                  for i in range(MAX_PARAMS)]
-                        wave_dd = gr.Dropdown(["sine", "triangle", "saw"],
-                                              value="sine", label="wave",
-                                              visible=False)
-                        mode_rb = gr.Radio(["replace", "add"], value="replace",
-                                           label="mode")
-                        preview_plot = gr.Plot(
-                            label="Preview (live — not yet applied)",
-                            elem_classes="plot-card")
-                        apply_btn = gr.Button("Apply shape", variant="primary")
-
-                    with gr.Column():
-                        gr.Markdown("### Key / style")
-                        with gr.Row():
-                            root_dd = gr.Dropdown(
-                                [("C", 0), ("C#", 1), ("D", 2), ("D#", 3),
-                                 ("E", 4), ("F", 5), ("F#", 6), ("G", 7),
-                                 ("G#", 8), ("A", 9), ("A#", 10), ("B", 11)],
-                                value=0, label="root")
-                            minor_cb = gr.Checkbox(value=False, label="minor")
-                        key_btn = gr.Button("Set key (whole window)")
-                        with gr.Row():
-                            style_dd = gr.Dropdown(presets, value=presets[0],
-                                                   label="morph style toward")
-                            style_amt = gr.Slider(0.0, 1.0, value=0.5,
-                                                  step=0.05, label="amount")
-                        style_btn = gr.Button("Morph style (whole window)")
-                        style_text = gr.Textbox(
-                            label="…or set style from text",
-                            placeholder="e.g. smoky late-night piano trio")
-                        # Whole window, like the two above it and like coverage.
-                        # It used to take a range, which was the same untrained
-                        # configuration the coverage panel now refuses to make:
-                        # this writes `active["style"] = True` over the range it
-                        # is given, so a range on a track whose style was off
-                        # produced a window with style on for part of it.
-                        style_text_btn = gr.Button(
-                            "Set style from text (whole window)")
-                        gr.Markdown(
-                            "<sub>*Morph* slerps each measure's style vector "
-                            "part-way toward a preset's, keeping the shape of "
-                            "what is there. *From text* replaces it outright "
-                            "with one CLAP embedding, the same vector a text "
-                            "prompt on **Generate** starts from.</sub>")
+                # ---- the editor ---------------------------------------------
+                # ONE picker for everything that can be changed, and one button
+                # that does it. Key and style used to be a second column with
+                # two more buttons in it, which read as a different kind of
+                # operation; they are not -- all four write conditioning for the
+                # same window and none of them makes a sound. What differs is
+                # the controls each one needs, so the picker reveals those and
+                # hides the rest. EDIT_TARGETS is the whole mapping.
+                gr.Markdown("### Edit the conditioning")
+                signal_dd = gr.Dropdown(EDIT_TARGETS, value=EDITABLE_SIGNALS[0],
+                                        label="what to edit")
+
+                # Groups, not individual components, because `_param_updates`
+                # already owns the visibility of `pslots` and `wave_dd` (per
+                # shape) -- two handlers writing the same `visible` flag from
+                # different triggers is a race with no winner. A container's
+                # visibility is a flag nothing else touches.
+                with gr.Column(visible=True) as curve_grp:
+                    with gr.Row():
+                        ed_start = gr.Slider(0, N_CHUNKS - 1, value=0, step=1,
+                                             label="from measure (in window)")
+                        ed_end = gr.Slider(1, N_CHUNKS, value=N_CHUNKS, step=1,
+                                           label="to measure (in window)")
+                    with gr.Row():
+                        with gr.Column():
+                            shape_dd = gr.Dropdown(SHAPES, value=SHAPES[0],
+                                                   label="shape")
+                            shape_help = gr.Markdown(
+                                f"*{SHAPE_HELP[SHAPES[0]]}*")
+                            # generic parameter slots (relabelled per shape)
+                            pslots = [gr.Number(value=0.0, label=f"p{i}",
+                                                visible=False)
+                                      for i in range(MAX_PARAMS)]
+                            wave_dd = gr.Dropdown(["sine", "triangle", "saw"],
+                                                  value="sine", label="wave",
+                                                  visible=False)
+                            mode_rb = gr.Radio(["replace", "add"],
+                                               value="replace", label="mode")
+                        with gr.Column():
+                            preview_plot = gr.Plot(
+                                label="Preview (live — not yet applied)",
+                                elem_classes="plot-card")
+
+                with gr.Column(visible=False) as key_grp:
+                    with gr.Row():
+                        root_dd = gr.Dropdown(
+                            [("C", 0), ("C#", 1), ("D", 2), ("D#", 3),
+                             ("E", 4), ("F", 5), ("F#", 6), ("G", 7),
+                             ("G#", 8), ("A", 9), ("A#", 10), ("B", 11)],
+                            value=0, label="root")
+                        minor_cb = gr.Checkbox(value=False, label="minor")
+
+                with gr.Column(visible=False) as morph_grp:
+                    with gr.Row():
+                        style_dd = gr.Dropdown(presets, value=presets[0],
+                                               label="morph style toward")
+                        style_amt = gr.Slider(0.0, 1.0, value=0.5, step=0.05,
+                                              label="amount")
+
+                with gr.Column(visible=False) as text_grp:
+                    # Whole window, like the two above it and like coverage. It
+                    # used to take a range, which was the same untrained
+                    # configuration the coverage panel now refuses to make:
+                    # this writes `active["style"] = True` over the range it is
+                    # given, so a range on a track whose style was off produced
+                    # a window with style on for part of it.
+                    style_text = gr.Textbox(
+                        label="style prompt",
+                        placeholder="e.g. smoky late-night piano trio")
+
+                apply_btn = gr.Button(_edit_action(EDITABLE_SIGNALS[0]),
+                                      variant="primary")
 
                 # ---- regenerate ---------------------------------------------
-                # At the bottom, after the editors, because that is the order
-                # the work happens in: nothing above this point makes a sound.
-                gr.Markdown(
-                    "<sub>Everything above changes what the model is **asked** "
-                    "for. This is where it answers.</sub>")
+                # At the bottom, after the editor, because that is the order the
+                # work happens in: nothing above this point makes a sound.
+                #
+                # THE seed for this tab, and the only one. There used to be a
+                # second (a "variation seed" beside a Vary button), which was
+                # the same operation -- rewrite the window from the same
+                # conditioning with different noise -- reached by a different
+                # control and remembered in a different box, so the two could
+                # disagree about which take you were listening to. Regenerate
+                # with this changed IS Vary; Regenerate with it untouched is the
+                # take you already have, because it follows the track (see
+                # refresh_window) and is always the seed the window was written
+                # with.
                 with gr.Row():
-                    # Follows the track (see refresh_window): pressing
-                    # Regenerate without touching anything has to be the same
-                    # seed the window was written with, or "unchanged" is a
-                    # setting the UI makes unreachable.
                     rg_seed = gr.Number(value=1, label="Seed",
                                         precision=0, scale=1)
                     regen_btn = gr.Button("♫ Regenerate",
@@ -2075,8 +2107,7 @@ def build_app(backend: ModelBackend | None = None) -> gr.Blocks:
             return _edit_outputs(tr, f"Switched to stage {int(stage)} model.")
 
         def _stage_controls(stage, cur_sig, cur_cov):
-            """Restrict the two signal pickers — and the chroma-only key button —
-            to the signals the selected model reads.
+            """Restrict the two pickers to the signals the selected model reads.
 
             The plots gate themselves off `track.stage`, but these are inputs,
             not views: with no track loaded there is nothing to gate against,
@@ -2085,10 +2116,19 @@ def build_app(backend: ModelBackend | None = None) -> gr.Blocks:
             the track because stage_rb is what the entry points read for the
             NEXT generation — and on_swap pushes the restored track's stage back
             into it, so swapping is covered for free. The current selection is
-            kept when it survives the switch."""
+            kept when it survives the switch.
+
+            Key and style are filtered by the channel they actually write --
+            key is chroma, both style edits are style -- which is how the old
+            greyed-out key button's job gets done now that there is no button to
+            grey: an edit the stage cannot hear is not in the list."""
             sigs = signals_for_stage(int(stage))
             ed = [(SIGNAL_LABELS[s], s) for s in EDITABLE_SIGNALS if s in sigs]
-            cov = [(ALL_SIGNAL_LABELS[s], s) for s in ALL_SIGNALS if s in sigs]
+            ed += [(lbl, t) for lbl, t in EDIT_SPECIAL_CHOICES
+                   if ("chroma" if t == EDIT_KEY else "style") in sigs]
+            cov = ([(COV_ALL_LABEL, COV_ALL)]
+                   + [(ALL_SIGNAL_LABELS[s], s) for s in ALL_SIGNALS
+                      if s in sigs])
 
             def keep(v, opts):
                 return v if any(v == o[1] for o in opts) else opts[0][1]
@@ -2096,7 +2136,6 @@ def build_app(backend: ModelBackend | None = None) -> gr.Blocks:
             return (
                 gr.update(choices=ed, value=keep(cur_sig, ed)),
                 gr.update(choices=cov, value=keep(cur_cov, cov)),
-                gr.update(interactive=("chroma" in sigs)),
             )
 
         def _diag_note(track):
@@ -2849,6 +2888,35 @@ def build_app(backend: ModelBackend | None = None) -> gr.Blocks:
                 tr, f"{mode.title()}d {shape} on **{lbl}** over "
                     f"measures [{int(start)},{int(end)}).")
 
+        def _target_controls(target):
+            """Show the controls the picked target needs, hide the rest, and
+            say on the button what pressing it will do.
+
+            Containers, not components: `_param_updates` owns `pslots` and
+            `wave_dd` per shape, and two handlers writing one `visible` flag
+            from different triggers is a race."""
+            return (gr.update(visible=target not in EDIT_SPECIALS),
+                    gr.update(visible=target == EDIT_KEY),
+                    gr.update(visible=target == EDIT_MORPH),
+                    gr.update(visible=target == EDIT_TEXT),
+                    gr.update(value=_edit_action(target)))
+
+        def on_edit_apply(track, target, start, end, shape, mode, wave,
+                          root, minor, style, amount, prompt, is_draft,
+                          *pvals):
+            """The one Apply button. Four edits, one press, chosen by the
+            picker -- the handlers below are unchanged, this only routes to
+            them. They all return `_edit_outputs`, so the wiring downstream
+            cannot tell which one ran."""
+            if target == EDIT_KEY:
+                return on_set_key(track, root, minor, is_draft)
+            if target == EDIT_MORPH:
+                return on_morph_style(track, style, amount, is_draft)
+            if target == EDIT_TEXT:
+                return on_style_from_text(track, prompt)
+            return on_apply(track, target, start, end, shape, mode, wave,
+                            is_draft, *pvals)
+
         # ---- moving the editable window --------------------------------------
         # Not a control of its own any more: the selection says which measures
         # to rewrite, `_sel_window` says which N_CHUNKS have to be loaded to do
@@ -2942,25 +3010,22 @@ def build_app(backend: ModelBackend | None = None) -> gr.Blocks:
                     f"the window was held frozen.{clamped}" + _splice_note(tr)
                     + _diag_note(tr))
 
-        def on_vary(track, seed, is_draft, guidance):
-            if track is None:
-                return (gr.update(),) * 5 + ("Start a track first.",)
-            tr = backend.set_guidance(track, float(guidance))
-            tr = backend.vary(tr, int(seed), n_steps=_steps(is_draft))
-            a, c, cov, s = _render_outputs(tr)
-            return (tr, a, c, cov, s,
-                    f"Variation with seed {int(seed)}." + _splice_note(tr))
-
         def _apply_coverage(track, signal, on):
-            """Toggle a signal on/off across the WHOLE window (edit only — no
-            re-render). Not a range: see the comment on the coverage panel."""
+            """Toggle a signal — or all of them — on/off across the WHOLE
+            window (edit only, no re-render). Not a range: see the comment on
+            the coverage panel. COV_ALL is handled here rather than by its own
+            pair of buttons, because "which signals" is the dropdown's job."""
             if track is None:
                 return (gr.update(),) * 5 + ("Start a track first.",)
-            tr = backend.set_active(track, signal, 0, track.cond.T, bool(on))
-            lbl = ALL_SIGNAL_LABELS.get(signal, signal)
+            sigs = ALL_SIGNALS if signal == COV_ALL else [signal]
+            tr = track
+            for s in sigs:
+                tr = backend.set_active(tr, s, 0, tr.cond.T, bool(on))
+            lbl = (COV_ALL_LABEL.lower() if signal == COV_ALL
+                   else f"**{ALL_SIGNAL_LABELS.get(signal, signal)}**")
             first = int(track.prefix_measures)
             return _edit_outputs(
-                tr, f"Turned **{lbl}** {'on' if on else 'off'} for measures "
+                tr, f"Turned {lbl} {'on' if on else 'off'} for measures "
                     f"{first}–{first + track.cond.T}.")
 
         def on_cov_on(track, signal):
@@ -2969,22 +3034,6 @@ def build_app(backend: ModelBackend | None = None) -> gr.Blocks:
         def on_cov_off(track, signal):
             return _apply_coverage(track, signal, False)
 
-        def _apply_all(track, on):
-            if track is None:
-                return (gr.update(),) * 5 + ("Start a track first.",)
-            tr = track
-            for sig in ALL_SIGNALS:
-                tr = backend.set_active(tr, sig, 0, tr.cond.T, on)
-            msg = ("All signals off — unconditional." if not on
-                   else "All signals on — fully conditioned.")
-            return _edit_outputs(tr, msg)
-
-        def on_cov_all_off(track):
-            return _apply_all(track, False)
-
-        def on_cov_all_on(track):
-            return _apply_all(track, True)
-
         # ---- A/B slots ------------------------------------------------------
         # A = `cur` (being edited), B = `prev` (parked snapshot). Both hold a
         # whole Track, so a swap carries the conditioning arrays, per-measure
@@ -3127,17 +3176,19 @@ def build_app(backend: ModelBackend | None = None) -> gr.Blocks:
         # `_raw_continue` / `_raw_fast_forward`, which were bound above this
         # block precisely so the Generate wrappers get mirrored once rather
         # than twice.
+        #
+        # `on_apply`, `on_set_key`, `on_morph_style` and `on_style_from_text`
+        # are absent for the same reason: `on_edit_apply` is the only thing
+        # wired to them, and mirroring both it and them would append the four
+        # mirror outputs twice.
         (on_new_preset, on_new_text, on_new_upload, on_set_bpm,
-         on_style_from_text, on_set_stage, on_simple_continue,
-         on_simple_ff, on_apply, on_set_key, on_morph_style, on_regen, on_vary,
-         on_cov_on, on_cov_off, on_cov_all_off, on_cov_all_on, on_swap,
-         on_seat) = [
+         on_set_stage, on_simple_continue, on_simple_ff, on_edit_apply,
+         on_regen, on_cov_on, on_cov_off, on_swap, on_seat) = [
             _mirror(f) for f in (
                 on_new_preset, on_new_text, on_new_upload,
-                on_set_bpm, on_style_from_text, on_set_stage,
-                on_simple_continue, on_simple_ff, on_apply, on_set_key,
-                on_morph_style, on_regen, on_vary, on_cov_on, on_cov_off,
-                on_cov_all_off, on_cov_all_on, on_swap, on_seat)]
+                on_set_bpm, on_set_stage,
+                on_simple_continue, on_simple_ff, on_edit_apply,
+                on_regen, on_cov_on, on_cov_off, on_swap, on_seat)]
         on_undo = _mirror(on_undo, off=1)
 
         # ---- wiring ---------------------------------------------------------
@@ -3155,6 +3206,13 @@ def build_app(backend: ModelBackend | None = None) -> gr.Blocks:
 
         def refresh_preview(track, signal, start, end, shape, mode, wave,
                             *pvals):
+            """The live shape preview, or nothing when the picker is not on a
+            curve. `_preview_figure` reads `cond.<signal>`, and the three
+            special targets are not channels -- the plot is hidden with the
+            rest of the curve controls in that case, so there is nothing to
+            draw either."""
+            if signal in EDIT_SPECIALS:
+                return gr.update()
             return _preview_figure(track, signal, start, end, shape, mode, wave,
                                    *pvals)
 
@@ -3465,31 +3523,26 @@ def build_app(backend: ModelBackend | None = None) -> gr.Blocks:
              .then(on_regen,
                    [cur, sel_from, sel_to, rg_seed, draft, guidance_sl],
                    out_all))
-        tail(vary_btn.click(_snapshot, [cur, hist], hist).then(
-            on_vary, [cur, vary_seed, draft, guidance_sl], out_all))
 
-        # --- the editors ------------------------------------------------------
+        # --- the editor -------------------------------------------------------
+        # One button, every edit. The inputs are the union of what the four
+        # branches need, because gradio binds an event's inputs once and the
+        # picker chooses the branch at press time -- the controls the branch
+        # does not read are hidden, not absent, and their values are ignored.
         tail(apply_btn.click(_snapshot, [cur, hist], hist).then(
-            on_apply,
+            on_edit_apply,
             [cur, signal_dd, ed_start, ed_end, shape_dd, mode_rb, wave_dd,
+             root_dd, minor_cb, style_dd, style_amt, style_text,
              draft, *pslots],
             out_all))
-        tail(key_btn.click(_snapshot, [cur, hist], hist).then(
-            on_set_key, [cur, root_dd, minor_cb, draft], out_all))
-        tail(style_btn.click(_snapshot, [cur, hist], hist).then(
-            on_morph_style, [cur, style_dd, style_amt, draft], out_all))
-        tail(style_text_btn.click(_snapshot, [cur, hist], hist).then(
-            on_style_from_text, [cur, style_text], out_all))
+        signal_dd.change(_target_controls, [signal_dd],
+                         [curve_grp, key_grp, morph_grp, text_grp, apply_btn])
 
         # --- coverage ---------------------------------------------------------
         tail(cov_on.click(_snapshot, [cur, hist], hist).then(
             on_cov_on, [cur, cov_signal], out_all))
         tail(cov_off.click(_snapshot, [cur, hist], hist).then(
             on_cov_off, [cur, cov_signal], out_all))
-        tail(cov_all_off.click(_snapshot, [cur, hist], hist).then(
-            on_cov_all_off, [cur], out_all))
-        tail(cov_all_on.click(_snapshot, [cur, hist], hist).then(
-            on_cov_all_on, [cur], out_all))
 
         # --- undo / A / B -----------------------------------------------------
         # Undo restores a whole Track, so it has to rebuild every A-facing view
@@ -3517,7 +3570,7 @@ def build_app(backend: ModelBackend | None = None) -> gr.Blocks:
         # views, this one rebuilds the controls. demo.load runs it once so the
         # initial radio position is honoured before anything is generated.
         stage_ctl_in = [stage_rb, signal_dd, cov_signal]
-        stage_ctl_out = [signal_dd, cov_signal, key_btn]
+        stage_ctl_out = [signal_dd, cov_signal]
         stage_rb.change(_stage_controls, stage_ctl_in, stage_ctl_out)
         demo.load(_stage_controls, stage_ctl_in, stage_ctl_out)