@hyperframes/studio 0.8.132 → 0.8.134

package/src/player/components/timelineStackingSync.ts

@@ -1,10 +1,10 @@
 /**
  * timelineStackingSync — lane ↔ stacking unification (pure).
  *
- * The approved design: **lane order implies stacking**. A clip on a higher lane
- * (rendered ABOVE another in the timeline) should render ON TOP of any clip it
- * OVERLAPS IN TIME. But authored z-indexes are sacred: z only changes on a user
- * edit, and ONLY for the clip(s) the user actually edited.
+ * A row move restacks the moved clip only: moved up, it rises above every clip
+ * it overlaps in time on the rows now below it; moved down, it sinks below every
+ * such clip on the rows now above it. Neighbours never change, so a clip nobody
+ * moved never goes behind anything (a full-frame scene on the top row stays put).
  *
  * Lane → screen mapping (see Timeline.tsx trackOrder / TimelineCanvas rows):
  * tracks are sorted ASCENDING and rendered top → bottom, so a LOWER `track`
@@ -38,7 +38,7 @@ export interface StackingElement {
    * (e.g. an unmounted / nested sub-comp element, or one outside the active file).
    * A non-finite-z clip is EXCLUDED from the computation — it is neither a stacking
    * neighbour nor resolvable as an edit — so an unresolved node never fabricates a
-   * z=0 neighbour that poisons the boundary math (item 13). The reader signals a
+   * z=0 neighbour. The reader signals a
    * miss with NaN rather than null so the value stays assignable to the existing
    * `(el) => number` reader contract the drag hook / commit deps declare.
    */
@@ -57,10 +57,9 @@ export interface StackingElement {
   /**
    * Discovery / DOM document position (optional). Two clips with EQUAL z paint by
    * DOM order — the one LATER in the DOM paints ON TOP. When supplied, "is A above
-   * B" uses (zIndex, domIndex); without it equal-z is ambiguous and the sync can
-   * under-patch (the reported bug: a clip dragged to the bottom lane over an
-   * equal-z neighbour changed nothing on canvas). Callers pass the index of the
-   * element in the discovery order array.
+   * B" uses (zIndex, domIndex); without it equal z counts as "not above", so the
+   * move writes a z. Callers pass the index of the element in the discovery order
+   * array.
    */
   domIndex?: number;
 }
@@ -74,7 +73,7 @@ export interface StackingPatch {
 /**
  * Canonical paint-scope key: leaf z-indexes are comparable only within the same
  * source document and CSS stacking context. The ONLY place this normalization
- * lives — partitioning, membership checks, and pairwise equality all use it.
+ * lives; samePaintScope compares with it.
  */
 const paintScopeKey = (el: { sourceFile?: string; stackingContextId?: string | null }): string =>
   JSON.stringify([el.sourceFile ?? null, el.stackingContextId ?? null]);
@@ -114,21 +113,13 @@ export function laneIsAbove(
   return a.track < b.track;
 }
 
-/**
- * Working record for the cascade resolver: a live-mutable, RESOLVED (non-null) z
- * the resolver can bump, plus the immutable identity/lane/time/dom fields. Clips
- * whose z could not be resolved (null) are dropped before this stage.
- */
-interface MutZ extends StackingElement {
-  zIndex: number;
-}
+/** Which way the edited clips moved between rows. */
+export type StackingDirection = "up" | "down";
 
 /**
  * Does `a` currently paint ON TOP of `b`? Higher z wins; equal z breaks by DOM
- * order (later in DOM paints on top). When either domIndex is absent, equal z is
- * treated as "not strictly above" (ambiguous) — callers should supply domIndex to
- * disambiguate (see StackingElement.domIndex). Exported (like laneIsAbove) as the
- * ONE paint-order predicate so every consumer agrees on what "paints above" means.
+ * order (later in DOM paints on top). Without both domIndex values equal z is
+ * ambiguous and counts as "not above", so the move still writes a z.
  */
 function paintsAbove(
   a: Pick<StackingElement, "zIndex" | "domIndex">,
@@ -139,233 +130,58 @@ function paintsAbove(
   return false;
 }
 
-/** Reduce a neighbour set's z-indices to a single bound, or null when empty. */
-function boundaryZ(neighbours: MutZ[], reduce: (zs: number[]) => number): number | null {
-  return neighbours.length > 0 ? reduce(neighbours.map((o) => o.zIndex)) : null;
+/** Moved up: one above the highest clip it now sits above, or null when it already paints above them all. */
+function raisedZ(clip: StackingElement, overlapping: StackingElement[]): number | null {
+  const below = overlapping.filter((o) => laneIsAbove(clip, o));
+  if (below.every((o) => paintsAbove(clip, o))) return null;
+  return Math.max(...below.map((o) => o.zIndex)) + 1;
 }
 
-/**
- * Resolve `edited` so that, among the clips it OVERLAPS IN TIME, its paint order
- * matches its lane order (lower lane ⇒ paints on top). Records every z change
- * (edited clip AND any neighbours that must be bumped) into `patchZ`.
- *
- * Fast path (unchanged behaviour): when a single non-negative z for the edited
- * clip alone realises the order — strictly between the neighbours if there is
- * integer room, else just above the lower neighbour, else just below the upper —
- * emit only that. This keeps every existing single-patch test passing.
- *
- * Cascade path: when ties/clamping make the single-clip patch impossible or
- * ineffective (must sit below an overlapping z=0 neighbour, or between adjacent /
- * equal-z neighbours where DOM order alone can't express it), bump the minimum set
- * of overlapping neighbours that must stay ABOVE by +1 (cascading only as far as
- * needed) so the edited clip's intended lane order is realised with all z ≥ 0.
- * "Authored z sacred" stays the default — neighbours are touched only when the
- * user's explicit lane move is otherwise inexpressible (same precedent as the
- * canvas context-menu tie-aware fix).
- *
- * Returns true when any z changed (recorded in `patchZ`), false for a no-op.
- */
-function resolveEditedZ(
-  edited: MutZ,
-  overlapping: MutZ[],
-  overlappersOf: (clip: MutZ) => MutZ[],
-  patchZ: (clip: MutZ, z: number) => void,
-): boolean {
-  const visualOverlap = overlapping.filter((o) => !o.isAudio);
-  if (visualOverlap.length === 0) return false;
-
-  // Neighbours that must end up BELOW edited (lower lane) vs ABOVE (higher lane).
-  const below = visualOverlap.filter((o) => laneIsAbove(edited, o));
-  const above = visualOverlap.filter((o) => laneIsAbove(o, edited));
-
-  // Already correct against every overlapping neighbour → no-op (authored z kept).
-  const correct =
-    below.every((o) => paintsAbove(edited, o)) && above.every((o) => paintsAbove(o, edited));
-  if (correct) return false;
-
-  const maxBelow = boundaryZ(below, (zs) => Math.max(...zs));
-
-  // ── Fast path: try to realise the order by moving only `edited`. ──────────────
-  const single = trySingleZ(edited, below, above);
-  if (single != null) {
-    if (single !== edited.zIndex) patchZ(edited, single);
-    // Even at an unchanged z the DOM-order ties may already be satisfied; if not,
-    // `trySingleZ` returned null and we fall through to the cascade.
-    return single !== edited.zIndex;
-  }
-
-  // ── Cascade path: can't fit `edited` between the neighbours with one z ≥ 0. ───
-  // Sit edited at maxBelow+1 (or 0 when it only has above-neighbours) and lift the
-  // above-neighbours that are now not strictly above, minimally, one step past it.
-  const target = maxBelow != null ? maxBelow + 1 : 0;
-  const clamped = Math.max(0, target);
-  if (clamped !== edited.zIndex) patchZ(edited, clamped);
-  liftAbove(edited, overlappersOf, patchZ);
-  return true;
+/** Moved down: one below the lowest clip it now sits under, but never under z 0 (a negative z can paint behind the
+ * composition's own background) and never under a clip on a lower row it paints over now, so the move cannot hide it.
+ * Null when it already paints under them all or cannot go lower. */
+function loweredZ(clip: StackingElement, overlapping: StackingElement[]): number | null {
+  const above = overlapping.filter((o) => laneIsAbove(o, clip));
+  if (above.every((o) => paintsAbove(o, clip))) return null;
+  const keepOver = overlapping.filter((o) => laneIsAbove(clip, o) && paintsAbove(clip, o));
+  const floor = Math.max(
+    0,
+    ...keepOver.map((o) =>
+      paintsAbove({ ...clip, zIndex: o.zIndex }, o) ? o.zIndex : o.zIndex + 1,
+    ),
+  );
+  const z = Math.max(floor, Math.min(...above.map((o) => o.zIndex)) - 1);
+  return z < clip.zIndex ? z : null;
 }
 
 /**
- * Pick a single non-negative z for `edited` that lands it correctly against its
- * neighbours (paints above every below-neighbour, below every above-neighbour), or
- * null when no such z exists and the caller must cascade.
- *
- * The candidate is verified with the SAME `paintsAbove` predicate the resolver uses
- * (z + DOM tie-break), so an authored z that already paints correctly by DOM order
- * is honoured instead of over-patched: with below=z3 and an above-neighbour at z4
- * that is LATER in the DOM, edited=4 ties the neighbour but the neighbour still
- * paints on top by DOM order — a valid single patch, no neighbour bump (item 12).
- * When the tie would INVERT (the above-neighbour is earlier in DOM) the candidate
- * fails verification and the caller cascades.
- */
-// edited has neighbours on BOTH sides: prefer the integer midpoint of a real gap;
-// with no strict gap a DOM tie-break may still let it sit AT minAbove (item 12),
-// else the caller cascades.
-function zBetweenNeighbours(
-  maxBelow: number,
-  minAbove: number,
-  correctAt: (z: number) => boolean,
-): number | null {
-  if (minAbove - maxBelow >= 2) {
-    const mid = Math.floor((maxBelow + minAbove) / 2);
-    return mid > maxBelow && mid < minAbove ? mid : null;
-  }
-  return correctAt(minAbove) ? minAbove : null;
-}
-
-// edited has only above-neighbours: sit one step below minAbove, or at the z=0
-// floor tie minAbove when a DOM tie-break keeps that neighbour on top.
-function zBelowOnly(minAbove: number, correctAt: (z: number) => boolean): number | null {
-  const candidate = minAbove - 1;
-  if (candidate >= 0) return candidate;
-  return correctAt(minAbove) ? minAbove : null;
-}
-
-function trySingleZ(edited: MutZ, below: MutZ[], above: MutZ[]): number | null {
-  const maxBelow = boundaryZ(below, (zs) => Math.max(...zs));
-  const minAbove = boundaryZ(above, (zs) => Math.min(...zs));
-
-  const correctAt = (z: number): boolean => {
-    const probe: MutZ = { ...edited, zIndex: z };
-    return below.every((b) => paintsAbove(probe, b)) && above.every((a) => paintsAbove(a, probe));
-  };
-
-  if (maxBelow != null && minAbove != null)
-    return zBetweenNeighbours(maxBelow, minAbove, correctAt);
-  if (maxBelow != null) return maxBelow + 1; // only below-neighbours → grow upward
-  if (minAbove != null) return zBelowOnly(minAbove, correctAt);
-  return null;
-}
-
-/**
- * Enforce the module invariant — for every OVERLAPPING pair, the clip on the upper
- * lane paints on top — starting from `edited` and cascading TRANSITIVELY.
- *
- * Seeded with `edited`: each of its upper-lane overlappers must paint strictly
- * above it (the deliberate lane move). Raising a clip can then tie or cross ANOTHER
- * clip it overlaps that sits on an even higher lane — that clip must be lifted too,
- * and so on. Without the cascade a lifted neighbour could tie an untouched clip on
- * a higher lane and, being later in the DOM, paint above it — an untouched pair
- * visibly inverting (#2198). The condition is LANE order (not "was originally
- * above"), so a clip that was already violating lane order — e.g. a bottom-lane
- * clip painting on top — is fixed, never preserved. Only clips whose z actually
- * changes are patched; z climbs by +1 each step so the walk terminates.
- */
-function liftAbove(
-  edited: MutZ,
-  overlappersOf: (clip: MutZ) => MutZ[],
-  patchZ: (clip: MutZ, z: number) => void,
-): void {
-  const queue: MutZ[] = [edited];
-  const raiseAbove = (clip: MutZ, floor: MutZ): void => {
-    if (paintsAbove(clip, floor)) return; // already strictly on top
-    patchZ(clip, floor.zIndex + 1); // patchZ mutates clip.zIndex in place
-    queue.push(clip);
-  };
-  while (queue.length > 0) {
-    const floor = queue.shift()!;
-    for (const other of overlappersOf(floor)) {
-      if (laneIsAbove(other, floor) && !paintsAbove(other, floor)) raiseAbove(other, floor);
-    }
-  }
-}
-
-/**
- * Compute z-index patches so each edited clip's stacking matches its lane order.
- *
- * @param elements  The FULL post-edit element set (edited clips already carry
- *                  their new lane/time). Untouched clips keep their current z.
- * @param editedKeys  Keys of the clip(s) the user just edited.
- * @returns  Minimal z patches. When a single-clip patch realises the order it is
- *           the only patch (authored z of neighbours untouched); when ties or a
- *           z=0 floor make that impossible, the minimum set of overlapping
- *           neighbours is bumped too so the lane move is always realisable with
- *           all z ≥ 0. Non-overlapping / already-correct edits yield nothing.
- *
- * Multi-clip edits: each edited clip is resolved against the CURRENT (already-
- * patched) z of all OTHER clips, lower lane first, so a group dragged onto a busy
- * region stacks consistently.
+ * The z-index patches for a row move: each edited clip, and only it, is raised (`up`) or lowered (`down`) against the
+ * clips it overlaps in time in its own paint scope. Clips whose live z is unresolved (non-finite) and audio clips take
+ * no part. Several edited clips resolve against each other's new z: the bottom one first when moving up, the top one
+ * first when moving down.
  */
 export function computeStackingPatches(
   elements: StackingElement[],
   editedKeys: Iterable<string>,
+  direction: StackingDirection,
 ): StackingPatch[] {
   const editedSet = new Set(editedKeys);
-  if (editedSet.size === 0) return [];
+  const live = elements
+    .filter((e) => Number.isFinite(e.zIndex) && !e.isAudio)
+    .map((e) => ({ ...e }));
+  const edited = live
+    .filter((e) => editedSet.has(e.key))
+    .sort((a, b) => (direction === "up" ? b.track - a.track : a.track - b.track));
 
-  // Drop clips whose live z couldn't be resolved (non-finite / NaN): a fabricated
-  // z=0 would enter the boundary math as a phantom neighbour at the z-floor. An
-  // unresolved clip is neither a neighbour nor resolvable as an edit, so it is
-  // excluded outright (item 13).
-  const allResolved = elements.filter((e) => Number.isFinite(e.zIndex));
-
-  // Leaf z is only meaningful within ONE source document and stacking context:
-  // across either boundary the ancestor composition/context decides paint order.
-  // Restrict the computation to the edited clips' own paint scope(s).
-  const editedScopes = new Set(allResolved.filter((e) => editedSet.has(e.key)).map(paintScopeKey));
-  const resolved = allResolved.filter((e) => editedScopes.has(paintScopeKey(e)));
-
-  // Mutable z snapshot so edits + cascaded bumps see each other's applied z.
-  const byKey = new Map<string, MutZ>(resolved.map((e) => [e.key, { ...e }]));
-  const edited = resolved
-    .filter((e) => editedSet.has(e.key) && !e.isAudio)
-    .map((e) => byKey.get(e.key)!)
-    // Resolve lower-lane (renders below) clips first so their new z is visible
-    // to higher-lane siblings resolved after them.
-    .sort((a, b) => b.track - a.track);
-
-  const changed = new Map<string, number>();
-  const patchZ = (clip: MutZ, z: number): void => {
-    clip.zIndex = z;
-    changed.set(clip.key, z);
-  };
-
-  // The full live set, so the transitive cascade can reach clips that overlap a
-  // LIFTED neighbour without overlapping the edited clip itself (#2198).
-  const all = [...byKey.values()];
-  const overlappersOf = (clip: MutZ): MutZ[] =>
-    all.filter(
-      (o) => o.key !== clip.key && !o.isAudio && samePaintScope(clip, o) && overlapsInTime(clip, o),
-    );
-
-  for (const clip of edited) {
-    resolveEditedZ(clip, overlappersOf(clip), overlappersOf, patchZ);
-  }
-
-  // Emit in a stable order (edited clips first in their resolve order, then any
-  // cascaded neighbours) — deterministic for tests and undo grouping.
-  const emitted = new Set<string>();
   const patches: StackingPatch[] = [];
   for (const clip of edited) {
-    if (changed.has(clip.key) && !emitted.has(clip.key)) {
-      patches.push({ key: clip.key, zIndex: changed.get(clip.key)! });
-      emitted.add(clip.key);
-    }
-  }
-  for (const [key, zIndex] of changed) {
-    if (!emitted.has(key)) {
-      patches.push({ key, zIndex });
-      emitted.add(key);
-    }
+    const overlapping = live.filter(
+      (o) => o.key !== clip.key && overlapsInTime(clip, o) && samePaintScope(clip, o),
+    );
+    const zIndex = direction === "up" ? raisedZ(clip, overlapping) : loweredZ(clip, overlapping);
+    if (zIndex === null) continue;
+    clip.zIndex = zIndex;
+    patches.push({ key: clip.key, zIndex });
   }
   return patches;
 }

package/src/player/components/useTimelineStackingSync.ts

@@ -55,7 +55,7 @@ export function useTimelineStackingSync({
   // NaN (NOT 0) when the element can't be resolved in the preview iframe — a
   // nested / unmounted sub-comp node, or one outside the active file. Fabricating
   // z=0 would enter computeStackingPatches as a real overlapping neighbour at the
-  // z-floor and skew the boundary math; a non-finite value tells it to EXCLUDE this
+  // z-floor; a non-finite value tells it to EXCLUDE this
   // clip instead. NaN (rather than null) keeps the return assignable to the
   // `(el) => number` reader contract the drag hook / commit deps declare.
   const readClipZIndex = useCallback(

package/src/timelineStackingSyncExport.test.tsx

@@ -24,8 +24,9 @@ it("restacks the host's preview when a lane move puts a clip below another", asy
   const iframe = document.createElement("iframe");
   document.body.appendChild(iframe);
   const doc = iframe.contentDocument!;
-  // No authored z: DOM order paints tag over title, which matches the rows until the move.
-  doc.body.innerHTML = '<div id="title"></div><div id="tag"></div><div id="note"></div>';
+  // Tag (top row) paints over title, matching the rows until the move.
+  doc.body.innerHTML =
+    '<div id="title" style="z-index: 2"></div><div id="tag" style="z-index: 3"></div><div id="note"></div>';
   const clip = (id: string, start: number, duration: number, track: number) =>
     ({ id, key: id, domId: id, tag: "div", start, duration, track }) as const;
   usePlayerStore.setState({

package/src/utils/elementGsap.ts

@@ -8,7 +8,6 @@
 type ElementGsapWindow = Window & {
   gsap?: {
     set?: (target: Element, vars: Record<string, number>) => void;
-    getProperty?: (target: Element, prop: string) => unknown;
   };
 };
 
@@ -38,10 +37,12 @@ export function setElementGsapScale(element: HTMLElement, x: number, y: number):
   return true;
 }
 
-/** The element's GSAP numeric property, or null when unreadable. */
-export function readElementGsapNumber(element: HTMLElement, prop: string): number | null {
-  const value = Number(gsapOf(element)?.getProperty?.(element, prop));
-  return Number.isFinite(value) ? value : null;
+/** Set the element's GSAP width/height. Returns false when no runtime is reachable. */
+export function setElementGsapSize(element: HTMLElement, width: number, height: number): boolean {
+  const gsap = gsapOf(element);
+  if (!gsap?.set) return false;
+  gsap.set(element, { width, height });
+  return true;
 }
 
 /** The targets CSSPlugin styles: not plain objects (the runtime's filler) or XML-namespace elements. */

package/src/utils/gsapUndoRestore.test.ts

@@ -21,6 +21,7 @@ import {
 } from "./gsapUndoRestore";
 import { applyPatch } from "./sourcePatcher";
 import { beginStudioManualEditGesture } from "../components/editor/manualEdits";
+import { studioManualEditSavesIn } from "../components/editor/manualEditsDom";
 import { writePlainMove, writeTranslatePx } from "../components/editor/plainTranslate";
 
 // ── Bug 2: undo/redo restore soft-apply ──────────────────────────────────────
@@ -281,6 +282,16 @@ describe("applyUndoRestoreToPreview", () => {
     expect(doc.getElementById("a")!.getAttribute("style")).toBe("z-index: 8");
   });
 
+  it("counts a script-only restore applied in place, so a reload requested before it loads again", () => {
+    const script = (x: number) => `window.__timelines["root"]=gsap.timeline().to("#a",{x:${x}});`;
+    const page = (x: number) => `<div id="a">t</div><script>${script(x)}</script>`;
+    const { iframe, doc } = buildLiveIframe(page(2));
+    const before = studioManualEditSavesIn(doc);
+    const files = { [ROOT]: { previous: wrap(page(2)), restored: wrap(page(1)) } };
+    applyUndoRestoreToPreview(iframe, ROOT, files, 3, vi.fn());
+    expect(studioManualEditSavesIn(doc)).toBeGreaterThan(before);
+  });
+
   it("does NOT re-run an UNCHANGED GSAP script for an attribute-only restore", () => {
     // The live doc holds a script element; a re-run would mutate/remove it
     // (applySoftReload removes stale script elements before re-running).
@@ -563,6 +574,17 @@ describe("an undo that lands while the layer is being dragged", () => {
     expect(el.style.getPropertyValue("width")).toBe("100px");
   });
 
+  it("counts an undo shown or applied in place, so a reload requested before it loads again", () => {
+    const { iframe, doc } = buildLiveIframe(undone);
+    const before = studioManualEditSavesIn(doc);
+
+    showRestoreInPlace(iframe, ROOT, files, 3);
+    expect(studioManualEditSavesIn(doc)).toBeGreaterThan(before);
+    const shown = studioManualEditSavesIn(doc);
+    applyUndoRestoreToPreview(iframe, ROOT, files, 3, vi.fn());
+    expect(studioManualEditSavesIn(doc)).toBeGreaterThan(shown);
+  });
+
   it("keeps a drag that started after the undo was shown when the undo is put back", () => {
     const { iframe, doc } = buildLiveIframe(undone);
     const el = doc.getElementById("a")!;

package/src/utils/gsapUndoRestore.ts

@@ -14,7 +14,7 @@ import { findAuthoredElement, parseSavedSource } from "./authoredSource";
 import { STUDIO_EDIT_ATTRS } from "../components/editor/manualEditsSeekReapply";
 import { markScenesStale } from "../player/sceneSwap";
 import { STUDIO_ORIGINAL_INLINE_TRANSLATE_ATTR } from "../components/editor/manualEditsTypes";
-import { studioGestureDraws } from "../components/editor/manualEditsDom";
+import { countStudioPreviewChange, studioGestureDraws } from "../components/editor/manualEditsDom";
 
 type PreviewWindow = Window & {
   __player?: { seek?: (t: number) => void };
@@ -312,7 +312,8 @@ export function showRestoreInPlace(
   const doc = iframe?.contentDocument;
   const win = iframe?.contentWindow as PreviewWindow | null;
   const plan = doc && win ? planRestoreTargets(doc, activeCompPath ?? "index.html", files) : null;
-  if (!iframe || !win || !plan || plan.scripted) return null;
+  if (!iframe || !doc || !win || !plan || plan.scripted) return null;
+  countStudioPreviewChange(doc);
   const before = plan.targets.map(
     ({ live, restored }) => [live, live.cloneNode(false) as Element, restored] as const,
   );
@@ -393,6 +394,7 @@ export function applyUndoRestoreToPreview(
     reloadPreview();
     return "full";
   }
+  countStudioPreviewChange(doc);
   // Sync each changed element's attributes onto the live DOM from the restored
   // markup, so the runtime's seek-reapply reads the reverted values.
   for (const target of plan.targets)

package/src/utils/studioPendingEdits.ts

@@ -66,8 +66,18 @@ export function hasStudioPendingEdits(): boolean {
   return pendingEdits.size > 0 || focusedField() !== null;
 }
 
+const shownRestores = new Set<Promise<void>>();
+
+export function beginStudioShownRestore(): () => void {
+  let end = () => {};
+  const landed = new Promise<void>((resolve) => (end = resolve));
+  shownRestores.add(landed);
+  void landed.then(() => shownRestores.delete(landed));
+  return end;
+}
+
 export function isStudioEditSaving(): boolean {
-  return pendingEdits.size > 0;
+  return pendingEdits.size > 0 || shownRestores.size > 0;
 }
 
 export function afterStudioPendingEdits(run: () => void): () => void {
@@ -75,7 +85,7 @@ export function afterStudioPendingEdits(run: () => void): () => void {
   const check = () => {
     if (!waiting) return;
     if (isStudioEditSaving()) {
-      void Promise.allSettled([...pendingEdits.keys()]).then(check);
+      void Promise.allSettled([...pendingEdits.keys(), ...shownRestores]).then(check);
       return;
     }
     waiting = false;