fix(studio): stop the last two automation writes reloading the preview

The quiet commit added here was only used by the FX group. Two writers still went
through the refreshing one, so they reloaded the preview and restarted every
playing track — the exact chop the live write during a drag exists to avoid:

- releasing a dragged breakpoint, so the audio hitched at the end of every point
  you moved;
- clicking the volume toggle, while the same click on an effect parameter was
  already silent.

Both are quiet now: still persisted, still resyncing the selection so a following
edit computes from the value just written.

Also fixes the seeded volume. `Number(dataAttributes.volume ?? "1")` is 0 for an
attribute that is present but empty, so automating such a track started its lane
at silence while the engine read the same empty value as unity.

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>

Author: vanceingalls

.fallowrc.jsonc

@@ -176,6 +176,13 @@
         "withLane",
       ],
     },
+    // propertyPanelAutomation is the shared reader for both panel sections; the
+    // FX group that consumes these two lands one PR upstack, so a per-PR audit
+    // against the merge base sees them as unused.
+    {
+      "file": "packages/studio/src/components/editor/propertyPanelAutomation.ts",
+      "exports": ["automatedTargetsOf", "resolveAutomationRange"],
+    },
     // drawElementService is the bottom of the fast-capture Graphite stack
     // (#1917): its consumers (frameCapture in #1919) land two PRs upstack, so
     // a per-PR audit diffing against the merge base sees these exports as

packages/studio/src/components/editor/useVolumeAutomation.test.tsx

@@ -8,12 +8,12 @@ import type { DomEditSelection } from "./domEditingTypes";
 (globalThis as unknown as { IS_REACT_ACT_ENVIRONMENT: boolean }).IS_REACT_ACT_ENVIRONMENT = true;
 
 function bind(dataAttributes: Record<string, string>) {
-  const onSetAttribute = vi.fn();
+  const onSetAttributeQuiet = vi.fn();
   const captured: { current: VolumeAutomationBinding | null } = { current: null };
   function Probe() {
     captured.current = useVolumeAutomation(
       { dataAttributes } as unknown as DomEditSelection,
-      onSetAttribute,
+      onSetAttributeQuiet,
     );
     return null;
   }
@@ -23,7 +23,7 @@ function bind(dataAttributes: Record<string, string>) {
     createRoot(host).render(<Probe />);
   });
   if (!captured.current) throw new Error("hook never ran");
-  return { binding: captured.current, onSetAttribute };
+  return { binding: captured.current, onSetAttributeQuiet };
 }
 
 const volumeLane = (v: number) =>
@@ -50,29 +50,29 @@ describe("useVolumeAutomation", () => {
 
   it("seeds a new lane at the level the slider already shows", () => {
     // Automating a track must not change how loud it is.
-    const { binding, onSetAttribute } = bind({ volume: "0.55" });
+    const { binding, onSetAttributeQuiet } = bind({ volume: "0.55" });
     act(() => binding.onAutomateVolume());
-    expect(onSetAttribute).toHaveBeenCalledWith(
+    expect(onSetAttributeQuiet).toHaveBeenCalledWith(
       "data-automation",
       JSON.stringify({ version: 1, lanes: [{ target: "volume", points: [{ t: 0, v: 0.55 }] }] }),
     );
   });
 
   it("treats a missing data-volume as unity", () => {
-    const { binding, onSetAttribute } = bind({});
+    const { binding, onSetAttributeQuiet } = bind({});
     act(() => binding.onAutomateVolume());
-    expect(JSON.parse(String(onSetAttribute.mock.calls[0][1])).lanes[0].points[0].v).toBe(1);
+    expect(JSON.parse(String(onSetAttributeQuiet.mock.calls[0][1])).lanes[0].points[0].v).toBe(1);
   });
 
   it("keeps FX lanes when adding the volume one", () => {
     const automation = JSON.stringify({
       version: 1,
       lanes: [{ target: "fx.n1.frequency", points: [{ t: 0, v: 400 }] }],
     });
-    const { binding, onSetAttribute } = bind({ volume: "0.4", automation });
+    const { binding, onSetAttributeQuiet } = bind({ volume: "0.4", automation });
     act(() => binding.onAutomateVolume());
     expect(
-      JSON.parse(String(onSetAttribute.mock.calls[0][1])).lanes.map(
+      JSON.parse(String(onSetAttributeQuiet.mock.calls[0][1])).lanes.map(
         (l: { target: string }) => l.target,
       ),
     ).toEqual(["fx.n1.frequency", "volume"]);
@@ -86,22 +86,37 @@ describe("useVolumeAutomation", () => {
         { target: "fx.n1.frequency", points: [{ t: 0, v: 400 }] },
       ],
     });
-    const { binding, onSetAttribute } = bind({ volume: "0.4", automation });
+    const { binding, onSetAttributeQuiet } = bind({ volume: "0.4", automation });
     act(() => binding.onRemoveVolumeAutomation());
     expect(
-      JSON.parse(String(onSetAttribute.mock.calls[0][1])).lanes.map(
+      JSON.parse(String(onSetAttributeQuiet.mock.calls[0][1])).lanes.map(
         (l: { target: string }) => l.target,
       ),
     ).toEqual(["fx.n1.frequency"]);
   });
 
   it("clears the attribute when the volume lane was the only one", () => {
-    const { binding, onSetAttribute } = bind({ volume: "0.4", automation: volumeLane(0.2) });
+    const { binding, onSetAttributeQuiet } = bind({ volume: "0.4", automation: volumeLane(0.2) });
     act(() => binding.onRemoveVolumeAutomation());
-    expect(onSetAttribute).toHaveBeenCalledWith("data-automation", "");
+    // Null, not "": the quiet path removes an attribute it is given null for.
+    expect(onSetAttributeQuiet).toHaveBeenCalledWith("data-automation", null);
   });
 
   it("reads an unreadable attribute as no automation", () => {
     expect(bind({ volume: "0.55", automation: "{not json" }).binding.volumeAutomated).toBe(false);
   });
+
+  it("seeds at unity when data-volume is present but empty", () => {
+    // Number("") is 0, so `?? "1"` alone seeded the lane at silence while the
+    // engine read the same empty attribute as unity.
+    const { binding, onSetAttributeQuiet } = bind({ volume: "" });
+    act(() => binding.onAutomateVolume());
+    expect(JSON.parse(String(onSetAttributeQuiet.mock.calls[0][1])).lanes[0].points[0].v).toBe(1);
+  });
+
+  it("seeds at unity when data-volume is not a number", () => {
+    const { binding, onSetAttributeQuiet } = bind({ volume: "loud" });
+    act(() => binding.onAutomateVolume());
+    expect(JSON.parse(String(onSetAttributeQuiet.mock.calls[0][1])).lanes[0].points[0].v).toBe(1);
+  });
 });

packages/studio/src/components/editor/useVolumeAutomation.ts

@@ -24,15 +24,22 @@ export interface VolumeAutomationBinding {
 
 export function useVolumeAutomation(
   element: DomEditSelection,
-  onSetAttribute: (attr: string, value: string) => void | Promise<void>,
+  onSetAttributeQuiet: (attr: string, value: string | null) => void | Promise<void>,
 ): VolumeAutomationBinding {
   // The chain is not needed to resolve a volume lane — volume is always a valid
   // target — so this deliberately does not parse it.
   const automation = readPanelAutomation(element.dataAttributes?.["automation"], undefined);
   const write = (next: Parameters<typeof automationAttrValue>[0]): void => {
-    void onSetAttribute(HF_AUDIO_AUTOMATION_ATTR, automationAttrValue(next));
+    // Quiet: clicking the toggle used to reload the preview and restart every
+    // playing track, while the same click on an effect parameter did not.
+    void onSetAttributeQuiet(HF_AUDIO_AUTOMATION_ATTR, automationAttrValue(next) || null);
   };
-  const current = Number(element.dataAttributes?.["volume"] ?? "1");
+  // `??` alone would let an empty `data-volume` through as Number("") === 0, so
+  // automating the track would seed its lane at silence. The engine reads the same
+  // empty value as unity.
+  const raw = element.dataAttributes?.["volume"];
+  const parsed = raw ? Number(raw) : 1;
+  const current = Number.isFinite(parsed) ? parsed : 1;
   return {
     volumeAutomated: automation.lanes.some((lane) => lane.target === VOLUME_TARGET),
     // Seeded at the level the slider already shows, so automating the track does

packages/studio/src/player/components/useAutomationLanes.ts

@@ -58,7 +58,11 @@ export function useAutomationLanes(): UseAutomationLanesResult {
       const write = (next: HfAutomation, persist: boolean): void => {
         if (!domEdit || !isSelected) return;
         const value = next.lanes.length > 0 ? serializeAutomation(next) : "";
-        if (persist) void domEdit.handleDomAttributeCommit(HF_AUDIO_AUTOMATION_ATTR, value);
+        // Quiet, not the refreshing commit: releasing a dragged point used to
+        // reload the preview, which restarts every playing track — the same chop
+        // the live write during the drag exists to avoid. Quiet still persists
+        // and still resyncs the selection, so the next edit sees this one.
+        if (persist) void domEdit.handleDomAttributeQuietCommit(HF_AUDIO_AUTOMATION_ATTR, value);
         // Dragging a point writes live: no preview refresh, so the composition
         // does not reload and restart playback on every pixel.
         else void domEdit.handleDomAttributeLiveCommit(HF_AUDIO_AUTOMATION_ATTR, value || null);