A test that waits for a deadline somebody guessed is waiting for the wrong thing, so it waits for the editor (#93)

The suite spent 88% of its step time asleep: 564 s of steps, 496 s of
them in sleep(n) - fixed spans estimated by hand and then copied from
step to step. That is why it was slow, and why it flickered.

The signal is afterFrames(count, timeout) in ui/render.ts, exposed as
__gm.afterFrames(). It wakes the loop itself, because an editor that
draws nothing would never redeem a promise of a frame, and it gives up
after a timeout instead of hanging the run. settle() in the harness
waits two drawn frames (~32 ms) instead of 150-300 ms and falls back to
sleep(150) when the hook is missing (an old build): silently not
waiting would make every later check a coin toss.

Every action goes through it now - click, doubleClick, wheel, drag,
dragAsset, press, typeText, select, mutate, undo, redo - and with that
about 550 sleep() calls behind those actions became redundant, helpers
that are nothing but a mutate in a coat included. What a frame cannot
answer got its own condition instead: waitUntil(expr), play()/stop()
waiting on __gm.state.mode rather than on 300 ms, saved() for the
autosave (the two hand-written polling loops sampled at 300 ms for
something that arrives after a second), and showTab() as a real tool -
47 places called evaluate("__gm.showTab(...)") raw, and 24 of them
waited for nothing at all and read the old panel.

564 s -> 243 s of step time, the waiting share 88% -> 76%. Three kinds
of wait were kept, and each one bit when it was taken away: loading
bytes (textures, fonts), game time that a repaint cannot stand in for
(time scale, shader and particle clocks, the live values a running
graph carries), and the inertia the scroll step measures on purpose.

Two things the new speed uncovered, both real: 25-animation read the
frame menu unfiltered and had frozen an incomplete list (the CI failure
on c990dbc), and 33-render-on-change measured idleness while the
autosave of the step before was still painting - it waits for
saveStatus to leave dirty/saving now, so it measures that nothing
happens any more instead of that it waited long enough.

tests/ui/render.test.ts

@@ -1,6 +1,7 @@
 import type { Application } from 'pixi.js';
 import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
 import {
+  afterFrames,
   initRenderLoop,
   isRendering,
   renderCount,
@@ -93,4 +94,48 @@ describe('render loop', () => {
     tick();
     expect(app.drawn).toBe(1);
   });
+
+  it('afterFrames resolves only once that many frames were really drawn', async () => {
+    const { app, tick } = fakeApp();
+    initRenderLoop(app as unknown as Application);
+    now += 500;
+
+    let done = false;
+    const waited = afterFrames(2).then(() => (done = true));
+
+    tick();
+    await Promise.resolve();
+    expect(done).toBe(false);
+    tick();
+    await waited;
+    expect(done).toBe(true);
+    expect(app.drawn).toBe(2);
+  });
+
+  it('afterFrames wakes the loop itself, so an idle editor still answers', async () => {
+    const { app, tick } = fakeApp();
+    initRenderLoop(app as unknown as Application);
+    now += 500;
+    for (let i = 0; i < 5; i++) tick();
+    expect(app.drawn).toBe(0);
+
+    const waited = afterFrames(1);
+    tick();
+    await waited;
+    expect(app.drawn).toBe(1);
+  });
+
+  it('afterFrames gives up rather than hanging when no frame ever comes', async () => {
+    vi.useFakeTimers();
+    try {
+      const { app } = fakeApp();
+      initRenderLoop(app as unknown as Application);
+      const waited = afterFrames(1, 50);
+      vi.advanceTimersByTime(60);
+      await waited;
+      expect(app.drawn).toBe(0);
+    } finally {
+      vi.useRealTimers();
+    }
+  });
 });