Merge branch 'chore/frontend-lint'

Includes chore/deps-security-prisma7 (Prisma 7 upgrade and npm audit fixes).

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

CHANGELOG.md

@@ -7,6 +7,182 @@ and this project follows [Semantic Versioning](https://semver.org/).
 
 ## [Unreleased]
 
+## [1.26.0] - 2026-10-21
+
+### Changed
+
+- Upgraded Prisma from 5.22 to 7.10. Prisma 7 connects through the `@prisma/adapter-pg` driver adapter (node-postgres) instead of the Rust query engine. The database URL moved from `schema.prisma` to the new `backend/prisma.config.js`, which loads `backend/.env` itself. All Prisma clients are now created in `src/config/db.js`, and the server shares one client instead of opening two connection pools. No schema or migration changes.
+- Prisma 7 checks TLS certificates on database connections. A `DATABASE_URL` that uses SSL with a self-signed or otherwise invalid certificate now fails to connect where Prisma 5 accepted it.
+- `npm run dev` in the backend now uses Node's built-in `node --watch` instead of `nodemon`.
+- The frontend now passes ESLint with no errors or warnings, down from 1,137, and `next build` runs ESLint again. It was skipped before (`eslint.ignoreDuringBuilds`), which is how the issues built up.
+  - API data is now typed. `src/types` describes the records the backend returns, modelled on the Prisma schema, and `apiFetch` returns `unknown` unless the caller names a type, so untyped responses no longer pass silently.
+  - Effects list everything they depend on. Data loaders are wrapped in `useCallback`, so a page reloads when its inputs change instead of showing stale data.
+  - The pricing helpers that were copied into several pages now live in `src/lib/pricing.ts`.
+
+### Fixed
+
+- Internal links on the home page, the 404 page and "Forgot your password?" now navigate client-side instead of reloading the whole page.
+- Changing the page size on Admin → Users fetched the list twice; it now fetches once.
+- At the door, the refund history now shows a refund's reason. The page was reading a field that doesn't exist, so the reason never appeared.
+- In the Master Orders report, a ticket option named like one of the fixed columns (e.g. "name") could overwrite that column's value.
+- Removed code that could never run: an unreachable "Pay with Yoco" button on the registration form, an unused attendee-forms block on the registration success page, unused export helpers in Reports, and fonts that were downloaded but never applied.
+
+### Security
+
+- Backend `npm audit` now reports 0 vulnerabilities:
+  - Patched `follow-redirects` (pulled in by `axios`) to 1.16.1, which fixes leaking credential headers on cross-origin redirects.
+  - Removed `nodemon`, the only backend package that pulled in `braces`.
+  - Jest's coverage loader now uses `js-yaml` 4, which drops the `sprintf-js` advisory.
+- Frontend: overrode `postcss-selector-parser` to 7.1.7, used by the Tailwind 3 build. The generated CSS is byte-identical. The remaining frontend findings (7 high) are all the same `braces` advisory (GHSA-vfj7-8cjw-p6xm). It has no patched release, comes in only through build and lint tools (Tailwind 3 and `eslint-config-next`), and only ever handles glob patterns from our own config, never user input.
+
+## [1.25.1] - 2026-10-20
+
+### Fixed
+
+- On mobile, the cookie consent banner now sits above the bottom navigation bar instead of being hidden behind it.
+- The floating help button moves up above the cookie consent banner while it is showing, so the banner no longer covers it.
+
+## [1.25.0] - 2026-10-20
+
+### Added
+
+- A **Yoco** tab in Site Settings for online payments:
+  - **Secret key:** shown masked like a card number (`sk_test_***…aba`) with a Test/Live badge. Yoco checks a new key before it is saved.
+  - **Webhook secret:** **Generate** registers this server's webhook URL (`BACKEND_URL/api/webhooks/yoco`, editable) with Yoco and saves the secret Yoco returns. **Enter manually** takes the secret of a webhook you registered yourself.
+  - **Registered webhooks:** every webhook on the Yoco account, with its URL and mode. It shows which one is active and warns when a URL isn't this server. Each can be deleted; deleting the active one also removes its stored secret.
+- New admin endpoints under `/api/yoco` (config and webhooks). Changes are written to the admin audit log, without the secret values.
+
+### Changed
+
+- The Yoco secret key and webhook secret are now stored in the database, AES-256-GCM encrypted, instead of only in `backend/.env`. `YOCO_SECRET_KEY` and `YOCO_WEBHOOK_SECRET` still work as fallbacks when the database has no value. `npm run migrate:env-to-db` moves them across.
+- Yoco secrets are never returned by `/api/settings/all` and can't be changed through `PUT /api/settings`.
+- Starting a checkout or sponsorship without a Yoco key now gives a clear "online payments are not configured" message instead of failing at Yoco.
+
+## [1.24.0] - 2026-10-19
+
+### Changed
+
+- Ticket transfers now need the new holder to accept.
+  - "Transfer" (in My Events, or At the door → Tickets) sends the person a link by email and/or WhatsApp, to the details typed.
+  - Nothing changes on the ticket until they accept on the new `/transfer/<link>` page. They can also decline.
+  - On accepting, the transfer completes as before: new QR code, ticket delivery, account activation link, parental consent on youth events.
+  - My Events shows "Waiting for … to accept" with a Cancel button.
+  - Offers expire after 7 days or when the event starts, and a new offer replaces an open one.
+- Privacy for group tickets and transfers: there is no user search, and nothing reveals whether an email or phone number belongs to an account.
+  - Registration responses no longer include named attendees' account links.
+  - If an email and phone point at two different accounts, this is no longer reported to the person typing them. The email's account is used.
+- Terms of Use and Privacy Policy updated for everything added since 1.12:
+  - booking for other people, ticket transfers, and youth-event consent with health information and how long it is kept;
+  - who can see what (door staff, group leaders, supervisors), and read-only admin support access;
+  - sponsorships, waitlists, discount codes and feedback;
+  - two-factor authentication and offline scanning.
+- The Privacy Policy has a full **cookie policy**: every item the site stores in the browser (necessary, staff-only and optional), the optional visit statistics, and the third-party cookies from the Google Maps embed and Yoco checkout.
+- A new "Cookie settings" link in the footer (and a button in the policy) lets visitors change their choice.
+- The API docs page (`/docs`) now lists every mounted route. 45 were missing, including dashboard stats, backups, attachments, the audit log, ticket transfer links and WhatsApp admin.
+
+### Fixed
+
+- After activating an account, the visitor is now really signed in. The token was saved under a key the app never read, so the "auto-login" didn't work.
+
+### Notes
+
+- `npm install` succeeds in the root, `backend` and `frontend` with no missing packages.
+- The remaining `npm audit` findings are all in development/build tools (Jest, nodemon, ESLint, Tailwind's build), and none affect the running site.
+  - `braces` and `sprintf-js` have no patched release.
+  - `postcss-selector-parser` 7 would break Tailwind 3.
+- Requires the `add_transfer_requests` database migration.
+
+## [1.23.0] - 2026-10-19
+
+### Added
+
+- Impersonate user (Admin → Manage users → Impersonate): an admin can see the site exactly as a user does, to help with problems such as "my ticket isn't showing".
+  - A reason is required, and the session lasts at most 30 minutes.
+  - A bright "Viewing as [name]" banner with a countdown and "End impersonation" shows on every page.
+- Impersonation is strictly read-only.
+  - A server-side guard, mounted before every route, refuses any change (registrations, payments, refunds, cancellations, profile, consent, messages and everything else) made with an impersonation token.
+  - Viewing pages doesn't trigger the price refresh it normally does.
+  - Admins can't be impersonated, and the admin must have two-factor authentication on.
+- Impersonation is recorded in the audit log: start, end, reason, and every page and API call, including blocked attempts.
+  - The audit log page lists recent sessions with their full trail.
+- New setting: email users when an admin views their account (Site Settings → Legal → Support access; off by default).
+- New `/api/admin/impersonate` endpoints.
+  - Requires the `add_impersonation` database migration.
+
+## [1.22.0] - 2026-10-19
+
+### Added
+
+- Registration funnel stats (first-party, no third-party analytics), showing where people drop off between seeing an event and paying.
+  - A new cookie notice asks visitors once. Only those who choose "Allow" are counted, using a random anonymous visit id.
+  - We record the event page view and the start of registration. The submit and paid stages come from the registration itself.
+  - Only the stage, the traffic source and the device type are stored. No name, IP address or User-Agent is kept.
+- New report, **Registration funnel**: counts and conversion % per stage over a date range, a daily trend, and breakdowns by traffic source, device and ticket option.
+  - Selecting several events compares them.
+  - Sources come from `utm_source` links and from short links, which now add `?src=<alias>` when redirecting.
+- A "Conversion (past month)" tile on the supervisor and admin dashboards covers live events.
+- Raw visit records are rolled up into daily totals after 90 days by a daily job (`ANALYTICS_ROLLUP_ENABLED=false` to turn it off).
+- The privacy policy's cookies section now describes these statistics.
+- New `/api/analytics` endpoints.
+  - Requires the `add_funnel_analytics` database migration.
+
+## [1.21.0] - 2026-10-19
+
+### Added
+
+- Post-event feedback, set up in a new Feedback step in the event wizard.
+  - Questions use the form builder.
+  - You pick when it's sent (the default is the morning after the event) and who gets it: everyone who checked in, or everyone registered.
+  - Each person gets a personal link by email (and WhatsApp where they use it).
+  - Anyone who hasn't answered gets one reminder 3 days later.
+  - Answers can be anonymous or named.
+  - "Send now" is available, and the questions lock once people start answering.
+- New form field types: **Rating (1–5 stars)** and **Multiple choice**. They're used for feedback, and can also go on attendee forms (registration page, My Events, the kiosk, manual registration and Supervisor → Forms).
+- New report, **Feedback summary**:
+  - response rate;
+  - average rating per question, with star distribution;
+  - multiple-choice and yes/no breakdowns as bar charts;
+  - a list of text answers (with names unless the form is anonymous).
+  - Select several events to compare their ratings (e.g. Camp 2025 vs Camp 2026). Exports to PDF and Excel like other reports.
+- New `/api/feedback` endpoints and a job every 15 minutes (`FEEDBACK_JOB_ENABLED=false` to turn it off).
+  - Requires the `add_feedback_forms` database migration.
+
+## [1.20.0] - 2026-10-19
+
+### Added
+
+- Sponsor a spot: a new event setting, "Allow sponsorships" (event wizard → Sponsor a spot).
+  - It adds a "Sponsor a spot" button on the event page so people can fund a place for someone who can't afford it.
+  - Sponsors choose one or more whole spots (at the main ticket price) or a custom amount, and pay through Yoco. Guests just give a name and email.
+  - Sponsors can give anonymously, or add a name and a message for the organisers.
+  - An optional goal ("12 of 20 spots sponsored") and public progress bar.
+- Each sponsorship is recorded as a donation tagged to the event, in that event's sponsorship pool.
+  - Supervisors assign pool money to registrations with the existing donation assign/unassign flow, fully or partly.
+  - Under Payments → Donations, sponsorships are labelled, there's an "Only the sponsorship pool" filter, and the sponsor's message is shown.
+  - Who receives help is never shown to sponsors.
+- Sponsors get a "Thank you for sponsoring a spot" receipt.
+  - Automations has a new "Thank Your Sponsors" email for events with sponsorships.
+  - Email attendees can target an event's sponsors (`filter.audience: 'sponsors'`).
+- The Donations breakdown report has sponsorship pool columns per event: received, assigned and remaining.
+- New `/api/sponsorships` endpoints.
+  - Requires the `add_sponsorships` database migration.
+
+## [1.19.0] - 2026-10-19
+
+### Added
+
+- Rooms & groups (Supervisor → Rooms & groups), for camps and lockdowns: put attendees into rooms, cabins, small groups, teams or buses.
+  - Each event can have several allocation sets (e.g. "Rooms" and "Buses"). Each set has groups with an optional capacity, an optional gender restriction and an optional leader (a staff member).
+  - A drag-and-drop board puts people not yet placed on the left and groups, with capacity counters, on the right. Full groups and groups for the other gender won't accept a person.
+  - Auto-allocate fills groups evenly with everyone not yet placed, respecting capacity and gender. It can keep people on the same booking together or spread them out.
+  - Printable lists per group (with leader) and a master list. On youth events they can include medical and emergency details from consent forms; viewing those is recorded in the audit log.
+  - "Show on tickets" prints the group on each person's ticket and shows it in My Events.
+  - Email and WhatsApp attendees can be sent to one group ("Bus 2 leaves at 07:30"). Messages go to whoever booked for the people in it.
+  - Group leaders see their people under Staff → My groups. Medical details are shown to supervisors only.
+- New event setting "Ask each person's gender" (under Named attendees). It adds a gender choice for each named person on the registration page, at the door, on the kiosk, in manual registration and in My Events, and is needed for gender-split rooms.
+- New `/api/allocations` endpoints.
+  - Requires the `add_room_allocation` database migration.
+
 ## [1.18.0] - 2026-10-19
 
 ### Added

FEATURES.md

@@ -164,13 +164,54 @@ Items & Pricing → Sections → Form → Visibility → Attachments**.
 ## Payments, donations & refunds
 
 - **Online card payments via Yoco** — checkout for the full outstanding balance,
-  confirmed by a signed webhook.
+  confirmed by a signed webhook. Keys and the webhook are set up from
+  Site Settings → Yoco.
 - **Payment links** — supervisors can generate and send a Yoco link for any
   amount (including partial).
 - **Manual payments** — cash, card, EFT, voucher or other, recorded by staff.
   Each payment records **who recorded it** as well as who it's for.
 - **Refunds** — negative payments against an original payment, netted against
   the original method.
+- **Impersonate user** (Admin → Manage users) — an admin with 2FA can view the site as a
+  user, to debug problems.
+  - It needs a reason, lasts at most 30 minutes, and shows a bright "Viewing as" banner
+    on every page.
+  - It is strictly read-only. A server-side guard refuses every write made with the
+    impersonation token before it reaches any route, and pages don't even refresh
+    prices while viewing.
+  - Admins can't be impersonated.
+  - The start, end, reason and every page and API call are in the audit log, with each
+    session's trail.
+  - Optional email to the user (`notify_user_on_impersonation`).
+- **Registration funnel stats** — first-party and consent-based, with no third-party analytics.
+  - A cookie notice asks once. Only visitors who allow it get a random visit id.
+  - We record event page views and registration starts. Submits and payments come
+    from the registration itself.
+  - Each record holds only the stage, the traffic source (utm_source, or the short-link
+    alias, which short links now pass as `?src=`) and the device type.
+  - The Registration funnel report shows counts and conversion per stage over a date
+    range, a daily trend, and breakdowns by source, device and ticket option.
+  - A "Conversion (past month)" tile on the supervisor/admin dashboards covers live
+    events.
+  - Raw rows are rolled up into daily totals after 90 days.
+- **Post-event feedback** — a Feedback step in the event wizard.
+  - Questions use the form builder, with new **star rating (1–5)** and **multiple
+    choice** types (also available on attendee forms).
+  - The form goes out at a chosen time to everyone who checked in, or to everyone
+    registered, each with a personal link (`/feedback/<token>`). One reminder goes
+    3 days later to anyone who hasn't answered.
+  - Answers can be anonymous or named. "Send now" is available, and the questions
+    lock once people have answered.
+- **Sponsor a spot** — per-event setting. A "Sponsor a spot" button on the event page
+  lets anyone, including guests, pay for one or more spots (at the main ticket price)
+  or any amount through Yoco. They can give anonymously or add a name and a message.
+  The money is a donation tagged to the event and goes into its sponsorship pool, which
+  supervisors assign to registrations with the usual donation flow.
+  - An optional public progress bar ("12 of 20 spots sponsored") with an optional goal.
+  - Sponsors get a thank-you receipt, and an Automations thank-you can go to all of an
+    event's sponsors.
+  - The Donations breakdown report shows each pool: received, assigned and remaining.
+  - Who is helped is never shown.
 - **Donations** — users can donate from their dashboard (`/dashboard/user/donate`).
   Supervisors can **assign** a donation (fully or partly) to someone's
   registration and **unassign** it later. Assignments are kept as separate
@@ -266,9 +307,12 @@ logout controls. Disconnected sessions are recovered automatically.
 - Registration detail: itemised bill (early-bird lines grouped), payments,
   **Invoice** and **Receipt** buttons, edit, cancel, **Make payment**.
 - Upcoming events and tickets side by side, with bulk ticket email/WhatsApp.
-- **Ticket transfer** — hand a ticket to someone else before the event (name plus
-  email/phone). They get a new ticket and QR code, and an inactive account with an
-  activation link if they're new. The old code stops working, and scanning it says it
+- **Ticket transfer** — offer a ticket to someone else before the event by typing
+  their name and email/phone (no user search, and nothing reveals whether they have an
+  account). They get a link to accept or decline; the ticket only moves once they
+  accept, and the sender can cancel until then (offers expire after 7 days or at the
+  event start). On accepting they get a new ticket and QR code, and an inactive account
+  with an activation link if they're new. The old code stops working, and scanning it says it
   was transferred, both online and in offline-mode sync reports. One place can be split
   off a ticket covering several people. Billing stays with the payer. It's not allowed
   once a ticket has been scanned, and it can be turned off per event (supervisors can
@@ -315,6 +359,17 @@ logout controls. Disconnected sessions are recovered automatically.
   Reconcile (Yoco transactions), and Payment Link.
 - **Coupon codes** (`/dashboard/supervisor/coupons`) — create, edit and turn off
   discount codes, and see who used each one.
+- **Rooms & groups** (`/dashboard/supervisor/allocations`):
+  - Per event, allocation sets such as "Rooms", "Small groups" or "Buses". Each set
+    has groups with an optional capacity, gender restriction and leader (staff).
+  - A drag-and-drop board, plus auto-allocate: fill evenly, respecting capacity and
+    gender, keeping bookings together or splitting them.
+  - Printable per-group and master lists. On youth events they can include medical
+    details, and viewing those is audited.
+  - The group can show on tickets and in My Events.
+  - Email and WhatsApp attendees can be filtered to one group.
+  - Leaders see their people under Staff → **My groups**.
+  - Works on named attendees. Events can ask each person's gender.
 - **Offline scanning** (`/dashboard/supervisor/offline-scans`) — devices holding
   offline locks (with force release) and sync reports to review.
 - **Waitlist** (`/dashboard/supervisor/waitlist`) — the queue per event: offer a
@@ -375,9 +430,9 @@ a viewer with its own filters, stat tiles and bar charts.
 | Category | Reports |
 |----------|---------|
 | Financial | Payments between dates · Revenue summary (by method) · Revenue detailed · Finance report (revenue & costs, after discounts) · Profit report · Discounts (coupon codes) |
-| Registration | Attendees per event (grouped by option) · Registration type counts · Master orders breakdown · Registration status breakdown (count by registration or ticket quantity) · Parental consent status · Medical & emergency list |
+| Registration | Registration funnel (views → started → submitted → paid, daily trend, by source / device / ticket option) · Attendees per event (grouped by option) · Registration type counts · Master orders breakdown · Registration status breakdown (count by registration or ticket quantity) · Parental consent status · Medical & emergency list · Feedback summary (response rate, average ratings, choice breakdowns, comments; compare events) |
 | Ticketing | Ticket usage summary |
-| Donations | Donations breakdown (used / unused per event) |
+| Donations | Donations breakdown (used / unused per event, plus the sponsorship pool) |
 | Cashup | Cashup reconciliation · Cashup audit trail |
 
 **Export:** Print, branded PDF download, styled Excel (`.xlsx`) workbook,
@@ -402,6 +457,7 @@ applied without a restart. Secrets are encrypted with AES-256-GCM.
 | Email | SMTP host/port/TLS/user/password/from, with a "Test connection" button |
 | Legal | Operator, Information Officer, website, effective date for the Terms/Privacy pages |
 | WhatsApp | WAWP credentials, connect a number, status/restart/logout |
+| Yoco | Secret key (masked, test/live), webhook secret (generate by registering with Yoco, or enter), list/delete the account's webhooks |
 | Backups | List, run now, download database backups |
 
 See [SETTINGS.md](./SETTINGS.md) for the default of every setting.
@@ -448,6 +504,8 @@ falling back to a general guide.
 | Scheduled email/WhatsApp worker | Polls every 30 s (`SCHEDULED_EMAILS_INTERVAL_MS`) and purges sent jobs after 24 h |
 | Daily event summary email | 07:00 daily |
 | Waitlist: expire unclaimed offers, offer freed places | Every 10 minutes (`WAITLIST_JOB_ENABLED=false` to disable) |
+| Funnel analytics: roll raw visit rows older than 90 days into daily totals | Daily (`ANALYTICS_ROLLUP_ENABLED=false` to disable) |
+| Post-event feedback forms and their 3-day reminder | Every 15 minutes (`FEEDBACK_JOB_ENABLED=false` to disable) |
 | Parental consent reminders, and deleting medical details after events | 09:00 daily (`CONSENT_JOBS_ENABLED=false` to disable) |
 | Database backup (`pg_dump`, gzipped, 14-day retention) | 02:00 daily (`BACKUP_ENABLED=false` to disable) |
 | Temp file cleanup (files older than 7 days in `/temp`) | Daily |
@@ -487,5 +545,5 @@ falling back to a general guide.
 | `/set-banner` | Supervisor | Site banner |
 | `/dashboard/user` (+ `/payments`, `/donate`, `/forms`, `/profile`, `/reset-password`) | User | My Events |
 | `/dashboard/staff` (+ `/ticket-scanning`, `/event-tickets`) | Staff | Staff tools |
-| `/dashboard/supervisor` (+ `/events`, `/event-options`, `/at-the-door`, `/manual`, `/manual-registration`, `/payments`, `/coupons`, `/waitlist`, `/consent`, `/offline-scans`, `/email-attendees`, `/whatsapp-attendees`, `/forms`, `/reports`) | Supervisor | Supervisor tools |
+| `/dashboard/supervisor` (+ `/events`, `/event-options`, `/at-the-door`, `/manual`, `/manual-registration`, `/payments`, `/coupons`, `/waitlist`, `/consent`, `/offline-scans`, `/allocations`, `/email-attendees`, `/whatsapp-attendees`, `/forms`, `/reports`) | Supervisor | Supervisor tools |
 | `/dashboard/admin` (+ `/users`, `/registrations`, `/forms`, `/cashup`, `/cashup/[id]`, `/audit-log`, `/settings`) | Admin | Admin tools |

README.md

@@ -59,8 +59,6 @@ Documentation: see Frontend README for environment and scripts.
   - DATABASE_URL
   - JWT_SECRET
   - PORT (optional; defaults to 3000 if not set)
-  - YOCO_SECRET_KEY (for payments)
-  - YOCO_WEBHOOK_SECRET (to verify webhooks)
   - EMAIL_HOST, EMAIL_PORT, EMAIL_USER, EMAIL_PASS, EMAIL_FROM (for ticket emails)
   - FRONTEND_URL or APP_BASE_URL (used in email links)
 
@@ -69,6 +67,7 @@ Documentation: see Frontend README for environment and scripts.
   Example for default backend: NEXT_PUBLIC_API_URL=http://localhost:5000
 
 - Organisation name, logo, brand colour, and notification emails are configured via the admin panel (Admin → Site Settings) and do not need to be set in .env files.
+- Yoco payments are set up in Admin → Site Settings → Yoco: paste the secret key, then generate the webhook (or enter its secret). YOCO_SECRET_KEY / YOCO_WEBHOOK_SECRET in backend/.env still work as fallbacks.
 
 ### 3) Run the apps
 

SETTINGS.md

@@ -57,6 +57,16 @@ or Branding tab has been saved even once — the wizard always writes
 | `smtp_user` / `smtp_pass` | *(blank)* | Stored AES-256-GCM encrypted (key derived from `JWT_SECRET`). |
 | `smtp_from` | *(blank)* | If blank, outgoing mail's `From:` address falls back to the literal `no-reply@crosscode.local`. |
 
+## Payments (Yoco)
+
+Managed in the Yoco tab (through `/api/yoco`, not the generic settings endpoints).
+
+| Setting | Default when unset | Notes |
+|---|---|---|
+| `yoco_secret_key` | `YOCO_SECRET_KEY` env var, else *(blank)* | Stored AES-256-GCM encrypted. If blank, online checkouts and sponsorships fail with "online payments are not configured". |
+| `yoco_webhook_secret` | `YOCO_WEBHOOK_SECRET` env var, else *(blank)* | Stored encrypted. If blank, Yoco webhooks are rejected, so payments aren't confirmed automatically. |
+| `yoco_webhook_id` | *(blank)* | The Yoco webhook whose secret is stored, set when it's generated from the tab. Used to mark it "Active" and to clear the secret when it's deleted. |
+
 ## Legal (Terms of Use / Privacy Policy)
 
 | Setting | Default when unset | Notes |
@@ -66,6 +76,7 @@ or Branding tab has been saved even once — the wizard always writes
 | `legal_io_email` | `"io@example.com"` | Rendered as a `mailto:` link, so the placeholder stays a syntactically valid address on the IANA-reserved `example.com` domain rather than a bracketed non-email string that would break the link. |
 | `legal_website_url` | `"example.com"` | Same reasoning — used to build an `https://` link. |
 | `legal_effective_date` | `"[not yet set]"` | Plain text only, no link — a bracketed placeholder is fine here. |
+| `notify_user_on_impersonation` | `"false"` | When `"true"`, a user is emailed (with the reason) whenever an admin views their account with Impersonate. Set under Site Settings → Legal → Support access. |
 | `consent_medical_retention_days` | `30` | Youth events: medical and emergency details from parental consent forms are deleted this many days after the event ends (daily 09:00 job). The consent record itself — who agreed, when, to which text — is kept. Set under Site Settings → Legal. |
 | `org_email` (as used on legal pages specifically) | `"privacy@example.com"` | Different fallback than `org_email`'s general default (blank) — also rendered as a `mailto:` link, so it needs to stay a valid-looking address. |
 

backend/.env.example

@@ -33,9 +33,11 @@ FRONTEND_URL=http://localhost:3000
 # EMAIL_PASS=your_email_password
 # EMAIL_FROM=no-reply@example.com
 
-# ─── Payments (Yoco) ──────────────────────────────────────────────────────────
-YOCO_SECRET_KEY=your_yoco_secret_key
-YOCO_WEBHOOK_SECRET=your_yoco_webhook_secret
+# ─── Payments (Yoco) — optional fallbacks ─────────────────────────────────────
+# Preferred: set the secret key and generate the webhook in Admin → Site Settings →
+# Yoco (stored AES-256 encrypted). These are only used if the database has no value.
+# YOCO_SECRET_KEY=sk_test_...
+# YOCO_WEBHOOK_SECRET=whsec_...
 
 # ─── Public URLs ──────────────────────────────────────────────────────────────
 # Used to build links in emails (password reset, activation, etc.)
@@ -72,6 +74,7 @@ BACKUP_ENABLED=true
 #   - Registration notification emails
 #   - SMTP settings (username and password stored AES-256-GCM encrypted, key
 #     derived from JWT_SECRET — do not change JWT_SECRET after saving SMTP creds)
+#   - Yoco secret key and webhook secret (encrypted the same way)
 #   - Legal page content (operator name, Information Officer, website URL, etc.)
 # The first-time setup wizard handles initial configuration on fresh deployments.
 # You no longer need ORG_NAME, ORG_TAGLINE, EMAIL_HEADER_COLOR, REGISTRATIONS_EMAIL,

backend/API_DOCUMENTATION.md

@@ -23,6 +23,11 @@ Tokens are issued by `POST /api/users/login`.
 - [Waitlist](#waitlist)
 - [Offline scanning](#offline-scanning)
 - [Ticket transfer](#ticket-transfer)
+- [Rooms & groups](#rooms--groups)
+- [Sponsor a spot](#sponsor-a-spot)
+- [Post-event feedback](#post-event-feedback)
+- [Registration funnel](#registration-funnel)
+- [Impersonation](#impersonation)
 - [Payments](#payments)
 - [Tickets](#tickets)
 - [Broadcasts (Email)](#broadcasts-email)
@@ -280,13 +285,106 @@ For unauthenticated (guest) registration on events with `requiresAuth: false`:
 
 ---
 
+## Impersonation
+
+| Method | Path | Auth | Description |
+|--------|------|------|-------------|
+| POST | `/api/admin/impersonate/:userId` | admin (2FA on) | `{ reason }` → `{ token, session }`. The token acts as the user, is read-only, and lasts 30 minutes. Refused for admins and inactive users |
+| POST | `/api/admin/impersonate/end` | impersonation token | End the session |
+| POST | `/api/admin/impersonate/log` | impersonation token | `{ path }` — page viewed (audit trail) |
+| GET | `/api/admin/impersonate/current` | impersonation token | The live session |
+| GET | `/api/admin/impersonation-sessions` | admin | Sessions with their request trail |
+
+Read-only enforcement:
+- A guard mounted before every route returns `403 { code: "IMPERSONATION_READ_ONLY" }` for any non-GET/HEAD/OPTIONS request made with an impersonation token. The only exceptions are `end` and `log`. Blocked attempts are logged.
+- An ended or expired session gets `401 { code: "IMPERSONATION_ENDED" }`.
+- GET handlers skip side-effect writes (pricing refresh) while `req.readOnly` is set.
+
+## Registration funnel
+
+| Method | Path | Auth | Description |
+|--------|------|------|-------------|
+| POST | `/api/analytics/track` | public (rate-limited) | `{ sessionId, eventId, stage: 'view'\|'start', source? }` → always `204`. Bots are ignored; device type comes from the User-Agent |
+| GET | `/api/analytics/funnel?eventIds=&from=&to=` | supervisor+ | `{ totals, conversion, trend, bySource, byDevice, byOption, perEvent }` |
+
+How the stages are recorded:
+- `POST /api/registrations` accepts `analyticsSessionId`. It's stored on the registration and records the `submit` stage.
+- `paid` is read from that registration's status.
+- Counts are sessions that reached a stage or a later one.
+
+Data handling:
+- Sessions inactive for 90 days are rolled up into `AnalyticsDaily` by a daily job (`ANALYTICS_ROLLUP_ENABLED`).
+- `/api/stats/overview` now includes `funnel: { views, paid, conversion }` for live events over the past 30 days.
+
+## Post-event feedback
+
+| Method | Path | Auth | Description |
+|--------|------|------|-------------|
+| GET | `/api/feedback/event/:eventId` | supervisor+ | The event's feedback form (with `invited` / `responses` counts), or null |
+| PUT | `/api/feedback/event/:eventId` | supervisor+ | `{ sendAt, audience: 'checked_in'\|'all', anonymous, intro, fields[] }` — fields can't change once answered (409) |
+| DELETE | `/api/feedback/event/:eventId` | supervisor+ | Remove the form |
+| POST | `/api/feedback/event/:eventId/send-now` | supervisor+ | Send now (also invites anyone not yet invited) |
+| GET / POST | `/api/feedback/public/:token` | link holder | Load the form / submit `{ answers: { fieldId: value } }` once |
+| GET | `/api/feedback/summary?eventIds=a,b` | supervisor+ | Per event: invited, responses, response rate, and per question: rating average + distribution, choice counts, text answers (names only when not anonymous) |
+
+Notes:
+- New field types `rating` (answers `"1"`–`"5"`) and `multiple_choice` (`options`: array of strings). They can be used on attendee forms too.
+- Only HMACs of link tokens are stored, and a reminder issues a new link.
+- A job every 15 minutes (`FEEDBACK_JOB_ENABLED`, `FEEDBACK_JOB_INTERVAL_MS`) sends due forms, and sends one reminder 3 days later to people who haven't answered.
+
+## Sponsor a spot
+
+| Method | Path | Auth | Description |
+|--------|------|------|-------------|
+| GET | `/api/sponsorships/event/:eventId` | public | `{ enabled, open, spotPrice, showProgress, goalSpots, spotsFunded, sponsors }` — never recipients |
+| POST | `/api/sponsorships/checkout` | public (optional login) | `{ eventId, spots? \| amount?, anonymous?, sponsorName?, message?, name?, email? }` → Yoco `redirectUrl`. Guests give a name and email |
+| GET | `/api/sponsorships/event/:eventId/pool` | supervisor+ | `{ received, assigned, remaining, sponsors, spotsFunded, spotPrice, goalSpots }` |
+
+How the money is handled:
+- A spot costs the cheapest paid main ticket.
+- Yoco checkout metadata carries `type: 'sponsorship'`. The webhook records the payment as `isDonation` + `isSponsorship` against the event, together with `sponsorName`, `sponsorMessage` and `sponsorAnonymous`.
+- Pool funds are assigned with `PUT /api/payments/assign-donation`.
+
+Other changes:
+- Event fields: `allowSponsorships`, `sponsorshipGoalSpots`, `showSponsorshipProgress`.
+- `POST /api/events/:id/email-attendees` accepts `filter.audience: 'sponsors'`.
+- `POST /api/automations/schedule` jobs accept `audience: 'sponsors'`.
+
+## Rooms & groups
+
+| Method | Path | Auth | Description |
+|--------|------|------|-------------|
+| GET | `/api/allocations/event/:eventId` | supervisor+ | Board: sets (groups, assignments), named attendees, possible leaders, unnamed places |
+| POST | `/api/allocations/sets` | supervisor+ | `{ eventId, name, showOnTicket? }` |
+| PUT / DELETE | `/api/allocations/sets/:id` | supervisor+ | Rename / show on tickets; delete |
+| POST | `/api/allocations/sets/:id/groups` | supervisor+ | `{ name, capacity?, gender? ('male'\|'female'), leaderUserId? }` |
+| PUT / DELETE | `/api/allocations/groups/:id` | supervisor+ | Edit (can't drop below current members or break gender); delete (members become unassigned) |
+| PUT | `/api/allocations/sets/:id/assignments` | supervisor+ | `{ attendeeId, groupId }` (null unassigns); enforces capacity and gender |
+| DELETE | `/api/allocations/sets/:id/assignments` | supervisor+ | Clear the set |
+| POST | `/api/allocations/sets/:id/auto` | supervisor+ | `{ mode: 'together' \| 'split' }` — places everyone not yet placed |
+| GET | `/api/allocations/sets/:id/lists?medical=true` | supervisor+ | Groups with members for printing (medical view is audited) |
+| GET | `/api/allocations/my-groups` | staff+ | Groups the caller leads (medical details for supervisors only) |
+
+Related changes:
+- `Event.collectGender` makes a gender (`male` / `female`) required for each named attendee.
+- Email and WhatsApp attendees accept `filter.allocationGroupId`.
+
 ## Ticket transfer
 
 | Method | Path | Auth | Description |
 |--------|------|------|-------------|
-| POST | `/api/tickets/:id/transfer` | payer, holder or supervisor+ | `{ name, email?, phone?, dateOfBirth?, parentName?, parentEmail?, parentPhone? }` (date of birth, plus parent details for a minor, on youth events) |
+| POST | `/api/tickets/:id/transfer` | payer, holder or supervisor+ | `{ name, email?, phone?, dateOfBirth?, gender?, parentName?, parentEmail?, parentPhone? }` → `201`. Creates an offer and sends a link to the details given. **Nothing changes on the ticket yet.** A new offer replaces an open one |
+| DELETE | `/api/tickets/:id/transfer` | payer, holder or supervisor+ | Withdraw the open offer |
+| GET | `/api/tickets/transfer-offer/:token` | link holder | `{ status, toName, fromName (first name), event, option, expiresAt }` |
+| POST | `/api/tickets/transfer-offer/:token/accept` | link holder | Accept — the transfer happens now (all checks run again) |
+| POST | `/api/tickets/transfer-offer/:token/decline` | link holder | Decline |
 | GET | `/api/tickets/:id/transfers` | payer, holder or staff+ | Transfer history |
 
+Privacy:
+- There is no user search. The sender's request is checked (rules, required fields) without looking up any account, and no response reveals whether the email/phone belongs to an account.
+- Offers expire after 7 days or when the event starts.
+- Only an HMAC of the link token is stored.
+
 Rules:
 - Only before the event starts, and only for tickets that have never been scanned.
 - `Event.allowTicketTransfer` turns it off for non-supervisors.
@@ -608,7 +706,7 @@ Manages the WAWP WhatsApp API instance. Credentials are stored in `AppSetting` (
 
 ## Settings
 
-Runtime configuration stored in the `AppSetting` table. Sensitive values (SMTP credentials, WAWP token) are stored AES-256-GCM encrypted.
+Runtime configuration stored in the `AppSetting` table. Sensitive values (SMTP credentials, Yoco secrets) are stored AES-256-GCM encrypted. Yoco secrets are never returned by `/api/settings/all` and can't be written through `PUT /api/settings`; use `/api/yoco` below.
 
 For what each individual setting key defaults to when it's never been saved, see [`SETTINGS.md`](../SETTINGS.md) at the repo root.
 
@@ -620,6 +718,18 @@ For what each individual setting key defaults to when it's never been saved, see
 | PUT | `/api/settings` | admin | Upsert settings; `smtp_user`/`smtp_pass` encrypted before storage; sending `••••••••` for `smtp_pass` keeps existing value |
 | POST | `/api/settings/test-smtp` | admin | Test SMTP with provided credentials; sends real test email to admin on success. The admin JWT returned by `POST /api/setup/register` also qualifies during the setup wizard. |
 
+## Yoco
+
+Managed from Admin → Site Settings → Yoco. `YOCO_SECRET_KEY` / `YOCO_WEBHOOK_SECRET` in `.env` are fallbacks used only when the database has no value.
+
+| Method | Path | Auth | Description |
+|--------|------|------|-------------|
+| GET | `/api/yoco/config` | admin | Yoco settings with secrets masked card-style (`sk_test_***…aba`), the source of each (`db`/`env`/`none`), test/live mode and the default webhook URL |
+| PUT | `/api/yoco/config` | admin | Save `secretKey` and/or `webhookSecret` (AES-256-GCM encrypted). A new key is checked with Yoco first; `''` clears a value |
+| GET | `/api/yoco/webhooks` | admin | Webhooks on the Yoco account, flagged `isActive` (its secret is the stored one) and `pointsHere` |
+| POST | `/api/yoco/webhooks` | admin | Register a webhook at Yoco (`{ name?, url? }`, URL defaults to `BACKEND_URL/api/webhooks/yoco`, must be public https) and store the secret it returns |
+| DELETE | `/api/yoco/webhooks/:id` | admin | Delete a webhook at Yoco; clears the stored secret if it was the active one |
+
 ### POST /api/settings/test-smtp
 ```json
 {

backend/README.md

@@ -79,8 +79,8 @@ Create `backend/.env` from `.env.example`. The only variables you must set are:
 | `DATABASE_URL` | Yes | PostgreSQL connection string |
 | `JWT_SECRET` | Yes | Secret key for JWTs (32+ random characters). Also used to derive the AES-256 encryption key for sensitive settings (SMTP credentials) stored in the DB — must be set before saving SMTP settings. |
 | `FRONTEND_URL` | Yes | Comma-separated allowed CORS origins |
-| `YOCO_SECRET_KEY` | Yes | Yoco secret API key |
-| `YOCO_WEBHOOK_SECRET` | Yes | Yoco webhook HMAC secret |
+| `YOCO_SECRET_KEY` | — | Fallback Yoco secret API key (preferred: set via Admin → Site Settings → Yoco) |
+| `YOCO_WEBHOOK_SECRET` | — | Fallback Yoco webhook secret (preferred: generate or enter it via Admin → Site Settings → Yoco) |
 | `APP_BASE_URL` | — | Public frontend URL — used in email links (fallback if not set via admin panel) |
 | `BACKEND_URL` | — | Public backend URL — used to serve ticket PDFs over WhatsApp |
 | `PORT` | — | Port to listen on (default `3000`) |
@@ -99,7 +99,9 @@ Create `backend/.env` from `.env.example`. The only variables you must set are:
 
 > **Organisation name, branding colour, logo, registration notification email, SMTP settings, and legal page content** are now managed through the admin panel at **Admin → Site Settings** and stored in the database. You no longer need `ORG_NAME`, `ORG_TAGLINE`, `EMAIL_HEADER_COLOR`, `REGISTRATIONS_EMAIL`, or SMTP vars in `.env` (they still work as fallbacks). On a fresh deployment these are set via the first-time setup wizard.
 >
-> **SMTP credentials** (`smtp_user`, `smtp_pass`) are stored **AES-256-GCM encrypted** in the database. The encryption key is derived from `JWT_SECRET`. Do not change `JWT_SECRET` after saving SMTP credentials — the stored values will become unreadable.
+> **SMTP credentials** (`smtp_user`, `smtp_pass`) and the **Yoco secret key and webhook secret** are stored **AES-256-GCM encrypted** in the database. The encryption key is derived from `JWT_SECRET`. Do not change `JWT_SECRET` after saving them — the stored values will become unreadable.
+>
+> To move existing Yoco values from `.env` into the database, run `npm run migrate:env-to-db` (or save them in the Yoco tab).
 
 ---
 
@@ -333,6 +335,15 @@ Full interactive API docs available at `GET /docs` (requires admin JWT — pass
 | PUT | `/` | admin | Upsert settings; `smtp_user` and `smtp_pass` are AES-256-GCM encrypted before storage; sending `••••••••` for `smtp_pass` is a no-op (keeps existing value) |
 | POST | `/test-smtp` | admin | Test SMTP connection with provided credentials; success returns `{ message }`, failure returns `{ message, raw }` where `message` is human-readable and `raw` is the original SMTP error. The short-lived admin JWT returned by `POST /api/setup/register` also qualifies during the setup wizard. |
 
+#### Yoco — `/api/yoco`
+| Method | Path | Auth | Description |
+|--------|------|------|-------------|
+| GET | `/config` | admin | Yoco settings with secrets masked card-style (`sk_test_***…aba`), the source of each (`db`/`env`/`none`), test/live mode and the default webhook URL |
+| PUT | `/config` | admin | Save `secretKey` and/or `webhookSecret` (AES-256-GCM encrypted). A new key is checked with Yoco first; `''` clears a value |
+| GET | `/webhooks` | admin | Webhooks on the Yoco account, flagged `isActive` (its secret is the stored one) and `pointsHere` |
+| POST | `/webhooks` | admin | Register a webhook at Yoco (`{ name?, url? }`, URL defaults to `BACKEND_URL/api/webhooks/yoco`, must be public https) and store the secret it returns |
+| DELETE | `/webhooks/:id` | admin | Delete a webhook at Yoco; clears the stored secret if it was the active one |
+
 #### Setup — `/api/setup`
 | Method | Path | Auth | Description |
 |--------|------|------|-------------|
@@ -500,6 +511,8 @@ The resolution priority at registration/payment time is: **variant tier → vari
 
 ## Payments (Yoco)
 
+Setup: Admin → Site Settings → **Yoco**. Paste the secret key (checked with Yoco before saving), then **Generate** a webhook — this registers `BACKEND_URL/api/webhooks/yoco` with Yoco and stores the secret Yoco returns (it's only shown once). Or **Enter** the secret of a webhook you registered yourself. The tab also lists the account's webhooks and can delete them.
+
 1. Frontend calls `POST /api/payments/yoco-checkout`
 2. Backend calls `refreshPricingForRegistration` — if any early-bird price changed, returns `{ priceUpdated: true, newTotal }` (HTTP 200) and does **not** create a checkout. Frontend shows warning; user retries.
 3. On the retry (or first attempt when prices are current), backend creates a Yoco checkout and returns `{ redirectUrl }`.
@@ -524,6 +537,6 @@ pm2 save && pm2 startup
 - [ ] `JWT_SECRET` is long (32+ chars) and secret
 - [ ] `FRONTEND_URL` lists only production origins
 - [ ] `NODE_ENV=production`
-- [ ] Yoco webhook registered and HTTPS
+- [ ] Yoco secret key saved and webhook generated (Site Settings → Yoco), over HTTPS
 - [ ] WAWP credentials saved via admin panel
 - [ ] SMTP credentials correct

backend/package.json

@@ -1,11 +1,11 @@
 {
   "name": "event-management-backend",
-  "version": "1.18.0",
+  "version": "1.26.0",
   "description": "Event Management System Backend",
   "main": "src/index.js",
   "scripts": {
     "start": "node src/index.js",
-    "dev": "nodemon src/index.js",
+    "dev": "node --watch src/index.js",
     "test": "jest",
     "postinstall": "prisma generate",
     "prisma:generate": "prisma generate",
@@ -16,7 +16,8 @@
     "migrate:env-to-db:dry": "node scripts/migrate-env-to-db.js --dry-run"
   },
   "dependencies": {
-    "@prisma/client": "^5.4.2",
+    "@prisma/adapter-pg": "^7.10.1",
+    "@prisma/client": "^7.10.1",
     "@sentry/node": "^10.71.0",
     "axios": "^1.11.0",
     "bcryptjs": "^2.4.3",
@@ -37,16 +38,18 @@
   },
   "devDependencies": {
     "jest": "^30.4.2",
-    "nodemon": "^3.0.1",
-    "prisma": "^5.4.2"
+    "prisma": "^7.10.1"
   },
   "overrides": {
-    "uuid": "^11.1.1"
+    "uuid": "^11.1.1",
+    "@istanbuljs/load-nyc-config": {
+      "js-yaml": "^4.1.1"
+    },
+    "follow-redirects": "^1.16.1"
   },
   "allowScripts": {
-    "prisma@5.22.0": true,
-    "@prisma/client@5.22.0": true,
-    "@prisma/engines@5.22.0": true,
+    "prisma@7.10.1": true,
+    "@prisma/engines@7.10.1": true,
     "unrs-resolver@1.12.2": true,
     "@parcel/watcher": false
   }

backend/prisma.config.js

@@ -0,0 +1,16 @@
+// Prisma CLI config (migrate, generate, studio). Prisma 7 no longer reads the
+// datasource URL from schema.prisma or auto-loads .env, so both happen here.
+require('dotenv/config');
+const { defineConfig } = require('prisma/config');
+
+module.exports = defineConfig({
+  schema: 'prisma/schema.prisma',
+  migrations: {
+    path: 'prisma/migrations',
+  },
+  datasource: {
+    // process.env rather than env() so `prisma generate` still works on a
+    // machine with no DATABASE_URL (generate never connects).
+    url: process.env.DATABASE_URL,
+  },
+});

backend/prisma/migrations/20261019142529_add_room_allocation/migration.sql

@@ -0,0 +1,78 @@
+-- AlterTable
+ALTER TABLE "Event" ADD COLUMN     "collectGender" BOOLEAN NOT NULL DEFAULT false;
+
+-- CreateTable
+CREATE TABLE "AllocationSet" (
+    "id" TEXT NOT NULL,
+    "eventId" TEXT NOT NULL,
+    "name" TEXT NOT NULL,
+    "showOnTicket" BOOLEAN NOT NULL DEFAULT false,
+    "order" INTEGER NOT NULL DEFAULT 0,
+    "createdAt" TIMESTAMP(3) NOT NULL DEFAULT CURRENT_TIMESTAMP,
+    "updatedAt" TIMESTAMP(3) NOT NULL,
+
+    CONSTRAINT "AllocationSet_pkey" PRIMARY KEY ("id")
+);
+
+-- CreateTable
+CREATE TABLE "AllocationGroup" (
+    "id" TEXT NOT NULL,
+    "setId" TEXT NOT NULL,
+    "name" TEXT NOT NULL,
+    "capacity" INTEGER,
+    "gender" TEXT,
+    "leaderUserId" TEXT,
+    "order" INTEGER NOT NULL DEFAULT 0,
+    "createdAt" TIMESTAMP(3) NOT NULL DEFAULT CURRENT_TIMESTAMP,
+    "updatedAt" TIMESTAMP(3) NOT NULL,
+
+    CONSTRAINT "AllocationGroup_pkey" PRIMARY KEY ("id")
+);
+
+-- CreateTable
+CREATE TABLE "AllocationAssignment" (
+    "id" TEXT NOT NULL,
+    "setId" TEXT NOT NULL,
+    "groupId" TEXT NOT NULL,
+    "attendeeId" TEXT NOT NULL,
+    "createdAt" TIMESTAMP(3) NOT NULL DEFAULT CURRENT_TIMESTAMP,
+
+    CONSTRAINT "AllocationAssignment_pkey" PRIMARY KEY ("id")
+);
+
+-- CreateIndex
+CREATE INDEX "AllocationSet_eventId_idx" ON "AllocationSet"("eventId");
+
+-- CreateIndex
+CREATE INDEX "AllocationGroup_setId_idx" ON "AllocationGroup"("setId");
+
+-- CreateIndex
+CREATE INDEX "AllocationGroup_leaderUserId_idx" ON "AllocationGroup"("leaderUserId");
+
+-- CreateIndex
+CREATE INDEX "AllocationAssignment_groupId_idx" ON "AllocationAssignment"("groupId");
+
+-- CreateIndex
+CREATE INDEX "AllocationAssignment_attendeeId_idx" ON "AllocationAssignment"("attendeeId");
+
+-- CreateIndex
+CREATE UNIQUE INDEX "AllocationAssignment_setId_attendeeId_key" ON "AllocationAssignment"("setId", "attendeeId");
+
+-- AddForeignKey
+ALTER TABLE "AllocationSet" ADD CONSTRAINT "AllocationSet_eventId_fkey" FOREIGN KEY ("eventId") REFERENCES "Event"("id") ON DELETE CASCADE ON UPDATE CASCADE;
+
+-- AddForeignKey
+ALTER TABLE "AllocationGroup" ADD CONSTRAINT "AllocationGroup_setId_fkey" FOREIGN KEY ("setId") REFERENCES "AllocationSet"("id") ON DELETE CASCADE ON UPDATE CASCADE;
+
+-- AddForeignKey
+ALTER TABLE "AllocationGroup" ADD CONSTRAINT "AllocationGroup_leaderUserId_fkey" FOREIGN KEY ("leaderUserId") REFERENCES "User"("id") ON DELETE SET NULL ON UPDATE CASCADE;
+
+-- AddForeignKey
+ALTER TABLE "AllocationAssignment" ADD CONSTRAINT "AllocationAssignment_setId_fkey" FOREIGN KEY ("setId") REFERENCES "AllocationSet"("id") ON DELETE CASCADE ON UPDATE CASCADE;
+
+-- AddForeignKey
+ALTER TABLE "AllocationAssignment" ADD CONSTRAINT "AllocationAssignment_groupId_fkey" FOREIGN KEY ("groupId") REFERENCES "AllocationGroup"("id") ON DELETE CASCADE ON UPDATE CASCADE;
+
+-- AddForeignKey
+ALTER TABLE "AllocationAssignment" ADD CONSTRAINT "AllocationAssignment_attendeeId_fkey" FOREIGN KEY ("attendeeId") REFERENCES "Attendee"("id") ON DELETE CASCADE ON UPDATE CASCADE;
+

backend/prisma/migrations/20261019145150_add_sponsorships/migration.sql

@@ -0,0 +1,11 @@
+-- AlterTable
+ALTER TABLE "Event" ADD COLUMN     "allowSponsorships" BOOLEAN NOT NULL DEFAULT false,
+ADD COLUMN     "showSponsorshipProgress" BOOLEAN NOT NULL DEFAULT true,
+ADD COLUMN     "sponsorshipGoalSpots" INTEGER;
+
+-- AlterTable
+ALTER TABLE "Payment" ADD COLUMN     "isSponsorship" BOOLEAN NOT NULL DEFAULT false,
+ADD COLUMN     "sponsorAnonymous" BOOLEAN NOT NULL DEFAULT false,
+ADD COLUMN     "sponsorMessage" TEXT,
+ADD COLUMN     "sponsorName" TEXT;
+

backend/prisma/migrations/20261019150657_add_feedback_forms/migration.sql

@@ -0,0 +1,122 @@
+-- AlterEnum
+-- This migration adds more than one value to an enum.
+-- With PostgreSQL versions 11 and earlier, this is not possible
+-- in a single migration. This can be worked around by creating
+-- multiple migrations, each migration adding only one value to
+-- the enum.
+
+
+ALTER TYPE "FormFieldType" ADD VALUE 'rating';
+ALTER TYPE "FormFieldType" ADD VALUE 'multiple_choice';
+
+-- CreateTable
+CREATE TABLE "FeedbackForm" (
+    "id" TEXT NOT NULL,
+    "eventId" TEXT NOT NULL,
+    "sendAt" TIMESTAMP(3),
+    "audience" TEXT NOT NULL DEFAULT 'checked_in',
+    "anonymous" BOOLEAN NOT NULL DEFAULT false,
+    "intro" TEXT,
+    "sentAt" TIMESTAMP(3),
+    "reminderSentAt" TIMESTAMP(3),
+    "createdAt" TIMESTAMP(3) NOT NULL DEFAULT CURRENT_TIMESTAMP,
+    "updatedAt" TIMESTAMP(3) NOT NULL,
+
+    CONSTRAINT "FeedbackForm_pkey" PRIMARY KEY ("id")
+);
+
+-- CreateTable
+CREATE TABLE "FeedbackField" (
+    "id" TEXT NOT NULL,
+    "formId" TEXT NOT NULL,
+    "type" "FormFieldType" NOT NULL,
+    "label" TEXT NOT NULL,
+    "isRequired" BOOLEAN NOT NULL DEFAULT false,
+    "order" INTEGER NOT NULL DEFAULT 0,
+    "helpText" TEXT,
+    "options" JSONB,
+
+    CONSTRAINT "FeedbackField_pkey" PRIMARY KEY ("id")
+);
+
+-- CreateTable
+CREATE TABLE "FeedbackInvite" (
+    "id" TEXT NOT NULL,
+    "formId" TEXT NOT NULL,
+    "userId" TEXT NOT NULL,
+    "tokenHash" TEXT NOT NULL,
+    "sentAt" TIMESTAMP(3) NOT NULL DEFAULT CURRENT_TIMESTAMP,
+    "remindedAt" TIMESTAMP(3),
+    "respondedAt" TIMESTAMP(3),
+
+    CONSTRAINT "FeedbackInvite_pkey" PRIMARY KEY ("id")
+);
+
+-- CreateTable
+CREATE TABLE "FeedbackResponse" (
+    "id" TEXT NOT NULL,
+    "formId" TEXT NOT NULL,
+    "userId" TEXT,
+    "createdAt" TIMESTAMP(3) NOT NULL DEFAULT CURRENT_TIMESTAMP,
+
+    CONSTRAINT "FeedbackResponse_pkey" PRIMARY KEY ("id")
+);
+
+-- CreateTable
+CREATE TABLE "FeedbackAnswer" (
+    "id" TEXT NOT NULL,
+    "responseId" TEXT NOT NULL,
+    "fieldId" TEXT NOT NULL,
+    "value" TEXT NOT NULL,
+
+    CONSTRAINT "FeedbackAnswer_pkey" PRIMARY KEY ("id")
+);
+
+-- CreateIndex
+CREATE UNIQUE INDEX "FeedbackForm_eventId_key" ON "FeedbackForm"("eventId");
+
+-- CreateIndex
+CREATE INDEX "FeedbackField_formId_idx" ON "FeedbackField"("formId");
+
+-- CreateIndex
+CREATE UNIQUE INDEX "FeedbackInvite_tokenHash_key" ON "FeedbackInvite"("tokenHash");
+
+-- CreateIndex
+CREATE INDEX "FeedbackInvite_userId_idx" ON "FeedbackInvite"("userId");
+
+-- CreateIndex
+CREATE UNIQUE INDEX "FeedbackInvite_formId_userId_key" ON "FeedbackInvite"("formId", "userId");
+
+-- CreateIndex
+CREATE INDEX "FeedbackResponse_formId_idx" ON "FeedbackResponse"("formId");
+
+-- CreateIndex
+CREATE INDEX "FeedbackAnswer_responseId_idx" ON "FeedbackAnswer"("responseId");
+
+-- CreateIndex
+CREATE INDEX "FeedbackAnswer_fieldId_idx" ON "FeedbackAnswer"("fieldId");
+
+-- AddForeignKey
+ALTER TABLE "FeedbackForm" ADD CONSTRAINT "FeedbackForm_eventId_fkey" FOREIGN KEY ("eventId") REFERENCES "Event"("id") ON DELETE CASCADE ON UPDATE CASCADE;
+
+-- AddForeignKey
+ALTER TABLE "FeedbackField" ADD CONSTRAINT "FeedbackField_formId_fkey" FOREIGN KEY ("formId") REFERENCES "FeedbackForm"("id") ON DELETE CASCADE ON UPDATE CASCADE;
+
+-- AddForeignKey
+ALTER TABLE "FeedbackInvite" ADD CONSTRAINT "FeedbackInvite_formId_fkey" FOREIGN KEY ("formId") REFERENCES "FeedbackForm"("id") ON DELETE CASCADE ON UPDATE CASCADE;
+
+-- AddForeignKey
+ALTER TABLE "FeedbackInvite" ADD CONSTRAINT "FeedbackInvite_userId_fkey" FOREIGN KEY ("userId") REFERENCES "User"("id") ON DELETE CASCADE ON UPDATE CASCADE;
+
+-- AddForeignKey
+ALTER TABLE "FeedbackResponse" ADD CONSTRAINT "FeedbackResponse_formId_fkey" FOREIGN KEY ("formId") REFERENCES "FeedbackForm"("id") ON DELETE CASCADE ON UPDATE CASCADE;
+
+-- AddForeignKey
+ALTER TABLE "FeedbackResponse" ADD CONSTRAINT "FeedbackResponse_userId_fkey" FOREIGN KEY ("userId") REFERENCES "User"("id") ON DELETE SET NULL ON UPDATE CASCADE;
+
+-- AddForeignKey
+ALTER TABLE "FeedbackAnswer" ADD CONSTRAINT "FeedbackAnswer_responseId_fkey" FOREIGN KEY ("responseId") REFERENCES "FeedbackResponse"("id") ON DELETE CASCADE ON UPDATE CASCADE;
+
+-- AddForeignKey
+ALTER TABLE "FeedbackAnswer" ADD CONSTRAINT "FeedbackAnswer_fieldId_fkey" FOREIGN KEY ("fieldId") REFERENCES "FeedbackField"("id") ON DELETE CASCADE ON UPDATE CASCADE;
+

backend/prisma/migrations/20261019180220_add_funnel_analytics/migration.sql

@@ -0,0 +1,47 @@
+-- AlterTable
+ALTER TABLE "Registration" ADD COLUMN     "analyticsSessionId" TEXT;
+
+-- CreateTable
+CREATE TABLE "AnalyticsEvent" (
+    "id" TEXT NOT NULL,
+    "sessionId" TEXT NOT NULL,
+    "eventId" TEXT NOT NULL,
+    "stage" TEXT NOT NULL,
+    "source" TEXT,
+    "device" TEXT,
+    "createdAt" TIMESTAMP(3) NOT NULL DEFAULT CURRENT_TIMESTAMP,
+
+    CONSTRAINT "AnalyticsEvent_pkey" PRIMARY KEY ("id")
+);
+
+-- CreateTable
+CREATE TABLE "AnalyticsDaily" (
+    "id" TEXT NOT NULL,
+    "eventId" TEXT NOT NULL,
+    "day" DATE NOT NULL,
+    "stage" TEXT NOT NULL,
+    "source" TEXT NOT NULL DEFAULT 'direct',
+    "device" TEXT NOT NULL DEFAULT 'unknown',
+    "sessions" INTEGER NOT NULL DEFAULT 0,
+
+    CONSTRAINT "AnalyticsDaily_pkey" PRIMARY KEY ("id")
+);
+
+-- CreateIndex
+CREATE INDEX "AnalyticsEvent_eventId_createdAt_idx" ON "AnalyticsEvent"("eventId", "createdAt");
+
+-- CreateIndex
+CREATE UNIQUE INDEX "AnalyticsEvent_sessionId_eventId_stage_key" ON "AnalyticsEvent"("sessionId", "eventId", "stage");
+
+-- CreateIndex
+CREATE INDEX "AnalyticsDaily_eventId_day_idx" ON "AnalyticsDaily"("eventId", "day");
+
+-- CreateIndex
+CREATE UNIQUE INDEX "AnalyticsDaily_eventId_day_stage_source_device_key" ON "AnalyticsDaily"("eventId", "day", "stage", "source", "device");
+
+-- AddForeignKey
+ALTER TABLE "AnalyticsEvent" ADD CONSTRAINT "AnalyticsEvent_eventId_fkey" FOREIGN KEY ("eventId") REFERENCES "Event"("id") ON DELETE CASCADE ON UPDATE CASCADE;
+
+-- AddForeignKey
+ALTER TABLE "AnalyticsDaily" ADD CONSTRAINT "AnalyticsDaily_eventId_fkey" FOREIGN KEY ("eventId") REFERENCES "Event"("id") ON DELETE CASCADE ON UPDATE CASCADE;
+

backend/prisma/migrations/20261019181608_add_impersonation/migration.sql

@@ -0,0 +1,55 @@
+-- AlterEnum
+-- This migration adds more than one value to an enum.
+-- With PostgreSQL versions 11 and earlier, this is not possible
+-- in a single migration. This can be worked around by creating
+-- multiple migrations, each migration adding only one value to
+-- the enum.
+
+
+ALTER TYPE "AdminAuditAction" ADD VALUE 'impersonation_started';
+ALTER TYPE "AdminAuditAction" ADD VALUE 'impersonation_ended';
+
+-- CreateTable
+CREATE TABLE "ImpersonationSession" (
+    "id" TEXT NOT NULL,
+    "adminId" TEXT NOT NULL,
+    "targetUserId" TEXT NOT NULL,
+    "reason" TEXT NOT NULL,
+    "startedAt" TIMESTAMP(3) NOT NULL DEFAULT CURRENT_TIMESTAMP,
+    "expiresAt" TIMESTAMP(3) NOT NULL,
+    "endedAt" TIMESTAMP(3),
+    "endedReason" TEXT,
+
+    CONSTRAINT "ImpersonationSession_pkey" PRIMARY KEY ("id")
+);
+
+-- CreateTable
+CREATE TABLE "ImpersonationRequestLog" (
+    "id" TEXT NOT NULL,
+    "sessionId" TEXT NOT NULL,
+    "method" TEXT NOT NULL,
+    "path" TEXT NOT NULL,
+    "blocked" BOOLEAN NOT NULL DEFAULT false,
+    "createdAt" TIMESTAMP(3) NOT NULL DEFAULT CURRENT_TIMESTAMP,
+
+    CONSTRAINT "ImpersonationRequestLog_pkey" PRIMARY KEY ("id")
+);
+
+-- CreateIndex
+CREATE INDEX "ImpersonationSession_adminId_idx" ON "ImpersonationSession"("adminId");
+
+-- CreateIndex
+CREATE INDEX "ImpersonationSession_targetUserId_idx" ON "ImpersonationSession"("targetUserId");
+
+-- CreateIndex
+CREATE INDEX "ImpersonationRequestLog_sessionId_createdAt_idx" ON "ImpersonationRequestLog"("sessionId", "createdAt");
+
+-- AddForeignKey
+ALTER TABLE "ImpersonationSession" ADD CONSTRAINT "ImpersonationSession_adminId_fkey" FOREIGN KEY ("adminId") REFERENCES "User"("id") ON DELETE CASCADE ON UPDATE CASCADE;
+
+-- AddForeignKey
+ALTER TABLE "ImpersonationSession" ADD CONSTRAINT "ImpersonationSession_targetUserId_fkey" FOREIGN KEY ("targetUserId") REFERENCES "User"("id") ON DELETE CASCADE ON UPDATE CASCADE;
+
+-- AddForeignKey
+ALTER TABLE "ImpersonationRequestLog" ADD CONSTRAINT "ImpersonationRequestLog_sessionId_fkey" FOREIGN KEY ("sessionId") REFERENCES "ImpersonationSession"("id") ON DELETE CASCADE ON UPDATE CASCADE;
+

backend/prisma/migrations/20261019182648_add_transfer_requests/migration.sql

@@ -0,0 +1,30 @@
+-- CreateTable
+CREATE TABLE "TicketTransferRequest" (
+    "id" TEXT NOT NULL,
+    "ticketId" TEXT NOT NULL,
+    "requestedById" TEXT NOT NULL,
+    "toName" TEXT NOT NULL,
+    "toEmail" TEXT,
+    "toPhone" TEXT,
+    "details" JSONB,
+    "tokenHash" TEXT NOT NULL,
+    "status" TEXT NOT NULL DEFAULT 'pending',
+    "expiresAt" TIMESTAMP(3) NOT NULL,
+    "respondedAt" TIMESTAMP(3),
+    "createdAt" TIMESTAMP(3) NOT NULL DEFAULT CURRENT_TIMESTAMP,
+
+    CONSTRAINT "TicketTransferRequest_pkey" PRIMARY KEY ("id")
+);
+
+-- CreateIndex
+CREATE UNIQUE INDEX "TicketTransferRequest_tokenHash_key" ON "TicketTransferRequest"("tokenHash");
+
+-- CreateIndex
+CREATE INDEX "TicketTransferRequest_ticketId_status_idx" ON "TicketTransferRequest"("ticketId", "status");
+
+-- AddForeignKey
+ALTER TABLE "TicketTransferRequest" ADD CONSTRAINT "TicketTransferRequest_ticketId_fkey" FOREIGN KEY ("ticketId") REFERENCES "Ticket"("id") ON DELETE CASCADE ON UPDATE CASCADE;
+
+-- AddForeignKey
+ALTER TABLE "TicketTransferRequest" ADD CONSTRAINT "TicketTransferRequest_requestedById_fkey" FOREIGN KEY ("requestedById") REFERENCES "User"("id") ON DELETE CASCADE ON UPDATE CASCADE;
+

backend/prisma/migrations/20261020101550_add_yoco_audit_actions/migration.sql

@@ -0,0 +1,12 @@
+-- AlterEnum
+-- This migration adds more than one value to an enum.
+-- With PostgreSQL versions 11 and earlier, this is not possible
+-- in a single migration. This can be worked around by creating
+-- multiple migrations, each migration adding only one value to
+-- the enum.
+
+
+ALTER TYPE "AdminAuditAction" ADD VALUE 'yoco_config_updated';
+ALTER TYPE "AdminAuditAction" ADD VALUE 'yoco_webhook_registered';
+ALTER TYPE "AdminAuditAction" ADD VALUE 'yoco_webhook_deleted';
+

backend/prisma/schema.prisma

@@ -7,7 +7,6 @@ generator client {
 
 datasource db {
   provider = "postgresql"
-  url      = env("DATABASE_URL")
 }
 
 enum UserRole {
@@ -108,6 +107,12 @@ model User {
   scanLocks        ScanLock[]          @relation("ScanLockOwner")
   transfersTo      TicketTransfer[]    @relation("TransferRecipient")
   transfersBy      TicketTransfer[]    @relation("TransferActor")
+  ledGroups        AllocationGroup[]   @relation("AllocationGroupLeader")
+  feedbackInvites  FeedbackInvite[]
+  feedbackGiven    FeedbackResponse[]
+  impersonationsDone ImpersonationSession[] @relation("ImpersonationAdmin")
+  transferRequests   TicketTransferRequest[] @relation("TransferRequester")
+  impersonatedIn     ImpersonationSession[] @relation("ImpersonationTarget")
   scanLocksForced  ScanLock[]          @relation("ScanLockForcedBy")
   syncReportsDone  OfflineSyncReport[] @relation("SyncReportReviewer")
 
@@ -144,6 +149,15 @@ model Event {
   // fewer places than asked for (otherwise skip to the next person who fits).
   waitlistEnabled         Boolean           @default(false)
   allowTicketTransfer     Boolean           @default(true)
+  collectGender           Boolean           @default(false)
+  // Sponsor a spot: public donations into a bursary pool for this event.
+  allowSponsorships       Boolean           @default(false)
+  sponsorshipGoalSpots    Int?
+  showSponsorshipProgress Boolean           @default(true)
+  feedbackForm            FeedbackForm?
+  analyticsEvents         AnalyticsEvent[]
+  analyticsDaily          AnalyticsDaily[]
+  allocationSets          AllocationSet[]
   waitlistOfferHours      Int               @default(24)
   waitlistPartialOffers   Boolean           @default(true)
   contactName             String?
@@ -256,6 +270,7 @@ model Registration {
   discountTotal       Float                @default(0)
   // Where named attendees' tickets go: all to the payer, or each to the attendee.
   ticketDelivery      TicketDelivery       @default(payer)
+  analyticsSessionId String?
   createdAt           DateTime             @default(now())
   updatedAt           DateTime             @updatedAt
   user                User                 @relation(fields: [userId], references: [id], onDelete: Restrict)
@@ -327,6 +342,11 @@ model Payment {
   registrationId    String?
   eventId           String?
   isDonation        Boolean           @default(false)
+  // A "sponsor a spot" donation (also isDonation): goes into the event's sponsorship pool.
+  isSponsorship     Boolean           @default(false)
+  sponsorName       String?
+  sponsorMessage    String?
+  sponsorAnonymous  Boolean           @default(false)
   externalId        String?           @unique
   status            String?
   originalPaymentId String?
@@ -369,6 +389,7 @@ model Ticket {
   event                Event              @relation(fields: [eventId], references: [id], onDelete: Restrict)
   usages               TicketUsage[]
   transfers            TicketTransfer[]
+  transferRequests     TicketTransferRequest[]
 
   @@index([holderUserId])
   @@index([eventId])
@@ -481,6 +502,11 @@ enum AdminAuditAction {
   scan_lock_force_released
   offline_sync
   ticket_transferred
+  impersonation_started
+  impersonation_ended
+  yoco_config_updated
+  yoco_webhook_registered
+  yoco_webhook_deleted
 }
 
 // Append-only audit trail for admin/supervisor-initiated actions with money or
@@ -526,6 +552,8 @@ enum FormFieldType {
   numeric
   statement
   paragraph
+  rating
+  multiple_choice
 }
 
 model EventForm {
@@ -734,167 +762,6 @@ model EventCashupPersonCountDenomination {
   @@index([countId])
 }
 
-// ─── Church Website Models (disabled — kept for reference, not active Prisma models) ──
-//
-// model Ministry {
-//   id          String             @id @default(uuid())
-//   slug        String             @unique
-//   title       String
-//   description String?
-//   image       String?
-//   isActive    Boolean            @default(true)
-//   order       Int                @default(0)
-//   leaderId    String?
-//   leader      TeamMember?        @relation(fields: [leaderId], references: [id], onDelete: SetNull)
-//   interests   MinistryInterest[]
-//   createdAt   DateTime           @default(now())
-//   updatedAt   DateTime           @updatedAt
-//
-//   @@index([isActive, order])
-//   @@index([leaderId])
-// }
-//
-// model TeamMember {
-//   id         String      @id @default(uuid())
-//   name       String
-//   title      String
-//   bio        String?
-//   photo      String?
-//   order      Int         @default(0)
-//   isActive   Boolean     @default(true)
-//   email      String?
-//   createdAt  DateTime    @default(now())
-//   updatedAt  DateTime    @updatedAt
-//   ministries Ministry[]
-//
-//   @@index([isActive, order])
-// }
-//
-// model ContentBlock {
-//   id        String   @id @default(uuid())
-//   page      String
-//   key       String
-//   value     String
-//   type      String   @default("text")
-//   updatedAt DateTime @updatedAt
-//
-//   @@unique([page, key])
-//   @@index([page])
-// }
-//
-// model ChurchDocument {
-//   id          String   @id @default(uuid())
-//   title       String
-//   description String?
-//   fileUrl     String
-//   category    String   @default("other")
-//   isPublic    Boolean  @default(true)
-//   uploadedAt  DateTime @default(now())
-//   updatedAt   DateTime @updatedAt
-// }
-//
-// model FellowshipGroup {
-//   id          String        @id @default(uuid())
-//   name        String
-//   description String?
-//   leader      String?
-//   isActive    Boolean       @default(true)
-//   order       Int           @default(0)
-//   members     ChurchMember[]
-//   createdAt   DateTime      @default(now())
-//   updatedAt   DateTime      @updatedAt
-//
-//   @@index([isActive, order])
-// }
-//
-// model ChurchMember {
-//   id                       String             @id @default(uuid())
-//   status                   String             @default("pending")
-//   mainName                 String
-//   mainEmail                String
-//   mainPhone                String?
-//   mainBirthday             DateTime?
-//   mainOccupation           String?
-//   mainEmploymentStatus     String?
-//   mainDateOfSalvation      DateTime?
-//   mainDateOfWaterBaptism   DateTime?
-//   mainHolySpiritBaptism    Boolean            @default(false)
-//   spouseName               String?
-//   spouseEmail              String?
-//   spousePhone              String?
-//   spouseBirthday           DateTime?
-//   spouseOccupation         String?
-//   spouseEmploymentStatus   String?
-//   spouseDateOfSalvation    DateTime?
-//   spouseDateOfWaterBaptism DateTime?
-//   spouseHolySpiritBaptism  Boolean?
-//   homeAddress              String?
-//   inFellowshipGroup        Boolean            @default(false)
-//   fellowshipGroupId        String?
-//   fellowshipGroup          FellowshipGroup?   @relation(fields: [fellowshipGroupId], references: [id], onDelete: SetNull)
-//   membershipConfirmed      Boolean            @default(false)
-//   notes                    String?
-//   appliedAt                DateTime           @default(now())
-//   approvedAt               DateTime?
-//   createdAt                DateTime           @default(now())
-//   updatedAt                DateTime           @updatedAt
-//   children                 ChurchChild[]
-//   ministryInterests        MinistryInterest[]
-//   donations                Donation[]
-//
-//   @@index([status])
-//   @@index([mainEmail])
-//   @@index([fellowshipGroupId])
-// }
-//
-// model ChurchChild {
-//   id        String       @id @default(uuid())
-//   memberId  String
-//   name      String
-//   birthday  DateTime?
-//   member    ChurchMember @relation(fields: [memberId], references: [id], onDelete: Cascade)
-//
-//   @@index([memberId])
-// }
-//
-// model MinistryInterest {
-//   id         String       @id @default(uuid())
-//   memberId   String
-//   ministryId String
-//   forSpouse  Boolean      @default(false)
-//   member     ChurchMember @relation(fields: [memberId], references: [id], onDelete: Cascade)
-//   ministry   Ministry     @relation(fields: [ministryId], references: [id], onDelete: Cascade)
-//
-//   @@unique([memberId, ministryId, forSpouse])
-//   @@index([memberId])
-//   @@index([ministryId])
-// }
-//
-// model Donation {
-//   id              String        @id @default(uuid())
-//   donorName       String?
-//   donorEmail      String?
-//   donorPhone      String?
-//   amount          Float
-//   method          String
-//   reference       String?
-//   note            String?
-//   isAnonymous     Boolean       @default(false)
-//   linkedMemberId  String?
-//   linkedMember    ChurchMember? @relation(fields: [linkedMemberId], references: [id], onDelete: SetNull)
-//   createdAt       DateTime      @default(now())
-//   updatedAt       DateTime      @updatedAt
-//
-//   @@index([linkedMemberId])
-//   @@index([createdAt])
-//   @@index([method])
-// }
-
-// ─── Coupon codes ─────────────────────────────────────────────────────────────
-// A code gives a percentage, fixed-amount or 100% (comp) discount on a registration.
-// The discount is locked into a CouponRedemption when applied, like early-bird
-// tranches: later pricing refreshes never re-price it (see utils/coupons.js).
-
 enum CouponType {
   percent
   fixed
@@ -995,6 +862,217 @@ enum TicketDelivery {
 
 // One named person on a group registration, for one main-ticket place. Gets their
 // own quantity-1 ticket and their own attendee form response.
+/// An admin viewing the site as another user (strictly read-only, at most 30 minutes).
+model ImpersonationSession {
+  id           String                    @id @default(uuid())
+  adminId      String
+  targetUserId String
+  reason       String
+  startedAt    DateTime                  @default(now())
+  expiresAt    DateTime
+  endedAt      DateTime?
+  endedReason  String? // 'ended' | 'expired'
+  admin        User                      @relation("ImpersonationAdmin", fields: [adminId], references: [id], onDelete: Cascade)
+  target       User                      @relation("ImpersonationTarget", fields: [targetUserId], references: [id], onDelete: Cascade)
+  requests     ImpersonationRequestLog[]
+
+  @@index([adminId])
+  @@index([targetUserId])
+}
+
+/// Every page viewed and API call made during an impersonation session.
+model ImpersonationRequestLog {
+  id        String               @id @default(uuid())
+  sessionId String
+  method    String
+  path      String
+  blocked   Boolean              @default(false)
+  createdAt DateTime             @default(now())
+  session   ImpersonationSession @relation(fields: [sessionId], references: [id], onDelete: Cascade)
+
+  @@index([sessionId, createdAt])
+}
+
+/// First-party funnel tracking (only after cookie consent): one row per anonymous
+/// session, event and stage ('view' | 'start' | 'submit'). "Paid" comes from the
+/// registration that carries the session id. Rows older than 90 days are rolled up
+/// into AnalyticsDaily and deleted.
+model AnalyticsEvent {
+  id        String   @id @default(uuid())
+  sessionId String
+  eventId   String
+  stage     String
+  source    String?
+  device    String?
+  createdAt DateTime @default(now())
+  event     Event    @relation(fields: [eventId], references: [id], onDelete: Cascade)
+
+  @@unique([sessionId, eventId, stage])
+  @@index([eventId, createdAt])
+}
+
+/// Rolled-up funnel counts: sessions that reached `stage`, per day, source and device.
+model AnalyticsDaily {
+  id       String   @id @default(uuid())
+  eventId  String
+  day      DateTime @db.Date
+  stage    String
+  source   String   @default("direct")
+  device   String   @default("unknown")
+  sessions Int      @default(0)
+  event    Event    @relation(fields: [eventId], references: [id], onDelete: Cascade)
+
+  @@unique([eventId, day, stage, source, device])
+  @@index([eventId, day])
+}
+
+/// Post-event survey. Sent at sendAt to checked-in attendees (or everyone registered),
+/// with one reminder 3 days later. anonymous responses aren't linked to a person.
+model FeedbackForm {
+  id             String             @id @default(uuid())
+  eventId        String             @unique
+  sendAt         DateTime?
+  audience       String             @default("checked_in") // 'checked_in' | 'all'
+  anonymous      Boolean            @default(false)
+  intro          String?
+  sentAt         DateTime?
+  reminderSentAt DateTime?
+  createdAt      DateTime           @default(now())
+  updatedAt      DateTime           @updatedAt
+  event          Event              @relation(fields: [eventId], references: [id], onDelete: Cascade)
+  fields         FeedbackField[]
+  invites        FeedbackInvite[]
+  responses      FeedbackResponse[]
+}
+
+model FeedbackField {
+  id         String           @id @default(uuid())
+  formId     String
+  type       FormFieldType
+  label      String
+  isRequired Boolean          @default(false)
+  order      Int              @default(0)
+  helpText   String?
+  options    Json?
+  form       FeedbackForm     @relation(fields: [formId], references: [id], onDelete: Cascade)
+  answers    FeedbackAnswer[]
+
+  @@index([formId])
+}
+
+/// Who was asked. tokenHash is the HMAC of the link token (the token itself isn't stored).
+model FeedbackInvite {
+  id          String       @id @default(uuid())
+  formId      String
+  userId      String
+  tokenHash   String       @unique
+  sentAt      DateTime     @default(now())
+  remindedAt  DateTime?
+  respondedAt DateTime?
+  form        FeedbackForm @relation(fields: [formId], references: [id], onDelete: Cascade)
+  user        User         @relation(fields: [userId], references: [id], onDelete: Cascade)
+
+  @@unique([formId, userId])
+  @@index([userId])
+}
+
+model FeedbackResponse {
+  id        String           @id @default(uuid())
+  formId    String
+  userId    String? // null when the form is anonymous
+  createdAt DateTime         @default(now())
+  form      FeedbackForm     @relation(fields: [formId], references: [id], onDelete: Cascade)
+  user      User?            @relation(fields: [userId], references: [id], onDelete: SetNull)
+  answers   FeedbackAnswer[]
+
+  @@index([formId])
+}
+
+model FeedbackAnswer {
+  id         String           @id @default(uuid())
+  responseId String
+  fieldId    String
+  value      String
+  response   FeedbackResponse @relation(fields: [responseId], references: [id], onDelete: Cascade)
+  field      FeedbackField    @relation(fields: [fieldId], references: [id], onDelete: Cascade)
+
+  @@index([responseId])
+  @@index([fieldId])
+}
+
+/// A way of splitting an event's attendees up: "Rooms", "Small groups", "Buses".
+model AllocationSet {
+  id           String                 @id @default(uuid())
+  eventId      String
+  name         String
+  showOnTicket Boolean                @default(false)
+  order        Int                    @default(0)
+  createdAt    DateTime               @default(now())
+  updatedAt    DateTime               @updatedAt
+  event        Event                  @relation(fields: [eventId], references: [id], onDelete: Cascade)
+  groups       AllocationGroup[]
+  assignments  AllocationAssignment[]
+
+  @@index([eventId])
+}
+
+/// One room / group / bus in a set. gender ('male' | 'female') restricts who can join.
+model AllocationGroup {
+  id           String                 @id @default(uuid())
+  setId        String
+  name         String
+  capacity     Int?
+  gender       String?
+  leaderUserId String?
+  order        Int                    @default(0)
+  createdAt    DateTime               @default(now())
+  updatedAt    DateTime               @updatedAt
+  set          AllocationSet          @relation(fields: [setId], references: [id], onDelete: Cascade)
+  leader       User?                  @relation("AllocationGroupLeader", fields: [leaderUserId], references: [id], onDelete: SetNull)
+  assignments  AllocationAssignment[]
+
+  @@index([setId])
+  @@index([leaderUserId])
+}
+
+/// An attendee placed in a group. One group per set.
+model AllocationAssignment {
+  id         String          @id @default(uuid())
+  setId      String
+  groupId    String
+  attendeeId String
+  createdAt  DateTime        @default(now())
+  set        AllocationSet   @relation(fields: [setId], references: [id], onDelete: Cascade)
+  group      AllocationGroup @relation(fields: [groupId], references: [id], onDelete: Cascade)
+  attendee   Attendee        @relation(fields: [attendeeId], references: [id], onDelete: Cascade)
+
+  @@unique([setId, attendeeId])
+  @@index([groupId])
+  @@index([attendeeId])
+}
+
+/// A transfer waiting for the new holder to accept it from the link sent to the email /
+/// phone the sender typed. Nothing changes on the ticket until it's accepted. `details`
+/// holds what the sender entered (date of birth, gender, parent details on youth events).
+model TicketTransferRequest {
+  id            String    @id @default(uuid())
+  ticketId      String
+  requestedById String
+  toName        String
+  toEmail       String?
+  toPhone       String?
+  details       Json?
+  tokenHash     String    @unique
+  status        String    @default("pending") // pending | accepted | declined | cancelled | expired
+  expiresAt     DateTime
+  respondedAt   DateTime?
+  createdAt     DateTime  @default(now())
+  ticket        Ticket    @relation(fields: [ticketId], references: [id], onDelete: Cascade)
+  requestedBy   User      @relation("TransferRequester", fields: [requestedById], references: [id], onDelete: Cascade)
+
+  @@index([ticketId, status])
+}
+
 /// A ticket handed to someone else. oldQrCode is the code that stopped working (null
 /// when one place was split off a shared group ticket, whose code stays valid).
 model TicketTransfer {
@@ -1039,6 +1117,7 @@ model Attendee {
   ticket               Ticket?
   formResponses        FormResponse[]
   consentRequests      ConsentRequest[]
+  allocations          AllocationAssignment[]
 
   @@index([registrationId])
   @@index([registrationOptionId])

backend/scripts/migrate-env-to-db.js

@@ -24,7 +24,7 @@ const dotenv = require('dotenv');
 // Load .env from the backend root
 dotenv.config({ path: path.resolve(__dirname, '../.env') });
 
-const { PrismaClient } = require('@prisma/client');
+const { createPrismaClient } = require('../src/config/db');
 const crypto = require('crypto');
 
 const DRY_RUN = process.argv.includes('--dry-run');
@@ -52,7 +52,7 @@ function encrypt(plaintext) {
   return `${SENTINEL}${iv.toString('hex')}:${tag.toString('hex')}:${enc.toString('hex')}`;
 }
 
-const ENCRYPTED_KEYS = new Set(['smtp_user', 'smtp_pass']);
+const ENCRYPTED_KEYS = new Set(['smtp_user', 'smtp_pass', 'yoco_secret_key', 'yoco_webhook_secret']);
 
 // ─── Mapping: env var(s) → DB key ────────────────────────────────────────────
 // Each entry: { key: DB key, envVars: [...candidates in priority order], encrypt?: bool }
@@ -79,6 +79,10 @@ const MAPPINGS = [
   { key: 'smtp_user',              envVars: ['SMTP_USER',   'EMAIL_USER'],  encrypt: true         },
   { key: 'smtp_pass',              envVars: ['SMTP_PASS',   'EMAIL_PASS'],  encrypt: true         },
 
+  // Yoco payments
+  { key: 'yoco_secret_key',        envVars: ['YOCO_SECRET_KEY'],              encrypt: true         },
+  { key: 'yoco_webhook_secret',    envVars: ['YOCO_WEBHOOK_SECRET'],          encrypt: true         },
+
   // App URLs (used in email templates)
   { key: 'app_base_url',           envVars: ['FRONTEND_URL', 'APP_BASE_URL']                      },
 ];
@@ -86,7 +90,7 @@ const MAPPINGS = [
 // ─── Main ─────────────────────────────────────────────────────────────────────
 
 async function main() {
-  const prisma = new PrismaClient();
+  const prisma = createPrismaClient();
 
   console.log(`\n${'─'.repeat(60)}`);
   console.log('  Settings migration: .env → DB');

backend/scripts/seed-users.js

@@ -3,10 +3,11 @@
  * Run: node scripts/seed-users.js
  */
 
-const { PrismaClient } = require('@prisma/client');
+require('dotenv').config({ path: require('path').resolve(__dirname, '../.env') });
+const { createPrismaClient } = require('../src/config/db');
 const bcrypt = require('bcryptjs');
 
-const prisma = new PrismaClient();
+const prisma = createPrismaClient();
 
 const firstNames = [
   'Liam', 'Olivia', 'Noah', 'Emma', 'James', 'Ava', 'Elijah', 'Sophia',

backend/src/config/db.js

@@ -1,5 +1,17 @@
 const { PrismaClient } = require('@prisma/client');
+const { PrismaPg } = require('@prisma/adapter-pg');
 
-const prisma = new PrismaClient();
+// Prisma 7 talks to Postgres through the node-postgres driver adapter instead of
+// the old Rust engine. pg has no connect timeout by default; 5s matches Prisma 5.
+function createPrismaClient() {
+  const adapter = new PrismaPg({
+    connectionString: process.env.DATABASE_URL,
+    connectionTimeoutMillis: 5000,
+  });
+  return new PrismaClient({ adapter });
+}
 
-module.exports = prisma;
+const prisma = createPrismaClient();
+
+module.exports = prisma;
+module.exports.createPrismaClient = createPrismaClient;

backend/src/controllers/allocationController.js

@@ -0,0 +1,323 @@
+const prisma = require('../config/db');
+const { safeErrorMessage } = require('../utils/errorUtils');
+const { logAdminAction } = require('../utils/adminAudit');
+const { getClientIp } = require('../utils/requestUtils');
+const { allocationError, cleanGender, joinBlocker, autoAllocate } = require('../utils/allocation');
+
+const SUPERVISORS = ['admin', 'supervisor'];
+const fail = (res, error) => res.status(error.statusCode || (res.statusCode === 200 ? 400 : res.statusCode)).json({ message: safeErrorMessage(error) });
+
+const cleanName = (v, what) => {
+  const name = String(v || '').trim();
+  if (!name) throw allocationError(`Enter a name for the ${what}.`);
+  return name.slice(0, 100);
+};
+const cleanCapacity = (v) => {
+  if (v === undefined || v === null || v === '') return null;
+  const n = parseInt(v, 10);
+  if (!Number.isFinite(n) || n < 1 || n > 10000) throw allocationError('Capacity must be a whole number of at least 1.');
+  return n;
+};
+
+/** Named attendees on the event's live registrations. */
+async function eventAttendees(eventId) {
+  return prisma.attendee.findMany({
+    where: { registration: { eventId, status: { not: 'cancelled' } } },
+    select: {
+      id: true, name: true, gender: true, dateOfBirth: true, registrationId: true, email: true, phone: true,
+      registration: { select: { user: { select: { name: true } } } },
+    },
+    orderBy: [{ registrationId: 'asc' }, { order: 'asc' }],
+  });
+}
+
+async function loadSet(id) {
+  const set = await prisma.allocationSet.findUnique({ where: { id }, include: { groups: { orderBy: { order: 'asc' } } } });
+  if (!set) throw allocationError('Allocation set not found', 404);
+  return set;
+}
+
+// @desc    Everything the allocation board needs for an event
+// @route   GET /api/allocations/event/:eventId
+// @access  Private/Supervisor
+const getBoard = async (req, res) => {
+  try {
+    const event = await prisma.event.findUnique({
+      where: { id: req.params.eventId },
+      select: { id: true, title: true, startDate: true, collectGender: true, allowNamedAttendees: true, requiresParentalConsent: true },
+    });
+    if (!event) throw allocationError('Event not found', 404);
+    const [sets, attendees, leaders, places] = await Promise.all([
+      prisma.allocationSet.findMany({
+        where: { eventId: event.id },
+        include: { groups: { orderBy: { order: 'asc' }, include: { leader: { select: { id: true, name: true } } } }, assignments: { select: { attendeeId: true, groupId: true } } },
+        orderBy: [{ order: 'asc' }, { createdAt: 'asc' }],
+      }),
+      eventAttendees(event.id),
+      prisma.user.findMany({ where: { role: { in: ['staff', 'supervisor', 'admin'] }, isActive: true }, select: { id: true, name: true }, orderBy: { name: 'asc' } }),
+      prisma.registrationOption.aggregate({
+        where: { registration: { eventId: event.id, status: { not: 'cancelled' } }, eventOption: { isMainTicket: true } },
+        _sum: { quantity: true },
+      }),
+    ]);
+    res.json({
+      event,
+      sets,
+      attendees: attendees.map(a => ({ id: a.id, name: a.name, gender: a.gender, dateOfBirth: a.dateOfBirth, registrationId: a.registrationId, bookedBy: a.registration.user?.name || '' })),
+      leaders,
+      unnamedPlaces: Math.max(0, (places._sum.quantity || 0) - attendees.length),
+    });
+  } catch (error) {
+    fail(res, error);
+  }
+};
+
+// @route POST /api/allocations/sets   { eventId, name, showOnTicket? }
+const createSet = async (req, res) => {
+  try {
+    const { eventId, name, showOnTicket } = req.body || {};
+    if (!(await prisma.event.findUnique({ where: { id: String(eventId || '') }, select: { id: true } }))) throw allocationError('Event not found', 404);
+    const order = await prisma.allocationSet.count({ where: { eventId } });
+    res.status(201).json(await prisma.allocationSet.create({ data: { eventId, name: cleanName(name, 'set'), showOnTicket: showOnTicket === true, order } }));
+  } catch (error) {
+    fail(res, error);
+  }
+};
+
+// @route PUT /api/allocations/sets/:id   { name?, showOnTicket? }
+const updateSet = async (req, res) => {
+  try {
+    await loadSet(req.params.id);
+    const { name, showOnTicket } = req.body || {};
+    res.json(await prisma.allocationSet.update({
+      where: { id: req.params.id },
+      data: { ...(name !== undefined ? { name: cleanName(name, 'set') } : {}), ...(showOnTicket !== undefined ? { showOnTicket: showOnTicket === true } : {}) },
+    }));
+  } catch (error) {
+    fail(res, error);
+  }
+};
+
+// @route DELETE /api/allocations/sets/:id
+const deleteSet = async (req, res) => {
+  try {
+    await loadSet(req.params.id);
+    await prisma.allocationSet.delete({ where: { id: req.params.id } });
+    res.json({ message: 'Deleted' });
+  } catch (error) {
+    fail(res, error);
+  }
+};
+
+async function groupData(body, setId, existing = null) {
+  const { name, capacity, gender, leaderUserId } = body || {};
+  const data = {};
+  if (name !== undefined || !existing) data.name = cleanName(name, 'group');
+  if (capacity !== undefined) data.capacity = cleanCapacity(capacity);
+  if (gender !== undefined) data.gender = cleanGender(gender);
+  if (leaderUserId !== undefined) {
+    if (leaderUserId) {
+      const leader = await prisma.user.findUnique({ where: { id: String(leaderUserId) }, select: { role: true } });
+      if (!leader || !['staff', 'supervisor', 'admin'].includes(leader.role)) throw allocationError('A group leader must be a staff member.');
+    }
+    data.leaderUserId = leaderUserId || null;
+  }
+  // Changing capacity or gender mustn't leave the group over capacity or mixed.
+  if (existing && (data.capacity !== undefined || data.gender !== undefined)) {
+    const members = await prisma.allocationAssignment.findMany({ where: { groupId: existing.id }, include: { attendee: { select: { name: true, gender: true } } } });
+    const next = { ...existing, ...data };
+    const blocker = joinBlocker(next, 0, members.map(m => m.attendee));
+    if (blocker) throw allocationError(`${blocker} Move people out first.`);
+  }
+  return data;
+}
+
+// @route POST /api/allocations/sets/:id/groups   { name, capacity?, gender?, leaderUserId? }
+const createGroup = async (req, res) => {
+  try {
+    const set = await loadSet(req.params.id);
+    const data = await groupData(req.body, set.id);
+    res.status(201).json(await prisma.allocationGroup.create({ data: { ...data, setId: set.id, order: set.groups.length } }));
+  } catch (error) {
+    fail(res, error);
+  }
+};
+
+// @route PUT /api/allocations/groups/:id
+const updateGroup = async (req, res) => {
+  try {
+    const group = await prisma.allocationGroup.findUnique({ where: { id: req.params.id } });
+    if (!group) throw allocationError('Group not found', 404);
+    const data = await groupData(req.body, group.setId, group);
+    res.json(await prisma.allocationGroup.update({ where: { id: group.id }, data }));
+  } catch (error) {
+    fail(res, error);
+  }
+};
+
+// @route DELETE /api/allocations/groups/:id   (its people go back to unassigned)
+const deleteGroup = async (req, res) => {
+  try {
+    await prisma.allocationGroup.delete({ where: { id: req.params.id } });
+    res.json({ message: 'Deleted' });
+  } catch (error) {
+    if (error.code === 'P2025') return res.status(404).json({ message: 'Group not found' });
+    fail(res, error);
+  }
+};
+
+// @desc    Put an attendee in a group (groupId null = unassign)
+// @route   PUT /api/allocations/sets/:id/assignments   { attendeeId, groupId }
+const assign = async (req, res) => {
+  try {
+    const set = await loadSet(req.params.id);
+    const { attendeeId, groupId } = req.body || {};
+    const attendee = await prisma.attendee.findFirst({
+      where: { id: String(attendeeId || ''), registration: { eventId: set.eventId, status: { not: 'cancelled' } } },
+      select: { id: true, name: true, gender: true },
+    });
+    if (!attendee) throw allocationError('Attendee not found for this event', 404);
+    if (!groupId) {
+      await prisma.allocationAssignment.deleteMany({ where: { setId: set.id, attendeeId: attendee.id } });
+      return res.json({ message: 'Unassigned' });
+    }
+    const group = set.groups.find(g => g.id === groupId);
+    if (!group) throw allocationError('Group not found in this set', 404);
+    await prisma.$transaction(async (tx) => {
+      await tx.$executeRaw`SELECT pg_advisory_xact_lock(hashtext(${'alloc:' + group.id}))`;
+      const count = await tx.allocationAssignment.count({ where: { groupId: group.id, NOT: { attendeeId: attendee.id } } });
+      const blocker = joinBlocker(group, count, [attendee]);
+      if (blocker) throw allocationError(blocker);
+      await tx.allocationAssignment.upsert({
+        where: { setId_attendeeId: { setId: set.id, attendeeId: attendee.id } },
+        update: { groupId: group.id },
+        create: { setId: set.id, groupId: group.id, attendeeId: attendee.id },
+      });
+    });
+    res.json({ message: `${attendee.name} → ${group.name}` });
+  } catch (error) {
+    fail(res, error);
+  }
+};
+
+// @desc    Place everyone not yet in a group
+// @route   POST /api/allocations/sets/:id/auto   { mode: 'together' | 'split' }
+const autoAssign = async (req, res) => {
+  try {
+    const set = await loadSet(req.params.id);
+    if (set.groups.length === 0) throw allocationError('Add some groups first.');
+    const mode = req.body?.mode === 'split' ? 'split' : 'together';
+    const result = await prisma.$transaction(async (tx) => {
+      await tx.$executeRaw`SELECT pg_advisory_xact_lock(hashtext(${'allocset:' + set.id}))`;
+      const [attendees, existing] = await Promise.all([
+        eventAttendees(set.eventId),
+        tx.allocationAssignment.findMany({ where: { setId: set.id } }),
+      ]);
+      const r = autoAllocate({ groups: set.groups, attendees, assigned: new Map(existing.map(a => [a.attendeeId, a.groupId])), mode });
+      if (r.placements.length) {
+        await tx.allocationAssignment.createMany({ data: r.placements.map(p => ({ setId: set.id, groupId: p.groupId, attendeeId: p.attendeeId })), skipDuplicates: true });
+      }
+      return r;
+    });
+    res.json({
+      placed: result.placements.length,
+      unplaced: result.unplaced.length,
+      message: `${result.placements.length} placed${result.unplaced.length ? `; ${result.unplaced.length} couldn't be placed (groups full, or gender doesn't match)` : ''}.`,
+    });
+  } catch (error) {
+    fail(res, error);
+  }
+};
+
+// @route DELETE /api/allocations/sets/:id/assignments   (clear the whole set)
+const clearAssignments = async (req, res) => {
+  try {
+    const set = await loadSet(req.params.id);
+    const { count } = await prisma.allocationAssignment.deleteMany({ where: { setId: set.id } });
+    res.json({ message: `${count} removed from groups.` });
+  } catch (error) {
+    fail(res, error);
+  }
+};
+
+/** Members of groups, with contact and (for supervisors) medical details. */
+async function groupMembers(groupIds, { withMedical }) {
+  const assignments = await prisma.allocationAssignment.findMany({
+    where: { groupId: { in: groupIds } },
+    include: {
+      attendee: {
+        select: {
+          id: true, name: true, gender: true, dateOfBirth: true, phone: true, parentName: true, parentPhone: true,
+          registration: { select: { user: { select: { name: true, phoneNumber: true } } } },
+        },
+      },
+    },
+    orderBy: { attendee: { name: 'asc' } },
+  });
+  let consent = new Map();
+  if (withMedical && assignments.length) {
+    const { latestRequestsFor, openJson } = require('../utils/consent');
+    const latest = await latestRequestsFor(assignments.map(a => a.attendeeId));
+    consent = new Map([...latest].map(([id, r]) => [id, r.status === 'given' ? { medical: openJson(r.medical), emergency: openJson(r.emergency) } : null]));
+  }
+  return assignments.map(a => ({
+    groupId: a.groupId,
+    id: a.attendee.id,
+    name: a.attendee.name,
+    gender: a.attendee.gender,
+    dateOfBirth: a.attendee.dateOfBirth,
+    phone: a.attendee.phone,
+    parentName: a.attendee.parentName,
+    parentPhone: a.attendee.parentPhone,
+    bookedBy: a.attendee.registration.user?.name || '',
+    bookedByPhone: a.attendee.registration.user?.phoneNumber || null,
+    ...(withMedical ? consent.get(a.attendee.id) || {} : {}),
+  }));
+}
+
+// @desc    Lists for printing: every group of a set, with members
+// @route   GET /api/allocations/sets/:id/lists?medical=true
+// @access  Private/Supervisor
+const getSetLists = async (req, res) => {
+  try {
+    const set = await prisma.allocationSet.findUnique({
+      where: { id: req.params.id },
+      include: { event: { select: { id: true, title: true, startDate: true } }, groups: { orderBy: { order: 'asc' }, include: { leader: { select: { name: true } } } } },
+    });
+    if (!set) throw allocationError('Allocation set not found', 404);
+    const withMedical = req.query.medical === 'true';
+    const members = await groupMembers(set.groups.map(g => g.id), { withMedical });
+    if (withMedical) {
+      logAdminAction({ actorId: req.user.id, actorRole: req.user.role, action: 'medical_list_viewed', targetType: 'AllocationSet', targetId: set.id, metadata: { eventId: set.eventId, attendees: members.length }, ip: getClientIp(req) });
+    }
+    res.json({ set: { id: set.id, name: set.name }, event: set.event, groups: set.groups.map(g => ({ id: g.id, name: g.name, capacity: g.capacity, gender: g.gender, leader: g.leader?.name || null, members: members.filter(m => m.groupId === g.id) })) });
+  } catch (error) {
+    fail(res, error);
+  }
+};
+
+// @desc    Groups the signed-in staff member leads, with their people
+// @route   GET /api/allocations/my-groups
+// @access  Private/Staff
+const getMyGroups = async (req, res) => {
+  try {
+    const groups = await prisma.allocationGroup.findMany({
+      where: { leaderUserId: req.user.id, set: { event: { endDate: { gte: new Date(Date.now() - 7 * 864e5) } } } },
+      include: { set: { include: { event: { select: { id: true, title: true, startDate: true } } } } },
+      orderBy: [{ set: { event: { startDate: 'asc' } } }, { order: 'asc' }],
+    });
+    const withMedical = SUPERVISORS.includes(req.user.role);
+    const members = await groupMembers(groups.map(g => g.id), { withMedical });
+    if (withMedical && members.length) {
+      logAdminAction({ actorId: req.user.id, actorRole: req.user.role, action: 'medical_list_viewed', targetType: 'AllocationGroup', targetId: null, metadata: { groups: groups.length, attendees: members.length }, ip: getClientIp(req) });
+    }
+    res.json({
+      medicalShown: withMedical,
+      groups: groups.map(g => ({ id: g.id, name: g.name, capacity: g.capacity, gender: g.gender, setName: g.set.name, event: g.set.event, members: members.filter(m => m.groupId === g.id) })),
+    });
+  } catch (error) {
+    fail(res, error);
+  }
+};
+
+module.exports = { getBoard, createSet, updateSet, deleteSet, createGroup, updateGroup, deleteGroup, assign, autoAssign, clearAssignments, getSetLists, getMyGroups };

backend/src/controllers/analyticsController.js

@@ -0,0 +1,44 @@
+const prisma = require('../config/db');
+const { safeErrorMessage } = require('../utils/errorUtils');
+const { track, funnelFor } = require('../utils/analytics');
+
+// @desc    Record a funnel step (event page view, registration started)
+// @route   POST /api/analytics/track   { sessionId, eventId, stage: 'view'|'start', source? }
+// @access  Public — only sent by browsers whose visitor accepted cookies
+const trackStage = async (req, res) => {
+  try {
+    const { sessionId, eventId, stage, source } = req.body || {};
+    await track({ sessionId, eventId, stage, source, userAgent: req.headers['user-agent'] });
+  } catch (e) {
+    console.warn('[analytics] track failed:', e?.message || e);
+  }
+  // Always a quiet 204 — tracking must never get in a visitor's way.
+  res.status(204).end();
+};
+
+// @desc    Registration funnel for one or more events
+// @route   GET /api/analytics/funnel?eventIds=a,b&from=YYYY-MM-DD&to=YYYY-MM-DD
+// @access  Private/Supervisor
+const getFunnel = async (req, res) => {
+  try {
+    const eventIds = String(req.query.eventIds || '').split(',').map(s => s.trim()).filter(Boolean).slice(0, 50);
+    if (eventIds.length === 0) { res.status(400); throw new Error('Choose at least one event'); }
+    const events = await prisma.event.findMany({ where: { id: { in: eventIds } }, select: { id: true, title: true } });
+    const total = await funnelFor(eventIds, { from: req.query.from, to: req.query.to });
+    // Per event too, so events can be compared.
+    const perEvent = [];
+    if (events.length > 1) {
+      for (const ev of events) {
+        const f = await funnelFor([ev.id], { from: req.query.from, to: req.query.to });
+        perEvent.push({ eventId: ev.id, title: ev.title, totals: f.totals, conversion: f.conversion });
+      }
+    } else if (events[0]) {
+      perEvent.push({ eventId: events[0].id, title: events[0].title, totals: total.totals, conversion: total.conversion });
+    }
+    res.json({ ...total, perEvent });
+  } catch (error) {
+    res.status(res.statusCode === 200 ? 400 : res.statusCode).json({ message: safeErrorMessage(error) });
+  }
+};
+
+module.exports = { trackStage, getFunnel };

backend/src/controllers/automationController.js

@@ -24,7 +24,7 @@ async function scheduleAutomations(req, res) {
         html: j.html ? String(j.html) : undefined,
         text: (!j.html && j.text) ? String(j.text) : (j.text ? String(j.text) : undefined),
         template: 'custom',
-        filter: { status: undefined, attendeeIds: undefined },
+        filter: { status: undefined, attendeeIds: undefined, ...(j.audience === 'sponsors' ? { audience: 'sponsors' } : {}) },
       };
       if (j.promoEventId && typeof j.promoEventId === 'string') {
         payload.promoEventId = j.promoEventId;

backend/src/controllers/eventController.js

@@ -44,7 +44,7 @@ function toAbsoluteUrl(req, url) {
 // @access  Private/Admin
 const createEvent = async (req, res) => {
   try {
-    const { title, description, startDate, endDate, registrationDeadline, goLiveAt, price, picture, redirectUrl, isHidden, requiresAuth, requiresRegistration, allowNamedAttendees, requiresParentalConsent, consentText, consentCollectMedical, consentCollectEmergency, consentCollectPhoto, waitlistEnabled, waitlistOfferHours, waitlistPartialOffers, allowTicketTransfer, contactName, contactPhone, contactEmail, location } = req.body;
+    const { title, description, startDate, endDate, registrationDeadline, goLiveAt, price, picture, redirectUrl, isHidden, requiresAuth, requiresRegistration, allowNamedAttendees, requiresParentalConsent, consentText, consentCollectMedical, consentCollectEmergency, consentCollectPhoto, waitlistEnabled, waitlistOfferHours, waitlistPartialOffers, allowTicketTransfer, collectGender, allowSponsorships, sponsorshipGoalSpots, showSponsorshipProgress, contactName, contactPhone, contactEmail, location } = req.body;
 
     const data = {
       id: uuidv4(),
@@ -71,6 +71,10 @@ const createEvent = async (req, res) => {
       consentCollectPhoto: consentCollectPhoto === true,
       waitlistEnabled: waitlistEnabled === true,
       allowTicketTransfer: allowTicketTransfer !== false,
+      collectGender: collectGender === true,
+      allowSponsorships: allowSponsorships === true,
+      sponsorshipGoalSpots: sponsorshipGoalSpots ? Math.max(1, parseInt(sponsorshipGoalSpots, 10) || 0) || null : null,
+      showSponsorshipProgress: showSponsorshipProgress !== false,
       waitlistOfferHours: Math.min(168, Math.max(1, parseInt(waitlistOfferHours, 10) || 24)),
       waitlistPartialOffers: waitlistPartialOffers !== false,
       contactName: contactName || null,
@@ -537,7 +541,7 @@ const updateEvent = async (req, res) => {
       ip: getClientIp(req),
     });
 
-    const { title, description, startDate, endDate, registrationDeadline, goLiveAt, price, picture, isActive, redirectUrl, isHidden, requiresAuth, requiresRegistration, allowNamedAttendees, requiresParentalConsent, consentText, consentCollectMedical, consentCollectEmergency, consentCollectPhoto, waitlistEnabled, waitlistOfferHours, waitlistPartialOffers, allowTicketTransfer, contactName, contactPhone, contactEmail, location } = req.body;
+    const { title, description, startDate, endDate, registrationDeadline, goLiveAt, price, picture, isActive, redirectUrl, isHidden, requiresAuth, requiresRegistration, allowNamedAttendees, requiresParentalConsent, consentText, consentCollectMedical, consentCollectEmergency, consentCollectPhoto, waitlistEnabled, waitlistOfferHours, waitlistPartialOffers, allowTicketTransfer, collectGender, allowSponsorships, sponsorshipGoalSpots, showSponsorshipProgress, contactName, contactPhone, contactEmail, location } = req.body;
 
     const data = {
       title: title || event.title,
@@ -561,6 +565,10 @@ const updateEvent = async (req, res) => {
       consentCollectPhoto: consentCollectPhoto !== undefined ? consentCollectPhoto === true : event.consentCollectPhoto,
       waitlistEnabled: waitlistEnabled !== undefined ? waitlistEnabled === true : event.waitlistEnabled,
       allowTicketTransfer: allowTicketTransfer !== undefined ? allowTicketTransfer !== false : event.allowTicketTransfer,
+      collectGender: collectGender !== undefined ? collectGender === true : event.collectGender,
+      allowSponsorships: allowSponsorships !== undefined ? allowSponsorships === true : event.allowSponsorships,
+      sponsorshipGoalSpots: sponsorshipGoalSpots !== undefined ? (sponsorshipGoalSpots ? Math.max(1, parseInt(sponsorshipGoalSpots, 10) || 0) || null : null) : event.sponsorshipGoalSpots,
+      showSponsorshipProgress: showSponsorshipProgress !== undefined ? showSponsorshipProgress !== false : event.showSponsorshipProgress,
       waitlistOfferHours: waitlistOfferHours !== undefined ? Math.min(168, Math.max(1, parseInt(waitlistOfferHours, 10) || 24)) : event.waitlistOfferHours,
       waitlistPartialOffers: waitlistPartialOffers !== undefined ? waitlistPartialOffers !== false : event.waitlistPartialOffers,
       // Editing the consent text starts a new version; parents who already agreed keep
@@ -1331,6 +1339,11 @@ const emailEventAttendees = async (req, res) => {
       where.status = 'cancelled';
     }
 
+    // Only registrations with someone in this allocation group ("everyone on Bus 2").
+    if (filter?.allocationGroupId) {
+      where.attendees = { some: { allocations: { some: { groupId: String(filter.allocationGroupId) } } } };
+    }
+
     // Optional explicit attendee selection by userIds
     const attendeeIds = Array.isArray(filter?.attendeeIds) ? filter.attendeeIds.filter((x) => typeof x === 'string' && x.trim().length > 0) : [];
     if (attendeeIds.length > 0) {
@@ -1381,6 +1394,24 @@ const emailEventAttendees = async (req, res) => {
     }
     const recipients = Array.from(uniqMap.values());
 
+    // Sponsors of this event instead of its attendees (e.g. the post-event thank-you).
+    if (filter?.audience === 'sponsors') {
+      recipients.length = 0;
+      registrations.length = 0;
+      const sponsorships = await prisma.payment.findMany({
+        where: { eventId, isDonation: true, isSponsorship: true, amount: { gt: 0 } },
+        include: { user: { select: { name: true, email: true, isActive: true } } },
+        orderBy: { createdAt: 'asc' },
+      });
+      const seen = new Set();
+      for (const s of sponsorships) {
+        const email = (s.user?.email || '').trim();
+        if (!email || email.endsWith('@guest.local') || email.endsWith('@deleted.invalid') || seen.has(email)) continue;
+        seen.add(email);
+        recipients.push({ email, name: s.sponsorName || s.user?.name || '' });
+      }
+    }
+
     if (dryRun) {
       return res.json({ eventId, matched: recipients.length, recipients: recipients.slice(0, 20) });
     }
@@ -1569,6 +1600,11 @@ const whatsappEventAttendees = async (req, res) => {
       where.status = 'cancelled';
     }
 
+    // Only registrations with someone in this allocation group ("everyone on Bus 2").
+    if (filter?.allocationGroupId) {
+      where.attendees = { some: { allocations: { some: { groupId: String(filter.allocationGroupId) } } } };
+    }
+
     const attendeeIds = Array.isArray(filter?.attendeeIds) ? filter.attendeeIds.filter((x) => typeof x === 'string' && x.trim().length > 0) : [];
     if (attendeeIds.length > 0) {
       where.userId = { in: attendeeIds };

backend/src/controllers/feedbackController.js

@@ -0,0 +1,179 @@
+const prisma = require('../config/db');
+const { safeErrorMessage } = require('../utils/errorUtils');
+const { ANSWERABLE, feedbackError, cleanFields, cleanAnswer, summarise, sendFeedbackInvites, findInviteByToken } = require('../utils/feedback');
+
+const fail = (res, error) => res.status(error.statusCode || (res.statusCode === 200 ? 400 : res.statusCode)).json({ message: safeErrorMessage(error) });
+const shape = (fields) => JSON.stringify(fields.map(f => [f.type, f.label, f.isRequired, f.options || null, f.helpText || null]));
+
+async function formWithStats(eventId) {
+  const form = await prisma.feedbackForm.findUnique({ where: { eventId }, include: { fields: { orderBy: { order: 'asc' } } } });
+  if (!form) return null;
+  const [invited, responses] = await Promise.all([
+    prisma.feedbackInvite.count({ where: { formId: form.id } }),
+    prisma.feedbackResponse.count({ where: { formId: form.id } }),
+  ]);
+  return { ...form, invited, responses };
+}
+
+// @desc    An event's feedback form (with invite/response counts)
+// @route   GET /api/feedback/event/:eventId
+// @access  Private/Supervisor
+const getEventFeedback = async (req, res) => {
+  try {
+    res.json(await formWithStats(req.params.eventId));
+  } catch (error) {
+    fail(res, error);
+  }
+};
+
+// @desc    Create or update an event's feedback form
+// @route   PUT /api/feedback/event/:eventId   { sendAt, audience, anonymous, intro, fields[] }
+// @access  Private/Supervisor
+const saveEventFeedback = async (req, res) => {
+  try {
+    const event = await prisma.event.findUnique({ where: { id: req.params.eventId }, select: { id: true, endDate: true } });
+    if (!event) throw feedbackError('Event not found', 404);
+    const { sendAt, audience, anonymous, intro, fields } = req.body || {};
+    const clean = cleanFields(fields);
+    let when = null;
+    if (sendAt) {
+      when = new Date(sendAt);
+      if (isNaN(when.getTime())) throw feedbackError('Enter a valid send time.');
+    }
+    const data = {
+      sendAt: when,
+      audience: audience === 'all' ? 'all' : 'checked_in',
+      anonymous: anonymous === true,
+      intro: intro ? String(intro).slice(0, 2000) : null,
+    };
+
+    const existing = await prisma.feedbackForm.findUnique({ where: { eventId: event.id }, include: { fields: { orderBy: { order: 'asc' } } } });
+    if (!existing) {
+      await prisma.feedbackForm.create({ data: { ...data, eventId: event.id, fields: { create: clean } } });
+    } else {
+      const answered = await prisma.feedbackResponse.count({ where: { formId: existing.id } });
+      const changed = shape(existing.fields) !== shape(clean);
+      if (answered > 0 && changed) throw feedbackError('People have already answered this feedback form, so its questions can’t be changed.', 409);
+      await prisma.$transaction(async (tx) => {
+        await tx.feedbackForm.update({ where: { id: existing.id }, data: existing.sentAt ? { ...data, sendAt: existing.sendAt } : data });
+        if (changed) {
+          await tx.feedbackField.deleteMany({ where: { formId: existing.id } });
+          await tx.feedbackField.createMany({ data: clean.map(f => ({ ...f, formId: existing.id, options: f.options ?? undefined })) });
+        }
+      });
+    }
+    res.json(await formWithStats(event.id));
+  } catch (error) {
+    fail(res, error);
+  }
+};
+
+// @route DELETE /api/feedback/event/:eventId
+const deleteEventFeedback = async (req, res) => {
+  try {
+    await prisma.feedbackForm.deleteMany({ where: { eventId: req.params.eventId } });
+    res.json({ message: 'Feedback form removed' });
+  } catch (error) {
+    fail(res, error);
+  }
+};
+
+// @desc    Send the feedback form now (instead of waiting for its send time)
+// @route   POST /api/feedback/event/:eventId/send-now
+// @access  Private/Supervisor
+const sendNow = async (req, res) => {
+  try {
+    const form = await prisma.feedbackForm.findUnique({ where: { eventId: req.params.eventId } });
+    if (!form) throw feedbackError('This event has no feedback form.', 404);
+    if (!form.sentAt) await prisma.feedbackForm.update({ where: { id: form.id }, data: { sentAt: new Date(), sendAt: form.sendAt || new Date() } });
+    // Also invites anyone who checked in after the first send.
+    const invited = await sendFeedbackInvites(form.id);
+    res.json({ invited, message: invited ? `Feedback form sent to ${invited} ${invited === 1 ? 'person' : 'people'}.` : 'Everyone has already been sent the form.' });
+  } catch (error) {
+    fail(res, error);
+  }
+};
+
+// @desc    The form behind a personal feedback link
+// @route   GET /api/feedback/public/:token
+// @access  Public (link holder)
+const getPublicForm = async (req, res) => {
+  try {
+    const invite = await findInviteByToken(req.params.token);
+    if (!invite) throw feedbackError('This feedback link isn’t valid (it may have been replaced by a newer one).', 404);
+    const { form } = invite;
+    res.json({
+      event: form.event,
+      name: invite.user?.name || '',
+      intro: form.intro,
+      anonymous: form.anonymous,
+      responded: !!invite.respondedAt,
+      fields: form.fields.map(f => ({ id: f.id, type: f.type, label: f.label, isRequired: f.isRequired, helpText: f.helpText, options: f.options })),
+    });
+  } catch (error) {
+    fail(res, error);
+  }
+};
+
+// @desc    Submit feedback (once per person)
+// @route   POST /api/feedback/public/:token   { answers: { fieldId: value } }
+// @access  Public (link holder)
+const submitPublicForm = async (req, res) => {
+  try {
+    const invite = await findInviteByToken(req.params.token);
+    if (!invite) throw feedbackError('This feedback link isn’t valid (it may have been replaced by a newer one).', 404);
+    if (invite.respondedAt) throw feedbackError('Thanks — you’ve already given feedback for this event.', 409);
+    const answers = req.body?.answers || {};
+    const rows = [];
+    for (const f of invite.form.fields.filter(x => ANSWERABLE.includes(x.type))) {
+      const value = cleanAnswer(f, answers[f.id]);
+      if (value !== null) rows.push({ fieldId: f.id, value });
+    }
+    if (rows.length === 0) throw feedbackError('Please answer at least one question.');
+    await prisma.$transaction(async (tx) => {
+      // Claim the invite first, so a double-submit can't create two responses.
+      const claimed = await tx.feedbackInvite.updateMany({ where: { id: invite.id, respondedAt: null }, data: { respondedAt: new Date() } });
+      if (claimed.count !== 1) throw feedbackError('Thanks — you’ve already given feedback for this event.', 409);
+      await tx.feedbackResponse.create({
+        data: { formId: invite.formId, userId: invite.form.anonymous ? null : invite.userId, answers: { create: rows } },
+      });
+    });
+    res.status(201).json({ message: 'Thank you for your feedback!' });
+  } catch (error) {
+    fail(res, error);
+  }
+};
+
+// @desc    Feedback summary for one or more events (for the report, and comparisons)
+// @route   GET /api/feedback/summary?eventIds=a,b
+// @access  Private/Supervisor
+const getSummary = async (req, res) => {
+  try {
+    const ids = String(req.query.eventIds || '').split(',').map(s => s.trim()).filter(Boolean).slice(0, 50);
+    const forms = await prisma.feedbackForm.findMany({
+      where: { eventId: { in: ids } },
+      include: {
+        event: { select: { id: true, title: true, startDate: true } },
+        fields: { orderBy: { order: 'asc' } },
+        responses: { include: { answers: true, user: { select: { name: true } } } },
+        _count: { select: { invites: true } },
+      },
+    });
+    const out = forms.map(form => {
+      const answers = form.responses.flatMap(r => r.answers.map(a => ({ fieldId: a.fieldId, value: a.value, ...(form.anonymous ? {} : { name: r.user?.name || '' }) })));
+      const invited = form._count.invites;
+      return {
+        eventId: form.event.id, title: form.event.title, startDate: form.event.startDate,
+        anonymous: form.anonymous, sentAt: form.sentAt,
+        invited, responses: form.responses.length,
+        responseRate: invited ? Math.round((form.responses.length / invited) * 100) : null,
+        questions: summarise(form.fields, answers),
+      };
+    }).sort((a, b) => new Date(a.startDate) - new Date(b.startDate));
+    res.json(out);
+  } catch (error) {
+    fail(res, error);
+  }
+};
+
+module.exports = { getEventFeedback, saveEventFeedback, deleteEventFeedback, sendNow, getPublicForm, submitPublicForm, getSummary };

backend/src/controllers/impersonationController.js

@@ -0,0 +1,108 @@
+const jwt = require('jsonwebtoken');
+const prisma = require('../config/db');
+const { safeErrorMessage } = require('../utils/errorUtils');
+const { logAdminAction } = require('../utils/adminAudit');
+const { getClientIp } = require('../utils/requestUtils');
+const { MAX_MINUTES, impersonationBlocker, logRequest } = require('../utils/impersonation');
+
+const fail = (res, error) => res.status(error.statusCode || (res.statusCode === 200 ? 400 : res.statusCode)).json({ message: safeErrorMessage(error) });
+const err = (message, statusCode = 400) => Object.assign(new Error(message), { statusCode });
+
+// @desc    Start viewing the site as a user (read-only, 30 minutes)
+// @route   POST /api/admin/impersonate/:userId   { reason }
+// @access  Private/Admin (with 2FA)
+const startImpersonation = async (req, res) => {
+  try {
+    if (req.readOnly) throw err('End the current impersonation first.', 403);
+    const reason = String(req.body?.reason || '').trim();
+    if (reason.length < 5) throw err('Give a reason (at least a few words) — it is recorded in the audit log.');
+    const target = await prisma.user.findUnique({ where: { id: req.params.userId }, select: { id: true, name: true, email: true, role: true, isActive: true, tokenVersion: true } });
+    const blocker = impersonationBlocker(req.user, target);
+    if (blocker) throw err(blocker, target ? 403 : 404);
+
+    // One live session per admin.
+    await prisma.impersonationSession.updateMany({ where: { adminId: req.user.id, endedAt: null }, data: { endedAt: new Date(), endedReason: 'replaced' } });
+    const expiresAt = new Date(Date.now() + MAX_MINUTES * 60 * 1000);
+    const session = await prisma.impersonationSession.create({ data: { adminId: req.user.id, targetUserId: target.id, reason: reason.slice(0, 500), expiresAt } });
+    const token = jwt.sign({ id: target.id, role: target.role, tokenVersion: target.tokenVersion, imp: session.id }, process.env.JWT_SECRET, { expiresIn: `${MAX_MINUTES}m` });
+
+    logAdminAction({
+      actorId: req.user.id, actorRole: req.user.role, action: 'impersonation_started', targetType: 'User', targetId: target.id,
+      metadata: { sessionId: session.id, reason: session.reason, targetName: target.name, expiresAt }, ip: getClientIp(req),
+    });
+
+    // Optional: tell the user (Site Settings → Security).
+    const { getSettingSync } = require('../utils/settingsCache');
+    if (getSettingSync('notify_user_on_impersonation', 'false') === 'true' && target.email && !target.email.endsWith('@guest.local')) {
+      const { sendMail } = require('../utils/email');
+      const orgName = getSettingSync('org_name', process.env.ORG_NAME || 'Cross Code');
+      sendMail({
+        to: target.email,
+        subject: `An administrator viewed your account — ${orgName}`,
+        text: `Hi ${target.name || 'there'},\n\nAn administrator at ${orgName} viewed your account (read-only) to help with support.\nReason given: ${session.reason}\n\nNothing was changed. If you have questions, reply to this email.\n\n${orgName}`,
+      }).catch(() => {});
+    }
+
+    res.status(201).json({ token, session: { id: session.id, expiresAt, target: { id: target.id, name: target.name, email: target.email, role: target.role } } });
+  } catch (error) {
+    fail(res, error);
+  }
+};
+
+// @desc    End impersonation (called with the impersonation token)
+// @route   POST /api/admin/impersonate/end
+// @access  Impersonation token
+const endImpersonation = async (req, res) => {
+  try {
+    const sessionId = req.impersonation?.id;
+    if (!sessionId) throw err('Not impersonating.', 400);
+    const s = await prisma.impersonationSession.update({ where: { id: sessionId }, data: { endedAt: new Date(), endedReason: 'ended' } });
+    const count = await prisma.impersonationRequestLog.count({ where: { sessionId } });
+    logAdminAction({
+      actorId: s.adminId, actorRole: 'admin', action: 'impersonation_ended', targetType: 'User', targetId: s.targetUserId,
+      metadata: { sessionId, minutes: Math.round((Date.now() - s.startedAt.getTime()) / 60000), requests: count }, ip: getClientIp(req),
+    });
+    res.json({ message: 'Impersonation ended.' });
+  } catch (error) {
+    fail(res, error);
+  }
+};
+
+// @desc    Record a page the admin viewed while impersonating
+// @route   POST /api/admin/impersonate/log   { path }
+// @access  Impersonation token
+const logPageView = async (req, res) => {
+  if (req.impersonation?.id) logRequest(req.impersonation.id, 'PAGE', String(req.body?.path || '').slice(0, 500));
+  res.status(204).end();
+};
+
+// @desc    The current impersonation session (for the banner)
+// @route   GET /api/admin/impersonate/current
+// @access  Impersonation token
+const currentImpersonation = async (req, res) => {
+  const s = req.impersonation;
+  if (!s) return res.json(null);
+  res.json({ id: s.id, expiresAt: s.expiresAt, target: { id: req.user.id, name: req.user.name, email: req.user.email } });
+};
+
+// @desc    Impersonation sessions with their request trail (audit log page)
+// @route   GET /api/admin/impersonation-sessions
+// @access  Private/Admin
+const listSessions = async (req, res) => {
+  try {
+    const sessions = await prisma.impersonationSession.findMany({
+      orderBy: { startedAt: 'desc' },
+      take: Math.min(parseInt(req.query.limit, 10) || 50, 200),
+      include: {
+        admin: { select: { name: true, email: true } },
+        target: { select: { name: true, email: true } },
+        requests: { orderBy: { createdAt: 'asc' }, take: 500, select: { method: true, path: true, blocked: true, createdAt: true } },
+      },
+    });
+    res.json(sessions);
+  } catch (error) {
+    fail(res, error);
+  }
+};
+
+module.exports = { startImpersonation, endImpersonation, logPageView, currentImpersonation, listSessions };

backend/src/controllers/paymentController.js

@@ -6,6 +6,7 @@ const { computeDonationRemaining } = require('../utils/donationUtils');
 const { logAdminAction } = require('../utils/adminAudit');
 const { getClientIp } = require('../utils/requestUtils');
 const axios = require('axios');
+const { yocoAuthHeader } = require('../utils/yoco');
 const { emailTickets } = require('./ticketController');
 const { safeErrorMessage } = require('../utils/errorUtils');
 const { assertEventOpen, assertRegistrationEventOpen } = require('../utils/cashupUtils');
@@ -987,7 +988,7 @@ async function createRegistrationCheckoutInternal(registrationId, userId, { succ
   const response = await axios.post(
     'https://payments.yoco.com/api/checkouts',
     checkoutData,
-    { headers: { 'Content-Type': 'application/json', 'Authorization': `Bearer ${process.env.YOCO_SECRET_KEY}`, 'Idempotency-Key': idempotencyKey } }
+    { headers: { 'Content-Type': 'application/json', 'Authorization': await yocoAuthHeader(), 'Idempotency-Key': idempotencyKey } }
   );
 
   await prisma.registration.update({
@@ -1090,7 +1091,7 @@ const createYocoCheckout = async (req, res) => {
           lineItems.push({ displayName: 'Partial Payment', quantity: 1, pricingDetails: { price: -Math.round((remainingAmount - charge) * 100) } });
         }
         const checkoutData = { amount: amountInCents, currency: 'ZAR', metadata: { registrationId, userId, eventId: registration.eventId, eventTitle: registration.event.title, type: 'registration_payment' }, successUrl, cancelUrl, failureUrl, lineItems };
-        const response = await axios.post('https://payments.yoco.com/api/checkouts', checkoutData, { headers: { 'Content-Type': 'application/json', 'Authorization': `Bearer ${process.env.YOCO_SECRET_KEY}`, 'Idempotency-Key': `reg_${registrationId}_${amountInCents}_${Date.now()}` } });
+        const response = await axios.post('https://payments.yoco.com/api/checkouts', checkoutData, { headers: { 'Content-Type': 'application/json', 'Authorization': await yocoAuthHeader(), 'Idempotency-Key': `reg_${registrationId}_${amountInCents}_${Date.now()}` } });
         await prisma.registration.update({ where: { id: registrationId }, data: { checkoutId: response.data.id, updatedAt: new Date() } });
         return res.status(200).json({ checkoutId: response.data.id, redirectUrl: response.data.redirectUrl, amount: charge, registration: { id: registration.id, eventId: registration.eventId, eventTitle: registration.event.title } });
       }
@@ -1151,7 +1152,7 @@ const createYocoCheckout = async (req, res) => {
       const response = await axios.post(
         'https://payments.yoco.com/api/checkouts',
         checkoutData,
-        { headers: { 'Content-Type': 'application/json', 'Authorization': `Bearer ${process.env.YOCO_SECRET_KEY}`, 'Idempotency-Key': idempotencyKey } }
+        { headers: { 'Content-Type': 'application/json', 'Authorization': await yocoAuthHeader(), 'Idempotency-Key': idempotencyKey } }
       );
 
       return res.status(200).json({
@@ -1163,7 +1164,7 @@ const createYocoCheckout = async (req, res) => {
     }
   } catch (error) {
     console.error('Yoco checkout error:', error.response?.data || error.message);
-    res.status(error.response?.status || 400).json({ 
+    res.status(error.statusCode || error.response?.status || 400).json({ 
       message: error.response?.data?.message || error.message 
     });
   }

backend/src/controllers/registrationController.js

@@ -110,7 +110,7 @@ async function checkVariantStock(variant, requestedQty, excludeEntryId = null) {
 // @access  Private
 const createRegistration = async (req, res) => {
   try {
-    const { eventId, options, guestName, guestEmail, guestPhone, couponCode, attendees, ticketDelivery, waitlistToken } = req.body;
+    const { eventId, options, guestName, guestEmail, guestPhone, couponCode, attendees, ticketDelivery, waitlistToken, analyticsSessionId } = req.body;
 
     // Check if event exists
     const canIncludeVariants = !!(prisma && prisma.optionVariant && typeof prisma.optionVariant.findMany === 'function');
@@ -503,6 +503,12 @@ const createRegistration = async (req, res) => {
       }
     })();
 
+    // Funnel: this registration came from a tracked (cookie-consented) visit.
+    if (analyticsSessionId) {
+      const { recordSubmit } = require('../utils/analytics');
+      recordSubmit(registration, analyticsSessionId).catch(e => console.warn('[analytics] submit not recorded:', e?.message || e));
+    }
+
     res.status(201).json({ ...attachComputedTotals(registration), ...(couponError ? { couponError } : {}) });
   } catch (error) {
     res.status(400).json({ message: error.message });
@@ -580,7 +586,7 @@ const getUserRegistrations = async (req, res) => {
       where: { ...whereClause, status: { in: ['pending', 'partial_paid'] } },
       select: { id: true }
     });
-    if (staleCandidates.length > 0) {
+    if (staleCandidates.length > 0 && !req.readOnly) {
       await Promise.all(staleCandidates.map(r => refreshPricingForRegistration(r.id).catch(() => {})));
     }
 
@@ -657,7 +663,7 @@ const getRegistrationById = async (req, res) => {
 
     // See getUserRegistrations — keep an unpaid/partially-paid registration's price current
     // whenever it's viewed, not just at payment time.
-    if (registration.status === 'pending' || registration.status === 'partial_paid') {
+    if ((registration.status === 'pending' || registration.status === 'partial_paid') && !req.readOnly) {
       await refreshPricingForRegistration(registration.id).catch(() => {});
       registration = await prisma.registration.findUnique({ where: { id: req.params.id }, include });
     }
@@ -870,7 +876,7 @@ const getRegistrationsByEvent = async (req, res) => {
       where: { eventId: req.params.eventId, status: { in: ['pending', 'partial_paid'] } },
       select: { id: true }
     });
-    if (staleCandidates.length > 0) {
+    if (staleCandidates.length > 0 && !req.readOnly) {
       await Promise.all(staleCandidates.map(r => refreshPricingForRegistration(r.id).catch(() => {})));
     }
 
@@ -2220,7 +2226,7 @@ const updateAttendees = async (req, res) => {
             where: { id: a.id },
             data: {
               name: c.name, email: c.email, phone: c.phone,
-              dateOfBirth: c.dateOfBirth, parentName: c.parentName, parentEmail: c.parentEmail, parentPhone: c.parentPhone,
+              dateOfBirth: c.dateOfBirth, gender: c.gender, parentName: c.parentName, parentEmail: c.parentEmail, parentPhone: c.parentPhone,
               ...(contactChanged ? { userId: match?.user?.id || null } : {}),
             },
           });
@@ -2248,7 +2254,7 @@ const updateAttendees = async (req, res) => {
       where: { id: registration.id },
       select: { id: true, ticketDelivery: true, attendees: ATTENDEES_INCLUDE },
     });
-    res.json(updated);
+    res.json({ ...updated, attendees: updated.attendees.map(({ userId, ...a }) => a) });
   } catch (error) {
     res.status(error.statusCode || (res.statusCode === 200 ? 400 : res.statusCode)).json({ message: error.message });
   }

backend/src/controllers/settingsController.js

@@ -8,6 +8,10 @@ const { logAdminAction } = require('../utils/adminAudit');
 const { getClientIp } = require('../utils/requestUtils');
 
 // Keys safe to return without auth — includes legal keys needed by public legal pages
+// Yoco secrets are only readable (masked) and writable through /api/yoco — never
+// through the generic settings endpoints.
+const YOCO_PRIVATE_KEYS = new Set(['yoco_secret_key', 'yoco_webhook_secret', 'yoco_webhook_id']);
+
 const PUBLIC_KEYS = [
   'org_name', 'org_tagline', 'org_email', 'org_phone', 'org_address',
   // Branding — primary_color/secondary_color/accent_color are the 3-color brand
@@ -44,6 +48,7 @@ const getAllSettings = async (req, res) => {
     const rows = await prisma.appSetting.findMany();
     const settings = {};
     for (const r of rows) {
+      if (YOCO_PRIVATE_KEYS.has(r.key)) continue;
       if (ENCRYPTED_KEYS.has(r.key)) {
         // Return a sentinel so the UI knows the value is set, without exposing it.
         // smtp_user (email address) we can safely return as-is after decryption so
@@ -79,7 +84,7 @@ const updateSettings = async (req, res) => {
     }
 
     const ops = Object.entries(updates)
-      .filter(([, v]) => v !== undefined && v !== null)
+      .filter(([k, v]) => v !== undefined && v !== null && !YOCO_PRIVATE_KEYS.has(k))
       .map(([key, value]) => {
         let storedValue = String(value);
 
@@ -118,7 +123,7 @@ const updateSettings = async (req, res) => {
         actorRole: req.user.role,
         action: 'settings_updated',
         targetType: 'AppSetting',
-        metadata: { changedKeys: Object.keys(updates).filter(k => updates[k] !== undefined && updates[k] !== null) },
+        metadata: { changedKeys: Object.keys(updates).filter(k => updates[k] !== undefined && updates[k] !== null && !YOCO_PRIVATE_KEYS.has(k)) },
         ip: getClientIp(req),
       });
     }
@@ -195,7 +200,7 @@ const runSetup = async (req, res) => {
 
     const toSave = { ...settings, setup_complete: 'true' };
     const ops = Object.entries(toSave)
-      .filter(([, v]) => v !== undefined && v !== null && String(v).trim() !== '')
+      .filter(([k, v]) => v !== undefined && v !== null && String(v).trim() !== '' && !YOCO_PRIVATE_KEYS.has(k))
       .map(([key, value]) => {
         let storedValue = String(value);
         if (ENCRYPTED_KEYS.has(key)) storedValue = encrypt(storedValue);

backend/src/controllers/sponsorshipController.js

@@ -0,0 +1,113 @@
+const axios = require('axios');
+const { yocoAuthHeader } = require('../utils/yoco');
+const prisma = require('../config/db');
+const { safeErrorMessage } = require('../utils/errorUtils');
+const { sponsorshipError, spotPrice, sponsorshipCharge, poolSummary } = require('../utils/sponsorship');
+
+const fail = (res, error) => res.status(error.statusCode || error.response?.status || 400).json({ message: safeErrorMessage(error) });
+
+async function sponsorableEvent(eventId) {
+  const event = await prisma.event.findUnique({ where: { id: String(eventId || '') }, include: { eventOptions: { select: { isMainTicket: true, price: true } } } });
+  if (!event || !event.isActive) throw sponsorshipError('Event not found', 404);
+  if (!event.allowSponsorships) throw sponsorshipError('This event isn’t taking sponsorships.');
+  if (event.cashupStatus === 'closed' || new Date(event.endDate) < new Date()) throw sponsorshipError('This event has ended and is no longer taking sponsorships.');
+  return event;
+}
+
+async function poolFor(event) {
+  const sponsorships = await prisma.payment.findMany({ where: { eventId: event.id, isDonation: true, isSponsorship: true, amount: { gt: 0 } }, select: { id: true, amount: true } });
+  const legs = sponsorships.length
+    ? await prisma.payment.findMany({ where: { originalPaymentId: { in: sponsorships.map(s => s.id) }, isDonation: false }, select: { originalPaymentId: true, amount: true } })
+    : [];
+  return poolSummary(sponsorships, legs, spotPrice(event));
+}
+
+// @desc    Public sponsorship progress for an event (never names who was helped)
+// @route   GET /api/sponsorships/event/:eventId
+// @access  Public
+const getEventSponsorship = async (req, res) => {
+  try {
+    const event = await prisma.event.findUnique({ where: { id: req.params.eventId }, include: { eventOptions: { select: { isMainTicket: true, price: true } } } });
+    if (!event || !event.isActive || !event.allowSponsorships) return res.json({ enabled: false });
+    const pool = await poolFor(event);
+    const open = event.cashupStatus !== 'closed' && new Date(event.endDate) >= new Date();
+    res.json({
+      enabled: true,
+      open,
+      spotPrice: spotPrice(event),
+      showProgress: event.showSponsorshipProgress,
+      goalSpots: event.sponsorshipGoalSpots,
+      spotsFunded: event.showSponsorshipProgress ? pool.spotsFunded : null,
+      sponsors: event.showSponsorshipProgress ? pool.sponsors : null,
+    });
+  } catch (error) {
+    fail(res, error);
+  }
+};
+
+// @desc    Start a Yoco checkout to sponsor spots (or a custom amount) at an event
+// @route   POST /api/sponsorships/checkout   { eventId, spots? | amount?, anonymous?, sponsorName?, message?, name?, email?, phone? }
+// @access  Public (guests give a name and email for the receipt)
+const createSponsorCheckout = async (req, res) => {
+  try {
+    const { eventId, spots, amount, anonymous, sponsorName, message, name, email, phone } = req.body || {};
+    const event = await sponsorableEvent(eventId);
+    const charge = sponsorshipCharge({ spots, amount }, spotPrice(event));
+
+    let payer = req.user || null;
+    if (!payer) {
+      const { hasValidEmail, findOrCreateAccount } = require('../utils/accountMatch');
+      const cleanName = String(name || '').trim().slice(0, 100);
+      if (!cleanName) throw sponsorshipError('Enter your name.');
+      if (!hasValidEmail(email)) throw sponsorshipError('Enter your email address so we can send your receipt.');
+      // An existing account is reused; otherwise a quiet inactive one holds the receipt —
+      // no activation link is sent, since a sponsor doesn't need to log in.
+      payer = (await findOrCreateAccount({ name: cleanName, email: String(email).trim(), phone })).user;
+    }
+    const isAnonymous = anonymous === true;
+    const displayName = isAnonymous ? null : (String(sponsorName || '').trim() || payer.name || '').slice(0, 100) || null;
+    const note = String(message || '').trim().slice(0, 300) || null;
+
+    const base = (process.env.FRONTEND_URL || process.env.APP_BASE_URL || 'http://localhost:3001').replace(/\/$/, '');
+    const back = `${base}/events/${encodeURIComponent(event.id)}`;
+    const amountInCents = Math.round(charge.amount * 100);
+    const label = charge.spots ? `Sponsor ${charge.spots} spot${charge.spots > 1 ? 's' : ''} at ${event.title}` : `Sponsorship for ${event.title}`;
+    const checkoutData = {
+      amount: amountInCents,
+      currency: 'ZAR',
+      metadata: {
+        type: 'sponsorship', isDonation: true, eventId: event.id, eventTitle: event.title, userId: payer.id,
+        sponsorAnonymous: isAnonymous ? 'true' : 'false',
+        ...(displayName ? { sponsorName: displayName } : {}),
+        ...(note ? { sponsorMessage: note } : {}),
+        ...(charge.spots ? { spots: String(charge.spots) } : {}),
+      },
+      successUrl: `${back}?sponsored=1`,
+      cancelUrl: back,
+      failureUrl: `${back}?sponsored=failed`,
+      lineItems: [{ displayName: label, quantity: 1, pricingDetails: { price: amountInCents } }],
+    };
+    const response = await axios.post('https://payments.yoco.com/api/checkouts', checkoutData, {
+      headers: { 'Content-Type': 'application/json', Authorization: await yocoAuthHeader(), 'Idempotency-Key': `spon_${event.id}_${payer.id}_${amountInCents}_${Date.now()}` },
+    });
+    res.json({ redirectUrl: response.data.redirectUrl, checkoutId: response.data.id, amount: charge.amount });
+  } catch (error) {
+    if (error.response) console.error('Sponsor checkout error:', error.response.data || error.message);
+    fail(res, error);
+  }
+};
+
+// @desc    The sponsorship pool for an event (supervisors)
+// @route   GET /api/sponsorships/event/:eventId/pool
+// @access  Private/Supervisor
+const getPool = async (req, res) => {
+  try {
+    const event = await prisma.event.findUnique({ where: { id: req.params.eventId }, include: { eventOptions: { select: { isMainTicket: true, price: true } } } });
+    if (!event) throw sponsorshipError('Event not found', 404);
+    res.json({ eventId: event.id, spotPrice: spotPrice(event), goalSpots: event.sponsorshipGoalSpots, ...(await poolFor(event)) });
+  } catch (error) {
+    fail(res, error);
+  }
+};
+
+module.exports = { getEventSponsorship, createSponsorCheckout, getPool, poolFor };

backend/src/controllers/statsController.js

@@ -267,7 +267,21 @@ const getOverviewStats = async (req, res) => {
       ticketsSold: ticketSumById[r.eventId] || 0,
     }));
 
+    // Funnel conversion (event page views → paid) across live events, last 30 days.
+    let funnel = null;
+    try {
+      const live = await prisma.event.findMany({ where: { isActive: true, endDate: { gte: now } }, select: { id: true } });
+      if (live.length) {
+        const { funnelFor } = require('../utils/analytics');
+        const f = await funnelFor(live.map(e => e.id), { from: new Date(now.getTime() - 30 * 864e5).toISOString() });
+        if (f.totals.view > 0) funnel = { views: f.totals.view, paid: f.totals.paid, conversion: f.conversion.paid };
+      }
+    } catch (e) {
+      console.warn('[stats] funnel tile failed:', e?.message || e);
+    }
+
     res.json({
+      funnel,
       activeEvents,
       registrations: { thisMonth: thisRegistrations, lastMonth: lastRegistrations, pctChange: pctChange(thisRegistrations, lastRegistrations) },
       ticketsSold: { thisMonth: thisTicketsSold, lastMonth: lastTicketsSold, pctChange: pctChange(thisTicketsSold, lastTicketsSold) },

backend/src/controllers/ticketController.js

@@ -95,9 +95,15 @@ const getUserTickets = async (req, res) => {
             registration: true
           }
         },
-        attendee: { select: { id: true, name: true } },
+        attendee: {
+          select: {
+            id: true, name: true,
+            allocations: { where: { set: { showOnTicket: true } }, select: { group: { select: { name: true } }, set: { select: { name: true, order: true } } } },
+          },
+        },
         user: { select: { id: true, name: true } },
         event: true,
+        transferRequests: { where: { status: 'pending' }, select: { id: true, toName: true, expiresAt: true } },
         usages: {
           include: {
             scannedBy: {
@@ -488,7 +494,7 @@ const getTicketsByEvent = async (req, res) => {
         registrationOption: { include: { eventOption: true, variant: true, registration: { select: { id: true } } } },
         user: { select: { id: true, name: true, email: true, phoneNumber: true } },
         attendee: { select: { id: true, name: true, email: true, phone: true } },
-        event: { select: { id: true, title: true, startDate: true, requiresParentalConsent: true, allowTicketTransfer: true } },
+        event: { select: { id: true, title: true, startDate: true, requiresParentalConsent: true, allowTicketTransfer: true, collectGender: true } },
         usages: { include: { scannedBy: { select: { id: true, name: true, email: true } } } }
       },
       orderBy: { createdAt: 'desc' },
@@ -698,20 +704,84 @@ const sendTicketsTo = async (req, res) => {
   }
 };
 
-// @desc    Transfer a ticket to someone else (new QR code; billing stays with the payer)
-// @route   POST /api/tickets/:id/transfer   { name, email?, phone?, dateOfBirth?, parentName?, parentEmail?, parentPhone? }
+// @desc    Offer a ticket to someone else: sends them a link to accept (nothing changes until they do)
+// @route   POST /api/tickets/:id/transfer   { name, email?, phone?, dateOfBirth?, gender?, parentName?, parentEmail?, parentPhone? }
 // @access  Private (payer or holder; supervisors always)
 const transferTicketHandler = async (req, res) => {
   try {
-    const { transferTicket } = require('../utils/ticketTransfer');
-    const { name, email, phone, dateOfBirth, parentName, parentEmail, parentPhone } = req.body || {};
-    const r = await transferTicket({ ticketId: req.params.id, actor: req.user, name, email, phone, dateOfBirth, parentName, parentEmail, parentPhone });
+    const { requestTransfer } = require('../utils/ticketTransfer');
+    const { name, email, phone, dateOfBirth, gender, parentName, parentEmail, parentPhone } = req.body || {};
+    const { request, sent } = await requestTransfer({ ticketId: req.params.id, actor: req.user, name, email, phone, dateOfBirth, gender, parentName, parentEmail, parentPhone });
+    res.status(201).json({
+      message: sent.length
+        ? `We've sent ${request.toName} a link by ${sent.join(' and ')} to accept the ticket. It moves to them once they accept — until then it's still yours.`
+        : `The transfer is waiting for ${request.toName} to accept, but the link couldn't be sent. Check the email or phone number.`,
+      requestId: request.id,
+      expiresAt: request.expiresAt,
+    });
+  } catch (error) {
+    res.status(error.statusCode || (res.statusCode === 200 ? 400 : res.statusCode)).json({ message: safeErrorMessage(error) });
+  }
+};
+
+// @desc    Withdraw a transfer that hasn't been accepted yet
+// @route   DELETE /api/tickets/:id/transfer
+// @access  Private (payer or holder; supervisors)
+const cancelTransferHandler = async (req, res) => {
+  try {
+    const { cancelTransfer } = require('../utils/ticketTransfer');
+    await cancelTransfer(req.params.id, req.user);
+    res.json({ message: 'Transfer cancelled — the ticket is still yours.' });
+  } catch (error) {
+    res.status(error.statusCode || 400).json({ message: safeErrorMessage(error) });
+  }
+};
+
+// @desc    What's on offer behind a transfer link
+// @route   GET /api/tickets/transfer-offer/:token
+// @access  Public (link holder)
+const getTransferOffer = async (req, res) => {
+  try {
+    const { findRequestByToken } = require('../utils/ticketTransfer');
+    const r = await findRequestByToken(req.params.token);
+    if (!r) return res.status(404).json({ message: 'This transfer link isn’t valid.' });
+    const t = r.ticket;
+    res.json({
+      status: r.status, toName: r.toName, expiresAt: r.expiresAt,
+      fromName: (t.attendee?.name || t.user?.name || r.requestedBy.name || '').split(' ')[0],
+      event: t.event,
+      option: t.registrationOption.variant ? `${t.registrationOption.eventOption.name} — ${t.registrationOption.variant.name}` : t.registrationOption.eventOption.name,
+    });
+  } catch (error) {
+    res.status(400).json({ message: safeErrorMessage(error) });
+  }
+};
+
+// @route   POST /api/tickets/transfer-offer/:token/decline
+const declineTransferOffer = async (req, res) => {
+  try {
+    const { declineTransfer } = require('../utils/ticketTransfer');
+    await declineTransfer(req.params.token);
+    res.json({ message: 'You declined the ticket. Nothing else will happen.' });
+  } catch (error) {
+    res.status(error.statusCode || 400).json({ message: safeErrorMessage(error) });
+  }
+};
+
+// @desc    Accept a transferred ticket — the transfer happens now
+// @route   POST /api/tickets/transfer-offer/:token/accept
+// @access  Public (link holder)
+const acceptTransferOffer = async (req, res) => {
+  try {
+    const { acceptTransfer } = require('../utils/ticketTransfer');
+    const r = await acceptTransfer(req.params.token);
+    const actor = r.request.requestedBy;
 
     const { logAdminAction } = require('../utils/adminAudit');
     const { getClientIp } = require('../utils/requestUtils');
     logAdminAction({
-      actorId: req.user.id, actorRole: req.user.role, action: 'ticket_transferred', targetType: 'Ticket', targetId: r.target.id,
-      metadata: { eventId: r.event.id, registrationId: r.registrationId, from: r.fromHolderName, to: r.attendee.name, toUserId: r.toUser.id, split: !r.transfer.oldQrCode },
+      actorId: actor.id, actorRole: actor.role, action: 'ticket_transferred', targetType: 'Ticket', targetId: r.target.id,
+      metadata: { eventId: r.event.id, registrationId: r.registrationId, from: r.fromHolderName, to: r.attendee.name, toUserId: r.toUser.id, split: !r.transfer.oldQrCode, acceptedVia: 'link' },
       ip: getClientIp(req),
     });
 
@@ -739,7 +809,7 @@ const transferTicketHandler = async (req, res) => {
     }
 
     res.json({
-      message: `Ticket transferred to ${a.name}. We've sent them the new ticket${r.needsConsent ? ' and a parental consent request' : ''}. The old QR code no longer works.`,
+      message: `The ticket is yours! We've sent it to you${r.needsConsent ? ', and asked your parent or guardian for consent' : ''}.${r.accountCreated ? ' We have also sent you a link to activate your account, where you can see your tickets.' : ''}`,
       ticketId: r.target.id,
     });
   } catch (error) {
@@ -767,6 +837,14 @@ const getTicketTransfers = async (req, res) => {
   }
 };
 
+/** "Room: Cabin 3 · Bus: Bus 2" for the sets shown on tickets, or ''. */
+function allocationLabel(attendee) {
+  return [...(attendee?.allocations || [])]
+    .sort((a, b) => (a.set?.order || 0) - (b.set?.order || 0))
+    .map(a => `${a.set.name}: ${a.group.name}`)
+    .join(' · ');
+}
+
 // Internal helper used by both emailTickets and sendTicketsTo
 async function emailTicketsInternal(req, res, userOverride) {
   const { ticketIds, registrationId } = req.body;
@@ -789,7 +867,7 @@ async function emailTicketsInternal(req, res, userOverride) {
   const ticketInclude = {
     event: true,
     registrationOption: { include: { eventOption: true, variant: true, registration: { select: { ticketDelivery: true } } } },
-    attendee: true,
+    attendee: { include: { allocations: { where: { set: { showOnTicket: true } }, include: { group: { select: { name: true } }, set: { select: { name: true, order: true } } } } } },
     user: { select: { name: true } },
     usages: true,
   };
@@ -890,7 +968,8 @@ async function emailTicketsInternal(req, res, userOverride) {
     doc.font('Helvetica').fontSize(10);
     const variantSuffix = ticket.registrationOption.variant ? ` — ${ticket.registrationOption.variant.name}` : '';
     doc.text(`Ticket Type: ${ticket.registrationOption.eventOption.name}${variantSuffix}`, x + 10, y + 30, { width: ticketWidth - 20 });
-    doc.text(ticket.attendee ? `Name: ${ticket.attendee.name}` : `Qty: ${ticket.quantity || 1}`, x + 10, y + 45, { width: ticketWidth - 20 });
+    const groupLabel = allocationLabel(ticket.attendee);
+    doc.text(ticket.attendee ? `Name: ${ticket.attendee.name}${groupLabel ? ` · ${groupLabel}` : ''}` : `Qty: ${ticket.quantity || 1}`, x + 10, y + 45, { width: ticketWidth - 20 });
     const eventDate = new Date(ticket.event.startDate);
     doc.text(`Date: ${new Intl.DateTimeFormat('en-GB', { day: '2-digit', month: 'long', year: 'numeric' }).format(eventDate)}`, x + 10, y + 60, { width: ticketWidth - 20 });
     doc.text(`Purchased by: ${ticket.user?.name || user.name}`, x + 10, y + 75, { width: ticketWidth - 20 });
@@ -966,5 +1045,9 @@ module.exports = {
   getRecentScans,
   getScanStats,
   transferTicketHandler,
+  cancelTransferHandler,
+  getTransferOffer,
+  acceptTransferOffer,
+  declineTransferOffer,
   getTicketTransfers
 };

backend/src/controllers/webhookController.js

@@ -4,6 +4,7 @@ const { v4: uuidv4 } = require('uuid');
 const { generateTicketsForRegistration } = require('../utils/ticketUtils');
 const { emailTickets } = require('./ticketController');
 const { computeRegistrationTotalDue, refreshPricingForRegistration } = require('../utils/pricing');
+const { getYocoWebhookSecret } = require('../utils/yoco');
 
 // @desc    Handle Yoco webhook events
 // @route   POST /api/webhooks/yoco
@@ -54,10 +55,10 @@ const handleYocoWebhook = async (req, res) => {
     // Construct the signed content
     const signedContent = `${id}.${timestamp}.${requestBody}`;
 
-    // Get the webhook secret from environment variables
-    const secret = process.env.YOCO_WEBHOOK_SECRET;
+    // Webhook secret from Site Settings → Yoco (falls back to .env)
+    const secret = await getYocoWebhookSecret();
     if (!secret) {
-      console.error('YOCO_WEBHOOK_SECRET is not defined in environment variables');
+      console.error('Yoco webhook secret is not configured (Site Settings → Yoco, or YOCO_WEBHOOK_SECRET)');
       const responseObj = { 
         success: false, 
         message: 'Server configuration error',
@@ -325,7 +326,13 @@ const handlePaymentSucceeded = async (webhookData) => {
         userId: resolvedUserId,
         recordedById: resolvedUserId, // self-service webhook payment — payer is the recorder
         eventId: registration?.eventId || metadata?.eventId || null,
-        isDonation: !registration?.id
+        isDonation: !registration?.id,
+        ...(!registration?.id && metadata?.type === 'sponsorship' ? {
+          isSponsorship: true,
+          sponsorAnonymous: String(metadata.sponsorAnonymous) === 'true',
+          sponsorName: String(metadata.sponsorAnonymous) === 'true' ? null : (metadata.sponsorName ? String(metadata.sponsorName).slice(0, 100) : null),
+          sponsorMessage: metadata.sponsorMessage ? String(metadata.sponsorMessage).slice(0, 300) : null,
+        } : {})
       },
       include: {
         user: {

backend/src/controllers/yocoController.js

@@ -0,0 +1,149 @@
+const prisma = require('../config/db');
+const { safeErrorMessage } = require('../utils/errorUtils');
+const { encrypt } = require('../utils/encryption');
+const { invalidate: invalidateSettingsCache, warmCache, getSetting } = require('../utils/settingsCache');
+const { logAdminAction } = require('../utils/adminAudit');
+const { getClientIp } = require('../utils/requestUtils');
+const {
+  KEY_SECRET, KEY_WEBHOOK, KEY_WEBHOOK_ID,
+  getYocoSecretKey, getYocoWebhookSecret, getYocoConfigSource,
+  maskSecret, yocoMode, listWebhooks, registerWebhook, deleteWebhook,
+  defaultWebhookUrl, webhookUrlProblem,
+} = require('../utils/yoco');
+
+const fail = (res, e) => res.status(e.statusCode || (res.statusCode === 200 ? 400 : res.statusCode)).json({ message: safeErrorMessage(e) });
+
+// Write settings (null/'' clears), then refresh the cache so the new values apply immediately.
+async function saveSettings(values) {
+  const ops = Object.entries(values).map(([key, value]) => {
+    const stored = value ? (key === KEY_WEBHOOK_ID ? value : encrypt(value)) : '';
+    return prisma.appSetting.upsert({ where: { key }, update: { value: stored }, create: { key, value: stored } });
+  });
+  await prisma.$transaction(ops);
+  invalidateSettingsCache();
+  await warmCache();
+}
+
+const audit = (req, action, metadata) => logAdminAction({
+  actorId: req.user.id, actorRole: req.user.role, action, targetType: 'AppSetting', metadata, ip: getClientIp(req),
+});
+
+// @desc  Yoco configuration with secrets masked
+// @route GET /api/yoco/config
+// @access Admin
+const getConfig = async (req, res) => {
+  try {
+    const [secretKey, webhookSecret, webhookId, source] = await Promise.all([
+      getYocoSecretKey(), getYocoWebhookSecret(), getSetting(KEY_WEBHOOK_ID), getYocoConfigSource(),
+    ]);
+    res.json({
+      secretKeyMasked:     maskSecret(secretKey),
+      secretKeySource:     source.secretKey,
+      mode:                yocoMode(secretKey),
+      webhookSecretMasked: maskSecret(webhookSecret),
+      webhookSecretSource: source.webhookSecret,
+      webhookId:           webhookId || '',
+      webhookUrl:          defaultWebhookUrl(req),
+      configured:          !!(secretKey && webhookSecret),
+    });
+  } catch (e) {
+    fail(res, e);
+  }
+};
+
+// @desc  Save the secret key and/or webhook secret ('' clears)
+// @route PUT /api/yoco/config
+// @access Admin
+const updateConfig = async (req, res) => {
+  try {
+    const { secretKey, webhookSecret } = req.body || {};
+    const updates = {};
+
+    if (typeof secretKey === 'string') {
+      const key = secretKey.trim();
+      if (key && !/^sk_(test|live)_\S+$/.test(key)) {
+        res.status(400); throw new Error('The secret key should start with sk_test_ or sk_live_.');
+      }
+      // Check Yoco accepts the key before replacing a working one.
+      if (key) await listWebhooks(key);
+      updates[KEY_SECRET] = key;
+    }
+
+    if (typeof webhookSecret === 'string') {
+      const secret = webhookSecret.trim();
+      if (secret && !/^whsec_[A-Za-z0-9+/=]+$/.test(secret)) {
+        res.status(400); throw new Error('The webhook secret should start with whsec_.');
+      }
+      updates[KEY_WEBHOOK] = secret;
+      // A typed-in secret isn't tied to a webhook we registered.
+      updates[KEY_WEBHOOK_ID] = '';
+    }
+
+    if (!Object.keys(updates).length) { res.status(400); throw new Error('Nothing to save'); }
+
+    await saveSettings(updates);
+    audit(req, 'yoco_config_updated', { changedKeys: Object.keys(updates) });
+    res.json({ message: 'Yoco settings saved' });
+  } catch (e) {
+    fail(res, e);
+  }
+};
+
+// @desc  Webhooks registered on the Yoco account
+// @route GET /api/yoco/webhooks
+// @access Admin
+const getWebhooks = async (req, res) => {
+  try {
+    const [hooks, activeId] = await Promise.all([listWebhooks(), getSetting(KEY_WEBHOOK_ID)]);
+    const here = defaultWebhookUrl(req);
+    res.json({
+      webhooks: hooks.map(h => ({ ...h, isActive: !!activeId && h.id === activeId, pointsHere: !!here && h.url === here })),
+      defaultUrl: here,
+    });
+  } catch (e) {
+    fail(res, e);
+  }
+};
+
+// @desc  Register a webhook at Yoco and store the secret it returns
+// @route POST /api/yoco/webhooks
+// @access Admin
+const createWebhook = async (req, res) => {
+  try {
+    const name = String(req.body?.name || '').trim() || 'hope-events';
+    const url = String(req.body?.url || '').trim() || defaultWebhookUrl(req);
+    const problem = webhookUrlProblem(url);
+    if (problem) { res.status(400); throw new Error(problem); }
+
+    const hook = await registerWebhook(name, url);
+    if (!hook?.secret) throw new Error('Yoco did not return a webhook secret.');
+
+    await saveSettings({ [KEY_WEBHOOK]: hook.secret, [KEY_WEBHOOK_ID]: hook.id });
+    audit(req, 'yoco_webhook_registered', { webhookId: hook.id, url: hook.url, mode: hook.mode });
+    res.status(201).json({
+      message: 'Webhook registered and its secret saved',
+      webhook: { id: hook.id, name: hook.name, url: hook.url, mode: hook.mode },
+      webhookSecretMasked: maskSecret(hook.secret),
+    });
+  } catch (e) {
+    fail(res, e);
+  }
+};
+
+// @desc  Delete a webhook at Yoco (clears the stored secret if it was the active one)
+// @route DELETE /api/yoco/webhooks/:id
+// @access Admin
+const removeWebhook = async (req, res) => {
+  try {
+    const { id } = req.params;
+    await deleteWebhook(id);
+    const wasActive = (await getSetting(KEY_WEBHOOK_ID)) === id;
+    if (wasActive) await saveSettings({ [KEY_WEBHOOK]: '', [KEY_WEBHOOK_ID]: '' });
+    audit(req, 'yoco_webhook_deleted', { webhookId: id, clearedSecret: wasActive });
+    res.json({ message: wasActive ? 'Webhook deleted and its secret removed' : 'Webhook deleted', clearedSecret: wasActive });
+  } catch (e) {
+    fail(res, e);
+  }
+};
+
+module.exports = { getConfig, updateConfig, getWebhooks, createWebhook, removeWebhook };

backend/src/index.js

@@ -24,13 +24,10 @@ const express = require('express');
 const { version: API_VERSION } = require('../package.json');
 const cors = require('cors');
 const rateLimit = require('express-rate-limit');
-const { PrismaClient } = require('@prisma/client');
+const prisma = require('./config/db');
 const { notFound, errorHandler } = require('./middleware/errorMiddleware');
 const getRawBody = require('raw-body');
 
-// Initialize Prisma client
-const prisma = new PrismaClient();
-
 // Initialize Express app
 const app = express();
 const PORT = process.env.PORT || 3000;
@@ -103,6 +100,10 @@ const globalLimiter = rateLimit({
 });
 app.use(globalLimiter);
 
+// Impersonation is strictly read-only: refuse every write made with an impersonation
+// token before it can reach any route (see utils/impersonation.js).
+app.use(require('./utils/impersonation').readOnlyGuard);
+
 // Raw body parsing middleware for webhooks
 app.use((req, res, next) => {
   if (req.path.startsWith('/api/webhooks')) {
@@ -145,6 +146,7 @@ const cashupRoutes    = require('./routes/cashupRoutes');
 const statsRoutes     = require('./routes/statsRoutes');
 const adminRoutes     = require('./routes/adminRoutes');
 const backupRoutes    = require('./routes/backupRoutes');
+const yocoRoutes      = require('./routes/yocoRoutes');
 
 // Mount webhook routes BEFORE JSON body parser to avoid double-reading the stream
 app.use('/api/webhooks', webhookRoutes);
@@ -179,7 +181,12 @@ app.use('/api/coupons', require('./routes/couponRoutes'));
 app.use('/api/consent', require('./routes/consentRoutes'));
 app.use('/api/waitlist', require('./routes/waitlistRoutes'));
 app.use('/api/scan-locks', require('./routes/scanLockRoutes'));
+app.use('/api/allocations', require('./routes/allocationRoutes'));
+app.use('/api/sponsorships', require('./routes/sponsorshipRoutes'));
+app.use('/api/feedback', require('./routes/feedbackRoutes'));
+app.use('/api/analytics', require('./routes/analyticsRoutes'));
 app.use('/api/backups', backupRoutes);
+app.use('/api/yoco', yocoRoutes);
 
 // Pre-warm the settings cache so synchronous helpers have DB values from startup
 const { getSettingSync, warmCache } = require('./utils/settingsCache');
@@ -384,6 +391,7 @@ app.get('/docs', async (req, res) => {
   // ── Endpoint data ────────────────────────────────────────────────────────
   const GROUPS = [
     { title: 'Users', base: '/api/users', endpoints: [
+      { method:'GET', path:'/api/users/activity', auth:'Bearer', desc:'Recent account activity (logins, password changes) for the current user' },
       { method:'POST', path:'/api/users', auth:'public', desc:'Register a new account',
         request:{ body:{ name:'Jane Doe', email:'jane@example.com', password:'secret123', phoneNumber:'+27821234567' }},
         responses:[
@@ -507,6 +515,14 @@ app.get('/docs', async (req, res) => {
     ]},
 
     { title: 'Events', base: '/api/events', endpoints: [
+      { method:'GET', path:'/api/events/admin/all', auth:'admin', desc:'All events, including inactive ones' },
+      { method:'GET', path:'/api/events/:id/ics', auth:'Public (optional login)', desc:'Download an .ics calendar file for an event' },
+      { method:'GET', path:'/api/events/:id/attachments', auth:'Public', desc:'List the downloadable attachments of an event' },
+      { method:'POST', path:'/api/events/:id/attachments', auth:'supervisor+', desc:'Upload an attachment (multipart, field "file")' },
+      { method:'DELETE', path:'/api/events/:eventId/attachments/:attachmentId', auth:'supervisor+', desc:'Delete an attachment' },
+      { method:'GET', path:'/api/events/attachments/status', auth:'admin', desc:'Diagnostics for the attachments pipeline' },
+      { method:'POST', path:'/api/events/attachments/sync', auth:'admin', desc:'Re-sync attachment records with the files on disk' },
+      { method:'POST', path:'/api/events/options/:id/variants', auth:'supervisor+', desc:'Add a variant (e.g. a size) to an event option' },
       { method:'GET', path:'/api/events', auth:'public', desc:'List active, public, upcoming events. Each event includes isSoldOut:boolean — true when every option with a stockLimit > 0 is fully booked.',
         queryParams:{ limit:'Max results (default 20)' },
         responses:[
@@ -584,6 +600,12 @@ app.get('/docs', async (req, res) => {
     ]},
 
     { title: 'Registrations', base: '/api/registrations', endpoints: [
+      { method:'PUT', path:'/api/registrations/:id/options', auth:'Bearer (owner or staff)', desc:'Change the items on a registration (add/remove), within stock and paid-ticket limits' },
+      { method:'POST', path:'/api/registrations/:id/coupon', auth:'Bearer (owner or staff)', desc:'Apply a coupon code to an existing registration', request:{ body:{ code:'STAFF50' }}},
+      { method:'DELETE', path:'/api/registrations/:id/coupon', auth:'staff+', desc:'Remove the coupon from a registration (frees the use)' },
+      { method:'GET', path:'/api/registrations/:id/forms/draft', auth:'Owner or staff', desc:'Saved draft of the attendee forms' },
+      { method:'PUT', path:'/api/registrations/:id/forms/draft', auth:'Owner or staff', desc:'Save a draft of the attendee forms (not submitted)' },
+      { method:'PUT', path:'/api/registrations/:id/forms/responses', auth:'supervisor+', desc:'Replace (edit) the submitted form responses of a registration' },
       { method:'POST', path:'/api/registrations', auth:'optional', desc:'Create a registration. Auth optional — guests are allowed when event does not require auth.',
         request:{ body:{ eventId:'ev-uuid-...', options:[{ eventOptionId:'opt-uuid-...', quantity:2 }] }},
         responses:[
@@ -635,7 +657,56 @@ app.get('/docs', async (req, res) => {
         ]},
     ]},
 
+    { title: 'Impersonation', base: '/api/admin', endpoints: [
+      { method:'GET', path:'/api/admin/audit-log', auth:'admin', desc:'Paginated admin/supervisor audit trail (?page, limit, actorId, action, from, to)' },
+      { method:'POST', path:'/api/admin/impersonate/:userId', auth:'admin (2FA)', desc:'View the site as a user — read-only token, 30 minutes, audited', request:{ body:{ reason:'Ticket not showing in My Events' }}, responses:[{ status:201, desc:'Started', body:{ token:'jwt…', session:{ id:'sess-uuid', expiresAt:'2025-07-10T08:45:00.000Z' }}}, { status:403, desc:'Not allowed', body:{ message:"Admins can't be impersonated." }}]},
+      { method:'POST', path:'/api/admin/impersonate/end', auth:'impersonation token', desc:'End the impersonation session' },
+      { method:'POST', path:'/api/admin/impersonate/log', auth:'impersonation token', desc:'Record a page viewed during the session' },
+      { method:'GET', path:'/api/admin/impersonate/current', auth:'impersonation token', desc:'The live impersonation session' },
+      { method:'GET', path:'/api/admin/impersonation-sessions', auth:'admin', desc:'Impersonation sessions with their request trail' },
+    ]},
+    { title: 'Registration funnel', base: '/api/analytics', endpoints: [
+      { method:'POST', path:'/api/analytics/track', auth:'Public (rate-limited)', desc:'Record a funnel step from a cookie-consented browser (always 204)',
+        request:{ body:{ sessionId:'random-uuid', eventId:'ev-uuid-...', stage:'view', source:'camp-2025' }}},
+      { method:'GET', path:'/api/analytics/funnel', auth:'supervisor+', desc:'Funnel for ?eventIds=a,b&from=&to= — totals, conversion, daily trend, by source/device/option' },
+    ]},
+    { title: 'Post-event feedback', base: '/api/feedback', endpoints: [
+      { method:'GET', path:'/api/feedback/event/:eventId', auth:'supervisor+', desc:'An event\'s feedback form, with invite and response counts' },
+      { method:'PUT', path:'/api/feedback/event/:eventId', auth:'supervisor+', desc:'Create/update the feedback form (questions lock once answered)',
+        request:{ body:{ sendAt:'2025-07-13T09:00:00.000Z', audience:'checked_in', anonymous:false, intro:'Thanks for coming!', fields:[{ type:'rating', label:'Overall?', isRequired:true }, { type:'multiple_choice', label:'Best part', options:['Worship','Talks'] }] }}},
+      { method:'DELETE', path:'/api/feedback/event/:eventId', auth:'supervisor+', desc:'Remove the feedback form' },
+      { method:'POST', path:'/api/feedback/event/:eventId/send-now', auth:'supervisor+', desc:'Send the feedback form now' },
+      { method:'GET', path:'/api/feedback/public/:token', auth:'Link holder', desc:'The form behind a personal feedback link' },
+      { method:'POST', path:'/api/feedback/public/:token', auth:'Link holder', desc:'Submit feedback once', request:{ body:{ answers:{ 'field-uuid':'5' } }}},
+      { method:'GET', path:'/api/feedback/summary', auth:'supervisor+', desc:'Feedback summary for ?eventIds=a,b (response rate, averages, breakdowns, comments)' },
+    ]},
+    { title: 'Sponsor a spot', base: '/api/sponsorships', endpoints: [
+      { method:'GET', path:'/api/sponsorships/event/:eventId', auth:'Public', desc:'Sponsorship progress for an event (spots funded, goal) — never who was helped',
+        responses:[{ status:200, desc:'Progress', body:{ enabled:true, open:true, spotPrice:450, showProgress:true, goalSpots:20, spotsFunded:12, sponsors:9 }}]},
+      { method:'POST', path:'/api/sponsorships/checkout', auth:'Public (optional login)', desc:'Start a Yoco checkout to sponsor spots or a custom amount; the money lands in the event sponsorship pool',
+        request:{ body:{ eventId:'ev-uuid-...', spots:2, anonymous:false, sponsorName:'The Smith family', message:'Have a great camp!', name:'Sam Smith', email:'sam@example.com' }},
+        responses:[{ status:200, desc:'Checkout created', body:{ redirectUrl:'https://pay.yoco.com/...', amount:900 }}]},
+      { method:'GET', path:'/api/sponsorships/event/:eventId/pool', auth:'supervisor+', desc:'Sponsorship pool totals: received, assigned, remaining' },
+    ]},
+    { title: 'Rooms & groups', base: '/api/allocations', endpoints: [
+      { method:'GET', path:'/api/allocations/event/:eventId', auth:'supervisor+', desc:'Allocation board: sets with groups and assignments, named attendees, possible leaders' },
+      { method:'POST', path:'/api/allocations/sets', auth:'supervisor+', desc:'Create an allocation set', request:{ body:{ eventId:'ev-uuid-...', name:'Rooms', showOnTicket:true }}},
+      { method:'PUT', path:'/api/allocations/sets/:id', auth:'supervisor+', desc:'Rename a set or show it on tickets' },
+      { method:'DELETE', path:'/api/allocations/sets/:id', auth:'supervisor+', desc:'Delete a set and its groups' },
+      { method:'POST', path:'/api/allocations/sets/:id/groups', auth:'supervisor+', desc:'Add a group', request:{ body:{ name:'Cabin 1', capacity:8, gender:'female', leaderUserId:'user-uuid-...' }}},
+      { method:'PUT', path:'/api/allocations/groups/:id', auth:'supervisor+', desc:'Edit a group' },
+      { method:'DELETE', path:'/api/allocations/groups/:id', auth:'supervisor+', desc:'Delete a group (its people become unassigned)' },
+      { method:'PUT', path:'/api/allocations/sets/:id/assignments', auth:'supervisor+', desc:'Place (or with groupId null, unplace) an attendee; enforces capacity and gender', request:{ body:{ attendeeId:'att-uuid-...', groupId:'grp-uuid-...' }}},
+      { method:'DELETE', path:'/api/allocations/sets/:id/assignments', auth:'supervisor+', desc:'Clear every assignment in a set' },
+      { method:'POST', path:'/api/allocations/sets/:id/auto', auth:'supervisor+', desc:'Auto-allocate everyone not yet placed', request:{ body:{ mode:'together' }}, responses:[{ status:200, desc:'Done', body:{ placed:12, unplaced:1 }}]},
+      { method:'GET', path:'/api/allocations/sets/:id/lists', auth:'supervisor+', desc:'Per-group lists for printing (?medical=true adds medical details; audited)' },
+      { method:'GET', path:'/api/allocations/my-groups', auth:'staff+', desc:'Groups the signed-in leader leads, with their people' },
+    ]},
     { title: 'Ticket transfer', base: '/api/tickets', endpoints: [
+      { method:'DELETE', path:'/api/tickets/:id/transfer', auth:'payer, holder or supervisor+', desc:'Withdraw a transfer offer that has not been accepted yet' },
+      { method:'GET', path:'/api/tickets/transfer-offer/:token', auth:'Link holder', desc:'The ticket offered behind a transfer link (status, event, ticket type, sender first name)' },
+      { method:'POST', path:'/api/tickets/transfer-offer/:token/accept', auth:'Link holder', desc:'Accept the ticket — the transfer happens now (new QR code, ticket sent to the new holder)' },
+      { method:'POST', path:'/api/tickets/transfer-offer/:token/decline', auth:'Link holder', desc:'Decline the ticket offer' },
       { method:'POST', path:'/api/tickets/:id/transfer', auth:'payer, holder or supervisor+', desc:'Give a ticket to someone else before the event (new QR code; the old one stops working; billing stays with the payer)',
         request:{ body:{ name:'Nia New', email:'nia@example.com', phone:'0821234567' }},
         responses:[{ status:200, desc:'Transferred', body:{ message:'Ticket transferred to Nia New…', ticketId:'ticket-uuid-...' }}, { status:400, desc:'Not allowed', body:{ message:'This ticket has already been used (or partly used), so it can’t be transferred.' }}]},
@@ -696,6 +767,10 @@ app.get('/docs', async (req, res) => {
       { method:'GET', path:'/api/coupons/redemptions', auth:'supervisor+', desc:'Active uses for the Discounts report. Query: eventIds (comma-separated), from, to' },
     ]},
     { title: 'Payments', base: '/api/payments', endpoints: [
+      { method:'GET', path:'/api/payments/:id', auth:'Bearer', desc:'A payment by id' },
+      { method:'GET', path:'/api/payments/registration/:registrationId', auth:'Bearer', desc:'Payments of a registration' },
+      { method:'POST', path:'/api/payments/yoco-checkout/send', auth:'supervisor+', desc:'Send a generated Yoco payment link to the registrant by email or WhatsApp', request:{ body:{ registrationId:'reg-uuid-...', redirectUrl:'https://pay.yoco.com/...', channel:'whatsapp' }}},
+      { method:'POST', path:'/api/payments/unassign-donation', auth:'supervisor+', desc:'Reverse a donation assignment (removes the leg and reverts the registration status)' },
       { method:'POST', path:'/api/payments/yoco-checkout', auth:'user+', desc:'Initiate a Yoco checkout session. Before creating the checkout, re-evaluates early-bird tier eligibility (deadline + stock). If any price changed since registration, returns priceUpdated:true instead of creating a checkout — the client must inform the user and retry.',
         request:{ body:{ registrationId:'reg-uuid-...', amount:450, successUrl:'https://events.example.com/payment/success', cancelUrl:'https://events.example.com/payment/cancel', failureUrl:'https://events.example.com/payment/failure' }},
         responses:[
@@ -735,6 +810,10 @@ app.get('/docs', async (req, res) => {
     ]},
 
     { title: 'Tickets', base: '/api/tickets', endpoints: [
+      { method:'GET', path:'/api/tickets', auth:'supervisor+', desc:'All tickets' },
+      { method:'GET', path:'/api/tickets/:id', auth:'Bearer (owner or staff)', desc:'A ticket by id' },
+      { method:'GET', path:'/api/tickets/qr/:qrCode', auth:'staff+', desc:'A ticket by QR code' },
+      { method:'PUT', path:'/api/tickets/email-sent', auth:'admin', desc:'Mark tickets as emailed' },
       { method:'GET', path:'/api/tickets/mytickets', auth:'user+', desc:'Get own tickets',
         responses:[{ status:200, desc:'Success', body:[{ id:'tkt-uuid-...', qrCode:'TKT-ABC123', event:{ title:'Camp 2025' }, registrationOption:{ eventOption:{ name:'Adult' }}, quantity:1, isUsed:false }]}]},
       { method:'POST', path:'/api/tickets/generate', auth:'supervisor+', desc:'Generate tickets for a registration (idempotent — skips already-generated options)',
@@ -814,6 +893,8 @@ app.get('/docs', async (req, res) => {
     ]},
 
     { title: 'Reports', base: '/api/reports', endpoints: [
+      { method:'POST', path:'/api/reports/excel', auth:'Bearer', desc:'Build an Excel file from a report payload' },
+      { method:'POST', path:'/api/reports/whatsapp', auth:'Bearer', desc:'Send a report PDF by WhatsApp' },
       { method:'POST', path:'/api/reports/pdf', auth:'user+', desc:'Generate a PDF report of own registrations and tickets and return it as a binary download',
         responses:[{ status:200, desc:'PDF file (application/pdf)', body:'<binary PDF>' }]},
       { method:'POST', path:'/api/reports/email', auth:'user+', desc:'Generate PDF report and email it to the authenticated user',
@@ -838,6 +919,8 @@ app.get('/docs', async (req, res) => {
     ]},
 
     { title: 'Cashups', base: '/api/cashups', endpoints: [
+      { method:'GET', path:'/api/cashups/event/:eventId/cash-by-user', auth:'supervisor+', desc:'Payments recorded for an event, by staff member and method' },
+      { method:'PUT', path:'/api/cashups/event/:eventId/person-cash/:userId', auth:'supervisor+', desc:'Enter one staff member\'s physical cash count for an event' },
       { method:'GET', path:'/api/cashups/event/:eventId', auth:'supervisor+', desc:'Live cashup preview for an event: system income vs. reconciled actual per method, method-tagged costs, unallocated donations, net profit, and the full close/reopen history',
         pathParams:{ ':eventId':'Event UUID' },
         responses:[{ status:200, desc:'Success', body:{ event:{ id:'ev-uuid-...', title:'Camp 2025', cashupStatus:'open' }, paymentsByMethod:{ cash:1200, card:4500, eft:600, other:0 }, expectedCashByMethod:{ cash:1150, card:4500, eft:600, other:0 }, unallocatedDonationsTotal:150, totalCosts:900, netProfit:6450, history:[] }}]},
@@ -859,6 +942,8 @@ app.get('/docs', async (req, res) => {
     ]},
 
     { title: 'Uploads', base: '/api/uploads', endpoints: [
+      { method:'POST', path:'/api/uploads/logo', auth:'admin (open during first-run setup)', desc:'Upload the site logo (multipart, field "image")' },
+      { method:'POST', path:'/api/uploads/favicon', auth:'admin (open during first-run setup)', desc:'Upload the site favicon (multipart, field "image")' },
       { method:'POST', path:'/api/uploads/event-image', auth:'supervisor+', desc:'Upload an event cover image. Send as multipart/form-data with field name "image". Returns the public URL.',
         notes:'Content-Type must be multipart/form-data. Max size is typically 5 MB.',
         responses:[
@@ -915,6 +1000,10 @@ app.get('/docs', async (req, res) => {
     ]},
 
     { title: 'WhatsApp Admin', base: '/api/whatsapp', endpoints: [
+      { method:'POST', path:'/api/whatsapp/start', auth:'admin', desc:'Start (or restart) the WAWP WhatsApp instance' },
+      { method:'POST', path:'/api/whatsapp/request-code', auth:'admin', desc:'Request a pairing code to link a WhatsApp number' },
+      { method:'POST', path:'/api/whatsapp/delete-instance', auth:'admin', desc:'Delete the WAWP instance' },
+      { method:'POST', path:'/api/whatsapp/webhook', auth:'—', desc:'WAWP event webhook (alias of /api/webhooks/whatsapp)' },
       { method:'GET', path:'/api/whatsapp/config', auth:'admin', desc:'Get the currently stored WAWP credentials from DB (tokens are partially masked)',
         responses:[{ status:200, desc:'Success', body:{ instanceId:'wawp-instance-abc', accessToken:'eyJ...****', source:'db' }}]},
       { method:'POST', path:'/api/whatsapp/config', auth:'admin', desc:'Save WAWP credentials to the database (AppSetting). Takes effect immediately; no restart needed.',
@@ -935,6 +1024,17 @@ app.get('/docs', async (req, res) => {
         responses:[{ status:200, desc:'Logged out', body:{ message:'Logged out.' }}]},
     ]},
 
+    { title: 'Dashboard stats', base: '/api/stats', endpoints: [
+      { method:'GET', path:'/api/stats/staff', auth:'staff+', desc:'Everything the staff dashboard needs, in one call' },
+      { method:'GET', path:'/api/stats/supervisor', auth:'supervisor+', desc:'Everything the supervisor dashboard needs, in one call' },
+      { method:'GET', path:'/api/stats/admin', auth:'admin', desc:'Everything the admin dashboard needs, in one call' },
+      { method:'GET', path:'/api/stats/overview', auth:'supervisor+', desc:'Trailing-month KPIs (registrations, tickets, revenue, donations), revenue trend, top events, funnel conversion' },
+    ]},
+    { title: 'Backups', base: '/api/backups', endpoints: [
+      { method:'GET', path:'/api/backups', auth:'admin', desc:'Local database backups, newest first' },
+      { method:'POST', path:'/api/backups/run', auth:'admin', desc:'Run a backup now' },
+      { method:'GET', path:'/api/backups/:filename/download', auth:'admin', desc:'Download a backup file' },
+    ]},
     { title: 'Webhooks', base: '/api/webhooks', endpoints: [
       { method:'POST', path:'/api/webhooks/yoco', auth:'HMAC', desc:'Yoco payment event webhook. Called by Yoco servers. Verified via HMAC-SHA256 signature in the X-Yoco-Signature header.',
         notes:'This endpoint bypasses the global rate limiter. Raw body is parsed before JSON middleware. Refreshes early-bird pricing before computing totalDue to ensure accurate paid/partial status.',
@@ -944,6 +1044,21 @@ app.get('/docs', async (req, res) => {
         responses:[{ status:200, desc:'Acknowledged', body:{ received:true }}]},
     ]},
 
+    { title: 'Yoco', base: '/api/yoco', endpoints: [
+      { method:'GET', path:'/api/yoco/config', auth:'admin', desc:'Yoco settings with secrets masked (prefix + last 3 characters), where each comes from (db, env or none), test/live mode and the default webhook URL.',
+        responses:[{ status:200, desc:'Success', body:{ secretKeyMasked:'sk_test_***************aba', secretKeySource:'db', mode:'test', webhookSecretMasked:'whsec_*****************1Xz', webhookSecretSource:'db', webhookId:'sub_123', webhookUrl:'https://api.example.com/api/webhooks/yoco', configured:true }}]},
+      { method:'PUT', path:'/api/yoco/config', auth:'admin', desc:'Save the secret key and/or webhook secret (stored AES-256-GCM encrypted). A new secret key is checked against Yoco first. An empty string clears the value (the .env fallback then applies).',
+        request:{ body:{ secretKey:'sk_test_...', webhookSecret:'whsec_...' }},
+        responses:[{ status:200, desc:'Saved', body:{ message:'Yoco settings saved' }}]},
+      { method:'GET', path:'/api/yoco/webhooks', auth:'admin', desc:'Webhooks registered on the Yoco account, flagged isActive (its secret is the stored one) and pointsHere (URL is this server).',
+        responses:[{ status:200, desc:'Success', body:{ webhooks:[{ id:'sub_123', name:'hope-events', url:'https://api.example.com/api/webhooks/yoco', mode:'test', isActive:true, pointsHere:true }], defaultUrl:'https://api.example.com/api/webhooks/yoco' }}]},
+      { method:'POST', path:'/api/yoco/webhooks', auth:'admin', desc:'Register a webhook at Yoco (defaults: name "hope-events", URL = BACKEND_URL/api/webhooks/yoco) and store the secret Yoco returns. The URL must be public https.',
+        request:{ body:{ name:'hope-events', url:'https://api.example.com/api/webhooks/yoco' }},
+        responses:[{ status:201, desc:'Registered', body:{ message:'Webhook registered and its secret saved', webhook:{ id:'sub_123', name:'hope-events', url:'https://api.example.com/api/webhooks/yoco', mode:'test' }, webhookSecretMasked:'whsec_*****************1Xz' }}]},
+      { method:'DELETE', path:'/api/yoco/webhooks/:id', auth:'admin', desc:'Delete a webhook at Yoco. If it was the active one, the stored webhook secret is cleared too.',
+        responses:[{ status:200, desc:'Deleted', body:{ message:'Webhook deleted', clearedSecret:false }}]},
+    ]},
+
     { title: 'Settings', base: '/api/settings', endpoints: [
       { method:'GET', path:'/api/settings', auth:'public', desc:'Public settings — org name, brand colours (primary/secondary/accent), logo URL, favicon URL, legal page slugs, registration notification email (no secrets)',
         responses:[{ status:200, desc:'Success', body:{ org_name:'Cross Code', org_tagline:'Event management, made simple', primary_color:'#4F46E5', secondary_color:'#8B5CF6', accent_color:'#EC4899', logo_url:'/uploads/branding/logo-123.png', favicon_url:'/uploads/branding/favicon-123.png' }}]},
@@ -1364,6 +1479,52 @@ app.listen(PORT, () => {
     console.warn('[waitlist] Not scheduled:', e?.message || e);
   }
 
+  // Funnel analytics — once a day, roll raw rows older than 90 days into daily totals.
+  try {
+    const enabled = String(process.env.ANALYTICS_ROLLUP_ENABLED || 'true').toLowerCase() !== 'false';
+    if (enabled) {
+      const { rollupOldEvents } = require('./utils/analytics');
+      const run = async () => {
+        try {
+          const n = await rollupOldEvents();
+          if (n) console.log(`[analytics] Rolled up ${n} session(s) older than 90 days.`);
+        } catch (e) {
+          console.warn('[analytics] Rollup failed:', e?.message || e);
+        }
+      };
+      setTimeout(run, 5 * 60 * 1000);
+      setInterval(run, 24 * 60 * 60 * 1000);
+      console.log('[analytics] Rollup daily.');
+    } else {
+      console.log('[analytics] Rollup disabled by env ANALYTICS_ROLLUP_ENABLED=false');
+    }
+  } catch (e) {
+    console.warn('[analytics] Not scheduled:', e?.message || e);
+  }
+
+  // Feedback job — send post-event feedback forms at their send time, and the one
+  // reminder 3 days later.
+  try {
+    const enabled = String(process.env.FEEDBACK_JOB_ENABLED || 'true').toLowerCase() !== 'false';
+    if (enabled) {
+      const { runFeedbackJob } = require('./utils/feedback');
+      const everyMs = parseInt(process.env.FEEDBACK_JOB_INTERVAL_MS || String(15 * 60 * 1000), 10);
+      setInterval(async () => {
+        try {
+          const r = await runFeedbackJob();
+          if (r.sent || r.reminded) console.log(`[feedback] ${r.sent} invite(s), ${r.reminded} reminder(s) sent.`);
+        } catch (e) {
+          console.warn('[feedback] Job failed:', e?.message || e);
+        }
+      }, everyMs);
+      console.log(`[feedback] Job every ${Math.round(everyMs / 60000)} min.`);
+    } else {
+      console.log('[feedback] Job disabled by env FEEDBACK_JOB_ENABLED=false');
+    }
+  } catch (e) {
+    console.warn('[feedback] Not scheduled:', e?.message || e);
+  }
+
   // Daily parental-consent job — reminders for unanswered requests, and purging
   // medical/emergency details a set number of days after each event.
   try {

backend/src/middleware/authMiddleware.js

@@ -48,6 +48,17 @@ const protect = async (req, res, next) => {
         return next(new Error('User account is deactivated'));
       }
 
+      // An admin viewing as this user: only while the session is live, and read-only.
+      if (decoded.imp) {
+        const { liveSession } = require('../utils/impersonation');
+        const session = await liveSession(String(decoded.imp));
+        if (!session || session.targetUserId !== req.user.id) {
+          return res.status(401).json({ message: 'The impersonation session has ended.', code: 'IMPERSONATION_ENDED' });
+        }
+        req.impersonation = session;
+        req.readOnly = true;
+      }
+
       // Revocation check — tokenVersion in JWT must match DB
       // Old tokens without tokenVersion are treated as version 0
       const tokenVer = decoded.tokenVersion ?? 0;
@@ -60,7 +71,8 @@ const protect = async (req, res, next) => {
       // requirement (or the user's promotion) is sent back to log in, where they
       // enrol. The setup wizard's own token gets a short grace period.
       const inSetupGrace = decoded.setup === true && Date.now() / 1000 - (decoded.iat || 0) < SETUP_TOKEN_GRACE_SECONDS;
-      if (!inSetupGrace && (await mustEnrolTwoFactor(req.user))) {
+      // (An impersonating admin has already passed 2FA themselves.)
+      if (!inSetupGrace && !req.impersonation && (await mustEnrolTwoFactor(req.user))) {
         return res.status(401).json({
           message: 'Two-factor authentication is required for your role. Please log in again to set it up.',
           code: 'TWO_FACTOR_REQUIRED',
@@ -128,7 +140,17 @@ const optionalAuth = async (req, res, next) => {
       select: { id: true, name: true, email: true, role: true, isActive: true, createdAt: true, updatedAt: true, phoneNumber: true, tokenVersion: true }
     });
     if (user && user.isActive && (decoded.tokenVersion ?? 0) === user.tokenVersion) {
-      req.user = user;
+      if (decoded.imp) {
+        const { liveSession } = require('../utils/impersonation');
+        const session = await liveSession(String(decoded.imp));
+        req.readOnly = true;
+        if (session && session.targetUserId === user.id) {
+          req.user = user;
+          req.impersonation = session;
+        }
+      } else {
+        req.user = user;
+      }
     }
   } catch {
     // Token invalid or expired — proceed without user

backend/src/routes/adminRoutes.js

@@ -1,8 +1,15 @@
 const express = require('express');
 const router = express.Router();
 const { listAuditLog } = require('../controllers/adminAuditController');
+const { startImpersonation, endImpersonation, logPageView, currentImpersonation, listSessions } = require('../controllers/impersonationController');
 const { protect, admin } = require('../middleware/authMiddleware');
 
 router.get('/audit-log', protect, admin, listAuditLog);
+router.get('/impersonation-sessions', protect, admin, listSessions);
+// Called with the impersonation token itself (which belongs to the viewed user).
+router.post('/impersonate/end', protect, endImpersonation);
+router.post('/impersonate/log', protect, logPageView);
+router.get('/impersonate/current', protect, currentImpersonation);
+router.post('/impersonate/:userId', protect, admin, startImpersonation);
 
 module.exports = router;

backend/src/routes/allocationRoutes.js

@@ -0,0 +1,22 @@
+const express = require('express');
+const router = express.Router();
+const {
+  getBoard, createSet, updateSet, deleteSet, createGroup, updateGroup, deleteGroup,
+  assign, autoAssign, clearAssignments, getSetLists, getMyGroups,
+} = require('../controllers/allocationController');
+const { protect, staff, supervisor } = require('../middleware/authMiddleware');
+
+router.get('/my-groups', protect, staff, getMyGroups);
+router.get('/event/:eventId', protect, supervisor, getBoard);
+router.post('/sets', protect, supervisor, createSet);
+router.put('/sets/:id', protect, supervisor, updateSet);
+router.delete('/sets/:id', protect, supervisor, deleteSet);
+router.get('/sets/:id/lists', protect, supervisor, getSetLists);
+router.post('/sets/:id/groups', protect, supervisor, createGroup);
+router.put('/sets/:id/assignments', protect, supervisor, assign);
+router.delete('/sets/:id/assignments', protect, supervisor, clearAssignments);
+router.post('/sets/:id/auto', protect, supervisor, autoAssign);
+router.put('/groups/:id', protect, supervisor, updateGroup);
+router.delete('/groups/:id', protect, supervisor, deleteGroup);
+
+module.exports = router;

backend/src/routes/analyticsRoutes.js

@@ -0,0 +1,18 @@
+const express = require('express');
+const rateLimit = require('express-rate-limit');
+const router = express.Router();
+const { trackStage, getFunnel } = require('../controllers/analyticsController');
+const { protect, supervisor } = require('../middleware/authMiddleware');
+
+const trackLimiter = rateLimit({
+  windowMs: 60 * 1000,
+  max: 60,
+  standardHeaders: true,
+  legacyHeaders: false,
+  handler: (req, res) => res.status(204).end(), // silently drop floods
+});
+
+router.post('/track', trackLimiter, trackStage);
+router.get('/funnel', protect, supervisor, getFunnel);
+
+module.exports = router;

backend/src/routes/feedbackRoutes.js

@@ -0,0 +1,14 @@
+const express = require('express');
+const router = express.Router();
+const { getEventFeedback, saveEventFeedback, deleteEventFeedback, sendNow, getPublicForm, submitPublicForm, getSummary } = require('../controllers/feedbackController');
+const { protect, supervisor } = require('../middleware/authMiddleware');
+
+router.get('/public/:token', getPublicForm);
+router.post('/public/:token', submitPublicForm);
+router.get('/summary', protect, supervisor, getSummary);
+router.get('/event/:eventId', protect, supervisor, getEventFeedback);
+router.put('/event/:eventId', protect, supervisor, saveEventFeedback);
+router.delete('/event/:eventId', protect, supervisor, deleteEventFeedback);
+router.post('/event/:eventId/send-now', protect, supervisor, sendNow);
+
+module.exports = router;

backend/src/routes/sponsorshipRoutes.js

@@ -0,0 +1,10 @@
+const express = require('express');
+const router = express.Router();
+const { getEventSponsorship, createSponsorCheckout, getPool } = require('../controllers/sponsorshipController');
+const { protect, supervisor, optionalAuth } = require('../middleware/authMiddleware');
+
+router.get('/event/:eventId', getEventSponsorship);
+router.get('/event/:eventId/pool', protect, supervisor, getPool);
+router.post('/checkout', optionalAuth, createSponsorCheckout);
+
+module.exports = router;

backend/src/routes/ticketRoutes.js

@@ -15,6 +15,10 @@ const {
   getRecentScans,
   getScanStats,
   transferTicketHandler,
+  cancelTransferHandler,
+  getTransferOffer,
+  acceptTransferOffer,
+  declineTransferOffer,
   getTicketTransfers
 } = require('../controllers/ticketController');
 const { protect, admin, supervisor, staff } = require('../middleware/authMiddleware');
@@ -24,6 +28,11 @@ router.get('/mytickets', protect, getUserTickets);
 router.get('/:id', protect, getTicketById);
 router.post('/email', protect, emailTickets);
 router.post('/:id/transfer', protect, transferTicketHandler);
+router.delete('/:id/transfer', protect, cancelTransferHandler);
+// Transfer links (public: the person the ticket is offered to)
+router.get('/transfer-offer/:token', getTransferOffer);
+router.post('/transfer-offer/:token/accept', acceptTransferOffer);
+router.post('/transfer-offer/:token/decline', declineTransferOffer);
 router.get('/:id/transfers', protect, getTicketTransfers);
 
 // Staff routes

backend/src/routes/yocoRoutes.js

@@ -0,0 +1,12 @@
+const express = require('express');
+const router = express.Router();
+const { getConfig, updateConfig, getWebhooks, createWebhook, removeWebhook } = require('../controllers/yocoController');
+const { protect, admin } = require('../middleware/authMiddleware');
+
+router.get('/config', protect, admin, getConfig);
+router.put('/config', protect, admin, updateConfig);
+router.get('/webhooks', protect, admin, getWebhooks);
+router.post('/webhooks', protect, admin, createWebhook);
+router.delete('/webhooks/:id', protect, admin, removeWebhook);
+
+module.exports = router;

backend/src/utils/accountMatch.js

@@ -40,11 +40,9 @@ async function findAccountByContact({ email, phone: rawPhone }, db = prisma) {
  */
 async function findOrCreateAccount({ name, email, phone }, db = prisma) {
   const match = await findAccountByContact({ email, phone }, db);
-  if (match.conflict) {
-    const err = new Error('That email address and phone number belong to two different accounts. Use just one of them.');
-    err.statusCode = 400;
-    throw err;
-  }
+  // Email and phone pointing at two different accounts: go with the email's account,
+  // without saying so — the person typing the details mustn't learn who has an account.
+  if (match.conflict) return { user: match.emailUser, created: false };
   if (match.user) return { user: match.user, created: false };
   const { v4: uuidv4 } = require('uuid');
   const { hashPassword } = require('../config/auth');

backend/src/utils/allocation.js

@@ -0,0 +1,107 @@
+/**
+ * Group / room allocation — placing named attendees into the groups of an allocation
+ * set ("Rooms", "Buses"…). Groups can have a capacity and a gender restriction.
+ * The placement rules and auto-allocate are pure, so they're unit-tested.
+ */
+
+const GENDERS = ['male', 'female'];
+
+function allocationError(message, statusCode = 400) {
+  const err = new Error(message);
+  err.statusCode = statusCode;
+  return err;
+}
+
+/** Normalises a gender value ('male' | 'female' | null); throws on anything else. */
+function cleanGender(value) {
+  if (value === undefined || value === null || value === '') return null;
+  const g = String(value).trim().toLowerCase();
+  if (!GENDERS.includes(g)) throw allocationError('Gender must be male or female.');
+  return g;
+}
+
+/**
+ * Why `attendees` can't all join `group` (which has `count` members already), or null. Pure.
+ * @param {object} group - { name, capacity?, gender? }
+ */
+function joinBlocker(group, count, attendees) {
+  if (group.capacity != null && count + attendees.length > group.capacity) {
+    return `${group.name} is full (${group.capacity} places).`;
+  }
+  if (group.gender) {
+    const wrong = attendees.find(a => a.gender !== group.gender);
+    if (wrong) return `${group.name} is for ${group.gender === 'male' ? 'males' : 'females'} only${wrong.gender ? '' : ` — ${wrong.name} has no gender recorded`}.`;
+  }
+  return null;
+}
+
+/**
+ * Places every unassigned attendee it can. Pure.
+ *
+ * Groups fill evenly (the emptiest group that fits goes first). With mode 'together',
+ * people on the same registration (siblings) stay in one group when a group can take
+ * them all, otherwise they're placed one by one. With mode 'split', people on the same
+ * registration (friends booking together) are spread across groups where possible.
+ *
+ * @param {object} p
+ * @param {Array} p.groups    - [{ id, name, capacity?, gender?, order? }]
+ * @param {Array} p.attendees - [{ id, name, registrationId, gender? }]
+ * @param {Map}   p.assigned  - attendeeId → groupId for attendees already placed
+ * @param {'together'|'split'} [p.mode]
+ * @returns {{ placements: {attendeeId, groupId}[], unplaced: string[] }}
+ */
+function autoAllocate({ groups, attendees, assigned = new Map(), mode = 'together' }) {
+  const count = new Map(groups.map(g => [g.id, 0]));
+  const regInGroup = new Map(groups.map(g => [g.id, new Map()]));
+  const byId = new Map(attendees.map(a => [a.id, a]));
+  const place = (groupId, a) => {
+    count.set(groupId, count.get(groupId) + 1);
+    const regs = regInGroup.get(groupId);
+    regs.set(a.registrationId, (regs.get(a.registrationId) || 0) + 1);
+  };
+  for (const [attendeeId, groupId] of assigned) {
+    const a = byId.get(attendeeId);
+    if (a && count.has(groupId)) place(groupId, a);
+  }
+
+  const todo = attendees.filter(a => !assigned.has(a.id));
+  let units;
+  if (mode === 'together') {
+    const byReg = new Map();
+    for (const a of todo) byReg.set(a.registrationId, [...(byReg.get(a.registrationId) || []), a]);
+    units = [...byReg.values()].sort((x, y) => y.length - x.length);
+  } else {
+    units = todo.map(a => [a]);
+  }
+
+  const orderOf = new Map(groups.map((g, i) => [g.id, g.order ?? i]));
+  const best = (members) => {
+    const reg = members[0].registrationId;
+    const fitting = groups.filter(g => !joinBlocker(g, count.get(g.id), members));
+    if (fitting.length === 0) return null;
+    fitting.sort((x, y) =>
+      (mode === 'split' ? (regInGroup.get(x.id).get(reg) || 0) - (regInGroup.get(y.id).get(reg) || 0) : 0)
+      || count.get(x.id) - count.get(y.id)
+      || orderOf.get(x.id) - orderOf.get(y.id));
+    return fitting[0];
+  };
+
+  const placements = [];
+  const unplaced = [];
+  const queue = [...units];
+  while (queue.length) {
+    const unit = queue.shift();
+    const g = best(unit);
+    if (g) {
+      for (const a of unit) { place(g.id, a); placements.push({ attendeeId: a.id, groupId: g.id }); }
+    } else if (unit.length > 1) {
+      // Can't keep them together — place them one by one instead.
+      queue.unshift(...unit.map(a => [a]));
+    } else {
+      unplaced.push(unit[0].id);
+    }
+  }
+  return { placements, unplaced };
+}
+
+module.exports = { GENDERS, allocationError, cleanGender, joinBlocker, autoAllocate };

backend/src/utils/analytics.js

@@ -0,0 +1,220 @@
+/**
+ * Registration funnel — first-party, consent-based tracking.
+ *
+ * The browser only tracks after the visitor accepts cookies: it keeps a random session
+ * id and reports 'view' (event page) and 'start' (registration page). 'submit' is
+ * recorded here when a registration arrives carrying that session id, and 'paid' is
+ * read from that registration's status, so no personal data is stored with the events —
+ * just a stage, a traffic source and a device type (worked out from the User-Agent,
+ * which isn't kept).
+ *
+ * Counts are "reached": a session counts at a stage if it got that far or further, so a
+ * visitor who went straight to the registration page still counts as a view. Raw rows
+ * older than 90 days are rolled up into AnalyticsDaily and deleted.
+ */
+
+const prisma = require('../config/db');
+
+const STAGES = ['view', 'start', 'submit', 'paid'];
+const TRACKED = ['view', 'start'];
+const RAW_DAYS = 90;
+const SESSION_RE = /^[a-zA-Z0-9-]{16,64}$/;
+
+const dayOf = (d) => new Date(d).toISOString().slice(0, 10);
+
+// ─── Pure helpers ─────────────────────────────────────────────────────────────
+
+const validSession = (sid) => typeof sid === 'string' && SESSION_RE.test(sid);
+
+/** 'mobile' | 'tablet' | 'desktop', or null for bots. Pure. */
+function deviceFromUA(ua) {
+  const s = String(ua || '');
+  if (!s || /bot|crawl|spider|slurp|preview|headless|lighthouse/i.test(s)) return null;
+  if (/iPad|Tablet|PlayBook|Silk|(Android(?!.*Mobile))/i.test(s)) return 'tablet';
+  if (/Mobi|iPhone|iPod|Android|Windows Phone/i.test(s)) return 'mobile';
+  return 'desktop';
+}
+
+/** A traffic source label: utm_source / short-link alias, tidied; 'direct' when none. Pure. */
+function cleanSource(src) {
+  const s = String(src || '').trim().toLowerCase().replace(/[^a-z0-9_.-]/g, '').slice(0, 50);
+  return s || 'direct';
+}
+
+/**
+ * One entry per session: the furthest stage reached, its source/device, and the day each
+ * stage was reached. Pure.
+ * @param {Array} events - [{ sessionId, stage, createdAt, source, device }]
+ * @param {Set} paidSessions - session ids whose registration is paid
+ */
+function sessionsFrom(events, paidSessions = new Set()) {
+  const map = new Map();
+  for (const e of [...events].sort((a, b) => new Date(a.createdAt) - new Date(b.createdAt))) {
+    const s = map.get(e.sessionId) || { sessionId: e.sessionId, reach: -1, source: null, device: null, days: {} };
+    const idx = STAGES.indexOf(e.stage);
+    if (idx > s.reach) s.reach = idx;
+    if (!s.days[e.stage]) s.days[e.stage] = dayOf(e.createdAt);
+    if (!s.source && e.source) s.source = e.source;
+    if (!s.device && e.device) s.device = e.device;
+    map.set(e.sessionId, s);
+  }
+  for (const s of map.values()) {
+    if (paidSessions.has(s.sessionId) && s.reach >= 2) { s.reach = 3; s.days.paid = s.days.submit; }
+    // A stage reached without its own event (e.g. no 'view' for a direct link) takes the
+    // day of the next stage that was recorded.
+    for (let i = STAGES.length - 1; i >= 0; i--) {
+      if (i <= s.reach && !s.days[STAGES[i]]) s.days[STAGES[i]] = s.days[STAGES[i + 1]];
+    }
+    s.source = s.source || 'direct';
+    s.device = s.device || 'unknown';
+  }
+  return [...map.values()];
+}
+
+/** Rows for AnalyticsDaily: sessions reaching each stage per day/source/device. Pure. */
+function rollupRows(sessions) {
+  const by = new Map();
+  for (const s of sessions) {
+    for (let i = 0; i <= s.reach; i++) {
+      const key = [s.days[STAGES[i]], STAGES[i], s.source, s.device].join('|');
+      by.set(key, (by.get(key) || 0) + 1);
+    }
+  }
+  return [...by.entries()].map(([key, n]) => {
+    const [day, stage, source, device] = key.split('|');
+    return { day, stage, source, device, sessions: n };
+  });
+}
+
+const emptyCounts = () => ({ view: 0, start: 0, submit: 0, paid: 0 });
+
+/**
+ * The funnel report from raw sessions plus rolled-up rows. Pure.
+ * @returns {{ totals, conversion, trend, bySource, byDevice }}
+ */
+function funnelReport(sessions, daily = []) {
+  const rows = [...rollupRows(sessions), ...daily.map(d => ({ ...d, day: typeof d.day === 'string' ? d.day.slice(0, 10) : dayOf(d.day) }))];
+  const totals = emptyCounts();
+  const trend = new Map(), bySource = new Map(), byDevice = new Map();
+  const add = (map, key, stage, n) => { const c = map.get(key) || emptyCounts(); c[stage] += n; map.set(key, c); };
+  for (const r of rows) {
+    totals[r.stage] += r.sessions;
+    add(trend, r.day, r.stage, r.sessions);
+    add(bySource, r.source, r.stage, r.sessions);
+    add(byDevice, r.device, r.stage, r.sessions);
+  }
+  const pct = (a, b) => (b ? Math.round((a / b) * 1000) / 10 : null);
+  const list = (map) => [...map.entries()].map(([key, c]) => ({ key, ...c, conversion: pct(c.paid, c.view) })).sort((a, b) => b.view - a.view);
+  return {
+    totals,
+    conversion: {
+      start: pct(totals.start, totals.view), submit: pct(totals.submit, totals.view), paid: pct(totals.paid, totals.view),
+      startToSubmit: pct(totals.submit, totals.start), submitToPaid: pct(totals.paid, totals.submit),
+    },
+    trend: [...trend.entries()].sort(([a], [b]) => a.localeCompare(b)).map(([day, c]) => ({ day, ...c })),
+    bySource: list(bySource),
+    byDevice: list(byDevice),
+  };
+}
+
+// ─── Database ─────────────────────────────────────────────────────────────────
+
+/** Records a 'view' or 'start'. Repeats from the same session are ignored. */
+async function track({ sessionId, eventId, stage, source, userAgent }) {
+  if (!validSession(sessionId) || !TRACKED.includes(stage) || typeof eventId !== 'string') return false;
+  const device = deviceFromUA(userAgent);
+  if (!device) return false; // bots
+  const event = await prisma.event.findUnique({ where: { id: eventId }, select: { id: true } });
+  if (!event) return false;
+  await prisma.analyticsEvent.createMany({ data: [{ sessionId, eventId, stage, source: cleanSource(source), device }], skipDuplicates: true });
+  return true;
+}
+
+/** 'submit' for a registration made on the public registration page. */
+async function recordSubmit(registration, sessionId) {
+  if (!validSession(sessionId) || !registration?.id) return;
+  const first = await prisma.analyticsEvent.findFirst({ where: { sessionId, eventId: registration.eventId }, orderBy: { createdAt: 'asc' } });
+  await prisma.registration.updateMany({ where: { id: registration.id, analyticsSessionId: null }, data: { analyticsSessionId: sessionId } });
+  await prisma.analyticsEvent.createMany({
+    data: [{ sessionId, eventId: registration.eventId, stage: 'submit', source: first?.source || 'direct', device: first?.device || null }],
+    skipDuplicates: true,
+  });
+}
+
+async function paidSessionsFor(eventIds, sessionIds) {
+  if (!sessionIds.length) return new Set();
+  const regs = await prisma.registration.findMany({
+    where: { eventId: { in: eventIds }, status: 'paid', analyticsSessionId: { in: sessionIds } },
+    select: { analyticsSessionId: true },
+  });
+  return new Set(regs.map(r => r.analyticsSessionId));
+}
+
+/**
+ * The funnel for some events between two dates (by the day each stage was reached).
+ * Adds a by-ticket-option breakdown from the tracked registrations.
+ */
+async function funnelFor(eventIds, { from, to } = {}) {
+  const range = {};
+  if (from) range.gte = new Date(from);
+  if (to) { const t = new Date(to); t.setHours(23, 59, 59, 999); range.lte = t; }
+  const where = { eventId: { in: eventIds }, ...(from || to ? { createdAt: range } : {}) };
+  const events = await prisma.analyticsEvent.findMany({ where, select: { sessionId: true, stage: true, createdAt: true, source: true, device: true, eventId: true } });
+  // A session is per event (the same browser can look at several events).
+  const keyed = events.map(e => ({ ...e, sessionId: `${e.eventId}:${e.sessionId}` }));
+  const paidRaw = await paidSessionsFor(eventIds, [...new Set(events.map(e => e.sessionId))]);
+  const paid = new Set(events.filter(e => paidRaw.has(e.sessionId)).map(e => `${e.eventId}:${e.sessionId}`));
+  const daily = await prisma.analyticsDaily.findMany({
+    where: { eventId: { in: eventIds }, ...(from || to ? { day: range } : {}) },
+    select: { day: true, stage: true, source: true, device: true, sessions: true },
+  });
+  const report = funnelReport(sessionsFrom(keyed, paid), daily);
+
+  const regs = await prisma.registration.findMany({
+    where: { eventId: { in: eventIds }, analyticsSessionId: { not: null }, status: { not: 'cancelled' }, ...(from || to ? { createdAt: range } : {}) },
+    select: { status: true, registrationOptions: { select: { quantity: true, eventOption: { select: { name: true } }, variant: { select: { name: true } } } } },
+  });
+  const byOption = new Map();
+  for (const r of regs) {
+    for (const ro of r.registrationOptions) {
+      const key = ro.variant ? `${ro.eventOption.name} — ${ro.variant.name}` : ro.eventOption.name;
+      const c = byOption.get(key) || { key, submitted: 0, paid: 0 };
+      c.submitted += 1;
+      if (r.status === 'paid') c.paid += 1;
+      byOption.set(key, c);
+    }
+  }
+  return { ...report, byOption: [...byOption.values()].sort((a, b) => b.submitted - a.submitted) };
+}
+
+/** Rolls up sessions whose last activity is older than 90 days, then deletes their rows. */
+async function rollupOldEvents(now = new Date()) {
+  const cutoff = new Date(now.getTime() - RAW_DAYS * 864e5);
+  const groups = await prisma.analyticsEvent.groupBy({ by: ['eventId', 'sessionId'], _max: { createdAt: true }, having: { createdAt: { _max: { lt: cutoff } } } });
+  if (groups.length === 0) return 0;
+  const byEvent = new Map();
+  for (const g of groups) byEvent.set(g.eventId, [...(byEvent.get(g.eventId) || []), g.sessionId]);
+  let rolled = 0;
+  for (const [eventId, sessionIds] of byEvent) {
+    for (let i = 0; i < sessionIds.length; i += 500) {
+      const batch = sessionIds.slice(i, i + 500);
+      const events = await prisma.analyticsEvent.findMany({ where: { eventId, sessionId: { in: batch } } });
+      const paid = await paidSessionsFor([eventId], batch);
+      const rows = rollupRows(sessionsFrom(events, paid));
+      await prisma.$transaction(async (tx) => {
+        for (const r of rows) {
+          await tx.analyticsDaily.upsert({
+            where: { eventId_day_stage_source_device: { eventId, day: new Date(r.day), stage: r.stage, source: r.source, device: r.device } },
+            update: { sessions: { increment: r.sessions } },
+            create: { eventId, day: new Date(r.day), stage: r.stage, source: r.source, device: r.device, sessions: r.sessions },
+          });
+        }
+        await tx.analyticsEvent.deleteMany({ where: { eventId, sessionId: { in: batch } } });
+      });
+      rolled += batch.length;
+    }
+  }
+  return rolled;
+}
+
+module.exports = { STAGES, RAW_DAYS, validSession, deviceFromUA, cleanSource, sessionsFrom, rollupRows, funnelReport, track, recordSubmit, funnelFor, rollupOldEvents };

backend/src/utils/attendees.js

@@ -69,6 +69,13 @@ function validateAttendees(event, placesByKey, attendees, namedByKey = {}) {
     } else if (consent) {
       throw attendeeError(`${name}: enter a date of birth.`);
     }
+    let gender = null;
+    if (a.gender) {
+      gender = String(a.gender).trim().toLowerCase();
+      if (!['male', 'female'].includes(gender)) throw attendeeError(`${name}: gender must be male or female.`);
+    } else if (event.collectGender) {
+      throw attendeeError(`${name}: choose a gender.`);
+    }
     const parentName = String(a.parentName || '').trim() || null;
     const parentEmail = String(a.parentEmail || '').trim() || null;
     const parentPhone = String(a.parentPhone || '').trim() || null;
@@ -78,7 +85,7 @@ function validateAttendees(event, placesByKey, attendees, namedByKey = {}) {
       }
       if (!EMAIL_RE.test(parentEmail)) throw attendeeError(`${name}: "${parentEmail}" isn't a valid parent email address.`);
     }
-    return { eventOptionId: a.eventOptionId, variantId: a.variantId || null, name, email, phone, dateOfBirth, parentName, parentEmail, parentPhone };
+    return { eventOptionId: a.eventOptionId, variantId: a.variantId || null, name, email, phone, dateOfBirth, gender, parentName, parentEmail, parentPhone };
   });
 
   // Youth events need every main place named (with a date of birth).
@@ -187,6 +194,7 @@ async function createAttendees(registrationId, attendees, db = prisma) {
         email: a.email,
         phone: a.phone,
         dateOfBirth: a.dateOfBirth || null,
+        gender: a.gender || null,
         parentName: a.parentName || null,
         parentEmail: a.parentEmail || null,
         parentPhone: a.parentPhone || null,

backend/src/utils/feedback.js

@@ -0,0 +1,230 @@
+/**
+ * Post-event feedback.
+ *
+ * A FeedbackForm is sent once, at its sendAt, to everyone who checked in (or everyone
+ * registered), with one reminder 3 days later to those who haven't answered. Each person
+ * gets a personal link; only an HMAC of its token is stored, and a reminder issues a new
+ * link. Anonymous forms record who has answered (so reminders skip them) but never link
+ * the answers to the person.
+ */
+
+const crypto = require('crypto');
+const prisma = require('../config/db');
+
+const ANSWERABLE = ['text', 'numeric', 'date', 'yes_no', 'rating', 'multiple_choice'];
+const ALL_TYPES = [...ANSWERABLE, 'statement', 'paragraph'];
+const REMINDER_AFTER_MS = 3 * 864e5;
+
+function feedbackError(message, statusCode = 400) {
+  const err = new Error(message);
+  err.statusCode = statusCode;
+  return err;
+}
+
+const hashToken = (token) => crypto.createHmac('sha256', process.env.JWT_SECRET || '').update(`feedback:${token}`).digest('hex');
+const newToken = () => crypto.randomBytes(24).toString('hex');
+function feedbackLink(token) {
+  const base = (process.env.FRONTEND_URL || process.env.APP_BASE_URL || 'http://localhost:3001').split(',')[0].trim().replace(/\/$/, '');
+  return `${base}/feedback/${token}`;
+}
+
+// ─── Pure helpers ─────────────────────────────────────────────────────────────
+
+/** Checks and tidies the questions from the form builder. Pure. */
+function cleanFields(fields) {
+  if (!Array.isArray(fields)) throw feedbackError('fields must be a list');
+  const out = fields.filter(f => f && String(f.label || '').trim()).map((f, i) => {
+    if (!ALL_TYPES.includes(f.type)) throw feedbackError(`Question ${i + 1}: unknown type "${f.type}".`);
+    const label = String(f.label).trim().slice(0, 500);
+    let options = null;
+    if (f.type === 'multiple_choice') {
+      options = [...new Set((Array.isArray(f.options) ? f.options : []).map(o => String(o || '').trim()).filter(Boolean))].slice(0, 20);
+      if (options.length < 2) throw feedbackError(`"${label}": a multiple-choice question needs at least two choices.`);
+    }
+    return {
+      type: f.type, label, order: i, options,
+      isRequired: ANSWERABLE.includes(f.type) && !!f.isRequired,
+      helpText: f.helpText ? String(f.helpText).slice(0, 1000) : null,
+    };
+  });
+  if (out.length > 50) throw feedbackError('A feedback form can have at most 50 questions.');
+  if (!out.some(f => ANSWERABLE.includes(f.type))) throw feedbackError('Add at least one question.');
+  return out;
+}
+
+/** The stored value for one answer (null when blank); throws when it's invalid. Pure. */
+function cleanAnswer(field, raw) {
+  if (raw === undefined || raw === null || String(raw).trim() === '') {
+    if (field.isRequired) throw feedbackError(`Please answer: ${field.label}`);
+    return null;
+  }
+  const v = String(raw).trim();
+  switch (field.type) {
+    case 'rating': {
+      const n = Number(v);
+      if (!Number.isInteger(n) || n < 1 || n > 5) throw feedbackError(`"${field.label}": choose 1 to 5 stars.`);
+      return String(n);
+    }
+    case 'multiple_choice':
+      if (!(field.options || []).includes(v)) throw feedbackError(`"${field.label}": choose one of the options.`);
+      return v;
+    case 'yes_no':
+      if (!['yes', 'no'].includes(v.toLowerCase())) throw feedbackError(`"${field.label}": answer yes or no.`);
+      return v.toLowerCase();
+    case 'numeric':
+      if (!Number.isFinite(Number(v))) throw feedbackError(`"${field.label}": enter a number.`);
+      return v;
+    case 'date':
+      if (isNaN(new Date(v).getTime())) throw feedbackError(`"${field.label}": enter a valid date.`);
+      return v.slice(0, 10);
+    default:
+      return v.slice(0, 4000);
+  }
+}
+
+/**
+ * Per-question summary. Pure.
+ * @param {Array} fields  - [{ id, type, label, options }]
+ * @param {Array} answers - [{ fieldId, value, name? }]  (name: respondent, for named forms)
+ */
+function summarise(fields, answers) {
+  const by = new Map();
+  for (const a of answers) by.set(a.fieldId, [...(by.get(a.fieldId) || []), a]);
+  const round1 = (n) => Math.round(n * 10) / 10;
+  return fields.filter(f => ANSWERABLE.includes(f.type)).map(f => {
+    const list = by.get(f.id) || [];
+    const base = { fieldId: f.id, type: f.type, label: f.label, answered: list.length };
+    if (f.type === 'rating') {
+      const nums = list.map(a => Number(a.value)).filter(n => n >= 1 && n <= 5);
+      const distribution = [1, 2, 3, 4, 5].map(star => ({ label: `${star}★`, value: nums.filter(n => n === star).length }));
+      return { ...base, average: nums.length ? round1(nums.reduce((s, n) => s + n, 0) / nums.length) : null, distribution };
+    }
+    if (f.type === 'multiple_choice' || f.type === 'yes_no') {
+      const choices = f.type === 'yes_no' ? ['yes', 'no'] : (f.options || []);
+      return { ...base, counts: choices.map(c => ({ label: f.type === 'yes_no' ? (c === 'yes' ? 'Yes' : 'No') : c, value: list.filter(a => a.value === c).length })) };
+    }
+    if (f.type === 'numeric') {
+      const nums = list.map(a => Number(a.value)).filter(Number.isFinite);
+      return { ...base, average: nums.length ? round1(nums.reduce((s, n) => s + n, 0) / nums.length) : null };
+    }
+    return { ...base, texts: list.map(a => ({ value: a.value, ...(a.name ? { name: a.name } : {}) })) };
+  });
+}
+
+// ─── Sending ──────────────────────────────────────────────────────────────────
+
+/** People to ask: those who checked in (a scan on their ticket), or everyone registered. */
+async function feedbackRecipients(form) {
+  const tickets = await prisma.ticket.findMany({
+    where: {
+      eventId: form.eventId,
+      registrationOption: { registration: { status: { not: 'cancelled' } } },
+      ...(form.audience === 'all' ? {} : { usages: { some: {} } }),
+    },
+    select: { userId: true, holderUserId: true, attendee: { select: { userId: true } } },
+  });
+  const ids = new Set(tickets.map(t => t.holderUserId || t.attendee?.userId || t.userId));
+  if (form.audience === 'all') {
+    const regs = await prisma.registration.findMany({ where: { eventId: form.eventId, status: { not: 'cancelled' } }, select: { userId: true } });
+    regs.forEach(r => ids.add(r.userId));
+  }
+  if (ids.size === 0) return [];
+  return prisma.user.findMany({ where: { id: { in: [...ids] } }, select: { id: true, name: true, email: true, phoneNumber: true, notificationPreference: true } });
+}
+
+async function sendFeedbackMessage(user, event, token, { reminder = false } = {}) {
+  const { sendMail, emailWrapper, ctaButton, fallbackLink } = require('./email');
+  const { waTextAny } = require('./notify');
+  const { isValidZAPhone } = require('./whatsapp');
+  const ff = `-apple-system,BlinkMacSystemFont,'Segoe UI',Roboto,Helvetica,Arial,sans-serif`;
+  const link = feedbackLink(token);
+  const subject = `${reminder ? 'Reminder: ' : ''}How was ${event.title}?`;
+  const emailOk = !!(user.email && user.email.includes('@') && !user.email.endsWith('@guest.local') && !user.email.endsWith('@deleted.invalid'));
+  const sent = [];
+  if (emailOk) {
+    const html = emailWrapper(`
+      <p style="font-size:22px;font-weight:800;color:#0f172a;margin:0 0 8px 0">${reminder ? 'A quick reminder — ' : ''}How was ${event.title}?</p>
+      <p style="margin:0 0 8px 0;color:#374151;font-family:${ff}">Hi <strong>${user.name || 'there'}</strong>,</p>
+      <p style="margin:0 0 24px 0;color:#374151;font-family:${ff}">Thank you for coming to <strong>${event.title}</strong>. We'd love to hear what you thought — it only takes a minute.</p>
+      ${ctaButton('Give feedback', link)}
+      ${fallbackLink(link)}
+    `, { preheader: `Tell us about ${event.title}` });
+    try {
+      await sendMail({ to: user.email, subject, html, text: `Hi ${user.name || 'there'},\n\nThank you for coming to ${event.title}. We'd love to hear what you thought: ${link}` });
+      sent.push('email');
+    } catch (e) {
+      console.warn('[feedback] email failed:', e?.message || e);
+    }
+  }
+  const wantsWA = ['whatsapp', 'both'].includes(user.notificationPreference) || !emailOk;
+  if (wantsWA && user.phoneNumber && isValidZAPhone(user.phoneNumber)) {
+    await waTextAny(user, `${reminder ? '⏰ ' : ''}Hi ${user.name || 'there'}, thank you for coming to *${event.title}*! We'd love your feedback — it only takes a minute: ${link}`);
+    sent.push('WhatsApp');
+  }
+  return sent;
+}
+
+/** Sends the form to everyone not yet invited. Returns how many were invited. */
+async function sendFeedbackInvites(formId) {
+  const form = await prisma.feedbackForm.findUnique({ where: { id: formId }, include: { event: true, invites: { select: { userId: true } } } });
+  if (!form) return 0;
+  const already = new Set(form.invites.map(i => i.userId));
+  const people = (await feedbackRecipients(form)).filter(u => !already.has(u.id));
+  for (const user of people) {
+    const token = newToken();
+    try {
+      await prisma.feedbackInvite.create({ data: { formId: form.id, userId: user.id, tokenHash: hashToken(token) } });
+    } catch (e) {
+      if (e.code === 'P2002') continue; // invited by a concurrent run
+      throw e;
+    }
+    await sendFeedbackMessage(user, form.event, token).catch(e => console.warn('[feedback] send failed:', e?.message || e));
+  }
+  return people.length;
+}
+
+/** The single reminder: a fresh link for everyone who hasn't answered. */
+async function sendFeedbackReminders(formId) {
+  const form = await prisma.feedbackForm.findUnique({ where: { id: formId }, include: { event: true } });
+  const invites = await prisma.feedbackInvite.findMany({
+    where: { formId, respondedAt: null, remindedAt: null },
+    include: { user: { select: { id: true, name: true, email: true, phoneNumber: true, notificationPreference: true } } },
+  });
+  for (const inv of invites) {
+    const token = newToken();
+    await prisma.feedbackInvite.update({ where: { id: inv.id }, data: { tokenHash: hashToken(token), remindedAt: new Date() } });
+    await sendFeedbackMessage(inv.user, form.event, token, { reminder: true }).catch(e => console.warn('[feedback] reminder failed:', e?.message || e));
+  }
+  return invites.length;
+}
+
+/** Background job: send forms whose time has come, and reminders 3 days after. */
+async function runFeedbackJob(now = new Date()) {
+  let sent = 0, reminded = 0;
+  const due = await prisma.feedbackForm.findMany({ where: { sentAt: null, sendAt: { lte: now } }, select: { id: true } });
+  for (const f of due) {
+    // Claim it first so two servers (or overlapping runs) never both send.
+    const claimed = await prisma.feedbackForm.updateMany({ where: { id: f.id, sentAt: null }, data: { sentAt: now } });
+    if (claimed.count === 1) sent += await sendFeedbackInvites(f.id);
+  }
+  const remind = await prisma.feedbackForm.findMany({ where: { reminderSentAt: null, sentAt: { lte: new Date(now.getTime() - REMINDER_AFTER_MS) } }, select: { id: true } });
+  for (const f of remind) {
+    const claimed = await prisma.feedbackForm.updateMany({ where: { id: f.id, reminderSentAt: null }, data: { reminderSentAt: now } });
+    if (claimed.count === 1) reminded += await sendFeedbackReminders(f.id);
+  }
+  return { sent, reminded };
+}
+
+async function findInviteByToken(token) {
+  if (!token || typeof token !== 'string' || token.length > 200) return null;
+  return prisma.feedbackInvite.findUnique({
+    where: { tokenHash: hashToken(token) },
+    include: { user: { select: { id: true, name: true } }, form: { include: { event: { select: { id: true, title: true, startDate: true, endDate: true } }, fields: { orderBy: { order: 'asc' } } } } },
+  });
+}
+
+module.exports = {
+  ANSWERABLE, ALL_TYPES, REMINDER_AFTER_MS, feedbackError, hashToken, feedbackLink,
+  cleanFields, cleanAnswer, summarise,
+  feedbackRecipients, sendFeedbackInvites, sendFeedbackReminders, runFeedbackJob, findInviteByToken,
+};

backend/src/utils/impersonation.js

@@ -0,0 +1,80 @@
+/**
+ * Admin "view as user" — strictly read-only.
+ *
+ * An impersonation token is an ordinary JWT for the target user plus an `imp` claim (the
+ * ImpersonationSession id), valid for at most 30 minutes. Three layers keep it read-only:
+ *  1. readOnlyGuard (mounted before every route): any request carrying an impersonation
+ *     token that isn't GET/HEAD/OPTIONS is refused, apart from ending the session and
+ *     logging page views. No controller can be reached for a write.
+ *  2. protect / optionalAuth check the session is live and set req.readOnly.
+ *  3. GET handlers that write as a side effect (price refresh on view) skip it when
+ *     req.readOnly is set.
+ * The only rows an impersonation session writes are its own session and request log.
+ */
+
+const jwt = require('jsonwebtoken');
+const prisma = require('../config/db');
+
+const MAX_MINUTES = 30;
+const SAFE_METHODS = ['GET', 'HEAD', 'OPTIONS'];
+const ALLOWED_WRITES = ['/api/admin/impersonate/end', '/api/admin/impersonate/log'];
+
+/** The `imp` claim of a bearer token, or null (no token, invalid token, or not impersonating). */
+function impersonationClaim(req) {
+  const h = req.headers.authorization;
+  if (!h || !h.startsWith('Bearer ')) return null;
+  try {
+    const decoded = jwt.verify(h.slice(7), process.env.JWT_SECRET, { algorithms: ['HS256'] });
+    return decoded.imp ? String(decoded.imp) : null;
+  } catch {
+    return null;
+  }
+}
+
+/** Whether this request may go ahead while impersonating. Pure. */
+function allowedWhileImpersonating(method, path) {
+  if (SAFE_METHODS.includes(String(method).toUpperCase())) return true;
+  const p = String(path || '').split('?')[0].replace(/\/+$/, '');
+  return method.toUpperCase() === 'POST' && ALLOWED_WRITES.includes(p);
+}
+
+function logRequest(sessionId, method, path, blocked = false) {
+  prisma.impersonationRequestLog.create({ data: { sessionId, method, path: String(path).slice(0, 500), blocked } }).catch(() => {});
+}
+
+/** Layer 1 — mounted in index.js before every route (webhooks never carry user tokens). */
+function readOnlyGuard(req, res, next) {
+  const sessionId = impersonationClaim(req);
+  if (!sessionId) return next();
+  const path = req.originalUrl || req.url;
+  if (!allowedWhileImpersonating(req.method, path)) {
+    logRequest(sessionId, req.method, path, true);
+    return res.status(403).json({ message: 'Read-only while viewing as another user. End impersonation to make changes.', code: 'IMPERSONATION_READ_ONLY' });
+  }
+  if (SAFE_METHODS.includes(req.method) && path.startsWith('/api/')) logRequest(sessionId, req.method, path);
+  next();
+}
+
+/** Layer 2 — the live session for an `imp` claim, or null when ended/expired. */
+async function liveSession(sessionId) {
+  const s = await prisma.impersonationSession.findUnique({ where: { id: sessionId } });
+  if (!s || s.endedAt) return null;
+  if (s.expiresAt <= new Date()) {
+    await prisma.impersonationSession.updateMany({ where: { id: s.id, endedAt: null }, data: { endedAt: new Date(), endedReason: 'expired' } });
+    return null;
+  }
+  return s;
+}
+
+/** Why `admin` can't view as `target`, or null. Pure. */
+function impersonationBlocker(admin, target) {
+  if (!admin || admin.role !== 'admin') return 'Only admins can view as another user.';
+  if (!admin.twoFactorEnabled) return 'Turn on two-factor authentication for your account first.';
+  if (!target) return 'User not found.';
+  if (target.id === admin.id) return "You can't view as yourself.";
+  if (target.role === 'admin') return "Admins can't be impersonated.";
+  if (!target.isActive) return 'That account is deactivated.';
+  return null;
+}
+
+module.exports = { MAX_MINUTES, impersonationClaim, allowedWhileImpersonating, readOnlyGuard, liveSession, impersonationBlocker, logRequest };

backend/src/utils/notifications.js

@@ -533,7 +533,7 @@ function buildPaymentReceipt(payment) {
   }
 
   // Donation receipt
-  const subject = `Donation received – ${eventTitle}`;
+  const subject = payment.isSponsorship ? `Thank you for sponsoring a spot – ${eventTitle}` : `Donation received – ${eventTitle}`;
   const preheader = `Thank you for your donation of ${fmtAmount(payment.amount)} to ${eventTitle}.`;
   const body = `
     <p style="font-size:22px;font-weight:800;color:#0f172a;margin:0 0 8px 0;letter-spacing:-0.3px">Thank you for your donation!</p>
@@ -541,7 +541,7 @@ function buildPaymentReceipt(payment) {
 
     <p style="margin:0 0 4px 0;color:#374151;font-family:${ff}">Hi <strong>${payment.user?.name || 'there'}</strong>,</p>
     <p style="margin:0 0 28px 0;color:#374151;font-family:${ff}">
-      We received your donation of <strong>${fmtAmount(payment.amount)}</strong> to <strong>${eventTitle}</strong>. Your support means the world to us.
+      We received your donation of <strong>${fmtAmount(payment.amount)}</strong> to <strong>${eventTitle}</strong>. Your support means the world to us.${payment.isSponsorship ? ' It goes into the sponsorship pool and helps someone attend who otherwise couldn’t.' : ''}
     </p>
 
     ${callout(`<strong style="font-size:15px">${fmtAmount(payment.amount)} donated</strong><br/>

backend/src/utils/pricing.js

@@ -346,6 +346,11 @@ function computeRegistrationSubtotal(registration, lastPaymentAt, atTime) {
  */
 function attachComputedTotals(registration) {
   if (!registration) return registration;
+  // Never send which named attendees have an account: the person who typed their email or
+  // phone mustn't be able to tell (the link is used server-side only).
+  if (Array.isArray(registration.attendees)) {
+    registration.attendees = registration.attendees.map(({ userId, ...a }) => a);
+  }
   let lastPaymentAt = null;
   try {
     if (registration.payments && Array.isArray(registration.payments) && registration.payments.length > 0) {

backend/src/utils/settingsCache.js

@@ -4,14 +4,14 @@
  * take effect without a server restart.
  * Falls back to environment variables when a key is not found in the DB.
  *
- * Encrypted keys (smtp_user, smtp_pass) are automatically decrypted on read.
+ * Encrypted keys (SMTP credentials, Yoco secrets) are automatically decrypted on read.
  */
 
 const prisma = require('../config/db');
 const { decrypt, isEncrypted } = require('./encryption');
 
 // Keys stored encrypted in the DB — decrypted transparently on read.
-const ENCRYPTED_KEYS = new Set(['smtp_user', 'smtp_pass']);
+const ENCRYPTED_KEYS = new Set(['smtp_user', 'smtp_pass', 'yoco_secret_key', 'yoco_webhook_secret']);
 
 let _cache = {};
 let _lastFetch = 0;

backend/src/utils/sponsorship.js

@@ -0,0 +1,72 @@
+/**
+ * Sponsor a spot — public donations into an event's bursary pool.
+ *
+ * A sponsorship is an ordinary event donation (isDonation) also flagged isSponsorship,
+ * so supervisors hand it out with the existing assign/unassign-donation flow. These
+ * helpers are pure: what one spot costs, what a sponsor is charged, and the pool totals.
+ */
+
+const { computeDonationRemaining } = require('./donationUtils');
+
+const MIN_AMOUNT = 15; // Yoco's minimum charge, same as other donations
+const MAX_SPOTS = 100;
+const MAX_AMOUNT = 100000;
+
+function sponsorshipError(message, statusCode = 400) {
+  const err = new Error(message);
+  err.statusCode = statusCode;
+  return err;
+}
+
+/** The price of one spot: the cheapest paid main ticket (or the event price), or null if free. */
+function spotPrice(event) {
+  const prices = (event.eventOptions || [])
+    .filter(o => o.isMainTicket && Number(o.price) > 0)
+    .map(o => Number(o.price));
+  if (prices.length) return Math.min(...prices);
+  return Number(event.price) > 0 ? Number(event.price) : null;
+}
+
+/**
+ * What the sponsor pays: `spots` whole spots, or a custom `amount`.
+ * @returns {{ amount: number, spots: number|null }}
+ */
+function sponsorshipCharge({ spots, amount }, price) {
+  if (spots !== undefined && spots !== null && spots !== '') {
+    const n = Number(spots);
+    if (!Number.isInteger(n) || n < 1 || n > MAX_SPOTS) throw sponsorshipError(`Choose between 1 and ${MAX_SPOTS} spots.`);
+    if (!price) throw sponsorshipError('This event has no ticket price — enter an amount instead.');
+    return { amount: Math.round(n * price * 100) / 100, spots: n };
+  }
+  const a = Math.round(Number(amount) * 100) / 100;
+  if (!Number.isFinite(a) || a <= 0) throw sponsorshipError('Enter an amount, or choose a number of spots.');
+  if (a < MIN_AMOUNT) throw sponsorshipError(`The minimum is R${MIN_AMOUNT}.`);
+  if (a > MAX_AMOUNT) throw sponsorshipError(`For gifts over R${MAX_AMOUNT.toLocaleString('en-ZA')}, please contact us directly.`);
+  return { amount: a, spots: null };
+}
+
+/**
+ * Pool totals for an event.
+ * @param {Array} sponsorships - sponsorship donation payments [{ id, amount }]
+ * @param {Array} legs         - payments with originalPaymentId set (assignments, refunds)
+ * @param {number|null} price  - one spot
+ */
+function poolSummary(sponsorships, legs, price) {
+  const legsBy = new Map();
+  for (const l of legs || []) legsBy.set(l.originalPaymentId, [...(legsBy.get(l.originalPaymentId) || []), l]);
+  let received = 0, remaining = 0;
+  for (const s of sponsorships || []) {
+    received += Number(s.amount) || 0;
+    remaining += Math.max(0, computeDonationRemaining(s.amount, legsBy.get(s.id) || []));
+  }
+  const round = (n) => Math.round(n * 100) / 100;
+  return {
+    received: round(received),
+    assigned: round(received - remaining),
+    remaining: round(remaining),
+    sponsors: (sponsorships || []).length,
+    spotsFunded: price ? Math.floor((received + 0.001) / price) : null,
+  };
+}
+
+module.exports = { MIN_AMOUNT, MAX_SPOTS, sponsorshipError, spotPrice, sponsorshipCharge, poolSummary };

backend/src/utils/ticketTransfer.js

@@ -1,6 +1,12 @@
 /**
  * Ticket transfer — handing a ticket to someone else before the event.
  *
+ * Privacy first: the sender only types the new holder's name and email/phone — there is
+ * no user search, and nothing tells the sender whether those details belong to an
+ * account. A TicketTransferRequest is created and a link is sent to the details typed;
+ * nothing changes on the ticket until the new holder accepts (requestTransfer →
+ * acceptTransfer). Accepting runs the transfer itself:
+ *
  * - The new holder becomes the ticket's attendee (name, contact details, account). The
  *   payer stays responsible for the registration; billing doesn't move.
  * - The QR code is replaced, so screenshots of the old ticket stop working. The old code
@@ -17,6 +23,13 @@ const { validateAttendees } = require('./attendees');
 const { isMinor } = require('./consent');
 
 const SUPERVISORS = ['admin', 'supervisor'];
+const OFFER_DAYS = 7;
+const crypto = require('crypto');
+const hashToken = (token) => crypto.createHmac('sha256', process.env.JWT_SECRET || '').update(`transfer:${token}`).digest('hex');
+function transferLink(token) {
+  const base = (process.env.FRONTEND_URL || process.env.APP_BASE_URL || 'http://localhost:3001').split(',')[0].trim().replace(/\/$/, '');
+  return `${base}/transfer/${token}`;
+}
 
 function transferError(message, statusCode = 400) {
   const err = new Error(message);
@@ -71,12 +84,12 @@ async function transferTicket({ ticketId, actor, ...holder }) {
 
   const { user: toUser, created } = await findOrCreateAccount({ name: clean.name, email: clean.email, phone: clean.phone });
   const currentHolderId = ticket.attendee ? ticket.attendee.userId || ticket.holderUserId : ticket.holderUserId || ticket.userId;
-  if (currentHolderId && currentHolderId === toUser.id) throw transferError(`${clean.name} already holds this ticket.`);
+  if (currentHolderId && currentHolderId === toUser.id) throw transferError('This ticket is already yours.');
 
   const fromHolderName = ticket.attendee?.name || ticket.holder?.name || ticket.user?.name || '';
   const attendeeData = {
     name: clean.name, email: clean.email, phone: clean.phone, userId: toUser.id,
-    dateOfBirth: clean.dateOfBirth, parentName: clean.parentName, parentEmail: clean.parentEmail, parentPhone: clean.parentPhone,
+    dateOfBirth: clean.dateOfBirth, gender: clean.gender, parentName: clean.parentName, parentEmail: clean.parentEmail, parentPhone: clean.parentPhone,
   };
 
   const result = await prisma.$transaction(async (tx) => {
@@ -126,6 +139,141 @@ async function transferTicket({ ticketId, actor, ...holder }) {
   };
 }
 
+/** Checks a transfer the way transferTicket will, without touching anything. */
+async function checkTransfer({ ticketId, actor, ...holder }) {
+  const ticket = await prisma.ticket.findUnique({
+    where: { id: ticketId },
+    include: {
+      usages: { select: { id: true } },
+      attendee: true, holder: { select: { name: true } }, user: { select: { name: true } },
+      event: { include: { eventOptions: true } },
+      registrationOption: { include: { eventOption: { select: { name: true } }, registration: { select: { id: true, status: true } } } },
+    },
+  });
+  if (!ticket) throw transferError('Ticket not found', 404);
+  const blocker = transferBlocker({ ...ticket, registrationStatus: ticket.registrationOption.registration.status }, actor);
+  if (blocker) throw transferError(blocker.message, blocker.status);
+  const ro = ticket.registrationOption;
+  const [clean] = validateAttendees({ ...ticket.event, allowNamedAttendees: true }, { [`${ro.eventOptionId}::${ro.variantId || ''}`]: 1 }, [{
+    eventOptionId: ro.eventOptionId, variantId: ro.variantId, ...holder,
+  }]);
+  if (!clean.email && !clean.phone) throw transferError('Enter an email address or phone number for the new holder, so we can send them the ticket.');
+  return { ticket, clean };
+}
+
+async function sendTransferOffer(request, ticket, token, fromName) {
+  const { sendMail, emailWrapper, ctaButton, fallbackLink } = require('./email');
+  const { waTextAny } = require('./notify');
+  const { isValidZAPhone } = require('./whatsapp');
+  const ff = `-apple-system,BlinkMacSystemFont,'Segoe UI',Roboto,Helvetica,Arial,sans-serif`;
+  const link = transferLink(token);
+  const event = ticket.event;
+  const when = new Date(event.startDate).toLocaleDateString('en-GB', { day: 'numeric', month: 'long', year: 'numeric' });
+  const subject = `${fromName} wants to give you a ticket for ${event.title}`;
+  const sent = [];
+  if (request.toEmail) {
+    const html = emailWrapper(`
+      <p style="font-size:22px;font-weight:800;color:#0f172a;margin:0 0 8px 0">You've been offered a ticket</p>
+      <p style="margin:0 0 8px 0;color:#374151;font-family:${ff}">Hi <strong>${request.toName}</strong>,</p>
+      <p style="margin:0 0 24px 0;color:#374151;font-family:${ff}">${fromName} would like to give you their ticket for <strong>${event.title}</strong> on <strong>${when}</strong>. Accept it to get your own ticket and QR code.</p>
+      ${ctaButton('View and accept the ticket', link)}
+      ${fallbackLink(link)}
+      <p style="font-size:13px;color:#64748b;margin:16px 0 0 0;font-family:${ff}">If you weren't expecting this, you can ignore this email or decline from the link.</p>
+    `, { preheader: subject });
+    try {
+      await sendMail({ to: request.toEmail, subject, html, text: `Hi ${request.toName},\n\n${fromName} would like to give you their ticket for ${event.title} on ${when}. View and accept it here: ${link}` });
+      sent.push('email');
+    } catch (e) {
+      console.warn('[transfer] offer email failed:', e?.message || e);
+    }
+  }
+  if (request.toPhone && isValidZAPhone(request.toPhone)) {
+    await waTextAny({ name: request.toName, phoneNumber: request.toPhone }, `Hi ${request.toName}, ${fromName} would like to give you their ticket for *${event.title}* on ${when}. View and accept it here: ${link}`);
+    sent.push('WhatsApp');
+  }
+  return sent;
+}
+
+/**
+ * Starts a transfer: checks it, then sends the new holder a link to accept. Nothing on
+ * the ticket changes yet, and no account is looked up.
+ */
+async function requestTransfer({ ticketId, actor, ...holder }) {
+  const { ticket, clean } = await checkTransfer({ ticketId, actor, ...holder });
+  const token = crypto.randomBytes(24).toString('hex');
+  const expiresAt = new Date(Math.min(new Date(ticket.event.startDate).getTime(), Date.now() + OFFER_DAYS * 864e5));
+  const request = await prisma.$transaction(async (tx) => {
+    // One open offer per ticket: a new one replaces the old.
+    await tx.ticketTransferRequest.updateMany({ where: { ticketId: ticket.id, status: 'pending' }, data: { status: 'cancelled', respondedAt: new Date() } });
+    return tx.ticketTransferRequest.create({
+      data: {
+        ticketId: ticket.id, requestedById: actor.id, toName: clean.name, toEmail: clean.email, toPhone: clean.phone,
+        details: { dateOfBirth: clean.dateOfBirth, gender: clean.gender, parentName: clean.parentName, parentEmail: clean.parentEmail, parentPhone: clean.parentPhone },
+        tokenHash: hashToken(token), expiresAt,
+      },
+    });
+  });
+  const fromName = ticket.attendee?.name || ticket.holder?.name || ticket.user?.name || actor.name || 'Someone';
+  const sent = await sendTransferOffer(request, ticket, token, fromName);
+  return { request, sent };
+}
+
+async function findRequestByToken(token) {
+  if (!token || typeof token !== 'string' || token.length > 200) return null;
+  const request = await prisma.ticketTransferRequest.findUnique({
+    where: { tokenHash: hashToken(token) },
+    include: {
+      requestedBy: { select: { id: true, name: true, role: true } },
+      ticket: { include: { event: { select: { id: true, title: true, startDate: true, location: true } }, registrationOption: { include: { eventOption: { select: { name: true } }, variant: { select: { name: true } } } }, attendee: { select: { name: true } }, user: { select: { name: true } } } },
+    },
+  });
+  if (request && request.status === 'pending' && request.expiresAt <= new Date()) {
+    await prisma.ticketTransferRequest.update({ where: { id: request.id }, data: { status: 'expired' } });
+    request.status = 'expired';
+  }
+  return request;
+}
+
+/** The new holder accepts: the transfer happens now, with every check run again. */
+async function acceptTransfer(token) {
+  const request = await findRequestByToken(token);
+  if (!request) throw transferError('This transfer link isn’t valid.', 404);
+  if (request.status !== 'pending') throw transferError(`This transfer has already been ${request.status}.`, 409);
+  // Claim it first so a double-click can't run the transfer twice.
+  const claimed = await prisma.ticketTransferRequest.updateMany({ where: { id: request.id, status: 'pending' }, data: { status: 'accepted', respondedAt: new Date() } });
+  if (claimed.count !== 1) throw transferError('This transfer has already been answered.', 409);
+  try {
+    const d = request.details || {};
+    const result = await transferTicket({
+      ticketId: request.ticketId, actor: request.requestedBy,
+      name: request.toName, email: request.toEmail, phone: request.toPhone,
+      dateOfBirth: d.dateOfBirth, gender: d.gender, parentName: d.parentName, parentEmail: d.parentEmail, parentPhone: d.parentPhone,
+    });
+    return { ...result, request };
+  } catch (e) {
+    // Couldn't go ahead (e.g. the ticket was scanned meanwhile): the offer is void.
+    await prisma.ticketTransferRequest.update({ where: { id: request.id }, data: { status: 'cancelled' } }).catch(() => {});
+    throw e;
+  }
+}
+
+async function declineTransfer(token) {
+  const request = await findRequestByToken(token);
+  if (!request) throw transferError('This transfer link isn’t valid.', 404);
+  if (request.status !== 'pending') throw transferError(`This transfer has already been ${request.status}.`, 409);
+  await prisma.ticketTransferRequest.update({ where: { id: request.id }, data: { status: 'declined', respondedAt: new Date() } });
+  return request;
+}
+
+/** The sender (or a supervisor) withdraws an offer that hasn't been accepted yet. */
+async function cancelTransfer(ticketId, actor) {
+  const ticket = await prisma.ticket.findUnique({ where: { id: ticketId }, select: { userId: true, holderUserId: true } });
+  if (!ticket) throw transferError('Ticket not found', 404);
+  if (!SUPERVISORS.includes(actor.role) && ticket.userId !== actor.id && ticket.holderUserId !== actor.id) throw transferError('Not authorized', 403);
+  const { count } = await prisma.ticketTransferRequest.updateMany({ where: { ticketId, status: 'pending' }, data: { status: 'cancelled', respondedAt: new Date() } });
+  if (!count) throw transferError('There is no transfer waiting for this ticket.', 404);
+}
+
 /** The transfer that retired this QR code, if any. */
 async function findTransferByOldCode(qrCode) {
   if (!qrCode) return null;
@@ -137,4 +285,7 @@ function transferredMessage(transfer) {
   return `This ticket was transferred to ${transfer.toName} on ${when}. The old QR code no longer works — ask for the new ticket.`;
 }
 
-module.exports = { transferError, transferBlocker, transferTicket, findTransferByOldCode, transferredMessage };
+module.exports = {
+  transferError, transferBlocker, transferTicket, findTransferByOldCode, transferredMessage,
+  checkTransfer, requestTransfer, findRequestByToken, acceptTransfer, declineTransfer, cancelTransfer,
+};

backend/src/utils/yoco.js

@@ -0,0 +1,134 @@
+/**
+ * Yoco configuration and API helpers.
+ *
+ * The secret key and webhook secret are stored AES-256-GCM encrypted in AppSetting
+ * (yoco_secret_key, yoco_webhook_secret) and managed from Admin → Site Settings → Yoco.
+ * YOCO_SECRET_KEY / YOCO_WEBHOOK_SECRET in .env are only used as fallbacks when the
+ * database has no value, so older deployments keep working until an admin saves them.
+ */
+
+const axios = require('axios');
+const prisma = require('../config/db');
+const { getSetting } = require('./settingsCache');
+
+const YOCO_API = 'https://payments.yoco.com/api';
+
+const KEY_SECRET  = 'yoco_secret_key';
+const KEY_WEBHOOK = 'yoco_webhook_secret';
+const KEY_WEBHOOK_ID = 'yoco_webhook_id';
+
+const getYocoSecretKey     = () => getSetting(KEY_SECRET, process.env.YOCO_SECRET_KEY);
+const getYocoWebhookSecret = () => getSetting(KEY_WEBHOOK, process.env.YOCO_WEBHOOK_SECRET);
+
+/** Where each value currently comes from: 'db' | 'env' | 'none'. */
+async function getYocoConfigSource() {
+  const rows = await prisma.appSetting.findMany({ where: { key: { in: [KEY_SECRET, KEY_WEBHOOK] } } });
+  const inDb = new Set(rows.filter(r => r.value).map(r => r.key));
+  const source = (key, envVar) => (inDb.has(key) ? 'db' : process.env[envVar] ? 'env' : 'none');
+  return {
+    secretKey:     source(KEY_SECRET, 'YOCO_SECRET_KEY'),
+    webhookSecret: source(KEY_WEBHOOK, 'YOCO_WEBHOOK_SECRET'),
+  };
+}
+
+const KNOWN_PREFIXES = ['sk_test_', 'sk_live_', 'whsec_'];
+
+/**
+ * Mask a secret like a card number: keep the prefix and the last 3 characters.
+ * maskSecret('sk_test_abcdefghijklmnaba') → 'sk_test_**************aba'
+ */
+function maskSecret(value) {
+  if (!value) return '';
+  const prefix = KNOWN_PREFIXES.find(p => value.startsWith(p)) || value.slice(0, 4);
+  const rest = value.slice(prefix.length);
+  if (rest.length <= 6) return prefix + '*'.repeat(rest.length);
+  return prefix + '*'.repeat(rest.length - 3) + rest.slice(-3);
+}
+
+function yocoMode(key) {
+  if (!key) return 'unknown';
+  if (key.startsWith('sk_test_')) return 'test';
+  if (key.startsWith('sk_live_')) return 'live';
+  return 'unknown';
+}
+
+function notConfiguredError() {
+  const err = new Error('Online payments are not configured. An admin needs to add the Yoco secret key in Site Settings → Yoco.');
+  err.statusCode = 503;
+  return err;
+}
+
+/** `Bearer <key>` for Yoco API calls; throws a 503-style error when no key is set. */
+async function yocoAuthHeader() {
+  const key = await getYocoSecretKey();
+  if (!key) throw notConfiguredError();
+  return `Bearer ${key}`;
+}
+
+/** Turn a Yoco API error into a message an admin can act on. */
+function friendlyYocoError(e) {
+  const status = e.response?.status;
+  const detail = e.response?.data?.message || e.response?.data?.description || e.response?.data?.errorMessage;
+  let message;
+  if (status === 401) message = 'Yoco rejected the secret key. Check that it was copied correctly.';
+  else if (status === 403) message = 'This Yoco account is not allowed to manage webhooks.';
+  else if (status === 400) message = `Yoco rejected the request${detail ? `: ${detail}` : '.'}`;
+  else if (status) message = `Yoco returned an error (${status})${detail ? `: ${detail}` : '.'}`;
+  else message = e.message || 'Could not reach Yoco.';
+  const err = new Error(message);
+  err.statusCode = e.statusCode || (status === 401 || status === 403 || status === 400 ? 400 : 502);
+  return err;
+}
+
+/** Call the Yoco API. `key` overrides the stored key (used to verify a key before saving it). */
+async function yocoRequest(method, path, body, key) {
+  const auth = key ? `Bearer ${key}` : await yocoAuthHeader();
+  try {
+    const res = await axios({
+      method,
+      url: `${YOCO_API}${path}`,
+      data: body,
+      headers: { 'Content-Type': 'application/json', Authorization: auth },
+      timeout: 15000,
+    });
+    return res.data;
+  } catch (e) {
+    throw friendlyYocoError(e);
+  }
+}
+
+async function listWebhooks(key) {
+  const data = await yocoRequest('get', '/webhooks', undefined, key);
+  return data?.subscriptions || [];
+}
+
+const registerWebhook = (name, url) => yocoRequest('post', '/webhooks', { name, url });
+const deleteWebhook   = (id) => yocoRequest('delete', `/webhooks/${encodeURIComponent(id)}`);
+
+/**
+ * The URL Yoco should post events to: BACKEND_URL, or the public origin of the
+ * current request (correct behind a proxy when TRUST_PROXY is set).
+ */
+function defaultWebhookUrl(req) {
+  const base = (process.env.BACKEND_URL || (req ? `${req.protocol}://${req.get('host')}` : '')).replace(/\/$/, '');
+  return base ? `${base}/api/webhooks/yoco` : '';
+}
+
+/** Returns an error message if Yoco won't be able to reach the URL, otherwise null. */
+function webhookUrlProblem(url) {
+  let u;
+  try { u = new URL(url); } catch { return 'Enter a full webhook URL, e.g. https://api.example.com/api/webhooks/yoco'; }
+  if (u.protocol !== 'https:') return 'The webhook URL must use https:// so Yoco can reach it.';
+  if (['localhost', '127.0.0.1', '::1', '[::1]'].includes(u.hostname)) {
+    return 'The webhook URL must be a public address, not localhost.';
+  }
+  return null;
+}
+
+module.exports = {
+  KEY_SECRET, KEY_WEBHOOK, KEY_WEBHOOK_ID,
+  getYocoSecretKey, getYocoWebhookSecret, getYocoConfigSource,
+  maskSecret, yocoMode, yocoAuthHeader,
+  yocoRequest, listWebhooks, registerWebhook, deleteWebhook,
+  defaultWebhookUrl, webhookUrlProblem,
+};

backend/tests/allocation.test.js

@@ -0,0 +1,84 @@
+const { joinBlocker, autoAllocate, cleanGender } = require('../src/utils/allocation');
+
+const person = (id, registrationId, gender = null) => ({ id, name: id, registrationId, gender });
+const groupsOf = (result) => {
+  const out = {};
+  for (const p of result.placements) (out[p.groupId] = out[p.groupId] || []).push(p.attendeeId);
+  return out;
+};
+
+describe('cleanGender', () => {
+  test('accepts male/female in any case, blank as null', () => {
+    expect(cleanGender('Male')).toBe('male');
+    expect(cleanGender('')).toBeNull();
+    expect(() => cleanGender('other')).toThrow();
+  });
+});
+
+describe('joinBlocker', () => {
+  test('capacity', () => {
+    expect(joinBlocker({ name: 'Cabin 1', capacity: 2 }, 1, [person('a', 'r')])).toBeNull();
+    expect(joinBlocker({ name: 'Cabin 1', capacity: 2 }, 2, [person('a', 'r')])).toMatch(/full/);
+  });
+
+  test('gender', () => {
+    expect(joinBlocker({ name: 'Boys', gender: 'male' }, 0, [person('a', 'r', 'male')])).toBeNull();
+    expect(joinBlocker({ name: 'Boys', gender: 'male' }, 0, [person('a', 'r', 'female')])).toMatch(/males only/);
+    expect(joinBlocker({ name: 'Boys', gender: 'male' }, 0, [person('a', 'r')])).toMatch(/no gender recorded/);
+  });
+});
+
+describe('autoAllocate', () => {
+  test('fills groups evenly', () => {
+    const groups = [{ id: 'g1', name: 'A' }, { id: 'g2', name: 'B' }];
+    const attendees = ['a', 'b', 'c', 'd'].map(id => person(id, id));
+    const r = autoAllocate({ groups, attendees });
+    const g = groupsOf(r);
+    expect(g.g1.length).toBe(2);
+    expect(g.g2.length).toBe(2);
+    expect(r.unplaced).toEqual([]);
+  });
+
+  test('respects capacity and reports who could not be placed', () => {
+    const groups = [{ id: 'g1', name: 'A', capacity: 1 }];
+    const r = autoAllocate({ groups, attendees: [person('a', 'r1'), person('b', 'r2')] });
+    expect(r.placements.length).toBe(1);
+    expect(r.unplaced.length).toBe(1);
+  });
+
+  test('respects gender', () => {
+    const groups = [{ id: 'boys', name: 'Boys', gender: 'male' }, { id: 'girls', name: 'Girls', gender: 'female' }];
+    const r = autoAllocate({ groups, attendees: [person('a', 'r1', 'male'), person('b', 'r2', 'female'), person('c', 'r3')] });
+    expect(groupsOf(r)).toEqual({ boys: ['a'], girls: ['b'] });
+    expect(r.unplaced).toEqual(['c']);
+  });
+
+  test('keeps a registration together when a group can take them all', () => {
+    const groups = [{ id: 'g1', name: 'A', capacity: 3 }, { id: 'g2', name: 'B', capacity: 3 }];
+    const attendees = [person('s1', 'fam'), person('s2', 'fam'), person('x', 'solo')];
+    const g = groupsOf(autoAllocate({ groups, attendees, mode: 'together' }));
+    const famGroup = Object.keys(g).find(k => g[k].includes('s1'));
+    expect(g[famGroup]).toContain('s2');
+  });
+
+  test('places siblings one by one when no group fits them all', () => {
+    const groups = [{ id: 'boys', name: 'Boys', gender: 'male' }, { id: 'girls', name: 'Girls', gender: 'female' }];
+    const r = autoAllocate({ groups, attendees: [person('bro', 'fam', 'male'), person('sis', 'fam', 'female')], mode: 'together' });
+    expect(groupsOf(r)).toEqual({ boys: ['bro'], girls: ['sis'] });
+  });
+
+  test('split mode spreads a registration across groups', () => {
+    const groups = [{ id: 'g1', name: 'A' }, { id: 'g2', name: 'B' }];
+    const attendees = [person('f1', 'friends'), person('f2', 'friends')];
+    const g = groupsOf(autoAllocate({ groups, attendees, mode: 'split' }));
+    expect(g.g1.length).toBe(1);
+    expect(g.g2.length).toBe(1);
+  });
+
+  test('counts people already placed and leaves them where they are', () => {
+    const groups = [{ id: 'g1', name: 'A', capacity: 2 }, { id: 'g2', name: 'B', capacity: 2 }];
+    const attendees = [person('a', 'r1'), person('b', 'r2'), person('c', 'r3')];
+    const r = autoAllocate({ groups, attendees, assigned: new Map([['a', 'g1'], ['b', 'g1']]) });
+    expect(r.placements).toEqual([{ attendeeId: 'c', groupId: 'g2' }]);
+  });
+});

backend/tests/analytics.test.js

@@ -0,0 +1,70 @@
+const { deviceFromUA, cleanSource, sessionsFrom, rollupRows, funnelReport } = require('../src/utils/analytics');
+
+const ev = (sessionId, stage, day, extra = {}) => ({ sessionId, stage, createdAt: `${day}T10:00:00Z`, ...extra });
+
+describe('deviceFromUA', () => {
+  test('mobile, tablet, desktop and bots', () => {
+    expect(deviceFromUA('Mozilla/5.0 (iPhone; CPU iPhone OS 17_0) Mobile/15E148')).toBe('mobile');
+    expect(deviceFromUA('Mozilla/5.0 (Linux; Android 14; SM-X200) Safari')).toBe('tablet');
+    expect(deviceFromUA('Mozilla/5.0 (Windows NT 10.0; Win64; x64) Chrome/120')).toBe('desktop');
+    expect(deviceFromUA('Googlebot/2.1')).toBeNull();
+    expect(deviceFromUA('')).toBeNull();
+  });
+});
+
+describe('cleanSource', () => {
+  test('tidies, defaulting to direct', () => {
+    expect(cleanSource(' Facebook ')).toBe('facebook');
+    expect(cleanSource('camp-2025<script>')).toBe('camp-2025script');
+    expect(cleanSource('')).toBe('direct');
+  });
+});
+
+describe('sessionsFrom', () => {
+  test('a session counts as having reached every earlier stage', () => {
+    const [s] = sessionsFrom([ev('a', 'start', '2026-01-02')]);
+    expect(s.reach).toBe(1);
+    expect(s.days.view).toBe('2026-01-02');
+  });
+
+  test('paid only counts for sessions that submitted', () => {
+    const out = sessionsFrom([ev('a', 'view', '2026-01-01', { source: 'fb', device: 'mobile' }), ev('a', 'submit', '2026-01-03'), ev('b', 'view', '2026-01-01')], new Set(['a', 'b']));
+    const a = out.find(s => s.sessionId === 'a');
+    expect(a.reach).toBe(3);
+    expect(a.days.paid).toBe('2026-01-03');
+    expect(a.source).toBe('fb');
+    expect(out.find(s => s.sessionId === 'b').reach).toBe(0);
+  });
+});
+
+describe('funnelReport', () => {
+  const sessions = sessionsFrom([
+    ev('a', 'view', '2026-01-01', { source: 'fb', device: 'mobile' }), ev('a', 'start', '2026-01-01'), ev('a', 'submit', '2026-01-01'),
+    ev('b', 'view', '2026-01-01', { source: 'fb', device: 'desktop' }), ev('b', 'start', '2026-01-02'),
+    ev('c', 'view', '2026-01-02', { device: 'mobile' }),
+    ev('d', 'view', '2026-01-02', { device: 'mobile' }),
+  ], new Set(['a']));
+
+  test('counts and conversion per stage', () => {
+    const r = funnelReport(sessions);
+    expect(r.totals).toEqual({ view: 4, start: 2, submit: 1, paid: 1 });
+    expect(r.conversion.start).toBe(50);
+    expect(r.conversion.paid).toBe(25);
+    expect(r.conversion.startToSubmit).toBe(50);
+  });
+
+  test('daily trend and breakdowns', () => {
+    const r = funnelReport(sessions);
+    expect(r.trend).toEqual([{ day: '2026-01-01', view: 2, start: 1, submit: 1, paid: 1 }, { day: '2026-01-02', view: 2, start: 1, submit: 0, paid: 0 }]);
+    expect(r.bySource.find(s => s.key === 'fb')).toMatchObject({ view: 2, paid: 1, conversion: 50 });
+    expect(r.bySource.find(s => s.key === 'direct').view).toBe(2);
+    expect(r.byDevice.find(s => s.key === 'mobile').view).toBe(3);
+  });
+
+  test('rolled-up rows add to the raw counts', () => {
+    const daily = rollupRows(sessionsFrom([ev('x', 'view', '2025-10-01'), ev('x', 'submit', '2025-10-01')], new Set(['x'])));
+    expect(daily.find(r => r.stage === 'paid').sessions).toBe(1);
+    const r = funnelReport(sessions, daily);
+    expect(r.totals).toEqual({ view: 5, start: 3, submit: 2, paid: 2 });
+  });
+});

backend/tests/feedback.test.js

@@ -0,0 +1,68 @@
+const { cleanFields, cleanAnswer, summarise } = require('../src/utils/feedback');
+
+describe('cleanFields', () => {
+  test('keeps labelled questions in order, tidying choices', () => {
+    const out = cleanFields([
+      { type: 'rating', label: ' Overall ', isRequired: true },
+      { type: 'text', label: '' },
+      { type: 'multiple_choice', label: 'Best part', options: ['Worship', ' Talks ', 'Worship', ''] },
+      { type: 'statement', label: 'Thanks!', isRequired: true },
+    ]);
+    expect(out.map(f => [f.type, f.label, f.order])).toEqual([['rating', 'Overall', 0], ['multiple_choice', 'Best part', 1], ['statement', 'Thanks!', 2]]);
+    expect(out[1].options).toEqual(['Worship', 'Talks']);
+    expect(out[2].isRequired).toBe(false);
+  });
+
+  test('rejects bad forms', () => {
+    expect(() => cleanFields([{ type: 'stars', label: 'X' }])).toThrow(/unknown type/);
+    expect(() => cleanFields([{ type: 'multiple_choice', label: 'X', options: ['only one'] }])).toThrow(/two choices/);
+    expect(() => cleanFields([{ type: 'statement', label: 'Hello' }])).toThrow(/at least one question/);
+  });
+});
+
+describe('cleanAnswer', () => {
+  test('ratings are whole stars from 1 to 5', () => {
+    expect(cleanAnswer({ type: 'rating', label: 'R' }, '4')).toBe('4');
+    expect(() => cleanAnswer({ type: 'rating', label: 'R' }, '6')).toThrow();
+    expect(() => cleanAnswer({ type: 'rating', label: 'R' }, '3.5')).toThrow();
+  });
+
+  test('multiple choice must be one of the options', () => {
+    const f = { type: 'multiple_choice', label: 'M', options: ['A', 'B'] };
+    expect(cleanAnswer(f, 'B')).toBe('B');
+    expect(() => cleanAnswer(f, 'C')).toThrow();
+  });
+
+  test('required questions need an answer; optional ones may be blank', () => {
+    expect(() => cleanAnswer({ type: 'text', label: 'Why?', isRequired: true }, ' ')).toThrow(/Please answer/);
+    expect(cleanAnswer({ type: 'text', label: 'Why?' }, '')).toBeNull();
+    expect(cleanAnswer({ type: 'yes_no', label: 'Again?' }, 'YES')).toBe('yes');
+  });
+});
+
+describe('summarise', () => {
+  const fields = [
+    { id: 'r', type: 'rating', label: 'Overall' },
+    { id: 'm', type: 'multiple_choice', label: 'Best part', options: ['Worship', 'Talks'] },
+    { id: 't', type: 'text', label: 'Comments' },
+    { id: 's', type: 'statement', label: 'Thanks' },
+  ];
+  const answers = [
+    { fieldId: 'r', value: '5' }, { fieldId: 'r', value: '4' }, { fieldId: 'r', value: '4' },
+    { fieldId: 'm', value: 'Talks' }, { fieldId: 'm', value: 'Talks' }, { fieldId: 'm', value: 'Worship' },
+    { fieldId: 't', value: 'Loved it', name: 'Ann' },
+  ];
+
+  test('averages ratings with a star distribution', () => {
+    const [r] = summarise(fields, answers);
+    expect(r.average).toBe(4.3);
+    expect(r.distribution.map(d => d.value)).toEqual([0, 0, 0, 2, 1]);
+  });
+
+  test('counts choices and lists text answers; skips statements', () => {
+    const out = summarise(fields, answers);
+    expect(out.length).toBe(3);
+    expect(out[1].counts).toEqual([{ label: 'Worship', value: 1 }, { label: 'Talks', value: 2 }]);
+    expect(out[2].texts).toEqual([{ value: 'Loved it', name: 'Ann' }]);
+  });
+});

backend/tests/impersonation.test.js

@@ -0,0 +1,43 @@
+const { allowedWhileImpersonating, impersonationBlocker } = require('../src/utils/impersonation');
+
+describe('allowedWhileImpersonating', () => {
+  test('reads are allowed', () => {
+    expect(allowedWhileImpersonating('GET', '/api/registrations/myregistrations')).toBe(true);
+    expect(allowedWhileImpersonating('HEAD', '/api/events')).toBe(true);
+    expect(allowedWhileImpersonating('OPTIONS', '/api/payments')).toBe(true);
+  });
+
+  test('every write is refused', () => {
+    for (const m of ['POST', 'PUT', 'PATCH', 'DELETE']) {
+      expect(allowedWhileImpersonating(m, '/api/registrations')).toBe(false);
+      expect(allowedWhileImpersonating(m, '/api/payments/yoco-checkout')).toBe(false);
+      expect(allowedWhileImpersonating(m, '/api/users/profile')).toBe(false);
+    }
+  });
+
+  test('except ending the session and logging page views', () => {
+    expect(allowedWhileImpersonating('POST', '/api/admin/impersonate/end')).toBe(true);
+    expect(allowedWhileImpersonating('POST', '/api/admin/impersonate/log?x=1')).toBe(true);
+    expect(allowedWhileImpersonating('DELETE', '/api/admin/impersonate/end')).toBe(false);
+    expect(allowedWhileImpersonating('POST', '/api/admin/impersonate/end/../../users')).toBe(false);
+  });
+});
+
+describe('impersonationBlocker', () => {
+  const admin = { id: 'a', role: 'admin', twoFactorEnabled: true };
+  const user = { id: 'u', role: 'user', isActive: true };
+
+  test('an admin with 2FA can view a user', () => {
+    expect(impersonationBlocker(admin, user)).toBeNull();
+    expect(impersonationBlocker(admin, { ...user, role: 'supervisor' })).toBeNull();
+  });
+
+  test('refusals', () => {
+    expect(impersonationBlocker({ ...admin, role: 'supervisor' }, user)).toMatch(/Only admins/);
+    expect(impersonationBlocker({ ...admin, twoFactorEnabled: false }, user)).toMatch(/two-factor/);
+    expect(impersonationBlocker(admin, { ...user, role: 'admin' })).toMatch(/Admins can't/);
+    expect(impersonationBlocker(admin, { ...admin })).toMatch(/yourself/);
+    expect(impersonationBlocker(admin, { ...user, isActive: false })).toMatch(/deactivated/);
+    expect(impersonationBlocker(admin, null)).toMatch(/not found/);
+  });
+});

backend/tests/sponsorship.test.js

@@ -0,0 +1,44 @@
+const { spotPrice, sponsorshipCharge, poolSummary } = require('../src/utils/sponsorship');
+
+describe('spotPrice', () => {
+  test('is the cheapest paid main ticket', () => {
+    expect(spotPrice({ price: 0, eventOptions: [
+      { isMainTicket: true, price: 450 }, { isMainTicket: true, price: 300 }, { isMainTicket: false, price: 50 }, { isMainTicket: true, price: 0 },
+    ] })).toBe(300);
+  });
+
+  test('falls back to the event price, or null for free events', () => {
+    expect(spotPrice({ price: 200, eventOptions: [] })).toBe(200);
+    expect(spotPrice({ price: 0, eventOptions: [{ isMainTicket: true, price: 0 }] })).toBeNull();
+  });
+});
+
+describe('sponsorshipCharge', () => {
+  test('whole spots cost the spot price each', () => {
+    expect(sponsorshipCharge({ spots: 3 }, 450)).toEqual({ amount: 1350, spots: 3 });
+  });
+
+  test('a custom amount is taken as given (2 decimals)', () => {
+    expect(sponsorshipCharge({ amount: '120.555' }, 450)).toEqual({ amount: 120.56, spots: null });
+  });
+
+  test('rejects bad input', () => {
+    expect(() => sponsorshipCharge({ spots: 0 }, 450)).toThrow(/between 1/);
+    expect(() => sponsorshipCharge({ spots: 1.5 }, 450)).toThrow();
+    expect(() => sponsorshipCharge({ spots: 1 }, null)).toThrow(/no ticket price/);
+    expect(() => sponsorshipCharge({ amount: 10 }, 450)).toThrow(/minimum/);
+    expect(() => sponsorshipCharge({}, 450)).toThrow();
+  });
+});
+
+describe('poolSummary', () => {
+  test('received, assigned and remaining, with spots funded', () => {
+    const sponsorships = [{ id: 'a', amount: 900 }, { id: 'b', amount: 300 }];
+    const legs = [{ originalPaymentId: 'a', amount: 450 }, { originalPaymentId: 'b', amount: -100 }];
+    expect(poolSummary(sponsorships, legs, 450)).toEqual({ received: 1200, assigned: 550, remaining: 650, sponsors: 2, spotsFunded: 2 });
+  });
+
+  test('no spot count for free events', () => {
+    expect(poolSummary([{ id: 'a', amount: 50 }], [], null).spotsFunded).toBeNull();
+  });
+});

backend/tests/yoco.test.js

@@ -0,0 +1,99 @@
+jest.mock('../src/config/db', () => ({
+  appSetting: { findMany: jest.fn() },
+}));
+
+const prisma = require('../src/config/db');
+const { encrypt } = require('../src/utils/encryption');
+const settingsCache = require('../src/utils/settingsCache');
+const {
+  maskSecret, yocoMode, getYocoSecretKey, getYocoWebhookSecret, yocoAuthHeader,
+  defaultWebhookUrl, webhookUrlProblem,
+} = require('../src/utils/yoco');
+
+const ENV = { ...process.env };
+afterEach(() => { process.env = { ...ENV }; });
+
+function dbHas(rows) {
+  prisma.appSetting.findMany.mockResolvedValue(rows);
+  settingsCache.invalidate();
+}
+
+describe('maskSecret', () => {
+  test('keeps the prefix and the last 3 characters', () => {
+    expect(maskSecret('sk_test_0123456789abcdefaba')).toBe('sk_test_****************aba');
+    expect(maskSecret('sk_live_0123456789xyz')).toBe('sk_live_**********xyz');
+    expect(maskSecret('whsec_MfKQ9r8GKYqrTwjUPD8ILPZIo2LaLaSw')).toBe(`whsec_${'*'.repeat(29)}aSw`);
+  });
+
+  test('masks the length exactly, like a card number', () => {
+    const v = 'sk_test_0123456789abcdefaba';
+    expect(maskSecret(v)).toHaveLength(v.length);
+  });
+
+  test('short values show nothing after the prefix', () => {
+    expect(maskSecret('sk_test_abc')).toBe('sk_test_***');
+    expect(maskSecret('whsec_')).toBe('whsec_');
+  });
+
+  test('unknown formats keep the first 4 characters', () => {
+    expect(maskSecret('abcd0123456789')).toBe('abcd*******789');
+  });
+
+  test('empty stays empty', () => {
+    expect(maskSecret('')).toBe('');
+    expect(maskSecret(undefined)).toBe('');
+  });
+});
+
+test('yocoMode reads the key prefix', () => {
+  expect(yocoMode('sk_test_x')).toBe('test');
+  expect(yocoMode('sk_live_x')).toBe('live');
+  expect(yocoMode('pk_test_x')).toBe('unknown');
+  expect(yocoMode('')).toBe('unknown');
+});
+
+describe('stored secrets', () => {
+  test('the database wins over .env, and is decrypted', async () => {
+    process.env.YOCO_SECRET_KEY = 'sk_test_fromenv';
+    dbHas([{ key: 'yoco_secret_key', value: encrypt('sk_test_fromdb') }]);
+    expect(await getYocoSecretKey()).toBe('sk_test_fromdb');
+  });
+
+  test('.env is the fallback when the database has no value', async () => {
+    process.env.YOCO_WEBHOOK_SECRET = 'whsec_ZW52';
+    dbHas([{ key: 'yoco_webhook_secret', value: '' }]);
+    expect(await getYocoWebhookSecret()).toBe('whsec_ZW52');
+  });
+
+  test('checkouts fail clearly when no key is configured', async () => {
+    delete process.env.YOCO_SECRET_KEY;
+    dbHas([]);
+    await expect(yocoAuthHeader()).rejects.toThrow(/not configured/);
+  });
+
+  test('the auth header uses the stored key', async () => {
+    dbHas([{ key: 'yoco_secret_key', value: encrypt('sk_live_abc') }]);
+    expect(await yocoAuthHeader()).toBe('Bearer sk_live_abc');
+  });
+});
+
+describe('webhook URL', () => {
+  const req = { protocol: 'https', get: () => 'events-demo-api.crosscode.co.za' };
+
+  test('built from BACKEND_URL', () => {
+    process.env.BACKEND_URL = 'https://api.example.com/';
+    expect(defaultWebhookUrl(req)).toBe('https://api.example.com/api/webhooks/yoco');
+  });
+
+  test('falls back to the request origin', () => {
+    delete process.env.BACKEND_URL;
+    expect(defaultWebhookUrl(req)).toBe('https://events-demo-api.crosscode.co.za/api/webhooks/yoco');
+  });
+
+  test('must be public https', () => {
+    expect(webhookUrlProblem('https://api.example.com/api/webhooks/yoco')).toBeNull();
+    expect(webhookUrlProblem('http://api.example.com/api/webhooks/yoco')).toMatch(/https/);
+    expect(webhookUrlProblem('https://localhost:5000/api/webhooks/yoco')).toMatch(/localhost/);
+    expect(webhookUrlProblem('not a url')).toMatch(/full webhook URL/);
+  });
+});

frontend/next.config.ts

@@ -5,9 +5,6 @@ const nextConfig: NextConfig = {
   images: {
     domains: ['images.unsplash.com'],
   },
-  eslint: {
-    ignoreDuringBuilds: true,
-  },
   compiler: {
     removeConsole: process.env.NODE_ENV === 'production',
   },

frontend/package-lock.json

@@ -1,13 +1,14 @@
 {
   "name": "hope-events-frontend",
-  "version": "1.18.0",
+  "version": "1.26.0",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
       "name": "hope-events-frontend",
-      "version": "1.18.0",
+      "version": "1.26.0",
       "dependencies": {
+        "@dnd-kit/core": "^6.3.1",
         "@hookform/resolvers": "^5.2.1",
         "@radix-ui/react-accordion": "^1.2.11",
         "@radix-ui/react-alert-dialog": "^1.1.14",
@@ -343,6 +344,45 @@
       "integrity": "sha512-lwYN/vDPeNRULcepoE/LO2Pgx+7/RV+S9ARfbc9lr2DtGkOD7pAiruHvbR1RX3Qyf6ja47EWJDMsNK5vK08DJg==",
       "license": "MIT"
     },
+    "node_modules/@dnd-kit/accessibility": {
+      "version": "3.1.1",
+      "resolved": "https://registry.npmjs.org/@dnd-kit/accessibility/-/accessibility-3.1.1.tgz",
+      "integrity": "sha512-2P+YgaXF+gRsIihwwY1gCsQSYnu9Zyj2py8kY5fFvUM1qm2WA2u639R6YNVfU4GWr+ZM5mqEsfHZZLoRONbemw==",
+      "license": "MIT",
+      "dependencies": {
+        "tslib": "^2.0.0"
+      },
+      "peerDependencies": {
+        "react": ">=16.8.0"
+      }
+    },
+    "node_modules/@dnd-kit/core": {
+      "version": "6.3.1",
+      "resolved": "https://registry.npmjs.org/@dnd-kit/core/-/core-6.3.1.tgz",
+      "integrity": "sha512-xkGBRQQab4RLwgXxoqETICr6S5JlogafbhNsidmrkVv2YRs5MLwpjoF2qpiGjQt8S9AoxtIV603s0GIUpY5eYQ==",
+      "license": "MIT",
+      "dependencies": {
+        "@dnd-kit/accessibility": "^3.1.1",
+        "@dnd-kit/utilities": "^3.2.2",
+        "tslib": "^2.0.0"
+      },
+      "peerDependencies": {
+        "react": ">=16.8.0",
+        "react-dom": ">=16.8.0"
+      }
+    },
+    "node_modules/@dnd-kit/utilities": {
+      "version": "3.2.2",
+      "resolved": "https://registry.npmjs.org/@dnd-kit/utilities/-/utilities-3.2.2.tgz",
+      "integrity": "sha512-+MKAJEOfaBe5SmV6t34p80MMKhjvUz0vRrvVJbPT0WElzaOJ/1xs+D+KDv+tD/NE5ujfrChEcshd4fLn0wpiqg==",
+      "license": "MIT",
+      "dependencies": {
+        "tslib": "^2.0.0"
+      },
+      "peerDependencies": {
+        "react": ">=16.8.0"
+      }
+    },
     "node_modules/@emnapi/core": {
       "version": "1.10.0",
       "resolved": "https://registry.npmjs.org/@emnapi/core/-/core-1.10.0.tgz",
@@ -8438,9 +8478,9 @@
       }
     },
     "node_modules/postcss-selector-parser": {
-      "version": "6.1.4",
-      "resolved": "https://registry.npmjs.org/postcss-selector-parser/-/postcss-selector-parser-6.1.4.tgz",
-      "integrity": "sha512-bIoJLOmjCO1S9XdY/DcnR5hJxvrDir1PbGChrzXG3vw0/FOliy/fA3dmdhQ441kah4gKv+TwckGzex6wNS5cnQ==",
+      "version": "7.1.7",
+      "resolved": "https://registry.npmjs.org/postcss-selector-parser/-/postcss-selector-parser-7.1.7.tgz",
+      "integrity": "sha512-wWBro/7hJ40ye6TPiXkUQoXKCw23xSsjriUvqd7Uls9Sso3oLiON1flc18cCdnjgCRXw4fBVqUJJeOdDTh3P3g==",
       "license": "MIT",
       "dependencies": {
         "cssesc": "^3.0.0",

frontend/package.json

@@ -1,6 +1,6 @@
 {
   "name": "hope-events-frontend",
-  "version": "1.18.0",
+  "version": "1.26.0",
   "private": true,
   "scripts": {
     "dev": "next dev --turbopack",
@@ -9,6 +9,7 @@
     "lint": "next lint"
   },
   "dependencies": {
+    "@dnd-kit/core": "^6.3.1",
     "@hookform/resolvers": "^5.2.1",
     "@radix-ui/react-accordion": "^1.2.11",
     "@radix-ui/react-alert-dialog": "^1.1.14",
@@ -61,7 +62,8 @@
   "overrides": {
     "next": {
       "postcss": "^8.5.23"
-    }
+    },
+    "postcss-selector-parser": "^7.1.7"
   },
   "allowScripts": {
     "@sentry/cli@2.58.6": true,

frontend/src/app/(auth)/forgot-password/page.tsx

@@ -4,6 +4,7 @@ import { Navbar } from "@/components/layout/Navbar";
 import { Footer } from "@/components/layout/Footer";
 import { apiFetch } from "@/lib/api";
 import { KeyRound } from "lucide-react";
+import { errorMessage } from "@/lib/utils";
 
 export default function ForgotPasswordPage() {
     const [email, setEmail] = useState("");
@@ -16,14 +17,14 @@ export default function ForgotPasswordPage() {
         try {
             setLoading(true);
             setStatus(null);
-            const res: any = await apiFetch("/api/users/forgot", { method: "POST", body: { email } });
+            const res = await apiFetch<{ message?: string }>("/api/users/forgot", { method: "POST", body: { email } });
             setStatus(res?.message || "If that email exists, a password reset link has been sent.");
-        } catch (err: any) {
+        } catch (err) {
             try {
-                const parsed = JSON.parse(err?.message || "");
+                const parsed = JSON.parse(errorMessage(err) || "");
                 setStatus(parsed?.message || "Something went wrong");
             } catch {
-                setStatus(err?.message || "Something went wrong");
+                setStatus(errorMessage(err) || "Something went wrong");
             }
         } finally {
             setLoading(false);
@@ -41,7 +42,7 @@ export default function ForgotPasswordPage() {
                         </div>
                         <h1 className="text-xl font-semibold text-gray-900">Forgot your password?</h1>
                     </div>
-                    <p className="text-gray-600 text-sm mb-6">Enter your account email and we'll send you a link to reset your password.</p>
+                    <p className="text-gray-600 text-sm mb-6">Enter your account email and we&apos;ll send you a link to reset your password.</p>
                     <form onSubmit={submit} className="space-y-4">
                         <div>
                             <label className="block text-sm font-medium mb-1">Email</label>

frontend/src/app/[redirectUrl]/page.tsx

@@ -1,5 +1,7 @@
+import Link from "next/link";
 import { redirect } from "next/navigation";
 import { apiFetch } from "@/lib/api";
+import type { Event } from "@/types";
 
 export const revalidate = 60;
 
@@ -14,11 +16,11 @@ const VALID_ALIAS = /^[a-zA-Z0-9_-]{1,100}$/;
 export default async function EventRedirectPage({ params }: { params: Promise<{ redirectUrl: string }> }) {
     const { redirectUrl } = await params;
 
-    let event: any = null;
+    let event: (Event & { message?: string }) | null = null;
 
     if (VALID_ALIAS.test(redirectUrl)) {
         try {
-            event = await apiFetch<any>(`/api/events/by-alias/${redirectUrl}`);
+            event = await apiFetch<Event & { message?: string }>(`/api/events/by-alias/${redirectUrl}`);
         } catch (error) {
             console.error("Failed to fetch event:", error);
         }
@@ -32,24 +34,24 @@ export default async function EventRedirectPage({ params }: { params: Promise<{
                 <p className="text-gray-500 mb-6">
                     The page you&apos;re looking for doesn&apos;t exist.
                 </p>
-                <a href="/" className="text-brand-600 hover:underline transition-all duration-200">
+                <Link href="/" className="text-brand-600 hover:underline transition-all duration-200">
                     Back to Home &rarr;
-                </a>
+                </Link>
             </main>
         );
     }
 
     if (event.isLive || event.isActive) {
-        redirect(`/events/${event.id}`);
+        redirect(`/events/${event.id}?src=${encodeURIComponent(redirectUrl)}`);
     }
 
     return (
         <main className="flex flex-col items-center justify-center min-h-screen text-center">
             <h1 className="text-3xl font-bold mb-2">This event has ended</h1>
             <p className="text-gray-600">Thanks for joining us! Stay tuned for the next one.</p>
-            <a href="/" className="mt-4 text-brand-600 hover:underline">
+            <Link href="/" className="mt-4 text-brand-600 hover:underline">
                 Back to Home &rarr;
-            </a>
+            </Link>
         </main>
     );
 }

frontend/src/app/activate-account/page.tsx

@@ -3,13 +3,14 @@ import React, { Suspense, useMemo, useState } from "react";
 import { Navbar } from "@/components/layout/Navbar";
 import { Footer } from "@/components/layout/Footer";
 import { apiFetch } from "@/lib/api";
-import { useSearchParams, useRouter } from "next/navigation";
+import { saveToken } from "@/lib/auth";
+import { useSearchParams } from "next/navigation";
 import { appName } from "@/lib/siteConfig";
 import { ShieldCheck } from "lucide-react";
+import { errorMessage } from "@/lib/utils";
 
 function ActivateAccountContent() {
   const search = useSearchParams();
-  const router = useRouter();
   const token = search.get("token") || "";
   const [password, setPassword] = useState("");
   const [confirm, setConfirm] = useState("");
@@ -24,15 +25,14 @@ function ActivateAccountContent() {
     try {
       setLoading(true);
       setStatus(null);
-      const data = await apiFetch<any>("/api/users/activate", { method: "POST", body: { token, password } });
-      // Auto-login: save token and redirect to dashboard
-      if (data?.token) {
-        localStorage.setItem("token", data.token);
-      }
+      const data = await apiFetch<{ token?: string }>("/api/users/activate", { method: "POST", body: { token, password } });
+      // Auto-login: save the session token (under the key AuthContext reads) and load the
+      // dashboard fresh so the new session is picked up.
+      if (data?.token) saveToken(data.token);
       setStatus("Your account is now active. Redirecting…");
-      setTimeout(() => router.push("/dashboard"), 1500);
-    } catch (err: any) {
-      setStatus(err?.message || "Activation failed. The link may have expired.");
+      setTimeout(() => { window.location.href = "/dashboard"; }, 1500);
+    } catch (err) {
+      setStatus(errorMessage(err) || "Activation failed. The link may have expired.");
     } finally {
       setLoading(false);
     }

frontend/src/app/dashboard/admin/audit-log/page.tsx

@@ -7,6 +7,7 @@ import { apiFetch } from "@/lib/api";
 import { useDismissingState } from "@/hooks/useDismissingState";
 import { History } from "lucide-react";
 import { Table, TableHeader, TableBody, TableRow, TableHead, TableCell } from "@/components/ui/table";
+import { errorMessage } from "@/lib/utils";
 
 const ACTIONS = [
   "refund_created",
@@ -30,6 +31,11 @@ const ACTIONS = [
   "scan_lock_force_released",
   "offline_sync",
   "ticket_transferred",
+  "impersonation_started",
+  "impersonation_ended",
+  "yoco_config_updated",
+  "yoco_webhook_registered",
+  "yoco_webhook_deleted",
 ] as const;
 
 const ACTION_LABELS: Record<string, string> = {
@@ -54,6 +60,11 @@ const ACTION_LABELS: Record<string, string> = {
   scan_lock_force_released: "Offline lock force-released",
   offline_sync: "Offline scans synced",
   ticket_transferred: "Ticket transferred",
+  impersonation_started: "Impersonation started",
+  impersonation_ended: "Impersonation ended",
+  yoco_config_updated: "Yoco settings changed",
+  yoco_webhook_registered: "Yoco webhook registered",
+  yoco_webhook_deleted: "Yoco webhook deleted",
 };
 
 interface AuditLogEntry {
@@ -81,6 +92,49 @@ function formatMetadata(metadata: Record<string, unknown> | null): string {
   }
 }
 
+type ImpSession = {
+  id: string; reason: string; startedAt: string; expiresAt: string; endedAt: string | null; endedReason: string | null;
+  admin: { name: string; email: string }; target: { name: string; email: string };
+  requests: { method: string; path: string; blocked: boolean; createdAt: string }[];
+};
+
+/** "View as" sessions, each with the trail of pages and API calls made during it. */
+function ImpersonationSessions({ token }: { token: string }) {
+  const [sessions, setSessions] = useState<ImpSession[]>([]);
+  const [open, setOpen] = useState<string | null>(null);
+  useEffect(() => {
+    apiFetch<ImpSession[]>("/api/admin/impersonation-sessions?limit=20", { authToken: token }).then(setSessions).catch(() => setSessions([]));
+  }, [token]);
+  if (sessions.length === 0) return null;
+  return (
+    <div className="border rounded-xl bg-white shadow-sm p-4 mb-4">
+      <div className="font-semibold mb-2">Impersonation sessions</div>
+      <ul className="divide-y text-sm">
+        {sessions.map(s => (
+          <li key={s.id} className="py-2">
+            <button className="w-full text-left flex flex-wrap items-baseline justify-between gap-2" onClick={() => setOpen(open === s.id ? null : s.id)}>
+              <span><strong>{s.admin.name}</strong> viewed as <strong>{s.target.name}</strong> — “{s.reason}”</span>
+              <span className="text-xs text-gray-500">
+                {new Date(s.startedAt).toLocaleString()} · {s.endedAt ? `${s.endedReason || "ended"} ${new Date(s.endedAt).toLocaleTimeString()}` : new Date(s.expiresAt) > new Date() ? "active" : "expired"} · {s.requests.length} request(s){s.requests.some(r => r.blocked) ? ` · ${s.requests.filter(r => r.blocked).length} blocked` : ""}
+              </span>
+            </button>
+            {open === s.id && (
+              <ul className="mt-2 text-xs font-mono bg-gray-50 rounded p-2 max-h-64 overflow-auto space-y-0.5">
+                {s.requests.map((r, i) => (
+                  <li key={i} className={r.blocked ? "text-red-700" : "text-gray-700"}>
+                    {new Date(r.createdAt).toLocaleTimeString()} {r.method} {r.path}{r.blocked ? "  (blocked — read-only)" : ""}
+                  </li>
+                ))}
+                {s.requests.length === 0 && <li className="text-gray-500">No requests recorded.</li>}
+              </ul>
+            )}
+          </li>
+        ))}
+      </ul>
+    </div>
+  );
+}
+
 export default function AdminAuditLogPage() {
   const { user, loading, token } = useAuth();
   const router = useRouter();
@@ -121,14 +175,15 @@ export default function AdminAuditLogPage() {
       setEntries(res?.rows || []);
       setTotal(res?.total ?? 0);
       setPage(p);
-    } catch (e: any) {
-      setError(e?.message || "Failed to load audit log");
+    } catch (e) {
+      setError(errorMessage(e) || "Failed to load audit log");
     } finally {
       setFetching(false);
     }
-  }, [token, buildQuery]);
+  }, [token, buildQuery, setError]);
 
-  useEffect(() => { if (token) load(1); }, [token, actionFilter, fromFilter, toFilter]);
+  // load changes whenever a filter does (via buildQuery), so this refetches page 1 on filter changes.
+  useEffect(() => { if (token) load(1); }, [token, load]);
 
   return (
     <div className="max-w-6xl mx-auto w-full p-6">
@@ -148,6 +203,7 @@ export default function AdminAuditLogPage() {
           You need admin access to view the audit log.
         </div>
       )}
+      {isAdmin && token && <ImpersonationSessions token={token} />}
 
       {error && <div className="mb-3 p-3 border rounded bg-red-50 text-red-800 text-sm">{error}</div>}
 

frontend/src/app/dashboard/admin/cashup/[id]/page.tsx

@@ -1,12 +1,13 @@
 "use client";
 
-import React, { useEffect, useMemo, useState } from "react";
+import React, { useCallback, useEffect, useMemo, useState } from "react";
 import { useParams, useRouter } from "next/navigation";
 import { useAuth } from "@/hooks/useAuth";
 import { apiFetch } from "@/lib/api";
 import { useDismissingState } from "@/hooks/useDismissingState";
-import type { EventCost, EventCostType, EventFinancials, CashupMethod } from "@/types";
+import type { EventCost, EventCostType, EventFinancials, CashupMethod, Event } from "@/types";
 import { Wallet, DollarSign, ClipboardCheck, FileBarChart } from "lucide-react";
+import { errorMessage } from "@/lib/utils";
 
 const METHOD_LABELS: Record<CashupMethod, string> = { cash: "Cash", card: "Card", eft: "EFT", other: "Other" };
 const METHODS: CashupMethod[] = ["cash", "card", "eft", "other"];
@@ -36,25 +37,25 @@ export default function EventCashupPage() {
 
   const isClosed = data?.event?.cashupStatus === "closed";
 
-  const load = async () => {
+  const load = useCallback(async () => {
     if (!token || !eventId) return;
     setLoading(true);
     setError(null);
     try {
       const [financials, event] = await Promise.all([
         apiFetch<EventFinancials>(`/api/cashups/event/${eventId}`, { authToken: token }),
-        apiFetch<any>(`/api/events/${eventId}`, { authToken: token })
+        apiFetch<Event>(`/api/events/${eventId}`, { authToken: token })
       ]);
       setData(financials);
-      setEventOptions((event.eventOptions || []).map((o: any) => ({ id: o.id, name: o.name })));
-    } catch (e: any) {
-      setError(e?.message || "Failed to load cashup data");
+      setEventOptions((event.eventOptions || []).map((o) => ({ id: o.id, name: o.name })));
+    } catch (e) {
+      setError(errorMessage(e) || "Failed to load cashup data");
     } finally {
       setLoading(false);
     }
-  };
+  }, [token, eventId, setError]);
 
-  useEffect(() => { load(); }, [token, eventId]);
+  useEffect(() => { load(); }, [load]);
 
   return (
     <div className="max-w-4xl mx-auto space-y-4">
@@ -151,8 +152,8 @@ function CostsTab({ eventId, token, costs, eventOptions, isClosed, onChanged }:
       }
       setEditingId(null);
       onChanged();
-    } catch (e: any) {
-      setErr(e?.message || "Failed to save cost");
+    } catch (e) {
+      setErr(errorMessage(e) || "Failed to save cost");
     } finally {
       setSaving(false);
     }
@@ -163,8 +164,8 @@ function CostsTab({ eventId, token, costs, eventOptions, isClosed, onChanged }:
     try {
       await apiFetch(`/api/costs/${id}`, { method: "DELETE", authToken: token });
       onChanged();
-    } catch (e: any) {
-      alert(e?.message || "Failed to delete cost");
+    } catch (e) {
+      alert(errorMessage(e) || "Failed to delete cost");
     }
   };
 
@@ -179,7 +180,7 @@ function CostsTab({ eventId, token, costs, eventOptions, isClosed, onChanged }:
         )}
       </div>
 
-      {isClosed && <div className="text-xs text-gray-500">This event is closed — costs can't be changed until it's reopened.</div>}
+      {isClosed && <div className="text-xs text-gray-500">This event is closed — costs can&apos;t be changed until it&apos;s reopened.</div>}
 
       <div className="overflow-auto">
         <table className="w-full text-sm min-w-[600px]">
@@ -257,11 +258,11 @@ function CostsTab({ eventId, token, costs, eventOptions, isClosed, onChanged }:
             </div>
             <div>
               <label className="block text-xs text-gray-600 mb-1">Paid from (optional)</label>
-              <select className="w-full border rounded px-2 py-1.5 text-sm" value={paidFromMethod} onChange={e => setPaidFromMethod(e.target.value as any)}>
+              <select className="w-full border rounded px-2 py-1.5 text-sm" value={paidFromMethod} onChange={e => setPaidFromMethod(e.target.value as "" | CashupMethod)}>
                 <option value="">Not from event takings</option>
                 {METHODS.map(m => <option key={m} value={m}>{METHOD_LABELS[m]}</option>)}
               </select>
-              <p className="text-[10px] text-gray-400 mt-0.5">If this was paid out of the door takings (e.g. cash to a vendor), tag it so the Cashup report deducts it from that method's expected amount.</p>
+              <p className="text-[10px] text-gray-400 mt-0.5">If this was paid out of the door takings (e.g. cash to a vendor), tag it so the Cashup report deducts it from that method&apos;s expected amount.</p>
             </div>
             <div className="col-span-2">
               <label className="block text-xs text-gray-600 mb-1">Notes (optional)</label>
@@ -306,16 +307,17 @@ function CashByUserSection({ eventId, token, onCashSummaryChange }: {
   const [open, setOpen] = useState(true);
   const [editingUserId, setEditingUserId] = useState<string | null>(null);
 
-  const load = () => {
+  const load = useCallback(() => {
     if (!token || !eventId) return;
     setLoading(true);
     apiFetch<AccountabilityResponse>(`/api/cashups/event/${eventId}/cash-by-user`, { authToken: token })
       .then(r => { setData(r); onCashSummaryChange?.({ actualTotal: r?.cashActualTotal ?? null, denominations: r?.cashDenominations || [] }); })
       .catch(() => setData({ rows: [], cashActualTotal: null, cashDenominations: [] }))
       .finally(() => setLoading(false));
-  };
+  }, [eventId, token, onCashSummaryChange]);
 
-  useEffect(load, [eventId, token]);
+  // onCashSummaryChange is a state setter in the parent, so this only reruns when the event/token change.
+  useEffect(load, [load]);
 
   const rows = data?.rows || [];
   const sumOf = (m: "cash" | "card" | "eft" | "other", key: "total" | "count") =>
@@ -461,8 +463,8 @@ function PersonCashCountEditor({ eventId, token, userId, initialDenominations, i
         method: "PUT", authToken: token, body: { denominations: lines, notes: notes || null }
       });
       onSaved();
-    } catch (e: any) {
-      setErr(e?.message || "Failed to save count");
+    } catch (e) {
+      setErr(errorMessage(e) || "Failed to save count");
     } finally {
       setSaving(false);
     }
@@ -568,7 +570,7 @@ function ReportTab({ eventId, token, data, isClosed }: {
           <div className="text-sm font-medium">Cash denomination count</div>
           <table className="text-sm">
             <tbody>
-              {reconciled.byMethod.cash.denominations.map((d: any) => (
+              {reconciled.byMethod.cash.denominations.map((d) => (
                 <tr key={d.id}><td className="pr-4 py-0.5">{denomLabel(d.value)}</td><td className="pr-4 py-0.5">× {d.count}</td><td className="py-0.5 text-gray-500">{money(d.value * d.count)}</td></tr>
               ))}
             </tbody>
@@ -590,7 +592,7 @@ function ReportTab({ eventId, token, data, isClosed }: {
               </tr>
             </thead>
             <tbody>
-              {data.costs.map((c: any) => (
+              {data.costs.map((c) => (
                 <tr key={c.id} className="border-b last:border-0">
                   <td className="py-1.5">{c.label}</td>
                   <td className="py-1.5 capitalize">{c.paidFromMethod || "—"}</td>
@@ -625,7 +627,7 @@ function ReconciliationTab({ eventId, token, data, busy, setBusy, setError, onCh
   setBusy: (b: boolean) => void; setError: (e: string | null) => void; onChanged: () => void; onClosed: () => void;
 }) {
   const isClosed = data.event.cashupStatus === "closed";
-  const draftLines = (data.event as any).cashupDraft?.lines as Array<{ method: string; actualAmount?: string | number; notes?: string; denominations?: { value: number; count: number }[] }> | undefined;
+  const draftLines = data.event.cashupDraft?.lines;
 
   const initialLines: Record<CashupMethod, LineInput> = useMemo(() => {
     const base: Record<CashupMethod, LineInput> = { cash: { actualAmount: "", notes: "" }, card: { actualAmount: "", notes: "" }, eft: { actualAmount: "", notes: "" }, other: { actualAmount: "", notes: "" } };
@@ -659,8 +661,8 @@ function ReconciliationTab({ eventId, token, data, busy, setBusy, setError, onCh
     try {
       await apiFetch(`/api/cashups/event/${eventId}/draft`, { method: "PUT", authToken: token, body: { lines: buildLinesPayload() } });
       onChanged();
-    } catch (e: any) {
-      setError(e?.message || "Failed to save draft");
+    } catch (e) {
+      setError(errorMessage(e) || "Failed to save draft");
     } finally {
       setBusy(false);
     }
@@ -673,8 +675,8 @@ function ReconciliationTab({ eventId, token, data, busy, setBusy, setError, onCh
       await apiFetch(`/api/cashups/event/${eventId}/close`, { method: "POST", authToken: token, body: { lines: buildLinesPayload(), notes: closeNotes || null } });
       onChanged();
       onClosed();
-    } catch (e: any) {
-      setError(e?.message || "Failed to close event");
+    } catch (e) {
+      setError(errorMessage(e) || "Failed to close event");
     } finally {
       setBusy(false);
     }
@@ -687,8 +689,8 @@ function ReconciliationTab({ eventId, token, data, busy, setBusy, setError, onCh
       await apiFetch(`/api/cashups/event/${eventId}/close`, { method: "POST", authToken: token, body: { notes: closeNotes || null } });
       onChanged();
       onClosed();
-    } catch (e: any) {
-      setError(e?.message || "Failed to close event");
+    } catch (e) {
+      setError(errorMessage(e) || "Failed to close event");
     } finally {
       setBusy(false);
     }
@@ -700,8 +702,8 @@ function ReconciliationTab({ eventId, token, data, busy, setBusy, setError, onCh
     try {
       await apiFetch(`/api/cashups/event/${eventId}/reopen`, { method: "POST", authToken: token, body: { notes: reopenNotes || null } });
       onChanged();
-    } catch (e: any) {
-      setError(e?.message || "Failed to reopen event");
+    } catch (e) {
+      setError(errorMessage(e) || "Failed to reopen event");
     } finally {
       setBusy(false);
     }
@@ -761,7 +763,7 @@ function ReconciliationTab({ eventId, token, data, busy, setBusy, setError, onCh
           </tbody>
         </table>
         {!isClosed && (
-          <div className="text-xs text-gray-500">Cash actual is the live sum of per-staff-member counts entered below — there's no separate event-wide entry.</div>
+          <div className="text-xs text-gray-500">Cash actual is the live sum of per-staff-member counts entered below — there&apos;s no separate event-wide entry.</div>
         )}
       </div>
 
@@ -774,7 +776,7 @@ function ReconciliationTab({ eventId, token, data, busy, setBusy, setError, onCh
           return denoms.length > 0 ? (
             <table className="text-sm">
               <tbody>
-                {denoms.map((d: any) => (
+                {denoms.map((d: PersonDenom & { id?: string }) => (
                   <tr key={d.id || d.value}><td className="pr-4 py-0.5">{denomLabel(d.value)}</td><td className="pr-4 py-0.5">× {d.count}</td><td className="py-0.5 text-gray-500">{money(d.value * d.count)}</td></tr>
                 ))}
               </tbody>

frontend/src/app/dashboard/admin/cashup/page.tsx

@@ -6,12 +6,14 @@ import { useAuth } from "@/hooks/useAuth";
 import { apiFetch } from "@/lib/api";
 import { useDismissingState } from "@/hooks/useDismissingState";
 import { Wallet } from "lucide-react";
+import { errorMessage } from "@/lib/utils";
+import type { Event } from "@/types";
 
 export default function CashupLandingPage() {
   const { token } = useAuth();
   const router = useRouter();
 
-  const [events, setEvents] = useState<any[]>([]);
+  const [events, setEvents] = useState<Event[]>([]);
   const [loading, setLoading] = useState(false);
   const [error, setError] = useDismissingState<string | null>(null);
   const [search, setSearch] = useState("");
@@ -25,15 +27,15 @@ export default function CashupLandingPage() {
       setLoading(true);
       setError(null);
       try {
-        const evs = await apiFetch<any[]>("/api/events/all?includePast=true&includeInactive=true", { authToken: token });
+        const evs = await apiFetch<Event[]>("/api/events/all?includePast=true&includeInactive=true", { authToken: token });
         setEvents(Array.isArray(evs) ? evs : []);
-      } catch (e: any) {
-        setError(e?.message || "Failed to load events");
+      } catch (e) {
+        setError(errorMessage(e) || "Failed to load events");
       } finally {
         setLoading(false);
       }
     })();
-  }, [token]);
+  }, [token, setError]);
 
   const filtered = useMemo(() => {
     const now = new Date();

frontend/src/app/dashboard/admin/page.tsx

@@ -1,6 +1,6 @@
 "use client";
 
-import React, { useEffect, useMemo, useRef, useState } from "react";
+import React, { useCallback, useEffect, useMemo, useRef, useState } from "react";
 import { useAuth } from "@/hooks/useAuth";
 import { useRouter } from "next/navigation";
 import { apiFetch } from "@/lib/api";
@@ -8,12 +8,13 @@ import { useStableState } from "@/hooks/useStableState";
 import { useVisiblePolling } from "@/hooks/useVisiblePolling";
 import {
   Calendar, Banknote, Gift, Users, Ticket, QrCode, ClipboardList,
-  UserPlus, FileText, MessageCircle, BarChart2, Mail, Wallet, DoorOpen, History, TicketPercent, ShieldCheck, ListChecks, WifiOff,
+  UserPlus, FileText, MessageCircle, BarChart2, Mail, Wallet, DoorOpen, History, TicketPercent, ShieldCheck, ListChecks, WifiOff, BedDouble, Filter,
 } from "lucide-react";
 import { StatCard, StatCardRow } from "@/components/shared/StatCard";
 import { QuickActionTile, QuickActionGrid } from "@/components/shared/QuickActionTile";
 import { AreaTrendChart } from "@/components/charts/AreaTrendChart";
 import { Table, TableHeader, TableBody, TableRow, TableHead, TableCell } from "@/components/ui/table";
+import type { DashboardStats, PaymentStats } from "@/types";
 
 const formatRand = (n: number) => `R ${(n || 0).toFixed(2)}`;
 const formatRandAxis = (n: number) => `R${new Intl.NumberFormat(undefined, { notation: "compact", maximumFractionDigits: 1 }).format(n)}`;
@@ -27,6 +28,7 @@ const QUICK_ACTIONS = [
   { href: "/dashboard/supervisor/manual", label: "Manual registration", description: "Register a guest and issue tickets", icon: UserPlus },
   { href: "/dashboard/supervisor/at-the-door", label: "At the door", description: "Walk-ins, payments, ticket printing", icon: DoorOpen },
   { href: "/dashboard/supervisor/payments", label: "Payments & donations", description: "Manual payments and assignment", icon: Wallet },
+  { href: "/dashboard/supervisor/allocations", label: "Rooms & groups", description: "Put attendees into rooms, groups or buses", icon: BedDouble },
   { href: "/dashboard/supervisor/offline-scans", label: "Offline scanning", description: "Devices scanning offline and their synced scans", icon: WifiOff },
   { href: "/dashboard/supervisor/waitlist", label: "Waitlist", description: "People waiting for sold-out tickets", icon: ListChecks },
   { href: "/dashboard/supervisor/consent", label: "Parental consent", description: "Youth events: consent status and medical list", icon: ShieldCheck },
@@ -42,6 +44,7 @@ const QUICK_ACTIONS = [
 
 type OverviewMetric = { thisMonth: number; lastMonth: number; pctChange: number | null };
 type Overview = {
+  funnel?: { views: number; paid: number; conversion: number | null } | null;
   activeEvents: number;
   registrations: OverviewMetric;
   ticketsSold: OverviewMetric;
@@ -65,35 +68,35 @@ export default function AdminDashboardPage() {
   // /api/stats/admin covers today/week/month payment totals (unchanged from before);
   // /api/stats/overview is the month-over-month KPI/trend/top-events endpoint. Both are
   // computed server-side — no full payments/events list ever ships to the client.
-  const [paymentStats, setPaymentStats] = useStableState<any | null>(null);
+  const [paymentStats, setPaymentStats] = useStableState<PaymentStats | null>(null);
   const [overview, setOverview] = useStableState<Overview | null>(null);
   const [loadingStats, setLoadingStats] = useState(false);
   const hasLoadedOnce = useRef(false);
   const [paymentsTab, setPaymentsTab] = useState<"today" | "week" | "month">("today");
 
-  const loadStats = async () => {
+  const loadStats = useCallback(async () => {
     if (!token) return;
     const isFirstLoad = !hasLoadedOnce.current;
     try {
       if (isFirstLoad) setLoadingStats(true);
       const [dash, overviewData] = await Promise.all([
-        apiFetch<any>("/api/stats/admin", { authToken: token }),
+        apiFetch<DashboardStats>("/api/stats/admin", { authToken: token }),
         apiFetch<Overview>("/api/stats/overview", { authToken: token }),
       ]);
       setPaymentStats(dash.paymentStats);
       setOverview(overviewData);
-    } catch (e) {
+    } catch {
       // ignore errors for dashboard summaries
     } finally {
       hasLoadedOnce.current = true;
       if (isFirstLoad) setLoadingStats(false);
     }
-  };
+  }, [token, setPaymentStats, setOverview]);
 
   useEffect(() => {
     if (!token) return;
     loadStats();
-  }, [token]);
+  }, [token, loadStats]);
 
   // Poll every 15s while the tab is visible; pause in the background and refetch
   // immediately on return instead of leaving stale numbers up.
@@ -103,7 +106,7 @@ export default function AdminDashboardPage() {
   }, 15000, !!token);
 
   const paymentsTabValue = paymentStats
-    ? paymentsTab === "today" ? paymentStats.totalToday : paymentsTab === "week" ? paymentStats.totalWeek : paymentStats.totalMonth
+    ? (paymentsTab === "today" ? paymentStats.totalToday : paymentsTab === "week" ? paymentStats.totalWeek : paymentStats.totalMonth) ?? 0
     : 0;
 
   return (
@@ -119,12 +122,15 @@ export default function AdminDashboardPage() {
         </div>
       )}
 
-      <StatCardRow>
+      <StatCardRow cols={overview?.funnel ? 6 : 5}>
         <StatCard icon={Calendar} label="Active events" value={overview ? formatCount(overview.activeEvents) : "—"} tone="brand" href="/dashboard/supervisor/events" linkLabel="View all events" />
         <StatCard icon={Banknote} label="Revenue (past month)" value={overview ? formatRand(overview.revenue.thisMonth) : "—"} tone="green" href={`${REPORTS_URL}?report=revenue&range=trailing_month`} linkLabel="View report" delta={overview ? { value: overview.revenue.pctChange } : undefined} />
         <StatCard icon={Gift} label="Donations (past month)" value={overview ? formatRand(overview.donations.thisMonth) : "—"} tone="rose" href={`${REPORTS_URL}?report=donations&range=trailing_month`} linkLabel="View report" delta={overview ? { value: overview.donations.pctChange } : undefined} />
         <StatCard icon={Users} label="Registrations (past month)" value={overview ? formatCount(overview.registrations.thisMonth) : "—"} tone="blue" href="/dashboard/admin/registrations" linkLabel="View registrations" delta={overview ? { value: overview.registrations.pctChange } : undefined} />
         <StatCard icon={Ticket} label="Tickets sold (past month)" value={overview ? formatCount(overview.ticketsSold.thisMonth) : "—"} tone="amber" href={`${REPORTS_URL}?report=usage&range=trailing_month`} linkLabel="View report" delta={overview ? { value: overview.ticketsSold.pctChange } : undefined} />
+        {overview?.funnel && (
+          <StatCard icon={Filter} label="Conversion (past month)" value={overview.funnel.conversion != null ? `${overview.funnel.conversion}%` : "—"} tone="violet" href={`${REPORTS_URL}?report=funnel&range=trailing_month`} linkLabel={`${overview.funnel.paid} of ${overview.funnel.views} visits`} />
+        )}
       </StatCardRow>
 
       <div className="border rounded-xl p-4 bg-white shadow-sm my-6">

frontend/src/app/dashboard/admin/registrations/page.tsx

@@ -1,11 +1,13 @@
 "use client";
 
-import React, { useEffect, useMemo, useState } from "react";
+import React, { useCallback, useEffect, useMemo, useState } from "react";
 import { useAuth } from "@/hooks/useAuth";
 import { useRouter } from "next/navigation";
 import { apiFetch } from "@/lib/api";
 import { useDismissingState } from "@/hooks/useDismissingState";
 import { ClipboardList } from "lucide-react";
+import { errorMessage } from "@/lib/utils";
+import type { Event, FormResponse, Registration } from "@/types";
 
 const STATUS_OPTIONS = ["pending", "confirmed", "partial_paid", "paid", "cancelled"] as const;
 
@@ -17,6 +19,16 @@ function fuzzyMatch(query: string, target: string): boolean {
   return tokens.every(tok => t.includes(tok));
 }
 
+// Backend attaches a tranche-aware totalDueComputed (exact even when a line spans multiple
+// early-bird prices) — fall back to the old client-side estimate only for stale payloads.
+const totalDueFor = (r: Registration) => r.totalDueComputed ?? (r.registrationOptions || []).reduce((sum, opt) => {
+  const unit = (opt.priceSnapshot !== null && opt.priceSnapshot !== undefined)
+    ? Number(opt.priceSnapshot)
+    : (opt.eventOption?.price || 0);
+  return sum + unit * (opt.quantity || 0);
+}, 0);
+const totalPaidFor = (r: Registration) => (r.payments || []).reduce((sum, p) => sum + (p.amount || 0), 0);
+
 export default function AdminRegistrationsPage() {
   const { user, loading, token } = useAuth();
   const router = useRouter();
@@ -28,8 +40,8 @@ export default function AdminRegistrationsPage() {
     if (!user) router.replace("/login");
   }, [user, loading, router]);
 
-  const [registrations, setRegistrations] = useState<any[]>([]);
-  const [events, setEvents] = useState<any[]>([]);
+  const [registrations, setRegistrations] = useState<Registration[]>([]);
+  const [events, setEvents] = useState<Event[]>([]);
   const [loadingRegs, setLoadingRegs] = useState(false);
   const [error, setError] = useDismissingState<string | null>(null);
   const [info, setInfo] = useDismissingState<string | null>(null);
@@ -43,48 +55,48 @@ export default function AdminRegistrationsPage() {
 
   // Expanded rows + form responses cache
   const [expanded, setExpanded] = useState<Set<string>>(new Set());
-  const [formResponses, setFormResponses] = useState<Record<string, any[]>>({});
+  const [formResponses, setFormResponses] = useState<Record<string, FormResponse[]>>({});
   const [loadingForms, setLoadingForms] = useState<Set<string>>(new Set());
 
-  const loadRegistrations = async () => {
+  const loadRegistrations = useCallback(async () => {
     if (!token) return;
     try {
       setLoadingRegs(true);
-      const regs = await apiFetch<any[]>("/api/registrations", { authToken: token });
+      const regs = await apiFetch<Registration[]>("/api/registrations", { authToken: token });
       const list = Array.isArray(regs) ? regs.sort((a, b) => {
         const eventCompare = (a.event?.startDate || a.eventId).localeCompare(b.event?.startDate || b.eventId);
         if (eventCompare !== 0) return eventCompare;
         return (a.user?.name || a.userId).localeCompare(b.user?.name || b.userId);
       }) : [];
       setRegistrations(list);
-    } catch (e: any) {
-      setError(e?.message || "Failed to load registrations");
+    } catch (e) {
+      setError(errorMessage(e) || "Failed to load registrations");
     } finally {
       setLoadingRegs(false);
     }
-  };
+  }, [token, setError]);
 
-  const loadEvents = async () => {
+  const loadEvents = useCallback(async () => {
     if (!token) return;
     try {
       const params = new URLSearchParams();
       if (includePastEvents) params.set("includePast", "true");
       if (includeInactiveEvents) params.set("includeInactive", "true");
       const qs = params.toString() ? `?${params.toString()}` : "";
-      const evs = await apiFetch<any[]>(`/api/events/all${qs}`, { authToken: token });
-      setEvents(Array.isArray(evs) ? evs.sort((a: any, b: any) => new Date(b.startDate).getTime() - new Date(a.startDate).getTime()) : []);
+      const evs = await apiFetch<Event[]>(`/api/events/all${qs}`, { authToken: token });
+      setEvents(Array.isArray(evs) ? evs.sort((a, b) => new Date(b.startDate).getTime() - new Date(a.startDate).getTime()) : []);
     } catch {}
-  };
+  }, [token, includePastEvents, includeInactiveEvents]);
 
   useEffect(() => {
     loadRegistrations();
-  }, [token]);
+  }, [loadRegistrations]);
 
   useEffect(() => {
     loadEvents();
-  }, [token, includePastEvents, includeInactiveEvents]);
+  }, [loadEvents]);
 
-  const toggleExpand = async (reg: any) => {
+  const toggleExpand = async (reg: Registration) => {
     const id = reg.id;
     const next = new Set(expanded);
     if (next.has(id)) {
@@ -98,8 +110,8 @@ export default function AdminRegistrationsPage() {
     if (!formResponses[id] && !loadingForms.has(id)) {
       setLoadingForms(prev => new Set(prev).add(id));
       try {
-        const res = await apiFetch<any>(`/api/forms/responses?registrationId=${encodeURIComponent(id)}`, { authToken: token! });
-        const items = Array.isArray(res?.items) ? res.items : (Array.isArray(res) ? res : []);
+        const res = await apiFetch<{ items?: FormResponse[] } | FormResponse[]>(`/api/forms/responses?registrationId=${encodeURIComponent(id)}`, { authToken: token! });
+        const items = Array.isArray(res) ? res : (Array.isArray(res?.items) ? res.items : []);
         setFormResponses(prev => ({ ...prev, [id]: items }));
       } catch {
         setFormResponses(prev => ({ ...prev, [id]: [] }));
@@ -109,7 +121,7 @@ export default function AdminRegistrationsPage() {
     }
   };
 
-  const cancelRegistration = async (reg: any) => {
+  const cancelRegistration = async (reg: Registration) => {
     if (!token) return;
     setError(null); setInfo(null);
     if (!confirm(`Cancel registration #${String(reg.id).slice(0, 8)} for ${reg.user?.name || reg.userId}?`)) return;
@@ -117,27 +129,27 @@ export default function AdminRegistrationsPage() {
       await apiFetch(`/api/registrations/${encodeURIComponent(reg.id)}`, { method: "DELETE", authToken: token });
       setInfo("Registration cancelled");
       await loadRegistrations();
-    } catch (e: any) {
-      setError(e?.message || "Failed to cancel registration");
+    } catch (e) {
+      setError(errorMessage(e) || "Failed to cancel registration");
     }
   };
 
-  const updateStatus = async (reg: any, status: string) => {
+  const updateStatus = async (reg: Registration, status: string) => {
     if (!token) return;
     setError(null); setInfo(null);
     try {
       await apiFetch(`/api/registrations/${encodeURIComponent(reg.id)}`, { method: "PUT", authToken: token, body: { status } });
       setInfo("Status updated");
       await loadRegistrations();
-    } catch (e: any) {
-      setError(e?.message || "Failed to update status");
+    } catch (e) {
+      setError(errorMessage(e) || "Failed to update status");
     }
   };
 
-  const eventIds = useMemo(() => new Set(events.map((ev: any) => ev.id)), [events]);
+  const eventIds = useMemo(() => new Set(events.map((ev) => ev.id)), [events]);
 
   const filtered = useMemo(() => {
-    return registrations.filter((r: any) => {
+    return registrations.filter((r) => {
       if (!eventIds.has(r.eventId)) return false;
       if (eventFilter && r.eventId !== eventFilter) return false;
       if (statusFilter && r.status !== statusFilter) return false;
@@ -145,10 +157,10 @@ export default function AdminRegistrationsPage() {
       const haystack = [
         r.id, r.user?.name, r.user?.email, r.user?.phoneNumber,
         r.userId, r.event?.title, r.eventId, r.status,
-      ].map((x: any) => String(x || "")).join(" ");
+      ].map((x) => String(x || "")).join(" ");
       return fuzzyMatch(query.trim(), haystack);
     });
-  }, [registrations, query, eventFilter, statusFilter]);
+  }, [registrations, query, eventFilter, statusFilter, eventIds]);
 
   const statusColor = (s: string) => {
     if (s === "paid") return "text-green-700 bg-green-50";
@@ -158,15 +170,6 @@ export default function AdminRegistrationsPage() {
     return "text-gray-700 bg-gray-50";
   };
 
-  // Backend attaches a tranche-aware totalDueComputed (exact even when a line spans multiple
-  // early-bird prices) — fall back to the old client-side estimate only for stale payloads.
-  const totalDueFor = (r: any) => r.totalDueComputed ?? (r.registrationOptions || []).reduce((sum: number, opt: any) => {
-    const unit = (opt.priceSnapshot !== null && opt.priceSnapshot !== undefined)
-      ? Number(opt.priceSnapshot)
-      : (opt.eventOption?.price || 0);
-    return sum + unit * (opt.quantity || 0);
-  }, 0);
-  const totalPaidFor = (r: any) => (r.payments || []).reduce((sum: number, p: any) => sum + (p.amount || 0), 0);
 
   // Aggregate stats across the currently filtered registrations — counts by status, plus
   // revenue/outstanding totals (cancelled registrations are excluded from the money totals
@@ -175,7 +178,7 @@ export default function AdminRegistrationsPage() {
     const counts: Record<string, number> = {};
     let totalRevenue = 0;
     let totalOutstanding = 0;
-    filtered.forEach((r: any) => {
+    filtered.forEach((r) => {
       counts[r.status] = (counts[r.status] || 0) + 1;
       if (r.status === "cancelled") return;
       const due = totalDueFor(r);
@@ -275,7 +278,7 @@ export default function AdminRegistrationsPage() {
 
       <div className="border rounded-xl bg-white shadow-sm">
         <ul className="divide-y text-sm">
-          {filtered.map((r: any) => {
+          {filtered.map((r) => {
             const totalDue = totalDueFor(r);
             const totalPaid = totalPaidFor(r);
             const outstanding = Math.max(totalDue - totalPaid, 0);
@@ -336,7 +339,7 @@ export default function AdminRegistrationsPage() {
                       <div className="mb-3">
                         <div className="text-xs font-semibold text-gray-600 mb-1 uppercase tracking-wide">Ticket options</div>
                         <div className="grid sm:grid-cols-2 gap-2">
-                          {r.registrationOptions.map((opt: any) => {
+                          {(r.registrationOptions || []).map((opt) => {
                             // A line can span multiple price tranches (e.g. tickets bought
                             // before and after an early-bird tier expired) — show one row per
                             // tranche so its own price/tier status is accurate, not blended.
@@ -356,7 +359,7 @@ export default function AdminRegistrationsPage() {
                                   {opt.eventOption?.name || opt.eventOptionId}
                                   {opt.variant?.name && <span className="text-gray-500"> ({opt.variant.name})</span>}
                                 </div>
-                                {tranches.map((t: any, idx: number) => {
+                                {tranches.map((t, idx) => {
                                   const unit = Number(t.priceSnapshot || 0);
                                   return (
                                     <div key={t.id || idx} className="text-gray-500">
@@ -382,7 +385,7 @@ export default function AdminRegistrationsPage() {
                         <div className="text-xs text-gray-400">No payments recorded.</div>
                       ) : (
                         <div className="grid sm:grid-cols-2 gap-2">
-                          {r.payments.map((p: any) => (
+                          {(r.payments || []).map((p) => (
                             <div key={p.id} className="bg-white border rounded p-2 text-xs">
                               <div className="font-medium">
                                 {p.amount < 0 ? '-' : ''}R {Math.abs(p.amount).toFixed(2)} · {p.method || 'payment'}
@@ -409,11 +412,11 @@ export default function AdminRegistrationsPage() {
                         <div className="text-xs text-gray-400">No form responses submitted.</div>
                       ) : (
                         <div className="space-y-2">
-                          {responses.map((resp: any, idx: number) => (
+                          {responses.map((resp, idx) => (
                             <div key={resp.id || idx} className="bg-white border rounded p-2">
                               <div className="text-xs font-medium text-gray-600 mb-1">Response #{idx + 1}</div>
                               <div className="grid sm:grid-cols-2 gap-1.5">
-                                {(resp.answers || []).map((a: any) => (
+                                {(resp.answers || []).map((a) => (
                                   <div key={a.id} className="bg-gray-50 border rounded p-1.5 text-xs">
                                     <div className="text-[10px] text-gray-500">{a.field?.label || a.fieldId}</div>
                                     <div className="font-medium">{a.value}</div>

frontend/src/app/dashboard/admin/settings/page.tsx

@@ -3,17 +3,19 @@
 import React, { Suspense, useCallback, useEffect, useRef, useState } from "react";
 import { useAuth } from "@/hooks/useAuth";
 import { useRouter, useSearchParams } from "next/navigation";
-import { apiFetch, API_BASE, resolveToApiOrigin } from "@/lib/api";
+import { apiFetch, ApiError, API_BASE, resolveToApiOrigin } from "@/lib/api";
 import { useSiteSettings } from "@/contexts/SiteSettingsContext";
 import { useDismissingState } from "@/hooks/useDismissingState";
-import { Building2, Palette, Bell, Mail, Scale, MessageCircle, DatabaseBackup, type LucideIcon } from "lucide-react";
+import { Building2, Palette, Bell, Mail, Scale, MessageCircle, CreditCard, DatabaseBackup, type LucideIcon } from "lucide-react";
 import { ColorPickerField } from "@/components/admin/ColorPickerField";
 import { BrandingPreviewPanel } from "@/components/admin/BrandingPreviewPanel";
 import { BackupsTab } from "@/components/admin/BackupsTab";
+import { YocoTab } from "@/components/admin/YocoTab";
 import { extractDominantColors } from "@/lib/extractColors";
 import { mapsSearchUrl } from "@/lib/maps";
+import { errorMessage } from "@/lib/utils";
 
-type TabId = "organisation" | "branding" | "notifications" | "email" | "legal" | "whatsapp" | "backups";
+type TabId = "organisation" | "branding" | "notifications" | "email" | "legal" | "whatsapp" | "yoco" | "backups";
 
 const TABS: { id: TabId; label: string; icon: LucideIcon }[] = [
   { id: "organisation",  label: "Organisation",  icon: Building2 },
@@ -22,6 +24,7 @@ const TABS: { id: TabId; label: string; icon: LucideIcon }[] = [
   { id: "email",         label: "Email",         icon: Mail },
   { id: "legal",         label: "Legal",         icon: Scale },
   { id: "whatsapp",      label: "WhatsApp",      icon: MessageCircle },
+  { id: "yoco",          label: "Yoco",          icon: CreditCard },
   { id: "backups",       label: "Backups",       icon: DatabaseBackup },
 ];
 
@@ -137,6 +140,7 @@ function SiteSettingsPageInner() {
   const [legalWebsiteUrl, setLegalWebsiteUrl] = useState("");
   const [legalEffectiveDate, setLegalEffectiveDate] = useState("");
   const [consentRetentionDays, setConsentRetentionDays] = useState("30");
+  const [notifyOnImpersonation, setNotifyOnImpersonation] = useState(false);
 
   // ── Load all settings once ────────────────────────────────────────────────
   useEffect(() => {
@@ -173,10 +177,11 @@ function SiteSettingsPageInner() {
         setLegalWebsiteUrl(s.legal_website_url || "");
         setLegalEffectiveDate(s.legal_effective_date || "");
         setConsentRetentionDays(s.consent_medical_retention_days || "30");
+        setNotifyOnImpersonation(s.notify_user_on_impersonation === "true");
       })
-      .catch((e: any) => setResult({ ok: false, message: e?.message || "Failed to load settings" }))
+      .catch((e: unknown) => setResult({ ok: false, message: errorMessage(e) || "Failed to load settings" }))
       .finally(() => setLoadingInitial(false));
-  }, [token]);
+  }, [token, setResult]);
 
   // Clear result when switching tabs
   const switchTab = (id: TabId) => { setActiveTab(id); setResult(null); };
@@ -190,8 +195,8 @@ function SiteSettingsPageInner() {
       await apiFetch("/api/settings", { method: "PUT", authToken: token, body: updates });
       setResult({ ok: true, message: "Saved." });
       reloadSettings();
-    } catch (e: any) {
-      setResult({ ok: false, message: e?.message || "Failed to save" });
+    } catch (e) {
+      setResult({ ok: false, message: errorMessage(e) || "Failed to save" });
     } finally {
       setSaving(false);
     }
@@ -249,8 +254,8 @@ function SiteSettingsPageInner() {
       setSuggestedColors([]);
       setResult({ ok: true, message: "Saved." });
       reloadSettings();
-    } catch (e: any) {
-      setResult({ ok: false, message: e?.message || "Failed to save" });
+    } catch (e) {
+      setResult({ ok: false, message: errorMessage(e) || "Failed to save" });
     } finally {
       setSaving(false);
     }
@@ -274,8 +279,8 @@ function SiteSettingsPageInner() {
       setSuggestedColors([]);
       setResult({ ok: true, message: "Reset to defaults." });
       reloadSettings();
-    } catch (e: any) {
-      setResult({ ok: false, message: e?.message || "Failed to reset" });
+    } catch (e) {
+      setResult({ ok: false, message: errorMessage(e) || "Failed to reset" });
     } finally {
       setSaving(false);
     }
@@ -308,8 +313,8 @@ function SiteSettingsPageInner() {
       if (smtpPass.trim() !== "") { setSmtpPassSet(true); setSmtpPass(""); }
       setResult({ ok: true, message: "Saved." });
       reloadSettings();
-    } catch (e: any) {
-      setResult({ ok: false, message: e?.message || "Failed to save" });
+    } catch (e) {
+      setResult({ ok: false, message: errorMessage(e) || "Failed to save" });
     } finally {
       setSaving(false);
     }
@@ -322,6 +327,7 @@ function SiteSettingsPageInner() {
     legal_website_url:    legalWebsiteUrl.trim(),
     legal_effective_date: legalEffectiveDate.trim(),
     consent_medical_retention_days: String(Math.max(0, parseInt(consentRetentionDays, 10) || 0)),
+    notify_user_on_impersonation: notifyOnImpersonation ? "true" : "false",
   });
 
   const handleTestSmtp = async () => {
@@ -342,8 +348,9 @@ function SiteSettingsPageInner() {
         },
       });
       setSmtpTestResult({ ok: true, message: "Connection successful — check your inbox for a test email." });
-    } catch (e: any) {
-      setSmtpTestResult({ ok: false, message: e?.message || "SMTP test failed", raw: e?.data?.raw });
+    } catch (e) {
+      const raw = e instanceof ApiError && typeof e.data?.raw === "string" ? e.data.raw : undefined;
+      setSmtpTestResult({ ok: false, message: errorMessage(e) || "SMTP test failed", raw });
     } finally {
       setSmtpTesting(false);
     }
@@ -670,6 +677,14 @@ function SiteSettingsPageInner() {
               <p className="text-xs text-gray-500 mt-1">Collected on parental consent forms. The consent record itself (who agreed, and when) is kept.</p>
             </div>
 
+            <div className="border-t pt-4">
+              <p className="text-sm font-medium text-gray-700 mb-3">Support access</p>
+              <label className="flex items-start gap-2 text-sm cursor-pointer">
+                <input type="checkbox" className="mt-0.5" checked={notifyOnImpersonation} onChange={e => setNotifyOnImpersonation(e.target.checked)} />
+                <span>Email a user when an admin views their account with &quot;Impersonate&quot; (read-only support access), including the reason given</span>
+              </label>
+            </div>
+
             <SaveBar saving={saving} onSave={saveLegal} result={result} />
           </div>
         )}
@@ -677,6 +692,9 @@ function SiteSettingsPageInner() {
         {/* ── WhatsApp ──────────────────────────────────────────────────────── */}
         {activeTab === "whatsapp" && <WhatsAppTab active={activeTab === "whatsapp"} />}
 
+        {/* ── Yoco ──────────────────────────────────────────────────────────── */}
+        {activeTab === "yoco" && <YocoTab active={activeTab === "yoco"} />}
+
         {/* ── Backups ───────────────────────────────────────────────────────── */}
         {activeTab === "backups" && <BackupsTab active={activeTab === "backups"} />}
       </div>
@@ -859,7 +877,7 @@ function WhatsAppTab({ active }: { active: boolean }) {
       const res = await apiFetch<StatusResponse>("/api/whatsapp/status", { authToken: token });
       setStatus(res.status ?? null);
       setStatusMsg(res.message ?? null);
-    } catch (e: any) {
+    } catch {
       await fetchConfig();
       setStatus("FAILED");
       setStatusMsg(null);
@@ -903,12 +921,12 @@ function WhatsAppTab({ active }: { active: boolean }) {
     setBusy(action);
     setActionMsg(null);
     try {
-      const res = await apiFetch<any>(`/api/whatsapp/${action}`, { method: "POST", authToken: token, body });
+      const res = await apiFetch<{ message?: string }>(`/api/whatsapp/${action}`, { method: "POST", authToken: token, body });
       setActionMsg({ type: "ok", text: res?.message || `${action} successful.` });
       await fetchStatus();
       await fetchConfig();
-    } catch (e: any) {
-      let msg = e?.message || `${action} failed.`;
+    } catch (e) {
+      let msg = errorMessage(e) || `${action} failed.`;
       try { msg = JSON.parse(msg)?.message || msg; } catch {}
       await fetchConfig();
       if (!msg.includes("SESSION_NOT_FOUND")) {
@@ -931,8 +949,8 @@ function WhatsAppTab({ active }: { active: boolean }) {
       await apiFetch("/api/whatsapp/config", { method: "POST", authToken: token!, body: { token: inputToken.trim(), instanceId: "" } });
       setInputToken("");
       await fetchConfig();
-    } catch (e: any) {
-      setActionMsg({ type: "err", text: e?.message || "Failed to save token." });
+    } catch (e) {
+      setActionMsg({ type: "err", text: errorMessage(e) || "Failed to save token." });
     } finally {
       setSavingToken(false);
     }
@@ -949,8 +967,8 @@ function WhatsAppTab({ active }: { active: boolean }) {
       await apiFetch("/api/whatsapp/config", { method: "POST", authToken: token!, body: { token: "", instanceId: inputInstanceId.trim() } });
       setInputInstanceId("");
       await fetchConfig();
-    } catch (e: any) {
-      setActionMsg({ type: "err", text: e?.message || "Failed to save Instance ID." });
+    } catch (e) {
+      setActionMsg({ type: "err", text: errorMessage(e) || "Failed to save Instance ID." });
     } finally {
       setSavingInstance(false);
     }
@@ -960,11 +978,11 @@ function WhatsAppTab({ active }: { active: boolean }) {
     setSavingInstance(true);
     setActionMsg(null);
     try {
-      const res = await apiFetch<any>("/api/whatsapp/create-instance", { method: "POST", authToken: token! });
+      const res = await apiFetch<{ message?: string }>("/api/whatsapp/create-instance", { method: "POST", authToken: token! });
       setActionMsg({ type: "ok", text: res?.message || "Instance created." });
       await fetchConfig();
-    } catch (e: any) {
-      setActionMsg({ type: "err", text: e?.message || "Failed to create instance." });
+    } catch (e) {
+      setActionMsg({ type: "err", text: errorMessage(e) || "Failed to create instance." });
     } finally {
       setSavingInstance(false);
     }
@@ -1208,8 +1226,8 @@ function WhatsAppTab({ active }: { active: boolean }) {
                     setInputToken("");
                     setInputInstanceId("");
                     await fetchConfig();
-                  } catch (e: any) {
-                    setActionMsg({ type: "err", text: e?.message || "Failed to update." });
+                  } catch (e) {
+                    setActionMsg({ type: "err", text: errorMessage(e) || "Failed to update." });
                   } finally {
                     setSavingToken(false);
                   }

frontend/src/app/dashboard/admin/users/page.tsx

@@ -5,8 +5,11 @@ import { useAuth } from "@/hooks/useAuth";
 import { useRouter } from "next/navigation";
 import { apiFetch } from "@/lib/api";
 import { useDismissingState } from "@/hooks/useDismissingState";
+import { beginImpersonation, type ImpersonationStart } from "@/lib/impersonation";
 import { Users as UsersIcon } from "lucide-react";
 import { RoleBadge, type Role as RoleBadgeRole } from "@/components/shared/RoleBadge";
+import { errorMessage } from "@/lib/utils";
+import type { Paginated } from "@/types";
 
 interface UserItem {
   id: string;
@@ -26,15 +29,6 @@ type Role = typeof roleOptions[number];
 
 const notificationPreferenceOptions = ["email", "whatsapp", "both"] as const;
 
-// Simple fuzzy: tolerate one missing/swapped char by checking if query chars appear in order
-function fuzzyMatch(query: string, target: string): boolean {
-  const q = query.toLowerCase();
-  const t = target.toLowerCase();
-  if (t.includes(q)) return true;
-  // token-based: all tokens must appear somewhere
-  const tokens = q.split(/\s+/).filter(Boolean);
-  return tokens.every(tok => t.includes(tok));
-}
 
 export default function AdminUsersPage() {
   const { user, loading, token } = useAuth();
@@ -97,26 +91,26 @@ export default function AdminUsersPage() {
     setFetching(true);
     try {
       const url = buildQuery(p, ps);
-      const res = await apiFetch<any>(url, { authToken: token });
+      const res = await apiFetch<Paginated<UserItem>>(url, { authToken: token });
       setUsers(Array.isArray(res?.data) ? res.data : []);
       setTotal(res?.total ?? 0);
       setTotalPages(res?.pages ?? 1);
       setPage(p);
-    } catch (e: any) {
-      setError(e?.message || "Failed to load users");
+    } catch (e) {
+      setError(errorMessage(e) || "Failed to load users");
     } finally {
       setFetching(false);
     }
-  }, [token, buildQuery]);
+  }, [token, buildQuery, pageSize, setError]);
 
-  // Initial load + reload on filter change
-  useEffect(() => { if (token) loadUsers(1); }, [token, debouncedQuery, roleFilter, activeFilter]);
+  // Initial load, and back to page 1 whenever a filter or the page size changes
+  // (loadUsers is recreated when any of them do).
+  useEffect(() => { if (token) loadUsers(1); }, [token, loadUsers]);
 
   const goToPage = (p: number) => loadUsers(p);
 
   const handlePageSizeChange = (newSize: number) => {
     setPageSize(newSize);
-    loadUsers(1, newSize);
   };
 
   const resetCreateForm = () => {
@@ -128,7 +122,7 @@ export default function AdminUsersPage() {
     if (!cEmail || !cPassword) { setError("Email and password are required"); return; }
     try {
       setCreating(true);
-      const created = await apiFetch<any>("/api/users", {
+      const created = await apiFetch<{ id?: string }>("/api/users", {
         method: "POST",
         body: { name: cName || cEmail.split("@")[0], email: cEmail, password: cPassword, phoneNumber: cPhone || undefined },
       });
@@ -140,8 +134,8 @@ export default function AdminUsersPage() {
       resetCreateForm();
       setCreateOpen(false);
       await loadUsers(page);
-    } catch (e: any) {
-      setError(e?.message || "Failed to create user");
+    } catch (e) {
+      setError(errorMessage(e) || "Failed to create user");
     } finally {
       setCreating(false);
     }
@@ -154,7 +148,7 @@ export default function AdminUsersPage() {
     if (!editingId) return;
     try {
       setSaving(true);
-      const payload: any = {
+      const payload: Partial<UserItem> & { password?: string } = {
         name: editData.name,
         email: editData.email,
         role: editData.role,
@@ -171,8 +165,8 @@ export default function AdminUsersPage() {
       setEditingId(null);
       setEditData({});
       await loadUsers(page);
-    } catch (e: any) {
-      setError(e?.message || "Failed to save user");
+    } catch (e) {
+      setError(errorMessage(e) || "Failed to save user");
     } finally {
       setSaving(false);
     }
@@ -182,8 +176,25 @@ export default function AdminUsersPage() {
     if (!confirm(`Revoke all active sessions for ${name}? They will be signed out on all devices.`)) return;
     try {
       await apiFetch(`/api/users/${encodeURIComponent(id)}/revoke-sessions`, { method: "POST", authToken: token! });
-    } catch (e: any) {
-      setError(e?.message || "Failed to revoke sessions");
+    } catch (e) {
+      setError(errorMessage(e) || "Failed to revoke sessions");
+    }
+  };
+
+  const [impTarget, setImpTarget] = useState<{ id: string; name: string } | null>(null);
+  const [impReason, setImpReason] = useState("");
+  const [impBusy, setImpBusy] = useState(false);
+  const [impError, setImpError] = useState<string | null>(null);
+  const startImpersonation = async () => {
+    if (!impTarget || !token) return;
+    setImpBusy(true);
+    setImpError(null);
+    try {
+      const res = await apiFetch<ImpersonationStart>(`/api/admin/impersonate/${encodeURIComponent(impTarget.id)}`, { method: "POST", authToken: token, body: { reason: impReason } });
+      beginImpersonation(res);
+    } catch (e) {
+      setImpError(errorMessage(e) || "Couldn't start impersonation");
+      setImpBusy(false);
     }
   };
 
@@ -197,8 +208,8 @@ export default function AdminUsersPage() {
     try {
       await apiFetch(`/api/users/${encodeURIComponent(id)}`, { method: "PUT", authToken: token!, body: { twoFactorEnabled: false } });
       await loadUsers(page);
-    } catch (e: any) {
-      setError(e?.message || "Failed to reset two-factor authentication");
+    } catch (e) {
+      setError(errorMessage(e) || "Failed to reset two-factor authentication");
     }
   };
 
@@ -207,8 +218,8 @@ export default function AdminUsersPage() {
     try {
       await apiFetch(`/api/users/${encodeURIComponent(id)}`, { method: "DELETE", authToken: token! });
       await loadUsers(page);
-    } catch (e: any) {
-      setError(e?.message || "Failed to deactivate user");
+    } catch (e) {
+      setError(errorMessage(e) || "Failed to deactivate user");
     }
   };
 
@@ -217,11 +228,29 @@ export default function AdminUsersPage() {
     try {
       await apiFetch(`/api/users/${encodeURIComponent(id)}/anonymize`, { method: "POST", authToken: token! });
       await loadUsers(page);
-    } catch (e: any) {
-      setError(e?.message || "Failed to delete user data");
+    } catch (e) {
+      setError(errorMessage(e) || "Failed to delete user data");
     }
   };
 
+  const impersonateModal = impTarget && (
+    <div className="fixed inset-0 bg-black/40 flex items-center justify-center z-50" onClick={() => !impBusy && setImpTarget(null)}>
+      <div className="bg-white rounded-xl shadow-lg max-w-md w-full mx-4 p-5 space-y-3" onClick={e => e.stopPropagation()}>
+        <h3 className="text-lg font-semibold">View as {impTarget.name}</h3>
+        <p className="text-sm text-gray-600">You&apos;ll see the site exactly as they do, for up to 30 minutes. It&apos;s strictly read-only: nothing can be registered, paid, changed or sent. The session, your reason and every page you open are recorded in the audit log.</p>
+        <div>
+          <label className="block text-xs text-gray-600 mb-1">Reason (required)</label>
+          <textarea className="w-full border rounded-lg px-3 py-2 text-sm" rows={2} value={impReason} onChange={e => setImpReason(e.target.value)} placeholder="e.g. Says their ticket isn't showing in My Events" maxLength={500} autoFocus />
+        </div>
+        {impError && <div className="p-2 rounded bg-red-50 text-red-800 text-sm">{impError}</div>}
+        <div className="flex justify-end gap-2">
+          <button className="px-3 py-1.5 text-sm rounded bg-gray-100 hover:bg-gray-200" onClick={() => setImpTarget(null)} disabled={impBusy}>Cancel</button>
+          <button className="px-3 py-1.5 text-sm rounded bg-violet-600 text-white hover:bg-violet-700 disabled:opacity-50" onClick={startImpersonation} disabled={impBusy || impReason.trim().length < 5}>{impBusy ? "Starting…" : "Start viewing"}</button>
+        </div>
+      </div>
+    </div>
+  );
+
   return (
     <div className="max-w-6xl mx-auto w-full p-6">
       <div className="flex items-center justify-between mb-4 flex-wrap gap-3">
@@ -367,6 +396,9 @@ export default function AdminUsersPage() {
                   <td className="p-2">
                     <div className="flex gap-1 flex-wrap">
                       <button className="px-2 py-1 text-xs rounded bg-gray-100 hover:bg-gray-200" onClick={() => startEdit(u)}>Edit</button>
+                      {user?.role === "admin" && u.role !== "admin" && u.isActive && (
+                        <button className="px-2 py-1 text-xs rounded bg-violet-600 text-white hover:bg-violet-700" onClick={() => { setImpTarget({ id: u.id, name: u.name }); setImpReason(""); setImpError(null); }} title="See the site exactly as this user sees it (read-only, 30 minutes, audited)">Impersonate</button>
+                      )}
                       <button className="px-2 py-1 text-xs rounded bg-amber-500 text-white hover:bg-amber-600" onClick={() => revokeUserSessions(u.id, u.name)} title="Force this user to sign in again on every device where they're currently logged in">Sign out everywhere</button>
                       {u.twoFactorEnabled && (
                         <button className="px-2 py-1 text-xs rounded bg-amber-500 text-white hover:bg-amber-600" onClick={() => resetTwoFactor(u.id, u.name, u.role)} title={u.role === "admin" || u.role === "supervisor" ? "Reset two-factor authentication — they set it up again at their next login" : "Turn off two-factor authentication for a user who can no longer receive their codes"}>Reset 2FA</button>
@@ -498,6 +530,7 @@ export default function AdminUsersPage() {
           </div>
         </div>
       )}
+      {impersonateModal}
     </div>
   );
 }

frontend/src/app/dashboard/staff/event-tickets/page.tsx

@@ -8,6 +8,8 @@ import { useRouter, useSearchParams } from "next/navigation";
 import { formatDate } from "@/lib/date";
 import { QrImage } from "@/components/shared/QrImage";
 import { Ticket } from "lucide-react";
+import { errorMessage } from "@/lib/utils";
+import type { Event, Ticket as TicketRecord } from "@/types";
 
 function EventTicketsContent() {
   const { token, user } = useAuth();
@@ -17,9 +19,9 @@ function EventTicketsContent() {
   const paramEventId = params.get("eventId") || "";
   const paramUserId = params.get("userId") || "";
 
-  const [events, setEvents] = useState<any[]>([]);
+  const [events, setEvents] = useState<Event[]>([]);
   const [eventId, setEventId] = useState<string>(paramEventId);
-  const [tickets, setTickets] = useState<any[]>([]);
+  const [tickets, setTickets] = useState<TicketRecord[]>([]);
   const [error, setError] = useDismissingState<string | null>(null);
   const [loading, setLoading] = useState(false);
 
@@ -36,7 +38,7 @@ function EventTicketsContent() {
     (async () => {
       try {
         if (!token) return;
-        const evs = await apiFetch<any[]>("/api/events/all", { authToken: token });
+        const evs = await apiFetch<Event[]>("/api/events/all", { authToken: token });
         const now = Date.now();
         const active = (evs || []).filter((ev) => {
           const t = new Date(ev.endDate).getTime();
@@ -47,25 +49,27 @@ function EventTicketsContent() {
                 new Date(a.startDate).getTime() - new Date(b.startDate).getTime()
         );
         setEvents(active);
-        if (!paramEventId && active.length > 0) {
-          setEventId(active[0].id);
-          router.replace(
-              `?eventId=${encodeURIComponent(active[0].id)}${
-                  selectedUserId ? `&userId=${encodeURIComponent(selectedUserId)}` : ""
-              }`
-          );
-        }
-      } catch (e: any) {
-        setError(e?.message || "Failed to load events");
+      } catch (e) {
+        setError(errorMessage(e) || "Failed to load events");
       }
     })();
-  }, [token]);
+  }, [token, setError]);
 
-  // Sync params → state
+  // No event in the URL: default to the first upcoming one once the list arrives.
   useEffect(() => {
-    if (paramEventId && paramEventId !== eventId) setEventId(paramEventId);
-    if (paramUserId && paramUserId !== selectedUserId)
-      setSelectedUserId(paramUserId);
+    if (paramEventId || events.length === 0) return;
+    setEventId(events[0].id);
+    router.replace(
+        `?eventId=${encodeURIComponent(events[0].id)}${
+            selectedUserId ? `&userId=${encodeURIComponent(selectedUserId)}` : ""
+        }`
+    );
+  }, [events, paramEventId, router, selectedUserId]);
+
+  // Sync params → state (setting the value it already has is a no-op)
+  useEffect(() => {
+    if (paramEventId) setEventId(paramEventId);
+    if (paramUserId) setSelectedUserId(paramUserId);
   }, [paramEventId, paramUserId]);
 
   // Load tickets when event changes
@@ -75,18 +79,18 @@ function EventTicketsContent() {
       setLoading(true);
       setError(null);
       try {
-        const list = await apiFetch<any[]>(
+        const list = await apiFetch<TicketRecord[]>(
             `/api/tickets/event/${encodeURIComponent(eventId)}`,
             { authToken: token }
         );
         setTickets(list);
-      } catch (e: any) {
-        setError(e?.message || "Failed to load tickets");
+      } catch (e) {
+        setError(errorMessage(e) || "Failed to load tickets");
       } finally {
         setLoading(false);
       }
     })();
-  }, [token, eventId]);
+  }, [token, eventId, setError]);
 
   // Build variants list for filter (only variants present in current event's tickets)
   const variantsList = useMemo(() => {
@@ -138,7 +142,7 @@ function EventTicketsContent() {
   }, [tickets, eventId, selectedUserId, selectedVariantId]);
 
   // Printing helpers
-  const buildTicketHtmlCard = (t: any) => {
+  const buildTicketHtmlCard = (t: TicketRecord) => {
     const eventTitle = t.event?.title || t.eventId || "Event";
     const eventDate = t.event?.startDate ? new Date(t.event.startDate) : null;
     const optBase = t.registrationOption?.eventOption?.name || "Ticket";
@@ -216,7 +220,7 @@ function EventTicketsContent() {
     w.focus();
   };
 
-  const printTickets = (ticketList: any[]) => {
+  const printTickets = (ticketList: TicketRecord[]) => {
     if (!ticketList || ticketList.length === 0) return;
     // Chunk into pages of 8 (2 columns × 4 rows per A4 sheet)
     const PAGE_SIZE = 8;

frontend/src/app/dashboard/staff/my-groups/page.tsx

@@ -0,0 +1,96 @@
+"use client";
+
+import React, { useEffect, useState } from "react";
+import { useAuth } from "@/hooks/useAuth";
+import { useRouter } from "next/navigation";
+import { apiFetch } from "@/lib/api";
+import { formatDate } from "@/lib/date";
+import { Users } from "lucide-react";
+
+type Member = {
+  id: string; name: string; gender: string | null; dateOfBirth: string | null; phone: string | null;
+  parentName: string | null; parentPhone: string | null; bookedBy: string; bookedByPhone: string | null;
+  medical?: Record<string, string> | null; emergency?: Record<string, string> | null;
+};
+type MyGroup = { id: string; name: string; capacity: number | null; setName: string; event: { id: string; title: string; startDate: string }; members: Member[] };
+
+const ageOn = (dob: string | null, on: string) => {
+  if (!dob) return null;
+  const d = new Date(dob), e = new Date(on);
+  let age = e.getFullYear() - d.getFullYear();
+  if (e.getMonth() < d.getMonth() || (e.getMonth() === d.getMonth() && e.getDate() < d.getDate())) age -= 1;
+  return age;
+};
+
+/** Groups the signed-in staff member leads (rooms, small groups, buses) and who's in them. */
+export default function MyGroupsPage() {
+  const { token } = useAuth();
+  const router = useRouter();
+  const [data, setData] = useState<{ medicalShown: boolean; groups: MyGroup[] } | null>(null);
+  const [error, setError] = useState<string | null>(null);
+
+  useEffect(() => {
+    if (!token) return;
+    apiFetch<{ medicalShown: boolean; groups: MyGroup[] }>("/api/allocations/my-groups", { authToken: token })
+      .then(setData).catch(e => setError(e?.message || "Failed to load your groups"));
+  }, [token]);
+
+  return (
+    <div className="max-w-4xl mx-auto w-full p-6">
+      <div className="flex items-center gap-3 mb-4">
+        <div className="w-10 h-10 rounded-xl bg-brand-50 flex items-center justify-center shrink-0">
+          <Users className="w-5 h-5 text-brand-600" />
+        </div>
+        <div>
+          <button className="text-xs text-brand-600 hover:underline" onClick={() => router.push("/dashboard")}>← Back to dashboard</button>
+          <h1 className="text-2xl font-semibold text-gray-900 mt-0.5">My groups</h1>
+          <p className="text-sm text-gray-500">Rooms, small groups and buses you lead</p>
+        </div>
+      </div>
+      {error && <div className="mb-3 p-3 border rounded bg-red-50 text-red-800 text-sm">{error}</div>}
+      {data && data.groups.length === 0 && <p className="text-sm text-gray-600">You aren&apos;t leading any groups for upcoming events.</p>}
+      <div className="space-y-4">
+        {data?.groups.map(g => (
+          <section key={g.id} className="border rounded-xl p-4 bg-white shadow-sm">
+            <div className="flex flex-wrap items-baseline justify-between gap-2 mb-2">
+              <h2 className="font-semibold">{g.name} <span className="text-sm font-normal text-gray-500">· {g.setName}</span></h2>
+              <span className="text-xs text-gray-500">{g.event.title} · {formatDate(new Date(g.event.startDate))} · {g.members.length}{g.capacity ? ` / ${g.capacity}` : ""} people</span>
+            </div>
+            {g.members.length === 0 ? <p className="text-sm text-gray-500">Nobody has been placed in this group yet.</p> : (
+              <div className="overflow-x-auto">
+                <table className="w-full text-sm">
+                  <thead><tr className="text-left text-xs text-gray-500 border-b">
+                    <th className="py-1 pr-3">Name</th><th className="py-1 pr-3">Age</th><th className="py-1 pr-3">Contact</th>
+                    {data.medicalShown && <th className="py-1 pr-3">Medical</th>}
+                  </tr></thead>
+                  <tbody>
+                    {g.members.map(m => {
+                      const age = ageOn(m.dateOfBirth, g.event.startDate);
+                      return (
+                        <tr key={m.id} className="border-b last:border-0 align-top">
+                          <td className="py-1.5 pr-3 font-medium">{m.name}</td>
+                          <td className="py-1.5 pr-3">{age ?? "—"}</td>
+                          <td className="py-1.5 pr-3 text-xs">
+                            {m.phone && <div>{m.phone}</div>}
+                            {m.parentName ? <div>Parent: {m.parentName}{m.parentPhone ? ` · ${m.parentPhone}` : ""}</div> : m.bookedBy && <div>Booked by {m.bookedBy}{m.bookedByPhone ? ` · ${m.bookedByPhone}` : ""}</div>}
+                          </td>
+                          {data.medicalShown && (
+                            <td className="py-1.5 pr-3 text-xs">
+                              {m.medical ? Object.values(m.medical).filter(Boolean).join("; ") || "—" : "—"}
+                              {m.emergency && Object.values(m.emergency).some(Boolean) && <div className="text-gray-500">Emergency: {Object.values(m.emergency).filter(Boolean).join(", ")}</div>}
+                            </td>
+                          )}
+                        </tr>
+                      );
+                    })}
+                  </tbody>
+                </table>
+              </div>
+            )}
+          </section>
+        ))}
+      </div>
+      {data && !data.medicalShown && data.groups.length > 0 && <p className="text-xs text-gray-500 mt-3">Medical details are only shown to supervisors. Ask one if you need them.</p>}
+    </div>
+  );
+}

frontend/src/app/dashboard/staff/page.tsx

@@ -1,18 +1,20 @@
 "use client";
 
-import React, { useEffect, useMemo, useRef, useState } from "react";
+import React, { useCallback, useEffect, useMemo, useRef, useState } from "react";
 import { useAuth } from "@/hooks/useAuth";
 import { useRouter } from "next/navigation";
 import { apiFetch } from "@/lib/api";
 import { useStableState } from "@/hooks/useStableState";
 import { useVisiblePolling } from "@/hooks/useVisiblePolling";
-import { QrCode, Ticket, Activity, UserCheck, Clock } from "lucide-react";
+import { QrCode, Ticket, Activity, UserCheck, Clock, Users } from "lucide-react";
 import { StatCard, StatCardRow } from "@/components/shared/StatCard";
 import { QuickActionTile, QuickActionGrid } from "@/components/shared/QuickActionTile";
+import type { DashboardStats, RecentScan, ScanStats } from "@/types";
 
 const QUICK_ACTIONS = [
   { href: "/dashboard/staff/ticket-scanning", label: "Scan tickets", description: "Use your device camera to validate tickets", icon: QrCode },
   { href: "/dashboard/staff/event-tickets", label: "Event tickets & printing", description: "Browse event tickets and print lists", icon: Ticket },
+  { href: "/dashboard/staff/my-groups", label: "My groups", description: "Rooms and groups you lead", icon: Users },
 ] as const;
 
 export default function StaffDashboardPage() {
@@ -34,31 +36,31 @@ export default function StaffDashboardPage() {
   // (/api/stats/staff) instead of two separate calls. useStableState skips re-renders when
   // a poll returns identical data, and hasLoadedOnce below means "Refreshing…" only shows
   // on the very first load — together these stop the stats panel from flickering.
-  const [stats, setStats] = useStableState<any | null>(null);
-  const [recentScans, setRecentScans] = useStableState<any[]>([]);
+  const [stats, setStats] = useStableState<ScanStats | null>(null);
+  const [recentScans, setRecentScans] = useStableState<RecentScan[]>([]);
   const [loadingStats, setLoadingStats] = useState(false);
   const hasLoadedOnce = useRef(false);
 
-  const loadStats = async () => {
+  const loadStats = useCallback(async () => {
     if (!token) return;
     const isFirstLoad = !hasLoadedOnce.current;
     try {
       if (isFirstLoad) setLoadingStats(true);
-      const data = await apiFetch<any>("/api/stats/staff", { authToken: token });
+      const data = await apiFetch<DashboardStats>("/api/stats/staff", { authToken: token });
       setStats(data.scanStats);
       setRecentScans(Array.isArray(data.recentScans) ? data.recentScans : []);
-    } catch (e) {
+    } catch {
       // ignore
     } finally {
       hasLoadedOnce.current = true;
       if (isFirstLoad) setLoadingStats(false);
     }
-  };
+  }, [token, setStats, setRecentScans]);
 
   useEffect(() => {
     if (!token) return;
     loadStats();
-  }, [token]);
+  }, [token, loadStats]);
 
   // Poll every 10s while the tab is visible; pause in the background and refetch
   // immediately on return instead of leaving stale numbers up.
@@ -103,7 +105,7 @@ export default function StaffDashboardPage() {
               {loadingStats && <span className="text-xs text-gray-500">Refreshing…</span>}
             </div>
             <ul className="text-sm space-y-2 max-h-96 overflow-auto pr-2">
-              {recentScans.map((u: any) => (
+              {recentScans.map((u) => (
                 <li key={u.id} className="border rounded p-2">
                   <div className="flex justify-between">
                     <div className="font-medium">{u.ticket?.event?.title || u.ticket?.eventId || 'Event'}</div>
@@ -121,9 +123,9 @@ export default function StaffDashboardPage() {
         <div>
           <div className="border rounded-xl p-4 bg-white shadow-sm">
             <h2 className="text-lg font-semibold mb-3">Today by staff</h2>
-            {stats?.byStaff?.length > 0 ? (
+            {stats && stats.byStaff?.length > 0 ? (
               <ul className="text-sm text-gray-700 space-y-1">
-                {stats.byStaff.map((s: any) => (
+                {stats.byStaff.map((s) => (
                   <li key={s.scannedById} className="flex justify-between">
                     <span>{s.name || 'Staff'}</span>
                     <span className="font-medium">{s.count}</span>

frontend/src/app/dashboard/staff/ticket-scanning/page.tsx

@@ -1,6 +1,6 @@
 "use client";
 
-import React, { useEffect, useMemo, useRef, useState } from "react";
+import React, { useCallback, useEffect, useMemo, useRef, useState } from "react";
 import { QRScanner, QRScannerHandle } from "@/components/qr/QRScanner";
 import { useAuth } from "@/hooks/useAuth";
 import { apiFetch } from "@/lib/api";
@@ -10,19 +10,39 @@ import { QrCode } from "lucide-react";
 import { useOfflineScanning } from "@/components/scanner/useOfflineScanning";
 import { OfflineScanPanel } from "@/components/scanner/OfflineScanPanel";
 import type { SnapshotTicket } from "@/lib/offlineScan";
+import { errorMessage } from "@/lib/utils";
+import type { Event, RecentScan, ScanStats, Section } from "@/types";
+
+// GET /api/tickets/scan-preview/:qr — just the fields the confirm step needs. Offline
+// scans build the same shape from the downloaded ticket list.
+type ScanTicket = {
+  id: string;
+  eventId?: string;
+  eventOptionId?: string;
+  quantity?: number;
+  consentStatus?: string;
+  event?: { id?: string; title?: string } | null;
+  registrationOption?: {
+    eventOption?: { id?: string; name?: string } | null;
+    variant?: { name?: string } | null;
+    registration?: { user?: { name?: string } | null } | null;
+  } | null;
+  attendee?: { name: string } | null;
+  user?: { name?: string; email?: string } | null;
+  usages?: { id: string; scannedAt: string; quantityRedeemed?: number }[];
+};
 
 export default function TicketScanningPage() {
   const router = useRouter();
   const scannerRef = useRef<QRScannerHandle>(null);
-  const [lastResult, setLastResult] = useState<string | null>(null);
   const [scanInfo, setScanInfo] = useDismissingState<string | null>(null);
   const [error, setError] = useDismissingState<string | null>(null);
-  const [alreadyUsedModal, setAlreadyUsedModal] = useState<{ message: string; ticket?: any } | null>(null);
+  const [alreadyUsedModal, setAlreadyUsedModal] = useState<{ message: string; ticket?: ScanTicket } | null>(null);
   const [errorModal, setErrorModal] = useState<string | null>(null);
   const { token, user } = useAuth();
   const offline = useOfflineScanning(token);
-  const [recentScans, setRecentScans] = useState<any[]>([]);
-  const [stats, setStats] = useState<any | null>(null);
+  const [recentScans, setRecentScans] = useState<RecentScan[]>([]);
+  const [stats, setStats] = useState<ScanStats | null>(null);
   const [loadingStats, setLoadingStats] = useState<boolean>(false);
   const [successModal, setSuccessModal] = useState<{
     optionName: string;
@@ -36,7 +56,7 @@ export default function TicketScanningPage() {
   // Confirm step state
   const [confirmModal, setConfirmModal] = useState<{
     qrCode: string;
-    ticket: any;
+    ticket: ScanTicket;
     remaining: number;
     offlineTicket?: SnapshotTicket; // scanned against the downloaded list (offline mode)
   } | null>(null);
@@ -47,11 +67,11 @@ export default function TicketScanningPage() {
   const [confirmQtyRaw, setConfirmQtyRaw] = useState("1");
 
   // Event selection state
-  const [allEvents, setAllEvents] = useState<any[]>([]);
+  const [allEvents, setAllEvents] = useState<Event[]>([]);
   const [includePastEvents, setIncludePastEvents] = useState(false);
   const [selectedEventId, setSelectedEventId] = useState<string>("all");
   const [loadingEvents, setLoadingEvents] = useState<boolean>(false);
-  const [sections, setSections] = useState<any[]>([]);
+  const [sections, setSections] = useState<Section[]>([]);
   const [selectedSectionId, setSelectedSectionId] = useState<string>("all");
   const [loadingSections, setLoadingSections] = useState(false);
 
@@ -61,10 +81,10 @@ export default function TicketScanningPage() {
       try {
         if (!token) return;
         setLoadingEvents(true);
-        const evs = await apiFetch<any[]>("/api/events/all?includePast=true", { authToken: token });
+        const evs = await apiFetch<Event[]>("/api/events/all?includePast=true", { authToken: token });
         const sorted = (evs || []).sort((a, b) => new Date(a.endDate).getTime() - new Date(b.endDate).getTime());
         setAllEvents(sorted);
-      } catch (e: any) {
+      } catch {
         // non-fatal
       } finally {
         setLoadingEvents(false);
@@ -90,7 +110,7 @@ export default function TicketScanningPage() {
       }
       try {
         setLoadingSections(true);
-        const list = await apiFetch<any[]>(`/api/sections?eventId=${selectedEventId}`, { authToken: token });
+        const list = await apiFetch<Section[]>(`/api/sections?eventId=${selectedEventId}`, { authToken: token });
         setSections(Array.isArray(list) ? list : []);
         setSelectedSectionId("all");
       } catch {
@@ -120,7 +140,6 @@ export default function TicketScanningPage() {
   }, [selectedEventId, selectedSectionId]);
 
   async function handleResult(text: string) {
-    setLastResult(text);
     setError(null);
     setScanInfo(null);
     try {
@@ -157,11 +176,11 @@ export default function TicketScanningPage() {
 
       // Always preview first to validate the ticket before showing confirm step
       // Uses the lightweight scan-preview endpoint (only fetches fields needed for the confirm modal)
-      let preview: any;
+      let preview: ScanTicket;
       try {
-        preview = await apiFetch<any>(`/api/tickets/scan-preview/${encodeURIComponent(text)}`, { authToken: token });
-      } catch (pe: any) {
-        setErrorModal(pe?.message || 'Failed to validate ticket');
+        preview = await apiFetch<ScanTicket>(`/api/tickets/scan-preview/${encodeURIComponent(text)}`, { authToken: token });
+      } catch (pe) {
+        setErrorModal(errorMessage(pe) || 'Failed to validate ticket');
         return;
       }
 
@@ -182,7 +201,7 @@ export default function TicketScanningPage() {
             return;
           }
           const section = sections.find(s => s.id === selectedSectionId);
-          const allowedOptionIds = (section?.allowedOptions || []).map((o: any) => o.eventOptionId);
+          const allowedOptionIds = (section?.allowedOptions || []).map((o) => o.eventOptionId);
           if (!allowedOptionIds.includes(ticketOptionId)) {
             setErrorModal("This ticket is not valid for this section");
             return;
@@ -192,7 +211,7 @@ export default function TicketScanningPage() {
 
       // Compute remaining qty
       const ticketQty = preview?.quantity || 1;
-      const totalRedeemed = (preview?.usages || []).reduce((s: number, u: any) => s + (u.quantityRedeemed || 1), 0);
+      const totalRedeemed = (preview?.usages || []).reduce((s, u) => s + (u.quantityRedeemed || 1), 0);
       const remaining = ticketQty - totalRedeemed;
 
       if (remaining <= 0) {
@@ -204,8 +223,8 @@ export default function TicketScanningPage() {
       setConfirmQty(remaining);
       setConfirmQtyRaw(String(remaining));
       setConfirmModal({ qrCode: text, ticket: preview, remaining });
-    } catch (e: any) {
-      setErrorModal(e?.message || "Failed to scan ticket");
+    } catch (e) {
+      setErrorModal(errorMessage(e) || "Failed to scan ticket");
     }
   }
 
@@ -239,9 +258,9 @@ export default function TicketScanningPage() {
     if (offlineTicket) {
       try {
         await offline.scanLocally(offlineTicket, qty);
-      } catch (e: any) {
+      } catch (e) {
         setSuccessModal(null);
-        setErrorModal(e?.message || "Couldn't save the scan on this device");
+        setErrorModal(errorMessage(e) || "Couldn't save the scan on this device");
       }
       return;
     }
@@ -251,7 +270,7 @@ export default function TicketScanningPage() {
       const url = `/api/tickets/scan/${encodeURIComponent(qrCode)}${
         selectedEventId && selectedEventId !== "all" ? `?eventId=${encodeURIComponent(selectedEventId)}` : ''
       }`;
-      await apiFetch<any>(url, {
+      await apiFetch(url, {
         method: "POST",
         authToken: token,
         body: {
@@ -262,10 +281,10 @@ export default function TicketScanningPage() {
         },
       });
       refreshStatsAndRecent();
-    } catch (e: any) {
+    } catch (e) {
       setSuccessModal(null);
       setScanInfo(null);
-      const raw = e?.message || "Failed to scan ticket";
+      const raw = errorMessage(e) || "Failed to scan ticket";
       try {
         const parsed = JSON.parse(raw);
         const msg: string | undefined = parsed?.message;
@@ -280,28 +299,27 @@ export default function TicketScanningPage() {
     }
   }
 
-  const loadRecent = async () => {
+  const loadRecent = useCallback(async () => {
     if (!token) return;
     try {
-      const list = await apiFetch<any[]>(`/api/tickets/scans/recent?limit=10`, { authToken: token });
+      const list = await apiFetch<RecentScan[]>(`/api/tickets/scans/recent?limit=10`, { authToken: token });
       setRecentScans(list);
     } catch {}
-  };
-  const loadStats = async () => {
+  }, [token]);
+  const loadStats = useCallback(async () => {
     if (!token) return;
     try {
       setLoadingStats(true);
-      const s = await apiFetch<any>(`/api/tickets/scans/stats`, { authToken: token });
+      const s = await apiFetch<ScanStats>(`/api/tickets/scans/stats`, { authToken: token });
       setStats(s);
     } catch {} finally {
       setLoadingStats(false);
     }
-  };
-  const refreshStatsAndRecent = () => { loadRecent(); loadStats(); };
+  }, [token]);
+  const refreshStatsAndRecent = useCallback(() => { loadRecent(); loadStats(); }, [loadRecent, loadStats]);
   useEffect(() => {
     refreshStatsAndRecent();
-  // eslint-disable-next-line react-hooks/exhaustive-deps
-  }, [token]);
+  }, [refreshStatsAndRecent]);
 
   return (
     <div className="max-w-6xl mx-auto w-full p-4">
@@ -403,11 +421,11 @@ export default function TicketScanningPage() {
             </div>
           )}
 
-          {stats?.byStaff?.length > 0 && (
+          {stats && stats.byStaff?.length > 0 && (
             <div className="mb-4">
               <div className="text-sm font-medium mb-1">Today by staff</div>
               <ul className="text-sm text-gray-700 space-y-1">
-                {stats.byStaff.map((s: any) => (
+                {stats.byStaff.map((s) => (
                   <li key={s.scannedById} className="flex justify-between">
                     <span>{s.name || 'Staff'}</span>
                     <span className="font-medium">{s.count}</span>
@@ -419,7 +437,7 @@ export default function TicketScanningPage() {
 
           <h3 className="text-lg font-semibold mb-2">Last 10 scans</h3>
           <ul className="text-sm space-y-2 max-h-80 overflow-auto pr-2">
-            {recentScans.map((u: any) => (
+            {recentScans.map((u) => (
               <li key={u.id} className="border rounded p-2 bg-white">
                 <div className="flex justify-between">
                   <div className="font-medium">{u.ticket?.event?.title || 'Event'}</div>
@@ -533,8 +551,8 @@ export default function TicketScanningPage() {
                   <div className="mt-2">
                     <div className="font-medium">Usages:</div>
                     <ul className="list-disc ml-5 mt-1 max-h-32 overflow-auto">
-                      {alreadyUsedModal.ticket.usages.map((u: any) => (
-                        <li key={u.id}>{new Date(u.scannedAt).toLocaleString()}{u.quantityRedeemed > 1 ? ` (×${u.quantityRedeemed})` : ''}</li>
+                      {alreadyUsedModal.ticket.usages.map((u) => (
+                        <li key={u.id}>{new Date(u.scannedAt).toLocaleString()}{(u.quantityRedeemed ?? 1) > 1 ? ` (×${u.quantityRedeemed})` : ''}</li>
                       ))}
                     </ul>
                   </div>

frontend/src/app/dashboard/supervisor/allocations/page.tsx

@@ -0,0 +1,327 @@
+"use client";
+
+import React, { useCallback, useEffect, useMemo, useState } from "react";
+import { useAuth } from "@/hooks/useAuth";
+import { useRouter } from "next/navigation";
+import { DndContext, DragEndEvent, PointerSensor, TouchSensor, useDraggable, useDroppable, useSensor, useSensors } from "@dnd-kit/core";
+import { apiFetch } from "@/lib/api";
+import { formatDate } from "@/lib/date";
+import { useDismissingState } from "@/hooks/useDismissingState";
+import { BedDouble, Plus, Wand2, Printer, Trash2, Pencil, Eraser } from "lucide-react";
+import { errorMessage } from "@/lib/utils";
+import type { Event } from "@/types";
+
+type Group = { id: string; name: string; capacity: number | null; gender: "male" | "female" | null; leaderUserId: string | null; leader?: { id: string; name: string } | null };
+type AllocSet = { id: string; name: string; showOnTicket: boolean; groups: Group[]; assignments: { attendeeId: string; groupId: string }[] };
+type Person = { id: string; name: string; gender: string | null; dateOfBirth: string | null; registrationId: string; bookedBy: string };
+// GET /api/allocations/sets/:id/lists — medical/emergency only when ?medical=true and consent was given.
+type ListMember = {
+  groupId: string; id: string; name: string; gender: string | null; dateOfBirth: string | null;
+  phone: string | null; parentName: string | null; parentPhone: string | null; bookedBy: string; bookedByPhone: string | null;
+  medical?: Record<string, unknown> | null; emergency?: Record<string, unknown> | null;
+};
+type SetLists = {
+  set: { id: string; name: string };
+  event: { id: string; title: string; startDate: string };
+  groups: { id: string; name: string; capacity: number | null; gender: string | null; leader: string | null; members: ListMember[] }[];
+};
+type Board = { event: { id: string; title: string; startDate: string; collectGender: boolean; requiresParentalConsent: boolean }; sets: AllocSet[]; attendees: Person[]; leaders: { id: string; name: string }[]; unnamedPlaces: number };
+
+const UNASSIGNED = "unassigned";
+const esc = (s: unknown) => String(s ?? "").replace(/[&<>"']/g, c => ({ "&": "&amp;", "<": "&lt;", ">": "&gt;", '"': "&quot;", "'": "&#39;" }[c]!));
+const genderLabel = (g: string | null) => (g === "male" ? "Male" : g === "female" ? "Female" : "");
+const ageOn = (dob: string | null, on: string) => {
+  if (!dob) return null;
+  const d = new Date(dob), e = new Date(on);
+  let age = e.getFullYear() - d.getFullYear();
+  if (e.getMonth() < d.getMonth() || (e.getMonth() === d.getMonth() && e.getDate() < d.getDate())) age -= 1;
+  return age;
+};
+
+function PersonChip({ person, eventStart }: { person: Person; eventStart: string }) {
+  const { attributes, listeners, setNodeRef, transform, isDragging } = useDraggable({ id: person.id });
+  const age = ageOn(person.dateOfBirth, eventStart);
+  return (
+    <div
+      ref={setNodeRef}
+      {...listeners}
+      {...attributes}
+      style={transform ? { transform: `translate(${transform.x}px, ${transform.y}px)`, zIndex: 50 } : undefined}
+      className={`px-2 py-1.5 rounded-lg border bg-white text-sm cursor-grab active:cursor-grabbing select-none touch-none ${isDragging ? "shadow-lg ring-2 ring-brand-300" : "shadow-sm"}`}
+      title={person.bookedBy ? `Booked by ${person.bookedBy}` : undefined}
+    >
+      <span className="font-medium">{person.name}</span>
+      <span className="text-xs text-gray-500">
+        {[genderLabel(person.gender), age != null ? `${age}` : "", person.bookedBy ? `· ${person.bookedBy}` : ""].filter(Boolean).map(s => ` ${s}`).join("")}
+      </span>
+    </div>
+  );
+}
+
+function Column({ id, title, subtitle, full, children, actions }: { id: string; title: string; subtitle?: string; full?: boolean; children: React.ReactNode; actions?: React.ReactNode }) {
+  const { setNodeRef, isOver } = useDroppable({ id });
+  return (
+    <div ref={setNodeRef} className={`rounded-xl border p-3 min-h-[8rem] transition-colors ${isOver ? "bg-brand-50 border-brand-300" : full ? "bg-gray-50" : "bg-white"}`}>
+      <div className="flex items-start justify-between gap-2 mb-2">
+        <div>
+          <div className="font-semibold text-sm">{title}</div>
+          {subtitle && <div className={`text-xs ${full ? "text-amber-700" : "text-gray-500"}`}>{subtitle}</div>}
+        </div>
+        {actions}
+      </div>
+      <div className="space-y-1.5">{children}</div>
+    </div>
+  );
+}
+
+export default function AllocationsPage() {
+  const { user, loading, token } = useAuth();
+  const router = useRouter();
+  const canView = useMemo(() => user?.role === "admin" || user?.role === "supervisor", [user]);
+  useEffect(() => { if (!loading && !user) router.replace("/login"); }, [user, loading, router]);
+
+  const [events, setEvents] = useState<Event[]>([]);
+  const [eventId, setEventId] = useState("");
+  const [board, setBoard] = useState<Board | null>(null);
+  const [setId, setSetId] = useState("");
+  const [busy, setBusy] = useState(false);
+  const [error, setError] = useDismissingState<string | null>(null);
+  const [info, setInfo] = useDismissingState<string | null>(null);
+  const [groupForm, setGroupForm] = useState<{ id?: string; name: string; capacity: string; gender: string; leaderUserId: string } | null>(null);
+  const [newSetName, setNewSetName] = useState("");
+  const sensors = useSensors(useSensor(PointerSensor, { activationConstraint: { distance: 5 } }), useSensor(TouchSensor, { activationConstraint: { delay: 150, tolerance: 5 } }));
+
+  useEffect(() => {
+    if (!token || !canView) return;
+    apiFetch<Event[]>("/api/events/all?includePast=true", { authToken: token })
+      .then(evs => {
+        const upcoming = (evs || []).filter(e => new Date(e.endDate).getTime() > Date.now() - 7 * 864e5)
+          .sort((a, b) => new Date(a.startDate).getTime() - new Date(b.startDate).getTime());
+        setEvents(upcoming);
+        if (upcoming.length) setEventId(id => id || upcoming[0].id);
+      })
+      .catch(e => setError(e?.message || "Failed to load events"));
+  }, [token, canView, setError]);
+
+  const load = useCallback(async () => {
+    if (!token || !eventId) return;
+    try {
+      const b = await apiFetch<Board>(`/api/allocations/event/${encodeURIComponent(eventId)}`, { authToken: token });
+      setBoard(b);
+      setSetId(id => (b.sets.some(s => s.id === id) ? id : b.sets[0]?.id || ""));
+    } catch (e) {
+      setError(errorMessage(e) || "Failed to load allocations");
+    }
+  }, [token, eventId, setError]);
+  useEffect(() => { load(); }, [load]);
+
+  const current = board?.sets.find(s => s.id === setId) || null;
+  const groupOf = useMemo(() => new Map((current?.assignments || []).map(a => [a.attendeeId, a.groupId])), [current]);
+  const membersOf = (groupId: string) => (board?.attendees || []).filter(p => groupOf.get(p.id) === groupId);
+  const unassigned = (board?.attendees || []).filter(p => !groupOf.has(p.id));
+
+  const call = async <T,>(path: string, method: string, body?: unknown): Promise<T> =>
+    apiFetch<T>(path, { method, authToken: token!, ...(body !== undefined ? { body } : {}) });
+
+  const onDragEnd = async (e: DragEndEvent) => {
+    if (!current || !e.over) return;
+    const attendeeId = String(e.active.id);
+    const target = String(e.over.id);
+    const groupId = target === UNASSIGNED ? null : target;
+    if ((groupOf.get(attendeeId) || null) === groupId) return;
+    // Optimistic move; reload on failure.
+    setBoard(b => b && ({
+      ...b,
+      sets: b.sets.map(s => s.id !== current.id ? s : {
+        ...s,
+        assignments: [...s.assignments.filter(a => a.attendeeId !== attendeeId), ...(groupId ? [{ attendeeId, groupId }] : [])],
+      }),
+    }));
+    try {
+      await call(`/api/allocations/sets/${current.id}/assignments`, "PUT", { attendeeId, groupId });
+    } catch (err) {
+      setError(errorMessage(err) || "Couldn't move them");
+      load();
+    }
+  };
+
+  const run = async (fn: () => Promise<string | void>) => {
+    setBusy(true);
+    try {
+      const msg = await fn();
+      if (msg) setInfo(msg);
+      await load();
+    } catch (e) {
+      setError(errorMessage(e) || "Something went wrong");
+    } finally {
+      setBusy(false);
+    }
+  };
+
+  const addSet = () => run(async () => {
+    const s = await call<{ id: string }>("/api/allocations/sets", "POST", { eventId, name: newSetName || "Rooms" });
+    setNewSetName("");
+    setSetId(s.id);
+  });
+  const saveGroup = () => groupForm && current && run(async () => {
+    const body = { name: groupForm.name, capacity: groupForm.capacity || null, gender: groupForm.gender || null, leaderUserId: groupForm.leaderUserId || null };
+    if (groupForm.id) await call(`/api/allocations/groups/${groupForm.id}`, "PUT", body);
+    else await call(`/api/allocations/sets/${current.id}/groups`, "POST", body);
+    setGroupForm(null);
+  });
+
+  const printLists = async (master: boolean, medical: boolean) => {
+    if (!current || !board) return;
+    try {
+      const data = await apiFetch<SetLists>(`/api/allocations/sets/${current.id}/lists${medical ? "?medical=true" : ""}`, { authToken: token! });
+      const w = window.open("", "_blank");
+      if (!w) return;
+      const row = (m: ListMember) => `<tr><td>${esc(m.name)}</td><td>${esc(genderLabel(m.gender))}</td><td>${esc(ageOn(m.dateOfBirth, board.event.startDate) ?? "")}</td>`
+        + `<td>${esc(m.phone || m.parentPhone || m.bookedByPhone || "")}</td><td>${esc(m.parentName || m.bookedBy || "")}</td>`
+        + (medical ? `<td>${esc(m.medical ? Object.values(m.medical).filter(Boolean).join("; ") : "")}</td><td>${esc(m.emergency ? Object.values(m.emergency).filter(Boolean).join(", ") : "")}</td>` : "") + `</tr>`;
+      const head = `<tr><th>Name</th><th>Gender</th><th>Age</th><th>Phone</th><th>Parent / booked by</th>${medical ? "<th>Medical</th><th>Emergency contact</th>" : ""}</tr>`;
+      let body = "";
+      if (master) {
+        const all = data.groups.flatMap((g) => g.members.map((m) => ({ ...m, group: g.name }))).sort((a, b) => a.name.localeCompare(b.name));
+        body = `<h1>${esc(data.event.title)} — ${esc(data.set.name)} (master list)</h1><table><tr><th>${esc(data.set.name)}</th>${head.slice(4)}${all.map((m) => row(m).replace("<tr>", `<tr><td>${esc(m.group)}</td>`)).join("")}</table>`;
+      } else {
+        body = data.groups.map((g) => `<section><h1>${esc(data.event.title)} — ${esc(g.name)}</h1>`
+          + `<p>${esc(data.set.name)}${g.leader ? ` · Leader: ${esc(g.leader)}` : ""} · ${g.members.length}${g.capacity ? ` / ${g.capacity}` : ""} people</p>`
+          + `<table>${head}${g.members.map(row).join("")}</table></section>`).join("");
+      }
+      w.document.write(`<!doctype html><html><head><title>${esc(data.set.name)}</title><style>
+        body{font-family:Arial,sans-serif;font-size:11pt;margin:12mm} h1{font-size:15pt;margin:0 0 2mm} p{margin:0 0 3mm;color:#555}
+        table{border-collapse:collapse;width:100%;margin-bottom:6mm} th,td{border:1px solid #bbb;padding:3px 6px;text-align:left;vertical-align:top} th{background:#f1f1f1}
+        section{page-break-after:always} section:last-child{page-break-after:auto}
+      </style></head><body>${body}<script>window.onload=function(){window.print()}</script></body></html>`);
+      w.document.close();
+    } catch (e) {
+      setError(errorMessage(e) || "Couldn't load the lists");
+    }
+  };
+
+  return (
+    <div className="max-w-7xl mx-auto w-full p-6">
+      <div className="flex items-center gap-3 mb-4">
+        <div className="w-10 h-10 rounded-xl bg-brand-50 flex items-center justify-center shrink-0">
+          <BedDouble className="w-5 h-5 text-brand-600" />
+        </div>
+        <div>
+          <button className="text-xs text-brand-600 hover:underline" onClick={() => router.push("/dashboard")}>← Back to dashboard</button>
+          <h1 className="text-2xl font-semibold text-gray-900 mt-0.5">Rooms &amp; groups</h1>
+          <p className="text-sm text-gray-500">Put attendees into rooms, small groups, teams or buses</p>
+        </div>
+      </div>
+
+      {!canView && <div className="p-3 border rounded bg-yellow-50 text-yellow-800 text-sm mb-4">You need supervisor access to manage allocations.</div>}
+      {error && <div className="mb-3 p-3 border rounded bg-red-50 text-red-800 text-sm">{error}</div>}
+      {info && <div className="mb-3 p-3 border rounded bg-green-50 text-green-800 text-sm">{info}</div>}
+
+      {canView && (
+        <div className="space-y-4">
+          <div className="flex flex-wrap items-end gap-3">
+            <div>
+              <label className="block text-xs text-gray-600 mb-1">Event</label>
+              <select className="border rounded-lg px-3 py-2 text-sm min-w-[16rem]" value={eventId} onChange={e => { setEventId(e.target.value); setSetId(""); }}>
+                {events.map(ev => <option key={ev.id} value={ev.id}>{ev.title} ({formatDate(new Date(ev.startDate))})</option>)}
+              </select>
+            </div>
+            {board && (
+              <div className="flex flex-wrap items-center gap-1">
+                {board.sets.map(s => (
+                  <button key={s.id} onClick={() => setSetId(s.id)} className={`px-3 py-1.5 text-sm rounded-lg border ${s.id === setId ? "bg-brand-600 text-white border-brand-600" : "bg-white hover:bg-gray-50"}`}>{s.name}</button>
+                ))}
+                <input className="border rounded-lg px-2 py-1.5 text-sm w-36" placeholder="New set, e.g. Buses" value={newSetName} onChange={e => setNewSetName(e.target.value)} onKeyDown={e => { if (e.key === "Enter") addSet(); }} />
+                <button onClick={addSet} disabled={busy} className="inline-flex items-center gap-1 px-2.5 py-1.5 text-sm rounded-lg border hover:bg-gray-50"><Plus className="w-4 h-4" /> Add set</button>
+              </div>
+            )}
+          </div>
+
+          {board && board.attendees.length === 0 && (
+            <div className="p-3 border rounded bg-amber-50 text-amber-900 text-sm">
+              No named attendees yet. Allocation works per person, so it needs names — turn on &quot;Named attendees&quot; for the event{board.event.collectGender ? "" : " (and \"Ask each person's gender\" if rooms are split by gender)"}.
+            </div>
+          )}
+          {board && board.unnamedPlaces > 0 && (
+            <p className="text-xs text-gray-500">{board.unnamedPlaces} place(s) have no name yet, so they can&apos;t be placed until the person booking adds names.</p>
+          )}
+
+          {current && board && (
+            <>
+              <div className="flex flex-wrap items-center gap-2 border rounded-xl p-3 bg-white">
+                <label className="flex items-center gap-2 text-sm cursor-pointer">
+                  <input type="checkbox" checked={current.showOnTicket} onChange={e => run(async () => { await call(`/api/allocations/sets/${current.id}`, "PUT", { showOnTicket: e.target.checked }); })} />
+                  Show {current.name.toLowerCase()} on tickets and in My Events
+                </label>
+                <div className="ml-auto flex flex-wrap gap-2">
+                  <button disabled={busy} onClick={() => run(async () => (await call<{ message: string }>(`/api/allocations/sets/${current.id}/auto`, "POST", { mode: "together" })).message)} className="inline-flex items-center gap-1 px-2.5 py-1.5 text-sm rounded-lg bg-brand-600 text-white hover:bg-brand-700 disabled:opacity-50" title="Fill groups evenly, keeping people on the same booking (e.g. siblings) together where possible"><Wand2 className="w-4 h-4" /> Auto-allocate (keep bookings together)</button>
+                  <button disabled={busy} onClick={() => run(async () => (await call<{ message: string }>(`/api/allocations/sets/${current.id}/auto`, "POST", { mode: "split" })).message)} className="inline-flex items-center gap-1 px-2.5 py-1.5 text-sm rounded-lg border hover:bg-gray-50 disabled:opacity-50" title="Fill groups evenly, spreading people on the same booking across groups">Auto-allocate (split bookings)</button>
+                  <button onClick={() => printLists(false, false)} className="inline-flex items-center gap-1 px-2.5 py-1.5 text-sm rounded-lg border hover:bg-gray-50"><Printer className="w-4 h-4" /> Group lists</button>
+                  <button onClick={() => printLists(true, false)} className="inline-flex items-center gap-1 px-2.5 py-1.5 text-sm rounded-lg border hover:bg-gray-50"><Printer className="w-4 h-4" /> Master list</button>
+                  {board.event.requiresParentalConsent && (
+                    <button onClick={() => printLists(false, true)} className="inline-flex items-center gap-1 px-2.5 py-1.5 text-sm rounded-lg border hover:bg-gray-50" title="Includes medical details from consent forms. Viewing is recorded in the audit log."><Printer className="w-4 h-4" /> Lists with medical info</button>
+                  )}
+                  <button disabled={busy} onClick={() => run(async () => (await call<{ message: string }>(`/api/allocations/sets/${current.id}/assignments`, "DELETE")).message)} className="inline-flex items-center gap-1 px-2.5 py-1.5 text-sm rounded-lg border hover:bg-gray-50 disabled:opacity-50"><Eraser className="w-4 h-4" /> Clear</button>
+                  <button disabled={busy} onClick={() => run(async () => { await call(`/api/allocations/sets/${current.id}`, "DELETE"); setSetId(""); return `Deleted ${current.name}.`; })} className="inline-flex items-center gap-1 px-2.5 py-1.5 text-sm rounded-lg border text-red-700 hover:bg-red-50 disabled:opacity-50"><Trash2 className="w-4 h-4" /> Delete set</button>
+                </div>
+              </div>
+
+              {groupForm ? (
+                <div className="border rounded-xl p-3 bg-white flex flex-wrap items-end gap-2">
+                  <div><label className="block text-xs text-gray-600 mb-1">Name</label><input className="border rounded-lg px-2 py-1.5 text-sm" value={groupForm.name} onChange={e => setGroupForm({ ...groupForm, name: e.target.value })} placeholder="Cabin 1" autoFocus /></div>
+                  <div><label className="block text-xs text-gray-600 mb-1">Capacity</label><input type="number" min="1" className="border rounded-lg px-2 py-1.5 text-sm w-24" value={groupForm.capacity} onChange={e => setGroupForm({ ...groupForm, capacity: e.target.value })} placeholder="No limit" /></div>
+                  <div><label className="block text-xs text-gray-600 mb-1">Gender</label>
+                    <select className="border rounded-lg px-2 py-1.5 text-sm" value={groupForm.gender} onChange={e => setGroupForm({ ...groupForm, gender: e.target.value })}>
+                      <option value="">Anyone</option><option value="male">Males only</option><option value="female">Females only</option>
+                    </select>
+                  </div>
+                  <div><label className="block text-xs text-gray-600 mb-1">Leader</label>
+                    <select className="border rounded-lg px-2 py-1.5 text-sm" value={groupForm.leaderUserId} onChange={e => setGroupForm({ ...groupForm, leaderUserId: e.target.value })}>
+                      <option value="">None</option>
+                      {board.leaders.map(l => <option key={l.id} value={l.id}>{l.name}</option>)}
+                    </select>
+                  </div>
+                  <button disabled={busy || !groupForm.name.trim()} onClick={saveGroup} className="px-3 py-1.5 text-sm rounded-lg bg-brand-600 text-white disabled:opacity-50">{groupForm.id ? "Save" : "Add group"}</button>
+                  <button onClick={() => setGroupForm(null)} className="px-3 py-1.5 text-sm rounded-lg bg-gray-100">Cancel</button>
+                </div>
+              ) : (
+                <button onClick={() => setGroupForm({ name: "", capacity: "", gender: "", leaderUserId: "" })} className="inline-flex items-center gap-1 px-2.5 py-1.5 text-sm rounded-lg border hover:bg-gray-50"><Plus className="w-4 h-4" /> Add a group to {current.name}</button>
+              )}
+
+              <DndContext sensors={sensors} onDragEnd={onDragEnd}>
+                <div className="grid grid-cols-1 md:grid-cols-[minmax(14rem,1fr)_3fr] gap-4 items-start">
+                  <div className="md:sticky md:top-4">
+                    <Column id={UNASSIGNED} title="Not placed yet" subtitle={`${unassigned.length} people · drag them into a group`}>
+                      {unassigned.map(p => <PersonChip key={p.id} person={p} eventStart={board.event.startDate} />)}
+                    </Column>
+                  </div>
+                  <div className="grid grid-cols-1 sm:grid-cols-2 xl:grid-cols-3 gap-3">
+                    {current.groups.length === 0 && <p className="text-sm text-gray-500">Add groups (rooms, cabins, buses…) to start placing people.</p>}
+                    {current.groups.map(g => {
+                      const members = membersOf(g.id);
+                      const full = g.capacity != null && members.length >= g.capacity;
+                      const subtitle = [`${members.length}${g.capacity ? ` / ${g.capacity}` : ""}${full ? " · full" : ""}`, g.gender ? (g.gender === "male" ? "males" : "females") : "", g.leader ? `leader ${g.leader.name}` : ""].filter(Boolean).join(" · ");
+                      return (
+                        <Column key={g.id} id={g.id} title={g.name} subtitle={subtitle} full={full} actions={
+                          <div className="flex gap-1 shrink-0">
+                            <button aria-label={`Edit ${g.name}`} onClick={() => setGroupForm({ id: g.id, name: g.name, capacity: g.capacity ? String(g.capacity) : "", gender: g.gender || "", leaderUserId: g.leaderUserId || "" })} className="p-1 rounded hover:bg-gray-100"><Pencil className="w-3.5 h-3.5" /></button>
+                            <button aria-label={`Delete ${g.name}`} onClick={() => run(async () => { await call(`/api/allocations/groups/${g.id}`, "DELETE"); return `${g.name} deleted; its people are back in "Not placed yet".`; })} className="p-1 rounded hover:bg-red-50 text-red-700"><Trash2 className="w-3.5 h-3.5" /></button>
+                          </div>
+                        }>
+                          {members.map(p => <PersonChip key={p.id} person={p} eventStart={board.event.startDate} />)}
+                        </Column>
+                      );
+                    })}
+                  </div>
+                </div>
+              </DndContext>
+            </>
+          )}
+          {board && board.sets.length === 0 && board.attendees.length > 0 && (
+            <p className="text-sm text-gray-600">Start by adding a set, e.g. &quot;Rooms&quot;, &quot;Small groups&quot; or &quot;Buses&quot;. An event can have several.</p>
+          )}
+        </div>
+      )}
+    </div>
+  );
+}

frontend/src/app/dashboard/supervisor/at-the-door/page.tsx

@@ -1,6 +1,6 @@
 "use client";
 
-import React, { useEffect, useMemo, useState } from "react";
+import React, { useCallback, useEffect, useMemo, useState } from "react";
 import { useAuth } from "@/hooks/useAuth";
 import { useRouter } from "next/navigation";
 import { apiFetch } from "@/lib/api";
@@ -10,6 +10,16 @@ import { CouponCodeField, AppliedCoupon } from "@/components/shared/CouponCodeFi
 import { TransferTicketModal, canOfferTransfer } from "@/components/shared/TransferTicketModal";
 import { AttendeeNamesEditor, AttendeeEntries, TicketDelivery, attendeesPayload, consentDetailsMissing } from "@/components/shared/AttendeeNamesEditor";
 import { DoorOpen, UserPlus, CreditCard, CheckSquare, Ticket, RotateCcw, type LucideIcon } from "lucide-react";
+import { errorMessage } from "@/lib/utils";
+import { optionUnitNow, variantUnitNow } from "@/lib/pricing";
+import type { Event, EventOption, Registration, Ticket as TicketRecord, UserSummary } from "@/types";
+
+type NewAttendee = { name: string; email: string | null; phone: string | null; notifPref: "email" | "whatsapp" | "both" };
+
+// GET /api/tickets/event/:id — a bare list (older builds wrapped it in `tickets` or `data`).
+type EventTicketsResponse = TicketRecord[] | { tickets?: TicketRecord[]; data?: TicketRecord[] };
+const ticketsFrom = (res: EventTicketsResponse | null | undefined): TicketRecord[] =>
+    Array.isArray(res) ? res : (res?.tickets || res?.data || []);
 
 type Mode = "registration" | "payment" | "checkin" | "tickets" | "refund";
 
@@ -31,7 +41,7 @@ const MODE_ICONS: Record<Mode, LucideIcon> = {
 
 // ─── Fuzzy search helpers ─────────────────────────────────────────────────────
 
-function fuzzyFilterRegs(allRegs: any[], search: string): any[] {
+function fuzzyFilterRegs(allRegs: Registration[], search: string): Registration[] {
     if (!search) return allRegs;
     if (search.length === 1) {
         const q = search.toLowerCase();
@@ -50,37 +60,24 @@ function fuzzyFilterRegs(allRegs: any[], search: string): any[] {
 
 // ─── Pricing helpers ─────────────────────────────────────────────────────────
 
-function effectiveOptionUnit(opt: any): number {
-    const base = opt.price || 0;
-    const tiers = (Array.isArray(opt.earlyBirdTiers) ? opt.earlyBirdTiers : []).filter((t: any) => !t.variantId);
-    if (!tiers.length) return base;
-    const now = new Date();
-    const hit = tiers
-        .map((t: any) => ({ ...t, deadline: new Date(t.deadline) }))
-        .filter((t: any) => now < t.deadline)
-        .sort((a: any, b: any) => a.deadline - b.deadline || (a.order || 0) - (b.order || 0) || a.price - b.price);
-    return hit.length ? hit[0].price : base;
+// Total due on a registration: the backend's tranche-aware total when present, else
+// the sum of its lines at their snapshot (or current list) prices.
+function registrationTotal(r: Registration): number {
+    return r.totalDueComputed ?? (r.registrationOptions || []).reduce((sum, opt) => {
+        const price = (opt.priceSnapshot !== null && opt.priceSnapshot !== undefined)
+            ? Number(opt.priceSnapshot)
+            : (opt.eventOption?.price ?? 0);
+        return sum + price * (opt.quantity || 0);
+    }, 0);
 }
 
-function effectiveVariantUnit(opt: any, variant: any): number {
-    const base = variant.price !== null && variant.price !== undefined ? variant.price : opt.price || 0;
-    const allTiers = Array.isArray(opt.earlyBirdTiers) ? opt.earlyBirdTiers : [];
-    const vtiers = allTiers.filter((t: any) => t.variantId === variant.id);
-    const tiers = vtiers.length ? vtiers : allTiers.filter((t: any) => !t.variantId);
-    if (!tiers.length) return base;
-    const now = new Date();
-    const hit = tiers
-        .map((t: any) => ({ ...t, deadline: new Date(t.deadline) }))
-        .filter((t: any) => now < t.deadline)
-        .sort((a: any, b: any) => a.deadline - b.deadline || (a.order || 0) - (b.order || 0) || a.price - b.price);
-    return hit.length ? hit[0].price : base;
-}
+const totalPaidOn = (r: Registration) => (r.payments || []).reduce((s, p) => s + (p.amount || 0), 0);
 
-function initQuantities(eventOptions: any[]): Record<string, number> {
+function initQuantities(eventOptions: EventOption[]): Record<string, number> {
     const map: Record<string, number> = {};
-    (eventOptions || []).forEach((o: any) => {
+    (eventOptions || []).forEach((o) => {
         if ((o.variants || []).length > 0) {
-            (o.variants as any[]).forEach((v: any) => { map[`${o.id}::${v.id}`] = 0; });
+            (o.variants || []).forEach((v) => { map[`${o.id}::${v.id}`] = 0; });
         } else {
             map[o.id] = 0;
         }
@@ -88,7 +85,7 @@ function initQuantities(eventOptions: any[]): Record<string, number> {
     return map;
 }
 
-function ticketLabel(t: any): string {
+function ticketLabel(t: TicketRecord): string {
     const opt = t.registrationOption?.eventOption?.name || "Ticket";
     const variant = t.registrationOption?.variant?.name;
     return variant ? `${opt} — ${variant}` : opt;
@@ -97,19 +94,20 @@ function ticketLabel(t: any): string {
 export default function AtTheDoorPage() {
     const { user, loading, token } = useAuth();
     const router = useRouter();
-    const [events, setEvents] = useState<any[]>([]);
+    const [events, setEvents] = useState<Event[]>([]);
     const [eventId, setEventId] = useState("");
 
-    const [eventOptions, setEventOptions] = useState<any[]>([]);
+    const [eventOptions, setEventOptions] = useState<EventOption[]>([]);
     const [showOptionsModal, setShowOptionsModal] = useState(false);
-    const [pendingUser, setPendingUser] = useState<any | null>(null);
+    const [pendingUser, setPendingUser] = useState<NewAttendee | null>(null);
     const [doorCoupon, setDoorCoupon] = useState<AppliedCoupon | null>(null);
     const [doorAllowsNames, setDoorAllowsNames] = useState(false);
     const [doorYouthStart, setDoorYouthStart] = useState<string | null>(null);
+    const [doorCollectGender, setDoorCollectGender] = useState(false);
     const [doorNaming, setDoorNaming] = useState(false);
     const [doorEntries, setDoorEntries] = useState<AttendeeEntries>({});
     const [doorDelivery, setDoorDelivery] = useState<TicketDelivery>("payer");
-    const [pendingEditReg, setPendingEditReg] = useState<any | null>(null);
+    const [pendingEditReg, setPendingEditReg] = useState<Registration | null>(null);
     const [confirming, setConfirming] = useState(false);
     const [quantities, setQuantities] = useState<Record<string, number>>({});
     // Already-issued ticket quantity per option/variant, keyed like `quantities` — a
@@ -118,7 +116,7 @@ export default function AtTheDoorPage() {
     const [minQuantities, setMinQuantities] = useState<Record<string, number>>({});
 
     const [showDonationModal, setShowDonationModal] = useState(false);
-    const [donationUser, setDonationUser] = useState<any | null>(null);
+    const [donationUser, setDonationUser] = useState<UserSummary | null>(null);
 
     const [showNewAttendeeModal, setShowNewAttendeeModal] = useState(false);
     const [newAttendeeSeed, setNewAttendeeSeed] = useState("");
@@ -127,7 +125,7 @@ export default function AtTheDoorPage() {
         if (!token) return;
         (async () => {
             try {
-                const evs = await apiFetch<any[]>("/api/events/all", { authToken: token });
+                const evs = await apiFetch<Event[]>("/api/events/all", { authToken: token });
                 const now = Date.now();
 
                 const active = (evs || []).filter(ev => {
@@ -157,13 +155,14 @@ export default function AtTheDoorPage() {
 
         (async () => {
             try {
-                const ev = await apiFetch(`/api/events/${eventId}`, {
+                const ev = await apiFetch<Event>(`/api/events/${eventId}`, {
                     authToken: token
                 });
 
                 setEventOptions(ev.options || ev.eventOptions || []);
                 setDoorAllowsNames(!!ev.allowNamedAttendees || !!ev.requiresParentalConsent);
                 setDoorYouthStart(ev.requiresParentalConsent ? ev.startDate : null);
+                setDoorCollectGender(!!ev.collectGender);
             } catch {
                 setEventOptions([]);
             }
@@ -178,19 +177,19 @@ export default function AtTheDoorPage() {
     useEffect(() => {
         if (loading) return;
         if (!user) router.replace("/login");
-    }, [user, loading]);
+    }, [user, loading, router]);
 
     const [mode, setMode] = useState<Mode>("registration");
 
-    const [activeRegistration, setActiveRegistration] = useState<any | null>(null);
+    const [activeRegistration, setActiveRegistration] = useState<Registration | null>(null);
     const [info, setInfo] = useDismissingState<string | null>(null);
     const [error, setError] = useDismissingState<string | null>(null);
 
-    const handleRegistrationCreated = (registration: any) => {
+    const handleRegistrationCreated = (registration: Registration) => {
         setActiveRegistration(registration); // 🚀 Jump automatically (see effect below)
     };
 
-    const handleRegistrationSelected = (registration: any) => {
+    const handleRegistrationSelected = (registration: Registration) => {
         setActiveRegistration(registration);
     };
 
@@ -225,8 +224,8 @@ export default function AtTheDoorPage() {
         for (const [key, minQty] of Object.entries(minQuantities)) {
             if (minQty > 0 && (quantities[key] || 0) < minQty) {
                 const [eventOptionId, variantId] = key.split("::");
-                const opt = eventOptions.find((o: any) => o.id === eventOptionId);
-                const variant = variantId ? (opt?.variants || []).find((v: any) => v.id === variantId) : null;
+                const opt = eventOptions.find((o) => o.id === eventOptionId);
+                const variant = variantId ? (opt?.variants || []).find((v) => v.id === variantId) : null;
                 const label = variant ? `${opt?.name || "item"} (${variant.name})` : (opt?.name || "item");
                 setError(`Cannot reduce "${label}" below the ${minQty} already issued`);
                 return;
@@ -242,7 +241,7 @@ export default function AtTheDoorPage() {
         try {
             if (pendingEditReg) {
                 // Edit existing registration — replace options via PUT
-                let res = await apiFetch(`/api/registrations/${pendingEditReg.id}/options`, {
+                let res = await apiFetch<Registration>(`/api/registrations/${pendingEditReg.id}/options`, {
                     method: "PUT",
                     authToken: token,
                     body: { options: opts }
@@ -251,14 +250,14 @@ export default function AtTheDoorPage() {
                 if (doorCoupon) {
                     // Applied after the items are saved, so it's worked out on the final items.
                     try {
-                        res = await apiFetch(`/api/registrations/${pendingEditReg.id}/coupon`, {
+                        res = await apiFetch<Registration>(`/api/registrations/${pendingEditReg.id}/coupon`, {
                             method: "POST",
                             authToken: token,
                             body: { code: doorCoupon.code },
                         });
                         message = `Registration updated — code ${doorCoupon.code} applied`;
-                    } catch (ce: any) {
-                        message = `Registration updated, but the code wasn't applied: ${ce?.message || "unknown error"}`;
+                    } catch (ce) {
+                        message = `Registration updated, but the code wasn't applied: ${errorMessage(ce) || "unknown error"}`;
                     }
                 }
                 setShowOptionsModal(false);
@@ -267,7 +266,7 @@ export default function AtTheDoorPage() {
                 handleRegistrationSelected(res);
             } else if (pendingUser) {
                 // New attendee
-                const res = await apiFetch("/api/registrations/manual", {
+                const res = await apiFetch<Registration & { couponError?: string }>("/api/registrations/manual", {
                     method: "POST",
                     authToken: token,
                     body: {
@@ -289,8 +288,8 @@ export default function AtTheDoorPage() {
                 if (res?.couponError) setError(`Registered, but the code wasn't applied: ${res.couponError}`);
                 handleRegistrationCreated(res);
             }
-        } catch (e: any) {
-            setError(e?.message || "Failed");
+        } catch (e) {
+            setError(errorMessage(e) || "Failed");
         } finally {
             setConfirming(false);
         }
@@ -309,7 +308,7 @@ export default function AtTheDoorPage() {
         eventOptions.forEach(o => {
             if (!o.isMainTicket) return;
             if ((o.variants || []).length > 0) {
-                qtyMap[`${o.id}::${(o.variants as any[])[0].id}`] = 1;
+                qtyMap[`${o.id}::${(o.variants || [])[0].id}`] = 1;
             } else {
                 qtyMap[o.id] = 1;
             }
@@ -330,27 +329,27 @@ export default function AtTheDoorPage() {
     // Re-fetches the registration fresh rather than trusting the (possibly up to 5-minutes-stale,
     // see DoorRegistrationPanel's polling interval) cached search-result snapshot, so the
     // already-issued-ticket floor below is always computed from current data.
-    const handleEditRegistration = async (reg: any) => {
+    const handleEditRegistration = async (reg: Registration) => {
         let freshReg = reg;
         try {
-            freshReg = await apiFetch<any>(`/api/registrations/${reg.id}`, { authToken: token });
-        } catch (e: any) {
-            setError(e?.message || "Failed to load latest registration data");
+            freshReg = await apiFetch<Registration>(`/api/registrations/${reg.id}`, { authToken: token });
+        } catch (e) {
+            setError(errorMessage(e) || "Failed to load latest registration data");
             return;
         }
 
         const qtyMap = initQuantities(eventOptions);
-        const regOptions = freshReg.registrationOptions || freshReg.options || [];
-        regOptions.forEach((ro: any) => {
+        const regOptions = freshReg.registrationOptions || [];
+        regOptions.forEach((ro) => {
             const key = ro.variantId ? `${ro.eventOptionId}::${ro.variantId}` : ro.eventOptionId;
             if (key in qtyMap) qtyMap[key] = ro.quantity || 0;
         });
 
         // Already-issued ticket quantity per option/variant — floor for the edit below
         const minQtyMap: Record<string, number> = {};
-        regOptions.forEach((ro: any) => {
+        regOptions.forEach((ro) => {
             const key = ro.variantId ? `${ro.eventOptionId}::${ro.variantId}` : ro.eventOptionId;
-            const issuedQty = (ro.tickets || []).reduce((s: number, t: any) => s + (t.quantity || 0), 0);
+            const issuedQty = (ro.tickets || []).reduce((s, t) => s + (t.quantity || 0), 0);
             if (issuedQty > 0) minQtyMap[key] = (minQtyMap[key] || 0) + issuedQty;
         });
 
@@ -362,7 +361,7 @@ export default function AtTheDoorPage() {
         setShowOptionsModal(true);
     };
 
-    const handlePaymentCaptured = async (registration?: any, partial?: boolean) => {
+    const handlePaymentCaptured = async (registration?: Registration, partial?: boolean) => {
 
         if (partial && registration) {
             setActiveRegistration(registration);
@@ -382,7 +381,7 @@ export default function AtTheDoorPage() {
         setMode("checkin");
     };
 
-    const handleDonation = (user?: any) => {
+    const handleDonation = (user?: UserSummary) => {
         setDonationUser(user || null); // null = anonymous
         setShowDonationModal(true);
     };
@@ -463,12 +462,10 @@ export default function AtTheDoorPage() {
                 <DoorRegistrationPanel
                     token={token}
                     eventId={eventId}
-                    onCreated={handleRegistrationCreated}
                     onSelected={handleRegistrationSelected}
                     onEditRegistration={handleEditRegistration}
                     onNewAttendee={handleShowNewAttendee}
                     onDonation={handleDonation}
-                    setError={setError}
                 />
             )}
 
@@ -490,7 +487,7 @@ export default function AtTheDoorPage() {
             )}
 
             {mode === "refund" && (
-                <DoorRefundPanel token={token} eventId={eventId} setError={setError} setInfo={setInfo} />
+                <DoorRefundPanel token={token} eventId={eventId} setInfo={setInfo} />
             )}
             <OptionsModal
                 open={showOptionsModal}
@@ -502,7 +499,7 @@ export default function AtTheDoorPage() {
                 onConfirm={confirmRegistration}
                 confirming={confirming}
                 isEdit={!!pendingEditReg}
-                totalPaid={(pendingEditReg?.payments || []).reduce((s: number, p: any) => s + (p.amount || 0), 0)}
+                totalPaid={pendingEditReg ? totalPaidOn(pendingEditReg) : 0}
                 eventId={eventId}
                 token={token}
                 coupon={doorCoupon}
@@ -514,6 +511,7 @@ export default function AtTheDoorPage() {
                     entries: doorEntries, onEntriesChange: setDoorEntries,
                     delivery: doorDelivery, onDeliveryChange: setDoorDelivery,
                     consentEventStart: doorYouthStart || undefined,
+                    collectGender: doorCollectGender,
                 } : null}
             />
             <DonationModal
@@ -534,9 +532,16 @@ export default function AtTheDoorPage() {
     );
 }
 
-function DoorRegistrationPanel({ token, eventId, onCreated, onSelected, onEditRegistration, onNewAttendee, onDonation, setError }: any) {
+function DoorRegistrationPanel({ token, eventId, onSelected, onEditRegistration, onNewAttendee, onDonation }: {
+    token: string | null;
+    eventId: string;
+    onSelected: (r: Registration) => void;
+    onEditRegistration: (r: Registration) => void;
+    onNewAttendee: (seed: string) => void;
+    onDonation: (user?: UserSummary) => void;
+}) {
     const [search, setSearch] = useState("");
-    const [allRegs, setAllRegs] = useState<any[]>([]);
+    const [allRegs, setAllRegs] = useState<Registration[]>([]);
     const [loading, setLoading] = useState(false);
 
     // Load registrations for this event — once on mount/eventId change, then every 5 min
@@ -547,7 +552,7 @@ function DoorRegistrationPanel({ token, eventId, onCreated, onSelected, onEditRe
         const load = async () => {
             try {
                 setLoading(true);
-                const regs = await apiFetch<any[]>(`/api/registrations/event/${eventId}`, { authToken: token });
+                const regs = await apiFetch<Registration[]>(`/api/registrations/event/${eventId}`, { authToken: token });
                 if (!cancelled) setAllRegs(regs || []);
             } catch {
                 if (!cancelled) setAllRegs([]);
@@ -573,7 +578,7 @@ function DoorRegistrationPanel({ token, eventId, onCreated, onSelected, onEditRe
                         if (!token || !eventId) return;
                         try {
                             setLoading(true);
-                            const regs = await apiFetch<any[]>(`/api/registrations/event/${eventId}`, { authToken: token });
+                            const regs = await apiFetch<Registration[]>(`/api/registrations/event/${eventId}`, { authToken: token });
                             setAllRegs(regs || []);
                         } catch {} finally { setLoading(false); }
                     }}
@@ -641,7 +646,12 @@ function DoorRegistrationPanel({ token, eventId, onCreated, onSelected, onEditRe
     );
 }
 
-function DoorPaymentPanel({ token, registration, onSuccess, setError }: any) {
+function DoorPaymentPanel({ token, registration, onSuccess, setError }: {
+    token: string | null;
+    registration: Registration | null;
+    onSuccess: (registration?: Registration, partial?: boolean) => void;
+    setError: (e: string | null) => void;
+}) {
     const [amount, setAmount] = useState("");
     const [method, setMethod] = useState("card");
     const [saving, setSaving] = useState(false);
@@ -656,23 +666,10 @@ function DoorPaymentPanel({ token, registration, onSuccess, setError }: any) {
         );
     }
 
-    const options = registration.options || registration.registrationOptions || [];
-    const payments = registration.payments || [];
-
     // Backend attaches a tranche-aware totalDueComputed (exact even when a line spans
     // multiple early-bird prices) — fall back to the old client-side estimate otherwise.
-    const totalValue = registration.totalDueComputed ?? options.reduce((sum: number, opt: any) => {
-        const price = (opt.priceSnapshot !== null && opt.priceSnapshot !== undefined)
-            ? Number(opt.priceSnapshot)
-            : (opt.eventOption?.price ?? opt.price ?? 0);
-        const qty = opt.quantity || 0;
-        return sum + price * qty;
-    }, 0);
-
-    const paidValue = payments.reduce(
-        (sum: number, p: any) => sum + (p.amount || 0),
-        0
-    );
+    const totalValue = registrationTotal(registration);
+    const paidValue = totalPaidOn(registration);
 
     const balance = Math.max(0, totalValue - paidValue);
 
@@ -695,26 +692,11 @@ function DoorPaymentPanel({ token, registration, onSuccess, setError }: any) {
                 }
             });
 
-            const updated = await apiFetch(`/api/registrations/${registration.id}`, {
+            const updated = await apiFetch<Registration>(`/api/registrations/${registration.id}`, {
                 authToken: token
             });
 
-            const updatedOptions = updated.options || updated.registrationOptions || [];
-            const updatedPayments = updated.payments || [];
-
-            const totalValue = updated.totalDueComputed ?? updatedOptions.reduce((sum: number, opt: any) => {
-                const price = (opt.priceSnapshot !== null && opt.priceSnapshot !== undefined)
-                    ? Number(opt.priceSnapshot)
-                    : (opt.eventOption?.price ?? opt.price ?? 0);
-                return sum + price * (opt.quantity || 0);
-            }, 0);
-
-            const paidValue = updatedPayments.reduce(
-                (sum: number, p: any) => sum + (p.amount || 0),
-                0
-            );
-
-            const updatedBalance = Math.max(0, totalValue - paidValue);
+            const updatedBalance = Math.max(0, registrationTotal(updated) - totalPaidOn(updated));
 
             if (updatedBalance === 0) {
                 onSuccess(updated);  // 🎯 ONLY NOW generate tickets
@@ -722,8 +704,8 @@ function DoorPaymentPanel({ token, registration, onSuccess, setError }: any) {
                 onSuccess(updated, true); // 🎯 partial payment flow
             }
 
-        } catch (e: any) {
-            setError(e?.message || "Payment failed");
+        } catch (e) {
+            setError(errorMessage(e) || "Payment failed");
         } finally {
             setSaving(false);
         }
@@ -846,11 +828,10 @@ function DoorPaymentPanel({ token, registration, onSuccess, setError }: any) {
                 token={token}
                 registration={registration}
                 maxRefund={paidValue}
-                onRefunded={(updated: any) => {
+                onRefunded={(updated) => {
                     setShowRefund(false);
                     onSuccess(updated, true);
                 }}
-                setError={setError}
             />
 
             <SendTicketsModal
@@ -858,20 +839,23 @@ function DoorPaymentPanel({ token, registration, onSuccess, setError }: any) {
                 onClose={() => setShowSendTickets(false)}
                 token={token}
                 registration={registration}
-                setError={setError}
-                setInfo={() => {}}
             />
         </div>
     );
 }
 
-function DoorTicketsPanel({ token, eventId }: any) {
+function DoorTicketsPanel({ token, eventId }: { token: string | null; eventId: string }) {
     const [search, setSearch] = useState("");
-    const [allTickets, setAllTickets] = useState<any[]>([]);
+    const [allTickets, setAllTickets] = useState<TicketRecord[]>([]);
     const [loading, setLoading] = useState(false);
-    const [sendTarget, setSendTarget] = useState<any | null>(null);
-    const [transferTarget, setTransferTarget] = useState<any | null>(null);
+    const [sendTarget, setSendTarget] = useState<TicketRecord | null>(null);
+    const [transferTarget, setTransferTarget] = useState<TicketRecord | null>(null);
     const [notice, setNotice] = useState<string | null>(null);
+    // Memoised so the send modal's reset effect doesn't rerun on every render of this panel.
+    const sendRegistration = useMemo(() => sendTarget ? {
+        id: sendTarget.registrationOption?.registration?.id || sendTarget.registrationOption?.registrationId || "",
+        user: sendTarget.user,
+    } : null, [sendTarget]);
 
     // Load all tickets for the event once
     useEffect(() => {
@@ -879,8 +863,8 @@ function DoorTicketsPanel({ token, eventId }: any) {
         (async () => {
             try {
                 setLoading(true);
-                const res = await apiFetch<any>(`/api/tickets/event/${eventId}`, { authToken: token });
-                setAllTickets(res?.tickets || res?.data || (Array.isArray(res) ? res : []));
+                const res = await apiFetch<EventTicketsResponse>(`/api/tickets/event/${eventId}`, { authToken: token });
+                setAllTickets(ticketsFrom(res));
             } catch {
                 setAllTickets([]);
             } finally {
@@ -913,8 +897,8 @@ function DoorTicketsPanel({ token, eventId }: any) {
         if (!token || !eventId) return;
         try {
             setLoading(true);
-            const res = await apiFetch<any>(`/api/tickets/event/${eventId}`, { authToken: token });
-            setAllTickets(res?.tickets || res?.data || (Array.isArray(res) ? res : []));
+            const res = await apiFetch<EventTicketsResponse>(`/api/tickets/event/${eventId}`, { authToken: token });
+            setAllTickets(ticketsFrom(res));
         } catch {
             setAllTickets([]);
         } finally {
@@ -922,7 +906,7 @@ function DoorTicketsPanel({ token, eventId }: any) {
         }
     };
 
-    const print = (ticket: any) => {
+    const print = (ticket: TicketRecord) => {
         const w = window.open("", "_blank");
         if (!w) return;
         const eventTitle = ticket.event?.title || ticket.eventId || "Event";
@@ -1058,49 +1042,50 @@ function DoorTicketsPanel({ token, eventId }: any) {
                 <TransferTicketModal
                     ticket={transferTarget}
                     event={transferTarget.event}
-                    token={token}
+                    token={token ?? ""}
                     onClose={() => setTransferTarget(null)}
                     onDone={(msg) => { setTransferTarget(null); setNotice(msg); load(); }}
                 />
             )}
-            {sendTarget && (
+            {sendRegistration && (
                 <SendTicketsModal
                     open={true}
                     onClose={() => setSendTarget(null)}
                     token={token}
-                    registration={{
-                        id: sendTarget.registrationOption?.registration?.id || sendTarget.registrationOption?.registrationId,
-                        user: sendTarget.user,
-                    }}
-                    setError={() => {}}
-                    setInfo={() => {}}
+                    registration={sendRegistration}
                 />
             )}
         </div>
     );
 }
 
-function DoorCheckInPanel({ token, eventId, registration, setError, setInfo }: any) {
-    const [ticketsForEvent, setTicketsForEvent] = useState<any[]>([]);
+function DoorCheckInPanel({ token, eventId, registration, setError, setInfo }: {
+    token: string | null;
+    eventId: string;
+    registration: Registration | null;
+    setError: (e: string | null) => void;
+    setInfo: (s: string | null) => void;
+}) {
+    const [ticketsForEvent, setTicketsForEvent] = useState<TicketRecord[]>([]);
     const [loading, setLoading] = useState(false);
     const [qtyByTicket, setQtyByTicket] = useState<Record<string, number>>({});
     const [submittingId, setSubmittingId] = useState<string | null>(null);
 
-    const load = async () => {
+    const load = useCallback(async () => {
         if (!token || !eventId) return;
         try {
             setLoading(true);
-            const res = await apiFetch<any>(`/api/tickets/event/${eventId}`, { authToken: token });
-            const tickets = res?.tickets || res?.data || (Array.isArray(res) ? res : []);
-            setTicketsForEvent(tickets.filter((t: any) => t.registrationOption?.eventOption?.isMainTicket));
+            const res = await apiFetch<EventTicketsResponse>(`/api/tickets/event/${eventId}`, { authToken: token });
+            const tickets = ticketsFrom(res);
+            setTicketsForEvent(tickets.filter((t) => t.registrationOption?.eventOption?.isMainTicket));
         } catch {
             setTicketsForEvent([]);
         } finally {
             setLoading(false);
         }
-    };
+    }, [token, eventId]);
 
-    useEffect(() => { load(); }, [token, eventId]);
+    useEffect(() => { load(); }, [load]);
 
     if (!registration) {
         return (
@@ -1113,29 +1098,30 @@ function DoorCheckInPanel({ token, eventId, registration, setError, setInfo }: a
     const myTickets = ticketsForEvent
         .filter(t => t.registrationOption?.registration?.id === registration.id)
         .map(t => {
-            const totalRedeemed = (t.usages || []).reduce((s: number, u: any) => s + (u.quantityRedeemed || 1), 0);
+            const totalRedeemed = (t.usages || []).reduce((s, u) => s + (u.quantityRedeemed || 1), 0);
             const remaining = (t.quantity || 1) - totalRedeemed;
             return { ...t, totalRedeemed, remaining };
         });
 
-    const qtyFor = (t: any) => qtyByTicket[t.id] ?? (t.remaining > 0 ? t.remaining : 1);
-    const setQtyFor = (t: any, n: number) =>
+    type CheckInTicket = (typeof myTickets)[number];
+    const qtyFor = (t: CheckInTicket) => qtyByTicket[t.id] ?? (t.remaining > 0 ? t.remaining : 1);
+    const setQtyFor = (t: CheckInTicket, n: number) =>
         setQtyByTicket(q => ({ ...q, [t.id]: Math.max(1, Math.min(t.remaining || 1, n)) }));
 
-    const commit = async (ticket: any) => {
+    const commit = async (ticket: CheckInTicket) => {
         const qty = qtyFor(ticket);
         try {
             setSubmittingId(ticket.id);
-            const res = await apiFetch<any>(
+            const res = await apiFetch<{ qtyRedeemed?: number; remaining?: number }>(
                 `/api/tickets/scan/${encodeURIComponent(ticket.qrCode)}?eventId=${encodeURIComponent(eventId)}`,
                 { method: "POST", authToken: token, body: { qty } }
             );
             setInfo(`${res?.qtyRedeemed ?? qty} checked in for ${registration.user?.name || "guest"}${
-                res?.remaining > 0 ? ` — ${res.remaining} remaining` : " — fully checked in"
+                (res?.remaining ?? 0) > 0 ? ` — ${res.remaining} remaining` : " — fully checked in"
             }. Confirmation sent.`);
             await load();
-        } catch (e: any) {
-            setError(e?.message || "Check-in failed");
+        } catch (e) {
+            setError(errorMessage(e) || "Check-in failed");
         } finally {
             setSubmittingId(null);
         }
@@ -1222,33 +1208,54 @@ function DoorCheckInPanel({ token, eventId, registration, setError, setInfo }: a
     );
 }
 
-function OptionsModal({ open, onClose, options, quantities, setQuantities, minQuantities = {}, onConfirm, confirming, isEdit, totalPaid = 0, eventId, token, coupon, setCoupon, couponForUserId, existingCode, names }: any) {
+type OptionsModalProps = {
+    open: boolean;
+    onClose: () => void;
+    options: EventOption[];
+    quantities: Record<string, number>;
+    setQuantities: React.Dispatch<React.SetStateAction<Record<string, number>>>;
+    minQuantities?: Record<string, number>;
+    onConfirm: () => void;
+    confirming: boolean;
+    isEdit: boolean;
+    totalPaid?: number;
+    eventId: string;
+    token: string | null;
+    coupon: AppliedCoupon | null;
+    setCoupon: (c: AppliedCoupon | null) => void;
+    couponForUserId: string | null;
+    existingCode: string | null;
+    // Named-attendee editor settings, or null when the event doesn't take names.
+    names: Omit<React.ComponentProps<typeof AttendeeNamesEditor>, "options" | "qtyFor" | "payerLabel"> | null;
+};
+
+function OptionsModal({ open, onClose, options, quantities, setQuantities, minQuantities = {}, onConfirm, confirming, isEdit, totalPaid = 0, eventId, token, coupon, setCoupon, couponForUserId, existingCode, names }: OptionsModalProps) {
     if (!open) return null;
 
-    const basket = Object.entries(quantities as Record<string, number>)
+    const basket = Object.entries(quantities)
         .filter(([, qty]) => qty > 0)
         .map(([key, quantity]) => {
             const [eventOptionId, variantId] = key.split("::");
             return { eventOptionId, quantity, variantId: variantId || null };
         });
 
-    const safeOptions: any[] = options || [];
+    const safeOptions: EventOption[] = options || [];
 
-    const total = safeOptions.reduce((sum: number, o: any) => {
+    const total = safeOptions.reduce((sum, o) => {
         if ((o.variants || []).length > 0) {
-            return sum + (o.variants as any[]).reduce((vs: number, v: any) =>
-                vs + (quantities[`${o.id}::${v.id}`] || 0) * effectiveVariantUnit(o, v), 0);
+            return sum + (o.variants || []).reduce((vs, v) =>
+                vs + (quantities[`${o.id}::${v.id}`] || 0) * variantUnitNow(o, v), 0);
         }
-        return sum + (quantities[o.id] || 0) * effectiveOptionUnit(o);
+        return sum + (quantities[o.id] || 0) * optionUnitNow(o);
     }, 0);
 
     const belowPaid = isEdit && total < totalPaid;
     const belowIssued = isEdit && Object.entries(minQuantities).some(
-        ([key, minQty]: [string, any]) => minQty > 0 && (quantities[key] || 0) < minQty
+        ([key, minQty]) => minQty > 0 && (quantities[key] || 0) < minQty
     );
 
     const stepper = (key: string, delta: number) =>
-        setQuantities((q: Record<string, number>) => ({ ...q, [key]: Math.max(minQuantities[key] || 0, (q[key] || 0) + delta) }));
+        setQuantities((q) => ({ ...q, [key]: Math.max(minQuantities[key] || 0, (q[key] || 0) + delta) }));
 
     return (
         <div className="fixed inset-0 bg-black/40 flex items-center justify-center z-50 p-4">
@@ -1268,7 +1275,7 @@ function OptionsModal({ open, onClose, options, quantities, setQuantities, minQu
 
                 {/* Scrollable Content */}
                 <div className="flex-1 overflow-y-auto overscroll-contain p-5 space-y-3">
-                    {safeOptions.map((opt: any) => {
+                    {safeOptions.map((opt) => {
                         const hasVariants = (opt.variants || []).length > 0;
                         if (hasVariants) {
                             return (
@@ -1277,8 +1284,8 @@ function OptionsModal({ open, onClose, options, quantities, setQuantities, minQu
                                         {opt.name}
                                         {opt.isMainTicket && <span className="ml-1.5 text-xs text-brand-600 font-normal">• Main</span>}
                                     </div>
-                                    {(opt.variants as any[]).map((v: any) => {
-                                        const unit = effectiveVariantUnit(opt, v);
+                                    {(opt.variants || []).map((v) => {
+                                        const unit = variantUnitNow(opt, v);
                                         const basePrice = v.price !== null && v.price !== undefined ? v.price : opt.price;
                                         const key = `${opt.id}::${v.id}`;
                                         const minQty = minQuantities[key] || 0;
@@ -1303,7 +1310,7 @@ function OptionsModal({ open, onClose, options, quantities, setQuantities, minQu
                                 </div>
                             );
                         }
-                        const unit = effectiveOptionUnit(opt);
+                        const unit = optionUnitNow(opt);
                         const minQty = minQuantities[opt.id] || 0;
                         return (
                             <div key={opt.id} className="border rounded-xl p-3">
@@ -1383,7 +1390,15 @@ function OptionsModal({ open, onClose, options, quantities, setQuantities, minQu
     );
 }
 
-function DonationModal({ open, onClose, user, token, eventId, onSuccess, setError }: any) {
+function DonationModal({ open, onClose, user, token, eventId, onSuccess, setError }: {
+    open: boolean;
+    onClose: () => void;
+    user: UserSummary | null;
+    token: string | null;
+    eventId: string;
+    onSuccess?: () => void;
+    setError: (e: string | null) => void;
+}) {
     const [amount, setAmount] = useState("");
     const [method, setMethod] = useState("cash");
     const [saving, setSaving] = useState(false);
@@ -1418,8 +1433,8 @@ function DonationModal({ open, onClose, user, token, eventId, onSuccess, setErro
             setAmount("");
             onClose();
 
-        } catch (e: any) {
-            setError(e?.message || "Donation failed");
+        } catch (e) {
+            setError(errorMessage(e) || "Donation failed");
         } finally {
             setSaving(false);
         }
@@ -1477,7 +1492,12 @@ function DonationModal({ open, onClose, user, token, eventId, onSuccess, setErro
     );
 }
 
-function SendTicketsModal({ open, onClose, token, registration, setError, setInfo }: any) {
+function SendTicketsModal({ open, onClose, token, registration }: {
+    open: boolean;
+    onClose: () => void;
+    token: string | null;
+    registration: Pick<Registration, "id" | "user"> | null;
+}) {
     const [channel, setChannel] = useState<"email" | "whatsapp" | "both">("email");
     const [phone, setPhone] = useState("");
     const [email, setEmail] = useState("");
@@ -1492,7 +1512,7 @@ function SendTicketsModal({ open, onClose, token, registration, setError, setInf
             setLocalError("");
             setLocalInfo("");
         }
-    }, [open, registration]);
+    }, [open, registration, setLocalError]);
 
     if (!open) return null;
 
@@ -1512,7 +1532,7 @@ function SendTicketsModal({ open, onClose, token, registration, setError, setInf
                 method: "POST",
                 authToken: token,
                 body: {
-                    registrationId: registration.id,
+                    registrationId: registration?.id,
                     channel,
                     overrideEmail: email.trim() || undefined,
                     overridePhone: phone.trim() || undefined,
@@ -1520,8 +1540,8 @@ function SendTicketsModal({ open, onClose, token, registration, setError, setInf
             });
             setLocalInfo("Tickets sent successfully.");
             setTimeout(() => { setLocalInfo(""); onClose(); }, 7000);
-        } catch (e: any) {
-            setLocalError(e?.message || "Failed to send tickets");
+        } catch (e) {
+            setLocalError(errorMessage(e) || "Failed to send tickets");
         } finally {
             setSending(false);
         }
@@ -1606,7 +1626,14 @@ function SendTicketsModal({ open, onClose, token, registration, setError, setInf
     );
 }
 
-function RefundModal({ open, onClose, token, registration, maxRefund, onRefunded, setError }: any) {
+function RefundModal({ open, onClose, token, registration, maxRefund, onRefunded }: {
+    open: boolean;
+    onClose: () => void;
+    token: string | null;
+    registration: Registration | null;
+    maxRefund: number;
+    onRefunded: (updated: Registration) => void;
+}) {
     const [amount, setAmount] = useState("");
     const [method, setMethod] = useState("cash");
     const [reason, setReason] = useState("");
@@ -1615,9 +1642,9 @@ function RefundModal({ open, onClose, token, registration, maxRefund, onRefunded
 
     useEffect(() => {
         if (open) { setAmount(""); setReason(""); setLocalError(""); }
-    }, [open]);
+    }, [open, setLocalError]);
 
-    if (!open) return null;
+    if (!open || !registration) return null;
 
     const save = async (e: React.FormEvent) => {
         e.preventDefault();
@@ -1640,10 +1667,10 @@ function RefundModal({ open, onClose, token, registration, maxRefund, onRefunded
                 }
             });
             // Re-fetch registration to get updated status & payments
-            const updated = await apiFetch<any>(`/api/registrations/${registration.id}`, { authToken: token });
+            const updated = await apiFetch<Registration>(`/api/registrations/${registration.id}`, { authToken: token });
             onRefunded(updated);
-        } catch (e: any) {
-            setLocalError(e?.message || "Refund failed.");
+        } catch (e) {
+            setLocalError(errorMessage(e) || "Refund failed.");
         } finally {
             setSaving(false);
         }
@@ -1726,48 +1753,48 @@ function RefundModal({ open, onClose, token, registration, maxRefund, onRefunded
     );
 }
 
-function DoorRefundPanel({ token, eventId, setError, setInfo }: any) {
+function DoorRefundPanel({ token, eventId, setInfo }: {
+    token: string | null;
+    eventId: string;
+    setInfo: (s: string | null) => void;
+}) {
     const [search, setSearch] = useState("");
-    const [allRegs, setAllRegs] = useState<any[]>([]);
+    const [allRegs, setAllRegs] = useState<Registration[]>([]);
     const [loading, setLoading] = useState(false);
-    const [selectedReg, setSelectedReg] = useState<any | null>(null);
+    const [selectedReg, setSelectedReg] = useState<Registration | null>(null);
     const [showRefund, setShowRefund] = useState(false);
 
-    const load = async () => {
+    const load = useCallback(async () => {
         if (!token || !eventId) return;
         try {
             setLoading(true);
-            const regs = await apiFetch<any[]>(`/api/registrations/event/${eventId}`, { authToken: token });
+            const regs = await apiFetch<Registration[]>(`/api/registrations/event/${eventId}`, { authToken: token });
             setAllRegs(regs || []);
         } catch {
             setAllRegs([]);
         } finally {
             setLoading(false);
         }
-    };
+    }, [token, eventId]);
 
     useEffect(() => {
         load();
-    }, [token, eventId]);
+    }, [load]);
 
     // Only show registrations that have at least one payment
-    const paidRegs = allRegs.filter(r =>
-        (r.payments || []).reduce((s: number, p: any) => s + (p.amount || 0), 0) > 0
-    );
+    const paidRegs = allRegs.filter(r => totalPaidOn(r) > 0);
     const results = fuzzyFilterRegs(paidRegs, search);
 
-    const handleRefunded = async (updated: any) => {
+    const handleRefunded = async (updated: Registration) => {
         setShowRefund(false);
         setSelectedReg(updated);
         setInfo("Refund recorded");
         // Refresh list
-        const regs = await apiFetch<any[]>(`/api/registrations/event/${eventId}`, { authToken: token }).catch(() => null);
+        const regs = await apiFetch<Registration[]>(`/api/registrations/event/${eventId}`, { authToken: token }).catch(() => null);
         if (regs) setAllRegs(regs);
     };
 
-    const maxRefund = selectedReg
-        ? (selectedReg.payments || []).reduce((s: number, p: any) => s + (p.amount || 0), 0)
-        : 0;
+    const maxRefund = selectedReg ? totalPaidOn(selectedReg) : 0;
 
     return (
         <div className="border rounded-xl p-4 bg-white shadow-sm">
@@ -1793,7 +1820,7 @@ function DoorRefundPanel({ token, eventId, setError, setInfo }: any) {
 
                     <div className="space-y-2 max-h-[32rem] overflow-auto">
                         {results.map(r => {
-                            const paidValue = (r.payments || []).reduce((s: number, p: any) => s + (p.amount || 0), 0);
+                            const paidValue = totalPaidOn(r);
                             return (
                                 <div key={r.id} className="border rounded p-3 flex justify-between items-center">
                                     <div>
@@ -1842,12 +1869,7 @@ function DoorRefundPanel({ token, eventId, setError, setInfo }: any) {
                             <div className="border rounded p-3 text-center">
                                 <div className="text-xs text-gray-500">TOTAL</div>
                                 <div className="font-semibold">
-                                    R {(selectedReg.totalDueComputed ?? (selectedReg.options || selectedReg.registrationOptions || []).reduce((s: number, o: any) => {
-                                        const price = o.priceSnapshot !== null && o.priceSnapshot !== undefined
-                                            ? Number(o.priceSnapshot)
-                                            : (o.eventOption?.price || o.price || 0);
-                                        return s + price * (o.quantity || 0);
-                                    }, 0)).toFixed(2)}
+                                    R {registrationTotal(selectedReg).toFixed(2)}
                                 </div>
                             </div>
                             <div className="border rounded p-3 text-center bg-red-50">
@@ -1860,11 +1882,12 @@ function DoorRefundPanel({ token, eventId, setError, setInfo }: any) {
                             <div className="mt-3">
                                 <div className="text-xs font-medium text-gray-500 mb-1">Payment history</div>
                                 <div className="space-y-1">
-                                    {selectedReg.payments.map((p: any, i: number) => (
+                                    {(selectedReg.payments || []).map((p, i) => (
                                         <div key={i} className="flex justify-between text-sm">
                                             <span className={p.amount < 0 ? "text-red-600" : ""}>
                                                 {p.amount < 0 ? "Refund" : "Payment"} — {p.method || "—"}
-                                                {p.reason ? ` (${p.reason})` : ""}
+                                                {/* A refund's reason is stored in its status field. */}
+                                                {p.amount < 0 && p.status ? ` (${p.status})` : ""}
                                             </span>
                                             <span className={p.amount < 0 ? "text-red-600 font-medium" : ""}>
                                                 R {Number(p.amount).toFixed(2)}
@@ -1898,7 +1921,6 @@ function DoorRefundPanel({ token, eventId, setError, setInfo }: any) {
                 registration={selectedReg}
                 maxRefund={maxRefund}
                 onRefunded={handleRefunded}
-                setError={setError}
             />
         </div>
     );

frontend/src/app/dashboard/supervisor/consent/page.tsx

@@ -8,26 +8,9 @@ import { formatDate } from "@/lib/date";
 import { useDismissingState } from "@/hooks/useDismissingState";
 import { ShieldCheck, Send, RefreshCw, HeartPulse, Printer } from "lucide-react";
 import { Table, TableHeader, TableBody, TableRow, TableHead, TableCell } from "@/components/ui/table";
+import { errorMessage } from "@/lib/utils";
+import type { Event, ConsentRow, MedicalRow } from "@/types";
 
-type ConsentRow = {
-  attendeeId: string;
-  name: string;
-  dateOfBirth: string | null;
-  minor: boolean;
-  parentName: string | null;
-  parentEmail: string | null;
-  parentPhone: string | null;
-  registrationStatus: string;
-  bookedBy: { name: string; email: string };
-  status: "not_required" | "missing" | "pending" | "given" | "declined";
-  request: { id: string; status: string; textVersion: number; signedName: string | null; respondedAt: string | null; lastSentAt: string; remindersSent: number; photoConsent: boolean | null; outdated: boolean } | null;
-};
-type MedicalRow = {
-  name: string; dateOfBirth: string | null; parentName: string | null; parentPhone: string | null; parentEmail: string | null;
-  medical: { allergies: string; medication: string; conditions: string; medicalAid: string } | null;
-  emergency: { name: string; phone: string; relationship: string } | null;
-  photoConsent: boolean | null; purged: boolean;
-};
 
 const STATUS_STYLE: Record<ConsentRow["status"], { label: string; cls: string }> = {
   not_required: { label: "Not needed (18+)", cls: "bg-gray-100 text-gray-600" },
@@ -51,9 +34,9 @@ export default function ConsentTrackerPage() {
     if (!user) router.replace("/login");
   }, [user, loading, router]);
 
-  const [events, setEvents] = useState<any[]>([]);
+  const [events, setEvents] = useState<Event[]>([]);
   const [eventId, setEventId] = useState<string>(search.get("eventId") || "");
-  const [data, setData] = useState<{ event: any; counts: Record<string, number>; rows: ConsentRow[] } | null>(null);
+  const [data, setData] = useState<{ event: Pick<Event, "id" | "title">; counts: Record<string, number>; rows: ConsentRow[] } | null>(null);
   const [filter, setFilter] = useState<"minors" | "all" | "waiting">("minors");
   const [busy, setBusy] = useState(false);
   const [error, setError] = useDismissingState<string | null>(null);
@@ -61,7 +44,7 @@ export default function ConsentTrackerPage() {
 
   useEffect(() => {
     if (!token || !canView) return;
-    apiFetch<any[]>("/api/events/all?includePast=true", { authToken: token })
+    apiFetch<Event[]>("/api/events/all?includePast=true", { authToken: token })
       .then(evs => {
         const youth = (evs || []).filter(e => e.requiresParentalConsent);
         setEvents(youth);
@@ -76,8 +59,8 @@ export default function ConsentTrackerPage() {
     setBusy(true);
     try {
       setData(await apiFetch(`/api/consent/events/${encodeURIComponent(eventId)}`, { authToken: token }));
-    } catch (e: any) {
-      setError(e?.message || "Failed to load consent status");
+    } catch (e) {
+      setError(errorMessage(e) || "Failed to load consent status");
     } finally {
       setBusy(false);
     }
@@ -100,8 +83,8 @@ export default function ConsentTrackerPage() {
       const res = await fn();
       setInfo(res.message);
       await load();
-    } catch (e: any) {
-      setError(e?.message || "Something went wrong");
+    } catch (e) {
+      setError(errorMessage(e) || "Something went wrong");
     } finally {
       setBusy(false);
     }
@@ -114,7 +97,7 @@ export default function ConsentTrackerPage() {
   // Printable list for camp leaders. Opening it is recorded in the audit log.
   const printMedical = async () => {
     try {
-      const res = await apiFetch<{ event: any; rows: MedicalRow[] }>(`/api/consent/events/${eventId}/medical`, { authToken: token! });
+      const res = await apiFetch<{ event: Pick<Event, "id" | "title">; rows: MedicalRow[] }>(`/api/consent/events/${eventId}/medical`, { authToken: token! });
       const w = window.open("", "_blank");
       if (!w) { setError("Allow pop-ups to print the medical list."); return; }
       const rowsHtml = res.rows.map(r => `
@@ -139,8 +122,8 @@ export default function ConsentTrackerPage() {
         <tbody>${rowsHtml || '<tr><td colspan="5">No consent given yet.</td></tr>'}</tbody></table>
         <script>window.onload=()=>window.print()</script></body></html>`);
       w.document.close();
-    } catch (e: any) {
-      setError(e?.message || "Failed to load the medical list");
+    } catch (e) {
+      setError(errorMessage(e) || "Failed to load the medical list");
     }
   };
 

frontend/src/app/dashboard/supervisor/coupons/page.tsx

@@ -7,6 +7,7 @@ import { apiFetch } from "@/lib/api";
 import { useDismissingState } from "@/hooks/useDismissingState";
 import { TicketPercent, Plus, X, Search } from "lucide-react";
 import { Table, TableHeader, TableBody, TableRow, TableHead, TableCell } from "@/components/ui/table";
+import { errorMessage } from "@/lib/utils";
 
 type CouponType = "percent" | "fixed" | "comp";
 type Role = "user" | "staff" | "supervisor" | "admin";
@@ -164,8 +165,8 @@ export default function CouponsPage() {
       ]);
       setCoupons(c || []);
       setEvents(ev || []);
-    } catch (e: any) {
-      setError(e?.message || "Failed to load coupons");
+    } catch (e) {
+      setError(errorMessage(e) || "Failed to load coupons");
     } finally {
       setFetching(false);
     }
@@ -183,8 +184,8 @@ export default function CouponsPage() {
       await apiFetch(`/api/coupons/${c.id}`, { method: "PUT", authToken: token!, body: { active: !c.active } });
       setInfo(`${c.code} turned ${c.active ? "off" : "on"}.`);
       load();
-    } catch (e: any) {
-      setError(e?.message || "Failed to update coupon");
+    } catch (e) {
+      setError(errorMessage(e) || "Failed to update coupon");
     }
   };
 
@@ -192,8 +193,8 @@ export default function CouponsPage() {
     try {
       const full = await apiFetch<Coupon & { redemptions: Redemption[] }>(`/api/coupons/${c.id}`, { authToken: token! });
       setViewing({ coupon: c, redemptions: full.redemptions || [] });
-    } catch (e: any) {
-      setError(e?.message || "Failed to load uses");
+    } catch (e) {
+      setError(errorMessage(e) || "Failed to load uses");
     }
   };
 
@@ -406,8 +407,8 @@ function CouponModal({ token, events, couponId, initial, onClose, onSaved }: {
         await apiFetch(`/api/coupons`, { method: "POST", authToken: token, body });
         onSaved(`${body.code.toUpperCase()} created.`);
       }
-    } catch (err: any) {
-      setError(err?.message || "Failed to save");
+    } catch (err) {
+      setError(errorMessage(err) || "Failed to save");
     } finally {
       setSaving(false);
     }

frontend/src/app/dashboard/supervisor/email-attendees/page.tsx

@@ -1,13 +1,22 @@
 "use client";
 
-import React, { Suspense, useEffect, useMemo, useState } from "react";
+import React, { Suspense, useCallback, useEffect, useMemo, useState } from "react";
 import { useAuth } from "@/hooks/useAuth";
 import { useRouter, useSearchParams } from "next/navigation";
 import { apiFetch, fetchAllUsers } from "@/lib/api";
 import { useDismissingState } from "@/hooks/useDismissingState";
 import { Mail, Users, Zap, Clock } from "lucide-react";
+import { AllocationGroupFilter } from "@/components/shared/AllocationGroupFilter";
+import { errorMessage } from "@/lib/utils";
+import type { Event, MessageSendResult, Registration, User } from "@/types";
 
 type Attendee = { id: string; name: string; email: string; pref: string };
+type TemplateKey = 'custom'|'payment_reminder'|'event_reminder'|'tickets';
+type StatusFilter = 'any'|'paid'|'unpaid'|'partial_paid'|'cancelled';
+type MessageFilter = { status?: Exclude<StatusFilter, 'any'>; attendeeIds?: string[]; allocationGroupId?: string };
+// A message body goes as `html` when it looks like markup, otherwise as plain `text`.
+type EmailContent = { html?: string; text?: string };
+type EmailSendResult = MessageSendResult<{ email: string; name?: string }>;
 
 export default function EmailAttendeesPage() {
   return (
@@ -134,16 +143,14 @@ function AttendeesCheckboxDropdown({
 }
 
 function PrefWarning({ attendees, selectedIds, channel }: { attendees: { id: string; pref: string }[]; selectedIds: string[]; channel: "email" | "whatsapp" }) {
-  const prefMatch = (pref: string) =>
-    channel === "email" ? pref === "email" || pref === "both" : pref === "whatsapp" || pref === "both";
-
-  const mismatched = useMemo(
-    () => selectedIds.filter(id => {
+  const mismatched = useMemo(() => {
+    const prefMatch = (pref: string) =>
+      channel === "email" ? pref === "email" || pref === "both" : pref === "whatsapp" || pref === "both";
+    return selectedIds.filter(id => {
       const a = attendees.find(x => x.id === id);
       return a && !prefMatch(a.pref);
-    }),
-    [attendees, selectedIds, channel]
-  );
+    });
+  }, [attendees, selectedIds, channel]);
 
   if (mismatched.length === 0) return null;
   return (
@@ -179,9 +186,7 @@ function EmailAttendeesPageInner() {
   // Tabs: attendees (current), automations (coming soon), broadcasts
   const [tab, setTab] = useState<'attendees'|'automations'|'broadcasts'|'scheduled'>('attendees');
 
-  const isAdmin = user?.role === "admin";
-
-  const [allEvents, setAllEvents] = useState<any[]>([]);
+  const [allEvents, setAllEvents] = useState<Event[]>([]);
   const [evIncludePast, setEvIncludePast] = useState(false);
 
   const events = useMemo(() => {
@@ -193,20 +198,21 @@ function EmailAttendeesPageInner() {
     });
   }, [allEvents, evIncludePast]);
 
-  const loadEvents = async () => {
+  const loadEvents = useCallback(async () => {
     try {
       setLoadingEvents(true);
-      const evs = await apiFetch<any[]>("/api/events/all?includePast=true", { authToken: token || undefined });
-      const sorted = (evs || []).sort((a: any, b: any) => new Date(a.startDate).getTime() - new Date(b.startDate).getTime());
+      const evs = await apiFetch<Event[]>("/api/events/all?includePast=true", { authToken: token || undefined });
+      const sorted = (evs || []).sort((a, b) => new Date(a.startDate).getTime() - new Date(b.startDate).getTime());
       setAllEvents(sorted);
-    } catch (e: any) {
-      setError(e?.message || "Failed to load events");
+    } catch (e) {
+      setError(errorMessage(e) || "Failed to load events");
     } finally {
       setLoadingEvents(false);
     }
-  };
+  }, [token, setError]);
 
-  useEffect(() => { loadEvents(); }, [user, token]);
+  // Reload when the signed-in user changes too (e.g. after an impersonation switch).
+  useEffect(() => { loadEvents(); }, [user, loadEvents]);
 
   // Load users for broadcasts
   useEffect(() => {
@@ -216,11 +222,11 @@ function EmailAttendeesPageInner() {
         setLoadingUsers(true);
         const allUsers = await fetchAllUsers(token);
         const mapped = allUsers
-          .filter((u: any) => u.isActive !== false && !u.email?.endsWith('@guest.local'))
-          .map((u: any) => ({ id: u.id, name: u.name || '', email: u.email || '', pref: u.notificationPreference || 'email' }))
-          .sort((a: any, b: any) => (a.name || '').localeCompare(b.name || '', undefined, { sensitivity: 'base' }));
+          .filter((u) => u.isActive !== false && !u.email?.endsWith('@guest.local'))
+          .map((u) => ({ id: u.id, name: u.name || '', email: u.email || '', pref: u.notificationPreference || 'email' }))
+          .sort((a, b) => (a.name || '').localeCompare(b.name || '', undefined, { sensitivity: 'base' }));
         setUsers(mapped);
-      } catch (e) {
+      } catch {
         // ignore for now
       } finally {
         setLoadingUsers(false);
@@ -235,7 +241,7 @@ function EmailAttendeesPageInner() {
     if (preselectEventId) setEventId(preselectEventId);
   }, [preselectEventId]);
 
-  const [templateKey, setTemplateKey] = useState<'custom'|'payment_reminder'|'event_reminder'|'tickets'>('custom');
+  const [templateKey, setTemplateKey] = useState<TemplateKey>('custom');
   const [showInfo, setShowInfo] = useState(false);
 
   // Broadcasts state
@@ -270,20 +276,20 @@ function EmailAttendeesPageInner() {
   const [editWhen, setEditWhen] = useState<string>('');
   const [savingEdit, setSavingEdit] = useState(false);
 
-  const loadScheduled = async () => {
+  const loadScheduled = useCallback(async () => {
     try {
       if (!token) return;
       setLoadingScheduled(true);
       const res = await apiFetch<{jobs: ScheduledJob[]}>(`/api/scheduled-emails?channel=email`, { authToken: token });
       setScheduled(Array.isArray(res?.jobs) ? res.jobs : []);
-    } catch (e) {
+    } catch {
       // ignore here; surfaces via UI when tab open
     } finally {
       setLoadingScheduled(false);
     }
-  };
+  }, [token]);
 
-  useEffect(() => { if (tab === 'scheduled') loadScheduled(); }, [tab, token]);
+  useEffect(() => { if (tab === 'scheduled') loadScheduled(); }, [tab, loadScheduled]);
 
   const openEdit = (job: ScheduledJob) => {
     setEditing(job);
@@ -297,7 +303,7 @@ function EmailAttendeesPageInner() {
     try {
       setSavingEdit(true);
       if (!token) { setError('Not authenticated'); return; }
-      const body: any = {};
+      const body: { scheduledAt?: string; subject?: string } & EmailContent = {};
       if (editWhen) body.scheduledAt = new Date(editWhen).toISOString();
       if (editSubject.trim().length || editBody.trim().length) {
         body.subject = editSubject;
@@ -313,8 +319,8 @@ function EmailAttendeesPageInner() {
       setInfo('Scheduled email updated.');
       setEditing(null);
       loadScheduled();
-    } catch (e:any) {
-      setError(e?.message || 'Failed to update scheduled email');
+    } catch (e) {
+      setError(errorMessage(e) || 'Failed to update scheduled email');
     } finally {
       setSavingEdit(false);
     }
@@ -326,8 +332,8 @@ function EmailAttendeesPageInner() {
       await apiFetch(`/api/scheduled-emails/${encodeURIComponent(job.id)}`, { method: 'DELETE', authToken: token });
       setInfo('Scheduled email removed.');
       loadScheduled();
-    } catch (e:any) {
-      setError(e?.message || 'Failed to remove scheduled email');
+    } catch (e) {
+      setError(errorMessage(e) || 'Failed to remove scheduled email');
     }
   };
 
@@ -335,7 +341,8 @@ function EmailAttendeesPageInner() {
   const [body, setBody] = useState("");
   const [subjectDirty, setSubjectDirty] = useState(false);
   const [bodyDirty, setBodyDirty] = useState(false);
-  const [status, setStatus] = useState<'any'|'paid'|'unpaid'|'partial_paid'|'cancelled'>("any");
+  const [status, setStatus] = useState<StatusFilter>("any");
+  const [groupId, setGroupId] = useState("");
   // Attendees list and selection
   const [attendees, setAttendees] = useState<Attendee[]>([]);
   const [selectedAttendeeIds, setSelectedAttendeeIds] = useState<string[]>([]);
@@ -358,11 +365,8 @@ function EmailAttendeesPageInner() {
       setBodyDirty(false);
       setSubject('');
       setBody('');
-    } else {
-      // custom: do not overwrite user content unless not dirty and we have event change
-      if (!subjectDirty && subject) setSubject(subject); // keep as-is
-      if (!bodyDirty && body) setBody(body);
     }
+    // custom: leave whatever the supervisor typed alone.
     // When event changes, refresh defaults if not dirty
   }, [templateKey, currentEvent, subjectDirty, bodyDirty]);
 
@@ -387,10 +391,10 @@ function EmailAttendeesPageInner() {
         setAttendees([]);
         setSelectedAttendeeIds([]);
         if (!eventId || !token) return;
-        const regs = await apiFetch<any[]>(`/api/registrations/event/${encodeURIComponent(eventId)}`, { authToken: token });
+        const regs = await apiFetch<Registration[]>(`/api/registrations/event/${encodeURIComponent(eventId)}`, { authToken: token });
         const uniq = new Map<string, Attendee>();
-        (regs || []).forEach((r: any) => {
-          const u = r?.user;
+        (regs || []).forEach((r) => {
+          const u: User | undefined = r?.user;
           if (u?.id && u?.email && !u.email.endsWith('@guest.local') && u.isActive !== false) {
             uniq.set(u.id, { id: u.id, name: u.name || '', email: u.email || '', pref: u.notificationPreference || 'email' });
           }
@@ -400,7 +404,7 @@ function EmailAttendeesPageInner() {
         // Default: select those with email/both preference; fall back to all
         const matching = list.filter(a => a.pref === 'email' || a.pref === 'both').map(a => a.id);
         setSelectedAttendeeIds(matching.length > 0 ? matching : list.map(a => a.id));
-      } catch (e) {
+      } catch {
         // ignore
       } finally {
         setLoadingAttendees(false);
@@ -418,21 +422,21 @@ function EmailAttendeesPageInner() {
         if (!subject.trim()) { setError("Subject is required"); return; }
         if (!body.trim()) { setError("Message is required"); return; }
       }
-      const payload: any = {
+      const payload: { subject: string; filter: MessageFilter; dryRun: boolean; template: TemplateKey } & EmailContent = {
         subject: subject || "(no subject)",
-        filter: { status: status !== 'any' ? status : undefined, attendeeIds: selectedAttendeeIds && selectedAttendeeIds.length ? selectedAttendeeIds : undefined },
+        filter: { status: status !== 'any' ? status : undefined, attendeeIds: selectedAttendeeIds && selectedAttendeeIds.length ? selectedAttendeeIds : undefined, allocationGroupId: groupId || undefined },
         dryRun: true,
         template: templateKey,
       };
       if (templateKey !== 'tickets') {
         if (body.trim().startsWith('<')) payload.html = body; else payload.text = body;
       }
-      const res = await apiFetch(`/api/events/${encodeURIComponent(eventId)}/email-attendees`, { method: 'POST', authToken: token, body: payload });
+      const res = await apiFetch<EmailSendResult>(`/api/events/${encodeURIComponent(eventId)}/email-attendees`, { method: 'POST', authToken: token, body: payload });
       setPreviewCount(res?.matched ?? 0);
       setPreviewSample(Array.isArray(res?.recipients) ? res.recipients : null);
       setInfo(`Matched ${res?.matched ?? 0} recipient(s).`);
-    } catch (e: any) {
-      setError(e?.message || 'Failed to preview recipients');
+    } catch (e) {
+      setError(errorMessage(e) || 'Failed to preview recipients');
     }
   };
 
@@ -458,21 +462,21 @@ function EmailAttendeesPageInner() {
         if (!body.trim()) { setError("Message is required"); return; }
       }
       setSending(true);
-      const payload: any = {
+      const payload: { subject: string; filter: MessageFilter; template: TemplateKey } & EmailContent = {
         subject,
-        filter: { status: status !== 'any' ? status : undefined, attendeeIds: selectedAttendeeIds && selectedAttendeeIds.length ? selectedAttendeeIds : undefined },
+        filter: { status: status !== 'any' ? status : undefined, attendeeIds: selectedAttendeeIds && selectedAttendeeIds.length ? selectedAttendeeIds : undefined, allocationGroupId: groupId || undefined },
         template: templateKey,
       };
       if (templateKey !== 'tickets') {
         if (body.trim().startsWith('<')) payload.html = body; else payload.text = body.replace(/\n/g, '\n');
       }
-      const res = await apiFetch(`/api/events/${encodeURIComponent(eventId)}/email-attendees`, { method: 'POST', authToken: token, body: payload });
+      const res = await apiFetch<EmailSendResult>(`/api/events/${encodeURIComponent(eventId)}/email-attendees`, { method: 'POST', authToken: token, body: payload });
       const queued = res?.queued ?? res?.matched ?? 0;
       setInfo(`Queued ${queued} recipient(s) for sending.`);
       // Reset form to default state
       resetAttendeesForm();
-    } catch (e: any) {
-      setError(e?.message || 'Failed to send emails');
+    } catch (e) {
+      setError(errorMessage(e) || 'Failed to send emails');
     } finally {
       setSending(false);
     }
@@ -554,7 +558,7 @@ function EmailAttendeesPageInner() {
                     Info
                   </button>
                 </div>
-                <select className="w-full border rounded px-3 py-2 text-sm" value={templateKey} onChange={e => setTemplateKey(e.target.value as any)}>
+                <select className="w-full border rounded px-3 py-2 text-sm" value={templateKey} onChange={e => setTemplateKey(e.target.value as TemplateKey)}>
                   <option value="custom">Custom message</option>
                   <option value="payment_reminder">Payment reminder (with outstanding)</option>
                   <option value="event_reminder">Event reminder (date & time)</option>
@@ -582,7 +586,7 @@ function EmailAttendeesPageInner() {
                         <li><code>{'{{event.title}}'}</code> — the event title.</li>
                         <li><code>{'{{event.start}}'}</code> — the event start date/time (local).</li>
                         <li><code>{'{{balance}}'}</code> — outstanding amount across the attendee’s registrations for the selected event.</li>
-                        <li><code>{'{{payment.link}}'}</code> — a direct Yoco payment link for the attendee's outstanding balance (generated per recipient when sending).</li>
+                        <li><code>{'{{payment.link}}'}</code> — a direct Yoco payment link for the attendee&apos;s outstanding balance (generated per recipient when sending).</li>
                       </ul>
                       <p className="mb-2">Example: Hi <code>{'{{name}}'}</code>, your balance is <code>{'{{balance}}'}</code>. Pay here: <code>{'{{payment.link}}'}</code></p>
                       <p className="text-[11px] text-gray-500">To add new placeholders, extend <span className="font-mono">backend/src/utils/placeholders.js</span> and update this help.</p>
@@ -599,7 +603,7 @@ function EmailAttendeesPageInner() {
               </div>
               <div>
                 <label className="block text-xs text-gray-600 mb-1">Payment status filter</label>
-                <select className="w-full border rounded px-3 py-2 text-sm" value={status} onChange={e => setStatus(e.target.value as any)}>
+                <select className="w-full border rounded px-3 py-2 text-sm" value={status} onChange={e => setStatus(e.target.value as StatusFilter)}>
                   <option value="any">Any</option>
                   <option value="paid">Paid</option>
                   <option value="unpaid">Unpaid (pending or partial)</option>
@@ -607,6 +611,7 @@ function EmailAttendeesPageInner() {
                   <option value="cancelled">Cancelled</option>
                 </select>
               </div>
+              <AllocationGroupFilter token={token} eventId={eventId} value={groupId} onChange={setGroupId} />
             </div>
 
             {templateKey !== 'tickets' ? (
@@ -657,16 +662,16 @@ function EmailAttendeesPageInner() {
                     if (!body.trim()) { setError('Message is required'); return; }
                   }
                   const whenIso = new Date(scheduledAtLocal).toISOString();
-                  const payload = {
+                  const payload: { subject: string; filter: MessageFilter; template: TemplateKey; scheduledAt: string } & EmailContent = {
                     subject,
-                    filter: { status: status !== 'any' ? status : undefined, attendeeIds: selectedAttendeeIds && selectedAttendeeIds.length ? selectedAttendeeIds : undefined },
+                    filter: { status: status !== 'any' ? status : undefined, attendeeIds: selectedAttendeeIds && selectedAttendeeIds.length ? selectedAttendeeIds : undefined, allocationGroupId: groupId || undefined },
                     template: templateKey,
                     scheduledAt: whenIso,
-                  } as any;
+                  };
                   if (templateKey !== 'tickets') {
                     if (body.trim().startsWith('<')) payload.html = body; else payload.text = body.replace(/\n/g, '\n');
                   }
-                  const res = await apiFetch(`/api/events/${encodeURIComponent(eventId)}/email-attendees/schedule`, { method: 'POST', authToken: token, body: payload });
+                  const res = await apiFetch<EmailSendResult>(`/api/events/${encodeURIComponent(eventId)}/email-attendees/schedule`, { method: 'POST', authToken: token, body: payload });
                   if (res?.job?.id) {
                     setInfo('Email scheduled. It will be sent around the specified time.');
                   } else {
@@ -674,8 +679,8 @@ function EmailAttendeesPageInner() {
                   }
                   // Reset form to default state
                   resetAttendeesForm();
-                } catch (e:any) {
-                  setError(e?.message || 'Failed to schedule email');
+                } catch (e) {
+                  setError(errorMessage(e) || 'Failed to schedule email');
                 }
               }}>Schedule send</button>
               {previewCount != null && (
@@ -776,13 +781,13 @@ Jane Doe <jane@example.com>
                   if (!token) { setError('Not authenticated'); return; }
                   if (!broadcastSubject.trim()) { setError('Subject is required'); return; }
                   if (!broadcastBody.trim()) { setError('Message is required'); return; }
-                  const body: any = { userIds: selectedUserIds, emails: broadcastEmails, eventId: broadcastEventId || undefined };
-                  const res = await apiFetch(`/api/broadcasts/preview`, { method: 'POST', authToken: token, body });
+                  const body = { userIds: selectedUserIds, emails: broadcastEmails, eventId: broadcastEventId || undefined };
+                  const res = await apiFetch<EmailSendResult>(`/api/broadcasts/preview`, { method: 'POST', authToken: token, body });
                   setBroadcastPreviewCount(res?.matched ?? 0);
                   setBroadcastPreviewSample(Array.isArray(res?.recipients) ? res.recipients : null);
                   setInfo(`Matched ${res?.matched ?? 0} recipient(s).`);
-                } catch (e:any) {
-                  setError(e?.message || 'Failed to preview recipients');
+                } catch (e) {
+                  setError(errorMessage(e) || 'Failed to preview recipients');
                 }
               }}>Preview recipients</button>
 
@@ -792,14 +797,14 @@ Jane Doe <jane@example.com>
                   if (!token) { setError('Not authenticated'); return; }
                   if (!broadcastSubject.trim()) { setError('Subject is required'); return; }
                   if (!broadcastBody.trim()) { setError('Message is required'); return; }
-                  const payload: any = { subject: broadcastSubject, eventId: broadcastEventId || undefined, userIds: selectedUserIds, emails: broadcastEmails };
+                  const payload: { subject: string; eventId?: string; userIds: string[]; emails: string } & EmailContent = { subject: broadcastSubject, eventId: broadcastEventId || undefined, userIds: selectedUserIds, emails: broadcastEmails };
                   if (broadcastBody.trim().startsWith('<')) payload.html = broadcastBody; else payload.text = broadcastBody;
-                  const res = await apiFetch(`/api/broadcasts/send`, { method: 'POST', authToken: token, body: payload });
+                  const res = await apiFetch<EmailSendResult>(`/api/broadcasts/send`, { method: 'POST', authToken: token, body: payload });
                   setInfo(`Sent ${res?.sent ?? 0} out of ${res?.matched ?? 0} recipient(s).`);
                   // Reset broadcast form
                   resetBroadcastForm();
-                } catch (e:any) {
-                  setError(e?.message || 'Failed to send broadcast');
+                } catch (e) {
+                  setError(errorMessage(e) || 'Failed to send broadcast');
                 }
               }}>Send now</button>
 
@@ -810,14 +815,14 @@ Jane Doe <jane@example.com>
                   if (!broadcastSubject.trim()) { setError('Subject is required'); return; }
                   if (!broadcastBody.trim()) { setError('Message is required'); return; }
                   const whenIso = new Date(broadcastScheduledAtLocal).toISOString();
-                  const payload: any = { scheduledAt: whenIso, subject: broadcastSubject, eventId: broadcastEventId || undefined, userIds: selectedUserIds, emails: broadcastEmails };
+                  const payload: { scheduledAt: string; subject: string; eventId?: string; userIds: string[]; emails: string } & EmailContent = { scheduledAt: whenIso, subject: broadcastSubject, eventId: broadcastEventId || undefined, userIds: selectedUserIds, emails: broadcastEmails };
                   if (broadcastBody.trim().startsWith('<')) payload.html = broadcastBody; else payload.text = broadcastBody;
-                  const res = await apiFetch(`/api/broadcasts/schedule`, { method: 'POST', authToken: token, body: payload });
+                  const res = await apiFetch<EmailSendResult>(`/api/broadcasts/schedule`, { method: 'POST', authToken: token, body: payload });
                   if (res?.job?.id) setInfo('Broadcast scheduled. It will be sent around the specified time.'); else setInfo('Scheduled.');
                   // Reset broadcast form
                   resetBroadcastForm();
-                } catch (e:any) {
-                  setError(e?.message || 'Failed to schedule broadcast');
+                } catch (e) {
+                  setError(errorMessage(e) || 'Failed to schedule broadcast');
                 }
               }}>Schedule send</button>
 
@@ -960,9 +965,9 @@ function toLocalInputValue(d: Date) {
   return `${y}-${m}-${day}T${hh}:${mm}`;
 }
 
-function AutomationsPanel({ events, token, onInfo, onError }:{ events: any[]; token?: string | null; onInfo: (s: string) => void; onError: (s: string) => void }) {
+function AutomationsPanel({ events, token, onInfo, onError }:{ events: Event[]; token?: string | null; onInfo: (s: string | null) => void; onError: (s: string | null) => void }) {
   const [autoEventId, setAutoEventId] = React.useState<string>('');
-  const currentEvent = React.useMemo(() => (events || []).find((e:any) => e.id === autoEventId), [events, autoEventId]);
+  const currentEvent = React.useMemo(() => (events || []).find((e) => e.id === autoEventId), [events, autoEventId]);
 
   // Defaults builders
   const preWeekDefault = React.useMemo(() => ({
@@ -986,6 +991,16 @@ function AutomationsPanel({ events, token, onInfo, onError }:{ events: any[]; to
   const [enablePre, setEnablePre] = React.useState(true);
   const [enableFinal, setEnableFinal] = React.useState(true);
   const [enableThanks, setEnableThanks] = React.useState(true);
+  // Sponsors of "sponsor a spot" events get their own thank-you.
+  const [enableSponsors, setEnableSponsors] = React.useState(true);
+  const [sponsorSubject, setSponsorSubject] = React.useState('Thank you for sponsoring a spot at {{event.title}}');
+  const [sponsorBody, setSponsorBody] = React.useState(`Hi {{name}}
+
+Thank you for sponsoring a spot at {{event.title}}. Because of you, someone was able to be there who otherwise couldn't.
+
+[add a highlight or two]
+
+With gratitude`);
   const [enablePromo, setEnablePromo] = React.useState(false);
 
   // Subjects/Bodies
@@ -1042,32 +1057,38 @@ function AutomationsPanel({ events, token, onInfo, onError }:{ events: any[]; to
 
   const onSchedule = async () => {
     try {
-      onError(null as any); onInfo(null as any);
+      onError(null); onInfo(null);
       if (!token) { onError('Not authenticated'); return; }
       if (!autoEventId) { onError('Please select an event'); return; }
-      const jobs: any[] = [];
+      type AutomationJob = { subject: string; scheduledAt: string; audience?: 'sponsors'; promoEventId?: string } & EmailContent;
+      const jobs: AutomationJob[] = [];
       if (enablePre && preSubject.trim() && preBody.trim() && preWhen) {
-        const payload: any = { subject: preSubject, scheduledAt: new Date(preWhen).toISOString() };
+        const payload: AutomationJob = { subject: preSubject, scheduledAt: new Date(preWhen).toISOString() };
         if (preBody.trim().startsWith('<')) payload.html = preBody; else payload.text = preBody;
         jobs.push(payload);
       }
       if (enableFinal && finalSubject.trim() && finalBody.trim() && finalWhen) {
-        const payload: any = { subject: finalSubject, scheduledAt: new Date(finalWhen).toISOString() };
+        const payload: AutomationJob = { subject: finalSubject, scheduledAt: new Date(finalWhen).toISOString() };
         if (finalBody.trim().startsWith('<')) payload.html = finalBody; else payload.text = finalBody;
         jobs.push(payload);
       }
       if (enableThanks && thanksSubject.trim() && thanksBody.trim() && thanksWhen) {
-        const payload: any = { subject: thanksSubject, scheduledAt: new Date(thanksWhen).toISOString() };
+        const payload: AutomationJob = { subject: thanksSubject, scheduledAt: new Date(thanksWhen).toISOString() };
         if (thanksBody.trim().startsWith('<')) payload.html = thanksBody; else payload.text = thanksBody;
         jobs.push(payload);
       }
+      if (currentEvent?.allowSponsorships && enableSponsors && sponsorSubject.trim() && sponsorBody.trim() && thanksWhen) {
+        const payload: AutomationJob = { subject: sponsorSubject, scheduledAt: new Date(thanksWhen).toISOString(), audience: 'sponsors' };
+        if (sponsorBody.trim().startsWith('<')) payload.html = sponsorBody; else payload.text = sponsorBody;
+        jobs.push(payload);
+      }
       if (enablePromo && promoSubject.trim() && promoBody.trim() && promoWhen) {
-        const payload: any = { subject: promoSubject, scheduledAt: new Date(promoWhen).toISOString(), promoEventId: promoEventId || undefined };
+        const payload: AutomationJob = { subject: promoSubject, scheduledAt: new Date(promoWhen).toISOString(), promoEventId: promoEventId || undefined };
         if (promoBody.trim().startsWith('<')) payload.html = promoBody; else payload.text = promoBody;
         jobs.push(payload);
       }
       if (jobs.length === 0) { onError('Please enable at least one automation and fill in details'); return; }
-      const res = await apiFetch(`/api/automations/schedule`, { method: 'POST', authToken: token, body: { eventId: autoEventId, jobs } });
+      const res = await apiFetch<{ message?: string }>(`/api/automations/schedule`, { method: 'POST', authToken: token, body: { eventId: autoEventId, jobs } });
       onInfo(res?.message || `Scheduled ${jobs.length} automation(s).`);
       // Reset to defaults (keep event selection)
       setEnablePre(true); setEnableFinal(true); setEnableThanks(true); setEnablePromo(false);
@@ -1075,8 +1096,8 @@ function AutomationsPanel({ events, token, onInfo, onError }:{ events: any[]; to
       setFinalSubject(finalDefault.subject); setFinalBody(finalDefault.body); setFinalHours('24');
       setThanksSubject(thanksDefault.subject); setThanksBody(thanksDefault.body);
       setPromoSubject(promoDefault.subject); setPromoBody(promoDefault.body); setPromoEventId('');
-    } catch (e:any) {
-      onError(e?.message || 'Failed to schedule automations');
+    } catch (e) {
+      onError(errorMessage(e) || 'Failed to schedule automations');
     }
   };
 
@@ -1086,7 +1107,7 @@ function AutomationsPanel({ events, token, onInfo, onError }:{ events: any[]; to
         <label className="block text-xs text-gray-600 mb-1">Event</label>
         <select className="w-full border rounded px-3 py-2 text-sm" value={autoEventId} onChange={e => setAutoEventId(e.target.value)}>
           <option value="">Select an event…</option>
-          {(events||[]).map((ev:any) => (
+          {(events||[]).map((ev) => (
             <option key={ev.id} value={ev.id}>{ev.title}</option>
           ))}
         </select>
@@ -1119,7 +1140,7 @@ function AutomationsPanel({ events, token, onInfo, onError }:{ events: any[]; to
               <input type="checkbox" checked={enableFinal} onChange={e => setEnableFinal(e.target.checked)} /> Enable
             </label>
             <label className="text-xs text-gray-600">Hours before: </label>
-            <select className="border rounded px-2 py-1 text-sm" value={finalHours} onChange={e => setFinalHours(e.target.value as any)}>
+            <select className="border rounded px-2 py-1 text-sm" value={finalHours} onChange={e => setFinalHours(e.target.value as '24'|'48')}>
               <option value="24">24</option>
               <option value="48">48</option>
             </select>
@@ -1157,6 +1178,20 @@ function AutomationsPanel({ events, token, onInfo, onError }:{ events: any[]; to
           <textarea className="w-full border rounded px-3 py-2 text-sm" rows={5} value={thanksBody} onChange={e => setThanksBody(e.target.value)} />
         </fieldset>
 
+        {currentEvent?.allowSponsorships && (
+          <fieldset className="border rounded p-3">
+            <legend className="text-sm font-medium">Thank Your Sponsors</legend>
+            <label className="inline-flex items-center gap-2 text-sm mb-2">
+              <input type="checkbox" checked={enableSponsors} onChange={e => setEnableSponsors(e.target.checked)} /> Enable
+            </label>
+            <p className="text-xs text-gray-500 mb-2">Goes to everyone who sponsored a spot at this event, at the same time as the thank-you above.</p>
+            <label className="block text-xs text-gray-600 mb-1">Subject</label>
+            <input className="w-full border rounded px-3 py-2 text-sm" value={sponsorSubject} onChange={e => setSponsorSubject(e.target.value)} />
+            <label className="block text-xs text-gray-600 mb-1 mt-2">Message</label>
+            <textarea className="w-full border rounded px-3 py-2 text-sm" rows={5} value={sponsorBody} onChange={e => setSponsorBody(e.target.value)} />
+          </fieldset>
+        )}
+
         <fieldset className="border rounded p-3">
           <legend className="text-sm font-medium">Next Event Promo</legend>
           <div className="flex items-center gap-4 mb-2">
@@ -1169,7 +1204,7 @@ function AutomationsPanel({ events, token, onInfo, onError }:{ events: any[]; to
               <label className="block text-xs text-gray-600 mb-1">Promo Event</label>
               <select className="w-full border rounded px-3 py-2 text-sm" value={promoEventId} onChange={e => setPromoEventId(e.target.value)}>
                 <option value="">Select event to promote…</option>
-                {(events||[]).map((ev:any) => (
+                {(events||[]).map((ev) => (
                   <option key={ev.id} value={ev.id}>{ev.title}</option>
                 ))}
               </select>

frontend/src/app/dashboard/supervisor/event-options/page.tsx

@@ -1,11 +1,13 @@
 "use client";
 
-import React, { Suspense, useEffect, useMemo, useState } from "react";
+import React, { Suspense, useCallback, useEffect, useMemo, useState } from "react";
 import { useAuth } from "@/hooks/useAuth";
 import { useRouter, useSearchParams } from "next/navigation";
 import { apiFetch } from "@/lib/api";
 import { useDismissingState } from "@/hooks/useDismissingState";
 import { Ticket } from "lucide-react";
+import { errorMessage } from "@/lib/utils";
+import type { Event, EventOption } from "@/types";
 
 // Format a Date (or date-like input) to the value expected by <input type="datetime-local">
 // This returns local time (browser timezone) as YYYY-MM-DDTHH:mm
@@ -21,7 +23,10 @@ function toLocalDateTimeInputValue(input: string | number | Date | null | undefi
   return `${y}-${m}-${day}T${hh}:${mm}`;
 }
 
-function EarlyBirdTiersEditor({ option, onSave }: { option: any; onSave: (tiers: { id?: string; deadline: string; price: number; order?: number }[]) => void }) {
+type TierInput = { id?: string; deadline: string; price: number; order?: number };
+type OptionPatch = Partial<Pick<EventOption, "name" | "price" | "isMainTicket">> & { earlyBirdTiers?: TierInput[] };
+
+function EarlyBirdTiersEditor({ option, onSave }: { option: EventOption; onSave: (tiers: TierInput[]) => void }) {
   const [rows, setRows] = React.useState<{ id?: string; deadline: string; price: string; order?: number }[]>([]);
   const [open, setOpen] = React.useState(false);
   const [saving, setSaving] = React.useState(false);
@@ -30,8 +35,8 @@ function EarlyBirdTiersEditor({ option, onSave }: { option: any; onSave: (tiers:
     const tiers = Array.isArray(option?.earlyBirdTiers) ? option.earlyBirdTiers : [];
     const normalized = tiers
       .slice()
-      .sort((a: any, b: any) => new Date(a.deadline).getTime() - new Date(b.deadline).getTime() || (a.order || 0) - (b.order || 0))
-      .map((t: any, i: number) => ({ id: t.id, deadline: toLocalDateTimeInputValue(t.deadline), price: String(t.price ?? ''), order: typeof t.order === 'number' ? t.order : i }));
+      .sort((a, b) => new Date(a.deadline).getTime() - new Date(b.deadline).getTime() || (a.order || 0) - (b.order || 0))
+      .map((t, i) => ({ id: t.id, deadline: toLocalDateTimeInputValue(t.deadline), price: String(t.price ?? ''), order: typeof t.order === 'number' ? t.order : i }));
     setRows(normalized);
   }, [option?.id, option?.earlyBirdTiers]);
 
@@ -45,7 +50,7 @@ function EarlyBirdTiersEditor({ option, onSave }: { option: any; onSave: (tiers:
   };
   const updateRow = (idx: number, patch: Partial<{ deadline: string; price: string; order?: number }>) => {
     const copy = rows.slice();
-    copy[idx] = { ...copy[idx], ...patch } as any;
+    copy[idx] = { ...copy[idx], ...patch };
     setRows(copy);
   };
 
@@ -110,27 +115,23 @@ function EventOptionsContent() {
     if (!user) router.replace("/login");
   }, [user, loading, router]);
 
-  const [events, setEvents] = useState<any[]>([]);
+  const [events, setEvents] = useState<Event[]>([]);
   const [selectedEventId, setSelectedEventId] = useState<string>("");
-  const [options, setOptions] = useState<any[]>([]);
-  const [loadingEv, setLoadingEv] = useState(false);
+  const [options, setOptions] = useState<EventOption[]>([]);
   const [error, setError] = useDismissingState<string | null>(null);
   const [info, setInfo] = useDismissingState<string | null>(null);
 
-  const loadEvents = async () => {
+  const loadEvents = useCallback(async () => {
     if (!token) return;
     try {
-      setLoadingEv(true);
-      const evs = await apiFetch<any[]>("/api/events/all", { authToken: token });
+      const evs = await apiFetch<Event[]>("/api/events/all", { authToken: token });
       setEvents(evs || []);
-    } catch (e) {
+    } catch {
       // ignore
-    } finally {
-      setLoadingEv(false);
     }
-  };
+  }, [token]);
 
-  useEffect(() => { loadEvents(); }, [token]);
+  useEffect(() => { loadEvents(); }, [loadEvents]);
 
   // Preselect event from query (?eventId=)
   useEffect(() => {
@@ -165,12 +166,12 @@ function EventOptionsContent() {
       setNewOpt({ name: "", price: "", isMainTicket: false });
       setInfo("Option created");
       await loadEvents();
-    } catch (e: any) {
-      setError(e?.message || "Failed to create option");
+    } catch (e) {
+      setError(errorMessage(e) || "Failed to create option");
     }
   };
 
-  const updateOption = async (opt: any, patch: any) => {
+  const updateOption = async (opt: EventOption, patch: OptionPatch) => {
     if (!token) return;
     setError(null); setInfo(null);
     try {
@@ -181,12 +182,12 @@ function EventOptionsContent() {
       });
       setInfo("Option updated");
       await loadEvents();
-    } catch (e: any) {
-      setError(e?.message || "Failed to update option");
+    } catch (e) {
+      setError(errorMessage(e) || "Failed to update option");
     }
   };
 
-  const deleteOption = async (opt: any) => {
+  const deleteOption = async (opt: EventOption) => {
     if (!token) return;
     setError(null); setInfo(null);
     try {
@@ -196,8 +197,8 @@ function EventOptionsContent() {
       });
       setInfo("Option deleted");
       await loadEvents();
-    } catch (e: any) {
-      setError(e?.message || "Failed to delete option");
+    } catch (e) {
+      setError(errorMessage(e) || "Failed to delete option");
     }
   };
 

frontend/src/app/dashboard/supervisor/events/page.tsx

@@ -1,16 +1,22 @@
 "use client";
 
-import React, { useEffect, useLayoutEffect, useMemo, useRef, useState } from "react";
+import React, { useCallback, useEffect, useLayoutEffect, useMemo, useRef, useState } from "react";
 import { createPortal } from "react-dom";
 import { useAuth } from "@/hooks/useAuth";
 import { useRouter } from "next/navigation";
-import { apiFetch, resolveToApiOrigin } from "@/lib/api";
+import { apiFetch } from "@/lib/api";
+import { ApiImage } from "@/components/shared/ApiImage";
 import { useDismissingState } from "@/hooks/useDismissingState";
 import { useSiteSettings } from "@/contexts/SiteSettingsContext";
 import { Calendar } from "lucide-react";
+import { ChoicesEditor } from "@/components/shared/FormFieldExtras";
+import { errorMessage } from "@/lib/utils";
+import type { Event, EventAttachment, EventFormField, EventOption, Paginated, Section } from "@/types";
 
 // ─── helpers ────────────────────────────────────────────────────────────────
 
+const cleanChoices = (opts: unknown): string[] => (Array.isArray(opts) ? opts.map(o => String(o).trim()).filter(Boolean) : []);
+
 function toLocalDT(input: string | Date | null | undefined): string {
   if (!input) return "";
   const d = new Date(input);
@@ -40,8 +46,27 @@ function DTInput({ label, value, onChange, hint, required }: { label: string; va
 
 // ─── types ───────────────────────────────────────────────────────────────────
 
-type FormFieldType = "yes_no" | "text" | "date" | "numeric" | "statement" | "paragraph";
-type EventFormDef = { isRequired: boolean; fields: { id?: string; type: FormFieldType; label: string; isRequired?: boolean; order?: number; helpText?: string | null; options?: any }[] };
+type FormFieldType = "yes_no" | "text" | "date" | "numeric" | "statement" | "paragraph" | "rating" | "multiple_choice";
+type EventFormDef = { isRequired: boolean; fields: { id?: string; type: FormFieldType; label: string; isRequired?: boolean; order?: number; helpText?: string | null; options?: unknown }[] };
+type FieldDef = EventFormDef["fields"][number];
+
+// What PUT /api/events/options/:id takes as earlyBirdTiers (variantId null = option-level).
+type TierPayload = { id?: string; deadline: string; price: number; stockLimit: number; order: number; variantId: string | null };
+
+// GET /api/feedback/event/:id — the event's post-event feedback form, if it has one.
+type FeedbackFormResponse = {
+  fields?: EventFormField[];
+  sendAt?: string | null;
+  audience?: string;
+  anonymous?: boolean;
+  intro?: string | null;
+  sentAt: string | null;
+  invited: number;
+  responses: number;
+};
+
+const toFieldDefs = (fields: EventFormField[] | undefined): FieldDef[] =>
+  (fields || []).map((x) => ({ id: x.id, type: x.type, label: x.label, isRequired: !!x.isRequired, helpText: x.helpText || "", options: x.options || undefined }));
 
 type Tier = { id?: string; deadline: string; price: string; stockLimit: string; order?: number };
 
@@ -85,8 +110,9 @@ function UploadImageButton({ onUploaded, label = "Upload image" }: { onUploaded:
         try {
           const fd = new FormData();
           fd.append("image", file);
-          const res: any = await apiFetch("/api/uploads/event-image", { method: "POST", body: fd, authToken: token });
-          if (res?.url || res?.path) onUploaded(res.url || res.path);
+          const res = await apiFetch<{ url?: string; path?: string }>("/api/uploads/event-image", { method: "POST", body: fd, authToken: token });
+          const uploaded = res?.url || res?.path;
+          if (uploaded) onUploaded(uploaded);
         } finally { setUploading(false); if (ref.current) ref.current.value = ""; }
       }} />
       <button type="button" onClick={() => ref.current?.click()} disabled={uploading}
@@ -97,25 +123,33 @@ function UploadImageButton({ onUploaded, label = "Upload image" }: { onUploaded:
   );
 }
 
-function FormBuilder({ value, onChange }: { value: EventFormDef; onChange: (v: EventFormDef) => void }) {
+function FormBuilder({ value, onChange, title = "Registration Form Fields", gateLabel = "Required before tickets generate" }: {
+  value: EventFormDef;
+  onChange: (v: EventFormDef) => void;
+  title?: string;
+  /** Label of the "form must be filled in" switch; null hides it (feedback forms). */
+  gateLabel?: string | null;
+}) {
   const fields = value.fields || [];
   const add = (type: FormFieldType) => onChange({ ...value, fields: [...fields, { type, label: "", isRequired: false, helpText: "" }] });
-  const upd = (idx: number, patch: any) => { const c = fields.slice(); c[idx] = { ...c[idx], ...patch }; onChange({ ...value, fields: c }); };
+  const upd = (idx: number, patch: Partial<FieldDef>) => { const c = fields.slice(); c[idx] = { ...c[idx], ...patch }; onChange({ ...value, fields: c }); };
   const rem = (idx: number) => { const c = fields.slice(); c.splice(idx, 1); onChange({ ...value, fields: c }); };
   const mov = (idx: number, dir: -1 | 1) => {
     const c = fields.slice(); const t = idx + dir;
     if (t < 0 || t >= c.length) return;
     [c[idx], c[t]] = [c[t], c[idx]]; onChange({ ...value, fields: c });
   };
-  const typeLabel = (t: FormFieldType) => ({ text: "Text", numeric: "Number", date: "Date", yes_no: "Yes/No", statement: "Statement", paragraph: "Heading" }[t] || t);
+  const typeLabel = (t: FormFieldType) => ({ text: "Text", numeric: "Number", date: "Date", yes_no: "Yes/No", statement: "Statement", paragraph: "Heading", rating: "Rating", multiple_choice: "Multiple choice" }[t] || t);
   return (
     <div className="border rounded-lg p-3 bg-gray-50">
       <div className="flex items-center justify-between mb-3">
-        <div className="text-sm font-semibold">Registration Form Fields</div>
-        <label className="text-xs flex items-center gap-1.5 cursor-pointer">
-          <input type="checkbox" checked={!!value.isRequired} onChange={e => onChange({ ...value, isRequired: e.target.checked })} />
-          Required before tickets generate
-        </label>
+        <div className="text-sm font-semibold">{title}</div>
+        {gateLabel && (
+          <label className="text-xs flex items-center gap-1.5 cursor-pointer">
+            <input type="checkbox" checked={!!value.isRequired} onChange={e => onChange({ ...value, isRequired: e.target.checked })} />
+            {gateLabel}
+          </label>
+        )}
       </div>
       {fields.length === 0
         ? <p className="text-xs text-gray-500 italic mb-3">No fields yet.</p>
@@ -132,9 +166,10 @@ function FormBuilder({ value, onChange }: { value: EventFormDef; onChange: (v: E
                   <button type="button" className="text-xs px-2 py-0.5 rounded bg-red-50 text-red-700 border border-red-200" onClick={() => rem(idx)}>Remove</button>
                 </div>
                 <div className="flex flex-wrap gap-2 mb-1.5">
-                  <select className="border rounded px-2 py-1 text-xs" value={f.type} onChange={e => upd(idx, { type: e.target.value })}>
+                  <select className="border rounded px-2 py-1 text-xs" value={f.type} onChange={e => upd(idx, { type: e.target.value as FormFieldType })}>
                     <option value="text">Text</option><option value="numeric">Number</option><option value="date">Date</option>
-                    <option value="yes_no">Yes/No</option><option value="statement">Statement</option><option value="paragraph">Heading+para</option>
+                    <option value="yes_no">Yes/No</option><option value="rating">Rating (1–5 stars)</option><option value="multiple_choice">Multiple choice</option>
+                    <option value="statement">Statement</option><option value="paragraph">Heading+para</option>
                   </select>
                   {f.type !== "statement" && f.type !== "paragraph" && (
                     <label className="text-xs flex items-center gap-1 cursor-pointer">
@@ -143,6 +178,7 @@ function FormBuilder({ value, onChange }: { value: EventFormDef; onChange: (v: E
                   )}
                 </div>
                 <input className="border rounded px-2 py-1 text-sm w-full mb-1" placeholder={f.type === "paragraph" ? "Heading text" : "Label"} value={f.label} onChange={e => upd(idx, { label: e.target.value })} />
+                {f.type === "multiple_choice" && <ChoicesEditor options={f.options} onChange={opts => upd(idx, { options: opts })} />}
                 {f.type === "paragraph"
                   ? <textarea className="border rounded px-2 py-1 text-xs w-full" rows={2} placeholder="Body text" value={f.helpText || ""} onChange={e => upd(idx, { helpText: e.target.value })} />
                   : f.type !== "statement"
@@ -154,6 +190,8 @@ function FormBuilder({ value, onChange }: { value: EventFormDef; onChange: (v: E
         )}
       <div className="flex gap-2 flex-wrap">
         <button type="button" className="text-xs px-3 py-1.5 rounded bg-brand-600 text-white hover:bg-brand-700" onClick={() => add("text")}>+ Question</button>
+        <button type="button" className="text-xs px-3 py-1.5 rounded bg-gray-200 text-gray-700" onClick={() => add("rating")}>+ Rating</button>
+        <button type="button" className="text-xs px-3 py-1.5 rounded bg-gray-200 text-gray-700" onClick={() => add("multiple_choice")}>+ Multiple choice</button>
         <button type="button" className="text-xs px-3 py-1.5 rounded bg-gray-200 text-gray-700" onClick={() => add("statement")}>+ Statement</button>
         <button type="button" className="text-xs px-3 py-1.5 rounded bg-gray-200 text-gray-700" onClick={() => add("paragraph")}>+ Heading</button>
       </div>
@@ -437,24 +475,24 @@ function SectionsDraftEditor({ sections, options, onChange }: {
 /** Edit-mode: live sections manager (DB-backed) */
 function SectionsManager({ eventId }: { eventId: string }) {
   const { token } = useAuth();
-  const [sections, setSections] = useState<any[]>([]);
-  const [eventOptions, setEventOptions] = useState<any[]>([]);
+  const [sections, setSections] = useState<Section[]>([]);
+  const [eventOptions, setEventOptions] = useState<EventOption[]>([]);
   const [loading, setLoading] = useState(false);
   const [newName, setNewName] = useState("");
   const [newOptionIds, setNewOptionIds] = useState<string[]>([]);
 
-  const load = async () => {
+  const load = useCallback(async () => {
     setLoading(true);
     try {
       const [secList, evFull] = await Promise.all([
-        apiFetch<any[]>("/api/sections", { authToken: token || undefined }),
-        apiFetch<any>(`/api/events/${eventId}`)
+        apiFetch<Section[]>("/api/sections", { authToken: token || undefined }),
+        apiFetch<Event>(`/api/events/${eventId}`)
       ]);
       setSections((secList || []).filter(s => s.eventId === eventId));
       setEventOptions(evFull?.eventOptions || []);
     } catch {} finally { setLoading(false); }
-  };
-  useEffect(() => { if (eventId) load(); }, [eventId]);
+  }, [eventId, token]);
+  useEffect(() => { if (eventId) load(); }, [eventId, load]);
 
   const create = async () => {
     if (!newName.trim() || !token) return;
@@ -499,14 +537,19 @@ function SectionsManager({ eventId }: { eventId: string }) {
   );
 }
 
-function SectionRow({ sec, options, onDelete, onUpdate }: any) {
+function SectionRow({ sec, options, onDelete, onUpdate }: {
+  sec: Section;
+  options: EventOption[];
+  onDelete: () => void;
+  onUpdate: (id: string, name: string, optionIds: string[]) => void;
+}) {
   const [name, setName] = useState(sec.name || "");
-  const [optIds, setOptIds] = useState<string[]>((sec.allowedOptions || []).map((o: any) => o.eventOptionId));
+  const [optIds, setOptIds] = useState<string[]>((sec.allowedOptions || []).map((o) => o.eventOptionId));
   return (
     <div className="border rounded p-3 bg-white">
       <input className="border rounded px-2 py-1 text-sm w-full mb-2" value={name} onChange={e => setName(e.target.value)} />
       <div className="flex flex-wrap gap-2 mb-2">
-        {options.map((opt: any) => (
+        {options.map((opt) => (
           <label key={opt.id} className="text-xs flex items-center gap-1 cursor-pointer">
             <input type="checkbox" checked={optIds.includes(opt.id)}
               onChange={e => setOptIds(e.target.checked ? [...optIds, opt.id] : optIds.filter(id => id !== opt.id))} />
@@ -526,15 +569,15 @@ function SectionRow({ sec, options, onDelete, onUpdate }: any) {
 
 function AttachmentsManager({ eventId }: { eventId: string }) {
   const { token } = useAuth();
-  const [items, setItems] = useState<any[]>([]);
+  const [items, setItems] = useState<EventAttachment[]>([]);
   const [uploading, setUploading] = useState(false);
   const ref = useRef<HTMLInputElement | null>(null);
 
-  const load = async () => {
-    const res = await apiFetch<any[]>(`/api/events/${eventId}/attachments`);
+  const load = useCallback(async () => {
+    const res = await apiFetch<EventAttachment[]>(`/api/events/${eventId}/attachments`);
     setItems(Array.isArray(res) ? res : []);
-  };
-  useEffect(() => { load(); }, [eventId]);
+  }, [eventId]);
+  useEffect(() => { load(); }, [load]);
 
   const upload: React.ChangeEventHandler<HTMLInputElement> = async e => {
     const file = e.target.files?.[0];
@@ -630,7 +673,7 @@ function NotifyRecipientsPicker({ selected, onChange, disabled }: { selected: No
     setSearching(true);
     const t = setTimeout(async () => {
       try {
-        const res = await apiFetch<any>(`/api/users?search=${encodeURIComponent(search.trim())}&limit=10`, { authToken: token || undefined });
+        const res = await apiFetch<Paginated<NotifyUser>>(`/api/users?search=${encodeURIComponent(search.trim())}&limit=10`, { authToken: token || undefined });
         if (!cancelled) setResults(Array.isArray(res?.data) ? res.data : []);
       } catch {
         if (!cancelled) setResults([]);
@@ -713,10 +756,10 @@ function NotifyRecipientsManager({ eventId, creator, initialRecipients }: { even
     (async () => {
       setLoading(true);
       try {
-        const res = await apiFetch<any>(`/api/events/${eventId}/notify-recipients`, { authToken: token || undefined });
+        const res = await apiFetch<NotifyUser[]>(`/api/events/${eventId}/notify-recipients`, { authToken: token || undefined });
         if (!cancelled) setSelected(Array.isArray(res) ? res : []);
-      } catch (e: any) {
-        if (!cancelled) setError(e?.message || "Failed to load notification recipients");
+      } catch (e) {
+        if (!cancelled) setError(errorMessage(e) || "Failed to load notification recipients");
       } finally {
         if (!cancelled) setLoading(false);
       }
@@ -735,9 +778,9 @@ function NotifyRecipientsManager({ eventId, creator, initialRecipients }: { even
         method: "PUT", authToken: token || undefined,
         body: { userIds: next.map(u => u.id) },
       });
-    } catch (e: any) {
+    } catch (e) {
       setSelected(prev);
-      setError(e?.message || "Failed to save notification recipients");
+      setError(errorMessage(e) || "Failed to save notification recipients");
     } finally {
       setSaving(false);
     }
@@ -759,8 +802,8 @@ function NotifyRecipientsManager({ eventId, creator, initialRecipients }: { even
 
 // ─── steps ───────────────────────────────────────────────────────────────────
 
-const STEPS = ["Basic Details", "Items & Pricing", "Sections", "Form", "Visibility", "Notifications", "Attachments"] as const;
-type StepIdx = 0 | 1 | 2 | 3 | 4 | 5 | 6;
+const STEPS = ["Basic Details", "Items & Pricing", "Sections", "Form", "Visibility", "Notifications", "Attachments", "Feedback"] as const;
+type StepIdx = 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7;
 const PRICING_SUBSTEPS = ["Options", "Variants", "Early Birds"] as const;
 type PricingSubstep = 0 | 1 | 2;
 
@@ -773,7 +816,8 @@ interface EventDraft {
   requiresParentalConsent: boolean; consentText: string;
   consentCollectMedical: boolean; consentCollectEmergency: boolean; consentCollectPhoto: boolean;
   waitlistEnabled: boolean; waitlistOfferHours: string; waitlistPartialOffers: boolean;
-  allowTicketTransfer: boolean;
+  allowTicketTransfer: boolean; collectGender: boolean;
+  allowSponsorships: boolean; sponsorshipGoalSpots: string; showSponsorshipProgress: boolean;
 }
 
 const blankDraft = (location = ""): EventDraft => ({
@@ -785,7 +829,8 @@ const blankDraft = (location = ""): EventDraft => ({
   requiresParentalConsent: false, consentText: "",
   consentCollectMedical: true, consentCollectEmergency: true, consentCollectPhoto: true,
   waitlistEnabled: false, waitlistOfferHours: "24", waitlistPartialOffers: true,
-  allowTicketTransfer: true,
+  allowTicketTransfer: true, collectGender: false,
+  allowSponsorships: false, sponsorshipGoalSpots: "", showSponsorshipProgress: true,
 });
 
 const blankOptions = (): OptionDraft[] => [
@@ -796,14 +841,13 @@ const blankOptions = (): OptionDraft[] => [
 
 interface EventModalProps {
   mode: "create" | "edit";
-  event?: any;
+  event?: Event | null;
   onClose: () => void;
   onSuccess: () => void;
 }
 
 function EventModal({ mode, event: ev, onClose, onSuccess }: EventModalProps) {
-  const { token, user } = useAuth();
-  const isAdmin = user?.role === "admin";
+  const { token } = useAuth();
   const { settings } = useSiteSettings();
   const [step, setStep] = useState<StepIdx>(0);
   const [pricingSubstep, setPricingSubstep] = useState<PricingSubstep>(0);
@@ -825,6 +869,8 @@ function EventModal({ mode, event: ev, onClose, onSuccess }: EventModalProps) {
     consentCollectMedical: !!ev.consentCollectMedical, consentCollectEmergency: !!ev.consentCollectEmergency, consentCollectPhoto: !!ev.consentCollectPhoto,
     waitlistEnabled: !!ev.waitlistEnabled, waitlistOfferHours: String(ev.waitlistOfferHours ?? 24), waitlistPartialOffers: ev.waitlistPartialOffers !== false,
     allowTicketTransfer: ev.allowTicketTransfer !== false,
+    collectGender: !!ev.collectGender,
+    allowSponsorships: !!ev.allowSponsorships, sponsorshipGoalSpots: ev.sponsorshipGoalSpots ? String(ev.sponsorshipGoalSpots) : "", showSponsorshipProgress: ev.showSponsorshipProgress !== false,
     contactName: ev.contactName || "", contactPhone: ev.contactPhone || "", contactEmail: ev.contactEmail || "",
     location: ev.location || "",
   } : blankDraft(settings.org_address || ""));
@@ -832,8 +878,8 @@ function EventModal({ mode, event: ev, onClose, onSuccess }: EventModalProps) {
   // ── options (with per-variant tiers) ──
   const [options, setOptions] = useState<OptionDraft[]>(() => {
     if (!ev?.eventOptions?.length) return blankOptions();
-    return ev.eventOptions.map((o: any) => {
-      const allTiers: any[] = o.earlyBirdTiers || [];
+    return ev.eventOptions.map((o) => {
+      const allTiers = o.earlyBirdTiers || [];
       return {
         id: o.id,
         name: o.name,
@@ -843,17 +889,17 @@ function EventModal({ mode, event: ev, onClose, onSuccess }: EventModalProps) {
         staffPrice: o.staffPrice !== null && o.staffPrice !== undefined ? String(o.staffPrice) : "",
         // Option-level tiers only (no variantId)
         earlyBirdTiers: allTiers
-          .filter((t: any) => !t.variantId)
-          .map((t: any) => ({ id: t.id, deadline: toLocalDT(t.deadline), price: String(t.price ?? ""), stockLimit: String(t.stockLimit ?? "0") })),
-        variants: (o.variants || []).map((v: any) => ({
+          .filter((t) => !t.variantId)
+          .map((t) => ({ id: t.id, deadline: toLocalDT(t.deadline), price: String(t.price ?? ""), stockLimit: String(t.stockLimit ?? "0") })),
+        variants: (o.variants || []).map((v) => ({
           id: v.id, name: v.name,
           price: v.price !== null && v.price !== undefined ? String(v.price) : "",
           stockLimit: String(v.stockLimit ?? "0"),
           staffPrice: v.staffPrice !== null && v.staffPrice !== undefined ? String(v.staffPrice) : "",
           // Variant-level tiers — filter by variantId
           earlyBirdTiers: allTiers
-            .filter((t: any) => t.variantId === v.id)
-            .map((t: any) => ({ id: t.id, deadline: toLocalDT(t.deadline), price: String(t.price ?? ""), stockLimit: String(t.stockLimit ?? "0") })),
+            .filter((t) => t.variantId === v.id)
+            .map((t) => ({ id: t.id, deadline: toLocalDT(t.deadline), price: String(t.price ?? ""), stockLimit: String(t.stockLimit ?? "0") })),
         })),
       };
     });
@@ -873,12 +919,59 @@ function EventModal({ mode, event: ev, onClose, onSuccess }: EventModalProps) {
   const formLoadedRef = useRef(false);
   useEffect(() => {
     if (mode !== "edit" || !ev?.id || formLoadedRef.current) return;
-    apiFetch<any>(`/api/events/${ev.id}`).then(full => {
+    apiFetch<Event>(`/api/events/${ev.id}`).then(full => {
       const f = full?.form;
-      if (f) setFormDef({ isRequired: !!f.isRequired, fields: (f.fields || []).map((x: any) => ({ id: x.id, type: x.type, label: x.label, isRequired: !!x.isRequired, helpText: x.helpText || "" })) });
+      if (f) setFormDef({ isRequired: !!f.isRequired, fields: toFieldDefs(f.fields) });
     }).catch(() => {}).finally(() => { formLoadedRef.current = true; });
   }, [mode, ev?.id]);
 
+  // ── post-event feedback ──
+  const [fbEnabled, setFbEnabled] = useState(false);
+  const [fbDef, setFbDef] = useState<EventFormDef>({ isRequired: false, fields: [] });
+  const [fbSettings, setFbSettings] = useState({ sendAt: "", audience: "checked_in", anonymous: false, intro: "" });
+  const [fbMeta, setFbMeta] = useState<{ sentAt: string | null; invited: number; responses: number } | null>(null);
+  useEffect(() => {
+    if (mode !== "edit" || !ev?.id || !token) return;
+    apiFetch<FeedbackFormResponse | null>(`/api/feedback/event/${ev.id}`, { authToken: token }).then(f => {
+      if (!f) return;
+      setFbEnabled(true);
+      setFbDef({ isRequired: false, fields: toFieldDefs(f.fields) });
+      setFbSettings({ sendAt: toLocalDT(f.sendAt), audience: f.audience || "checked_in", anonymous: !!f.anonymous, intro: f.intro || "" });
+      setFbMeta({ sentAt: f.sentAt, invited: f.invited, responses: f.responses });
+    }).catch(() => {});
+  }, [mode, ev?.id, token]);
+  const enableFeedback = (on: boolean) => {
+    setFbEnabled(on);
+    if (on && fbDef.fields.length === 0) {
+      setFbDef({ isRequired: false, fields: [
+        { type: "rating", label: "Overall, how would you rate the event?", isRequired: true, helpText: "" },
+        { type: "rating", label: "How would you rate the organisation?", isRequired: false, helpText: "" },
+        { type: "text", label: "What did you enjoy most?", isRequired: false, helpText: "" },
+        { type: "text", label: "What could we do better?", isRequired: false, helpText: "" },
+      ] });
+    }
+    if (on && !fbSettings.sendAt && draft.endDate) {
+      const next = new Date(draft.endDate);
+      next.setDate(next.getDate() + 1);
+      next.setHours(9, 0, 0, 0);
+      setFbSettings(s => ({ ...s, sendAt: toLocalDT(next) }));
+    }
+  };
+  const saveFeedback = async (eventId: string) => {
+    if (fbEnabled) {
+      await apiFetch(`/api/feedback/event/${eventId}`, {
+        method: "PUT", authToken: token || undefined,
+        body: {
+          sendAt: fbSettings.sendAt ? new Date(fbSettings.sendAt).toISOString() : null,
+          audience: fbSettings.audience, anonymous: fbSettings.anonymous, intro: fbSettings.intro || null,
+          fields: fbDef.fields.filter(f => f.label?.trim()).map((f, i) => ({ type: f.type, label: f.label, isRequired: !!f.isRequired, order: i, helpText: f.helpText || null, options: f.type === "multiple_choice" ? cleanChoices(f.options) : undefined })),
+        },
+      });
+    } else if (fbMeta) {
+      await apiFetch(`/api/feedback/event/${eventId}`, { method: "DELETE", authToken: token || undefined });
+    }
+  };
+
   const upd = (patch: Partial<EventDraft>) => setDraft(d => ({ ...d, ...patch }));
 
   // ── auto-fill first option's price from the event base price (create mode only, until the
@@ -917,7 +1010,7 @@ function EventModal({ mode, event: ev, onClose, onSuccess }: EventModalProps) {
       if (mode === "edit") {
         await apiFetch(`/api/events/${eventId}`, {
           method: "PUT", authToken: token || undefined,
-          body: { form: { isRequired: !!formDef.isRequired, fields: formDef.fields.filter(f => f.label?.trim()).map((f, i) => ({ type: f.type, label: f.label, isRequired: !!f.isRequired, order: i, helpText: f.helpText || null })) } }
+          body: { form: { isRequired: !!formDef.isRequired, fields: formDef.fields.filter(f => f.label?.trim()).map((f, i) => ({ type: f.type, label: f.label, isRequired: !!f.isRequired, order: i, helpText: f.helpText || null, options: f.type === "multiple_choice" ? cleanChoices(f.options) : undefined })) } }
         });
       }
       return;
@@ -925,7 +1018,7 @@ function EventModal({ mode, event: ev, onClose, onSuccess }: EventModalProps) {
     if (mode === "edit") {
       for (const opt of options) {
         // Build flat tier array: option-level + all variant tiers
-        const allTiers: any[] = [
+        const allTiers: TierPayload[] = [
           ...opt.earlyBirdTiers
             .filter(t => t.deadline && t.price !== "")
             .map((t, i) => ({ id: t.id, deadline: new Date(t.deadline).toISOString(), price: parseFloat(t.price), stockLimit: parseInt(t.stockLimit || "0"), order: i, variantId: null })),
@@ -940,16 +1033,16 @@ function EventModal({ mode, event: ev, onClose, onSuccess }: EventModalProps) {
 
         if (opt.id) {
           // Update option + variants first to get/confirm variant IDs
-          const updated: any = await apiFetch(`/api/events/options/${opt.id}`, {
+          const updated = await apiFetch<EventOption>(`/api/events/options/${opt.id}`, {
             method: "PUT", authToken: token || undefined,
             body: { name: opt.name, price: parseFloat(opt.price || "0"), isMainTicket: opt.isMainTicket, stockLimit: parseInt(opt.stockLimit || "0"), staffPrice: opt.staffPrice ? parseFloat(opt.staffPrice) : null, variants: variantsPayload }
           });
 
           // Build variant tiers with confirmed IDs from response
-          const serverVariants: any[] = updated?.variants || [];
+          const serverVariants = updated?.variants || [];
           for (let vi = 0; vi < opt.variants.length; vi++) {
             const v = opt.variants[vi];
-            const serverVariant = serverVariants[vi] || serverVariants.find((sv: any) => sv.name === v.name);
+            const serverVariant = serverVariants[vi] || serverVariants.find((sv) => sv.name === v.name);
             if (!serverVariant) continue;
             for (let ti = 0; ti < v.earlyBirdTiers.length; ti++) {
               const t = v.earlyBirdTiers[ti];
@@ -968,23 +1061,23 @@ function EventModal({ mode, event: ev, onClose, onSuccess }: EventModalProps) {
           // Handle form save (edit only)
           await apiFetch(`/api/events/${eventId}`, {
             method: "PUT", authToken: token || undefined,
-            body: { form: { isRequired: !!formDef.isRequired, fields: formDef.fields.filter(f => f.label?.trim()).map((f, i) => ({ type: f.type, label: f.label, isRequired: !!f.isRequired, order: i, helpText: f.helpText || null })) } }
+            body: { form: { isRequired: !!formDef.isRequired, fields: formDef.fields.filter(f => f.label?.trim()).map((f, i) => ({ type: f.type, label: f.label, isRequired: !!f.isRequired, order: i, helpText: f.helpText || null, options: f.type === "multiple_choice" ? cleanChoices(f.options) : undefined })) } }
           });
         } else {
           // New option added during edit
-          const created: any = await apiFetch(`/api/events/${eventId}/options`, {
+          const created = await apiFetch<EventOption>(`/api/events/${eventId}/options`, {
             method: "POST", authToken: token || undefined,
             body: { name: opt.name, price: parseFloat(opt.price || "0"), isMainTicket: opt.isMainTicket, stockLimit: parseInt(opt.stockLimit || "0"), staffPrice: opt.staffPrice ? parseFloat(opt.staffPrice) : null }
           });
           if (created?.id) {
-            const updated: any = await apiFetch(`/api/events/options/${created.id}`, {
+            const updated = await apiFetch<EventOption>(`/api/events/options/${created.id}`, {
               method: "PUT", authToken: token || undefined,
               body: { variants: variantsPayload }
             });
-            const serverVariants: any[] = updated?.variants || [];
+            const serverVariants = updated?.variants || [];
             for (let vi = 0; vi < opt.variants.length; vi++) {
               const v = opt.variants[vi];
-              const sv = serverVariants[vi] || serverVariants.find((x: any) => x.name === v.name);
+              const sv = serverVariants[vi] || serverVariants.find((x) => x.name === v.name);
               if (!sv) continue;
               for (let ti = 0; ti < v.earlyBirdTiers.length; ti++) {
                 const t = v.earlyBirdTiers[ti];
@@ -1002,9 +1095,9 @@ function EventModal({ mode, event: ev, onClose, onSuccess }: EventModalProps) {
       }
     } else {
       // Create mode — backend auto-creates a "Main Ticket" option; replace/create from draft
-      let createdEvent: any = null;
-      try { createdEvent = await apiFetch(`/api/events/${eventId}`); } catch {}
-      const existingMain = (createdEvent?.eventOptions || []).find((o: any) => !!o.isMainTicket);
+      let createdEvent: Event | null = null;
+      try { createdEvent = await apiFetch<Event>(`/api/events/${eventId}`); } catch {}
+      const existingMain = (createdEvent?.eventOptions || []).find((o) => !!o.isMainTicket);
       const uiMainIdx = options.findIndex(o => o.isMainTicket);
 
       for (let i = 0; i < options.length; i++) {
@@ -1025,7 +1118,7 @@ function EventModal({ mode, event: ev, onClose, onSuccess }: EventModalProps) {
           });
           optId = existingMain.id;
         } else {
-          const created: any = await apiFetch(`/api/events/${eventId}/options`, {
+          const created = await apiFetch<EventOption>(`/api/events/${eventId}/options`, {
             method: "POST", authToken: token || undefined,
             body: { name: opt.name, price: parseFloat(opt.price || "0"), isMainTicket: opt.isMainTicket, stockLimit: parseInt(opt.stockLimit || "0"), staffPrice: opt.staffPrice ? parseFloat(opt.staffPrice) : null }
           });
@@ -1035,18 +1128,18 @@ function EventModal({ mode, event: ev, onClose, onSuccess }: EventModalProps) {
         if (!optId) continue;
 
         // Save variants, then build tiers with resolved IDs
-        const allTiers: any[] = opt.earlyBirdTiers
+        const allTiers: TierPayload[] = opt.earlyBirdTiers
           .filter(t => t.deadline && t.price !== "")
           .map((t, ti) => ({ deadline: new Date(t.deadline).toISOString(), price: parseFloat(t.price), stockLimit: parseInt(t.stockLimit || "0"), order: ti, variantId: null }));
 
         if (variantsPayload.length > 0 || opt.variants.some(v => v.earlyBirdTiers.length > 0)) {
-          const updated: any = await apiFetch(`/api/events/options/${optId}`, {
+          const updated = await apiFetch<EventOption>(`/api/events/options/${optId}`, {
             method: "PUT", authToken: token || undefined, body: { variants: variantsPayload }
           });
-          const serverVariants: any[] = updated?.variants || [];
+          const serverVariants = updated?.variants || [];
           for (let vi = 0; vi < opt.variants.length; vi++) {
             const v = opt.variants[vi];
-            const sv = serverVariants[vi] || serverVariants.find((x: any) => x.name === v.name);
+            const sv = serverVariants[vi] || serverVariants.find((x) => x.name === v.name);
             if (!sv) continue;
             for (let ti = 0; ti < v.earlyBirdTiers.length; ti++) {
               const t = v.earlyBirdTiers[ti];
@@ -1065,7 +1158,7 @@ function EventModal({ mode, event: ev, onClose, onSuccess }: EventModalProps) {
     }
   };
 
-  const saveStagedSections = async (eventId: string, createdOptions: any[]) => {
+  const saveStagedSections = async (eventId: string, createdOptions: EventOption[]) => {
     for (const sec of sectionDrafts) {
       if (!sec.name.trim()) continue;
       const optionIds = sec.optionIndices
@@ -1089,7 +1182,7 @@ function EventModal({ mode, event: ev, onClose, onSuccess }: EventModalProps) {
     }
     setSaving(true); setError(null);
     try {
-      const body: any = {
+      const body: Record<string, unknown> = {
         title: draft.title.trim(), description: draft.description || undefined,
         startDate: new Date(draft.startDate).toISOString(), endDate: new Date(draft.endDate).toISOString(),
         registrationDeadline: draft.registrationDeadline ? new Date(draft.registrationDeadline).toISOString() : undefined,
@@ -1106,6 +1199,10 @@ function EventModal({ mode, event: ev, onClose, onSuccess }: EventModalProps) {
         consentCollectPhoto: draft.consentCollectPhoto,
         waitlistEnabled: draft.waitlistEnabled,
         allowTicketTransfer: draft.allowTicketTransfer,
+        collectGender: draft.collectGender,
+        allowSponsorships: draft.allowSponsorships,
+        sponsorshipGoalSpots: draft.allowSponsorships && draft.sponsorshipGoalSpots ? parseInt(draft.sponsorshipGoalSpots, 10) || null : null,
+        showSponsorshipProgress: draft.showSponsorshipProgress,
         waitlistOfferHours: parseInt(draft.waitlistOfferHours, 10) || 24,
         waitlistPartialOffers: draft.waitlistPartialOffers,
         contactName: draft.contactName || undefined,
@@ -1116,18 +1213,21 @@ function EventModal({ mode, event: ev, onClose, onSuccess }: EventModalProps) {
 
       if (mode === "edit") {
         body.isActive = draft.isActive;
+        if (!ev) throw new Error("No event loaded to save");
         await apiFetch(`/api/events/${ev.id}`, { method: "PUT", authToken: token || undefined, body });
         await saveOptions(ev.id);
         // Form is saved inside saveOptions for edit mode; avoid double call
+        await saveFeedback(ev.id);
       } else {
         if (formDef.isRequired || formDef.fields.length > 0) {
-          body.form = { isRequired: !!formDef.isRequired, fields: formDef.fields.filter(f => f.label?.trim()).map((f, i) => ({ type: f.type, label: f.label, isRequired: !!f.isRequired, order: i, helpText: f.helpText || null })) };
+          body.form = { isRequired: !!formDef.isRequired, fields: formDef.fields.filter(f => f.label?.trim()).map((f, i) => ({ type: f.type, label: f.label, isRequired: !!f.isRequired, order: i, helpText: f.helpText || null, options: f.type === "multiple_choice" ? cleanChoices(f.options) : undefined })) };
         }
-        const created: any = await apiFetch("/api/events", { method: "POST", authToken: token || undefined, body });
+        const created = await apiFetch<Event>("/api/events", { method: "POST", authToken: token || undefined, body });
         if (created?.id) {
           await saveOptions(created.id);
+          await saveFeedback(created.id);
           // Fetch event to get final option IDs for sections
-          const fullEvent: any = await apiFetch(`/api/events/${created.id}`).catch(() => null);
+          const fullEvent = await apiFetch<Event>(`/api/events/${created.id}`).catch(() => null);
           const createdOptions = fullEvent?.eventOptions || [];
           if (sectionDrafts.length > 0) await saveStagedSections(created.id, createdOptions);
           // Upload staged attachments
@@ -1147,8 +1247,8 @@ function EventModal({ mode, event: ev, onClose, onSuccess }: EventModalProps) {
       }
 
       onSuccess(); onClose();
-    } catch (e: any) {
-      setError(e?.message || "Failed to save event");
+    } catch (e) {
+      setError(errorMessage(e) || "Failed to save event");
     } finally {
       setSaving(false);
     }
@@ -1234,7 +1334,7 @@ function EventModal({ mode, event: ev, onClose, onSuccess }: EventModalProps) {
         <div className="p-5 space-y-4 max-h-[65vh] overflow-y-auto">
           {isClosed && (
             <div className="p-3 border rounded bg-rose-50 text-rose-800 text-sm">
-              This event is closed — it can't be edited until it's reopened from the cashup page (admin only).
+              This event is closed — it can&apos;t be edited until it&apos;s reopened from the cashup page (admin only).
             </div>
           )}
           {error && <div className="p-3 border rounded bg-red-50 text-red-700 text-sm">{error}</div>}
@@ -1270,7 +1370,7 @@ function EventModal({ mode, event: ev, onClose, onSuccess }: EventModalProps) {
                   onChange={e => upd({ requiresRegistration: !e.target.checked, price: e.target.checked ? "0" : draft.price })}
                 />
                 <label htmlFor="contact-only-toggle" className="text-xs text-gray-700">
-                  <span className="font-medium">This is a contact-only event</span> (e.g. baptism) — no online registration or payment. Shows a "Contact us" button on the public site instead of "Register".
+                  <span className="font-medium">This is a contact-only event</span> (e.g. baptism) — no online registration or payment. Shows a &quot;Contact us&quot; button on the public site instead of &quot;Register&quot;.
                 </label>
               </div>
               {draft.requiresRegistration ? (
@@ -1297,7 +1397,7 @@ function EventModal({ mode, event: ev, onClose, onSuccess }: EventModalProps) {
               )}
               <div>
                 <label className="block text-xs text-gray-600 mb-1">Picture</label>
-                {draft.picture && <img src={resolveToApiOrigin(draft.picture) || undefined} alt="" className="h-20 w-20 object-cover rounded border mb-2" />}
+                <ApiImage src={draft.picture} className="h-20 w-20 object-cover rounded border mb-2" />
                 <div className="flex items-center gap-2">
                   <input className="flex-1 border rounded px-3 py-2 text-sm" placeholder="/uploads/... or https://" value={draft.picture} onChange={e => upd({ picture: e.target.value })} />
                   <UploadImageButton onUploaded={url => upd({ picture: url })} label="Upload" />
@@ -1333,7 +1433,7 @@ function EventModal({ mode, event: ev, onClose, onSuccess }: EventModalProps) {
           {/* ── Step 2: Sections ── */}
           {step === 2 && (
             <div>
-              <p className="text-xs text-gray-500 mb-3">Group ticket options into named sections shown on the registration page (e.g. "Tickets", "Add-ons", "Accommodation").</p>
+              <p className="text-xs text-gray-500 mb-3">Group ticket options into named sections shown on the registration page (e.g. &quot;Tickets&quot;, &quot;Add-ons&quot;, &quot;Accommodation&quot;).</p>
               {mode === "edit" && ev?.id
                 ? <SectionsManager eventId={ev.id} />
                 : <SectionsDraftEditor sections={sectionDrafts} options={options} onChange={setSectionDrafts} />
@@ -1349,6 +1449,46 @@ function EventModal({ mode, event: ev, onClose, onSuccess }: EventModalProps) {
             </div>
           )}
 
+          {step === 7 && (
+            <div className="space-y-3">
+              <p className="text-xs text-gray-500">Ask people what they thought, automatically after the event. Responses appear in Reports → Feedback summary.</p>
+              <label className="flex items-start gap-2 text-sm cursor-pointer">
+                <input type="checkbox" className="mt-0.5" checked={fbEnabled} onChange={e => enableFeedback(e.target.checked)} />
+                <span><strong>Send a feedback form after the event</strong></span>
+              </label>
+              {fbEnabled && (
+                <>
+                  {fbMeta?.sentAt && (
+                    <div className="text-xs rounded bg-green-50 text-green-800 p-2">Sent {new Date(fbMeta.sentAt).toLocaleString()} to {fbMeta.invited} {fbMeta.invited === 1 ? "person" : "people"} · {fbMeta.responses} response(s).{fbMeta.responses > 0 ? " The questions can't be changed now that people have answered." : ""}</div>
+                  )}
+                  <div className="grid sm:grid-cols-2 gap-3">
+                    <div>
+                      <label className="block text-xs text-gray-600 mb-1">Send at</label>
+                      <input type="datetime-local" className="border rounded px-2 py-1.5 text-sm w-full" value={fbSettings.sendAt} disabled={!!fbMeta?.sentAt} onChange={e => setFbSettings(s => ({ ...s, sendAt: e.target.value }))} />
+                    </div>
+                    <div>
+                      <label className="block text-xs text-gray-600 mb-1">Send to</label>
+                      <select className="border rounded px-2 py-1.5 text-sm w-full" value={fbSettings.audience} onChange={e => setFbSettings(s => ({ ...s, audience: e.target.value }))}>
+                        <option value="checked_in">Everyone who checked in</option>
+                        <option value="all">Everyone registered</option>
+                      </select>
+                    </div>
+                  </div>
+                  <label className="flex items-start gap-2 text-sm cursor-pointer">
+                    <input type="checkbox" className="mt-0.5" checked={fbSettings.anonymous} onChange={e => setFbSettings(s => ({ ...s, anonymous: e.target.checked }))} />
+                    <span>Anonymous — answers aren&apos;t linked to people&apos;s names</span>
+                  </label>
+                  <div>
+                    <label className="block text-xs text-gray-600 mb-1">Intro (optional)</label>
+                    <textarea className="border rounded px-2 py-1.5 text-sm w-full" rows={2} value={fbSettings.intro} onChange={e => setFbSettings(s => ({ ...s, intro: e.target.value }))} placeholder="Thanks for coming! Tell us how it went." />
+                  </div>
+                  <p className="text-xs text-gray-500">Anyone who hasn&apos;t answered gets one reminder 3 days later.</p>
+                  <FormBuilder value={fbDef} onChange={setFbDef} title="Feedback questions" gateLabel={null} />
+                </>
+              )}
+            </div>
+          )}
+
           {/* ── Step 4: Visibility ── */}
           {step === 4 && (
             <div className="space-y-3">
@@ -1366,6 +1506,12 @@ function EventModal({ mode, event: ev, onClose, onSuccess }: EventModalProps) {
                   <input type="checkbox" className="mt-0.5" checked={draft.allowNamedAttendees} onChange={e => upd({ allowNamedAttendees: e.target.checked })} />
                   <span><strong>Named attendees (group tickets)</strong> — someone registering several people can give each a name, so each gets their own ticket and attendee form</span>
                 </label>
+                {(draft.allowNamedAttendees || draft.requiresParentalConsent) && (
+                  <label className="flex items-start gap-2 text-sm cursor-pointer ml-6">
+                    <input type="checkbox" className="mt-0.5" checked={draft.collectGender} onChange={e => upd({ collectGender: e.target.checked })} />
+                    <span><strong>Ask each person&apos;s gender</strong> — needed to split rooms or cabins by gender (Rooms &amp; groups)</span>
+                  </label>
+                )}
                 {mode === "edit" && (
                   <label className="flex items-start gap-2 text-sm cursor-pointer">
                     <input type="checkbox" className="mt-0.5" checked={draft.isActive} onChange={e => upd({ isActive: e.target.checked })} />
@@ -1395,6 +1541,27 @@ function EventModal({ mode, event: ev, onClose, onSuccess }: EventModalProps) {
                 )}
               </div>
 
+              <div className="border rounded-lg p-4 bg-gray-50 space-y-3">
+                <div className="text-xs font-semibold text-gray-500 uppercase tracking-wide mb-1">Sponsor a spot</div>
+                <label className="flex items-start gap-2 text-sm cursor-pointer">
+                  <input type="checkbox" className="mt-0.5" checked={draft.allowSponsorships} onChange={e => upd({ allowSponsorships: e.target.checked })} />
+                  <span><strong>Allow sponsorships</strong> — a &quot;Sponsor a spot&quot; button on the event page lets people pay for spots (or any amount) for those who can&apos;t afford to come. The money goes into a sponsorship pool you assign under Payments → Donations</span>
+                </label>
+                {draft.allowSponsorships && (
+                  <>
+                    <label className="flex items-center gap-2 text-sm">
+                      Goal
+                      <input type="number" min="1" className="border rounded px-2 py-1 text-sm w-20" value={draft.sponsorshipGoalSpots} onChange={e => upd({ sponsorshipGoalSpots: e.target.value })} placeholder="—" />
+                      spots (optional)
+                    </label>
+                    <label className="flex items-start gap-2 text-sm cursor-pointer">
+                      <input type="checkbox" className="mt-0.5" checked={draft.showSponsorshipProgress} onChange={e => upd({ showSponsorshipProgress: e.target.checked })} />
+                      <span>Show progress on the event page (&quot;12 of 20 spots sponsored&quot;)</span>
+                    </label>
+                  </>
+                )}
+              </div>
+
               <div className="border rounded-lg p-4 bg-gray-50 space-y-3">
                 <div className="text-xs font-semibold text-gray-500 uppercase tracking-wide mb-1">Ticket transfer</div>
                 <label className="flex items-start gap-2 text-sm cursor-pointer">
@@ -1531,7 +1698,7 @@ function EventModal({ mode, event: ev, onClose, onSuccess }: EventModalProps) {
 
 // ─── event card ───────────────────────────────────────────────────────────────
 
-function EventCard({ ev, onEdit }: { ev: any; onEdit: () => void }) {
+function EventCard({ ev, onEdit }: { ev: Event; onEdit: () => void }) {
   const isPast = ev.endDate && new Date(ev.endDate) < new Date();
   const isInactive = ev.isActive === false;
   const isClosed = ev.cashupStatus === "closed";
@@ -1571,27 +1738,28 @@ export default function ManageEventsPage() {
     if (!user) router.replace("/login");
   }, [user, loading, router]);
 
-  const [events, setEvents] = useState<any[]>([]);
+  const [events, setEvents] = useState<Event[]>([]);
   const [loadingEvents, setLoadingEvents] = useState(false);
   const [error, setError] = useDismissingState<string | null>(null);
 
-  const loadEvents = async () => {
+  const loadEvents = useCallback(async () => {
     if (!token) return;
     setLoadingEvents(true);
     try {
-      const evs = await apiFetch<any[]>("/api/events/all?includePast=true&includeInactive=true", { authToken: token });
+      const evs = await apiFetch<Event[]>("/api/events/all?includePast=true&includeInactive=true", { authToken: token });
       setEvents(Array.isArray(evs) ? evs.sort((a, b) => new Date(b.startDate).getTime() - new Date(a.startDate).getTime()) : []);
-    } catch (e: any) {
-      setError(e?.message || "Failed to load events");
+    } catch (e) {
+      setError(errorMessage(e) || "Failed to load events");
     } finally {
       setLoadingEvents(false);
     }
-  };
+  }, [token, setError]);
 
-  useEffect(() => { loadEvents(); }, [user, token]);
+  // Reload when the signed-in user changes too (e.g. after an impersonation switch).
+  useEffect(() => { loadEvents(); }, [user, loadEvents]);
 
   const [modalMode, setModalMode] = useState<"create" | "edit" | null>(null);
-  const [editingEvent, setEditingEvent] = useState<any | null>(null);
+  const [editingEvent, setEditingEvent] = useState<Event | null>(null);
   const [includePast, setIncludePast] = useState(false);
   const [showInactive, setShowInactive] = useState(false);
   const [showClosed, setShowClosed] = useState(false);
@@ -1608,9 +1776,9 @@ export default function ManageEventsPage() {
   }), [events, includePast, showInactive, showClosed, search, now]);
 
   const openCreate = () => { setEditingEvent(null); setModalMode("create"); };
-  const openEdit = async (ev: any) => {
+  const openEdit = async (ev: Event) => {
     try {
-      const full = await apiFetch<any>(`/api/events/${ev.id}`, { authToken: token || undefined });
+      const full = await apiFetch<Event>(`/api/events/${ev.id}`, { authToken: token || undefined });
       setEditingEvent(full);
     } catch { setEditingEvent(ev); }
     setModalMode("edit");

frontend/src/app/dashboard/supervisor/forms/page.tsx

@@ -1,15 +1,28 @@
 "use client";
+import { ExtraFieldInput, isExtraFieldType, ChoicesEditor } from "@/components/shared/FormFieldExtras";
 
-import React, { useEffect, useMemo, useState } from "react";
+import React, { useCallback, useEffect, useMemo, useRef, useState } from "react";
 import { useAuth } from "@/hooks/useAuth";
 import { useRouter } from "next/navigation";
 import { apiFetch, fetchAllUsers } from "@/lib/api";
 import { useDismissingState } from "@/hooks/useDismissingState";
 import { FileText } from "lucide-react";
+import { errorMessage } from "@/lib/utils";
+import type { Event, EventForm, FormResponse, Registration, User } from "@/types";
 
-type FormFieldType = 'yes_no' | 'text' | 'date' | 'numeric' | 'statement' | 'paragraph';
+type FormFieldType = 'yes_no' | 'text' | 'date' | 'numeric' | 'statement' | 'paragraph' | 'rating' | 'multiple_choice';
 
-type EventFormDef = { isRequired: boolean; fields: { id?: string; type: FormFieldType; label: string; isRequired?: boolean; order?: number; helpText?: string|null; options?: any }[] };
+type EventFormDef = { isRequired: boolean; fields: { id?: string; type: FormFieldType; label: string; isRequired?: boolean; order?: number; helpText?: string|null; options?: unknown }[] };
+
+// The form as GET /api/events/:id returns it, mapped into the editor's shape.
+const toFormDef = (f: EventForm | null | undefined): EventFormDef =>
+  f && Array.isArray(f.fields)
+    ? { isRequired: !!f.isRequired, fields: f.fields.map((x) => ({ id: x.id, type: x.type, label: x.label, isRequired: !!x.isRequired, order: x.order, helpText: x.helpText || '', options: x.options || undefined })) }
+    : { isRequired: false, fields: [] };
+
+// /api/forms/responses returns { items } (older builds returned a bare array).
+const responseItems = (res: { items?: FormResponse[] } | FormResponse[] | null | undefined): FormResponse[] =>
+  Array.isArray(res) ? res : (Array.isArray(res?.items) ? res.items : []);
 
 function FormBuilder({ value, onChange }: { value: EventFormDef; onChange: (v: EventFormDef) => void }) {
   const fields = value.fields || [];
@@ -36,7 +49,7 @@ function FormBuilder({ value, onChange }: { value: EventFormDef; onChange: (v: E
   };
 
   const typeLabel = (type: FormFieldType) => {
-    const labels: Record<FormFieldType, string> = { text: 'Text', numeric: 'Number', date: 'Date', yes_no: 'Yes/No', statement: 'Statement', paragraph: 'Heading' };
+    const labels: Record<FormFieldType, string> = { text: 'Text', numeric: 'Number', date: 'Date', yes_no: 'Yes/No', statement: 'Statement', paragraph: 'Heading', rating: 'Rating', multiple_choice: 'Multiple choice' };
     return labels[type] || type;
   };
 
@@ -73,6 +86,8 @@ function FormBuilder({ value, onChange }: { value: EventFormDef; onChange: (v: E
                   <option value="numeric">Number</option>
                   <option value="date">Date</option>
                   <option value="yes_no">Yes / No</option>
+                  <option value="rating">Rating (1–5 stars)</option>
+                  <option value="multiple_choice">Multiple choice</option>
                   <option value="statement">Statement (display text)</option>
                   <option value="paragraph">Heading + paragraph</option>
                 </select>
@@ -89,6 +104,7 @@ function FormBuilder({ value, onChange }: { value: EventFormDef; onChange: (v: E
                 value={f.label}
                 onChange={e => updateField(idx, { label: e.target.value })}
               />
+              {f.type === 'multiple_choice' && <ChoicesEditor options={f.options} onChange={opts => updateField(idx, { options: opts })} />}
               {f.type === 'paragraph' ? (
                 <textarea
                   className="border rounded px-2 py-1 text-xs w-full"
@@ -134,36 +150,36 @@ export default function FormsBrowserPage() {
 
   const [mode, setMode] = useState<'view' | 'manage' | 'fill'>('view');
 
-  const [allEvents, setAllEvents] = useState<any[]>([]);
+  const [allEvents, setAllEvents] = useState<Event[]>([]);
   const [evIncludePast, setEvIncludePast] = useState(false);
   const [evIncludeInactive, setEvIncludeInactive] = useState(false);
   const [selectedEventId, setSelectedEventId] = useState<string>("");
   const [userId, setUserId] = useState<string>("");
   const [userSearch, setUserSearch] = useState<string>("");
-  const [allUsers, setAllUsers] = useState<any[]>([]);
+  const [allUsers, setAllUsers] = useState<User[]>([]);
   const [userDropdownOpen, setUserDropdownOpen] = useState(false);
   const [registrationId, setRegistrationId] = useState<string>("");
-  const [items, setItems] = useState<any[]>([]);
+  const [items, setItems] = useState<FormResponse[]>([]);
   const [nextCursor, setNextCursor] = useState<string | null>(null);
   const [loadingList, setLoadingList] = useState(false);
   const [error, setError] = useDismissingState<string | null>(null);
   const [info, setInfo] = useDismissingState<string | null>(null);
 
-  const loadEvents = async () => {
+  const loadEvents = useCallback(async () => {
     if (!token) return;
     try {
-      const evs = await apiFetch<any[]>("/api/events/all?includePast=true&includeInactive=true", { authToken: token });
-      const sorted = (evs || []).sort((a: any, b: any) => new Date(b.startDate).getTime() - new Date(a.startDate).getTime());
+      const evs = await apiFetch<Event[]>("/api/events/all?includePast=true&includeInactive=true", { authToken: token });
+      const sorted = (evs || []).sort((a, b) => new Date(b.startDate).getTime() - new Date(a.startDate).getTime());
       setAllEvents(Array.isArray(sorted) ? sorted : []);
     } catch {}
-  };
-  useEffect(() => { loadEvents(); }, [token]);
+  }, [token]);
+  useEffect(() => { loadEvents(); }, [loadEvents]);
 
   useEffect(() => {
     if (!token) return;
     fetchAllUsers(token)
       .then(list => {
-        setAllUsers(list.sort((a: any, b: any) => (a.name || "").localeCompare(b.name || "")));
+        setAllUsers(list.sort((a, b) => (a.name || "").localeCompare(b.name || "")));
       })
       .catch(() => {});
   }, [token]);
@@ -203,32 +219,36 @@ export default function FormsBrowserPage() {
       if (registrationId.trim()) qs.set("registrationId", registrationId.trim());
       if (append && nextCursor) qs.set("cursor", nextCursor);
       const url = "/api/forms/responses" + (qs.toString() ? `?${qs.toString()}` : "");
-      const res = await apiFetch<{ items: any[]; nextCursor?: string }>(url, { authToken: token });
+      const res = await apiFetch<{ items: FormResponse[]; nextCursor?: string }>(url, { authToken: token });
       const newItems = Array.isArray(res?.items) ? res!.items : [];
       setItems(prev => append ? [...prev, ...newItems] : newItems);
       setNextCursor(res?.nextCursor || null);
-    } catch (e: any) {
-      setError(e?.message || "Failed to load form responses");
+    } catch (e) {
+      setError(errorMessage(e) || "Failed to load form responses");
     } finally {
       setLoadingList(false);
     }
   };
 
+  // Load once the token is available; after that, searching is on demand (the
+  // filters don't refetch as they're typed). The ref keeps the latest `search`.
+  const searchRef = useRef(search);
+  useEffect(() => { searchRef.current = search; });
   useEffect(() => {
-    if (token) search(false);
+    if (token) searchRef.current(false);
   }, [token]);
 
   const onPrint = () => {
     if (!items || items.length === 0) return;
     const w = window.open("", "_blank");
     if (!w) return;
-    const formPages = items.map((r: any) => {
+    const formPages = items.map((r) => {
       const eventTitle = r.registration?.event?.title || "Event";
       const attendeeName = r.registration?.user?.name || "Attendee";
       const attendeeEmail = r.registration?.user?.email || "";
       const regId = String(r.registrationId || r.id || "").slice(0, 8);
       const createdAt = r.createdAt ? new Date(r.createdAt).toLocaleDateString("en-ZA") : "";
-      const answers = (r.answers || []).map((a: any) => `
+      const answers = (r.answers || []).map((a) => `
         <div class="answer">
           <div class="label">${a.field?.label || a.fieldId || "Field"}</div>
           <div class="value">${a.value ?? ""}</div>
@@ -281,58 +301,53 @@ export default function FormsBrowserPage() {
   const [formLoading, setFormLoading] = useState(false);
   const [formDef, setFormDef] = useState<EventFormDef>({ isRequired: false, fields: [] });
   const [formLoadedFor, setFormLoadedFor] = useState<string>("");
-  const loadFormForEvent = async (eventId: string) => {
+  const loadFormForEvent = useCallback(async (eventId: string) => {
     if (!eventId) return;
     try {
       setFormLoading(true);
-      const evFull = await apiFetch<any>(`/api/events/${encodeURIComponent(eventId)}`);
-      const f = evFull?.form;
-      if (f && Array.isArray(f.fields)) {
-        setFormDef({ isRequired: !!f.isRequired, fields: f.fields.map((x: any) => ({ id: x.id, type: x.type, label: x.label, isRequired: !!x.isRequired, order: x.order, helpText: x.helpText || '' })) });
-      } else {
-        setFormDef({ isRequired: false, fields: [] });
-      }
+      const evFull = await apiFetch<Event>(`/api/events/${encodeURIComponent(eventId)}`);
+      setFormDef(toFormDef(evFull?.form));
       setFormLoadedFor(eventId);
-    } catch (e:any) {
-      setError(e?.message || 'Failed to load form');
+    } catch (e) {
+      setError(errorMessage(e) || 'Failed to load form');
     } finally {
       setFormLoading(false);
     }
-  };
+  }, [setError]);
 
   useEffect(() => {
     if (mode === 'manage' && selectedEventId && selectedEventId !== formLoadedFor) {
       loadFormForEvent(selectedEventId);
     }
-  }, [mode, selectedEventId]);
+  }, [mode, selectedEventId, formLoadedFor, loadFormForEvent]);
 
   const saveForm = async () => {
     if (!token || !selectedEventId) return;
     setError(null); setInfo(null);
     try {
-      const fields = (formDef.fields || []).filter(f => (f.label || '').trim().length > 0).map((f, i) => ({ type: f.type, label: f.label, isRequired: !!f.isRequired && f.type !== 'statement' && f.type !== 'paragraph', order: i, helpText: f.helpText || null }));
+      const fields = (formDef.fields || []).filter(f => (f.label || '').trim().length > 0).map((f, i) => ({ type: f.type, label: f.label, isRequired: !!f.isRequired && f.type !== 'statement' && f.type !== 'paragraph', order: i, helpText: f.helpText || null, options: f.type === 'multiple_choice' && Array.isArray(f.options) ? f.options.map((o) => String(o).trim()).filter(Boolean) : undefined }));
       await apiFetch(`/api/events/${encodeURIComponent(selectedEventId)}`, { method: 'PUT', authToken: token, body: { form: { isRequired: !!formDef.isRequired, fields } } });
       setInfo('Form saved');
-    } catch (e:any) {
-      setError(e?.message || 'Failed to save form');
+    } catch (e) {
+      setError(errorMessage(e) || 'Failed to save form');
     }
   };
 
   // Fill/edit responses state
   const [fillEventId, setFillEventId] = useState<string>("");
-  const [fillRegistrations, setFillRegistrations] = useState<any[]>([]);
+  const [fillRegistrations, setFillRegistrations] = useState<Registration[]>([]);
   const [loadingRegs, setLoadingRegs] = useState(false);
   const [fillRegistrationId, setFillRegistrationId] = useState<string>("");
-  const [fillRegistration, setFillRegistration] = useState<any | null>(null);
+  const [fillRegistration, setFillRegistration] = useState<Registration | null>(null);
   const [fillForm, setFillForm] = useState<EventFormDef>({ isRequired: false, fields: [] });
-  const [existingResponses, setExistingResponses] = useState<any[]>([]);
+  const [existingResponses, setExistingResponses] = useState<FormResponse[]>([]);
   const [savingFill, setSavingFill] = useState(false);
 
-  const loadRegsForEvent = async (evId: string) => {
+  const loadRegsForEvent = useCallback(async (evId: string) => {
     if (!token || !evId) return;
     try {
       setLoadingRegs(true);
-      const regs = await apiFetch<any[]>(`/api/registrations/event/${encodeURIComponent(evId)}`, { authToken: token });
+      const regs = await apiFetch<Registration[]>(`/api/registrations/event/${encodeURIComponent(evId)}`, { authToken: token });
       const sorted = (Array.isArray(regs) ? regs : []).sort((a, b) => (a.user?.name || '').toLowerCase().localeCompare((b.user?.name || '').toLowerCase()));
       setFillRegistrations(sorted);
     } catch {
@@ -340,54 +355,48 @@ export default function FormsBrowserPage() {
     } finally {
       setLoadingRegs(false);
     }
-  };
+  }, [token]);
 
   useEffect(() => {
     if (mode === 'fill') setFillEventId(prev => prev || selectedEventId || "");
-  }, [mode]);
+  }, [mode, selectedEventId]);
 
   useEffect(() => {
     if (mode !== 'fill') return;
     if (fillEventId) loadRegsForEvent(fillEventId);
     setFillRegistrationId(""); setFillRegistration(null); setExistingResponses([]); setFillForm({ isRequired: false, fields: [] });
-  }, [fillEventId, mode]);
+  }, [fillEventId, mode, loadRegsForEvent]);
 
   useEffect(() => {
     (async () => {
       if (mode !== 'fill' || !fillRegistrationId) return;
       try {
-        const reg = await apiFetch<any>(`/api/registrations/${encodeURIComponent(fillRegistrationId)}`, { authToken: token! });
+        const reg = await apiFetch<Registration>(`/api/registrations/${encodeURIComponent(fillRegistrationId)}`, { authToken: token! });
         setFillRegistration(reg);
         if (reg?.event?.id) {
-          const evFull = await apiFetch<any>(`/api/events/${encodeURIComponent(reg.event.id)}`);
-          const f = evFull?.form;
-          if (f && Array.isArray(f.fields)) {
-            setFillForm({ isRequired: !!f.isRequired, fields: f.fields.map((x:any)=>({ id:x.id, type:x.type, label:x.label, isRequired:!!x.isRequired, order:x.order, helpText:x.helpText||'' })) });
-          } else {
-            setFillForm({ isRequired: false, fields: [] });
-          }
+          const evFull = await apiFetch<Event>(`/api/events/${encodeURIComponent(reg.event.id)}`);
+          setFillForm(toFormDef(evFull?.form));
         }
-        const resList = await apiFetch<any>(`/api/forms/responses?registrationId=${encodeURIComponent(fillRegistrationId)}`, { authToken: token! });
-        const items = Array.isArray(resList?.items) ? resList.items : (Array.isArray(resList) ? resList : []);
-        setExistingResponses(items);
-      } catch (e:any) {
-        setError(e?.message || 'Failed to load registration/form');
+        const resList = await apiFetch<{ items?: FormResponse[] } | FormResponse[]>(`/api/forms/responses?registrationId=${encodeURIComponent(fillRegistrationId)}`, { authToken: token! });
+        setExistingResponses(responseItems(resList));
+      } catch (e) {
+        setError(errorMessage(e) || 'Failed to load registration/form');
       }
     })();
-  }, [fillRegistrationId, mode]);
+  }, [fillRegistrationId, mode, token, setError]);
 
   const mainTicketCount = useMemo(() => {
     const ros = fillRegistration?.registrationOptions || [];
-    return ros.filter((ro:any)=> ro?.eventOption?.isMainTicket).reduce((s:number, ro:any)=> s + (ro.quantity||0), 0);
+    return ros.filter((ro)=> ro?.eventOption?.isMainTicket).reduce((s, ro)=> s + (ro.quantity||0), 0);
   }, [fillRegistration]);
 
   const [editableResponses, setEditableResponses] = useState<{ answers: Record<string,string> }[]>([]);
   useEffect(() => {
     if (mode !== 'fill') return;
     const fields = (fillForm.fields || []).filter(f => f.type !== 'statement' && f.type !== 'paragraph');
-    const mapped: { answers: Record<string,string> }[] = (existingResponses || []).map((r:any)=>{
+    const mapped: { answers: Record<string,string> }[] = (existingResponses || []).map((r)=>{
       const ans: Record<string,string> = {};
-      (r.answers || []).forEach((a:any)=>{ if (a.fieldId) ans[a.fieldId] = String(a.value ?? ''); });
+      (r.answers || []).forEach((a)=>{ if (a.fieldId) ans[a.fieldId] = String(a.value ?? ''); });
       for (const f of fields) if (!(f.id! in ans)) ans[f.id!] = '';
       return { answers: ans };
     });
@@ -404,7 +413,7 @@ export default function FormsBrowserPage() {
   const setAnswer = (respIdx: number, fieldId: string, value: string) => {
     setEditableResponses(prev => {
       const copy = prev.slice();
-      if (!copy[respIdx]) copy[respIdx] = { answers: {} } as any;
+      if (!copy[respIdx]) copy[respIdx] = { answers: {} };
       copy[respIdx] = { answers: { ...copy[respIdx].answers, [fieldId]: value } };
       return copy;
     });
@@ -427,11 +436,10 @@ export default function FormsBrowserPage() {
         method: 'PUT', authToken: token, body: { responses: editableResponses }
       });
       setInfo('Responses saved');
-      const resList = await apiFetch<any>(`/api/forms/responses?registrationId=${encodeURIComponent(fillRegistrationId)}`, { authToken: token! });
-      const items = Array.isArray(resList?.items) ? resList.items : (Array.isArray(resList) ? resList : []);
-      setExistingResponses(items);
-    } catch (e:any) {
-      setError(e?.message || 'Failed to save responses');
+      const resList = await apiFetch<{ items?: FormResponse[] } | FormResponse[]>(`/api/forms/responses?registrationId=${encodeURIComponent(fillRegistrationId)}`, { authToken: token! });
+      setExistingResponses(responseItems(resList));
+    } catch (e) {
+      setError(errorMessage(e) || 'Failed to save responses');
     } finally {
       setSavingFill(false);
     }
@@ -569,7 +577,7 @@ export default function FormsBrowserPage() {
               </div>
             ) : (
               <ul className="divide-y print-form-wrapper">
-                {items.map((r: any) => (
+                {items.map((r) => (
                   <li key={r.id} className="print-page-break">
                     <div className="p-4 print-response">
                       {/* Header */}
@@ -589,7 +597,7 @@ export default function FormsBrowserPage() {
                         <div className="text-xs text-gray-400 italic">No answers submitted.</div>
                       ) : (
                         <div className="grid sm:grid-cols-2 gap-2 print-answers">
-                          {r.answers.map((a: any) => (
+                          {r.answers.map((a) => (
                             <div key={a.id} className="bg-gray-50 border rounded p-2 print-answer">
                               <div className="text-[10px] text-gray-500 mb-0.5 print-answer-label">{a.field?.label || a.fieldId}</div>
                               <div className="font-medium text-sm break-words print-answer-value">{a.value}</div>
@@ -676,7 +684,7 @@ export default function FormsBrowserPage() {
               <label className="block text-xs text-gray-600 mb-1">Registration</label>
               <select className="border rounded px-2 py-1.5 text-sm w-full" value={fillRegistrationId} onChange={e => setFillRegistrationId(e.target.value)} disabled={!fillEventId || loadingRegs}>
                 <option value="">{loadingRegs ? 'Loading registrations…' : 'Select registration…'}</option>
-                {fillRegistrations.map((r:any)=>{
+                {fillRegistrations.map((r)=>{
                   const label = `${r.user?.name || r.userId} — ${r.user?.email || ''} — #${String(r.id).slice(0,8)}`;
                   return <option key={r.id} value={r.id}>{label}</option>;
                 })}
@@ -698,7 +706,7 @@ export default function FormsBrowserPage() {
                 <div key={idx} className="border rounded-lg p-3 bg-white shadow-sm">
                   <div className="text-sm font-semibold mb-3 text-gray-700">Attendee #{idx+1}</div>
                   <div className="grid sm:grid-cols-2 gap-3">
-                    {fillForm.fields.filter(f=>f.type!=='statement' && f.type !== 'paragraph').map((f:any)=> (
+                    {fillForm.fields.filter((f): f is typeof f & { id: string } => !!f.id && f.type!=='statement' && f.type !== 'paragraph').map((f)=> (
                       <div key={f.id}>
                         <label className="block text-xs text-gray-600 mb-1">{f.label}{f.isRequired ? ' *' : ''}</label>
                         {f.type === 'text' && (
@@ -710,6 +718,9 @@ export default function FormsBrowserPage() {
                         {f.type === 'date' && (
                           <input type="date" className="border rounded px-2 py-1 text-sm w-full" value={resp.answers[f.id]||''} onChange={e=> setAnswer(idx, f.id!, e.target.value)} />
                         )}
+                        {isExtraFieldType(f.type) && (
+                          <ExtraFieldInput field={f} idPrefix={`r${idx}`} value={resp.answers[f.id!]||''} onChange={v => setAnswer(idx, f.id!, v)} />
+                        )}
                         {f.type === 'yes_no' && (
                           <select className="border rounded px-2 py-1 text-sm w-full" value={resp.answers[f.id]||''} onChange={e=> setAnswer(idx, f.id!, e.target.value)}>
                             <option value="">Select…</option>

frontend/src/app/dashboard/supervisor/manual-registration/page.tsx

@@ -1,4 +1,5 @@
 "use client";
+import { ExtraFieldInput, isExtraFieldType } from "@/components/shared/FormFieldExtras";
 
 import React, { useEffect, useState } from "react";
 import { useAuth } from "@/hooks/useAuth";
@@ -6,8 +7,10 @@ import { useRouter } from "next/navigation";
 import { apiFetch } from "@/lib/api";
 import { useDismissingState } from "@/hooks/useDismissingState";
 import { UserPlus } from "lucide-react";
+import { errorMessage } from "@/lib/utils";
+import type { Registration } from "@/types";
 
-type FormField = { id: string; type: 'yes_no'|'text'|'date'|'numeric'|'statement'|'paragraph'; label: string; isRequired?: boolean; helpText?: string|null };
+type FormField = { id: string; type: 'yes_no'|'text'|'date'|'numeric'|'statement'|'paragraph'|'rating'|'multiple_choice'; label: string; isRequired?: boolean; helpText?: string|null; options?: unknown };
 
 export default function ManualRegistrationPage() {
   const { user, token, loading } = useAuth();
@@ -20,7 +23,7 @@ export default function ManualRegistrationPage() {
   const [phoneNumber, setPhoneNumber] = useState("");
   const [busy, setBusy] = useState(false);
   const [error, setError] = useDismissingState<string | null>(null);
-  const [createdReg, setCreatedReg] = useState<any | null>(null);
+  const [createdReg, setCreatedReg] = useState<Registration | null>(null);
   const [form, setForm] = useState<{ isRequired: boolean; fields: FormField[] } | null>(null);
   const [formsData, setFormsData] = useState<Record<number, Record<string, string>>>({});
 
@@ -35,7 +38,7 @@ export default function ManualRegistrationPage() {
     setBusy(true);
     setError(null);
     try {
-      const res = await apiFetch<any>("/api/registrations/manual", {
+      const res = await apiFetch<Registration>("/api/registrations/manual", {
         method: "POST",
         authToken: token,
         body: {
@@ -47,12 +50,12 @@ export default function ManualRegistrationPage() {
       setCreatedReg(res);
       // Load form definition for this event (if any)
       try {
-        const ev = await apiFetch<any>(`/api/events/${encodeURIComponent(eventId)}`);
+        const ev = await apiFetch<{ form?: { isRequired: boolean; fields: FormField[] } | null }>(`/api/events/${encodeURIComponent(eventId)}`);
         if (ev?.form) setForm(ev.form);
       } catch {}
       alert("Manual registration created");
-    } catch (e: any) {
-      setError(e?.message || "Failed to create manual registration");
+    } catch (e) {
+      setError(errorMessage(e) || "Failed to create manual registration");
     } finally {
       setBusy(false);
     }
@@ -109,12 +112,14 @@ export default function ManualRegistrationPage() {
   );
 }
 
-function AttendeeFormsSection({ registration, form, formsData, setFormsData }: { registration: any; form: { isRequired: boolean; fields: FormField[] }; formsData: Record<number, Record<string,string>>; setFormsData: any; }) {
+type FormsData = Record<number, Record<string, string>>;
+
+function AttendeeFormsSection({ registration, form, formsData, setFormsData }: { registration: Registration; form: { isRequired: boolean; fields: FormField[] }; formsData: FormsData; setFormsData: React.Dispatch<React.SetStateAction<FormsData>>; }) {
   const { token } = useAuth();
   const [submitting, setSubmitting] = useState(false);
   const [error, setError] = useDismissingState<string | null>(null);
   const [info, setInfo] = useDismissingState<string | null>(null);
-  const mainTickets = (registration?.registrationOptions || []).filter((o: any) => o?.eventOption?.isMainTicket).reduce((s: number, o: any) => s + (o.quantity || 0), 0);
+  const mainTickets = (registration?.registrationOptions || []).filter((o) => o?.eventOption?.isMainTicket).reduce((s, o) => s + (o.quantity || 0), 0);
   const count = Math.max(0, mainTickets);
 
   const canSubmit = React.useMemo(() => {
@@ -135,7 +140,7 @@ function AttendeeFormsSection({ registration, form, formsData, setFormsData }: {
   }, [form, formsData, count]);
 
   const update = (idx: number, fieldId: string, value: string) => {
-    setFormsData((prev: any) => ({ ...prev, [idx]: { ...(prev[idx]||{}), [fieldId]: value } }));
+    setFormsData((prev) => ({ ...prev, [idx]: { ...(prev[idx]||{}), [fieldId]: value } }));
   };
 
   const submit = async () => {
@@ -143,14 +148,14 @@ function AttendeeFormsSection({ registration, form, formsData, setFormsData }: {
     try {
       setSubmitting(true);
       setError(null); setInfo(null);
-      const payload = [] as any[];
+      const payload: { answers: Record<string, string> }[] = [];
       for (let i = 0; i < count; i++) payload.push({ answers: formsData[i] || {} });
       await apiFetch(`/api/registrations/${encodeURIComponent(registration.id)}/forms/responses`, {
         method: 'POST', authToken: token, body: { responses: payload }
       });
       setInfo('Attendee forms submitted successfully.');
-    } catch (e: any) {
-      setError(e?.message || 'Failed to submit forms');
+    } catch (e) {
+      setError(errorMessage(e) || 'Failed to submit forms');
     } finally {
       setSubmitting(false);
     }
@@ -178,7 +183,9 @@ function AttendeeFormsSection({ registration, form, formsData, setFormsData }: {
                 ) : (
                   <>
                     <label className="block text-xs text-gray-600 mb-1">{f.label}{f.isRequired ? ' *' : ''}</label>
-                    {f.type === 'yes_no' ? (
+                    {isExtraFieldType(f.type) ? (
+                      <ExtraFieldInput field={f} idPrefix={`a${idx}`} value={formsData[idx]?.[f.id] || ''} onChange={v => update(idx, f.id, v)} />
+                    ) : f.type === 'yes_no' ? (
                       <select className="border rounded px-2 py-1 text-sm" value={formsData[idx]?.[f.id] || ''} onChange={e => update(idx, f.id, e.target.value)}>
                         <option value="">Select</option>
                         <option value="yes">Yes</option>

frontend/src/app/dashboard/supervisor/manual/page.tsx

@@ -9,35 +9,12 @@ import { useDismissingState } from "@/hooks/useDismissingState";
 import { CouponCodeField, AppliedCoupon } from "@/components/shared/CouponCodeField";
 import { AttendeeNamesEditor, AttendeeEntries, TicketDelivery, attendeesPayload, consentDetailsMissing } from "@/components/shared/AttendeeNamesEditor";
 import { UserPlus, CreditCard } from "lucide-react";
+import { errorMessage } from "@/lib/utils";
+import { optionUnitNow, variantUnitNow } from "@/lib/pricing";
+import type { Event, EventOption, Registration, RegistrationOption, User } from "@/types";
 
 // ─── Pricing helpers ─────────────────────────────────────────────────────────
 
-function effectiveOptionUnit(opt: any): number {
-  const base = opt.price || 0;
-  const tiers = (Array.isArray(opt.earlyBirdTiers) ? opt.earlyBirdTiers : []).filter((t: any) => !t.variantId);
-  if (tiers.length === 0) return base;
-  const now = new Date();
-  const applicable = tiers
-    .map((t: any) => ({ ...t, deadline: new Date(t.deadline) }))
-    .filter((t: any) => now < t.deadline)
-    .sort((a: any, b: any) => a.deadline - b.deadline || (a.order || 0) - (b.order || 0) || a.price - b.price);
-  return applicable.length > 0 ? applicable[0].price : base;
-}
-
-function effectiveVariantUnit(opt: any, variant: any): number {
-  const base = variant.price !== null && variant.price !== undefined ? variant.price : opt.price || 0;
-  const allTiers = Array.isArray(opt.earlyBirdTiers) ? opt.earlyBirdTiers : [];
-  const variantTiers = allTiers.filter((t: any) => t.variantId === variant.id);
-  const tiers = variantTiers.length > 0 ? variantTiers : allTiers.filter((t: any) => !t.variantId);
-  if (tiers.length === 0) return base;
-  const now = new Date();
-  const applicable = tiers
-    .map((t: any) => ({ ...t, deadline: new Date(t.deadline) }))
-    .filter((t: any) => now < t.deadline)
-    .sort((a: any, b: any) => a.deadline - b.deadline || (a.order || 0) - (b.order || 0) || a.price - b.price);
-  return applicable.length > 0 ? applicable[0].price : base;
-}
-
 function fmtPrice(n: number) {
   return n === 0 ? "Free" : `R ${n.toFixed(2)}`;
 }
@@ -45,13 +22,14 @@ function fmtPrice(n: number) {
 // Effective unit price for an existing registration option (as returned by /api/registrations).
 // Prefers priceSnapshot (authoritative price captured at registration time) and only falls
 // back to a live early-bird calculation for legacy rows without a snapshot.
-function optionUnitPrice(opt: any): number {
+function optionUnitPrice(opt: RegistrationOption): number {
   if (opt.priceSnapshot !== null && opt.priceSnapshot !== undefined) {
     return Number(opt.priceSnapshot);
   }
   const eo = opt.eventOption;
-  if (opt.variant) return effectiveVariantUnit(eo, opt.variant);
-  return effectiveOptionUnit(eo);
+  if (!eo) return 0;
+  if (opt.variant) return variantUnitNow(eo, opt.variant);
+  return optionUnitNow(eo);
 }
 
 // ─── Component ───────────────────────────────────────────────────────────────
@@ -70,12 +48,12 @@ export default function ManualRegistrationPage() {
     if (!user) router.replace("/login");
   }, [user, loading, router]);
 
-  const [events, setEvents] = useState<any[]>([]);
+  const [events, setEvents] = useState<Event[]>([]);
   const [selectedEventId, setSelectedEventId] = useState<string>("");
-  const [options, setOptions] = useState<any[]>([]);
+  const [options, setOptions] = useState<EventOption[]>([]);
 
   // All system users for fuzzy lookup
-  const [allUsers, setAllUsers] = useState<any[]>([]);
+  const [allUsers, setAllUsers] = useState<User[]>([]);
 
   const [guest, setGuest] = useState({ name: "", email: "", phoneNumber: "" });
   const [notifPref, setNotifPref] = useState<"email" | "whatsapp" | "both">("email");
@@ -94,7 +72,7 @@ export default function ManualRegistrationPage() {
   const [tab, setTab] = useState<"register" | "payment">("register");
 
   // ── Record Payment tab state ─────────────────────────────────────────────
-  const [allRegistrations, setAllRegistrations] = useState<any[]>([]);
+  const [allRegistrations, setAllRegistrations] = useState<Registration[]>([]);
   const [payUserId, setPayUserId] = useState<string>("");
   const [payUserQuery, setPayUserQuery] = useState("");
   const [payDropdownOpen, setPayDropdownOpen] = useState(false);
@@ -119,7 +97,7 @@ export default function ManualRegistrationPage() {
   // balances can be computed without a per-registration fetch loop).
   useEffect(() => {
     if (!token) return;
-    apiFetch<any[]>("/api/registrations", { authToken: token })
+    apiFetch<Registration[]>("/api/registrations", { authToken: token })
       .then(regs => setAllRegistrations(Array.isArray(regs) ? regs : []))
       .catch(() => {});
   }, [token]);
@@ -127,8 +105,8 @@ export default function ManualRegistrationPage() {
   const regOutstanding = useMemo(() => {
     const map: Record<string, { totalDue: number; totalPaid: number; outstanding: number }> = {};
     for (const r of allRegistrations) {
-      const totalDue = r.totalDueComputed ?? (r.registrationOptions || []).reduce((sum: number, opt: any) => sum + optionUnitPrice(opt) * (opt.quantity || 0), 0);
-      const totalPaid = (r.payments || []).reduce((s: number, p: any) => s + (p.amount || 0), 0);
+      const totalDue = r.totalDueComputed ?? (r.registrationOptions || []).reduce((sum, opt) => sum + optionUnitPrice(opt) * (opt.quantity || 0), 0);
+      const totalPaid = (r.payments || []).reduce((s, p) => s + (p.amount || 0), 0);
       map[r.id] = { totalDue, totalPaid, outstanding: Math.max(0, totalDue - totalPaid) };
     }
     return map;
@@ -144,7 +122,7 @@ export default function ManualRegistrationPage() {
       .map(x => x.u);
   }, [payUserQuery, allUsers]);
 
-  const selectPayUser = (u: any) => {
+  const selectPayUser = (u: User) => {
     setPayUserId(u.id);
     setPayUserQuery(u.name || "");
     setPayDropdownOpen(false);
@@ -165,9 +143,9 @@ export default function ManualRegistrationPage() {
   const regsForPayUser = useMemo(() => {
     if (!payUserId) return [];
     return allRegistrations
-      .filter((r: any) => String(r.userId || r.user?.id) === String(payUserId))
-      .filter((r: any) => (regOutstanding[r.id]?.outstanding ?? 0) > 0.000001)
-      .sort((a: any, b: any) => new Date(b.createdAt).getTime() - new Date(a.createdAt).getTime());
+      .filter((r) => String(r.userId || r.user?.id) === String(payUserId))
+      .filter((r) => (regOutstanding[r.id]?.outstanding ?? 0) > 0.000001)
+      .sort((a, b) => new Date(b.createdAt).getTime() - new Date(a.createdAt).getTime());
   }, [allRegistrations, payUserId, regOutstanding]);
 
   const createManualPayment = async () => {
@@ -179,7 +157,7 @@ export default function ManualRegistrationPage() {
     if (!payRegistrationId) { setPayError("Please select a registration"); return; }
     try {
       setPaySubmitting(true);
-      await apiFetch<any>("/api/payments", {
+      await apiFetch("/api/payments", {
         method: "POST",
         authToken: token,
         body: {
@@ -196,11 +174,11 @@ export default function ManualRegistrationPage() {
       setPayPaidAtLocal("");
       // Refresh registrations so the displayed outstanding balance updates
       try {
-        const regs = await apiFetch<any[]>("/api/registrations", { authToken: token });
+        const regs = await apiFetch<Registration[]>("/api/registrations", { authToken: token });
         setAllRegistrations(Array.isArray(regs) ? regs : []);
       } catch {}
-    } catch (e: any) {
-      setPayError(e?.message || "Failed to record payment");
+    } catch (e) {
+      setPayError(errorMessage(e) || "Failed to record payment");
     } finally {
       setPaySubmitting(false);
     }
@@ -229,7 +207,7 @@ export default function ManualRegistrationPage() {
   const selectedEventAllowsNames = !!selectedEv?.allowNamedAttendees || selectedIsYouth;
   const [pickedUserId, setPickedUserId] = useState<string | null>(null);
 
-  const selectUser = (u: any) => {
+  const selectUser = (u: User) => {
     setPickedUserId(u.id || null);
     setGuest({ name: u.name || "", email: u.email || "", phoneNumber: u.phoneNumber || "" });
     setUserQuery(u.name || "");
@@ -251,7 +229,7 @@ export default function ManualRegistrationPage() {
     (async () => {
       try {
         if (!token) return;
-        const evs = await apiFetch<any[]>("/api/events/all", { authToken: token });
+        const evs = await apiFetch<Event[]>("/api/events/all", { authToken: token });
         const now = Date.now();
         const active = (evs || []).filter(ev => {
           const t = new Date(ev.endDate).getTime();
@@ -261,7 +239,7 @@ export default function ManualRegistrationPage() {
         });
         active.sort((a, b) => new Date(a.startDate).getTime() - new Date(b.startDate).getTime());
         setEvents(active);
-      } catch (e: any) {
+      } catch {
         // ignore
       }
     })();
@@ -273,9 +251,9 @@ export default function ManualRegistrationPage() {
       const opts = ev.options || ev.eventOptions || [];
       setOptions(opts);
       const map: Record<string, number> = {};
-      opts.forEach((o: any) => {
+      opts.forEach((o) => {
         if ((o.variants || []).length > 0) {
-          (o.variants as any[]).forEach(v => { map[`${o.id}::${v.id}`] = 0; });
+          (o.variants || []).forEach(v => { map[`${o.id}::${v.id}`] = 0; });
         } else {
           map[o.id] = 0;
         }
@@ -290,9 +268,9 @@ export default function ManualRegistrationPage() {
   const totalDue = useMemo(() => {
     return options.reduce((sum, o) => {
       if ((o.variants || []).length > 0) {
-        return sum + (o.variants as any[]).reduce((vs: number, v: any) => vs + (quantities[`${o.id}::${v.id}`] || 0) * effectiveVariantUnit(o, v), 0);
+        return sum + (o.variants || []).reduce((vs, v) => vs + (quantities[`${o.id}::${v.id}`] || 0) * variantUnitNow(o, v), 0);
       }
-      return sum + (quantities[o.id] || 0) * effectiveOptionUnit(o);
+      return sum + (quantities[o.id] || 0) * optionUnitNow(o);
     }, 0);
   }, [options, quantities]);
 
@@ -319,7 +297,7 @@ export default function ManualRegistrationPage() {
       const hasEmail = !!guest.email.trim();
       const hasPhone = !!guest.phoneNumber.trim();
       const resolvedPref = hasEmail && hasPhone ? notifPref : hasPhone ? "whatsapp" : "email";
-      const res = await apiFetch<any>("/api/registrations/manual", {
+      const res = await apiFetch<Registration & { couponError?: string }>("/api/registrations/manual", {
         method: "POST",
         authToken: token,
         body: {
@@ -339,7 +317,7 @@ export default function ManualRegistrationPage() {
 
       // Pre-load the Record Payment tab with this registration so it's ready to go the
       // moment a supervisor clicks over — the tab itself is never switched to automatically.
-      setAllRegistrations(prev => [res, ...prev.filter((r: any) => r.id !== res.id)]);
+      setAllRegistrations(prev => [res, ...prev.filter((r) => r.id !== res.id)]);
       setPayUserId(res.userId || res.user?.id || "");
       setPayUserQuery(res.user?.name || guest.name || "");
       setPayRegistrationId(res.id);
@@ -356,8 +334,8 @@ export default function ManualRegistrationPage() {
       setAttendeeEntries({});
       setDelivery("payer");
       setQuantities(prev => Object.fromEntries(Object.keys(prev).map(k => [k, 0])));
-    } catch (e: any) {
-      setError(e?.message || "Failed to create manual registration");
+    } catch (e) {
+      setError(errorMessage(e) || "Failed to create manual registration");
     } finally {
       setSubmitting(false);
     }
@@ -558,8 +536,8 @@ export default function ManualRegistrationPage() {
                     <div className="px-3 py-2 bg-gray-50 border-b text-sm font-medium text-gray-800">
                       {opt.name}{opt.isMainTicket ? <span className="ml-1.5 text-xs text-brand-600 font-normal">• Main</span> : null}
                     </div>
-                    {(opt.variants as any[]).map((v: any) => {
-                      const unit = effectiveVariantUnit(opt, v);
+                    {(opt.variants || []).map((v) => {
+                      const unit = variantUnitNow(opt, v);
                       const basePrice = v.price !== null && v.price !== undefined ? v.price : opt.price;
                       const key = `${opt.id}::${v.id}`;
                       return (
@@ -586,7 +564,7 @@ export default function ManualRegistrationPage() {
                   </div>
                 );
               }
-              const unit = effectiveOptionUnit(opt);
+              const unit = optionUnitNow(opt);
               return (
                 <div key={opt.id} className="border rounded p-3">
                   <div className="font-medium text-sm">{opt.name}</div>
@@ -624,6 +602,7 @@ export default function ManualRegistrationPage() {
             onDeliveryChange={setDelivery}
             payerLabel="the person registering"
             consentEventStart={selectedIsYouth ? selectedEv.startDate : undefined}
+            collectGender={!!selectedEv?.collectGender}
           />
         </div>
       )}
@@ -717,7 +696,7 @@ export default function ManualRegistrationPage() {
               <label className="block text-xs text-gray-600 mb-1">Registration</label>
               <select className="w-full max-w-full border rounded px-3 py-2 text-sm truncate" value={payRegistrationId} onChange={e => setPayRegistrationId(e.target.value)} disabled={!payUserId}>
                 <option value="">Select registration…</option>
-                {regsForPayUser.map((r: any) => {
+                {regsForPayUser.map((r) => {
                   const out = regOutstanding[r.id]?.outstanding ?? 0;
                   const label = `${r.event?.title || r.eventId || 'Event'} — Outstanding: R ${out.toFixed(2)} — #${String(r.id).slice(0,8)}`;
                   return <option key={r.id} value={r.id} title={label}>{label}</option>;

frontend/src/app/dashboard/supervisor/offline-scans/page.tsx

@@ -7,6 +7,8 @@ import { apiFetch } from "@/lib/api";
 import { formatDate } from "@/lib/date";
 import { useDismissingState } from "@/hooks/useDismissingState";
 import { WifiOff, Unlock, CheckCircle2 } from "lucide-react";
+import { errorMessage } from "@/lib/utils";
+import type { Event } from "@/types";
 
 type Lock = { id: string; sectionName: string | null; deviceName: string | null; user: { name: string }; lockedAt: string; snapshotAt: string | null; lastSyncAt: string | null };
 type Report = {
@@ -28,7 +30,7 @@ export default function OfflineScansPage() {
     if (!user) router.replace("/login");
   }, [user, loading, router]);
 
-  const [events, setEvents] = useState<any[]>([]);
+  const [events, setEvents] = useState<Event[]>([]);
   const [eventId, setEventId] = useState("");
   const [locks, setLocks] = useState<Lock[]>([]);
   const [reports, setReports] = useState<Report[]>([]);
@@ -38,7 +40,7 @@ export default function OfflineScansPage() {
 
   useEffect(() => {
     if (!token || !canView) return;
-    apiFetch<any[]>("/api/events/all?includePast=true", { authToken: token })
+    apiFetch<Event[]>("/api/events/all?includePast=true", { authToken: token })
       .then(evs => {
         const recent = (evs || []).filter(e => new Date(e.endDate).getTime() > Date.now() - 14 * 864e5);
         setEvents(recent);
@@ -57,8 +59,8 @@ export default function OfflineScansPage() {
       ]);
       setLocks(l);
       setReports(r.filter(x => !onlyOpen || x.conflicts.length > 0 || x.afterForceRelease));
-    } catch (e: any) {
-      setError(e?.message || "Failed to load offline scanning");
+    } catch (e) {
+      setError(errorMessage(e) || "Failed to load offline scanning");
     }
   }, [token, eventId, onlyOpen, setError]);
   useEffect(() => { load(); }, [load]);
@@ -68,13 +70,13 @@ export default function OfflineScansPage() {
       const res = await apiFetch<{ message: string }>(`/api/scan-locks/${l.id}/force-release`, { method: "POST", authToken: token! });
       setInfo(res.message);
       load();
-    } catch (e: any) { setError(e?.message || "Failed"); }
+    } catch (e) { setError(errorMessage(e) || "Failed"); }
   };
   const review = async (r: Report) => {
     try {
       await apiFetch(`/api/scan-locks/reports/${r.id}/review`, { method: "POST", authToken: token! });
       load();
-    } catch (e: any) { setError(e?.message || "Failed"); }
+    } catch (e) { setError(errorMessage(e) || "Failed"); }
   };
 
   return (

frontend/src/app/dashboard/supervisor/page.tsx

@@ -1,6 +1,6 @@
 "use client";
 
-import React, { useEffect, useMemo, useRef, useState } from "react";
+import React, { useCallback, useEffect, useMemo, useRef, useState } from "react";
 import { useAuth } from "@/hooks/useAuth";
 import { useRouter } from "next/navigation";
 import { apiFetch } from "@/lib/api";
@@ -8,12 +8,13 @@ import { useStableState } from "@/hooks/useStableState";
 import { useVisiblePolling } from "@/hooks/useVisiblePolling";
 import {
   Calendar, Banknote, Gift, Users, Ticket, QrCode, DoorOpen, Wallet,
-  UserPlus, FileText, MessageCircle, BarChart2, Mail, TicketPercent, ShieldCheck, ListChecks, WifiOff,
+  UserPlus, FileText, MessageCircle, BarChart2, Mail, TicketPercent, ShieldCheck, ListChecks, WifiOff, BedDouble, Filter,
 } from "lucide-react";
 import { StatCard, StatCardRow } from "@/components/shared/StatCard";
 import { QuickActionTile, QuickActionGrid } from "@/components/shared/QuickActionTile";
 import { AreaTrendChart } from "@/components/charts/AreaTrendChart";
 import { Table, TableHeader, TableBody, TableRow, TableHead, TableCell } from "@/components/ui/table";
+import type { DashboardStats, PaymentStats, RecentScan, ScanStats } from "@/types";
 
 const formatRand = (n: number) => `R ${(n || 0).toFixed(2)}`;
 const formatRandAxis = (n: number) => `R${new Intl.NumberFormat(undefined, { notation: "compact", maximumFractionDigits: 1 }).format(n)}`;
@@ -24,6 +25,7 @@ const QUICK_ACTIONS = [
   { href: "/dashboard/supervisor/manual", label: "Manual registration", description: "Register a guest and issue tickets", icon: UserPlus },
   { href: "/dashboard/supervisor/events", label: "Manage events", description: "Create, edit, and update ticket types", icon: Calendar },
   { href: "/dashboard/supervisor/payments", label: "Payments & donations", description: "Manual payments and assignment", icon: Wallet },
+  { href: "/dashboard/supervisor/allocations", label: "Rooms & groups", description: "Put attendees into rooms, groups or buses", icon: BedDouble },
   { href: "/dashboard/supervisor/offline-scans", label: "Offline scanning", description: "Devices scanning offline and their synced scans", icon: WifiOff },
   { href: "/dashboard/supervisor/waitlist", label: "Waitlist", description: "People waiting for sold-out tickets", icon: ListChecks },
   { href: "/dashboard/supervisor/consent", label: "Parental consent", description: "Youth events: consent status and medical list", icon: ShieldCheck },
@@ -38,6 +40,7 @@ const QUICK_ACTIONS = [
 
 type OverviewMetric = { thisMonth: number; lastMonth: number; pctChange: number | null };
 type Overview = {
+  funnel?: { views: number; paid: number; conversion: number | null } | null;
   activeEvents: number;
   registrations: OverviewMetric;
   ticketsSold: OverviewMetric;
@@ -64,38 +67,38 @@ export default function SupervisorDashboardPage() {
   // /api/stats/supervisor covers scan activity + today's payments (unchanged from before);
   // /api/stats/overview is the month-over-month KPI/trend/top-events endpoint, shared
   // with the admin dashboard since supervisors already have full revenue/donation visibility.
-  const [scanStats, setScanStats] = useStableState<any | null>(null);
-  const [paymentStats, setPaymentStats] = useStableState<any | null>(null);
-  const [recentScans, setRecentScans] = useStableState<any[]>([]);
+  const [scanStats, setScanStats] = useStableState<ScanStats | null>(null);
+  const [paymentStats, setPaymentStats] = useStableState<PaymentStats | null>(null);
+  const [recentScans, setRecentScans] = useStableState<RecentScan[]>([]);
   const [overview, setOverview] = useStableState<Overview | null>(null);
   const [loadingStats, setLoadingStats] = useState(false);
   const hasLoadedOnce = useRef(false);
 
-  const loadStats = async () => {
+  const loadStats = useCallback(async () => {
     if (!token) return;
     const isFirstLoad = !hasLoadedOnce.current;
     try {
       if (isFirstLoad) setLoadingStats(true);
       const [data, overviewData] = await Promise.all([
-        apiFetch<any>("/api/stats/supervisor", { authToken: token }),
+        apiFetch<DashboardStats>("/api/stats/supervisor", { authToken: token }),
         apiFetch<Overview>("/api/stats/overview", { authToken: token }),
       ]);
       setScanStats(data.scanStats);
       setPaymentStats(data.paymentStats);
       setRecentScans(Array.isArray(data.recentScans) ? data.recentScans : []);
       setOverview(overviewData);
-    } catch (e) {
+    } catch {
       // ignore
     } finally {
       hasLoadedOnce.current = true;
       if (isFirstLoad) setLoadingStats(false);
     }
-  };
+  }, [token, setScanStats, setPaymentStats, setRecentScans, setOverview]);
 
   useEffect(() => {
     if (!token) return;
     loadStats();
-  }, [token]);
+  }, [token, loadStats]);
 
   // Poll every 15s while the tab is visible; pause in the background and refetch
   // immediately on return instead of leaving stale numbers up.
@@ -117,12 +120,15 @@ export default function SupervisorDashboardPage() {
         </div>
       )}
 
-      <StatCardRow>
+      <StatCardRow cols={overview?.funnel ? 6 : 5}>
         <StatCard icon={Calendar} label="Active events" value={overview ? formatCount(overview.activeEvents) : "—"} tone="brand" href="/dashboard/supervisor/events" linkLabel="View all events" />
         <StatCard icon={Banknote} label="Revenue (past month)" value={overview ? formatRand(overview.revenue.thisMonth) : "—"} tone="green" href={`${REPORTS_URL}?report=revenue&range=trailing_month`} linkLabel="View report" delta={overview ? { value: overview.revenue.pctChange } : undefined} />
         <StatCard icon={Gift} label="Donations (past month)" value={overview ? formatRand(overview.donations.thisMonth) : "—"} tone="rose" href={`${REPORTS_URL}?report=donations&range=trailing_month`} linkLabel="View report" delta={overview ? { value: overview.donations.pctChange } : undefined} />
         <StatCard icon={Users} label="Registrations (past month)" value={overview ? formatCount(overview.registrations.thisMonth) : "—"} tone="blue" href={`${REPORTS_URL}?report=regStatus&range=trailing_month`} linkLabel="View report" delta={overview ? { value: overview.registrations.pctChange } : undefined} />
         <StatCard icon={Ticket} label="Tickets sold (past month)" value={overview ? formatCount(overview.ticketsSold.thisMonth) : "—"} tone="amber" href={`${REPORTS_URL}?report=usage&range=trailing_month`} linkLabel="View report" delta={overview ? { value: overview.ticketsSold.pctChange } : undefined} />
+        {overview?.funnel && (
+          <StatCard icon={Filter} label="Conversion (past month)" value={overview.funnel.conversion != null ? `${overview.funnel.conversion}%` : "—"} tone="violet" href={`${REPORTS_URL}?report=funnel&range=trailing_month`} linkLabel={`${overview.funnel.paid} of ${overview.funnel.views} visits`} />
+        )}
       </StatCardRow>
 
       <div className="border rounded-xl p-4 bg-white shadow-sm my-6">
@@ -179,7 +185,7 @@ export default function SupervisorDashboardPage() {
               {loadingStats && <span className="text-xs text-gray-500">Refreshing…</span>}
             </div>
             <ul className="text-sm space-y-2 max-h-96 overflow-auto pr-2">
-              {recentScans.map((u: any) => (
+              {recentScans.map((u) => (
                 <li key={u.id} className="border rounded p-2">
                   <div className="flex justify-between">
                     <div className="font-medium">{u.ticket?.event?.title || u.ticket?.eventId || 'Event'}</div>
@@ -231,11 +237,11 @@ export default function SupervisorDashboardPage() {
               <div className="text-sm text-gray-500">No payment data yet.</div>
             )}
 
-            {scanStats?.byStaff?.length > 0 && (
+            {scanStats && scanStats.byStaff?.length > 0 && (
               <div className="mt-4">
                 <div className="text-sm font-medium mb-1">Today by staff</div>
                 <ul className="text-sm text-gray-700 space-y-1">
-                  {scanStats.byStaff.map((s: any) => (
+                  {scanStats.byStaff.map((s) => (
                     <li key={s.scannedById} className="flex justify-between">
                       <span>{s.name || 'Staff'}</span>
                       <span className="font-medium">{s.count}</span>

frontend/src/app/dashboard/supervisor/payments/page.tsx

@@ -1,19 +1,22 @@
 "use client";
 
-import React, { Suspense, useEffect, useMemo, useRef, useState } from "react";
+import React, { Suspense, useCallback, useEffect, useMemo, useRef, useState } from "react";
 import { useAuth } from "@/hooks/useAuth";
 import { useRouter, useSearchParams } from "next/navigation";
 import { apiFetch, fetchAllUsers, fetchAllPayments } from "@/lib/api";
 import { useDismissingState } from "@/hooks/useDismissingState";
 import { scoreUser } from "@/lib/fuzzyMatch";
 import { Wallet, RotateCcw, HandHeart, ScanLine, Link2 } from "lucide-react";
+import { errorMessage } from "@/lib/utils";
+import { registrationOptionUnitPrice } from "@/lib/pricing";
+import type { Event, Payment, Registration, User } from "@/types";
 
 // A donation is never mutated once created — assigning it to a registration creates a separate
 // "leg" Payment row (isDonation:false, originalPaymentId -> the donation, amount > 0) instead.
 // That leg is not new money: it just re-labels part of an already-counted donation as applied
 // to a registration. Money stats/lists must count each real inflow exactly once, so legs are
 // excluded — the money was already counted via the original donation row.
-function isDonationLeg(p: any): boolean {
+function isDonationLeg(p: Payment): boolean {
   return !p?.isDonation && !!p?.originalPaymentId && (p?.amount || 0) > 0;
 }
 
@@ -29,13 +32,27 @@ function refundMethodForOriginal(method: string | null | undefined): string {
   return "";
 }
 
+type Outstanding = Record<string, { totalDue: number; totalPaid: number; outstanding: number }>;
+
+// An unreconciled Yoco transaction (GET /api/yoco-transactions/unreconciled). `raw` is the
+// webhook as Yoco sent it; its checkout metadata says who/what the payment was for.
+type YocoTx = {
+  id: string;
+  amount: number;
+  checkoutId?: string | null;
+  externalId?: string | null;
+  methodType?: string | null;
+  createdDate?: string | null;
+  raw?: { payload?: { metadata?: { userId?: string; eventId?: string } } } | null;
+};
+
 function RegistrationOptions({ regs, regOutstanding }: {
-  regs: any[];
+  regs: Registration[];
   regOutstanding: Record<string, { totalDue: number; totalPaid: number; outstanding: number }>;
 }) {
   return (
     <>
-      {regs.map((r: any) => {
+      {regs.map((r) => {
         const out = regOutstanding[r.id]?.outstanding ?? 0;
         const label = `${r.event?.title || r.eventId || 'Event'} — ${r.user?.name || r.userId || 'User'} — Outstanding: R ${out.toFixed(2)} — #${String(r.id).slice(0,8)}`;
         return (
@@ -49,7 +66,7 @@ function RegistrationOptions({ regs, regOutstanding }: {
 }
 
 function UserSearchField({ allUsers, value, onChange, placeholder = "Search by name, email or phone…", disabled = false }: {
-  allUsers: any[];
+  allUsers: User[];
   value: string;
   onChange: (userId: string) => void;
   placeholder?: string;
@@ -136,87 +153,59 @@ function PaymentsContent() {
     if (!user) router.replace("/login");
   }, [user, loading, router]);
 
-  const [payments, setPayments] = useState<any[]>([]);
+  const [payments, setPayments] = useState<Payment[]>([]);
   const [loadingList, setLoadingList] = useState(false);
   const [error, setError] = useDismissingState<string | null>(null);
   const [info, setInfo] = useDismissingState<string | null>(null);
-  const [registrations, setRegistrations] = useState<any[]>([]);
+  const [registrations, setRegistrations] = useState<Registration[]>([]);
   const [loadingRegs, setLoadingRegs] = useState(false);
-  const [regOutstanding, setRegOutstanding] = useState<Record<string, { totalDue: number; totalPaid: number; outstanding: number }>>({});
+  const [regOutstanding, setRegOutstanding] = useState<Outstanding>({});
 
-  const loadPayments = async () => {
+  const loadPayments = useCallback(async () => {
     if (!token) return;
     try {
       setLoadingList(true);
       const list = await fetchAllPayments(token);
-      setPayments(list.sort((a: any, b: any) => new Date(b.createdAt).getTime() - new Date(a.createdAt).getTime()));
-    } catch (e: any) {
-      setError(e?.message || "Failed to load payments");
+      setPayments(list.sort((a, b) => new Date(b.createdAt).getTime() - new Date(a.createdAt).getTime()));
+    } catch (e) {
+      setError(errorMessage(e) || "Failed to load payments");
     } finally {
       setLoadingList(false);
     }
-  };
+  }, [token, setError]);
 
-  useEffect(() => { loadPayments(); }, [token]);
-
-  // Compute effective unit price for a registration option.
-  // Uses priceSnapshot when available (authoritative backend price, variant-aware).
-  // Falls back to deadline-only early-bird calculation for legacy rows without a snapshot.
-  const optionUnitPrice = (opt: any, referenceTime: any, atTime: Date): number => {
-    if (opt.priceSnapshot !== null && opt.priceSnapshot !== undefined) {
-      return Number(opt.priceSnapshot);
-    }
-    const eo = opt.eventOption;
-    const variantId: string | null = opt.variantId || null;
-    const base = (opt.variant?.price !== null && opt.variant?.price !== undefined)
-      ? Number(opt.variant.price)
-      : Number(eo?.price || 0);
-    const allTiers = Array.isArray(eo?.earlyBirdTiers) ? eo.earlyBirdTiers.slice() : [];
-    const tiers = variantId
-      ? allTiers.filter((t: any) => t.variantId === variantId)
-      : allTiers.filter((t: any) => !t.variantId);
-    if (tiers.length === 0) return base;
-    const t = atTime ? new Date(atTime) : new Date();
-    const ref = referenceTime ? new Date(referenceTime) : t;
-    const applicable = tiers
-      .map((x: any) => ({ ...x, deadline: new Date(x.deadline) }))
-      .filter((x: any) => (ref < x.deadline) && (t < x.deadline))
-      .sort((a: any, b: any) => a.deadline.getTime() - b.deadline.getTime() || (a.order||0) - (b.order||0) || a.price - b.price);
-    if (applicable.length === 0) return base;
-    const price = Number(applicable[0].price);
-    return (price >= 0) ? price : base;
-  };
+  useEffect(() => { loadPayments(); }, [loadPayments]);
 
   // Load registrations for dropdowns.
   // GET /api/registrations already embeds each registration's `payments`, so outstanding
   // balances are computed from that in one pass — no per-registration follow-up requests.
-  const loadRegistrations = async () => {
+  const loadRegistrations = useCallback(async () => {
     if (!token) return;
     try {
       setLoadingRegs(true);
-      const regs = await apiFetch<any[]>("/api/registrations", { authToken: token });
+      const regs = await apiFetch<Registration[]>("/api/registrations", { authToken: token });
       const list = Array.isArray(regs) ? regs : [];
       const now = new Date();
-      const map: Record<string, { totalDue: number; totalPaid: number; outstanding: number }> = {};
+      const map: Outstanding = {};
       for (const r of list) {
         // Backend attaches a tranche-aware totalDueComputed (exact even when a line spans
         // multiple early-bird prices) — fall back to the old client-side estimate otherwise.
-        const totalDue = r.totalDueComputed ?? (r.registrationOptions || []).reduce((sum: number, opt: any) => sum + optionUnitPrice(opt, null, now) * (opt.quantity || 0), 0);
-        const totalPaid = (r.payments || []).reduce((s: number, p: any) => s + (p.amount || 0), 0);
+        const totalDue = r.totalDueComputed ?? (r.registrationOptions || []).reduce((sum, opt) => sum + registrationOptionUnitPrice(opt, null, now) * (opt.quantity || 0), 0);
+        const totalPaid = (r.payments || []).reduce((s, p) => s + (p.amount || 0), 0);
         map[r.id] = { totalDue, totalPaid, outstanding: Math.max(0, totalDue - totalPaid) };
       }
       setRegOutstanding(map);
       // Sort by createdAt desc
       const sorted = list.sort((a,b) => new Date(b.createdAt).getTime() - new Date(a.createdAt).getTime());
       setRegistrations(sorted);
-    } catch (e) {
+    } catch {
       // ignore
     } finally {
       setLoadingRegs(false);
     }
-  };
+  }, [token]);
 
-  useEffect(() => { loadRegistrations(); }, [token]);
+  useEffect(() => { loadRegistrations(); }, [loadRegistrations]);
 
   // Load all users for Refund section
   useEffect(() => {
@@ -226,7 +215,7 @@ function PaymentsContent() {
         setLoadingUsers(true);
         const users = await fetchAllUsers(token);
         setAllUsers(users);
-      } catch (e) {
+      } catch {
         // ignore; fallback to derived users from registrations
       } finally {
         setLoadingUsers(false);
@@ -240,12 +229,12 @@ function PaymentsContent() {
   const [registrationId, setRegistrationId] = useState<string>("");
   const [isDonation, setIsDonation] = useState<boolean>(false);
   const [eventId, setEventId] = useState<string>("");
-  const [events, setEvents] = useState<any[]>([]);
+  const [events, setEvents] = useState<Event[]>([]);
   const [submitting, setSubmitting] = useState(false);
   // Backdate field
   const [paidAtLocal, setPaidAtLocal] = useState<string>("");
   // Users for Refund section (load all users with supervisor rights)
-  const [allUsers, setAllUsers] = useState<any[]>([]);
+  const [allUsers, setAllUsers] = useState<User[]>([]);
   const [loadingUsers, setLoadingUsers] = useState(false);
 
   // New: user selection states for split dropdowns
@@ -253,33 +242,12 @@ function PaymentsContent() {
 
   // Derived lists for users and outstanding registrations
   const outstandingRegs = useMemo(() => {
-    return registrations.filter((r: any) => (r.status !== 'paid') && (r.status !== 'cancelled') && ((regOutstanding[r.id]?.outstanding ?? 0) > 0));
+    return registrations.filter((r) => (r.status !== 'paid') && (r.status !== 'cancelled') && ((regOutstanding[r.id]?.outstanding ?? 0) > 0));
   }, [registrations, regOutstanding]);
 
-  // Users list for UI dropdowns (use all users if loaded; fallback to outstanding registrations)
-  const usersList = useMemo(() => {
-    if (allUsers && allUsers.length > 0) {
-      return [...allUsers]
-        //.filter(u => u?.isActive !== false)
-        .map(u => ({ id: String(u.id), name: String(u.name || u.email || u.id) }))
-        .sort((a, b) => a.name.localeCompare(b.name, undefined as any, { sensitivity: 'base' } as any));
-    }
-    const map = new Map<string, string>();
-    for (const r of outstandingRegs) {
-      const uid = r.user?.id || r.userId;
-      if (!uid) continue;
-      const name = r.user?.name || r.user?.email || String(r.userId || uid);
-      if (!map.has(String(uid))) {
-        map.set(String(uid), String(name));
-      }
-    }
-    return Array.from(map.entries())
-      .map(([id, name]) => ({ id, name }))
-      .sort((a, b) => a.name.localeCompare(b.name, undefined as any, { sensitivity: 'base' } as any));
-  }, [allUsers, outstandingRegs]);
 
   const regsForSelectedUser = useMemo(() => {
-    return outstandingRegs.filter((r: any) => (String(r.user?.id || r.userId) === String(selectedUserId)));
+    return outstandingRegs.filter((r) => (String(r.user?.id || r.userId) === String(selectedUserId)));
   }, [outstandingRegs, selectedUserId]);
 
   // Payment link tab state
@@ -292,7 +260,7 @@ function PaymentsContent() {
   const [linkCopied, setLinkCopied] = useState(false);
 
   const regsForLinkUser = useMemo(() => {
-    return outstandingRegs.filter((r: any) => (String(r.user?.id || r.userId) === String(linkUserId)));
+    return outstandingRegs.filter((r) => (String(r.user?.id || r.userId) === String(linkUserId)));
   }, [outstandingRegs, linkUserId]);
 
   useEffect(() => {
@@ -327,8 +295,8 @@ function PaymentsContent() {
       if (!res.redirectUrl) { setError("Failed to generate link"); return; }
       setLinkResult({ redirectUrl: res.redirectUrl, amount: res.amount ?? amt, registrationId: linkRegistrationId });
       setInfo("Payment link generated");
-    } catch (e: any) {
-      setError(e?.message || "Failed to generate payment link");
+    } catch (e) {
+      setError(errorMessage(e) || "Failed to generate payment link");
     } finally {
       setLinkGenerating(false);
     }
@@ -356,8 +324,8 @@ function PaymentsContent() {
         body: { registrationId: linkResult.registrationId, redirectUrl: linkResult.redirectUrl, channel },
       });
       setInfo(`Payment link sent via ${channel === "email" ? "email" : "WhatsApp"}`);
-    } catch (e: any) {
-      setError(e?.message || `Failed to send link via ${channel}`);
+    } catch (e) {
+      setError(errorMessage(e) || `Failed to send link via ${channel}`);
     } finally {
       setLinkSending(null);
     }
@@ -371,7 +339,7 @@ function PaymentsContent() {
   // If a registration is preselected via query, infer and set its user
   useEffect(() => {
     if (!registrationId) return;
-    const reg = registrations.find((r: any) => String(r.id) === String(registrationId));
+    const reg = registrations.find((r) => String(r.id) === String(registrationId));
     const uid = reg?.user?.id || reg?.userId;
     if (uid) setSelectedUserId(String(uid));
   }, [registrationId, registrations]);
@@ -387,7 +355,7 @@ function PaymentsContent() {
         if (eventsIncludePast) params.set("includePast", "true");
         if (eventsIncludeInactive) params.set("includeInactive", "true");
         const qs = params.toString() ? `?${params.toString()}` : "";
-        const evs = await apiFetch<any[]>(`/api/events/all${qs}`, { authToken: token });
+        const evs = await apiFetch<Event[]>(`/api/events/all${qs}`, { authToken: token });
         setEvents(evs || []);
       } catch {}
     })();
@@ -417,7 +385,7 @@ function PaymentsContent() {
     }
     try {
       setSubmitting(true);
-      const res = await apiFetch<any>("/api/payments", {
+      await apiFetch("/api/payments", {
         method: "POST",
         authToken: token,
         body: {
@@ -433,8 +401,8 @@ function PaymentsContent() {
       setInfo(`Payment created (R ${amt.toFixed(2)})`);
       setAmount(""); setRegistrationId(""); setIsDonation(false); setEventId(""); setPaidAtLocal("");
       await Promise.all([loadPayments(), loadRegistrations()]);
-    } catch (e: any) {
-      setError(e?.message || "Failed to create payment");
+    } catch (e) {
+      setError(errorMessage(e) || "Failed to create payment");
     } finally {
       setSubmitting(false);
     }
@@ -454,38 +422,38 @@ function PaymentsContent() {
 
   // Yoco unreconciled list and actions
   const [yocoLoading, setYocoLoading] = useState(false);
-  const [yocoTxs, setYocoTxs] = useState<any[]>([]);
-  const loadYocoUnreconciled = async () => {
+  const [yocoTxs, setYocoTxs] = useState<YocoTx[]>([]);
+  const loadYocoUnreconciled = useCallback(async () => {
     if (!token) return;
     try {
       setYocoLoading(true);
-      const res = await apiFetch<any>("/api/yoco-transactions/unreconciled", { authToken: token });
-      const items = Array.isArray(res?.data) ? res.data : (Array.isArray(res) ? res : []);
+      const res = await apiFetch<{ data?: YocoTx[] } | YocoTx[]>("/api/yoco-transactions/unreconciled", { authToken: token });
+      const items = Array.isArray(res) ? res : (Array.isArray(res?.data) ? res.data : []);
       setYocoTxs(items);
-    } catch (e) {
+    } catch {
       // ignore silently, shown on demand via error state if needed
     } finally {
       setYocoLoading(false);
     }
-  };
-  useEffect(() => { loadYocoUnreconciled(); }, [token]);
+  }, [token]);
+  useEffect(() => { loadYocoUnreconciled(); }, [loadYocoUnreconciled]);
 
   // Inline reconcile form state per-row
   const [reconcileForm, setReconcileForm] = useState<{ txId: string | null; type: 'reg' | 'don' | null; userId: string; registrationId: string; eventId: string; submitting: boolean }>({ txId: null, type: null, userId: '', registrationId: '', eventId: '', submitting: false });
 
-  const openReconcileToRegistration = (tx: any) => {
+  const openReconcileToRegistration = (tx: YocoTx) => {
     const metaUser = tx?.raw?.payload?.metadata?.userId ? String(tx.raw.payload.metadata.userId) : '';
     setReconcileForm({ txId: tx.id, type: 'reg', userId: metaUser, registrationId: '', eventId: '', submitting: false });
   };
 
-  const openReconcileAsDonation = (tx: any) => {
+  const openReconcileAsDonation = (tx: YocoTx) => {
     const metaEvent = tx?.raw?.payload?.metadata?.eventId ? String(tx.raw.payload.metadata.eventId) : '';
     setReconcileForm({ txId: tx.id, type: 'don', userId: '', registrationId: '', eventId: metaEvent, submitting: false });
   };
 
   const regsForUser = (uid: string) => registrations
-    .filter((r: any) => String(r.user?.id || r.userId) === String(uid))
-    .filter((r: any) => {
+    .filter((r) => String(r.user?.id || r.userId) === String(uid))
+    .filter((r) => {
       const out = regOutstanding[r.id]?.outstanding ?? 0;
       return out > 0.000001; // show only registrations with an outstanding balance
     });
@@ -515,8 +483,8 @@ function PaymentsContent() {
       }
       setReconcileForm({ txId: null, type: null, userId: '', registrationId: '', eventId: '', submitting: false });
       await Promise.all([loadYocoUnreconciled(), loadPayments(), loadRegistrations()]);
-    } catch (e: any) {
-      setError(e?.message || 'Failed to reconcile');
+    } catch (e) {
+      setError(errorMessage(e) || 'Failed to reconcile');
     } finally {
       setReconcileForm(prev => ({ ...prev, submitting: false }));
     }
@@ -618,8 +586,8 @@ function PaymentsContent() {
                               await apiFetch(`/api/yoco-transactions/${encodeURIComponent(tx.id)}/ignore`, { method: 'POST', authToken: token });
                               setInfo('Transaction ignored');
                               await loadYocoUnreconciled();
-                            } catch (e:any) {
-                              setError(e?.message || 'Failed to ignore');
+                            } catch (e) {
+                              setError(errorMessage(e) || 'Failed to ignore');
                             }
                           }}>Ignore</button>
                         </td>
@@ -637,7 +605,7 @@ function PaymentsContent() {
                                   <label className="block text-xs text-gray-600 mb-1">Registration</label>
                                   <select className="w-full border rounded px-3 py-2 text-sm" value={reconcileForm.registrationId} onChange={e => setReconcileForm(prev => ({ ...prev, registrationId: e.target.value }))} disabled={!reconcileForm.userId}>
                                     <option value="">Select registration…</option>
-                                    {reconcileForm.userId && regsForUser(reconcileForm.userId).map((r: any) => {
+                                    {reconcileForm.userId && regsForUser(reconcileForm.userId).map((r) => {
                                       const out = regOutstanding[r.id]?.outstanding ?? 0;
                                       const label = `${r.event?.title || r.eventId || 'Event'} — Outstanding: R ${out.toFixed(2)} — #${String(r.id).slice(0,8)}`;
                                       return <option key={r.id} value={r.id} title={label}>{label}</option>;
@@ -753,8 +721,7 @@ function PaymentsContent() {
               <RefundSection
                 payments={payments}
                 allUsers={allUsers}
-                usersList={usersList}
-                regsForUser={(uid:string)=> registrations.filter((r:any)=> String(r.user?.id||r.userId)===String(uid))}
+                regsForUser={(uid:string)=> registrations.filter((r)=> String(r.user?.id||r.userId)===String(uid))}
                 regOutstanding={regOutstanding}
                 onDone={async()=>{ await Promise.all([loadPayments(), loadRegistrations()]); setInfo('Refund recorded'); }}
               />
@@ -832,7 +799,7 @@ function PaymentsContent() {
                 return (
                   <li key={p.id} className={`border rounded p-2 ${isRefund ? 'bg-red-50' : ''}`}>
                     <div className="flex justify-between">
-                      <div className={`font-medium ${isRefund ? 'text-red-700' : ''}`}>{isRefund ? '-' : ''}R {Math.abs(amt).toFixed(2)} {p.isDonation ? <span className="text-xs text-emerald-700">(donation)</span> : null} {isRefund ? <span className="text-xs text-red-700">(refund)</span> : null}</div>
+                      <div className={`font-medium ${isRefund ? 'text-red-700' : ''}`}>{isRefund ? '-' : ''}R {Math.abs(amt).toFixed(2)} {p.isDonation ? <span className="text-xs text-emerald-700">({p.isSponsorship ? 'sponsorship' : 'donation'})</span> : null} {isRefund ? <span className="text-xs text-red-700">(refund)</span> : null}</div>
                       <div className="text-xs text-gray-500">{new Date(p.createdAt).toLocaleString()}</div>
                     </div>
                     <div className="text-xs text-gray-600">Method: {p.method || 'payment'}</div>
@@ -875,15 +842,14 @@ function PaymentsContent() {
 }
 
 type RefundSectionProps = {
-  payments: any[];
-  allUsers: any[];
-  usersList: { id: string; name: string }[];
-  regsForUser: (userId: string) => any[];
-  regOutstanding: Record<string, { totalDue: number; totalPaid: number; outstanding: number }>;
+  payments: Payment[];
+  allUsers: User[];
+  regsForUser: (userId: string) => Registration[];
+  regOutstanding: Outstanding;
   onDone: () => void | Promise<void>;
 };
 
-function RefundSection({ payments, allUsers, usersList, regsForUser, regOutstanding, onDone }: RefundSectionProps) {
+function RefundSection({ payments, allUsers, regsForUser, regOutstanding, onDone }: RefundSectionProps) {
   const { token } = useAuth();
   const [userId, setUserId] = useState<string>("");
   const [target, setTarget] = useState<'payment'|'registration'>('payment');
@@ -896,7 +862,7 @@ function RefundSection({ payments, allUsers, usersList, regsForUser, regOutstand
   const [err, setErr] = useState<string | null>(null);
 
   const paymentsForUser = useMemo(() => {
-    if (!userId) return [] as any[];
+    if (!userId) return [];
     return payments.filter(p => String(p.userId) === String(userId) && (p.amount || 0) > 0);
   }, [payments, userId]);
 
@@ -946,8 +912,8 @@ function RefundSection({ payments, allUsers, usersList, regsForUser, regOutstand
       });
       setUserId(""); setPaymentId(""); setRegistrationId(""); setAmount(""); setReason(""); setMethod("");
       await onDone();
-    } catch (e: any) {
-      setErr(e?.message || 'Failed to create refund');
+    } catch (e) {
+      setErr(errorMessage(e) || 'Failed to create refund');
     } finally {
       setSubmitting(false);
     }
@@ -970,7 +936,7 @@ function RefundSection({ payments, allUsers, usersList, regsForUser, regOutstand
             <label className="text-xs text-gray-600 mt-2">Payment</label>
             <select className="w-full max-w-full border rounded px-3 py-2 text-sm truncate" value={paymentId} onChange={e => setPaymentId(e.target.value)} disabled={!userId}>
               <option value="">Select payment…</option>
-              {paymentsForUser.map((p:any)=>{
+              {paymentsForUser.map((p)=>{
                 const label = `R ${(p.amount||0).toFixed(2)} — ${p.registrationId ? `Registration ${String(p.registrationId).slice(0,8)}` : (p.event?.title || p.eventId || 'Event')} — #${String(p.id).slice(0,8)}`;
                 return <option key={p.id} value={p.id} title={label}>{label}</option>;
               })}
@@ -981,7 +947,7 @@ function RefundSection({ payments, allUsers, usersList, regsForUser, regOutstand
             <label className="text-xs text-gray-600 mt-2">Registration</label>
             <select className="w-full max-w-full border rounded px-3 py-2 text-sm truncate" value={registrationId} onChange={e => setRegistrationId(e.target.value)} disabled={!userId}>
               <option value="">Select registration…</option>
-              {regs.map((r:any)=>{
+              {regs.map((r)=>{
                 const out = regOutstanding[r.id]?.outstanding ?? 0;
                 const label = `${r.event?.title || r.eventId || 'Event'} — Outstanding: R ${out.toFixed(2)} — #${String(r.id).slice(0,8)}`;
                 return <option key={r.id} value={r.id} title={label}>{label}</option>;
@@ -1003,7 +969,7 @@ function RefundSection({ payments, allUsers, usersList, regsForUser, regOutstand
               <option value="eft-refund">EFT refund</option>
               <option value="voucher-refund">Voucher refund</option>
             </select>
-            <div className="text-[10px] text-gray-500 mt-1">Mirrors the method being refunded — this is what nets against that method's total in reports.</div>
+            <div className="text-[10px] text-gray-500 mt-1">Mirrors the method being refunded — this is what nets against that method&apos;s total in reports.</div>
           </div>
         </div>
         <label className="block text-xs text-gray-600 mt-2">Reason (optional)</label>
@@ -1019,7 +985,7 @@ function RefundSection({ payments, allUsers, usersList, regsForUser, regOutstand
 // stats both deliberately filter them out (they're not new money, see isDonationLeg's comment) —
 // so this is the only place staff can see and reverse an assignment.
 type AssignedDonationsListProps = {
-  payments: any[];
+  payments: Payment[];
   onDone: () => void | Promise<void>;
 };
 
@@ -1033,12 +999,12 @@ function AssignedDonationsList({ payments, onDone }: AssignedDonationsListProps)
   const allLegs = useMemo(() => {
     return payments
       .filter(isDonationLeg)
-      .sort((a: any, b: any) => new Date(b.createdAt).getTime() - new Date(a.createdAt).getTime());
+      .sort((a, b) => new Date(b.createdAt).getTime() - new Date(a.createdAt).getTime());
   }, [payments]);
 
   const donationById = useMemo(() => {
-    const m = new Map<string, any>();
-    payments.forEach((p: any) => { if (p.isDonation) m.set(p.id, p); });
+    const m = new Map<string, Payment>();
+    payments.forEach((p) => { if (p.isDonation) m.set(p.id, p); });
     return m;
   }, [payments]);
 
@@ -1046,7 +1012,7 @@ function AssignedDonationsList({ payments, onDone }: AssignedDonationsListProps)
   // never shows an event with nothing to filter down to.
   const eventOptions = useMemo(() => {
     const m = new Map<string, string>();
-    allLegs.forEach((leg: any) => {
+    allLegs.forEach((leg) => {
       const ev = leg.registration?.event;
       if (ev?.id) m.set(String(ev.id), ev.title || String(ev.id));
     });
@@ -1055,10 +1021,10 @@ function AssignedDonationsList({ payments, onDone }: AssignedDonationsListProps)
 
   const legs = useMemo(() => {
     const q = query.trim().toLowerCase();
-    return allLegs.filter((leg: any) => {
+    return allLegs.filter((leg) => {
       if (eventFilter && String(leg.registration?.eventId || leg.registration?.event?.id) !== eventFilter) return false;
       if (!q) return true;
-      const donation = donationById.get(leg.originalPaymentId);
+      const donation = leg.originalPaymentId ? donationById.get(leg.originalPaymentId) : undefined;
       const haystack = [
         leg.registration?.user?.name,
         leg.registration?.user?.email,
@@ -1072,7 +1038,7 @@ function AssignedDonationsList({ payments, onDone }: AssignedDonationsListProps)
     });
   }, [allLegs, donationById, query, eventFilter]);
 
-  const unassign = async (leg: any) => {
+  const unassign = async (leg: Payment) => {
     if (!token) return;
     setErr(null);
     const ok = window.confirm("Unassign this donation? The registration's balance will increase, and any tickets issued only because this payment completed it may be revoked.");
@@ -1085,8 +1051,8 @@ function AssignedDonationsList({ payments, onDone }: AssignedDonationsListProps)
         body: { legId: leg.id }
       });
       await onDone();
-    } catch (e: any) {
-      setErr(e?.message || 'Failed to unassign donation');
+    } catch (e) {
+      setErr(errorMessage(e) || 'Failed to unassign donation');
     } finally {
       setUnassigningId(null);
     }
@@ -1120,8 +1086,8 @@ function AssignedDonationsList({ payments, onDone }: AssignedDonationsListProps)
         <div className="text-sm text-gray-500">No assigned donations match your search.</div>
       ) : (
         <ul className="text-sm space-y-2 max-h-[420px] overflow-auto pr-2">
-          {legs.map((leg: any) => {
-            const donation = donationById.get(leg.originalPaymentId);
+          {legs.map((leg) => {
+            const donation = leg.originalPaymentId ? donationById.get(leg.originalPaymentId) : undefined;
             return (
               <li key={leg.id} className="border rounded p-2">
                 <div className="flex justify-between items-start gap-2">
@@ -1153,10 +1119,10 @@ function AssignedDonationsList({ payments, onDone }: AssignedDonationsListProps)
 }
 
 type DonationAssignSectionProps = {
-  payments: any[];
-  allUsers: any[];
-  registrations: any[];
-  regOutstanding: Record<string, { totalDue: number; totalPaid: number; outstanding: number }>;
+  payments: Payment[];
+  allUsers: User[];
+  registrations: Registration[];
+  regOutstanding: Outstanding;
   onDone: () => void | Promise<void>;
 };
 
@@ -1171,6 +1137,7 @@ function DonationAssignSection({ payments, allUsers, registrations, regOutstandi
   const [paymentId, setPaymentId] = useState<string>("");
   const [amountStr, setAmountStr] = useState<string>("");
   const [assigning, setAssigning] = useState(false);
+  const [sponsorshipsOnly, setSponsorshipsOnly] = useState(false);
   const [err, setErr] = useState<string | null>(null);
 
   useEffect(() => { setRegistrationId(""); setPaymentId(""); }, [userId]);
@@ -1179,8 +1146,8 @@ function DonationAssignSection({ payments, allUsers, registrations, regOutstandi
   // Registrations for the selected user that can actually receive a donation: an outstanding
   // balance to apply it to, and an event that isn't closed.
   const regsForUser = useMemo(() => {
-    if (!userId) return [] as any[];
-    return registrations.filter((r: any) => {
+    if (!userId) return [];
+    return registrations.filter((r) => {
       if (String(r.user?.id || r.userId) !== String(userId)) return false;
       if (r.status === 'cancelled') return false;
       if (r.event?.cashupStatus === 'closed') return false;
@@ -1190,7 +1157,7 @@ function DonationAssignSection({ payments, allUsers, registrations, regOutstandi
   }, [registrations, regOutstanding, userId]);
 
   const selectedRegistration = useMemo(
-    () => registrations.find((r: any) => String(r.id) === String(registrationId)),
+    () => registrations.find((r) => String(r.id) === String(registrationId)),
     [registrations, registrationId]
   );
 
@@ -1203,7 +1170,7 @@ function DonationAssignSection({ payments, allUsers, registrations, regOutstandi
   // adding the refund back on top of what's left to allocate).
   const legsById = useMemo(() => {
     const m = new Map<string, number>();
-    payments.forEach((p: any) => {
+    payments.forEach((p) => {
       if (p.originalPaymentId && !p.isDonation) {
         m.set(p.originalPaymentId, (m.get(p.originalPaymentId) || 0) + Math.abs(p.amount || 0));
       }
@@ -1214,18 +1181,19 @@ function DonationAssignSection({ payments, allUsers, registrations, regOutstandi
   // Donations "relevant to that event" — donations logged against the same event as the
   // chosen registration that still have a remaining, unused balance.
   const donationsForEvent = useMemo(() => {
-    if (!selectedRegistration) return [] as any[];
+    if (!selectedRegistration) return [];
     const eventId = selectedRegistration.eventId || selectedRegistration.event?.id;
-    return payments.filter((p: any) => {
+    return payments.filter((p) => {
       if (!p.isDonation || p.registrationId) return false;
       if (String(p.eventId) !== String(eventId)) return false;
+      if (sponsorshipsOnly && !p.isSponsorship) return false;
       const remaining = (p.amount || 0) - (legsById.get(p.id) || 0);
       return remaining > 0.000001;
     });
-  }, [payments, selectedRegistration, legsById]);
+  }, [payments, selectedRegistration, legsById, sponsorshipsOnly]);
 
   const selectedDonation = useMemo(
-    () => payments.find((p: any) => String(p.id) === String(paymentId)),
+    () => payments.find((p) => String(p.id) === String(paymentId)),
     [payments, paymentId]
   );
 
@@ -1267,8 +1235,8 @@ function DonationAssignSection({ payments, allUsers, registrations, regOutstandi
       });
       setUserId(""); setRegistrationId(""); setPaymentId(""); setAmountStr("");
       await onDone();
-    } catch (e: any) {
-      setErr(e?.message || 'Failed to assign donation');
+    } catch (e) {
+      setErr(errorMessage(e) || 'Failed to assign donation');
     } finally {
       setAssigning(false);
     }
@@ -1304,14 +1272,21 @@ function DonationAssignSection({ payments, allUsers, registrations, regOutstandi
           disabled={!registrationId}
         >
           <option value="">Select donation…</option>
-          {donationsForEvent.map((p: any) => {
+          {donationsForEvent.map((p) => {
             const remaining = (p.amount || 0) - (legsById.get(p.id) || 0);
-            const label = `R ${remaining.toFixed(2)} of R ${(p.amount || 0).toFixed(2)} left — ${p.user?.name || p.userId || 'Donor'} — #${String(p.id).slice(0,8)}`;
+            const donor = p.isSponsorship ? `Sponsorship: ${p.sponsorAnonymous ? 'anonymous' : (p.sponsorName || p.user?.name || 'sponsor')}` : (p.user?.name || p.userId || 'Donor');
+            const label = `R ${remaining.toFixed(2)} of R ${(p.amount || 0).toFixed(2)} left — ${donor} — #${String(p.id).slice(0,8)}`;
             return <option key={p.id} value={p.id} title={label}>{label}</option>;
           })}
         </select>
+        <label className="flex items-center gap-2 text-xs text-gray-600 cursor-pointer">
+          <input type="checkbox" checked={sponsorshipsOnly} onChange={e => { setSponsorshipsOnly(e.target.checked); setPaymentId(""); }} /> Only the sponsorship pool
+        </label>
         {registrationId && donationsForEvent.length === 0 && (
-          <div className="text-xs text-gray-500">No donations with a remaining balance for this event.</div>
+          <div className="text-xs text-gray-500">No {sponsorshipsOnly ? "sponsorships" : "donations"} with a remaining balance for this event.</div>
+        )}
+        {selectedDonation?.isSponsorship && selectedDonation.sponsorMessage && (
+          <div className="text-xs text-rose-800 bg-rose-50 rounded p-2">Sponsor&apos;s message: “{selectedDonation.sponsorMessage}”</div>
         )}
 
         {selectedDonation && (

frontend/src/app/dashboard/supervisor/waitlist/page.tsx

@@ -8,6 +8,8 @@ import { formatDate } from "@/lib/date";
 import { useDismissingState } from "@/hooks/useDismissingState";
 import { ListChecks, ArrowUp, ArrowDown } from "lucide-react";
 import { Table, TableHeader, TableBody, TableRow, TableHead, TableCell } from "@/components/ui/table";
+import { errorMessage } from "@/lib/utils";
+import type { Event } from "@/types";
 
 type Entry = {
   id: string;
@@ -43,7 +45,7 @@ export default function WaitlistPage() {
     if (!user) router.replace("/login");
   }, [user, loading, router]);
 
-  const [events, setEvents] = useState<any[]>([]);
+  const [events, setEvents] = useState<Event[]>([]);
   const [eventId, setEventId] = useState(search.get("eventId") || "");
   const [entries, setEntries] = useState<Entry[]>([]);
   const [busy, setBusy] = useState(false);
@@ -52,7 +54,7 @@ export default function WaitlistPage() {
 
   useEffect(() => {
     if (!token || !canView) return;
-    apiFetch<any[]>("/api/events/all", { authToken: token })
+    apiFetch<Event[]>("/api/events/all", { authToken: token })
       .then(evs => {
         const withList = (evs || []).filter(e => e.waitlistEnabled);
         setEvents(withList);
@@ -67,22 +69,22 @@ export default function WaitlistPage() {
     setBusy(true);
     try {
       setEntries(await apiFetch<Entry[]>(`/api/waitlist/events/${encodeURIComponent(eventId)}`, { authToken: token }));
-    } catch (e: any) {
-      setError(e?.message || "Failed to load the waitlist");
+    } catch (e) {
+      setError(errorMessage(e) || "Failed to load the waitlist");
     } finally {
       setBusy(false);
     }
   }, [token, eventId, setError]);
   useEffect(() => { load(); }, [load]);
 
-  const act = async (path: string, body?: any) => {
+  const act = async (path: string, body?: { direction: "up" | "down" }) => {
     setBusy(true);
     try {
       const res = await apiFetch<{ message?: string }>(path, { method: "POST", authToken: token!, body });
       if (res?.message) setInfo(res.message);
       await load();
-    } catch (e: any) {
-      setError(e?.message || "Something went wrong");
+    } catch (e) {
+      setError(errorMessage(e) || "Something went wrong");
     } finally {
       setBusy(false);
     }

frontend/src/app/dashboard/supervisor/whatsapp-attendees/page.tsx

@@ -1,15 +1,21 @@
 "use client";
 
-import React, { Suspense, useEffect, useMemo, useState } from "react";
+import React, { Suspense, useCallback, useEffect, useMemo, useRef, useState } from "react";
 import { useAuth } from "@/hooks/useAuth";
 import { useRouter, useSearchParams } from "next/navigation";
 import { apiFetch, fetchAllUsers } from "@/lib/api";
 import { useDismissingState } from "@/hooks/useDismissingState";
 import { MessageCircle, Users, Zap, Send, Clock, type LucideIcon } from "lucide-react";
+import { AllocationGroupFilter } from "@/components/shared/AllocationGroupFilter";
+import { errorMessage } from "@/lib/utils";
+import type { Event, MessageSendResult, Registration, User } from "@/types";
 
 // Attendee with preference info
 type Attendee = { id: string; name: string; phone: string; pref: string };
 type UserEntry = { id: string; name: string; phone: string; pref: string };
+type TemplateKey = "custom" | "payment_reminder" | "event_reminder" | "tickets";
+type StatusFilter = "any" | "paid" | "unpaid" | "partial_paid" | "cancelled";
+type MessageFilter = { status?: Exclude<StatusFilter, "any">; attendeeIds?: string[]; allocationGroupId?: string };
 
 const WA_TAB_ICONS: Record<"attendees" | "automations" | "broadcasts" | "scheduled", LucideIcon> = {
   attendees: Users,
@@ -159,16 +165,14 @@ function AttendeesCheckboxDropdown({
 
 // ─── Preference warning banner ────────────────────────────────────────────────
 function PrefWarning({ attendees, selectedIds, channel }: { attendees: (Attendee|UserEntry)[]; selectedIds: string[]; channel: "whatsapp" | "email" }) {
-  const prefMatch = (pref: string) =>
-    channel === "whatsapp" ? pref === "whatsapp" || pref === "both" : pref === "email" || pref === "both";
-
-  const mismatched = useMemo(
-    () => selectedIds.filter((id) => {
+  const mismatched = useMemo(() => {
+    const prefMatch = (pref: string) =>
+      channel === "whatsapp" ? pref === "whatsapp" || pref === "both" : pref === "email" || pref === "both";
+    return selectedIds.filter((id) => {
       const a = attendees.find((x) => x.id === id);
       return a && !prefMatch(a.pref);
-    }),
-    [attendees, selectedIds, channel]
-  );
+    });
+  }, [attendees, selectedIds, channel]);
 
   if (mismatched.length === 0) return null;
   return (
@@ -187,9 +191,9 @@ function PrefWarning({ attendees, selectedIds, channel }: { attendees: (Attendee
 }
 
 // ─── WhatsApp Automations Panel ───────────────────────────────────────────────
-function WAAutomationsPanel({ events, token, onInfo, onError }: { events: any[]; token?: string | null; onInfo: (s: string) => void; onError: (s: string) => void }) {
+function WAAutomationsPanel({ events, token, onInfo, onError }: { events: Event[]; token?: string | null; onInfo: (s: string | null) => void; onError: (s: string | null) => void }) {
   const [autoEventId, setAutoEventId] = React.useState<string>("");
-  const currentEvent = React.useMemo(() => (events || []).find((e: any) => e.id === autoEventId), [events, autoEventId]);
+  const currentEvent = React.useMemo(() => (events || []).find((e) => e.id === autoEventId), [events, autoEventId]);
 
   const preWeekDefault = `Hi {{name}}\n\nJust a friendly reminder that {{event.title}} is one week away!\n\nEvent details: {{event.link}}`;
   const finalDefault = `Hi {{name}}\n\nFinal reminder for {{event.title}}.\nPlease have your QR code/ticket ready at entry.\n\nEvent details: {{event.link}}`;
@@ -229,10 +233,10 @@ function WAAutomationsPanel({ events, token, onInfo, onError }: { events: any[];
 
   const onSchedule = async () => {
     try {
-      onError(null as any); onInfo(null as any);
+      onError(null); onInfo(null);
       if (!token) { onError("Not authenticated"); return; }
       if (!autoEventId) { onError("Please select an event"); return; }
-      const jobs: any[] = [];
+      const jobs: { message: string; scheduledAt: string; promoEventId?: string }[] = [];
       if (enablePre && preBody.trim() && preWhen) jobs.push({ message: preBody, scheduledAt: new Date(preWhen).toISOString() });
       if (enableFinal && finalBody.trim() && finalWhen) jobs.push({ message: finalBody, scheduledAt: new Date(finalWhen).toISOString() });
       if (enableThanks && thanksBody.trim() && thanksWhen) jobs.push({ message: thanksBody, scheduledAt: new Date(thanksWhen).toISOString() });
@@ -247,8 +251,8 @@ function WAAutomationsPanel({ events, token, onInfo, onError }: { events: any[];
         scheduled++;
       }
       onInfo(`Scheduled ${scheduled} WhatsApp automation(s).`);
-    } catch (e: any) {
-      onError(e?.message || "Failed to schedule automations");
+    } catch (e) {
+      onError(errorMessage(e) || "Failed to schedule automations");
     }
   };
 
@@ -258,7 +262,7 @@ function WAAutomationsPanel({ events, token, onInfo, onError }: { events: any[];
         <label className="block text-xs text-gray-600 mb-1">Event</label>
         <select className="w-full border rounded px-3 py-2 text-sm" value={autoEventId} onChange={(e) => setAutoEventId(e.target.value)}>
           <option value="">Select an event…</option>
-          {(events || []).map((ev: any) => (
+          {(events || []).map((ev) => (
             <option key={ev.id} value={ev.id}>{ev.title}</option>
           ))}
         </select>
@@ -285,7 +289,7 @@ function WAAutomationsPanel({ events, token, onInfo, onError }: { events: any[];
               <input type="checkbox" checked={enableFinal} onChange={(e) => setEnableFinal(e.target.checked)} /> Enable
             </label>
             <label className="text-xs text-gray-600">Hours before:</label>
-            <select className="border rounded px-2 py-1 text-sm" value={finalHours} onChange={(e) => setFinalHours(e.target.value as any)}>
+            <select className="border rounded px-2 py-1 text-sm" value={finalHours} onChange={(e) => setFinalHours(e.target.value as "24" | "48")}>
               <option value="24">24</option>
               <option value="48">48</option>
             </select>
@@ -323,7 +327,7 @@ function WAAutomationsPanel({ events, token, onInfo, onError }: { events: any[];
               <label className="block text-xs text-gray-600 mb-1">Promo Event</label>
               <select className="w-full border rounded px-3 py-2 text-sm" value={promoEventId} onChange={(e) => setPromoEventId(e.target.value)}>
                 <option value="">Select event to promote…</option>
-                {(events || []).map((ev: any) => (
+                {(events || []).map((ev) => (
                   <option key={ev.id} value={ev.id}>{ev.title}</option>
                 ))}
               </select>
@@ -371,7 +375,7 @@ function WhatsAppAttendeesPageInner() {
   const [info, setInfo] = useDismissingState<string | null>(null);
   const [tab, setTab] = useState<"attendees" | "automations" | "broadcasts" | "scheduled">("attendees");
   const [loadingEvents, setLoadingEvents] = useState(false);
-  const [allEvents, setAllEvents] = useState<any[]>([]);
+  const [allEvents, setAllEvents] = useState<Event[]>([]);
   const [evIncludePast, setEvIncludePast] = useState(false);
 
   const events = useMemo(() => {
@@ -384,24 +388,27 @@ function WhatsAppAttendeesPageInner() {
     const loadEvents = async () => {
       try {
         setLoadingEvents(true);
-        const evs = await apiFetch<any[]>("/api/events/all?includePast=true", { authToken: token || undefined });
-        setAllEvents((evs || []).sort((a: any, b: any) => new Date(a.startDate).getTime() - new Date(b.startDate).getTime()));
-      } catch (e: any) {
-        setError(e?.message || "Failed to load events");
+        const evs = await apiFetch<Event[]>("/api/events/all?includePast=true", { authToken: token || undefined });
+        setAllEvents((evs || []).sort((a, b) => new Date(a.startDate).getTime() - new Date(b.startDate).getTime()));
+      } catch (e) {
+        setError(errorMessage(e) || "Failed to load events");
       } finally {
         setLoadingEvents(false);
       }
     };
     loadEvents();
-  }, [user, token]);
+  }, [user, token, setError]);
 
   // ── Attendees tab ──────────────────────────────────────────────────────────
   const [eventId, setEventId] = useState<string>(preselectEventId);
   useEffect(() => { if (preselectEventId) setEventId(preselectEventId); }, [preselectEventId]);
-  const [templateKey, setTemplateKey] = useState<"custom" | "payment_reminder" | "event_reminder" | "tickets">("custom");
+  const [templateKey, setTemplateKey] = useState<TemplateKey>("custom");
   const [message, setMessage] = useState("");
-  const [messageDirty, setMessageDirty] = useState(false);
-  const [status, setStatus] = useState<"any" | "paid" | "unpaid" | "partial_paid" | "cancelled">("any");
+  // Set once the supervisor edits the message, so picking a template doesn't overwrite it.
+  // A ref, not state: it only gates the template effect below and is never rendered.
+  const messageDirtyRef = useRef(false);
+  const [status, setStatus] = useState<StatusFilter>("any");
+  const [groupId, setGroupId] = useState("");
   const [attendees, setAttendees] = useState<Attendee[]>([]);
   const [selectedAttendeeIds, setSelectedAttendeeIds] = useState<string[]>([]);
   const [loadingAttendees, setLoadingAttendees] = useState(false);
@@ -416,11 +423,11 @@ function WhatsAppAttendeesPageInner() {
   useEffect(() => {
     const title = currentEvent?.title || "the event";
     if (templateKey === "payment_reminder") {
-      if (!messageDirty) setMessage(`Hi {{name}}\n\nFriendly reminder: you have an outstanding balance for ${title}.\n\nPlease settle your balance to secure your tickets. Thank you!`);
+      if (!messageDirtyRef.current) setMessage(`Hi {{name}}\n\nFriendly reminder: you have an outstanding balance for ${title}.\n\nPlease settle your balance to secure your tickets. Thank you!`);
     } else if (templateKey === "event_reminder") {
-      if (!messageDirty) setMessage(`Hi {{name}}\n\nA quick reminder about ${title}.\nStart: {{event.start}}\n\nWe look forward to seeing you!`);
+      if (!messageDirtyRef.current) setMessage(`Hi {{name}}\n\nA quick reminder about ${title}.\nStart: {{event.start}}\n\nWe look forward to seeing you!`);
     } else if (templateKey === "tickets") {
-      setMessageDirty(false); setMessage("");
+      messageDirtyRef.current = false; setMessage("");
     }
   }, [templateKey, currentEvent]);
 
@@ -429,10 +436,10 @@ function WhatsAppAttendeesPageInner() {
       try {
         setLoadingAttendees(true); setAttendees([]); setSelectedAttendeeIds([]);
         if (!eventId || !token) return;
-        const regs = await apiFetch<any[]>(`/api/registrations/event/${encodeURIComponent(eventId)}`, { authToken: token });
+        const regs = await apiFetch<Registration[]>(`/api/registrations/event/${encodeURIComponent(eventId)}`, { authToken: token });
         const uniq = new Map<string, Attendee>();
-        (regs || []).forEach((r: any) => {
-          const u = r?.user;
+        (regs || []).forEach((r) => {
+          const u: User | undefined = r?.user;
           if (u?.id && u?.phoneNumber && !u.email?.endsWith("@guest.local") && u.isActive !== false) {
             uniq.set(u.id, { id: u.id, name: u.name || "", phone: u.phoneNumber, pref: u.notificationPreference || "email" });
           }
@@ -448,8 +455,8 @@ function WhatsAppAttendeesPageInner() {
   }, [eventId, token]);
 
   const buildPayload = (dryRun?: boolean) => {
-    const payload: any = {
-      filter: { status: status !== "any" ? status : undefined, attendeeIds: selectedAttendeeIds.length ? selectedAttendeeIds : undefined },
+    const payload: { filter: MessageFilter; template: TemplateKey; dryRun?: boolean; message?: string } = {
+      filter: { status: status !== "any" ? status : undefined, attendeeIds: selectedAttendeeIds.length ? selectedAttendeeIds : undefined, allocationGroupId: groupId || undefined },
       template: templateKey,
       dryRun: dryRun || undefined,
     };
@@ -463,15 +470,15 @@ function WhatsAppAttendeesPageInner() {
       if (!token) { setError("Not authenticated"); return; }
       if (!eventId) { setError("Please select an event"); return; }
       if (templateKey !== "tickets" && !message.trim()) { setError("Message is required"); return; }
-      const res = await apiFetch(`/api/events/${encodeURIComponent(eventId)}/whatsapp-attendees`, { method: "POST", authToken: token, body: buildPayload(true) });
+      const res = await apiFetch<MessageSendResult>(`/api/events/${encodeURIComponent(eventId)}/whatsapp-attendees`, { method: "POST", authToken: token, body: buildPayload(true) });
       setPreviewCount(res?.matched ?? 0);
       setPreviewSample(Array.isArray(res?.recipients) ? res.recipients : null);
       setInfo(`Matched ${res?.matched ?? 0} recipient(s) with a phone number.`);
-    } catch (e: any) { setError(e?.message || "Failed to preview"); }
+    } catch (e) { setError(errorMessage(e) || "Failed to preview"); }
   };
 
   const resetAttendeesForm = () => {
-    setTemplateKey("custom"); setMessage(""); setMessageDirty(false);
+    setTemplateKey("custom"); setMessage(""); messageDirtyRef.current = false;
     setStatus("any"); setScheduledAtLocal(""); setPreviewCount(null); setPreviewSample(null);
     setSelectedAttendeeIds(attendees.map((a) => a.id));
   };
@@ -483,10 +490,10 @@ function WhatsAppAttendeesPageInner() {
       if (!eventId) { setError("Please select an event"); return; }
       if (templateKey !== "tickets" && !message.trim()) { setError("Message is required"); return; }
       setSending(true);
-      const res = await apiFetch(`/api/events/${encodeURIComponent(eventId)}/whatsapp-attendees`, { method: "POST", authToken: token, body: buildPayload() });
+      const res = await apiFetch<MessageSendResult>(`/api/events/${encodeURIComponent(eventId)}/whatsapp-attendees`, { method: "POST", authToken: token, body: buildPayload() });
       setInfo(`Queued ${res?.queued ?? res?.matched ?? 0} recipient(s) for sending.`);
       resetAttendeesForm();
-    } catch (e: any) { setError(e?.message || "Failed to send"); } finally { setSending(false); }
+    } catch (e) { setError(errorMessage(e) || "Failed to send"); } finally { setSending(false); }
   };
 
   const onScheduleSend = async () => {
@@ -497,15 +504,15 @@ function WhatsAppAttendeesPageInner() {
       if (templateKey !== "tickets" && !message.trim()) { setError("Message is required"); return; }
       if (!scheduledAtLocal) { setError("Scheduled time is required"); return; }
       const whenIso = new Date(scheduledAtLocal).toISOString();
-      const payload: any = {
+      const payload: { message?: string; filter: MessageFilter; template: TemplateKey; scheduledAt: string } = {
         message: message || undefined,
-        filter: { status: status !== "any" ? status : undefined, attendeeIds: selectedAttendeeIds.length ? selectedAttendeeIds : undefined },
+        filter: { status: status !== "any" ? status : undefined, attendeeIds: selectedAttendeeIds.length ? selectedAttendeeIds : undefined, allocationGroupId: groupId || undefined },
         template: templateKey, scheduledAt: whenIso,
       };
-      const res = await apiFetch(`/api/events/${encodeURIComponent(eventId)}/whatsapp-attendees/schedule`, { method: "POST", authToken: token, body: payload });
+      const res = await apiFetch<MessageSendResult>(`/api/events/${encodeURIComponent(eventId)}/whatsapp-attendees/schedule`, { method: "POST", authToken: token, body: payload });
       setInfo(res?.job?.id ? "WhatsApp scheduled. It will be sent around the specified time." : "Scheduled.");
       resetAttendeesForm();
-    } catch (e: any) { setError(e?.message || "Failed to schedule"); }
+    } catch (e) { setError(errorMessage(e) || "Failed to schedule"); }
   };
 
   // ── Broadcasts tab ─────────────────────────────────────────────────────────
@@ -526,9 +533,9 @@ function WhatsAppAttendeesPageInner() {
         setLoadingUsers(true);
         const allUsers = await fetchAllUsers(token);
         const mapped = allUsers
-          .filter((u: any) => u.isActive !== false && !u.email?.endsWith("@guest.local") && u.phoneNumber)
-          .map((u: any) => ({ id: u.id, name: u.name || "", phone: u.phoneNumber, pref: u.notificationPreference || "email" }))
-          .sort((a: any, b: any) => (a.name || "").localeCompare(b.name || "", undefined, { sensitivity: "base" }));
+          .filter((u) => u.isActive !== false && !u.email?.endsWith("@guest.local") && u.phoneNumber)
+          .map((u) => ({ id: u.id, name: u.name || "", phone: u.phoneNumber || "", pref: u.notificationPreference || "email" }))
+          .sort((a, b) => (a.name || "").localeCompare(b.name || "", undefined, { sensitivity: "base" }));
         setUsers(mapped);
       } catch { } finally { setLoadingUsers(false); }
     };
@@ -550,30 +557,30 @@ function WhatsAppAttendeesPageInner() {
   const [editWhen, setEditWhen] = useState<string>("");
   const [savingEdit, setSavingEdit] = useState(false);
 
-  const loadScheduled = async () => {
+  const loadScheduled = useCallback(async () => {
     try {
       if (!token) return;
       setLoadingScheduled(true);
       const res = await apiFetch<{ jobs: ScheduledJob[] }>(`/api/scheduled-emails?channel=whatsapp`, { authToken: token });
       setScheduled(Array.isArray(res?.jobs) ? res.jobs : []);
     } catch { } finally { setLoadingScheduled(false); }
-  };
+  }, [token]);
 
-  useEffect(() => { if (tab === "scheduled") loadScheduled(); }, [tab, token]);
+  useEffect(() => { if (tab === "scheduled") loadScheduled(); }, [tab, loadScheduled]);
 
   const saveEdit = async () => {
     if (!editing) return;
     try {
       setSavingEdit(true);
       if (!token) { setError("Not authenticated"); return; }
-      const body: any = {};
+      const body: { scheduledAt?: string; message?: string } = {};
       if (editWhen) body.scheduledAt = new Date(editWhen).toISOString();
       if (editMessage.trim()) body.message = editMessage;
       await apiFetch(`/api/scheduled-emails/${encodeURIComponent(editing.id)}`, { method: "PATCH", authToken: token, body });
       setInfo("Scheduled message updated.");
       setEditing(null);
       loadScheduled();
-    } catch (e: any) { setError(e?.message || "Failed to update"); } finally { setSavingEdit(false); }
+    } catch (e) { setError(errorMessage(e) || "Failed to update"); } finally { setSavingEdit(false); }
   };
 
   const removeJob = async (job: ScheduledJob) => {
@@ -582,7 +589,7 @@ function WhatsAppAttendeesPageInner() {
       await apiFetch(`/api/scheduled-emails/${encodeURIComponent(job.id)}`, { method: "DELETE", authToken: token });
       setInfo("Scheduled message removed.");
       loadScheduled();
-    } catch (e: any) { setError(e?.message || "Failed to remove"); }
+    } catch (e) { setError(errorMessage(e) || "Failed to remove"); }
   };
 
   // ── Render ─────────────────────────────────────────────────────────────────
@@ -661,7 +668,7 @@ function WhatsAppAttendeesPageInner() {
                     Info
                   </button>
                 </div>
-                <select className="w-full border rounded px-3 py-2 text-sm" value={templateKey} onChange={(e) => setTemplateKey(e.target.value as any)}>
+                <select className="w-full border rounded px-3 py-2 text-sm" value={templateKey} onChange={(e) => setTemplateKey(e.target.value as TemplateKey)}>
                   <option value="custom">Custom message</option>
                   <option value="payment_reminder">Payment reminder</option>
                   <option value="event_reminder">Event reminder</option>
@@ -691,7 +698,7 @@ function WhatsAppAttendeesPageInner() {
                         <li><code>{"{{event.title}}"}</code> — the event title.</li>
                         <li><code>{"{{event.start}}"}</code> — the event start date/time.</li>
                         <li><code>{"{{balance}}"}</code> — outstanding balance for the event.</li>
-                        <li><code>{"{{payment.link}}"}</code> — a direct Yoco payment link for the attendee's outstanding balance (generated per recipient when sending).</li>
+                        <li><code>{"{{payment.link}}"}</code> — a direct Yoco payment link for the attendee&apos;s outstanding balance (generated per recipient when sending).</li>
                       </ul>
                       <p className="text-[11px] text-gray-500 mt-2">
                         Preference indicators: <span className="text-green-700 bg-green-50 px-1 rounded">WA</span> = WhatsApp only,{" "}
@@ -707,7 +714,7 @@ function WhatsAppAttendeesPageInner() {
             <div className="grid sm:grid-cols-2 gap-3">
               <div>
                 <label className="block text-xs text-gray-600 mb-1">Payment status filter</label>
-                <select className="w-full border rounded px-3 py-2 text-sm" value={status} onChange={(e) => setStatus(e.target.value as any)}>
+                <select className="w-full border rounded px-3 py-2 text-sm" value={status} onChange={(e) => setStatus(e.target.value as StatusFilter)}>
                   <option value="any">Any</option>
                   <option value="paid">Paid</option>
                   <option value="unpaid">Unpaid (pending or partial)</option>
@@ -715,13 +722,14 @@ function WhatsAppAttendeesPageInner() {
                   <option value="cancelled">Cancelled</option>
                 </select>
               </div>
+              <AllocationGroupFilter token={token} eventId={eventId} value={groupId} onChange={setGroupId} />
             </div>
 
             {templateKey !== "tickets" ? (
               <div>
                 <label className="block text-xs text-gray-600 mb-1">Message</label>
                 <textarea className="w-full border rounded px-3 py-2 text-sm" rows={8} value={message}
-                  onChange={(e) => { setMessage(e.target.value); setMessageDirty(true); }}
+                  onChange={(e) => { setMessage(e.target.value); messageDirtyRef.current = true; }}
                   placeholder="Write your WhatsApp message to attendees..." />
               </div>
             ) : (
@@ -834,11 +842,11 @@ function WhatsAppAttendeesPageInner() {
                 try {
                   setError(null); setInfo(null); setBroadcastPreviewCount(null); setBroadcastPreviewSample(null);
                   if (!token) { setError("Not authenticated"); return; }
-                  const res = await apiFetch(`/api/whatsapp-broadcasts/preview`, { method: "POST", authToken: token, body: { userIds: selectedUserIds, phones: broadcastPhones, eventId: broadcastEventId || undefined } });
+                  const res = await apiFetch<MessageSendResult>(`/api/whatsapp-broadcasts/preview`, { method: "POST", authToken: token, body: { userIds: selectedUserIds, phones: broadcastPhones, eventId: broadcastEventId || undefined } });
                   setBroadcastPreviewCount(res?.matched ?? 0);
                   setBroadcastPreviewSample(Array.isArray(res?.recipients) ? res.recipients : null);
                   setInfo(`Matched ${res?.matched ?? 0} recipient(s).`);
-                } catch (e: any) { setError(e?.message || "Failed to preview"); }
+                } catch (e) { setError(errorMessage(e) || "Failed to preview"); }
               }}>Preview recipients</button>
 
               <button type="button" className="px-3 py-1.5 text-sm rounded bg-green-600 text-white hover:bg-green-700 disabled:opacity-50" onClick={async () => {
@@ -846,10 +854,10 @@ function WhatsAppAttendeesPageInner() {
                   setError(null); setInfo(null);
                   if (!token) { setError("Not authenticated"); return; }
                   if (!broadcastMessage.trim()) { setError("Message is required"); return; }
-                  const res = await apiFetch(`/api/whatsapp-broadcasts/send`, { method: "POST", authToken: token, body: { message: broadcastMessage, userIds: selectedUserIds, phones: broadcastPhones, eventId: broadcastEventId || undefined } });
+                  const res = await apiFetch<MessageSendResult>(`/api/whatsapp-broadcasts/send`, { method: "POST", authToken: token, body: { message: broadcastMessage, userIds: selectedUserIds, phones: broadcastPhones, eventId: broadcastEventId || undefined } });
                   setInfo(`Sent ${res?.sent ?? 0} out of ${res?.matched ?? 0} recipient(s).`);
                   resetBroadcastForm();
-                } catch (e: any) { setError(e?.message || "Failed to send"); }
+                } catch (e) { setError(errorMessage(e) || "Failed to send"); }
               }}>Send now</button>
 
               <button type="button" disabled={!broadcastScheduledAtLocal} className="px-3 py-1.5 text-sm rounded bg-emerald-600 text-white hover:bg-emerald-700 disabled:opacity-50" onClick={async () => {
@@ -858,10 +866,10 @@ function WhatsAppAttendeesPageInner() {
                   if (!token) { setError("Not authenticated"); return; }
                   if (!broadcastMessage.trim()) { setError("Message is required"); return; }
                   const whenIso = new Date(broadcastScheduledAtLocal).toISOString();
-                  const res = await apiFetch(`/api/whatsapp-broadcasts/schedule`, { method: "POST", authToken: token, body: { scheduledAt: whenIso, message: broadcastMessage, userIds: selectedUserIds, phones: broadcastPhones, eventId: broadcastEventId || undefined } });
+                  const res = await apiFetch<MessageSendResult>(`/api/whatsapp-broadcasts/schedule`, { method: "POST", authToken: token, body: { scheduledAt: whenIso, message: broadcastMessage, userIds: selectedUserIds, phones: broadcastPhones, eventId: broadcastEventId || undefined } });
                   if (res?.job?.id) setInfo("WhatsApp broadcast scheduled."); else setInfo("Scheduled.");
                   resetBroadcastForm();
-                } catch (e: any) { setError(e?.message || "Failed to schedule broadcast"); }
+                } catch (e) { setError(errorMessage(e) || "Failed to schedule broadcast"); }
               }}>Schedule send</button>
 
               {broadcastPreviewCount != null && <span className="text-xs text-gray-600">Preview: {broadcastPreviewCount} recipient(s)</span>}

frontend/src/app/dashboard/user/donate/page.tsx

@@ -4,10 +4,12 @@ import { useAuth } from "@/hooks/useAuth";
 import { apiFetch } from "@/lib/api";
 import { useDismissingState } from "@/hooks/useDismissingState";
 import { HandHeart } from "lucide-react";
+import { errorMessage } from "@/lib/utils";
+import type { Event } from "@/types";
 
 export default function DonatePage() {
   const { token } = useAuth();
-  const [events, setEvents] = useState<any[]>([]);
+  const [events, setEvents] = useState<Event[]>([]);
   const [eventId, setEventId] = useState<string>("");
   const [amount, setAmount] = useState<string>("");
   const [loading, setLoading] = useState(false);
@@ -17,14 +19,14 @@ export default function DonatePage() {
   useEffect(() => {
     (async () => {
       try {
-        const evs = await apiFetch<any[]>("/api/events");
+        const evs = await apiFetch<Event[]>("/api/events");
         setEvents(evs);
         if (evs.length > 0) setEventId(evs[0].id);
-      } catch (e: any) {
-        setError(e?.message || "Failed to load events");
+      } catch (e) {
+        setError(errorMessage(e) || "Failed to load events");
       }
     })();
-  }, []);
+  }, [setError]);
 
   const submit = async () => {
     if (!token) { setError("Please login"); return; }
@@ -49,8 +51,8 @@ export default function DonatePage() {
       });
       setInfo("Redirecting to payment...");
       window.location.href = res.redirectUrl;
-    } catch (e: any) {
-      setError(e?.message || "Failed to start donation checkout");
+    } catch (e) {
+      setError(errorMessage(e) || "Failed to start donation checkout");
     } finally {
       setLoading(false);
     }

frontend/src/app/dashboard/user/forms/page.tsx

@@ -1,13 +1,16 @@
 "use client";
+import { ExtraFieldInput, isExtraFieldType } from "@/components/shared/FormFieldExtras";
 import React, { Suspense, useEffect, useMemo, useState } from "react";
 import { useSearchParams, useRouter } from "next/navigation";
 import { useAuth } from "@/hooks/useAuth";
 import { apiFetch } from "@/lib/api";
 import { useDismissingState } from "@/hooks/useDismissingState";
 import { FileText } from "lucide-react";
+import { errorMessage } from "@/lib/utils";
+import type { Registration } from "@/types";
 
 // Types for form fields
-type FormField = { id: string; type: 'yes_no'|'text'|'date'|'numeric'|'statement'|'paragraph'; label: string; isRequired?: boolean; helpText?: string|null };
+type FormField = { id: string; type: 'yes_no'|'text'|'date'|'numeric'|'statement'|'paragraph'|'rating'|'multiple_choice'; label: string; isRequired?: boolean; helpText?: string|null; options?: unknown };
 
 function FormsContent() {
   const search = useSearchParams();
@@ -15,7 +18,7 @@ function FormsContent() {
   const { token } = useAuth();
   const registrationId = search.get("registrationId");
 
-  const [registration, setRegistration] = useState<any | null>(null);
+  const [registration, setRegistration] = useState<Registration | null>(null);
   const [eventForm, setEventForm] = useState<{ isRequired: boolean; fields: FormField[] } | null>(null);
   const [loading, setLoading] = useState(false);
   const [error, setError] = useDismissingState<string | null>(null);
@@ -31,22 +34,22 @@ function FormsContent() {
       setError(null);
       setInfo(null);
       try {
-        const reg = await apiFetch<any>(`/api/registrations/${encodeURIComponent(registrationId)}`, { authToken: token });
+        const reg = await apiFetch<Registration>(`/api/registrations/${encodeURIComponent(registrationId)}`, { authToken: token });
         setRegistration(reg);
-        const ev = await apiFetch<any>(`/api/events/${encodeURIComponent(reg.eventId)}`);
+        const ev = await apiFetch<{ form?: { isRequired: boolean; fields: FormField[] } | null }>(`/api/events/${encodeURIComponent(reg.eventId)}`);
         if (ev?.form) setEventForm(ev.form);
         // Load any saved draft
         try {
-          const draft = await apiFetch<any>(`/api/registrations/${encodeURIComponent(registrationId)}/forms/draft`, { authToken: token });
+          const draft = await apiFetch<{ data?: Record<number, Record<string, string>> } | null>(`/api/registrations/${encodeURIComponent(registrationId)}/forms/draft`, { authToken: token });
           if (draft && draft.data && typeof draft.data === 'object') setFormsData(draft.data);
         } catch {}
-      } catch (e: any) {
-        setError(e?.message || 'Failed to load registration');
+      } catch (e) {
+        setError(errorMessage(e) || 'Failed to load registration');
       } finally {
         setLoading(false);
       }
     })();
-  }, [token, registrationId]);
+  }, [token, registrationId, setError, setInfo]);
 
   const submittedCount = useMemo(() => {
     return (registration?.formResponses || []).length;
@@ -56,8 +59,8 @@ function FormsContent() {
     if (!registration) return 0;
     try {
       return (registration.registrationOptions || [])
-        .filter((ro: any) => ro.eventOption?.isMainTicket)
-        .reduce((s: number, ro: any) => s + (ro.quantity || 0), 0);
+        .filter((ro) => ro.eventOption?.isMainTicket)
+        .reduce((s, ro) => s + (ro.quantity || 0), 0);
     } catch {
       return 0;
     }
@@ -87,7 +90,7 @@ function FormsContent() {
     if (!token || !registrationId) return;
     try {
       setError(null); setInfo(null);
-      const payload: any[] = [];
+      const payload: { answers: Record<string, string> }[] = [];
       for (let i = 0; i < remaining; i++) {
         payload.push({ answers: formsData[i] || {} });
       }
@@ -102,13 +105,13 @@ function FormsContent() {
       });
       setInfo('Attendee forms submitted successfully.');
       // reload registration to reflect new responses
-      const reg = await apiFetch<any>(`/api/registrations/${encodeURIComponent(registrationId)}`, { authToken: token });
+      const reg = await apiFetch<Registration>(`/api/registrations/${encodeURIComponent(registrationId)}`, { authToken: token });
       setRegistration(reg);
       setFormsData({});
       // On success, redirect to the user dashbaord
       router.push('/dashboard/user');
-    } catch (e: any) {
-      setError(e?.message || 'Failed to submit forms');
+    } catch (e) {
+      setError(errorMessage(e) || 'Failed to submit forms');
     }
   };
 
@@ -122,8 +125,8 @@ function FormsContent() {
         body: { data: formsData }
       });
       setInfo('Draft saved. You can return later to finish.');
-    } catch (e: any) {
-      setError(e?.message || 'Failed to save draft');
+    } catch (e) {
+      setError(errorMessage(e) || 'Failed to save draft');
     }
   };
 
@@ -158,14 +161,14 @@ function FormsContent() {
         <div className="border rounded p-3 mb-4 bg-gray-50">
           <div className="text-sm font-medium mb-2">Submitted responses</div>
           <ul className="space-y-2">
-            {(registration.formResponses || []).map((resp: any, idx: number) => (
+            {(registration.formResponses || []).map((resp, idx) => (
               <li key={resp.id} className="bg-white border rounded p-2">
                 <div className="font-medium text-sm mb-1">Attendee {idx + 1}</div>
                 {(resp.answers || []).length === 0 ? (
                   <div className="text-xs text-gray-600">No answers recorded.</div>
                 ) : (
                   <ul className="text-xs list-disc pl-5 space-y-0.5">
-                    {resp.answers.map((a: any) => (
+                    {(resp.answers || []).map((a) => (
                       <li key={a.id}>
                         <span className="text-gray-600">{eventForm?.fields.find(f => f.id === a.fieldId)?.label || (`Field ${a.fieldId}`)}</span>: {a.value}
                       </li>
@@ -198,7 +201,9 @@ function FormsContent() {
                     ) : (
                       <>
                         <label className="block text-xs text-gray-600 mb-1">{f.label}{f.isRequired ? ' *' : ''}</label>
-                        {f.type === 'yes_no' ? (
+                        {isExtraFieldType(f.type) ? (
+                          <ExtraFieldInput field={f} idPrefix={`a${idx}`} value={formsData[idx]?.[f.id] || ''} onChange={v => setFormsData(prev => ({ ...prev, [idx]: { ...(prev[idx]||{}), [f.id]: v } }))} />
+                        ) : f.type === 'yes_no' ? (
                           <select className="border rounded px-2 py-1 text-sm" value={formsData[idx]?.[f.id] || ''} onChange={e => setFormsData(prev => ({ ...prev, [idx]: { ...(prev[idx]||{}), [f.id]: e.target.value } }))}>
                             <option value="">Select</option>
                             <option value="yes">Yes</option>

frontend/src/app/dashboard/user/page.tsx

@@ -12,16 +12,22 @@ import { AttendeesPanel } from "@/components/shared/AttendeesPanel";
 import { MyWaitlists } from "@/components/shared/MyWaitlists";
 import { TransferTicketModal, canOfferTransfer } from "@/components/shared/TransferTicketModal";
 import { ClipboardList, Calendar, Ticket, ChevronRight } from "lucide-react";
+import { errorMessage } from "@/lib/utils";
+import { registrationOptionUnitPrice } from "@/lib/pricing";
+import type { Event, EventOption, Payment, Registration, RegistrationOption, Ticket as TicketRecord } from "@/types";
 
 // Helper formatters
 const formatRand = (n: number) => `R ${n.toFixed(2)}`;
 const isFuture = (d: string | Date) => new Date(d).getTime() > Date.now();
-const isEventOver = (ev: any) =>
+type EventStatusFields = Pick<Event, "endDate" | "cashupStatus" | "isActive">;
+type Billing = { totalDue: number; totalPaid: number; outstanding: number; payments: Payment[] };
+
+const isEventOver = (ev: EventStatusFields | null | undefined) =>
   !!ev && ((ev.endDate && new Date(ev.endDate).getTime() < Date.now()) || ev.cashupStatus === 'closed');
 
 // Status badge for an event, shown wherever an event title is displayed on this page.
 // Precedence when more than one applies: Closed > Past > Inactive.
-function EventStatusBadge({ event }: { event: any }) {
+function EventStatusBadge({ event }: { event: EventStatusFields | null | undefined }) {
   if (!event) return null;
   let label: string | null = null;
   let className = '';
@@ -53,26 +59,26 @@ function RegistrationStatusBadge({ status }: { status: string }) {
 // Effective unit price for an event option (or one of its variants), early-bird aware.
 // Used by the registration editor, which works off raw /api/events/:id data rather than
 // a registration's priceSnapshot — mirrors the pricing logic in register/[eventId]/RegisterForm.tsx.
-function effectiveEventOptionUnitPrice(eo: any, variantId: string | null): number {
-  const variant = variantId ? (eo?.variants || []).find((v: any) => v.id === variantId) : null;
+function effectiveEventOptionUnitPrice(eo: EventOption, variantId: string | null): number {
+  const variant = variantId ? (eo?.variants || []).find((v) => v.id === variantId) : null;
   const base = (variant && variant.price !== null && variant.price !== undefined)
     ? Number(variant.price)
     : Number(eo?.price || 0);
   const allTiers = Array.isArray(eo?.earlyBirdTiers) ? eo.earlyBirdTiers : [];
-  const tiers = variantId ? allTiers.filter((t: any) => t.variantId === variantId) : allTiers.filter((t: any) => !t.variantId);
+  const tiers = variantId ? allTiers.filter((t) => t.variantId === variantId) : allTiers.filter((t) => !t.variantId);
   if (tiers.length === 0) return base;
   const now = new Date();
   const applicable = tiers
-    .map((t: any) => ({ ...t, _d: new Date(t.deadline) }))
-    .filter((t: any) => now < t._d)
-    .sort((a: any, b: any) => a.price - b.price || a._d.getTime() - b._d.getTime());
+    .map((t) => ({ ...t, _d: new Date(t.deadline) }))
+    .filter((t) => now < t._d)
+    .sort((a, b) => a.price - b.price || a._d.getTime() - b._d.getTime());
   return applicable.length > 0 ? applicable[0].price : base;
 }
 
 export default function UserDashboardPage() {
   const { token, user } = useAuth();
-  const [registrations, setRegistrations] = useState<any[]>([]);
-  const [tickets, setTickets] = useState<any[]>([]);
+  const [registrations, setRegistrations] = useState<Registration[]>([]);
+  const [tickets, setTickets] = useState<TicketRecord[]>([]);
   const [error, setError] = useDismissingState<string | null>(null);
   const [info, setInfo] = useDismissingState<string | null>(null);
   const [loading, setLoading] = useState<boolean>(false);
@@ -81,7 +87,7 @@ export default function UserDashboardPage() {
   const [showPast, setShowPast] = useState<boolean>(false);
 
   // Billing map: regId -> { totalDue, totalPaid, outstanding, payments }
-  const [billing, setBilling] = useState<Record<string, { totalDue: number; totalPaid: number; outstanding: number; payments: any[] }>>({});
+  const [billing, setBilling] = useState<Record<string, Billing>>({});
 
   // Forms status cache for registrations
   // regId -> { hasForm: boolean; isRequired?: boolean; submittedCount?: number; requiredCount?: number; complete?: boolean }
@@ -99,35 +105,6 @@ export default function UserDashboardPage() {
   // Track whether the active registration's event has attendee forms
   const [activeEventHasForm, setActiveEventHasForm] = useState<boolean | null>(null);
 
-  // Compute effective unit price for a registration option.
-  // Uses priceSnapshot when available (authoritative backend price, variant-aware).
-  // Falls back to deadline-only early-bird calculation for legacy rows without a snapshot.
-  const optionUnitPrice = (opt: any, referenceTime: any, atTime: Date): number => {
-    if (opt.priceSnapshot !== null && opt.priceSnapshot !== undefined) {
-      return Number(opt.priceSnapshot);
-    }
-    const eo = opt.eventOption;
-    const variantId: string | null = opt.variantId || null;
-    // Use variant price as base if available, otherwise option base
-    const base = (opt.variant?.price !== null && opt.variant?.price !== undefined)
-      ? Number(opt.variant.price)
-      : Number(eo?.price || 0);
-    const allTiers = Array.isArray(eo?.earlyBirdTiers) ? eo.earlyBirdTiers.slice() : [];
-    // Filter: variant options use only their variant-specific tiers; plain options use option-level tiers
-    const tiers = variantId
-      ? allTiers.filter((t: any) => t.variantId === variantId)
-      : allTiers.filter((t: any) => !t.variantId);
-    if (tiers.length === 0) return base;
-    const t = atTime ? new Date(atTime) : new Date();
-    const ref = referenceTime ? new Date(referenceTime) : t;
-    const applicable = tiers
-      .map((x: any) => ({ ...x, deadline: new Date(x.deadline) }))
-      .filter((x: any) => (ref < x.deadline) && (t < x.deadline))
-      .sort((a: any, b: any) => a.deadline.getTime() - b.deadline.getTime() || (a.order||0) - (b.order||0) || a.price - b.price);
-    if (applicable.length === 0) return base;
-    const price = Number(applicable[0].price);
-    return (price >= 0) ? price : base;
-  };
 
   useEffect(() => {
     (async () => {
@@ -139,29 +116,29 @@ export default function UserDashboardPage() {
         // waterfalling — this was previously fetched only after registrations + all
         // their payments had already resolved.
         const [myRegs, myTicks] = await Promise.all([
-          apiFetch<any[]>(`/api/registrations/myregistrations?showPast=${showPast ? '1' : '0'}`, { authToken: token }),
-          apiFetch<any[]>("/api/tickets/mytickets", { authToken: token }),
+          apiFetch<Registration[]>(`/api/registrations/myregistrations?showPast=${showPast ? '1' : '0'}`, { authToken: token }),
+          apiFetch<TicketRecord[]>("/api/tickets/mytickets", { authToken: token }),
         ]);
         setRegistrations(myRegs);
         setTickets(myTicks);
 
         // Use the backend's tranche-aware totalDueComputed (exact even when a line spans
         // multiple early-bird prices) rather than re-deriving from priceSnapshot client-side.
-        const totals: Record<string, { totalDue: number; totalPaid: number; outstanding: number; payments: any[] }> = {};
+        const totals: Record<string, Billing> = {};
         for (const r of myRegs) {
-          const totalDue = r.totalDueComputed ?? (r.registrationOptions || []).reduce((sum: number, opt: any) => sum + optionUnitPrice(opt, null, new Date()) * (opt.quantity || 0), 0);
+          const totalDue = r.totalDueComputed ?? (r.registrationOptions || []).reduce((sum, opt) => sum + registrationOptionUnitPrice(opt, null, new Date()) * (opt.quantity || 0), 0);
           totals[r.id] = { totalDue, totalPaid: 0, outstanding: totalDue, payments: [] };
         }
         setBilling(totals);
 
         // Fetch payments per registration to compute outstanding
         await Promise.all(
-          myRegs.map(async (r: any) => {
+          myRegs.map(async (r) => {
             try {
-              const pays = await apiFetch<any[]>(`/api/payments/registration/${encodeURIComponent(r.id)}`, { authToken: token });
+              const pays = await apiFetch<Payment[]>(`/api/payments/registration/${encodeURIComponent(r.id)}`, { authToken: token });
               const totalPaid = pays.reduce((s, p) => s + (p.amount || 0), 0);
               // totalDueComputed is not time-dependent, no need to recompute per payment time
-              const totalDue = r.totalDueComputed ?? (r.registrationOptions || []).reduce((sum: number, opt: any) => sum + optionUnitPrice(opt, null, new Date()) * (opt.quantity || 0), 0);
+              const totalDue = r.totalDueComputed ?? (r.registrationOptions || []).reduce((sum, opt) => sum + registrationOptionUnitPrice(opt, null, new Date()) * (opt.quantity || 0), 0);
               const outstanding = Math.max(0, totalDue - totalPaid);
               setBilling(prev => ({
                 ...prev,
@@ -178,13 +155,13 @@ export default function UserDashboardPage() {
             }
           })
         );
-      } catch (e: any) {
-        setError(e?.message || "Failed to load data");
+      } catch (e) {
+        setError(errorMessage(e) || "Failed to load data");
       } finally {
         setLoading(false);
       }
     })();
-  }, [token, showPast]);
+  }, [token, showPast, setError]);
 
   // After registrations load, compute forms status for each registration.
   // `myregistrations` now embeds event.form (with fields) directly, so this no longer
@@ -195,7 +172,7 @@ export default function UserDashboardPage() {
       if (!token || registrations.length === 0) return;
       const next: Record<string, { hasForm: boolean; isRequired?: boolean; submittedCount?: number; requiredCount?: number; complete?: boolean }> = {};
       await Promise.all(
-        registrations.map(async (r: any) => {
+        registrations.map(async (r) => {
           try {
             const ev = r.event;
             const hasForm = !!(ev?.form && Array.isArray(ev.form.fields) && ev.form.fields.length > 0);
@@ -204,12 +181,12 @@ export default function UserDashboardPage() {
               return;
             }
             // Load registration to get number of submitted responses
-            const regFull = await apiFetch<any>(`/api/registrations/${encodeURIComponent(r.id)}`, { authToken: token });
+            const regFull = await apiFetch<Registration>(`/api/registrations/${encodeURIComponent(r.id)}`, { authToken: token });
             const submittedCount = (regFull?.formResponses || []).length;
             // Required count equals the number of main tickets purchased
             const requiredCount = (r.registrationOptions || [])
-              .filter((ro: any) => ro.eventOption?.isMainTicket)
-              .reduce((s: number, ro: any) => s + (ro.quantity || 0), 0);
+              .filter((ro) => ro.eventOption?.isMainTicket)
+              .reduce((s, ro) => s + (ro.quantity || 0), 0);
             const complete = submittedCount >= requiredCount && requiredCount > 0 ? true : (submittedCount >= requiredCount);
             next[r.id] = {
               hasForm: true,
@@ -218,7 +195,7 @@ export default function UserDashboardPage() {
               requiredCount,
               complete,
             };
-          } catch (e) {
+          } catch {
             // On any error, do not show forms status to avoid noisy UI
             next[r.id] = { hasForm: false };
           }
@@ -245,16 +222,16 @@ export default function UserDashboardPage() {
     // Open loading dialog immediately
     setDialog({ open: true, message: "Sending tickets…", loading: true });
     try {
-      const res: any = await apiFetch("/api/tickets/email", {
+      const res = await apiFetch<{ message?: string }>("/api/tickets/email", {
         method: "POST",
         body: { ticketIds },
         authToken: token,
       });
       const msg = (res && res.message) ? res.message : `${ticketIds.length} ticket(s) emailed successfully.`;
       setDialog({ open: true, message: msg, loading: false });
-    } catch (e: any) {
+    } catch (e) {
       setDialog({ open: false, message: "", loading: false });
-      setError(e?.message || "Failed to email tickets");
+      setError(errorMessage(e) || "Failed to email tickets");
     }
   };
 
@@ -265,16 +242,16 @@ export default function UserDashboardPage() {
     setInfo(null);
     setDialog({ open: true, message: "Sending to WhatsApp…", loading: true });
     try {
-      const res: any = await apiFetch("/api/tickets/email", {
+      const res = await apiFetch<{ message?: string }>("/api/tickets/email", {
         method: "POST",
         body: { ticketIds, channel: "whatsapp" },
         authToken: token,
       });
       const msg = (res && res.message) ? res.message : `${ticketIds.length} ticket(s) sent to WhatsApp.`;
       setDialog({ open: true, message: msg, loading: false });
-    } catch (e: any) {
+    } catch (e) {
       setDialog({ open: false, message: "", loading: false });
-      setError(e?.message || "Failed to send tickets to WhatsApp");
+      setError(errorMessage(e) || "Failed to send tickets to WhatsApp");
     }
   };
 
@@ -288,15 +265,15 @@ export default function UserDashboardPage() {
       loadingSubtitle: "Please wait while we prepare your invoice.",
     });
     try {
-      const res: any = await apiFetch(`/api/registrations/${encodeURIComponent(registrationId)}/send-invoice`, {
+      const res = await apiFetch<{ message?: string }>(`/api/registrations/${encodeURIComponent(registrationId)}/send-invoice`, {
         method: "POST",
         body: { channel },
         authToken: token,
       });
       setDialog({ open: true, loading: false, title: "Invoice sent", message: (res && res.message) || "Invoice sent." });
-    } catch (e: any) {
+    } catch (e) {
       setDialog({ open: false, message: "", loading: false });
-      setError(e?.message || "Failed to send invoice");
+      setError(errorMessage(e) || "Failed to send invoice");
     }
   };
 
@@ -310,15 +287,15 @@ export default function UserDashboardPage() {
       loadingSubtitle: "Please wait while we prepare your receipt.",
     });
     try {
-      const res: any = await apiFetch(`/api/payments/${encodeURIComponent(paymentId)}/send-receipt`, {
+      const res = await apiFetch<{ message?: string }>(`/api/payments/${encodeURIComponent(paymentId)}/send-receipt`, {
         method: "POST",
         body: { channel },
         authToken: token,
       });
       setDialog({ open: true, loading: false, title: "Receipt sent", message: (res && res.message) || "Receipt sent." });
-    } catch (e: any) {
+    } catch (e) {
       setDialog({ open: false, message: "", loading: false });
-      setError(e?.message || "Failed to send receipt");
+      setError(errorMessage(e) || "Failed to send receipt");
     }
   };
 
@@ -347,10 +324,10 @@ export default function UserDashboardPage() {
         // Refresh this registration's billing so the displayed outstanding reflects the new price
         try {
           const now = new Date();
-          const r = await apiFetch<any>(`/api/registrations/${encodeURIComponent(registrationId)}`, { authToken: token });
-          const pays = await apiFetch<any[]>(`/api/payments/registration/${encodeURIComponent(registrationId)}`, { authToken: token });
+          const r = await apiFetch<Registration>(`/api/registrations/${encodeURIComponent(registrationId)}`, { authToken: token });
+          const pays = await apiFetch<Payment[]>(`/api/payments/registration/${encodeURIComponent(registrationId)}`, { authToken: token });
           const totalPaid = pays.reduce((s, p) => s + (p.amount || 0), 0);
-          const totalDue = (r.registrationOptions || []).reduce((sum: number, opt: any) => sum + optionUnitPrice(opt, null, now) * (opt.quantity || 0), 0);
+          const totalDue = (r.registrationOptions || []).reduce((sum, opt) => sum + registrationOptionUnitPrice(opt, null, now) * (opt.quantity || 0), 0);
           setBilling(prev => ({ ...prev, [registrationId]: { totalDue, totalPaid, outstanding: Math.max(0, totalDue - totalPaid), payments: pays } }));
         } catch {}
         return;
@@ -361,14 +338,14 @@ export default function UserDashboardPage() {
         return;
       }
       window.location.href = res.redirectUrl;
-    } catch (e: any) {
+    } catch (e) {
       setDialog({ open: false, message: "", loading: false });
-      setError(e?.message || "Failed to create checkout");
+      setError(errorMessage(e) || "Failed to create checkout");
     }
   };
 
   // Print helpers
-  const buildTicketHtmlCard = (t: any, buyerName?: string) => {
+  const buildTicketHtmlCard = (t: TicketRecord, buyerName?: string) => {
     const eventTitle = t.event?.title || t.eventId || "Event";
     const eventDate = t.event?.startDate ? new Date(t.event.startDate) : null;
     const optionName = t.registrationOption?.eventOption?.name || "Ticket";
@@ -439,7 +416,7 @@ export default function UserDashboardPage() {
     w.focus();
   };
 
-  const printTickets = (ticketList: any[]) => {
+  const printTickets = (ticketList: TicketRecord[]) => {
     if (!ticketList || ticketList.length === 0) return;
     const cards = ticketList.map(t => buildTicketHtmlCard(t, user?.name)).join("");
     openPrintWindow(`Tickets (${ticketList.length})`, cards);
@@ -447,7 +424,7 @@ export default function UserDashboardPage() {
 
   // Upcoming events derived from registrations
   const upcomingEvents = useMemo(() => {
-    const map = new Map<string, any>();
+    const map = new Map<string, Event>();
     for (const r of registrations) {
       if (r.event && isFuture(r.event.startDate)) {
         if (!map.has(r.event.id)) map.set(r.event.id, r.event);
@@ -456,16 +433,6 @@ export default function UserDashboardPage() {
     return Array.from(map.values()).sort((a, b) => new Date(a.startDate).getTime() - new Date(b.startDate).getTime());
   }, [registrations]);
 
-  // Tickets by grouping
-  const ticketsByEvent = useMemo(() => {
-    const m: Record<string, any[]> = {};
-    for (const t of tickets) {
-      const eid = t.eventId;
-      if (!m[eid]) m[eid] = [];
-      m[eid].push(t);
-    }
-    return m;
-  }, [tickets]);
 
   // Registration click -> open modal
   const activeReg = useMemo(() => registrations.find(r => r.id === activeRegId) || null, [registrations, activeRegId]);
@@ -484,7 +451,7 @@ export default function UserDashboardPage() {
     }
     (async () => {
       try {
-        const ev = await apiFetch<any>(`/api/events/${encodeURIComponent(ar.eventId)}`);
+        const ev = await apiFetch<Event>(`/api/events/${encodeURIComponent(ar.eventId)}`);
         const has = !!(ev?.form && Array.isArray(ev.form.fields) && ev.form.fields.length > 0);
         setActiveEventHasForm(has);
       } catch {
@@ -515,35 +482,35 @@ export default function UserDashboardPage() {
         authToken: token,
         body: { code: codeInput.trim() },
       });
-      const myRegs = await apiFetch<any[]>(`/api/registrations/myregistrations?showPast=${showPast ? '1' : '0'}`, { authToken: token });
+      const myRegs = await apiFetch<Registration[]>(`/api/registrations/myregistrations?showPast=${showPast ? '1' : '0'}`, { authToken: token });
       setRegistrations(myRegs);
       const updated = myRegs.find(r => r.id === activeRegId);
-      const pays = await apiFetch<any[]>(`/api/payments/registration/${encodeURIComponent(activeRegId)}`, { authToken: token });
+      const pays = await apiFetch<Payment[]>(`/api/payments/registration/${encodeURIComponent(activeRegId)}`, { authToken: token });
       const totalPaid = pays.reduce((s, p) => s + (p.amount || 0), 0);
       const totalDue = updated?.totalDueComputed ?? 0;
       setBilling(prev => ({ ...prev, [activeRegId]: { totalDue, totalPaid, outstanding: Math.max(0, totalDue - totalPaid), payments: pays } }));
       try {
-        const myTicks = await apiFetch<any[]>("/api/tickets/mytickets", { authToken: token });
+        const myTicks = await apiFetch<TicketRecord[]>("/api/tickets/mytickets", { authToken: token });
         setTickets(myTicks);
       } catch {}
       setCodeInput("");
       setInfo(res?.message || 'Code applied.');
-    } catch (e: any) {
-      setCodeError(e?.message || "Couldn't apply that code");
+    } catch (e) {
+      setCodeError(errorMessage(e) || "Couldn't apply that code");
     } finally {
       setCodeBusy(false);
     }
   };
 
-  const [transferTarget, setTransferTarget] = useState<any | null>(null);
+  const [transferTarget, setTransferTarget] = useState<TicketRecord | null>(null);
 
   // Re-fetch registrations and tickets after something on one changes (attendee names).
   const reloadAfterAttendees = async () => {
     if (!token) return;
     try {
-      const myRegs = await apiFetch<any[]>(`/api/registrations/myregistrations?showPast=${showPast ? '1' : '0'}`, { authToken: token });
+      const myRegs = await apiFetch<Registration[]>(`/api/registrations/myregistrations?showPast=${showPast ? '1' : '0'}`, { authToken: token });
       setRegistrations(myRegs);
-      const myTicks = await apiFetch<any[]>("/api/tickets/mytickets", { authToken: token });
+      const myTicks = await apiFetch<TicketRecord[]>("/api/tickets/mytickets", { authToken: token });
       setTickets(myTicks);
     } catch {}
   };
@@ -560,13 +527,13 @@ export default function UserDashboardPage() {
         method: 'DELETE',
         authToken: token,
       });
-      const myRegs = await apiFetch<any[]>(`/api/registrations/myregistrations?showPast=${showPast ? '1' : '0'}`, { authToken: token });
+      const myRegs = await apiFetch<Registration[]>(`/api/registrations/myregistrations?showPast=${showPast ? '1' : '0'}`, { authToken: token });
       setRegistrations(myRegs);
       setActiveRegId(null);
       setShowCancelConfirm(false);
       setInfo('Registration cancelled.');
-    } catch (e: any) {
-      setError(e?.message || 'Failed to cancel registration');
+    } catch (e) {
+      setError(errorMessage(e) || 'Failed to cancel registration');
       setShowCancelConfirm(false);
     } finally {
       setCancelLoading(false);
@@ -577,7 +544,7 @@ export default function UserDashboardPage() {
   // "eventOptionId" for plain options, "eventOptionId:variantId" for variant options.
   const [editMode, setEditMode] = useState<boolean>(false);
   const [editLoading, setEditLoading] = useState<boolean>(false);
-  const [editEventOptions, setEditEventOptions] = useState<any[]>([]);
+  const [editEventOptions, setEditEventOptions] = useState<EventOption[]>([]);
   const [editQuantities, setEditQuantities] = useState<Record<string, number>>({});
   const [editBaseQty, setEditBaseQty] = useState<Record<string, number>>({});
   const [editMinQty, setEditMinQty] = useState<Record<string, number>>({});
@@ -591,9 +558,9 @@ export default function UserDashboardPage() {
   }, [activeReg]);
 
   const editTotal = useMemo(() => {
-    return editEventOptions.reduce((sum: number, eo: any) => {
+    return editEventOptions.reduce((sum, eo) => {
       if (Array.isArray(eo.variants) && eo.variants.length > 0) {
-        return sum + eo.variants.reduce((vsum: number, v: any) => {
+        return sum + eo.variants.reduce((vsum, v) => {
           const qty = editQuantities[`${eo.id}:${v.id}`] || 0;
           return vsum + qty * effectiveEventOptionUnitPrice(eo, v.id);
         }, 0);
@@ -608,10 +575,10 @@ export default function UserDashboardPage() {
     setEditLoading(true);
     try {
       // Load event options (with variants) for this event
-      const eventData = await apiFetch<any>(`/api/events/${encodeURIComponent(activeReg.eventId)}`);
-      const eventOptions = (eventData?.eventOptions || []) as any[];
+      const eventData = await apiFetch<Event>(`/api/events/${encodeURIComponent(activeReg.eventId)}`);
+      const eventOptions = eventData?.eventOptions || [];
 
-      const regOptById = new Map<string, any>((activeReg.registrationOptions || []).map((o: any) => [o.id, o]));
+      const regOptById = new Map<string, RegistrationOption>((activeReg.registrationOptions || []).map((o) => [o.id, o]));
 
       // Prefill quantities from the current registration
       const qtyMap: Record<string, number> = {};
@@ -624,16 +591,16 @@ export default function UserDashboardPage() {
       // (tickets are never deleted or shrunk, only ever grown, once paid).
       const minQtyMap: Record<string, number> = {};
       for (const t of tickets) {
-        const ro = regOptById.get(t.registrationOptionId);
+        const ro = t.registrationOptionId ? regOptById.get(t.registrationOptionId) : undefined;
         if (!ro) continue;
         const key = ro.variantId ? `${ro.eventOptionId}:${ro.variantId}` : ro.eventOptionId;
         minQtyMap[key] = (minQtyMap[key] || 0) + (t.quantity || 0);
       }
 
       // Ensure every option/variant has a (possibly zero) entry so they all render
-      eventOptions.forEach((eo: any) => {
+      eventOptions.forEach((eo) => {
         if (Array.isArray(eo.variants) && eo.variants.length > 0) {
-          eo.variants.forEach((v: any) => {
+          eo.variants.forEach((v) => {
             const key = `${eo.id}:${v.id}`;
             if (!(key in qtyMap)) qtyMap[key] = 0;
           });
@@ -648,7 +615,7 @@ export default function UserDashboardPage() {
       setEditMinQty(minQtyMap);
       setEditMode(true);
     } catch (e) {
-      setEditError((e as any)?.message || 'Failed to load event options');
+      setEditError(errorMessage(e) || 'Failed to load event options');
     } finally {
       setEditLoading(false);
     }
@@ -662,8 +629,8 @@ export default function UserDashboardPage() {
       if (minQty <= 0) continue;
       if ((editQuantities[key] || 0) < minQty) {
         const [eventOptionId, variantId] = key.includes(':') ? key.split(':') : [key, undefined];
-        const eo = editEventOptions.find((o: any) => o.id === eventOptionId);
-        const variant = variantId ? (eo?.variants || []).find((v: any) => v.id === variantId) : null;
+        const eo = editEventOptions.find((o) => o.id === eventOptionId);
+        const variant = variantId ? (eo?.variants || []).find((v) => v.id === variantId) : null;
         const label = variant ? `${eo?.name || 'item'} (${variant.name})` : (eo?.name || 'item');
         setEditError(`Cannot reduce "${label}" below the ${minQty} already issued`);
         return;
@@ -698,22 +665,22 @@ export default function UserDashboardPage() {
         body: { options: payloadOptions },
       });
       // Reload registrations to reflect changes
-      const myRegs = await apiFetch<any[]>(`/api/registrations/myregistrations?showPast=${showPast ? '1' : '0'}`, { authToken: token });
+      const myRegs = await apiFetch<Registration[]>(`/api/registrations/myregistrations?showPast=${showPast ? '1' : '0'}`, { authToken: token });
       setRegistrations(myRegs);
       try {
-        const myTicks = await apiFetch<any[]>("/api/tickets/mytickets", { authToken: token });
+        const myTicks = await apiFetch<TicketRecord[]>("/api/tickets/mytickets", { authToken: token });
         setTickets(myTicks);
       } catch {}
       // Recompute billing totals using the backend's tranche-aware totalDueComputed
-      const totals: Record<string, { totalDue: number; totalPaid: number; outstanding: number; payments: any[] }> = {};
+      const totals: Record<string, Billing> = {};
       for (const r of myRegs) {
-        const totalDue = r.totalDueComputed ?? (r.registrationOptions || []).reduce((sum: number, opt: any) => sum + optionUnitPrice(opt, null, new Date()) * (opt.quantity || 0), 0);
+        const totalDue = r.totalDueComputed ?? (r.registrationOptions || []).reduce((sum, opt) => sum + registrationOptionUnitPrice(opt, null, new Date()) * (opt.quantity || 0), 0);
         totals[r.id] = { totalDue, totalPaid: 0, outstanding: totalDue, payments: [] };
       }
       setBilling(totals);
       // Payments will be refreshed lazily or on next open; fetch for this one immediately
       try {
-        const pays = await apiFetch<any[]>(`/api/payments/registration/${encodeURIComponent(activeReg.id)}`, { authToken: token });
+        const pays = await apiFetch<Payment[]>(`/api/payments/registration/${encodeURIComponent(activeReg.id)}`, { authToken: token });
         const totalPaid = pays.reduce((s, p) => s + (p.amount || 0), 0);
         const totalDue = totals[activeReg.id]?.totalDue ?? 0;
         setBilling(prev => ({
@@ -728,8 +695,8 @@ export default function UserDashboardPage() {
       } catch {}
       setInfo('Registration updated successfully');
       setEditMode(false);
-    } catch (e: any) {
-      setEditError(e?.message || 'Failed to update registration');
+    } catch (e) {
+      setEditError(errorMessage(e) || 'Failed to update registration');
     } finally {
       setLoading(false);
     }
@@ -787,9 +754,9 @@ export default function UserDashboardPage() {
           <ul className="space-y-2">
             {registrations
               // Hide cancelled always; hide past unless showPast
-              .filter((r: any) => r.status !== 'cancelled')
-              .filter((r: any) => showPast || !isEventOver(r.event))
-              .map((r: any) => {
+              .filter((r) => r.status !== 'cancelled')
+              .filter((r) => showPast || !isEventOver(r.event))
+              .map((r) => {
                 const bill = billing[r.id];
                 const isCancelled = r.status === 'cancelled';
                 const outstanding = isCancelled ? 0 : (bill?.outstanding ?? 0);
@@ -829,18 +796,18 @@ export default function UserDashboardPage() {
                         {(() => {
                           if (r.status == 'paid') return null;
                           // Early-bird notice: only for events with tiers that haven't passed
-                          const allTiers = (r.registrationOptions || []).flatMap((ro: any) => Array.isArray(ro.eventOption?.earlyBirdTiers) ? ro.eventOption.earlyBirdTiers : []);
+                          const allTiers = (r.registrationOptions || []).flatMap((ro) => Array.isArray(ro.eventOption?.earlyBirdTiers) ? ro.eventOption.earlyBirdTiers : []);
                           const upcoming = allTiers
-                            .map((t: any) => ({ ...t, deadline: new Date(t.deadline) }))
-                            .filter((t: any) => new Date() < t.deadline)
-                            .sort((a: any, b: any) => a.deadline.getTime() - b.deadline.getTime());
+                            .map((t) => ({ ...t, deadline: new Date(t.deadline) }))
+                            .filter((t) => new Date() < t.deadline)
+                            .sort((a, b) => a.deadline.getTime() - b.deadline.getTime());
                           if (upcoming.length === 0) return null;
                           const nextDeadline = upcoming[0].deadline;
                           const pays = (billing[r.id]?.payments || []);
-                          const lastPaymentAt = pays.length > 0 ? new Date(Math.max(...pays.map((p: any) => new Date(p.createdAt).getTime()))) : null;
+                          const lastPaymentAt = pays.length > 0 ? new Date(Math.max(...pays.map((p) => new Date(p.createdAt).getTime()))) : null;
                           const now = new Date();
-                          const priceNow = (r.registrationOptions || []).reduce((s: number, ro: any) => s + optionUnitPrice(ro, lastPaymentAt, now) * (ro.quantity || 0), 0);
-                          const afterPrice = (r.registrationOptions || []).reduce((s: number, ro: any) => s + optionUnitPrice(ro, lastPaymentAt, new Date(nextDeadline.getTime() + 1000)) * (ro.quantity || 0), 0);
+                          const priceNow = (r.registrationOptions || []).reduce((s, ro) => s + registrationOptionUnitPrice(ro, lastPaymentAt, now) * (ro.quantity || 0), 0);
+                          const afterPrice = (r.registrationOptions || []).reduce((s, ro) => s + registrationOptionUnitPrice(ro, lastPaymentAt, new Date(nextDeadline.getTime() + 1000)) * (ro.quantity || 0), 0);
                           const dateStr = nextDeadline.toLocaleDateString(undefined, { year: 'numeric', month: 'short', day: '2-digit' });
                           if (afterPrice > priceNow) {
                             return (
@@ -971,8 +938,8 @@ export default function UserDashboardPage() {
         ) : (
           <ul className="grid sm:grid-cols-2 gap-3">
             {tickets
-                        .filter((t: any) => showPast || !isEventOver(t.event))
-                        .map((t: any) => {
+                        .filter((t) => showPast || !isEventOver(t.event))
+                        .map((t) => {
               const eventDate = t.event?.startDate ? new Date(t.event.startDate) : null;
               const optionName = t.registrationOption?.eventOption?.name || "Ticket";
               const variantName = t.registrationOption?.variant?.name;
@@ -995,6 +962,11 @@ export default function UserDashboardPage() {
                   <div className="text-xs font-medium text-blue-700 bg-blue-50 rounded px-2 py-0.5 inline-block">
                     {t.attendee?.name ? <>For: {t.attendee.name}</> : <>Qty: {t.quantity || 1}</>}
                   </div>
+                  {(t.attendee?.allocations || []).length > 0 && (
+                    <div className="text-xs text-violet-800 bg-violet-50 rounded px-2 py-0.5 inline-block ml-1">
+                      {[...(t.attendee?.allocations || [])].sort((a, b) => (a.set?.order || 0) - (b.set?.order || 0)).map((a) => `${a.set.name}: ${a.group.name}`).join(" · ")}
+                    </div>
+                  )}
                   {t.userId && user?.id && t.userId !== user.id && t.user?.name && (
                     <div className="text-xs text-gray-500">Booked by {t.user.name}</div>
                   )}
@@ -1006,6 +978,18 @@ export default function UserDashboardPage() {
                       <button onClick={() => whatsappTickets([t.id])} className="px-3 py-1.5 text-sm bg-green-600 text-white rounded hover:bg-green-700 shadow-sm focus:outline-none focus:ring-2 focus:ring-green-500 focus:ring-offset-1">WhatsApp</button>
                     )}
                     <button onClick={() => printTickets([t])} className="px-3 py-1.5 text-sm rounded bg-gray-100 hover:bg-gray-200 text-gray-800 shadow-sm focus:outline-none focus:ring-2 focus:ring-blue-500 focus:ring-offset-1">Print</button>
+                    {(t.transferRequests || [])[0] && (
+                      <span className="w-full text-xs text-violet-800 bg-violet-50 rounded px-2 py-1 flex items-center justify-between gap-2">
+                        <span>Waiting for {t.transferRequests?.[0]?.toName} to accept</span>
+                        <button className="underline" onClick={async () => {
+                          try {
+                            const r = await apiFetch<{ message?: string }>(`/api/tickets/${t.id}/transfer`, { method: "DELETE", authToken: token! });
+                            setInfo(r?.message || "Transfer cancelled");
+                            reloadAfterAttendees();
+                          } catch (e) { setError(errorMessage(e) || "Couldn't cancel"); }
+                        }}>Cancel</button>
+                      </span>
+                    )}
                     {canOfferTransfer(t, t.event) && (
                       <button onClick={() => setTransferTarget(t)} className="px-3 py-1.5 text-sm rounded border border-gray-300 hover:bg-gray-100 text-gray-800 shadow-sm focus:outline-none focus:ring-2 focus:ring-blue-500 focus:ring-offset-1" title="Give this ticket to someone else">Transfer</button>
                     )}
@@ -1063,7 +1047,7 @@ export default function UserDashboardPage() {
                   // early-bird rows separately from standard-price rows so repeat purchases
                   // of the same item don't show as a wall of near-duplicate lines.
                   const rows: { key: string; label: string; quantity: number; unitPrice: number; isEarlyBird: boolean }[] = [];
-                  (activeReg.registrationOptions || []).forEach((opt: any) => {
+                  (activeReg.registrationOptions || []).forEach((opt) => {
                     const variantLabel = opt.variant?.name ? ` (${opt.variant.name})` : '';
                     const label = `${opt.eventOption?.name || ''}${variantLabel}`;
                     const tranches = Array.isArray(opt.tranches) && opt.tranches.length > 0
@@ -1075,7 +1059,7 @@ export default function UserDashboardPage() {
                             : (opt.variant?.price ?? opt.eventOption?.price ?? 0),
                           appliedTierId: opt.appliedTierId,
                         }];
-                    tranches.forEach((t: any) => {
+                    tranches.forEach((t) => {
                       const unitPrice = Number(t.priceSnapshot || 0);
                       const isEarlyBird = !!t.appliedTierId;
                       const key = `${label}__${isEarlyBird}__${unitPrice}`;
@@ -1146,7 +1130,7 @@ export default function UserDashboardPage() {
                     ) : (
                       <>
                         <div className="space-y-2">
-                          {editEventOptions.map((eo: any) => {
+                          {editEventOptions.map((eo) => {
                             const hasVariants = Array.isArray(eo.variants) && eo.variants.length > 0;
 
                             const renderQtyInput = (key: string, unitPrice: number, stockLimit?: number, availableCount?: number) => {
@@ -1171,12 +1155,12 @@ export default function UserDashboardPage() {
                             };
 
                             if (hasVariants) {
-                              const variants = eo.variants.slice().sort((a: any, b: any) => (a.order || 0) - (b.order || 0));
+                              const variants = (eo.variants || []).slice().sort((a, b) => (a.order || 0) - (b.order || 0));
                               return (
                                 <div key={eo.id} className="border rounded bg-white overflow-hidden">
                                   <div className="px-3 py-2 bg-gray-100 text-sm font-medium">{eo.name}</div>
                                   <ul className="divide-y">
-                                    {variants.map((v: any) => {
+                                    {variants.map((v) => {
                                       const key = `${eo.id}:${v.id}`;
                                       const minQty = editMinQty[key] || 0;
                                       const unitPrice = effectiveEventOptionUnitPrice(eo, v.id);
@@ -1254,7 +1238,7 @@ export default function UserDashboardPage() {
                 <div>
                   <div className="font-medium mb-1">Payments</div>
                   <ul className="text-sm space-y-1">
-                    {activeBill.payments.map((p: any) => (
+                    {activeBill.payments.map((p) => (
                       <li key={p.id} className="flex items-center justify-between gap-2 py-0.5">
                         <span>{new Date(p.createdAt).toLocaleString()} — {formatRand(p.amount)} ({formatPaymentMethod(p.method)})</span>
                         <button className="text-xs text-brand-700 hover:underline shrink-0" onClick={() => setChannelPicker({ kind: 'receipt', id: p.id })}>Receipt</button>
@@ -1281,8 +1265,8 @@ export default function UserDashboardPage() {
                   >Make payment</button>
                 )}
                 <button className="px-3 py-1.5 text-sm rounded bg-gray-100 hover:bg-gray-200 text-gray-800 shadow-sm focus:outline-none focus:ring-2 focus:ring-blue-500 focus:ring-offset-1" onClick={() => {
-                  const regOptIds = new Set((activeReg.registrationOptions || []).map((o: any) => o.id));
-                  const list = tickets.filter(t => regOptIds.has(t.registrationOptionId));
+                  const regOptIds = new Set((activeReg.registrationOptions || []).map((o) => o.id));
+                  const list = tickets.filter(t => !!t.registrationOptionId && regOptIds.has(t.registrationOptionId));
                   printTickets(list);
                 }}>Print all tickets</button>
               </div>

frontend/src/app/dashboard/user/payments/page.tsx

@@ -7,6 +7,8 @@ import { useDismissingState } from "@/hooks/useDismissingState";
 import { formatDateTime } from "@/lib/date";
 import { formatPaymentMethod } from "@/lib/paymentMethod";
 import { Receipt } from "lucide-react";
+import { errorMessage } from "@/lib/utils";
+import type { Paginated } from "@/types";
 
 interface PaymentItem {
   id: string;
@@ -49,14 +51,14 @@ export default function UserPaymentsPage() {
     setInfo(null);
     setSendingReceipt(true);
     try {
-      const res: any = await apiFetch<any>(`/api/payments/${encodeURIComponent(paymentId)}/send-receipt`, {
+      const res = await apiFetch<{ message?: string }>(`/api/payments/${encodeURIComponent(paymentId)}/send-receipt`, {
         method: "POST",
         body: { channel },
         authToken: token,
       });
       setInfo((res && res.message) || "Receipt sent.");
-    } catch (e: any) {
-      setError(e?.message || "Failed to send receipt");
+    } catch (e) {
+      setError(errorMessage(e) || "Failed to send receipt");
     } finally {
       setSendingReceipt(false);
     }
@@ -82,19 +84,20 @@ export default function UserPaymentsPage() {
     setError(null);
     setFetching(true);
     try {
-      const res = await apiFetch<any>(buildQuery(p), { authToken: token });
+      const res = await apiFetch<Paginated<PaymentItem>>(buildQuery(p), { authToken: token });
       setPayments(Array.isArray(res?.data) ? res.data : []);
       setTotal(res?.total ?? 0);
       setTotalPages(res?.pages ?? 1);
       setPage(p);
-    } catch (e: any) {
-      setError(e?.message || "Failed to load payments");
+    } catch (e) {
+      setError(errorMessage(e) || "Failed to load payments");
     } finally {
       setFetching(false);
     }
-  }, [token, buildQuery]);
+  }, [token, buildQuery, setError]);
 
-  useEffect(() => { if (token) loadPayments(1); }, [token, startDate, endDate, method, kind]);
+  // loadPayments changes whenever a filter does (via buildQuery), so this refetches page 1 on filter changes.
+  useEffect(() => { if (token) loadPayments(1); }, [token, loadPayments]);
 
   const goToPage = (p: number) => loadPayments(p);
 
@@ -150,7 +153,7 @@ export default function UserPaymentsPage() {
           </div>
           <div>
             <label className="block text-xs text-gray-600 mb-1">Type</label>
-            <select className="border rounded px-2 py-1.5 text-sm" value={kind} onChange={e => setKind(e.target.value as any)}>
+            <select className="border rounded px-2 py-1.5 text-sm" value={kind} onChange={e => setKind(e.target.value as "" | "payment" | "refund")}>
               <option value="">Payments &amp; refunds</option>
               <option value="payment">Payments only</option>
               <option value="refund">Refunds only</option>

frontend/src/app/dashboard/user/profile/page.tsx

@@ -1,6 +1,6 @@
 "use client";
 
-import React, { useEffect, useState } from "react";
+import React, { useCallback, useEffect, useState } from "react";
 import { useAuth } from "@/hooks/useAuth";
 import { useRouter } from "next/navigation";
 import { apiFetch } from "@/lib/api";
@@ -8,6 +8,7 @@ import { isValidZAPhone } from "@/lib/phone";
 import { useDismissingState } from "@/hooks/useDismissingState";
 import { TwoFactorChallenge, TwoFactorMethod } from "@/lib/auth";
 import { User, Lock, ShieldAlert, ShieldCheck, ShieldOff, Trash2, Clock, LogIn, KeyRound, RotateCcw } from "lucide-react";
+import { errorMessage } from "@/lib/utils";
 
 type ActivityEvent = { id: string; type: "login" | "password_changed" | "password_reset" | "two_factor_enabled" | "two_factor_disabled"; device: string | null; createdAt: string };
 
@@ -54,7 +55,7 @@ export default function UserProfilePage() {
     setSavingProfile(true);
     setProfileMsg(null);
     try {
-      const res = await apiFetch<any>("/api/users/profile", {
+      const res = await apiFetch<{ token?: string }>("/api/users/profile", {
         method: "PUT",
         authToken: token,
         body: {
@@ -67,8 +68,8 @@ export default function UserProfilePage() {
       // Backend returns a refreshed token — save it so the session stays valid
       if (res?.token) updateToken(res.token);
       setProfileMsg({ type: "ok", text: "Profile updated." });
-    } catch (e: any) {
-      setProfileMsg({ type: "err", text: e?.message || "Failed to update profile." });
+    } catch (e) {
+      setProfileMsg({ type: "err", text: errorMessage(e) || "Failed to update profile." });
     } finally {
       setSavingProfile(false);
     }
@@ -95,7 +96,7 @@ export default function UserProfilePage() {
     setSavingPw(true);
     setPwMsg(null);
     try {
-      const res = await apiFetch<any>("/api/users/profile", {
+      const res = await apiFetch<{ token?: string }>("/api/users/profile", {
         method: "PUT",
         authToken: token,
         body: { currentPassword, password: newPassword },
@@ -106,8 +107,8 @@ export default function UserProfilePage() {
       setConfirmPassword("");
       setPwMsg({ type: "ok", text: "Password changed." });
       loadActivity();
-    } catch (e: any) {
-      setPwMsg({ type: "err", text: e?.message || "Failed to change password." });
+    } catch (e) {
+      setPwMsg({ type: "err", text: errorMessage(e) || "Failed to change password." });
     } finally {
       setSavingPw(false);
     }
@@ -123,7 +124,7 @@ export default function UserProfilePage() {
     setRevoking(true);
     setRevokeMsg(null);
     try {
-      const res = await apiFetch<any>("/api/users/revoke-sessions", {
+      const res = await apiFetch<{ token?: string; message?: string }>("/api/users/revoke-sessions", {
         method: "POST",
         authToken: token,
       });
@@ -131,8 +132,8 @@ export default function UserProfilePage() {
       // save the freshly issued one so this device stays signed in.
       if (res?.token) updateToken(res.token);
       setRevokeMsg({ type: "ok", text: res?.message || "All other sessions signed out." });
-    } catch (e: any) {
-      setRevokeMsg({ type: "err", text: e?.message || "Failed to revoke sessions." });
+    } catch (e) {
+      setRevokeMsg({ type: "err", text: errorMessage(e) || "Failed to revoke sessions." });
     } finally {
       setRevoking(false);
     }
@@ -142,20 +143,20 @@ export default function UserProfilePage() {
   const [activity, setActivity] = useState<ActivityEvent[]>([]);
   const [loadingActivity, setLoadingActivity] = useState(false);
 
-  const loadActivity = async () => {
+  const loadActivity = useCallback(async () => {
     if (!token) return;
     setLoadingActivity(true);
     try {
       const res = await apiFetch<ActivityEvent[]>("/api/users/activity", { authToken: token });
       setActivity(Array.isArray(res) ? res : []);
-    } catch (e) {
+    } catch {
       // Non-critical — just leave the list empty rather than showing an error banner.
     } finally {
       setLoadingActivity(false);
     }
-  };
+  }, [token]);
 
-  useEffect(() => { loadActivity(); }, [token]);
+  useEffect(() => { loadActivity(); }, [loadActivity]);
 
   // ── Two-factor authentication ─────────────────────────────────────────────
   // Mirrors the saved account state locally: the auth context's `user` is only
@@ -203,8 +204,8 @@ export default function UserProfilePage() {
       setTfCode("");
       setTfPassword("");
       setTfStep("code");
-    } catch (e: any) {
-      setTfMsg({ type: "err", text: e?.message || "Failed to send a verification code." });
+    } catch (e) {
+      setTfMsg({ type: "err", text: errorMessage(e) || "Failed to send a verification code." });
     } finally {
       setTfBusy(false);
     }
@@ -227,8 +228,8 @@ export default function UserProfilePage() {
       resetTwoFactorForm();
       setTfMsg({ type: "ok", text: wasEnabled ? `Codes will now be sent by ${TWO_FACTOR_METHOD_LABEL[res.twoFactorMethod]}.` : "Two-factor authentication is on." });
       loadActivity();
-    } catch (e: any) {
-      setTfMsg({ type: "err", text: e?.message || "Failed to verify the code." });
+    } catch (e) {
+      setTfMsg({ type: "err", text: errorMessage(e) || "Failed to verify the code." });
     } finally {
       setTfBusy(false);
     }
@@ -249,8 +250,8 @@ export default function UserProfilePage() {
       resetTwoFactorForm();
       setTfMsg({ type: "ok", text: "Two-factor authentication is off." });
       loadActivity();
-    } catch (e: any) {
-      setTfMsg({ type: "err", text: e?.message || "Failed to turn off two-factor authentication." });
+    } catch (e) {
+      setTfMsg({ type: "err", text: errorMessage(e) || "Failed to turn off two-factor authentication." });
     } finally {
       setTfBusy(false);
     }
@@ -269,7 +270,7 @@ export default function UserProfilePage() {
     setClosing(true);
     setCloseMsg(null);
     try {
-      const res = await apiFetch<any>("/api/users/close-account", {
+      const res = await apiFetch<{ message?: string }>("/api/users/close-account", {
         method: "POST",
         authToken: token,
         body: { password: closePassword, deleteData },
@@ -277,8 +278,8 @@ export default function UserProfilePage() {
       setCloseMsg({ type: "ok", text: res?.message || "Account closed." });
       // Slight delay so the user can read the message, then log out
       setTimeout(() => logout(), 2500);
-    } catch (e: any) {
-      setCloseMsg({ type: "err", text: e?.message || "Failed to close account." });
+    } catch (e) {
+      setCloseMsg({ type: "err", text: errorMessage(e) || "Failed to close account." });
     } finally {
       setClosing(false);
     }

frontend/src/app/dashboard/user/reset-password/page.tsx

@@ -5,6 +5,7 @@ import { apiFetch } from "@/lib/api";
 import { useDismissingState } from "@/hooks/useDismissingState";
 import { useRouter } from "next/navigation";
 import { KeyRound } from "lucide-react";
+import { errorMessage } from "@/lib/utils";
 
 export default function ResetPasswordPage() {
   const { token } = useAuth();
@@ -35,8 +36,8 @@ export default function ResetPasswordPage() {
       setPassword("");
       setConfirm("");
       setTimeout(() => router.push("/dashboard/user"), 1200);
-    } catch (err: any) {
-      setError(err?.message || "Failed to update password");
+    } catch (err) {
+      setError(errorMessage(err) || "Failed to update password");
     } finally {
       setLoading(false);
     }