diff --git a/.claude/settings.json b/.claude/settings.json
index fa4bc827c..deffac973 100644
--- a/.claude/settings.json
+++ b/.claude/settings.json
@@ -1,17 +1,3 @@
 {
-  "hooks": {
-    "PreToolUse": [
-      {
-        "matcher": "Bash",
-        "hooks": [
-          {
-            "type": "command",
-            "timeout": 180,
-            "statusMessage": "Running build + lint + typecheck before commit…",
-            "command": "node -e \"\nconst chunks = [];\nprocess.stdin.on('data', d => chunks.push(d));\nprocess.stdin.on('end', () => {\n  const input = JSON.parse(Buffer.concat(chunks).toString());\n  const cmd = input.tool_input?.command || '';\n  if (!/git\\\\s+commit\\\\b/.test(cmd)) process.exit(0);\n  const { execSync } = require('child_process');\n  const cwd = execSync('git rev-parse --show-toplevel', { encoding: 'utf8' }).trim();\n  const steps = [\n    ['bun run build', 'Build'],\n    ['bun run lint', 'Lint'],\n    ['bun run --filter \\'*\\' typecheck 2>&1 | grep -v \\'vitest\\\\|test\\\\.ts\\' || true', 'Typecheck'],\n  ];\n  const failures = [];\n  for (const [script, label] of steps) {\n    try { execSync(script, { cwd, stdio: 'pipe' }); }\n    catch (e) {\n      failures.push(label + ':\\\\n' + (e.stdout?.toString() || e.message).slice(0, 400));\n    }\n  }\n  if (failures.length > 0) {\n    process.stdout.write(JSON.stringify({\n      continue: false,\n      stopReason: '\\u274c Pre-commit checks failed:\\\\n\\\\n' + failures.join('\\\\n\\\\n') + '\\\\n\\\\nFix the issues above before committing.',\n    }));\n  }\n});\""
-          }
-        ]
-      }
-    ]
-  }
+  "hooks": {}
 }
diff --git a/.fallowrc.jsonc b/.fallowrc.jsonc
index 4703fa525..ea558d77d 100644
--- a/.fallowrc.jsonc
+++ b/.fallowrc.jsonc
@@ -31,6 +31,15 @@
     // Keyframe UI components — wired dynamically via EaseCurveSection/MotionPanel.
     "packages/studio/src/components/editor/KeyframeDiamond.tsx",
     "packages/studio/src/components/editor/SpringEaseEditor.tsx",
+    // MotionPathOverlay — rendered conditionally via DomEditOverlay.
+    "packages/studio/src/components/editor/MotionPathOverlay.tsx",
+    // AE-level keyframe Phase 2/3 components — scaffolded, wired in follow-up PRs.
+    "packages/studio/src/components/editor/DopesheetStrip.tsx",
+    "packages/studio/src/components/editor/StaggerControls.tsx",
+    "packages/studio/src/hooks/gsapRuntimePreview.ts",
+    "packages/studio/src/hooks/useKeyframeKeyboard.ts",
+    "packages/studio/src/player/components/TimelinePropertyRows.tsx",
+    "packages/studio/src/utils/audioBeatDetection.ts",
   ],
   "ignorePatterns": [
     "docs/**",
@@ -111,6 +120,17 @@
         "createFailedCaptureCalibrationEstimate",
       ],
     },
+    // propertyPanelHelpers: exported utility functions used conditionally by
+    // PropertyPanel features behind feature flags or consumed by external tools.
+    {
+      "file": "packages/studio/src/components/editor/propertyPanelHelpers.ts",
+      "exports": [
+        "EMPTY_FILTER_VALUE",
+        "BOX_SHADOW_PRESETS",
+        "clampPanelNumber",
+        "computeFitToChildrenSize",
+      ],
+    },
   ],
   "ignoreDependencies": [
     // Runtime/dynamic deps not visible to static analysis: tsup `external`,
diff --git a/packages/core/src/generators/hyperframes.ts b/packages/core/src/generators/hyperframes.ts
index 68307921b..f8da4e69c 100644
--- a/packages/core/src/generators/hyperframes.ts
+++ b/packages/core/src/generators/hyperframes.ts
@@ -7,7 +7,12 @@ import {
 } from "../core.types";
 import type { GsapAnimation } from "../parsers/gsapParser";
 import { serializeGsapAnimations, keyframesToGsapAnimations } from "../parsers/gsapParser";
-import { GSAP_CDN, BASE_STYLES, ZOOM_CONTAINER_STYLES } from "../templates/constants";
+import {
+  GSAP_CDN,
+  MOTIONPATH_CDN,
+  BASE_STYLES,
+  ZOOM_CONTAINER_STYLES,
+} from "../templates/constants";
 
 const GOOGLE_FONTS_BASE = "https://fonts.googleapis.com/css2";
 const FONT_WEIGHTS: Record<string, string> = {
@@ -337,6 +342,10 @@ export function generateHyperframesHtml(
     : "";
 
   const gsapCdnTag = includeScripts ? `  <script src="${GSAP_CDN}"></script>` : "";
+  const motionPathCdnTag =
+    includeScripts && gsapScript && /motionPath\s*[:{]/.test(gsapScript)
+      ? `\n  <script src="${MOTIONPATH_CDN}"></script>`
+      : "";
 
   const gsapScriptTag = includeScripts
     ? `  <script>
@@ -373,7 +382,7 @@ ${gsapScript}
   <meta charset="UTF-8">
   <meta name="viewport" content="width=device-width, initial-scale=1.0">
   ${includeStyles ? googleFontsLink : ""}
-  ${gsapCdnTag}
+  ${gsapCdnTag}${motionPathCdnTag}
 ${styleTags ? `  ${styleTags}` : ""}
 </head>
 <body>
diff --git a/packages/core/src/parsers/gsapConstants.ts b/packages/core/src/parsers/gsapConstants.ts
index 902e32fce..9cae4cc9f 100644
--- a/packages/core/src/parsers/gsapConstants.ts
+++ b/packages/core/src/parsers/gsapConstants.ts
@@ -76,4 +76,5 @@ export const SUPPORTED_EASES = [
   "spring-stiff",
   "spring-wobbly",
   "spring-heavy",
+  "steps(1)",
 ];
diff --git a/packages/core/src/parsers/gsapParser.test.ts b/packages/core/src/parsers/gsapParser.test.ts
index d4e0e7cd2..35032063f 100644
--- a/packages/core/src/parsers/gsapParser.test.ts
+++ b/packages/core/src/parsers/gsapParser.test.ts
@@ -16,6 +16,7 @@ import {
   updateKeyframeInScript,
   convertToKeyframesInScript,
   removeAllKeyframesFromScript,
+  addAnimationWithKeyframesToScript,
 } from "./gsapParser.js";
 import type { GsapAnimation } from "./gsapParser.js";
 import type { Keyframe } from "../core.types";
@@ -1504,3 +1505,202 @@ describe("keyframe mutations", () => {
     expect(anim.properties.opacity).toBe(1);
   });
 });
+
+describe("motionPath parsing", () => {
+  it("parses motionPath with waypoint array and curviness", () => {
+    const script = `
+      const tl = gsap.timeline({ paused: true });
+      tl.to("#el", {
+        motionPath: {
+          path: [{x: 0, y: 0}, {x: 200, y: -100}, {x: 400, y: 50}],
+          curviness: 1.5
+        },
+        duration: 2
+      }, 0);
+    `;
+    const result = parseGsapScript(script);
+    expect(result.animations).toHaveLength(1);
+    const anim = result.animations[0];
+
+    expect(anim.arcPath).toBeDefined();
+    expect(anim.arcPath!.enabled).toBe(true);
+    expect(anim.arcPath!.segments).toHaveLength(2);
+    expect(anim.arcPath!.segments[0].curviness).toBe(1.5);
+    expect(anim.arcPath!.segments[1].curviness).toBe(1.5);
+
+    expect(anim.keyframes).toBeDefined();
+    expect(anim.keyframes!.keyframes).toHaveLength(3);
+    expect(anim.keyframes!.keyframes[0].properties.x).toBe(0);
+    expect(anim.keyframes!.keyframes[0].properties.y).toBe(0);
+    expect(anim.keyframes!.keyframes[1].properties.x).toBe(200);
+    expect(anim.keyframes!.keyframes[1].properties.y).toBe(-100);
+    expect(anim.keyframes!.keyframes[2].properties.x).toBe(400);
+    expect(anim.keyframes!.keyframes[2].properties.y).toBe(50);
+  });
+
+  it("parses motionPath with type cubic and explicit control points", () => {
+    const script = `
+      const tl = gsap.timeline({ paused: true });
+      tl.to("#el", {
+        motionPath: {
+          path: [
+            {x: 0, y: 0},
+            {x: 50, y: -80}, {x: 150, y: -120},
+            {x: 200, y: -100},
+            {x: 250, y: -80}, {x: 350, y: 30},
+            {x: 400, y: 50}
+          ],
+          type: "cubic"
+        },
+        duration: 2
+      }, 0);
+    `;
+    const result = parseGsapScript(script);
+    const anim = result.animations[0];
+
+    expect(anim.arcPath).toBeDefined();
+    expect(anim.arcPath!.segments).toHaveLength(2);
+
+    expect(anim.arcPath!.segments[0].cp1).toEqual({ x: 50, y: -80 });
+    expect(anim.arcPath!.segments[0].cp2).toEqual({ x: 150, y: -120 });
+
+    expect(anim.arcPath!.segments[1].cp1).toEqual({ x: 250, y: -80 });
+    expect(anim.arcPath!.segments[1].cp2).toEqual({ x: 350, y: 30 });
+
+    expect(anim.keyframes!.keyframes).toHaveLength(3);
+    expect(anim.keyframes!.keyframes[0].properties).toEqual({ x: 0, y: 0 });
+    expect(anim.keyframes!.keyframes[1].properties).toEqual({ x: 200, y: -100 });
+    expect(anim.keyframes!.keyframes[2].properties).toEqual({ x: 400, y: 50 });
+  });
+
+  it("parses motionPath with autoRotate", () => {
+    const script = `
+      const tl = gsap.timeline({ paused: true });
+      tl.to("#el", {
+        motionPath: {
+          path: [{x: 0, y: 0}, {x: 200, y: 100}],
+          autoRotate: true
+        },
+        duration: 1
+      }, 0);
+    `;
+    const result = parseGsapScript(script);
+    const anim = result.animations[0];
+    expect(anim.arcPath!.autoRotate).toBe(true);
+  });
+
+  it("merges motionPath waypoints into existing keyframes", () => {
+    const script = `
+      const tl = gsap.timeline({ paused: true });
+      tl.to("#el", {
+        motionPath: {
+          path: [{x: 0, y: 0}, {x: 200, y: 100}],
+          curviness: 2
+        },
+        keyframes: {
+          "0%": { opacity: 1 },
+          "100%": { opacity: 0 }
+        },
+        duration: 2
+      }, 0);
+    `;
+    const result = parseGsapScript(script);
+    const anim = result.animations[0];
+
+    expect(anim.arcPath).toBeDefined();
+    expect(anim.arcPath!.segments).toHaveLength(1);
+    expect(anim.arcPath!.segments[0].curviness).toBe(2);
+
+    expect(anim.keyframes!.keyframes).toHaveLength(2);
+    expect(anim.keyframes!.keyframes[0].properties).toEqual({ opacity: 1, x: 0, y: 0 });
+    expect(anim.keyframes!.keyframes[1].properties).toEqual({ opacity: 0, x: 200, y: 100 });
+  });
+
+  it("skips motionPath with fewer than 2 waypoints", () => {
+    const script = `
+      const tl = gsap.timeline({ paused: true });
+      tl.to("#el", {
+        motionPath: { path: [{x: 0, y: 0}] },
+        duration: 1
+      }, 0);
+    `;
+    const result = parseGsapScript(script);
+    expect(result.animations[0].arcPath).toBeUndefined();
+  });
+
+  it("tween without motionPath parses identically to before", () => {
+    const script = `
+      const tl = gsap.timeline({ paused: true });
+      tl.to("#el", { x: 100, y: 200, duration: 1 }, 0);
+    `;
+    const result = parseGsapScript(script);
+    const anim = result.animations[0];
+    expect(anim.arcPath).toBeUndefined();
+    expect(anim.properties.x).toBe(100);
+    expect(anim.properties.y).toBe(200);
+  });
+});
+
+// ── addAnimationWithKeyframesToScript ──────────────────────────────────────
+
+describe("addAnimationWithKeyframesToScript", () => {
+  const BASE = `
+const tl = gsap.timeline({ paused: true });
+tl.to("#title", { x: 100, duration: 0.5 }, 0);
+  `.trim();
+
+  it("adds a new tween with keyframes after existing tweens", () => {
+    const { script, id } = addAnimationWithKeyframesToScript(BASE, "#box", 3, 0.5, [
+      { percentage: 0, properties: { x: 0 } },
+      { percentage: 100, properties: { x: 200 } },
+    ]);
+    expect(script).toContain("#box");
+    expect(script).toContain("keyframes");
+    expect(script).toContain('"0%"');
+    expect(script).toContain('"100%"');
+    expect(id).toBeTruthy();
+
+    const parsed = parseGsapScript(script);
+    expect(parsed.animations.length).toBe(2);
+    const newAnim = parsed.animations[1];
+    expect(newAnim.targetSelector).toBe("#box");
+    expect(newAnim.keyframes).toBeDefined();
+    expect(newAnim.keyframes!.keyframes.length).toBe(2);
+  });
+
+  it("preserves existing tween code", () => {
+    const { script } = addAnimationWithKeyframesToScript(BASE, "#new", 2, 1, [
+      { percentage: 0, properties: { opacity: 0 } },
+      { percentage: 100, properties: { opacity: 1 } },
+    ]);
+    expect(script).toContain("#title");
+    expect(script).toContain("x: 100");
+  });
+
+  it("produces a stable ID for the new animation", () => {
+    const { script, id } = addAnimationWithKeyframesToScript(BASE, "#el", 1, 1, [
+      { percentage: 0, properties: { y: 0 } },
+      { percentage: 100, properties: { y: 100 } },
+    ]);
+    expect(id).toContain("#el");
+    const parsed = parseGsapScript(script);
+    const match = parsed.animations.find((a) => a.id === id);
+    expect(match).toBeDefined();
+  });
+
+  it("includes per-keyframe ease when provided", () => {
+    const { script } = addAnimationWithKeyframesToScript(BASE, "#el", 0, 1, [
+      { percentage: 0, properties: { x: 0 }, ease: "power2.out" },
+      { percentage: 100, properties: { x: 100 } },
+    ]);
+    expect(script).toContain("power2.out");
+  });
+
+  it("returns original script on parse failure", () => {
+    const { script, id } = addAnimationWithKeyframesToScript("not valid js {{", "#el", 0, 1, [
+      { percentage: 0, properties: { x: 0 } },
+    ]);
+    expect(script).toBe("not valid js {{");
+    expect(id).toBe("");
+  });
+});
diff --git a/packages/core/src/parsers/gsapParser.ts b/packages/core/src/parsers/gsapParser.ts
index 478fbdbba..0a9888d32 100644
--- a/packages/core/src/parsers/gsapParser.ts
+++ b/packages/core/src/parsers/gsapParser.ts
@@ -11,6 +11,8 @@
 import * as recast from "recast";
 import { parse as babelParse } from "@babel/parser";
 import {
+  type ArcPathConfig,
+  type ArcPathSegment,
   type GsapAnimation,
   type GsapKeyframesData,
   type GsapMethod,
@@ -19,6 +21,8 @@ import {
 } from "./gsapSerialize";
 
 export type {
+  ArcPathConfig,
+  ArcPathSegment,
   GsapAnimation,
   GsapMethod,
   ParsedGsap,
@@ -685,6 +689,84 @@ function parseSimpleArrayKeyframes(node: any, scope: ScopeBindings): GsapKeyfram
   };
 }
 
+// ── MotionPath Parsing ────────────────────────────────────────────────────
+
+interface MotionPathParseResult {
+  arcPath: ArcPathConfig;
+  waypoints: Array<{ x: number; y: number }>;
+}
+
+function parseMotionPathNode(node: any, scope: ScopeBindings): MotionPathParseResult | undefined {
+  if (!node) return undefined;
+
+  let pathNode: any;
+  let autoRotate: boolean | number = false;
+  let curviness = 1;
+  let isCubic = false;
+
+  if (node.type === "ObjectExpression") {
+    for (const prop of node.properties ?? []) {
+      if (!isObjectProperty(prop)) continue;
+      const key = propKeyName(prop);
+      if (key === "path") pathNode = prop.value;
+      else if (key === "autoRotate") {
+        const val = resolveNode(prop.value, scope);
+        autoRotate = typeof val === "number" ? val : val === true;
+      } else if (key === "curviness") {
+        const val = resolveNode(prop.value, scope);
+        if (typeof val === "number") curviness = val;
+      } else if (key === "type") {
+        const val = resolveNode(prop.value, scope);
+        if (val === "cubic") isCubic = true;
+      }
+    }
+  } else if (node.type === "ArrayExpression") {
+    pathNode = node;
+  }
+
+  if (!pathNode || pathNode.type !== "ArrayExpression") return undefined;
+
+  const elements = pathNode.elements ?? [];
+  const coords: Array<{ x: number; y: number }> = [];
+  for (const elem of elements) {
+    if (!elem || elem.type !== "ObjectExpression") continue;
+    const rec = objectExpressionToRecord(elem, scope);
+    const x = typeof rec.x === "number" ? rec.x : undefined;
+    const y = typeof rec.y === "number" ? rec.y : undefined;
+    if (x !== undefined && y !== undefined) coords.push({ x, y });
+  }
+
+  if (coords.length < 2) return undefined;
+
+  let waypoints: Array<{ x: number; y: number }>;
+  const segments: ArcPathSegment[] = [];
+
+  if (isCubic && coords.length >= 4) {
+    // type: "cubic" — coords are [anchor, cp1, cp2, anchor, cp1, cp2, anchor, ...]
+    // Every 3rd coord starting from 0 is an anchor, the two between are control points.
+    waypoints = [];
+    waypoints.push(coords[0]!);
+    for (let i = 1; i + 2 < coords.length; i += 3) {
+      const cp1 = coords[i]!;
+      const cp2 = coords[i + 1]!;
+      const anchor = coords[i + 2]!;
+      waypoints.push(anchor);
+      segments.push({ curviness, cp1, cp2 });
+    }
+  } else {
+    // Waypoint array with global curviness
+    waypoints = coords;
+    for (let i = 0; i < waypoints.length - 1; i++) {
+      segments.push({ curviness });
+    }
+  }
+
+  return {
+    arcPath: { enabled: true, autoRotate, segments },
+    waypoints,
+  };
+}
+
 // fallow-ignore-next-line complexity
 function tweenCallToAnimation(
   call: TweenCallInfo,
@@ -695,6 +777,7 @@ function tweenCallToAnimation(
   const extras: Record<string, unknown> = {};
   let keyframesData: GsapKeyframesData | undefined;
   let hasUnresolvedKeyframes = false;
+  let motionPathResult: MotionPathParseResult | undefined;
 
   for (const [key, val] of Object.entries(vars)) {
     if (BUILTIN_VAR_KEYS.has(key)) continue;
@@ -707,6 +790,12 @@ function tweenCallToAnimation(
       continue;
     }
 
+    if (key === "motionPath") {
+      const mpNode = findPropertyNode(call.varsArg, "motionPath");
+      motionPathResult = parseMotionPathNode(mpNode, scope);
+      continue;
+    }
+
     if (key === "easeEach") {
       // easeEach is only meaningful alongside keyframes — handled below.
       continue;
@@ -734,6 +823,30 @@ function tweenCallToAnimation(
     keyframesData.easeEach = vars.easeEach as string;
   }
 
+  // When motionPath is present, reconstruct x/y as keyframe waypoints.
+  if (motionPathResult) {
+    const { waypoints } = motionPathResult;
+    if (!keyframesData) {
+      // No explicit keyframes — create synthetic percentage keyframes from waypoints.
+      const kf: GsapPercentageKeyframe[] = waypoints.map((wp, i) => ({
+        percentage: waypoints.length > 1 ? Math.round((i / (waypoints.length - 1)) * 100) : 0,
+        properties: { x: wp.x, y: wp.y },
+      }));
+      keyframesData = { format: "percentage", keyframes: kf };
+    } else {
+      // Merge waypoint positions into existing keyframes at matching percentages.
+      // If keyframe count matches waypoint count, assign positionally.
+      const kfs = keyframesData.keyframes;
+      if (kfs.length === waypoints.length) {
+        for (let i = 0; i < kfs.length; i++) {
+          kfs[i]!.properties.x = waypoints[i]!.x;
+          kfs[i]!.properties.y = waypoints[i]!.y;
+        }
+      }
+    }
+    // arcPath is attached below on the animation result.
+  }
+
   let fromProperties: Record<string, number | string> | undefined;
   if (call.method === "fromTo" && call.fromArg) {
     fromProperties = {};
@@ -762,6 +875,7 @@ function tweenCallToAnimation(
   };
   if (Object.keys(extras).length > 0) anim.extras = extras;
   if (keyframesData) anim.keyframes = keyframesData;
+  if (motionPathResult) anim.arcPath = motionPathResult.arcPath;
   if (hasUnresolvedKeyframes) anim.hasUnresolvedKeyframes = true;
   if (call.selector === "__unresolved__") anim.hasUnresolvedSelector = true;
   return anim;
@@ -941,7 +1055,15 @@ function applyUpdatesToCall(call: TweenCallInfo, updates: Partial<GsapAnimation>
     reconcileEditableProperties(call.fromArg, updates.fromProperties);
   }
   if (updates.duration !== undefined) setVarsKey(call.varsArg, "duration", updates.duration);
-  if (updates.ease !== undefined) setVarsKey(call.varsArg, "ease", updates.ease);
+  if (updates.ease !== undefined) {
+    const kfNode = findKeyframesObjectNode(call.varsArg);
+    if (kfNode) {
+      setVarsKey(kfNode, "easeEach", updates.ease);
+      removeVarsKey(call.varsArg, "ease");
+    } else {
+      setVarsKey(call.varsArg, "ease", updates.ease);
+    }
+  }
   if (updates.position !== undefined) {
     const posIdx = call.method === "fromTo" ? 3 : 2;
     call.node.arguments[posIdx] = parseExpr(valueToCode(updates.position));
@@ -1036,6 +1158,61 @@ export function addAnimationToScript(
   return { script: recast.print(parsed.ast).code, id };
 }
 
+export function addAnimationWithKeyframesToScript(
+  script: string,
+  targetSelector: string,
+  position: number,
+  duration: number,
+  keyframes: Array<{
+    percentage: number;
+    properties: Record<string, number | string>;
+    ease?: string;
+  }>,
+  ease?: string,
+): { script: string; id: string } {
+  let parsed: ParsedGsapAst;
+  try {
+    parsed = parseGsapAst(script);
+  } catch (e) {
+    console.warn("[gsap-parser] addAnimationWithKeyframesToScript parse failed:", e);
+    return { script, id: "" };
+  }
+  if (parsed.located.length === 0 && parsed.detection.timelineVar === null) {
+    return { script, id: "" };
+  }
+
+  const selector = JSON.stringify(targetSelector);
+  const kfEntries = keyframes.map((kf) => {
+    const propEntries = Object.entries(kf.properties).map(
+      ([k, v]) => `${safeKey(k)}: ${valueToCode(v)}`,
+    );
+    if (kf.ease) propEntries.push(`ease: ${JSON.stringify(kf.ease)}`);
+    return `${JSON.stringify(`${kf.percentage}%`)}: { ${propEntries.join(", ")} }`;
+  });
+  const kfCode = `{ ${kfEntries.join(", ")} }`;
+  const varEntries = [`keyframes: ${kfCode}`, `duration: ${valueToCode(duration)}`];
+  if (ease) varEntries.push(`ease: ${JSON.stringify(ease)}`);
+  const posCode = valueToCode(position);
+  const stmtCode = `${parsed.timelineVar}.to(${selector}, { ${varEntries.join(", ")} }, ${posCode});`;
+
+  const newStatement = parseScript(stmtCode).program.body[0];
+  const lastCall = parsed.located[parsed.located.length - 1]?.call;
+  const anchorPath = lastCall
+    ? findStatementPath(lastCall.path)
+    : findTimelineDeclarationPath(parsed.ast, parsed.timelineVar);
+
+  if (anchorPath) {
+    anchorPath.insertAfter(newStatement);
+  } else {
+    parsed.ast.program.body.push(newStatement);
+  }
+
+  const result = recast.print(parsed.ast).code;
+  const reParsed = parseGsapAst(result);
+  const newId = reParsed.located[reParsed.located.length - 1]?.id ?? "";
+  return { script: result, id: newId };
+}
+
 /** Find the statement path of `const <timelineVar> = gsap.timeline(...)`. */
 function findTimelineDeclarationPath(ast: any, timelineVar: string): any {
   let found: any = null;
@@ -1481,6 +1658,219 @@ export function materializeKeyframesInScript(
   return recast.print(loc.parsed.ast).code;
 }
 
+// ── Arc Path (motionPath) AST Mutations ──────────────────────────────────
+
+function buildMotionPathObjectCode(config: {
+  waypoints: Array<{ x: number; y: number }>;
+  segments: ArcPathSegment[];
+  autoRotate: boolean | number;
+}): string {
+  const { waypoints, segments, autoRotate } = config;
+  const hasExplicitControlPoints = segments.some((s) => s.cp1 && s.cp2);
+
+  let pathEntries: string[];
+  if (hasExplicitControlPoints && waypoints.length >= 2) {
+    // type: "cubic" — interleave control points: [anchor, cp1, cp2, anchor, ...]
+    pathEntries = [`{x: ${waypoints[0]!.x}, y: ${waypoints[0]!.y}}`];
+    for (let i = 0; i < segments.length; i++) {
+      const seg = segments[i]!;
+      const nextWp = waypoints[i + 1]!;
+      if (seg.cp1 && seg.cp2) {
+        pathEntries.push(`{x: ${seg.cp1.x}, y: ${seg.cp1.y}}`);
+        pathEntries.push(`{x: ${seg.cp2.x}, y: ${seg.cp2.y}}`);
+      } else {
+        // Auto-generate simple midpoint control points from curviness
+        const wp = waypoints[i]!;
+        const dx = nextWp.x - wp.x;
+        const dy = nextWp.y - wp.y;
+        const c = seg.curviness ?? 1;
+        pathEntries.push(
+          `{x: ${wp.x + dx * 0.33}, y: ${wp.y + dy * 0.33 - c * Math.abs(dx) * 0.25}}`,
+        );
+        pathEntries.push(
+          `{x: ${wp.x + dx * 0.66}, y: ${wp.y + dy * 0.66 - c * Math.abs(dx) * 0.25}}`,
+        );
+      }
+      pathEntries.push(`{x: ${nextWp.x}, y: ${nextWp.y}}`);
+    }
+    const pathStr = pathEntries.join(", ");
+    const parts = [`path: [${pathStr}]`, `type: "cubic"`];
+    if (autoRotate === true) parts.push("autoRotate: true");
+    else if (typeof autoRotate === "number") parts.push(`autoRotate: ${autoRotate}`);
+    return `{ ${parts.join(", ")} }`;
+  }
+
+  // Simple waypoint array with curviness
+  pathEntries = waypoints.map((wp) => `{x: ${wp.x}, y: ${wp.y}}`);
+  const curviness = segments[0]?.curviness ?? 1;
+  const parts = [`path: [${pathEntries.join(", ")}]`];
+  if (curviness !== 1) parts.push(`curviness: ${curviness}`);
+  if (autoRotate === true) parts.push("autoRotate: true");
+  else if (typeof autoRotate === "number") parts.push(`autoRotate: ${autoRotate}`);
+  return `{ ${parts.join(", ")} }`;
+}
+
+export function setArcPathInScript(
+  script: string,
+  animationId: string,
+  config: ArcPathConfig,
+): string {
+  const loc = locateAnimation(script, animationId);
+  if (!loc) return script;
+
+  const varsArg = loc.target.call.varsArg;
+  const anim = loc.target.animation;
+
+  if (!config.enabled) {
+    // Disable arc: restore x/y from motionPath's last waypoint, then remove motionPath
+    const motionPathProp = varsArg.properties.find(
+      (p: any) => isObjectProperty(p) && propKeyName(p) === "motionPath",
+    );
+    if (motionPathProp) {
+      const mpVal = motionPathProp.value;
+      let pathArr: any[] | undefined;
+      if (mpVal?.type === "ObjectExpression") {
+        const pathProp = mpVal.properties.find(
+          (p: any) => isObjectProperty(p) && propKeyName(p) === "path",
+        );
+        if (pathProp?.value?.type === "ArrayExpression") pathArr = pathProp.value.elements;
+      }
+      if (pathArr && pathArr.length > 0) {
+        const last = pathArr[pathArr.length - 1];
+        if (last?.type === "ObjectExpression") {
+          for (const p of last.properties) {
+            const k = propKeyName(p);
+            if (k === "x" || k === "y") {
+              const v = p.value?.value;
+              if (typeof v === "number") setVarsKey(varsArg, k, v);
+            }
+          }
+        }
+      }
+    }
+    removeVarsKey(varsArg, "motionPath");
+    return recast.print(loc.parsed.ast).code;
+  }
+
+  // Extract x/y waypoints from keyframes or flat tween properties
+  const kfs = anim.keyframes?.keyframes ?? [];
+  const waypoints: Array<{ x: number; y: number }> = [];
+  for (const kf of kfs) {
+    const x = typeof kf.properties.x === "number" ? kf.properties.x : undefined;
+    const y = typeof kf.properties.y === "number" ? kf.properties.y : undefined;
+    if (x !== undefined && y !== undefined) waypoints.push({ x, y });
+  }
+
+  // For flat tweens with x/y in properties, synthesize start → end waypoints
+  if (waypoints.length < 2) {
+    const px = anim.properties.x;
+    const py = anim.properties.y;
+    if (typeof px === "number" || typeof py === "number") {
+      waypoints.length = 0;
+      waypoints.push({ x: 0, y: 0 });
+      waypoints.push({ x: typeof px === "number" ? px : 0, y: typeof py === "number" ? py : 0 });
+    }
+  }
+
+  if (waypoints.length < 2) return script;
+
+  // Build segments — use provided segments or create defaults
+  const segments: ArcPathSegment[] =
+    config.segments.length === waypoints.length - 1
+      ? config.segments
+      : Array.from({ length: waypoints.length - 1 }, () => ({ curviness: 1 }));
+
+  const motionPathCode = buildMotionPathObjectCode({
+    waypoints,
+    segments,
+    autoRotate: config.autoRotate,
+  });
+
+  // Set motionPath on the vars
+  const motionPathNode = parseExpr(motionPathCode);
+  const existingProp = varsArg.properties.find(
+    (p: any) => isObjectProperty(p) && propKeyName(p) === "motionPath",
+  );
+  if (existingProp) {
+    existingProp.value = motionPathNode;
+  } else {
+    const prop = parseExpr(`{ motionPath: ${motionPathCode} }`).properties[0];
+    varsArg.properties.push(prop);
+  }
+
+  // Strip x/y from keyframes (they're now in motionPath)
+  const kfNode = findKeyframesObjectNode(varsArg);
+  if (kfNode) {
+    for (const pctProp of filterPercentageProps(kfNode)) {
+      if (pctProp.value?.type === "ObjectExpression") {
+        pctProp.value.properties = pctProp.value.properties.filter((p: any) => {
+          const k = propKeyName(p);
+          return k !== "x" && k !== "y";
+        });
+      }
+    }
+  }
+
+  // Strip flat x/y from vars (they're now in motionPath)
+  removeVarsKey(varsArg, "x");
+  removeVarsKey(varsArg, "y");
+
+  return recast.print(loc.parsed.ast).code;
+}
+
+export function updateArcSegmentInScript(
+  script: string,
+  animationId: string,
+  segmentIndex: number,
+  update: Partial<ArcPathSegment>,
+): string {
+  const loc = locateAnimation(script, animationId);
+  if (!loc) return script;
+
+  const anim = loc.target.animation;
+  if (!anim.arcPath?.enabled) return script;
+
+  const segments = [...anim.arcPath.segments];
+  if (segmentIndex < 0 || segmentIndex >= segments.length) return script;
+
+  segments[segmentIndex] = { ...segments[segmentIndex]!, ...update };
+
+  // Rebuild the full motionPath with updated segments
+  const kfs = anim.keyframes?.keyframes ?? [];
+  const waypoints: Array<{ x: number; y: number }> = [];
+  for (const kf of kfs) {
+    const x = typeof kf.properties.x === "number" ? kf.properties.x : undefined;
+    const y = typeof kf.properties.y === "number" ? kf.properties.y : undefined;
+    if (x !== undefined && y !== undefined) waypoints.push({ x, y });
+  }
+
+  if (waypoints.length < 2) return script;
+
+  const motionPathCode = buildMotionPathObjectCode({
+    waypoints,
+    segments,
+    autoRotate: anim.arcPath.autoRotate,
+  });
+
+  const varsArg = loc.target.call.varsArg;
+  const existingProp = varsArg.properties.find(
+    (p: any) => isObjectProperty(p) && propKeyName(p) === "motionPath",
+  );
+  if (existingProp) {
+    existingProp.value = parseExpr(motionPathCode);
+  }
+
+  return recast.print(loc.parsed.ast).code;
+}
+
+export function removeArcPathFromScript(script: string, animationId: string): string {
+  return setArcPathInScript(script, animationId, {
+    enabled: false,
+    autoRotate: false,
+    segments: [],
+  });
+}
+
 /**
  * Replace a dynamic loop that generates multiple tween calls with individual
  * static `tl.to()` calls — one per element. Finds the loop containing the
diff --git a/packages/core/src/parsers/gsapSerialize.ts b/packages/core/src/parsers/gsapSerialize.ts
index 364c586da..b480190e6 100644
--- a/packages/core/src/parsers/gsapSerialize.ts
+++ b/packages/core/src/parsers/gsapSerialize.ts
@@ -23,6 +23,8 @@ export interface GsapAnimation {
   extras?: Record<string, unknown>;
   /** Native GSAP keyframes data — present when the tween uses keyframes: { ... }. */
   keyframes?: GsapKeyframesData;
+  /** Arc motion path config — present when the tween uses motionPath for curved position interpolation. */
+  arcPath?: ArcPathConfig;
   /** True when the tween has a `keyframes` property that couldn't be statically resolved (dynamic). */
   hasUnresolvedKeyframes?: boolean;
   /** True when the tween's target selector couldn't be statically resolved (dynamic). */
@@ -44,6 +46,18 @@ export interface GsapKeyframesData {
   easeEach?: string;
 }
 
+export interface ArcPathSegment {
+  curviness: number;
+  cp1?: { x: number; y: number };
+  cp2?: { x: number; y: number };
+}
+
+export interface ArcPathConfig {
+  enabled: boolean;
+  autoRotate: boolean | number;
+  segments: ArcPathSegment[];
+}
+
 export interface ParsedGsap {
   animations: GsapAnimation[];
   timelineVar: string;
@@ -176,10 +190,8 @@ const FORBIDDEN_GSAP_PATTERNS: Array<{ pattern: RegExp; message: string }> = [
   { pattern: /\.add\s*\(/, message: "add() method not allowed" },
   { pattern: /\.addLabel\s*\(/, message: "addLabel() method not allowed" },
   { pattern: /\.addPause\s*\(/, message: "addPause() method not allowed" },
-  { pattern: /gsap\.registerPlugin\s*\(/, message: "registerPlugin() not allowed" },
   { pattern: /gsap\.registerEffect\s*\(/, message: "registerEffect() not allowed" },
   { pattern: /ScrollTrigger/, message: "ScrollTrigger not allowed" },
-  { pattern: /MotionPathPlugin/, message: "MotionPathPlugin not allowed" },
   { pattern: /onComplete\s*:/, message: "onComplete callback not allowed" },
   { pattern: /onUpdate\s*:/, message: "onUpdate callback not allowed" },
   { pattern: /onStart\s*:/, message: "onStart callback not allowed" },
diff --git a/packages/core/src/runtime/init.ts b/packages/core/src/runtime/init.ts
index 22c570d8a..a4758d62f 100644
--- a/packages/core/src/runtime/init.ts
+++ b/packages/core/src/runtime/init.ts
@@ -1000,6 +1000,66 @@ export function initSandboxRuntimeModular(): void {
         mediaDurationFloorSeconds: resolution.mediaDurationFloorSeconds ?? null,
       },
     });
+    // Stamp data-start / data-duration on GSAP-targeted elements that lack
+    // them so the Studio timeline can discover individual animated elements.
+    // Skip elements whose ancestor already carries timing — stamping them
+    // would override the parent's clip visibility and cause preview/render
+    // parity drift.
+    {
+      const rootComp = resolveRootCompositionElement();
+      const rootDuration = boundDuration > 0 ? boundDuration : 0;
+      const dur = String(rootDuration > 0 ? rootDuration : 1);
+      const seen = new Set<Element>();
+
+      const hasTimedAncestor = (el: HTMLElement): boolean => {
+        let cursor = el.parentElement;
+        while (cursor) {
+          if (cursor.hasAttribute("data-start")) return true;
+          if (cursor === rootComp) return false;
+          cursor = cursor.parentElement;
+        }
+        return false;
+      };
+
+      // Stamp GSAP-targeted elements
+      if (state.capturedTimeline.getChildren) {
+        try {
+          for (const child of state.capturedTimeline.getChildren(true)) {
+            if (typeof child.targets !== "function") continue;
+            for (const target of child.targets()) {
+              if (!(target instanceof HTMLElement)) continue;
+              if (target === rootComp) continue;
+              if (target.hasAttribute("data-start")) continue;
+              if (hasTimedAncestor(target)) continue;
+              if (seen.has(target)) continue;
+              seen.add(target);
+              target.setAttribute("data-start", "0");
+              target.setAttribute("data-duration", dur);
+            }
+          }
+        } catch {
+          /* timeline access guard */
+        }
+      }
+
+      // Stamp all ID'd children of the composition root so they appear
+      // in the timeline even without animations. Enables selecting and
+      // adding animations from the design panel on a blank canvas.
+      if (rootComp instanceof HTMLElement) {
+        for (const el of rootComp.querySelectorAll("[id]")) {
+          if (!(el instanceof HTMLElement)) continue;
+          if (el === rootComp) continue;
+          if (el.hasAttribute("data-start")) continue;
+          if (hasTimedAncestor(el)) continue;
+          if (seen.has(el)) continue;
+          if (el.tagName === "SCRIPT" || el.tagName === "STYLE" || el.tagName === "LINK") continue;
+          seen.add(el);
+          el.setAttribute("data-start", "0");
+          el.setAttribute("data-duration", dur);
+        }
+      }
+    }
+
     // (Re-)probe all already-bound media elements against the new timeline.
     // Clear the cache first so elements probed against a prior timeline get fresh keyframes.
     for (const el of metadataBoundMedia) {
diff --git a/packages/core/src/studio-api/helpers/studioMotionRenderScript.ts b/packages/core/src/studio-api/helpers/studioMotionRenderScript.ts
index 87d2b815e..d229e8832 100644
--- a/packages/core/src/studio-api/helpers/studioMotionRenderScript.ts
+++ b/packages/core/src/studio-api/helpers/studioMotionRenderScript.ts
@@ -58,6 +58,7 @@ function studioMotionRenderRuntime(
       registerPlugin?: (...plugins: unknown[]) => unknown;
     };
     CustomEase?: { create?: (id: string, data: string) => unknown };
+    MotionPathPlugin?: unknown;
     __player?: { getTime?: () => number };
     __timeline?: { time?: () => number };
     __timelines?: Record<
@@ -212,6 +213,9 @@ function studioMotionRenderRuntime(
     restoreStudioMotionElements();
     const gsap = runtimeWindow.gsap;
     if (!gsap?.timeline || manifestMotions.length === 0) return 0;
+    if (runtimeWindow.MotionPathPlugin) {
+      gsap.registerPlugin?.(runtimeWindow.MotionPathPlugin);
+    }
 
     const timeline = gsap.timeline({ paused: true, defaults: { overwrite: "auto" } });
     let applied = 0;
diff --git a/packages/core/src/studio-api/routes/files.ts b/packages/core/src/studio-api/routes/files.ts
index fddd4321d..96f02bb58 100644
--- a/packages/core/src/studio-api/routes/files.ts
+++ b/packages/core/src/studio-api/routes/files.ts
@@ -651,6 +651,38 @@ export function registerFileRoutes(api: Hono, adapter: StudioApiAdapter): void {
           keyframes: Array<{ percentage: number; properties: Record<string, number | string> }>;
           easeEach?: string;
         }>;
+      }
+    | {
+        type: "set-arc-path";
+        animationId: string;
+        enabled: boolean;
+        autoRotate?: boolean | number;
+        segments?: Array<{
+          curviness: number;
+          cp1?: { x: number; y: number };
+          cp2?: { x: number; y: number };
+        }>;
+      }
+    | {
+        type: "update-arc-segment";
+        animationId: string;
+        segmentIndex: number;
+        curviness?: number;
+        cp1?: { x: number; y: number };
+        cp2?: { x: number; y: number };
+      }
+    | { type: "remove-arc-path"; animationId: string }
+    | {
+        type: "add-with-keyframes";
+        targetSelector: string;
+        position: number;
+        duration: number;
+        keyframes: Array<{
+          percentage: number;
+          properties: Record<string, number | string>;
+          ease?: string;
+        }>;
+        ease?: string;
       };
 
   api.post("/projects/:id/gsap-mutations/*", async (c) => {
@@ -835,6 +867,47 @@ export function registerFileRoutes(api: Hono, adapter: StudioApiAdapter): void {
         }
         break;
       }
+      case "set-arc-path": {
+        const { setArcPathInScript } = await loadGsapParser();
+        newScript = setArcPathInScript(block.scriptText, body.animationId, {
+          enabled: body.enabled,
+          autoRotate: body.autoRotate ?? false,
+          segments: body.segments ?? [],
+        });
+        break;
+      }
+      case "update-arc-segment": {
+        const { updateArcSegmentInScript } = await loadGsapParser();
+        newScript = updateArcSegmentInScript(
+          block.scriptText,
+          body.animationId,
+          body.segmentIndex,
+          {
+            ...(body.curviness !== undefined ? { curviness: body.curviness } : {}),
+            ...(body.cp1 ? { cp1: body.cp1 } : {}),
+            ...(body.cp2 ? { cp2: body.cp2 } : {}),
+          },
+        );
+        break;
+      }
+      case "remove-arc-path": {
+        const { removeArcPathFromScript } = await loadGsapParser();
+        newScript = removeArcPathFromScript(block.scriptText, body.animationId);
+        break;
+      }
+      case "add-with-keyframes": {
+        const { addAnimationWithKeyframesToScript } = await loadGsapParser();
+        const result = addAnimationWithKeyframesToScript(
+          block.scriptText,
+          body.targetSelector,
+          body.position,
+          body.duration,
+          body.keyframes,
+          body.ease,
+        );
+        newScript = result.script;
+        break;
+      }
       default:
         return c.json({ error: `unknown mutation type: ${(body as { type: string }).type}` }, 400);
     }
diff --git a/packages/core/src/templates/constants.ts b/packages/core/src/templates/constants.ts
index 787d4b139..8078f5a27 100644
--- a/packages/core/src/templates/constants.ts
+++ b/packages/core/src/templates/constants.ts
@@ -1,4 +1,6 @@
 export const GSAP_CDN = "https://cdn.jsdelivr.net/npm/gsap@3.12.5/dist/gsap.min.js";
+export const MOTIONPATH_CDN =
+  "https://cdn.jsdelivr.net/npm/gsap@3.12.5/dist/MotionPathPlugin.min.js";
 
 export const BASE_STYLES = `* { margin: 0; padding: 0; box-sizing: border-box; }
 html, body { width: 100%; height: 100%; overflow: hidden; background: #000; display: flex; align-items: center; justify-content: center; }`;
diff --git a/packages/producer/build.mjs b/packages/producer/build.mjs
index 7b4cacbf6..4721ef685 100644
--- a/packages/producer/build.mjs
+++ b/packages/producer/build.mjs
@@ -15,6 +15,14 @@ mkdirSync("dist", { recursive: true });
 
 const scriptDir = dirname(fileURLToPath(import.meta.url));
 
+// The banner provides a real `require` function via createRequire so that
+// esbuild's CJS interop (__require) works correctly in ESM output.
+// Without this, bundled CJS deps (recast, yauzl, etc.) that call
+// require("fs") throw "Dynamic require of 'fs' is not supported".
+const cjsBanner = {
+  js: "import { createRequire as __cjsRequire } from 'module'; const require = __cjsRequire(import.meta.url);",
+};
+
 const workspaceAliasPlugin = {
   name: "workspace-alias",
   setup(build) {
@@ -36,80 +44,32 @@ const workspaceAliasPlugin = {
   },
 };
 
+const sharedOpts = {
+  bundle: true,
+  platform: "node",
+  target: "node22",
+  format: "esm",
+  external: ["puppeteer", "esbuild", "postcss"],
+  plugins: [workspaceAliasPlugin],
+  minify: false,
+  sourcemap: true,
+  banner: cjsBanner,
+};
+
 await Promise.all([
+  build({ ...sharedOpts, entryPoints: ["src/index.ts"], outfile: "dist/index.js" }),
+  build({ ...sharedOpts, entryPoints: ["src/server.ts"], outfile: "dist/public-server.js" }),
   build({
-    bundle: true,
-    platform: "node",
-    target: "node22",
-    format: "esm",
-    external: ["puppeteer", "esbuild", "postcss", "wawoff2"],
-    plugins: [workspaceAliasPlugin],
-    minify: false,
-    sourcemap: true,
-    entryPoints: ["src/index.ts"],
-    outfile: "dist/index.js",
-  }),
-  build({
-    bundle: true,
-    platform: "node",
-    target: "node22",
-    format: "esm",
-    external: ["puppeteer", "esbuild", "postcss", "wawoff2"],
-    plugins: [workspaceAliasPlugin],
-    minify: false,
-    sourcemap: true,
-    entryPoints: ["src/server.ts"],
-    outfile: "dist/public-server.js",
-  }),
-  // PNG decode + alpha-blit worker (hf#732 lever-4). Loaded by
-  // `pngDecodeBlitWorkerPool.createPngDecodeBlitWorkerPool` via
-  // `new Worker(<path>)`. Must be a separate entry point so the worker
-  // module is standalone and shares no parent module-graph state.
-  build({
-    bundle: true,
-    platform: "node",
-    target: "node22",
-    format: "esm",
-    external: ["puppeteer", "esbuild", "postcss", "wawoff2"],
-    plugins: [workspaceAliasPlugin],
-    minify: false,
-    sourcemap: true,
+    ...sharedOpts,
     entryPoints: ["src/services/pngDecodeBlitWorker.ts"],
     outfile: "dist/services/pngDecodeBlitWorker.js",
   }),
-  // Shader-blend worker (hf#677 follow-up). Loaded by
-  // `shaderTransitionWorkerPool.createShaderTransitionWorkerPool` via
-  // `new Worker(<path>)`. Same bundling rationale as the
-  // `pngDecodeBlitWorker` entry above.
   build({
-    bundle: true,
-    platform: "node",
-    target: "node22",
-    format: "esm",
-    external: ["puppeteer", "esbuild", "postcss", "wawoff2"],
-    plugins: [workspaceAliasPlugin],
-    minify: false,
-    sourcemap: true,
+    ...sharedOpts,
     entryPoints: ["src/services/shaderTransitionWorker.ts"],
     outfile: "dist/services/shaderTransitionWorker.js",
   }),
-  // `@hyperframes/producer/distributed` subpath — the public distributed
-  // render primitives (plan / renderChunk / assemble). Bundled as a
-  // separate entry so adopters that don't need the in-process renderer
-  // (Lambda chunk workers, CDK constructs, thin orchestrators) can import
-  // only this surface and skip the rest of the producer's dependency tree.
-  build({
-    bundle: true,
-    platform: "node",
-    target: "node22",
-    format: "esm",
-    external: ["puppeteer", "esbuild", "postcss", "wawoff2"],
-    plugins: [workspaceAliasPlugin],
-    minify: false,
-    sourcemap: true,
-    entryPoints: ["src/distributed.ts"],
-    outfile: "dist/distributed.js",
-  }),
+  build({ ...sharedOpts, entryPoints: ["src/distributed.ts"], outfile: "dist/distributed.js" }),
 ]);
 
 // Copy core runtime artifacts so the producer can find them at dist/
diff --git a/packages/studio/src/App.tsx b/packages/studio/src/App.tsx
index 5bbaaf29e..af9edf131 100644
--- a/packages/studio/src/App.tsx
+++ b/packages/studio/src/App.tsx
@@ -514,6 +514,7 @@ export function StudioApp() {
                 refreshCaptureFrameTime={frameCapture.refreshCaptureFrameTime}
                 inspectorButtonActive={inspectorButtonActive}
                 inspectorPanelActive={inspectorPanelActive}
+                onExport={() => void renderQueue.startRender()}
               />
 
               <div className="flex flex-1 min-h-0">
diff --git a/packages/studio/src/components/StudioHeader.tsx b/packages/studio/src/components/StudioHeader.tsx
index 9384950ab..3404df15c 100644
--- a/packages/studio/src/components/StudioHeader.tsx
+++ b/packages/studio/src/components/StudioHeader.tsx
@@ -17,6 +17,7 @@ export interface StudioHeaderProps {
   refreshCaptureFrameTime: () => void;
   inspectorButtonActive: boolean;
   inspectorPanelActive: boolean;
+  onExport?: () => void;
 }
 
 function HyperframesLogo() {
@@ -147,6 +148,7 @@ export function StudioHeader({
   refreshCaptureFrameTime,
   inspectorButtonActive,
   inspectorPanelActive,
+  onExport,
 }: StudioHeaderProps) {
   const { projectId, editHistory, handleUndo, handleRedo } = useStudioContext();
   const { rightCollapsed, setRightCollapsed, setRightPanelTab } = usePanelLayoutContext();
@@ -264,6 +266,17 @@ export function StudioHeader({
           </svg>
           Inspector
         </button>
+        <button
+          type="button"
+          onClick={() => {
+            setRightPanelTab("renders");
+            setRightCollapsed(false);
+            onExport?.();
+          }}
+          className="h-7 flex items-center gap-1.5 px-3 rounded-md text-[11px] font-semibold bg-studio-accent text-[#09090B] hover:brightness-110 transition-colors"
+        >
+          Export
+        </button>
       </div>
     </div>
   );
diff --git a/packages/studio/src/components/StudioRightPanel.tsx b/packages/studio/src/components/StudioRightPanel.tsx
index a0adf87d4..ed68072a8 100644
--- a/packages/studio/src/components/StudioRightPanel.tsx
+++ b/packages/studio/src/components/StudioRightPanel.tsx
@@ -92,6 +92,8 @@ export function StudioRightPanel({
     handleGsapAddFromProperty,
     handleGsapRemoveFromProperty,
     commitAnimatedProperty,
+    handleSetArcPath,
+    handleUpdateArcSegment,
   } = useDomEditContext();
 
   const { assets, fontAssets, projectDir, handleImportFiles, handleImportFonts } =
@@ -226,6 +228,8 @@ export function StudioRightPanel({
                   onRemoveGsapFromProperty={handleGsapRemoveFromProperty}
                   onAddGsapAnimation={handleGsapAddAnimation}
                   onCommitAnimatedProperty={commitAnimatedProperty}
+                  onSetArcPath={handleSetArcPath}
+                  onUpdateArcSegment={handleUpdateArcSegment}
                 />
               ) : motionPanelActive ? (
                 <MotionPanel
diff --git a/packages/studio/src/components/TimelineToolbar.tsx b/packages/studio/src/components/TimelineToolbar.tsx
index 4754c1295..943c12bd4 100644
--- a/packages/studio/src/components/TimelineToolbar.tsx
+++ b/packages/studio/src/components/TimelineToolbar.tsx
@@ -80,12 +80,47 @@ function readRuntimeKeyframeValues(
   return result;
 }
 
+// fallow-ignore-next-line complexity
+function readRuntimeValuesForAnim(
+  iframe: HTMLIFrameElement | null,
+  sel: DomEditSelection,
+  anim: GsapAnimation,
+): Record<string, number> {
+  if (!iframe?.contentWindow) return {};
+  let gsap: { getProperty?: (el: Element, prop: string) => number } | undefined;
+  try {
+    gsap = (iframe.contentWindow as Window & { gsap?: typeof gsap }).gsap;
+  } catch {
+    return {};
+  }
+  if (!gsap?.getProperty) return {};
+  const selector = sel.id ? `#${sel.id}` : sel.selector;
+  if (!selector) return {};
+  let doc: Document | null = null;
+  try {
+    doc = iframe.contentDocument;
+  } catch {
+    return {};
+  }
+  const element = doc?.querySelector(selector);
+  if (!element) return {};
+  const result: Record<string, number> = {};
+  for (const prop of Object.keys(anim.properties)) {
+    const val = Number(gsap.getProperty(element, prop));
+    if (Number.isFinite(val)) result[prop] = Math.round(val);
+  }
+  return result;
+}
+
 interface DomEditSessionSlice {
   domEditSelection: DomEditSelection | null;
   selectedGsapAnimations: GsapAnimation[];
   handleGsapRemoveKeyframe: (animId: string, pct: number) => void;
   handleGsapAddKeyframe: (animId: string, pct: number, prop: string, val: number | string) => void;
-  handleGsapConvertToKeyframes: (animId: string) => void;
+  handleGsapConvertToKeyframes: (
+    animId: string,
+    resolvedFromValues?: Record<string, number | string>,
+  ) => void;
   handleGsapMaterializeKeyframes?: (animId: string) => Promise<void>;
   handleGsapAddAnimation: (method: "to" | "from" | "set" | "fromTo") => void;
   previewIframeRef?: React.RefObject<HTMLIFrameElement | null>;
@@ -154,7 +189,15 @@ function useKeyframeToggle(session?: DomEditSessionSlice) {
             }
           }
         } else if (flatAnim) {
-          session.handleGsapConvertToKeyframes(flatAnim.id);
+          const runtimeProps = readRuntimeValuesForAnim(
+            session.previewIframeRef?.current ?? null,
+            sel,
+            flatAnim,
+          );
+          session.handleGsapConvertToKeyframes(
+            flatAnim.id,
+            Object.keys(runtimeProps).length > 0 ? runtimeProps : undefined,
+          );
         } else {
           session.handleGsapAddAnimation("to");
         }
diff --git a/packages/studio/src/components/editor/AnimationCard.tsx b/packages/studio/src/components/editor/AnimationCard.tsx
index 839d3f7b3..4173d6534 100644
--- a/packages/studio/src/components/editor/AnimationCard.tsx
+++ b/packages/studio/src/components/editor/AnimationCard.tsx
@@ -17,6 +17,9 @@ import {
 } from "./gsapAnimationConstants";
 import { buildTweenSummary } from "./gsapAnimationHelpers";
 import { EaseCurveSection } from "./EaseCurveSection";
+import { ArcPathControls } from "./ArcPathControls";
+import type { ArcPathSegment } from "@hyperframes/core/gsap-parser";
+import { P } from "./panelTokens";
 const BOOLEAN_PROPS = new Set(["visibility"]);
 const STRING_PROPS = new Set(["filter", "clipPath"]);
 
@@ -97,11 +100,18 @@ function PropertyRow({
           <button
             type="button"
             onClick={() => onCommit(isVisible ? "hidden" : "visible")}
-            className={`flex-shrink-0 w-7 h-4 rounded-full transition-colors relative ${isVisible ? "bg-emerald-500/30" : "bg-neutral-700"}`}
+            className={`flex-shrink-0 rounded-full transition-all duration-150 relative`}
+            style={{ width: 28, height: 16, background: isVisible ? P.accent : P.borderInput }}
             title={isVisible ? "Visible — click to hide" : "Hidden — click to show"}
           >
             <span
-              className={`absolute top-0.5 h-3 w-3 rounded-full transition-transform ${isVisible ? "bg-emerald-400 translate-x-3.5" : "bg-neutral-500 translate-x-0.5"}`}
+              className="absolute top-[2px] left-0 rounded-full transition-transform duration-150"
+              style={{
+                width: 12,
+                height: 12,
+                background: isVisible ? P.white : P.textMuted,
+                transform: isVisible ? "translateX(14px)" : "translateX(2px)",
+              }}
             />
           </button>
         </div>
@@ -241,6 +251,15 @@ interface AnimationCardProps {
   onRemoveFromProperty?: (animationId: string, property: string) => void;
   onLivePreview?: (property: string, value: number | string) => void;
   onLivePreviewEnd?: () => void;
+  onSetArcPath?: (
+    animationId: string,
+    config: { enabled: boolean; autoRotate?: boolean | number; segments?: ArcPathSegment[] },
+  ) => void;
+  onUpdateArcSegment?: (
+    animationId: string,
+    segmentIndex: number,
+    update: Partial<ArcPathSegment>,
+  ) => void;
 }
 
 // fallow-ignore-next-line complexity
@@ -257,6 +276,8 @@ export const AnimationCard = memo(function AnimationCard({
   onRemoveFromProperty,
   onLivePreview,
   onLivePreviewEnd,
+  onSetArcPath,
+  onUpdateArcSegment,
 }: AnimationCardProps) {
   const [expanded, setExpanded] = useState(defaultExpanded);
   const [addingProp, setAddingProp] = useState(false);
@@ -329,7 +350,7 @@ export const AnimationCard = memo(function AnimationCard({
   const [copied, setCopied] = useState(false);
 
   const methodLabel = METHOD_LABELS[animation.method] ?? animation.method;
-  const easeName = animation.ease ?? "none";
+  const easeName = animation.ease ?? animation.keyframes?.easeEach ?? "none";
   const easeLabel = easeName.startsWith("custom(")
     ? "Custom curve"
     : (EASE_LABELS[easeName] ?? easeName);
@@ -348,7 +369,7 @@ export const AnimationCard = memo(function AnimationCard({
         className="flex w-full items-center gap-2 py-1.5"
       >
         <span
-          className="rounded bg-emerald-500/10 px-1.5 py-0.5 text-[10px] font-semibold text-emerald-400"
+          className="rounded bg-panel-accent/10 px-1.5 py-0.5 text-[10px] font-semibold text-panel-accent"
           title={METHOD_TOOLTIPS[animation.method]}
         >
           {methodLabel}
@@ -420,13 +441,13 @@ export const AnimationCard = memo(function AnimationCard({
               <>
                 <SelectField
                   label="Speed"
-                  value={
-                    animation.ease?.startsWith("custom(") ? "custom" : (animation.ease ?? "none")
-                  }
+                  value={easeName.startsWith("custom(") ? "custom" : easeName}
                   options={[...SUPPORTED_EASES, "custom"]}
                   onChange={(next) => {
                     if (next === "custom") {
-                      const points = controlPointsForGsapEase(animation.ease ?? "power2.out");
+                      const points = controlPointsForGsapEase(
+                        easeName !== "none" ? easeName : "power2.out",
+                      );
                       const path = `M0,0 C${points.x1},${points.y1} ${points.x2},${points.y2} 1,1`;
                       onUpdateMeta(animation.id, { ease: `custom(${path})` });
                     } else {
@@ -435,7 +456,7 @@ export const AnimationCard = memo(function AnimationCard({
                   }}
                 />
                 <EaseCurveSection
-                  ease={animation.ease ?? "none"}
+                  ease={easeName}
                   duration={animation.duration}
                   onCustomEaseCommit={(customEase) =>
                     onUpdateMeta(animation.id, { ease: customEase })
@@ -477,7 +498,7 @@ export const AnimationCard = memo(function AnimationCard({
             )}
 
             {animation.method === "fromTo" && Object.keys(animation.properties).length > 0 && (
-              <p className="text-[9px] font-semibold uppercase tracking-wider text-emerald-400/70">
+              <p className="text-[9px] font-semibold uppercase tracking-wider text-panel-accent/70">
                 To
               </p>
             )}
@@ -500,6 +521,39 @@ export const AnimationCard = memo(function AnimationCard({
               </div>
             )}
 
+            {onSetArcPath &&
+              (animation.properties.x != null ||
+                animation.properties.y != null ||
+                animation.keyframes) && (
+                <div className="border-t border-neutral-800 pt-3">
+                  <ArcPathControls
+                    arcPath={
+                      animation.arcPath ?? { enabled: false, autoRotate: false, segments: [] }
+                    }
+                    segmentCount={Math.max(
+                      animation.properties.x != null || animation.properties.y != null ? 1 : 0,
+                      (animation.keyframes?.keyframes?.length ?? 0) - 1,
+                    )}
+                    onToggle={(enabled) =>
+                      onSetArcPath(animation.id, {
+                        enabled,
+                        segments: animation.arcPath?.segments,
+                      })
+                    }
+                    onUpdateSegment={(index, update) =>
+                      onUpdateArcSegment?.(animation.id, index, update)
+                    }
+                    onToggleAutoRotate={(autoRotate) =>
+                      onSetArcPath(animation.id, {
+                        enabled: true,
+                        autoRotate,
+                        segments: animation.arcPath?.segments,
+                      })
+                    }
+                  />
+                </div>
+              )}
+
             <div className="flex items-center gap-2 pt-1">
               <AddPropertyTrigger
                 adding={addingProp}
diff --git a/packages/studio/src/components/editor/ArcPathControls.tsx b/packages/studio/src/components/editor/ArcPathControls.tsx
new file mode 100644
index 000000000..e9f46607d
--- /dev/null
+++ b/packages/studio/src/components/editor/ArcPathControls.tsx
@@ -0,0 +1,131 @@
+import { memo, useCallback } from "react";
+import type { ArcPathConfig, ArcPathSegment } from "@hyperframes/core/gsap-parser";
+import { SliderControl } from "./propertyPanelPrimitives";
+import { LABEL } from "./propertyPanelHelpers";
+import { P } from "./panelTokens";
+
+interface ArcPathControlsProps {
+  arcPath: ArcPathConfig;
+  segmentCount: number;
+  onToggle: (enabled: boolean) => void;
+  onUpdateSegment: (index: number, update: Partial<ArcPathSegment>) => void;
+  onToggleAutoRotate: (autoRotate: boolean) => void;
+  disabled?: boolean;
+}
+
+export const ArcPathControls = memo(function ArcPathControls({
+  arcPath,
+  segmentCount,
+  onToggle,
+  onUpdateSegment,
+  onToggleAutoRotate,
+  disabled,
+}: ArcPathControlsProps) {
+  const handleToggle = useCallback(() => {
+    onToggle(!arcPath.enabled);
+  }, [arcPath.enabled, onToggle]);
+
+  const handleAutoRotate = useCallback(() => {
+    onToggleAutoRotate(!arcPath.autoRotate);
+  }, [arcPath.autoRotate, onToggleAutoRotate]);
+
+  if (segmentCount < 1) {
+    return (
+      <div className="rounded-md border border-neutral-800 bg-neutral-900/50 px-3 py-2">
+        <p className="text-[11px] text-neutral-500">
+          Add at least 2 position keyframes to enable arc motion.
+        </p>
+      </div>
+    );
+  }
+
+  return (
+    <div className="space-y-3">
+      <div className="flex items-center justify-between">
+        <span className={LABEL}>Arc Motion</span>
+        <button
+          type="button"
+          onClick={handleToggle}
+          disabled={disabled}
+          className="relative rounded-full transition-all duration-150"
+          style={{ width: 28, height: 16, background: arcPath.enabled ? P.accent : P.borderInput }}
+          title={arcPath.enabled ? "Disable arc motion" : "Enable arc motion"}
+        >
+          <span
+            className="absolute top-[2px] left-0 rounded-full transition-transform duration-150"
+            style={{
+              width: 12,
+              height: 12,
+              background: arcPath.enabled ? P.white : P.textMuted,
+              transform: arcPath.enabled ? "translateX(14px)" : "translateX(2px)",
+            }}
+          />
+        </button>
+      </div>
+
+      {arcPath.enabled && (
+        <>
+          <div className="flex items-center justify-between">
+            <span className={LABEL}>Auto-Rotate</span>
+            <button
+              type="button"
+              onClick={handleAutoRotate}
+              disabled={disabled}
+              className="relative rounded-full transition-all duration-150"
+              style={{
+                width: 28,
+                height: 16,
+                background: arcPath.autoRotate ? P.accent : "#27272A",
+              }}
+              title={
+                arcPath.autoRotate
+                  ? "Disable auto-rotate along path"
+                  : "Rotate element to follow path tangent"
+              }
+            >
+              <span
+                className="absolute top-[2px] left-0 rounded-full transition-transform duration-150"
+                style={{
+                  width: 12,
+                  height: 12,
+                  background: arcPath.autoRotate ? P.white : P.textMuted,
+                  transform: arcPath.autoRotate ? "translateX(14px)" : "translateX(2px)",
+                }}
+              />
+            </button>
+          </div>
+
+          {arcPath.segments.map((seg, i) => (
+            <div key={i} className="grid min-w-0 gap-1.5">
+              <div className="flex items-center justify-between">
+                <span className={LABEL}>
+                  {segmentCount === 1 ? "Curviness" : `Segment ${i + 1}`}
+                </span>
+                {seg.cp1 && seg.cp2 && (
+                  <button
+                    type="button"
+                    onClick={() => onUpdateSegment(i, { cp1: undefined, cp2: undefined })}
+                    className="text-[9px] font-medium text-neutral-500 transition-colors hover:text-neutral-300"
+                    title="Reset to auto-generated control points"
+                  >
+                    Reset
+                  </button>
+                )}
+              </div>
+              <SliderControl
+                value={seg.curviness}
+                min={0}
+                max={3}
+                step={0.1}
+                disabled={disabled}
+                displayValue={seg.curviness.toFixed(1)}
+                formatDisplayValue={(v) => v.toFixed(1)}
+                onCommit={(v) => onUpdateSegment(i, { curviness: v })}
+              />
+            </div>
+          ))}
+        </>
+      )}
+    </div>
+  );
+});
diff --git a/packages/studio/src/components/editor/BorderRadiusEditor.tsx b/packages/studio/src/components/editor/BorderRadiusEditor.tsx
index c4f697a5f..011d5aeb6 100644
--- a/packages/studio/src/components/editor/BorderRadiusEditor.tsx
+++ b/packages/studio/src/components/editor/BorderRadiusEditor.tsx
@@ -83,28 +83,28 @@ export function BorderRadiusEditor({
             cx={sTL}
             cy={sTL}
             r={3}
-            fill={linked ? "#3b82f6" : "#a78bfa"}
+            fill={linked ? "#3CE6AC" : "#52525B"}
             className="cursor-pointer"
           />
           <circle
             cx={PREVIEW_W - sTR}
             cy={sTR}
             r={3}
-            fill={linked ? "#3b82f6" : "#a78bfa"}
+            fill={linked ? "#3CE6AC" : "#52525B"}
             className="cursor-pointer"
           />
           <circle
             cx={PREVIEW_W - sBR}
             cy={PREVIEW_H - sBR}
             r={3}
-            fill={linked ? "#3b82f6" : "#a78bfa"}
+            fill={linked ? "#3CE6AC" : "#52525B"}
             className="cursor-pointer"
           />
           <circle
             cx={sBL}
             cy={PREVIEW_H - sBL}
             r={3}
-            fill={linked ? "#3b82f6" : "#a78bfa"}
+            fill={linked ? "#3CE6AC" : "#52525B"}
             className="cursor-pointer"
           />
         </svg>
diff --git a/packages/studio/src/components/editor/DomEditOverlay.tsx b/packages/studio/src/components/editor/DomEditOverlay.tsx
index ec289fc78..a8625355b 100644
--- a/packages/studio/src/components/editor/DomEditOverlay.tsx
+++ b/packages/studio/src/components/editor/DomEditOverlay.tsx
@@ -90,6 +90,29 @@ export const DomEditOverlay = memo(function DomEditOverlay({
 }: DomEditOverlayProps) {
   const overlayRef = useRef<HTMLDivElement | null>(null);
   const boxRef = useRef<HTMLDivElement | null>(null);
+
+  const selectionShapeStyles = (() => {
+    const fallback = {
+      borderRadius: 4 as string | number,
+      clipPath: undefined as string | undefined,
+    };
+    if (!selection?.element) return fallback;
+    try {
+      const tag = selection.element.tagName.toLowerCase();
+      if (tag === "svg" || tag === "img" || tag === "video" || tag === "canvas") return fallback;
+      const win = selection.element.ownerDocument.defaultView;
+      if (!win) return fallback;
+      const cs = win.getComputedStyle(selection.element);
+      const br = cs.borderRadius;
+      const cp = cs.clipPath;
+      return {
+        borderRadius: br && br !== "0px" ? br : 4,
+        clipPath: cp && cp !== "none" ? cp : undefined,
+      };
+    } catch {
+      return fallback;
+    }
+  })();
   const gestureRef = useRef<GestureState | null>(null);
   const groupGestureRef = useRef<GroupGestureState | null>(null);
   const blockedMoveRef = useRef<BlockedMoveState | null>(null);
@@ -134,6 +157,7 @@ export const DomEditOverlay = memo(function DomEditOverlay({
     groupOverlayItems,
     groupOverlayItemsRef,
     setGroupOverlayItems,
+    childRects,
   } = useDomEditOverlayRects({
     iframeRef,
     overlayRef,
@@ -324,13 +348,30 @@ export const DomEditOverlay = memo(function DomEditOverlay({
         <div
           aria-hidden="true"
           data-dom-edit-hover-box="true"
-          className="pointer-events-none absolute rounded-xl border border-studio-accent/80 bg-studio-accent/5 shadow-[0_0_0_1px_rgba(60,230,172,0.25)]"
-          style={{
-            left: hoverRect.left,
-            top: hoverRect.top,
-            width: hoverRect.width,
-            height: hoverRect.height,
-          }}
+          className="pointer-events-none absolute border border-studio-accent/80 bg-studio-accent/5 shadow-[0_0_0_1px_rgba(60,230,172,0.25)]"
+          style={(() => {
+            let br: string | number = 4;
+            let cp: string | undefined;
+            try {
+              const el = hoverSelection.element;
+              const tag = el.tagName.toLowerCase();
+              if (tag !== "svg" && tag !== "img" && tag !== "video" && tag !== "canvas") {
+                const cs = el.ownerDocument.defaultView?.getComputedStyle(el);
+                if (cs?.borderRadius && cs.borderRadius !== "0px") br = cs.borderRadius;
+                if (cs?.clipPath && cs.clipPath !== "none") cp = cs.clipPath;
+              }
+            } catch {
+              /* cross-origin guard */
+            }
+            return {
+              left: hoverRect.left,
+              top: hoverRect.top,
+              width: hoverRect.width,
+              height: hoverRect.height,
+              borderRadius: br,
+              clipPath: cp,
+            };
+          })()}
         />
       )}
       {hasGroupSelection && groupOverlayItems.length > 1 && groupBounds && (
@@ -398,12 +439,14 @@ export const DomEditOverlay = memo(function DomEditOverlay({
             key={selectionKey}
             ref={boxRef}
             data-dom-edit-selection-box="true"
-            className="pointer-events-auto absolute rounded-xl border border-studio-accent/80 bg-studio-accent/5 shadow-[0_0_0_1px_rgba(60,230,172,0.25)]"
+            className={`pointer-events-auto absolute ${selectionShapeStyles.clipPath ? "shadow-[inset_0_0_0_2px_rgba(60,230,172,0.6)]" : "border border-studio-accent/80 shadow-[0_0_0_1px_rgba(60,230,172,0.25)]"} bg-studio-accent/5`}
             style={{
               left: overlayRect.left,
               top: overlayRect.top,
               width: overlayRect.width,
               height: overlayRect.height,
+              borderRadius: selectionShapeStyles.borderRadius,
+              clipPath: selectionShapeStyles.clipPath,
               cursor:
                 allowCanvasMovement && selection.capabilities.canApplyManualOffset
                   ? "move"
@@ -441,6 +484,19 @@ export const DomEditOverlay = memo(function DomEditOverlay({
           </div>
         </>
       )}
+      {childRects.length > 0 &&
+        childRects.map((cr, i) => (
+          <div
+            key={i}
+            className="pointer-events-none absolute border border-dashed border-white/20 rounded-sm"
+            style={{
+              left: cr.left,
+              top: cr.top,
+              width: cr.width,
+              height: cr.height,
+            }}
+          />
+        ))}
       <GridOverlay
         visible={gridVisible}
         spacing={gridSpacing}
diff --git a/packages/studio/src/components/editor/DopesheetStrip.tsx b/packages/studio/src/components/editor/DopesheetStrip.tsx
new file mode 100644
index 000000000..10fab3e66
--- /dev/null
+++ b/packages/studio/src/components/editor/DopesheetStrip.tsx
@@ -0,0 +1,141 @@
+import { memo, useCallback, useRef } from "react";
+
+interface DopesheetKeyframe {
+  percentage: number;
+  properties: Record<string, number | string>;
+  ease?: string;
+}
+
+interface DopesheetStripProps {
+  keyframes: DopesheetKeyframe[];
+  selectedPercentage: number | null;
+  currentPercentage: number;
+  accentColor?: string;
+  onSelectKeyframe: (percentage: number) => void;
+  onDragKeyframe?: (fromPct: number, toPct: number) => void;
+}
+
+const DIAMOND_SIZE = 8;
+const HALF = DIAMOND_SIZE / 2;
+const STRIP_HEIGHT = 20;
+const PADDING_X = 8;
+
+export const DopesheetStrip = memo(function DopesheetStrip({
+  keyframes,
+  selectedPercentage,
+  currentPercentage,
+  accentColor = "#3CE6AC",
+  onSelectKeyframe,
+  onDragKeyframe,
+}: DopesheetStripProps) {
+  const containerRef = useRef<HTMLDivElement>(null);
+  const dragRef = useRef<{ startX: number; startPct: number } | null>(null);
+
+  const sorted = keyframes.slice().sort((a, b) => a.percentage - b.percentage);
+
+  const handlePointerDown = useCallback(
+    (e: React.PointerEvent, pct: number) => {
+      if (e.button !== 0) return;
+      e.stopPropagation();
+      const startX = e.clientX;
+
+      const handleMove = (me: PointerEvent) => {
+        if (Math.abs(me.clientX - startX) > 4) {
+          dragRef.current = { startX, startPct: pct };
+        }
+      };
+
+      const handleUp = (ue: PointerEvent) => {
+        document.removeEventListener("pointermove", handleMove);
+        document.removeEventListener("pointerup", handleUp);
+        if (dragRef.current && containerRef.current && onDragKeyframe) {
+          const rect = containerRef.current.getBoundingClientRect();
+          const usableWidth = rect.width - PADDING_X * 2;
+          const dx = ue.clientX - dragRef.current.startX;
+          const dpct = (dx / usableWidth) * 100;
+          const newPct = Math.max(0, Math.min(100, Math.round((pct + dpct) * 10) / 10));
+          if (newPct !== pct) onDragKeyframe(pct, newPct);
+        } else {
+          onSelectKeyframe(pct);
+        }
+        dragRef.current = null;
+      };
+
+      document.addEventListener("pointermove", handleMove);
+      document.addEventListener("pointerup", handleUp);
+    },
+    [onSelectKeyframe, onDragKeyframe],
+  );
+
+  return (
+    <div
+      ref={containerRef}
+      className="relative w-full rounded-md bg-neutral-900/60 border border-neutral-800/50"
+      style={{ height: STRIP_HEIGHT }}
+    >
+      {/* Playhead indicator */}
+      <div
+        className="absolute top-0 bottom-0 w-px bg-white/30"
+        style={{
+          left: `${PADDING_X + (currentPercentage / 100) * (100 - PADDING_X * 2)}%`,
+          marginLeft: -0.5,
+        }}
+      />
+
+      {/* Diamond markers */}
+      <svg
+        className="absolute inset-0 w-full"
+        style={{ height: STRIP_HEIGHT }}
+        viewBox={`0 0 100 ${STRIP_HEIGHT}`}
+        preserveAspectRatio="none"
+      >
+        {sorted.map((kf) => {
+          const x = PADDING_X + (kf.percentage / 100) * (100 - PADDING_X * 2);
+          const y = STRIP_HEIGHT / 2;
+          const isSelected =
+            selectedPercentage !== null && Math.abs(kf.percentage - selectedPercentage) < 0.5;
+          const isHold = kf.ease === "steps(1)";
+          const fillColor = isSelected ? accentColor : "#737373";
+
+          return (
+            <g
+              key={kf.percentage}
+              onPointerDown={(e) => handlePointerDown(e, kf.percentage)}
+              style={{ cursor: "pointer" }}
+            >
+              {isHold ? (
+                <rect
+                  x={x - HALF}
+                  y={y - HALF}
+                  width={DIAMOND_SIZE}
+                  height={DIAMOND_SIZE}
+                  fill={fillColor}
+                />
+              ) : (
+                <rect
+                  x={x - HALF}
+                  y={y - HALF}
+                  width={DIAMOND_SIZE}
+                  height={DIAMOND_SIZE}
+                  fill={fillColor}
+                  transform={`rotate(45, ${x}, ${y})`}
+                />
+              )}
+            </g>
+          );
+        })}
+      </svg>
+
+      {/* Time labels */}
+      {sorted.length > 0 && (
+        <div
+          className="absolute bottom-0 left-0 right-0 flex justify-between px-2 text-[8px] text-neutral-600 pointer-events-none"
+          style={{ lineHeight: "10px" }}
+        >
+          <span>{sorted[0].percentage}%</span>
+          {sorted.length > 1 && <span>{sorted[sorted.length - 1].percentage}%</span>}
+        </div>
+      )}
+    </div>
+  );
+});
diff --git a/packages/studio/src/components/editor/EaseCurveSection.tsx b/packages/studio/src/components/editor/EaseCurveSection.tsx
index 88e6b81f8..5eef531d0 100644
--- a/packages/studio/src/components/editor/EaseCurveSection.tsx
+++ b/packages/studio/src/components/editor/EaseCurveSection.tsx
@@ -1,6 +1,80 @@
-import { useCallback, useRef, useState } from "react";
+import { memo, useCallback, useRef, useState } from "react";
 import { EASE_CURVES, EASE_LABELS, parseCustomEaseFromString } from "./gsapAnimationConstants";
 
+const PRESET_GRID_EASES = [
+  "none",
+  "power2.out",
+  "power2.in",
+  "power2.inOut",
+  "power3.out",
+  "back.out",
+  "expo.out",
+  "elastic.out",
+] as const;
+
+function MiniCurveSvg({
+  curve,
+  active,
+}: {
+  curve: [number, number, number, number];
+  active: boolean;
+}) {
+  const [x1, y1, x2, y2] = curve;
+  const s = 24;
+  const p = 3;
+  const g = s - p * 2;
+  const sx = (px: number) => p + g * px;
+  const sy = (py: number) => s - p - g * py;
+  const d = `M${p},${s - p} C${sx(x1)},${sy(y1)} ${sx(x2)},${sy(y2)} ${s - p},${p}`;
+  return (
+    <svg width={s} height={s} viewBox={`0 0 ${s} ${s}`}>
+      <path
+        d={d}
+        fill="none"
+        stroke={active ? "#3CE6AC" : "#737373"}
+        strokeWidth="1.5"
+        strokeLinecap="round"
+      />
+    </svg>
+  );
+}
+
+const EasePresetGrid = memo(function EasePresetGrid({
+  currentEase,
+  onSelect,
+}: {
+  currentEase: string;
+  onSelect: (ease: string) => void;
+}) {
+  return (
+    <div className="grid grid-cols-4 gap-1 mb-2">
+      {PRESET_GRID_EASES.map((name) => {
+        const curve = EASE_CURVES[name];
+        if (!curve) return null;
+        const isActive = currentEase === name;
+        return (
+          <button
+            key={name}
+            type="button"
+            onClick={() => onSelect(name)}
+            className={`flex flex-col items-center gap-0.5 rounded-md p-1 transition-colors ${
+              isActive ? "bg-panel-accent/10 ring-1 ring-panel-accent/30" : "hover:bg-neutral-800"
+            }`}
+            title={EASE_LABELS[name] ?? name}
+          >
+            <MiniCurveSvg curve={curve} active={isActive} />
+            <span
+              className={`text-[8px] leading-none ${isActive ? "text-panel-accent" : "text-neutral-500"}`}
+            >
+              {(EASE_LABELS[name] ?? name).split(" ").slice(0, 2).join(" ")}
+            </span>
+          </button>
+        );
+      })}
+    </div>
+  );
+});
+
 function round2(n: number): number {
   return Math.round(n * 100) / 100;
 }
@@ -108,12 +182,13 @@ export function EaseCurveSection({
 
   return (
     <div className="rounded-lg bg-neutral-900/50 p-2">
+      <EasePresetGrid currentEase={ease} onSelect={(name) => onCustomEaseCommit(name)} />
       <div className="mb-1.5 flex items-center justify-between">
         <span className="text-[10px] font-medium text-neutral-500">Speed curve</span>
         <button
           type="button"
           onClick={play}
-          className="rounded px-1.5 py-0.5 text-[10px] font-medium text-emerald-400 transition-colors hover:bg-emerald-500/10"
+          className="rounded px-1.5 py-0.5 text-[10px] font-medium text-panel-accent transition-colors hover:bg-panel-accent/10"
         >
           {progress !== null ? "Playing…" : "Preview"}
         </button>
@@ -165,17 +240,17 @@ export function EaseCurveSection({
             y1={end.y}
             x2={p2.x}
             y2={p2.y}
-            stroke="rgba(52,211,153,0.25)"
+            stroke="rgba(45,212,191,0.25)"
             strokeWidth="1"
           />
-          <path d={curvePath} fill="none" stroke="#34d399" strokeWidth="2" strokeLinecap="round" />
-          {progress !== null && <circle cx={dotX} cy={dotY} r="4" fill="#34d399" />}
+          <path d={curvePath} fill="none" stroke="#3CE6AC" strokeWidth="2" strokeLinecap="round" />
+          {progress !== null && <circle cx={dotX} cy={dotY} r="4" fill="#3CE6AC" />}
           <circle
             cx={p1.x}
             cy={p1.y}
             r="5"
             fill="#0a0a1a"
-            stroke="#34d399"
+            stroke="#3CE6AC"
             strokeWidth="2"
             className="cursor-grab active:cursor-grabbing"
             onPointerDown={(e) => handlePointerDown("p1", e)}
@@ -185,7 +260,7 @@ export function EaseCurveSection({
             cy={p2.y}
             r="5"
             fill="#0a0a1a"
-            stroke="#34d399"
+            stroke="#3CE6AC"
             strokeWidth="2"
             className="cursor-grab active:cursor-grabbing"
             onPointerDown={(e) => handlePointerDown("p2", e)}
diff --git a/packages/studio/src/components/editor/GsapAnimationSection.tsx b/packages/studio/src/components/editor/GsapAnimationSection.tsx
index f9c6a505e..72ecf5186 100644
--- a/packages/studio/src/components/editor/GsapAnimationSection.tsx
+++ b/packages/studio/src/components/editor/GsapAnimationSection.tsx
@@ -1,5 +1,5 @@
 import { memo, useState } from "react";
-import type { GsapAnimation } from "@hyperframes/core/gsap-parser";
+import type { ArcPathSegment, GsapAnimation } from "@hyperframes/core/gsap-parser";
 import { Film } from "../../icons/SystemIcons";
 import { Section } from "./propertyPanelPrimitives";
 import { ADD_METHODS, ADD_METHOD_LABELS, METHOD_TOOLTIPS } from "./gsapAnimationConstants";
@@ -23,6 +23,15 @@ interface GsapAnimationSectionProps {
   onAddAnimation: (method: "to" | "from" | "set" | "fromTo") => void;
   onLivePreview?: (property: string, value: number | string) => void;
   onLivePreviewEnd?: () => void;
+  onSetArcPath?: (
+    animationId: string,
+    config: { enabled: boolean; autoRotate?: boolean | number; segments?: ArcPathSegment[] },
+  ) => void;
+  onUpdateArcSegment?: (
+    animationId: string,
+    segmentIndex: number,
+    update: Partial<ArcPathSegment>,
+  ) => void;
 }
 
 export const GsapAnimationSection = memo(function GsapAnimationSection({
@@ -40,6 +49,8 @@ export const GsapAnimationSection = memo(function GsapAnimationSection({
   onAddAnimation,
   onLivePreview,
   onLivePreviewEnd,
+  onSetArcPath,
+  onUpdateArcSegment,
 }: GsapAnimationSectionProps) {
   const [addMenuOpen, setAddMenuOpen] = useState(false);
 
@@ -75,6 +86,8 @@ export const GsapAnimationSection = memo(function GsapAnimationSection({
               onRemoveFromProperty={onRemoveFromProperty}
               onLivePreview={onLivePreview}
               onLivePreviewEnd={onLivePreviewEnd}
+              onSetArcPath={onSetArcPath}
+              onUpdateArcSegment={onUpdateArcSegment}
             />
           ))}
 
diff --git a/packages/studio/src/components/editor/KeyframeDiamond.tsx b/packages/studio/src/components/editor/KeyframeDiamond.tsx
index 10c7814c8..57722eef9 100644
--- a/packages/studio/src/components/editor/KeyframeDiamond.tsx
+++ b/packages/studio/src/components/editor/KeyframeDiamond.tsx
@@ -7,6 +7,7 @@ interface KeyframeDiamondProps {
   onClick: () => void;
   title?: string;
   size?: number;
+  isHold?: boolean;
 }
 
 // fallow-ignore-next-line complexity
@@ -15,10 +16,11 @@ export const KeyframeDiamond = memo(function KeyframeDiamond({
   onClick,
   title,
   size = 10,
+  isHold = false,
 }: KeyframeDiamondProps) {
   const isFilled = state === "active";
   const opacity = state === "ghost" ? 0.25 : state === "inactive" ? 0.6 : 1;
-  const color = state === "active" ? "#3b82f6" : "#a3a3a3";
+  const color = state === "active" ? "#3CE6AC" : "#a3a3a3";
 
   return (
     <button
@@ -32,17 +34,30 @@ export const KeyframeDiamond = memo(function KeyframeDiamond({
       title={title}
     >
       <svg width={size} height={size} viewBox="0 0 10 10">
-        <rect
-          x="5"
-          y="0.7"
-          width="6"
-          height="6"
-          rx="1"
-          transform="rotate(45 5 0.7)"
-          fill={isFilled ? "currentColor" : "none"}
-          stroke="currentColor"
-          strokeWidth="1.2"
-        />
+        {isHold ? (
+          <rect
+            x="2"
+            y="2"
+            width="6"
+            height="6"
+            rx="0.5"
+            fill={isFilled ? "currentColor" : "none"}
+            stroke="currentColor"
+            strokeWidth="1.2"
+          />
+        ) : (
+          <rect
+            x="5"
+            y="0.7"
+            width="6"
+            height="6"
+            rx="1"
+            transform="rotate(45 5 0.7)"
+            fill={isFilled ? "currentColor" : "none"}
+            stroke="currentColor"
+            strokeWidth="1.2"
+          />
+        )}
       </svg>
     </button>
   );
diff --git a/packages/studio/src/components/editor/LayersPanel.tsx b/packages/studio/src/components/editor/LayersPanel.tsx
index 8dddc31f1..4eda5c35d 100644
--- a/packages/studio/src/components/editor/LayersPanel.tsx
+++ b/packages/studio/src/components/editor/LayersPanel.tsx
@@ -239,9 +239,9 @@ export const LayersPanel = memo(function LayersPanel() {
 
   if (layers.length === 0) {
     return (
-      <div className="flex h-full flex-col items-center justify-center bg-neutral-900 px-6 text-center">
-        <Layers size={18} className="mb-3 text-neutral-600" />
-        <p className="text-sm font-medium text-neutral-200">No layers</p>
+      <div className="flex h-full flex-col items-center justify-center bg-panel-bg px-6 text-center">
+        <Layers size={18} className="mb-3 text-panel-text-5" />
+        <p className="text-sm font-medium text-panel-text-1">No layers</p>
         <p className="mt-1 text-xs text-neutral-500">Load a composition to see its element tree</p>
       </div>
     );
@@ -249,10 +249,10 @@ export const LayersPanel = memo(function LayersPanel() {
 
   return (
     <div
-      className="flex h-full min-h-0 flex-col overflow-hidden bg-neutral-900"
+      className="flex h-full min-h-0 flex-col overflow-hidden bg-panel-bg"
       onPointerLeave={() => handleLayerHover(null)}
     >
-      <div className="border-b border-white/10 px-3 py-2 text-[11px] text-neutral-500">
+      <div className="border-b border-panel-border px-3 py-2 text-[11px] text-panel-text-3">
         {layers.length} layer{layers.length === 1 ? "" : "s"}
       </div>
       <div
@@ -289,8 +289,8 @@ export const LayersPanel = memo(function LayersPanel() {
                 isDragged
                   ? "opacity-40"
                   : selected
-                    ? "bg-studio-accent/14 text-studio-accent"
-                    : "text-neutral-300 hover:bg-white/[0.04] hover:text-neutral-100"
+                    ? "bg-panel-accent/14 text-panel-accent"
+                    : "text-panel-text-2 hover:bg-panel-hover/40 hover:text-panel-text-1"
               } ${dragKey ? "cursor-grabbing" : draggable ? "cursor-pointer" : "cursor-not-allowed opacity-50"}`}
               style={{ paddingLeft: 8 + layer.depth * 16 }}
             >
@@ -316,17 +316,19 @@ export const LayersPanel = memo(function LayersPanel() {
               <span
                 className={`flex h-5 w-5 flex-shrink-0 items-center justify-center rounded text-[8px] font-bold uppercase ${
                   selected
-                    ? "bg-studio-accent/18 text-studio-accent"
+                    ? "bg-panel-accent/18 text-panel-accent"
                     : isCompHost
-                      ? "bg-blue-900/40 text-blue-400"
-                      : "bg-neutral-800 text-neutral-500"
+                      ? "bg-panel-accent/40 text-panel-accent"
+                      : "bg-panel-hover text-panel-text-4"
                 }`}
               >
                 {getTagBadge(layer.tagName)}
               </span>
               <span className="min-w-0 flex-1 truncate text-[11px]">{layer.label}</span>
               {hasChildren && (
-                <span className="text-[9px] tabular-nums text-neutral-600">{layer.childCount}</span>
+                <span className="text-[9px] tabular-nums text-panel-text-5">
+                  {layer.childCount}
+                </span>
               )}
             </div>
           );
diff --git a/packages/studio/src/components/editor/MotionPathOverlay.tsx b/packages/studio/src/components/editor/MotionPathOverlay.tsx
new file mode 100644
index 000000000..49ea39dd0
--- /dev/null
+++ b/packages/studio/src/components/editor/MotionPathOverlay.tsx
@@ -0,0 +1,146 @@
+import { memo, useMemo, type RefObject } from "react";
+import type { ArcPathConfig } from "@hyperframes/core/gsap-parser";
+
+interface MotionPathOverlayProps {
+  iframeRef: RefObject<HTMLIFrameElement | null>;
+  arcPath: ArcPathConfig | null;
+  waypoints: Array<{ x: number; y: number }> | null;
+  elementBaseRect: { left: number; top: number; scaleX: number; scaleY: number } | null;
+}
+
+function buildSvgPath(
+  waypoints: Array<{ x: number; y: number }>,
+  segments: ArcPathConfig["segments"],
+  base: { left: number; top: number; scaleX: number; scaleY: number },
+): string {
+  if (waypoints.length < 2) return "";
+
+  const toPixel = (wp: { x: number; y: number }) => ({
+    x: base.left + wp.x * base.scaleX,
+    y: base.top + wp.y * base.scaleY,
+  });
+
+  const first = toPixel(waypoints[0]!);
+  const parts = [`M ${first.x} ${first.y}`];
+
+  for (let i = 0; i < segments.length && i < waypoints.length - 1; i++) {
+    const seg = segments[i]!;
+    const end = toPixel(waypoints[i + 1]!);
+
+    if (seg.cp1 && seg.cp2) {
+      const c1 = toPixel(seg.cp1);
+      const c2 = toPixel(seg.cp2);
+      parts.push(`C ${c1.x} ${c1.y} ${c2.x} ${c2.y} ${end.x} ${end.y}`);
+    } else {
+      const start = toPixel(waypoints[i]!);
+      const dx = end.x - start.x;
+      const dy = end.y - start.y;
+      const c = seg.curviness ?? 1;
+      const offset = c * Math.abs(dx) * 0.25;
+      const c1x = start.x + dx * 0.33;
+      const c1y = start.y + dy * 0.33 - offset;
+      const c2x = start.x + dx * 0.66;
+      const c2y = start.y + dy * 0.66 - offset;
+      parts.push(`C ${c1x} ${c1y} ${c2x} ${c2y} ${end.x} ${end.y}`);
+    }
+  }
+
+  return parts.join(" ");
+}
+
+export const MotionPathOverlay = memo(function MotionPathOverlay({
+  arcPath,
+  waypoints,
+  elementBaseRect,
+}: MotionPathOverlayProps) {
+  const pathD = useMemo(() => {
+    if (!arcPath?.enabled || !waypoints || waypoints.length < 2 || !elementBaseRect) return "";
+    return buildSvgPath(waypoints, arcPath.segments, elementBaseRect);
+  }, [arcPath, waypoints, elementBaseRect]);
+
+  const anchorPoints = useMemo(() => {
+    if (!waypoints || !elementBaseRect) return [];
+    return waypoints.map((wp) => ({
+      x: elementBaseRect.left + wp.x * elementBaseRect.scaleX,
+      y: elementBaseRect.top + wp.y * elementBaseRect.scaleY,
+    }));
+  }, [waypoints, elementBaseRect]);
+
+  const controlPoints = useMemo(() => {
+    if (!arcPath?.enabled || !elementBaseRect) return [];
+    const points: Array<{
+      segIndex: number;
+      type: "cp1" | "cp2";
+      x: number;
+      y: number;
+      anchorX: number;
+      anchorY: number;
+    }> = [];
+    for (let i = 0; i < arcPath.segments.length; i++) {
+      const seg = arcPath.segments[i]!;
+      if (seg.cp1 && seg.cp2 && waypoints) {
+        const anchor1 = waypoints[i]!;
+        const anchor2 = waypoints[i + 1]!;
+        points.push({
+          segIndex: i,
+          type: "cp1",
+          x: elementBaseRect.left + seg.cp1.x * elementBaseRect.scaleX,
+          y: elementBaseRect.top + seg.cp1.y * elementBaseRect.scaleY,
+          anchorX: elementBaseRect.left + anchor1.x * elementBaseRect.scaleX,
+          anchorY: elementBaseRect.top + anchor1.y * elementBaseRect.scaleY,
+        });
+        points.push({
+          segIndex: i,
+          type: "cp2",
+          x: elementBaseRect.left + seg.cp2.x * elementBaseRect.scaleX,
+          y: elementBaseRect.top + seg.cp2.y * elementBaseRect.scaleY,
+          anchorX: elementBaseRect.left + anchor2.x * elementBaseRect.scaleX,
+          anchorY: elementBaseRect.top + anchor2.y * elementBaseRect.scaleY,
+        });
+      }
+    }
+    return points;
+  }, [arcPath, waypoints, elementBaseRect]);
+
+  if (!pathD) return null;
+
+  return (
+    <svg className="absolute inset-0 pointer-events-none z-20 overflow-visible">
+      <path d={pathD} fill="none" stroke="rgba(45, 212, 191, 0.4)" strokeWidth={2} />
+
+      {controlPoints.map((cp) => (
+        <g key={`${cp.segIndex}-${cp.type}`}>
+          <line
+            x1={cp.anchorX}
+            y1={cp.anchorY}
+            x2={cp.x}
+            y2={cp.y}
+            stroke="rgba(167, 139, 250, 0.3)"
+            strokeWidth={1}
+            strokeDasharray="3 2"
+          />
+          <circle
+            cx={cp.x}
+            cy={cp.y}
+            r={4}
+            fill="#a78bfa"
+            className="pointer-events-auto cursor-grab"
+          />
+        </g>
+      ))}
+
+      {anchorPoints.map((pt, i) => (
+        <circle
+          key={i}
+          cx={pt.x}
+          cy={pt.y}
+          r={5}
+          fill="#3CE6AC"
+          stroke="rgba(255,255,255,0.5)"
+          strokeWidth={1}
+          className="pointer-events-auto cursor-pointer"
+        />
+      ))}
+    </svg>
+  );
+});
diff --git a/packages/studio/src/components/editor/PropertyPanel.tsx b/packages/studio/src/components/editor/PropertyPanel.tsx
index 551d734be..a95996e39 100644
--- a/packages/studio/src/components/editor/PropertyPanel.tsx
+++ b/packages/studio/src/components/editor/PropertyPanel.tsx
@@ -4,7 +4,6 @@ import { readStudioBoxSize, readStudioPathOffset, readStudioRotation } from "./m
 import {
   EMPTY_STYLES,
   formatPxMetricValue,
-  LABEL,
   parsePxMetricValue,
   RESPONSIVE_GRID,
 } from "./propertyPanelHelpers";
@@ -16,7 +15,7 @@ import { KeyframeNavigation } from "./KeyframeNavigation";
 import { STUDIO_GSAP_PANEL_ENABLED, STUDIO_KEYFRAMES_ENABLED } from "./manualEditingAvailability";
 import { usePlayerStore } from "../../player";
 import { TimingSection } from "./propertyPanelTimingSection";
-import { computeFitToChildrenSize, type PropertyPanelProps } from "./propertyPanelHelpers";
+import { type PropertyPanelProps } from "./propertyPanelHelpers";
 
 // Re-export helpers that external consumers import from this module
 export {
@@ -70,6 +69,8 @@ export const PropertyPanel = memo(function PropertyPanel({
   onAddGsapFromProperty,
   onRemoveGsapFromProperty,
   onAddGsapAnimation,
+  onSetArcPath,
+  onUpdateArcSegment,
   onAddKeyframe,
   onRemoveKeyframe,
   onConvertToKeyframes,
@@ -252,34 +253,33 @@ export const PropertyPanel = memo(function PropertyPanel({
   const displayR = gsapRuntimeValues?.rotation ?? manualRotation.angle;
 
   return (
-    <div className="flex h-full min-h-0 flex-col overflow-hidden bg-neutral-900 text-neutral-100">
-      <div className="border-b border-neutral-800 px-4 py-5">
-        <div className="flex items-start justify-between gap-4">
+    <div className="flex h-full min-h-0 flex-col overflow-hidden bg-panel-bg text-panel-text-1">
+      <div className="px-4 py-3">
+        <div className="flex items-center justify-between gap-4">
           <div className="min-w-0">
-            <div className={LABEL}>Document</div>
-            <div className="mt-3 truncate text-[12px] font-semibold text-neutral-100">
+            <div className="truncate text-[13px] font-semibold text-neutral-100">
               {element.label}
             </div>
-            <div className="mt-1 truncate text-[11px] text-neutral-500">{sourceLabel}</div>
+            <div className="mt-0.5 truncate text-[11px] text-neutral-500">{sourceLabel}</div>
+          </div>
+          <div className="flex items-center gap-1">
+            <button
+              type="button"
+              onClick={onAskAgent}
+              className="flex h-6 w-6 items-center justify-center rounded text-neutral-500 transition-colors hover:bg-neutral-800 hover:text-neutral-300"
+              title={copiedAgentPrompt ? "Prompt copied" : "Copy prompt to AI agent"}
+            >
+              <MessageSquare size={13} />
+            </button>
+            <button
+              type="button"
+              aria-label="Clear selection"
+              onClick={onClearSelection}
+              className="flex h-6 w-6 items-center justify-center rounded text-neutral-500 transition-colors hover:bg-neutral-800 hover:text-neutral-300"
+            >
+              <X size={13} />
+            </button>
           </div>
-          <button
-            type="button"
-            aria-label="Clear selection"
-            onClick={onClearSelection}
-            className="flex h-9 w-9 items-center justify-center rounded-full border border-neutral-700 bg-neutral-950 text-neutral-500 shadow-[0_1px_2px_rgba(0,0,0,0.2)] transition-colors hover:border-neutral-600 hover:text-neutral-200"
-          >
-            <X size={13} />
-          </button>
-        </div>
-        <div className="mt-4 flex min-w-0 flex-wrap items-center gap-2">
-          <button
-            type="button"
-            onClick={onAskAgent}
-            className="inline-flex h-8 items-center justify-center gap-2 rounded-xl border border-neutral-700 bg-neutral-950 px-3.5 text-[11px] font-medium text-neutral-100 transition-colors hover:border-studio-accent/40 hover:text-studio-accent"
-          >
-            <MessageSquare size={15} />
-            <span>{copiedAgentPrompt ? "Prompt copied" : "Copy prompt to AI agent"}</span>
-          </button>
         </div>
       </div>
 
@@ -412,29 +412,6 @@ export const PropertyPanel = memo(function PropertyPanel({
                 />
               )}
             </div>
-            {element.capabilities.canApplyManualSize && (
-              <button
-                type="button"
-                className="flex-shrink-0 rounded p-1 text-neutral-500 transition-colors hover:bg-neutral-800 hover:text-neutral-300"
-                title="Fit to children"
-                onClick={() => {
-                  const size = computeFitToChildrenSize(element);
-                  if (size) onSetManualSize(element, size);
-                }}
-              >
-                <svg
-                  width="14"
-                  height="14"
-                  viewBox="0 0 14 14"
-                  fill="none"
-                  stroke="currentColor"
-                  strokeWidth="1.2"
-                >
-                  <rect x="2" y="2" width="10" height="10" strokeDasharray="2 1.5" rx="1" />
-                  <path d="M2 4.5h1m-1 5h1m8-5h1m-1 5h1M4.5 2v1m5-1v1M4.5 11v1m5-1v1" />
-                </svg>
-              </button>
-            )}
             <div className="flex items-center gap-1">
               <div className="flex-1">
                 <MetricField
@@ -495,17 +472,40 @@ export const PropertyPanel = memo(function PropertyPanel({
                     />
                   )}
                 </div>
-                <MetricField
-                  label="Scale"
-                  value={String(gsapRuntimeValues.scale ?? 1)}
-                  scrub
-                  onCommit={(next) => {
-                    const v = Number.parseFloat(next);
-                    if (Number.isFinite(v) && onCommitAnimatedProperty) {
-                      void onCommitAnimatedProperty(element, "scale", v);
-                    }
-                  }}
-                />
+                <div className="flex items-center gap-1">
+                  <div className="flex-1">
+                    <MetricField
+                      label="Scale"
+                      value={String(gsapRuntimeValues.scale ?? 1)}
+                      scrub
+                      onCommit={(next) => {
+                        const v = Number.parseFloat(next);
+                        if (Number.isFinite(v) && onCommitAnimatedProperty) {
+                          void onCommitAnimatedProperty(element, "scale", v);
+                        }
+                      }}
+                    />
+                  </div>
+                  {STUDIO_KEYFRAMES_ENABLED && (gsapAnimId || onCommitAnimatedProperty) && (
+                    <KeyframeNavigation
+                      property="scale"
+                      keyframes={gsapKeyframes}
+                      currentPercentage={currentPct}
+                      onSeek={(pct) => onSeekToTime?.(elStart + (pct / 100) * elDuration)}
+                      onAddKeyframe={() => {
+                        if (onCommitAnimatedProperty) {
+                          void onCommitAnimatedProperty(
+                            element,
+                            "scale",
+                            gsapRuntimeValues?.scale ?? 1,
+                          );
+                        }
+                      }}
+                      onRemoveKeyframe={(pct) => gsapAnimId && onRemoveKeyframe?.(gsapAnimId, pct)}
+                      onConvertToKeyframes={() => gsapAnimId && onConvertToKeyframes?.(gsapAnimId)}
+                    />
+                  )}
+                </div>
                 <MetricField
                   label="RotX"
                   value={`${gsapRuntimeValues.rotationX ?? 0}°`}
@@ -561,6 +561,8 @@ export const PropertyPanel = memo(function PropertyPanel({
               onAddFromProperty={onAddGsapFromProperty}
               onRemoveFromProperty={onRemoveGsapFromProperty}
               onAddAnimation={onAddGsapAnimation}
+              onSetArcPath={onSetArcPath}
+              onUpdateArcSegment={onUpdateArcSegment}
             />
           )}
 
diff --git a/packages/studio/src/components/editor/StaggerControls.tsx b/packages/studio/src/components/editor/StaggerControls.tsx
new file mode 100644
index 000000000..4f9127520
--- /dev/null
+++ b/packages/studio/src/components/editor/StaggerControls.tsx
@@ -0,0 +1,61 @@
+import { memo, useState } from "react";
+import { MetricField } from "./propertyPanelPrimitives";
+
+export type StaggerOrder = "dom" | "reverse" | "center" | "edges" | "random";
+
+interface StaggerControlsProps {
+  elementCount: number;
+  onApplyStagger: (offsetMs: number, order: StaggerOrder) => void;
+}
+
+const ORDER_OPTIONS: StaggerOrder[] = ["dom", "reverse", "center", "edges", "random"];
+const ORDER_LABELS: Record<StaggerOrder, string> = {
+  dom: "DOM order",
+  reverse: "Reverse",
+  center: "Center out",
+  edges: "Edges in",
+  random: "Random",
+};
+
+export const StaggerControls = memo(function StaggerControls({
+  elementCount,
+  onApplyStagger,
+}: StaggerControlsProps) {
+  const [offsetMs, setOffsetMs] = useState(80);
+  const [order, setOrder] = useState<StaggerOrder>("dom");
+
+  if (elementCount < 2) return null;
+
+  return (
+    <div className="flex items-center gap-2 rounded-lg border border-neutral-800 bg-neutral-900/50 px-2 py-1.5">
+      <span className="text-[10px] font-medium text-neutral-500">Stagger</span>
+      <MetricField
+        label="Offset"
+        value={String(offsetMs)}
+        suffix="ms"
+        onCommit={(raw) => {
+          const v = Number.parseInt(raw, 10);
+          if (Number.isFinite(v) && v >= 0) setOffsetMs(v);
+        }}
+      />
+      <select
+        value={order}
+        onChange={(e) => setOrder(e.target.value as StaggerOrder)}
+        className="rounded-md border border-neutral-700 bg-neutral-900 px-1.5 py-1 text-[10px] text-neutral-200 outline-none"
+      >
+        {ORDER_OPTIONS.map((o) => (
+          <option key={o} value={o}>
+            {ORDER_LABELS[o]}
+          </option>
+        ))}
+      </select>
+      <button
+        type="button"
+        onClick={() => onApplyStagger(offsetMs, order)}
+        className="rounded-md bg-panel-accent/10 px-2 py-1 text-[10px] font-semibold text-panel-accent transition-colors hover:bg-panel-accent/20"
+      >
+        Apply ({elementCount})
+      </button>
+    </div>
+  );
+});
diff --git a/packages/studio/src/components/editor/domEditingElement.ts b/packages/studio/src/components/editor/domEditingElement.ts
index b081d6498..ab60f39b4 100644
--- a/packages/studio/src/components/editor/domEditingElement.ts
+++ b/packages/studio/src/components/editor/domEditingElement.ts
@@ -37,9 +37,26 @@ export function isElementComputedVisible(el: HTMLElement): boolean {
 
 const VISUAL_LEAF_TAGS = new Set(["img", "video", "canvas", "svg", "audio"]);
 
+function hasVisualPresence(el: HTMLElement): boolean {
+  const win = el.ownerDocument.defaultView;
+  if (!win) return false;
+  const cs = win.getComputedStyle(el);
+  if (cs.backgroundImage !== "none") return true;
+  if (
+    cs.backgroundColor &&
+    cs.backgroundColor !== "transparent" &&
+    cs.backgroundColor !== "rgba(0, 0, 0, 0)"
+  )
+    return true;
+  if (cs.borderWidth && parseFloat(cs.borderWidth) > 0 && cs.borderStyle !== "none") return true;
+  if (cs.boxShadow && cs.boxShadow !== "none") return true;
+  return false;
+}
+
 function isEmptyVisualContainer(el: HTMLElement): boolean {
   const tag = el.tagName.toLowerCase();
   if (VISUAL_LEAF_TAGS.has(tag)) return false;
+  if (hasVisualPresence(el)) return false;
 
   const { children } = el;
   if (children.length === 0) {
diff --git a/packages/studio/src/components/editor/manualEditingAvailability.ts b/packages/studio/src/components/editor/manualEditingAvailability.ts
index 553bb5e8d..dc4af6756 100644
--- a/packages/studio/src/components/editor/manualEditingAvailability.ts
+++ b/packages/studio/src/components/editor/manualEditingAvailability.ts
@@ -74,7 +74,7 @@ export const STUDIO_GSAP_PANEL_ENABLED = resolveStudioBooleanEnvFlag(
 export const STUDIO_KEYFRAMES_ENABLED = resolveStudioBooleanEnvFlag(
   env,
   ["VITE_STUDIO_ENABLE_KEYFRAMES", "VITE_STUDIO_KEYFRAMES_ENABLED"],
-  false,
+  true,
 );
 
 export const STUDIO_PREVIEW_SELECTION_ENABLED = STUDIO_INSPECTOR_PANELS_ENABLED;
diff --git a/packages/studio/src/components/editor/panelTokens.ts b/packages/studio/src/components/editor/panelTokens.ts
new file mode 100644
index 000000000..607101ab3
--- /dev/null
+++ b/packages/studio/src/components/editor/panelTokens.ts
@@ -0,0 +1,10 @@
+// ── Design Panel Tokens (for inline style={{}} usage) ──────────────────
+// Tailwind classes use `panel-*` from tailwind.config.js theme.extend.colors.
+// This file provides the same values for inline styles where Tailwind can't reach.
+
+export const P = {
+  accent: "#3CE6AC",
+  borderInput: "#27272A",
+  textMuted: "#52525B",
+  white: "#FAFAFA",
+} as const;
diff --git a/packages/studio/src/components/editor/propertyPanelColor.tsx b/packages/studio/src/components/editor/propertyPanelColor.tsx
index 2a8cb0fd5..962f0e917 100644
--- a/packages/studio/src/components/editor/propertyPanelColor.tsx
+++ b/packages/studio/src/components/editor/propertyPanelColor.tsx
@@ -71,7 +71,7 @@ function ColorSlider({
         aria-valuemax={max}
         aria-valuenow={value}
         aria-disabled={disabled}
-        className={`relative h-4 rounded-full border border-neutral-700 shadow-[inset_0_1px_2px_rgba(0,0,0,0.55)] outline-none focus:border-[#f5a400] focus:ring-2 focus:ring-[#f5a400]/40 ${
+        className={`relative h-4 rounded-full border border-neutral-700 shadow-[inset_0_1px_2px_rgba(0,0,0,0.55)] outline-none focus:border-panel-accent focus:ring-2 focus:ring-panel-accent/40 ${
           disabled ? "cursor-not-allowed opacity-50" : "cursor-ew-resize"
         }`}
         style={{ background }}
@@ -294,7 +294,7 @@ export function ColorField({
                 <div className="truncate text-[11px] font-medium text-neutral-100">
                   {currentColor}
                 </div>
-                <div className="mt-0.5 text-[9px] uppercase tracking-[0.12em] text-neutral-600">
+                <div className="mt-0.5 text-[9px] text-neutral-600">
                   S {saturationPercent}% · B {brightnessPercent}% · A {alphaPercent}%
                 </div>
               </div>
diff --git a/packages/studio/src/components/editor/propertyPanelFill.tsx b/packages/studio/src/components/editor/propertyPanelFill.tsx
index 77a0d2961..3b1669e04 100644
--- a/packages/studio/src/components/editor/propertyPanelFill.tsx
+++ b/packages/studio/src/components/editor/propertyPanelFill.tsx
@@ -278,7 +278,7 @@ export function GradientField({
               checked={parsed.repeating}
               disabled={disabled}
               onChange={(e) => patch({ repeating: e.target.checked })}
-              className="h-4 w-4 rounded border-neutral-700 bg-neutral-950 text-[#3ce6ac] focus:ring-[#3ce6ac]"
+              className="h-4 w-4 rounded border-neutral-700 bg-neutral-950 text-panel-accent focus:ring-panel-accent"
             />
             Repeat
           </label>
diff --git a/packages/studio/src/components/editor/propertyPanelHelpers.ts b/packages/studio/src/components/editor/propertyPanelHelpers.ts
index d043ca332..f5e205a76 100644
--- a/packages/studio/src/components/editor/propertyPanelHelpers.ts
+++ b/packages/studio/src/components/editor/propertyPanelHelpers.ts
@@ -41,6 +41,19 @@ export interface PropertyPanelProps {
   onAddGsapFromProperty?: (animId: string, prop: string) => void;
   onRemoveGsapFromProperty?: (animId: string, prop: string) => void;
   onAddGsapAnimation?: (method: "to" | "from" | "set" | "fromTo") => void;
+  onSetArcPath?: (
+    animId: string,
+    config: {
+      enabled: boolean;
+      autoRotate?: boolean | number;
+      segments?: import("@hyperframes/core/gsap-parser").ArcPathSegment[];
+    },
+  ) => void;
+  onUpdateArcSegment?: (
+    animId: string,
+    segmentIndex: number,
+    update: Partial<import("@hyperframes/core/gsap-parser").ArcPathSegment>,
+  ) => void;
   onAddKeyframe?: (
     animationId: string,
     percentage: number,
@@ -184,8 +197,8 @@ function fontSourceRank(source: FontSource): number {
 /* ------------------------------------------------------------------ */
 
 export const FIELD =
-  "min-w-0 rounded-xl border border-neutral-800 bg-neutral-900/95 px-3 py-2 text-neutral-100 shadow-[inset_0_1px_0_rgba(255,255,255,0.03)] transition-colors focus-within:border-neutral-600";
-export const LABEL = "text-[11px] font-medium uppercase tracking-[0.18em] text-neutral-500";
+  "min-w-0 rounded-md bg-panel-input px-3 py-[7px] text-panel-text-1 transition-colors focus-within:ring-1 focus-within:ring-panel-accent/30";
+export const LABEL = "text-[11px] font-medium text-panel-text-3";
 export const RESPONSIVE_GRID = "grid grid-cols-[repeat(auto-fit,minmax(118px,1fr))] gap-3";
 export const EMPTY_STYLES: Record<string, string> = {};
 
diff --git a/packages/studio/src/components/editor/propertyPanelMediaSection.tsx b/packages/studio/src/components/editor/propertyPanelMediaSection.tsx
index 33269298d..eeff73077 100644
--- a/packages/studio/src/components/editor/propertyPanelMediaSection.tsx
+++ b/packages/studio/src/components/editor/propertyPanelMediaSection.tsx
@@ -76,7 +76,7 @@ export function MediaSection({
         {srcAttr && (
           <div className="min-w-0">
             <div className="flex items-center justify-between gap-2">
-              <div className="text-[10px] uppercase tracking-[0.12em] text-neutral-500">Source</div>
+              <div className="text-[11px] font-medium text-neutral-500">Source</div>
               <button
                 type="button"
                 onClick={() => {
diff --git a/packages/studio/src/components/editor/propertyPanelPrimitives.tsx b/packages/studio/src/components/editor/propertyPanelPrimitives.tsx
index 32e0ff0cc..c12173585 100644
--- a/packages/studio/src/components/editor/propertyPanelPrimitives.tsx
+++ b/packages/studio/src/components/editor/propertyPanelPrimitives.tsx
@@ -257,9 +257,9 @@ export function SliderControl({
         onMouseUp={() => commitDraft(draft)}
         onTouchEnd={() => commitDraft(draft)}
         onBlur={() => commitDraft(draft)}
-        className="h-2 min-w-0 w-full cursor-pointer appearance-none rounded-full bg-neutral-800 accent-[#3ce6ac] disabled:cursor-not-allowed"
+        className="h-4 min-w-0 w-full cursor-pointer appearance-none bg-transparent disabled:cursor-not-allowed disabled:opacity-50 [&::-webkit-slider-runnable-track]:h-[2px] [&::-webkit-slider-runnable-track]:rounded-full [&::-webkit-slider-runnable-track]:bg-panel-border [&::-webkit-slider-thumb]:appearance-none [&::-webkit-slider-thumb]:w-[10px] [&::-webkit-slider-thumb]:h-[10px] [&::-webkit-slider-thumb]:rounded-full [&::-webkit-slider-thumb]:bg-white [&::-webkit-slider-thumb]:-mt-1 [&::-webkit-slider-thumb]:shadow-[0_0_0_2px_#0C0C0E,0_1px_3px_rgba(0,0,0,0.5)] [&::-webkit-slider-thumb]:cursor-grab [&::-webkit-slider-thumb:active]:cursor-grabbing"
       />
-      <div className="min-w-[52px] rounded-xl border border-neutral-800 bg-neutral-900 px-2 py-2 text-right text-[11px] font-medium text-neutral-100 shadow-[inset_0_1px_0_rgba(255,255,255,0.03)]">
+      <div className="min-w-[44px] rounded-md bg-panel-input px-2 py-1.5 text-right text-[11px] font-medium text-panel-text-1 tabular-nums">
         {formatDisplayValue?.(draft) ?? displayValue}
       </div>
     </div>
@@ -279,7 +279,7 @@ export function SegmentedControl({
 }) {
   return (
     <div
-      className="grid min-w-0 gap-1 rounded-xl bg-neutral-900 p-1 shadow-[inset_0_1px_0_rgba(255,255,255,0.03)]"
+      className="grid min-w-0 gap-[2px] rounded-md bg-panel-input p-[2px]"
       style={{ gridTemplateColumns: `repeat(${options.length}, minmax(0, 1fr))` }}
     >
       {options.map((option) => (
@@ -288,10 +288,10 @@ export function SegmentedControl({
           type="button"
           disabled={disabled}
           onClick={() => onChange(option.value)}
-          className={`min-w-0 truncate rounded-lg px-2 py-1.5 text-[11px] font-medium transition-colors disabled:cursor-not-allowed ${
+          className={`min-w-0 truncate rounded px-2 py-[5px] text-[11px] font-medium transition-colors disabled:cursor-not-allowed ${
             option.value === value
-              ? "bg-neutral-800 text-white shadow-[0_1px_3px_rgba(0,0,0,0.28)]"
-              : "text-neutral-500 hover:text-neutral-200"
+              ? "bg-panel-hover text-white"
+              : "text-panel-text-4 hover:text-panel-text-2"
           }`}
         >
           {option.label}
@@ -336,7 +336,7 @@ export function SelectField({
 
 export function Section({
   title,
-  icon,
+  icon: _icon,
   children,
   accessory,
   defaultCollapsed = false,
@@ -350,32 +350,45 @@ export function Section({
   const [collapsed, setCollapsed] = useState(defaultCollapsed);
 
   return (
-    <section className="min-w-0 border-t border-neutral-800/80">
+    <section className="min-w-0 border-t border-panel-border">
       <button
         type="button"
         onClick={() => setCollapsed((v) => !v)}
-        className="flex w-full items-center justify-between gap-2 px-4 py-3"
+        className="flex w-full items-center justify-between gap-2 px-4 py-2.5"
       >
-        <div className="flex min-w-0 items-center gap-2.5">
-          <span className="flex-shrink-0 text-neutral-500">{icon}</span>
-          <h3 className="text-[11px] font-semibold uppercase tracking-[0.12em] text-neutral-300">
-            {title}
-          </h3>
-        </div>
+        <h3 className="text-[12px] font-semibold text-panel-text-1">{title}</h3>
         <div className="flex items-center gap-2">
           {accessory}
-          <svg
-            width="10"
-            height="10"
-            viewBox="0 0 10 10"
-            fill="currentColor"
-            className={`flex-shrink-0 text-neutral-500 transition-transform ${collapsed ? "-rotate-90" : ""}`}
-          >
-            <path d="M2 3l3 4 3-4z" />
-          </svg>
+          {collapsed && (
+            <svg
+              width="12"
+              height="12"
+              viewBox="0 0 12 12"
+              fill="none"
+              className="flex-shrink-0 text-panel-text-5"
+            >
+              <path
+                d="M6 2.5v7M2.5 6h7"
+                stroke="currentColor"
+                strokeWidth="1.2"
+                strokeLinecap="round"
+              />
+            </svg>
+          )}
+          {!collapsed && (
+            <svg
+              width="10"
+              height="10"
+              viewBox="0 0 10 10"
+              fill="currentColor"
+              className="flex-shrink-0 text-panel-text-5"
+            >
+              <path d="M2 3l3 4 3-4z" />
+            </svg>
+          )}
         </div>
       </button>
-      {!collapsed && <div className="px-4 pb-4">{children}</div>}
+      {!collapsed && <div className="px-4 pb-3">{children}</div>}
     </section>
   );
 }
diff --git a/packages/studio/src/components/editor/propertyPanelSections.tsx b/packages/studio/src/components/editor/propertyPanelSections.tsx
index cef2c9602..2eaaa1792 100644
--- a/packages/studio/src/components/editor/propertyPanelSections.tsx
+++ b/packages/studio/src/components/editor/propertyPanelSections.tsx
@@ -262,15 +262,13 @@ function TextFieldEditor({
   onRemoveTextField: (fieldKey: string) => void;
 }) {
   return (
-    <div className="space-y-4 rounded-xl border border-neutral-800 bg-neutral-900/60 p-3">
+    <div className="space-y-3">
       <div className={showRemove ? "flex min-w-0 items-center justify-between gap-2" : "min-w-0"}>
         <div className="min-w-0">
           <div className="truncate text-[11px] font-medium text-neutral-100">
             {formatTextFieldPreview(field.value) || "Text"}
           </div>
-          <div className="text-[10px] uppercase tracking-[0.12em] text-neutral-500">
-            {field.tagName}
-          </div>
+          <div className="text-[10px] text-neutral-500">{field.tagName}</div>
         </div>
         {showRemove && (
           <button
@@ -368,7 +366,7 @@ export function TextSection({
 
   if (textFields.length === 1) {
     return (
-      <Section title="Text" icon={<Type size={15} />}>
+      <Section title="Text" icon={<Type size={15} />} defaultCollapsed>
         <TextFieldEditor
           field={activeField}
           styles={styles}
@@ -426,7 +424,7 @@ export function TextSection({
                         {formatTextFieldPreview(field.value) || `Text ${index + 1}`}
                       </span>
                     </div>
-                    <span className="flex-shrink-0 rounded-md border border-neutral-700 bg-neutral-950 px-1.5 py-0.5 text-[10px] uppercase tracking-[0.12em] text-neutral-500">
+                    <span className="flex-shrink-0 rounded-md border border-neutral-700 bg-neutral-950 px-1.5 py-0.5 text-[10px] text-neutral-500">
                       {field.tagName}
                     </span>
                   </div>
diff --git a/packages/studio/src/components/editor/useDomEditOverlayRects.ts b/packages/studio/src/components/editor/useDomEditOverlayRects.ts
index 1bda0197d..0c06b84c0 100644
--- a/packages/studio/src/components/editor/useDomEditOverlayRects.ts
+++ b/packages/studio/src/components/editor/useDomEditOverlayRects.ts
@@ -17,6 +17,14 @@ import {
   toOverlayRect,
 } from "./domEditOverlayGeometry";
 
+function childRectsEqual(a: OverlayRect[], b: OverlayRect[]): boolean {
+  if (a.length !== b.length) return false;
+  for (let i = 0; i < a.length; i++) {
+    if (!rectsEqual(a[i]!, b[i]!)) return false;
+  }
+  return true;
+}
+
 interface UseDomEditOverlayRectsOptions {
   iframeRef: RefObject<HTMLIFrameElement | null>;
   overlayRef: RefObject<HTMLDivElement | null>;
@@ -37,6 +45,7 @@ interface UseDomEditOverlayRectsResult {
   groupOverlayItems: GroupOverlayItem[];
   groupOverlayItemsRef: RefObject<GroupOverlayItem[]>;
   setGroupOverlayItems: (next: GroupOverlayItem[]) => void;
+  childRects: OverlayRect[];
 }
 
 export function useDomEditOverlayRects({
@@ -51,6 +60,7 @@ export function useDomEditOverlayRects({
   const [overlayRect, setOverlayRectState] = useState<OverlayRect | null>(null);
   const [hoverRect, setHoverRectState] = useState<OverlayRect | null>(null);
   const [groupOverlayItems, setGroupOverlayItemsState] = useState<GroupOverlayItem[]>([]);
+  const [childRects, setChildRectsState] = useState<OverlayRect[]>([]);
 
   const overlayRectRef = useRef<OverlayRect | null>(null);
   const hoverRectRef = useRef<OverlayRect | null>(null);
@@ -58,6 +68,7 @@ export function useDomEditOverlayRects({
   const resolvedElementRef = useRef<{ key: string; element: HTMLElement } | null>(null);
   const resolvedHoverElementRef = useRef<{ key: string; element: HTMLElement } | null>(null);
   const resolvedGroupElementRef = useRef<Map<string, HTMLElement>>(new Map());
+  const childRectsRef = useRef<OverlayRect[]>([]);
 
   const setOverlayRect = (next: OverlayRect | null) => {
     if (rectsEqual(overlayRectRef.current, next)) return;
@@ -133,12 +144,37 @@ export function useDomEditOverlayRects({
         );
         if (el && isElementVisibleForOverlay(el)) {
           setOverlayRect(toOverlayRect(overlayEl, iframe, el));
+          const descendants = el.querySelectorAll("*");
+          if (descendants.length > 0 && descendants.length <= 60) {
+            const nextChildRects: OverlayRect[] = [];
+            for (let i = 0; i < descendants.length; i++) {
+              const child = descendants[i] as HTMLElement;
+              if (!child.getBoundingClientRect) continue;
+              const r = toOverlayRect(overlayEl, iframe, child);
+              if (r && r.width > 2 && r.height > 2) nextChildRects.push(r);
+            }
+            if (!childRectsEqual(childRectsRef.current, nextChildRects)) {
+              childRectsRef.current = nextChildRects;
+              setChildRectsState(nextChildRects);
+            }
+          } else if (childRectsRef.current.length > 0) {
+            childRectsRef.current = [];
+            setChildRectsState([]);
+          }
         } else {
           setOverlayRect(null);
+          if (childRectsRef.current.length > 0) {
+            childRectsRef.current = [];
+            setChildRectsState([]);
+          }
         }
       } else {
         resolvedElementRef.current = null;
         setOverlayRect(null);
+        if (childRectsRef.current.length > 0) {
+          childRectsRef.current = [];
+          setChildRectsState([]);
+        }
       }
 
       const group = groupSelectionsRef.current;
@@ -203,5 +239,6 @@ export function useDomEditOverlayRects({
     groupOverlayItems,
     groupOverlayItemsRef,
     setGroupOverlayItems,
+    childRects,
   };
 }
diff --git a/packages/studio/src/components/renders/RenderQueue.tsx b/packages/studio/src/components/renders/RenderQueue.tsx
index 1e00b9326..f3362843e 100644
--- a/packages/studio/src/components/renders/RenderQueue.tsx
+++ b/packages/studio/src/components/renders/RenderQueue.tsx
@@ -154,22 +154,22 @@ function FormatInfoTooltip({ format }: { format: "mp4" | "webm" | "mov" }) {
         strokeWidth="2"
         strokeLinecap="round"
         strokeLinejoin="round"
-        className="text-neutral-600 hover:text-neutral-400 transition-colors cursor-help"
+        className="text-panel-text-5 hover:text-panel-text-3 transition-colors cursor-help"
       >
         <circle cx="12" cy="12" r="10" />
         <path d="M9.09 9a3 3 0 015.83 1c0 2-3 3-3 3" />
         <line x1="12" y1="17" x2="12.01" y2="17" />
       </svg>
       {open && (
-        <div className="absolute top-full right-0 mt-1.5 w-52 p-2 rounded bg-neutral-900 border border-neutral-700 shadow-lg z-50">
-          <p className="text-[10px] font-semibold text-neutral-200 mb-0.5">{info.label}</p>
-          <p className="text-[9px] text-neutral-400 leading-tight">{info.desc}</p>
+        <div className="absolute top-full right-0 mt-1.5 w-52 p-2 rounded bg-panel-input border border-neutral-700 shadow-lg z-50">
+          <p className="text-[10px] font-semibold text-panel-text-1 mb-0.5">{info.label}</p>
+          <p className="text-[9px] text-panel-text-3 leading-tight">{info.desc}</p>
           <div className="mt-1.5 pt-1.5 border-t border-neutral-800">
             {(["mp4", "mov", "webm"] as const)
               .filter((f) => f !== format)
               .map((f) => (
-                <p key={f} className="text-[9px] text-neutral-500 leading-relaxed">
-                  <span className="text-neutral-400 font-medium">{FORMAT_INFO[f].label}</span>
+                <p key={f} className="text-[9px] text-panel-text-4 leading-relaxed">
+                  <span className="text-panel-text-3 font-medium">{FORMAT_INFO[f].label}</span>
                   {" — "}
                   {FORMAT_INFO[f].desc}
                 </p>
@@ -209,80 +209,97 @@ function FormatExportButton({
   // MOV (ProRes) is a fixed-quality codec — quality selector has no effect.
   const showQuality = format !== "mov";
 
+  const selectCls =
+    "h-7 w-full px-2 text-[11px] bg-panel-input rounded-md text-panel-text-1 outline-none cursor-pointer disabled:opacity-50 hover:bg-panel-hover transition-colors";
+
   return (
-    <div className="flex items-center gap-1 flex-wrap justify-end">
-      <FormatInfoTooltip format={format} />
-      {/* Resolution must remain the leftmost <select> in this row — it
-          carries `rounded-l` for the joined-button look. If you ever hide it
-          (feature-flag, etc.), move `rounded-l` to whichever element ends up
-          leftmost. */}
-      <select
-        value={resolution}
-        onChange={(e) => setResolution(e.target.value as ResolutionPreset | "auto")}
-        disabled={isRendering}
-        className="h-5 px-1 text-[10px] rounded-l bg-neutral-800 border border-neutral-700 text-neutral-300 outline-none disabled:opacity-50"
-      >
-        {SCALE_OPTION_ORDER.map((value) => (
-          <option key={value} value={value} disabled={!scaleApplies(value, compositionDimensions)}>
-            {scaleOptionLabel(value, compositionDimensions)}
-          </option>
-        ))}
-      </select>
-      {showQuality && (
-        <select
-          value={quality}
-          onChange={(e) => {
-            const v = e.target.value as "draft" | "standard" | "high";
-            setQuality(v);
-            persistRenderSettings(format, v, fps);
-          }}
-          disabled={isRendering}
-          title={QUALITY_OPTIONS.find((q) => q.value === quality)?.title}
-          className="h-5 px-1 text-[10px] bg-neutral-800 border border-neutral-700 text-neutral-300 outline-none disabled:opacity-50"
-        >
-          {QUALITY_OPTIONS.map((q) => (
-            <option key={q.value} value={q.value} title={q.title}>
-              {q.label}
-            </option>
-          ))}
-        </select>
-      )}
-      <select
-        value={fps}
-        onChange={(e) => {
-          const v = Number(e.target.value) as 24 | 30 | 60;
-          setFps(v);
-          persistRenderSettings(format, quality, v);
-        }}
-        disabled={isRendering}
-        title="Frames per second"
-        className="h-5 px-1 text-[10px] bg-neutral-800 border border-neutral-700 text-neutral-300 outline-none disabled:opacity-50"
-      >
-        <option value={24}>24fps</option>
-        <option value={30}>30fps</option>
-        <option value={60}>60fps</option>
-      </select>
-      <select
-        value={format}
-        onChange={(e) => {
-          const v = e.target.value as "mp4" | "webm" | "mov";
-          setFormat(v);
-          persistRenderSettings(v, quality, fps);
-        }}
-        disabled={isRendering}
-        className="h-5 px-1 text-[10px] bg-neutral-800 border border-neutral-700 text-neutral-300 outline-none disabled:opacity-50"
-      >
-        <option value="mp4">MP4</option>
-        <option value="mov">MOV</option>
-        <option value="webm">WebM</option>
-      </select>
+    <div className="flex flex-col gap-3">
+      <div className="grid grid-cols-2 gap-2">
+        <div className="flex flex-col gap-1">
+          <div className="flex items-center gap-1">
+            <span className="text-[10px] text-panel-text-4">Format</span>
+            <FormatInfoTooltip format={format} />
+          </div>
+          <select
+            value={format}
+            onChange={(e) => {
+              const v = e.target.value as "mp4" | "webm" | "mov";
+              setFormat(v);
+              persistRenderSettings(v, quality, fps);
+            }}
+            disabled={isRendering}
+            className={selectCls}
+          >
+            <option value="mp4">MP4</option>
+            <option value="mov">MOV (ProRes)</option>
+            <option value="webm">WebM</option>
+          </select>
+        </div>
+        <div className="flex flex-col gap-1">
+          <span className="text-[10px] text-panel-text-4">Resolution</span>
+          <select
+            value={resolution}
+            onChange={(e) => setResolution(e.target.value as ResolutionPreset | "auto")}
+            disabled={isRendering}
+            className={selectCls}
+          >
+            {SCALE_OPTION_ORDER.map((value) => (
+              <option
+                key={value}
+                value={value}
+                disabled={!scaleApplies(value, compositionDimensions)}
+              >
+                {scaleOptionLabel(value, compositionDimensions)}
+              </option>
+            ))}
+          </select>
+        </div>
+        <div className="flex flex-col gap-1">
+          <span className="text-[10px] text-panel-text-4">Frame rate</span>
+          <select
+            value={fps}
+            onChange={(e) => {
+              const v = Number(e.target.value) as 24 | 30 | 60;
+              setFps(v);
+              persistRenderSettings(format, quality, v);
+            }}
+            disabled={isRendering}
+            className={selectCls}
+          >
+            <option value={24}>24 fps</option>
+            <option value={30}>30 fps</option>
+            <option value={60}>60 fps</option>
+          </select>
+        </div>
+        {showQuality && (
+          <div className="flex flex-col gap-1">
+            <span className="text-[10px] text-panel-text-4">Quality</span>
+            <select
+              value={quality}
+              onChange={(e) => {
+                const v = e.target.value as "draft" | "standard" | "high";
+                setQuality(v);
+                persistRenderSettings(format, v, fps);
+              }}
+              disabled={isRendering}
+              className={selectCls}
+            >
+              {QUALITY_OPTIONS.map((q) => (
+                <option key={q.value} value={q.value}>
+                  {q.label}
+                </option>
+              ))}
+            </select>
+          </div>
+        )}
+      </div>
       <button
         onClick={() => {
           trackStudioEvent("render_start", { format, quality, resolution, fps });
           void onStartRender(format, quality, resolution, fps);
         }}
         disabled={isRendering}
-        className="flex items-center gap-1 px-2 py-0.5 text-[10px] font-semibold rounded-r bg-studio-accent text-[#09090B] hover:brightness-110 transition-colors disabled:opacity-50"
+        className="w-full flex items-center justify-center h-8 text-[11px] font-semibold rounded-md bg-panel-accent text-[#09090B] hover:brightness-110 transition-colors disabled:opacity-50"
       >
         {isRendering ? "Rendering..." : "Export"}
       </button>
@@ -313,23 +330,12 @@ export const RenderQueue = memo(function RenderQueue({
 
   return (
     <div className="flex flex-col h-full">
-      {/* Header — no title, already shown in header button */}
-      <div className="flex items-center justify-end flex-wrap gap-y-1.5 px-3 py-2 border-b border-neutral-800/50 flex-shrink-0">
-        <div className="flex items-center gap-1.5">
-          {completedCount > 0 && (
-            <button
-              onClick={onClearCompleted}
-              className="text-[10px] text-neutral-600 hover:text-neutral-400 transition-colors"
-            >
-              Clear
-            </button>
-          )}
-          <FormatExportButton
-            onStartRender={onStartRender}
-            isRendering={isRendering}
-            compositionDimensions={compositionDimensions}
-          />
-        </div>
+      <div className="px-3 py-3 border-b border-panel-border flex-shrink-0">
+        <FormatExportButton
+          onStartRender={onStartRender}
+          isRendering={isRendering}
+          compositionDimensions={compositionDimensions}
+        />
       </div>
 
       {/* Job list */}
@@ -343,7 +349,7 @@ export const RenderQueue = memo(function RenderQueue({
               fill="none"
               stroke="currentColor"
               strokeWidth="1.5"
-              className="text-neutral-700"
+              className="text-panel-text-5"
             >
               <rect
                 x="2"
@@ -361,17 +367,32 @@ export const RenderQueue = memo(function RenderQueue({
                 strokeLinejoin="round"
               />
             </svg>
-            <p className="text-[10px] text-neutral-600 text-center">No renders yet</p>
+            <p className="text-[10px] text-panel-text-5 text-center">No renders yet</p>
           </div>
         ) : (
-          jobs.map((job) => (
-            <RenderQueueItem
-              key={job.id}
-              job={job}
-              projectId={projectId}
-              onDelete={() => onDelete(job.id)}
-            />
-          ))
+          <div>
+            {completedCount > 0 && (
+              <div className="flex items-center justify-between px-3 py-1.5 border-b border-panel-border">
+                <span className="text-[10px] text-panel-text-4">
+                  {jobs.length} render{jobs.length === 1 ? "" : "s"}
+                </span>
+                <button
+                  onClick={onClearCompleted}
+                  className="text-[10px] text-panel-text-4 hover:text-panel-text-2 transition-colors"
+                >
+                  Clear
+                </button>
+              </div>
+            )}
+            {jobs.map((job) => (
+              <RenderQueueItem
+                key={job.id}
+                job={job}
+                projectId={projectId}
+                onDelete={() => onDelete(job.id)}
+              />
+            ))}
+          </div>
         )}
       </div>
     </div>
diff --git a/packages/studio/src/components/renders/RenderQueueItem.tsx b/packages/studio/src/components/renders/RenderQueueItem.tsx
index 09a78b8a1..1005328f2 100644
--- a/packages/studio/src/components/renders/RenderQueueItem.tsx
+++ b/packages/studio/src/components/renders/RenderQueueItem.tsx
@@ -57,15 +57,15 @@ export const RenderQueueItem = memo(function RenderQueueItem({
       onPointerLeave={() => setHovered(false)}
       onClick={isComplete ? handleOpen : undefined}
       className={[
-        "px-3 py-2.5 border-b border-neutral-800/30 last:border-0 transition-colors duration-150",
-        isComplete ? "cursor-pointer hover:bg-neutral-800/30" : "",
+        "px-3 py-2.5 border-b border-panel-border last:border-0 transition-colors duration-150",
+        isComplete ? "cursor-pointer hover:bg-panel-hover/30" : "",
       ]
         .filter(Boolean)
         .join(" ")}
     >
       <div className="flex items-center gap-2.5">
         {/* Thumbnail — static frame; swaps to live video on hover */}
-        <div className="w-20 h-[45px] rounded overflow-hidden bg-neutral-900 flex-shrink-0 relative">
+        <div className="w-20 h-[45px] rounded-md overflow-hidden bg-panel-input flex-shrink-0 relative">
           {isComplete && (
             <>
               {/* Live video — visible on hover */}
@@ -90,7 +90,7 @@ export const RenderQueueItem = memo(function RenderQueueItem({
           )}
           {job.status === "rendering" && (
             <div className="w-full h-full flex items-center justify-center">
-              <div className="w-2 h-2 rounded-full bg-studio-accent animate-pulse" />
+              <div className="w-2 h-2 rounded-full bg-panel-accent animate-pulse" />
             </div>
           )}
           {job.status === "failed" && (
@@ -108,11 +108,11 @@ export const RenderQueueItem = memo(function RenderQueueItem({
         {/* Info */}
         <div className="flex-1 min-w-0">
           <div className="flex items-center gap-1.5">
-            <span className="text-[11px] font-medium text-neutral-300 truncate">
+            <span className="text-[11px] font-medium text-panel-text-2 truncate">
               {job.filename}
             </span>
             {job.durationMs && (
-              <span className="text-[9px] text-neutral-600 flex-shrink-0">
+              <span className="text-[9px] text-panel-text-5 flex-shrink-0">
                 {formatDuration(job.durationMs)}
               </span>
             )}
@@ -121,12 +121,12 @@ export const RenderQueueItem = memo(function RenderQueueItem({
           {job.status === "rendering" && (
             <div className="mt-1">
               <div className="flex items-center justify-between mb-0.5">
-                <span className="text-[9px] text-neutral-500">{job.stage || "Rendering"}</span>
-                <span className="text-[9px] font-mono text-studio-accent">{job.progress}%</span>
+                <span className="text-[9px] text-panel-text-4">{job.stage || "Rendering"}</span>
+                <span className="text-[9px] font-mono text-panel-accent">{job.progress}%</span>
               </div>
-              <div className="w-full h-1 bg-neutral-800 rounded-full overflow-hidden">
+              <div className="w-full h-1 bg-panel-border rounded-full overflow-hidden">
                 <div
-                  className="h-full bg-studio-accent rounded-full transition-all duration-300"
+                  className="h-full bg-panel-accent rounded-full transition-all duration-300"
                   style={{ width: `${job.progress}%` }}
                 />
               </div>
@@ -138,7 +138,7 @@ export const RenderQueueItem = memo(function RenderQueueItem({
           )}
 
           {job.status !== "rendering" && (
-            <span className="text-[9px] text-neutral-600">{formatTimeAgo(job.createdAt)}</span>
+            <span className="text-[9px] text-panel-text-5">{formatTimeAgo(job.createdAt)}</span>
           )}
         </div>
 
@@ -148,7 +148,7 @@ export const RenderQueueItem = memo(function RenderQueueItem({
             {isComplete && (
               <button
                 onClick={handleDownload}
-                className="p-1 rounded text-neutral-500 hover:text-green-400 transition-colors"
+                className="p-1 rounded text-panel-text-4 hover:text-panel-accent transition-colors"
                 title="Download"
               >
                 <svg
@@ -172,7 +172,7 @@ export const RenderQueueItem = memo(function RenderQueueItem({
                 e.stopPropagation();
                 onDelete();
               }}
-              className="p-1 rounded text-neutral-500 hover:text-red-400 transition-colors"
+              className="p-1 rounded text-panel-text-4 hover:text-red-400 transition-colors"
               title="Remove"
             >
               <svg
diff --git a/packages/studio/src/contexts/DomEditContext.tsx b/packages/studio/src/contexts/DomEditContext.tsx
index feed5118f..985cbc57b 100644
--- a/packages/studio/src/contexts/DomEditContext.tsx
+++ b/packages/studio/src/contexts/DomEditContext.tsx
@@ -72,6 +72,8 @@ export function DomEditProvider({
     handleGsapRemoveAllKeyframes,
     handleResetSelectedElementKeyframes,
     commitAnimatedProperty,
+    handleSetArcPath,
+    handleUpdateArcSegment,
     invalidateGsapCache,
     previewIframeRef,
   },
@@ -141,6 +143,8 @@ export function DomEditProvider({
       handleGsapRemoveAllKeyframes,
       handleResetSelectedElementKeyframes,
       commitAnimatedProperty,
+      handleSetArcPath,
+      handleUpdateArcSegment,
       invalidateGsapCache,
       previewIframeRef,
     }),
@@ -204,6 +208,8 @@ export function DomEditProvider({
       handleGsapRemoveAllKeyframes,
       handleResetSelectedElementKeyframes,
       commitAnimatedProperty,
+      handleSetArcPath,
+      handleUpdateArcSegment,
       invalidateGsapCache,
       previewIframeRef,
     ],
diff --git a/packages/studio/src/hooks/gsapKeyframeCommit.ts b/packages/studio/src/hooks/gsapKeyframeCommit.ts
new file mode 100644
index 000000000..18c294a31
--- /dev/null
+++ b/packages/studio/src/hooks/gsapKeyframeCommit.ts
@@ -0,0 +1,92 @@
+import type { GsapAnimation } from "@hyperframes/core/gsap-parser";
+import type { DomEditSelection } from "../components/editor/domEditingTypes";
+import { absoluteToPercentageForAnimation, findTweenAtTime } from "../utils/globalTimeCompiler";
+
+const PROPERTY_DEFAULTS: Record<string, number> = {
+  opacity: 1,
+  x: 0,
+  y: 0,
+  scale: 1,
+  scaleX: 1,
+  scaleY: 1,
+  rotation: 0,
+  width: 100,
+  height: 100,
+};
+
+type CommitFn = (
+  selection: DomEditSelection,
+  mutation: Record<string, unknown>,
+  options: {
+    label: string;
+    coalesceKey?: string;
+    softReload?: boolean;
+    skipReload?: boolean;
+  },
+) => Promise<void>;
+
+export async function commitKeyframeAtTimeImpl(
+  selection: DomEditSelection,
+  absoluteTime: number,
+  animations: GsapAnimation[],
+  properties: Record<string, number | string>,
+  commitMutation: CommitFn,
+): Promise<void> {
+  const selector = selection.id ? `#${selection.id}` : selection.selector;
+  if (!selector) return;
+
+  const tween = findTweenAtTime(absoluteTime, animations, selector);
+  if (tween) {
+    const pct = absoluteToPercentageForAnimation(absoluteTime, tween);
+    if (pct === null) return;
+
+    const hasExplicitKeyframes = !!tween.keyframes && tween.keyframes.keyframes.length > 0;
+    if (!hasExplicitKeyframes) {
+      await commitMutation(
+        selection,
+        { type: "convert-to-keyframes", animationId: tween.id },
+        { label: "Convert to keyframes", skipReload: true },
+      );
+    }
+
+    const backfillDefaults: Record<string, number | string> = {};
+    for (const key of Object.keys(properties)) {
+      backfillDefaults[key] = PROPERTY_DEFAULTS[key] ?? 0;
+    }
+
+    await commitMutation(
+      selection,
+      {
+        type: "add-keyframe",
+        animationId: tween.id,
+        percentage: pct,
+        properties,
+        backfillDefaults,
+      },
+      {
+        label: `Add keyframe at ${Math.round(absoluteTime * 100) / 100}s`,
+        coalesceKey: `keyframe:${tween.id}:${pct}`,
+        softReload: true,
+      },
+    );
+  } else {
+    const defaultDuration = 0.5;
+    await commitMutation(
+      selection,
+      {
+        type: "add-with-keyframes" as const,
+        targetSelector: selector,
+        position: absoluteTime,
+        duration: defaultDuration,
+        keyframes: [
+          { percentage: 0, properties },
+          { percentage: 100, properties },
+        ],
+      },
+      {
+        label: `New animation at ${Math.round(absoluteTime * 100) / 100}s`,
+        softReload: true,
+      },
+    );
+  }
+}
diff --git a/packages/studio/src/hooks/gsapRuntimeBridge.ts b/packages/studio/src/hooks/gsapRuntimeBridge.ts
index 58b604c00..6e641dfc8 100644
--- a/packages/studio/src/hooks/gsapRuntimeBridge.ts
+++ b/packages/studio/src/hooks/gsapRuntimeBridge.ts
@@ -13,6 +13,11 @@ import type { DomEditSelection } from "../components/editor/domEditingTypes";
 import { clearStudioPathOffset } from "../components/editor/manualEdits";
 import { usePlayerStore } from "../player/store/playerStore";
 import { readRuntimeKeyframes, scanAllRuntimeKeyframes } from "./gsapRuntimeKeyframes";
+import {
+  absoluteToPercentage,
+  resolveTweenStart,
+  resolveTweenDuration,
+} from "../utils/globalTimeCompiler";
 
 // ── Runtime reads ──────────────────────────────────────────────────────────
 
@@ -91,10 +96,17 @@ function selectorForSelection(selection: DomEditSelection): string | null {
 
 // ── Percentage computation ─────────────────────────────────────────────────
 
-function computeCurrentPercentage(selection: DomEditSelection): number {
+function computeCurrentPercentage(selection: DomEditSelection, animation?: GsapAnimation): number {
+  const currentTime = usePlayerStore.getState().currentTime;
+  if (animation) {
+    const start = resolveTweenStart(animation);
+    const duration = resolveTweenDuration(animation);
+    if (start !== null) {
+      return absoluteToPercentage(currentTime, start, duration);
+    }
+  }
   const elStart = Number.parseFloat(selection.dataAttributes?.start ?? "0") || 0;
   const elDuration = Number.parseFloat(selection.dataAttributes?.duration ?? "1") || 1;
-  const currentTime = usePlayerStore.getState().currentTime;
   return elDuration > 0
     ? Math.max(0, Math.min(100, Math.round(((currentTime - elStart) / elDuration) * 1000) / 10))
     : 0;
@@ -275,7 +287,7 @@ async function commitKeyframedPosition(
   callbacks: GsapDragCommitCallbacks,
   beforeReload: () => void,
 ): Promise<void> {
-  const pct = computeCurrentPercentage(selection);
+  const pct = computeCurrentPercentage(selection, anim);
 
   await callbacks.commitMutation(
     selection,
@@ -308,7 +320,7 @@ async function commitFlatViaKeyframes(
     { label: "Convert to keyframes for drag", skipReload: true },
   );
 
-  const pct = computeCurrentPercentage(selection);
+  const pct = computeCurrentPercentage(selection, anim);
 
   await callbacks.commitMutation(
     selection,
@@ -461,7 +473,7 @@ export async function tryGsapResizeIntercept(
   }
   if (!anim) return false;
 
-  const pct = computeCurrentPercentage(selection);
+  const pct = computeCurrentPercentage(selection, anim);
 
   if (anim.hasUnresolvedKeyframes || anim.hasUnresolvedSelector) {
     const newId = await materializeIfDynamic(anim, iframe, commitMutation, selection);
@@ -545,7 +557,7 @@ export async function tryGsapRotationIntercept(
     }
   }
 
-  const pct = computeCurrentPercentage(selection);
+  const pct = computeCurrentPercentage(selection, anim);
   const newRotation = Math.round(gsapRotation + angle);
 
   if (anim.hasUnresolvedKeyframes || anim.hasUnresolvedSelector) {
diff --git a/packages/studio/src/hooks/gsapRuntimeKeyframes.ts b/packages/studio/src/hooks/gsapRuntimeKeyframes.ts
index 4aa976f59..1029fd6df 100644
--- a/packages/studio/src/hooks/gsapRuntimeKeyframes.ts
+++ b/packages/studio/src/hooks/gsapRuntimeKeyframes.ts
@@ -126,45 +126,96 @@ export function scanAllRuntimeKeyframes(iframe: HTMLIFrameElement | null): Map<
 
   for (const timeline of Object.values(timelines)) {
     if (!timeline?.getChildren) continue;
+    const tlDuration = typeof timeline.duration === "function" ? timeline.duration() : 0;
+
     for (const tween of timeline.getChildren(true)) {
       if (!tween.targets || !tween.vars) continue;
       const vars = tween.vars;
-      if (!vars.keyframes || typeof vars.keyframes !== "object") continue;
 
-      const kfObj = vars.keyframes as Record<string, unknown>;
-      const keyframes: Array<{ percentage: number; properties: Record<string, number | string> }> =
-        [];
-      let easeEach: string | undefined;
+      if (vars.keyframes && typeof vars.keyframes === "object") {
+        const kfObj = vars.keyframes as Record<string, unknown>;
+        const keyframes: Array<{
+          percentage: number;
+          properties: Record<string, number | string>;
+        }> = [];
+        let easeEach: string | undefined;
+
+        for (const [key, val] of Object.entries(kfObj)) {
+          if (key === "easeEach") {
+            if (typeof val === "string") easeEach = val;
+            continue;
+          }
+          const pctMatch = key.match(/^(\d+(?:\.\d+)?)%$/);
+          if (!pctMatch || !val || typeof val !== "object") continue;
+          const percentage = parseFloat(pctMatch[1]);
+          const properties: Record<string, number | string> = {};
+          for (const [pk, pv] of Object.entries(val as Record<string, unknown>)) {
+            if (pk === "ease") continue;
+            if (typeof pv === "number") properties[pk] = Math.round(pv * 1000) / 1000;
+            else if (typeof pv === "string") properties[pk] = pv;
+          }
+          if (Object.keys(properties).length > 0) {
+            keyframes.push({ percentage, properties });
+          }
+        }
 
-      for (const [key, val] of Object.entries(kfObj)) {
-        if (key === "easeEach") {
-          if (typeof val === "string") easeEach = val;
+        if (keyframes.length > 0) {
+          keyframes.sort((a, b) => a.percentage - b.percentage);
+          for (const target of tween.targets()) {
+            const id = (target as HTMLElement).id;
+            if (id && !result.has(id)) {
+              result.set(id, { keyframes, easeEach });
+            }
+          }
           continue;
         }
-        const pctMatch = key.match(/^(\d+(?:\.\d+)?)%$/);
-        if (!pctMatch || !val || typeof val !== "object") continue;
-        const percentage = parseFloat(pctMatch[1]);
-        const properties: Record<string, number | string> = {};
-        for (const [pk, pv] of Object.entries(val as Record<string, unknown>)) {
-          if (pk === "ease") continue;
-          if (typeof pv === "number") properties[pk] = Math.round(pv * 1000) / 1000;
-          else if (typeof pv === "string") properties[pk] = pv;
-        }
-        if (Object.keys(properties).length > 0) {
-          keyframes.push({ percentage, properties });
-        }
       }
 
-      if (keyframes.length === 0) continue;
-      keyframes.sort((a, b) => a.percentage - b.percentage);
+      // Flat tweens: synthesize start + end keyframe entries
+      if (!tlDuration || tlDuration <= 0) continue;
+      const tweenStart = typeof tween.startTime === "function" ? tween.startTime() : undefined;
+      if (typeof tweenStart !== "number" || !Number.isFinite(tweenStart)) continue;
+      const tweenDur = typeof tween.duration === "function" ? tween.duration() : 0;
+
+      const startPct = Math.round((tweenStart / tlDuration) * 1000) / 10;
+      const endPct =
+        tweenDur > 0 ? Math.round(((tweenStart + tweenDur) / tlDuration) * 1000) / 10 : startPct;
+      const properties: Record<string, number | string> = {};
+      const skip = new Set([
+        "ease",
+        "duration",
+        "delay",
+        "stagger",
+        "motionPath",
+        "overwrite",
+        "immediateRender",
+        "onComplete",
+        "onUpdate",
+        "onStart",
+      ]);
+      for (const [k, v] of Object.entries(vars)) {
+        if (skip.has(k)) continue;
+        if (typeof v === "number") properties[k] = Math.round(v * 1000) / 1000;
+        else if (typeof v === "string") properties[k] = v;
+      }
+      if (Object.keys(properties).length === 0) continue;
 
       for (const target of tween.targets()) {
         const id = (target as HTMLElement).id;
-        if (id && !result.has(id)) {
-          result.set(id, { keyframes, easeEach });
+        if (!id) continue;
+        const existing = result.get(id);
+        const entries = existing ?? { keyframes: [] };
+        entries.keyframes.push({ percentage: startPct, properties });
+        if (endPct !== startPct) {
+          entries.keyframes.push({ percentage: endPct, properties });
         }
+        if (!existing) result.set(id, entries);
       }
     }
   }
+
+  for (const entry of result.values()) {
+    entry.keyframes.sort((a, b) => a.percentage - b.percentage);
+  }
   return result;
 }
diff --git a/packages/studio/src/hooks/gsapRuntimePreview.ts b/packages/studio/src/hooks/gsapRuntimePreview.ts
new file mode 100644
index 000000000..16afb98c3
--- /dev/null
+++ b/packages/studio/src/hooks/gsapRuntimePreview.ts
@@ -0,0 +1,19 @@
+export function previewKeyframeChange(
+  iframe: HTMLIFrameElement | null,
+  selector: string,
+  properties: Record<string, number | string>,
+): boolean {
+  if (!iframe?.contentWindow) return false;
+  try {
+    const gsap = (
+      iframe.contentWindow as unknown as {
+        gsap?: { set: (target: string, vars: Record<string, number | string>) => void };
+      }
+    ).gsap;
+    if (!gsap?.set) return false;
+    gsap.set(selector, properties);
+    return true;
+  } catch {
+    return false;
+  }
+}
diff --git a/packages/studio/src/hooks/useDomEditSession.ts b/packages/studio/src/hooks/useDomEditSession.ts
index cf788ec4f..02013491e 100644
--- a/packages/studio/src/hooks/useDomEditSession.ts
+++ b/packages/studio/src/hooks/useDomEditSession.ts
@@ -244,6 +244,7 @@ export function useDomEditSession({
     STUDIO_GSAP_PANEL_ENABLED ? (projectId ?? null) : null,
     gsapSourceFile,
     gsapCacheVersion,
+    previewIframeRef,
   );
 
   const {
@@ -274,6 +275,8 @@ export function useDomEditSession({
     removeKeyframe,
     convertToKeyframes,
     removeAllKeyframes,
+    setArcPath,
+    updateArcSegment,
   } = useGsapScriptCommits({
     projectIdRef,
     activeCompPath,
@@ -464,6 +467,22 @@ export function useDomEditSession({
     bumpGsapCache,
   });
 
+  const handleSetArcPath = useCallback(
+    (animId: string, config: Parameters<typeof setArcPath>[2]) => {
+      if (!domEditSelection) return;
+      setArcPath(domEditSelection, animId, config);
+    },
+    [domEditSelection, setArcPath],
+  );
+
+  const handleUpdateArcSegment = useCallback(
+    (animId: string, segmentIndex: number, update: Parameters<typeof updateArcSegment>[3]) => {
+      if (!domEditSelection) return;
+      updateArcSegment(domEditSelection, animId, segmentIndex, update);
+    },
+    [domEditSelection, updateArcSegment],
+  );
+
   // Sync selection from preview document on load / refresh
   // eslint-disable-next-line no-restricted-syntax
   useEffect(() => {
@@ -609,6 +628,8 @@ export function useDomEditSession({
     handleGsapRemoveAllKeyframes,
     handleResetSelectedElementKeyframes,
     commitAnimatedProperty,
+    handleSetArcPath,
+    handleUpdateArcSegment,
     invalidateGsapCache: bumpGsapCache,
     previewIframeRef,
   };
diff --git a/packages/studio/src/hooks/useGsapScriptCommits.ts b/packages/studio/src/hooks/useGsapScriptCommits.ts
index fbc8acd86..57d62c36e 100644
--- a/packages/studio/src/hooks/useGsapScriptCommits.ts
+++ b/packages/studio/src/hooks/useGsapScriptCommits.ts
@@ -1,10 +1,11 @@
 import { useCallback, useEffect, useRef } from "react";
-import type { ParsedGsap } from "@hyperframes/core/gsap-parser";
+import type { GsapAnimation, ParsedGsap } from "@hyperframes/core/gsap-parser";
 import type { DomEditSelection } from "../components/editor/domEditingTypes";
 import type { EditHistoryKind } from "../utils/editHistory";
 import { applySoftReload } from "../utils/gsapSoftReload";
 import { executeOptimistic } from "../utils/optimisticUpdate";
 import { usePlayerStore, type KeyframeCacheEntry } from "../player/store/playerStore";
+import { commitKeyframeAtTimeImpl } from "./gsapKeyframeCommit";
 
 const PROPERTY_DEFAULTS: Record<string, number> = {
   opacity: 1,
@@ -71,11 +72,51 @@ async function mutateGsapScript(
     return null;
   }
 }
-
+function updateKeyframeCacheFromParsed(
+  animations: GsapAnimation[],
+  targetPath: string,
+  selectionId: string | undefined,
+  mutation: Record<string, unknown>,
+): void {
+  const { setKeyframeCache } = usePlayerStore.getState();
+  const idsWithKeyframes = new Set<string>();
+  const merged = new Map<string, KeyframeCacheEntry>();
+  for (const anim of animations) {
+    const id = anim.targetSelector.match(/^#([\w-]+)/)?.[1];
+    if (!id || !anim.keyframes) continue;
+    idsWithKeyframes.add(id);
+    const existing = merged.get(id);
+    if (existing) {
+      const byPct = new Map<number, (typeof existing.keyframes)[0]>();
+      for (const kf of [...existing.keyframes, ...anim.keyframes.keyframes]) {
+        const prev = byPct.get(kf.percentage);
+        if (prev) {
+          prev.properties = { ...prev.properties, ...kf.properties };
+          if (kf.ease) prev.ease = kf.ease;
+        } else {
+          byPct.set(kf.percentage, { ...kf, properties: { ...kf.properties } });
+        }
+      }
+      existing.keyframes = Array.from(byPct.values()).sort((a, b) => a.percentage - b.percentage);
+    } else {
+      merged.set(id, { ...anim.keyframes, keyframes: [...anim.keyframes.keyframes] });
+    }
+  }
+  for (const [id, entry] of merged) {
+    setKeyframeCache(`${targetPath}#${id}`, entry);
+    if (targetPath !== "index.html") setKeyframeCache(`index.html#${id}`, entry);
+  }
+  const targetId =
+    (mutation as { targetSelector?: string }).targetSelector?.match(/^#([\w-]+)/)?.[1] ??
+    selectionId;
+  if (targetId && !idsWithKeyframes.has(targetId)) {
+    setKeyframeCache(`${targetPath}#${targetId}`, undefined);
+    if (targetPath !== "index.html") setKeyframeCache(`index.html#${targetId}`, undefined);
+  }
+}
 function buildCacheKey(sourceFile: string, elementId: string): string {
   return `${sourceFile}#${elementId}`;
 }
-
 function readKeyframeSnapshot(
   sourceFile: string,
   elementId: string | null | undefined,
@@ -83,7 +124,6 @@ function readKeyframeSnapshot(
   if (!elementId) return undefined;
   return usePlayerStore.getState().keyframeCache.get(buildCacheKey(sourceFile, elementId));
 }
-
 function writeKeyframeCache(
   sourceFile: string,
   elementId: string | null | undefined,
@@ -92,7 +132,6 @@ function writeKeyframeCache(
   if (!elementId) return;
   usePlayerStore.getState().setKeyframeCache(buildCacheKey(sourceFile, elementId), data);
 }
-
 interface GsapScriptCommitsParams {
   projectIdRef: React.MutableRefObject<string | null>;
   activeCompPath: string | null;
@@ -110,7 +149,6 @@ interface GsapScriptCommitsParams {
   onCacheInvalidate: () => void;
   onFileContentChanged?: (path: string, content: string) => void;
 }
-
 const DEBOUNCE_MS = 150;
 
 // fallow-ignore-next-line complexity unit-size
@@ -131,7 +169,6 @@ export function useGsapScriptCommits({
     value: number | string;
   } | null>(null);
   const debounceTimerRef = useRef<ReturnType<typeof setTimeout> | null>(null);
-
   /** Send a mutation and record the edit in undo history. */
   const commitMutation = useCallback(
     // fallow-ignore-next-line complexity
@@ -171,24 +208,12 @@ export function useGsapScriptCommits({
       }
 
       if (result.parsed?.animations) {
-        const { setKeyframeCache } = usePlayerStore.getState();
-        const idsWithKeyframes = new Set<string>();
-        for (const anim of result.parsed.animations) {
-          const id = anim.targetSelector.match(/^#([\w-]+)/)?.[1];
-          if (!id) continue;
-          if (anim.keyframes) {
-            idsWithKeyframes.add(id);
-            setKeyframeCache(`${targetPath}#${id}`, anim.keyframes);
-            if (targetPath !== "index.html") setKeyframeCache(`index.html#${id}`, anim.keyframes);
-          }
-        }
-        const targetId =
-          (mutation as { targetSelector?: string }).targetSelector?.match(/^#([\w-]+)/)?.[1] ??
-          selection.id;
-        if (targetId && !idsWithKeyframes.has(targetId)) {
-          setKeyframeCache(`${targetPath}#${targetId}`, undefined);
-          if (targetPath !== "index.html") setKeyframeCache(`index.html#${targetId}`, undefined);
-        }
+        updateKeyframeCacheFromParsed(
+          result.parsed.animations,
+          targetPath,
+          selection.id ?? undefined,
+          mutation,
+        );
       }
 
       if (options.skipReload) return;
@@ -214,7 +239,6 @@ export function useGsapScriptCommits({
       onFileContentChanged,
     ],
   );
-
   const flushPendingPropertyEdit = useCallback(() => {
     const pending = pendingPropertyEditRef.current;
     if (!pending) return;
@@ -244,7 +268,6 @@ export function useGsapScriptCommits({
     },
     [flushPendingPropertyEdit],
   );
-
   useEffect(() => {
     return () => {
       if (debounceTimerRef.current) clearTimeout(debounceTimerRef.current);
@@ -269,7 +292,6 @@ export function useGsapScriptCommits({
     },
     [commitMutation],
   );
-
   const deleteGsapAnimation = useCallback(
     (selection: DomEditSelection, animationId: string) => {
       void commitMutation(
@@ -280,7 +302,6 @@ export function useGsapScriptCommits({
     },
     [commitMutation],
   );
-
   const addGsapAnimation = useCallback(
     // fallow-ignore-next-line complexity
     async (
@@ -342,7 +363,6 @@ export function useGsapScriptCommits({
     },
     [commitMutation, projectIdRef, activeCompPath],
   );
-
   const addGsapProperty = useCallback(
     // fallow-ignore-next-line complexity
     (selection: DomEditSelection, animationId: string, property: string) => {
@@ -363,7 +383,6 @@ export function useGsapScriptCommits({
     },
     [commitMutation],
   );
-
   const removeGsapProperty = useCallback(
     (selection: DomEditSelection, animationId: string, property: string) => {
       void commitMutation(
@@ -374,7 +393,6 @@ export function useGsapScriptCommits({
     },
     [commitMutation],
   );
-
   const updateGsapFromProperty = useCallback(
     (
       selection: DomEditSelection,
@@ -393,7 +411,6 @@ export function useGsapScriptCommits({
     },
     [commitMutation],
   );
-
   const addGsapFromProperty = useCallback(
     (selection: DomEditSelection, animationId: string, property: string) => {
       const defaultValue = PROPERTY_DEFAULTS[property] ?? 0;
@@ -405,7 +422,6 @@ export function useGsapScriptCommits({
     },
     [commitMutation],
   );
-
   const removeGsapFromProperty = useCallback(
     (selection: DomEditSelection, animationId: string, property: string) => {
       void commitMutation(
@@ -416,7 +432,6 @@ export function useGsapScriptCommits({
     },
     [commitMutation],
   );
-
   const addKeyframe = useCallback(
     (
       selection: DomEditSelection,
@@ -452,7 +467,6 @@ export function useGsapScriptCommits({
     },
     [commitMutation, activeCompPath],
   );
-
   const removeKeyframe = useCallback(
     (selection: DomEditSelection, animationId: string, percentage: number) => {
       const sf = selection.sourceFile || activeCompPath || "index.html";
@@ -479,18 +493,20 @@ export function useGsapScriptCommits({
     },
     [commitMutation, activeCompPath],
   );
-
   const convertToKeyframes = useCallback(
-    (selection: DomEditSelection, animationId: string) => {
+    (
+      selection: DomEditSelection,
+      animationId: string,
+      resolvedFromValues?: Record<string, number | string>,
+    ) => {
       void commitMutation(
         selection,
-        { type: "convert-to-keyframes", animationId },
+        { type: "convert-to-keyframes", animationId, resolvedFromValues },
         { label: "Convert to keyframes" },
       );
     },
     [commitMutation],
   );
-
   const removeAllKeyframes = useCallback(
     (selection: DomEditSelection, animationId: string) => {
       void commitMutation(
@@ -501,7 +517,66 @@ export function useGsapScriptCommits({
     },
     [commitMutation],
   );
-
+  const setArcPath = useCallback(
+    (
+      selection: DomEditSelection,
+      animationId: string,
+      config: {
+        enabled: boolean;
+        autoRotate?: boolean | number;
+        segments?: Array<{
+          curviness: number;
+          cp1?: { x: number; y: number };
+          cp2?: { x: number; y: number };
+        }>;
+      },
+    ) => {
+      void commitMutation(
+        selection,
+        { type: "set-arc-path" as const, animationId, ...config },
+        { label: config.enabled ? "Enable arc path" : "Disable arc path", softReload: true },
+      );
+    },
+    [commitMutation],
+  );
+  const updateArcSegment = useCallback(
+    (
+      selection: DomEditSelection,
+      animationId: string,
+      segmentIndex: number,
+      update: {
+        curviness?: number;
+        cp1?: { x: number; y: number };
+        cp2?: { x: number; y: number };
+      },
+    ) => {
+      void commitMutation(
+        selection,
+        { type: "update-arc-segment" as const, animationId, segmentIndex, ...update },
+        { label: "Update arc segment", softReload: true },
+      );
+    },
+    [commitMutation],
+  );
+  const removeArcPath = useCallback(
+    (selection: DomEditSelection, animationId: string) => {
+      void commitMutation(
+        selection,
+        { type: "remove-arc-path" as const, animationId },
+        { label: "Remove arc path", softReload: true },
+      );
+    },
+    [commitMutation],
+  );
+  const commitKeyframeAtTime = useCallback(
+    (
+      selection: DomEditSelection,
+      absoluteTime: number,
+      animations: GsapAnimation[],
+      properties: Record<string, number | string>,
+    ) => commitKeyframeAtTimeImpl(selection, absoluteTime, animations, properties, commitMutation),
+    [commitMutation],
+  );
   return {
     commitMutation,
     updateGsapProperty,
@@ -517,5 +592,9 @@ export function useGsapScriptCommits({
     removeKeyframe,
     convertToKeyframes,
     removeAllKeyframes,
+    setArcPath,
+    updateArcSegment,
+    removeArcPath,
+    commitKeyframeAtTime,
   };
 }
diff --git a/packages/studio/src/hooks/useGsapSelectionHandlers.ts b/packages/studio/src/hooks/useGsapSelectionHandlers.ts
index 311656969..60f288d8e 100644
--- a/packages/studio/src/hooks/useGsapSelectionHandlers.ts
+++ b/packages/studio/src/hooks/useGsapSelectionHandlers.ts
@@ -62,7 +62,11 @@ export function useGsapSelectionHandlers({
     value: number | string,
   ) => void;
   removeKeyframe: (sel: DomEditSelection, animId: string, percentage: number) => void;
-  convertToKeyframes: (sel: DomEditSelection, animId: string) => void;
+  convertToKeyframes: (
+    sel: DomEditSelection,
+    animId: string,
+    resolvedFromValues?: Record<string, number | string>,
+  ) => void;
   removeAllKeyframes: (sel: DomEditSelection, animId: string) => void;
   currentTime: number;
   handleDomManualEditsReset: (sel: DomEditSelection) => void;
@@ -160,9 +164,9 @@ export function useGsapSelectionHandlers({
   );
 
   const handleGsapConvertToKeyframes = useCallback(
-    (animId: string) => {
+    (animId: string, resolvedFromValues?: Record<string, number | string>) => {
       if (!domEditSelection) return;
-      convertToKeyframes(domEditSelection, animId);
+      convertToKeyframes(domEditSelection, animId, resolvedFromValues);
     },
     [domEditSelection, convertToKeyframes],
   );
diff --git a/packages/studio/src/hooks/useGsapTweenCache.ts b/packages/studio/src/hooks/useGsapTweenCache.ts
index f47b806cf..4075c711c 100644
--- a/packages/studio/src/hooks/useGsapTweenCache.ts
+++ b/packages/studio/src/hooks/useGsapTweenCache.ts
@@ -1,8 +1,72 @@
 import { useEffect, useMemo, useRef, useState, useCallback } from "react";
-import type { GsapAnimation, ParsedGsap } from "@hyperframes/core/gsap-parser";
+import type { GsapAnimation, GsapKeyframesData, ParsedGsap } from "@hyperframes/core/gsap-parser";
+import type { GsapPercentageKeyframe } from "@hyperframes/core/gsap-parser";
 import { usePlayerStore } from "../player/store/playerStore";
 import { readRuntimeKeyframes, scanAllRuntimeKeyframes } from "./gsapRuntimeBridge";
 
+function deduplicateKeyframes(keyframes: GsapPercentageKeyframe[]): GsapPercentageKeyframe[] {
+  const byPct = new Map<number, GsapPercentageKeyframe>();
+  for (const kf of keyframes) {
+    const existing = byPct.get(kf.percentage);
+    if (existing) {
+      existing.properties = { ...existing.properties, ...kf.properties };
+      if (kf.ease) existing.ease = kf.ease;
+    } else {
+      byPct.set(kf.percentage, { ...kf, properties: { ...kf.properties } });
+    }
+  }
+  return Array.from(byPct.values()).sort((a, b) => a.percentage - b.percentage);
+}
+
+const PROPERTY_DEFAULTS: Record<string, number> = {
+  opacity: 1,
+  x: 0,
+  y: 0,
+  scale: 1,
+  scaleX: 1,
+  scaleY: 1,
+  rotation: 0,
+};
+
+function synthesizeFlatTweenKeyframes(anim: GsapAnimation): GsapKeyframesData | null {
+  if (anim.method === "set") {
+    return {
+      format: "percentage",
+      keyframes: [{ percentage: 0, properties: { ...anim.properties } }],
+    };
+  }
+  const toProps = anim.properties;
+  const fromProps = anim.fromProperties;
+  if (!toProps || Object.keys(toProps).length === 0) return null;
+
+  const startProps: Record<string, number | string> = {};
+  const endProps: Record<string, number | string> = {};
+
+  if (anim.method === "from") {
+    for (const [k, v] of Object.entries(toProps)) {
+      startProps[k] = v;
+      endProps[k] = PROPERTY_DEFAULTS[k] ?? 0;
+    }
+  } else if (anim.method === "fromTo" && fromProps) {
+    Object.assign(startProps, fromProps);
+    Object.assign(endProps, toProps);
+  } else {
+    for (const [k, v] of Object.entries(toProps)) {
+      startProps[k] = PROPERTY_DEFAULTS[k] ?? 0;
+      endProps[k] = v;
+    }
+  }
+
+  return {
+    format: "percentage",
+    keyframes: [
+      { percentage: 0, properties: startProps },
+      { percentage: 100, properties: endProps },
+    ],
+    ...(anim.ease ? { ease: anim.ease } : {}),
+  };
+}
+
 function extractIdFromSelector(selector: string): string | null {
   const match = selector.match(/^#([\w-]+)/);
   return match ? match[1] : null;
@@ -182,12 +246,33 @@ export function useGsapAnimationsForElement(
 
   // Populate keyframe cache for the selected element.
   // Key format must match timeline element keys: "sourceFile#domId".
+  // Merges keyframes from ALL animations targeting this element and synthesizes
+  // flat tweens so the cache is never downgraded vs the bulk populate.
   const elementId = target?.id ?? null;
   useEffect(() => {
     if (!elementId) return;
+    const allKeyframes: GsapKeyframesData["keyframes"] = [];
+    let format: GsapKeyframesData["format"] = "percentage";
+    let ease: string | undefined;
+    let easeEach: string | undefined;
+    for (const anim of animations) {
+      const kf = anim.keyframes ?? synthesizeFlatTweenKeyframes(anim);
+      if (!kf) continue;
+      allKeyframes.push(...kf.keyframes);
+      format = kf.format;
+      if (kf.ease) ease = kf.ease;
+      if (kf.easeEach) easeEach = kf.easeEach;
+    }
+    if (allKeyframes.length === 0) return;
+    const dedupedKeyframes = deduplicateKeyframes(allKeyframes);
+    const merged: GsapKeyframesData = {
+      format,
+      keyframes: dedupedKeyframes,
+      ...(ease ? { ease } : {}),
+      ...(easeEach ? { easeEach } : {}),
+    };
     const { setKeyframeCache } = usePlayerStore.getState();
-    const withKeyframes = animations.find((a) => a.keyframes);
-    setKeyframeCache(`${sourceFile}#${elementId}`, withKeyframes?.keyframes ?? undefined);
+    setKeyframeCache(`${sourceFile}#${elementId}`, merged);
   }, [elementId, sourceFile, animations]);
 
   return { animations, multipleTimelines, unsupportedTimelinePattern };
@@ -213,12 +298,14 @@ export function usePopulateKeyframeCacheForFile(
   const lastFetchKeyRef = useRef("");
 
   const runtimeScanDoneRef = useRef("");
+  const astFetchDoneRef = useRef("");
 
   useEffect(() => {
     const fetchKey = `kf-cache:${projectId}:${sourceFile}:${version}`;
     if (fetchKey === lastFetchKeyRef.current) return;
     lastFetchKeyRef.current = fetchKey;
     runtimeScanDoneRef.current = "";
+    astFetchDoneRef.current = "";
     if (!projectId) return;
 
     const sf = sourceFile;
@@ -232,13 +319,25 @@ export function usePopulateKeyframeCacheForFile(
           setKeyframeCache(key, undefined);
         }
       }
+      const mergedByElement = new Map<string, GsapKeyframesData>();
       for (const anim of parsed.animations) {
         const id = extractIdFromSelector(anim.targetSelector);
-        if (!id || !anim.keyframes) continue;
-        setKeyframeCache(`${sf}#${id}`, anim.keyframes);
-        if (sf !== "index.html") setKeyframeCache(`index.html#${id}`, anim.keyframes);
+        if (!id) continue;
+        const kfData = anim.keyframes ?? synthesizeFlatTweenKeyframes(anim);
+        if (!kfData) continue;
+        const existing = mergedByElement.get(id);
+        if (existing) {
+          existing.keyframes = deduplicateKeyframes([...existing.keyframes, ...kfData.keyframes]);
+        } else {
+          mergedByElement.set(id, { ...kfData, keyframes: [...kfData.keyframes] });
+        }
+      }
+      for (const [id, kfData] of mergedByElement) {
+        setKeyframeCache(`${sf}#${id}`, kfData);
+        setKeyframeCache(id, kfData);
+        if (sf !== "index.html") setKeyframeCache(`index.html#${id}`, kfData);
       }
-      runtimeScanDoneRef.current = fetchKey;
+      astFetchDoneRef.current = fetchKey;
     });
   }, [projectId, sourceFile, version]);
 
@@ -253,7 +352,8 @@ export function usePopulateKeyframeCacheForFile(
 
     const tryRuntimeScan = () => {
       if (runtimeScanDoneRef.current === `kf-cache:${projectId}:${sf}:${version}`) return true;
-      const iframe = iframeRef?.current;
+      const iframe =
+        iframeRef?.current ?? document.querySelector<HTMLIFrameElement>("iframe[src*='/preview/']");
       if (!iframe) return false;
       const scanned = scanAllRuntimeKeyframes(iframe);
       if (scanned.size === 0) return false;
@@ -261,7 +361,8 @@ export function usePopulateKeyframeCacheForFile(
       for (const [id, data] of scanned) {
         const cacheKey = `${sf}#${id}`;
         const fallbackKey = `index.html#${id}`;
-        if (keyframeCache.has(cacheKey) || keyframeCache.has(fallbackKey)) continue;
+        if (keyframeCache.has(cacheKey) || keyframeCache.has(fallbackKey) || keyframeCache.has(id))
+          continue;
         const entry = {
           format: "percentage" as const,
           keyframes: data.keyframes,
@@ -269,6 +370,7 @@ export function usePopulateKeyframeCacheForFile(
         };
         setKeyframeCache(cacheKey, entry);
         if (sf !== "index.html") setKeyframeCache(fallbackKey, entry);
+        setKeyframeCache(id, entry);
       }
       runtimeScanDoneRef.current = `kf-cache:${projectId}:${sf}:${version}`;
       return true;
diff --git a/packages/studio/src/hooks/useKeyframeKeyboard.ts b/packages/studio/src/hooks/useKeyframeKeyboard.ts
new file mode 100644
index 000000000..260c749f2
--- /dev/null
+++ b/packages/studio/src/hooks/useKeyframeKeyboard.ts
@@ -0,0 +1,103 @@
+import { useEffect, useCallback } from "react";
+import { usePlayerStore } from "../player/store/playerStore";
+
+interface KeyframeKeyboardOptions {
+  enabled: boolean;
+  onAddKeyframe?: () => void;
+  onDeleteKeyframe?: () => void;
+  onPrevKeyframe?: () => void;
+  onNextKeyframe?: () => void;
+  onToggleHold?: () => void;
+  onToggleExpand?: () => void;
+  onNudgeKeyframe?: (direction: -1 | 1, large: boolean) => void;
+}
+
+function isTextInput(el: Element | null): boolean {
+  if (!el) return false;
+  const tag = el.tagName;
+  if (tag === "INPUT" || tag === "TEXTAREA" || tag === "SELECT") return true;
+  return (el as HTMLElement).isContentEditable === true;
+}
+
+export function useKeyframeKeyboard({
+  enabled,
+  onAddKeyframe,
+  onDeleteKeyframe,
+  onPrevKeyframe,
+  onNextKeyframe,
+  onToggleHold,
+  onToggleExpand,
+  onNudgeKeyframe,
+}: KeyframeKeyboardOptions): void {
+  const handler = useCallback(
+    (e: KeyboardEvent) => {
+      if (!enabled) return;
+      if (isTextInput(document.activeElement)) return;
+
+      const hasSelectedKeyframes = usePlayerStore.getState().selectedKeyframes.size > 0;
+
+      switch (e.key.toLowerCase()) {
+        case "k":
+          if (!e.metaKey && !e.ctrlKey) {
+            e.preventDefault();
+            onAddKeyframe?.();
+          }
+          break;
+        case "delete":
+        case "backspace":
+          if (hasSelectedKeyframes) {
+            e.preventDefault();
+            onDeleteKeyframe?.();
+          }
+          break;
+        case "j":
+          if (!e.metaKey && !e.ctrlKey) {
+            e.preventDefault();
+            if (e.shiftKey) onNextKeyframe?.();
+            else onPrevKeyframe?.();
+          }
+          break;
+        case "h":
+          if (!e.metaKey && !e.ctrlKey && hasSelectedKeyframes) {
+            e.preventDefault();
+            onToggleHold?.();
+          }
+          break;
+        case "u":
+          if (!e.metaKey && !e.ctrlKey) {
+            e.preventDefault();
+            onToggleExpand?.();
+          }
+          break;
+        case "arrowleft":
+          if (hasSelectedKeyframes && !e.metaKey && !e.ctrlKey && !e.altKey) {
+            e.preventDefault();
+            onNudgeKeyframe?.(-1, e.shiftKey);
+          }
+          break;
+        case "arrowright":
+          if (hasSelectedKeyframes && !e.metaKey && !e.ctrlKey && !e.altKey) {
+            e.preventDefault();
+            onNudgeKeyframe?.(1, e.shiftKey);
+          }
+          break;
+      }
+    },
+    [
+      enabled,
+      onAddKeyframe,
+      onDeleteKeyframe,
+      onPrevKeyframe,
+      onNextKeyframe,
+      onToggleHold,
+      onToggleExpand,
+      onNudgeKeyframe,
+    ],
+  );
+
+  useEffect(() => {
+    if (!enabled) return;
+    window.addEventListener("keydown", handler);
+    return () => window.removeEventListener("keydown", handler);
+  }, [enabled, handler]);
+}
diff --git a/packages/studio/src/player/components/ShortcutsPanel.tsx b/packages/studio/src/player/components/ShortcutsPanel.tsx
index c282c7ef1..c5c201b3e 100644
--- a/packages/studio/src/player/components/ShortcutsPanel.tsx
+++ b/packages/studio/src/player/components/ShortcutsPanel.tsx
@@ -17,6 +17,16 @@ const SHORTCUT_SECTIONS = [
       { key: "F", label: "Toggle fullscreen" },
     ],
   },
+  {
+    title: "Keyframes",
+    hints: [
+      { key: "K", label: "Add keyframe at playhead" },
+      { key: "Del", label: "Delete selected keyframe" },
+      { key: "H", label: "Toggle hold / bezier" },
+      { key: "U", label: "Expand / collapse properties" },
+      { key: "R", label: "Record gesture" },
+    ],
+  },
   {
     title: "Work area",
     hints: [
diff --git a/packages/studio/src/player/components/TimelinePropertyRows.tsx b/packages/studio/src/player/components/TimelinePropertyRows.tsx
new file mode 100644
index 000000000..dc16be86d
--- /dev/null
+++ b/packages/studio/src/player/components/TimelinePropertyRows.tsx
@@ -0,0 +1,120 @@
+import { memo } from "react";
+import type { KeyframeCacheEntry } from "../store/playerStore";
+
+const SUB_TRACK_H = 24;
+const DIAMOND_SIZE = 6;
+const HALF = DIAMOND_SIZE / 2;
+
+interface TimelinePropertyRowsProps {
+  keyframesData: KeyframeCacheEntry;
+  clipWidthPx: number;
+  clipLeftPx: number;
+  accentColor: string;
+  isSelected: boolean;
+  currentPercentage: number;
+  elementId: string;
+  selectedKeyframes: Set<string>;
+  onClickKeyframe?: (percentage: number) => void;
+}
+
+function extractProperties(data: KeyframeCacheEntry): string[] {
+  const props = new Set<string>();
+  for (const kf of data.keyframes) {
+    for (const key of Object.keys(kf.properties)) {
+      props.add(key);
+    }
+  }
+  return Array.from(props).sort();
+}
+
+export const TimelinePropertyRows = memo(function TimelinePropertyRows({
+  keyframesData,
+  clipWidthPx,
+  clipLeftPx,
+  accentColor,
+  isSelected,
+  currentPercentage,
+  elementId,
+  selectedKeyframes,
+  onClickKeyframe,
+}: TimelinePropertyRowsProps) {
+  const properties = extractProperties(keyframesData);
+  if (properties.length === 0 || clipWidthPx < 20) return null;
+
+  return (
+    <div className="flex flex-col">
+      {properties.map((prop) => {
+        const propKeyframes = keyframesData.keyframes.filter((kf) => prop in kf.properties);
+        if (propKeyframes.length === 0) return null;
+
+        return (
+          <div key={prop} className="relative flex items-center" style={{ height: SUB_TRACK_H }}>
+            <span className="absolute left-1 text-[8px] font-medium text-neutral-600 z-10 select-none">
+              {prop}
+            </span>
+            <svg
+              className="absolute"
+              style={{ left: clipLeftPx, width: clipWidthPx, height: SUB_TRACK_H }}
+              viewBox={`0 0 ${clipWidthPx} ${SUB_TRACK_H}`}
+            >
+              <line
+                x1={0}
+                y1={SUB_TRACK_H / 2}
+                x2={clipWidthPx}
+                y2={SUB_TRACK_H / 2}
+                stroke={isSelected ? accentColor : "#525252"}
+                strokeOpacity={0.15}
+                strokeWidth={1}
+              />
+              {propKeyframes.map((kf) => {
+                const x = (kf.percentage / 100) * clipWidthPx;
+                const y = SUB_TRACK_H / 2;
+                const key = `${elementId}:${kf.percentage}`;
+                const isKfSelected = selectedKeyframes.has(key);
+                const isHold = kf.ease === "steps(1)";
+                const fillColor =
+                  isKfSelected || (isSelected && Math.abs(kf.percentage - currentPercentage) < 0.5)
+                    ? accentColor
+                    : isSelected
+                      ? `${accentColor}80`
+                      : "#737373";
+
+                return (
+                  <g
+                    key={kf.percentage}
+                    onClick={(e) => {
+                      e.stopPropagation();
+                      onClickKeyframe?.(kf.percentage);
+                    }}
+                    style={{ cursor: "pointer" }}
+                  >
+                    {isHold ? (
+                      <rect
+                        x={x - HALF}
+                        y={y - HALF}
+                        width={DIAMOND_SIZE}
+                        height={DIAMOND_SIZE}
+                        fill={fillColor}
+                      />
+                    ) : (
+                      <rect
+                        x={x - HALF}
+                        y={y - HALF}
+                        width={DIAMOND_SIZE}
+                        height={DIAMOND_SIZE}
+                        fill={fillColor}
+                        transform={`rotate(45, ${x}, ${y})`}
+                      />
+                    )}
+                  </g>
+                );
+              })}
+            </svg>
+          </div>
+        );
+      })}
+    </div>
+  );
+});
+
+export { SUB_TRACK_H };
diff --git a/packages/studio/src/player/store/playerStore.ts b/packages/studio/src/player/store/playerStore.ts
index d67aad396..90e886240 100644
--- a/packages/studio/src/player/store/playerStore.ts
+++ b/packages/studio/src/player/store/playerStore.ts
@@ -68,6 +68,23 @@ interface PlayerState {
   toggleSelectedKeyframe: (key: string) => void;
   clearSelectedKeyframes: () => void;
 
+  /** Multi-select: additional selected elements beyond selectedElementId. */
+  selectedElementIds: Set<string>;
+  toggleSelectedElementId: (id: string) => void;
+  clearSelectedElementIds: () => void;
+
+  /** Clipboard for keyframe copy/paste — stores keyframes with relative times. */
+  keyframeClipboard: Array<{
+    relativeTime: number;
+    properties: Record<string, number | string>;
+    ease?: string;
+  }> | null;
+  setKeyframeClipboard: (data: PlayerState["keyframeClipboard"]) => void;
+
+  /** Elements with expanded property rows in the timeline. */
+  expandedTimelineElements: Set<string>;
+  toggleExpandedElement: (id: string) => void;
+
   /** Keyframe data per element id, populated from parsed GSAP animations. */
   keyframeCache: Map<string, KeyframeCacheEntry>;
   setKeyframeCache: (elementId: string, data: KeyframeCacheEntry | undefined) => void;
@@ -138,6 +155,28 @@ export const usePlayerStore = create<PlayerState>((set) => ({
     }),
   clearSelectedKeyframes: () => set({ selectedKeyframes: new Set() }),
 
+  keyframeClipboard: null,
+  setKeyframeClipboard: (data) => set({ keyframeClipboard: data }),
+
+  selectedElementIds: new Set<string>(),
+  toggleSelectedElementId: (id: string) =>
+    set((s) => {
+      const next = new Set(s.selectedElementIds);
+      if (next.has(id)) next.delete(id);
+      else next.add(id);
+      return { selectedElementIds: next };
+    }),
+  clearSelectedElementIds: () => set({ selectedElementIds: new Set() }),
+
+  expandedTimelineElements: new Set<string>(),
+  toggleExpandedElement: (id: string) =>
+    set((s) => {
+      const next = new Set(s.expandedTimelineElements);
+      if (next.has(id)) next.delete(id);
+      else next.add(id);
+      return { expandedTimelineElements: next };
+    }),
+
   keyframeCache: new Map(),
   setKeyframeCache: (elementId, data) =>
     set((s) => {
@@ -210,6 +249,8 @@ export const usePlayerStore = create<PlayerState>((set) => ({
       inPoint: null,
       outPoint: null,
       selectedKeyframes: new Set(),
+      selectedElementIds: new Set(),
+      expandedTimelineElements: new Set(),
       keyframeCache: new Map(),
     }),
 }));
diff --git a/packages/studio/src/utils/audioBeatDetection.ts b/packages/studio/src/utils/audioBeatDetection.ts
new file mode 100644
index 000000000..158dea08a
--- /dev/null
+++ b/packages/studio/src/utils/audioBeatDetection.ts
@@ -0,0 +1,58 @@
+const WINDOW_SIZE = 1024;
+const HOP_SIZE = 512;
+
+// fallow-ignore-next-line complexity
+export async function detectBeats(audioBuffer: AudioBuffer): Promise<number[]> {
+  const channelData = audioBuffer.getChannelData(0);
+  const sampleRate = audioBuffer.sampleRate;
+
+  const energies: number[] = [];
+  for (let i = 0; i < channelData.length - WINDOW_SIZE; i += HOP_SIZE) {
+    let sum = 0;
+    for (let j = 0; j < WINDOW_SIZE; j++) {
+      const sample = channelData[i + j]!;
+      sum += sample * sample;
+    }
+    energies.push(sum / WINDOW_SIZE);
+  }
+
+  const beats: number[] = [];
+  const localWindowSize = 20;
+
+  for (let i = localWindowSize; i < energies.length - localWindowSize; i++) {
+    let localMean = 0;
+    for (let j = i - localWindowSize; j < i + localWindowSize; j++) {
+      localMean += energies[j]!;
+    }
+    localMean /= localWindowSize * 2;
+
+    const threshold = localMean * 1.5;
+    const current = energies[i]!;
+
+    if (
+      current > threshold &&
+      current > (energies[i - 1] ?? 0) &&
+      current > (energies[i + 1] ?? 0)
+    ) {
+      const timeInSeconds = (i * HOP_SIZE) / sampleRate;
+      if (beats.length === 0 || timeInSeconds - beats[beats.length - 1]! > 0.1) {
+        beats.push(Math.round(timeInSeconds * 1000) / 1000);
+      }
+    }
+  }
+
+  return beats;
+}
+
+// fallow-ignore-next-line complexity
+export async function detectBeatsFromUrl(url: string): Promise<number[]> {
+  const audioContext = new AudioContext();
+  try {
+    const response = await fetch(url);
+    const arrayBuffer = await response.arrayBuffer();
+    const audioBuffer = await audioContext.decodeAudioData(arrayBuffer);
+    return detectBeats(audioBuffer);
+  } finally {
+    await audioContext.close();
+  }
+}
diff --git a/packages/studio/src/utils/globalTimeCompiler.test.ts b/packages/studio/src/utils/globalTimeCompiler.test.ts
new file mode 100644
index 000000000..db4095cbc
--- /dev/null
+++ b/packages/studio/src/utils/globalTimeCompiler.test.ts
@@ -0,0 +1,169 @@
+import { describe, expect, test } from "vitest";
+import {
+  absoluteToPercentage,
+  absoluteToPercentageForAnimation,
+  findTweenAtTime,
+  isTimeWithinTween,
+  percentageToAbsolute,
+  percentageToAbsoluteForAnimation,
+  resolveTweenDuration,
+  resolveTweenStart,
+} from "./globalTimeCompiler";
+import type { GsapAnimation } from "@hyperframes/core/gsap-parser";
+
+function makeAnim(overrides: Partial<GsapAnimation> = {}): GsapAnimation {
+  return {
+    id: "#el-to-0",
+    targetSelector: "#el",
+    method: "to",
+    position: 0,
+    properties: { x: 100 },
+    ...overrides,
+  };
+}
+
+describe("absoluteToPercentage", () => {
+  test("mid-point of a tween", () => {
+    expect(absoluteToPercentage(0.5, 0, 2)).toBe(25);
+  });
+
+  test("tween with offset start", () => {
+    expect(absoluteToPercentage(1.0, 0.5, 1)).toBe(50);
+  });
+
+  test("clamps below tween start to 0%", () => {
+    expect(absoluteToPercentage(-1, 0, 2)).toBe(0);
+  });
+
+  test("clamps past tween end to 100%", () => {
+    expect(absoluteToPercentage(5, 0, 2)).toBe(100);
+  });
+
+  test("zero duration returns 0", () => {
+    expect(absoluteToPercentage(1, 0, 0)).toBe(0);
+  });
+});
+
+describe("percentageToAbsolute", () => {
+  test("converts percentage back to absolute time", () => {
+    expect(percentageToAbsolute(50, 0.5, 1)).toBe(1.0);
+  });
+
+  test("0% returns tween start", () => {
+    expect(percentageToAbsolute(0, 2, 3)).toBe(2);
+  });
+
+  test("100% returns tween end", () => {
+    expect(percentageToAbsolute(100, 2, 3)).toBe(5);
+  });
+});
+
+describe("isTimeWithinTween", () => {
+  test("time inside returns true", () => {
+    expect(isTimeWithinTween(0.5, 0, 2)).toBe(true);
+  });
+
+  test("time at start returns true", () => {
+    expect(isTimeWithinTween(0, 0, 2)).toBe(true);
+  });
+
+  test("time at end returns true", () => {
+    expect(isTimeWithinTween(2, 0, 2)).toBe(true);
+  });
+
+  test("time before returns false", () => {
+    expect(isTimeWithinTween(-0.1, 0, 2)).toBe(false);
+  });
+
+  test("time after returns false", () => {
+    expect(isTimeWithinTween(2.1, 0, 2)).toBe(false);
+  });
+});
+
+describe("resolveTweenStart", () => {
+  test("numeric position", () => {
+    expect(resolveTweenStart(makeAnim({ position: 1.5 }))).toBe(1.5);
+  });
+
+  test("parseable string position", () => {
+    expect(resolveTweenStart(makeAnim({ position: "2.5" }))).toBe(2.5);
+  });
+
+  test("unparseable string position returns null", () => {
+    expect(resolveTweenStart(makeAnim({ position: "myLabel" }))).toBeNull();
+  });
+
+  test("relative position +=0.5 returns null", () => {
+    expect(resolveTweenStart(makeAnim({ position: "+=0.5" }))).toBeNull();
+  });
+});
+
+describe("resolveTweenDuration", () => {
+  test("explicit duration", () => {
+    expect(resolveTweenDuration(makeAnim({ duration: 2 }))).toBe(2);
+  });
+
+  test("missing duration defaults to 1", () => {
+    expect(resolveTweenDuration(makeAnim({ duration: undefined }))).toBe(1);
+  });
+});
+
+describe("findTweenAtTime", () => {
+  const anims = [
+    makeAnim({ id: "#el-to-0", position: 0, duration: 0.5 }),
+    makeAnim({ id: "#el-to-1", position: 1, duration: 1 }),
+    makeAnim({
+      id: "#other-to-0",
+      targetSelector: "#other",
+      position: 0,
+      duration: 2,
+    }),
+  ];
+
+  test("finds tween at time within range", () => {
+    expect(findTweenAtTime(0.3, anims, "#el")?.id).toBe("#el-to-0");
+  });
+
+  test("finds second tween", () => {
+    expect(findTweenAtTime(1.5, anims, "#el")?.id).toBe("#el-to-1");
+  });
+
+  test("returns null for gap between tweens", () => {
+    expect(findTweenAtTime(0.7, anims, "#el")).toBeNull();
+  });
+
+  test("filters by selector", () => {
+    expect(findTweenAtTime(0.3, anims, "#other")?.id).toBe("#other-to-0");
+  });
+
+  test("returns null for unmatched selector", () => {
+    expect(findTweenAtTime(0.3, anims, "#missing")).toBeNull();
+  });
+
+  test("skips tweens with unresolvable string positions", () => {
+    const withLabel = [makeAnim({ id: "#el-to-0", position: "myLabel", duration: 1 })];
+    expect(findTweenAtTime(0.5, withLabel, "#el")).toBeNull();
+  });
+});
+
+describe("animation-level helpers", () => {
+  const anim = makeAnim({ position: 0.5, duration: 2 });
+
+  test("absoluteToPercentageForAnimation", () => {
+    expect(absoluteToPercentageForAnimation(1.5, anim)).toBe(50);
+  });
+
+  test("absoluteToPercentageForAnimation returns null for string position", () => {
+    const labelAnim = makeAnim({ position: "label" });
+    expect(absoluteToPercentageForAnimation(0.5, labelAnim)).toBeNull();
+  });
+
+  test("percentageToAbsoluteForAnimation", () => {
+    expect(percentageToAbsoluteForAnimation(50, anim)).toBe(1.5);
+  });
+
+  test("percentageToAbsoluteForAnimation returns null for string position", () => {
+    const labelAnim = makeAnim({ position: "+=1" });
+    expect(percentageToAbsoluteForAnimation(50, labelAnim)).toBeNull();
+  });
+});
diff --git a/packages/studio/src/utils/globalTimeCompiler.ts b/packages/studio/src/utils/globalTimeCompiler.ts
new file mode 100644
index 000000000..9abe6c83d
--- /dev/null
+++ b/packages/studio/src/utils/globalTimeCompiler.ts
@@ -0,0 +1,77 @@
+import type { GsapAnimation } from "@hyperframes/core/gsap-parser";
+
+export function absoluteToPercentage(
+  time: number,
+  tweenStart: number,
+  tweenDuration: number,
+): number {
+  if (tweenDuration <= 0) return 0;
+  const raw = ((time - tweenStart) / tweenDuration) * 100;
+  return Math.max(0, Math.min(100, Math.round(raw * 10) / 10));
+}
+
+export function percentageToAbsolute(
+  pct: number,
+  tweenStart: number,
+  tweenDuration: number,
+): number {
+  return tweenStart + (pct / 100) * tweenDuration;
+}
+
+export function isTimeWithinTween(
+  time: number,
+  tweenStart: number,
+  tweenDuration: number,
+): boolean {
+  return time >= tweenStart && time <= tweenStart + tweenDuration;
+}
+
+export function resolveTweenStart(animation: GsapAnimation): number | null {
+  if (typeof animation.position === "number") return animation.position;
+  const parsed = Number.parseFloat(animation.position as string);
+  if (!Number.isNaN(parsed)) return parsed;
+  return null;
+}
+
+export function resolveTweenDuration(animation: GsapAnimation): number {
+  return animation.duration ?? 1;
+}
+
+export function findTweenAtTime(
+  time: number,
+  animations: GsapAnimation[],
+  selector: string,
+): GsapAnimation | null {
+  for (const anim of animations) {
+    if (!matchesSelector(anim.targetSelector, selector)) continue;
+    const start = resolveTweenStart(anim);
+    if (start === null) continue;
+    const duration = resolveTweenDuration(anim);
+    if (isTimeWithinTween(time, start, duration)) return anim;
+  }
+  return null;
+}
+
+export function absoluteToPercentageForAnimation(
+  time: number,
+  animation: GsapAnimation,
+): number | null {
+  const start = resolveTweenStart(animation);
+  if (start === null) return null;
+  const duration = resolveTweenDuration(animation);
+  return absoluteToPercentage(time, start, duration);
+}
+
+export function percentageToAbsoluteForAnimation(
+  pct: number,
+  animation: GsapAnimation,
+): number | null {
+  const start = resolveTweenStart(animation);
+  if (start === null) return null;
+  const duration = resolveTweenDuration(animation);
+  return percentageToAbsolute(pct, start, duration);
+}
+
+function matchesSelector(tweenSelector: string, querySelector: string): boolean {
+  return tweenSelector.split(",").some((part) => part.trim() === querySelector);
+}
diff --git a/packages/studio/src/utils/gsapSoftReload.ts b/packages/studio/src/utils/gsapSoftReload.ts
index b27d404e1..d35488e26 100644
--- a/packages/studio/src/utils/gsapSoftReload.ts
+++ b/packages/studio/src/utils/gsapSoftReload.ts
@@ -4,7 +4,11 @@ type IframeWindow = Window & {
   __hfForceTimelineRebind?: () => void;
   __hfSuppressSceneMutations?: <T>(fn: () => T) => T;
   __hfStudioManualEditsApply?: () => void;
-  gsap?: { timeline?: (...args: unknown[]) => unknown };
+  gsap?: {
+    timeline?: (...args: unknown[]) => unknown;
+    registerPlugin?: (...plugins: unknown[]) => unknown;
+  };
+  MotionPathPlugin?: unknown;
 };
 
 function isGsapScript(text: string): boolean {
@@ -64,16 +68,30 @@ export function applySoftReload(iframe: HTMLIFrameElement | null, scriptText: st
     }
 
     oldScriptEl.remove();
-    const newScript = doc.createElement("script");
-    // IIFE prevents const/let redeclaration errors across consecutive edits.
-    // Top-level declarations are scoped to the IIFE; window.* assignments
-    // (e.g. window.__timelines["root"] = tl) still reach the global scope.
-    newScript.textContent = `(function(){${scriptText}\n})();`;
-    doc.body.appendChild(newScript);
 
-    win.__hfForceTimelineRebind?.();
-    win.__player?.seek?.(currentTime);
-    win.__hfStudioManualEditsApply?.();
+    const executeScript = () => {
+      if (win.MotionPathPlugin && win.gsap?.registerPlugin) {
+        win.gsap.registerPlugin(win.MotionPathPlugin);
+      }
+      const s = doc.createElement("script");
+      s.textContent = `(function(){${scriptText}\n})();`;
+      doc.body.appendChild(s);
+      win.__hfForceTimelineRebind?.();
+      win.__player?.seek?.(currentTime);
+      win.__hfStudioManualEditsApply?.();
+    };
+
+    // Load MotionPathPlugin on demand if the script uses motionPath
+    const needsMotionPath = /motionPath\s*[:{]/.test(scriptText);
+    if (needsMotionPath && !win.MotionPathPlugin && win.gsap) {
+      const pluginScript = doc.createElement("script");
+      pluginScript.src = "https://cdn.jsdelivr.net/npm/gsap@3.12.5/dist/MotionPathPlugin.min.js";
+      pluginScript.onload = () => executeScript();
+      doc.head.appendChild(pluginScript);
+      return;
+    }
+
+    executeScript();
   };
 
   try {
diff --git a/packages/studio/src/utils/keyframeSnapping.test.ts b/packages/studio/src/utils/keyframeSnapping.test.ts
new file mode 100644
index 000000000..7152c0640
--- /dev/null
+++ b/packages/studio/src/utils/keyframeSnapping.test.ts
@@ -0,0 +1,74 @@
+import { describe, expect, test } from "vitest";
+import { computeSnapThreshold, snapKeyframe } from "./keyframeSnapping";
+
+describe("snapKeyframe", () => {
+  test("snaps to frame boundary", () => {
+    const result = snapKeyframe(0.34, { fps: 30, keyframeTimes: [], threshold: 0.05 });
+    expect(result.snapType).toBe("frame");
+    expect(Math.abs(result.snappedTime - 1 / 3)).toBeLessThan(0.01);
+  });
+
+  test("snaps to cross-element keyframe when closest", () => {
+    const result = snapKeyframe(1.005, { fps: 30, keyframeTimes: [1.0], threshold: 0.05 });
+    expect(result.snapType).toBe("keyframe");
+    expect(result.snappedTime).toBe(1.0);
+  });
+
+  test("keyframe snap wins tie with frame at same position", () => {
+    const result = snapKeyframe(1.0, { fps: 30, keyframeTimes: [1.0], threshold: 0.05 });
+    expect(result.snapType).toBe("keyframe");
+    expect(result.snappedTime).toBe(1.0);
+  });
+
+  test("snaps to beat marker when closer than frame", () => {
+    const result = snapKeyframe(2.49, {
+      fps: 30,
+      keyframeTimes: [],
+      beatTimes: [2.5],
+      threshold: 0.05,
+    });
+    expect(result.snapType).toBe("beat");
+    expect(result.snappedTime).toBe(2.5);
+  });
+
+  test("disabled returns raw time", () => {
+    const result = snapKeyframe(1.5, {
+      fps: 30,
+      keyframeTimes: [1.5],
+      threshold: 0.05,
+      disabled: true,
+    });
+    expect(result.snapType).toBeNull();
+    expect(result.snappedTime).toBe(1.5);
+  });
+
+  test("no snap when outside threshold", () => {
+    const result = snapKeyframe(1.5, {
+      fps: 30,
+      keyframeTimes: [0.5],
+      threshold: 0.05,
+    });
+    expect(result.snapType).toBe("frame");
+  });
+
+  test("empty beat times is graceful", () => {
+    const result = snapKeyframe(0.5, {
+      fps: 30,
+      keyframeTimes: [],
+      beatTimes: [],
+      threshold: 0.05,
+    });
+    expect(result.snapType).toBe("frame");
+  });
+});
+
+describe("computeSnapThreshold", () => {
+  test("returns threshold based on pixels per second", () => {
+    const threshold = computeSnapThreshold(100, 5);
+    expect(threshold).toBe(0.05);
+  });
+
+  test("fallback for zero pixels per second", () => {
+    expect(computeSnapThreshold(0)).toBe(0.1);
+  });
+});
diff --git a/packages/studio/src/utils/keyframeSnapping.ts b/packages/studio/src/utils/keyframeSnapping.ts
new file mode 100644
index 000000000..daa743e41
--- /dev/null
+++ b/packages/studio/src/utils/keyframeSnapping.ts
@@ -0,0 +1,63 @@
+export type SnapType = "frame" | "keyframe" | "beat" | null;
+
+export interface SnapResult {
+  snappedTime: number;
+  snapType: SnapType;
+}
+
+export function snapKeyframe(
+  time: number,
+  options: {
+    fps: number;
+    keyframeTimes: number[];
+    beatTimes?: number[];
+    threshold: number;
+    disabled?: boolean;
+  },
+): SnapResult {
+  if (options.disabled) return { snappedTime: time, snapType: null };
+
+  const { fps, keyframeTimes, beatTimes = [], threshold } = options;
+
+  let bestDist = threshold;
+  let bestTime = time;
+  let bestType: SnapType = null;
+
+  // Priority: cross-element keyframes > beat markers > frame boundaries
+  // Higher priority snaps use strict < so they win on equal distance
+  if (fps > 0) {
+    const frameDuration = 1 / fps;
+    const nearestFrame = Math.round(time / frameDuration) * frameDuration;
+    const dist = Math.abs(time - nearestFrame);
+    if (dist < bestDist) {
+      bestDist = dist;
+      bestTime = nearestFrame;
+      bestType = "frame";
+    }
+  }
+
+  for (const bt of beatTimes) {
+    const dist = Math.abs(time - bt);
+    if (dist <= bestDist) {
+      bestDist = dist;
+      bestTime = bt;
+      bestType = "beat";
+    }
+  }
+
+  for (const kt of keyframeTimes) {
+    const dist = Math.abs(time - kt);
+    if (dist <= bestDist) {
+      bestDist = dist;
+      bestTime = kt;
+      bestType = "keyframe";
+    }
+  }
+
+  return { snappedTime: bestTime, snapType: bestType };
+}
+
+export function computeSnapThreshold(pixelsPerSecond: number, baseThresholdPx: number = 5): number {
+  if (pixelsPerSecond <= 0) return 0.1;
+  return baseThresholdPx / pixelsPerSecond;
+}
diff --git a/packages/studio/tailwind.config.js b/packages/studio/tailwind.config.js
index ecdc87de4..3c9488b5e 100644
--- a/packages/studio/tailwind.config.js
+++ b/packages/studio/tailwind.config.js
@@ -17,6 +17,21 @@ export default {
           muted: "#737373",
           accent: "#3CE6AC",
         },
+        panel: {
+          bg: "#0C0C0E",
+          input: "#161618",
+          surface: "#18181B",
+          hover: "#27272A",
+          border: "#1E1E1E",
+          "border-input": "#27272A",
+          "text-1": "#E4E4E7",
+          "text-2": "#A1A1AA",
+          "text-3": "#71717A",
+          "text-4": "#52525B",
+          "text-5": "#3F3F46",
+          accent: "#3CE6AC",
+          danger: "#EF4444",
+        },
       },
     },
   },
diff --git a/packages/studio/vite.config.ts b/packages/studio/vite.config.ts
index fd213fd6f..a5e661549 100644
--- a/packages/studio/vite.config.ts
+++ b/packages/studio/vite.config.ts
@@ -192,4 +192,7 @@ export default defineConfig({
     // "Dynamic require of fs is not supported". Browser bundles never reach them.
     external: ["recast", "@babel/parser", "ast-types"],
   },
+  test: {
+    exclude: ["data/**", "node_modules/**"],
+  },
 });