@hyperframes/studio 0.8.107 → 0.8.109

package/src/player/components/audioClipLink.ts

@@ -1,33 +1,80 @@
-import type { TimelineElement } from "../store/timelineElement";
+import { sameCompositionScope, type TimelineElement } from "../store/timelineElement";
 
-function mediaFileKey(src: string | undefined): string | null {
+type LinkScoped = Pick<TimelineElement, "sourceFile" | "compositionScope">;
+type LinkedElement = Pick<TimelineElement, "id" | "key" | "link"> & LinkScoped;
+
+const keyOf = (element: Pick<TimelineElement, "id" | "key">) => element.key ?? element.id;
+
+const SOURCE_BASE = "https://project.invalid/";
+const SOURCE_ORIGIN = new URL(SOURCE_BASE).origin;
+
+export function mediaAssetIdentity(
+  element: Pick<TimelineElement, "src" | "sourceFile">,
+): string | null {
+  const src = element.src?.trim();
   if (!src) return null;
-  const path = src.split(/[?#]/, 1)[0] ?? "";
-  const segment = path.split(/[/\\]/).pop()?.trim().toLowerCase() ?? "";
-  return segment.length > 0 ? segment : null;
+  try {
+    const url = new URL(src, new URL(element.sourceFile ?? "index.html", SOURCE_BASE));
+    if (url.origin !== SOURCE_ORIGIN) return `${url.origin}${url.pathname}${url.search}`;
+    return decodeURIComponent(`${url.origin}${url.pathname}`);
+  } catch {
+    return null;
+  }
 }
 
-export function audioPillFlags(
-  audio: Pick<TimelineElement, "id" | "tag" | "src" | "hidden" | "audioGroupHidden">,
-  elements: readonly Pick<TimelineElement, "id" | "tag" | "src">[],
-): { muted: boolean; linked: boolean } {
-  return {
-    muted: audio.hidden === true || audio.audioGroupHidden === true,
-    linked: isLinkedVideoAudio(audio, elements),
-  };
+function isLinked(element: Pick<TimelineElement, "link">): boolean {
+  return typeof element.link === "string" && element.link.length > 0;
 }
 
-/** An audio pill whose file is also a video clip on this timeline. */
-export function isLinkedVideoAudio(
-  audio: Pick<TimelineElement, "id" | "tag" | "src">,
-  elements: readonly Pick<TimelineElement, "id" | "tag" | "src">[],
+export function sharesLinkGroup(
+  a: Pick<TimelineElement, "link"> & LinkScoped,
+  b: Pick<TimelineElement, "link"> & LinkScoped,
 ): boolean {
-  if (audio.tag.trim().toLowerCase() !== "audio") return false;
-  const key = mediaFileKey(audio.src);
-  if (!key) return false;
-  return elements.some((element) => {
-    if (element.id === audio.id) return false;
-    if (element.tag.trim().toLowerCase() !== "video") return false;
-    return mediaFileKey(element.src) === key;
-  });
+  return isLinked(a) && a.link === b.link && sameCompositionScope(a, b);
+}
+
+export function audioPillFlags(
+  audio: Pick<TimelineElement, "hidden" | "audioGroupHidden">,
+  _elements?: readonly unknown[],
+): { muted: boolean } {
+  return { muted: audio.hidden === true || audio.audioGroupHidden === true };
+}
+
+export function linkedMembersOf<T extends LinkedElement>(
+  element: T,
+  elements: readonly T[],
+  linked = true,
+): T[] {
+  if (!linked || !isLinked(element)) return [element];
+  const members = elements.filter((candidate) => sharesLinkGroup(candidate, element));
+  return members.some((member) => keyOf(member) === keyOf(element))
+    ? members
+    : [element, ...members];
+}
+
+export function expandToLinkedMembers(
+  keys: Iterable<string>,
+  elements: readonly LinkedElement[],
+  linked = true,
+): Set<string> {
+  const expanded = new Set(keys);
+  if (!linked) return expanded;
+  const seeds = elements.filter((el) => expanded.has(keyOf(el)) && isLinked(el));
+  for (const element of elements) {
+    if (seeds.some((seed) => sharesLinkGroup(seed, element))) expanded.add(keyOf(element));
+  }
+  return expanded;
+}
+
+export function linkedGestureKeys(
+  selected: ReadonlySet<string>,
+  grabbed: LinkedElement,
+  elements: readonly LinkedElement[],
+  altKey: boolean,
+  linked = true,
+): Set<string> {
+  const grabbedKey = keyOf(grabbed);
+  if (altKey) return new Set([grabbedKey]);
+  const base = selected.has(grabbedKey) ? selected : [grabbedKey];
+  return expandToLinkedMembers(base, elements, linked);
 }

package/src/player/components/clipMenuAudioItems.noShell.test.tsx

@@ -0,0 +1,78 @@
+// @vitest-environment happy-dom
+import { act } from "react";
+import { afterEach, describe, expect, it, vi } from "vitest";
+import { createHappyDomRootHarness } from "./testRootHarness";
+import { ClipMenuAudioItems } from "./clipMenuAudioItems";
+import { usePlayerStore } from "../store/playerStore";
+import { usePreviewIframeStore } from "../store/previewIframeStore";
+import type { TimelineElement } from "../store/timelineElement";
+
+const onNotice = vi.fn();
+const setQuiet = vi.fn(async () => {});
+
+vi.mock("../../contexts/StudioContext", () => ({
+  useStudioShellContextOptional: () => null,
+}));
+vi.mock("../../contexts/TimelineEditContext", () => ({
+  useTimelineEditContextOptional: () => ({ onSetElementAttributeQuiet: setQuiet, onNotice }),
+}));
+
+const harness = createHappyDomRootHarness();
+const tour: TimelineElement = {
+  id: "tour",
+  tag: "video",
+  start: 0,
+  duration: 4,
+  track: 0,
+  hasAudio: true,
+  src: "tour.mp4",
+};
+
+function mountPreview(): void {
+  const iframe = document.createElement("iframe");
+  document.body.appendChild(iframe);
+  const doc = iframe.contentDocument;
+  if (!doc) throw new Error("iframe has no document");
+  doc.body.innerHTML =
+    '<video id="tour" src="tour.mp4" data-has-audio="true" data-start="0" data-duration="4"></video><audio id="voiceover" src="vo.wav" data-start="1" data-duration="2"></audio>';
+  usePreviewIframeStore.getState().setIframe(iframe);
+}
+
+function render(part: "normalize" | "duck") {
+  const host = document.createElement("div");
+  document.body.appendChild(host);
+  act(() =>
+    harness
+      .mount(host)
+      .render(<ClipMenuAudioItems part={part} element={tour} onClose={() => {}} />),
+  );
+  return host;
+}
+
+afterEach(() => {
+  usePreviewIframeStore.getState().setIframe(null);
+  vi.unstubAllGlobals();
+});
+
+describe("ClipMenuAudioItems in a host without Studio's shell", () => {
+  it("offers Normalize and Duck from the timeline session and the live preview", () => {
+    usePlayerStore.getState().beginTimelineSession("p1");
+    mountPreview();
+    expect(render("normalize").textContent).toContain("Normalize loudness");
+    expect(render("duck").textContent).toContain("Duck under voice");
+  });
+
+  it("normalizes through the session's project and reports through onNotice", async () => {
+    usePlayerStore.getState().beginTimelineSession("p1");
+    mountPreview();
+    const plan = { targetLufs: -16, projectedLufs: -16, volume: 2, changeDb: 6, limitedBy: null };
+    const fetchSpy = vi.fn(async (_url: string) => Response.json({ plan }));
+    vi.stubGlobal("fetch", fetchSpy);
+    const button = render("normalize").querySelector("button");
+    await act(async () => button?.click());
+    await vi.waitFor(() => expect(onNotice).toHaveBeenCalled());
+    expect(String(fetchSpy.mock.calls[0]?.[0])).toContain("/api/projects/p1/loudness/normalize");
+    expect(setQuiet).toHaveBeenCalledWith(tour, "data-volume", "2", "Normalize loudness");
+    expect(onNotice).toHaveBeenCalledWith("Normalized to −16 LUFS (+6.0 dB)", "info");
+  });
+});

package/src/player/components/clipMenuAudioItems.test.tsx

@@ -0,0 +1,168 @@
+// @vitest-environment happy-dom
+import { act } from "react";
+import { beforeEach, describe, expect, it, vi } from "vitest";
+import { createHappyDomRootHarness } from "./testRootHarness";
+import { ClipMenuAudioItems } from "./clipMenuAudioItems";
+import type { TimelineElement } from "../store/timelineElement";
+
+const showToast = vi.fn();
+const setQuiet = vi.fn<(...args: unknown[]) => Promise<unknown>>(async () => {});
+let previewDoc: Document | null = null;
+const iframe = {
+  get contentDocument() {
+    return previewDoc;
+  },
+};
+
+vi.mock("../../contexts/StudioContext", () => ({
+  useStudioShellContextOptional: () => ({
+    projectId: "p1",
+    showToast,
+    previewIframeRef: { current: iframe },
+  }),
+}));
+vi.mock("../../contexts/TimelineEditContext", () => ({
+  useTimelineEditContextOptional: () => ({ onSetElementAttributeQuiet: setQuiet }),
+}));
+
+const harness = createHappyDomRootHarness();
+
+function render(element: TimelineElement, part: "normalize" | "duck" = "normalize") {
+  const host = document.createElement("div");
+  document.body.appendChild(host);
+  act(() =>
+    harness
+      .mount(host)
+      .render(<ClipMenuAudioItems part={part} element={element} onClose={() => {}} />),
+  );
+  return host;
+}
+
+const base = { start: 0, duration: 4, track: 0 };
+const plan = { targetLufs: -16, projectedLufs: -16, volume: 2, changeDb: 6, limitedBy: null };
+const clickItem = async (host: HTMLElement, label: string) => {
+  const button = [...host.querySelectorAll("button")].find((b) => b.textContent?.includes(label));
+  await act(async () => button?.click());
+};
+
+beforeEach(() => {
+  showToast.mockClear();
+  setQuiet.mockReset();
+  setQuiet.mockResolvedValue(undefined);
+});
+
+describe("ClipMenuAudioItems", () => {
+  it("offers nothing on a muted video", () => {
+    const host = render({ ...base, id: "b", tag: "video", hasAudio: true, muted: true });
+    expect(host.textContent).toBe("");
+  });
+
+  describe("Duck under voice", () => {
+    const duckLabel = (host: HTMLElement) =>
+      [...host.querySelectorAll("button")].find((b) => b.textContent?.includes("Duck under voice"));
+    const compose = (body: string) => {
+      previewDoc = document.implementation.createHTMLDocument("c");
+      previewDoc.body.innerHTML = body;
+    };
+    const music: TimelineElement = { ...base, id: "music", tag: "audio", src: "music.mp3" };
+
+    it("is hidden on a lone video with sound", () => {
+      compose(
+        `<video id="a-roll" src="a.mp4" data-start="0" data-duration="4" data-has-audio="true"></video>`,
+      );
+      const host = render(
+        { ...base, id: "a-roll", tag: "video", hasAudio: true, src: "a.mp4" },
+        "duck",
+      );
+      expect(duckLabel(host)).toBeUndefined();
+    });
+
+    it("shows for a music bed with an overlapping voice", () => {
+      compose(`<audio id="music" src="music.mp3" data-start="0" data-duration="4"></audio>
+        <audio id="voiceover" src="vo.wav" data-start="1" data-duration="2"></audio>`);
+      const host = render(music, "duck");
+      expect(duckLabel(host)?.getAttribute("aria-checked")).toBe("false");
+    });
+
+    it("stays available, checked, once ducked even with the voice gone", () => {
+      compose(
+        `<audio id="music" src="music.mp3" data-start="0" data-duration="4" data-fx-carve='{"enabled":true,"sources":["voiceover"],"strength":0.25}'></audio>`,
+      );
+      const host = render(music, "duck");
+      const item = duckLabel(host);
+      expect(item?.getAttribute("aria-checked")).toBe("true");
+      expect(item?.textContent).toBe("Duck under voice✓");
+    });
+  });
+
+  it("normalizes a video with sound by writing data-volume as one edit", async () => {
+    const plan = { targetLufs: -16, projectedLufs: -16, volume: 2, changeDb: 6, limitedBy: null };
+    vi.stubGlobal(
+      "fetch",
+      vi.fn(async () => Response.json({ plan })),
+    );
+    const element: TimelineElement = {
+      ...base,
+      id: "a-roll",
+      tag: "video",
+      hasAudio: true,
+      src: "talk.mp4",
+    };
+    const host = render(element);
+    const button = [...host.querySelectorAll("button")].find((b) =>
+      b.textContent?.includes("Normalize loudness"),
+    );
+    await act(async () => button?.click());
+    await vi.waitFor(() => expect(setQuiet).toHaveBeenCalled());
+    expect(setQuiet).toHaveBeenCalledWith(element, "data-volume", "2", "Normalize loudness");
+    expect(showToast).toHaveBeenCalledWith("Normalized to −16 LUFS (+6.0 dB)", "info");
+    vi.unstubAllGlobals();
+  });
+
+  it("refuses to normalize a clip whose volume lane owns its gain", async () => {
+    const fetchSpy = vi.fn(async () => Response.json({ plan }));
+    vi.stubGlobal("fetch", fetchSpy);
+    const automation = JSON.stringify({
+      version: 1,
+      lanes: [{ target: "volume", points: [{ t: 0, v: 0.25 }] }],
+    });
+    const host = render({ ...base, id: "vo", tag: "audio", src: "vo.mp3", automation });
+    await clickItem(host, "Normalize loudness");
+    await vi.waitFor(() => expect(showToast).toHaveBeenCalled());
+    expect(showToast).toHaveBeenCalledWith(expect.stringContaining("volume is automated"), "error");
+    expect(setQuiet).not.toHaveBeenCalled();
+    expect(fetchSpy).not.toHaveBeenCalled();
+    vi.unstubAllGlobals();
+  });
+
+  it("reports a failed save instead of claiming the clip was normalized", async () => {
+    vi.stubGlobal(
+      "fetch",
+      vi.fn(async () => Response.json({ plan })),
+    );
+    setQuiet.mockResolvedValue({ status: "failed", reason: "disk full" });
+    const host = render({ ...base, id: "vo", tag: "audio", src: "vo.mp3" });
+    await clickItem(host, "Normalize loudness");
+    await vi.waitFor(() => expect(showToast).toHaveBeenCalledWith("disk full", "error"));
+    expect(showToast).not.toHaveBeenCalledWith(expect.stringContaining("Normalized"), "info");
+    vi.unstubAllGlobals();
+  });
+
+  it("stops ducking at the first refused save and says why", async () => {
+    previewDoc = document.implementation.createHTMLDocument("c");
+    previewDoc.body.innerHTML = `<audio id="music" src="music.mp3" data-start="0" data-duration="10"></audio>
+      <audio id="voiceover" src="vo.wav" data-start="1" data-duration="3"></audio>`;
+    setQuiet.mockResolvedValue({
+      status: "refused",
+      reason: "Cannot edit timeline while recording",
+    });
+    const host = render({ ...base, id: "music", tag: "audio", src: "music.mp3" }, "duck");
+    await clickItem(host, "Duck under voice");
+    await vi.waitFor(() =>
+      expect(showToast).toHaveBeenCalledWith("Cannot edit timeline while recording", "error"),
+    );
+    expect(setQuiet).toHaveBeenCalledTimes(1);
+    expect(showToast).not.toHaveBeenCalledWith(expect.stringContaining("Ducks under"), "info");
+    previewDoc = null;
+  });
+});

package/src/player/components/clipMenuAudioItems.tsx

@@ -0,0 +1,116 @@
+import { formatAudioGain } from "@hyperframes/core/audio-gain";
+import type { TimelineElement } from "../store/timelineElement";
+import { useTimelineEditContextOptional } from "../../contexts/TimelineEditContext";
+import { useStudioShellContextOptional } from "../../contexts/StudioContext";
+import { usePlayerStore } from "../store/playerStore";
+import { useLivePreviewIframe } from "../store/previewIframeStore";
+import {
+  clipHasSound,
+  normalizeToastText,
+  requestNormalizePlan,
+  throwUnlessSaved,
+  TimelineSaveError,
+  VOLUME_LANE_REFUSAL,
+  volumeLaneOwnsGain,
+} from "./clipMenuNormalize";
+import { offersDuck, readBedCarve, setDuckUnderVoice, type DuckOutcome } from "./clipMenuDuck";
+
+const ITEM_CLASS =
+  "w-full flex items-center justify-between px-3 py-1.5 text-xs text-left outline-hidden text-neutral-300 hover:bg-neutral-800 focus-visible:bg-neutral-800 cursor-pointer";
+
+const DUCK_TOAST: Record<DuckOutcome, string> = {
+  ducked: "Ducks under the voice. Normalize the voice first for the most even result.",
+  off: "No longer ducks under the voice.",
+  "no-voice": "No overlapping voice to duck under.",
+  aborted: "Could not group the voices to duck under.",
+};
+
+/** Normalize loudness (one-shot) or Duck under voice (toggle), placed separately in the sound group. */
+export function ClipMenuAudioItems({
+  part,
+  element,
+  onClose,
+}: {
+  part: "normalize" | "duck";
+  element: TimelineElement;
+  onClose: () => void;
+}) {
+  const shell = useStudioShellContextOptional();
+  const { onSetElementAttributeQuiet, onGroupClips, onNotice } = useTimelineEditContextOptional();
+  const liveIframe = useLivePreviewIframe();
+  const sessionProjectId = usePlayerStore((s) => s.timelineProjectId);
+  const projectId = shell?.projectId ?? sessionProjectId;
+  const showToast = shell?.showToast ?? onNotice;
+  const doc = (shell?.previewIframeRef.current ?? liveIframe)?.contentDocument ?? null;
+  const bed = doc?.getElementById(element.domId ?? element.id) ?? null;
+  const ducked = bed ? readBedCarve(bed)?.enabled === true : false;
+  if (!clipHasSound(element) || !projectId || !showToast || !onSetElementAttributeQuiet) {
+    return null;
+  }
+
+  const normalize = async () => {
+    onClose();
+    if (volumeLaneOwnsGain(element)) {
+      showToast(VOLUME_LANE_REFUSAL, "error");
+      return;
+    }
+    try {
+      const plan = await requestNormalizePlan(projectId, element);
+      throwUnlessSaved(
+        await onSetElementAttributeQuiet(
+          element,
+          "data-volume",
+          formatAudioGain(plan.volume),
+          "Normalize loudness",
+        ),
+      );
+      showToast(normalizeToastText(plan), "info");
+    } catch (error) {
+      showToast(error instanceof Error ? error.message : String(error), "error");
+    }
+  };
+
+  const toggleDuck = async () => {
+    onClose();
+    if (!doc || !bed) return;
+    const outcome = await setDuckUnderVoice(
+      doc,
+      bed,
+      !ducked,
+      async (attr, value) => {
+        throwUnlessSaved(
+          await onSetElementAttributeQuiet(element, attr, value, "Duck under voice"),
+        );
+      },
+      onGroupClips ? (ids, groupId) => onGroupClips(ids, groupId, "Voice") : undefined,
+    ).catch((error: unknown): DuckOutcome | TimelineSaveError =>
+      error instanceof TimelineSaveError ? error : "aborted",
+    );
+    if (outcome instanceof TimelineSaveError) {
+      showToast(outcome.message, "error");
+      return;
+    }
+    showToast(DUCK_TOAST[outcome], outcome === "aborted" ? "error" : "info");
+  };
+
+  if (part === "normalize") {
+    return (
+      <button type="button" role="menuitem" className={ITEM_CLASS} onClick={() => void normalize()}>
+        <span>Normalize loudness</span>
+      </button>
+    );
+  }
+  if (!offersDuck(doc, bed)) return null;
+  return (
+    <button
+      type="button"
+      role="menuitemcheckbox"
+      aria-checked={ducked}
+      className={ITEM_CLASS}
+      onClick={() => void toggleDuck()}
+    >
+      <span>Duck under voice</span>
+      <span aria-hidden="true">{ducked ? "✓" : ""}</span>
+    </button>
+  );
+}

package/src/player/components/clipMenuDuck.test.ts

@@ -0,0 +1,117 @@
+// @vitest-environment happy-dom
+import { describe, expect, it, vi } from "vitest";
+import { duckVoiceSources, isDuckableBed, readBedCarve, setDuckUnderVoice } from "./clipMenuDuck";
+
+function compose(body: string): Document {
+  const doc = document.implementation.createHTMLDocument("c");
+  doc.body.innerHTML = body;
+  return doc;
+}
+
+const BED = `<audio id="music" src="music.mp3" data-start="0" data-duration="10"></audio>`;
+
+describe("duckVoiceSources", () => {
+  it("offers an overlapping video with sound and a voiceover, never the bed or silent video", () => {
+    const doc = compose(`${BED}
+      <video id="talk" src="talk.mp4" data-start="0" data-duration="6" data-has-audio="true"></video>
+      <video id="b-roll" src="b.mp4" data-start="0" data-duration="6" muted></video>
+      <audio id="voiceover" src="vo.wav" data-start="2" data-duration="3"></audio>
+      <audio id="late-vo" src="vo2.wav" data-start="20" data-duration="3"></audio>`);
+    const bed = doc.getElementById("music");
+    expect(bed && duckVoiceSources(doc, bed)).toEqual(["talk", "voiceover"]);
+  });
+});
+
+describe("isDuckableBed", () => {
+  it("allows a music clip and refuses a voice clip", () => {
+    const doc = compose(`${BED}<audio id="voiceover" src="voiceover.wav"></audio>`);
+    expect(isDuckableBed(doc.getElementById("music"))).toBe(true);
+    expect(isDuckableBed(doc.getElementById("voiceover"))).toBe(false);
+  });
+
+  it("refuses a clip another bed is already carving against", () => {
+    const doc = compose(
+      `<audio id="music" src="music.mp3" data-fx-carve='{"enabled":true,"sources":["sting"],"strength":0.25}'></audio><audio id="sting" src="sting-bed.mp3"></audio>`,
+    );
+    expect(isDuckableBed(doc.getElementById("sting"))).toBe(false);
+  });
+});
+
+describe("setDuckUnderVoice", () => {
+  it("writes a carve at core's default strength naming the one voice", async () => {
+    const doc = compose(
+      `${BED}<audio id="voiceover" src="vo.wav" data-start="1" data-duration="3"></audio>`,
+    );
+    const bed = doc.getElementById("music");
+    if (!bed) throw new Error("fixture");
+    const write = vi.fn(async (attr: string, value: string | null) => {
+      if (value === null) bed.removeAttribute(attr);
+      else bed.setAttribute(attr, value);
+    });
+    await expect(setDuckUnderVoice(doc, bed, true, write)).resolves.toBe("ducked");
+    expect(readBedCarve(bed)).toEqual({ enabled: true, sources: ["voiceover"], strength: 0.25 });
+  });
+
+  it("groups several voices first so the carve names one group", async () => {
+    const doc = compose(`${BED}
+      <audio id="voiceover" src="vo.wav" data-start="1" data-duration="3"></audio>
+      <audio id="narration" src="n.wav" data-start="5" data-duration="3"></audio>`);
+    const bed = doc.getElementById("music");
+    if (!bed) throw new Error("fixture");
+    const write = vi.fn(async (attr: string, value: string | null) => {
+      if (value !== null) bed.setAttribute(attr, value);
+    });
+    const group = vi.fn(async () => {});
+    await setDuckUnderVoice(doc, bed, true, write, group);
+    expect(group).toHaveBeenCalledWith(["voiceover", "narration"], "voiceover-2");
+    expect(readBedCarve(bed)?.sources).toEqual(["voiceover-2"]);
+  });
+
+  it("reports no voice instead of writing an empty carve", async () => {
+    const doc = compose(BED);
+    const bed = doc.getElementById("music");
+    if (!bed) throw new Error("fixture");
+    const write = vi.fn(async () => {});
+    await expect(setDuckUnderVoice(doc, bed, true, write)).resolves.toBe("no-voice");
+    expect(write).not.toHaveBeenCalled();
+  });
+
+  it("turning it off disables the carve and drops the generated nodes and lanes", async () => {
+    const chain = {
+      version: 1,
+      nodes: [
+        { id: "c1", type: "peaking", enabled: true, fromCarve: true, params: {} },
+        { id: "eq", type: "highpass", enabled: true, params: {} },
+      ],
+    };
+    const automation = {
+      version: 1,
+      lanes: [
+        {
+          target: "fx.c1.gain",
+          points: [
+            { t: 0, v: 0 },
+            { t: 1, v: -3 },
+          ],
+        },
+      ],
+    };
+    const doc = compose(BED);
+    const bed = doc.getElementById("music");
+    if (!bed) throw new Error("fixture");
+    bed.setAttribute(
+      "data-fx-carve",
+      JSON.stringify({ enabled: true, sources: ["vo"], strength: 0.25 }),
+    );
+    bed.setAttribute("data-fx-chain", JSON.stringify(chain));
+    bed.setAttribute("data-automation", JSON.stringify(automation));
+    const writes: Array<[string, string | null]> = [];
+    await setDuckUnderVoice(doc, bed, false, async (attr, value) => {
+      writes.push([attr, value]);
+    });
+    const byAttr = new Map(writes);
+    expect(JSON.parse(byAttr.get("data-fx-carve") ?? "{}").enabled).toBe(false);
+    expect(byAttr.get("data-automation")).toBeNull();
+    expect(byAttr.get("data-fx-chain")).not.toContain("c1");
+  });
+});