docs(ci): use the actual case-sensitive SonarQube project keys

link and Android-app reuse the pre-existing capitalised keys (Runic-Gateway-link, Runic-Gateway-Android-app); the server rejects case-variant duplicates. Note the case-sensitivity gotcha. Co-Authored-By: Claude <noreply@anthropic.com>
2026-07-20 23:21:04 -05:00
5 changed files with 21 additions and 422 deletions
--- a/android/PLAN.md
+++ b/android/PLAN.md
@@ -419,29 +419,21 @@ console. It is a **read + self-service** app, not an operator tool.
 - **Access-level menu**: one shared navigation that reveals items based on the signed-in user's role.
 - **Opt-in push notifications** (post-v1; architected for from the start): per-stream subscriptions the
  user chooses — nothing is pushed unless subscribed. See §11.
 - **Staff operations subset** (post-v1, **M10** — decided 2026-07-21): a *defined* slice of the admin
  surface, native, for `admin`/`moderator` staff. In scope: **moderation actions** (kick / ban / unban /
  broadcast), the **support (help-page) queue** (reply / close / resolve), the **dashboard summary +
  site-mode** toggle, and **content management** (news posts — list / create / edit / publish / delete —
  plus wiki category & tag management). These consume the existing `/api/v1/admin/**` routes (which
  already accept bearer auth and re-check role every request); no backend routes are added. See §6.4 + §10.
 ### Explicitly OUT of scope (never in the app, for any role)
-The exclusions are now a *narrow* list (M10 brought the operational admin subset in-scope, above). The
+- The **hero editor** and any CMS authoring/block editing.
-app still never ships:
+- The **admin / auth-management console** — user management, invites issuance, SSO provider config,
- The **hero editor** and CMS **block/page authoring** (the visual page builder). *(News-post and
+  moderation console, email config, bot-activity/ban console. (Players still *log in*; what's
-  wiki category/tag management ARE in scope; the excluded piece is the CMS block editor / hero builder.)*
+  excluded is the management surface, not authentication itself.)
- **Discord bot** configuration (and anything under the unpublished `/internal/**` port — it returns the
+- The **Discord bot** management (and anything under the unpublished `/internal/**` port — it
-  decrypted bot token and must never be reachable from a client).
+  returns the decrypted bot token and must never be reachable from a client).
- **uo-link / sidecar administration** — the shard sidecar base-URL/token config (`uoLinkConfig`). (The
+- **Shard / uo-link administration** — sidecar base-URL/token config (`uoLinkConfig`), shard ops,
-  app performs *shard operations* like kick/ban/broadcast against the live shard, but never configures
+  the staff shard-user console. (The app shows *public* shard widgets and a player's *own* game
-  the sidecar connection itself.)
+  data; it does not manage the sidecar.)
 - **OAuth / SSO provider setup** — creating/editing identity providers and their client secrets.
-> The app calls `/api/v1/public/**`, `/api/v1/auth/**` (incl. the role-agnostic self surface
+> The excluded surfaces all live under `/api/v1/admin/**` and `/api/v1/internal/**`. The app only
-> `/auth/me/*`, §6.4), `/api/v1/player/**`, and — for staff, M10 — the **defined `/api/v1/admin/**`
+> ever calls `/api/v1/public/**`, `/api/v1/auth/**` (incl. the new role-agnostic self surface
-> operations listed above. It never touches `/api/v1/internal/**`, nor the four excluded admin surfaces
+> `/auth/me/*`, §6.4), and `/api/v1/player/**` — it never references `/admin`.
 > (hero/CMS block editor, Discord-bot config, uo-link config, OAuth-provider setup).
 ---
@@ -499,13 +491,7 @@ compiled in.
  `/public/settings` for branding: name/colors/logo). Only on a successful, well-formed response is
  the URL persisted to DataStore and the app allowed to initialize its main UI.
  - Accept `https://host[/base]`; normalize/trim; require HTTPS in release builds (allow HTTP only in
-    debug for local dev against `127.0.0.1:3000`). This app-layer rule (`ServerUrl`,
+    debug for local dev against `127.0.0.1:3000`).
    `allowInsecureHttp = BuildConfig.DEBUG`) is backed at the platform socket layer by an explicit
    **network security config** (`res/xml/network_security_config.xml`, wired via
    `application android:networkSecurityConfig`): the main/release config permits **no** cleartext,
    and a debug-only override (`app/src/debug/res/xml/`) re-permits cleartext to loopback
    (`127.0.0.1`/`localhost`) only. Being explicit also stops a merged library manifest from
    re-enabling cleartext and clears the `usesCleartextTraffic`-implicitly-enabled scanner finding.
  - Failure states: unreachable, non-2xx, not-a-Runic-Gateway-site (missing expected `/public/status`
    shape), TLS error — each gets a clear retry message. Nothing else in the app runs until this
    succeeds.
@@ -643,18 +629,11 @@ Guidelines:
 Player self-service is under `/player/account/*` (gated to `role='player'`) and staff use the *same*
 handlers under `/admin/account/*`. Rather than have the app branch by role (and touch `/admin`), we
 **add a role-agnostic self surface under `/auth/**`** — the canonical "me" endpoints for every role.
-The app calls these regardless of role. This is an **additive v1**
+The app calls these regardless of role, and never references `/admin`. This is an **additive v1**
 change (see §8): the existing `/player/account/*` and `/admin/account/*` routes stay for web
 back-compat; `/auth/me/*` reuses the same `account.controller` handlers behind `requireAuth` (any
 authenticated role), so there's no logic duplication.
 > **M10 update (2026-07-21):** *self-service* stays role-agnostic under `/auth/me/*` as above. Separately,
 > the **operational** admin subset (§1, §10 — moderation, support queue, dashboard/site-mode, content)
 > *does* call `/api/v1/admin/**` directly, gated to staff by a new `STAFF`/`ADMIN` menu access level.
 > The earlier "the app never references `/admin`" rule is superseded for these defined staff operations
 > only; `validateSession` accepts the mobile bearer on those routes and `requireRole` re-checks every
 > request, so a demoted user loses the surface immediately (the app treats any `403` as authoritative).
 ---
 ## 7. Degradation & offline
@@ -823,25 +802,6 @@ push, and Play (M6–M8) follow the designed app.
      generic build stays custom-scheme; white-label/first-party builds bake one host). The custom
      scheme remains the permanent fallback on every build. Full spec + rollout in
      [`APP_LINKS.md`](./APP_LINKS.md).
 11. **M10 — Native SSO fixes + staff operations** (post-v1; decided 2026-07-21). Two threads found
    during on-device QA:
    - **SSO discovery + reachability fixes (app-only, done):** the native login screen only rendered
      provider buttons when `GET /auth/providers` was non-empty and otherwise fell back to the desktop
      website login (which can't deep-link a mobile session back → it hung). `AuthRepository.ssoProviders()`
      now returns `Available` / `None` / `Unavailable` (retry once); the login screen shows native
      buttons / a loading hint / a retry, and the website-login fallback is removed. The pending PKCE
      `{state,verifier}` is persisted (encrypted `PendingSsoStore`) so the exchange survives Custom-Tab
      process death. The nav drawer is now `verticalScroll`-wrapped so a signed-in session's longer menu
      (which includes **Notifications**) can't clip on short screens. Dev testing uses a **stub OAuth IdP**
      (`website/scripts/dev/`), since dev configures no real provider. Verified end-to-end on an emulator.
    - **Staff operations (§1, §6.4):** a new `STAFF`/`ADMIN` menu access level reveals a staff section
      for `admin`/`moderator`, with native screens over the existing `/api/v1/admin/**`: **moderation**
      (`POST /admin/shard/{kick,ban,unban,broadcast}`), **support queue** (`GET /admin/shard/pages`,
      `POST /admin/shard/pages/:id/{respond,close}`), **dashboard + site-mode** (`GET /admin/dashboard`,
      `PUT /admin/site-mode`), and **content** (news posts under `/admin/posts*`, wiki categories/tags
      under `/admin/wiki/*`). No backend routes added (they already accept bearer + re-check role);
      shard-write actions degrade gracefully when the sidecar is offline. Excluded: hero/CMS block
      editor, Discord-bot config, uo-link config, OAuth-provider setup.
 ---
--- a/ci/SONARQUBE.md
+++ b/ci/SONARQUBE.md
@@ -16,8 +16,13 @@ feeds the dashboard.
 | Repo | Project key | Sources analysed | Language |
 |---|---|---|---|
 | `website` | `runic-gateway-website` | `server/src`, `client/src`, `bot/src` | JS/TS |
-| `link` | `runic-gateway-link` | `sidecar/src` | Rust |
+| `link` | `Runic-Gateway-link` | `sidecar/src` | Rust |
-| `Android-app` | `runic-gateway-android-app` | `app/src/main` | Kotlin |
+| `Android-app` | `Runic-Gateway-Android-app` | `app/src/main` | Kotlin |
 > Project keys are **case-sensitive** and must match what already exists on the
 > server — SonarQube refuses to create a key that differs only in case from an
 > existing one. `link` and `Android-app` reuse the pre-existing capitalised keys
 > above; `website` predates this note with its lower-case key.
 ## How it's wired
--- a/website/ARCHITECTURE.md
+++ b/website/ARCHITECTURE.md
@@ -1,114 +0,0 @@
 # Website — Architecture
 How the pieces of `RunicGateway/website` fit together. The React SPA and the native mobile app
 talk to one Express backend (`router → controller → model → db`), which persists to MariaDB and
 bridges to the live game world **only** through the **uo-link** sidecar. The ServUO shard itself is
 never internet-facing — it dials out to the sidecar over loopback, and only the sidecar is exposed.
 This is the canonical copy of the diagram; the same diagram is embedded in the website's
 [`README.md`](https://gitea.whitlocktech.com/RunicGateway/website/src/branch/main/README.md#architecture).
 See [BACKEND_DESIGN.md](BACKEND_DESIGN.md) for the full API / schema / security contract, and
 [`docs/link/`](../link/) for the wire protocol between the sidecar and the shard.
 ```mermaid
 flowchart TB
    %% ---------- Clients ----------
    subgraph clients["Clients"]
        browser["Browser<br/>React + Vite SPA<br/>(public · wiki · admin)"]
        mobile["Native mobile app<br/>(bearer tokens)"]
    end
    idp["SSO providers<br/>Google · Discord · custom OIDC"]
    discord["Discord"]
    %% ---------- Website (one repo) ----------
    subgraph website["website/ &nbsp;— Node app (one repo)"]
        direction TB
        subgraph backend["server/ — Express backend"]
            direction TB
            mw["Middleware<br/>helmet · siteMode · noindex<br/>rateLimit · loginProtection · botScore · validate"]
            router["Router /api/v1<br/>auth (web · mobile · sso) · public · admin"]
            ctrl["Controllers"]
            auth["Session layer (auth/)<br/>sessionService · JWT/cookie · bearer · SSO+PKCE"]
            model["Models (.model + .db)<br/>raw parameterized SQL — no ORM"]
            sse["SSE fan-out<br/>public stream (allowlist) · admin stream (sensitive)"]
            subgraph shardutil["Shard integration (utils/)"]
                ingest["shardIngest.js<br/>WS ingest dispatcher"]
                restcli["uoLinkClient.js<br/>REST client (never throws)"]
            end
            secret["secretBox.js<br/>AES-256-GCM secrets at rest"]
        end
        bot["bot/<br/>Discord bot"]
    end
    db[("MariaDB<br/>users · posts · wiki · settings · activity<br/>mobileSessions · authProviders · userIdentities<br/>uoLinkConfig · shard_online/economy/houses/events")]
    %% ---------- Shard side ----------
    subgraph shardside["Game shard (never internet-facing)"]
        direction TB
        sidecar["uo-link sidecar<br/>(Rust) — the only bridge exposed"]
        servuo["ServUO shard<br/>(C# plugin)"]
    end
    %% ---------- Edges ----------
    browser <-->|"same-origin JSON + SSE (cookie)"| mw
    mobile -->|"REST (bearer access/refresh)"| mw
    browser -.->|"OAuth redirect + PKCE"| idp
    auth -.->|"token exchange"| idp
    mw --> router --> ctrl
    ctrl --> auth
    ctrl --> model
    ctrl --> restcli
    ctrl --> sse
    auth --> model
    model <--> db
    auth -. reads/writes secrets .-> secret
    restcli -. reads config/token .-> secret
    ingest --> model
    ingest --> sse
    sse -->|"live events"| browser
    bot -->|"messages"| discord
    bot <--> db
    restcli -->|"REST: /char /roster /economy /history · /link/confirm · /towncrier"| sidecar
    sidecar -->|"WebSocket live event feed (bearer + X-UOLink-Version)"| ingest
    servuo -->|"loopback TCP 127.0.0.1:7788<br/>newline-delimited JSON (shard dials out)"| sidecar
    %% ---------- Styling ----------
    classDef ext fill:#2d2233,stroke:#7a5c94,color:#e8dff0;
    classDef store fill:#1f2d2a,stroke:#4c8c7d,color:#dff0ea;
    classDef bridge fill:#2d2620,stroke:#94764c,color:#f0e6d8;
    class idp,discord ext;
    class db store;
    class sidecar,servuo bridge;
 ```
 ## Notes on the diagram
 - **One backend, layered.** Every request flows `middleware → router → controller → model → db`.
  Web browsers authenticate with an httpOnly JWT cookie; the native app uses short-lived bearer
  access tokens plus rotated, hashed, revocable refresh tokens; SSO (Google/Discord/OIDC) is
  link-only and PKCE-guarded. All three surfaces resolve to the *same* session model via the session
  layer, and admin routes are re-validated against the DB on every request.
 - **The shard is never reachable.** The ServUO shard *dials out* over loopback TCP `127.0.0.1:7788`
  (newline-delimited JSON) to the uo-link sidecar; only the sidecar is exposed, and only the backend
  talks to it. Every backend→sidecar call carries `Authorization: Bearer <token>` and an
  `X-UOLink-Version` header (a protocol mismatch fails fast with `409`). The REST client
  (`uoLinkClient.js`) never throws — every call returns `{ ok, data, status }` — so the site degrades
  gracefully when the shard is down.
 - **Two ways in from the sidecar.** Live game events arrive over an outbound **WebSocket** and are
  routed by the `shardIngest.js` dispatcher (state-changing kinds update `shard_*` tables, notable
  kinds append to `shard_events`, high-frequency kinds only update state). Point-in-time reads and
  commands go over **REST** through `uoLinkClient.js`.
 - **Sensitive events stay private.** Ingested events fan out to browsers over two **SSE** channels —
  a public allowlist stream and an admin-only stream that additionally carries staff audit, cheat
  detection, and login-attempt events. The allowlist split is a security boundary; sensitive kinds
  can never leak onto the public channel.
 - **Secrets at rest.** OAuth client secrets, the uo-link token, and the Gmail refresh token are
  AES-256-GCM encrypted via `secretBox.js` (keyed by `SECRET_ENC_KEY`). The uo-link token is
  write-only in the API — never returned to any client.
--- a/website/test-plan.md
+++ b/website/test-plan.md
@@ -1,154 +0,0 @@
 # Runic Gateway Website — Test Plan (Discord bot)
 > Companion to [website-README.md](website-README.md) (overview) and
 > [BACKEND_DESIGN.md](BACKEND_DESIGN.md) (server API/schema/security contract).
 > Establishes the test plan for the **`bot/` workspace** (the Discord bot), the
 > last of the three `website` npm workspaces without a suite. The server and
 > client suites already exist (website PR #86); this doc closes the bot gap and
 > records the shared conventions so all three stay consistent.
 ## 1. Goal & philosophy
 Cover **meaningful bot behavior** — the moderation/filter decisions a future
 change could silently break — not a coverage number. The bot's value is in *what
 it decides to delete, warn, mute, or let through*; a good test reads "given this
 message + config, what action does the bot take?", never "did this function call
 that function?".
 The whole `website` repo tests on **Node's built-in runner (`node --test`)** with
 **zero external test dependencies** — no jest, no vitest, no jsdom. Unit tests
 run without a database or a live Discord gateway: the DB pool is pointed at a dead
 port and every collaborator (`db.query`, a model, a Discord `message`/`client`) is
 replaced with an in-memory fake. This mirrors the server suite exactly (the bot is
 CommonJS, like the server — `require`/`module.exports` — so the same patterns
 apply verbatim).
 ## 2. Current state
 | Workspace | Runner | Status |
 |---|---|---|
 | `server/` | `node --test` | **Exists** — models, controllers, auth/session, shard ingest. |
 | `client/` | `node --test` (pure-logic ESM) | **Exists** (PR #86) — `lib/`, `api/`, `data/`. |
 | `bot/` | — | **This plan** — no runner or tests yet. |
 The 46% SonarQube aggregate is dragged down by the bot (and the client's
 un-unit-testable React components) reading as 0% covered. Standing up the bot
 suite lifts the real number and, more importantly, locks the filter/moderation
 rules.
 ## 3. Harness
 Add a test script to `bot/package.json` (mirrors server/client):
 ```json
 "scripts": { "test": "node --test" }
 ```
 Conventions, identical to `server/test/`:
 - **No DB.** Set `process.env.DB_HOST = '127.0.0.1'` / `DB_PORT = '59999'` at the
  top of any test whose module transitively `require`s `../db`, so the pool is
  built against a dead port and a stray query fails fast instead of hanging.
  Models are exercised by monkeypatching `db.query` (or the model method the unit
  under test calls) with an in-memory fake; restore it in `afterEach`.
 - **No Discord.** The `discord.js` `Client`, `Message`, `GuildMember`, and
  `Interaction` objects are hand-rolled fakes carrying only the fields the unit
  reads (e.g. `message.mentions.users.size`, `message.member.roles.cache`,
  `message.client.fetchInvite`). Never construct a real client or open a gateway
  connection.
 - **Tests live in `bot/test/*.test.js`.** One file per module under test.
 ## 4. Units to cover
 Ordered high-value first. Each row names the module, the behavior worth locking,
 and the seam a test drives it through.
 ### 4.1 Pure logic (no mocks beyond inputs)
 | Module | Behaviors to lock | Notes |
 |---|---|---|
 | `filter/normalize.js` | leetspeak folding (`b4d`→`bad`, `@ss`→`ass`), 3+-repeat collapse (`sooooo`→`so`), case-fold; `matches()` is word-boundary anchored (so `bad` does not fire inside `badminton`); `findMatch()` returns the first `{word, severity}` row or `null`; the *documented gaps* stay gaps (spaced-out `b a d` is **not** caught). | The core obfuscation-resistance contract. Pin the gaps too, so a future tightening is a deliberate, test-visible change. |
 | `utils/duration.js` | `"30s"/"10m"/"2h"/"1d"` → correct ms; whitespace tolerated; garbage/empty/unknown-unit → `null`; `MAX_TIMEOUT_MS` is 28 days (the Discord cap callers clamp to). | Feeds `/mute` and temp-role expiry — a wrong parse mutes for the wrong span. |
 | `filter/spamFilter.js` | `isRateLimited` trips on the 6th message inside the 5 s window and is per-`guild:user`; it has a **side effect** (records the timestamp) so it must be called once; `isMassMention` counts users **+** roles against the threshold; `isMassEmoji` counts custom `<:name:id>` and unicode pictographs. | Drive time with a stubbed `Date.now` (or accept the real clock and use tight windows). The module-load `setInterval(...).unref()` sweep must not keep the runner alive — `.unref()` already handles this; assert no leak by letting the suite exit. |
 ### 4.2 Logic with a single mocked collaborator
 | Module | Behaviors to lock | Seam / mock |
 |---|---|---|
 | `filter/inviteFilter.js` | returns the **code** (not a bool) of the first *foreign* invite; an invite resolving to the current guild is allowed; an invite that **fails to resolve** (expired/invalid) is treated as foreign (fail-closed); no invite in the message → `null`. | Fake `message.client.fetchInvite(code)` — resolve with `{ guild: { id } }` for local/foreign, or throw for unresolvable. Set `message.guildId` + `message.content`. |
 | `site/siteApiClient.js` | never throws on a network/timeout/HTTP failure — always returns the `{ ok, ... }` shape so a command never breaks when the site is down: `{ ok: true, data }` on success, `{ ok: false, error }` on failure, and the distinct `{ ok: false, maintenance: true, message }` for the site's 503 maintenance response. (Public read client — **no** shared secret; the keyed channel is `botInternalClient.js`.) | Stub `global.fetch` (resolve various statuses/bodies, reject/timeout via `AbortController`). Same non-throwing contract the server's `uoLinkClient` follows. |
 | `internal/requireInternalKey.js` | `401` on a missing/wrong key; `next()` on the configured key; **fail-closed** when `BOT_INTERNAL_KEY` is empty (never matches); timing-safe compare (equal-length + `crypto.timingSafeEqual`, no early-exit length leak). | Call the middleware with a fake `req` (`req.get('X-Internal-Key')`) + `res`/`next` spies; mirrors `server/test/requireInternalKey.test.js`. |
 ### 4.3 The filter pipeline (orchestration)
 `discord/messageFilter.js` is the highest-value integration seam — it composes
 all of §4.1–4.2. Lock the **decision order and the actions**, with every
 collaborator faked:
 - **Bypass wins first:** an allow-listed channel, or a member holding an
  allow-listed role, short-circuits the whole pipeline (`isBypassed`) — no
  delete, no hit recorded.
 - **Order:** invite link → banned word → spam (rate-limit → mass-mention →
  mass-emoji). `detectSpam` must evaluate `isRateLimited` **first and exactly
  once** (it has the timestamp side effect).
 - **Actions:** invite/spam always delete + warn (no severity tiers); a
  word-filter hit applies the action for its severity; filter-triggered mutes use
  the fixed `FILTER_MUTE_SECONDS` (600 s).
 - **Best-effort recording never breaks moderation:** `recordFilterHit` /
  `recordSpamHit` throwing must be swallowed — the delete/warn still happens.
 Mocks: `filterCache` (in-memory `allowChannels`/`allowRoles` Sets + words), a fake
 `message` (content, author, member roles, `delete()`, `guildId`), and spies on
 `warnings`/`filterHits`/`spamHits`/`modLog` to assert what was called.
 ### 4.4 Models (`bot/model/*.js`)
 Thin `db.query` wrappers (e.g. `warnings.js`, `filterWords.js`, `filterHits.js`,
 `spamHits.js`, `memberEvents.js`, `guildConfig.js`, `scheduledMessages.js`,
 `tempRoles.js`). Cover only those with **shaping/branching logic** (a query that
 maps rows, applies an "active/not-expired" predicate, or upserts) by asserting the
 **SQL params** passed to a fake `db.query` and the shape returned. Skip pure
 one-line inserts with no logic — testing those only proves the mock.
 ## 5. Explicitly out of scope
 - **`discord.js` internals / the live gateway** — not ours to test; never open a
  real connection.
 - **Thin command wrappers** (`discord/commands/*.command.js`) that only validate
  args and call a Discord API + a model — cover their *logic* (arg parsing,
  duration clamping) if any, but not the Discord round-trip.
 - **`node-cron` scheduling itself** — test the job's callback logic, not that cron
  fires.
 ## 6. CI & coverage wiring
 Mirror what PR #86 did for the client:
 - **`.gitea/workflows/pr-checks.yml`** — add a `bot-tests` job (or a
  `Run bot tests` step) that runs `npm test --prefix bot`, gating PRs into `main`.
 - **`.gitea/workflows/sonarqube.yml`** — generate a bot LCOV from the repo root so
  `SF:` paths resolve to `bot/src/...`:
  ```
  node --test --experimental-test-coverage \
    --test-reporter=lcov --test-reporter-destination=bot/coverage/lcov.info \
    bot/test/*.test.js
  ```
 - **`sonar-project.properties`** — add `bot/test` to `sonar.tests`, the glob to
  `sonar.test.inclusions`, `bot/coverage/lcov.info` to
  `sonar.javascript.lcov.reportPaths`, and `bot/coverage/**` to `sonar.exclusions`.
  (`bot/src` is already in `sonar.sources`.)
 Bot units need no `npm ci` to run when they import only relative files + Node
 built-ins; a test that stubs `global.fetch` or fakes `db` needs no `discord.js`
 either. Keep the pool pointed at a dead port so the run is hermetic.
 ## 7. Suggested phasing
 1. **Harness + pure logic** — `test` script, then `normalize`, `duration`,
   `spamFilter`. Fast, zero mocks, immediate value.
 2. **Single-collaborator units** — `inviteFilter`, `siteApiClient`,
   `requireInternalKey`.
 3. **Pipeline** — `messageFilter` decision order + actions (the payoff test).
 4. **Models with logic**, then the **CI/Sonar wiring** so it all counts.
--- a/website/website-README.md
+++ b/website/website-README.md
@@ -18,7 +18,6 @@ The design reference is [BACKEND_DESIGN.md](BACKEND_DESIGN.md) (API contract, sc
 ## Contents
 - [Architecture](#architecture)
 - [Tech stack](#tech-stack)
 - [Project structure](#project-structure)
 - [Prerequisites](#prerequisites)
@@ -38,103 +37,6 @@ The design reference is [BACKEND_DESIGN.md](BACKEND_DESIGN.md) (API contract, sc
 ---
 ## Architecture
 How the pieces fit together — the React SPA and native app talk to one Express backend
 (`router → controller → model → db`), which persists to MariaDB and bridges to the live
 game world only through the **uo-link** sidecar. The shard itself is never internet-facing.
 See [ARCHITECTURE.md](ARCHITECTURE.md) for the fuller write-up.
 ```mermaid
 flowchart TB
    %% ---------- Clients ----------
    subgraph clients["Clients"]
        browser["Browser<br/>React + Vite SPA<br/>(public · wiki · admin)"]
        mobile["Native mobile app<br/>(bearer tokens)"]
    end
    idp["SSO providers<br/>Google · Discord · custom OIDC"]
    discord["Discord"]
    %% ---------- Website (one repo) ----------
    subgraph website["website/ &nbsp;— Node app (one repo)"]
        direction TB
        subgraph backend["server/ — Express backend"]
            direction TB
            mw["Middleware<br/>helmet · siteMode · noindex<br/>rateLimit · loginProtection · botScore · validate"]
            router["Router /api/v1<br/>auth (web · mobile · sso) · public · admin"]
            ctrl["Controllers"]
            auth["Session layer (auth/)<br/>sessionService · JWT/cookie · bearer · SSO+PKCE"]
            model["Models (.model + .db)<br/>raw parameterized SQL — no ORM"]
            sse["SSE fan-out<br/>public stream (allowlist) · admin stream (sensitive)"]
            subgraph shardutil["Shard integration (utils/)"]
                ingest["shardIngest.js<br/>WS ingest dispatcher"]
                restcli["uoLinkClient.js<br/>REST client (never throws)"]
            end
            secret["secretBox.js<br/>AES-256-GCM secrets at rest"]
        end
        bot["bot/<br/>Discord bot"]
    end
    db[("MariaDB<br/>users · posts · wiki · settings · activity<br/>mobileSessions · authProviders · userIdentities<br/>uoLinkConfig · shard_online/economy/houses/events")]
    %% ---------- Shard side ----------
    subgraph shardside["Game shard (never internet-facing)"]
        direction TB
        sidecar["uo-link sidecar<br/>(Rust) — the only bridge exposed"]
        servuo["ServUO shard<br/>(C# plugin)"]
    end
    %% ---------- Edges ----------
    browser <-->|"same-origin JSON + SSE (cookie)"| mw
    mobile -->|"REST (bearer access/refresh)"| mw
    browser -.->|"OAuth redirect + PKCE"| idp
    auth -.->|"token exchange"| idp
    mw --> router --> ctrl
    ctrl --> auth
    ctrl --> model
    ctrl --> restcli
    ctrl --> sse
    auth --> model
    model <--> db
    auth -. reads/writes secrets .-> secret
    restcli -. reads config/token .-> secret
    ingest --> model
    ingest --> sse
    sse -->|"live events"| browser
    bot -->|"messages"| discord
    bot <--> db
    restcli -->|"REST: /char /roster /economy /history · /link/confirm · /towncrier"| sidecar
    sidecar -->|"WebSocket live event feed (bearer + X-UOLink-Version)"| ingest
    servuo -->|"loopback TCP 127.0.0.1:7788<br/>newline-delimited JSON (shard dials out)"| sidecar
    %% ---------- Styling ----------
    classDef ext fill:#2d2233,stroke:#7a5c94,color:#e8dff0;
    classDef store fill:#1f2d2a,stroke:#4c8c7d,color:#dff0ea;
    classDef bridge fill:#2d2620,stroke:#94764c,color:#f0e6d8;
    class idp,discord ext;
    class db store;
    class sidecar,servuo bridge;
 ```
 - **One backend, layered.** Every request flows `middleware → router → controller → model → db`.
  Web browsers authenticate with an httpOnly JWT cookie; the native app uses short-lived bearer
  access tokens plus rotated refresh tokens; SSO (Google/Discord/OIDC) is link-only and PKCE-guarded.
  All three surfaces produce the *same* session via the session layer.
 - **The shard is never reachable.** The ServUO shard *dials out* over loopback TCP to the uo-link
  sidecar; only the sidecar is exposed, and only the backend talks to it. The REST client
  (`uoLinkClient.js`) never throws, so the site degrades gracefully when the shard is down.
 - **Sensitive events stay private.** Ingested game events fan out to browsers over two SSE channels —
  a public allowlist stream and an admin-only stream that adds staff audit / cheat / login events.
 ---
 ## Tech stack
 | Layer | Tech |