your corpse is your own dead body, and particles take the room's light

- corpses render: a corpse create spawned a real entity, latched its guid for the reclaim send, and drew nothing — one missing EntityKind variant folded it into the catch-all and four downstream lanes then failed by default, not even the debug cube fired; the reference forks once, on the bones flag: a fresh body builds a character composite from the corpse's OWN appearance bytes and 19 item slots through the same compositor a living player is dressed by (its own hide-helm/hide-cloak bits honoured, the ranged slot never dresses, and weapons never dress because the client looks a packed display word up as a guid — we reproduce the outcome, not the dead lookup), while a bone pile takes its race and sex's DeathSkeleton, sixteen of which ship; the pose is one settled arm — Dead, or Drowned when the body lies more than 0.66666669 yd under a liquid surface — and a corpse is not a unit, so clicking one no longer sends a selection for a guid no unit owns
- a lit particle takes its MODEL's committed light node, not the sky's: indoors the reference lights an object's particles from the object's own node — the footprint's baked floor colours on the fixed interior axis plus the room's placed lights — never the day/night sun; a particle quad carries exactly one normal, world up, one constant per draw, so the whole node collapses to three floats, published off the same fold the model's mesh renders from so a mesh and its own particles can never disagree about the room they stand in; in Onyxia's Lair the 78 lit falling-rock emitters on the 26 anchors that classify interior now take the room's light
- and that lit lane is FIXED FUNCTION, not the mesh's soft SH curve: the shipped client null-binds both shader slots for a particle batch and re-zeroes the shader mask at the head of every batch, so a model and its own particles share the same committed light words and legitimately differ in the curve applied to them — the mesh's wrapping lobe against the hardware's max(N·L, 0) is 0.900 vs 0.869 on the key axis, up to the three nearest room lights arrive diffuse-only under GL's own 1/(0.7d + 0.03d²) falloff (a light at or below the emitter cannot reach it at all), and the clamp sits on the product, never the multiplier, because it is GL that clamps the lit vertex colour
- the cinematic letterbox has no aspect test in it: CinematicFrame.lua's if guards a recompute, not whether there are bars — below 4:3 the reference's bar textures simply stand at their declared 1024x128 on the client's native 1024x768 sheet, which is height/6, the same formula evaluated at exactly 4:3 — so one expression covers every window shape, min((h − min(w/2, h))/2, h/6): a 2:1 picture when wide, bars at 4:3 too; and a shown keyboard frame swallows EVERY key, not the ten names the host used to feed it — you could walk around underneath your own intro; the proof is the reference's own handler, which has to RunBinding("SCREENSHOT") by hand to get one key back; ESC still skips, and a W already held when the shot starts keeps running, which is faithful too

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

crates/benilla-app/src/ui_script/input.rs

@@ -277,6 +277,30 @@ pub(super) fn feed_ui_input(
                 continue;
             }
         }
+        // EVERY OTHER KEY reaches a keyboard frame by name too. The reference's key-down walk
+        // carries the whole key table — its `arg1` comes from the *same* table the keybinding
+        // chord uses (wow-re `frame-key-script-delivery.md` §4.2), which is [`chord::key_token`]
+        // here — and the frame's gate is EXISTENCE, not handling: a shown keyboard frame with an
+        // `OnKeyDown` swallows the key whatever its script does with it (§3, §3.1). This host used
+        // to feed only the ten names above, so `CinematicFrame` — fullscreen, keyboard-enabled, an
+        // `OnKeyDown` that answers ESCAPE — consumed ESC and let W straight through, and the player
+        // walked around underneath their own intro cinematic.
+        //
+        // The reference's own Lua is the proof this is the law and not an over-reading: that
+        // handler has to call `RunBinding("SCREENSHOT")` **by hand** to get one key back. It would
+        // not need to if unhandled keys fell through to their bindings.
+        //
+        // Consumption sets the capture gate and nothing else: it suppresses the binding and the
+        // world/gameplay readers, and deliberately does NOT suppress `char_input` below — `OnChar`
+        // is a separate channel off a separate dispatcher (`0x765df0`), which is exactly how the
+        // stack-split spinner receives a digit whose key-down its own `OnKeyDown` already ate.
+        else if named.is_none() {
+            if let Some(token) = crate::bindings::chord::key_token(ev.key_code) {
+                if script.frame_key_input(token) {
+                    capture.0 = true;
+                }
+            }
+        }
         if let Some(name) = named {
             // The three box-event keys. An unconsumed press is not acted on here: every GAME
             // action of a key — ESCAPE's close/cancel ladder (TOGGLEGAMEMENU), TAB's targeting,