feat(studio): copy and paste automation ranges across lanes

.fallowrc.jsonc

@@ -176,6 +176,22 @@
         "withLane",
       ],
     },
+    // automationShapes is part of the audio-automation stack: its consumer is
+    // the UI layer that uses shape generators one PR upstack, so a per-PR audit
+    // diffing against the merge base sees these as unused. Consumed for real once
+    // the stack merges; safe to drop this entry then.
+    {
+      "file": "packages/studio/src/player/components/automationShapes.ts",
+      "exports": ["AUTOMATION_SHAPES"],
+    },
+    // automationSimplify is part of the audio-automation stack: its consumer is
+    // the UI layer one PR upstack, so a per-PR audit diffing against the merge
+    // base sees these as unused. Consumed for real once the stack merges; safe
+    // to drop this entry then.
+    {
+      "file": "packages/studio/src/player/components/automationSimplify.ts",
+      "exports": ["simplifyPoints"],
+    },
     // 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.
@@ -747,6 +763,11 @@
       "packages/parsers/src/gsapParser.ts",
       // htmlParser.ts has pre-existing complexity (moved from packages/core).
       "packages/parsers/src/htmlParser.ts",
+      // automationSimplify.ts: Ramer–Douglas–Peucker algorithm inherently requires
+      // nested loops and stack-based control flow (12 cyclomatic / 20 cognitive);
+      // this complexity is by design and not refactorable. Consumed by the UI
+      // layer one PR upstack in the audio-automation feature stack.
+      "packages/studio/src/player/components/automationSimplify.ts",
       // studio-server files: pre-existing complexity (moved from packages/core/src/studio-api/).
       // files.ts: executeGsapMutationRecast/Acorn are CRITICAL; excluded as files.ts
       // was already in health.ignore at the old path (packages/core/src/studio-api/routes/files.ts).

packages/studio/src/contexts/DomEditContext.tsx

@@ -117,6 +117,13 @@ export function useDomEditSelectionContext(): DomEditSelectionValue {
   return ctx;
 }
 
+/** Optional counterpart to useDomEditActionsContextOptional — same reason: the
+ *  player package's own components mount outside a provider in standalone and
+ *  test trees, where "no dom-edit selection" is the correct answer. */
+export function useDomEditSelectionContextOptional(): DomEditSelectionValue | null {
+  return useContext(DomEditSelectionContext);
+}
+
 /** @deprecated Prefer useDomEditActionsContext or useDomEditSelectionContext. */
 export function useDomEditContext(): DomEditValue {
   return { ...useDomEditActionsContext(), ...useDomEditSelectionContext() };

packages/studio/src/hooks/useAppHotkeys.test.ts

@@ -1,7 +1,9 @@
 // @vitest-environment happy-dom
 import { afterEach, describe, expect, it, vi } from "vitest";
-import { dispatchPlainKey } from "./useAppHotkeys";
+import { dispatchModifierKey, dispatchPlainKey } from "./useAppHotkeys";
 import { usePlayerStore } from "../player/store/playerStore";
+import { clearAutomationClipboard, copyRange } from "../player/components/automationClipboard";
+import { VOLUME_RANGE } from "@hyperframes/core/audio-automation";
 import type { TimelineElement } from "../player/store/timelineElement";
 
 /** Minimal valid fixture — TimelineElement only requires these five fields. */
@@ -38,7 +40,11 @@ function callbacks() {
 const press = (key: string) =>
   new KeyboardEvent("keydown", { key, bubbles: true, cancelable: true });
 
+const chord = (key: string) =>
+  new KeyboardEvent("keydown", { key, metaKey: true, bubbles: true, cancelable: true });
+
 afterEach(() => {
+  clearAutomationClipboard();
   usePlayerStore.getState().clearAutomationSelection();
   usePlayerStore.setState({
     elements: [],
@@ -111,3 +117,82 @@ describe("dispatchPlainKey — Delete arbitration", () => {
     expect(e.defaultPrevented).toBe(true);
   });
 });
+
+describe("dispatchModifierKey — Cmd+C/Cmd+V arbitration", () => {
+  const clip: TimelineElement = {
+    id: "bgm",
+    key: "bgm",
+    tag: "audio",
+    start: 0,
+    duration: 6,
+    track: 0,
+  };
+
+  it("lets the clip clipboard have Cmd+C when no automation range is active", () => {
+    usePlayerStore.setState({ elements: [clip], selectedElementId: "bgm" });
+    const cb = callbacks();
+    dispatchModifierKey(chord("c"), "c", cb);
+    expect(cb.handleCopy).toHaveBeenCalled();
+  });
+
+  it("keeps Cmd+C from the clip clipboard when an automation range is active", () => {
+    // Both clipboards arming on one press double-wrote and toasted "Copied clip".
+    usePlayerStore.setState({ elements: [clip], selectedElementId: "bgm" });
+    usePlayerStore.getState().setAutomationSelection({
+      elementKey: "bgm",
+      target: "volume",
+      t0: 1,
+      t1: 3,
+    });
+    const cb = callbacks();
+    const e = chord("c");
+    expect(dispatchModifierKey(e, "c", cb)).toBe(true);
+    expect(cb.handleCopy).not.toHaveBeenCalled();
+    // No preventDefault: the automation handler downstream still needs the key.
+    expect(e.defaultPrevented).toBe(false);
+  });
+
+  it("lets the clip clipboard have Cmd+V when the automation clipboard is empty", () => {
+    // Nothing to paste means nothing to claim — the clip paste should still run.
+    clearAutomationClipboard();
+    usePlayerStore.setState({ elements: [clip], selectedElementId: "bgm" });
+    usePlayerStore.getState().setAutomationSelection({
+      elementKey: "bgm",
+      target: "volume",
+      t0: 1,
+      t1: 3,
+    });
+    const cb = callbacks();
+    dispatchModifierKey(chord("v"), "v", cb);
+    expect(cb.handlePaste).toHaveBeenCalled();
+  });
+
+  it("keeps Cmd+V from duplicating the clip while an automation paste is pending", () => {
+    clearAutomationClipboard();
+    copyRange(
+      null,
+      {
+        target: "volume",
+        points: [
+          { t: 1, v: 1 },
+          { t: 3, v: 0.25 },
+        ],
+      },
+      VOLUME_RANGE,
+      1,
+      3,
+    );
+    usePlayerStore.setState({ elements: [clip], selectedElementId: "bgm" });
+    usePlayerStore.getState().setAutomationSelection({
+      elementKey: "bgm",
+      target: "volume",
+      t0: 1,
+      t1: 3,
+    });
+    const cb = callbacks();
+    const e = chord("v");
+    dispatchModifierKey(e, "v", cb);
+    expect(cb.handlePaste).not.toHaveBeenCalled();
+    expect(e.defaultPrevented).toBe(false);
+  });
+});

packages/studio/src/hooks/useAppHotkeys.ts

@@ -1,10 +1,12 @@
 import { useCallback, useEffect, useRef } from "react";
+import { automationOwnsKey } from "./useAutomationSelectionKeyboard";
 import { usePlayerStore } from "../player";
 import type { TimelineElement } from "../player";
 import type { DomEditSelection } from "../components/editor/domEditing";
 import type { LeftSidebarHandle } from "../components/sidebar/LeftSidebar";
 import { STUDIO_MOTION_PATH } from "../components/editor/studioMotion";
 import { isTypingTarget } from "../utils/typingTarget";
+import { isEditableTarget } from "../utils/timelineDiscovery";
 import { shouldIgnoreHistoryShortcut } from "../utils/studioHelpers";
 import { canSplitElement } from "../utils/timelineElementSplit";
 import { trackStudioEvent } from "../utils/studioTelemetry";
@@ -158,7 +160,14 @@ interface HotkeyCallbacks {
   showToast: (message: string, tone?: "error" | "info") => void;
 }
 
-function dispatchModifierKey(event: KeyboardEvent, key: string, cb: HotkeyCallbacks): boolean {
+/** Exported for tests, like dispatchPlainKey below: lets the Cmd+C/Cmd+V
+ *  arbitration between an automation range and the clip clipboard be asserted
+ *  without standing up the whole hook. */
+export function dispatchModifierKey(
+  event: KeyboardEvent,
+  key: string,
+  cb: HotkeyCallbacks,
+): boolean {
   if (
     !shouldIgnoreHistoryShortcut(event.target) &&
     handleUndoRedoKey(
@@ -195,7 +204,15 @@ function dispatchModifierKey(event: KeyboardEvent, key: string, cb: HotkeyCallba
     return true;
   }
 
-  if (!event.shiftKey && !event.altKey && !isTypingTarget(event.target)) {
+  if (!event.shiftKey && !event.altKey && !isEditableTarget(event.target)) {
+    // An active automation range owns Cmd+C/Cmd+V, the same way it owns Delete
+    // below. This listener is on window/capture and runs before
+    // useAutomationSelectionKeyboard's document/capture handler, so without
+    // this the clip clipboard also claimed the key: Cmd+V duplicated the clip
+    // while the automation paste wrote the same file, and Cmd+C armed both
+    // clipboards and toasted "Copied clip". Return without preventDefault so
+    // the downstream handler still sees the key.
+    if (automationOwnsKey(event)) return true;
     if (key === "c") {
       if (cb.handleCopy()) {
         event.preventDefault();