fix(core): gsap writer — keyframe ease routing, convert preserves delay, addLabel dedup (R3 #7/#8/#12)

- #7: updateAnimationInScript routes an ease update on a keyframe tween to
  keyframes.easeEach (per-keyframe), not a top-level ease that GSAP ignores —
  the user's keyframe-easing edit was silently a no-op.
- #8: convertToKeyframesFromScript now preserves every non-editable vars key
  (delay/callbacks/stagger/yoyo/…) verbatim via preservedVarsEntries instead of
  rebuilding from the GsapAnimation object, which had no `delay` field and
  dropped it — shifting the tween's start time.
- #12: addLabelToScript moves an existing same-named label (overwrites its
  position) instead of appending a duplicate; duplicates made removeLabel
  over-remove (it deletes every match, including a pre-existing label).

Tests: easeEach routing, delay preservation, addLabel move-not-duplicate +
hand-authored-dup removal. Updated the old "no dedup contract" corpus test.

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

Author: vanceingalls

packages/core/src/parsers/gsapWriter.reviewFixes.test.ts

@@ -15,6 +15,8 @@ import {
   updateArcSegmentInScript,
   splitAnimationsInScript,
   unrollDynamicAnimations,
+  updateAnimationInScript,
+  convertToKeyframesFromScript,
 } from "./gsapWriterAcorn.js";
 import { parseGsapScriptAcornForWrite } from "./gsapParserAcorn.js";
 
@@ -283,3 +285,33 @@ tl.to("#h", { x: -120, y: -40, duration: 1 }, 0);`;
     expect(disabled).not.toContain("motionPath");
   });
 });
+
+// ── #7 — updating ease on a keyframe tween routes to easeEach, not top-level ──
+
+describe("#7 — ease update on a keyframe tween targets keyframes.easeEach", () => {
+  const KF = `var tl = gsap.timeline({ paused: true });
+tl.to(".a", { keyframes: { "0%": { x: 0 }, "100%": { x: 100 } }, duration: 1, ease: "none" }, 0);`;
+
+  it("writes easeEach (per-keyframe), not a no-op top-level ease", () => {
+    const id = parseGsapScriptAcornForWrite(KF)?.located[0]?.id ?? "";
+    const out = updateAnimationInScript(KF, id, { ease: "power2.inOut" });
+    expect(out).toContain('easeEach: "power2.inOut"');
+    // The original top-level `ease: "none"` is untouched (no second top-level ease).
+    expect((out.match(/ease: "power2.inOut"/g) ?? []).length).toBe(0);
+  });
+});
+
+// ── #8 — convertToKeyframes preserves builtin vars like `delay` ──
+
+describe("#8 — convertToKeyframes keeps delay (was dropped, shifting start time)", () => {
+  const DELAY = `var tl = gsap.timeline({ paused: true });
+tl.to(".a", { x: 100, duration: 1, delay: 0.3 }, 0);`;
+
+  it("preserves delay on the converted vars object", () => {
+    const id = parseGsapScriptAcornForWrite(DELAY)?.located[0]?.id ?? "";
+    const out = convertToKeyframesFromScript(DELAY, id);
+    expect(out).toContain("keyframes:");
+    expect(out).toContain("delay: 0.3"); // was lost → tween started 0.3s early
+    expect(out).toContain("duration: 1");
+  });
+});

packages/core/src/parsers/gsapWriterAcorn.ts

@@ -90,6 +90,12 @@ function findPropertyNode(varsArgNode: any, key: string): any | undefined {
   return undefined;
 }
 
+/** The `keyframes` property's ObjectExpression value, or null when not a keyframe tween. */
+function keyframesObjectNode(varsNode: any): any | null {
+  const kfProp = findPropertyNode(varsNode, "keyframes");
+  return kfProp?.value?.type === "ObjectExpression" ? kfProp.value : null;
+}
+
 function findEnclosingExpressionStatement(ancestors: any[]): any | null {
   for (let i = ancestors.length - 2; i >= 0; i--) {
     if (ancestors[i]?.type === "ExpressionStatement") return ancestors[i];
@@ -315,7 +321,12 @@ export function updateAnimationInScript(
       upsertProp(ms, call.varsArg, "duration", updates.duration);
     }
     if (updates.ease !== undefined) {
-      upsertProp(ms, call.varsArg, "ease", updates.ease);
+      // For a keyframe tween, easing lives at keyframes.easeEach (per-keyframe),
+      // not a top-level ease. Writing top-level ease would leave the per-keyframe
+      // easing unchanged — the user's edit would silently do nothing.
+      const kfNode = keyframesObjectNode(call.varsArg);
+      if (kfNode) upsertProp(ms, kfNode, "easeEach", updates.ease);
+      else upsertProp(ms, call.varsArg, "ease", updates.ease);
     }
     if (updates.extras) {
       for (const [key, value] of Object.entries(updates.extras)) {
@@ -1055,18 +1066,18 @@ function buildKeyframesVarsCode(
   animation: GsapAnimation,
   fromProps: Record<string, number | string>,
   toProps: Record<string, number | string>,
+  varsNode: any,
+  source: string,
 ): string {
   const fromEntries = Object.entries(fromProps).map(([k, v]) => `${safeKey(k)}: ${valueToCode(v)}`);
   const toEntries = Object.entries(toProps).map(([k, v]) => `${safeKey(k)}: ${valueToCode(v)}`);
   const easeEntry = animation.ease ? `, easeEach: ${JSON.stringify(animation.ease)}` : "";
   const kfCode = `{ "0%": { ${fromEntries.join(", ")} }, "100%": { ${toEntries.join(", ")} }${easeEntry} }`;
-  const parts: string[] = [`keyframes: ${kfCode}`];
-  if (animation.duration !== undefined) parts.push(`duration: ${valueToCode(animation.duration)}`);
+  // Preserve every non-editable key (duration/delay/callbacks/stagger/yoyo/…)
+  // verbatim from source — rebuilding from the animation object alone dropped
+  // `delay` (not a GsapAnimation field), shifting the tween's start time.
+  const parts: string[] = [`keyframes: ${kfCode}`, ...preservedVarsEntries(varsNode, source)];
   if (animation.ease) parts.push(`ease: "none"`);
-  for (const [k, v] of Object.entries(animation.extras ?? {})) {
-    if (typeof v === "number" || typeof v === "string")
-      parts.push(`${safeKey(k)}: ${valueToCode(v)}`);
-  }
   return `{ ${parts.join(", ")} }`;
 }
 
@@ -1096,7 +1107,11 @@ export function convertToKeyframesFromScript(
   if (call.method === "fromTo" && call.fromArg) {
     ms.remove(call.fromArg.start, call.varsArg.start);
   }
-  overwriteVarsArg(ms, call, buildKeyframesVarsCode(animation, fromProps, toProps));
+  overwriteVarsArg(
+    ms,
+    call,
+    buildKeyframesVarsCode(animation, fromProps, toProps, call.varsArg, script),
+  );
 
   return ms.toString();
 }
@@ -1363,10 +1378,54 @@ export function splitIntoPropertyGroupsFromScript(
 
 // ── Label write ops ───────────────────────────────────────────────────────────
 
+/** True when `expr` is `tl.<method>(…)` rooted at the timeline var. */
+function isTimelineMethodCall(expr: any, timelineVar: string, method: string): boolean {
+  return (
+    expr?.type === "CallExpression" &&
+    expr.callee?.type === "MemberExpression" &&
+    isTimelineRooted(expr.callee.object, timelineVar) &&
+    expr.callee.property?.name === method
+  );
+}
+
+/** True when `expr` is `tl.addLabel("<name>", …)` rooted at the timeline var. */
+function isAddLabelCall(expr: any, timelineVar: string, name: string): boolean {
+  const firstArg = expr?.arguments?.[0];
+  return (
+    isTimelineMethodCall(expr, timelineVar, "addLabel") &&
+    firstArg?.type === "Literal" &&
+    firstArg.value === name
+  );
+}
+
+/** Every `tl.addLabel("<name>", …)` ExpressionStatement in the script. */
+function findLabelStatements(parsed: ParsedGsapAcornForWrite, name: string): any[] {
+  const targets: any[] = [];
+  acornWalk.simple(parsed.ast, {
+    ExpressionStatement(node: any) {
+      if (isAddLabelCall(node.expression, parsed.timelineVar, name)) targets.push(node);
+    },
+  });
+  return targets;
+}
+
 export function addLabelToScript(script: string, name: string, position: number): string {
   const parsed = parseGsapScriptAcornForWrite(script);
   if (!parsed) return script;
 
+  // If the label already exists, MOVE it (overwrite its position) rather than
+  // appending a duplicate. Two same-named addLabel statements make removeLabel
+  // over-remove — it deletes every match, including a pre-existing label the
+  // user never touched.
+  const existing = findLabelStatements(parsed, name)[0];
+  if (existing) {
+    const ms = new MagicString(script);
+    const posArg = existing.expression.arguments?.[1];
+    if (posArg) ms.overwrite(posArg.start, posArg.end, valueToCode(position));
+    else ms.appendLeft(existing.expression.end - 1, `, ${valueToCode(position)}`);
+    return ms.toString();
+  }
+
   const insertionPoint = findInsertionPoint(parsed);
   if (insertionPoint === null) return script;
 
@@ -1380,24 +1439,7 @@ export function removeLabelFromScript(script: string, name: string): string {
   const parsed = parseGsapScriptAcornForWrite(script);
   if (!parsed) return script;
 
-  const targets: any[] = [];
-  acornWalk.simple(parsed.ast, {
-    // fallow-ignore-next-line complexity
-    ExpressionStatement(node: any) {
-      const expr = node.expression;
-      if (
-        expr?.type === "CallExpression" &&
-        expr.callee?.type === "MemberExpression" &&
-        isTimelineRooted(expr.callee.object, parsed.timelineVar) &&
-        expr.callee.property?.name === "addLabel" &&
-        expr.arguments?.[0]?.type === "Literal" &&
-        expr.arguments[0].value === name
-      ) {
-        targets.push(node);
-      }
-    },
-  });
-
+  const targets = findLabelStatements(parsed, name);
   if (!targets.length) return script;
 
   const ms = new MagicString(script);

packages/core/src/parsers/gsapWriterParity.corpus.test.ts

@@ -616,17 +616,19 @@ describe("correctness — addLabelToScript / removeLabelFromScript", () => {
     expect(removeLabelFromScript(SYN_SINGLE, "nope")).toBe(SYN_SINGLE);
   });
 
-  it("adding the same label twice yields two addLabel calls (no dedup contract)", () => {
+  it("adding the same label twice MOVES it instead of duplicating (dedup contract)", () => {
+    // A second addLabel for an existing name must not append a duplicate —
+    // duplicates make removeLabel over-remove. It moves the label's position.
     const once = addLabelToScript(SYN_SINGLE, "mid", 1.0);
     const twice = addLabelToScript(once, "mid", 2.0);
-    expect(labelCallCount(twice, "mid")).toBe(2);
+    expect(labelCallCount(twice, "mid")).toBe(1);
+    expect(twice).toContain('tl.addLabel("mid", 2)');
   });
 
-  it("removeLabel deletes ALL matching addLabel calls for the name", () => {
-    const once = addLabelToScript(SYN_SINGLE, "mid", 1.0);
-    const twice = addLabelToScript(once, "mid", 2.0);
-    const cleared = removeLabelFromScript(twice, "mid");
-    expect(labelCallCount(cleared, "mid")).toBe(0);
+  it("removeLabel deletes ALL matching addLabel calls for the name (hand-authored dups)", () => {
+    const dup = `var tl = gsap.timeline({ paused: true });\ntl.addLabel("mid", 1);\ntl.addLabel("mid", 2);\nwindow.__timelines["t"] = tl;`;
+    expect(labelCallCount(dup, "mid")).toBe(2);
+    expect(labelCallCount(removeLabelFromScript(dup, "mid"), "mid")).toBe(0);
   });
 
   it("the added label is observable by the parser when a tween references it", () => {