feat(studio): GSAP tween editing in Design panel (#1102)

* feat(studio): GSAP tween editing in Design panel

Add a GSAP animation editor to the studio Design panel: select an element,
view and edit its tweens (properties, easing, timing), add/delete animations,
and drag custom bezier speed curves — all persisted back to the composition
HTML. Gated behind VITE_STUDIO_ENABLE_GSAP_PANEL.

Parsing of existing GSAP source now uses a recast + Babel AST parser instead of
regex, giving scope resolution, stable tween IDs, and round-trip preservation of
extras and unresolved raw values.

recast compiles to CommonJS that calls require("fs"), which breaks browser and
Vite SSR bundles. To contain it, @hyperframes/core is split into an isomorphic
layer and a Node-only AST layer:

- gsapSerialize.ts holds the recast-free helpers (serialization, keyframe
  conversion, validation, shared types). htmlParser.ts is now fully isomorphic.
- parseGsapScript and the script-mutation helpers live in gsapParser.ts,
  reachable only via the @hyperframes/core/gsap-parser subpath, loaded
  server-side by the studio-api mutation routes and the linter via dynamic
  import (recast stays external under SSR).
- The barrel and the gsap-constants subpath are recast-free, so studio browser
  bundles never trace recast.

Adds AST parser unit + stress coverage and e2e helpers for the panel.

* fix(lint): await async lintHyperframeHtml in all callers

lintHyperframeHtml became async (gsap rules use dynamic import)
but lintProject and check-hyperframe-static weren't awaiting it,
causing typecheck failures and runtime crashes in CI.

Also wire LintRule type in gsap rules to fix fallow unused-type
finding, and suppress render.ts exported-for-tests symbols.

packages/studio/src/hooks/useGsapTweenCache.ts

@@ -0,0 +1,80 @@
+import { useCallback, useEffect, useMemo, useRef, useState } from "react";
+import type { GsapAnimation, ParsedGsap } from "@hyperframes/core/gsap-parser";
+
+function getAnimationsForElement(animations: GsapAnimation[], elementId: string): GsapAnimation[] {
+  return animations.filter((a) => a.targetSelector === `#${elementId}`);
+}
+
+async function fetchParsedAnimations(
+  projectId: string,
+  sourceFile: string,
+): Promise<ParsedGsap | null> {
+  try {
+    const res = await fetch(
+      `/api/projects/${encodeURIComponent(projectId)}/gsap-animations/${encodeURIComponent(sourceFile)}`,
+    );
+    return res.ok ? ((await res.json()) as ParsedGsap) : null;
+  } catch {
+    return null;
+  }
+}
+
+export function useGsapAnimationsForElement(
+  projectId: string | null,
+  sourceFile: string,
+  elementId: string | null,
+  version: number,
+): {
+  animations: GsapAnimation[];
+  multipleTimelines: boolean;
+  unsupportedTimelinePattern: boolean;
+} {
+  const [allAnimations, setAllAnimations] = useState<GsapAnimation[]>([]);
+  const [multipleTimelines, setMultipleTimelines] = useState(false);
+  const [unsupportedTimelinePattern, setUnsupportedTimelinePattern] = useState(false);
+  const lastFetchKeyRef = useRef("");
+
+  useEffect(() => {
+    const fetchKey = `${projectId}:${sourceFile}:${version}`;
+    if (fetchKey === lastFetchKeyRef.current) return;
+    lastFetchKeyRef.current = fetchKey;
+
+    if (!projectId) {
+      setAllAnimations([]);
+      setMultipleTimelines(false);
+      setUnsupportedTimelinePattern(false);
+      return;
+    }
+
+    let cancelled = false;
+    fetchParsedAnimations(projectId, sourceFile).then((parsed) => {
+      if (cancelled) return;
+      if (!parsed) {
+        setAllAnimations([]);
+        setMultipleTimelines(false);
+        setUnsupportedTimelinePattern(false);
+        return;
+      }
+      setAllAnimations(parsed.animations);
+      setMultipleTimelines(parsed.multipleTimelines === true);
+      setUnsupportedTimelinePattern(parsed.unsupportedTimelinePattern === true);
+    });
+
+    return () => {
+      cancelled = true;
+    };
+  }, [projectId, sourceFile, version]);
+
+  const animations = useMemo(
+    () => (elementId ? getAnimationsForElement(allAnimations, elementId) : []),
+    [allAnimations, elementId],
+  );
+
+  return { animations, multipleTimelines, unsupportedTimelinePattern };
+}
+
+export function useGsapCacheVersion() {
+  const [version, setVersion] = useState(0);
+  const bump = useCallback(() => setVersion((v) => v + 1), []);
+  return { version, bump };
+}