The flick stops losing the point, and the corpse falls and serves

THE FLICK. "when returning a ball with a spin it seems too sensitive, 8/10
times the ball lands out." Arithmetic, not feel. The singles line is 4.115 m;
an aimed shot targeted a flat ax*3.3 and THEN added err() on top — up to
+-2.4 m at quality 0 — so a flicked return landed as wide as 5.7 m, and the
only clamp in the path sat at +-5, outside the court. An UNAIMED return
targets 0 + the same scatter and is therefore always in: aiming was the thing
losing the point, which is backwards for the mode's one act of skill.

TUNE.flickReach scales the aim width by the same quality the scatter shrinks
with, so the two can never sum past the line — worst case 1.49+2.4 = 3.89, and
a perfectly timed flick still gets the full 3.3 with nothing left to scatter.
The test asserts that sum across the whole quality range rather than sampling
rallies. Not named `aimReach`: that key already exists further down TUNE (the
slingshot's 22 m aim ray) and the duplicate silently won until a test caught it.

The placement ring carries `q` now and is the flick's receipt — tight and hot
when your timing earned the full width, wide and dim when you barely got a
racket on it. Without it the rule is invisible: the shot just goes less wide.

THE FALL (handoff item 4). A point that takes a limb knocks the body down and
it drags itself up short of it. The three collapse frames wear the stage it
STILL WAS and the rise wears the stage it has BECOME — that order is the whole
beat, and it is what turns a popping wound stage into something the point did.
Own clock beside the horde's warning, for the reason this file keeps relearning
(a beat that moves the phase under a latch strands it); the 'over' beat it sets
outlives the fall so it cannot expire into setupPoint() mid-collapse. Only
fires when the stage actually moved — a quarter off a full pool is 0.75, so
point one has no limb to explain and a second of collapse for nothing is a beat
the player waits out.

THE OPPONENT SERVES (handoff item 7), and it was mostly switched off rather
than missing. setupPoint already placed a non-player server behind its own
baseline and armed aiServeT; update() already tossed and struck for O. Both
were gated on `G.mode === 'tennis'` and the match runs in splatter under a
permanent interlude — one condition. Genuinely new: service alternates at each
game boundary (the match calls advancePoint directly and the flip lives in
tennis's pointTo, which it bypasses — the same shape as the G.serveNum bug),
the zombie takes O's mark so picture and ballistics agree on where it stands,
and the serve poses are named onto it because O is invisible here.

racketStage() moves to config: drawZombie and the fall must not answer the
same question twice, which is how the boss's skins and its blood drifted apart.

Docs: PROJECT.md gains THE ZOMBIE FAMILY PIPELINE — the measured API contract
(4K is a parameter and the default is 1K; n is 1 so "return both" is not a
thing; aspect is an enum so pad to it), why magenta stays despite green being
the documented key, and the two things _zsheet.py must do globally.

Verified in the browser: brute in the match, z_brfall2 -> z_brw1rise on a
wounding point, and bounce -> toss -> serve off the opponent's own baseline.
58 tests green.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>

src/config.js

@@ -23,6 +23,13 @@ export const TUNE = {
                     // tape AND come down on a target, so it got throttled back to walking pace.
                     // Heavy topspin lets it leave flat and DIVE, which is what a smash actually is.
   aimError: 2.4,           // m of scatter at quality 0
+  // NOT `aimReach` — that name is taken further down by the slingshot's aim-ray LENGTH (22 m), and
+  // the duplicate key silently won: every aimed shot reached 22x its width until a test caught it.
+  flickReach: 0.45,        // how much of an aimed shot's width a MISTIMED flick gets (1 = all of it).
+                           // Reach x quality must stay under the sideline once aimError is added on
+                           // top, or the flick goes out — which is exactly the bug this fixed:
+                           // 3.3 * 0.45 + 2.4 = 3.89 against a 4.11 m line. Raise it and the flick
+                           // gets punchy again AND starts sailing wide on sloppy timing.
   perfectMs: 45,           // |offset from window center| for PERFECT
   // The tennis CPU only exists in the OPENING match (after the transition, tennis never comes
   // back — duels use racket* dials), so these three are the "how long until the first game is won"
@@ -735,6 +742,15 @@ export const BENCH_STAGES = ['HEALTHY', 'ARM OFF', 'HEADLESS'];
 // the gate working, not the gate being wrong. Re-registering it is one entry here; see the note at
 // the top of _master.py for the fix its next attempt needs.
 export const ZFAMS = ['r', 'br'];
+
+// THE RACKET FAMILY'S THREE STAGES, as a FRACTION of the pool — never against literal hp, the rule
+// this whole file already holds (see woundStage). It lived inline in drawZombie; the FALL BEAT needs
+// the same answer to know which body collapses and which one gets back up, and two copies of a
+// threshold is exactly how the boss's skins and its blood drifted apart before.
+export const racketStage = zb => {
+  const f = zb.hp / (zb.hpMax || TUNE.racketHp);
+  return f <= 0.34 ? 2 : f <= 0.67 ? 1 : 0;         // 0 unhurt, 1 arm off, 2 headless
+};
 const POSES = ['bounce', 'toss', 'serve', 'fall1', 'fall2', 'fall3', 'rise'];
 export const famFrames = f => [
   `z_${f}1`, `z_${f}2`, `z_${f}3`, `z_${f}4`,          // stance, shuffle A, shuffle B, forehand