Function handleSetTiming

packages/sdk/src/engine/mutate.ts:401–562

(
  parsed: ParsedDocument,
  ids: HfId[],
  timing: { start?: number; duration?: number; trackIndex?: number },
)

// fallow-ignore-next-line complexity
function handleSetTiming(
  parsed: ParsedDocument,
  ids: HfId[],
  timing: { start?: number; duration?: number; trackIndex?: number },
): MutationResult {
  const result: MutationResult = { forward: [], inverse: [] };

  // Parse GSAP script once; updateAnimationInScript re-parses internally per call but
  // we avoid re-fetching the script element on every iteration.
  const origScript = getGsapScript(parsed.document);
  const parsedGsap = origScript ? parseGsapScriptAcornForWrite(origScript) : null;
  let currentScript = origScript;

  for (const id of ids) {
    const el = resolveScoped(parsed.document, id);
    if (!el) continue;

    const oldStartStr = el.getAttribute("data-start");
    const oldEndStr = el.getAttribute("data-end");
    const oldDurationStr = el.getAttribute("data-duration");
    const oldTrackStr = el.getAttribute("data-track-index");

    const oldStart = oldStartStr !== null ? parseFloat(oldStartStr) : null;
    const oldEnd = oldEndStr !== null ? parseFloat(oldEndStr) : null;
    const oldDurationAttr = oldDurationStr !== null ? parseFloat(oldDurationStr) : null;
    // Prefer an explicit data-duration — the attribute clips are authored with and
    // the runtime reads — falling back to data-end − data-start. Reading only
    // data-end left oldDuration null for duration-authored clips, collapsing the
    // GSAP duration-scale ratio to 1 and scaling nothing.
    const oldDuration =
      oldDurationAttr !== null
        ? oldDurationAttr
        : oldStart !== null && oldEnd !== null
          ? oldEnd - oldStart
          : null;
    const oldTrack = oldTrackStr !== null ? parseInt(oldTrackStr, 10) : null;

    const newStart = timing.start ?? oldStart;
    const newDuration = timing.duration ?? oldDuration;

    if (timing.start !== undefined && newStart !== null) {
      const path = timingPath(id, "start");
      const p = scalarChange(path, oldStart, newStart);
      result.forward.push(p.forward);
      result.inverse.push(p.inverse);
      el.setAttribute("data-start", String(newStart));
    }

    // Write to whichever timing attribute the clip actually uses. A data-duration
    // clip updates data-duration only on a real resize (duration is invariant
    // under a move); a data-end clip updates data-end whenever start or duration
    // changes (end = start + duration). Writing a fresh data-end beside a stale
    // data-duration had no playback effect.
    if (oldDurationStr !== null) {
      if (timing.duration !== undefined && newDuration !== null) {
        const path = timingPath(id, "duration");
        const p = scalarChange(path, oldDurationAttr, newDuration);
        result.forward.push(p.forward);