feat(rust): Rust's own world events — feed, credit rule, triggers, Call a world event (PLAN_REDESIGNS §14.3.1)

The site half of stage 1, on protocol 14:

- server/worldEvents.js: the 24 types, D372's four credit rules, the grid
  from the map's geometry (none off the map), and the per-viewer reading.
- The feed serves `world.event` (a public kind): an unknown type is staff's;
  the event and its grid are public; names only for the presence audience
  (D376); Steam ids and positions only for staff (D353). A downed one carries
  `credited`/`creditedCount` by the server's rule. Client lines for all 24
  types and a World events filter.
- rust_servers.credit_rule (blow, last, most, all; default blow), set on the
  server's settings. Ingest counts heli_kills (patrol helicopters and
  Chinooks, D379) and apc_kills from `world.event` by that rule, so the line
  and Rotorbane / Tankbreaker agree. A protocol-13 tally's heliKills/apcKills
  still add as before.
- The tally's cratesHacked / dropsLooted → crates_hacked / drops_looted;
  title categories Safecracker and Scavenger (D356); leaderboard columns
  Crates hacked and Drops looted, sortable (D377).
- 24 engagement triggers rust.world.<event> (D355): ceiling everyone,
  cooldown subject the server and event (crates add where), names only.
- server/eventWorldCall.js: rust.world.call, "Call a world event"
  (risk change, reversible none, budget rust.world.calls). A position for an
  airdrop or a patrol helicopter only; the Chinook takes none (D378).

Server 585/585 (22 new in test/worldEvents.test.js), client 84/84, every
check; booted against the pinned core (43 triggers, 12 actions, 10 budgets,
20 option sources), routes.manifest unchanged at 89. Engagement manifest and
swagger fragment regenerated.

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

client/src/components/Leaderboard.jsx

@@ -30,6 +30,10 @@ const COLUMNS = [
   { key: 'npcKills', label: 'NPC kills', sort: 'npcKills', value: (r) => count(r.npcKills) },
   { key: 'structures', label: 'Structures', sort: null, value: (r) => count(r.structures) },
   { key: 'playtimeSec', label: 'Played', sort: 'playtime', value: (r) => duration(r.playtimeSec) },
+  // Rust's own world events (protocol 14, D356, D377): the counts Safecracker
+  // and Scavenger rank, on every server, since the game itself raises them.
+  { key: 'cratesHacked', label: 'Crates hacked', sort: 'cratesHacked', value: (r) => count(r.cratesHacked) },
+  { key: 'dropsLooted', label: 'Drops looted', sort: 'dropsLooted', value: (r) => count(r.dropsLooted) },
 ]
 
 // The richest (PLAN_REDESIGNS §11.2.2): the last known Economics balance. The

client/src/lib/feed.js

@@ -44,6 +44,9 @@ export const FEED_KINDS = Object.freeze([
   // The death names its killer, so the server shows it only where presence is on.
   'npc.boss.spawned',
   'npc.boss.died',
+  // Rust's own world events (protocol 14, PLAN_REDESIGNS §14.3.1): the server
+  // reads each one for the viewer, so a name is here only where it may be.
+  'world.event',
 ])
 
 /** The filters the feed offers, and the kinds each one asks the API for. */
@@ -58,6 +61,7 @@ export const FILTERS = Object.freeze([
   },
   { id: 'server', label: 'Server', kinds: ['server.wipe', 'server.initialized', 'server.shutdown'] },
   { id: 'bosses', label: 'Bosses', kinds: ['npc.boss.spawned', 'npc.boss.died'] },
+  { id: 'world', label: 'World events', kinds: ['world.event'] },
 ])
 
 export function kindsFor(filterId) {
@@ -144,6 +148,9 @@ export function describe(row) {
         : { tone: 'death', actor: name, verb: 'was killed', subject: null, detail: fought }
     }
 
+    case 'world.event':
+      return worldLine(frame)
+
     default:
       return { tone: 'other', actor: name, verb: String((row && row.kind) || 'unknown'), subject: null, detail: '' }
   }
@@ -193,4 +200,107 @@ function death(frame, name) {
   }
 }
 
+/** Where a locked crate is, as the end of a sentence. */
+const CRATE_PLACES = Object.freeze({
+  oilrig_large: 'on Large Oil Rig',
+  oilrig_small: 'on Small Oil Rig',
+  cargo: 'on the cargo ship',
+  ghostship: 'on a ghost ship',
+  chinook: 'dropped by a Chinook',
+})
+
+/**
+ * Who a downed helicopter, Chinook or Bradley credits, as a phrase: "Alice",
+ * "Alice and Bob", "Alice, Bob and 2 others". Null when the line names nobody
+ * — below the presence audience the server sends `creditedCount` and no names.
+ */
+export function creditedPhrase(frame) {
+  const names = (Array.isArray(frame.credited) ? frame.credited : []).map((c) => c && c.name).filter(Boolean)
+  if (names.length === 0) return null
+  const total = Math.max(names.length, Number(frame.creditedCount) || 0)
+  const shown = names.slice(0, 2)
+  const more = total - shown.length
+  if (more > 0) return `${shown.join(', ')} and ${more} other${more === 1 ? '' : 's'}`
+  return shown.length === 2 ? `${shown[0]} and ${shown[1]}` : shown[0]
+}
+
+/**
+ * Rust's own world events (protocol 14), one sentence per type. The server has
+ * already read the frame for this viewer: it carries `grid`, a `name` only for
+ * the presence audience, and `credited` by the server's rule (D372, D376). A
+ * line therefore never decides who may read a name; it only says what it has.
+ */
+function worldLine(frame) {
+  const grid = frame.grid || ''
+  const who = frame.name || null
+  const place = CRATE_PLACES[frame.where] || 'somewhere on the map'
+  const by = creditedPhrase(frame)
+  const downed = (what) => (by
+    ? { tone: 'kill', actor: null, verb: `${what} by`, subject: by, detail: grid }
+    : { tone: 'kill', actor: null, verb: what, subject: null, detail: grid })
+  const say = (verb, detail = grid) => ({ tone: 'server', actor: null, verb, subject: null, detail })
+  const harbour = frame.harbourName || 'the harbour'
+
+  switch (frame.event) {
+    case 'heli.arrived':
+      return say('A patrol helicopter has arrived')
+    case 'heli.left':
+      return say('The patrol helicopter has left', '')
+    case 'heli.downed':
+      return downed('Patrol helicopter downed')
+    case 'chinook.downed':
+      return downed('Chinook shot down')
+    case 'bradley.destroyed':
+      return downed(frame.where === 'launch_site' ? "Launch Site's Bradley destroyed" : frame.where === 'road' ? 'Road Bradley destroyed' : 'Bradley destroyed')
+    case 'bradley.spawned': {
+      const n = Number(frame.count) || 1
+      if (frame.where === 'road') return say(n > 1 ? `${n} road Bradleys are out` : 'A road Bradley is out', '')
+      return say('Bradley is patrolling Launch Site', '')
+    }
+    case 'cargo.arrived':
+      return say('The cargo ship has arrived')
+    case 'cargo.docking':
+      return say(`The cargo ship is docking at ${harbour}`)
+    case 'cargo.docked':
+      return say(`The cargo ship has docked at ${harbour}`)
+    case 'cargo.undocked':
+      return say(`The cargo ship has cast off from ${harbour}`)
+    case 'cargo.left':
+      return say('The cargo ship is leaving', '')
+    case 'chinook.arrived':
+      return say('A Chinook is inbound with a locked crate')
+    case 'chinook.dropped':
+      return say(frame.monumentName ? `A Chinook dropped a locked crate at ${frame.monumentName}` : 'A Chinook dropped a locked crate')
+    case 'airdrop.called':
+      return who ? { tone: 'server', actor: who, verb: 'called an airdrop', subject: null, detail: grid } : say('An airdrop is on its way')
+    case 'airdrop.landed':
+      return say('An airdrop has landed', [who ? `called by ${who}` : null, grid].filter(Boolean).join(' · '))
+    case 'airdrop.looted':
+      return who ? { tone: 'server', actor: who, verb: 'looted an airdrop', subject: null, detail: grid } : say('An airdrop was looted')
+    case 'crate.hack.started':
+      return who
+        ? { tone: 'server', actor: who, verb: `started hacking the locked crate ${place}`, subject: null, detail: grid }
+        : say(`A locked crate is being hacked ${place}`)
+    case 'crate.unlocked':
+      return say(`The locked crate ${place} is open`)
+    case 'crate.looted':
+      return who
+        ? { tone: 'server', actor: who, verb: `looted the locked crate ${place}`, subject: null, detail: grid }
+        : say(`The locked crate ${place} was looted`)
+    case 'vendor.arrived':
+      return say('The Travelling Vendor has arrived')
+    case 'vendor.left':
+      return say('The Travelling Vendor has left', '')
+    case 'satellite.crashed':
+      return say('A satellite has crashed')
+    case 'deepsea.opened':
+      return say('The Deep Sea is open', '')
+    case 'deepsea.closed':
+      return say('The Deep Sea has closed', '')
+    default:
+      // A type this build has no words for, which only staff are sent: its own name.
+      return { tone: 'other', actor: who, verb: String(frame.event || 'world event'), subject: null, detail: grid }
+  }
+}
+
 export default { describe, FEED_KINDS, FILTERS, kindsFor }

client/src/routes/admin/ServerSettings.jsx

@@ -38,6 +38,16 @@ const RULES = [
   { id: 'biweekly', label: 'Every other week', hint: 'Every second week, on the weeks the date below falls in, and the forced wipe.' },
 ]
 
+// Who a downed patrol helicopter, Chinook or Bradley credits (protocol 14, D372).
+// The same rule writes the feed line and the Rotorbane / Tankbreaker counts; the
+// server's own list, mirrored here so the form needs no round trip.
+const CREDIT_RULES = [
+  { id: 'blow', label: 'Killing blow', hint: 'The player whose hit destroyed it — for the patrol helicopter, the crippling hit, else the last hit. The default.' },
+  { id: 'last', label: 'Last hit', hint: 'The last player to hurt it.' },
+  { id: 'most', label: 'Most damage', hint: 'The player who dealt it the most damage.' },
+  { id: 'all', label: 'Everyone who hurt it', hint: 'Every player who damaged it, one each.' },
+]
+
 const DAYS = ['Sunday', 'Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday', 'Saturday']
 
 const SOURCE = { forced: 'the forced wipe', rule: 'its own schedule', once: 'the one-off date' }
@@ -110,6 +120,7 @@ function blankForm() {
     wipeTz: localZone(),
     wipeAnchor: '',
     wipeOnce: '',
+    creditRule: 'blow',
   }
 }
 
@@ -131,6 +142,7 @@ function formFrom(server) {
     wipeAnchor: s.anchor || '',
     wipeOnce: toLocalInput(s.onceAt),
     storedOnceAt: s.onceAt || null,
+    creditRule: server.creditRule || 'blow',
   }
 }
 
@@ -155,6 +167,7 @@ function bodyFrom(form) {
       ? null
       : new Date(form.wipeOnce).toISOString(),
   }
+  if (form.creditRule) body.creditRule = form.creditRule
   if (form.sidecarToken) body.sidecarToken = form.sidecarToken
   if (form.protocol !== undefined) body.protocol = form.protocol
   return body
@@ -409,6 +422,17 @@ function ServerForm({ form, set, busy, error, onSave, onCancel }) {
           </p>
         )}
       </fieldset>
+      <fieldset style={{ border: '1px solid var(--line-soft)', borderRadius: 8, padding: '12px 14px', display: 'grid', gap: 12 }}>
+        <legend className="sans" style={{ color: 'var(--head)', fontSize: '0.86rem', padding: '0 6px' }}>World events</legend>
+        <Field
+          label="Who downs a helicopter or a Bradley"
+          hint={`${(CREDIT_RULES.find((r) => r.id === form.creditRule) || CREDIT_RULES[0]).hint} It names them in the feed and counts toward Rotorbane and Tankbreaker, from now on.`}
+        >
+          <select value={form.creditRule} onChange={set('creditRule')} style={inputStyle}>
+            {CREDIT_RULES.map((r) => <option key={r.id} value={r.id}>{r.label}</option>)}
+          </select>
+        </Field>
+      </fieldset>
       <datalist id="rust-zones">{ZONES.map((z) => <option key={z} value={z} />)}</datalist>
 
       <div className="sans" style={{ display: 'flex', alignItems: 'center', gap: 12 }}>