[vanceingalls]

What

#7191 undid what a timeline callback wrote by journalling the DOM, which left the JS state of the callback consumed: a once-guarded or memoized callback never showed its state again (if (done) return; done = true; label.textContent = "B" painted A, A against blur off's A, B). It shipped in 0.9.16, which Desktop pins, and Studio's Subtle and Strong write data-motion-blur-events="on", so films can hit it today.

This replaces the journal. During the scan, the landing and eventful pose reads, blur puts a no-op in place of GSAP's discrete callbacks (onStart, onComplete, onReverseComplete, onRepeat, which includes tl.call) and puts the originals back afterwards. onUpdate keeps firing, which is what finds callback-driven movers. The loud rewind through 0 stays: a silent seek to 0 leaves onUpdate state from the scan.

Measured in a spike first (report and raw results are in the plan folder): across 25 real-GSAP patterns, in both tiers, with and without an eventful mover, blur on matches blur off in label and fire count in all but one row (a non-GSAP adapter stand-in), against 248 of 300 comparisons differing on main. Mute plus restore over 2002 animations measured 0.2 ms median.

Details that matter: the swap is a no-op, not a clear, because hasZeroDurationCallbackTween reads typeof vars.onComplete during the seek; it walks tween.timeline as well as getChildren because staggers and keyframes keep per-target tweens there; and it skips an animation it already muted, because scene timelines nest inside the root and one animation is reached twice (the first spike version left a scene's tl.call muted for good).

Tests

• gsap.mute.test.ts: 5 tests with real GSAP (quiets the four callbacks and leaves onUpdate; stagger and keyframes; reached through two timelines; nested mutes; params and scope).
• index.test.ts: callbacks are restored when onUpdate throws during the scan; the three tests pinned to the journal are repaired and assert the same behaviour.
• captureMotionBlur.callbacks.browser.test.ts (new): 23 patterns x 3 paint sequences ([0.3, 0.7], a fresh worker at [0.7], and [0.3, 0.7, 0.3]) x both tiers, each asserting label and fire count equal blur off.
• New fixture once-guard-label in the differential and in the producer's 7-worker render check.
• With only the source reverted: 5 of 5 core mute tests fail, 21 of 25 engine callbacks tests fail (every GSAP row except three that main already handles), and the producer once-guard-label render fails.
• On the final head: core src/runtime 2814 pass, engine browser 151, producer blurDifferential + motionBlurVideo 28.

Known limits (accepted, please look at these)

• A mover that exists only because a muted callback set it up is found only if that callback fired before the scan, so a worker that starts before the call leaves that mover sharp while a later worker blurs it. Positions stay right.
• tl.call(() => gsap.to(card, ...)): the tween runs on GSAP's global timeline, the card is never a mover and stays sharp, as with blur off.
• A non-GSAP adapter's once-only completion still shows early (adapters/animejs.ts ignores suppressEvents; real anime.js is not installed here, so this rests on a stand-in). Pinned by a KNOWN LIMIT test.
• Animations created while the mute is on are not muted.
• If the traversal throws partway, the callbacks muted so far stay no-ops; restore overwrites a callback reassigned while muted. Both are tracked for the final review of this plan.

Supersedes the accepted limit in #7191's description.

🤖 Generated with Claude Code

[github-actions]

Edit accuracy: accurate 267 (base branch 267), smooth 131 of those

The gate passes.
Smoothness is reported in the artifact, not gated. A case fails only if it fails 2 of 3 runs.

Quarantined, measured but not gated (8)

• seqplainkeys-none-center-r0-nested-z100 (fixed by studio: undo/redo on a keyframed plain element sometimes leaves the box 230-400px off (edit-accuracy seqplainkeys-none-*) #6989): fail / pass / pass, passes
• seqplainkeys-none-center-r0-root-z100 (fixed by studio: undo/redo on a keyframed plain element sometimes leaves the box 230-400px off (edit-accuracy seqplainkeys-none-*) #6989): pass, passes
• seqplainkeys-none-center-r30-root-z100 (fixed by studio: undo/redo on a keyframed plain element sometimes leaves the box 230-400px off (edit-accuracy seqplainkeys-none-*) #6989): not run
• seqplainkeys-none-pct-r0-root-z100 (fixed by studio: undo/redo on a keyframed plain element sometimes leaves the box 230-400px off (edit-accuracy seqplainkeys-none-*) #6989): pass, passes
• seqplainkeys-none-pct-r30-root-z100 (fixed by studio: undo/redo on a keyframed plain element sometimes leaves the box 230-400px off (edit-accuracy seqplainkeys-none-*) #6989): not run
• seqplainkeys-none-px-r0-nested-z100 (fixed by studio: undo/redo on a keyframed plain element sometimes leaves the box 230-400px off (edit-accuracy seqplainkeys-none-*) #6989): pass, passes
• seqplainkeys-none-px-r30-nested-z100 (fixed by studio: undo/redo on a keyframed plain element sometimes leaves the box 230-400px off (edit-accuracy seqplainkeys-none-*) #6989): not run
• seqplainkeys-none-px-r30-root-z100 (fixed by studio: undo/redo on a keyframed plain element sometimes leaves the box 230-400px off (edit-accuracy seqplainkeys-none-*) #6989): not run

Unstable (1)

• seqfastkeys-none-px-r0-root-z100: tracking 0.06, pressJump 0.05, drop 0, reload 0, render 0.02, renderKey -, undo false, teleport true / tracking 0.06, pressJump 0.05, drop 0, reload 0, render 0.02, renderKey -, undo true, teleport true / tracking 0.06, pressJump 0.05, drop 0, reload 0, render 0.02, renderKey -, undo true, teleport true

[heygengenesis]

Verdict: APPROVE · 0 blocker · 3 important · 0 nits · head 476d48e1

The once-guard/memo regression is fixed. The mute/restore bookkeeping holds up for nesting, for a scene timeline reached twice, and for onUpdate throwing. The one failure path left is the walk throwing partway; a ↓ suggestion fixes that and the reassigned-while-muted limit. The Flake gate (optional) is deterministically red on the new browser test ↓.

Scope and checks

• Read end-to-end: adapters/gsap.ts, discover.ts, filterTier.ts, index.ts, the init.ts host, both new test files.
• Checked against GSAP 3.15 source: _callback reads vars[type] at call time. The no-op's truthiness matters for vars.onRepeat && (gsap-core L1605/L2525) as well as hasZeroDurationCallbackTween. tween.timeline is the stagger/keyframe timeline and Timelines have no .timeline of their own, so the walk can't cycle on real GSAP. Seeks flush lazy renders synchronously, so nothing fires after unmute.
• Probed with real GSAP: outer mute then inner mute on overlapping timelines, inner restored first, is correct. A walk that throws partway leaves callbacks muted permanently (inline). A callback reassigned while muted gets overwritten (fixed by the same suggestion).
• muteCallbacks covers exactly what host.seek drives (scene timelines and the root). Non-GSAP adapters are the documented limit.
• Local: core gsap.mute + captureMotionBlur/ 218/218. CI: all required checks green. Player Safari perf failed on a Safari webdriver error in heavy-alpha-webm run 2 (optional, unrelated).

— Claude

[heygengenesis]

important — If the walk throws partway, the callbacks it has already muted stay no-ops for the rest of the session, and the next mute/restore can't bring them back. On the next pass those no-ops look like an outer mute's, so the skip on L500 passes over them and they never go into held. I reproduced it: muteDiscreteCallbacks([a, objWhoseGetChildrenThrows]) throws, after which a's tl.call fires 0 times, including after a later full mute → restore → seek(0)/seek(1) cycle. whileCallbacksMuted calls muteCallbacks() before its try, and the paint swallows the error (runtime.captureMotionBlur.paint), so the film just loses its calls without any visible failure. The trigger is any window.__timelines entry that isn't a GSAP timeline and whose getChildren throws (or nests deeply enough to overflow the recursion).

The fix is small. The same guard on restore also covers your second limit, a callback reassigned while muted. I ran it with both cases as tests, plus gsap.mute.test.ts and captureMotionBlur/: 220/220 pass.

Suggested change

	const held: Array<[Record<string, unknown>, string, unknown]> = [];
	for (const timeline of timelines) {
	eachAnimationIn(gsapTimelineOf(timeline) as GsapCallbackHolder, ({ vars }) => {
	if (!vars) return;
	for (const name of DISCRETE_CALLBACKS) {
	if (typeof vars[name] !== "function" || vars[name] === noOpInPlaceOfCallback) continue;
	held.push([vars, name, vars[name]]);
	vars[name] = noOpInPlaceOfCallback;
	}
	});
	}
	return () => {
	for (const [vars, name, callback] of held) vars[name] = callback;
	};
	const held: Array<[Record<string, unknown>, string, unknown]> = [];
	const restore = (): void => {
	for (const [vars, name, callback] of held)
	if (vars[name] === noOpInPlaceOfCallback) vars[name] = callback;
	};
	try {
	for (const timeline of timelines) {
	eachAnimationIn(gsapTimelineOf(timeline) as GsapCallbackHolder, ({ vars }) => {
	if (!vars) return;
	for (const name of DISCRETE_CALLBACKS) {
	if (typeof vars[name] !== "function" || vars[name] === noOpInPlaceOfCallback) continue;
	held.push([vars, name, vars[name]]);
	vars[name] = noOpInPlaceOfCallback;
	}
	});
	}
	} catch (err) {
	restore();
	throw err;
	}
	return restore;

[heygengenesis]

important — The Flake gate is red because of this file: 0/10 runs pass, and every run is killed at flake-gate.mjs's 120 s RUN_TIMEOUT_MS. Under --maxWorkers=2 with CPU contention, 25 tests × 3 sequences × 5 page opens (about 375 fixture loads) doesn't fit in 120 s. It passes in the required Test (cli 2/2) in 89 s. That makes the failure deterministic, not a flake, and it will hit every later PR that touches this file. Splitting it into two or three files by row group (for example a–i, j–r, s–y plus the KNOWN LIMIT) should bring each run under the cap.

[heygengenesis]

important (answering your question about tl.call movers): tl.call(() => gsap.to(card, …)) staying sharp is fine. That tween is on the global timeline, which the render seek never drives. The mute is also strictly better than the journal here: the journal fired the call during the scan and spawned a global tween that undoing the DOM couldn't remove (row g pins that).

The other limit is worse. Take a mover that only gets a box because of a muted call, e.g. tl.call(() => card.style.display = "") or a class toggle that reveals an element a root tween moves all along. 0.9.16 found it, because the call fired during the scan before the DOM was undone. Now it's found only if the worker starts after the call, so a 7-worker render blurs it in later chunks and not in earlier ones, and the blur pops on at a chunk boundary. I'd still ship it: wrong content is worse than missing blur. But please pin it as a KNOWN LIMIT row like row x (say tl.call(() => card.style.display = "") at 0.5, worker started at 0.3 vs 0.7), so the change from 0.9.16 is on record and a fix flips the pin. A possible follow-up: rediscover when a tween target that had no box at scan time gains one at paint.

[heygengenesis]

Verdict: APPROVE · 0 blocker · 0 important · 0 nits · 476d48e1 → a50f4545

Rebase is patch-identical (range-diff = on both commits); a50f454 touches only the callbacks test harness: paintFrame is captureFrame minus the unused PNG, assertions and all three sequences are unchanged, and the row partition is self-checked. Dropping the no-mover arms is the stated trade-off. CI is green on this head, Flake gate included.