@hyperframes/studio 0.7.7 → 0.7.8

package/src/hooks/gsapRuntimePatch.ts

@@ -13,13 +13,22 @@
  * "Which tween" is resolved by the same all-timelines scan `readRuntimeKeyframes`
  * uses (`resolveRuntimeTween`), so read and write agree on the target.
  */
-import { resolveRuntimeTween, type RuntimeTween } from "./gsapRuntimeKeyframes";
+import {
+  resolveRuntimeTween,
+  type RuntimeTween,
+  type RuntimeTimeline,
+} from "./gsapRuntimeKeyframes";
 
 /** Value-only channels a `tl.set(...)` patch may touch. */
 export interface SetPatchProps {
   x?: number;
   y?: number;
   rotation?: number;
+  rotationX?: number;
+  rotationY?: number;
+  rotationZ?: number;
+  z?: number;
+  transformPerspective?: number;
   scaleX?: number;
   scaleY?: number;
   scale?: number;
@@ -31,12 +40,28 @@ export type KeyframeStep = Record<string, number>;
 
 export type RuntimeTweenChange =
   | { kind: "set"; props: SetPatchProps }
-  | { kind: "keyframes"; keyframes: KeyframeStep[] };
+  | { kind: "keyframes"; keyframes: KeyframeStep[] }
+  // Edit ONE step (at `pct`) of an object-form keyframe tween — the form the studio
+  // writes (`keyframes: { "0%": {...} }`). GSAP pre-compiles those into sub-tweens
+  // and won't re-read `vars.keyframes` on `invalidate()`, so this REBUILDS the tween
+  // (kill + recreate at the same position) instead of mutating it. Lets a design-panel
+  // keyframe edit show instantly rather than soft-reloading the iframe (a flash).
+  | { kind: "keyframe-rebuild"; pct: number; props: KeyframeStep }
+  // Apply a base `gsap.set` value to the element directly (`gsap.set(el, props)`).
+  // A base set lives OFF the timeline, so there's no runtime tween to patch — but
+  // the element is static on these channels, so setting them immediately reflects
+  // the edit with no soft reload (no flash) and leaves no keyframe marker.
+  | { kind: "global-set"; props: SetPatchProps };
 
 const SET_CHANNELS: Array<keyof SetPatchProps> = [
   "x",
   "y",
   "rotation",
+  "rotationX",
+  "rotationY",
+  "rotationZ",
+  "z",
+  "transformPerspective",
   "scaleX",
   "scaleY",
   "scale",
@@ -45,8 +70,42 @@ const SET_CHANNELS: Array<keyof SetPatchProps> = [
 
 type IframeWindow = Window & {
   __player?: { getTime?: () => number; seek?: (t: number) => void };
+  gsap?: { set?: (target: Element, vars: Record<string, number>) => void };
 };
 
+/**
+ * Apply a base `gsap.set` value to the element in the live runtime. Returns `true`
+ * if applied. Used for off-timeline static holds (position / 3D transform) — there's
+ * no tween to patch, so we set the channels directly. Safe because the element is
+ * static on these channels (the caller only uses this for non-animated values).
+ */
+/** The props as finite numbers, or null if any value is non-finite / none present. */
+function finiteNumericProps(props: SetPatchProps): Record<string, number> | null {
+  const numeric: Record<string, number> = {};
+  for (const [k, v] of Object.entries(props)) {
+    if (typeof v !== "number" || !Number.isFinite(v)) return null;
+    numeric[k] = v;
+  }
+  return Object.keys(numeric).length > 0 ? numeric : null;
+}
+
+function applyGlobalSet(
+  iframe: HTMLIFrameElement,
+  selector: string,
+  props: SetPatchProps,
+): boolean {
+  try {
+    const gsapLib = (iframe.contentWindow as IframeWindow | null)?.gsap;
+    const el = iframe.contentDocument?.querySelector(selector) ?? null;
+    const numeric = finiteNumericProps(props);
+    if (!gsapLib?.set || !el || !numeric) return false;
+    gsapLib.set(el, numeric);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
 function playerOf(iframe: HTMLIFrameElement): IframeWindow["__player"] | null {
   try {
     return (iframe.contentWindow as IframeWindow | null)?.__player ?? null;
@@ -100,10 +159,95 @@ function patchKeyframes(tween: RuntimeTween, keyframes: KeyframeStep[]): boolean
   return true;
 }
 
+/** The object-form keyframes map with `props` merged into the step at `pct`. */
+function mergeKeyframeStep(
+  map: Record<string, Record<string, number>>,
+  pct: number,
+  props: KeyframeStep,
+): Record<string, Record<string, number>> {
+  const next: Record<string, Record<string, number>> = {};
+  for (const [k, step] of Object.entries(map)) next[k] = { ...step };
+  // Match the existing percentage key numerically ("50%" ≡ pct 50), else add one.
+  let key: string | null = null;
+  for (const k of Object.keys(next)) {
+    const n = parseFloat(k);
+    if (Number.isFinite(n) && Math.abs(n - pct) < 0.05) {
+      key = k;
+      break;
+    }
+  }
+  if (key === null) key = `${pct}%`;
+  next[key] = { ...(next[key] ?? {}), ...props };
+  return next;
+}
+
+/**
+ * Rebuild an object-form keyframe tween with `props` merged into the step at `pct`,
+ * in place: kill the old tween and recreate it on the SAME parent timeline at the
+ * SAME position, with all other vars (duration, ease, repeat, …) preserved. This
+ * is the only way to reflect an object-form keyframe edit live — GSAP compiles
+ * those keyframes into sub-tweens at creation and ignores later `vars.keyframes`
+ * mutations. Declines (→ caller soft-reloads) for array-form, motionPath arcs,
+ * non-finite/dynamic values, or a tween whose parent/targets can't be resolved.
+ */
+// fallow-ignore-next-line complexity
+function rebuildKeyframeTween(tween: RuntimeTween, pct: number, props: KeyframeStep): boolean {
+  const vars = tween.vars;
+  if (!vars || "motionPath" in vars) return false;
+  const kf = vars.keyframes;
+  if (!kf || typeof kf !== "object" || Array.isArray(kf)) return false;
+  for (const v of Object.values(props)) {
+    if (typeof v !== "number" || !Number.isFinite(v)) return false;
+  }
+  const parent = tween.parent;
+  const targets = tween.targets?.();
+  if (!parent?.to || !targets || targets.length === 0) return false;
+  if (typeof tween.startTime !== "function" || typeof tween.kill !== "function") return false;
+
+  const next = mergeKeyframeStep(kf as Record<string, Record<string, number>>, pct, props);
+  const newVars = { ...vars, keyframes: next };
+  const position = tween.startTime();
+  tween.kill();
+  parent.to(targets, newVars, position);
+  return true;
+}
+
+/** The channels a change writes, for the resolver to disambiguate co-located tweens. */
+function changeChannels(change: RuntimeTweenChange): string[] | undefined {
+  if (change.kind === "set") {
+    return Object.keys(change.props).filter(
+      (k) => change.props[k as keyof SetPatchProps] !== undefined,
+    );
+  }
+  if (change.kind === "keyframe-rebuild") return Object.keys(change.props);
+  return undefined;
+}
+
+/** Re-render the timeline at the current playhead after an in-place edit. */
+function seekToCurrent(iframe: HTMLIFrameElement, timeline: RuntimeTimeline): void {
+  const player = playerOf(iframe);
+  const currentTime =
+    typeof player?.getTime === "function"
+      ? player.getTime()
+      : typeof timeline.time === "function"
+        ? timeline.time()
+        : 0;
+  player?.seek?.(Number.isFinite(currentTime) ? currentTime : 0);
+}
+
+/** Apply `change` to the resolved tween. `true` if applied, `false` to soft-reload.
+ *  `global-set` is handled before this (no tween) and never reaches here. */
+function applyChange(tween: RuntimeTween, change: RuntimeTweenChange): boolean {
+  if (change.kind === "set") return patchSet(tween, change.props);
+  if (change.kind === "keyframes") return patchKeyframes(tween, change.keyframes);
+  if (change.kind === "keyframe-rebuild")
+    return rebuildKeyframeTween(tween, change.pct, change.props);
+  return false;
+}
+
 /**
- * Update one tween's values in `window.__timelines` in place + re-seek to the
- * current playhead. Returns `true` on a confident patch, `false` otherwise
- * (caller falls back to a soft reload).
+ * Edit one tween in `window.__timelines` in place + re-seek to the current playhead.
+ * Returns `true` on a confident patch, `false` otherwise (caller soft-reloads).
  */
 export function patchRuntimeTweenInPlace(
   iframe: HTMLIFrameElement | null,
@@ -112,46 +256,29 @@ export function patchRuntimeTweenInPlace(
   compositionId?: string,
 ): boolean {
   if (!iframe) return false;
+  // A base `gsap.set` has no timeline tween to resolve — apply the value straight
+  // to the element so the edit shows instantly (no soft reload, no flash).
+  if (change.kind === "global-set") return applyGlobalSet(iframe, selector, change.props);
   try {
-    // For a `set` patch, hand the resolver the channels actually being written so
-    // it picks the set whose vars carry them — an element can have separate
-    // {x,y} and {rotation} sets, and a position patch must not corrupt the
-    // rotation set (channel-blind resolution would return the first match).
-    const channels =
-      change.kind === "set"
-        ? Object.keys(change.props).filter(
-            (k) => change.props[k as keyof SetPatchProps] !== undefined,
-          )
-        : undefined;
     const resolved = resolveRuntimeTween(
       iframe,
       selector,
       change.kind === "set" ? "set" : "keyframe",
       compositionId,
-      channels,
+      changeChannels(change),
     );
     if (!resolved) return false;
     const { tween, timeline } = resolved;
 
-    const applied =
-      change.kind === "set"
-        ? patchSet(tween, change.props)
-        : patchKeyframes(tween, change.keyframes);
-    if (!applied) return false;
-
-    // Recompute the tween (and its timeline) from the new vars, then re-render at
-    // the current playhead. `invalidate()` makes GSAP re-read vars on the next render.
-    tween.invalidate?.();
-    timeline.invalidate?.();
-
-    const player = playerOf(iframe);
-    const currentTime =
-      typeof player?.getTime === "function"
-        ? player.getTime()
-        : typeof timeline.time === "function"
-          ? timeline.time()
-          : 0;
-    player?.seek?.(Number.isFinite(currentTime) ? currentTime : 0);
+    if (!applyChange(tween, change)) return false;
+
+    // A rebuild already recreated the tween; set/keyframes mutate vars in place, so
+    // invalidate to make GSAP re-read them on the next render. Either way, re-seek.
+    if (change.kind !== "keyframe-rebuild") {
+      tween.invalidate?.();
+      timeline.invalidate?.();
+    }
+    seekToCurrent(iframe, timeline);
     return true;
   } catch {
     return false;

package/src/hooks/useAnimatedPropertyCommit.ts

@@ -1,10 +1,11 @@
 /**
  * Unified helper for committing any GSAP property value from the design panel.
  *
- * Handles three cases:
- * 1. Animation with keyframes → add-keyframe at current percentage
- * 2. Flat animation (no keyframes) → convert to keyframes, then add-keyframe
- * 3. No animation → create tl.to(), convert to keyframes, then add-keyframe
+ * Routing depends on whether the element is animated (has keyframes on any tween):
+ * - Animated → write the value into a keyframe at the current playhead (convert a
+ *   flat tween first if needed). An existing static `set` auto-converts to keyframes.
+ * - Static (no keyframes anywhere) → persist as a `tl.set`, NEVER keyframes — same
+ *   as manual drag / resize / rotate. Updates an existing set or creates one.
  */
 import { useCallback } from "react";
 import type { GsapAnimation } from "@hyperframes/core/gsap-parser";
@@ -12,6 +13,7 @@ import { classifyPropertyGroup } from "@hyperframes/core/gsap-parser";
 import type { DomEditSelection } from "../components/editor/domEditingTypes";
 import { usePlayerStore } from "../player/store/playerStore";
 import { readAllAnimatedProperties, readGsapProperty } from "./gsapRuntimeBridge";
+import type { SetPatchProps } from "./gsapRuntimePatch";
 import { selectorFromSelection, computeElementPercentage } from "./gsapShared";
 
 interface CommitAnimatedPropertyDeps {
@@ -47,6 +49,7 @@ function pickBestAnimation(
   const currentTime = usePlayerStore.getState().currentTime;
   const targetGroup = property ? classifyPropertyGroup(property) : undefined;
 
+  // fallow-ignore-next-line complexity
   const scored = animations.map((a) => {
     let score = 0;
     if (targetGroup && a.propertyGroup === targetGroup) score += 20;
@@ -62,96 +65,271 @@ function pickBestAnimation(
   return scored[0]?.anim;
 }
 
+/**
+ * Auto-keyframe a just-updated static `set`: if the element is already animated
+ * (its clip carries keyframes on another tween), convert the set to keyframes so
+ * subsequent edits at other playheads interpolate — matching the drag / resize /
+ * rotate UX. Purely static elements (no other keyframes) are left as a set.
+ */
+async function maybeAutoKeyframeSet(
+  selection: DomEditSelection,
+  setAnim: GsapAnimation,
+  animations: GsapAnimation[],
+  commit: NonNullable<CommitAnimatedPropertyDeps["gsapCommitMutation"]>,
+): Promise<void> {
+  const animatedTween = animations.find((a) => a.keyframes && a.id !== setAnim.id);
+  if (!animatedTween) return;
+  await commit(
+    selection,
+    {
+      type: "convert-to-keyframes",
+      animationId: setAnim.id,
+      duration: animatedTween.duration ?? 1,
+    },
+    { label: "Keyframe 3D transform", softReload: true },
+  );
+}
+
+type Commit = NonNullable<CommitAnimatedPropertyDeps["gsapCommitMutation"]>;
+
+/** Merge ALL props into the static `set` in ONE commit (value-only, instant), then
+ *  auto-keyframe. One mutation — a per-property loop would shift the set's
+ *  group-derived id mid-way (e.g. reset adding `scale` to a rotation set), 404-ing
+ *  the next update. */
+async function commitSetProps(
+  selection: DomEditSelection,
+  setAnim: GsapAnimation,
+  propEntries: [string, number | string][],
+  selector: string | null,
+  animations: GsapAnimation[],
+  commit: Commit,
+): Promise<void> {
+  const properties = Object.fromEntries(propEntries);
+  const numericProps: SetPatchProps = {};
+  for (const [k, v] of propEntries) {
+    if (typeof v === "number") numericProps[k as keyof SetPatchProps] = v;
+  }
+  const instantPatch =
+    selector && Object.keys(numericProps).length > 0
+      ? {
+          selector,
+          change: {
+            kind: (setAnim.global ? "global-set" : "set") as "set" | "global-set",
+            props: numericProps,
+          },
+        }
+      : undefined;
+  await commit(
+    selection,
+    { type: "update-properties", animationId: setAnim.id, properties },
+    { label: "Set 3D transform", softReload: true, ...(instantPatch ? { instantPatch } : {}) },
+  );
+  await maybeAutoKeyframeSet(selection, setAnim, animations, commit);
+}
+
+/**
+ * Static element (no keyframes on ANY of its tweens): persist the 3D props as a
+ * `tl.set` — NEVER keyframes. Mirrors manual drag / resize / rotate, which `tl.set`
+ * a static element instead of animating it. Updates an existing `set` in place, or
+ * creates a dedicated `set` at position 0 when the element has none.
+ */
+async function commitStaticSet(
+  selection: DomEditSelection,
+  propEntries: [string, number | string][],
+  selector: string | null,
+  animations: GsapAnimation[],
+  commit: Commit,
+): Promise<void> {
+  if (!selector) return;
+  // Update an existing `set` in ONE batched commit — NEVER a flat `to`/`from`. A
+  // set's id is GROUP-derived, so a per-prop loop shifts it the instant a new-group
+  // prop lands (e.g. `scale` onto a rotation set), 404-ing the next prop; commitSetProps
+  // sends them together. A static element with no set gets a dedicated `set` carrying
+  // ALL props in ONE `add`.
+  const existingSet = animations.find((a) => a.method === "set" && a.targetSelector === selector);
+  if (existingSet) {
+    await commitSetProps(selection, existingSet, propEntries, selector, animations, commit);
+    return;
+  }
+  // Base `gsap.set` (off-timeline) — a static hold with no 0% keyframe marker, so
+  // adjusting a 3D transform on a non-keyframed element doesn't drop a keyframe on
+  // the timeline (matches the manual-drag UX). The global-set instant patch applies
+  // it straight to the element so the first edit shows with no soft-reload flash.
+  const numericProps: SetPatchProps = {};
+  for (const [k, v] of propEntries) {
+    if (typeof v === "number") numericProps[k as keyof SetPatchProps] = v;
+  }
+  await commit(
+    selection,
+    {
+      type: "add",
+      targetSelector: selector,
+      method: "set",
+      position: 0,
+      properties: Object.fromEntries(propEntries),
+      global: true,
+    },
+    {
+      label: "Set 3D transform",
+      softReload: true,
+      ...(Object.keys(numericProps).length > 0
+        ? {
+            instantPatch: {
+              selector,
+              change: { kind: "global-set" as const, props: numericProps },
+            },
+          }
+        : {}),
+    },
+  );
+}
+
+/** Convert-if-flat, then write ALL props into ONE keyframe at the playhead. */
+// fallow-ignore-next-line complexity
+async function commitKeyframeProps(
+  selection: DomEditSelection,
+  anim: GsapAnimation,
+  props: Record<string, number | string>,
+  propEntries: [string, number | string][],
+  primaryProp: string,
+  selector: string | null,
+  iframe: HTMLIFrameElement | null,
+  commit: Commit,
+): Promise<void> {
+  if (!anim.keyframes) {
+    await commit(
+      selection,
+      { type: "convert-to-keyframes", animationId: anim.id },
+      { label: "Convert to keyframes", skipReload: true },
+    );
+  }
+  const pct = computeElementPercentage(usePlayerStore.getState().currentTime, selection, anim);
+  const runtimeProps = selector ? readAllAnimatedProperties(iframe, selector, anim) : {};
+  const properties: Record<string, number | string> = { ...runtimeProps, ...props };
+
+  const backfillDefaults: Record<string, number | string> = { ...runtimeProps };
+  for (const [property, value] of propEntries) {
+    if (!(property in runtimeProps) && selector) {
+      const cssVal = readGsapProperty(iframe, selector, property);
+      if (cssVal != null) backfillDefaults[property] = cssVal;
+    }
+    backfillDefaults[property] = value;
+  }
+
+  const existingKf = anim.keyframes?.keyframes.some((kf) => Math.abs(kf.percentage - pct) < 0.05);
+  // Rebuild the live keyframe tween in place so the edit shows instantly (no flash);
+  // rebuildKeyframeTween declines → soft reload if the tween can't be safely rebuilt.
+  const numericProps: Record<string, number> = {};
+  for (const [k, v] of Object.entries(properties)) {
+    if (typeof v === "number") numericProps[k] = v;
+  }
+  const instantPatch =
+    selector && Object.keys(numericProps).length > 0
+      ? { selector, change: { kind: "keyframe-rebuild" as const, pct, props: numericProps } }
+      : undefined;
+  await commit(
+    selection,
+    existingKf
+      ? { type: "update-keyframe", animationId: anim.id, percentage: pct, properties }
+      : {
+          type: "add-keyframe",
+          animationId: anim.id,
+          percentage: pct,
+          properties,
+          backfillDefaults,
+        },
+    {
+      label: `Edit ${primaryProp} (keyframe ${pct}%)`,
+      softReload: true,
+      ...(instantPatch ? { instantPatch } : {}),
+    },
+  );
+}
+
 export function useAnimatedPropertyCommit(deps: CommitAnimatedPropertyDeps) {
-  const {
-    selectedGsapAnimations,
-    gsapCommitMutation,
-    addGsapAnimation,
-    previewIframeRef,
-    bumpGsapCache,
-  } = deps;
+  const { selectedGsapAnimations, gsapCommitMutation, previewIframeRef, bumpGsapCache } = deps;
 
-  const commitAnimatedProperty = useCallback(
-    async (
-      selection: DomEditSelection,
-      property: string,
-      value: number | string,
-    ): Promise<void> => {
+  const commitAnimatedProperties = useCallback(
+    async (selection: DomEditSelection, props: Record<string, number | string>): Promise<void> => {
       if (!gsapCommitMutation) return;
+      const propEntries = Object.entries(props);
+      if (propEntries.length === 0) return;
+      const primaryProp = propEntries[0]![0];
 
       const iframe = previewIframeRef.current;
       const selector = selectorFromSelection(selection);
 
-      let anim: GsapAnimation | undefined = pickBestAnimation(
+      const anim: GsapAnimation | undefined = pickBestAnimation(
         selectedGsapAnimations,
         selector,
-        property,
+        primaryProp,
       );
+      // Whether the element is animated at all. A 3D edit only creates/edits
+      // keyframes when it IS — a static element (no keyframes on any of its tweens)
+      // gets a `tl.set`, never new keyframes (matches manual drag / resize / rotate).
+      const elementHasKeyframes = selectedGsapAnimations.some((a) => !!a.keyframes);
 
-      // Case 3: No animation — create one first
-      if (!anim) {
-        addGsapAnimation(selection, "to");
-        // The addGsapAnimation triggers a reload. We need to wait for the cache
-        // to update. Use a small delay then bump cache to re-fetch.
-        await new Promise((r) => setTimeout(r, 500));
-        bumpGsapCache();
-        // After creation, we can't proceed in this call — the animation isn't
-        // in our local state yet. The user's next edit will find it.
-        // For immediate feedback, trigger a convert-to-keyframes on the new animation.
-        return;
-      }
+      // The picked anim comes from the (possibly stale) panel cache: if keyframes
+      // were just removed or the script changed underneath us, its id is gone
+      // server-side and the commit 404s. The raw commit already toasts; we catch
+      // so the rejection doesn't escape as an uncaught promise, and bump the cache
+      // so selectedGsapAnimations re-syncs and the user's next edit self-heals.
+      try {
+        // Existing static hold — merge the props into the `set`, then auto-keyframe
+        // ONLY if the element is already animated (maybeAutoKeyframeSet no-ops if not).
+        if (anim?.method === "set") {
+          await commitSetProps(
+            selection,
+            anim,
+            propEntries,
+            selector,
+            selectedGsapAnimations,
+            gsapCommitMutation,
+          );
+          return;
+        }
 
-      // Case 2: Flat animation — convert to keyframes first
-      if (!anim.keyframes) {
-        await gsapCommitMutation(
+        // Static element — persist as a `tl.set`, never keyframes (incl. the
+        // no-animation case, which now creates a set instead of a keyframed tween).
+        if (!elementHasKeyframes) {
+          await commitStaticSet(
+            selection,
+            propEntries,
+            selector,
+            selectedGsapAnimations,
+            gsapCommitMutation,
+          );
+          return;
+        }
+
+        // Animated element — write ALL props into ONE keyframe so a multi-axis cube
+        // edit doesn't race into adjacent duplicates.
+        if (!anim) {
+          bumpGsapCache();
+          return;
+        }
+        await commitKeyframeProps(
           selection,
-          { type: "convert-to-keyframes", animationId: anim.id },
-          { label: "Convert to keyframes", skipReload: true },
+          anim,
+          props,
+          propEntries,
+          primaryProp,
+          selector,
+          iframe,
+          gsapCommitMutation,
         );
+      } catch {
+        bumpGsapCache();
       }
-
-      const pct = computeElementPercentage(usePlayerStore.getState().currentTime, selection, anim);
-
-      // Read all currently animated properties from runtime for backfill
-      const runtimeProps = selector ? readAllAnimatedProperties(iframe, selector, anim) : {};
-
-      // Build the properties object: all runtime props + the new value
-      const properties: Record<string, number | string> = { ...runtimeProps };
-      properties[property] = value;
-
-      // Compute backfill defaults for properties not in existing keyframes
-      const backfillDefaults: Record<string, number | string> = { ...runtimeProps };
-      if (!(property in runtimeProps) && selector) {
-        const cssVal = readGsapProperty(iframe, selector, property);
-        if (cssVal != null) backfillDefaults[property] = cssVal;
-      }
-      backfillDefaults[property] = typeof value === "number" ? value : value;
-
-      const existingKf = anim.keyframes?.keyframes.some(
-        (kf) => Math.abs(kf.percentage - pct) < 0.05,
-      );
-
-      await gsapCommitMutation(
-        selection,
-        existingKf
-          ? {
-              type: "update-keyframe",
-              animationId: anim.id,
-              percentage: pct,
-              properties,
-            }
-          : {
-              type: "add-keyframe",
-              animationId: anim.id,
-              percentage: pct,
-              properties,
-              backfillDefaults,
-            },
-        { label: `Edit ${property} (keyframe ${pct}%)`, softReload: true },
-      );
     },
-    [selectedGsapAnimations, gsapCommitMutation, addGsapAnimation, previewIframeRef, bumpGsapCache],
+    [selectedGsapAnimations, gsapCommitMutation, previewIframeRef, bumpGsapCache],
+  );
+
+  const commitAnimatedProperty = useCallback(
+    (selection: DomEditSelection, property: string, value: number | string) =>
+      commitAnimatedProperties(selection, { [property]: value }),
+    [commitAnimatedProperties],
   );
 
-  return commitAnimatedProperty;
+  return { commitAnimatedProperty, commitAnimatedProperties };
 }

package/src/hooks/useDomEditCommits.ts

@@ -301,7 +301,6 @@ export function useDomEditCommits({
 
   const {
     handleDomPathOffsetCommit,
-    handleDomGroupPathOffsetCommit,
     handleDomBoxSizeCommit,
     handleDomRotationCommit,
     handleDomManualEditsReset,
@@ -340,7 +339,6 @@ export function useDomEditCommits({
     handleDomAddTextField,
     handleDomRemoveTextField,
     handleDomPathOffsetCommit,
-    handleDomGroupPathOffsetCommit,
     handleDomBoxSizeCommit,
     handleDomRotationCommit,
     handleDomManualEditsReset,

package/src/hooks/useDomEditSession.ts

@@ -215,7 +215,6 @@ export function useDomEditSession({
     handleDomTextFieldStyleCommit,
     handleDomAddTextField,
     handleDomRemoveTextField,
-    handleDomGroupPathOffsetCommit,
     handleDomBoxSizeCommit,
     handleDomManualEditsReset,
     handleDomEditElementDelete,
@@ -368,9 +367,11 @@ export function useDomEditSession({
 
   const {
     handleGsapAwarePathOffsetCommit,
+    handleGsapAwareGroupPathOffsetCommit,
     handleGsapAwareBoxSizeCommit,
     handleGsapAwareRotationCommit,
     commitAnimatedProperty,
+    commitAnimatedProperties,
     handleSetArcPath,
     handleUpdateArcSegment,
     handleUnroll,
@@ -452,7 +453,7 @@ export function useDomEditSession({
     handleDomAttributeLiveCommit,
     handleDomHtmlAttributeCommit,
     handleDomPathOffsetCommit: handleGsapAwarePathOffsetCommit,
-    handleDomGroupPathOffsetCommit,
+    handleDomGroupPathOffsetCommit: handleGsapAwareGroupPathOffsetCommit,
     handleDomZIndexReorderCommit,
     handleDomBoxSizeCommit: handleGsapAwareBoxSizeCommit,
     handleDomRotationCommit: handleGsapAwareRotationCommit,
@@ -498,6 +499,7 @@ export function useDomEditSession({
     handleUpdateKeyframeEase,
     handleSetAllKeyframeEases,
     commitAnimatedProperty,
+    commitAnimatedProperties,
     handleSetArcPath,
     handleUpdateArcSegment,
     handleUnroll,