fix(rust): nothing names who is online by default

The org lead's rule, settled 2026-09-22: who is online is always the
narrowest audience - staff - unless an operator deliberately widens it,
and a count is fine where a list of names is not.

The public site broke that in three places since phase 4. The Online
tab named every player, the feed carried joins, respawns, deaths, chat
and tallies, and the leaderboard's lastSeen - refreshed every minute by
a gather tally - said who was on as plainly as either. All three now
sit behind one setting:

* PRESENCE_KINDS, a subset of the public allowlist, gated per request.
  Below the audience the feed keeps the server's own story (wipe, start,
  shutdown) and says presenceHidden rather than looking quiet.
* the Online route answers { players: [], hidden, count, audience } -
  same shape, so an older client renders empty rather than breaking.
* rungs staff / signed_in / public, fleet-wide default in a new
  rust_settings table with an optional per-server override on
  rust_servers; an unknown stored word narrows to staff.
* the viewer's standing is RE-READ from the users row (ctx.users.getById),
  not taken from the token, so a demotion or a ban applies on the next
  request. Walked: a moderator demoted mid-session lost the roll call on
  the same cookie.
* per-viewer answers are Cache-Control: private, no-store.
* GET/PUT /admin/rust/visibility (requireRole admin) and an admin page,
  Rust visibility; every save is one activity-log row.

The browser walk also found every empty state in this module rendering
as a blank box. Core's EmptyState renders children only; this module
passed title/message (the shape the Integration Kit template teaches)
and React dropped both without a word. Fixed module-side with a small
Empty wrapper - nothing core or module-uo renders changes - and a client
test that refuses a titled EmptyState or a PageHeader subtitle.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01E14m6SuuY6i1vASFeGDBeY

server/router/admin/rust.router.js

@@ -37,6 +37,11 @@ adminRustRouter.use('/permissions', require('./permissions.router'))
 // and this one edits the game host's own plugin settings.
 adminRustRouter.use('/config', require('./config.router'))
 
+// Who may see who is online, under `/rust/visibility`. The org lead's rule is
+// that nothing names who is online by default; this is where an operator
+// deliberately widens it, fleet-wide or for one server.
+adminRustRouter.use('/visibility', require('./visibility.router'))
+
 adminRustRouter.get(
   '/servers',
   // #swagger.tags = ['Admin · Rust']

server/router/admin/visibility.controller.js

@@ -0,0 +1,39 @@
+// ── Admin · Rust · Visibility — the handlers ──────────────────────────────
+
+const core = require('../../core')
+
+const visibility = require('../../model/visibility/visibility.model')
+
+const log = core.logger('visibility')
+
+async function read(req, res) {
+  try {
+    res.json(await visibility.describe())
+  } catch (err) {
+    log.error('failed to read visibility settings', { error: err.message })
+    res.status(500).json({ message: 'Failed to read the visibility settings' })
+  }
+}
+
+async function update(req, res) {
+  try {
+    const { fleet, servers } = req.body || {}
+    const result = await visibility.update({ fleet, servers }, req.user)
+    if (!result.ok) {
+      res.status(result.status || 400).json({ message: result.message })
+      return
+    }
+
+    // One row per save, naming everything it changed. Widening who may see the
+    // roll call is exactly the kind of change somebody later needs to trace to a
+    // person and a time.
+    await core.activity.log({ req, action: 'rust.visibility.save', detail: result.changed })
+
+    res.json(await visibility.describe())
+  } catch (err) {
+    log.error('failed to save visibility settings', { error: err.message })
+    res.status(500).json({ message: 'Failed to save the visibility settings' })
+  }
+}
+
+module.exports = { read, update }

server/router/admin/visibility.router.js

@@ -0,0 +1,51 @@
+// ── Admin · Rust · Visibility ─────────────────────────────────────────────
+//
+// Mounted under the admin tier's `/rust` prefix, so every path here is
+// `/api/v1/admin/rust/visibility`. Who may see what the servers say about the
+// people on them — a fourth subject beside the bridge, the permissions and the
+// mod configuration.
+//
+// **Every route is `requireRole('admin')`.** The tier's own gate admits editors
+// and moderators, and a moderator widening the roll call to the public is the
+// decision the org lead settled should be deliberate. Reading is gated the same
+// as writing: the screen is one form, and a view of the settings without the
+// power to change them is not something anybody has asked for.
+
+const core = require('../../core')
+
+const express = core.express
+const visibility = require('./visibility.controller')
+const { requireRole, validate } = core.middleware
+const { body } = core.validator
+
+const visibilityRouter = express.Router()
+
+const AUDIENCES = ['staff', 'signed_in', 'public']
+
+visibilityRouter.get(
+  '/',
+  // #swagger.tags = ['Admin · Rust']
+  // #swagger.summary = 'Who may see who is online'
+  // #swagger.description = 'The fleet default and every server’s optional override. It governs the Online list, every feed item that names a player who was on the server (connects, respawns, deaths, chat, tallies) and the leaderboard’s `lastSeen`. The default is `staff`: nothing names who is online until an operator widens it. The player count is public at every setting.'
+  /* #swagger.responses[200] = { description: 'The fleet default and each server', content: { "application/json": { schema: { $ref: "#/components/schemas/RustVisibility" } } } } */
+  requireRole('admin'),
+  visibility.read,
+)
+
+visibilityRouter.put(
+  '/',
+  // #swagger.tags = ['Admin · Rust']
+  // #swagger.summary = 'Change who may see who is online'
+  // #swagger.description = 'Sets the fleet default, one or more server overrides, or both. A server set to `null` follows the fleet default again. Validated whole before anything is written: a request naming a server that does not exist changes nothing.'
+  /* #swagger.requestBody = { required: true, content: { "application/json": { schema: { $ref: "#/components/schemas/RustVisibilityUpdate" } } } } */
+  /* #swagger.responses[200] = { description: 'Saved; answers the new state', content: { "application/json": { schema: { $ref: "#/components/schemas/RustVisibility" } } } } */
+  /* #swagger.responses[400] = { description: 'An audience that does not exist' } */
+  /* #swagger.responses[404] = { description: 'A server that does not exist' } */
+  requireRole('admin'),
+  body('fleet').optional().isIn(AUDIENCES).withMessage(`fleet must be one of ${AUDIENCES.join(', ')}`),
+  body('servers').optional().isObject().withMessage('servers maps a server id to an audience or null'),
+  validate,
+  visibility.update,
+)
+
+module.exports = visibilityRouter

server/router/public/rust.controller.js

@@ -13,9 +13,24 @@ const core = require('../../core')
 
 const events = require('../../model/events/events.model')
 const servers = require('../../model/servers/servers.model')
+const visibility = require('../../model/visibility/visibility.model')
 
 const log = core.logger('public')
 
+/**
+ * Marks a response as depending on who asked.
+ *
+ * Three routes below answer differently for a moderator and for a stranger, and
+ * a shared cache in front of the site that stored the moderator's answer would
+ * hand the roll call to the next anonymous visitor. `private` keeps it out of
+ * every cache but the viewer's own; `Vary` says why, for any cache that reads it.
+ */
+function perViewer(res) {
+  res.set('Cache-Control', 'private, no-store')
+  res.vary('Cookie')
+  res.vary('Authorization')
+}
+
 async function listServers(req, res) {
   try {
     res.json({ servers: await servers.listPublic() })
@@ -56,16 +71,26 @@ async function getServer(req, res) {
  * handler.** `events.recent` takes the viewer explicitly and defaults to the
  * public allowlist, so the way to leak an IP address from here is to add an
  * argument rather than to forget one.
+ *
+ * `presence` is resolved per request from the operator's setting. Below it, the
+ * feed carries only what names nobody — a wipe, a start, a shutdown — and says
+ * so with `presenceHidden`, so a page can explain a quiet feed instead of
+ * implying a quiet server.
  */
 async function listEvents(req, res) {
   try {
+    const presence = await visibility.canSeePresence(req, req.params.id)
+    perViewer(res)
     res.json({
       events: await events.recent({
         serverId: req.params.id,
+        presence: presence.visible,
         kind: req.query.kind,
         wipeId: req.query.wipe || null,
         limit: req.query.limit,
       }),
+      presenceHidden: !presence.visible,
+      presenceAudience: presence.required,
     })
   } catch (err) {
     log.error('failed to read events', { server: req.params.id, error: err.message })
@@ -75,12 +100,15 @@ async function listEvents(req, res) {
 
 async function listLeaderboard(req, res) {
   try {
+    const presence = await visibility.canSeePresence(req, req.params.id)
+    perViewer(res)
     res.json({
       leaderboard: await events.leaderboard({
         serverId: req.params.id,
         wipeId: req.query.wipe || null,
         sort: req.query.sort,
         limit: req.query.limit,
+        presence: presence.visible,
       }),
     })
   } catch (err) {
@@ -98,9 +126,34 @@ async function listWipes(req, res) {
   }
 }
 
+/**
+ * Who is on the server right now — or, below the operator's audience, how many.
+ *
+ * The count stays public: it is already on the server list and in the footer,
+ * and a number names nobody. The names do not, by default (the org lead's rule,
+ * `model/visibility`). A hidden answer is still a 200 with the same shape — an
+ * empty `players` array — plus `hidden` and `count`, so a client that predates
+ * the flag renders an empty list rather than breaking, and a current one can say
+ * "12 online" instead of "nobody".
+ */
 async function listOnline(req, res) {
   try {
-    res.json({ players: await events.online(req.params.id) })
+    const presence = await visibility.canSeePresence(req, req.params.id)
+    perViewer(res)
+
+    if (!presence.visible) {
+      const server = await servers.getPublic(req.params.id)
+      res.json({
+        players: [],
+        hidden: true,
+        count: server ? server.players : 0,
+        audience: presence.required,
+      })
+      return
+    }
+
+    const players = await events.online(req.params.id)
+    res.json({ players, hidden: false, count: players.length, audience: presence.required })
   } catch (err) {
     log.error('failed to read presence', { server: req.params.id, error: err.message })
     res.status(500).json({ message: 'Failed to read who is online' })

server/router/public/rust.router.js

@@ -68,7 +68,7 @@ rustRouter.get(
   '/servers/:id/events',
   // #swagger.tags = ['Public · Rust']
   // #swagger.summary = 'Recent events on one Rust server'
-  // #swagger.description = 'The killfeed and everything else public that happened on a server, newest first. Narrow with `kind` (comma-separated) and `wipe`. Only publicly classified kinds are ever returned — moderation events, login attempts and anything carrying an IP address are stored but never served here.'
+  // #swagger.description = 'The killfeed and everything else public that happened on a server, newest first. Narrow with `kind` (comma-separated) and `wipe`. Only publicly classified kinds are ever returned — moderation events, login attempts and anything carrying an IP address are stored but never served here. Kinds that name a player who was on the server (connects, respawns, deaths, chat, tallies) are served only to viewers inside the operator’s presence audience, which defaults to staff; `presenceHidden` says when they were withheld.'
   // #swagger.parameters['id'] = { in: 'path', required: true, description: 'The server’s slug', schema: { type: 'string' } }
   // #swagger.parameters['kind'] = { in: 'query', required: false, description: 'One kind, or several comma-separated', schema: { type: 'string' } }
   // #swagger.parameters['wipe'] = { in: 'query', required: false, description: 'Restrict to one wipe id', schema: { type: 'string' } }
@@ -82,7 +82,7 @@ rustRouter.get(
   '/servers/:id/leaderboard',
   // #swagger.tags = ['Public · Rust']
   // #swagger.summary = 'The leaderboard for one Rust server'
-  // #swagger.description = 'Per-wipe when `wipe` is given, all-time otherwise. All-time is the per-wipe rows summed rather than a second set of counters, so a wipe splits a player’s history without ending it.'
+  // #swagger.description = 'Per-wipe when `wipe` is given, all-time otherwise. All-time is the per-wipe rows summed rather than a second set of counters, so a wipe splits a player’s history without ending it. `lastSeen` is withheld below the operator’s presence audience: a gather tally refreshes it every minute a player is on, so it would name who is online.'
   // #swagger.parameters['id'] = { in: 'path', required: true, description: 'The server’s slug', schema: { type: 'string' } }
   // #swagger.parameters['wipe'] = { in: 'query', required: false, description: 'Restrict to one wipe id', schema: { type: 'string' } }
   // #swagger.parameters['sort'] = { in: 'query', required: false, description: 'kills, deaths, npcKills or playtime', schema: { type: 'string' } }
@@ -107,9 +107,9 @@ rustRouter.get(
   '/servers/:id/online',
   // #swagger.tags = ['Public · Rust']
   // #swagger.summary = 'Who is on one Rust server right now'
-  // #swagger.description = 'Read from the presence board the bridge re-sends on every connect and every minute, rather than counted from connect and disconnect events — so it is correct even after the website has missed one.'
+  // #swagger.description = 'Read from the presence board the bridge re-sends on every connect and every minute, rather than counted from connect and disconnect events — so it is correct even after the website has missed one. **Nothing names who is online by default**: below the operator’s presence audience (staff unless widened) the names are withheld and only `count` is answered.'
   // #swagger.parameters['id'] = { in: 'path', required: true, description: 'The server’s slug', schema: { type: 'string' } }
-  /* #swagger.responses[200] = { description: 'Who is online' } */
+  /* #swagger.responses[200] = { description: 'Who is online — or, below the operator’s presence audience, only how many', content: { "application/json": { schema: { $ref: "#/components/schemas/RustOnline" } } } } */
   siteMode,
   servers.listOnline,
 )