the world map blips are the reference's, and particles go untinted

- the world map speaks the reference's names: WorldMapTooltip is declared (six corpus addons index it; pfUI dies on it at file scope), the blackout frame takes the reference's spelling BlackoutWorld, and the four hand-written party blips become the reference's own unit-blip templates — all 44 blips as instances, each with its published $parentIcon, the name pfUI recolours group blips by class through; the 40 raid ones are declared but not positioned yet, named in the OUT list rather than faked
- the templates addons build their own buttons from are published: ItemButtonTemplate, ContainerFrameItemButtonTemplate and the bag-slot chain — most of the handler scripts were live the whole time (this client executes the reference's own container and paper-doll code off the player's patch chain), so what was missing was mostly declarations, not behaviour — the bank arm stays out and is named as the omission it is; OptionsFrameSliders becomes real, with the three Graphics rows reading it and re-reading on show, so an addon's write to a slider's bounds actually moves the slider; and the template census that had ranked these at "zero demand" learns to see a local bound to a literal — its table went from 3 rows to 7
- the bindings answer in 1.12's own shapes: Button:IsEnabled() answers the NUMBER 1 or 0 (0 is truthy in Lua, so the reference's own == 0 tests got false forever, and three of our files had hand-worked around the divergence rather than fixed it); the constructors' string arguments are four shapes, not one rule — pfUI passes a Button where a template name goes and the reference constructs the FontString and ignores it; SetInventoryItem returns THREE values, the reference's own paper doll destructuring repairCost; UnitIsVisible is object presence and nothing else (57 bytes, one branch, no distance — an out-of-range party member is exists-yes, visible-nil); the tapped pair reads the two dynamic-flags bits, and its repaint wire fires UNIT_FACTION on the tap bit — the half a passing predicate test never sees; UnitIsPartyLeader is two ORed legs covering disjoint failures (a held stranger leading their own party, and an out-of-range member with no object to read a flag from); and the four nameplate verbs take no argument and return zero values
- the ghost's wisps compose onto its body instead of over it — the four emitters drew at full strength over a body at alpha 0.5, and now inherit the instance alpha down the attachment chain the way the reference recomposes it per frame; the residual we had parked ("the wisps should inherit the tint too") is REFUTED at the bytes: a particle batch commits hardcoded white RGB, and even that never reaches the fragment — particles are never tinted, only the alpha crosses, applied to the alpha byte alone — so the shipped shader split was already right and no code changes

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

crates/benilla-ui/src/script/tests/reference_surface.rs

@@ -1551,3 +1551,74 @@ fn every_installed_region_method_lands_in_a_leaf() {
         "installed on the region table but in NO leaf list, so no region can call them: {orphans:?}"
     );
 }
+
+/// **The four nameplate verbs take no argument and return nothing.**
+///
+/// `ShowNameplates 0x489450` / `HideNameplates 0x489460` / `ShowFriendNameplates 0x489470` /
+/// `HideFriendNameplates 0x489480` — four 10-byte bodies over two setters, differing only in an
+/// `or`/`and` mask (wow-re `ui/scratch/party-leader-and-nameplate-verbs.md`).
+///
+/// Both halves of the shape are asserted because both are easy to invent differently:
+///
+/// - **No argument is read.** `ShowNameplates(false)` still shows — there is no `lua_gettop` and
+///   no `lua_toboolean` in any of the four. That is *why* there are four verbs instead of two
+///   taking a flag, and a binding typed `fn(bool)` would reject a call the reference accepts.
+/// - **Zero return values, not nil.** `select('#', ...)` sees 0, which is observably different
+///   from one nil for a caller that counts.
+#[test]
+fn the_nameplate_verbs_ignore_their_arguments_and_return_nothing() {
+    let mut s = script();
+    s.register_cvars([
+        (crate::script::CVAR_NAMEPLATE_ENEMIES, "1"),
+        (crate::script::CVAR_NAMEPLATE_FRIENDS, "0"),
+    ]);
+
+    let get = |s: &crate::script::UiScript, n: &str| s.cvar(n);
+    assert_eq!(
+        get(&s, crate::script::CVAR_NAMEPLATE_ENEMIES).as_deref(),
+        Some("1")
+    );
+
+    // Each verb writes its own bit and leaves the other alone.
+    s.run("HideNameplates()").unwrap();
+    assert_eq!(
+        get(&s, crate::script::CVAR_NAMEPLATE_ENEMIES).as_deref(),
+        Some("0")
+    );
+    assert_eq!(
+        get(&s, crate::script::CVAR_NAMEPLATE_FRIENDS).as_deref(),
+        Some("0"),
+        "the friendly bit is a separate setter — hiding enemies must not touch it"
+    );
+    s.run("ShowFriendNameplates()").unwrap();
+    assert_eq!(
+        get(&s, crate::script::CVAR_NAMEPLATE_FRIENDS).as_deref(),
+        Some("1")
+    );
+    assert_eq!(
+        get(&s, crate::script::CVAR_NAMEPLATE_ENEMIES).as_deref(),
+        Some("0"),
+        "...and back the other way"
+    );
+
+    // **An argument is accepted and IGNORED.** `ShowNameplates(false)` shows, which is the whole
+    // reason the reference ships four verbs rather than two taking a flag.
+    s.run("ShowNameplates(false)").unwrap();
+    assert_eq!(
+        get(&s, crate::script::CVAR_NAMEPLATE_ENEMIES).as_deref(),
+        Some("1"),
+        "the verb IS the value — a falsy argument does not invert it"
+    );
+    for call in ["HideNameplates(1, 2, 3)", "ShowFriendNameplates({})"] {
+        s.run(call)
+            .unwrap_or_else(|e| panic!("{call} must not raise: {e}"));
+    }
+
+    // ZERO return values, not one nil.
+    assert_eq!(
+        s.eval::<usize>("return select('#', ShowNameplates())")
+            .unwrap(),
+        0,
+        "zero values — observably different from nil for a caller that counts"
+    );
+}