fix(studio,core,cli): review hardening for beat detection + timeline UX

- playerStore.reset() now clears beat state (analysis, edits, undo/redo,
  persist) so a project switch can't apply the previous project's beats,
  undo stack, or file-writer to the new one.
- removeUserBeat returns the same reference on a no-op, and delete/move beat
  actions skip committing when nothing changed — no more phantom undo
  entries / debounced writes for no-op edits.
- regularizeBeats bails to raw onsets when the (octave-misread) tempo would
  produce a sub-125ms grid, avoiding a tens-of-thousands-of-beats freeze.
- parseBeats clamps strength to [0,1] and rejects non-finite time/strength,
  so a hand-edited file can't feed NaN into the gamma curve (Math.pow on a
  negative base) and blank out beat markers.
- Start-edge beat-snap now also requires duration >= minDuration, matching
  the end-edge guard, so a rightward snap can't collapse the clip.
- Center-anchor zoom effect always consumes its skip flag, so a pinch that
  produced no pps change can't leave it stranded and skip the next zoom.
- Headless beats analyzer projects to {beatTimes,beatStrengths,bpm,confidence}
  before returning, so page.evaluate no longer serializes the full decoded
  PCM (channelData) across the CDP boundary.

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

Co-authored-by: Miguel Ángel <miguel07alm@protonmail.com>

Author: vanceingalls

packages/cli/src/beats/headlessAnalyzer.ts

@@ -89,10 +89,21 @@ function inPageAnalyze(data: string) {
   };
   if (typeof win.__hfAnalyze !== "function") throw new Error("beat analyzer not loaded");
   const ctx = new (win.AudioContext || win.webkitAudioContext!)();
-  return ctx
-    .decodeAudioData(bytes.buffer)
-    .then((buf) => win.__hfAnalyze!(buf))
-    .finally(() => ctx.close());
+  return (
+    ctx
+      .decodeAudioData(bytes.buffer)
+      .then((buf) => win.__hfAnalyze!(buf))
+      // analyzeMusicFromBuffer also returns the decoded PCM (channelData) + sampleRate;
+      // project to only the fields we need so page.evaluate doesn't serialize an
+      // ~8-million-element Float32Array back across the CDP boundary.
+      .then((r) => ({
+        beatTimes: r.beatTimes,
+        beatStrengths: r.beatStrengths,
+        bpm: r.bpm,
+        bpmConfidence: r.bpmConfidence,
+      }))
+      .finally(() => ctx.close())
+  );
 }
 
 // Load the analyzer bundle into the page, run analysis, and surface in-page

packages/core/src/beats/beatDetection.ts

@@ -144,6 +144,10 @@ function octaveAlignBpm(bpm: number, reference: number): number {
 function regularizeBeats(rawBeats: number[], bpm: number, duration: number): number[] {
   if (rawBeats.length === 0 || bpm <= 0 || duration <= 0) return rawBeats;
   const beatInterval = 60 / bpm;
+  // Guard against a pathological (octave-misread) tempo producing a millisecond
+  // interval → tens of thousands of grid beats that freeze the timeline. 480 BPM
+  // (0.125s) is well above any real music tempo; bail to the raw onsets instead.
+  if (beatInterval < 0.125) return rawBeats;
   const threshold = beatInterval * 0.25;
 
   // Find phase offset that maximally aligns with raw onsets

packages/core/src/beats/beatFile.ts

@@ -63,9 +63,13 @@ export function parseBeats(content: string): { times: number[]; strengths: numbe
     const times: number[] = [];
     const strengths: number[] = [];
     for (const b of data.beats) {
-      if (b && typeof b.time === "number") {
+      if (b && typeof b.time === "number" && Number.isFinite(b.time)) {
         times.push(b.time);
-        strengths.push(typeof b.strength === "number" ? b.strength : 0.5);
+        // Clamp to [0,1] — a hand-edited file could carry an out-of-range or
+        // non-finite strength, and the renderers feed it into Math.pow(s, 2.2)
+        // (NaN for a negative base).
+        const s = typeof b.strength === "number" && Number.isFinite(b.strength) ? b.strength : 0.5;
+        strengths.push(Math.max(0, Math.min(1, s)));
       }
     }
     return { times, strengths };

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

@@ -365,11 +365,19 @@ export function useTimelineClipDrag({
               nextResize.playbackStart != null
                 ? nextResize.playbackStart / playbackRate
                 : Number.POSITIVE_INFINITY;
-            if (snapped !== nextResize.start && snapped >= 0 && delta <= maxLeftDelta + 1e-6) {
+            // Also require the resulting duration to stay >= minDuration so a
+            // rightward snap (delta < 0) can't collapse the clip to zero/negative.
+            const snappedDuration = Math.round((nextResize.duration + delta) * 1000) / 1000;
+            if (
+              snapped !== nextResize.start &&
+              snapped >= 0 &&
+              delta <= maxLeftDelta + 1e-6 &&
+              snappedDuration >= 0.05
+            ) {
               nextResize = {
                 ...nextResize,
                 start: snapped,
-                duration: Math.round((nextResize.duration + delta) * 1000) / 1000,
+                duration: snappedDuration,
                 playbackStart:
                   nextResize.playbackStart != null
                     ? Math.round(

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

@@ -64,11 +64,12 @@ export function useTimelinePlayhead({
     const scroll = scrollRef.current;
     const prevPps = previousAnchorPpsRef.current;
     previousAnchorPpsRef.current = pps;
-    if (!scroll || pps === prevPps) return;
-    if (skipCenterAnchorRef.current) {
-      skipCenterAnchorRef.current = false;
-      return;
-    }
+    // Always consume the skip flag, even when pps didn't change — otherwise a
+    // pinch that produced no pps change (already at the zoom clamp) would strand
+    // it true and the next toolbar zoom would wrongly skip center-anchoring.
+    const skip = skipCenterAnchorRef.current;
+    skipCenterAnchorRef.current = false;
+    if (!scroll || pps === prevPps || skip) return;
     const nextScrollLeft = getTimelineScrollLeftForZoomAnchor({
       pointerX: scroll.clientWidth / 2,
       currentScrollLeft: scroll.scrollLeft,

packages/studio/src/player/store/playerStore.ts

@@ -338,5 +338,12 @@ export const usePlayerStore = create<PlayerState>((set, get) => ({
       selectedKeyframes: new Set(),
       selectedElementIds: new Set(),
       keyframeCache: new Map(),
+      // Beat state is project-specific — clear it so a project switch can't
+      // apply the previous project's beats/undo/persist to the new one.
+      beatAnalysis: null,
+      beatEdits: null,
+      beatUndo: [],
+      beatRedo: [],
+      beatPersist: null,
     }),
 }));

packages/studio/src/utils/beatEditActions.ts

@@ -87,10 +87,9 @@ export function deleteBeatAtCompositionTime(compT: number): void {
   const c = ctx();
   if (!c) return;
   const audioT = compToAudio(c.music.start, c.music.playbackStart ?? 0, compT);
-  c.s.commitBeatEdits(
-    removeUserBeat(c.s.beatEdits, c.src, c.analysis.beatTimes, audioT),
-    "delete beat",
-  );
+  const next = removeUserBeat(c.s.beatEdits, c.src, c.analysis.beatTimes, audioT);
+  // No-op when there was no beat to remove — skip the undo entry + write.
+  if (next !== c.s.beatEdits) c.s.commitBeatEdits(next, "delete beat");
 }
 
 export function moveBeatCompositionTime(fromCompT: number, toCompT: number): void {
@@ -101,11 +100,10 @@ export function moveBeatCompositionTime(fromCompT: number, toCompT: number): voi
   const toAudio = compToAudio(c.music.start, playbackStart, toCompT);
   const clamped = Math.max(playbackStart, Math.min(playbackStart + clipDuration(c.music), toAudio));
   const strength = strengthAtTime(c.analysis, clamped);
-  c.s.commitBeatEdits(
-    moveUserBeat(c.s.beatEdits, c.src, c.analysis.beatTimes, fromAudio, {
-      time: clamped,
-      strength,
-    }),
-    "move beat",
-  );
+  const next = moveUserBeat(c.s.beatEdits, c.src, c.analysis.beatTimes, fromAudio, {
+    time: clamped,
+    strength,
+  });
+  // No-op when the move resolves to no change — skip the undo entry + write.
+  if (next !== c.s.beatEdits) c.s.commitBeatEdits(next, "move beat");
 }

packages/studio/src/utils/beatEditing.ts

@@ -92,20 +92,31 @@ export function addUserBeat(
   return next;
 }
 
-/** Remove the beat nearest `time` — drops a user-added beat or hides a detected one. */
+/**
+ * Remove the beat nearest `time` — drops a user-added beat or hides a detected
+ * one. Returns the SAME reference when nothing changed (no added beat near
+ * `time`, and no live detected beat to hide) so callers can skip persisting a
+ * phantom edit/undo/write.
+ */
 export function removeUserBeat(
   edits: BeatEditState | null,
   src: string,
   detectedTimes: number[],
   time: number,
-): BeatEditState {
+): BeatEditState | null {
+  const active = activeEdits(edits, src);
+  const hasAdded = (active?.added ?? []).some((b) => near(b.time, time));
+  const detected = detectedTimes.find((t) => near(t, time));
+  const alreadyHidden =
+    detected !== undefined && (active?.removed ?? []).some((r) => near(r, detected));
+  if (!hasAdded && (detected === undefined || alreadyHidden)) return edits;
+
   const next = base(edits, src);
   const ai = next.added.findIndex((b) => near(b.time, time));
   if (ai >= 0) {
     next.added.splice(ai, 1);
     return next;
   }
-  const detected = detectedTimes.find((t) => near(t, time));
   if (detected !== undefined && !next.removed.some((r) => near(r, detected))) {
     next.removed.push(detected);
   }
@@ -119,7 +130,7 @@ export function moveUserBeat(
   detectedTimes: number[],
   fromTime: number,
   toBeat: UserBeat,
-): BeatEditState {
+): BeatEditState | null {
   const removed = removeUserBeat(edits, src, detectedTimes, fromTime);
   return addUserBeat(removed, src, toBeat, detectedTimes) ?? removed;
 }