fix(parsers): keep the hold for label-placed tweens and re-sync one-line scripts stably

The recast parser leaves a label start unresolved; an unknown start no longer counts as earlier,
so the hold stays. The acorn insert now ends the hold on its own line when the next statement
shares the timeline line, matching what removal takes, so a second sync changes no bytes.

Author: miguel-heygen

packages/parsers/src/gsapConstants.ts

@@ -109,9 +109,9 @@ export function classifyTweenPropertyGroup(
   return undefined;
 }
 
-function animationStart(animation: GsapAnimation): number {
+function knownStart(animation: GsapAnimation): number | undefined {
   if (animation.resolvedStart !== undefined) return animation.resolvedStart;
-  return typeof animation.position === "number" ? animation.position : 0;
+  return typeof animation.position === "number" ? animation.position : undefined;
 }
 
 /**
@@ -124,19 +124,23 @@ export function positionHoldForAnimation(
   animations: readonly GsapAnimation[],
 ): Record<string, number> | null {
   if (!animation.keyframes) return null;
-  const start = animationStart(animation);
+  const start = knownStart(animation) ?? 0;
   if (!(start > 0.001)) return null;
   const first = [...animation.keyframes.keyframes].sort(
     (left, right) => left.percentage - right.percentage,
   )[0];
   if (!first) return null;
-  const earlier = animations.filter(
-    (other) =>
+  // A tween whose start the parser could not resolve (a label, say) is not known to come first.
+  const earlier = animations.filter((other) => {
+    const otherStart = knownStart(other);
+    return (
       other !== animation &&
       !other.global &&
       other.targetSelector === animation.targetSelector &&
-      animationStart(other) < start - 0.001,
-  );
+      otherStart !== undefined &&
+      otherStart < start - 0.001
+    );
+  });
   const position: Record<string, number> = {};
   for (const [property, value] of Object.entries(first.properties)) {
     if (classifyPropertyGroup(property) !== "position" || typeof value !== "number") continue;

packages/parsers/src/gsapParser.test.ts

@@ -1827,6 +1827,26 @@ describe("keyframe mutations", () => {
       expect(hold!.properties).toEqual({ x: -50, data: "hf-hold" });
     });
 
+    it.each([
+      ["recast", syncPositionHoldsBeforeKeyframes],
+      ["acorn", syncPositionHoldsBeforeKeyframesAcorn],
+    ])("%s: still holds when the other tween sits at a label after the keyframes", (_, sync) => {
+      const script =
+        `const tl = gsap.timeline({ paused: true });\n` +
+        `tl.addLabel("later", 5);\n` +
+        `tl.to("#t", { x: 20, duration: 1 }, "later");\n` +
+        `tl.to("#t", { keyframes: { "0%": { x: -50 }, "100%": { x: 60 } }, duration: 1 }, 2);`;
+      const hold = parseGsapScript(sync(script)).animations.find((a) => a.method === "set");
+      expect(hold!.properties).toEqual({ x: -50, data: "hf-hold" });
+    });
+
+    it("acorn: a re-sync of a one-line script is byte-stable", () => {
+      const once = syncPositionHoldsBeforeKeyframesAcorn(
+        `const tl = gsap.timeline({ paused: true });tl.to("#t", { keyframes: { "0%": { x: -50 }, "100%": { x: 60 } }, duration: 1 }, 2);`,
+      );
+      expect(syncPositionHoldsBeforeKeyframesAcorn(once)).toBe(once);
+    });
+
     it("removes an orphaned hold when its tween is gone", () => {
       const withHold = syncPositionHoldsBeforeKeyframes(posTweenAt(1.2));
       const tweenId = parseGsapScript(withHold).animations.find((a) => a.keyframes)!.id;

packages/parsers/src/gsapWriterAcorn.ts

@@ -2440,7 +2440,9 @@ function insertInheritedStateSetInScript(
   const tlDecl = findTimelineDeclarationStatement(parsed.ast, parsed.timelineVar);
   const firstLocated = parsed.located[0];
   if (tlDecl) {
-    ms.appendLeft(tlDecl.end, "\n" + code);
+    // Own line both sides: a removal takes the trailing newline, so a re-sync is byte-stable.
+    const lineEnd = script[tlDecl.end] === "\n" ? "" : "\n";
+    ms.appendLeft(tlDecl.end, "\n" + code + lineEnd);
   } else if (firstLocated) {
     const firstCall = firstLocated.call;
     const exprStmt = findEnclosingExpressionStatement(firstCall.ancestors);