Merge branch 'feat/unified-ticket-design'

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Bump to 1.30.1
2026-10-22 08:59:24 +02:00 · 2026-10-22 08:59:21 +02:00 · 2026-10-22 08:59:07 +02:00 · 2026-10-22 08:29:17 +02:00 · 2026-10-22 08:29:11 +02:00 · 2026-10-22 08:27:47 +02:00
133 changed files with 9805 additions and 3303 deletions
@@ -7,6 +7,149 @@ and this project follows [Semantic Versioning](https://semver.org/).

 ## [Unreleased]

+## [1.30.1] - 2026-10-22
+
+### Changed
+
+- All tickets now share the design of the tickets printed from the user dashboard: rounded white cards with a light border and soft shadow, the date beside the event name, and the QR code in the middle. This covers the PDF sent by email and WhatsApp (now 6 per page, so the QR codes are bigger) and printing from Event Tickets (staff) and At the door (supervisor). Printed names are now escaped, so a name with `<` or `&` prints correctly.
+
+## [1.30.0] - 2026-10-22
+
+### Added
+
+- The register form asks for an optional **Donation amount** under the ticket options. Pick a suggested amount (worked out from the ticket total), enter a custom amount (min R15), or choose None. The donation shows in the total and is paid in the same Yoco checkout as the tickets. It's recorded as a separate donation to the event, so it never counts towards the registration's balance.
+
+### Fixed
+
+- Event pages with a waitlist crashed with "Attempted to call soldOutLines() from the server". The sold-out helper now lives in `lib/waitlist.ts` so the server page can call it.
+
+## [1.29.1] - 2026-10-21
+
+### Changed
+
+- The Coupon codes page matches the Bundle deals page and works on phones. Codes show as cards with the discount, events, uses, restrictions, dates and limits. On phones, the edit form and the list of uses open full-width from the bottom, and the discount type is picked from three buttons.
+- The coupons list hides codes that are off, expired or used up unless you tick "Show codes that are off, expired or used up". Search also matches event names.
+- When creating or editing a code, the Events list shows upcoming events only, soonest first, with a search box and a "Show past events" option. Past events already on the code stay listed so they can be unticked.
+
+## [1.29.0] - 2026-10-21
+
+Run `npm run prisma:deploy` in the backend when deploying. This release adds a migration.
+
+### Added
+
+- Bundle deals now come in four types, chosen when you create one:
+  - **Exact set**: these tickets in these numbers for one price, e.g. 2 adults + 3 kids for R220. This is how bundles worked before.
+  - **Pick any**: any mix of the qualifying tickets for a set price, e.g. any 4 of Adult or Child for R250, so 2 + 2 and 4 + 0 both count.
+  - **Buy X get Y free**: in every set of qualifying tickets the cheapest are free, e.g. buy 3, get 1 free.
+  - **Group discount**: from a group size up, every qualifying ticket costs less (a price per ticket or a percentage off), e.g. 10+ tickets: R70 each. It applies once, to the whole group, and never makes a ticket dearer.
+- The deals list and the "Complete bundle" cards on the register form, at the door, manual registration and the kiosk describe each type in one line, e.g. "Any 4 of Adult, Child for R250". For a group discount the button reads "Complete group" and adds the tickets still needed.
+- `npm run set-demo`: Family Fun Day also has a pick-any deal, "Lunch for four" (any 4 lunch packs for R220).
+
+## [1.28.3] - 2026-10-21
+
+### Fixed
+
+- Bundle deals edit form: each ticket row's quantity box filled the whole row, which pushed the ticket picker off the side and added a sideways scrollbar. The quantity box is narrow again, with the ticket picker beside it.
+
+## [1.28.2] - 2026-10-21
+
+### Changed
+
+- The Bundle deals page has a new layout that works on phones. It shows upcoming events only, soonest first, with a "Show past events" option. Bundles show as cards with their tickets, price, saving, uses and dates. On a phone, the edit form opens full-width from the bottom, and its price section shows the standard price, the bundle price and the saving side by side.
+
+## [1.28.1] - 2026-10-21
+
+### Added
+
+- At the door, manual registration and the self-service kiosk now list the event's bundle deals and show the same bundle cards as the register form: once a ticket from a bundle is picked, **Complete bundle** tops up the ticket numbers, and **+** adds another full set.
+
+### Fixed
+
+- At the door now has the same "← Back to dashboard" link as the other dashboard pages.
+- At the door's "less than already paid" warning shows the total after bundle deals.
+
+## [1.28.0] - 2026-10-21
+
+Run `npm run prisma:deploy` in the backend when deploying. This release adds a migration.
+
+### Added
+
+- **Bundle deals**: sell a set of tickets together for one price, e.g. 5 Adult + 3 Child for R500 instead of R550. Supervisors set them up per event under Dashboard → **Bundle deals**: the tickets and quantities (one variant or any variant), the price, optional dates, and on/off.
+- Bundles apply automatically, with no code, as many times as a registration's tickets allow; leftover tickets are charged as usual. A bundle only applies when it's cheaper than the tickets at the prices actually charged, early-bird and staff prices included. When several compete, the one that saves the most is used first. This works for online registration, manual registration, at the door and on the kiosk.
+- The event page and the register form list the event's deals, and every basket shows the saving live. On the register form, once a ticket from a bundle is picked, the bundle appears with what's missing and a **Complete bundle** button that tops up the ticket numbers. Once it's complete, **+** adds another full set. Invoices, receipts, emails, WhatsApp messages and the Yoco payment page show it as its own line, e.g. "Bundle: Family deal ×2".
+- The Discounts report lists bundle deals next to coupon codes. Each bundle shows how often it's been used and the total saving given.
+- `npm run set-demo`: Family Fun Day sells a **Family deal** bundle (2 adults + 3 kids for R220) in place of the old Family pass ticket.
+
+### Changed
+
+- Coupon codes now work out after bundle deals, on what's left. Registration.discountTotal now holds bundle and coupon discounts together, with the bundle part in the new `bundleDiscount`.
+- Removing a code from a registration keeps its bundle deal. When an early-bird tier expires before payment and prices change, bundle deals are worked out again and coupon amounts are kept.
+- Registrations keep a bundle they already have, even after it's turned off or its dates pass. Deleting a bundle that has been used turns it off instead.
+
+## [1.27.1] - 2026-10-21
+
+### Added
+
+- `npm run set-demo` also stages ten completed events from the past year, with door sales recorded by staff, staff cash counts, check-ins, refunds, donations and post-event feedback. Their cashups go through every path: a quick close; full closes with card fees, a cash deposit fee, a written-off shortfall, cash kept on hand and an unaccounted amount; a close, reopen and re-close; pending EFT money that was later received and some still outstanding; and one event left open with the cash counted, ready for a live cashup. Funnel stats older than 90 days are stored as daily totals, the way the app rolls them up. See `backend/DEMO_DATA.md`.
+
+## [1.27.0] - 2026-10-21
+
+Run `npm run prisma:deploy` in the backend when deploying. This release adds a migration.
+
+### Added
+
+- Cashups now record where each payment method's money ended up. For cash, card, EFT and other, the expected takings are split into what's **in the bank**, **cash on hand**, and **pending** (on the card machine or Yoco report, or with a proof of payment), with a reference for the pending amount. Card fees, bank charges, cash shortfalls and other losses are **written off** with a reason. Each method shows what's still **unaccounted**. Closing with an unaccounted amount is allowed after a warning, and the amount comes off profit, as variance did before.
+- When staff have counted the cash, cash on hand is worked out for you: the count, less what reached the bank and any deposit fee written off as a bank charge.
+- Pending money on a closed event can be marked **received** or **written off** later from the cashup screen, without reopening the event. Each one is logged with who did it and when.
+- Reopening an event starts the next cashup from the last one, with any pending money settled since folded in.
+- Write-offs show as **Bank & card charges** on the cashup screen and in the Cashup, Finance and Profit reports. The Cashup report has new In bank, On hand, Pending, Written off and Unaccounted columns.
+
+### Changed
+
+- Net profit now subtracts write-offs as their own line instead of showing card fees and bank charges as missing income. The net figure is the same.
+- Every dashboard page uses the same back link: the small "← Back to dashboard" link above the page title, as on the Waitlist page. The grey Back buttons are gone. Site settings, profile, donate and manual registration, which had no way back, now have one too.
+
+## [1.26.1] - 2026-10-21
+
+### Added
+
+- `npm run set-demo` in the backend replaces the database contents with demo data for showing the platform to other churches. It keeps the site settings and the admin account, and stages six upcoming events with registrations, payments, tickets, a waitlist, camp cabins, coupons, costs and funnel stats. See `backend/DEMO_DATA.md`.
+
+## [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
@@ -0,0 +1,191 @@
+# Demo data
+
+`npm run set-demo` replaces everything in the database with a realistic set of demo data,
+for showing the platform to other churches. It stages six upcoming events with
+registrations, payments, tickets and people, and ten completed events from the past year
+with door sales, check-ins, feedback and cashups. That way every dashboard, report,
+check-in and cashup screen has something to show.
+
+> **This deletes real data.** Run it only against a database you're happy to wipe, such
+> as a dedicated demo deployment. It is not something to run on a live church site.
+
+---
+
+## Running it
+
+```bash
+cd backend
+npm run set-demo            # shows the database it will wipe and asks you to type "demo"
+npm run set-demo -- --yes   # no prompt (for scripts)
+```
+
+The script uses `DATABASE_URL` from `backend/.env`. To point it at another database
+for one run, set it in the environment first. A value already in the environment wins
+over `.env`:
+
+```bash
+DATABASE_URL="postgresql://user:pass@host:5432/hope_demo" npm run set-demo
+```
+
+It takes about five seconds and is safe to re-run as often as you like. Each run wipes the
+previous demo and creates it again.
+
+### Before you run it
+
+- The admin account must already exist. By default that's `joshua@crosscode.co.za`.
+  To keep a different account, set `DEMO_ADMIN_EMAIL`:
+  ```bash
+  DEMO_ADMIN_EMAIL="admin@example.org" npm run set-demo
+  ```
+  If the account isn't found, the script stops before changing anything.
+- Migrations must be up to date (`npm run prisma:deploy`).
+
+---
+
+## What it keeps and what it clears
+
+| Kept | Cleared |
+|---|---|
+| Site settings (`AppSetting`): org name, branding, SMTP, Yoco, WhatsApp, legal pages | Every event, with its options, variants, early-bird tiers, sections, forms, costs and cash-ups |
+| The admin account, including its login history, trusted devices and 2FA | Every other user |
+| Migration history | Registrations, payments, tickets, scans, coupons, waitlists, consents, cabins, feedback, analytics, audit log |
+| Uploaded files on disk (`public/uploads`) | Queued scheduled emails/WhatsApps (`data/scheduled-emails.json`) |
+
+The wipe and the new data are written in one database transaction. If that fails,
+nothing changes. The past events' cashups run straight afterwards, through the same
+code as the cashup screen. If one of those fails, re-run the script.
+
+---
+
+## What it creates
+
+### Upcoming events
+
+All dates are worked out from the day you run it, so these events are always upcoming.
+Registrations are spread over the past month, as if sign-ups have been coming in.
+The data is generated from a fixed seed, so every run looks the same.
+
+| When (from today) | Event | Shows off |
+|---|---|---|
+| ~1½ weeks, Sat 07:30 | **Men's Breakfast: Built to Last** | **Sold out** (60 places), 5 people on the **waitlist**, card / cash / EFT payments recorded by staff, 2 cancelled registrations |
+| ~2½ weeks, Sat 10:00 | **Family Fun Day** | Adult and child tickets with a **bundle deal** (Family deal: 2 adults + 3 kids for R220 instead of R280, used by about a third of registrations) and a **pick-any** deal (Lunch for four: any 4 lunch packs for R220), a non-ticket **add-on** (lunch pack), a fixed-amount **coupon** (`FUNDAY20`), entry and food-stall check-in sections |
+| ~5 weeks, Fri–Sat | **Rooted Women's Conference** | Two **early-bird tiers** (one already expired, one still open) plus a Saturday-only ticket, T-shirt **variants** (S–XXL), a **required sign-up form** (dietary needs, workshop choice, prayer requests), a 20% **group coupon** (`ROOTED20`) used by 4 registrations |
+| ~7 weeks, Mon–Thu | **Ignite Summer Camp** | **Named attendees** (campers aged 12–17), signed **parental consent**, gender collected, **deposits and part-payments**, campers placed in boys' and girls' **cabins** with staff leaders, **sponsor-a-spot** donations towards a 10-spot goal |
+| ~8 weeks, Sun 19:00 | **Carols by Candlelight** | A **free event** with group tickets (1–6 people), plus general **donations** |
+| ~14 weeks, Fri–Sun | **Marriage Enrichment Weekend** | Room-type **variants with limited stock**, early-bird prices per room type, a per-person spa add-on, R1 000 EFT deposits |
+
+Each event also gets:
+
+- A cover photo (from Unsplash, which `next.config` already allows) and a contact person.
+- **Costs**, both once-off and per item, so the profit view and cash-up have figures.
+- About 30 days of **funnel analytics** (views → started → submitted → paid) by source
+  (WhatsApp, Facebook, Instagram, email, direct) and device.
+
+Paid registrations have tickets with QR codes, the same way the app issues them once
+payment is complete. Part-paid and pending ones don't have tickets yet.
+
+### Past events
+
+Ten completed events spread over the past year, for showing cashups and the historical
+reports. Each one has:
+
+- Online sales in the five weeks before the event, with a few unpaid no-shows.
+- **Door sales** on the day, recorded by the staff team (cash and card machine).
+- **Check-ins**: about 90% of tickets scanned, with the odd group arriving short.
+- **Staff cash counts** with note and coin denominations.
+
+Some events also have refunds, donations and post-event feedback.
+
+The cashups cover every path through the cashup screen:
+
+| When | Event | Cashup to demo |
+|---|---|---|
+| ~11 months ago | **Church Family Picnic** | **Quick closed** (no settlement) |
+| 24 Dec | **Christmas Eve Candlelight Service** | Free event with card and cash **donations**. Card settled net of **Yoco fees**, collection banked |
+| Easter Sunday | **Easter Sunrise Service & Breakfast** | Cash banked less a **cash deposit fee** (bank charge), card fees, a **refund** |
+| Mother's Day | **Mother's Day Brunch** | **Closed with R50 cash short → reopened → recounted → closed again.** The history shows all three steps |
+| ~3½ months ago | **Youth Winter Camp** | Deposits and balances. **EFT pending** (POPs) at close, later **marked received** without reopening |
+| ~2½ months ago | **Men's Golf Day** | Card-heavy, card fees written off, a refund |
+| ~2 months ago | **Kids Holiday Club** | Cash-heavy door sales. **R20 cash shortfall written off**, **R500 kept on hand** as float |
+| ~6 weeks ago | **Women's High Tea** | Closed with **R30 unaccounted**, shown in red |
+| ~4 weeks ago | **Missions Fundraiser Dinner** | **R2 600 EFT still pending** (POP received, not cleared). Shows "Mark received" / "Write off" |
+| ~10 days ago | **Worship Night** | **Still open, with the cash already counted.** Use it to do a cashup live in the demo |
+
+Easter, the Youth Camp, the Holiday Club and the High Tea have **feedback forms** with
+ratings and comments. Funnel stats older than 90 days are stored as daily totals, the
+way the app rolls them up overnight, so the funnel report covers the whole year.
+
+### Totals
+
+A typical run gives roughly:
+
+| | |
+|---|---|
+| Users | 130 (plus the admin) |
+| Registrations | ~700 (paid, part-paid, pending, cancelled and refunded) |
+| Payments | ~640, including donations, sponsorships and refunds |
+| Tickets | ~780, with ~490 check-ins |
+| Named campers | ~45 |
+| Feedback responses | ~80 |
+| Funnel rows | ~4 400 |
+
+---
+
+## Logging in
+
+Every demo account uses the password **`Demo@1234`**.
+
+| Role | Email | Good for showing |
+|---|---|---|
+| Supervisor | `lerato.khumalo@example.com` | Event setup, reports, coupons, viewing cashups |
+| Staff | `sipho.dlamini@example.com` | At-the-door payments and check-in scanning |
+| Staff | `anri.botha@example.com` | |
+| Staff | `daniel.pillay@example.com` | |
+
+Closing, reopening and settling pending money in a cashup are admin-only, so do the
+live Worship Night cashup as your own admin account.
+
+The other 126 people are ordinary members (role `user`), with emails like
+`thandi.mokoena@example.com`. Log in as one of them to show the member view: their
+registrations, tickets and payments. Any registrant's email from an event's attendee
+list works.
+
+Your own admin account keeps its existing password.
+
+---
+
+## Safety
+
+- **Nothing is sent.** The script writes straight to the database and never calls the
+  email, WhatsApp or Yoco code.
+- **Nothing can reach a real person later.** Demo people use `@example.com` addresses
+  (a reserved domain that can't receive mail) and have **no phone numbers**, so
+  reminders or broadcasts sent during a demo go nowhere. All parental consents are
+  already signed, so no consent reminders go out.
+- Card payments have made-up Yoco ids (`demo_…`). They don't exist in Yoco, so leave
+  the demo site's Yoco settings in test mode or empty.
+
+---
+
+## Customising
+
+Everything lives in [`scripts/set-demo.js`](scripts/set-demo.js). There is one
+`build…()` function per event (`buildMensBreakfast`, `buildYouthCamp`, …), and
+`main()` decides which ones run. To change an event's name, prices, ticket types or
+number of registrations, edit its function. To add an event, write a new `build…()`
+and add it to the list in `main()`. `addBundle(event, { name, price }, [[option, quantity], …])`
+adds a bundle deal. Registrations added after it get the deal automatically, worked out
+the same way as the app does it.
+
+The past events are in `buildPastEvents()`, one spec each: dates, ticket types, costs,
+how many people bought online and at the door, and a `cashup` that says how it was
+closed. Supported closes:
+- `'quick'`
+- `'full'`, with `lines` saying where the money ended up
+- `'reclose'`
+- `'none'`, which leaves the event open
+
+A full close can add `later` to settle pending money after closing. The helpers
+`cardLine`, `eftLine` and `cashLine` build the usual settlements: card net of Yoco fees,
+EFT with an optional pending POP, and cash banked with an optional float, deposit fee or
+shortfall.
@@ -143,6 +143,10 @@ npm run prisma:status
 npm run prisma:generate
 ```

+### Demo data
+
+`npm run set-demo` wipes the database (keeping site settings and the admin account) and stages six upcoming demo events with registrations, payments and tickets. See [DEMO_DATA.md](DEMO_DATA.md).
+
 ---

 ## Running the Server
@@ -1,11 +1,11 @@
 {
  "name": "event-management-backend",
-  "version": "1.25.0",
+  "version": "1.30.1",
  "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",
@@ -13,10 +13,12 @@
    "prisma:status": "prisma migrate status",
    "prisma:reset": "prisma migrate reset --force",
    "migrate:env-to-db": "node scripts/migrate-env-to-db.js",
-    "migrate:env-to-db:dry": "node scripts/migrate-env-to-db.js --dry-run"
+    "migrate:env-to-db:dry": "node scripts/migrate-env-to-db.js --dry-run",
+    "set-demo": "node scripts/set-demo.js"
  },
  "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 +39,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
  }
@@ -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,
+  },
+});
@@ -0,0 +1,53 @@
+-- CreateEnum
+CREATE TYPE "CashupWriteOffCategory" AS ENUM ('card_fees', 'bank_charges', 'cash_shortfall', 'other');
+
+-- AlterTable
+ALTER TABLE "EventCashupLine" ADD COLUMN     "bankAmount" DOUBLE PRECISION,
+ADD COLUMN     "onHandAmount" DOUBLE PRECISION,
+ADD COLUMN     "pendingAmount" DOUBLE PRECISION,
+ADD COLUMN     "pendingReference" TEXT,
+ADD COLUMN     "writeOffTotal" DOUBLE PRECISION NOT NULL DEFAULT 0;
+
+-- CreateTable
+CREATE TABLE "EventCashupWriteOff" (
+    "id" TEXT NOT NULL,
+    "lineId" TEXT NOT NULL,
+    "category" "CashupWriteOffCategory" NOT NULL,
+    "amount" DOUBLE PRECISION NOT NULL,
+    "reason" TEXT,
+    "createdAt" TIMESTAMP(3) NOT NULL DEFAULT CURRENT_TIMESTAMP,
+
+    CONSTRAINT "EventCashupWriteOff_pkey" PRIMARY KEY ("id")
+);
+
+-- CreateTable
+CREATE TABLE "EventCashupPendingResolution" (
+    "id" TEXT NOT NULL,
+    "lineId" TEXT NOT NULL,
+    "outcome" TEXT NOT NULL,
+    "amount" DOUBLE PRECISION NOT NULL,
+    "category" "CashupWriteOffCategory",
+    "notes" TEXT,
+    "performedById" TEXT,
+    "createdAt" TIMESTAMP(3) NOT NULL DEFAULT CURRENT_TIMESTAMP,
+
+    CONSTRAINT "EventCashupPendingResolution_pkey" PRIMARY KEY ("id")
+);
+
+-- CreateIndex
+CREATE INDEX "EventCashupWriteOff_lineId_idx" ON "EventCashupWriteOff"("lineId");
+
+-- CreateIndex
+CREATE INDEX "EventCashupPendingResolution_lineId_idx" ON "EventCashupPendingResolution"("lineId");
+
+-- CreateIndex
+CREATE INDEX "EventCashupPendingResolution_performedById_idx" ON "EventCashupPendingResolution"("performedById");
+
+-- AddForeignKey
+ALTER TABLE "EventCashupWriteOff" ADD CONSTRAINT "EventCashupWriteOff_lineId_fkey" FOREIGN KEY ("lineId") REFERENCES "EventCashupLine"("id") ON DELETE CASCADE ON UPDATE CASCADE;
+
+-- AddForeignKey
+ALTER TABLE "EventCashupPendingResolution" ADD CONSTRAINT "EventCashupPendingResolution_lineId_fkey" FOREIGN KEY ("lineId") REFERENCES "EventCashupLine"("id") ON DELETE CASCADE ON UPDATE CASCADE;
+
+-- AddForeignKey
+ALTER TABLE "EventCashupPendingResolution" ADD CONSTRAINT "EventCashupPendingResolution_performedById_fkey" FOREIGN KEY ("performedById") REFERENCES "User"("id") ON DELETE SET NULL ON UPDATE CASCADE;
@@ -0,0 +1,83 @@
+-- AlterEnum
+ALTER TYPE "AdminAuditAction" ADD VALUE 'bundle_created';
+ALTER TYPE "AdminAuditAction" ADD VALUE 'bundle_updated';
+ALTER TYPE "AdminAuditAction" ADD VALUE 'bundle_deleted';
+
+-- AlterTable
+ALTER TABLE "Registration" ADD COLUMN     "bundleDiscount" DOUBLE PRECISION NOT NULL DEFAULT 0;
+
+-- CreateTable
+CREATE TABLE "EventBundle" (
+    "id" TEXT NOT NULL,
+    "eventId" TEXT NOT NULL,
+    "name" TEXT NOT NULL,
+    "description" TEXT,
+    "price" DOUBLE PRECISION NOT NULL,
+    "isActive" BOOLEAN NOT NULL DEFAULT true,
+    "validFrom" TIMESTAMP(3),
+    "validUntil" TIMESTAMP(3),
+    "order" INTEGER NOT NULL DEFAULT 0,
+    "createdAt" TIMESTAMP(3) NOT NULL DEFAULT CURRENT_TIMESTAMP,
+    "updatedAt" TIMESTAMP(3) NOT NULL,
+
+    CONSTRAINT "EventBundle_pkey" PRIMARY KEY ("id")
+);
+
+-- CreateTable
+CREATE TABLE "EventBundleItem" (
+    "id" TEXT NOT NULL,
+    "bundleId" TEXT NOT NULL,
+    "eventOptionId" TEXT NOT NULL,
+    "variantId" TEXT,
+    "quantity" INTEGER NOT NULL,
+
+    CONSTRAINT "EventBundleItem_pkey" PRIMARY KEY ("id")
+);
+
+-- CreateTable
+CREATE TABLE "RegistrationBundle" (
+    "id" TEXT NOT NULL,
+    "registrationId" TEXT NOT NULL,
+    "bundleId" TEXT NOT NULL,
+    "count" INTEGER NOT NULL,
+    "discount" DOUBLE PRECISION NOT NULL,
+    "createdAt" TIMESTAMP(3) NOT NULL DEFAULT CURRENT_TIMESTAMP,
+
+    CONSTRAINT "RegistrationBundle_pkey" PRIMARY KEY ("id")
+);
+
+-- CreateIndex
+CREATE INDEX "EventBundle_eventId_idx" ON "EventBundle"("eventId");
+
+-- CreateIndex
+CREATE INDEX "EventBundleItem_bundleId_idx" ON "EventBundleItem"("bundleId");
+
+-- CreateIndex
+CREATE INDEX "EventBundleItem_eventOptionId_idx" ON "EventBundleItem"("eventOptionId");
+
+-- CreateIndex
+CREATE INDEX "EventBundleItem_variantId_idx" ON "EventBundleItem"("variantId");
+
+-- CreateIndex
+CREATE INDEX "RegistrationBundle_registrationId_idx" ON "RegistrationBundle"("registrationId");
+
+-- CreateIndex
+CREATE INDEX "RegistrationBundle_bundleId_idx" ON "RegistrationBundle"("bundleId");
+
+-- AddForeignKey
+ALTER TABLE "EventBundle" ADD CONSTRAINT "EventBundle_eventId_fkey" FOREIGN KEY ("eventId") REFERENCES "Event"("id") ON DELETE CASCADE ON UPDATE CASCADE;
+
+-- AddForeignKey
+ALTER TABLE "EventBundleItem" ADD CONSTRAINT "EventBundleItem_bundleId_fkey" FOREIGN KEY ("bundleId") REFERENCES "EventBundle"("id") ON DELETE CASCADE ON UPDATE CASCADE;
+
+-- AddForeignKey
+ALTER TABLE "EventBundleItem" ADD CONSTRAINT "EventBundleItem_eventOptionId_fkey" FOREIGN KEY ("eventOptionId") REFERENCES "EventOption"("id") ON DELETE CASCADE ON UPDATE CASCADE;
+
+-- AddForeignKey
+ALTER TABLE "EventBundleItem" ADD CONSTRAINT "EventBundleItem_variantId_fkey" FOREIGN KEY ("variantId") REFERENCES "OptionVariant"("id") ON DELETE CASCADE ON UPDATE CASCADE;
+
+-- AddForeignKey
+ALTER TABLE "RegistrationBundle" ADD CONSTRAINT "RegistrationBundle_registrationId_fkey" FOREIGN KEY ("registrationId") REFERENCES "Registration"("id") ON DELETE CASCADE ON UPDATE CASCADE;
+
+-- AddForeignKey
+ALTER TABLE "RegistrationBundle" ADD CONSTRAINT "RegistrationBundle_bundleId_fkey" FOREIGN KEY ("bundleId") REFERENCES "EventBundle"("id") ON DELETE RESTRICT ON UPDATE CASCADE;
@@ -0,0 +1,12 @@
+-- CreateEnum
+CREATE TYPE "BundleKind" AS ENUM ('exact', 'mix', 'free', 'group');
+
+-- CreateEnum
+CREATE TYPE "BundleGroupPricing" AS ENUM ('per_ticket', 'percent');
+
+-- AlterTable
+ALTER TABLE "EventBundle" ADD COLUMN     "freeCount" INTEGER,
+ADD COLUMN     "groupPricing" "BundleGroupPricing",
+ADD COLUMN     "kind" "BundleKind" NOT NULL DEFAULT 'exact',
+ADD COLUMN     "setSize" INTEGER;
+
@@ -7,7 +7,6 @@ generator client {

 datasource db {
  provider = "postgresql"
-  url      = env("DATABASE_URL")
 }

 enum UserRole {
@@ -89,6 +88,7 @@ model User {
  eventsClosed     Event[]       @relation("EventClosedBy")
  eventsReopened   Event[]       @relation("EventReopenedBy")
  cashupsPerformed EventCashup[]
+  pendingResolved  EventCashupPendingResolution[] @relation("PendingResolutionBy")
  notifyForEvents  Event[]       @relation("EventNotifyRecipients")

  personCashCountsFor     EventCashupPersonCount[] @relation("EventCashupPersonCountFor")
@@ -197,6 +197,7 @@ model Event {
  consentRequests  ConsentRequest[]
  waitlistEntries  WaitlistEntry[]
  scanLocks        ScanLock[]
+  bundles          EventBundle[]

  @@index([createdById])
  @@index([closedById])
@@ -220,6 +221,7 @@ model EventOption {
  costs               EventCost[]
  couponScopes        CouponOption[]
  waitlistEntries     WaitlistEntry[]
+  bundleItems         EventBundleItem[]

  @@index([eventId])
 }
@@ -255,6 +257,7 @@ model OptionVariant {
  earlyBirdTiers      EarlyBirdTier[]
  couponScopes        CouponOption[]
  waitlistEntries     WaitlistEntry[]
+  bundleItems         EventBundleItem[]

  @@index([eventOptionId])
 }
@@ -265,10 +268,13 @@ model Registration {
  eventId             String
  status              RegistrationStatus   @default(pending)
  checkoutId          String?              @unique
-  // Sum of this registration's active coupon discounts, kept in step with
-  // couponRedemptions. Stored here so every total-due calculation sees it no matter
-  // which relations the caller loaded (see utils/pricing.js computeRegistrationTotalDue).
+  // Sum of this registration's discounts: bundle deals plus active coupon discounts,
+  // kept in step with bundleApplications and couponRedemptions. Stored here so every
+  // total-due calculation sees it no matter which relations the caller loaded (see
+  // utils/pricing.js computeRegistrationTotalDue).
  discountTotal       Float                @default(0)
+  // The bundle-deal part of discountTotal (the rest is coupons).
+  bundleDiscount      Float                @default(0)
  // Where named attendees' tickets go: all to the payer, or each to the attendee.
  ticketDelivery      TicketDelivery       @default(payer)
  analyticsSessionId String?
@@ -281,6 +287,7 @@ model Registration {
  formResponses       FormResponse[]
  formDrafts          FormDraft[]
  couponRedemptions   CouponRedemption[]
+  bundleApplications  RegistrationBundle[]
  attendees           Attendee[]
  waitlistEntries     WaitlistEntry[]

@@ -495,6 +502,9 @@ enum AdminAuditAction {
  coupon_updated
  coupon_disabled
  coupon_applied_manual
+  bundle_created
+  bundle_updated
+  bundle_deleted
  consent_override
  consent_rerequested
  medical_list_viewed
@@ -709,20 +719,68 @@ model EventCashup {
  @@index([eventId, createdAt])
 }

+// Where one method's expected takings ended up. actualAmount = bank + on hand + pending
+// (money held or on its way); write-offs explain money that's gone (fees, charges,
+// shortfalls). expected - actual - writeOffTotal is what's still unaccounted for.
 model EventCashupLine {
-  id             String                    @id @default(uuid())
-  cashupId       String
-  cashup         EventCashup               @relation(fields: [cashupId], references: [id], onDelete: Cascade)
-  method         String
-  expectedAmount Float                     @default(0)
-  actualAmount   Float?
-  variance       Float?
-  notes          String?
-  denominations  EventCashupDenomination[]
+  id                 String                         @id @default(uuid())
+  cashupId           String
+  cashup             EventCashup                    @relation(fields: [cashupId], references: [id], onDelete: Cascade)
+  method             String
+  expectedAmount     Float                          @default(0)
+  actualAmount       Float?
+  variance           Float?
+  notes              String?
+  bankAmount         Float?
+  onHandAmount       Float?
+  pendingAmount      Float?
+  // Card/Yoco report or POP reference for the pending amount.
+  pendingReference   String?
+  writeOffTotal      Float                          @default(0)
+  denominations      EventCashupDenomination[]
+  writeOffs          EventCashupWriteOff[]
+  pendingResolutions EventCashupPendingResolution[]

  @@index([cashupId])
 }

+enum CashupWriteOffCategory {
+  card_fees
+  bank_charges
+  cash_shortfall
+  other
+}
+
+model EventCashupWriteOff {
+  id        String                 @id @default(uuid())
+  lineId    String
+  line      EventCashupLine        @relation(fields: [lineId], references: [id], onDelete: Cascade)
+  category  CashupWriteOffCategory
+  amount    Float
+  reason    String?
+  createdAt DateTime               @default(now())
+
+  @@index([lineId])
+}
+
+// Pending money settled after the event was closed: it reached the bank ('received') or
+// never will ('written_off'). Append-only, like EventCashup — the line itself is never edited.
+model EventCashupPendingResolution {
+  id            String                  @id @default(uuid())
+  lineId        String
+  line          EventCashupLine         @relation(fields: [lineId], references: [id], onDelete: Cascade)
+  outcome       String // 'received' | 'written_off'
+  amount        Float
+  category      CashupWriteOffCategory?
+  notes         String?
+  performedById String?
+  performedBy   User?                   @relation("PendingResolutionBy", fields: [performedById], references: [id], onDelete: SetNull)
+  createdAt     DateTime                @default(now())
+
+  @@index([lineId])
+  @@index([performedById])
+}
+
 model EventCashupDenomination {
  id     String          @id @default(uuid())
  lineId String
@@ -854,6 +912,85 @@ model CouponRedemption {
  @@index([appliedById])
 }

+// ─── Bundle deals ─────────────────────────────────────────────────────────────
+
+// How a bundle is made up (see utils/bundles.js):
+// exact: these tickets in these numbers, for `price`, e.g. 5 Adult + 3 Child for R500
+// mix:   any `setSize` of the qualifying tickets, for `price`
+// free:  any `setSize` of the qualifying tickets, the cheapest `freeCount` free
+// group: `setSize` or more qualifying tickets, all at `price` each (or `price`% off)
+enum BundleKind {
+  exact
+  mix
+  free
+  group
+}
+
+enum BundleGroupPricing {
+  per_ticket
+  percent
+}
+
+// Tickets sold together at a better price. Applied automatically, as many times as a
+// registration's items allow (a group discount once), and only when it beats what the
+// items would cost anyway (see utils/bundles.js).
+model EventBundle {
+  id           String               @id @default(uuid())
+  eventId      String
+  name         String
+  description  String?
+  kind         BundleKind           @default(exact)
+  // exact/mix: the set's price. group: the per-ticket price, or the percentage off.
+  price        Float
+  setSize      Int?
+  freeCount    Int?
+  groupPricing BundleGroupPricing?
+  isActive     Boolean              @default(true)
+  validFrom    DateTime?
+  validUntil   DateTime?
+  order        Int                  @default(0)
+  createdAt    DateTime             @default(now())
+  updatedAt    DateTime             @updatedAt
+  event        Event                @relation(fields: [eventId], references: [id], onDelete: Cascade)
+  items        EventBundleItem[]
+  uses         RegistrationBundle[]
+
+  @@index([eventId])
+}
+
+// One line of a bundle: for exact bundles a ticket and how many; for the others a
+// qualifying ticket (quantity unused). variantId null = any variant of the option.
+model EventBundleItem {
+  id            String         @id @default(uuid())
+  bundleId      String
+  eventOptionId String
+  variantId     String?
+  quantity      Int
+  bundle        EventBundle    @relation(fields: [bundleId], references: [id], onDelete: Cascade)
+  eventOption   EventOption    @relation(fields: [eventOptionId], references: [id], onDelete: Cascade)
+  variant       OptionVariant? @relation(fields: [variantId], references: [id], onDelete: Cascade)
+
+  @@index([bundleId])
+  @@index([eventOptionId])
+  @@index([variantId])
+}
+
+// How many times a bundle applies to a registration and what it saved. Rebuilt each
+// time the registration's discounts are recalculated.
+model RegistrationBundle {
+  id             String       @id @default(uuid())
+  registrationId String
+  bundleId       String
+  count          Int
+  discount       Float
+  createdAt      DateTime     @default(now())
+  registration   Registration @relation(fields: [registrationId], references: [id], onDelete: Cascade)
+  bundle         EventBundle  @relation(fields: [bundleId], references: [id], onDelete: Restrict)
+
+  @@index([registrationId])
+  @@index([bundleId])
+}
+
 // ─── Group tickets ────────────────────────────────────────────────────────────

 enum TicketDelivery {
@@ -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');
@@ -90,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');
@@ -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',
@@ -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;
@@ -0,0 +1,325 @@
+const prisma = require('../config/db');
+const { safeErrorMessage } = require('../utils/errorUtils');
+const { logAdminAction } = require('../utils/adminAudit');
+const { getClientIp } = require('../utils/requestUtils');
+const { KINDS, describeBundle, describeBundleItems, isBundleAvailable } = require('../utils/bundles');
+const { previewBundles } = require('../utils/coupons');
+const { basketBuyer, priceBasket } = require('./couponController');
+
+const round2 = (n) => Math.round(Number(n || 0) * 100) / 100;
+const fmtR = (n) => `R${Number(n || 0).toFixed(2).replace(/\.00$/, '')}`;
+const GROUP_PRICING = ['per_ticket', 'percent'];
+
+const optionalDate = (v, label) => {
+  if (v === undefined) return undefined;
+  if (v === null || v === '') return null;
+  const d = new Date(v);
+  if (isNaN(d.getTime())) throw new Error(`${label} is not a valid date`);
+  return d;
+};
+
+/** Standard (variant or option) price of one unit of an item. */
+function itemPrice(i) {
+  const variant = i.variantId ? (i.eventOption?.variants || []).find(v => v.id === i.variantId) : null;
+  return Number((variant && variant.price !== null && variant.price !== undefined ? variant.price : i.eventOption?.price) || 0);
+}
+
+/**
+ * What the deal is worth at standard prices: `standardValue` is what an exact set costs
+ * separately (or the dearest pick-any set); `savingText` is a short "save …" line, or
+ * null when the headline already says it.
+ */
+function valueOf(bundle) {
+  const kind = bundle.kind || 'exact';
+  const items = bundle.items || [];
+  const dearest = items.reduce((m, i) => Math.max(m, itemPrice(i)), 0);
+  const price = Number(bundle.price || 0);
+  if (kind === 'exact') {
+    const standard = round2(items.reduce((s, i) => s + itemPrice(i) * Number(i.quantity || 0), 0));
+    return { standardValue: standard, savingText: standard - price > 0.005 ? `save ${fmtR(standard - price)}` : null };
+  }
+  if (kind === 'mix') {
+    const standard = round2(dearest * Number(bundle.setSize || 0));
+    return { standardValue: standard, savingText: standard - price > 0.005 ? `save up to ${fmtR(standard - price)}` : null };
+  }
+  if (kind === 'free') {
+    return { standardValue: null, savingText: dearest > 0 ? `save up to ${fmtR(dearest * Number(bundle.freeCount || 0))} a set` : null };
+  }
+  if (bundle.groupPricing === 'per_ticket' && dearest - price > 0.005) {
+    return { standardValue: null, savingText: `save up to ${fmtR(dearest - price)} a ticket` };
+  }
+  return { standardValue: null, savingText: null };
+}
+
+// Items with prices loaded, so the standard value can be shown next to the bundle price.
+const DETAIL_INCLUDE = {
+  items: {
+    include: {
+      eventOption: { select: { id: true, name: true, price: true, variants: { select: { id: true, price: true } } } },
+      variant: { select: { id: true, name: true } },
+    },
+  },
+};
+
+function shape(bundle, now = new Date()) {
+  const items = (bundle.items || []).map(({ eventOption, ...i }) => ({ ...i, eventOption: eventOption ? { id: eventOption.id, name: eventOption.name, price: eventOption.price } : null }));
+  return {
+    ...bundle,
+    items,
+    summary: describeBundleItems(bundle),
+    headline: describeBundle(bundle),
+    ...valueOf(bundle),
+    available: isBundleAvailable(bundle, now),
+  };
+}
+
+const PRICING_FIELDS = ['kind', 'price', 'setSize', 'freeCount', 'groupPricing', 'items'];
+
+/**
+ * Turns a create/update body into Prisma data plus the item list. On update, fields
+ * left out of the body are left alone; when any pricing field is sent, the bundle as a
+ * whole (saved values plus the new ones) is checked. Items must belong to the event.
+ */
+async function parseBundleBody(body, eventId, { isCreate, current = null }) {
+  const data = {};
+  if (isCreate || body.name !== undefined) {
+    const name = String(body.name || '').trim();
+    if (!name) throw new Error('Give the bundle a name');
+    if (name.length > 80) throw new Error('Keep the name under 80 characters');
+    data.name = name;
+  }
+  if (body.description !== undefined) data.description = body.description ? String(body.description).trim() : null;
+  if (body.isActive !== undefined) data.isActive = !!body.isActive;
+  if (body.order !== undefined) data.order = Number.isInteger(Number(body.order)) ? Number(body.order) : 0;
+  const validFrom = optionalDate(body.validFrom, 'Available from');
+  const validUntil = optionalDate(body.validUntil, 'Available until');
+  if (validFrom !== undefined) data.validFrom = validFrom;
+  if (validUntil !== undefined) data.validUntil = validUntil;
+  if (validFrom && validUntil && validFrom > validUntil) throw new Error('"Available from" must be before "Available until"');
+
+  let items;
+  if (!isCreate && !PRICING_FIELDS.some(f => body[f] !== undefined)) return { data, items };
+
+  const pick = (f) => (body[f] !== undefined ? body[f] : current?.[f]);
+  const kind = pick('kind') || 'exact';
+  if (!KINDS.includes(kind)) throw new Error('Unknown bundle type');
+  data.kind = kind;
+
+  const rawItems = body.items !== undefined ? body.items : (current?.items || []);
+  // The same option/variant twice becomes one line.
+  const merged = new Map();
+  for (const it of Array.isArray(rawItems) ? rawItems : []) {
+    if (!it || !it.eventOptionId) continue;
+    const quantity = kind === 'exact' ? Number(it.quantity) : 1;
+    if (!Number.isInteger(quantity) || quantity < 1) throw new Error('Each ticket needs a quantity of at least 1');
+    const key = `${it.eventOptionId}::${it.variantId || ''}`;
+    const prev = merged.get(key);
+    merged.set(key, { eventOptionId: it.eventOptionId, variantId: it.variantId || null, quantity: kind === 'exact' ? (prev?.quantity || 0) + quantity : 1 });
+  }
+  items = [...merged.values()];
+  if (items.length === 0) throw new Error(kind === 'exact' ? 'Add at least one ticket to the bundle' : 'Choose at least one qualifying ticket');
+
+  const price = Number(pick('price'));
+  const setSize = Number(pick('setSize'));
+  const freeCount = Number(pick('freeCount'));
+  const groupPricing = pick('groupPricing');
+  const priceGiven = pick('price') !== '' && pick('price') !== null && pick('price') !== undefined;
+
+  if (kind === 'exact') {
+    if (items.reduce((s, i) => s + i.quantity, 0) < 2) throw new Error('A bundle needs at least two tickets in it');
+    if (!priceGiven || !(price >= 0)) throw new Error('Enter the bundle price (zero or more)');
+    Object.assign(data, { price: round2(price), setSize: null, freeCount: null, groupPricing: null });
+  } else if (kind === 'mix') {
+    if (!Number.isInteger(setSize) || setSize < 2) throw new Error('A pick-any bundle needs at least 2 tickets per set');
+    if (!priceGiven || !(price >= 0)) throw new Error('Enter the price for the set (zero or more)');
+    Object.assign(data, { price: round2(price), setSize, freeCount: null, groupPricing: null });
+  } else if (kind === 'free') {
+    if (!Number.isInteger(freeCount) || freeCount < 1) throw new Error('At least one ticket must be free');
+    if (!Number.isInteger(setSize) || setSize <= freeCount) throw new Error('Buy at least one ticket to get the free ones');
+    Object.assign(data, { price: 0, setSize, freeCount, groupPricing: null });
+  } else {
+    if (!Number.isInteger(setSize) || setSize < 2) throw new Error('A group needs at least 2 tickets');
+    if (!GROUP_PRICING.includes(groupPricing)) throw new Error('Choose a price per ticket or a percentage off');
+    if (groupPricing === 'percent' && !(price > 0 && price <= 100)) throw new Error('Enter a percentage between 1 and 100');
+    if (groupPricing === 'per_ticket' && (!priceGiven || !(price >= 0))) throw new Error('Enter the price per ticket (zero or more)');
+    Object.assign(data, { price: round2(price), setSize, freeCount: null, groupPricing });
+  }
+
+  const options = await prisma.eventOption.findMany({
+    where: { id: { in: items.map(i => i.eventOptionId) } },
+    select: { id: true, eventId: true, variants: { select: { id: true } } },
+  });
+  for (const i of items) {
+    const row = options.find(o => o.id === i.eventOptionId);
+    if (!row || row.eventId !== eventId) throw new Error('One of the tickets isn\'t part of this event');
+    if (i.variantId && !row.variants.some(v => v.id === i.variantId)) throw new Error('One of the selected variants no longer exists');
+  }
+  return { data, items };
+}
+
+async function eventOr404(eventId, res) {
+  const event = await prisma.event.findUnique({ where: { id: eventId }, select: { id: true, title: true } });
+  if (!event) { res.status(404); throw new Error('Event not found'); }
+  return event;
+}
+
+// @desc    An event's bundle deals with how often each has been used
+// @route   GET /api/bundles/event/:eventId
+// @access  Private/Supervisor
+const listBundles = async (req, res) => {
+  try {
+    await eventOr404(req.params.eventId, res);
+    const bundles = await prisma.eventBundle.findMany({
+      where: { eventId: req.params.eventId },
+      include: DETAIL_INCLUDE,
+      orderBy: [{ order: 'asc' }, { createdAt: 'asc' }],
+    });
+    const totals = await prisma.registrationBundle.groupBy({
+      by: ['bundleId'],
+      where: { bundle: { eventId: req.params.eventId }, registration: { status: { not: 'cancelled' } } },
+      _sum: { count: true, discount: true },
+      _count: { _all: true },
+    });
+    const byId = Object.fromEntries(totals.map(t => [t.bundleId, t]));
+    const now = new Date();
+    res.json(bundles.map(b => ({
+      ...shape(b, now),
+      uses: byId[b.id]?._sum?.count || 0,
+      registrations: byId[b.id]?._count?._all || 0,
+      totalDiscount: round2(byId[b.id]?._sum?.discount || 0),
+    })));
+  } catch (error) {
+    res.status(res.statusCode === 200 ? 400 : res.statusCode).json({ message: safeErrorMessage(error) });
+  }
+};
+
+// @desc    Create a bundle deal
+// @route   POST /api/bundles/event/:eventId
+// @access  Private/Supervisor
+const createBundle = async (req, res) => {
+  try {
+    const event = await eventOr404(req.params.eventId, res);
+    let parsed;
+    try {
+      parsed = await parseBundleBody(req.body || {}, event.id, { isCreate: true });
+    } catch (e) { res.status(400); throw e; }
+    const bundle = await prisma.eventBundle.create({
+      data: { ...parsed.data, eventId: event.id, items: { create: parsed.items } },
+      include: DETAIL_INCLUDE,
+    });
+    logAdminAction({
+      actorId: req.user.id, actorRole: req.user.role, action: 'bundle_created',
+      targetType: 'EventBundle', targetId: bundle.id,
+      metadata: { eventId: event.id, name: bundle.name, kind: bundle.kind, deal: describeBundle(bundle) },
+      ip: getClientIp(req),
+    });
+    res.status(201).json({ ...shape(bundle), uses: 0, registrations: 0, totalDiscount: 0 });
+  } catch (error) {
+    res.status(res.statusCode === 200 ? 400 : res.statusCode).json({ message: safeErrorMessage(error) });
+  }
+};
+
+// @desc    Edit a bundle deal (including switching it off). Registrations that already
+//          have it are only re-worked when their own items change.
+// @route   PUT /api/bundles/:id
+// @access  Private/Supervisor
+const updateBundle = async (req, res) => {
+  try {
+    const existing = await prisma.eventBundle.findUnique({ where: { id: req.params.id }, include: { items: true } });
+    if (!existing) { res.status(404); throw new Error('Bundle not found'); }
+    let parsed;
+    try {
+      parsed = await parseBundleBody(req.body || {}, existing.eventId, { isCreate: false, current: existing });
+    } catch (e) { res.status(400); throw e; }
+    const bundle = await prisma.eventBundle.update({
+      where: { id: existing.id },
+      data: { ...parsed.data, ...(parsed.items ? { items: { deleteMany: {}, create: parsed.items } } : {}) },
+      include: DETAIL_INCLUDE,
+    });
+    logAdminAction({
+      actorId: req.user.id, actorRole: req.user.role, action: 'bundle_updated',
+      targetType: 'EventBundle', targetId: bundle.id,
+      metadata: { eventId: bundle.eventId, name: bundle.name, changedKeys: Object.keys(req.body || {}) },
+      ip: getClientIp(req),
+    });
+    res.json(shape(bundle));
+  } catch (error) {
+    res.status(res.statusCode === 200 ? 400 : res.statusCode).json({ message: safeErrorMessage(error) });
+  }
+};
+
+// @desc    Delete a bundle deal. One that's been used is switched off instead, so the
+//          registrations that got it keep their price.
+// @route   DELETE /api/bundles/:id
+// @access  Private/Supervisor
+const deleteBundle = async (req, res) => {
+  try {
+    const existing = await prisma.eventBundle.findUnique({ where: { id: req.params.id } });
+    if (!existing) { res.status(404); throw new Error('Bundle not found'); }
+    const used = await prisma.registrationBundle.count({ where: { bundleId: existing.id } });
+    if (used > 0) {
+      await prisma.eventBundle.update({ where: { id: existing.id }, data: { isActive: false } });
+    } else {
+      await prisma.eventBundle.delete({ where: { id: existing.id } });
+    }
+    logAdminAction({
+      actorId: req.user.id, actorRole: req.user.role, action: 'bundle_deleted',
+      targetType: 'EventBundle', targetId: existing.id,
+      metadata: { eventId: existing.eventId, name: existing.name, switchedOff: used > 0 },
+      ip: getClientIp(req),
+    });
+    res.json(used > 0
+      ? { switchedOff: true, message: 'This bundle has been used, so it\'s been switched off instead. Registrations that got it keep their price.' }
+      : { deleted: true, message: 'Bundle deleted' });
+  } catch (error) {
+    res.status(res.statusCode === 200 ? 400 : res.statusCode).json({ message: safeErrorMessage(error) });
+  }
+};
+
+// @desc    The bundle deals a basket gets, before any coupon code
+// @route   POST /api/bundles/quote
+// @access  Public. Body: { eventId, options: [{ eventOptionId, variantId?, quantity }], forUserId? }
+const quoteBundles = async (req, res) => {
+  try {
+    const { eventId, options, forUserId } = req.body || {};
+    if (!eventId || !Array.isArray(options)) { res.status(400); throw new Error('eventId and options are required'); }
+    const event = await prisma.event.findUnique({
+      where: { id: eventId },
+      include: { eventOptions: { include: { earlyBirdTiers: true, variants: true } } },
+    });
+    if (!event) { res.status(404); throw new Error('Event not found'); }
+    const { buyer } = await basketBuyer(req, forUserId);
+    const lines = await priceBasket(event, options, buyer);
+    const subtotal = round2(lines.reduce((s, l) => s + l.unitPrice * l.quantity, 0));
+    const bundles = await previewBundles(eventId, lines);
+    res.json({
+      subtotal,
+      bundleDiscount: bundles.discount,
+      bundles: bundles.applications,
+      total: round2(Math.max(0, subtotal - bundles.discount)),
+    });
+  } catch (error) {
+    res.status(res.statusCode === 200 ? 400 : res.statusCode).json({ message: safeErrorMessage(error) });
+  }
+};
+
+/** The deals to show on an event's page: available bundles, without internal fields. */
+async function publicBundlesForEvent(eventId) {
+  const bundles = await prisma.eventBundle.findMany({
+    where: { eventId, isActive: true },
+    include: DETAIL_INCLUDE,
+    orderBy: [{ order: 'asc' }, { createdAt: 'asc' }],
+  });
+  const now = new Date();
+  return bundles.filter(b => isBundleAvailable(b, now)).map(b => {
+    const s = shape(b, now);
+    return {
+      id: s.id, name: s.name, description: s.description, validUntil: s.validUntil,
+      kind: s.kind, price: s.price, setSize: s.setSize, freeCount: s.freeCount, groupPricing: s.groupPricing,
+      summary: s.summary, headline: s.headline, standardValue: s.standardValue, savingText: s.savingText,
+      items: s.items.map(i => ({ eventOptionId: i.eventOptionId, variantId: i.variantId, quantity: i.quantity })),
+    };
+  });
+}
+
+module.exports = { listBundles, createBundle, updateBundle, deleteBundle, quoteBundles, publicBundlesForEvent };
@@ -1,7 +1,20 @@
 const prisma = require('../config/db');
 const { v4: uuidv4 } = require('uuid');
 const { safeErrorMessage } = require('../utils/errorUtils');
-const { ALL_METHODS, assertEventOpen, computeEventFinancials, computeAccountabilityByUser, computeEventCashActualFromPersonCounts, savePersonCashCount } = require('../utils/cashupUtils');
+const { ALL_METHODS, WRITE_OFF_CATEGORIES, PENDING_OUTCOMES, settleLine, applyPendingResolutions, assertEventOpen, computeEventFinancials, computeAccountabilityByUser, computeEventCashActualFromPersonCounts, savePersonCashCount } = require('../utils/cashupUtils');
+
+// What the cashup screen sends per method: where the money ended up and what was written off.
+function cleanDraftLine(l) {
+  return {
+    method: l.method,
+    bankAmount: l.bankAmount ?? null,
+    onHandAmount: l.onHandAmount ?? null,
+    pendingAmount: l.pendingAmount ?? null,
+    pendingReference: l.pendingReference || null,
+    writeOffs: (Array.isArray(l.writeOffs) ? l.writeOffs : []).map(w => ({ category: w.category, amount: w.amount ?? null, reason: w.reason || null })),
+    notes: l.notes || null
+  };
+}

 // @desc    Cashup preview for an event: live expected/actual numbers, costs, donations-to-profit, and history
 // @route   GET /api/cashups/event/:eventId
@@ -66,7 +79,7 @@ const saveEventCashupDraft = async (req, res) => {

    await prisma.event.update({
      where: { id: eventId },
-      data: { cashupDraft: { lines: Array.isArray(lines) ? lines : [], notes: notes || null, savedAt: new Date().toISOString() } }
+      data: { cashupDraft: { lines: (Array.isArray(lines) ? lines : []).filter(l => l && ALL_METHODS.includes(l.method)).map(cleanDraftLine), notes: notes || null, savedAt: new Date().toISOString() } }
    });

    res.json({ message: 'Draft saved' });
@@ -88,40 +101,32 @@ const closeEvent = async (req, res) => {
    const financials = await computeEventFinancials(eventId);
    const isFullCashup = Array.isArray(lines) && lines.length > 0;

+    // Each method says where its expected money ended up (see settleLine). Cash is never a
+    // single event-wide figure: when staff counted it, the count is the cash there is, sourced
+    // here from the per-person counts rather than from whatever the frontend sent.
    let cashupLines = [];
    if (isFullCashup) {
-      const nonCashLines = lines
-        .filter(l => l && ALL_METHODS.includes(l.method) && l.method !== 'cash')
-        .map(l => {
-          const expected = financials.expectedCashByMethod[l.method] || 0;
-          const actual = l.actualAmount !== undefined && l.actualAmount !== null && l.actualAmount !== '' ? parseFloat(l.actualAmount) : null;
-          return {
-            id: uuidv4(),
-            method: l.method,
-            expectedAmount: expected,
-            actualAmount: actual,
-            variance: actual !== null ? actual - expected : null,
-            notes: l.notes || null
-          };
-        });
-
-      // Cash is never entered as a single event-wide figure — it's always the live sum of every
-      // staff member's per-person count (see computeEventCashActualFromPersonCounts), so it's
-      // always sourced here rather than from whatever (if anything) the frontend sent for it.
-      const cashLineInput = lines.find(l => l && l.method === 'cash');
-      const { actual: cashActual, denominations: cashDenominations } = await computeEventCashActualFromPersonCounts(eventId);
-      const cashExpected = financials.expectedCashByMethod.cash || 0;
-      const cashLine = {
-        id: uuidv4(),
-        method: 'cash',
-        expectedAmount: cashExpected,
-        actualAmount: cashActual,
-        variance: cashActual !== null ? cashActual - cashExpected : null,
-        notes: cashLineInput?.notes || null,
-        denominations: cashDenominations.length > 0 ? { create: cashDenominations } : undefined
-      };
-
-      cashupLines = [cashLine, ...nonCashLines];
+      const { actual: cashCounted, denominations: cashDenominations } = await computeEventCashActualFromPersonCounts(eventId);
+      cashupLines = ALL_METHODS.map(method => {
+        const input = lines.find(l => l && l.method === method) || {};
+        const expected = financials.expectedCashByMethod[method] || 0;
+        const settled = settleLine({ method, expected, counted: method === 'cash' ? cashCounted : null, input });
+        return {
+          id: uuidv4(),
+          method,
+          expectedAmount: expected,
+          actualAmount: settled.actual,
+          variance: settled.variance,
+          notes: input.notes || null,
+          bankAmount: settled.bankAmount,
+          onHandAmount: settled.onHandAmount,
+          pendingAmount: settled.pendingAmount,
+          pendingReference: settled.pendingReference,
+          writeOffTotal: settled.writeOffTotal,
+          writeOffs: settled.writeOffs.length > 0 ? { create: settled.writeOffs } : undefined,
+          denominations: method === 'cash' && cashDenominations.length > 0 ? { create: cashDenominations } : undefined
+        };
+      });
    }

    const totalActualRevenue = isFullCashup
@@ -142,7 +147,7 @@ const closeEvent = async (req, res) => {
        performedById: req.user.id,
        lines: { create: cashupLines }
      },
-      include: { lines: { include: { denominations: true } }, performedBy: { select: { id: true, name: true, email: true } } }
+      include: { lines: { include: { denominations: true, writeOffs: true } }, performedBy: { select: { id: true, name: true, email: true } } }
    });

    await prisma.event.update({
@@ -185,9 +190,33 @@ const reopenEvent = async (req, res) => {
      include: { performedBy: { select: { id: true, name: true, email: true } } }
    });

+    // Start the next cashup from the last one, with pending money that has since been
+    // received or written off folded in, so nothing has to be typed in again.
+    const lastClose = await prisma.eventCashup.findFirst({
+      where: { eventId, action: { in: ['closed', 'quick_closed'] } },
+      orderBy: { createdAt: 'desc' },
+      include: { lines: { include: { writeOffs: true, pendingResolutions: true } } }
+    });
+    const cashupDraft = lastClose && lastClose.lines.length > 0 ? {
+      lines: lastClose.lines.map(l => {
+        const settled = applyPendingResolutions(l);
+        return cleanDraftLine({
+          method: l.method,
+          bankAmount: settled.bank,
+          onHandAmount: settled.onHand,
+          pendingAmount: settled.pendingOutstanding || null,
+          pendingReference: settled.pendingOutstanding ? settled.pendingReference : null,
+          writeOffs: settled.writeOffs,
+          notes: l.notes
+        });
+      }),
+      notes: null,
+      savedAt: new Date().toISOString()
+    } : undefined;
+
    await prisma.event.update({
      where: { id: eventId },
-      data: { cashupStatus: 'open', reopenedAt: new Date(), reopenedById: req.user.id }
+      data: { cashupStatus: 'open', reopenedAt: new Date(), reopenedById: req.user.id, ...(cashupDraft ? { cashupDraft } : {}) }
    });

    res.status(201).json(auditRow);
@@ -196,6 +225,66 @@ const reopenEvent = async (req, res) => {
  }
 };

+// @desc    Settle money that was pending when the event was closed (on the card report, or a
+//          POP we hadn't seen in the bank yet): it has now reached the bank, or it never will and
+//          is written off. Allowed while the event is closed — no reopen needed.
+// @route   POST /api/cashups/lines/:lineId/pending
+// @access  Private/Admin
+const resolvePending = async (req, res) => {
+  try {
+    const { lineId } = req.params;
+    const { outcome, amount, category, notes } = req.body;
+
+    if (!PENDING_OUTCOMES.includes(outcome)) {
+      res.status(400);
+      throw new Error('Say whether the money was received or written off');
+    }
+    const value = Math.round(Number(amount) * 100) / 100;
+    if (!Number.isFinite(value) || value <= 0) {
+      res.status(400);
+      throw new Error('Enter an amount more than R0');
+    }
+
+    const resolution = await prisma.$transaction(async (tx) => {
+      // Lock the line so two people settling at once can't settle more than is pending.
+      await tx.$executeRaw`SELECT 1 FROM "EventCashupLine" WHERE id = ${lineId} FOR UPDATE`;
+      const line = await tx.eventCashupLine.findUnique({
+        where: { id: lineId },
+        include: { cashup: { select: { id: true, eventId: true } }, pendingResolutions: true }
+      });
+      if (!line) {
+        res.status(404);
+        throw new Error('Cashup line not found');
+      }
+      const latest = await tx.eventCashup.findFirst({ where: { eventId: line.cashup.eventId }, orderBy: { createdAt: 'desc' }, select: { id: true } });
+      if (!latest || latest.id !== line.cashupId) {
+        res.status(400);
+        throw new Error('Only the current cashup of a closed event can be updated');
+      }
+      const { pendingOutstanding } = applyPendingResolutions(line);
+      if (value > pendingOutstanding + 0.005) {
+        res.status(400);
+        throw new Error(`Only R${pendingOutstanding.toFixed(2)} is still pending`);
+      }
+      return tx.eventCashupPendingResolution.create({
+        data: {
+          lineId,
+          outcome,
+          amount: value,
+          category: outcome === 'written_off' ? (WRITE_OFF_CATEGORIES.includes(category) ? category : 'other') : null,
+          notes: notes ? String(notes).trim().slice(0, 200) : null,
+          performedById: req.user.id
+        },
+        include: { performedBy: { select: { id: true, name: true } } }
+      });
+    });
+
+    res.status(201).json(resolution);
+  } catch (error) {
+    res.status(res.statusCode === 200 ? 400 : res.statusCode).json({ message: safeErrorMessage(error) });
+  }
+};
+
 // @desc    Flat audit log of every close/quick-close/reopen, optionally filtered
 // @route   GET /api/cashups/audit
 // @access  Private/Supervisor
@@ -234,5 +323,6 @@ module.exports = {
  saveEventCashupDraft,
  closeEvent,
  reopenEvent,
+  resolvePending,
  getCashupAudit
 };
@@ -4,6 +4,7 @@ const { logAdminAction } = require('../utils/adminAudit');
 const { getClientIp } = require('../utils/requestUtils');
 const { normalizeCode, previewCoupon, buildCouponLines, describeCoupon, countCouponUses } = require('../utils/coupons');
 const { resolveOptionPrice, resolveVariantTierPrice } = require('../utils/pricing');
+const { describeBundle } = require('../utils/bundles');

 const TYPES = ['percent', 'fixed', 'comp'];
 const ROLES = ['user', 'staff', 'supervisor', 'admin'];
@@ -231,6 +232,39 @@ const updateCoupon = async (req, res) => {
  }
 };

+/**
+ * Who a basket is being priced for: the logged-in buyer, or, for staff, the attendee
+ * (`forUserId`) or a walk-in with no account yet (`forUserId: null`).
+ */
+async function basketBuyer(req, forUserId) {
+  const isStaff = !!(req.user && STAFF_ROLES.includes(req.user.role));
+  let buyer = req.user ? { id: req.user.id, role: req.user.role, email: req.user.email } : null;
+  if (isStaff && forUserId) {
+    buyer = await prisma.user.findUnique({ where: { id: forUserId }, select: { id: true, role: true, email: true } });
+  } else if (isStaff && forUserId === null) {
+    buyer = null; // a walk-in without an account yet
+  }
+  return { buyer, isStaff };
+}
+
+/** Prices a basket the same way registration will, as coupon/bundle lines. */
+async function priceBasket(event, options, buyer) {
+  const registrationOptions = [];
+  for (const o of options || []) {
+    const eo = event.eventOptions.find(x => x.id === o.eventOptionId);
+    const qty = Number(o.quantity || 0);
+    if (!eo || qty < 1) continue;
+    const resolved = o.variantId
+      ? await resolveVariantTierPrice(eo, o.variantId, qty, buyer)
+      : await resolveOptionPrice(eo, qty, buyer);
+    registrationOptions.push({
+      eventOptionId: eo.id, variantId: o.variantId || null, quantity: qty, eventOption: eo,
+      tranches: [{ quantity: qty, priceSnapshot: resolved.price, appliedTierId: resolved.tierId }],
+    });
+  }
+  return buildCouponLines({ registrationOptions });
+}
+
 // @desc    Check a code against the items someone is about to register for
 // @route   POST /api/coupons/validate
 // @access  Public (login needed for restricted codes)
@@ -249,33 +283,12 @@ const validateCode = async (req, res) => {
    });
    if (!event) { res.status(404); throw new Error('Event not found'); }

-    const isStaff = req.user && STAFF_ROLES.includes(req.user.role);
-    let buyer = req.user ? { id: req.user.id, role: req.user.role, email: req.user.email } : null;
-    if (isStaff && forUserId) {
-      buyer = await prisma.user.findUnique({ where: { id: forUserId }, select: { id: true, role: true, email: true } });
-    } else if (isStaff && forUserId === null) {
-      buyer = null; // a walk-in without an account yet
-    }
-
-    // Price the basket the same way registration will.
-    const registrationOptions = [];
-    for (const o of options) {
-      const eo = event.eventOptions.find(x => x.id === o.eventOptionId);
-      const qty = Number(o.quantity || 0);
-      if (!eo || qty < 1) continue;
-      const resolved = o.variantId
-        ? await resolveVariantTierPrice(eo, o.variantId, qty, buyer)
-        : await resolveOptionPrice(eo, qty, buyer);
-      registrationOptions.push({
-        eventOptionId: eo.id, variantId: o.variantId || null, quantity: qty, eventOption: eo,
-        tranches: [{ quantity: qty, priceSnapshot: resolved.price, appliedTierId: resolved.tierId }],
-      });
-    }
-    const lines = buildCouponLines({ registrationOptions });
+    const { buyer, isStaff } = await basketBuyer(req, forUserId);
+    const lines = await priceBasket(event, options, buyer);
    const subtotal = lines.reduce((s, l) => s + l.unitPrice * l.quantity, 0);

    try {
-      const { coupon, discount } = await previewCoupon({
+      const { coupon, discount, bundles } = await previewCoupon({
        code, eventId, user: buyer, lines,
        deferRestrictions: isStaff && !buyer,
      });
@@ -287,8 +300,10 @@ const validateCode = async (req, res) => {
        summary: describeCoupon(coupon),
        description: coupon.description,
        discount,
+        bundleDiscount: bundles.discount,
+        bundles: bundles.applications,
        subtotal,
-        total: Math.max(0, subtotal - discount),
+        total: Math.max(0, subtotal - bundles.discount - discount),
      });
    } catch (e) {
      if (!e.isCouponError) throw e;
@@ -299,7 +314,7 @@ const validateCode = async (req, res) => {
  }
 };

-// @desc    Coupon uses for the Discounts report
+// @desc    Coupon and bundle-deal uses for the Discounts report
 // @route   GET /api/coupons/redemptions?eventIds=a,b&from=&to=
 // @access  Private/Supervisor
 const listRedemptions = async (req, res) => {
@@ -322,10 +337,34 @@ const listRedemptions = async (req, res) => {
        registration: { select: { id: true, status: true, event: { select: { id: true, title: true } } } },
      },
    });
-    res.json(rows.map(r => ({ ...r, summary: describeCoupon(r.coupon) })));
+    // Bundle deals, in the same shape. Their rows are rebuilt whenever a registration's
+    // discounts are recalculated, so dates go by when the registration was made.
+    const regDate = from || to ? { createdAt: { ...(from && !isNaN(from) ? { gte: from } : {}), ...(to && !isNaN(to) ? { lte: to } : {}) } } : {};
+    const bundleRows = await prisma.registrationBundle.findMany({
+      where: { registration: { status: { not: 'cancelled' }, ...(eventIds.length ? { eventId: { in: eventIds } } : {}), ...regDate } },
+      include: {
+        bundle: { include: { items: { include: { eventOption: { select: { name: true } }, variant: { select: { name: true } } } } } },
+        registration: { select: { id: true, status: true, createdAt: true, user: { select: { id: true, name: true, email: true } }, event: { select: { id: true, title: true } } } },
+      },
+    });
+    res.json([
+      ...rows.map(r => ({ ...r, kind: 'coupon', uses: 1, summary: describeCoupon(r.coupon) })),
+      ...bundleRows.map(b => ({
+        id: b.id,
+        kind: 'bundle',
+        uses: b.count,
+        discountAmount: b.discount,
+        createdAt: b.registration.createdAt,
+        summary: describeBundle(b.bundle),
+        coupon: { id: b.bundleId, code: b.bundle.name },
+        user: b.registration.user,
+        appliedBy: null,
+        registration: { id: b.registration.id, status: b.registration.status, event: b.registration.event },
+      })),
+    ]);
  } catch (error) {
    res.status(res.statusCode === 200 ? 400 : res.statusCode).json({ message: safeErrorMessage(error) });
  }
 };

-module.exports = { listCoupons, getCoupon, createCoupon, updateCoupon, validateCode, listRedemptions };
+module.exports = { listCoupons, getCoupon, createCoupon, updateCoupon, validateCode, listRedemptions, basketBuyer, priceBasket };
@@ -457,6 +457,7 @@ const getEventById = async (req, res) => {
        url: toAbsoluteUrl(req, att.url)
      })),
      form,
+      bundles: await require('./bundleController').publicBundlesForEvent(eventId).catch(() => []),
    };
    res.json(mapped);
  } catch (error) {
@@ -917,25 +917,27 @@ const unassignDonationFromRegistration = async (req, res) => {
 /**
 * Yoco line items for a registration: one per item at each price actually charged
 * (tranche-aware, so a line bought partly at early-bird shows both prices), plus the
- * coupon discount as a negative line. Previous/partial payment lines are added by callers.
+ * bundle saving and coupon discount as negative lines. Previous/partial payment lines are
+ * added by callers.
 */
 function checkoutLineItems(registration) {
-  const { buildLineItems, couponDiscountLine } = require('../utils/pdfDocs');
+  const { buildLineItems, discountLines } = require('../utils/pdfDocs');
  const items = buildLineItems(registration.registrationOptions).map(row => ({
    displayName: row.label + (row.isEarlyBird ? ' (early bird)' : ''),
    quantity: row.quantity,
    pricingDetails: { price: Math.round(row.unitPrice * 100) },
  }));
-  const coupon = couponDiscountLine(registration);
-  if (coupon) {
-    items.push({ displayName: coupon.label, quantity: 1, pricingDetails: { price: -Math.round(coupon.amount * 100) } });
+  for (const line of discountLines(registration)) {
+    items.push({ displayName: line.label, quantity: 1, pricingDetails: { price: -Math.round(line.amount * 100) } });
  }
  return items;
 }

 // Internal helper: create a Yoco checkout for a registration and return { checkoutId, redirectUrl, amount }
 // Does NOT check user authorization — callers are responsible for ensuring the user owns the registration.
-async function createRegistrationCheckoutInternal(registrationId, userId, { successUrl, cancelUrl, failureUrl } = {}) {
+// donationAmount (optional) is added on top as its own line; the webhook splits it off into a
+// separate donation payment using the amount carried in the checkout metadata.
+async function createRegistrationCheckoutInternal(registrationId, userId, { successUrl, cancelUrl, failureUrl, donationAmount = 0 } = {}) {
  const registration = await prisma.registration.findUnique({
    where: { id: registrationId },
    include: {
@@ -947,7 +949,7 @@ async function createRegistrationCheckoutInternal(registrationId, userId, { succ
        }
      },
      payments: true,
-      couponRedemptions: { where: { releasedAt: null }, include: { coupon: { select: { code: true } } } },
+      couponRedemptions: { where: { releasedAt: null }, include: { coupon: { select: { code: true } } } }, bundleApplications: { include: { bundle: { select: { name: true } } } },
      user: { select: { id: true, name: true, email: true } },
      event: true
    }
@@ -961,7 +963,8 @@ async function createRegistrationCheckoutInternal(registrationId, userId, { succ

  if (remainingAmount <= 0) throw new Error('This registration is already paid in full');

-  const amountInCents = Math.round(remainingAmount * 100);
+  const donationInCents = Math.round((Number(donationAmount) || 0) * 100);
+  const amountInCents = Math.round(remainingAmount * 100) + donationInCents;
  const idempotencyKey = `reg_${registrationId}_${amountInCents}_${Date.now()}`;
  const lineItems = checkoutLineItems(registration);

@@ -974,11 +977,17 @@ async function createRegistrationCheckoutInternal(registrationId, userId, { succ
    });
  }
  // Paying full remaining — no "Partial Payment" line needed
+  if (donationInCents > 0) {
+    lineItems.push({ displayName: 'Donation', quantity: 1, pricingDetails: { price: donationInCents } });
+  }

  const checkoutData = {
    amount: amountInCents,
    currency: 'ZAR',
-    metadata: { registrationId, userId, eventId: registration.eventId, eventTitle: registration.event.title, type: 'registration_payment' },
+    metadata: {
+      registrationId, userId, eventId: registration.eventId, eventTitle: registration.event.title, type: 'registration_payment',
+      ...(donationInCents > 0 ? { donationAmount: (donationInCents / 100).toFixed(2) } : {})
+    },
    successUrl,
    cancelUrl,
    failureUrl,
@@ -999,7 +1008,7 @@ async function createRegistrationCheckoutInternal(registrationId, userId, { succ
  return {
    checkoutId: response.data.id,
    redirectUrl: response.data.redirectUrl,
-    amount: remainingAmount,
+    amount: amountInCents / 100,
    registration: { id: registration.id, eventId: registration.eventId, eventTitle: registration.event.title }
  };
 }
@@ -1009,7 +1018,7 @@ async function createRegistrationCheckoutInternal(registrationId, userId, { succ
 // @access  Private
 const createYocoCheckout = async (req, res) => {
  try {
-    const { registrationId, eventId, amount, successUrl, cancelUrl, failureUrl } = req.body;
+    const { registrationId, eventId, amount, donationAmount, successUrl, cancelUrl, failureUrl } = req.body;
    const userId = req.user.id;

    // Validate required parameters for either registration payment or donation
@@ -1067,7 +1076,7 @@ const createYocoCheckout = async (req, res) => {
              }
            },
            payments: true,
-            couponRedemptions: { where: { releasedAt: null }, include: { coupon: { select: { code: true } } } },
+            couponRedemptions: { where: { releasedAt: null }, include: { coupon: { select: { code: true } } } }, bundleApplications: { include: { bundle: { select: { name: true } } } },
            user: { select: { id: true, name: true, email: true } },
            event: true
          }
@@ -1096,7 +1105,15 @@ const createYocoCheckout = async (req, res) => {
        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 } });
      }

-      const result = await createRegistrationCheckoutInternal(registrationId, userId, { successUrl, cancelUrl, failureUrl });
+      // Optional donation added at registration ("Donation amount" on the register form)
+      let donation = 0;
+      if (donationAmount !== undefined && donationAmount !== null && donationAmount !== '') {
+        donation = Math.round(parseFloat(donationAmount) * 100) / 100;
+        if (!(donation >= 0) || donation > 100000) { res.status(400); throw new Error('Invalid donation amount'); }
+        if (donation > 0 && donation < 15) { res.status(400); throw new Error('Minimum donation is R15'); }
+      }
+
+      const result = await createRegistrationCheckoutInternal(registrationId, userId, { successUrl, cancelUrl, failureUrl, donationAmount: donation });
      return res.status(200).json(result);
    }

@@ -51,6 +51,7 @@ const ACTIVE_COUPONS_INCLUDE = {
  where: { releasedAt: null },
  select: { id: true, discountAmount: true, createdAt: true, coupon: { select: { id: true, code: true, type: true, value: true, description: true } } },
 };
+const { BUNDLE_APPS_INCLUDE } = require('../utils/bundles');

 /**
 * Coupon lines for options that haven't been saved yet, so a code can be checked
@@ -429,9 +430,9 @@ const createRegistration = async (req, res) => {
      await prisma.registration.update({ where: { id: registration.id }, data: { ticketDelivery } });
    }

-    // Apply the coupon (or re-work an existing one over the merged items).
+    // Bundle deals, then the coupon (or re-work an existing one over the merged items).
    let couponError = null;
-    if (!isNewRegistration) await recalculateRegistrationDiscount(registration.id);
+    const hasDiscount = (await recalculateRegistrationDiscount(registration.id)) > 0;
    if (couponCode) {
      try {
        await applyCouponToRegistration({ registrationId: registration.id, code: couponCode });
@@ -441,7 +442,7 @@ const createRegistration = async (req, res) => {
        couponError = e.message;
      }
    }
-    if (couponCode || !isNewRegistration || cleanAttendees.length > 0 || ticketDelivery) {
+    if (couponCode || hasDiscount || !isNewRegistration || cleanAttendees.length > 0 || ticketDelivery) {
      registration = await prisma.registration.findUnique({
        where: { id: registration.id },
        include: {
@@ -449,6 +450,8 @@ const createRegistration = async (req, res) => {
          event: true,
          user: { select: { id: true, name: true, email: true, phoneNumber: true } },
          couponRedemptions: ACTIVE_COUPONS_INCLUDE,
+
+          bundleApplications: BUNDLE_APPS_INCLUDE,
          attendees: ATTENDEES_INCLUDE,
        }
      });
@@ -522,6 +525,8 @@ const getRegistrations = async (req, res) => {
  try {
    const include = {
      couponRedemptions: ACTIVE_COUPONS_INCLUDE,
+
+      bundleApplications: BUNDLE_APPS_INCLUDE,
      attendees: ATTENDEES_INCLUDE,
      payments: { include: { recordedBy: { select: { id: true, name: true, email: true } } } },
      registrationOptions: {
@@ -601,6 +606,8 @@ const getUserRegistrations = async (req, res) => {
          }
        },
        couponRedemptions: ACTIVE_COUPONS_INCLUDE,
+
+        bundleApplications: BUNDLE_APPS_INCLUDE,
        attendees: ATTENDEES_INCLUDE,
        formResponses: { select: { id: true, attendeeId: true } },
        // Nest the event's form so the frontend can tell whether attendee forms are
@@ -651,6 +658,8 @@ const getRegistrationById = async (req, res) => {
      payments: { include: { recordedBy: { select: { id: true, name: true, email: true } } } },
      formResponses: { include: { answers: true } },
      couponRedemptions: ACTIVE_COUPONS_INCLUDE,
+
+      bundleApplications: BUNDLE_APPS_INCLUDE,
      attendees: ATTENDEES_INCLUDE,
    };

@@ -894,6 +903,8 @@ const getRegistrationsByEvent = async (req, res) => {
        payments: { include: { recordedBy: { select: { id: true, name: true, email: true } } } },
        user: { select: { id: true, name: true, email: true, phoneNumber: true, notificationPreference: true, isActive: true } },
        couponRedemptions: ACTIVE_COUPONS_INCLUDE,
+
+        bundleApplications: BUNDLE_APPS_INCLUDE,
        attendees: ATTENDEES_INCLUDE,
      },
      orderBy: { createdAt: 'asc' }
@@ -1225,6 +1236,8 @@ const createManualRegistration = async (req, res) => {
          event: true,
          user: { select: { id: true, name: true, email: true, phoneNumber: true } },
          couponRedemptions: ACTIVE_COUPONS_INCLUDE,
+
+          bundleApplications: BUNDLE_APPS_INCLUDE,
        },
      });
      registration.status = newExistingStatus;
@@ -1262,6 +1275,7 @@ const createManualRegistration = async (req, res) => {
          user: { select: { id: true, name: true, email: true, phoneNumber: true } },
        },
      });
+      const hasDiscount = (await recalculateRegistrationDiscount(registration.id)) > 0;
      if (couponCode) {
        try {
          await applyCouponToRegistration({ registrationId: registration.id, code: couponCode, appliedById: req.user.id });
@@ -1269,6 +1283,8 @@ const createManualRegistration = async (req, res) => {
          if (!e.isCouponError) throw e;
          couponError = e.message;
        }
+      }
+      if (couponCode || hasDiscount) {
        registration = await prisma.registration.findUnique({
          where: { id: registration.id },
          include: {
@@ -1276,6 +1292,8 @@ const createManualRegistration = async (req, res) => {
            event: true,
            user: { select: { id: true, name: true, email: true, phoneNumber: true } },
            couponRedemptions: ACTIVE_COUPONS_INCLUDE,
+
+            bundleApplications: BUNDLE_APPS_INCLUDE,
          },
        });
      }
@@ -1717,6 +1735,8 @@ const updateRegistrationOptions = async (req, res) => {
        user: { select: { id: true, name: true, email: true, phoneNumber: true } },
        payments: true,
        couponRedemptions: ACTIVE_COUPONS_INCLUDE,
+
+        bundleApplications: BUNDLE_APPS_INCLUDE,
        attendees: ATTENDEES_INCLUDE,
      }
    });
@@ -2123,6 +2143,8 @@ const applyCoupon = async (req, res) => {
        registrationOptions: { include: { eventOption: true, variant: { select: { id: true, name: true, price: true } }, tranches: true } },
        payments: true,
        couponRedemptions: ACTIVE_COUPONS_INCLUDE,
+
+        bundleApplications: BUNDLE_APPS_INCLUDE,
      },
    });
    res.json({ ...attachComputedTotals(updated), message: `Code ${coupon.code} applied — ${describeCoupon(coupon)}.` });
@@ -845,6 +845,66 @@ function allocationLabel(attendee) {
    .join(' · ');
 }

+// One ticket card on the PDF, matching the printed design in frontend/src/lib/ticketPrint.ts.
+function drawTicketCard(doc, { x, y, w, h }, ticket, qrDataUrl, buyerName) {
+  const pad = 12; const radius = 9;
+  const innerW = w - pad * 2;
+  const gray700 = '#374151'; const gray500 = '#6b7280';
+
+  doc.save();
+  doc.roundedRect(x, y + 1.5, w, h, radius).fillOpacity(0.06).fill('#000000');
+  doc.restore();
+  doc.save();
+  doc.roundedRect(x, y, w, h, radius).lineWidth(0.75).fillAndStroke('#ffffff', '#e5e7eb');
+  doc.restore();
+
+  // Event title, with the date on the right of the same line
+  let cy = y + pad;
+  const eventDate = ticket.event.startDate ? new Date(ticket.event.startDate) : null;
+  const dateStr = eventDate ? new Intl.DateTimeFormat('en-GB', { day: '2-digit', month: 'long', year: 'numeric' }).format(eventDate) : '';
+  doc.font('Helvetica').fontSize(9);
+  const dateW = dateStr ? doc.widthOfString(dateStr) : 0;
+  if (dateStr) doc.fillColor(gray500).text(dateStr, x + w - pad - dateW, cy + 1, { width: dateW, lineBreak: false });
+  const titleW = innerW - (dateStr ? dateW + 8 : 0);
+  doc.font('Helvetica-Bold').fontSize(11).fillColor('#111827');
+  doc.text(ticket.event.title, x + pad, cy, { width: titleW });
+  cy += doc.heightOfString(ticket.event.title, { width: titleW }) + 4;
+
+  // Ticket type
+  const variantSuffix = ticket.registrationOption.variant ? ` — ${ticket.registrationOption.variant.name}` : '';
+  const type = `${ticket.registrationOption.eventOption.name}${variantSuffix}`;
+  doc.font('Helvetica').fontSize(10).fillColor(gray700).text(type, x + pad, cy, { width: innerW });
+  cy += doc.heightOfString(type, { width: innerW }) + 2;
+
+  // Name (named ticket) or quantity, value in bold
+  doc.font('Helvetica').fontSize(9).fillColor(gray700)
+    .text(ticket.attendee ? 'Name: ' : 'Qty: ', x + pad, cy, { continued: true })
+    .font('Helvetica-Bold').text(ticket.attendee ? ticket.attendee.name : String(ticket.quantity || 1));
+  cy += 12;
+  const groupLabel = allocationLabel(ticket.attendee);
+  if (groupLabel) {
+    doc.font('Helvetica').fontSize(9).fillColor(gray500).text(groupLabel, x + pad, cy, { width: innerW });
+    cy += doc.heightOfString(groupLabel, { width: innerW }) + 2;
+  }
+
+  // Footer lines are measured first so the QR code takes the remaining space
+  const footer = [`Ticket ID: ${ticket.id}`, ...(buyerName ? [`Purchased by: ${buyerName}`] : [])];
+  doc.font('Helvetica').fontSize(8.5);
+  const footerH = footer.reduce((sum, line) => sum + doc.heightOfString(line, { width: innerW }) + 2, 0);
+  const qrSpace = (y + h - pad - footerH) - (cy + 6) - 6;
+  const qrSize = Math.max(60, Math.min(130, qrSpace));
+  const qrY = cy + 6 + Math.max(0, (qrSpace - qrSize) / 2);
+  doc.image(qrDataUrl, x + (w - qrSize) / 2, qrY, { width: qrSize, height: qrSize });
+
+  let fy = y + h - pad - footerH;
+  doc.fillColor(gray500);
+  for (const line of footer) {
+    doc.text(line, x + pad, fy, { width: innerW, align: 'center' });
+    fy += doc.heightOfString(line, { width: innerW }) + 2;
+  }
+  doc.fillColor('#000000');
+}
+
 // Internal helper used by both emailTickets and sendTicketsTo
 async function emailTicketsInternal(req, res, userOverride) {
  const { ticketIds, registrationId } = req.body;
@@ -951,32 +1011,22 @@ async function emailTicketsInternal(req, res, userOverride) {
  const doc = new PDFDocument({ size: 'A4', margin: 20 });
  const writeStream = fs.createWriteStream(tempFilePath);
  doc.pipe(writeStream);
-  const pageWidth = doc.page.width - 40; const pageHeight = doc.page.height - 40;
-  const ticketsPerRow = 2; const ticketsPerColumn = 4;
-  const ticketWidth = pageWidth / ticketsPerRow; const ticketHeight = pageHeight / ticketsPerColumn;
+  // Same card design as the printed tickets (frontend/src/lib/ticketPrint.ts): rounded white
+  // cards with a light border and soft shadow, two columns, three rows per page.
+  const margin = 20; const gap = 12;
+  const ticketsPerRow = 2; const ticketsPerColumn = 3;
+  const ticketWidth = (doc.page.width - margin * 2 - gap * (ticketsPerRow - 1)) / ticketsPerRow;
+  const ticketHeight = (doc.page.height - margin * 2 - gap * (ticketsPerColumn - 1)) / ticketsPerColumn;
  const qrCodes = await Promise.all(tickets.map(ticket => new Promise((resolve, reject) => {
-    QRCode.toDataURL(ticket.qrCode, (err, url) => err ? reject(err) : resolve({ ticketId: ticket.id, qrDataUrl: url }));
+    QRCode.toDataURL(ticket.qrCode, { margin: 1, width: 400 }, (err, url) => err ? reject(err) : resolve({ ticketId: ticket.id, qrDataUrl: url }));
  })));
  const qrCodeMap = qrCodes.reduce((map, item) => { map[item.ticketId] = item.qrDataUrl; return map; }, {});
  let ticketIndex = 0;
  for (const ticket of tickets) {
-    const row = Math.floor(ticketIndex % ticketsPerColumn);
-    const col = Math.floor((ticketIndex / ticketsPerColumn) % ticketsPerRow);
-    const x = col * ticketWidth + 20; const y = row * ticketHeight + 20;
-    doc.rect(x, y, ticketWidth, ticketHeight).stroke();
-    doc.font('Helvetica-Bold').fontSize(12).text(ticket.event.title, x + 10, y + 10, { width: ticketWidth - 20 });
-    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 });
-    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 });
-    const qrCodeSize = Math.min(ticketWidth, ticketHeight) * 0.45;
-    const qrX = x + (ticketWidth - qrCodeSize) / 2; const qrY = y + 90;
-    doc.image(qrCodeMap[ticket.id], qrX, qrY, { width: qrCodeSize, height: qrCodeSize });
-    doc.fontSize(8).text(`Ticket ID: ${ticket.id}`, x + 10, qrY + qrCodeSize + 5, { width: ticketWidth - 20, align: 'center' });
+    const slot = ticketIndex % (ticketsPerRow * ticketsPerColumn);
+    const x = margin + (slot % ticketsPerRow) * (ticketWidth + gap);
+    const y = margin + Math.floor(slot / ticketsPerRow) * (ticketHeight + gap);
+    drawTicketCard(doc, { x, y, w: ticketWidth, h: ticketHeight }, ticket, qrCodeMap[ticket.id], ticket.user?.name || user.name);
    ticketIndex++;
    if (ticketIndex % (ticketsPerRow * ticketsPerColumn) === 0 && ticketIndex < tickets.length) doc.addPage();
  }
@@ -314,11 +314,18 @@ const handlePaymentSucceeded = async (webhookData) => {
      } catch (e) { /* ignore — payment will fail below if still null */ }
    }

+    // A registration checkout can carry a donation on top (metadata.donationAmount). It's
+    // recorded as its own donation payment so it never counts towards the registration.
+    const grossAmount = amount / 100; // Convert cents to your currency unit
+    const donationPart = registration?.id
+      ? Math.min(Math.max(Number(metadata?.donationAmount) || 0, 0), grossAmount)
+      : 0;
+
    // Create payment record
    const payment = await prisma.payment.create({
      data: {
        id: uuidv4(), // Generate a UUID for the payment
-        amount: amount / 100, // Convert cents to your currency unit
+        amount: Math.round((grossAmount - donationPart) * 100) / 100,
        method: method.type, // The type of payment from the webhook
        status: status === 'succeeded' ? 'completed' : status,
        externalId: yocoPaymentId,
@@ -358,6 +365,24 @@ const handlePaymentSucceeded = async (webhookData) => {
      }
    });
    
+    let donationPayment = null;
+    if (donationPart > 0) {
+      donationPayment = await prisma.payment.create({
+        data: {
+          id: uuidv4(),
+          amount: donationPart,
+          method: method.type,
+          status: status === 'succeeded' ? 'completed' : status,
+          userId: resolvedUserId,
+          recordedById: resolvedUserId,
+          registrationId: null,
+          eventId: registration.eventId,
+          isDonation: true,
+          originalPaymentId: payment.id,
+        }
+      });
+    }
+
    // If this payment is for a registration, update the registration status
    let updatedRegistration = null;
    let generatedTickets = [];
@@ -392,6 +417,7 @@ const handlePaymentSucceeded = async (webhookData) => {

    // Send emails: payment confirmation first, then tickets (guarantees order)
    const _whPaymentId = payment.id;
+    const _whDonationId = donationPayment?.id;
    const _whUserId = registration?.userId;
    const _whRegId = registration?.id;
    const _whTicketsGenerated = generatedTickets.length > 0;
@@ -402,6 +428,14 @@ const handlePaymentSucceeded = async (webhookData) => {
      } catch (e) {
        console.error('Failed to send webhook payment emails:', e);
      }
+      if (_whDonationId) {
+        try {
+          const { sendPaymentEmails } = require('../utils/notifications');
+          await sendPaymentEmails(_whDonationId);
+        } catch (e) {
+          console.error('Failed to send webhook donation emails:', e);
+        }
+      }
      if (_whTicketsGenerated && _whUserId && _whRegId) {
        const mockReq = { user: { id: _whUserId }, body: { registrationId: _whRegId } };
        const mockRes = { status: () => mockRes, json: () => {} };
@@ -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;
@@ -181,6 +178,7 @@ app.use('/api', costRoutes);
 app.use('/api/cashups', cashupRoutes);
 app.use('/api/admin', adminRoutes);
 app.use('/api/coupons', require('./routes/couponRoutes'));
+app.use('/api/bundles', require('./routes/bundleRoutes'));
 app.use('/api/consent', require('./routes/consentRoutes'));
 app.use('/api/waitlist', require('./routes/waitlistRoutes'));
 app.use('/api/scan-locks', require('./routes/scanLockRoutes'));
@@ -757,7 +755,7 @@ app.get('/docs', async (req, res) => {
      { method:'POST', path:'/api/coupons/validate', auth:'public', desc:'Check a code against a basket before registering; returns the discount. Login needed for restricted codes; staff can pass forUserId (or null for a walk-in).',
        request:{ body:{ code:'STAFF50', eventId:'ev-uuid-...', options:[{ eventOptionId:'opt-uuid-...', quantity:2 }] }},
        responses:[
-          { status:200, desc:'Valid', body:{ valid:true, code:'STAFF50', type:'percent', value:50, summary:'50% off', discount:450, subtotal:900, total:450 }},
+          { status:200, desc:'Valid (bundle deals come off first, then the code)', body:{ valid:true, code:'STAFF50', type:'percent', value:50, summary:'50% off', discount:450, bundleDiscount:0, bundles:[], subtotal:900, total:450 }},
          { status:400, desc:'Not usable', body:{ valid:false, message:'This code has expired.' }},
        ]},
      { method:'GET', path:'/api/coupons', auth:'supervisor+', desc:'List codes with use counts and total discount given',
@@ -769,6 +767,16 @@ app.get('/docs', async (req, res) => {
      { method:'PUT', path:'/api/coupons/:id', auth:'supervisor+', desc:'Edit a code or turn it off ({ active:false }). Discounts already given keep their amount; a used code can\'t be renamed.' },
      { method:'GET', path:'/api/coupons/redemptions', auth:'supervisor+', desc:'Active uses for the Discounts report. Query: eventIds (comma-separated), from, to' },
    ]},
+    { title: 'Bundle deals', base: '/api/bundles', endpoints: [
+      { method:'POST', path:'/api/bundles/quote', auth:'public', desc:'The bundle deals a basket gets, applied automatically as many times as they fit and only when cheaper. Staff can pass forUserId (or null for a walk-in).',
+        request:{ body:{ eventId:'ev-uuid-...', options:[{ eventOptionId:'opt-adult', quantity:5 }, { eventOptionId:'opt-child', quantity:3 }] }},
+        responses:[{ status:200, desc:'Success', body:{ subtotal:550, bundleDiscount:50, bundles:[{ bundleId:'bnd-uuid-...', name:'Family deal', count:1, discount:50 }], total:500 }}]},
+      { method:'GET', path:'/api/bundles/event/:eventId', auth:'supervisor+', desc:'An event\'s bundles with uses and total discount given' },
+      { method:'POST', path:'/api/bundles/event/:eventId', auth:'supervisor+', desc:'Create a bundle. kind: exact (items with quantities, price for the set) | mix (any setSize of the items for price) | free (any setSize, cheapest freeCount free) | group (setSize or more of the items: groupPricing per_ticket price each, or percent off). items: [{ eventOptionId, variantId?, quantity }] (variantId left out = any variant; quantity only for exact).',
+        request:{ body:{ name:'Family deal', price:500, items:[{ eventOptionId:'opt-adult', quantity:5 }, { eventOptionId:'opt-child', quantity:3 }], validUntil:null }}},
+      { method:'PUT', path:'/api/bundles/:id', auth:'supervisor+', desc:'Edit a bundle or switch it off ({ isActive:false }). Registrations keep a bundle they already have.' },
+      { method:'DELETE', path:'/api/bundles/:id', auth:'supervisor+', desc:'Delete a bundle; one that has been used is switched off instead' },
+    ]},
    { 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' },
@@ -0,0 +1,14 @@
+const express = require('express');
+const router = express.Router();
+const { listBundles, createBundle, updateBundle, deleteBundle, quoteBundles } = require('../controllers/bundleController');
+const { protect, supervisor, optionalAuth } = require('../middleware/authMiddleware');
+
+// What a basket gets off before registering (guests included)
+router.post('/quote', optionalAuth, quoteBundles);
+
+router.get('/event/:eventId', protect, supervisor, listBundles);
+router.post('/event/:eventId', protect, supervisor, createBundle);
+router.put('/:id', protect, supervisor, updateBundle);
+router.delete('/:id', protect, supervisor, deleteBundle);
+
+module.exports = router;
@@ -1,6 +1,6 @@
 const express = require('express');
 const router = express.Router();
-const { getEventCashup, getCashByRecordedUser, savePersonCash, saveEventCashupDraft, closeEvent, reopenEvent, getCashupAudit } = require('../controllers/cashupController');
+const { getEventCashup, getCashByRecordedUser, savePersonCash, saveEventCashupDraft, closeEvent, reopenEvent, resolvePending, getCashupAudit } = require('../controllers/cashupController');
 const { protect, supervisor, admin } = require('../middleware/authMiddleware');

 router.get('/audit', protect, supervisor, getCashupAudit);
@@ -10,5 +10,6 @@ router.put('/event/:eventId/person-cash/:userId', protect, supervisor, savePerso
 router.put('/event/:eventId/draft', protect, admin, saveEventCashupDraft);
 router.post('/event/:eventId/close', protect, admin, closeEvent);
 router.post('/event/:eventId/reopen', protect, admin, reopenEvent);
+router.post('/lines/:lineId/pending', protect, admin, resolvePending);

 module.exports = router;
@@ -0,0 +1,255 @@
+/**
+ * Bundle deals — tickets sold together at a better price. Four kinds:
+ * - exact: these tickets in these numbers for a set price, e.g. 5 Adult + 3 Child for R500.
+ * - mix:   any `setSize` of the qualifying tickets for a set price, e.g. any 4 for R250.
+ * - free:  any `setSize` qualifying tickets with the cheapest `freeCount` free, e.g.
+ *          buy 3 get 1 free (setSize 4, freeCount 1).
+ * - group: `setSize` or more qualifying tickets, all of them at `price` each
+ *          (groupPricing per_ticket) or `price`% off (percent).
+ *
+ * Rules:
+ * - Applied automatically: no code needed. exact, mix and free apply as many times as
+ *   the registration's items allow; leftover items are charged as usual. A group
+ *   discount applies once, to every qualifying ticket.
+ * - Best price wins: a bundle only counts when it beats what its items cost at the
+ *   prices actually charged (early-bird, staff price), so it never makes anything
+ *   dearer. A group discount never raises a ticket's price. The most expensive matching
+ *   units go into a bundle first, and when several bundles compete the one saving the
+ *   most is applied first.
+ * - A bundle item with no variant matches any variant of its option.
+ * - Coupons are worked out after bundles, on what's left: bundled units are passed on
+ *   to the coupon code at their share of the bundle price (see utils/coupons.js).
+ * - The discount is stored on Registration.bundleDiscount (and included in
+ *   discountTotal), with one RegistrationBundle row per bundle used.
+ * - A registration keeps any bundle it already has, even after the bundle is switched
+ *   off or its dates pass, so editing a registration never takes a deal away.
+ */
+
+const prisma = require('../config/db');
+
+const round2 = (n) => Math.round(Number(n || 0) * 100) / 100;
+const fmtR = (n) => `R${Number(n || 0).toFixed(2).replace(/\.00$/, '')}`;
+
+const KINDS = ['exact', 'mix', 'free', 'group'];
+
+/** Whether a bundle's settings make sense (bad rows are skipped, never applied). */
+function isBundleUsable(bundle) {
+  const items = (bundle?.items || []).filter(i => i && i.eventOptionId);
+  if (items.length === 0 || !(Number(bundle.price) >= 0)) return false;
+  const kind = bundle.kind || 'exact';
+  const size = Number(bundle.setSize);
+  if (kind === 'exact') return items.some(i => Number(i.quantity) > 0);
+  if (!Number.isInteger(size) || size < 1) return false;
+  if (kind === 'free') return Number.isInteger(Number(bundle.freeCount)) && bundle.freeCount >= 1 && bundle.freeCount < size;
+  if (kind === 'group' && bundle.groupPricing === 'percent') return Number(bundle.price) > 0 && Number(bundle.price) <= 100;
+  return KINDS.includes(kind);
+}
+
+/** Whether a bundle can be offered right now (switched on, within its dates, set up properly). */
+function isBundleAvailable(bundle, now = new Date()) {
+  if (!bundle || !bundle.isActive) return false;
+  if (bundle.validFrom && now < new Date(bundle.validFrom)) return false;
+  if (bundle.validUntil && now > new Date(bundle.validUntil)) return false;
+  return isBundleUsable(bundle);
+}
+
+const itemMatches = (item, line) => item.eventOptionId === line.eventOptionId && (!item.variantId || item.variantId === line.variantId);
+const qualifies = (bundle, line) => (bundle.items || []).some(i => itemMatches(i, line));
+
+/** Takes up to `need` units from matching pool lines, dearest first. Mutates `left`. */
+function takeDearest(pool, left, need, matches) {
+  const takes = [];
+  const candidates = pool
+    .map((p, index) => ({ p, index }))
+    .filter(({ p, index }) => left[index] > 0 && matches(p.line))
+    .sort((a, b) => b.p.line.unitPrice - a.p.line.unitPrice);
+  for (const { p, index } of candidates) {
+    if (need === 0) break;
+    const q = Math.min(need, left[index]);
+    left[index] -= q;
+    need -= q;
+    takes.push({ index, quantity: q, unitPrice: p.line.unitPrice });
+  }
+  return need > 0 ? null : takes;
+}
+
+// Every unit at the same share of a set price.
+const atSetPrice = (takes, price) => {
+  const charged = takes.reduce((s, t) => s + t.quantity * t.unitPrice, 0);
+  const ratio = charged > 0 ? price / charged : 0;
+  return { charged, takes: takes.map(t => ({ ...t, newPrice: t.unitPrice * ratio })) };
+};
+
+/**
+ * Works out one application of `bundle` against what's left in `pool`, without changing
+ * it. Returns { takes: [{ index, quantity, newPrice }], saving } or null when the
+ * bundle can't apply.
+ */
+function tryBundle(bundle, pool) {
+  const left = pool.map(p => p.remaining);
+  const kind = bundle.kind || 'exact';
+  const price = Number(bundle.price || 0);
+  let priced;
+
+  if (kind === 'exact') {
+    // Variant-specific items first, so an "any variant" item can't use up the units a
+    // specific one needs.
+    const items = [...bundle.items].filter(i => Number(i.quantity) > 0).sort((a, b) => (b.variantId ? 1 : 0) - (a.variantId ? 1 : 0));
+    const takes = [];
+    for (const item of items) {
+      const got = takeDearest(pool, left, Number(item.quantity), line => itemMatches(item, line));
+      if (!got) return null;
+      takes.push(...got);
+    }
+    priced = atSetPrice(takes, price);
+  } else if (kind === 'mix' || kind === 'free') {
+    const takes = takeDearest(pool, left, Number(bundle.setSize), line => qualifies(bundle, line));
+    if (!takes) return null;
+    if (kind === 'mix') {
+      priced = atSetPrice(takes, price);
+    } else {
+      // The cheapest freeCount units cost nothing; split takes so only those are free.
+      let free = Number(bundle.freeCount);
+      const out = [];
+      for (const t of [...takes].sort((a, b) => a.unitPrice - b.unitPrice)) {
+        const f = Math.min(free, t.quantity);
+        free -= f;
+        if (f > 0) out.push({ ...t, quantity: f, newPrice: 0 });
+        if (t.quantity - f > 0) out.push({ ...t, quantity: t.quantity - f, newPrice: t.unitPrice });
+      }
+      priced = { charged: takes.reduce((s, t) => s + t.quantity * t.unitPrice, 0), takes: out };
+    }
+  } else if (kind === 'group') {
+    const total = pool.reduce((s, p, i) => s + (qualifies(bundle, p.line) ? left[i] : 0), 0);
+    if (total < Number(bundle.setSize)) return null;
+    const takes = takeDearest(pool, left, total, line => qualifies(bundle, line));
+    const pct = Math.min(100, Math.max(0, price)) / 100;
+    priced = {
+      charged: takes.reduce((s, t) => s + t.quantity * t.unitPrice, 0),
+      takes: takes.map(t => ({ ...t, newPrice: bundle.groupPricing === 'percent' ? t.unitPrice * (1 - pct) : Math.min(t.unitPrice, price) })),
+    };
+  } else {
+    return null;
+  }
+
+  const after = priced.takes.reduce((s, t) => s + t.quantity * t.newPrice, 0);
+  return { takes: priced.takes, saving: priced.charged - after };
+}
+
+/**
+ * Applies bundles to coupon-style lines (see coupons.js buildCouponLines). Pure.
+ *
+ * @param {Array} bundles - [{ id, name, kind, price, setSize, freeCount, groupPricing,
+ *                          items: [{ eventOptionId, variantId?, quantity }] }]
+ *                          already filtered to the ones this registration may use
+ * @param {Array} lines   - [{ eventOptionId, variantId, quantity, unitPrice, basePrice }]
+ * @returns {{ discount: number, applications: Array<{ bundleId, name, count, discount }>, lines: Array }}
+ *          `lines` are the input lines with bundled units split out at their bundle
+ *          price (flagged `bundled: true`), ready for the coupon calculation.
+ */
+function applyBundles(bundles, lines) {
+  const usable = (bundles || []).filter(isBundleUsable);
+  const pool = (lines || []).map(line => ({ line, remaining: Number(line.quantity || 0), bundled: [] }));
+  const byBundle = new Map();
+
+  // Each round applies the single best-saving bundle once; stops when nothing saves.
+  const maxRounds = pool.reduce((s, p) => s + p.remaining, 0);
+  for (let round = 0; round < maxRounds; round++) {
+    let best = null;
+    for (const bundle of usable) {
+      // A group discount covers every qualifying ticket in one go, so it applies once.
+      if (bundle.kind === 'group' && byBundle.has(bundle.id)) continue;
+      const attempt = tryBundle(bundle, pool);
+      if (attempt && attempt.saving > 0.005 && (!best || attempt.saving > best.attempt.saving + 0.0001)) best = { bundle, attempt };
+    }
+    if (!best) break;
+    const { bundle, attempt } = best;
+    for (const t of attempt.takes) {
+      pool[t.index].remaining -= t.quantity;
+      pool[t.index].bundled.push({ quantity: t.quantity, unitPrice: t.newPrice });
+    }
+    const entry = byBundle.get(bundle.id) || { bundleId: bundle.id, name: bundle.name, count: 0, discount: 0 };
+    entry.count += 1;
+    entry.discount += attempt.saving;
+    byBundle.set(bundle.id, entry);
+  }
+
+  const applications = [...byBundle.values()].map(a => ({ ...a, discount: round2(a.discount) }));
+  const outLines = [];
+  for (const p of pool) {
+    if (p.remaining > 0) outLines.push({ ...p.line, quantity: p.remaining });
+    for (const b of p.bundled) {
+      outLines.push({ ...p.line, quantity: b.quantity, unitPrice: b.unitPrice, basePrice: b.unitPrice, bundled: true });
+    }
+  }
+  return { discount: round2(applications.reduce((s, a) => s + a.discount, 0)), applications, lines: outLines };
+}
+
+const itemLabel = (i) => `${i.eventOption?.name || 'ticket'}${i.variant?.name ? ` (${i.variant.name})` : ''}`;
+
+/** "5 × Adult + 3 × Child (Large)", or for the other kinds "Adult, Child". Needs names loaded. */
+function describeBundleItems(bundle) {
+  const items = bundle?.items || [];
+  if ((bundle?.kind || 'exact') === 'exact') return items.map(i => `${i.quantity} × ${itemLabel(i)}`).join(' + ');
+  return items.map(itemLabel).join(', ');
+}
+
+/**
+ * The deal in one line, e.g. "2 × Adult + 3 × Child for R220", "Any 4 of Adult, Child
+ * for R250", "Buy 3, get 1 free: Adult, Child", "10+ tickets (Adult, Child): R70 each".
+ */
+function describeBundle(bundle) {
+  const kind = bundle?.kind || 'exact';
+  const items = describeBundleItems(bundle);
+  const price = Number(bundle?.price || 0);
+  if (kind === 'mix') return `Any ${bundle.setSize} of ${items} for ${fmtR(price)}`;
+  if (kind === 'free') return `Buy ${bundle.setSize - bundle.freeCount}, get ${bundle.freeCount} free: ${items}`;
+  if (kind === 'group') {
+    return `${bundle.setSize}+ tickets (${items}): ${bundle.groupPricing === 'percent' ? `${price}% off` : `${fmtR(price)} each`}`;
+  }
+  return `${items} for ${fmtR(price)}`;
+}
+
+// ─── Database helpers ─────────────────────────────────────────────────────────
+
+const BUNDLE_INCLUDE = {
+  items: { include: { eventOption: { select: { id: true, name: true } }, variant: { select: { id: true, name: true } } } },
+};
+
+// A registration's bundle deals, for API responses and receipts.
+const BUNDLE_APPS_INCLUDE = { select: { id: true, bundleId: true, count: true, discount: true, bundle: { select: { id: true, name: true } } } };
+
+/**
+ * Bundles a registration on this event may use: the ones available now, plus any in
+ * `keepIds` (bundles the registration already has).
+ */
+async function loadBundlesFor(eventId, { keepIds = [], now = new Date() } = {}, db = prisma) {
+  if (!eventId) return [];
+  const bundles = await db.eventBundle.findMany({ where: { eventId }, include: BUNDLE_INCLUDE, orderBy: [{ order: 'asc' }, { createdAt: 'asc' }] });
+  return bundles.filter(b => isBundleAvailable(b, now) || (keepIds.includes(b.id) && isBundleUsable(b)));
+}
+
+/** Replaces a registration's RegistrationBundle rows when the applications changed. */
+async function saveBundleApplications(registrationId, existing, applications, db = prisma) {
+  const key = (list) => JSON.stringify([...list].map(a => [a.bundleId, a.count, round2(a.discount)]).sort());
+  if (key(existing || []) === key(applications)) return;
+  await db.registrationBundle.deleteMany({ where: { registrationId } });
+  if (applications.length > 0) {
+    await db.registrationBundle.createMany({
+      data: applications.map(a => ({ registrationId, bundleId: a.bundleId, count: a.count, discount: a.discount })),
+    });
+  }
+}
+
+module.exports = {
+  KINDS,
+  isBundleUsable,
+  isBundleAvailable,
+  applyBundles,
+  describeBundleItems,
+  describeBundle,
+  loadBundlesFor,
+  saveBundleApplications,
+  BUNDLE_INCLUDE,
+  BUNDLE_APPS_INCLUDE,
+};
@@ -6,10 +6,114 @@ const ALL_METHODS = ['cash', 'card', 'eft', 'other'];
 // Standard South African Rand note/coin denominations used for the cash count grid.
 const ZAR_DENOMINATIONS = [200, 100, 50, 20, 10, 5, 2, 1, 0.5, 0.2, 0.1];

+const WRITE_OFF_CATEGORIES = ['card_fees', 'bank_charges', 'cash_shortfall', 'other'];
+const PENDING_OUTCOMES = ['received', 'written_off'];
+
 function emptyByMethod(fill = 0) {
  return { cash: fill, card: fill, eft: fill, other: fill };
 }

+const cents = (n) => Math.round(n * 100) / 100;
+const sum = (rows) => rows.reduce((s, r) => s + r.amount, 0);
+
+// A non-negative amount rounded to cents, or null when left blank.
+function amountOrNull(value, label) {
+  if (value === undefined || value === null || value === '') return null;
+  const n = Number(value);
+  if (!Number.isFinite(n) || n < 0) throw new Error(`${label} must be zero or more`);
+  return cents(n);
+}
+
+/**
+ * Where one method's expected takings ended up, as entered on the cashup screen. Pure.
+ *
+ * actual = in bank + on hand + pending (money held or on its way); write-offs explain money
+ * that's gone (card fees, bank charges, a cash shortfall). Whatever is left —
+ * expected − actual − write-offs — is unaccounted for. Cash has no pending; when staff
+ * counted it (per-person counts), the count is all the cash there is, so whatever wasn't
+ * deposited (or taken by the bank as a deposit fee) is on hand.
+ *
+ * @param {object} p
+ * @param {string} p.method - 'cash' | 'card' | 'eft' | 'other'
+ * @param {number} p.expected - expected amount for the method (payments − costs paid from it)
+ * @param {number|null} [p.counted] - cash counted by staff, or null when nobody counted
+ * @param {object} [p.input] - { bankAmount, onHandAmount, pendingAmount, pendingReference, writeOffs: [{ category, amount, reason }] }
+ */
+function settleLine({ method, expected, counted = null, input = {} }) {
+  const bankAmount = amountOrNull(input.bankAmount, 'In bank');
+  let onHandAmount = method === 'cash' ? amountOrNull(input.onHandAmount, 'Cash on hand') : null;
+  const pendingAmount = method === 'cash' ? null : amountOrNull(input.pendingAmount, 'Pending');
+
+  const writeOffs = (Array.isArray(input.writeOffs) ? input.writeOffs : [])
+    .filter(w => w && w.amount !== undefined && w.amount !== null && w.amount !== '')
+    .map(w => {
+      if (!WRITE_OFF_CATEGORIES.includes(w.category)) throw new Error('Choose what each write-off is for');
+      const amount = amountOrNull(w.amount, 'Write-off');
+      if (!(amount > 0)) throw new Error('A write-off must be more than R0');
+      return { category: w.category, amount, reason: String(w.reason || '').trim().slice(0, 200) || null };
+    });
+  const writeOffTotal = cents(sum(writeOffs));
+
+  if (method === 'cash' && counted !== null && counted !== undefined) {
+    // A deposit fee comes out of cash that was counted and banked, so the count is what
+    // reached the bank + the fee + what's still on hand.
+    const depositFees = cents(sum(writeOffs.filter(w => w.category === 'bank_charges')));
+    if ((bankAmount || 0) + depositFees > counted + 0.005) throw new Error('More cash was deposited than was counted');
+    onHandAmount = cents(counted - (bankAmount || 0) - depositFees);
+  }
+
+  const parts = [bankAmount, onHandAmount, pendingAmount];
+  const entered = parts.some(v => v !== null) || writeOffs.length > 0;
+  const actual = entered ? cents(parts.reduce((s, v) => s + (v || 0), 0)) : null;
+
+  return {
+    bankAmount,
+    onHandAmount,
+    pendingAmount,
+    pendingReference: pendingAmount ? (String(input.pendingReference || '').trim().slice(0, 200) || null) : null,
+    writeOffs,
+    writeOffTotal,
+    actual,
+    variance: actual === null ? null : cents(actual - expected),
+    unaccounted: entered ? cents(expected - actual - writeOffTotal) : null,
+  };
+}
+
+/**
+ * A closed cashup line with any later pending resolutions folded in. Pure.
+ * 'received' moves pending money into the bank (actual unchanged); 'written_off' turns it
+ * into a write-off (actual goes down). Lines from before settlement existed have only
+ * actualAmount, so their unaccounted is the old variance.
+ */
+function applyPendingResolutions(line) {
+  const resolutions = line.pendingResolutions || [];
+  const received = cents(sum(resolutions.filter(r => r.outcome === 'received')));
+  const lateWriteOffs = resolutions.filter(r => r.outcome === 'written_off');
+  const writtenOff = cents(sum(lateWriteOffs));
+
+  const pending = line.pendingAmount || 0;
+  const actual = line.actualAmount === null || line.actualAmount === undefined ? null : cents(line.actualAmount - writtenOff);
+  const writeOffTotal = cents((line.writeOffTotal || 0) + writtenOff);
+  const expected = line.expectedAmount || 0;
+
+  return {
+    bank: line.bankAmount == null && received === 0 ? null : cents((line.bankAmount || 0) + received),
+    onHand: line.onHandAmount ?? null,
+    pending: line.pendingAmount ?? null,
+    pendingReference: line.pendingReference || null,
+    pendingReceived: received,
+    pendingOutstanding: cents(Math.max(pending - received - writtenOff, 0)),
+    writeOffs: [
+      ...(line.writeOffs || []).map(w => ({ id: w.id, category: w.category, amount: w.amount, reason: w.reason, createdAt: w.createdAt, afterClose: false })),
+      ...lateWriteOffs.map(r => ({ id: r.id, category: r.category || 'other', amount: r.amount, reason: r.notes, createdAt: r.createdAt, afterClose: true })),
+    ],
+    writeOffTotal,
+    actual,
+    variance: actual === null ? null : cents(actual - expected),
+    unaccounted: actual === null && writeOffTotal === 0 ? null : cents(expected - (actual || 0) - writeOffTotal),
+  };
+}
+
 // Normalizes a free-text Payment.method into one of the fixed cashup buckets.
 // Card-network wallets (Apple Pay, Google Pay, etc.) settle exactly like a card payment —
 // no separate float to reconcile — so they belong in the 'card' bucket, not 'other'.
@@ -88,7 +192,13 @@ async function computeEventFinancials(eventId) {
    prisma.eventCashup.findMany({
      where: { eventId },
      include: {
-        lines: { include: { denominations: true } },
+        lines: {
+          include: {
+            denominations: true,
+            writeOffs: { orderBy: { createdAt: 'asc' } },
+            pendingResolutions: { include: { performedBy: { select: { id: true, name: true } } }, orderBy: { createdAt: 'asc' } }
+          }
+        },
        performedBy: { select: { id: true, name: true, email: true } }
      },
      orderBy: { createdAt: 'desc' }
@@ -169,29 +279,55 @@ async function computeEventFinancials(eventId) {
      const out = {};
      for (const m of ALL_METHODS) {
        const line = latestReconciled.lines.find(l => l.method === m);
+        const settled = line ? applyPendingResolutions(line) : null;
        out[m] = {
+          lineId: line ? line.id : null,
          expected: line ? line.expectedAmount : expectedCashByMethod[m],
-          actual: line && line.actualAmount != null ? line.actualAmount : null,
-          variance: line && line.variance != null ? line.variance : null,
+          actual: settled ? settled.actual : null,
+          variance: settled ? settled.variance : null,
          notes: line ? line.notes : null,
-          denominations: line ? line.denominations : []
+          denominations: line ? line.denominations : [],
+          bank: settled ? settled.bank : null,
+          onHand: settled ? settled.onHand : null,
+          pending: settled ? settled.pending : null,
+          pendingReference: settled ? settled.pendingReference : null,
+          pendingReceived: settled ? settled.pendingReceived : 0,
+          pendingOutstanding: settled ? settled.pendingOutstanding : 0,
+          pendingResolutions: line ? line.pendingResolutions : [],
+          writeOffs: settled ? settled.writeOffs : [],
+          writeOffTotal: settled ? settled.writeOffTotal : 0,
+          unaccounted: settled ? settled.unaccounted : null
        };
      }
      return out;
    })()
  } : null;

+  // Money written off at (or after) the cashup: card fees, bank charges, shortfalls.
+  const writeOffsByMethod = emptyByMethod();
+  const writeOffsByCategory = Object.fromEntries(WRITE_OFF_CATEGORIES.map(c => [c, 0]));
+  let pendingOutstandingTotal = 0;
+  for (const m of ALL_METHODS) {
+    const r = reconciled?.byMethod?.[m];
+    if (!r) continue;
+    writeOffsByMethod[m] = r.writeOffTotal;
+    pendingOutstandingTotal += r.pendingOutstanding;
+    for (const w of r.writeOffs) writeOffsByCategory[w.category] = cents((writeOffsByCategory[w.category] || 0) + w.amount);
+  }
+  const totalWriteOffs = cents(ALL_METHODS.reduce((s, m) => s + writeOffsByMethod[m], 0));
+
  // Reconciled value is truth; system (expected) value is the fallback when nothing was counted.
-  // Tagged costs are added back so a reconciled cash count still yields a correct *gross* income figure —
-  // costs get subtracted from profit exactly once, via totalCosts, never twice.
+  // Tagged costs and write-offs are added back so income stays a *gross* figure — costs and
+  // write-offs each come off profit exactly once, below, never twice. (Unaccounted money
+  // isn't added back: it lowers income, like any variance.)
  const effectiveGrossIncomeByMethod = emptyByMethod();
  for (const m of ALL_METHODS) {
    const actual = reconciled?.byMethod?.[m]?.actual;
-    const base = actual != null ? actual : expectedCashByMethod[m];
+    const base = actual != null ? actual + writeOffsByMethod[m] : expectedCashByMethod[m];
    effectiveGrossIncomeByMethod[m] = base + costsByMethod[m];
  }
  const effectiveTotalRevenue = ALL_METHODS.reduce((s, m) => s + effectiveGrossIncomeByMethod[m], 0);
-  const netProfit = effectiveTotalRevenue - totalCosts;
+  const netProfit = effectiveTotalRevenue - totalCosts - totalWriteOffs;

  // What was actually sold, by ticket type — for the Finance report's income-stream breakdown.
  // Revenue is tranche-aware: a line spanning two early-bird prices contributes each tranche
@@ -221,6 +357,10 @@ async function computeEventFinancials(eventId) {
    reconciled,
    effectiveGrossIncomeByMethod,
    effectiveTotalRevenue,
+    writeOffsByMethod,
+    writeOffsByCategory,
+    totalWriteOffs,
+    pendingOutstandingTotal: cents(pendingOutstandingTotal),
    netProfit,
    unallocatedDonations,
    unallocatedDonationsTotal,
@@ -362,6 +502,10 @@ module.exports = {
  METHOD_BUCKETS,
  ALL_METHODS,
  ZAR_DENOMINATIONS,
+  WRITE_OFF_CATEGORIES,
+  PENDING_OUTCOMES,
+  settleLine,
+  applyPendingResolutions,
  bucketForMethod,
  isDonationLeg,
  assertEventOpen,
@@ -15,9 +15,12 @@
 *   standard price, and only the part that beats the early-bird price is discounted.
 * - Restricted codes (users, roles, email domain) need a known account, so guests
 *   can't use them; a match on any one restriction is enough.
+ * - Bundle deals (utils/bundles.js) come off first; the coupon is worked out on what's
+ *   left. discountTotal = bundle discount + coupon discounts.
 */

 const prisma = require('../config/db');
+const { applyBundles, loadBundlesFor, saveBundleApplications } = require('./bundles');

 function normalizeCode(code) {
  return String(code || '').trim().toUpperCase();
@@ -166,9 +169,15 @@ const COUPON_INCLUDE = { events: true, options: true, allowedUsers: true };
 const REGISTRATION_INCLUDE = {
  registrationOptions: { include: { tranches: true, eventOption: { include: { variants: true } } } },
  couponRedemptions: { where: { releasedAt: null }, include: { coupon: { include: COUPON_INCLUDE } } },
+  bundleApplications: true,
  user: { select: { id: true, role: true, email: true } },
 };

+/** Bundle deals a basket gets before any coupon (nothing saved). */
+async function previewBundles(eventId, lines, db = prisma) {
+  return applyBundles(await loadBundlesFor(eventId, {}, db), lines);
+}
+
 async function findCouponByCode(code, db = prisma) {
  const normalized = normalizeCode(code);
  if (!normalized) return null;
@@ -187,14 +196,16 @@ async function countCouponUses(couponId, userId, db = prisma) {

 /**
 * Validates `code` against hypothetical lines (nothing saved) and returns the discount it
- * would give. Throws a coupon error with a user-facing message when it can't be used.
+ * would give after the basket's bundle deals (returned as `bundles`). Throws a coupon
+ * error with a user-facing message when it can't be used.
 */
 async function previewCoupon({ code, eventId, user, lines, deferRestrictions = false }) {
  const coupon = await findCouponByCode(code);
  const uses = coupon ? await countCouponUses(coupon.id, user?.id) : {};
-  const check = validateCoupon(coupon, { eventId, user, lines, deferRestrictions, ...uses });
+  const bundles = await previewBundles(eventId, lines);
+  const check = validateCoupon(coupon, { eventId, user, lines: bundles.lines, deferRestrictions, ...uses });
  if (!check.ok) throw couponError(check.message);
-  return { coupon, discount: computeCouponDiscount(coupon, lines) };
+  return { coupon, discount: computeCouponDiscount(coupon, bundles.lines), bundles };
 }

 /**
@@ -219,7 +230,7 @@ async function applyCouponToRegistration({ registrationId, code, appliedById = n
        : 'A code has already been applied to this registration.');
    }

-    const lines = buildCouponLines(registration);
+    const { lines } = await registrationBundles(registration, tx);
    const uses = await countCouponUses(coupon.id, registration.userId, tx);
    const check = validateCoupon(coupon, { eventId: registration.eventId, user: registration.user, lines, ...uses });
    if (!check.ok) throw couponError(check.message);
@@ -228,31 +239,37 @@ async function applyCouponToRegistration({ registrationId, code, appliedById = n
    const redemption = await tx.couponRedemption.create({
      data: { couponId: coupon.id, registrationId, userId: registration.userId, discountAmount: discount, appliedById },
    });
-    await tx.registration.update({ where: { id: registrationId }, data: { discountTotal: discount, updatedAt: new Date() } });
+    await recalculateRegistrationDiscount(registrationId, tx);
+    await tx.registration.update({ where: { id: registrationId }, data: { updatedAt: new Date() } });
    return { coupon, discount, redemption };
  });
 }

+/** A loaded registration's bundle deals (bundles it already has stay usable). */
+async function registrationBundles(registration, db = prisma) {
+  const bundles = await loadBundlesFor(registration.eventId, { keepIds: (registration.bundleApplications || []).map(a => a.bundleId) }, db);
+  return applyBundles(bundles, buildCouponLines(registration));
+}
+
 /**
- * Re-works active discounts after a registration's items change: percentage and comp
- * codes are recalculated over the new items, fixed codes keep their amount (capped at
- * what's still in scope). Pass `tx` to run inside the caller's transaction.
+ * Re-works a registration's discounts: bundle deals first, then the coupon on what's
+ * left. Percentage and comp codes are recalculated over the new items, fixed codes keep
+ * their amount (capped at what's still in scope). `keepCouponAmounts` keeps every
+ * coupon's amount (capped the same way): used when only prices changed, e.g. an
+ * early-bird tier expiring. Updates bundleDiscount and discountTotal and returns
+ * discountTotal. Pass `tx` to run inside the caller's transaction.
 */
-async function recalculateRegistrationDiscount(registrationId, db = prisma) {
+async function recalculateRegistrationDiscount(registrationId, db = prisma, { keepCouponAmounts = false } = {}) {
  const registration = await db.registration.findUnique({ where: { id: registrationId }, include: REGISTRATION_INCLUDE });
  if (!registration) return 0;
-  if (registration.couponRedemptions.length === 0) {
-    if (registration.discountTotal !== 0) {
-      await db.registration.update({ where: { id: registrationId }, data: { discountTotal: 0 } });
-    }
-    return 0;
-  }

-  const lines = buildCouponLines(registration);
-  let total = 0;
+  const bundles = await registrationBundles(registration, db);
+  await saveBundleApplications(registrationId, registration.bundleApplications, bundles.applications, db);
+  const lines = bundles.lines;
+  let total = bundles.discount;
  for (const r of registration.couponRedemptions) {
    let amount;
-    if (r.coupon.type === 'fixed') {
+    if (r.coupon.type === 'fixed' || keepCouponAmounts) {
      const inScope = scopedLines(r.coupon, lines).reduce((s, l) => s + l.unitPrice * l.quantity, 0);
      amount = round2(Math.min(r.discountAmount, inScope));
    } else {
@@ -264,21 +281,22 @@ async function recalculateRegistrationDiscount(registrationId, db = prisma) {
    total += amount;
  }
  total = round2(total);
-  if (Math.abs(total - registration.discountTotal) > 0.001) {
-    await db.registration.update({ where: { id: registrationId }, data: { discountTotal: total } });
+  if (Math.abs(total - registration.discountTotal) > 0.001 || Math.abs(bundles.discount - registration.bundleDiscount) > 0.001) {
+    await db.registration.update({ where: { id: registrationId }, data: { discountTotal: total, bundleDiscount: bundles.discount } });
  }
  return total;
 }

-/** Releases a cancelled registration's coupon uses so they can be claimed again. */
+/**
+ * Releases a registration's coupon uses so they can be claimed again (cancelled, or the
+ * code removed). Bundle deals stay.
+ */
 async function releaseRegistrationCoupons(registrationId, db = prisma) {
  const released = await db.couponRedemption.updateMany({
    where: { registrationId, releasedAt: null },
    data: { releasedAt: new Date() },
  });
-  if (released.count > 0) {
-    await db.registration.update({ where: { id: registrationId }, data: { discountTotal: 0 } });
-  }
+  if (released.count > 0) await recalculateRegistrationDiscount(registrationId, db);
  return released.count;
 }

@@ -292,6 +310,7 @@ module.exports = {
  findCouponByCode,
  countCouponUses,
  previewCoupon,
+  previewBundles,
  applyCouponToRegistration,
  recalculateRegistrationDiscount,
  releaseRegistrationCoupons,
@@ -2,7 +2,7 @@ const fs = require('fs');
 const prisma = require('../config/db');
 const { sendMail, emailWrapper, ctaButton, fallbackLink, secondaryLink, divider, callout, paymentOption } = require('./email');
 const { computeRegistrationTotalDue, computeOptionLineTotal } = require('./pricing');
-const { couponDiscountLine } = require('./pdfDocs');
+const { discountLines } = require('./pdfDocs');

 // ─── Formatting helpers ───────────────────────────────────────────────────────

@@ -90,7 +90,7 @@ async function loadRegistrationFull(registrationId) {
    include: {
      registrationOptions: { include: { eventOption: { include: { earlyBirdTiers: true } }, variant: true, tranches: true } },
      payments: true,
-      couponRedemptions: { where: { releasedAt: null }, include: { coupon: { select: { code: true } } } },
+      couponRedemptions: { where: { releasedAt: null }, include: { coupon: { select: { code: true } } } }, bundleApplications: { include: { bundle: { select: { name: true } } } },
      user: { select: { id: true, name: true, email: true, phoneNumber: true, isActive: true, notificationPreference: true } },
      event: { include: { createdBy: { select: { id: true, name: true, email: true } }, notifyRecipients: { select: { id: true, name: true, email: true } } } },
    },
@@ -137,7 +137,7 @@ async function loadPaymentFull(paymentId) {
        include: {
          registrationOptions: { include: { eventOption: { include: { earlyBirdTiers: true } }, variant: true, tranches: true } },
          payments: true,
-          couponRedemptions: { where: { releasedAt: null }, include: { coupon: { select: { code: true } } } },
+          couponRedemptions: { where: { releasedAt: null }, include: { coupon: { select: { code: true } } } }, bundleApplications: { include: { bundle: { select: { name: true } } } },
          user: { select: { id: true, name: true, email: true, phoneNumber: true, isActive: true, notificationPreference: true } },
          event: { include: { createdBy: { select: { id: true, name: true, email: true } }, notifyRecipients: { select: { id: true, name: true, email: true } } } },
        },
@@ -149,8 +149,8 @@ async function loadPaymentFull(paymentId) {

 // ─── Shared building blocks ───────────────────────────────────────────────────

-/** Renders the selections summary table, with the coupon discount (if any) as its own row. */
-function selectionsTable(registrationOptions, couponLine = null) {
+/** Renders the selections summary table, with each discount (bundle, coupon) as its own row. */
+function selectionsTable(registrationOptions, discounts = []) {
  const rows = (registrationOptions || []).map(ro => {
    const name = ro.eventOption?.name || 'Option';
    const qty = ro.quantity || 1;
@@ -164,10 +164,10 @@ function selectionsTable(registrationOptions, couponLine = null) {

  if (!rows.length) return `<p style="color:#94a3b8;font-size:14px;margin:0">No items</p>`;

-  if (couponLine) {
+  for (const line of discounts || []) {
    rows.push(`<tr>
-      <td colspan="2" style="padding:10px 16px 10px 0;font-size:14px;color:#059669;font-family:${ff};border-bottom:1px solid #f1f5f9">${couponLine.label}</td>
-      <td style="padding:10px 0 10px 16px;font-size:14px;color:#059669;text-align:right;font-weight:500;font-family:${ff};border-bottom:1px solid #f1f5f9">-${fmtAmount(couponLine.amount)}</td>
+      <td colspan="2" style="padding:10px 16px 10px 0;font-size:14px;color:#059669;font-family:${ff};border-bottom:1px solid #f1f5f9">${line.label}</td>
+      <td style="padding:10px 0 10px 16px;font-size:14px;color:#059669;text-align:right;font-weight:500;font-family:${ff};border-bottom:1px solid #f1f5f9">-${fmtAmount(line.amount)}</td>
    </tr>`);
  }

@@ -181,11 +181,10 @@ function selectionsTable(registrationOptions, couponLine = null) {
  </table>`;
 }

-/** Plain-text selections, one bullet per item plus the coupon discount. */
+/** Plain-text selections, one bullet per item plus each discount. */
 function selectionsText(reg) {
  const lines = (reg.registrationOptions || []).map(ro => `  • ${ro.eventOption?.name || 'Option'} ×${ro.quantity} — ${fmtAmount(computeOptionLineTotal(ro, null, new Date()))}`);
-  const coupon = couponDiscountLine(reg);
-  if (coupon) lines.push(`  • ${coupon.label} — -${fmtAmount(coupon.amount)}`);
+  for (const d of discountLines(reg)) lines.push(`  • ${d.label} — -${fmtAmount(d.amount)}`);
  return lines.join('\n');
 }

@@ -317,7 +316,7 @@ function buildRegistrationConfirmation(reg, { isNew = true } = {}) {
    <p style="margin:0 0 28px 0;color:#374151;font-family:${ff}">${subtext}${eventDate ? ` — <strong>${eventDate}</strong>` : ''}</p>

    <p style="font-size:16px;font-weight:700;color:#0f172a;margin:0 0 12px 0;font-family:${ff}">Your registration</p>
-    ${selectionsTable(reg.registrationOptions, couponDiscountLine(reg))}
+    ${selectionsTable(reg.registrationOptions, discountLines(reg))}
    ${financialSummary(totalDue, totalPaid, balance)}

    ${paymentSection({ balance, yocoLink: null, source: 'user', siteUrl: org.url, formRequired: false, isUserActive })}
@@ -358,7 +357,7 @@ function buildAdminInitiatedRegistrationConfirmation(reg, { yocoLink = null, for
    <p style="margin:0 0 28px 0;color:#374151;font-family:${ff}">${subtext}${eventDate ? ` The event takes place on <strong>${eventDate}</strong>.` : ''}</p>

    <p style="font-size:16px;font-weight:700;color:#0f172a;margin:0 0 12px 0;font-family:${ff}">Your registration</p>
-    ${selectionsTable(reg.registrationOptions, couponDiscountLine(reg))}
+    ${selectionsTable(reg.registrationOptions, discountLines(reg))}
    ${financialSummary(totalDue, totalPaid, balance)}

    ${paymentSection({ balance, yocoLink, source: 'admin', siteUrl: org.url, formRequired, isUserActive })}
@@ -95,16 +95,34 @@ function buildLineItems(registrationOptions) {

 /**
 * The registration's coupon discount and a label naming the code(s), e.g. "Code STAFF50".
- * Needs `couponRedemptions[].coupon.code` loaded for the label; the amount comes from
- * Registration.discountTotal, which is always present.
+ * Needs `couponRedemptions[].coupon.code` loaded for the label; the amount is
+ * Registration.discountTotal less the bundle part, both always present.
 */
 function couponDiscountLine(registration) {
-  const amount = Number(registration?.discountTotal || 0);
+  const amount = Math.round((Number(registration?.discountTotal || 0) - Number(registration?.bundleDiscount || 0)) * 100) / 100;
  if (!(amount > 0.001)) return null;
  const codes = (registration.couponRedemptions || []).map(r => r.coupon?.code).filter(Boolean);
  return { amount, label: codes.length ? `Code ${codes.join(', ')}` : 'Discount code' };
 }

+/**
+ * The registration's bundle-deal saving, labelled with the bundle names when
+ * `bundleApplications[].bundle.name` is loaded, e.g. "Bundle: Family deal ×2".
+ */
+function bundleDiscountLine(registration) {
+  const amount = Number(registration?.bundleDiscount || 0);
+  if (!(amount > 0.001)) return null;
+  const names = (registration.bundleApplications || [])
+    .map(a => a.bundle?.name ? `${a.bundle.name}${a.count > 1 ? ` ×${a.count}` : ''}` : null)
+    .filter(Boolean);
+  return { amount, label: names.length ? `Bundle: ${names.join(', ')}` : 'Bundle deal' };
+}
+
+/** Bundle saving then coupon discount, as display lines ({ label, amount }). */
+function discountLines(registration) {
+  return [bundleDiscountLine(registration), couponDiscountLine(registration)].filter(Boolean);
+}
+
 /** Draws a two-column item table starting at `y`; returns the y position after the last row. */
 function drawItemsTable(doc, { x, width, y, rows, brandColor, headerLight = true }) {
  const colDesc = x;
@@ -210,13 +228,13 @@ async function generateReceiptPdf(payment) {
  if (rows.length > 0) {
    y = drawItemsTable(doc, { x: marginX, width: pageWidth - marginX * 2, y, rows, brandColor: org.brandColor });
  }
-  const coupon = couponDiscountLine(reg);
-  if (coupon) {
+  for (const line of discountLines(reg)) {
    y += 8;
    doc.font('Helvetica').fontSize(10).fillColor('#059669')
-      .text(`${coupon.label}:  -${fmtAmount(coupon.amount)}`, marginX, y, { width: pageWidth - marginX * 2 - 8, align: 'right' });
-    y += 14;
+      .text(`${line.label}:  -${fmtAmount(line.amount)}`, marginX, y, { width: pageWidth - marginX * 2 - 8, align: 'right' });
+    y += 6;
  }
+  if (discountLines(reg).length > 0) y += 8;
  y += 20;

  const boxW = 160, boxH = 32;
@@ -259,7 +277,7 @@ async function generateInvoicePdf(registration, { paymentUrl = null, totalDue =
  const fullPriceTotal = rows.reduce((s, r) => s + (r.isEarlyBird ? r.basePrice : r.unitPrice) * r.quantity, 0);
  const chargedTotal = rows.reduce((s, r) => s + r.unitPrice * r.quantity, 0);
  const discount = Math.max(0, fullPriceTotal - chargedTotal);
-  const coupon = couponDiscountLine(registration);
+  const extraDiscounts = discountLines(registration);

  const filename = `invoice-${invoiceNo}.pdf`;
  const filePath = path.join(tempDir(), `${Date.now()}-${filename}`);
@@ -323,10 +341,10 @@ async function generateInvoicePdf(registration, { paymentUrl = null, totalDue =
      .text(value, totalsX + 120, y, { width: 100, align: 'right' });
    y += (opts.size || 10) + 10;
  };
-  if (discount > 0.01 || coupon) {
+  if (discount > 0.01 || extraDiscounts.length > 0) {
    totalLine('SUBTOTAL', fmtAmount(fullPriceTotal));
-    if (discount > 0.01) totalLine(coupon ? 'EARLY BIRD' : 'DISCOUNT', `-${fmtAmount(discount)}`, { color: '#059669' });
-    if (coupon) totalLine(coupon.label.toUpperCase(), `-${fmtAmount(coupon.amount)}`, { color: '#059669' });
+    if (discount > 0.01) totalLine(extraDiscounts.length ? 'EARLY BIRD' : 'DISCOUNT', `-${fmtAmount(discount)}`, { color: '#059669' });
+    for (const line of extraDiscounts) totalLine(line.label.toUpperCase(), `-${fmtAmount(line.amount)}`, { color: '#059669' });
    doc.moveTo(totalsX, y).lineTo(totalsX + 220, y).strokeColor('#e2e8f0').stroke();
    y += 8;
  }
@@ -369,4 +387,4 @@ async function generateInvoicePdf(registration, { paymentUrl = null, totalDue =
  return { filePath, filename };
 }

-module.exports = { generateReceiptPdf, generateInvoicePdf, buildLineItems, couponDiscountLine, getBranding, docNumber };
+module.exports = { generateReceiptPdf, generateInvoicePdf, buildLineItems, couponDiscountLine, bundleDiscountLine, discountLines, getBranding, docNumber };
@@ -25,7 +25,8 @@
 * - refreshPricingForRegistration: re-evaluates only the newest, not-yet-paid-for tranche of
 *   each RegistrationOption; if its tier has expired or lost stock, resolves the next
 *   applicable tier/price for just that tranche. Older tranches — already priced-in — are
- *   never touched.
+ *   never touched. When a price changes, bundle deals are re-worked (they depend on the
+ *   prices charged) and coupon amounts are kept.
 */

 const prisma = require('../config/db');
@@ -269,7 +270,12 @@ async function refreshPricingForRegistration(registrationId) {
    return false;
  }));

-  return { changed: results.some(Boolean) };
+  const changed = results.some(Boolean);
+  if (changed) {
+    const { recalculateRegistrationDiscount } = require('./coupons');
+    await recalculateRegistrationDiscount(registrationId, prisma, { keepCouponAmounts: true });
+  }
+  return { changed };
 }

 /**
@@ -47,11 +47,10 @@ function buildWARegistration(reg, { isNew = true, balance, totalDue, totalPaid }
    : `Your registration for *${eventTitle}* has been updated.`;

  const { computeOptionLineTotal } = require('./pricing');
-  const { couponDiscountLine } = require('./pdfDocs');
-  const coupon = couponDiscountLine(reg);
+  const { discountLines } = require('./pdfDocs');
  const items = [
    ...(reg.registrationOptions || []).map(ro => `- ${ro.eventOption?.name || 'Option'} ×${ro.quantity} — ${fmtAmount(computeOptionLineTotal(ro, null, new Date()))}`),
-    ...(coupon ? [`- ${coupon.label} — -${fmtAmount(coupon.amount)}`] : []),
+    ...discountLines(reg).map(d => `- ${d.label} — -${fmtAmount(d.amount)}`),
  ].join('\n');

  const paid    = totalPaid  ?? (reg.payments || []).reduce((s, p) => s + (p.amount || 0), 0);
@@ -0,0 +1,194 @@
+const { applyBundles, isBundleAvailable } = require('../src/utils/bundles');
+const { computeCouponDiscount } = require('../src/utils/coupons');
+
+const line = (eventOptionId, quantity, unitPrice, extra = {}) => ({ eventOptionId, variantId: null, quantity, unitPrice, basePrice: unitPrice, ...extra });
+const family = { id: 'b1', name: 'Family deal', price: 500, items: [{ eventOptionId: 'adult', quantity: 5 }, { eventOptionId: 'child', quantity: 3 }] };
+const charged = (lines) => lines.reduce((s, l) => s + l.unitPrice * l.quantity, 0);
+
+describe('applyBundles', () => {
+  test('5 adults + 3 children for R500 instead of R550', () => {
+    const r = applyBundles([family], [line('adult', 5, 80), line('child', 3, 50)]);
+    expect(r.discount).toBe(50);
+    expect(r.applications).toEqual([{ bundleId: 'b1', name: 'Family deal', count: 1, discount: 50 }]);
+    expect(charged(r.lines)).toBeCloseTo(500, 6);
+    expect(r.lines.every(l => l.bundled)).toBe(true);
+  });
+
+  test('applies as many times as fits, leftovers at full price', () => {
+    const r = applyBundles([family], [line('adult', 11, 80), line('child', 7, 50)]);
+    expect(r.applications[0].count).toBe(2);
+    expect(r.discount).toBe(100);
+    // 1 adult and 1 child left over at full price.
+    expect(charged(r.lines)).toBeCloseTo(1000 + 80 + 50, 6);
+    expect(r.lines.filter(l => !l.bundled).map(l => [l.eventOptionId, l.quantity])).toEqual([['adult', 1], ['child', 1]]);
+  });
+
+  test('nothing applies when the items are not all there', () => {
+    const r = applyBundles([family], [line('adult', 5, 80), line('child', 2, 50)]);
+    expect(r.discount).toBe(0);
+    expect(r.applications).toEqual([]);
+    expect(charged(r.lines)).toBe(500);
+  });
+
+  test('best price wins: no discount when early-bird prices already beat the bundle', () => {
+    const r = applyBundles([family], [line('adult', 5, 60, { basePrice: 80 }), line('child', 3, 40, { basePrice: 50 })]);
+    expect(r.discount).toBe(0);
+    expect(charged(r.lines)).toBe(420);
+  });
+
+  test('the most expensive units go into the bundle first', () => {
+    // Two adults bought at early-bird R60, four at R80: the bundle should take the R80 ones.
+    const r = applyBundles([family], [line('adult', 2, 60), line('adult', 4, 80), line('child', 3, 50)]);
+    // 4×80 + 1×60 + 3×50 = 530 → R30 saving.
+    expect(r.discount).toBe(30);
+    expect(r.lines.find(l => !l.bundled)).toMatchObject({ eventOptionId: 'adult', quantity: 1, unitPrice: 60 });
+  });
+
+  test('when bundles compete, the bigger saving wins', () => {
+    const pair = { id: 'b2', name: 'Pair', price: 150, items: [{ eventOptionId: 'adult', quantity: 2 }] };
+    const r = applyBundles([family, pair], [line('adult', 5, 80), line('child', 3, 50)]);
+    // Family saves 50 once; pairs save 10 each (two of them = 20), and would block the family deal.
+    expect(r.applications.map(a => a.bundleId)).toEqual(['b1']);
+    expect(r.discount).toBe(50);
+  });
+
+  test('different bundles can stack on different items', () => {
+    const pair = { id: 'b2', name: 'Pair', price: 150, items: [{ eventOptionId: 'adult', quantity: 2 }] };
+    const r = applyBundles([family, pair], [line('adult', 7, 80), line('child', 3, 50)]);
+    expect(r.applications).toEqual([
+      { bundleId: 'b1', name: 'Family deal', count: 1, discount: 50 },
+      { bundleId: 'b2', name: 'Pair', count: 1, discount: 10 },
+    ]);
+  });
+
+  test('a variant-specific item only takes that variant; an any-variant item takes the rest', () => {
+    const shirts = { id: 'b3', name: 'Shirts', price: 300, items: [{ eventOptionId: 'shirt', variantId: 'L', quantity: 1 }, { eventOptionId: 'shirt', quantity: 2 }] };
+    const lines = [
+      { eventOptionId: 'shirt', variantId: 'L', quantity: 1, unitPrice: 150, basePrice: 150 },
+      { eventOptionId: 'shirt', variantId: 'S', quantity: 2, unitPrice: 120, basePrice: 120 },
+    ];
+    const r = applyBundles([shirts], lines);
+    expect(r.discount).toBe(90);
+    const noLarge = applyBundles([shirts], [{ ...lines[1], quantity: 3 }]);
+    expect(noLarge.discount).toBe(0);
+  });
+
+  test('a coupon after the bundle works out on the bundle price', () => {
+    const r = applyBundles([family], [line('adult', 5, 80), line('child', 3, 50), line('lunch', 2, 40)]);
+    const tenPercent = { type: 'percent', value: 10, stackEarlyBird: true, options: [] };
+    // (500 + 80) × 10% = 58
+    expect(computeCouponDiscount(tenPercent, r.lines)).toBe(58);
+    // Best-price-wins coupons also see the bundle price as the base, so it still gives 10%.
+    expect(computeCouponDiscount({ ...tenPercent, stackEarlyBird: false }, r.lines)).toBe(58);
+    const childOnly = { ...tenPercent, options: [{ eventOptionId: 'child' }] };
+    // The 3 children cost 150 of 550 → 136.36 of the R500 bundle → 13.64 off.
+    expect(computeCouponDiscount(childOnly, r.lines)).toBe(13.64);
+  });
+
+  test('a free bundle (R0) still works', () => {
+    const r = applyBundles([{ ...family, price: 0 }], [line('adult', 5, 80), line('child', 3, 50)]);
+    expect(r.discount).toBe(550);
+    expect(charged(r.lines)).toBe(0);
+  });
+
+  test('bundles with no items are ignored', () => {
+    expect(applyBundles([{ id: 'x', name: 'x', price: 1, items: [] }], [line('adult', 3, 80)]).discount).toBe(0);
+  });
+});
+
+describe('pick any (mix)', () => {
+  const anyFour = { id: 'm', name: 'Any 4', kind: 'mix', price: 250, setSize: 4, items: [{ eventOptionId: 'adult' }, { eventOptionId: 'child' }] };
+
+  test('2 adults + 2 children or 4 adults both make a set', () => {
+    expect(applyBundles([anyFour], [line('adult', 2, 80), line('child', 2, 50)]).discount).toBe(10);
+    expect(applyBundles([anyFour], [line('adult', 4, 80)]).discount).toBe(70);
+  });
+
+  test('repeats, dearest tickets first, leftovers at full price', () => {
+    const r = applyBundles([anyFour], [line('adult', 5, 80), line('child', 4, 50)]);
+    // Set 1: 4 adults (320 → 250). Set 2: 1 adult + 3 children (230): no saving, so not applied.
+    expect(r.applications[0].count).toBe(1);
+    expect(r.discount).toBe(70);
+    expect(charged(r.lines)).toBeCloseTo(250 + 80 + 200, 6);
+  });
+
+  test('non-qualifying tickets are left alone', () => {
+    const r = applyBundles([anyFour], [line('adult', 2, 80), line('lunch', 5, 65)]);
+    expect(r.discount).toBe(0);
+  });
+});
+
+describe('buy X get Y free', () => {
+  const b3g1 = { id: 'f', name: 'Buy 3 get 1', kind: 'free', price: 0, setSize: 4, freeCount: 1, items: [{ eventOptionId: 'adult' }, { eventOptionId: 'child' }] };
+
+  test('the cheapest ticket in the set is free', () => {
+    const r = applyBundles([b3g1], [line('adult', 3, 80), line('child', 1, 50)]);
+    expect(r.discount).toBe(50);
+    expect(r.lines.find(l => l.unitPrice === 0)).toMatchObject({ eventOptionId: 'child', quantity: 1, bundled: true });
+  });
+
+  test('8 tickets make two sets', () => {
+    const r = applyBundles([b3g1], [line('adult', 8, 80)]);
+    expect(r.applications[0].count).toBe(2);
+    expect(r.discount).toBe(160);
+  });
+
+  test('three tickets get nothing', () => {
+    expect(applyBundles([b3g1], [line('adult', 3, 80)]).discount).toBe(0);
+  });
+
+  test('a free count that is not below the set size is ignored', () => {
+    expect(applyBundles([{ ...b3g1, freeCount: 4 }], [line('adult', 8, 80)]).discount).toBe(0);
+  });
+});
+
+describe('group discount', () => {
+  const tenPlus = { id: 'g', name: 'Groups', kind: 'group', price: 70, setSize: 10, groupPricing: 'per_ticket', items: [{ eventOptionId: 'adult' }, { eventOptionId: 'child' }] };
+
+  test('10+ qualifying tickets all get the group price, once, never dearer', () => {
+    const r = applyBundles([tenPlus], [line('adult', 8, 80), line('child', 4, 50)]);
+    // Adults 80 → 70 (8 × 10 = 80 saved); children already cheaper, unchanged.
+    expect(r.discount).toBe(80);
+    expect(r.applications).toEqual([{ bundleId: 'g', name: 'Groups', count: 1, discount: 80 }]);
+    expect(charged(r.lines)).toBeCloseTo(8 * 70 + 4 * 50, 6);
+  });
+
+  test('below the minimum: nothing', () => {
+    expect(applyBundles([tenPlus], [line('adult', 9, 80)]).discount).toBe(0);
+  });
+
+  test('percentage off everything in the group', () => {
+    const pct = { ...tenPlus, groupPricing: 'percent', price: 10 };
+    expect(applyBundles([pct], [line('adult', 10, 80), line('child', 2, 50)]).discount).toBe(90);
+  });
+
+  test('an exact bundle beats a group discount when it saves more', () => {
+    const r = applyBundles([family, tenPlus], [line('adult', 5, 80), line('child', 5, 50)]);
+    // Group: 5 × 10 = 50 saved. Family: 50 saved on 5A+3C, then group can't reach 10 again.
+    // Equal savings: the first found wins, either way the total is 50.
+    expect(r.discount).toBe(50);
+  });
+});
+
+describe('describeBundle', () => {
+  const { describeBundle } = require('../src/utils/bundles');
+  const names = [{ eventOptionId: 'a', quantity: 2, eventOption: { name: 'Adult' } }, { eventOptionId: 'c', quantity: 3, eventOption: { name: 'Child' } }];
+  test('one line per kind', () => {
+    expect(describeBundle({ kind: 'exact', price: 220, items: names })).toBe('2 × Adult + 3 × Child for R220');
+    expect(describeBundle({ kind: 'mix', price: 250, setSize: 4, items: names })).toBe('Any 4 of Adult, Child for R250');
+    expect(describeBundle({ kind: 'free', setSize: 4, freeCount: 1, items: names })).toBe('Buy 3, get 1 free: Adult, Child');
+    expect(describeBundle({ kind: 'group', price: 70, setSize: 10, groupPricing: 'per_ticket', items: names })).toBe('10+ tickets (Adult, Child): R70 each');
+    expect(describeBundle({ kind: 'group', price: 15, setSize: 10, groupPricing: 'percent', items: names })).toBe('10+ tickets (Adult, Child): 15% off');
+  });
+});
+
+describe('isBundleAvailable', () => {
+  const now = new Date('2026-06-01T10:00:00Z');
+  test('switched off, not started, ended and empty bundles are not available', () => {
+    expect(isBundleAvailable({ ...family, isActive: true }, now)).toBe(true);
+    expect(isBundleAvailable({ ...family, isActive: false }, now)).toBe(false);
+    expect(isBundleAvailable({ ...family, isActive: true, validFrom: '2026-06-02' }, now)).toBe(false);
+    expect(isBundleAvailable({ ...family, isActive: true, validUntil: '2026-05-31' }, now)).toBe(false);
+    expect(isBundleAvailable({ ...family, isActive: true, items: [] }, now)).toBe(false);
+  });
+});
@@ -0,0 +1,154 @@
+const { settleLine, applyPendingResolutions } = require('../src/utils/cashupUtils');
+
+describe('settleLine', () => {
+  test('card settled net of fees, with the fees written off, leaves nothing unaccounted', () => {
+    const s = settleLine({
+      method: 'card',
+      expected: 12450,
+      input: { bankAmount: '12080.40', writeOffs: [{ category: 'card_fees', amount: '369.60', reason: 'Yoco 2.95%' }] },
+    });
+    expect(s.actual).toBe(12080.4);
+    expect(s.writeOffTotal).toBe(369.6);
+    expect(s.unaccounted).toBe(0);
+    expect(s.variance).toBe(-369.6);
+    expect(s.writeOffs).toEqual([{ category: 'card_fees', amount: 369.6, reason: 'Yoco 2.95%' }]);
+  });
+
+  test('EFT with a POP not yet in the bank counts the pending money as accounted for', () => {
+    const s = settleLine({ method: 'eft', expected: 8200, input: { bankAmount: 7200, pendingAmount: 1000, pendingReference: 'POP #417' } });
+    expect(s.actual).toBe(8200);
+    expect(s.pendingAmount).toBe(1000);
+    expect(s.pendingReference).toBe('POP #417');
+    expect(s.unaccounted).toBe(0);
+  });
+
+  test('a pending reference is dropped when nothing is pending', () => {
+    const s = settleLine({ method: 'eft', expected: 100, input: { bankAmount: 100, pendingReference: 'POP' } });
+    expect(s.pendingReference).toBeNull();
+  });
+
+  test('counted cash that was not deposited is on hand, and a shortfall shows as unaccounted', () => {
+    const s = settleLine({ method: 'cash', expected: 3000, counted: 2950, input: { bankAmount: 2000, onHandAmount: 999 } });
+    expect(s.onHandAmount).toBe(950); // derived from the count, not the typed 999
+    expect(s.actual).toBe(2950);
+    expect(s.unaccounted).toBe(50);
+  });
+
+  test('a cash shortfall written off leaves nothing unaccounted', () => {
+    const s = settleLine({ method: 'cash', expected: 3000, counted: 2950, input: { bankAmount: 2950, writeOffs: [{ category: 'cash_shortfall', amount: 50 }] } });
+    expect(s.onHandAmount).toBe(0);
+    expect(s.unaccounted).toBe(0);
+  });
+
+  test('a deposit fee comes out of the counted cash, not on top of it', () => {
+    // Counted R1000; the bank credited R941.50 after a R58.50 deposit fee; nothing left on hand.
+    const s = settleLine({ method: 'cash', expected: 1000, counted: 1000, input: { bankAmount: 941.5, writeOffs: [{ category: 'bank_charges', amount: 58.5 }] } });
+    expect(s.onHandAmount).toBe(0);
+    expect(s.actual).toBe(941.5);
+    expect(s.unaccounted).toBe(0);
+  });
+
+  test('a cash shortfall write-off does not change what is on hand', () => {
+    const s = settleLine({ method: 'cash', expected: 1000, counted: 980, input: { bankAmount: 480, writeOffs: [{ category: 'cash_shortfall', amount: 20 }] } });
+    expect(s.onHandAmount).toBe(500);
+    expect(s.unaccounted).toBe(0);
+  });
+
+  test('banking more than was counted, counting the deposit fee, is rejected', () => {
+    expect(() => settleLine({ method: 'cash', expected: 1000, counted: 1000, input: { bankAmount: 1000, writeOffs: [{ category: 'bank_charges', amount: 58.5 }] } })).toThrow('More cash was deposited');
+  });
+
+  test('cash never has a pending amount', () => {
+    const s = settleLine({ method: 'cash', expected: 500, input: { onHandAmount: 500, pendingAmount: 200 } });
+    expect(s.pendingAmount).toBeNull();
+    expect(s.actual).toBe(500);
+  });
+
+  test('without a count, cash on hand can be typed in', () => {
+    const s = settleLine({ method: 'cash', expected: 500, counted: null, input: { bankAmount: 300, onHandAmount: 200 } });
+    expect(s.actual).toBe(500);
+    expect(s.unaccounted).toBe(0);
+  });
+
+  test('depositing more cash than was counted is rejected', () => {
+    expect(() => settleLine({ method: 'cash', expected: 500, counted: 400, input: { bankAmount: 450 } })).toThrow('More cash was deposited');
+  });
+
+  test('negative or non-numeric amounts are rejected', () => {
+    expect(() => settleLine({ method: 'card', expected: 100, input: { bankAmount: -5 } })).toThrow('In bank');
+    expect(() => settleLine({ method: 'card', expected: 100, input: { pendingAmount: 'abc' } })).toThrow('Pending');
+  });
+
+  test('a write-off needs a known category and an amount over zero', () => {
+    expect(() => settleLine({ method: 'card', expected: 100, input: { writeOffs: [{ category: 'lunch', amount: 5 }] } })).toThrow('what each write-off is for');
+    expect(() => settleLine({ method: 'card', expected: 100, input: { writeOffs: [{ category: 'other', amount: 0 }] } })).toThrow('more than R0');
+  });
+
+  test('blank write-off rows are ignored', () => {
+    const s = settleLine({ method: 'card', expected: 100, input: { bankAmount: 100, writeOffs: [{ category: 'other', amount: '' }] } });
+    expect(s.writeOffs).toEqual([]);
+  });
+
+  test('nothing entered leaves the method unreconciled', () => {
+    const s = settleLine({ method: 'eft', expected: 100, input: {} });
+    expect(s.actual).toBeNull();
+    expect(s.variance).toBeNull();
+    expect(s.unaccounted).toBeNull();
+  });
+
+  test('amounts are rounded to cents', () => {
+    const s = settleLine({ method: 'card', expected: 0.3, input: { bankAmount: 0.1, pendingAmount: 0.2 } });
+    expect(s.actual).toBe(0.3);
+    expect(s.unaccounted).toBe(0);
+  });
+});
+
+describe('applyPendingResolutions', () => {
+  const line = {
+    expectedAmount: 8200,
+    actualAmount: 8200,
+    bankAmount: 7200,
+    onHandAmount: null,
+    pendingAmount: 1000,
+    pendingReference: 'POP #417',
+    writeOffTotal: 0,
+    writeOffs: [],
+  };
+
+  test('with nothing settled yet, all the pending money is outstanding', () => {
+    const s = applyPendingResolutions({ ...line, pendingResolutions: [] });
+    expect(s.pendingOutstanding).toBe(1000);
+    expect(s.bank).toBe(7200);
+    expect(s.unaccounted).toBe(0);
+  });
+
+  test('money received later moves into the bank without changing actual', () => {
+    const s = applyPendingResolutions({ ...line, pendingResolutions: [{ id: 'r1', outcome: 'received', amount: 600 }] });
+    expect(s.bank).toBe(7800);
+    expect(s.actual).toBe(8200);
+    expect(s.pendingOutstanding).toBe(400);
+    expect(s.writeOffTotal).toBe(0);
+  });
+
+  test('money written off later lowers actual and becomes a write-off', () => {
+    const s = applyPendingResolutions({
+      ...line,
+      pendingResolutions: [
+        { id: 'r1', outcome: 'received', amount: 600 },
+        { id: 'r2', outcome: 'written_off', amount: 400, category: 'other', notes: 'Never paid' },
+      ],
+    });
+    expect(s.actual).toBe(7800);
+    expect(s.writeOffTotal).toBe(400);
+    expect(s.pendingOutstanding).toBe(0);
+    expect(s.unaccounted).toBe(0);
+    expect(s.writeOffs).toEqual([expect.objectContaining({ id: 'r2', category: 'other', amount: 400, reason: 'Never paid', afterClose: true })]);
+  });
+
+  test('a line from before settlement existed reports its old variance as unaccounted', () => {
+    const s = applyPendingResolutions({ expectedAmount: 1000, actualAmount: 980, variance: -20 });
+    expect(s.bank).toBeNull();
+    expect(s.pendingOutstanding).toBe(0);
+    expect(s.unaccounted).toBe(20);
+  });
+});
@@ -5,9 +5,6 @@ const nextConfig: NextConfig = {
  images: {
    domains: ['images.unsplash.com'],
  },
-  eslint: {
-    ignoreDuringBuilds: true,
-  },
  compiler: {
    removeConsole: process.env.NODE_ENV === 'production',
  },
@@ -1,12 +1,12 @@
 {
  "name": "hope-events-frontend",
-  "version": "1.25.0",
+  "version": "1.30.1",
  "lockfileVersion": 3,
  "requires": true,
  "packages": {
    "": {
      "name": "hope-events-frontend",
-      "version": "1.25.0",
+      "version": "1.30.1",
      "dependencies": {
        "@dnd-kit/core": "^6.3.1",
        "@hookform/resolvers": "^5.2.1",
@@ -8478,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",
@@ -1,6 +1,6 @@
 {
  "name": "hope-events-frontend",
-  "version": "1.25.0",
+  "version": "1.30.1",
  "private": true,
  "scripts": {
    "dev": "next dev --turbopack",
@@ -62,7 +62,8 @@
  "overrides": {
    "next": {
      "postcss": "^8.5.23"
-    }
+    },
+    "postcss-selector-parser": "^7.1.7"
  },
  "allowScripts": {
    "@sentry/cli@2.58.6": true,
@@ -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>
@@ -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,9 +34,9 @@ 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>
        );
    }
@@ -47,9 +49,9 @@ export default async function EventRedirectPage({ params }: { params: Promise<{
        <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>
    );
 }
@@ -7,6 +7,7 @@ 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();
@@ -24,14 +25,14 @@ function ActivateAccountContent() {
    try {
      setLoading(true);
      setStatus(null);
-      const data = await apiFetch<any>("/api/users/activate", { method: "POST", body: { token, password } });
+      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(() => { window.location.href = "/dashboard"; }, 1500);
-    } catch (err: any) {
-      setStatus(err?.message || "Activation failed. The link may have expired.");
+    } catch (err) {
+      setStatus(errorMessage(err) || "Activation failed. The link may have expired.");
    } finally {
      setLoading(false);
    }
@@ -7,6 +7,8 @@ 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";
+import { BackLink } from "@/components/shared/BackLink";

 const ACTIONS = [
  "refund_created",
@@ -22,6 +24,9 @@ const ACTIONS = [
  "coupon_updated",
  "coupon_disabled",
  "coupon_applied_manual",
+  "bundle_created",
+  "bundle_updated",
+  "bundle_deleted",
  "consent_override",
  "consent_rerequested",
  "medical_list_viewed",
@@ -51,6 +56,9 @@ const ACTION_LABELS: Record<string, string> = {
  coupon_updated: "Coupon edited",
  coupon_disabled: "Coupon turned off",
  coupon_applied_manual: "Coupon applied/removed by staff",
+  bundle_created: "Bundle deal created",
+  bundle_updated: "Bundle deal edited",
+  bundle_deleted: "Bundle deal deleted",
  consent_override: "Consent overridden at check-in",
  consent_rerequested: "Consent re-requested",
  medical_list_viewed: "Medical list viewed",
@@ -174,14 +182,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">
@@ -190,7 +199,7 @@ export default function AdminAuditLogPage() {
          <History className="w-5 h-5 text-brand-600" />
        </div>
        <div>
-          <button className="text-xs text-brand-600 hover:underline" onClick={() => router.push("/dashboard/admin")}>← Back to dashboard</button>
+          <BackLink href="/dashboard/admin" />
          <h1 className="text-2xl font-semibold text-gray-900 mt-0.5">Admin Audit Log</h1>
          <p className="text-sm text-gray-500">{total} action{total !== 1 ? "s" : ""} recorded</p>
        </div>
@@ -1,12 +1,14 @@
 "use client";

-import React, { useEffect, useMemo, useState } from "react";
-import { useParams, useRouter } from "next/navigation";
+import React, { useCallback, useEffect, useMemo, useState } from "react";
+import { useParams } 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, CashupWriteOffCategory, ReconciledByMethod, Event } from "@/types";
 import { Wallet, DollarSign, ClipboardCheck, FileBarChart } from "lucide-react";
+import { errorMessage } from "@/lib/utils";
+import { BackLink } from "@/components/shared/BackLink";

 const METHOD_LABELS: Record<CashupMethod, string> = { cash: "Cash", card: "Card", eft: "EFT", other: "Other" };
 const METHODS: CashupMethod[] = ["cash", "card", "eft", "other"];
@@ -19,12 +21,9 @@ function denomLabel(v: number): string {
  return v >= 1 ? `R${v}` : `${Math.round(v * 100)}c`;
 }

-type LineInput = { actualAmount: string; notes: string };
-
 export default function EventCashupPage() {
  const params = useParams<{ id: string }>();
  const eventId = params.id;
-  const router = useRouter();
  const { token } = useAuth();

  const [tab, setTab] = useState<"costs" | "reconciliation" | "report">("costs");
@@ -36,25 +35,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">
@@ -64,7 +63,7 @@ export default function EventCashupPage() {
            <Wallet className="w-5 h-5 text-brand-600" />
          </div>
          <div>
-            <button className="text-xs text-brand-600 hover:underline" onClick={() => router.push("/dashboard/admin/cashup")}>← Back to cashup</button>
+            <BackLink href="/dashboard/admin/cashup" label="Back to cashup" />
            <h1 className="text-xl font-semibold text-gray-900 mt-0.5">{data?.event?.title || "Event"} — Cashup</h1>
          </div>
        </div>
@@ -151,8 +150,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 +162,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 +178,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 +256,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 +305,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 +461,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);
    }
@@ -535,40 +535,79 @@ function ReportTab({ eventId, token, data, isClosed }: {
      </div>

      <div className="bg-white border rounded-lg p-4 space-y-2 overflow-auto">
-        <div className="text-sm font-medium">Revenue by method</div>
-        <table className="w-full text-sm min-w-[560px]">
+        <div className="text-sm font-medium">Where the money ended up</div>
+        <table className="w-full text-sm min-w-[720px]">
          <thead>
            <tr className="text-left text-gray-500 border-b">
              <th className="py-1">Method</th>
              <th className="py-1 text-right">Income</th>
-              <th className="py-1 text-right">Expected cash</th>
-              <th className="py-1 text-right">Actual</th>
-              <th className="py-1 text-right">Variance</th>
+              <th className="py-1 text-right">Expected</th>
+              <th className="py-1 text-right">In bank</th>
+              <th className="py-1 text-right">On hand</th>
+              <th className="py-1 text-right">Pending</th>
+              <th className="py-1 text-right">Written off</th>
+              <th className="py-1 text-right">Unaccounted</th>
            </tr>
          </thead>
          <tbody>
            {METHODS.map(m => {
              const r = reconciled?.byMethod?.[m];
+              const cell = (v: number | null | undefined) => (v != null && Math.abs(v) >= 0.005 ? money(v) : "—");
              return (
                <tr key={m} className="border-b last:border-0">
                  <td className="py-1.5">{METHOD_LABELS[m]}</td>
                  <td className="py-1.5 text-right">{money(data.paymentsByMethod[m])}</td>
                  <td className="py-1.5 text-right">{money(data.expectedCashByMethod[m])}</td>
-                  <td className="py-1.5 text-right">{r?.actual != null ? money(r.actual) : "—"}</td>
-                  <td className="py-1.5 text-right">{r?.variance != null ? money(r.variance) : "—"}</td>
+                  <td className="py-1.5 text-right">{cell(r?.bank)}</td>
+                  <td className="py-1.5 text-right">{cell(r?.onHand)}</td>
+                  <td className="py-1.5 text-right">{cell(r?.pendingOutstanding)}</td>
+                  <td className="py-1.5 text-right">{cell(r?.writeOffTotal)}</td>
+                  <td className={"py-1.5 text-right " + (r?.unaccounted != null && Math.abs(r.unaccounted) >= 0.005 ? "text-rose-700 font-medium" : "")}>
+                    {r?.unaccounted != null ? (Math.abs(r.unaccounted) >= 0.005 ? money(r.unaccounted) : "R0.00") : "—"}
+                  </td>
                </tr>
              );
            })}
          </tbody>
        </table>
+        {!reconciled && <div className="text-xs text-gray-400">Not settled yet. Columns fill in once the event is closed with a cashup.</div>}
      </div>

+      {(() => {
+        const writeOffs = METHODS.flatMap(m => (reconciled?.byMethod?.[m]?.writeOffs || []).map(w => ({ ...w, method: m })));
+        return writeOffs.length > 0 ? (
+          <div className="bg-white border rounded-lg p-4 space-y-2 overflow-auto">
+            <div className="text-sm font-medium">Write-offs</div>
+            <table className="w-full text-sm min-w-[480px]">
+              <thead>
+                <tr className="text-left text-gray-500 border-b">
+                  <th className="py-1">Method</th>
+                  <th className="py-1">Type</th>
+                  <th className="py-1">Reason</th>
+                  <th className="py-1 text-right">Amount</th>
+                </tr>
+              </thead>
+              <tbody>
+                {writeOffs.map((w, i) => (
+                  <tr key={w.id || i} className="border-b last:border-0">
+                    <td className="py-1.5">{METHOD_LABELS[w.method]}</td>
+                    <td className="py-1.5">{WRITE_OFF_LABELS[w.category]}{w.afterClose ? " (after closing)" : ""}</td>
+                    <td className="py-1.5 text-gray-600">{w.reason || "—"}</td>
+                    <td className="py-1.5 text-right">{money(w.amount)}</td>
+                  </tr>
+                ))}
+              </tbody>
+            </table>
+          </div>
+        ) : null;
+      })()}
+
      {reconciled?.byMethod?.cash?.denominations?.length ? (
        <div className="bg-white border rounded-lg p-4 space-y-2">
          <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 +629,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>
@@ -602,19 +641,273 @@ function ReportTab({ eventId, token, data, isClosed }: {
        </div>
      )}

-      <div className="bg-white border rounded-lg p-4 grid grid-cols-1 sm:grid-cols-3 gap-3 text-sm">
+      <ProfitSummary data={data} />
+    </div>
+  );
+}
+
+// ─── Settlement ────────────────────────────────────────────────────────────
+// For each method, where did the expected money end up: in the bank, still on hand (cash),
+// or pending (on the card report / a POP we haven't seen in the bank yet) — and what was
+// written off (card fees, bank charges, a shortfall). Mirrors settleLine in
+// backend/src/utils/cashupUtils.js, which has the final say when the event is closed.
+
+type WriteOffInput = { category: CashupWriteOffCategory; amount: string; reason: string };
+type SettlementInput = { bankAmount: string; onHandAmount: string; pendingAmount: string; pendingReference: string; writeOffs: WriteOffInput[]; notes: string };
+
+const WRITE_OFF_LABELS: Record<CashupWriteOffCategory, string> = {
+  card_fees: "Card / online fees",
+  bank_charges: "Bank charges",
+  cash_shortfall: "Cash shortfall",
+  other: "Other",
+};
+const WRITE_OFF_CATEGORIES = Object.keys(WRITE_OFF_LABELS) as CashupWriteOffCategory[];
+const DEFAULT_WRITE_OFF: Record<CashupMethod, CashupWriteOffCategory> = { cash: "cash_shortfall", card: "card_fees", eft: "bank_charges", other: "other" };
+const BANK_HELP: Record<CashupMethod, string> = {
+  cash: "What reached the bank, after any deposit fee",
+  card: "Settled into the bank account",
+  eft: "Showing on the bank statement",
+  other: "Received in the bank",
+};
+const PENDING_HELP: Record<CashupMethod, string> = {
+  cash: "",
+  card: "On the card machine / Yoco report, not in the bank yet",
+  eft: "Proof of payment received, not in the bank yet",
+  other: "Expected but not in the bank yet",
+};
+const PENDING_REFERENCE_PLACEHOLDER: Record<CashupMethod, string> = { cash: "", card: "Report or batch reference", eft: "POP reference", other: "Reference" };
+
+const round2 = (n: number) => Math.round(n * 100) / 100;
+const emptySettlement = (): SettlementInput => ({ bankAmount: "", onHandAmount: "", pendingAmount: "", pendingReference: "", writeOffs: [], notes: "" });
+const amountText = (v: string | number | null | undefined) => (v === null || v === undefined ? "" : String(v));
+
+function settle(method: CashupMethod, expected: number, counted: number | null, input: SettlementInput) {
+  const num = (v: string) => (v.trim() === "" || isNaN(Number(v)) ? null : Number(v));
+  const bank = num(input.bankAmount);
+  const writeOffTotal = round2(input.writeOffs.reduce((s, w) => s + (num(w.amount) || 0), 0));
+  // A deposit fee comes out of the counted cash that was banked.
+  const depositFees = round2(input.writeOffs.filter(w => w.category === "bank_charges").reduce((s, w) => s + (num(w.amount) || 0), 0));
+  const onHand = method === "cash" ? (counted !== null ? round2(counted - (bank || 0) - depositFees) : num(input.onHandAmount)) : null;
+  const pending = method === "cash" ? null : num(input.pendingAmount);
+  const entered = [bank, onHand, pending].some(v => v !== null) || input.writeOffs.some(w => num(w.amount) !== null);
+  const actual = entered ? round2((bank || 0) + (onHand || 0) + (pending || 0)) : null;
+  return { bank, onHand, pending, writeOffTotal, actual, unaccounted: actual === null ? null : round2(expected - actual - writeOffTotal) };
+}
+
+function UnaccountedBadge({ unaccounted }: { unaccounted: number | null }) {
+  if (unaccounted === null) return <span className="text-xs text-gray-400">Not settled yet</span>;
+  if (Math.abs(unaccounted) < 0.005) return <span className="inline-block px-2 py-0.5 rounded text-xs font-medium bg-emerald-50 text-emerald-700">All accounted for</span>;
+  return (
+    <span className="inline-block px-2 py-0.5 rounded text-xs font-medium bg-rose-50 text-rose-700">
+      {unaccounted > 0 ? `${money(unaccounted)} unaccounted` : `${money(-unaccounted)} more than expected`}
+    </span>
+  );
+}
+
+function SettlementCard({ method, data, counted, input, onChange }: {
+  method: CashupMethod; data: EventFinancials; counted: number | null; input: SettlementInput; onChange: (next: SettlementInput) => void;
+}) {
+  const expected = data.expectedCashByMethod[method];
+  const s = settle(method, expected, counted, input);
+  const set = (field: keyof SettlementInput, value: string) => onChange({ ...input, [field]: value });
+  const setWriteOff = (i: number, patch: Partial<WriteOffInput>) =>
+    onChange({ ...input, writeOffs: input.writeOffs.map((w, j) => (j === i ? { ...w, ...patch } : w)) });
+  const addWriteOff = () => onChange({ ...input, writeOffs: [...input.writeOffs, { category: DEFAULT_WRITE_OFF[method], amount: "", reason: "" }] });
+  const removeWriteOff = (i: number) => onChange({ ...input, writeOffs: input.writeOffs.filter((_, j) => j !== i) });
+
+  return (
+    <div className="border rounded-lg p-3 space-y-3">
+      <div className="flex items-start justify-between gap-3 flex-wrap">
        <div>
-          <div className="text-gray-500 text-xs">Donations counted as profit</div>
-          <div className="font-semibold">{money(data.unallocatedDonationsTotal)}</div>
+          <div className="text-sm font-medium">{METHOD_LABELS[method]}</div>
+          <div className="text-xs text-gray-500">
+            Expected {money(expected)}
+            {data.costsByMethod[method] > 0 && <> ({money(data.paymentsByMethod[method])} taken, less {money(data.costsByMethod[method])} paid out)</>}
+          </div>
        </div>
+        <UnaccountedBadge unaccounted={s.unaccounted} />
+      </div>
+
+      <div className="grid grid-cols-1 sm:grid-cols-2 gap-3">
        <div>
-          <div className="text-gray-500 text-xs">Total costs</div>
-          <div className="font-semibold">{money(data.totalCosts)}</div>
+          <label className="block text-xs text-gray-600 mb-1">In bank</label>
+          <input type="number" step="0.01" min={0} className="w-full border rounded px-2 py-1.5 text-sm" value={input.bankAmount} onChange={e => set("bankAmount", e.target.value)} />
+          <p className="text-[10px] text-gray-400 mt-0.5">{BANK_HELP[method]}</p>
        </div>
+        {method === "cash" ? (
+          <div>
+            <label className="block text-xs text-gray-600 mb-1">Cash on hand</label>
+            {counted !== null ? (
+              <div className="text-sm py-1.5">{money(s.onHand)}</div>
+            ) : (
+              <input type="number" step="0.01" min={0} className="w-full border rounded px-2 py-1.5 text-sm" value={input.onHandAmount} onChange={e => set("onHandAmount", e.target.value)} />
+            )}
+            <p className="text-[10px] text-gray-400 mt-0.5">
+              {counted !== null ? `Counted ${money(counted)}, less what was deposited and any deposit fee` : "Not deposited yet. Enter staff cash counts below to work this out."}
+            </p>
+          </div>
+        ) : (
+          <div>
+            <label className="block text-xs text-gray-600 mb-1">Pending</label>
+            <div className="flex gap-2">
+              <input type="number" step="0.01" min={0} className="w-28 border rounded px-2 py-1.5 text-sm" value={input.pendingAmount} onChange={e => set("pendingAmount", e.target.value)} />
+              <input className="flex-1 min-w-0 border rounded px-2 py-1.5 text-sm" placeholder={PENDING_REFERENCE_PLACEHOLDER[method]} value={input.pendingReference} onChange={e => set("pendingReference", e.target.value)} />
+            </div>
+            <p className="text-[10px] text-gray-400 mt-0.5">{PENDING_HELP[method]}</p>
+          </div>
+        )}
+      </div>
+
+      <div className="space-y-2">
+        <div className="text-xs text-gray-600">Write-offs</div>
+        {input.writeOffs.map((w, i) => (
+          <div key={i} className="flex flex-wrap gap-2 items-center">
+            <select className="border rounded px-2 py-1.5 text-sm" value={w.category} onChange={e => setWriteOff(i, { category: e.target.value as CashupWriteOffCategory })}>
+              {WRITE_OFF_CATEGORIES.map(c => <option key={c} value={c}>{WRITE_OFF_LABELS[c]}</option>)}
+            </select>
+            <input type="number" step="0.01" min={0} className="w-28 border rounded px-2 py-1.5 text-sm" placeholder="Amount" value={w.amount} onChange={e => setWriteOff(i, { amount: e.target.value })} />
+            <input className="flex-1 min-w-[140px] border rounded px-2 py-1.5 text-sm" placeholder="Reason (optional)" value={w.reason} onChange={e => setWriteOff(i, { reason: e.target.value })} />
+            <button className="text-xs text-red-600 hover:underline" onClick={() => removeWriteOff(i)}>Remove</button>
+          </div>
+        ))}
+        <button className="text-xs text-brand-600 hover:underline" onClick={addWriteOff}>+ Add write-off</button>
+      </div>
+
+      <div>
+        <label className="block text-xs text-gray-600 mb-1">Notes (optional)</label>
+        <input className="w-full border rounded px-2 py-1.5 text-sm" value={input.notes} onChange={e => set("notes", e.target.value)} />
+      </div>
+    </div>
+  );
+}
+
+// A closed method's settlement, read-only, with a way to settle pending money that has
+// since arrived (or never will) without reopening the event.
+function SettledCard({ method, r, token, onChanged }: { method: CashupMethod; r: ReconciledByMethod; token: string; onChanged: () => void }) {
+  return (
+    <div className="border rounded-lg p-3 space-y-2">
+      <div className="flex items-start justify-between gap-3 flex-wrap">
        <div>
-          <div className="text-gray-500 text-xs">Net profit</div>
-          <div className="font-semibold">{money(data.netProfit)}</div>
+          <div className="text-sm font-medium">{METHOD_LABELS[method]}</div>
+          <div className="text-xs text-gray-500">Expected {money(r.expected)}</div>
        </div>
+        <UnaccountedBadge unaccounted={r.unaccounted} />
+      </div>
+      <dl className="grid grid-cols-2 sm:grid-cols-4 gap-2 text-sm">
+        <div><dt className="text-xs text-gray-500">In bank</dt><dd>{r.bank !== null ? money(r.bank) : "—"}</dd></div>
+        {method === "cash"
+          ? <div><dt className="text-xs text-gray-500">On hand</dt><dd>{r.onHand !== null ? money(r.onHand) : "—"}</dd></div>
+          : <div><dt className="text-xs text-gray-500">Pending</dt><dd>{r.pendingOutstanding > 0 ? money(r.pendingOutstanding) : "—"}</dd></div>}
+        <div><dt className="text-xs text-gray-500">Written off</dt><dd>{r.writeOffTotal > 0 ? money(r.writeOffTotal) : "—"}</dd></div>
+        <div><dt className="text-xs text-gray-500">Actual</dt><dd>{r.actual !== null ? money(r.actual) : "—"}</dd></div>
+      </dl>
+      {r.writeOffs.length > 0 && (
+        <ul className="text-xs text-gray-600 space-y-0.5">
+          {r.writeOffs.map((w, i) => (
+            <li key={w.id || i}>
+              {WRITE_OFF_LABELS[w.category]} {money(w.amount)}{w.reason ? ` — ${w.reason}` : ""}{w.afterClose ? " (after closing)" : ""}
+            </li>
+          ))}
+        </ul>
+      )}
+      {(r.pending || 0) > 0 && (
+        <PendingSettler method={method} r={r} token={token} onChanged={onChanged} />
+      )}
+      {r.notes && <div className="text-xs text-gray-500">Notes: {r.notes}</div>}
+    </div>
+  );
+}
+
+function PendingSettler({ method, r, token, onChanged }: { method: CashupMethod; r: ReconciledByMethod; token: string; onChanged: () => void }) {
+  const [mode, setMode] = useState<"received" | "written_off" | null>(null);
+  const [amount, setAmount] = useState("");
+  const [category, setCategory] = useState<CashupWriteOffCategory>(DEFAULT_WRITE_OFF[method]);
+  const [notes, setNotes] = useState("");
+  const [saving, setSaving] = useState(false);
+  const [err, setErr] = useState<string | null>(null);
+
+  const start = (m: "received" | "written_off") => { setMode(m); setAmount(String(r.pendingOutstanding)); setNotes(""); setErr(null); };
+
+  const save = async () => {
+    if (!r.lineId || !mode) return;
+    setSaving(true); setErr(null);
+    try {
+      await apiFetch(`/api/cashups/lines/${r.lineId}/pending`, { method: "POST", authToken: token, body: { outcome: mode, amount: parseFloat(amount), category, notes: notes || null } });
+      setMode(null);
+      onChanged();
+    } catch (e) {
+      setErr(errorMessage(e) || "Failed to save");
+    } finally {
+      setSaving(false);
+    }
+  };
+
+  return (
+    <div className="bg-amber-50 border border-amber-100 rounded p-2 space-y-2 text-xs">
+      <div className="flex items-center justify-between gap-2 flex-wrap">
+        <span>
+          Pending {money(r.pending)}{r.pendingReference ? ` (${r.pendingReference})` : ""}
+          {r.pendingOutstanding > 0 ? <> — <strong>{money(r.pendingOutstanding)} still outstanding</strong></> : " — all settled"}
+        </span>
+        {r.pendingOutstanding > 0 && mode === null && (
+          <span className="flex gap-3">
+            <button className="text-brand-600 hover:underline" onClick={() => start("received")}>Mark received</button>
+            <button className="text-red-600 hover:underline" onClick={() => start("written_off")}>Write off</button>
+          </span>
+        )}
+      </div>
+      {r.pendingResolutions.length > 0 && (
+        <ul className="text-gray-600 space-y-0.5">
+          {r.pendingResolutions.map(p => (
+            <li key={p.id}>
+              {p.outcome === "received" ? "Received in bank" : `Written off (${WRITE_OFF_LABELS[p.category || "other"]})`} {money(p.amount)}
+              {" — "}{p.performedBy?.name || "Unknown"}, {new Date(p.createdAt).toLocaleDateString()}{p.notes ? ` — ${p.notes}` : ""}
+            </li>
+          ))}
+        </ul>
+      )}
+      {mode !== null && (
+        <div className="flex flex-wrap gap-2 items-center">
+          <input type="number" step="0.01" min={0} className="w-28 border rounded px-2 py-1 text-sm bg-white" value={amount} onChange={e => setAmount(e.target.value)} />
+          {mode === "written_off" && (
+            <select className="border rounded px-2 py-1 text-sm bg-white" value={category} onChange={e => setCategory(e.target.value as CashupWriteOffCategory)}>
+              {WRITE_OFF_CATEGORIES.map(c => <option key={c} value={c}>{WRITE_OFF_LABELS[c]}</option>)}
+            </select>
+          )}
+          <input className="flex-1 min-w-[140px] border rounded px-2 py-1 text-sm bg-white" placeholder={mode === "received" ? "Bank reference (optional)" : "Reason (optional)"} value={notes} onChange={e => setNotes(e.target.value)} />
+          <button className="px-2 py-1 rounded border bg-white" onClick={() => setMode(null)} disabled={saving}>Cancel</button>
+          <button className="px-2 py-1 rounded bg-brand-600 text-white hover:bg-brand-700" onClick={save} disabled={saving}>
+            {saving ? "Saving…" : mode === "received" ? "Mark received" : "Write off"}
+          </button>
+          {err && <span className="text-red-600 w-full">{err}</span>}
+        </div>
+      )}
+    </div>
+  );
+}
+
+function ProfitSummary({ data }: { data: EventFinancials }) {
+  return (
+    <div className="bg-white border rounded-lg p-4 grid grid-cols-2 sm:grid-cols-5 gap-3 text-sm">
+      <div>
+        <div className="text-gray-500 text-xs">Donations counted as profit</div>
+        <div className="font-semibold">{money(data.unallocatedDonationsTotal)}</div>
+      </div>
+      <div>
+        <div className="text-gray-500 text-xs">Total costs</div>
+        <div className="font-semibold">{money(data.totalCosts)}</div>
+      </div>
+      <div>
+        <div className="text-gray-500 text-xs">Bank &amp; card charges</div>
+        <div className="font-semibold">{money(data.totalWriteOffs)}</div>
+      </div>
+      <div>
+        <div className="text-gray-500 text-xs">Pending (outstanding)</div>
+        <div className="font-semibold">{money(data.pendingOutstandingTotal)}</div>
+      </div>
+      <div>
+        <div className="text-gray-500 text-xs">Net profit</div>
+        <div className="font-semibold">{money(data.netProfit)}</div>
      </div>
    </div>
  );
@@ -625,70 +918,98 @@ 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: "" } };
+  const initialLines: Record<CashupMethod, SettlementInput> = useMemo(() => {
+    const base: Record<CashupMethod, SettlementInput> = { cash: emptySettlement(), card: emptySettlement(), eft: emptySettlement(), other: emptySettlement() };
    for (const l of draftLines || []) {
-      if (l.method in base) base[l.method as CashupMethod] = { actualAmount: l.actualAmount != null ? String(l.actualAmount) : "", notes: l.notes || "" };
+      if (!(l.method in base)) continue;
+      base[l.method as CashupMethod] = {
+        bankAmount: amountText(l.bankAmount),
+        onHandAmount: amountText(l.onHandAmount),
+        pendingAmount: amountText(l.pendingAmount),
+        pendingReference: l.pendingReference || "",
+        writeOffs: (l.writeOffs || []).map(w => ({ category: w.category, amount: amountText(w.amount), reason: w.reason || "" })),
+        notes: l.notes || "",
+      };
    }
    return base;
  }, [draftLines]);

-  const [lines, setLines] = useState<Record<CashupMethod, LineInput>>(initialLines);
+  const [lines, setLines] = useState<Record<CashupMethod, SettlementInput>>(initialLines);
  const [closeNotes, setCloseNotes] = useState("");
  const [reopenNotes, setReopenNotes] = useState("");
-  // Cash no longer has its own manual entry — it's the live sum of every staff member's
-  // per-person count, reported up from CashByUserSection below.
+  // Counted cash is the live sum of every staff member's per-person count, reported up from
+  // CashByUserSection below; when there is one, cash on hand is whatever wasn't deposited.
  const [cashSummary, setCashSummary] = useState<{ actualTotal: number | null; denominations: PersonDenom[] }>({ actualTotal: null, denominations: [] });

  useEffect(() => { setLines(initialLines); }, [initialLines]);

-  const setLine = (method: CashupMethod, field: keyof LineInput, value: string) => {
-    setLines(prev => ({ ...prev, [method]: { ...prev[method], [field]: value } }));
-  };
+  const setLine = (method: CashupMethod, next: SettlementInput) => setLines(prev => ({ ...prev, [method]: next }));

-  // Cash is included with notes only — its actual/denominations are always sourced server-side
-  // from per-person counts (see cashupController.closeEvent), never from this payload.
-  const buildLinesPayload = () => METHODS.map(m => m === "cash"
-    ? { method: "cash", notes: lines.cash.notes || null }
-    : { method: m, actualAmount: lines[m].actualAmount === "" ? null : parseFloat(lines[m].actualAmount), notes: lines[m].notes || null });
+  // Methods with nothing expected and nothing entered are hidden to keep the screen short.
+  const hasInput = (m: CashupMethod) => {
+    const l = lines[m];
+    return l.bankAmount !== "" || l.onHandAmount !== "" || l.pendingAmount !== "" || l.writeOffs.length > 0;
+  };
+  const shownMethods = METHODS.filter(m => Math.abs(data.expectedCashByMethod[m]) > 0.005 || hasInput(m) || (m === "cash" && cashSummary.actualTotal !== null));
+
+  const buildLinesPayload = () => METHODS.map(m => {
+    const l = lines[m];
+    const amount = (v: string) => (v.trim() === "" ? null : parseFloat(v));
+    return {
+      method: m,
+      bankAmount: amount(l.bankAmount),
+      onHandAmount: m === "cash" ? amount(l.onHandAmount) : null,
+      pendingAmount: m === "cash" ? null : amount(l.pendingAmount),
+      pendingReference: l.pendingReference || null,
+      writeOffs: l.writeOffs.map(w => ({ category: w.category, amount: amount(w.amount), reason: w.reason || null })),
+      notes: l.notes || null,
+    };
+  });

  const saveDraft = async () => {
    setBusy(true); setError(null);
    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);
    }
  };

  const closeWithCashup = async () => {
-    if (!confirm("Close this event with the entered reconciliation? This will count unallocated donations as profit and fully lock the event until it's reopened.")) return;
+    const open = shownMethods
+      .map(m => ({ m, s: settle(m, data.expectedCashByMethod[m], m === "cash" ? cashSummary.actualTotal : null, lines[m]) }))
+      .filter(({ s }) => s.unaccounted === null || Math.abs(s.unaccounted) >= 0.005)
+      .map(({ m, s }) => `${METHOD_LABELS[m]}: ${s.unaccounted === null ? "not settled" : money(s.unaccounted)}`);
+    const warning = open.length > 0
+      ? `\n\nNot everything is accounted for:\n${open.join("\n")}\n\nThis will be recorded as a variance and comes off profit.`
+      : "";
+    if (!confirm(`Close this event with this cashup? Unallocated donations will be counted as profit and the event will be locked until it's reopened.${warning}`)) return;
    setBusy(true); setError(null);
    try {
      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);
    }
  };

  const quickClose = async () => {
-    if (!confirm("Quick close this event without a per-method cashup? System totals will be accepted as-is, unallocated donations will be counted as profit, and the event will be fully locked until it's reopened.")) return;
+    if (!confirm("Quick close this event without a cashup? System totals will be accepted as-is, unallocated donations will be counted as profit, and the event will be fully locked until it's reopened.")) return;
    setBusy(true); setError(null);
    try {
      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,68 +1021,49 @@ 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);
    }
  };

  const reconciled = data.reconciled;
+  const settledMethods = METHODS.filter(m => {
+    const r = reconciled?.byMethod?.[m];
+    return r && (Math.abs(r.expected) > 0.005 || r.actual !== null || r.writeOffTotal > 0);
+  });

  return (
    <div className="space-y-4">
-      <div className="bg-white border rounded-lg p-4 space-y-3 overflow-auto">
-        <div className="text-sm font-medium">Cash-up reconciliation</div>
-        <table className="w-full text-sm min-w-[640px]">
-          <thead>
-            <tr className="text-left text-gray-500 border-b">
-              <th className="py-1">Method</th>
-              <th className="py-1 text-right">Income</th>
-              <th className="py-1 text-right">Costs from method</th>
-              <th className="py-1 text-right">Expected cash</th>
-              <th className="py-1 text-right">Actual</th>
-              <th className="py-1 text-right">Variance</th>
-              <th className="py-1">Notes</th>
-            </tr>
-          </thead>
-          <tbody>
-            {METHODS.map(m => {
-              const r = reconciled?.byMethod?.[m];
-              return (
-                <tr key={m} className="border-b last:border-0 align-top">
-                  <td className="py-1.5">{METHOD_LABELS[m]}</td>
-                  <td className="py-1.5 text-right">{money(data.paymentsByMethod[m])}</td>
-                  <td className="py-1.5 text-right">{money(data.costsByMethod[m])}</td>
-                  <td className="py-1.5 text-right">{money(data.expectedCashByMethod[m])}</td>
-                  <td className="py-1.5 text-right">
-                    {isClosed ? (
-                      money(r?.actual ?? null)
-                    ) : m === "cash" ? (
-                      cashSummary.actualTotal != null ? money(cashSummary.actualTotal) : <span className="text-gray-400">not counted</span>
-                    ) : (
-                      <input type="number" step="0.01" className="w-28 border rounded px-2 py-1 text-sm text-right" value={lines[m].actualAmount} onChange={e => setLine(m, "actualAmount", e.target.value)} />
-                    )}
-                  </td>
-                  <td className="py-1.5 text-right">
-                    {isClosed
-                      ? (r?.variance != null ? money(r.variance) : <span className="text-gray-400">not reconciled</span>)
-                      : (m === "cash"
-                        ? (cashSummary.actualTotal != null ? money(cashSummary.actualTotal - data.expectedCashByMethod[m]) : "—")
-                        : (lines[m].actualAmount !== "" ? money(parseFloat(lines[m].actualAmount) - data.expectedCashByMethod[m]) : "—"))}
-                  </td>
-                  <td className="py-1.5">
-                    {isClosed ? (r?.notes || "—") : (
-                      <input className="w-full border rounded px-2 py-1 text-sm" value={lines[m].notes} onChange={e => setLine(m, "notes", e.target.value)} />
-                    )}
-                  </td>
-                </tr>
-              );
-            })}
-          </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="bg-white border rounded-lg p-4 space-y-3">
+        <div>
+          <div className="text-sm font-medium">Where did the money end up?</div>
+          <div className="text-xs text-gray-500">
+            {isClosed
+              ? "As recorded when the event was closed. Pending money can be marked received or written off without reopening."
+              : "For each payment method, say how much is in the bank, still on hand or pending, and write off anything lost to fees, charges or shortfalls."}
+          </div>
+        </div>
+        {isClosed ? (
+          reconciled?.action === "closed" && settledMethods.length > 0 ? (
+            settledMethods.map(m => <SettledCard key={m} method={m} r={reconciled.byMethod[m]} token={token} onChanged={onChanged} />)
+          ) : (
+            <div className="text-xs text-gray-400">This event was quick closed, so no settlement was recorded.</div>
+          )
+        ) : shownMethods.length === 0 ? (
+          <div className="text-xs text-gray-400">No payments to settle for this event.</div>
+        ) : (
+          shownMethods.map(m => (
+            <SettlementCard
+              key={m}
+              method={m}
+              data={data}
+              counted={m === "cash" ? cashSummary.actualTotal : null}
+              input={lines[m]}
+              onChange={next => setLine(m, next)}
+            />
+          ))
        )}
      </div>

@@ -774,7 +1076,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>
@@ -787,20 +1089,7 @@ function ReconciliationTab({ eventId, token, data, busy, setBusy, setError, onCh
        })()}
      </div>

-      <div className="bg-white border rounded-lg p-4 grid grid-cols-1 sm:grid-cols-3 gap-3 text-sm">
-        <div>
-          <div className="text-gray-500 text-xs">Donations counted as profit</div>
-          <div className="font-semibold">{money(data.unallocatedDonationsTotal)}</div>
-        </div>
-        <div>
-          <div className="text-gray-500 text-xs">Total costs</div>
-          <div className="font-semibold">{money(data.totalCosts)}</div>
-        </div>
-        <div>
-          <div className="text-gray-500 text-xs">Net profit</div>
-          <div className="font-semibold">{money(data.netProfit)}</div>
-        </div>
-      </div>
+      <ProfitSummary data={data} />

      {!isClosed && (
        <div className="bg-white border rounded-lg p-4 space-y-2">
@@ -6,12 +6,15 @@ 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";
+import { BackLink } from "@/components/shared/BackLink";

 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 +28,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();
@@ -53,15 +56,11 @@ export default function CashupLandingPage() {
            <Wallet className="w-5 h-5 text-brand-600" />
          </div>
          <div>
-            <h1 className="text-xl font-semibold text-gray-900">Post-event Cashup</h1>
+            <BackLink href="/dashboard" />
+            <h1 className="text-xl font-semibold text-gray-900 mt-0.5">Post-event Cashup</h1>
            <p className="text-sm text-gray-500 mt-1">Set costs, reconcile takings, and close out an event. Admin only.</p>
          </div>
        </div>
-        <button
-          type="button"
-          className="px-3 py-1.5 text-sm rounded-lg bg-gray-100 hover:bg-gray-200 text-gray-800 shrink-0"
-          onClick={() => router.push("/dashboard")}
-        >Back</button>
      </div>

      {error && <div className="text-sm text-red-600 bg-red-50 border border-red-100 rounded p-2">{error}</div>}
@@ -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";
@@ -14,6 +14,7 @@ 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)}`;
@@ -32,6 +33,7 @@ const QUICK_ACTIONS = [
  { 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 },
  { href: "/dashboard/supervisor/coupons", label: "Coupon codes", description: "Discounts for staff, leaders and promotions", icon: TicketPercent },
+  { href: "/dashboard/supervisor/bundles", label: "Bundle deals", description: "Tickets sold together for one price", icon: Gift },
  { href: "/dashboard/staff/ticket-scanning", label: "Open scanner", description: "Use your device camera to validate tickets", icon: QrCode },
  { href: "/dashboard/supervisor/reports", label: "Reports", description: "View, export, and email reports", icon: BarChart2 },
  { href: "/dashboard/admin/forms", label: "Attendee forms", description: "View submitted attendee forms", icon: FileText },
@@ -67,35 +69,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.
@@ -105,7 +107,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 (
@@ -1,11 +1,14 @@
 "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";
+import { BackLink } from "@/components/shared/BackLink";

 const STATUS_OPTIONS = ["pending", "confirmed", "partial_paid", "paid", "cancelled"] as const;

@@ -17,6 +20,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 +41,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 +56,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 +111,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 +122,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 +130,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 +158,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 +171,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 +179,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);
@@ -194,11 +198,11 @@ export default function AdminRegistrationsPage() {
            <ClipboardList className="w-5 h-5 text-brand-600" />
          </div>
          <div>
-            <h1 className="text-2xl font-semibold text-gray-900">Manage Registrations</h1>
+            <BackLink href="/dashboard" />
+            <h1 className="text-2xl font-semibold text-gray-900 mt-0.5">Manage Registrations</h1>
            <p className="text-sm text-gray-500">{registrations.length} registration{registrations.length !== 1 ? "s" : ""} total</p>
          </div>
        </div>
-        <button className="px-3 py-1.5 text-sm rounded-lg bg-gray-100 hover:bg-gray-200" onClick={() => router.push('/dashboard')}>Back</button>
      </div>

      {!isAdmin && (
@@ -275,7 +279,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 +340,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 +360,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 +386,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 +413,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>
@@ -2,8 +2,8 @@

 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 { useSearchParams } from "next/navigation";
+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, CreditCard, DatabaseBackup, type LucideIcon } from "lucide-react";
@@ -13,6 +13,8 @@ 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";
+import { BackLink } from "@/components/shared/BackLink";

 type TabId = "organisation" | "branding" | "notifications" | "email" | "legal" | "whatsapp" | "yoco" | "backups";

@@ -84,7 +86,6 @@ export default function SiteSettingsPage() {

 function SiteSettingsPageInner() {
  const { token } = useAuth();
-  const router = useRouter();
  const searchParams = useSearchParams();
  const { reload: reloadSettings } = useSiteSettings();

@@ -178,9 +179,9 @@ function SiteSettingsPageInner() {
        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); };
@@ -194,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);
    }
@@ -253,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);
    }
@@ -278,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);
    }
@@ -312,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);
    }
@@ -347,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);
    }
@@ -364,15 +366,10 @@ function SiteSettingsPageInner() {
      {/* Header */}
      <div className="flex items-center justify-between mb-6">
        <div>
-          <h1 className="text-2xl font-semibold text-gray-900">Site Settings</h1>
+          <BackLink href="/dashboard/admin" />
+          <h1 className="text-2xl font-semibold text-gray-900 mt-0.5">Site Settings</h1>
          <p className="text-sm text-gray-500 mt-1">Configure your organisation, branding, email, and legal pages.</p>
        </div>
-        <button
-          className="px-3 py-1.5 text-sm rounded-lg bg-gray-100 hover:bg-gray-200"
-          onClick={() => router.push("/dashboard/admin")}
-        >
-          Back
-        </button>
      </div>

      {/* Tab bar */}
@@ -875,7 +872,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);
@@ -919,12 +916,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")) {
@@ -947,8 +944,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);
    }
@@ -965,8 +962,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);
    }
@@ -976,11 +973,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);
    }
@@ -1224,8 +1221,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);
                  }
@@ -5,9 +5,12 @@ import { useAuth } from "@/hooks/useAuth";
 import { useRouter } from "next/navigation";
 import { apiFetch } from "@/lib/api";
 import { useDismissingState } from "@/hooks/useDismissingState";
-import { beginImpersonation } from "@/lib/impersonation";
+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";
+import { BackLink } from "@/components/shared/BackLink";

 interface UserItem {
  id: string;
@@ -27,15 +30,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();
@@ -98,26 +92,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 = () => {
@@ -129,7 +123,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 },
      });
@@ -141,8 +135,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);
    }
@@ -155,7 +149,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,
@@ -172,8 +166,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);
    }
@@ -183,8 +177,8 @@ 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");
    }
  };

@@ -197,10 +191,10 @@ export default function AdminUsersPage() {
    setImpBusy(true);
    setImpError(null);
    try {
-      const res = await apiFetch<any>(`/api/admin/impersonate/${encodeURIComponent(impTarget.id)}`, { method: "POST", authToken: token, body: { reason: impReason } });
+      const res = await apiFetch<ImpersonationStart>(`/api/admin/impersonate/${encodeURIComponent(impTarget.id)}`, { method: "POST", authToken: token, body: { reason: impReason } });
      beginImpersonation(res);
-    } catch (e: any) {
-      setImpError(e?.message || "Couldn't start impersonation");
+    } catch (e) {
+      setImpError(errorMessage(e) || "Couldn't start impersonation");
      setImpBusy(false);
    }
  };
@@ -215,8 +209,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");
    }
  };

@@ -225,8 +219,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");
    }
  };

@@ -235,8 +229,8 @@ 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");
    }
  };

@@ -266,12 +260,12 @@ export default function AdminUsersPage() {
            <UsersIcon className="w-5 h-5 text-brand-600" />
          </div>
          <div>
-            <h1 className="text-2xl font-semibold text-gray-900">User Management</h1>
+            <BackLink href="/dashboard" />
+            <h1 className="text-2xl font-semibold text-gray-900 mt-0.5">User Management</h1>
            <p className="text-sm text-gray-500">{total} user{total !== 1 ? "s" : ""} total</p>
          </div>
        </div>
        <div className="flex gap-2">
-          <button className="px-3 py-1.5 text-sm rounded-lg bg-gray-100 hover:bg-gray-200" onClick={() => router.push("/dashboard")}>Back</button>
          <button className="px-3 py-1.5 text-sm rounded-lg bg-brand-600 text-white hover:bg-brand-700" onClick={() => setCreateOpen(v => !v)}>
            {createOpen ? "Close" : "Create user"}
          </button>
@@ -6,8 +6,12 @@ import { apiFetch } from "@/lib/api";
 import { useDismissingState } from "@/hooks/useDismissingState";
 import { useRouter, useSearchParams } from "next/navigation";
 import { formatDate } from "@/lib/date";
+import { printTicketCards } from "@/lib/ticketPrint";
 import { QrImage } from "@/components/shared/QrImage";
 import { Ticket } from "lucide-react";
+import { errorMessage } from "@/lib/utils";
+import type { Event, Ticket as TicketRecord } from "@/types";
+import { BackLink } from "@/components/shared/BackLink";

 function EventTicketsContent() {
  const { token, user } = useAuth();
@@ -17,9 +21,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 +40,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 +51,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 +81,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(() => {
@@ -137,96 +143,7 @@ function EventTicketsContent() {
    return list;
  }, [tickets, eventId, selectedUserId, selectedVariantId]);

-  // Printing helpers
-  const buildTicketHtmlCard = (t: any) => {
-    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";
-    const optVariant = t.registrationOption?.variant?.name;
-    const type = optVariant ? `${optBase} — ${optVariant}` : optBase;
-    const qty = t.quantity || 1;
-    const holder = t.attendee?.name ? `${t.attendee.name}${t.user?.name ? ` (booked by ${t.user.name})` : ""}` : (t.user?.name || t.userId || "");
-    const qrSrc = `https://api.qrserver.com/v1/create-qr-code/?size=140x140&data=${encodeURIComponent(
-        t.qrCode || t.id
-    )}`;
-    const dateStr = eventDate ? formatDate(eventDate) : "";
-    return `
-      <div class="ticket">
-        <div class="evt">${eventTitle}</div>
-        ${dateStr ? `<div class="date">${dateStr}</div>` : ""}
-        <div class="type">${type}</div>
-        <div class="qty">Qty: <strong>${qty}</strong></div>
-        <div class="qrwrap"><img src="${qrSrc}" alt="QR" /></div>
-        <div class="meta">ID: ${t.id}</div>
-        ${holder ? `<div class="meta">${holder}</div>` : ""}
-      </div>
-    `;
-  };
-
-  const openPrintWindow = (pagesHtml: string) => {
-    const w = window.open("", "_blank");
-    if (!w) return;
-    w.document.write(`<!doctype html><html><head><title>Tickets</title>
-      <style>
-        @page { size: A4; margin: 10mm; }
-        * { box-sizing: border-box; }
-        body { font-family: Arial, Helvetica, sans-serif; margin: 0; padding: 0; }
-        .page {
-          display: grid;
-          grid-template-columns: repeat(2, 1fr);
-          grid-template-rows: repeat(4, 1fr);
-          height: 277mm;
-          gap: 6mm;
-          page-break-after: always;
-          break-after: page;
-        }
-        .page:last-child { page-break-after: avoid; break-after: avoid; }
-        .ticket { border: 1px solid #000; padding: 5mm; display: flex; flex-direction: column; justify-content: space-between; overflow: hidden; }
-        .evt { font-weight: bold; font-size: 14px; }
-        .type { font-size: 12px; margin-top: 2mm; }
-        .qty { font-size: 11px; margin-top: 1mm; }
-        .date { font-size: 10px; color: #555; margin-top: 1mm; }
-        .qrwrap { display: flex; justify-content: center; margin: 2mm 0; }
-        .qrwrap img { width: 30mm; height: 30mm; }
-        .meta { font-size: 10px; text-align: center; }
-      </style>
-    </head><body>
-      ${pagesHtml}
-      <script>
-        (function(){
-          function printWhenReady(){
-            var imgs = Array.prototype.slice.call(document.images);
-            if(imgs.length === 0){ window.print(); return; }
-            var remaining = imgs.length;
-            function done(){ remaining--; if(remaining <= 0){ setTimeout(function(){ window.print(); }, 100); } }
-            imgs.forEach(function(img){
-              if (img.complete) { done(); }
-              else {
-                img.addEventListener('load', done, { once: true });
-                img.addEventListener('error', done, { once: true });
-              }
-            });
-          }
-          if (document.readyState === 'complete') printWhenReady();
-          else window.addEventListener('load', printWhenReady);
-        })();
-      </script>
-    </body></html>`);
-    w.document.close();
-    w.focus();
-  };
-
-  const printTickets = (ticketList: any[]) => {
-    if (!ticketList || ticketList.length === 0) return;
-    // Chunk into pages of 8 (2 columns × 4 rows per A4 sheet)
-    const PAGE_SIZE = 8;
-    const pages: string[] = [];
-    for (let i = 0; i < ticketList.length; i += PAGE_SIZE) {
-      const chunk = ticketList.slice(i, i + PAGE_SIZE);
-      pages.push(`<div class="page">${chunk.map(buildTicketHtmlCard).join("")}</div>`);
-    }
-    openPrintWindow(pages.join(""));
-  };
+  const printTickets = (ticketList: TicketRecord[]) => printTicketCards(ticketList, (t) => t.user?.name);

  return (
      <div className="max-w-6xl mx-auto w-full p-6">
@@ -235,14 +152,11 @@ function EventTicketsContent() {
            <div className="w-10 h-10 rounded-xl bg-brand-50 flex items-center justify-center shrink-0">
              <Ticket className="w-5 h-5 text-brand-600" />
            </div>
-            <h1 className="text-2xl font-semibold text-gray-900">Event Tickets</h1>
+            <div>
+              <BackLink href="/dashboard" />
+              <h1 className="text-2xl font-semibold text-gray-900 mt-0.5">Event Tickets</h1>
+            </div>
          </div>
-          <button
-              className="px-3 py-1.5 text-sm rounded-lg bg-gray-100 hover:bg-gray-200 text-gray-800 shadow-sm"
-              onClick={() => router.push("/dashboard")}
-          >
-            Back
-          </button>
        </div>
        <p className="text-sm text-gray-600 mb-4">
          View and print tickets for an event.
@@ -2,10 +2,10 @@

 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";
+import { BackLink } from "@/components/shared/BackLink";

 type Member = {
  id: string; name: string; gender: string | null; dateOfBirth: string | null; phone: string | null;
@@ -25,7 +25,6 @@ const ageOn = (dob: string | null, on: string) => {
 /** 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);

@@ -42,7 +41,7 @@ export default function MyGroupsPage() {
          <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>
+          <BackLink href="/dashboard" />
          <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>
@@ -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";
@@ -9,6 +9,7 @@ import { useVisiblePolling } from "@/hooks/useVisiblePolling";
 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 },
@@ -35,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.
@@ -104,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>
@@ -122,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>
@@ -1,28 +1,47 @@
 "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";
 import { useDismissingState } from "@/hooks/useDismissingState";
-import { useRouter } from "next/navigation";
 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";
+import { BackLink } from "@/components/shared/BackLink";
+
+// 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 +55,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 +66,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 +80,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 +109,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 +139,6 @@ export default function TicketScanningPage() {
  }, [selectedEventId, selectedSectionId]);

  async function handleResult(text: string) {
-    setLastResult(text);
    setError(null);
    setScanInfo(null);
    try {
@@ -157,11 +175,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 +200,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 +210,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 +222,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 +257,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 +269,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 +280,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 +298,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">
@@ -312,9 +329,11 @@ export default function TicketScanningPage() {
              <div className="w-10 h-10 rounded-xl bg-brand-50 flex items-center justify-center shrink-0">
                <QrCode className="w-5 h-5 text-brand-600" />
              </div>
-              <h1 className="text-2xl font-semibold text-gray-900">Ticket Scanning</h1>
+              <div>
+                <BackLink href="/dashboard" />
+                <h1 className="text-2xl font-semibold text-gray-900 mt-0.5">Ticket Scanning</h1>
+              </div>
            </div>
-            <button className="px-3 py-1.5 text-sm rounded-lg bg-gray-100 hover:bg-gray-200 text-gray-800 shadow-sm" onClick={() => router.push('/dashboard')}>Back</button>
          </div>
          <p className="text-sm text-gray-600 mb-4">
            Use the button to start/stop scanning. The back camera will be used when available.
@@ -403,11 +422,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 +438,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 +552,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>
@@ -8,10 +8,24 @@ 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";
+import { BackLink } from "@/components/shared/BackLink";

 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";
@@ -67,7 +81,7 @@ export default function AllocationsPage() {
  const canView = useMemo(() => user?.role === "admin" || user?.role === "supervisor", [user]);
  useEffect(() => { if (!loading && !user) router.replace("/login"); }, [user, loading, router]);

-  const [events, setEvents] = useState<any[]>([]);
+  const [events, setEvents] = useState<Event[]>([]);
  const [eventId, setEventId] = useState("");
  const [board, setBoard] = useState<Board | null>(null);
  const [setId, setSetId] = useState("");
@@ -80,7 +94,7 @@ export default function AllocationsPage() {

  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 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());
@@ -96,8 +110,8 @@ export default function AllocationsPage() {
      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: any) {
-      setError(e?.message || "Failed to load allocations");
+    } catch (e) {
+      setError(errorMessage(e) || "Failed to load allocations");
    }
  }, [token, eventId, setError]);
  useEffect(() => { load(); }, [load]);
@@ -126,8 +140,8 @@ export default function AllocationsPage() {
    }));
    try {
      await call(`/api/allocations/sets/${current.id}/assignments`, "PUT", { attendeeId, groupId });
-    } catch (err: any) {
-      setError(err?.message || "Couldn't move them");
+    } catch (err) {
+      setError(errorMessage(err) || "Couldn't move them");
      load();
    }
  };
@@ -138,8 +152,8 @@ export default function AllocationsPage() {
      const msg = await fn();
      if (msg) setInfo(msg);
      await load();
-    } catch (e: any) {
-      setError(e?.message || "Something went wrong");
+    } catch (e) {
+      setError(errorMessage(e) || "Something went wrong");
    } finally {
      setBusy(false);
    }
@@ -160,19 +174,19 @@ export default function AllocationsPage() {
  const printLists = async (master: boolean, medical: boolean) => {
    if (!current || !board) return;
    try {
-      const data = await apiFetch<any>(`/api/allocations/sets/${current.id}/lists${medical ? "?medical=true" : ""}`, { authToken: token! });
+      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: any) => `<tr><td>${esc(m.name)}</td><td>${esc(genderLabel(m.gender))}</td><td>${esc(ageOn(m.dateOfBirth, board.event.startDate) ?? "")}</td>`
+      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: any) => g.members.map((m: any) => ({ ...m, group: g.name }))).sort((a: any, b: any) => 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: any) => row(m).replace("<tr>", `<tr><td>${esc(m.group)}</td>`)).join("")}</table>`;
+        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: any) => `<section><h1>${esc(data.event.title)} — ${esc(g.name)}</h1>`
+        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("");
      }
@@ -182,8 +196,8 @@ export default function AllocationsPage() {
        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: any) {
-      setError(e?.message || "Couldn't load the lists");
+    } catch (e) {
+      setError(errorMessage(e) || "Couldn't load the lists");
    }
  };

@@ -194,7 +208,7 @@ export default function AllocationsPage() {
          <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>
+          <BackLink href="/dashboard" />
          <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>
@@ -0,0 +1,557 @@
+"use client";
+
+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 { Gift, Plus, X, Trash2, Pencil, Power, CalendarClock } from "lucide-react";
+import { errorMessage } from "@/lib/utils";
+import { BackLink } from "@/components/shared/BackLink";
+import type { BundleGroupPricing, BundleKind, EventBundle } from "@/types";
+
+type OptionLite = { id: string; name: string; price: number; variants?: { id: string; name: string; price?: number | null }[] };
+type EventLite = { id: string; title: string; startDate: string; endDate?: string; eventOptions: OptionLite[] };
+
+type ItemDraft = { eventOptionId: string; variantId: string | null; quantity: string };
+type Draft = {
+  name: string;
+  description: string;
+  kind: BundleKind;
+  price: string;
+  setSize: string;
+  freeCount: string;
+  groupPricing: BundleGroupPricing;
+  items: ItemDraft[];
+  validFrom: string;
+  validUntil: string;
+  isActive: boolean;
+};
+
+const blankDraft = (options: OptionLite[]): Draft => ({
+  name: "", description: "", kind: "exact", price: "", setSize: "4", freeCount: "1", groupPricing: "per_ticket",
+  items: options.slice(0, 2).map(o => ({ eventOptionId: o.id, variantId: null, quantity: "1" })),
+  validFrom: "", validUntil: "", isActive: true,
+});
+
+// <input type="datetime-local"> wants local "YYYY-MM-DDTHH:mm".
+const toLocalInput = (iso: string | null | undefined) => {
+  if (!iso) return "";
+  const d = new Date(iso);
+  const pad = (n: number) => String(n).padStart(2, "0");
+  return `${d.getFullYear()}-${pad(d.getMonth() + 1)}-${pad(d.getDate())}T${pad(d.getHours())}:${pad(d.getMinutes())}`;
+};
+
+const draftFromBundle = (b: EventBundle): Draft => ({
+  name: b.name, description: b.description || "", kind: b.kind || "exact",
+  price: b.kind === "free" ? "" : String(b.price),
+  setSize: b.setSize ? String(b.setSize) : "4", freeCount: b.freeCount ? String(b.freeCount) : "1",
+  groupPricing: b.groupPricing || "per_ticket",
+  items: b.items.map(i => ({ eventOptionId: i.eventOptionId, variantId: i.variantId || null, quantity: String(i.quantity) })),
+  validFrom: toLocalInput(b.validFrom), validUntil: toLocalInput(b.validUntil), isActive: b.isActive,
+});
+
+const fmtDate = (iso: string | null | undefined) => (iso ? new Date(iso).toLocaleDateString(undefined, { day: "numeric", month: "short", year: "numeric" }) : "");
+const fmtRand = (n: number) => `R ${(n || 0).toFixed(2)}`;
+// fieldCls has no width, for fields sized by their row (inputCls is full width).
+const fieldCls = "border rounded-lg px-3 py-2 text-sm focus:outline-none focus:ring-2 focus:ring-brand-400";
+const inputCls = `w-full ${fieldCls}`;
+const isPast = (ev: EventLite) => new Date(ev.endDate || ev.startDate).getTime() < Date.now();
+
+const KIND_INFO: Record<BundleKind, { label: string; hint: string; example: string }> = {
+  exact: { label: "Exact set", hint: "These tickets in these numbers", example: "2 adults + 3 kids for R220" },
+  mix: { label: "Pick any", hint: "Any mix of the chosen tickets", example: "Any 4 tickets for R250" },
+  free: { label: "Buy X get Y free", hint: "Cheapest ones in each set are free", example: "Buy 3, get 1 free" },
+  group: { label: "Group discount", hint: "A lower price from a group size up", example: "10+ tickets: R70 each" },
+};
+
+/** Standard price of one unit of an item (variant price, else the option's). */
+function unitPrice(options: OptionLite[], item: { eventOptionId: string; variantId: string | null }) {
+  const o = options.find(x => x.id === item.eventOptionId);
+  if (!o) return 0;
+  const v = item.variantId ? (o.variants || []).find(x => x.id === item.variantId) : null;
+  return Number(v && v.price !== null && v.price !== undefined ? v.price : o.price) || 0;
+}
+
+function bundleStatus(b: EventBundle): { label: string; cls: string } {
+  const now = Date.now();
+  if (!b.isActive) return { label: "Off", cls: "bg-gray-100 text-gray-600" };
+  if (b.validUntil && new Date(b.validUntil).getTime() < now) return { label: "Ended", cls: "bg-gray-100 text-gray-600" };
+  if (b.validFrom && new Date(b.validFrom).getTime() > now) return { label: "Scheduled", cls: "bg-amber-100 text-amber-800" };
+  return { label: "On sale", cls: "bg-green-100 text-green-800" };
+}
+
+export default function BundlesPage() {
+  const { user, loading, token } = useAuth();
+  const router = useRouter();
+  const canView = useMemo(() => user?.role === "admin" || user?.role === "supervisor", [user]);
+
+  useEffect(() => {
+    if (loading) return;
+    if (!user) router.replace("/login");
+  }, [user, loading, router]);
+
+  const [allEvents, setAllEvents] = useState<EventLite[]>([]);
+  const [showPast, setShowPast] = useState(false);
+  const [eventId, setEventId] = useState("");
+  const [bundles, setBundles] = useState<EventBundle[]>([]);
+  const [fetching, setFetching] = useState(false);
+  const [error, setError] = useDismissingState<string | null>(null);
+  const [info, setInfo] = useDismissingState<string | null>(null);
+  const [editing, setEditing] = useState<{ id: string | null; draft: Draft } | null>(null);
+
+  useEffect(() => {
+    if (!token || !canView) return;
+    apiFetch<EventLite[]>("/api/events/all?includePast=true", { authToken: token })
+      .then(list => setAllEvents(list || []))
+      .catch(e => setError(errorMessage(e) || "Failed to load events"));
+  }, [token, canView, setError]);
+
+  // Upcoming events soonest first; past ones (when shown) after them, most recent first.
+  const events = useMemo(() => {
+    const upcoming = allEvents.filter(e => !isPast(e)).sort((a, b) => new Date(a.startDate).getTime() - new Date(b.startDate).getTime());
+    const past = allEvents.filter(isPast).sort((a, b) => new Date(b.startDate).getTime() - new Date(a.startDate).getTime());
+    return showPast ? [...upcoming, ...past] : upcoming;
+  }, [allEvents, showPast]);
+
+  // Keep the picked event while it's in the list; otherwise start on the next upcoming one.
+  useEffect(() => {
+    if (!events.some(e => e.id === eventId)) setEventId(events[0]?.id || "");
+  }, [events, eventId]);
+
+  const event = events.find(e => e.id === eventId) || null;
+  const options = event?.eventOptions || [];
+
+  const load = useCallback(async () => {
+    if (!token || !eventId) { setBundles([]); return; }
+    setFetching(true);
+    try {
+      setBundles(await apiFetch<EventBundle[]>(`/api/bundles/event/${eventId}`, { authToken: token }) || []);
+    } catch (e) {
+      setError(errorMessage(e) || "Failed to load bundles");
+    } finally {
+      setFetching(false);
+    }
+  }, [token, eventId, setError]);
+
+  useEffect(() => { load(); }, [load]);
+
+  const toggleActive = async (b: EventBundle) => {
+    try {
+      await apiFetch(`/api/bundles/${b.id}`, { method: "PUT", authToken: token!, body: { isActive: !b.isActive } });
+      setInfo(`${b.name} turned ${b.isActive ? "off" : "on"}.`);
+      load();
+    } catch (e) {
+      setError(errorMessage(e) || "Failed to update bundle");
+    }
+  };
+
+  const remove = async (b: EventBundle) => {
+    if (!window.confirm(`Delete "${b.name}"?`)) return;
+    try {
+      const res = await apiFetch<{ message: string }>(`/api/bundles/${b.id}`, { method: "DELETE", authToken: token! });
+      setInfo(res?.message || "Bundle deleted");
+      load();
+    } catch (e) {
+      setError(errorMessage(e) || "Failed to delete bundle");
+    }
+  };
+
+  const startNew = () => setEditing({ id: null, draft: blankDraft(options) });
+  const canAdd = !!event && options.length > 0;
+
+  return (
+    <div className="max-w-6xl mx-auto w-full p-4 sm:p-6">
+      <div className="flex flex-col sm:flex-row sm:items-center sm:justify-between gap-3 mb-4">
+        <div className="flex items-center gap-3">
+          <div className="w-10 h-10 rounded-xl bg-brand-50 flex items-center justify-center shrink-0">
+            <Gift className="w-5 h-5 text-brand-600" />
+          </div>
+          <div>
+            <BackLink href="/dashboard" />
+            <h1 className="text-2xl font-semibold text-gray-900 mt-0.5">Bundle deals</h1>
+            <p className="text-sm text-gray-500">Tickets sold together for one price</p>
+          </div>
+        </div>
+        {canView && (
+          <button
+            onClick={startNew}
+            disabled={!canAdd}
+            className="inline-flex items-center justify-center gap-2 px-4 py-2 rounded-lg bg-brand-600 text-white text-sm font-medium hover:bg-brand-700 disabled:opacity-50 w-full sm:w-auto"
+          >
+            <Plus className="w-4 h-4" /> New bundle
+          </button>
+        )}
+      </div>
+
+      {!canView && (
+        <div className="p-3 border rounded bg-yellow-50 text-yellow-800 text-sm mb-4">You need supervisor access to manage bundle deals.</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="border rounded-xl p-4 bg-white shadow-sm">
+          <div className="flex flex-col sm:flex-row sm:items-end gap-3 mb-4">
+            <div className="w-full sm:w-auto">
+              <label className="block text-xs text-gray-600 mb-1">Event</label>
+              <select className="border rounded-lg px-3 py-2 text-sm w-full sm:min-w-[20rem]" value={eventId} onChange={e => setEventId(e.target.value)}>
+                {events.length === 0 && <option value="">{showPast ? "No events" : "No upcoming events"}</option>}
+                {events.map(ev => (
+                  <option key={ev.id} value={ev.id}>{ev.title} ({fmtDate(ev.startDate)}){isPast(ev) ? " · past" : ""}</option>
+                ))}
+              </select>
+            </div>
+            <label className="flex items-center gap-2 text-sm text-gray-700 sm:pb-2">
+              <input type="checkbox" checked={showPast} onChange={e => setShowPast(e.target.checked)} /> Show past events
+            </label>
+          </div>
+
+          {event && options.length === 0 && (
+            <p className="text-sm text-gray-500 py-6 text-center">This event has no tickets yet. Add ticket options to the event first.</p>
+          )}
+
+          {event && options.length > 0 && !fetching && bundles.length === 0 && (
+            <div className="text-center py-10">
+              <div className="w-12 h-12 rounded-full bg-emerald-50 flex items-center justify-center mx-auto mb-3">
+                <Gift className="w-6 h-6 text-emerald-600" />
+              </div>
+              <p className="text-sm font-medium text-gray-900">No bundle deals for this event yet</p>
+              <p className="text-xs text-gray-500 mt-1 max-w-sm mx-auto">e.g. &quot;Family deal: 2 adults + 3 kids for R220&quot;. Buyers get it automatically when their tickets match.</p>
+              <button onClick={startNew} className="mt-4 inline-flex items-center gap-2 px-4 py-2 rounded-lg bg-brand-600 text-white text-sm font-medium hover:bg-brand-700">
+                <Plus className="w-4 h-4" /> Create a bundle
+              </button>
+            </div>
+          )}
+
+          {bundles.length > 0 && (
+            <div className="grid grid-cols-1 md:grid-cols-2 gap-3">
+              {bundles.map(b => (
+                <BundleCard
+                  key={b.id}
+                  bundle={b}
+                  onEdit={() => setEditing({ id: b.id, draft: draftFromBundle(b) })}
+                  onToggle={() => toggleActive(b)}
+                  onDelete={() => remove(b)}
+                />
+              ))}
+            </div>
+          )}
+
+          <p className="text-xs text-gray-500 mt-4">
+            Bundles apply automatically, as many times as someone&apos;s tickets allow, and only when cheaper than the tickets at the prices
+            actually charged (early-bird and staff prices included). Coupon codes come off afterwards.
+          </p>
+        </div>
+      )}
+
+      {editing && event && (
+        <BundleModal
+          token={token!}
+          event={event}
+          bundleId={editing.id}
+          initial={editing.draft}
+          onClose={() => setEditing(null)}
+          onSaved={(msg) => { setEditing(null); setInfo(msg); load(); }}
+        />
+      )}
+    </div>
+  );
+}
+
+function BundleCard({ bundle: b, onEdit, onToggle, onDelete }: { bundle: EventBundle; onEdit: () => void; onToggle: () => void; onDelete: () => void }) {
+  const status = bundleStatus(b);
+  const kind = b.kind || "exact";
+  const dates = b.validFrom || b.validUntil
+    ? `${b.validFrom ? fmtDate(b.validFrom) : "Now"} – ${b.validUntil ? fmtDate(b.validUntil) : "no end date"}`
+    : null;
+  return (
+    <div className={`border rounded-xl p-4 flex flex-col gap-3 ${b.isActive ? "bg-white" : "bg-gray-50"}`}>
+      <div className="flex items-start justify-between gap-3">
+        <div className="min-w-0">
+          <div className="font-semibold text-gray-900 break-words">{b.name}</div>
+          {b.description && <div className="text-xs text-gray-500 mt-0.5 break-words">{b.description}</div>}
+        </div>
+        <span className={`shrink-0 text-xs px-2 py-0.5 rounded-full font-medium ${status.cls}`}>{status.label}</span>
+      </div>
+
+      <div className="text-xs font-medium text-brand-700">{KIND_INFO[kind].label}{kind === "exact" ? "" : ` · ${kind === "group" ? "qualifying" : "any of"}:`}</div>
+
+      <div className="flex flex-wrap gap-1.5">
+        {b.items.map(i => (
+          <span key={i.id || `${i.eventOptionId}-${i.variantId}`} className="inline-flex items-center gap-1 rounded-full bg-emerald-50 text-emerald-800 border border-emerald-100 px-2.5 py-1 text-xs">
+            {kind === "exact" && <span className="font-semibold">{i.quantity} ×</span>} {i.eventOption?.name || "Ticket"}{i.variant ? ` (${i.variant.name})` : ""}
+          </span>
+        ))}
+      </div>
+
+      <div>
+        <div className="flex items-baseline flex-wrap gap-x-2 gap-y-0.5">
+          {kind === "exact" || kind === "mix" ? (
+            <>
+              <span className="text-xl font-semibold text-gray-900">{fmtRand(b.price)}</span>
+              <span className="text-sm text-gray-500">{kind === "mix" ? `for any ${b.setSize}` : "for the set"}</span>
+              {b.standardValue !== null && <span className="text-sm text-gray-400 line-through">{fmtRand(b.standardValue)}</span>}
+            </>
+          ) : kind === "free" ? (
+            <span className="text-xl font-semibold text-gray-900">Buy {(b.setSize || 0) - (b.freeCount || 0)}, get {b.freeCount} free</span>
+          ) : (
+            <>
+              <span className="text-xl font-semibold text-gray-900">{b.groupPricing === "percent" ? `${b.price}% off` : `${fmtRand(b.price)} each`}</span>
+              <span className="text-sm text-gray-500">from {b.setSize} tickets</span>
+            </>
+          )}
+        </div>
+        <div className={`text-xs font-medium ${b.savingText || kind === "free" || (kind === "group" && b.groupPricing === "percent") ? "text-green-700" : "text-amber-700"}`}>
+          {b.savingText || (kind === "free" || (kind === "group" && b.groupPricing === "percent") ? "" : "No saving at the standard prices")}
+        </div>
+      </div>
+
+      <div className="text-xs text-gray-600 space-y-0.5">
+        <div>
+          Used <strong>{b.uses || 0}×</strong> on {b.registrations || 0} registration{b.registrations === 1 ? "" : "s"} · {fmtRand(b.totalDiscount || 0)} given
+        </div>
+        {dates && <div className="flex items-center gap-1"><CalendarClock className="w-3.5 h-3.5" /> {dates}</div>}
+      </div>
+
+      <div className="flex flex-wrap gap-2 pt-1 border-t border-gray-100 mt-auto">
+        <button onClick={onEdit} className="inline-flex items-center gap-1.5 px-3 py-1.5 text-xs rounded-lg border hover:bg-gray-50 mt-2">
+          <Pencil className="w-3.5 h-3.5" /> Edit
+        </button>
+        <button onClick={onToggle} className={`inline-flex items-center gap-1.5 px-3 py-1.5 text-xs rounded-lg border mt-2 ${b.isActive ? "text-amber-700 border-amber-200 hover:bg-amber-50" : "text-green-700 border-green-200 hover:bg-green-50"}`}>
+          <Power className="w-3.5 h-3.5" /> {b.isActive ? "Turn off" : "Turn on"}
+        </button>
+        <button onClick={onDelete} className="inline-flex items-center gap-1.5 px-3 py-1.5 text-xs rounded-lg border text-red-700 border-red-200 hover:bg-red-50 mt-2 sm:ml-auto">
+          <Trash2 className="w-3.5 h-3.5" /> Delete
+        </button>
+      </div>
+    </div>
+  );
+}
+
+function BundleModal({ token, event, bundleId, initial, onClose, onSaved }: {
+  token: string;
+  event: EventLite;
+  bundleId: string | null;
+  initial: Draft;
+  onClose: () => void;
+  onSaved: (message: string) => void;
+}) {
+  const [d, setD] = useState<Draft>(initial);
+  const [saving, setSaving] = useState(false);
+  const [error, setError] = useState<string | null>(null);
+  const set = <K extends keyof Draft>(key: K, value: Draft[K]) => setD(prev => ({ ...prev, [key]: value }));
+  const options = event.eventOptions || [];
+
+  const setItem = (i: number, patch: Partial<ItemDraft>) => set("items", d.items.map((it, j) => (j === i ? { ...it, ...patch } : it)));
+  const exact = d.kind === "exact";
+  const price = Number(d.price) || 0;
+  const size = Math.max(0, Math.floor(Number(d.setSize) || 0));
+  const free = Math.max(0, Math.floor(Number(d.freeCount) || 0));
+  const dearest = d.items.reduce((m, it) => Math.max(m, unitPrice(options, it)), 0);
+  // Exact: what the set costs separately. Pick any: the dearest possible set.
+  const standardValue = exact ? d.items.reduce((s, it) => s + unitPrice(options, it) * (Number(it.quantity) || 0), 0) : dearest * size;
+  const saving_ = standardValue - price;
+  const priceLabel = exact ? "Bundle price (R)" : d.kind === "mix" ? "Price for the set (R)" : d.groupPricing === "percent" ? "Percentage off (%)" : "Price per ticket (R)";
+
+  const save = async (e: React.FormEvent) => {
+    e.preventDefault();
+    setError(null);
+    setSaving(true);
+    try {
+      const body = {
+        name: d.name.trim(),
+        description: d.description.trim() || null,
+        kind: d.kind,
+        price: d.kind === "free" ? 0 : Number(d.price),
+        setSize: exact ? null : Number(d.setSize),
+        freeCount: d.kind === "free" ? Number(d.freeCount) : null,
+        groupPricing: d.kind === "group" ? d.groupPricing : null,
+        items: d.items.map(it => ({ eventOptionId: it.eventOptionId, variantId: it.variantId, quantity: exact ? Number(it.quantity) : 1 })),
+        validFrom: d.validFrom ? new Date(d.validFrom).toISOString() : null,
+        validUntil: d.validUntil ? new Date(d.validUntil).toISOString() : null,
+        isActive: d.isActive,
+      };
+      if (bundleId) {
+        await apiFetch(`/api/bundles/${bundleId}`, { method: "PUT", authToken: token, body });
+        onSaved(`${body.name} saved.`);
+      } else {
+        await apiFetch(`/api/bundles/event/${event.id}`, { method: "POST", authToken: token, body });
+        onSaved(`${body.name} created.`);
+      }
+    } catch (err) {
+      setError(errorMessage(err) || "Failed to save");
+    } finally {
+      setSaving(false);
+    }
+  };
+
+  return (
+    <div className="fixed inset-0 z-50 bg-black/40 flex items-end sm:items-center justify-center sm:p-4" onClick={onClose}>
+      <form onSubmit={save} className="bg-white w-full sm:max-w-2xl max-h-[92vh] sm:max-h-[90vh] rounded-t-2xl sm:rounded-xl shadow-xl flex flex-col" onClick={e => e.stopPropagation()}>
+        <div className="flex items-start justify-between gap-3 p-4 border-b">
+          <div className="min-w-0">
+            <h2 className="font-semibold">{bundleId ? "Edit bundle" : "New bundle deal"}</h2>
+            <p className="text-xs text-gray-500 truncate">{event.title}</p>
+          </div>
+          <button type="button" onClick={onClose} aria-label="Close" className="p-1 -m-1"><X className="w-5 h-5 text-gray-500" /></button>
+        </div>
+
+        <div className="p-4 space-y-5 overflow-y-auto overflow-x-hidden overscroll-contain">
+          <div className="grid grid-cols-1 sm:grid-cols-2 gap-4">
+            <div>
+              <label className="block text-sm font-medium text-gray-700 mb-1">Name</label>
+              <input className={inputCls} value={d.name} onChange={e => set("name", e.target.value)} placeholder="Family deal" required maxLength={80} />
+              <p className="text-xs text-gray-500 mt-1">Shown to buyers and on receipts.</p>
+            </div>
+            <div>
+              <label className="block text-sm font-medium text-gray-700 mb-1">Description <span className="font-normal text-gray-400">(optional)</span></label>
+              <input className={inputCls} value={d.description} onChange={e => set("description", e.target.value)} placeholder="Bring the whole family" />
+            </div>
+          </div>
+
+          <div>
+            <label className="block text-sm font-medium text-gray-700 mb-2">Type of deal</label>
+            <div className="grid grid-cols-2 gap-2">
+              {(Object.keys(KIND_INFO) as BundleKind[]).map(k => (
+                <button type="button" key={k} onClick={() => set("kind", k)} aria-pressed={d.kind === k}
+                  className={`text-left rounded-lg border p-2.5 transition-colors ${d.kind === k ? "border-brand-500 bg-brand-50 ring-1 ring-brand-500" : "hover:bg-gray-50"}`}>
+                  <div className="text-sm font-medium text-gray-900">{KIND_INFO[k].label}</div>
+                  <div className="text-xs text-gray-500">{KIND_INFO[k].hint}</div>
+                  <div className="text-[11px] text-gray-400 mt-0.5 hidden sm:block">e.g. {KIND_INFO[k].example}</div>
+                </button>
+              ))}
+            </div>
+          </div>
+
+          <div>
+            <label className="block text-sm font-medium text-gray-700 mb-2">{exact ? "Tickets in the bundle" : "Qualifying tickets"}</label>
+            {!exact && <p className="text-xs text-gray-500 -mt-1 mb-2">Any of these count towards the deal.</p>}
+            <div className="space-y-2">
+              {d.items.map((it, i) => {
+                const opt = options.find(o => o.id === it.eventOptionId);
+                const hasVariants = (opt?.variants || []).length > 0;
+                return (
+                  <div key={i} className="rounded-lg border bg-gray-50 p-2.5">
+                    <div className="flex items-center gap-2">
+                      {exact && (
+                        <>
+                          <input type="number" min="1" step="1" inputMode="numeric" className={`${fieldCls} w-16 shrink-0 px-2 bg-white text-center`} value={it.quantity} onChange={e => setItem(i, { quantity: e.target.value })} aria-label="Quantity" required />
+                          <span className="text-sm text-gray-500 shrink-0">×</span>
+                        </>
+                      )}
+                      <select className={`${fieldCls} min-w-0 flex-1 bg-white`} value={it.eventOptionId} onChange={e => setItem(i, { eventOptionId: e.target.value, variantId: null })} aria-label="Ticket">
+                        {options.map(o => <option key={o.id} value={o.id}>{o.name} ({fmtRand(o.price)})</option>)}
+                      </select>
+                      <button type="button" onClick={() => set("items", d.items.filter((_, j) => j !== i))} disabled={d.items.length <= 1}
+                        className="p-2 shrink-0 rounded-lg text-gray-400 hover:text-red-600 hover:bg-red-50 disabled:opacity-30 disabled:hover:bg-transparent" aria-label="Remove ticket">
+                        <Trash2 className="w-4 h-4" />
+                      </button>
+                    </div>
+                    {hasVariants && (
+                      <select className={`${inputCls} mt-2 bg-white`} value={it.variantId || ""} onChange={e => setItem(i, { variantId: e.target.value || null })} aria-label="Variant">
+                        <option value="">Any {opt?.name.toLowerCase()} variant</option>
+                        {(opt?.variants || []).map(v => <option key={v.id} value={v.id}>{v.name}</option>)}
+                      </select>
+                    )}
+                  </div>
+                );
+              })}
+            </div>
+            <button type="button" onClick={() => set("items", [...d.items, { eventOptionId: options[0]?.id || "", variantId: null, quantity: "1" }])}
+              className="mt-2 inline-flex items-center gap-1 text-sm font-medium text-brand-700 hover:underline">
+              <Plus className="w-4 h-4" /> Add a ticket type
+            </button>
+          </div>
+
+          {!exact && (
+            <div className="grid grid-cols-2 gap-4">
+              <div>
+                <label className="block text-sm font-medium text-gray-700 mb-1">{d.kind === "group" ? "Minimum tickets" : "Tickets per set"}</label>
+                <input type="number" min={d.kind === "free" ? 2 : 2} step="1" inputMode="numeric" className={inputCls} value={d.setSize} onChange={e => set("setSize", e.target.value)} required />
+              </div>
+              {d.kind === "free" && (
+                <div>
+                  <label className="block text-sm font-medium text-gray-700 mb-1">Free in each set</label>
+                  <input type="number" min="1" step="1" inputMode="numeric" className={inputCls} value={d.freeCount} onChange={e => set("freeCount", e.target.value)} required />
+                </div>
+              )}
+              {d.kind === "group" && (
+                <div>
+                  <label className="block text-sm font-medium text-gray-700 mb-1">Group price</label>
+                  <select className={inputCls} value={d.groupPricing} onChange={e => set("groupPricing", e.target.value as BundleGroupPricing)}>
+                    <option value="per_ticket">Price per ticket</option>
+                    <option value="percent">Percentage off</option>
+                  </select>
+                </div>
+              )}
+            </div>
+          )}
+
+          {d.kind === "free" ? (
+            <div className="rounded-lg bg-emerald-50 p-3 text-sm text-emerald-900">
+              {size > free && free > 0
+                ? <>Buy {size - free}, get {free} free. In every {size} qualifying tickets, the cheapest {free === 1 ? "one is" : `${free} are`} free.</>
+                : <span className="text-amber-700">The set needs more tickets than are free.</span>}
+            </div>
+          ) : (
+          <div>
+            <label className="block text-sm font-medium text-gray-700 mb-1">{priceLabel}</label>
+            <input type="number" min="0" max={d.kind === "group" && d.groupPricing === "percent" ? 100 : undefined} step="0.01" inputMode="decimal" className={`${inputCls} sm:max-w-[12rem]`} value={d.price} onChange={e => set("price", e.target.value)} required />
+            {d.kind === "group" ? (
+              <p className="text-xs text-gray-500 mt-2">
+                {size >= 2 ? `From ${size} qualifying tickets, every one of them ` : "Every qualifying ticket "}
+                {d.groupPricing === "percent" ? `gets ${d.price || "…"}% off.` : `costs ${d.price === "" ? "…" : fmtRand(price)} (tickets already cheaper stay as they are).`}
+              </p>
+            ) : (
+            <>
+            <div className="mt-2 grid grid-cols-3 gap-2 text-center">
+              <div className="rounded-lg bg-gray-50 p-2">
+                <div className="text-[11px] uppercase tracking-wide text-gray-500">{exact ? "Separately" : "Dearest set"}</div>
+                <div className="text-sm font-semibold text-gray-900">{fmtRand(standardValue)}</div>
+              </div>
+              <div className="rounded-lg bg-gray-50 p-2">
+                <div className="text-[11px] uppercase tracking-wide text-gray-500">Bundle</div>
+                <div className="text-sm font-semibold text-gray-900">{d.price === "" ? "—" : fmtRand(price)}</div>
+              </div>
+              <div className={`rounded-lg p-2 ${d.price !== "" && saving_ <= 0 ? "bg-amber-50" : "bg-emerald-50"}`}>
+                <div className="text-[11px] uppercase tracking-wide text-gray-500">Saving</div>
+                <div className={`text-sm font-semibold ${d.price !== "" && saving_ <= 0 ? "text-amber-700" : "text-emerald-700"}`}>{d.price === "" ? "—" : fmtRand(Math.max(0, saving_))}</div>
+              </div>
+            </div>
+            {d.price !== "" && saving_ <= 0 && <p className="text-xs text-amber-700 mt-1">The bundle isn&apos;t cheaper than the standard prices, so it won&apos;t apply unless prices change.</p>}
+            {!exact && <p className="text-xs text-gray-500 mt-1">The saving depends on which tickets are picked; it only applies when the set price is cheaper.</p>}
+            </>
+            )}
+          </div>
+          )}
+
+          <div className="grid grid-cols-1 sm:grid-cols-2 gap-4">
+            <div>
+              <label className="block text-sm font-medium text-gray-700 mb-1">Available from <span className="font-normal text-gray-400">(optional)</span></label>
+              <input type="datetime-local" className={inputCls} value={d.validFrom} onChange={e => set("validFrom", e.target.value)} />
+            </div>
+            <div>
+              <label className="block text-sm font-medium text-gray-700 mb-1">Available until <span className="font-normal text-gray-400">(optional)</span></label>
+              <input type="datetime-local" className={inputCls} value={d.validUntil} onChange={e => set("validUntil", e.target.value)} />
+            </div>
+          </div>
+
+          <label className="flex items-start gap-2 text-sm text-gray-700">
+            <input type="checkbox" className="mt-0.5" checked={d.isActive} onChange={e => set("isActive", e.target.checked)} />
+            <span>On sale <span className="block text-xs text-gray-500">Registrations that already have this bundle keep it if you turn it off later.</span></span>
+          </label>
+
+          {error && <div className="p-3 border rounded bg-red-50 text-red-800 text-sm">{error}</div>}
+        </div>
+
+        <div className="flex flex-col-reverse sm:flex-row sm:justify-end gap-2 sm:gap-3 p-4 border-t">
+          <button type="button" onClick={onClose} className="px-4 py-2 rounded-lg bg-gray-100 text-sm font-medium hover:bg-gray-200">Cancel</button>
+          <button type="submit" disabled={saving} className="px-4 py-2 rounded-lg bg-brand-600 text-white text-sm font-medium hover:bg-brand-700 disabled:opacity-50">
+            {saving ? "Saving…" : bundleId ? "Save changes" : "Create bundle"}
+          </button>
+        </div>
+      </form>
+    </div>
+  );
+}
@@ -8,26 +8,10 @@ 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";
+import { BackLink } from "@/components/shared/BackLink";

-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 +35,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 +45,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 +60,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 +84,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 +98,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 +123,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");
    }
  };

@@ -151,7 +135,7 @@ export default function ConsentTrackerPage() {
          <ShieldCheck 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>
+          <BackLink href="/dashboard" />
          <h1 className="text-2xl font-semibold text-gray-900 mt-0.5">Parental consent</h1>
          <p className="text-sm text-gray-500">Youth events: who still needs a parent&apos;s consent before check-in</p>
        </div>
@@ -5,8 +5,9 @@ import { useAuth } from "@/hooks/useAuth";
 import { useRouter } from "next/navigation";
 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 { TicketPercent, Plus, X, Search, Pencil, Power, Users, CalendarClock, ListChecks } from "lucide-react";
+import { errorMessage } from "@/lib/utils";
+import { BackLink } from "@/components/shared/BackLink";

 type CouponType = "percent" | "fixed" | "comp";
 type Role = "user" | "staff" | "supervisor" | "admin";
@@ -15,6 +16,7 @@ type EventLite = {
  id: string;
  title: string;
  startDate: string;
+  endDate?: string;
  eventOptions: { id: string; name: string; variants?: { id: string; name: string }[] }[];
 };

@@ -120,17 +122,19 @@ function bodyFromDraft(d: Draft) {
  };
 }

-const fmtDate = (iso: string | null) => (iso ? new Date(iso).toLocaleDateString(undefined, { day: "numeric", month: "short", year: "numeric" }) : "");
+const fmtDate = (iso: string | null | undefined) => (iso ? new Date(iso).toLocaleDateString(undefined, { day: "numeric", month: "short", year: "numeric" }) : "");
 const fmtRand = (n: number) => `R ${(n || 0).toFixed(2)}`;
 const inputCls = "w-full border rounded-lg px-3 py-2 text-sm focus:outline-none focus:ring-2 focus:ring-brand-400";
+const isPast = (ev: EventLite) => new Date(ev.endDate || ev.startDate).getTime() < Date.now();

-function couponStatus(c: Coupon): { label: string; cls: string } {
+type Status = { key: "active" | "scheduled" | "off" | "expired" | "used"; label: string; cls: string };
+function couponStatus(c: Coupon): Status {
  const now = Date.now();
-  if (!c.active) return { label: "Off", cls: "bg-gray-100 text-gray-600" };
-  if (c.validUntil && new Date(c.validUntil).getTime() < now) return { label: "Expired", cls: "bg-gray-100 text-gray-600" };
-  if (c.validFrom && new Date(c.validFrom).getTime() > now) return { label: "Scheduled", cls: "bg-amber-100 text-amber-800" };
-  if (c.maxUses && c.uses >= c.maxUses) return { label: "Used up", cls: "bg-gray-100 text-gray-600" };
-  return { label: "Active", cls: "bg-green-100 text-green-800" };
+  if (!c.active) return { key: "off", label: "Off", cls: "bg-gray-100 text-gray-600" };
+  if (c.validUntil && new Date(c.validUntil).getTime() < now) return { key: "expired", label: "Expired", cls: "bg-gray-100 text-gray-600" };
+  if (c.maxUses && c.uses >= c.maxUses) return { key: "used", label: "Used up", cls: "bg-gray-100 text-gray-600" };
+  if (c.validFrom && new Date(c.validFrom).getTime() > now) return { key: "scheduled", label: "Scheduled", cls: "bg-amber-100 text-amber-800" };
+  return { key: "active", label: "Active", cls: "bg-green-100 text-green-800" };
 }

 export default function CouponsPage() {
@@ -149,7 +153,7 @@ export default function CouponsPage() {
  const [error, setError] = useDismissingState<string | null>(null);
  const [info, setInfo] = useDismissingState<string | null>(null);
  const [query, setQuery] = useState("");
-  const [showOff, setShowOff] = useState(false);
+  const [showInactive, setShowInactive] = useState(false);

  const [editing, setEditing] = useState<{ id: string | null; draft: Draft } | null>(null);
  const [viewing, setViewing] = useState<{ coupon: Coupon; redemptions: Redemption[] } | null>(null);
@@ -164,8 +168,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);
    }
@@ -173,18 +177,25 @@ export default function CouponsPage() {

  useEffect(() => { if (token && canView) load(); }, [token, canView, load]);

+  // Codes that can still be used first; off, expired and used-up ones only when asked for.
  const visible = useMemo(() => {
    const q = query.trim().toLowerCase();
-    return coupons.filter(c => (showOff || c.active) && (!q || c.code.toLowerCase().includes(q) || (c.description || "").toLowerCase().includes(q)));
-  }, [coupons, query, showOff]);
+    const order: Record<Status["key"], number> = { active: 0, scheduled: 1, used: 2, expired: 3, off: 4 };
+    return coupons
+      .map(c => ({ c, status: couponStatus(c) }))
+      .filter(({ c, status }) => (showInactive || status.key === "active" || status.key === "scheduled")
+        && (!q || c.code.toLowerCase().includes(q) || (c.description || "").toLowerCase().includes(q) || c.events.some(e => e.event.title.toLowerCase().includes(q))))
+      .sort((a, b) => order[a.status.key] - order[b.status.key]);
+  }, [coupons, query, showInactive]);
+  const hiddenCount = coupons.filter(c => !["active", "scheduled"].includes(couponStatus(c).key)).length;

  const toggleActive = async (c: Coupon) => {
    try {
      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,28 +203,30 @@ 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");
    }
  };

+  const startNew = () => setEditing({ id: null, draft: blankDraft() });
+
  return (
-    <div className="max-w-6xl mx-auto w-full p-6">
-      <div className="flex items-center justify-between gap-3 mb-4 flex-wrap">
+    <div className="max-w-6xl mx-auto w-full p-4 sm:p-6">
+      <div className="flex flex-col sm:flex-row sm:items-center sm:justify-between gap-3 mb-4">
        <div className="flex items-center gap-3">
          <div className="w-10 h-10 rounded-xl bg-brand-50 flex items-center justify-center shrink-0">
            <TicketPercent 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>
+            <BackLink href="/dashboard" />
            <h1 className="text-2xl font-semibold text-gray-900 mt-0.5">Coupon codes</h1>
            <p className="text-sm text-gray-500">Discounts for staff, leaders, volunteers and promotions</p>
          </div>
        </div>
        {canView && (
          <button
-            onClick={() => setEditing({ id: null, draft: blankDraft() })}
-            className="inline-flex items-center gap-2 px-4 py-2 rounded-lg bg-brand-600 text-white text-sm font-medium hover:bg-brand-700"
+            onClick={startNew}
+            className="inline-flex items-center justify-center gap-2 px-4 py-2 rounded-lg bg-brand-600 text-white text-sm font-medium hover:bg-brand-700 w-full sm:w-auto"
          >
            <Plus className="w-4 h-4" /> New code
          </button>
@@ -228,72 +241,46 @@ export default function CouponsPage() {

      {canView && (
        <div className="border rounded-xl p-4 bg-white shadow-sm">
-          <div className="flex flex-wrap items-center gap-3 mb-3">
-            <div className="relative w-full sm:w-64">
+          <div className="flex flex-col sm:flex-row sm:items-center gap-3 mb-4">
+            <div className="relative w-full sm:w-72">
              <Search className="w-4 h-4 text-gray-400 absolute left-2.5 top-2.5" />
-              <input className={`${inputCls} pl-8`} placeholder="Search codes" value={query} onChange={e => setQuery(e.target.value)} />
+              <input className={`${inputCls} pl-8`} placeholder="Search codes or events" value={query} onChange={e => setQuery(e.target.value)} />
            </div>
            <label className="flex items-center gap-2 text-sm text-gray-700">
-              <input type="checkbox" checked={showOff} onChange={e => setShowOff(e.target.checked)} /> Show codes that are off
+              <input type="checkbox" checked={showInactive} onChange={e => setShowInactive(e.target.checked)} />
+              Show codes that are off, expired or used up{hiddenCount > 0 ? ` (${hiddenCount})` : ""}
            </label>
          </div>

-          <div className="overflow-x-auto">
-            <Table>
-              <TableHeader>
-                <TableRow>
-                  <TableHead>Code</TableHead>
-                  <TableHead>Discount</TableHead>
-                  <TableHead>Events</TableHead>
-                  <TableHead>Uses</TableHead>
-                  <TableHead>Valid</TableHead>
-                  <TableHead>Status</TableHead>
-                  <TableHead className="text-right">Actions</TableHead>
-                </TableRow>
-              </TableHeader>
-              <TableBody>
-                {visible.map(c => {
-                  const status = couponStatus(c);
-                  return (
-                    <TableRow key={c.id}>
-                      <TableCell>
-                        <div className="font-mono font-semibold text-gray-900">{c.code}</div>
-                        {c.description && <div className="text-xs text-gray-500">{c.description}</div>}
-                        {(c.restrictRoles.length > 0 || c.allowedUsers.length > 0 || c.restrictDomain) && (
-                          <div className="text-xs text-amber-700 mt-0.5">
-                            Restricted: {c.allowedUsers.length ? `${c.allowedUsers.length} person${c.allowedUsers.length === 1 ? "" : "s"}` : c.restrictRoles.length ? c.restrictRoles.join(", ") : `@${c.restrictDomain}`}
-                          </div>
-                        )}
-                      </TableCell>
-                      <TableCell>
-                        <div>{c.summary}</div>
-                        {c.options.length > 0 && <div className="text-xs text-gray-500">{c.options.map(o => o.eventOption.name + (o.variant ? ` (${o.variant.name})` : "")).join(", ")}</div>}
-                      </TableCell>
-                      <TableCell className="text-sm">{c.events.length ? c.events.map(e => e.event.title).join(", ") : <span className="text-gray-500">All events</span>}</TableCell>
-                      <TableCell className="text-sm">
-                        {c.uses}{c.maxUses ? ` / ${c.maxUses}` : ""}
-                        <div className="text-xs text-gray-500">{fmtRand(c.totalDiscount)} given</div>
-                      </TableCell>
-                      <TableCell className="text-xs text-gray-600">
-                        {c.validFrom || c.validUntil ? `${c.validFrom ? fmtDate(c.validFrom) : "Now"} – ${c.validUntil ? fmtDate(c.validUntil) : "no end"}` : "Always"}
-                      </TableCell>
-                      <TableCell><span className={`text-xs px-2 py-0.5 rounded-full font-medium ${status.cls}`}>{status.label}</span></TableCell>
-                      <TableCell className="text-right whitespace-nowrap">
-                        <button className="px-2 py-1 text-xs rounded border hover:bg-gray-50 mr-1" onClick={() => openUses(c)}>Uses</button>
-                        <button className="px-2 py-1 text-xs rounded border hover:bg-gray-50 mr-1" onClick={() => setEditing({ id: c.id, draft: draftFromCoupon(c) })}>Edit</button>
-                        <button className={`px-2 py-1 text-xs rounded text-white ${c.active ? "bg-amber-500 hover:bg-amber-600" : "bg-green-600 hover:bg-green-700"}`} onClick={() => toggleActive(c)}>
-                          {c.active ? "Turn off" : "Turn on"}
-                        </button>
-                      </TableCell>
-                    </TableRow>
-                  );
-                })}
-                {!fetching && visible.length === 0 && (
-                  <TableRow><TableCell colSpan={7} className="text-center text-sm text-gray-500 py-8">No coupon codes yet.</TableCell></TableRow>
-                )}
-              </TableBody>
-            </Table>
-          </div>
+          {!fetching && visible.length === 0 && (
+            <div className="text-center py-10">
+              <div className="w-12 h-12 rounded-full bg-brand-50 flex items-center justify-center mx-auto mb-3">
+                <TicketPercent className="w-6 h-6 text-brand-600" />
+              </div>
+              <p className="text-sm font-medium text-gray-900">{coupons.length === 0 ? "No coupon codes yet" : "No codes match"}</p>
+              <p className="text-xs text-gray-500 mt-1 max-w-sm mx-auto">e.g. &quot;STAFF50&quot;: 50% off for staff, or &quot;WELCOME20&quot;: R20 off for first-time visitors.</p>
+              {coupons.length === 0 && (
+                <button onClick={startNew} className="mt-4 inline-flex items-center gap-2 px-4 py-2 rounded-lg bg-brand-600 text-white text-sm font-medium hover:bg-brand-700">
+                  <Plus className="w-4 h-4" /> Create a code
+                </button>
+              )}
+            </div>
+          )}
+
+          {visible.length > 0 && (
+            <div className="grid grid-cols-1 md:grid-cols-2 gap-3">
+              {visible.map(({ c, status }) => (
+                <CouponCard
+                  key={c.id}
+                  coupon={c}
+                  status={status}
+                  onUses={() => openUses(c)}
+                  onEdit={() => setEditing({ id: c.id, draft: draftFromCoupon(c) })}
+                  onToggle={() => toggleActive(c)}
+                />
+              ))}
+            </div>
+          )}
        </div>
      )}

@@ -309,47 +296,119 @@ export default function CouponsPage() {
      )}

      {viewing && (
-        <div className="fixed inset-0 z-50 bg-black/40 flex items-center justify-center p-4" onClick={() => setViewing(null)}>
-          <div className="bg-white rounded-xl shadow-xl w-full max-w-2xl max-h-[85vh] flex flex-col" onClick={e => e.stopPropagation()}>
-            <div className="flex items-center justify-between p-4 border-b">
-              <h2 className="font-semibold">Uses of <span className="font-mono">{viewing.coupon.code}</span></h2>
-              <button onClick={() => setViewing(null)} aria-label="Close"><X className="w-5 h-5 text-gray-500" /></button>
-            </div>
-            <div className="p-4 overflow-y-auto">
-              {viewing.redemptions.length === 0 ? (
-                <p className="text-sm text-gray-500">This code hasn&apos;t been used yet.</p>
-              ) : (
-                <Table>
-                  <TableHeader>
-                    <TableRow><TableHead>Person</TableHead><TableHead>Event</TableHead><TableHead>Discount</TableHead><TableHead>When</TableHead></TableRow>
-                  </TableHeader>
-                  <TableBody>
-                    {viewing.redemptions.map(r => (
-                      <TableRow key={r.id} className={r.releasedAt ? "opacity-60" : ""}>
-                        <TableCell>
-                          <div className="text-sm">{r.user.name}</div>
-                          <div className="text-xs text-gray-500">{r.user.email}</div>
-                          {r.appliedBy && <div className="text-xs text-gray-500">Applied by {r.appliedBy.name}</div>}
-                        </TableCell>
-                        <TableCell className="text-sm">{r.registration.event.title}</TableCell>
-                        <TableCell className="text-sm">
-                          {fmtRand(r.discountAmount)}
-                          {r.releasedAt && <div className="text-xs text-gray-500">Released (cancelled)</div>}
-                        </TableCell>
-                        <TableCell className="text-xs text-gray-600">{fmtDate(r.createdAt)}</TableCell>
-                      </TableRow>
-                    ))}
-                  </TableBody>
-                </Table>
-              )}
-            </div>
-          </div>
-        </div>
+        <Sheet title={<>Uses of <span className="font-mono">{viewing.coupon.code}</span></>} onClose={() => setViewing(null)}>
+          {viewing.redemptions.length === 0 ? (
+            <p className="text-sm text-gray-500">This code hasn&apos;t been used yet.</p>
+          ) : (
+            <ul className="divide-y">
+              {viewing.redemptions.map(r => (
+                <li key={r.id} className={`py-2.5 flex items-start justify-between gap-3 ${r.releasedAt ? "opacity-60" : ""}`}>
+                  <div className="min-w-0">
+                    <div className="text-sm font-medium text-gray-900 truncate">{r.user.name}</div>
+                    <div className="text-xs text-gray-500 truncate">{r.user.email}</div>
+                    <div className="text-xs text-gray-500">{r.registration.event.title} · {fmtDate(r.createdAt)}</div>
+                    {r.appliedBy && <div className="text-xs text-gray-500">Applied by {r.appliedBy.name}</div>}
+                  </div>
+                  <div className="text-right shrink-0">
+                    <div className="text-sm font-semibold">{fmtRand(r.discountAmount)}</div>
+                    {r.releasedAt && <div className="text-xs text-gray-500">Released (cancelled)</div>}
+                  </div>
+                </li>
+              ))}
+            </ul>
+          )}
+        </Sheet>
      )}
    </div>
  );
 }

+/** A dialog that slides up full-width on phones and sits centred on bigger screens. */
+function Sheet({ title, subtitle, onClose, children, footer, onSubmit }: {
+  title: React.ReactNode;
+  subtitle?: React.ReactNode;
+  onClose: () => void;
+  children: React.ReactNode;
+  footer?: React.ReactNode;
+  onSubmit?: (e: React.FormEvent) => void;
+}) {
+  const Box = onSubmit ? "form" : "div";
+  return (
+    <div className="fixed inset-0 z-50 bg-black/40 flex items-end sm:items-center justify-center sm:p-4" onClick={onClose}>
+      <Box onSubmit={onSubmit} className="bg-white w-full sm:max-w-2xl max-h-[92vh] sm:max-h-[90vh] rounded-t-2xl sm:rounded-xl shadow-xl flex flex-col" onClick={e => e.stopPropagation()}>
+        <div className="flex items-start justify-between gap-3 p-4 border-b">
+          <div className="min-w-0">
+            <h2 className="font-semibold">{title}</h2>
+            {subtitle && <p className="text-xs text-gray-500 truncate">{subtitle}</p>}
+          </div>
+          <button type="button" onClick={onClose} aria-label="Close" className="p-1 -m-1"><X className="w-5 h-5 text-gray-500" /></button>
+        </div>
+        <div className="p-4 overflow-y-auto overflow-x-hidden overscroll-contain">{children}</div>
+        {footer && <div className="flex flex-col-reverse sm:flex-row sm:justify-end gap-2 sm:gap-3 p-4 border-t">{footer}</div>}
+      </Box>
+    </div>
+  );
+}
+
+function CouponCard({ coupon: c, status, onUses, onEdit, onToggle }: { coupon: Coupon; status: Status; onUses: () => void; onEdit: () => void; onToggle: () => void }) {
+  const restricted = c.allowedUsers.length
+    ? `${c.allowedUsers.length} ${c.allowedUsers.length === 1 ? "person" : "people"}`
+    : c.restrictRoles.length ? c.restrictRoles.map(r => (r === "user" ? "members" : r)).join(", ") : c.restrictDomain ? `@${c.restrictDomain}` : null;
+  const dates = c.validFrom || c.validUntil ? `${c.validFrom ? fmtDate(c.validFrom) : "Now"} – ${c.validUntil ? fmtDate(c.validUntil) : "no end date"}` : null;
+  const limits = [
+    c.maxUses ? `${c.maxUses} uses in total` : null,
+    c.maxUsesPerUser ? `${c.maxUsesPerUser} per person` : null,
+    c.minQuantity ? `min ${c.minQuantity} tickets` : null,
+  ].filter(Boolean).join(" · ");
+  const live = status.key === "active" || status.key === "scheduled";
+
+  return (
+    <div className={`border rounded-xl p-4 flex flex-col gap-3 ${live ? "bg-white" : "bg-gray-50"}`}>
+      <div className="flex items-start justify-between gap-3">
+        <div className="min-w-0">
+          <div className="font-mono font-semibold text-gray-900 break-all">{c.code}</div>
+          {c.description && <div className="text-xs text-gray-500 mt-0.5 break-words">{c.description}</div>}
+        </div>
+        <span className={`shrink-0 text-xs px-2 py-0.5 rounded-full font-medium ${status.cls}`}>{status.label}</span>
+      </div>
+
+      <div className="flex items-baseline flex-wrap gap-x-2 gap-y-0.5">
+        <span className="text-xl font-semibold text-gray-900">{c.summary}</span>
+        {c.options.length > 0 && (
+          <span className="text-xs text-gray-500">on {c.options.map(o => o.eventOption.name + (o.variant ? ` (${o.variant.name})` : "")).join(", ")}</span>
+        )}
+      </div>
+
+      <div className="flex flex-wrap gap-1.5">
+        {c.events.length === 0
+          ? <span className="rounded-full bg-gray-100 text-gray-700 px-2.5 py-1 text-xs">All events</span>
+          : c.events.map(e => (
+            <span key={e.eventId} className="rounded-full bg-brand-50 text-brand-800 border border-brand-100 px-2.5 py-1 text-xs break-words">{e.event.title}</span>
+          ))}
+      </div>
+
+      <div className="text-xs text-gray-600 space-y-0.5">
+        <div>Used <strong>{c.uses}{c.maxUses ? ` / ${c.maxUses}` : ""}×</strong> · {fmtRand(c.totalDiscount)} given</div>
+        {restricted && <div className="flex items-center gap-1 text-amber-700"><Users className="w-3.5 h-3.5 shrink-0" /> Only for {restricted}</div>}
+        {dates && <div className="flex items-center gap-1"><CalendarClock className="w-3.5 h-3.5 shrink-0" /> {dates}</div>}
+        {limits && <div>{limits}</div>}
+      </div>
+
+      <div className="flex flex-wrap gap-2 pt-1 border-t border-gray-100 mt-auto">
+        <button onClick={onUses} className="inline-flex items-center gap-1.5 px-3 py-1.5 text-xs rounded-lg border hover:bg-gray-50 mt-2">
+          <ListChecks className="w-3.5 h-3.5" /> Uses
+        </button>
+        <button onClick={onEdit} className="inline-flex items-center gap-1.5 px-3 py-1.5 text-xs rounded-lg border hover:bg-gray-50 mt-2">
+          <Pencil className="w-3.5 h-3.5" /> Edit
+        </button>
+        <button onClick={onToggle} className={`inline-flex items-center gap-1.5 px-3 py-1.5 text-xs rounded-lg border mt-2 sm:ml-auto ${c.active ? "text-amber-700 border-amber-200 hover:bg-amber-50" : "text-green-700 border-green-200 hover:bg-green-50"}`}>
+          <Power className="w-3.5 h-3.5" /> {c.active ? "Turn off" : "Turn on"}
+        </button>
+      </div>
+    </div>
+  );
+}
+
 function CouponModal({ token, events, couponId, initial, onClose, onSaved }: {
  token: string;
  events: EventLite[];
@@ -363,8 +422,22 @@ function CouponModal({ token, events, couponId, initial, onClose, onSaved }: {
  const [error, setError] = useState<string | null>(null);
  const [userQuery, setUserQuery] = useState("");
  const [userResults, setUserResults] = useState<{ id: string; name: string; email: string }[]>([]);
+  const [eventQuery, setEventQuery] = useState("");
+  const [showPast, setShowPast] = useState(false);
  const set = <K extends keyof Draft>(key: K, value: Draft[K]) => setD(prev => ({ ...prev, [key]: value }));

+  // Upcoming events soonest first. Past events only when asked for, but ones already
+  // picked always stay in the list so they can be unticked.
+  const eventChoices = useMemo(() => {
+    const q = eventQuery.trim().toLowerCase();
+    const upcoming = events.filter(e => !isPast(e)).sort((a, b) => new Date(a.startDate).getTime() - new Date(b.startDate).getTime());
+    const past = events.filter(isPast).sort((a, b) => new Date(b.startDate).getTime() - new Date(a.startDate).getTime());
+    return [...upcoming, ...past]
+      .filter(e => showPast || !isPast(e) || d.eventIds.includes(e.id))
+      .filter(e => !q || e.title.toLowerCase().includes(q));
+  }, [events, eventQuery, showPast, d.eventIds]);
+  const pastCount = events.filter(isPast).length;
+
  // Ticket options only make sense within the chosen events.
  const scopedEvents = useMemo(() => events.filter(e => d.eventIds.includes(e.id)), [events, d.eventIds]);

@@ -406,191 +479,207 @@ 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);
    }
  };

+  const label = "block text-sm font-medium text-gray-700 mb-1";
+  const optional = <span className="font-normal text-gray-400">(optional)</span>;
+
  return (
-    <div className="fixed inset-0 z-50 bg-black/40 flex items-center justify-center p-4" onClick={onClose}>
-      <form onSubmit={save} className="bg-white rounded-xl shadow-xl w-full max-w-2xl max-h-[90vh] flex flex-col" onClick={e => e.stopPropagation()}>
-        <div className="flex items-center justify-between p-4 border-b">
-          <h2 className="font-semibold">{couponId ? "Edit code" : "New coupon code"}</h2>
-          <button type="button" onClick={onClose} aria-label="Close"><X className="w-5 h-5 text-gray-500" /></button>
-        </div>
-
-        <div className="p-4 space-y-5 overflow-y-auto">
-          <div className="grid grid-cols-1 sm:grid-cols-2 gap-4">
-            <div>
-              <label className="block text-sm font-medium text-gray-700 mb-1">Code</label>
-              <input className={`${inputCls} font-mono uppercase`} value={d.code} onChange={e => set("code", e.target.value.toUpperCase().replace(/[^A-Z0-9_-]/g, ""))} placeholder="STAFF50" required maxLength={32} />
-              <p className="text-xs text-gray-500 mt-1">Letters, numbers, - and _. Not case-sensitive when entered.</p>
-            </div>
-            <div>
-              <label className="block text-sm font-medium text-gray-700 mb-1">Description (internal)</label>
-              <input className={inputCls} value={d.description} onChange={e => set("description", e.target.value)} placeholder="Staff discount for Camp 2026" />
-            </div>
-          </div>
-
-          <div className="grid grid-cols-1 sm:grid-cols-3 gap-4">
-            <div>
-              <label className="block text-sm font-medium text-gray-700 mb-1">Discount type</label>
-              <select className={inputCls} value={d.type} onChange={e => set("type", e.target.value as CouponType)}>
-                <option value="percent">Percentage</option>
-                <option value="fixed">Fixed amount (R)</option>
-                <option value="comp">Free (100%)</option>
-              </select>
-            </div>
-            {d.type !== "comp" && (
-              <div>
-                <label className="block text-sm font-medium text-gray-700 mb-1">{d.type === "percent" ? "Percent off" : "Amount off (R)"}</label>
-                <input type="number" min="0" step={d.type === "percent" ? "1" : "0.01"} max={d.type === "percent" ? 100 : undefined} className={inputCls} value={d.value} onChange={e => set("value", e.target.value)} required />
-              </div>
-            )}
-            <div className="flex items-end">
-              <label className="flex items-start gap-2 text-sm text-gray-700">
-                <input type="checkbox" className="mt-0.5" checked={d.stackEarlyBird} onChange={e => set("stackEarlyBird", e.target.checked)} />
-                <span>Also apply on top of early-bird prices <span className="block text-xs text-gray-500">Off: the better of the two prices wins.</span></span>
-              </label>
-            </div>
-          </div>
-
-          <div>
-            <label className="block text-sm font-medium text-gray-700 mb-1">Events</label>
-            <p className="text-xs text-gray-500 mb-2">Leave all unticked for every event.</p>
-            <div className="max-h-40 overflow-y-auto border rounded-lg divide-y">
-              {events.map(ev => (
-                <label key={ev.id} className="flex items-center gap-2 px-3 py-2 text-sm">
-                  <input type="checkbox" checked={d.eventIds.includes(ev.id)} onChange={() => toggleEvent(ev.id)} />
-                  <span>{ev.title}</span>
-                  <span className="text-xs text-gray-500 ml-auto">{fmtDate(ev.startDate)}</span>
-                </label>
-              ))}
-              {events.length === 0 && <p className="px-3 py-2 text-sm text-gray-500">No events.</p>}
-            </div>
-          </div>
-
-          {scopedEvents.length > 0 && (
-            <div>
-              <label className="block text-sm font-medium text-gray-700 mb-1">Only these tickets / items</label>
-              <p className="text-xs text-gray-500 mb-2">Leave all unticked to discount the whole registration.</p>
-              <div className="space-y-2">
-                {scopedEvents.map(ev => (
-                  <div key={ev.id} className="border rounded-lg p-3">
-                    <div className="text-xs font-semibold text-gray-600 mb-1">{ev.title}</div>
-                    {ev.eventOptions.map(o => (
-                      <div key={o.id}>
-                        <label className="flex items-center gap-2 text-sm">
-                          <input type="checkbox" checked={d.options.some(s => scopeKey(s) === scopeKey({ eventOptionId: o.id, variantId: null }))} onChange={() => toggleScope(o.id, null)} />
-                          {o.name}{(o.variants || []).length > 0 && <span className="text-xs text-gray-500">(all variants)</span>}
-                        </label>
-                        {(o.variants || []).map(v => (
-                          <label key={v.id} className="flex items-center gap-2 text-sm ml-6">
-                            <input type="checkbox" checked={d.options.some(s => scopeKey(s) === scopeKey({ eventOptionId: o.id, variantId: v.id }))} onChange={() => toggleScope(o.id, v.id)} />
-                            {v.name}
-                          </label>
-                        ))}
-                      </div>
-                    ))}
-                  </div>
-                ))}
-              </div>
-            </div>
-          )}
-
-          <div className="grid grid-cols-1 sm:grid-cols-2 gap-4">
-            <div>
-              <label className="block text-sm font-medium text-gray-700 mb-1">Valid from</label>
-              <input type="datetime-local" className={inputCls} value={d.validFrom} onChange={e => set("validFrom", e.target.value)} />
-            </div>
-            <div>
-              <label className="block text-sm font-medium text-gray-700 mb-1">Valid until</label>
-              <input type="datetime-local" className={inputCls} value={d.validUntil} onChange={e => set("validUntil", e.target.value)} />
-            </div>
-          </div>
-
-          <div className="grid grid-cols-1 sm:grid-cols-3 gap-4">
-            <div>
-              <label className="block text-sm font-medium text-gray-700 mb-1">Max total uses</label>
-              <input type="number" min="1" className={inputCls} value={d.maxUses} onChange={e => set("maxUses", e.target.value)} placeholder="Unlimited" />
-            </div>
-            <div>
-              <label className="block text-sm font-medium text-gray-700 mb-1">Max uses per person</label>
-              <input type="number" min="1" className={inputCls} value={d.maxUsesPerUser} onChange={e => set("maxUsesPerUser", e.target.value)} placeholder="Unlimited" />
-            </div>
-            <div>
-              <label className="block text-sm font-medium text-gray-700 mb-1">Minimum tickets</label>
-              <input type="number" min="1" className={inputCls} value={d.minQuantity} onChange={e => set("minQuantity", e.target.value)} placeholder="None" />
-            </div>
-          </div>
-
-          <div>
-            <label className="block text-sm font-medium text-gray-700 mb-1">Who can use it</label>
-            <select className={inputCls} value={d.restrictTo} onChange={e => set("restrictTo", e.target.value as Draft["restrictTo"])}>
-              <option value="anyone">Anyone with the code</option>
-              <option value="roles">People with certain roles</option>
-              <option value="users">Specific people</option>
-              <option value="domain">An email domain</option>
-            </select>
-            {d.restrictTo !== "anyone" && (
-              <p className="text-xs text-gray-500 mt-1">Restricted codes need the person to be logged in (or registered by staff), so they can&apos;t be shared in group chats.</p>
-            )}
-
-            {d.restrictTo === "roles" && (
-              <div className="flex flex-wrap gap-4 mt-2">
-                {(["user", "staff", "supervisor", "admin"] as Role[]).map(r => (
-                  <label key={r} className="flex items-center gap-2 text-sm capitalize">
-                    <input type="checkbox" checked={d.restrictRoles.includes(r)} onChange={() => set("restrictRoles", d.restrictRoles.includes(r) ? d.restrictRoles.filter(x => x !== r) : [...d.restrictRoles, r])} />
-                    {r === "user" ? "Member" : r}
-                  </label>
-                ))}
-              </div>
-            )}
-
-            {d.restrictTo === "domain" && (
-              <input className={`${inputCls} mt-2`} value={d.restrictDomain} onChange={e => set("restrictDomain", e.target.value)} placeholder="church.org" required />
-            )}
-
-            {d.restrictTo === "users" && (
-              <div className="mt-2">
-                <div className="flex flex-wrap gap-2 mb-2">
-                  {d.users.map(u => (
-                    <span key={u.id} className="inline-flex items-center gap-1 text-xs bg-brand-50 text-brand-800 rounded-full px-2 py-1">
-                      {u.name}
-                      <button type="button" onClick={() => set("users", d.users.filter(x => x.id !== u.id))} aria-label={`Remove ${u.name}`}><X className="w-3 h-3" /></button>
-                    </span>
-                  ))}
-                </div>
-                <input className={inputCls} value={userQuery} onChange={e => setUserQuery(e.target.value)} placeholder="Search by name, email or phone" />
-                {userResults.length > 0 && (
-                  <div className="border rounded-lg mt-1 divide-y max-h-40 overflow-y-auto">
-                    {userResults.filter(r => !d.users.some(u => u.id === r.id)).map(r => (
-                      <button type="button" key={r.id} className="w-full text-left px-3 py-2 text-sm hover:bg-gray-50" onClick={() => { set("users", [...d.users, r]); setUserQuery(""); }}>
-                        {r.name} <span className="text-xs text-gray-500">{r.email}</span>
-                      </button>
-                    ))}
-                  </div>
-                )}
-              </div>
-            )}
-          </div>
-
-          <label className="flex items-center gap-2 text-sm text-gray-700">
-            <input type="checkbox" checked={d.active} onChange={e => set("active", e.target.checked)} /> Active
-          </label>
-
-          {error && <div className="p-3 border rounded bg-red-50 text-red-800 text-sm">{error}</div>}
-        </div>
-
-        <div className="flex justify-end gap-3 p-4 border-t">
+    <Sheet
+      title={couponId ? "Edit code" : "New coupon code"}
+      onClose={onClose}
+      onSubmit={save}
+      footer={(
+        <>
          <button type="button" onClick={onClose} className="px-4 py-2 rounded-lg bg-gray-100 text-sm font-medium hover:bg-gray-200">Cancel</button>
          <button type="submit" disabled={saving} className="px-4 py-2 rounded-lg bg-brand-600 text-white text-sm font-medium hover:bg-brand-700 disabled:opacity-50">
            {saving ? "Saving…" : couponId ? "Save changes" : "Create code"}
          </button>
+        </>
+      )}
+    >
+      <div className="space-y-5">
+        <div className="grid grid-cols-1 sm:grid-cols-2 gap-4">
+          <div>
+            <label className={label}>Code</label>
+            <input className={`${inputCls} font-mono uppercase`} value={d.code} onChange={e => set("code", e.target.value.toUpperCase().replace(/[^A-Z0-9_-]/g, ""))} placeholder="STAFF50" required maxLength={32} />
+            <p className="text-xs text-gray-500 mt-1">Letters, numbers, - and _. Not case-sensitive when entered.</p>
+          </div>
+          <div>
+            <label className={label}>Description {optional}</label>
+            <input className={inputCls} value={d.description} onChange={e => set("description", e.target.value)} placeholder="Staff discount for Camp 2026" />
+            <p className="text-xs text-gray-500 mt-1">Only staff see this.</p>
+          </div>
        </div>
-      </form>
-    </div>
+
+        <div>
+          <label className="block text-sm font-medium text-gray-700 mb-2">Discount</label>
+          <div className="grid grid-cols-3 gap-2">
+            {([["percent", "Percentage", "e.g. 20% off"], ["fixed", "Amount off", "e.g. R50 off"], ["comp", "Free", "100% off"]] as [CouponType, string, string][]).map(([t, name, hint]) => (
+              <button type="button" key={t} onClick={() => set("type", t)} aria-pressed={d.type === t}
+                className={`text-left rounded-lg border p-2.5 transition-colors ${d.type === t ? "border-brand-500 bg-brand-50 ring-1 ring-brand-500" : "hover:bg-gray-50"}`}>
+                <div className="text-sm font-medium text-gray-900">{name}</div>
+                <div className="text-xs text-gray-500">{hint}</div>
+              </button>
+            ))}
+          </div>
+          {d.type !== "comp" && (
+            <div className="mt-3 sm:max-w-[12rem]">
+              <label className={label}>{d.type === "percent" ? "Percent off" : "Amount off (R)"}</label>
+              <input type="number" min="0" inputMode="decimal" step={d.type === "percent" ? "1" : "0.01"} max={d.type === "percent" ? 100 : undefined} className={inputCls} value={d.value} onChange={e => set("value", e.target.value)} required />
+            </div>
+          )}
+          <label className="mt-3 flex items-start gap-2 text-sm text-gray-700">
+            <input type="checkbox" className="mt-0.5" checked={d.stackEarlyBird} onChange={e => set("stackEarlyBird", e.target.checked)} />
+            <span>Also apply on top of early-bird prices <span className="block text-xs text-gray-500">Off: the better of the two prices wins.</span></span>
+          </label>
+        </div>
+
+        <div>
+          <label className={label}>Events</label>
+          <p className="text-xs text-gray-500 mb-2">
+            {d.eventIds.length === 0 ? "None picked: the code works for every event." : `${d.eventIds.length} picked. The code only works for ${d.eventIds.length === 1 ? "this event" : "these events"}.`}
+          </p>
+          <div className="flex flex-col sm:flex-row sm:items-center gap-2 mb-2">
+            <div className="relative flex-1">
+              <Search className="w-4 h-4 text-gray-400 absolute left-2.5 top-2.5" />
+              <input className={`${inputCls} pl-8`} placeholder="Find an event" value={eventQuery} onChange={e => setEventQuery(e.target.value)} />
+            </div>
+            {pastCount > 0 && (
+              <label className="flex items-center gap-2 text-sm text-gray-700 shrink-0">
+                <input type="checkbox" checked={showPast} onChange={e => setShowPast(e.target.checked)} /> Show past events
+              </label>
+            )}
+          </div>
+          <div className="max-h-48 overflow-y-auto border rounded-lg divide-y">
+            {eventChoices.map(ev => (
+              <label key={ev.id} className={`flex items-center gap-2 px-3 py-2 text-sm ${d.eventIds.includes(ev.id) ? "bg-brand-50/60" : ""}`}>
+                <input type="checkbox" checked={d.eventIds.includes(ev.id)} onChange={() => toggleEvent(ev.id)} />
+                <span className="min-w-0 flex-1 truncate">{ev.title}</span>
+                <span className="text-xs text-gray-500 shrink-0">{fmtDate(ev.startDate)}{isPast(ev) ? " · past" : ""}</span>
+              </label>
+            ))}
+            {eventChoices.length === 0 && <p className="px-3 py-2 text-sm text-gray-500">{eventQuery ? "No events match." : "No upcoming events."}</p>}
+          </div>
+        </div>
+
+        {scopedEvents.length > 0 && (
+          <div>
+            <label className={label}>Only these tickets / items {optional}</label>
+            <p className="text-xs text-gray-500 mb-2">Leave all unticked to discount the whole registration.</p>
+            <div className="space-y-2">
+              {scopedEvents.map(ev => (
+                <div key={ev.id} className="border rounded-lg p-3 bg-gray-50">
+                  <div className="text-xs font-semibold text-gray-600 mb-1">{ev.title}</div>
+                  {ev.eventOptions.map(o => (
+                    <div key={o.id}>
+                      <label className="flex items-center gap-2 text-sm py-0.5">
+                        <input type="checkbox" checked={d.options.some(s => scopeKey(s) === scopeKey({ eventOptionId: o.id, variantId: null }))} onChange={() => toggleScope(o.id, null)} />
+                        {o.name}{(o.variants || []).length > 0 && <span className="text-xs text-gray-500">(all variants)</span>}
+                      </label>
+                      {(o.variants || []).map(v => (
+                        <label key={v.id} className="flex items-center gap-2 text-sm ml-6 py-0.5">
+                          <input type="checkbox" checked={d.options.some(s => scopeKey(s) === scopeKey({ eventOptionId: o.id, variantId: v.id }))} onChange={() => toggleScope(o.id, v.id)} />
+                          {v.name}
+                        </label>
+                      ))}
+                    </div>
+                  ))}
+                </div>
+              ))}
+            </div>
+          </div>
+        )}
+
+        <div className="grid grid-cols-1 sm:grid-cols-2 gap-4">
+          <div>
+            <label className={label}>Valid from {optional}</label>
+            <input type="datetime-local" className={inputCls} value={d.validFrom} onChange={e => set("validFrom", e.target.value)} />
+          </div>
+          <div>
+            <label className={label}>Valid until {optional}</label>
+            <input type="datetime-local" className={inputCls} value={d.validUntil} onChange={e => set("validUntil", e.target.value)} />
+          </div>
+        </div>
+
+        <div className="grid grid-cols-1 sm:grid-cols-3 gap-4">
+          <div>
+            <label className={label}>Max total uses</label>
+            <input type="number" min="1" inputMode="numeric" className={inputCls} value={d.maxUses} onChange={e => set("maxUses", e.target.value)} placeholder="Unlimited" />
+          </div>
+          <div>
+            <label className={label}>Max uses per person</label>
+            <input type="number" min="1" inputMode="numeric" className={inputCls} value={d.maxUsesPerUser} onChange={e => set("maxUsesPerUser", e.target.value)} placeholder="Unlimited" />
+          </div>
+          <div>
+            <label className={label}>Minimum tickets</label>
+            <input type="number" min="1" inputMode="numeric" className={inputCls} value={d.minQuantity} onChange={e => set("minQuantity", e.target.value)} placeholder="None" />
+          </div>
+        </div>
+
+        <div>
+          <label className={label}>Who can use it</label>
+          <select className={inputCls} value={d.restrictTo} onChange={e => set("restrictTo", e.target.value as Draft["restrictTo"])}>
+            <option value="anyone">Anyone with the code</option>
+            <option value="roles">People with certain roles</option>
+            <option value="users">Specific people</option>
+            <option value="domain">An email domain</option>
+          </select>
+          {d.restrictTo !== "anyone" && (
+            <p className="text-xs text-gray-500 mt-1">Restricted codes need the person to be logged in (or registered by staff), so they can&apos;t be shared in group chats.</p>
+          )}
+
+          {d.restrictTo === "roles" && (
+            <div className="flex flex-wrap gap-x-4 gap-y-2 mt-2">
+              {(["user", "staff", "supervisor", "admin"] as Role[]).map(r => (
+                <label key={r} className="flex items-center gap-2 text-sm capitalize">
+                  <input type="checkbox" checked={d.restrictRoles.includes(r)} onChange={() => set("restrictRoles", d.restrictRoles.includes(r) ? d.restrictRoles.filter(x => x !== r) : [...d.restrictRoles, r])} />
+                  {r === "user" ? "Member" : r}
+                </label>
+              ))}
+            </div>
+          )}
+
+          {d.restrictTo === "domain" && (
+            <input className={`${inputCls} mt-2`} value={d.restrictDomain} onChange={e => set("restrictDomain", e.target.value)} placeholder="church.org" required />
+          )}
+
+          {d.restrictTo === "users" && (
+            <div className="mt-2">
+              <div className="flex flex-wrap gap-2 mb-2">
+                {d.users.map(u => (
+                  <span key={u.id} className="inline-flex items-center gap-1 text-xs bg-brand-50 text-brand-800 rounded-full px-2 py-1">
+                    {u.name}
+                    <button type="button" onClick={() => set("users", d.users.filter(x => x.id !== u.id))} aria-label={`Remove ${u.name}`}><X className="w-3 h-3" /></button>
+                  </span>
+                ))}
+              </div>
+              <input className={inputCls} value={userQuery} onChange={e => setUserQuery(e.target.value)} placeholder="Search by name, email or phone" />
+              {userResults.length > 0 && (
+                <div className="border rounded-lg mt-1 divide-y max-h-40 overflow-y-auto">
+                  {userResults.filter(r => !d.users.some(u => u.id === r.id)).map(r => (
+                    <button type="button" key={r.id} className="w-full text-left px-3 py-2 text-sm hover:bg-gray-50" onClick={() => { set("users", [...d.users, r]); setUserQuery(""); }}>
+                      {r.name} <span className="text-xs text-gray-500">{r.email}</span>
+                    </button>
+                  ))}
+                </div>
+              )}
+            </div>
+          )}
+        </div>
+
+        <label className="flex items-start gap-2 text-sm text-gray-700">
+          <input type="checkbox" className="mt-0.5" checked={d.active} onChange={e => set("active", e.target.checked)} />
+          <span>Active <span className="block text-xs text-gray-500">Discounts already given keep their amount if you turn it off later.</span></span>
+        </label>
+
+        {error && <div className="p-3 border rounded bg-red-50 text-red-800 text-sm">{error}</div>}
+      </div>
+    </Sheet>
  );
 }
@@ -1,14 +1,23 @@
 "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";
+import { BackLink } from "@/components/shared/BackLink";

 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 (
@@ -135,16 +144,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 (
@@ -180,9 +187,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(() => {
@@ -194,20 +199,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(() => {
@@ -217,11 +223,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);
@@ -236,7 +242,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
@@ -271,20 +277,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);
@@ -298,7 +304,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;
@@ -314,8 +320,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);
    }
@@ -327,8 +333,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');
    }
  };

@@ -336,7 +342,7 @@ 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[]>([]);
@@ -360,11 +366,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]);

@@ -389,10 +392,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' });
          }
@@ -402,7 +405,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);
@@ -420,7 +423,7 @@ 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, allocationGroupId: groupId || undefined },
        dryRun: true,
@@ -429,12 +432,12 @@ function EmailAttendeesPageInner() {
      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');
    }
  };

@@ -460,7 +463,7 @@ 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, allocationGroupId: groupId || undefined },
        template: templateKey,
@@ -468,13 +471,13 @@ function EmailAttendeesPageInner() {
      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);
    }
@@ -487,10 +490,10 @@ function EmailAttendeesPageInner() {
          <div className="w-10 h-10 rounded-xl bg-brand-50 flex items-center justify-center shrink-0">
            <Mail className="w-5 h-5 text-brand-600" />
          </div>
-          <h1 className="text-2xl font-semibold text-gray-900">Email Attendees</h1>
-        </div>
-        <div className="flex items-center gap-2">
-          <button className="px-3 py-1.5 text-sm rounded-lg bg-gray-100 hover:bg-gray-200 text-gray-800 shadow-sm" onClick={() => router.push('/dashboard')}>Back</button>
+          <div>
+            <BackLink href="/dashboard" />
+            <h1 className="text-2xl font-semibold text-gray-900 mt-0.5">Email Attendees</h1>
+          </div>
        </div>
      </div>

@@ -556,7 +559,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>
@@ -584,7 +587,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>
@@ -601,7 +604,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>
@@ -660,16 +663,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, 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 {
@@ -677,8 +680,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 && (
@@ -779,13 +782,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>

@@ -795,14 +798,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>

@@ -813,14 +816,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>

@@ -963,9 +966,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(() => ({
@@ -1055,37 +1058,38 @@ With gratitude`);

  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: any = { subject: sponsorSubject, scheduledAt: new Date(thanksWhen).toISOString(), audience: 'sponsors' };
+        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);
@@ -1093,8 +1097,8 @@ With gratitude`);
      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');
    }
  };

@@ -1104,7 +1108,7 @@ With gratitude`);
        <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>
@@ -1137,7 +1141,7 @@ With gratitude`);
              <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>
@@ -1201,7 +1205,7 @@ With gratitude`);
              <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>
@@ -1,11 +1,14 @@
 "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";
+import { BackLink } from "@/components/shared/BackLink";

 // 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 +24,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 +36,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 +51,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 +116,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 +167,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 +183,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 +198,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");
    }
  };

@@ -208,9 +210,11 @@ function EventOptionsContent() {
          <div className="w-10 h-10 rounded-xl bg-brand-50 flex items-center justify-center shrink-0">
            <Ticket className="w-5 h-5 text-brand-600" />
          </div>
-          <h1 className="text-2xl font-semibold text-gray-900">Event options</h1>
+          <div>
+            <BackLink href="/dashboard/supervisor/events" label="Back to events" />
+            <h1 className="text-2xl font-semibold text-gray-900 mt-0.5">Event options</h1>
+          </div>
        </div>
-        <button className="px-3 py-1.5 text-sm rounded-lg bg-gray-100 hover:bg-gray-200 text-gray-800 shadow-sm" onClick={() => router.push('/dashboard/supervisor/events')}>Back</button>
      </div>

      {!canView && (
@@ -1,14 +1,18 @@
 "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";
+import { BackLink } from "@/components/shared/BackLink";

 // ─── helpers ────────────────────────────────────────────────────────────────

@@ -44,7 +48,26 @@ function DTInput({ label, value, onChange, hint, required }: { label: string; va
 // ─── types ───────────────────────────────────────────────────────────────────

 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 }[] };
+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 };

@@ -88,8 +111,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}
@@ -109,7 +133,7 @@ function FormBuilder({ value, onChange, title = "Registration Form Fields", gate
 }) {
  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;
@@ -143,7 +167,7 @@ function FormBuilder({ value, onChange, title = "Registration Form Fields", gate
                  <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="rating">Rating (1–5 stars)</option><option value="multiple_choice">Multiple choice</option>
                    <option value="statement">Statement</option><option value="paragraph">Heading+para</option>
@@ -452,24 +476,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;
@@ -514,14 +538,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))} />
@@ -541,15 +570,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];
@@ -645,7 +674,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([]);
@@ -728,10 +757,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);
      }
@@ -750,9 +779,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);
    }
@@ -813,14 +842,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);
@@ -851,8 +879,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,
@@ -862,17 +890,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") })),
        })),
      };
    });
@@ -892,9 +920,9 @@ 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 || "", options: x.options || undefined })) });
+      if (f) setFormDef({ isRequired: !!f.isRequired, fields: toFieldDefs(f.fields) });
    }).catch(() => {}).finally(() => { formLoadedRef.current = true; });
  }, [mode, ev?.id]);

@@ -905,10 +933,10 @@ function EventModal({ mode, event: ev, onClose, onSuccess }: EventModalProps) {
  const [fbMeta, setFbMeta] = useState<{ sentAt: string | null; invited: number; responses: number } | null>(null);
  useEffect(() => {
    if (mode !== "edit" || !ev?.id || !token) return;
-    apiFetch<any>(`/api/feedback/event/${ev.id}`, { authToken: token }).then(f => {
+    apiFetch<FeedbackFormResponse | null>(`/api/feedback/event/${ev.id}`, { authToken: token }).then(f => {
      if (!f) return;
      setFbEnabled(true);
-      setFbDef({ isRequired: false, fields: (f.fields || []).map((x: any) => ({ id: x.id, type: x.type, label: x.label, isRequired: !!x.isRequired, helpText: x.helpText || "", options: x.options || undefined })) });
+      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(() => {});
@@ -991,7 +1019,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 })),
@@ -1006,16 +1034,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];
@@ -1038,19 +1066,19 @@ function EventModal({ mode, event: ev, onClose, onSuccess }: EventModalProps) {
          });
        } 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];
@@ -1068,9 +1096,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++) {
@@ -1091,7 +1119,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 }
          });
@@ -1101,18 +1129,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];
@@ -1131,7 +1159,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
@@ -1155,7 +1183,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,
@@ -1186,6 +1214,7 @@ 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
@@ -1194,12 +1223,12 @@ function EventModal({ mode, event: ev, onClose, onSuccess }: EventModalProps) {
        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, 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
@@ -1219,8 +1248,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);
    }
@@ -1306,7 +1335,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>}
@@ -1342,7 +1371,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 ? (
@@ -1369,7 +1398,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" />
@@ -1405,7 +1434,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} />
@@ -1670,7 +1699,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";
@@ -1710,27 +1739,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);
@@ -1747,9 +1777,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");
@@ -1763,13 +1793,13 @@ export default function ManageEventsPage() {
            <Calendar className="w-5 h-5 text-brand-600" />
          </div>
          <div>
-            <h1 className="text-2xl font-semibold text-gray-900">Events</h1>
+            <BackLink href="/dashboard" />
+            <h1 className="text-2xl font-semibold text-gray-900 mt-0.5">Events</h1>
            <p className="text-sm text-gray-500 mt-0.5">Manage and create events</p>
          </div>
        </div>
        <div className="flex items-center gap-2">
          <button type="button" className="px-4 py-2 text-sm rounded-lg bg-brand-600 text-white hover:bg-brand-700 shadow-sm font-medium" onClick={openCreate}>+ Add Event</button>
-          <button className="px-3 py-1.5 text-sm rounded-lg bg-gray-100 hover:bg-gray-200 text-gray-800" onClick={() => router.push("/dashboard")}>Back</button>
        </div>
      </div>

@@ -1,16 +1,29 @@
 "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";
+import { BackLink } from "@/components/shared/BackLink";

 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 || [];
@@ -138,36 +151,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]);
@@ -207,32 +220,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>
@@ -285,58 +302,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 || '', options: x.options || undefined })) });
-      } 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, options: f.type === 'multiple_choice' && Array.isArray(f.options) ? f.options.map((o: any) => String(o).trim()).filter(Boolean) : undefined }));
+      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 {
@@ -344,54 +356,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||'', options: x.options || undefined })) });
-          } 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 };
    });
@@ -408,7 +414,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;
    });
@@ -431,11 +437,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);
    }
@@ -448,10 +453,12 @@ export default function FormsBrowserPage() {
          <div className="w-10 h-10 rounded-xl bg-brand-50 flex items-center justify-center shrink-0">
            <FileText className="w-5 h-5 text-brand-600" />
          </div>
-          <h1 className="text-2xl font-semibold text-gray-900">Forms</h1>
+          <div>
+            <BackLink href="/dashboard" />
+            <h1 className="text-2xl font-semibold text-gray-900 mt-0.5">Forms</h1>
+          </div>
        </div>
        <div className="flex gap-2">
-          <button className="px-3 py-1.5 text-sm rounded-lg bg-gray-100 hover:bg-gray-200" onClick={() => router.push("/dashboard")}>Back</button>
          {mode === 'view' && (
            <button className="px-3 py-1.5 text-sm rounded-lg bg-brand-600 text-white hover:bg-brand-700" onClick={onPrint} disabled={items.length === 0}>
              Print forms
@@ -573,7 +580,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 */}
@@ -593,7 +600,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>
@@ -680,7 +687,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>;
                })}
@@ -702,7 +709,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' && (
@@ -7,6 +7,9 @@ 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";
+import { BackLink } from "@/components/shared/BackLink";

 type FormField = { id: string; type: 'yes_no'|'text'|'date'|'numeric'|'statement'|'paragraph'|'rating'|'multiple_choice'; label: string; isRequired?: boolean; helpText?: string|null; options?: unknown };

@@ -21,7 +24,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>>>({});

@@ -36,7 +39,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: {
@@ -48,12 +51,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);
    }
@@ -65,7 +68,10 @@ export default function ManualRegistrationPage() {
        <div className="w-10 h-10 rounded-xl bg-brand-50 flex items-center justify-center shrink-0">
          <UserPlus className="w-5 h-5 text-brand-600" />
        </div>
-        <h1 className="text-xl font-semibold text-gray-900">Manual Registration</h1>
+        <div>
+          <BackLink href="/dashboard" />
+          <h1 className="text-xl font-semibold text-gray-900 mt-0.5">Manual Registration</h1>
+        </div>
      </div>
      <form onSubmit={submit} className="space-y-3">
        <div>
@@ -110,12 +116,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(() => {
@@ -136,7 +144,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 () => {
@@ -144,14 +152,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);
    }
@@ -7,37 +7,16 @@ import { apiFetch, fetchAllUsers } from "@/lib/api";
 import { scoreUser } from "@/lib/fuzzyMatch";
 import { useDismissingState } from "@/hooks/useDismissingState";
 import { CouponCodeField, AppliedCoupon } from "@/components/shared/CouponCodeField";
+import { BundleBuilder, BundleOffers, BundleSavings, useBundleQuote } from "@/components/shared/BundleDeals";
 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, PublicBundle, Registration, RegistrationOption, User } from "@/types";
+import { BackLink } from "@/components/shared/BackLink";

 // ─── 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 +24,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,16 +50,17 @@ 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");
  const [quantities, setQuantities] = useState<Record<string, number>>({});
+  const [bundles, setBundles] = useState<PublicBundle[]>([]);

  // User search state
  const [userQuery, setUserQuery] = useState("");
@@ -94,7 +75,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 +100,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 +108,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 +125,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 +146,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 +160,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 +177,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 +210,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 +232,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 +242,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 +254,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;
        }
@@ -287,15 +268,32 @@ export default function ManualRegistrationPage() {
    }
  }, [selectedEventId, events]);

+  // The events list doesn't carry bundle deals; the single-event response does.
+  useEffect(() => {
+    if (!selectedEventId) { setBundles([]); return; }
+    let cancelled = false;
+    apiFetch<Event>(`/api/events/${selectedEventId}`, { authToken: token || undefined })
+      .then(ev => { if (!cancelled) setBundles(ev?.bundles || []); })
+      .catch(() => { if (!cancelled) setBundles([]); });
+    return () => { cancelled = true; };
+  }, [selectedEventId, token]);
+
  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]);

+  const basket = useMemo(() => Object.entries(quantities).map(([key, quantity]) => {
+    const [eventOptionId, variantId] = key.split("::");
+    return { eventOptionId, quantity, variantId: variantId || null };
+  }), [quantities]);
+  const bundleQuote = useBundleQuote({ eventId: selectedEventId, basket, token, forUserId: pickedUserId });
+  const payable = coupon ? coupon.total : bundleQuote ? bundleQuote.total : totalDue;
+
  const submit = async () => {
    if (!token) return;
    setError(null);
@@ -319,7 +317,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 +337,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 +354,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);
    }
@@ -370,9 +368,11 @@ export default function ManualRegistrationPage() {
          <div className="w-10 h-10 rounded-xl bg-brand-50 flex items-center justify-center shrink-0">
            <UserPlus className="w-5 h-5 text-brand-600" />
          </div>
-          <h1 className="text-2xl font-semibold text-gray-900">Manual registration</h1>
+          <div>
+            <BackLink href="/dashboard" />
+            <h1 className="text-2xl font-semibold text-gray-900 mt-0.5">Manual registration</h1>
+          </div>
        </div>
-        <button className="px-3 py-1.5 text-sm rounded-lg bg-gray-100 hover:bg-gray-200 text-gray-800 shadow-sm" onClick={() => router.push('/dashboard')}>Back</button>
      </div>

      {!canView && (
@@ -546,6 +546,7 @@ export default function ManualRegistrationPage() {

      <div className="mt-6 border rounded-xl p-4 bg-white shadow-sm">
        <div className="text-lg font-semibold mb-3">3) Select ticket options</div>
+        {options.length > 0 && <BundleOffers bundles={bundles} className="mb-3" />}
        {options.length === 0 ? (
          <div className="text-sm text-gray-500">Select an event to view options.</div>
        ) : (
@@ -558,8 +559,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 +587,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>
@@ -609,6 +610,13 @@ export default function ManualRegistrationPage() {
            })}
          </div>
        )}
+        <BundleBuilder
+          className="mt-3"
+          bundles={bundles}
+          options={options}
+          qty={(o, v) => quantities[v ? `${o}::${v}` : o] || 0}
+          onSetQuantity={(o, v, n) => setQuantities(q => ({ ...q, [v ? `${o}::${v}` : o]: n }))}
+        />
      </div>

      {selectedEventAllowsNames && (
@@ -633,10 +641,7 @@ export default function ManualRegistrationPage() {
        <div className="mt-6 max-w-md">
          <CouponCodeField
            eventId={selectedEventId}
-            basket={Object.entries(quantities).map(([key, quantity]) => {
-              const [eventOptionId, variantId] = key.split("::");
-              return { eventOptionId, quantity, variantId: variantId || null };
-            })}
+            basket={basket}
            token={token}
            forUserId={pickedUserId}
            applied={coupon}
@@ -647,8 +652,9 @@ export default function ManualRegistrationPage() {

      <div className="flex items-center justify-between mt-6">
        <div className="text-sm">
-          Total due: <span className="font-semibold">R {(coupon ? coupon.total : totalDue).toFixed(2)}</span>
-          {coupon && coupon.discount > 0 && <span className="ml-2 text-xs text-gray-500 line-through">R {totalDue.toFixed(2)}</span>}
+          <BundleSavings applications={bundleQuote?.bundles} />
+          Total due: <span className="font-semibold">R {payable.toFixed(2)}</span>
+          {payable < totalDue - 0.005 && <span className="ml-2 text-xs text-gray-500 line-through">R {totalDue.toFixed(2)}</span>}
        </div>
        <button disabled={submitting} onClick={submit} className="px-4 py-2 text-sm rounded bg-brand-600 text-white hover:bg-brand-700 disabled:opacity-50 shadow-sm">{submitting ? 'Creating…' : 'Create registration'}</button>
      </div>
@@ -718,7 +724,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>;
@@ -7,6 +7,9 @@ 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";
+import { BackLink } from "@/components/shared/BackLink";

 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 +31,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 +41,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 +60,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 +71,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 (
@@ -84,7 +87,7 @@ export default function OfflineScansPage() {
          <WifiOff 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>
+          <BackLink href="/dashboard" />
          <h1 className="text-2xl font-semibold text-gray-900 mt-0.5">Offline scanning</h1>
          <p className="text-sm text-gray-500">Devices scanning without a connection, and their synced scans</p>
        </div>
@@ -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";
@@ -14,6 +14,7 @@ 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)}`;
@@ -29,6 +30,7 @@ const QUICK_ACTIONS = [
  { 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 },
  { href: "/dashboard/supervisor/coupons", label: "Coupon codes", description: "Discounts for staff, leaders and promotions", icon: TicketPercent },
+  { href: "/dashboard/supervisor/bundles", label: "Bundle deals", description: "Tickets sold together for one price", icon: Gift },
  { href: "/dashboard/staff/ticket-scanning", label: "Open scanner", description: "Use your device camera to validate tickets", icon: QrCode },
  { href: "/dashboard/supervisor/at-the-door", label: "At the door", description: "Walk-ins, payments, ticket printing", icon: DoorOpen },
  { href: "/dashboard/supervisor/reports", label: "Reports", description: "View, export, and email reports", icon: BarChart2 },
@@ -66,38 +68,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.
@@ -184,7 +186,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>
@@ -236,11 +238,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>
@@ -1,19 +1,23 @@
 "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";
+import { BackLink } from "@/components/shared/BackLink";

 // 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 +33,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 +67,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 +154,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 +216,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 +230,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 +243,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 +261,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 +296,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 +325,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 +340,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 +356,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 +386,7 @@ function PaymentsContent() {
    }
    try {
      setSubmitting(true);
-      const res = await apiFetch<any>("/api/payments", {
+      await apiFetch("/api/payments", {
        method: "POST",
        authToken: token,
        body: {
@@ -433,8 +402,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 +423,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 +484,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 }));
    }
@@ -531,9 +500,11 @@ function PaymentsContent() {
          <div className="w-10 h-10 rounded-xl bg-brand-50 flex items-center justify-center shrink-0">
            <Wallet className="w-5 h-5 text-brand-600" />
          </div>
-          <h1 className="text-2xl font-semibold text-gray-900">Payments</h1>
+          <div>
+            <BackLink href="/dashboard" />
+            <h1 className="text-2xl font-semibold text-gray-900 mt-0.5">Payments</h1>
+          </div>
        </div>
-        <button className="px-3 py-1.5 text-sm rounded-lg bg-gray-100 hover:bg-gray-200 text-gray-800 shadow-sm" onClick={() => router.push('/dashboard')}>Back</button>
      </div>

      {!canView && (
@@ -618,8 +589,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 +608,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 +724,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'); }}
              />
@@ -875,15 +845,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 +865,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 +915,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 +939,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 +950,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 +972,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 +988,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 +1002,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 +1015,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 +1024,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 +1041,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 +1054,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 +1089,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 +1122,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>;
 };

@@ -1180,8 +1149,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;
@@ -1191,7 +1160,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]
  );

@@ -1204,7 +1173,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));
      }
@@ -1215,9 +1184,9 @@ 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;
@@ -1227,7 +1196,7 @@ function DonationAssignSection({ payments, allUsers, registrations, regOutstandi
  }, [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]
  );

@@ -1269,8 +1238,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);
    }
@@ -1306,7 +1275,7 @@ 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 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)}`;
@@ -1,15 +1,13 @@
 "use client";

 import React, { Suspense } from "react";
-import { useRouter } from "next/navigation";
 import ReportsV2 from "@/components/reports/ReportsV2";

 export default function SupervisorReportsPage() {
-  const router = useRouter();
  return (
    <div className="w-full p-6">
      <Suspense fallback={<div className="text-sm text-gray-400">Loading…</div>}>
-        <ReportsV2 onBack={() => router.push('/dashboard')} />
+        <ReportsV2 backHref="/dashboard" />
      </Suspense>
    </div>
  );
@@ -8,6 +8,9 @@ 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";
+import { BackLink } from "@/components/shared/BackLink";

 type Entry = {
  id: string;
@@ -43,7 +46,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 +55,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 +70,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);
    }
@@ -98,7 +101,7 @@ export default function WaitlistPage() {
          <ListChecks 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>
+          <BackLink href="/dashboard" />
          <h1 className="text-2xl font-semibold text-gray-900 mt-0.5">Waitlist</h1>
          <p className="text-sm text-gray-500">People waiting for sold-out tickets</p>
        </div>
@@ -1,16 +1,22 @@
 "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";
+import { BackLink } from "@/components/shared/BackLink";

 // 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,
@@ -160,16 +166,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 (
@@ -188,9 +192,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}}`;
@@ -230,10 +234,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() });
@@ -248,8 +252,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");
    }
  };

@@ -259,7 +263,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>
@@ -286,7 +290,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>
@@ -324,7 +328,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>
@@ -372,7 +376,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(() => {
@@ -385,24 +389,26 @@ 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[]>([]);
@@ -418,11 +424,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]);

@@ -431,10 +437,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" });
          }
@@ -450,7 +456,7 @@ function WhatsAppAttendeesPageInner() {
  }, [eventId, token]);

  const buildPayload = (dryRun?: boolean) => {
-    const payload: any = {
+    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,
@@ -465,15 +471,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));
  };
@@ -485,10 +491,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 () => {
@@ -499,15 +505,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, 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 ─────────────────────────────────────────────────────────
@@ -528,9 +534,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); }
    };
@@ -552,30 +558,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) => {
@@ -584,7 +590,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 ─────────────────────────────────────────────────────────────────
@@ -603,11 +609,11 @@ function WhatsAppAttendeesPageInner() {
          <div className="w-10 h-10 rounded-xl bg-brand-50 flex items-center justify-center shrink-0">
            <MessageCircle className="w-5 h-5 text-brand-600" />
          </div>
-          <h1 className="text-2xl font-semibold text-gray-900">WhatsApp Attendees</h1>
+          <div>
+            <BackLink href="/dashboard" />
+            <h1 className="text-2xl font-semibold text-gray-900 mt-0.5">WhatsApp Attendees</h1>
+          </div>
        </div>
-        <button className="px-3 py-1.5 text-sm rounded-lg bg-gray-100 hover:bg-gray-200 text-gray-800 shadow-sm" onClick={() => router.push("/dashboard")}>
-          Back
-        </button>
      </div>

      {!canView && (
@@ -663,7 +669,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>
@@ -693,7 +699,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,{" "}
@@ -709,7 +715,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>
@@ -724,7 +730,7 @@ function WhatsAppAttendeesPageInner() {
              <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>
            ) : (
@@ -837,11 +843,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 () => {
@@ -849,10 +855,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 () => {
@@ -861,10 +867,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>}
@@ -4,10 +4,13 @@ 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";
+import { BackLink } from "@/components/shared/BackLink";

 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 +20,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 +52,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);
    }
@@ -63,7 +66,8 @@ export default function DonatePage() {
          <HandHeart className="w-5 h-5 text-rose-600" />
        </div>
        <div>
-          <h1 className="text-2xl font-semibold text-gray-900">Make a donation</h1>
+          <BackLink href="/dashboard/user" />
+          <h1 className="text-2xl font-semibold text-gray-900 mt-0.5">Make a donation</h1>
          <p className="text-sm text-gray-500">Support an event or the ministry directly.</p>
        </div>
      </div>
@@ -6,6 +6,9 @@ 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";
+import { BackLink } from "@/components/shared/BackLink";

 // Types for form fields
 type FormField = { id: string; type: 'yes_no'|'text'|'date'|'numeric'|'statement'|'paragraph'|'rating'|'multiple_choice'; label: string; isRequired?: boolean; helpText?: string|null; options?: unknown };
@@ -16,7 +19,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);
@@ -32,22 +35,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;
@@ -57,8 +60,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;
    }
@@ -88,7 +91,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] || {} });
      }
@@ -103,13 +106,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');
    }
  };

@@ -123,8 +126,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');
    }
  };

@@ -137,9 +140,11 @@ function FormsContent() {
          <div className="w-10 h-10 rounded-xl bg-brand-50 flex items-center justify-center shrink-0">
            <FileText className="w-5 h-5 text-brand-600" />
          </div>
-          <h1 className="text-2xl font-semibold text-gray-900">Attendee forms</h1>
+          <div>
+            <BackLink href="/dashboard/user" />
+            <h1 className="text-2xl font-semibold text-gray-900 mt-0.5">Attendee forms</h1>
+          </div>
        </div>
-        <button className="px-3 py-1.5 text-sm rounded-lg bg-gray-100 hover:bg-gray-200" onClick={() => router.push('/dashboard/user')}>Back</button>
      </div>

      {loading && <div className="text-sm text-gray-600 mb-2">Loading…</div>}
@@ -159,14 +164,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>
@@ -4,6 +4,7 @@ import { useAuth } from "@/hooks/useAuth";
 import { apiFetch, createFullPaymentCheckout } from "@/lib/api";
 import { useRouter } from "next/navigation";
 import { formatDate } from "@/lib/date";
+import { printTicketCards } from "@/lib/ticketPrint";
 import { formatPaymentMethod } from "@/lib/paymentMethod";
 import { QrImage } from "@/components/shared/QrImage";
 import { ApiImage } from "@/components/shared/ApiImage";
@@ -12,16 +13,23 @@ 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 { BundleSavings } from "@/components/shared/BundleDeals";
+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 +61,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 +89,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 +107,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 +118,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 +157,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 +174,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 +183,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 +197,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 +224,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 +244,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 +267,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 +289,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 +326,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,93 +340,17 @@ 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 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";
-    const variantName = t.registrationOption?.variant?.name;
-    const type = variantName ? `${optionName} — ${variantName}` : optionName;
-    const qty = t.quantity || 1;
-    const qrSrc = `https://api.qrserver.com/v1/create-qr-code/?size=160x160&data=${encodeURIComponent(t.qrCode || t.id)}`;
-    const dateStr = eventDate ? formatDate(eventDate) : '';
-    return `
-      <div class="ticket">
-        <div class="row between">
-          <div class="evt">${eventTitle}</div>
-          ${dateStr ? `<div class="date">${dateStr}</div>` : ''}
-        </div>
-        <div class="type">${type}</div>
-        ${t.attendee?.name ? `<div class="qty">Name: <strong>${t.attendee.name}</strong></div>` : `<div class="qty">Qty: <strong>${qty}</strong></div>`}
-        <div class="qrwrap"><img src="${qrSrc}" alt="QR" /></div>
-        <div class="meta">Ticket ID: ${t.id}</div>
-        ${buyerName ? `<div class="meta">Purchased by: ${buyerName}</div>` : ''}
-      </div>
-    `;
-  };
-
-  const openPrintWindow = (title: string, cardsHtml: string) => {
-    const w = window.open("", "_blank");
-    if (!w) return;
-    w.document.write(`<!doctype html><html><head><title>${title}</title>
-      <style>
-        *{box-sizing:border-box}
-        body{font-family:Arial,Helvetica,sans-serif;margin:0;padding:16px;background:#f7f7f7}
-        .grid{display:grid;grid-template-columns:repeat(auto-fill,minmax(260px,1fr));gap:16px}
-        .ticket{background:#fff;border:1px solid #e5e7eb;border-radius:12px;padding:14px;box-shadow:0 1px 3px rgba(0,0,0,0.06);break-inside:avoid;page-break-inside:avoid}
-        .evt{font-weight:700;font-size:14px}
-        .type{margin-top:4px;color:#374151}
-        .qty{margin-top:2px;font-size:12px;color:#374151}
-        .date{color:#6b7280;font-size:12px}
-        .row{display:flex;gap:8px;align-items:center}
-        .between{justify-content:space-between}
-        .qrwrap{display:flex;justify-content:center;align-items:center;margin:10px 0}
-        .qrwrap img{width:160px;height:160px}
-        .meta{font-size:12px;color:#6b7280;text-align:center;margin-top:6px}
-        @media print { body{background:#fff} .print-hidden{display:none !important} }
-      </style>
-    </head><body>
-      <h2 class="print-hidden" style="margin:8px 0 16px 0;font-size:18px">${title}</h2>
-      <div class="grid">${cardsHtml}</div>
-      <script>
-        (function(){
-          function printWhenReady(){
-            var imgs = Array.prototype.slice.call(document.images);
-            if(imgs.length === 0){ window.print(); return; }
-            var remaining = imgs.length;
-            function done(){ remaining--; if(remaining <= 0){ setTimeout(function(){ window.print(); }, 200); } }
-            imgs.forEach(function(img){
-              if (img.complete) { done(); }
-              else {
-                img.addEventListener('load', done, { once: true });
-                img.addEventListener('error', done, { once: true });
-              }
-            });
-          }
-          if (document.readyState === 'complete') printWhenReady();
-          else window.addEventListener('load', printWhenReady);
-        })();
-      </script>
-    </body></html>`);
-    w.document.close();
-    w.focus();
-  };
-
-  const printTickets = (ticketList: any[]) => {
-    if (!ticketList || ticketList.length === 0) return;
-    const cards = ticketList.map(t => buildTicketHtmlCard(t, user?.name)).join("");
-    openPrintWindow(`Tickets (${ticketList.length})`, cards);
-  };
+  const printTickets = (ticketList: TicketRecord[]) => printTicketCards(ticketList, () => user?.name);

  // 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 +359,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 +377,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 +408,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 +453,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 +470,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 +484,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 +501,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 +517,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 +541,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 +555,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 +591,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 +621,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 +680,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 +722,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 +864,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;
@@ -997,7 +890,7 @@ export default function UserDashboardPage() {
                  </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: any, b: any) => (a.set?.order || 0) - (b.set?.order || 0)).map((a: any) => `${a.set.name}: ${a.group.name}`).join(" · ")}
+                      {[...(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 && (
@@ -1013,13 +906,13 @@ export default function UserDashboardPage() {
                    <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>
+                        <span>Waiting for {t.transferRequests?.[0]?.toName} to accept</span>
                        <button className="underline" onClick={async () => {
                          try {
-                            const r: any = await apiFetch(`/api/tickets/${t.id}/transfer`, { method: "DELETE", authToken: token! });
+                            const r = await apiFetch<{ message?: string }>(`/api/tickets/${t.id}/transfer`, { method: "DELETE", authToken: token! });
                            setInfo(r?.message || "Transfer cancelled");
                            reloadAfterAttendees();
-                          } catch (e: any) { setError(e?.message || "Couldn't cancel"); }
+                          } catch (e) { setError(errorMessage(e) || "Couldn't cancel"); }
                        }}>Cancel</button>
                      </span>
                    )}
@@ -1080,7 +973,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
@@ -1092,7 +985,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}`;
@@ -1129,9 +1022,10 @@ export default function UserDashboardPage() {
                    <div>
                      {renderGroup('Early bird', earlyBirdRows)}
                      {renderGroup('Standard price', standardRows)}
-                      {Number(activeReg.discountTotal || 0) > 0 && (
+                      <BundleSavings applications={activeReg.bundleApplications} className="mt-2" />
+                      {Number(activeReg.discountTotal || 0) - Number(activeReg.bundleDiscount || 0) > 0.005 && (
                        <div className="text-sm text-green-700 mt-2">
-                          Discount code{activeCoupon?.coupon?.code ? <> <span className="font-mono font-semibold">{activeCoupon.coupon.code}</span></> : null} — −{formatRand(Number(activeReg.discountTotal))}
+                          Discount code{activeCoupon?.coupon?.code ? <> <span className="font-mono font-semibold">{activeCoupon.coupon.code}</span></> : null} — −{formatRand(Number(activeReg.discountTotal) - Number(activeReg.bundleDiscount || 0))}
                        </div>
                      )}
                      {canModifyActive && activeBill && activeBill.outstanding > 0 && !activeCoupon && (
@@ -1163,7 +1057,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) => {
@@ -1188,12 +1082,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);
@@ -1271,7 +1165,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>
@@ -1298,8 +1192,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>
@@ -7,6 +7,9 @@ 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";
+import { BackLink } from "@/components/shared/BackLink";

 interface PaymentItem {
  id: string;
@@ -49,14 +52,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 +85,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);

@@ -105,12 +109,11 @@ export default function UserPaymentsPage() {
          <div className="w-10 h-10 rounded-xl bg-brand-50 flex items-center justify-center shrink-0">
            <Receipt className="w-5 h-5 text-brand-600" />
          </div>
-          <h1 className="text-2xl font-semibold text-gray-900">My Payments</h1>
+          <div>
+            <BackLink href="/dashboard/user" />
+            <h1 className="text-2xl font-semibold text-gray-900 mt-0.5">My Payments</h1>
+          </div>
        </div>
-        <button
-          className="px-2.5 py-1 text-xs rounded-lg bg-gray-100 hover:bg-gray-200 text-gray-800 shadow-sm focus:outline-none focus:ring-2 focus:ring-brand-500 focus:ring-offset-1"
-          onClick={() => router.push("/dashboard/user")}
-        >Back to dashboard</button>
      </div>

      {error && <p className="text-red-600 text-sm mb-3">{error}</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>
@@ -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,8 @@ 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";
+import { BackLink } from "@/components/shared/BackLink";

 type ActivityEvent = { id: string; type: "login" | "password_changed" | "password_reset" | "two_factor_enabled" | "two_factor_disabled"; device: string | null; createdAt: string };

@@ -54,7 +56,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 +69,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 +97,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 +108,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 +125,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 +133,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 +144,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 +205,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 +229,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 +251,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 +271,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 +279,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);
    }
@@ -308,7 +310,8 @@ export default function UserProfilePage() {
  return (
    <div className="max-w-4xl mx-auto w-full">
      <div className="mb-6">
-        <h1 className="text-2xl font-semibold text-gray-900">Profile &amp; Security</h1>
+        <BackLink href="/dashboard" />
+        <h1 className="text-2xl font-semibold text-gray-900 mt-0.5">Profile &amp; Security</h1>
        <p className="text-sm text-gray-500 mt-1">Manage your personal information and keep your account secure.</p>
      </div>

@@ -5,6 +5,8 @@ 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";
+import { BackLink } from "@/components/shared/BackLink";

 export default function ResetPasswordPage() {
  const { token } = useAuth();
@@ -35,8 +37,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);
    }
@@ -49,12 +51,11 @@ export default function ResetPasswordPage() {
          <div className="w-10 h-10 rounded-xl bg-brand-50 flex items-center justify-center shrink-0">
            <KeyRound className="w-5 h-5 text-brand-600" />
          </div>
-          <h1 className="text-2xl font-semibold text-gray-900">Reset password</h1>
+          <div>
+            <BackLink href="/dashboard/user" />
+            <h1 className="text-2xl font-semibold text-gray-900 mt-0.5">Reset password</h1>
+          </div>
        </div>
-        <button
-          className="px-2.5 py-1 text-xs rounded-lg bg-gray-100 hover:bg-gray-200 text-gray-800 shadow-sm focus:outline-none focus:ring-2 focus:ring-brand-500 focus:ring-offset-1"
-          onClick={() => router.push("/dashboard/user")}
-        >Back to dashboard</button>
      </div>

      {error && <p className="text-red-600 text-sm mb-3">{error}</p>}
@@ -4,7 +4,9 @@ import { Share2, QrCode, CalendarPlus } from "lucide-react";
 import QRCode from "qrcode";
 import { API_BASE } from "@/lib/api";

-export default function ClientActions({ event }: { event: any }) {
+type Props = { event: { id: string; title: string; description?: string | null } };
+
+export default function ClientActions({ event }: Props) {
    return (
        <div className="flex gap-2">
            <button
@@ -12,7 +14,7 @@ export default function ClientActions({ event }: { event: any }) {
                    try {
                        await navigator.share({
                            title: event.title,
-                            text: event.description,
+                            text: event.description ?? undefined,
                            url: window.location.href,
                        });
                    } catch (err) {
@@ -5,14 +5,15 @@ import { Footer } from "@/components/layout/Footer";
 import ClientActions from "@/app/events/[id]/ClientActions";
 import { ContactButton } from "@/components/events/ContactButton";
 import { LocationMap } from "@/components/events/LocationMap";
-import { JoinWaitlistButton, soldOutLines } from "@/components/events/JoinWaitlistButton";
+import { JoinWaitlistButton } from "@/components/events/JoinWaitlistButton";
+import { soldOutLines } from "@/lib/waitlist";
 import { SponsorSpot } from "@/components/events/SponsorSpot";
 import { FunnelTracker } from "@/components/events/FunnelTracker";
 import { Calendar, Ticket, Paperclip, Sparkles } from "lucide-react";

 export const revalidate = 60;

-type OptionVariant = { id: string; name: string; price: number | null; stockLimit?: number; availableCount?: number };
+type OptionVariant = { id: string; name: string; price: number | null; stockLimit?: number; availableCount?: number; order?: number };
 type EventOption = {
  id: string;
  name: string;
@@ -45,11 +46,14 @@ type Event = {
  location?: string | null;
  waitlistEnabled?: boolean;
  allowSponsorships?: boolean;
+  bundles?: PublicBundle[];
 };

 import { apiFetch, ApiError, resolveToApiOrigin } from "@/lib/api";
 import { ApiImage } from "@/components/shared/ApiImage";
 import { formatDateTimeRange } from "@/lib/date";
+import { BundleOffers } from "@/components/shared/BundleDeals";
+import type { PublicBundle } from "@/types";

 // Tiered low-stock threshold: larger events use a smaller percentage.
 // Math.round avoids Math.ceil inflating the threshold (e.g. ceil(1.5)=2 made
@@ -262,6 +266,7 @@ function TicketList({ event }: { event: Event }) {
  }
  return (
    <div className="space-y-2">
+      <BundleOffers bundles={event.bundles} />
      {options.map((opt) => {
        const hasVariants = Array.isArray(opt.variants) && opt.variants.length > 0;
        const soldOut = (opt.stockLimit ?? 0) > 0 && opt.availableCount !== undefined && opt.availableCount <= 0;
@@ -283,7 +288,7 @@ function TicketList({ event }: { event: Event }) {
                </div>
              </div>
              <ul className="divide-y">
-                {opt.variants!.slice().sort((a, b) => (a as any).order - (b as any).order).map((v) => {
+                {opt.variants!.slice().sort((a, b) => (a.order ?? 0) - (b.order ?? 0)).map((v) => {
                  const vPrice = v.price !== null && v.price !== undefined ? v.price : opt.price;
                  const vSoldOut = (v.stockLimit ?? 0) > 0 && v.availableCount !== undefined && v.availableCount <= 0;
                  const vNearlyOut = !vSoldOut && (v.stockLimit ?? 0) > 0 && v.availableCount !== undefined && v.availableCount <= lowStockThreshold(v.stockLimit ?? 0);
@@ -7,6 +7,7 @@ import { apiFetch } from "@/lib/api";
 import { formatDate } from "@/lib/date";
 import { MessageSquareHeart, CheckCircle2 } from "lucide-react";
 import { ExtraFieldInput, isExtraFieldType } from "@/components/shared/FormFieldExtras";
+import { errorMessage } from "@/lib/utils";

 type Field = { id: string; type: string; label: string; isRequired: boolean; helpText: string | null; options: unknown };
 type FeedbackInfo = {
@@ -46,8 +47,8 @@ export default function FeedbackPage() {
    try {
      await apiFetch(`/api/feedback/public/${encodeURIComponent(token!)}`, { method: "POST", body: { answers } });
      setDone(true);
-    } catch (err: any) {
-      setError(err?.message || "Couldn't send your feedback");
+    } catch (err) {
+      setError(errorMessage(err) || "Couldn't send your feedback");
    } finally {
      setBusy(false);
    }
@@ -7,6 +7,8 @@ import { apiFetch } from "@/lib/api";
 import { Navbar } from "@/components/layout/Navbar";
 import { Footer } from "@/components/layout/Footer";
 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'|'rating'|'multiple_choice'; label: string; isRequired?: boolean; helpText?: string|null; options?: unknown };
@@ -16,10 +18,12 @@ function FormsContent() {
  const router = useRouter();
  const { token } = useAuth();
  const registrationId = search.get("registrationId");
+  // Donation chosen on the register form — passed through so the success page can add it to the payment.
+  const donationParam = search.get("donation") ? `&donation=${encodeURIComponent(search.get("donation")!)}` : "";
  // Set when a named attendee opens the link sent to them — show only their form.
  const onlyAttendeeId = search.get("attendeeId");

-  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] = useState<string | null>(null);
@@ -36,17 +40,17 @@ function FormsContent() {
      setInfo(null);
      try {
        // authToken optional — guests access via registrationId alone
-        const reg = await apiFetch<any>(`/api/registrations/${encodeURIComponent(registrationId)}`, { authToken: token || undefined });
+        const reg = await apiFetch<Registration>(`/api/registrations/${encodeURIComponent(registrationId)}`, { authToken: token || undefined });
        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 to prefill fields
        try {
-          const draft = await apiFetch<any>(`/api/registrations/${encodeURIComponent(registrationId)}/forms/draft`, { authToken: token || undefined });
+          const draft = await apiFetch<{ data?: Record<string, Record<string, string>> } | null>(`/api/registrations/${encodeURIComponent(registrationId)}/forms/draft`, { authToken: token || undefined });
          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);
      }
@@ -61,8 +65,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;
    }
@@ -75,13 +79,13 @@ function FormsContent() {
  const blocks = useMemo((): FormBlock[] => {
    if (!registration) return [];
    const responses = registration.formResponses || [];
-    const answered = new Set(responses.map((r: any) => r.attendeeId).filter(Boolean));
-    const attendees = (registration.attendees || []) as any[];
+    const answered = new Set(responses.map((r) => r.attendeeId).filter(Boolean));
+    const attendees = registration.attendees || [];
    const named = attendees
      .filter(a => !answered.has(a.id))
-      .map(a => ({ key: `a:${a.id}`, label: a.name, attendeeId: a.id as string }));
+      .map(a => ({ key: `a:${a.id}`, label: a.name, attendeeId: a.id }));
    const unnamedPlaces = Math.max(0, requiredCount - attendees.length);
-    const unnamedAnswered = responses.filter((r: any) => !r.attendeeId).length;
+    const unnamedAnswered = responses.filter((r) => !r.attendeeId).length;
    const unnamed = Array.from({ length: Math.max(0, unnamedPlaces - unnamedAnswered) }, (_, i) => ({
      key: String(i), label: `Attendee ${unnamedAnswered + i + 1}`,
    }));
@@ -89,7 +93,7 @@ function FormsContent() {
    return onlyAttendeeId ? all.filter(b => b.attendeeId === onlyAttendeeId) : all;
  }, [registration, requiredCount, onlyAttendeeId]);
  const remaining = blocks.length;
-  const attendeeName = (id: string | null | undefined) => (registration?.attendees || []).find((a: any) => a.id === id)?.name;
+  const attendeeName = (id: string | null | undefined) => (registration?.attendees || []).find((a) => a.id === id)?.name;

  // Determine if all required fields are filled for each attendee form to be submitted
  const canSubmit = useMemo(() => {
@@ -116,8 +120,8 @@ function FormsContent() {
      const payload = blocks.map(b => ({ ...(b.attendeeId ? { attendeeId: b.attendeeId } : {}), answers: formsData[b.key] || {} }));
      if (payload.length === 0) {
        // Nothing left to submit – still go to success page to continue the flow
-        const totalDue = (registration?.registrationOptions || []).reduce((s: number, ro: any) => s + ((ro.eventOption?.price || 0) * (ro.quantity || 0)), 0);
-        router.push(`/registration/success?registrationId=${encodeURIComponent(registrationId)}${totalDue>0?`&totalDue=${encodeURIComponent(totalDue.toFixed(2))}`:''}`);
+        const totalDue = (registration?.registrationOptions || []).reduce((s, ro) => s + ((ro.eventOption?.price || 0) * (ro.quantity || 0)), 0);
+        router.push(`/registration/success?registrationId=${encodeURIComponent(registrationId)}${totalDue>0?`&totalDue=${encodeURIComponent(totalDue.toFixed(2))}`:''}${donationParam}`);
        return;
      }
      await apiFetch(`/api/registrations/${encodeURIComponent(registrationId)}/forms/responses`, {
@@ -126,10 +130,10 @@ function FormsContent() {
        body: { responses: payload }
      });
      // On success, redirect to the success page
-      const totalDue = (registration?.registrationOptions || []).reduce((s: number, ro: any) => s + ((ro.eventOption?.price || 0) * (ro.quantity || 0)), 0);
-      router.push(`/registration/success?registrationId=${encodeURIComponent(registrationId)}${totalDue>0?`&totalDue=${encodeURIComponent(totalDue.toFixed(2))}`:''}`);
-    } catch (e: any) {
-      setError(e?.message || 'Failed to submit forms');
+      const totalDue = (registration?.registrationOptions || []).reduce((s, ro) => s + ((ro.eventOption?.price || 0) * (ro.quantity || 0)), 0);
+      router.push(`/registration/success?registrationId=${encodeURIComponent(registrationId)}${totalDue>0?`&totalDue=${encodeURIComponent(totalDue.toFixed(2))}`:''}${donationParam}`);
+    } catch (e) {
+      setError(errorMessage(e) || 'Failed to submit forms');
    }
  };

@@ -146,13 +150,13 @@ function FormsContent() {
      if (!token || !registrationId) return;
      try {
        // Redirect to the success page
-        const totalDue = (registration?.registrationOptions || []).reduce((s: number, ro: any) => s + ((ro.eventOption?.price || 0) * (ro.quantity || 0)), 0);
-        router.push(`/registration/success?registrationId=${encodeURIComponent(registrationId)}${totalDue>0?`&totalDue=${encodeURIComponent(totalDue.toFixed(2))}`:''}`);
-      } catch (e: any) {
-        setError(e?.message || 'Failded to go to next step');
+        const totalDue = (registration?.registrationOptions || []).reduce((s, ro) => s + ((ro.eventOption?.price || 0) * (ro.quantity || 0)), 0);
+        router.push(`/registration/success?registrationId=${encodeURIComponent(registrationId)}${totalDue>0?`&totalDue=${encodeURIComponent(totalDue.toFixed(2))}`:''}${donationParam}`);
+      } catch (e) {
+        setError(errorMessage(e) || 'Failded to go to next step');
      }
-    } catch (e: any) {
-      setError(e?.message || 'Failed to save draft');
+    } catch (e) {
+      setError(errorMessage(e) || 'Failed to save draft');
    }
  };

@@ -160,10 +164,10 @@ function FormsContent() {
    if (!registrationId) return;
    try {
      // Redirect to the success page
-      const totalDue = (registration?.registrationOptions || []).reduce((s: number, ro: any) => s + ((ro.eventOption?.price || 0) * (ro.quantity || 0)), 0);
-      router.push(`/registration/success?registrationId=${encodeURIComponent(registrationId)}${totalDue>0?`&totalDue=${encodeURIComponent(totalDue.toFixed(2))}`:''}`);
-    } catch (e: any) {
-      setError(e?.message || 'Failded to skip');
+      const totalDue = (registration?.registrationOptions || []).reduce((s, ro) => s + ((ro.eventOption?.price || 0) * (ro.quantity || 0)), 0);
+      router.push(`/registration/success?registrationId=${encodeURIComponent(registrationId)}${totalDue>0?`&totalDue=${encodeURIComponent(totalDue.toFixed(2))}`:''}${donationParam}`);
+    } catch (e) {
+      setError(errorMessage(e) || 'Failded to skip');
    }
  };

@@ -210,14 +214,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">{attendeeName(resp.attendeeId) || `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>
@@ -1,5 +1,4 @@
 import type { Metadata } from "next";
-import { Geist, Geist_Mono } from "next/font/google";
 import "./globals.css";
 import { AuthProvider } from "@/contexts/AuthContext";
 import { SiteSettingsProvider } from "@/contexts/SiteSettingsContext";
@@ -14,16 +13,6 @@ import { API_BASE, resolveToApiOrigin } from "@/lib/api";
 import { buildThemeCssVars } from "@/lib/colorScale";
 import { appUrl } from "@/lib/siteConfig";

-const geistSans = Geist({
-  variable: "--font-geist-sans",
-  subsets: ["latin"],
-});
-
-const geistMono = Geist_Mono({
-  variable: "--font-geist-mono",
-  subsets: ["latin"],
-});
-
 const appName = process.env.NEXT_PUBLIC_APP_NAME || 'Cross Code';

 /**
@@ -1,3 +1,4 @@
+import Link from "next/link";
 import { EventCard } from "@/components/events/EventCard";
 import { Navbar } from "@/components/layout/Navbar";
 import { Footer } from "@/components/layout/Footer";
@@ -71,10 +72,10 @@ export default async function HomePage() {
                        <h1 className="text-4xl sm:text-5xl font-bold mb-4 text-gray-900">Welcome to {displayName}</h1>
                        <p className="text-gray-600 text-lg mb-8">Experience unforgettable moments. Powered by purpose.</p>
                        <div className="flex flex-wrap items-center justify-center gap-3">
-                            <a href="/events" className="inline-flex items-center gap-2 px-6 py-2.5 bg-brand-600 text-white rounded-xl hover:bg-brand-700 shadow-sm font-medium transition-colors">
+                            <Link href="/events" className="inline-flex items-center gap-2 px-6 py-2.5 bg-brand-600 text-white rounded-xl hover:bg-brand-700 shadow-sm font-medium transition-colors">
                                <Calendar className="w-4 h-4" />
                                View Events
-                            </a>
+                            </Link>
                            <JoinUsButton />
                        </div>
                    </div>
@@ -83,10 +84,10 @@ export default async function HomePage() {
                <section className="py-12 px-4 max-w-7xl mx-auto">
                    <div className="flex items-center justify-between mb-6">
                        <h2 className="text-2xl font-semibold text-gray-900">Upcoming Events</h2>
-                        <a href="/events" className="hidden sm:inline-flex items-center gap-1 text-sm font-medium text-brand-600 hover:underline">
+                        <Link href="/events" className="hidden sm:inline-flex items-center gap-1 text-sm font-medium text-brand-600 hover:underline">
                            View all events
                            <ArrowRight className="w-3.5 h-3.5" />
-                        </a>
+                        </Link>
                    </div>
                    {sorted.length === 0 ? (
                        <div className="text-center py-12 border rounded-xl bg-gray-50">
@@ -101,10 +102,10 @@ export default async function HomePage() {
                        </div>
                    )}
                    <div className="text-center mt-8 sm:hidden">
-                        <a href="/events" className="inline-flex items-center gap-1 text-brand-600 hover:underline text-sm font-medium">
+                        <Link href="/events" className="inline-flex items-center gap-1 text-brand-600 hover:underline text-sm font-medium">
                            View all events
                            <ArrowRight className="w-3.5 h-3.5" />
-                        </a>
+                        </Link>
                    </div>
                </section>

@@ -4,9 +4,12 @@ import React, { useEffect, useMemo, useState } from "react";
 import { useAuth } from "@/hooks/useAuth";
 import { apiFetch } from "@/lib/api";
 import { CouponCodeField, AppliedCoupon } from "@/components/shared/CouponCodeField";
+import { BundleBuilder, BundleOffers, BundleSavings, useBundleQuote } from "@/components/shared/BundleDeals";
+import type { PublicBundle } from "@/types";
 import { AttendeeNamesEditor, AttendeeEntries, TicketDelivery, attendeesPayload, consentDetailsMissing } from "@/components/shared/AttendeeNamesEditor";
 import { JoinWaitlistButton } from "@/components/events/JoinWaitlistButton";
 import { analyticsSessionId } from "@/lib/analytics";
+import { errorMessage } from "@/lib/utils";

 // Tiered low-stock threshold — mirrors events/[id]/page.tsx
 function lowStockThreshold(stockLimit: number): number {
@@ -18,7 +21,7 @@ function lowStockThreshold(stockLimit: number): number {
  return Math.round(stockLimit * pct);
 }

-type EarlyBirdTier = { id: string; deadline: string; price: number; stockLimit?: number; order?: number };
+type EarlyBirdTier = { id: string; deadline: string; price: number; stockLimit?: number; availableCount?: number; order?: number };
 type OptionVariant = { id: string; name: string; price: number | null; stockLimit?: number; availableCount?: number; order?: number };
 type EventOption = {
  id: string;
@@ -31,7 +34,7 @@ type EventOption = {
  variants?: OptionVariant[];
 };

-type Event = {
+export type RegisterEvent = {
  id: string;
  title: string;
  description?: string;
@@ -41,12 +44,14 @@ type Event = {
  price: number;
  picture?: string;
  eventOptions?: EventOption[];
-  form?: { isRequired: boolean; fields?: any[] } | null;
+  form?: { isRequired: boolean; fields?: unknown[] } | null;
+  requiresRegistration?: boolean;
  requiresAuth?: boolean;
  allowNamedAttendees?: boolean;
  requiresParentalConsent?: boolean;
  collectGender?: boolean;
  waitlistEnabled?: boolean;
+  bundles?: PublicBundle[];
 };

 type WaitlistOffer = { eventOptionId: string; variantId: string | null; quantity: number; expiresAt: string; optionName: string; variantName: string | null };
@@ -61,7 +66,7 @@ function effectiveUnitForOption(opt: EventOption): number {
  const now = new Date();
  const applicable = tiers
    .map((t) => ({ ...t, _d: new Date(t.deadline) }))
-    .filter((t) => now < t._d && (t.stockLimit === undefined || t.stockLimit === 0 || (t as any).availableCount === undefined || (t as any).availableCount > 0))
+    .filter((t) => now < t._d && (t.stockLimit === undefined || t.stockLimit === 0 || t.availableCount === undefined || t.availableCount > 0))
    .sort((a, b) => a.price - b.price || a._d.getTime() - b._d.getTime());
  return applicable.length > 0 ? applicable[0].price : base;
 }
@@ -252,7 +257,78 @@ function OptionCard({
  );
 }

-export default function RegisterForm({ event: baseEvent }: { event: Event }) {
+// Online donations have the same R15 minimum as the donate page and the backend.
+const MIN_DONATION = 15;
+
+// Suggested donations: 10/15/20/25% of the ticket total rounded up to the next R10 (at least R20),
+// topped up with fixed amounts when the percentages collapse on a small total.
+function donationPresets(total: number): number[] {
+  const out: number[] = [];
+  for (const pct of [0.10, 0.15, 0.20, 0.25]) {
+    const v = Math.max(20, Math.ceil((total * pct) / 10) * 10);
+    if (!out.includes(v)) out.push(v);
+  }
+  for (const v of [50, 100, 200]) {
+    if (out.length >= 3) break;
+    if (!out.includes(v) && v > out[out.length - 1]) out.push(v);
+  }
+  return out;
+}
+
+type DonationChoice = { kind: "none" } | { kind: "preset"; index: number } | { kind: "custom" };
+
+function DonationPicker({
+  presets,
+  choice,
+  onChoiceChange,
+  customAmount,
+  onCustomAmountChange,
+}: {
+  presets: number[];
+  choice: DonationChoice;
+  onChoiceChange: (c: DonationChoice) => void;
+  customAmount: string;
+  onCustomAmountChange: (v: string) => void;
+}) {
+  const btn = (active: boolean) =>
+    `px-3 py-2 rounded-lg border text-sm font-medium transition-colors ${active ? "bg-brand-600 border-brand-600 text-white" : "bg-white text-gray-700 hover:bg-gray-50"}`;
+  return (
+    <div className="border rounded-lg p-4 bg-white shadow-sm">
+      <div className="font-medium text-sm">Donation amount</div>
+      <p className="text-xs text-gray-500 mt-0.5 mb-3">Would you like to add a donation to support this event? It&apos;s added to your payment.</p>
+      <div className="flex flex-wrap gap-2">
+        {presets.map((amt, i) => (
+          <button key={i} type="button" className={btn(choice.kind === "preset" && choice.index === i)} onClick={() => onChoiceChange({ kind: "preset", index: i })}>
+            R{amt}
+          </button>
+        ))}
+        <button type="button" className={btn(choice.kind === "custom")} onClick={() => onChoiceChange({ kind: "custom" })}>
+          Custom
+        </button>
+        <button type="button" className={btn(choice.kind === "none")} onClick={() => onChoiceChange({ kind: "none" })}>
+          None
+        </button>
+      </div>
+      {choice.kind === "custom" && (
+        <div className="mt-3">
+          <input
+            type="number"
+            min={MIN_DONATION}
+            step="1"
+            inputMode="decimal"
+            autoFocus
+            placeholder={`Amount in Rand (min R${MIN_DONATION})`}
+            value={customAmount}
+            onChange={(e) => onCustomAmountChange(e.target.value)}
+            className="w-full sm:w-60 border rounded-lg px-3 py-2 text-sm focus:outline-none focus:ring-2 focus:ring-brand-400"
+          />
+        </div>
+      )}
+    </div>
+  );
+}
+
+export default function RegisterForm({ event: baseEvent }: { event: RegisterEvent }) {
  const { token, user } = useAuth();
  const eventId = baseEvent.id;

@@ -271,9 +347,9 @@ export default function RegisterForm({ event: baseEvent }: { event: Event }) {
        setOffer(res);
        setQuantities(q => ({ ...q, [res.variantId ? `${res.eventOptionId}:${res.variantId}` : res.eventOptionId]: res.quantity }));
      })
-      .catch((e: any) => setOfferError(e?.message || "This waitlist link is not valid."));
+      .catch((e: unknown) => setOfferError(errorMessage(e) || "This waitlist link is not valid."));
  }, []);
-  const event = useMemo<Event>(() => {
+  const event = useMemo<RegisterEvent>(() => {
    if (!offer) return baseEvent;
    return {
      ...baseEvent,
@@ -300,8 +376,6 @@ export default function RegisterForm({ event: baseEvent }: { event: Event }) {
    return initial;
  });
  const [error, setError] = useState<string | null>(null);
-  const [registrationId, setRegistrationId] = useState<string | null>(null);
-  const [creatingCheckout, setCreatingCheckout] = useState(false);
  const [creatingRegistration, setCreatingRegistration] = useState(false);
  const [coupon, setCoupon] = useState<AppliedCoupon | null>(null);
  const [namingOthers, setNamingOthers] = useState(false);
@@ -359,8 +433,21 @@ export default function RegisterForm({ event: baseEvent }: { event: Event }) {
  }, [event]);

  const basket = useMemo(() => buildItems(), [quantities]); // eslint-disable-line react-hooks/exhaustive-deps
-  // The server prices the basket (staff price, tiers) when checking a code, so its total wins.
-  const payable = coupon ? coupon.total : total;
+  const bundleQuote = useBundleQuote({ eventId, basket, token, enabled: (event.bundles || []).length > 0 });
+  // The server prices the basket (staff price, tiers, bundle deals) when quoting or checking
+  // a code, so its total wins.
+  const payable = coupon ? coupon.total : bundleQuote ? bundleQuote.total : total;
+
+  // Optional donation on top of the tickets — paid in the same Yoco checkout and recorded
+  // as a separate donation payment. Only offered when there's something to pay online.
+  const [donationChoice, setDonationChoice] = useState<DonationChoice>({ kind: "none" });
+  const [customDonation, setCustomDonation] = useState("");
+  const presets = useMemo(() => donationPresets(total), [total]);
+  const showDonation = isLoggedIn && payable > 0 && !eventSoldOut;
+  const donation = !showDonation ? 0
+    : donationChoice.kind === "preset" ? (presets[donationChoice.index] ?? 0)
+    : donationChoice.kind === "custom" ? Math.max(0, Math.round((parseFloat(customDonation) || 0) * 100) / 100)
+    : 0;

  function buildItems() {
    const items: { eventOptionId: string; quantity: number; variantId?: string }[] = [];
@@ -386,6 +473,11 @@ export default function RegisterForm({ event: baseEvent }: { event: Event }) {
      const missing = consentDetailsMissing(event.eventOptions || [], qtyFor, attendeeEntries, event.startDate);
      if (missing) { setError(missing); return; }
    }
+    if (showDonation && donationChoice.kind === "custom" && donation > 0 && donation < MIN_DONATION) {
+      setError(`The minimum donation is R${MIN_DONATION}. Choose None to skip it.`);
+      return;
+    }
+    const donationParam = donation > 0 ? `&donation=${encodeURIComponent(donation.toFixed(2))}` : "";

    // Claim link without logging in: the link identifies the person.
    if (waitlistToken && !isLoggedIn) {
@@ -397,8 +489,8 @@ export default function RegisterForm({ event: baseEvent }: { event: Event }) {
          body: { eventId, options: items, waitlistToken, analyticsSessionId: analyticsSessionId(), ...(namedAttendees().length > 0 ? { attendees: namedAttendees(), ticketDelivery: delivery } : {}) },
        });
        if (res?.id) window.location.href = `/registration/success?registrationId=${encodeURIComponent(res.id)}&totalDue=${encodeURIComponent((res.totalDueComputed ?? payable).toFixed(2))}`;
-      } catch (e: any) {
-        setError(e?.message || "Registration failed");
+      } catch (e) {
+        setError(errorMessage(e) || "Registration failed");
      } finally {
        setCreatingRegistration(false);
      }
@@ -430,8 +522,8 @@ export default function RegisterForm({ event: baseEvent }: { event: Event }) {
          const hasForm = !!(event?.form && Array.isArray(event.form.fields) && event.form.fields.length > 0);
          const due = res.totalDueComputed ?? payable;
          const next = hasForm
-            ? `/forms?registrationId=${encodeURIComponent(res.id)}`
-            : `/registration/success?registrationId=${encodeURIComponent(res.id)}&totalDue=${encodeURIComponent((due || 0).toFixed(2))}`;
+            ? `/forms?registrationId=${encodeURIComponent(res.id)}${donationParam}`
+            : `/registration/success?registrationId=${encodeURIComponent(res.id)}&totalDue=${encodeURIComponent((due || 0).toFixed(2))}${donationParam}`;
          if (res.couponError) {
            // The code ran out between checking and registering — the registration is
            // saved at full price, so say so before moving on.
@@ -441,8 +533,8 @@ export default function RegisterForm({ event: baseEvent }: { event: Event }) {
          }
          window.location.href = next;
        }
-      } catch (e: any) {
-        setError(e?.message || "Registration failed");
+      } catch (e) {
+        setError(errorMessage(e) || "Registration failed");
      } finally {
        setCreatingRegistration(false);
      }
@@ -477,34 +569,13 @@ export default function RegisterForm({ event: baseEvent }: { event: Event }) {
          window.location.href = `/registration/success?registrationId=${encodeURIComponent(res.id)}&totalDue=0.00`;
        }
      }
-    } catch (e: any) {
-      setError(e?.message || "Registration failed");
+    } catch (e) {
+      setError(errorMessage(e) || "Registration failed");
    } finally {
      setCreatingRegistration(false);
    }
  };

-  const createYocoCheckout = async () => {
-    if (!token || !registrationId) return;
-    try {
-      setCreatingCheckout(true);
-      const res = await apiFetch<{ redirectUrl: string }>("/api/payments/yoco-checkout", {
-        method: "POST",
-        body: {
-          registrationId,
-          successUrl: window.location.origin + "/payment/success",
-          cancelUrl: window.location.origin + "/payment/cancel",
-          failureUrl: window.location.origin + "/payment/failure",
-        },
-        authToken: token,
-      });
-      window.open(res.redirectUrl, "_blank");
-    } catch (e: any) {
-      setError(e?.message || "Failed to create checkout");
-    } finally {
-      setCreatingCheckout(false);
-    }
-  };

  return (
    <>
@@ -565,6 +636,8 @@ export default function RegisterForm({ event: baseEvent }: { event: Event }) {
        </div>
      )}

+      {!eventSoldOut && <BundleOffers bundles={event.bundles} className="mb-3" />}
+
      <div className="space-y-3">
        {(event.eventOptions || []).map((opt) => (
          <OptionCard
@@ -577,16 +650,38 @@ export default function RegisterForm({ event: baseEvent }: { event: Event }) {
        ))}
      </div>

+      {!eventSoldOut && (
+        <BundleBuilder
+          className="mt-3"
+          bundles={event.bundles}
+          options={event.eventOptions || []}
+          qty={qtyFor}
+          onSetQuantity={(optionId, variantId, quantity) => handleQtyChange(variantId ? `${optionId}:${variantId}` : optionId, quantity)}
+        />
+      )}
+
+      {showDonation && (
+        <div className="mt-3">
+          <DonationPicker
+            presets={presets}
+            choice={donationChoice}
+            onChoiceChange={setDonationChoice}
+            customAmount={customDonation}
+            onCustomAmountChange={setCustomDonation}
+          />
+        </div>
+      )}
+
      {(() => {
        // Collect all upcoming early-bird tiers across all options
        const now = new Date();
        const upcomingTiers = (event.eventOptions || []).flatMap(opt =>
          (opt.earlyBirdTiers || [])
-            .map((t: any) => ({ ...t, deadline: new Date(t.deadline) }))
-            .filter((t: any) => t.deadline > now)
-        ).sort((a: any, b: any) => a.deadline.getTime() - b.deadline.getTime());
+            .map((t) => ({ ...t, deadline: new Date(t.deadline) }))
+            .filter((t) => t.deadline > now)
+        ).sort((a, b) => a.deadline.getTime() - b.deadline.getTime());
        if (upcomingTiers.length === 0) return null;
-        const soonest = upcomingTiers[0].deadline as Date;
+        const soonest = upcomingTiers[0].deadline;
        const dateStr = soonest.toLocaleDateString(undefined, { year: "numeric", month: "long", day: "numeric" });
        return (
          <div className="mt-4 p-3 rounded-lg bg-amber-50 border border-amber-200 text-sm text-amber-800">
@@ -620,20 +715,23 @@ export default function RegisterForm({ event: baseEvent }: { event: Event }) {

      <div className="mt-6 flex items-center justify-between">
        <div>
-          {coupon && coupon.discount > 0 && (
-            <div className="text-sm text-gray-500">
-              <span className="line-through">R{coupon.subtotal.toFixed(2)}</span>
-              <span className="ml-2 text-green-700">−R{coupon.discount.toFixed(2)}</span>
-            </div>
+          {(bundleQuote || (coupon && coupon.discount > 0)) && (
+            <div className="text-sm text-gray-500 line-through">R{(coupon?.subtotal ?? bundleQuote?.subtotal ?? total).toFixed(2)}</div>
          )}
-          <div className="text-lg font-semibold">Total: R{payable.toFixed(2)}</div>
+          <BundleSavings applications={bundleQuote?.bundles} />
+          {coupon && coupon.discount > 0 && (
+            <div className="text-sm text-green-700">Code {coupon.code} −R{coupon.discount.toFixed(2)}</div>
+          )}
+          {donation > 0 && (
+            <div className="text-sm text-gray-600">Donation +R{donation.toFixed(2)}</div>
+          )}
+          <div className="text-lg font-semibold">Total: R{(payable + donation).toFixed(2)}</div>
        </div>
-        {!registrationId ? (
-          eventSoldOut ? (
-            <button disabled className="bg-red-50 text-red-700 border border-red-200 px-4 py-2 rounded cursor-not-allowed">
-              Sold Out
-            </button>
-          ) : (
+        {eventSoldOut ? (
+          <button disabled className="bg-red-50 text-red-700 border border-red-200 px-4 py-2 rounded cursor-not-allowed">
+            Sold Out
+          </button>
+        ) : (
          <button
            onClick={submitRegistration}
            disabled={creatingRegistration || (!isLoggedIn && !isGuestEligible && !waitlistToken)}
@@ -641,15 +739,6 @@ export default function RegisterForm({ event: baseEvent }: { event: Event }) {
          >
            {creatingRegistration ? "Registering..." : "Register"}
          </button>
-          )
-        ) : (
-          <button
-            onClick={createYocoCheckout}
-            disabled={creatingCheckout}
-            className="bg-green-600 text-white px-4 py-2 rounded disabled:opacity-60"
-          >
-            {creatingCheckout ? "Creating checkout..." : "Pay with Yoco"}
-          </button>
        )}
      </div>

@@ -2,18 +2,18 @@ import { notFound, redirect } from "next/navigation";
 import { Navbar } from "@/components/layout/Navbar";
 import { Footer } from "@/components/layout/Footer";
 import { apiFetch, ApiError } from "@/lib/api";
-import RegisterForm from "./RegisterForm";
+import RegisterForm, { type RegisterEvent } from "./RegisterForm";
 import { FunnelTracker } from "@/components/events/FunnelTracker";

 export const revalidate = 60;

 export default async function RegisterPage({ params }: { params: Promise<{ eventId: string }> }) {
  const { eventId } = await params;
-  let event: any;
+  let event: RegisterEvent;
  try {
    // Fetched server-side (same pattern as /events/[id]) so the form's content is part of
    // the initial HTML instead of showing a loading skeleton after a client-side fetch.
-    event = await apiFetch<any>(`/api/events/${eventId}`, { nextOptions: { next: { revalidate } } });
+    event = await apiFetch<RegisterEvent>(`/api/events/${eventId}`, { nextOptions: { next: { revalidate } } });
  } catch (e) {
    if (e instanceof ApiError && e.status === 404) notFound();
    throw e;
@@ -1,11 +1,12 @@
 "use client";
-import { ExtraFieldInput, isExtraFieldType } from "@/components/shared/FormFieldExtras";
 import React, { Suspense } from "react";
 import { Navbar } from "@/components/layout/Navbar";
 import { Footer } from "@/components/layout/Footer";
 import { useSearchParams, useRouter } from "next/navigation";
 import { useAuth } from "@/hooks/useAuth";
 import { CheckCircle2 } 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'|'rating'|'multiple_choice'; label: string; isRequired?: boolean; helpText?: string|null; options?: unknown };

@@ -20,37 +21,32 @@ function RegistrationSuccessContent() {
    return isNaN(n) ? 0 : n;
  }, [fallbackTotalParam]);

-  const [reg, setReg] = React.useState<any | null>(null);
+  // Optional donation picked on the register form; added to the Yoco checkout as its own line.
+  const donationParam = search.get("donation");
+  const donation = React.useMemo(() => {
+    const n = donationParam ? Number(donationParam) : 0;
+    return isNaN(n) || n < 15 ? 0 : Math.round(n * 100) / 100;
+  }, [donationParam]);
+
+  const [reg, setReg] = React.useState<Registration | null>(null);
  const [form, setForm] = React.useState<{ isRequired: boolean; fields: FormField[] } | null>(null);
-  const [formsData, setFormsData] = React.useState<Record<number, Record<string, string>>>({});
-  const [loading, setLoading] = React.useState(false);
  const [error, setError] = React.useState<string | null>(null);
-  const [info, setInfo] = React.useState<string | null>(null);
  const [payLoading, setPayLoading] = React.useState(false);

  React.useEffect(() => {
    (async () => {
      setError(null);
-      setInfo(null);
      if (!registrationId) return;
      try {
-        setLoading(true);
        // Try to fetch registration and event form
-        const r = token ? await (await import('@/lib/api')).apiFetch(`/api/registrations/${encodeURIComponent(registrationId)}`, { authToken: token }) : null;
+        const r = token ? await (await import('@/lib/api')).apiFetch<Registration>(`/api/registrations/${encodeURIComponent(registrationId)}`, { authToken: token }) : null;
        if (r) {
          setReg(r);
-          const ev = await (await import('@/lib/api')).apiFetch(`/api/events/${encodeURIComponent(r.eventId)}`);
+          const ev = await (await import('@/lib/api')).apiFetch<{ form?: { isRequired: boolean; fields: FormField[] } | null }>(`/api/events/${encodeURIComponent(r.eventId)}`);
          if (ev?.form) setForm(ev.form);
-          // Load any saved draft
-          try {
-            const d = await (await import('@/lib/api')).apiFetch(`/api/registrations/${encodeURIComponent(registrationId)}/forms/draft`, { authToken: token || undefined });
-            if (d && d.data && typeof d.data === 'object') setFormsData(d.data);
-          } catch {}
        }
-      } catch (e: any) {
-        setError(e?.message || 'Failed to load details');
-      } finally {
-        setLoading(false);
+      } catch (e) {
+        setError(errorMessage(e) || 'Failed to load details');
      }
    })();
  }, [registrationId, token]);
@@ -61,7 +57,7 @@ function RegistrationSuccessContent() {
    // multiple early-bird prices) — fall back to the old client-side estimate otherwise.
    if (reg.totalDueComputed !== null && reg.totalDueComputed !== undefined) return reg.totalDueComputed;
    try {
-      return (reg.registrationOptions || []).reduce((s: number, ro: any) => {
+      return (reg.registrationOptions || []).reduce((s, ro) => {
        const unit = (ro.priceSnapshot !== null && ro.priceSnapshot !== undefined)
          ? Number(ro.priceSnapshot)
          : (ro.variant?.price ?? ro.eventOption?.price ?? 0);
@@ -92,21 +88,21 @@ function RegistrationSuccessContent() {
      setError(null);
      setPayLoading(true);
      const { createFullPaymentCheckout } = await import('@/lib/api');
-      const res = await createFullPaymentCheckout(token, registrationId);
+      const res = await createFullPaymentCheckout(token, registrationId, donation);
      if (res.priceUpdated) {
        // Early-bird price changed since registration — surface the new total and
        // reload the registration so the displayed totalDue reflects it, instead of redirecting.
        setError(`${res.message || 'Pricing has changed.'} New total: R ${(res.newTotal ?? 0).toFixed(2)}. Please try again.`);
        try {
-          const r = await (await import('@/lib/api')).apiFetch(`/api/registrations/${encodeURIComponent(registrationId)}`, { authToken: token });
+          const r = await (await import('@/lib/api')).apiFetch<Registration>(`/api/registrations/${encodeURIComponent(registrationId)}`, { authToken: token });
          if (r) setReg(r);
        } catch {}
        return;
      }
      if (!res.redirectUrl) { setError('Failed to create checkout'); return; }
      window.location.href = res.redirectUrl;
-    } catch (e: any) {
-      setError(e?.message || 'Failed to create checkout');
+    } catch (e) {
+      setError(errorMessage(e) || 'Failed to create checkout');
    } finally {
      setPayLoading(false);
    }
@@ -134,7 +130,14 @@ function RegistrationSuccessContent() {
              <div className="text-sm">Please complete one form per main ticket to receive tickets. You can also do this later from your dashboard, but tickets cannot be generated until completed.</div>
            </div>
          ) : (totalDue > 0 || (!reg && fallbackTotalDue > 0)) ? (
-            <p className="text-gray-700 mb-6">Would you like to pay with Yoco now?</p>
+            <>
+              {donation > 0 && (
+                <p className="text-gray-700 mb-2">
+                  Thank you for adding a donation of <strong>R{donation.toFixed(2)}</strong>. It&apos;s included when you pay now.
+                </p>
+              )}
+              <p className="text-gray-700 mb-6">Would you like to pay with Yoco now?</p>
+            </>
          ) : null}

          <div className="flex flex-col sm:flex-row gap-3 mt-4">
@@ -161,119 +164,6 @@ function RegistrationSuccessContent() {
  );
 }

-function AttendeeForms({ reg, form, formsData, setFormsData, setError, setInfo }: { reg: any; form: { isRequired: boolean; fields: FormField[] }; formsData: Record<number, Record<string,string>>; setFormsData: any; setError: any; setInfo: any; }) {
-  const { token } = useAuth();
-  const registrationId = reg?.id;
-  const mainTickets = (reg?.registrationOptions || []).filter((o: any) => o?.eventOption?.isMainTicket).reduce((s: number, o: any) => s + (o.quantity || 0), 0);
-  const count = Math.max(0, mainTickets);
-
-  const canSubmit = React.useMemo(() => {
-    if (!form || count <= 0) return false;
-    const reqFields = (form.fields || [])
-      .filter(f => !!f.isRequired && f.type !== 'statement' && f.type !== 'paragraph')
-      .map(f => f.id);
-    for (let i = 0; i < count; i++) {
-      const data = formsData[i] || {};
-      for (const fid of reqFields) {
-        const v = data[fid];
-        if (v === undefined || v === null || String(v).trim() === '') {
-          return false;
-        }
-      }
-    }
-    return true;
-  }, [form, formsData, count]);
-
-  const update = (idx: number, fieldId: string, value: string) => {
-    setFormsData((prev: any) => ({ ...prev, [idx]: { ...(prev[idx]||{}), [fieldId]: value } }));
-  };
-
-  const submit = async () => {
-    try {
-      setError(null); setInfo(null);
-      if (!token) { setError('Please login to submit forms.'); return; }
-      const payload = [] as any[];
-      for (let i = 0; i < count; i++) {
-        payload.push({ answers: formsData[i] || {} });
-      }
-      await (await import('@/lib/api')).apiFetch(`/api/registrations/${encodeURIComponent(registrationId)}/forms/responses`, {
-        method: 'POST',
-        authToken: token,
-        body: { responses: payload }
-      });
-      setInfo('Attendee forms submitted. You will receive tickets once payment is confirmed.');
-    } catch (e: any) {
-      setError(e?.message || 'Failed to submit forms');
-    }
-  };
-
-  const saveDraft = async () => {
-    try {
-      setError(null); setInfo(null);
-      if (!token) { setError('Please login to save drafts.'); return; }
-      await (await import('@/lib/api')).apiFetch(`/api/registrations/${encodeURIComponent(registrationId)}/forms/draft`, {
-        method: 'PUT',
-        authToken: token,
-        body: { data: formsData }
-      });
-      setInfo('Draft saved. You can finish later from your dashboard.');
-    } catch (e: any) {
-      setError(e?.message || 'Failed to save draft');
-    }
-  };
-
-  if (!form || !Array.isArray(form.fields) || count === 0) return null;
-
-  return (
-    <div className="border rounded p-3 bg-gray-50 mb-4">
-      <div className="text-sm font-medium mb-2">Attendee details</div>
-      <div className="space-y-4">
-        {Array.from({ length: count }, (_, idx) => (
-          <div key={idx} className="bg-white border rounded p-3">
-            <div className="font-medium mb-2">Attendee {idx + 1}</div>
-            {form.fields.map((f) => (
-              <div key={f.id} className="mb-2">
-                {f.type === 'statement' ? (
-                  <div className="text-sm text-gray-700 whitespace-pre-line">{f.label}</div>
-                ) : f.type === 'paragraph' ? (
-                  <div className="text-sm text-gray-700">
-                    {f.label && <div className="font-medium mb-1 whitespace-pre-line">{f.label}</div>}
-                    {f.helpText && <div className="whitespace-pre-line">{f.helpText}</div>}
-                  </div>
-                ) : (
-                  <>
-                    <label className="block text-xs text-gray-600 mb-1">{f.label}{f.isRequired ? ' *' : ''}</label>
-                    {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>
-                        <option value="no">No</option>
-                      </select>
-                    ) : f.type === 'date' ? (
-                      <input type="date" className="border rounded px-2 py-1 text-sm" value={formsData[idx]?.[f.id] || ''} onChange={e => update(idx, f.id, e.target.value)} />
-                    ) : f.type === 'numeric' ? (
-                      <input type="number" className="border rounded px-2 py-1 text-sm" value={formsData[idx]?.[f.id] || ''} onChange={e => update(idx, f.id, e.target.value)} />
-                    ) : (
-                      <input type="text" className="border rounded px-2 py-1 text-sm w-full" value={formsData[idx]?.[f.id] || ''} onChange={e => update(idx, f.id, e.target.value)} />
-                    )}
-                    {f.helpText && <div className="text-xs text-gray-500 mt-1">{f.helpText}</div>}
-                  </>
-                )}
-              </div>
-            ))}
-          </div>
-        ))}
-      </div>
-      <div className="mt-3 flex gap-2">
-        <button className="px-3 py-1.5 text-sm rounded bg-brand-600 text-white hover:bg-brand-700 disabled:opacity-50" disabled={!canSubmit} onClick={submit}>Submit attendee forms</button>
-        <button className="px-3 py-1.5 text-sm rounded bg-gray-100 hover:bg-gray-200" onClick={saveDraft}>Save for later</button>
-      </div>
-    </div>
-  );
-}
-
 export default function RegistrationSuccessPage() {
  return (
    <Suspense fallback={<div className="p-6">Loading...</div>}>
@@ -5,6 +5,7 @@ import { Footer } from "@/components/layout/Footer";
 import { apiFetch } from "@/lib/api";
 import { useSearchParams, useRouter } from "next/navigation";
 import { KeyRound } from "lucide-react";
+import { errorMessage } from "@/lib/utils";

 function ResetPasswordContent() {
  const search = useSearchParams();
@@ -26,8 +27,8 @@ function ResetPasswordContent() {
      await apiFetch("/api/users/reset", { method: "POST", body: { token, password } });
      setStatus("Your password has been reset. You can now log in.");
      setTimeout(() => router.push("/login"), 1500);
-    } catch (err: any) {
-      setStatus(err?.message || "Reset failed");
+    } catch (err) {
+      setStatus(errorMessage(err) || "Reset failed");
    } finally {
      setLoading(false);
    }
@@ -3,9 +3,12 @@ import { ExtraFieldInput, isExtraFieldType } from "@/components/shared/FormField

 import React, { useCallback, useEffect, useMemo, useRef, useState } from "react";
 import { apiFetch } from "@/lib/api";
-import { TwoFactorChallenge, isTwoFactorChallenge } from "@/lib/auth";
+import { AuthResponse, TwoFactorChallenge, isTwoFactorChallenge } from "@/lib/auth";
 import { CouponCodeField, AppliedCoupon } from "@/components/shared/CouponCodeField";
+import { BundleBuilder, BundleOffers, BundleSavings, useBundleQuote } from "@/components/shared/BundleDeals";
 import { AttendeeNamesEditor, AttendeeEntries, TicketDelivery, attendeesPayload, consentDetailsMissing } from "@/components/shared/AttendeeNamesEditor";
+import { errorMessage } from "@/lib/utils";
+import type { PublicBundle, Registration } from "@/types";

 // ─── Types ────────────────────────────────────────────────────────────────────
 type EarlyBirdTier = { deadline: string; price: number; order?: number; variantId?: string | null };
@@ -25,7 +28,7 @@ type FormField = {
  isRequired: boolean;
  order: number;
  helpText?: string | null;
-  options?: any;
+  options?: unknown;
 };
 type EventForm = {
  id: string;
@@ -141,6 +144,7 @@ export default function SelfServicePage() {
  const [setupError, setSetupError] = useState<string | null>(null);
  const [supervisorToken, setSupervisorToken] = useState<string | null>(null);
  const [kioskCoupon, setKioskCoupon] = useState<AppliedCoupon | null>(null);
+  const [kioskBundles, setKioskBundles] = useState<PublicBundle[]>([]);
  const [namingOthers, setNamingOthers] = useState(false);
  const [attendeeEntries, setAttendeeEntries] = useState<AttendeeEntries>({});
  const [delivery, setDelivery] = useState<TicketDelivery>("payer");
@@ -187,7 +191,6 @@ export default function SelfServicePage() {

  // ── Event form (attendee form) state ────────────────────────────
  const [currentRegistrationId, setCurrentRegistrationId] = useState<string | null>(null);
-  const [currentUserId, setCurrentUserId] = useState<string | null>(null);
  const [currentTicketIndex, setCurrentTicketIndex] = useState(0);
  const [allFormAnswers, setAllFormAnswers] = useState<Record<string, string>[]>([]);
  const [currentTicketAnswers, setCurrentTicketAnswers] = useState<Record<string, string>>({});
@@ -216,6 +219,22 @@ export default function SelfServicePage() {
    }, 0);
  }, [selectedEvent, quantities]);

+  // The events list doesn't carry bundle deals; the single-event response does.
+  useEffect(() => {
+    if (!selectedEventId) { setKioskBundles([]); return; }
+    let cancelled = false;
+    apiFetch<{ bundles?: PublicBundle[] }>(`/api/events/${selectedEventId}`, { authToken: supervisorToken || undefined })
+      .then(ev => { if (!cancelled) setKioskBundles(ev?.bundles || []); })
+      .catch(() => { if (!cancelled) setKioskBundles([]); });
+    return () => { cancelled = true; };
+  }, [selectedEventId, supervisorToken]);
+
+  const kioskBasket = useMemo(() => Object.entries(quantities).map(([key, quantity]) => {
+    const [eventOptionId, variantId] = key.split("::");
+    return { eventOptionId, quantity, variantId: variantId || null };
+  }), [quantities]);
+  const bundleQuote = useBundleQuote({ eventId: selectedEventId || "", basket: kioskBasket, token: supervisorToken, forUserId: matchedAccount?.id ?? null });
+
  // Does the selected event have a required form?
  const eventHasRequiredForm = useMemo(() => {
    return !!(selectedEvent?.form?.isRequired && (selectedEvent.form.fields || []).some(f => f.type !== 'statement'));
@@ -294,11 +313,11 @@ export default function SelfServicePage() {
      // Second pass for accounts with two-factor on: exchange the code that was
      // sent after the password step. The kiosk never asks to be remembered.
      const data = setupChallenge
-        ? await apiFetch("/api/users/login/2fa", {
+        ? await apiFetch<AuthResponse>("/api/users/login/2fa", {
            method: "POST",
            body: { challengeId: setupChallenge.challengeId, code: setupCode, rememberDevice: false },
          })
-        : await apiFetch("/api/users/login", {
+        : await apiFetch<AuthResponse | TwoFactorChallenge>("/api/users/login", {
            method: "POST",
            body: { email: setupEmail, password: setupPassword },
          });
@@ -319,8 +338,8 @@ export default function SelfServicePage() {
      setSetupCode("");
      setSupervisorToken(data.token);
      await loadEvents(data.token);
-    } catch (err: any) {
-      setSetupError(err?.message || "Login failed. Please check your credentials.");
+    } catch (err) {
+      setSetupError(errorMessage(err) || "Login failed. Please check your credentials.");
    } finally {
      setSetupLoading(false);
    }
@@ -362,8 +381,8 @@ export default function SelfServicePage() {
      setScreen("setup");
      setSelectedEventId("");
      resetForm();
-    } catch (err: any) {
-      setChangeError(err?.message || "Incorrect password.");
+    } catch (err) {
+      setChangeError(errorMessage(err) || "Incorrect password.");
    } finally {
      setChangeLoading(false);
    }
@@ -405,7 +424,15 @@ export default function SelfServicePage() {
  async function handleRegister() {
    setFormLoading(true);
    try {
-      const payload: any = {
+      const user: { name: string; email?: string; phoneNumber?: string; password?: string } = {
+        name: visitorName.trim(),
+        ...(visitorEmail.trim() ? { email: visitorEmail.trim() } : {}),
+        ...(visitorPhone.trim() ? { phoneNumber: visitorPhone.trim() } : {}),
+      };
+      if (createAccount && visitorPassword) {
+        user.password = visitorPassword;
+      }
+      const payload: Record<string, unknown> = {
        eventId: selectedEventId,
        options: Object.entries(quantities)
          .filter(([, qty]) => qty > 0)
@@ -413,11 +440,7 @@ export default function SelfServicePage() {
            const [eventOptionId, variantId] = key.split("::");
            return { eventOptionId, quantity, ...(variantId ? { variantId } : {}) };
          }),
-        user: {
-          name: visitorName.trim(),
-          ...(visitorEmail.trim() ? { email: visitorEmail.trim() } : {}),
-          ...(visitorPhone.trim() ? { phoneNumber: visitorPhone.trim() } : {}),
-        },
+        user,
        // If the visitor declined to create an account, don't push an unsolicited
        // activation email/WhatsApp at them afterward.
        skipActivationNotice: !createAccount,
@@ -431,18 +454,13 @@ export default function SelfServicePage() {
        payload.attendees = kioskNames;
        payload.ticketDelivery = delivery;
      }
-      if (createAccount && visitorPassword) {
-        payload.user.password = visitorPassword;
-      }
-
-      const result: any = await apiFetch("/api/registrations/manual", {
+      const result = await apiFetch<Registration>("/api/registrations/manual", {
        method: "POST",
        body: payload,
        authToken: supervisorToken,
      });

      setCurrentRegistrationId(result?.id || null);
-      setCurrentUserId(result?.userId || null);
      setRegistrationIsFree(result?.status === "paid" || (result?.totalDueComputed ?? total) === 0);
      setConfirmationName(visitorName.trim());

@@ -457,8 +475,8 @@ export default function SelfServicePage() {
        setScreen("confirmation");
        startCountdown();
      }
-    } catch (err: any) {
-      setFormError(err?.message || "Registration failed. Please try again.");
+    } catch (err) {
+      setFormError(errorMessage(err) || "Registration failed. Please try again.");
    } finally {
      setFormLoading(false);
    }
@@ -505,8 +523,8 @@ export default function SelfServicePage() {

      setScreen("confirmation");
      startCountdown();
-    } catch (err: any) {
-      setFormSubmitError(err?.message || "Form submission failed. Please try again.");
+    } catch (err) {
+      setFormSubmitError(errorMessage(err) || "Form submission failed. Please try again.");
    } finally {
      setFormSubmitLoading(false);
    }
@@ -562,7 +580,6 @@ export default function SelfServicePage() {
    setLookupMessage(null);
    setFormError(null);
    setCurrentRegistrationId(null);
-    setCurrentUserId(null);
    setCurrentTicketIndex(0);
    setAllFormAnswers([]);
    setCurrentTicketAnswers({});
@@ -940,6 +957,7 @@ export default function SelfServicePage() {
              {(selectedEvent.eventOptions || []).length > 0 && (
                <div>
                  <label className="block text-sm font-medium text-gray-700 mb-3">Ticket Options</label>
+                  <BundleOffers bundles={kioskBundles} className="mb-3" />
                  <div className="space-y-3">
                    {(selectedEvent.eventOptions || []).map((opt) => {
                      const hasVariants = (opt.variants || []).length > 0;
@@ -1015,6 +1033,13 @@ export default function SelfServicePage() {
                      );
                    })}
                  </div>
+                  <BundleBuilder
+                    className="mt-3"
+                    bundles={kioskBundles}
+                    options={selectedEvent.eventOptions || []}
+                    qty={(o, v) => quantities[v ? `${o}::${v}` : o] || 0}
+                    onSetQuantity={(o, v, n) => setQuantities(q => ({ ...q, [v ? `${o}::${v}` : o]: n }))}
+                  />
                  {(selectedEvent?.allowNamedAttendees || selectedEvent?.requiresParentalConsent) && (
                    <div className="mt-4">
                      <AttendeeNamesEditor
@@ -1035,10 +1060,7 @@ export default function SelfServicePage() {
                    <div className="mt-4">
                      <CouponCodeField
                        eventId={selectedEventId}
-                        basket={Object.entries(quantities).map(([key, quantity]) => {
-                          const [eventOptionId, variantId] = key.split("::");
-                          return { eventOptionId, quantity, variantId: variantId || null };
-                        })}
+                        basket={kioskBasket}
                        token={supervisorToken}
                        forUserId={matchedAccount?.id ?? null}
                        applied={kioskCoupon}
@@ -1048,10 +1070,11 @@ export default function SelfServicePage() {
                  )}
                  {total > 0 && (
                    <div className="mt-3 text-right text-base font-semibold text-gray-800">
-                      {kioskCoupon && kioskCoupon.discount > 0 && (
-                        <span className="mr-2 text-sm font-normal text-gray-500 line-through">{fmtCurrency(kioskCoupon.subtotal)}</span>
+                      <BundleSavings applications={bundleQuote?.bundles} className="flex flex-col items-end font-normal" />
+                      {((kioskCoupon && kioskCoupon.discount > 0) || bundleQuote) && (
+                        <span className="mr-2 text-sm font-normal text-gray-500 line-through">{fmtCurrency(kioskCoupon?.subtotal ?? bundleQuote?.subtotal ?? total)}</span>
                      )}
-                      Total: {fmtCurrency(kioskCoupon ? kioskCoupon.total : total)}
+                      Total: {fmtCurrency(kioskCoupon ? kioskCoupon.total : bundleQuote ? bundleQuote.total : total)}
                    </div>
                  )}
                </div>
@@ -5,6 +5,7 @@ import { useAuth } from "@/hooks/useAuth";
 import { useRouter } from "next/navigation";
 import { apiFetch } from "@/lib/api";
 import { Megaphone } from "lucide-react";
+import { errorMessage } from "@/lib/utils";

 type BannerType = "info" | "warning" | "success" | "danger";

@@ -37,7 +38,7 @@ export default function SetBannerPage() {

  // Load current banner
  useEffect(() => {
-    apiFetch<any>("/api/banner")
+    apiFetch<{ message?: string; type?: BannerType; liveFrom?: string | null; liveTill?: string | null } | null>("/api/banner")
      .then(b => {
        if (!b) return;
        setMessage(b.message || "");
@@ -75,8 +76,8 @@ export default function SetBannerPage() {
        },
      });
      setStatus("Banner saved.");
-    } catch (e: any) {
-      setError(e?.message || "Failed to save banner.");
+    } catch (e) {
+      setError(errorMessage(e) || "Failed to save banner.");
    } finally {
      setBusy(false);
    }
@@ -98,8 +99,8 @@ export default function SetBannerPage() {
      setLiveFrom("");
      setLiveTill("");
      setStatus("Banner cleared.");
-    } catch (e: any) {
-      setError(e?.message || "Failed to clear banner.");
+    } catch (e) {
+      setError(errorMessage(e) || "Failed to clear banner.");
    } finally {
      setBusy(false);
    }
@@ -6,6 +6,7 @@ import { apiFetch, API_BASE } from "@/lib/api";
 import { ColorPickerField } from "@/components/admin/ColorPickerField";
 import { BrandingPreviewPanel } from "@/components/admin/BrandingPreviewPanel";
 import { extractDominantColors } from "@/lib/extractColors";
+import { errorMessage } from "@/lib/utils";

 type Step = 1 | 2 | 3 | 4 | 5 | 6;

@@ -100,7 +101,7 @@ export default function SetupPage() {
    apiFetch<{ needsSetup: boolean }>("/api/settings/needs-setup")
      .then((d) => { if (!d?.needsSetup) router.replace("/login"); })
      .catch(() => {});
-  }, []);
+  }, [router]);

  const next = () => setStep((s) => Math.min(s + 1, 6) as Step);
  const back = () => { setError(null); setStep((s) => Math.max(s - 1, 1) as Step); };
@@ -144,8 +145,8 @@ export default function SetupPage() {
      });
      setSetupToken(res.token);
      next();
-    } catch (e: any) {
-      setError(e?.message || "Failed to create admin account. Please try again.");
+    } catch (e) {
+      setError(errorMessage(e) || "Failed to create admin account. Please try again.");
    } finally {
      setLoading(false);
    }
@@ -173,8 +174,8 @@ export default function SetupPage() {
        },
      });
      setSmtpTestResult({ ok: true, message: res.message || "Connection successful." });
-    } catch (e: any) {
-      setSmtpTestResult({ ok: false, message: e?.message || "Connection failed." });
+    } catch (e) {
+      setSmtpTestResult({ ok: false, message: errorMessage(e) || "Connection failed." });
    } finally {
      setSmtpTesting(false);
    }
@@ -260,8 +261,8 @@ export default function SetupPage() {
      });

      next(); // → step 6 (done)
-    } catch (e: any) {
-      setError(e?.message || "Setup failed. Please try again.");
+    } catch (e) {
+      setError(errorMessage(e) || "Setup failed. Please try again.");
    } finally {
      setLoading(false);
    }
@@ -386,6 +387,8 @@ export default function SetupPage() {
                <Field label="Logo image (optional)" hint="PNG, JPG, SVG or WebP, max 2 MB. If skipped, a default logo is used.">
                  <input type="file" accept="image/*" onChange={handleLogoChange} className="text-sm" />
                  {logoPreview && (
+                    // Local file preview (data: URL) — nothing for next/image to optimize.
+                    // eslint-disable-next-line @next/next/no-img-element
                    <img src={logoPreview} alt="Preview" className="mt-2 h-16 object-contain rounded border" />
                  )}
                  {suggestedColors.length > 0 && (
@@ -6,6 +6,7 @@ import { Footer } from "@/components/layout/Footer";
 import { apiFetch } from "@/lib/api";
 import { formatDate } from "@/lib/date";
 import { Ticket, CheckCircle2, XCircle } from "lucide-react";
+import { errorMessage } from "@/lib/utils";

 type Offer = {
  status: "pending" | "accepted" | "declined" | "cancelled" | "expired";
@@ -46,8 +47,8 @@ export default function TransferOfferPage() {
    try {
      const r = await apiFetch<{ message: string }>(`/api/tickets/transfer-offer/${encodeURIComponent(token!)}/${action}`, { method: "POST" });
      setDone({ ok: action === "accept", message: r.message });
-    } catch (e: any) {
-      setError(e?.message || "Something went wrong");
+    } catch (e) {
+      setError(errorMessage(e) || "Something went wrong");
    } finally {
      setBusy(false);
    }
@@ -5,6 +5,7 @@ import { useAuth } from "@/hooks/useAuth";
 import { apiFetch, API_BASE } from "@/lib/api";
 import { useDismissingState } from "@/hooks/useDismissingState";
 import { DatabaseBackup, Download } from "lucide-react";
+import { errorMessage } from "@/lib/utils";

 interface BackupEntry {
  filename: string;
@@ -38,12 +39,12 @@ export function BackupsTab({ active }: { active: boolean }) {
      ]);
      setBackups(list || []);
      setRetainCount(allSettings?.backup_retain_count || "14");
-    } catch (e: any) {
-      setMessage({ type: "err", text: e?.message || "Failed to load backups" });
+    } catch (e) {
+      setMessage({ type: "err", text: errorMessage(e) || "Failed to load backups" });
    } finally {
      setLoading(false);
    }
-  }, [token]);
+  }, [token, setMessage]);

  const saveRetainCount = async () => {
    if (!token) return;
@@ -51,8 +52,8 @@ export function BackupsTab({ active }: { active: boolean }) {
    try {
      await apiFetch("/api/settings", { method: "PUT", authToken: token, body: { backup_retain_count: retainCount } });
      setMessage({ type: "ok", text: "Retention setting saved." });
-    } catch (e: any) {
-      setMessage({ type: "err", text: e?.message || "Failed to save retention setting" });
+    } catch (e) {
+      setMessage({ type: "err", text: errorMessage(e) || "Failed to save retention setting" });
    } finally {
      setSavingRetain(false);
    }
@@ -68,8 +69,8 @@ export function BackupsTab({ active }: { active: boolean }) {
      const res = await apiFetch<{ filename: string }>("/api/backups/run", { method: "POST", authToken: token });
      setMessage({ type: "ok", text: `Backup created: ${res.filename}` });
      await load();
-    } catch (e: any) {
-      setMessage({ type: "err", text: e?.message || "Backup failed" });
+    } catch (e) {
+      setMessage({ type: "err", text: errorMessage(e) || "Backup failed" });
    } finally {
      setRunning(false);
    }
@@ -5,6 +5,7 @@ import { useAuth } from "@/hooks/useAuth";
 import { apiFetch } from "@/lib/api";
 import { useDismissingState } from "@/hooks/useDismissingState";
 import { Copy, CreditCard, KeyRound, Trash2, Webhook } from "lucide-react";
+import { errorMessage } from "@/lib/utils";

 type Source = "db" | "env" | "none";

@@ -99,9 +100,9 @@ export function YocoTab({ active }: { active: boolean }) {
      const res = await apiFetch<{ webhooks: YocoWebhook[] }>("/api/yoco/webhooks", { authToken: token });
      setHooks(res.webhooks || []);
      setHooksError(null);
-    } catch (e: any) {
+    } catch (e) {
      setHooks([]);
-      setHooksError(e?.message || "Could not load webhooks from Yoco");
+      setHooksError(errorMessage(e) || "Could not load webhooks from Yoco");
    }
  }, [token]);

@@ -114,8 +115,8 @@ export function YocoTab({ active }: { active: boolean }) {
      setHookUrl((prev) => prev || c.webhookUrl);
      if (c.secretKeySource !== "none") await loadHooks();
      else { setHooks([]); setHooksError(null); }
-    } catch (e: any) {
-      setMessage({ type: "err", text: e?.message || "Failed to load Yoco settings" });
+    } catch (e) {
+      setMessage({ type: "err", text: errorMessage(e) || "Failed to load Yoco settings" });
    } finally {
      setLoading(false);
    }
@@ -130,8 +131,8 @@ export function YocoTab({ active }: { active: boolean }) {
      const text = await fn();
      setMessage({ type: "ok", text });
      await load();
-    } catch (e: any) {
-      setMessage({ type: "err", text: e?.message || "Something went wrong" });
+    } catch (e) {
+      setMessage({ type: "err", text: errorMessage(e) || "Something went wrong" });
    } finally {
      setBusy(null);
    }
@@ -5,6 +5,7 @@ import { useAuth } from "@/hooks/useAuth";
 import { AuthUser, TwoFactorChallenge, isTwoFactorChallenge } from "@/lib/auth";
 import { useSearchParams } from "next/navigation";
 import Link from "next/link";
+import { errorMessage } from "@/lib/utils";

 // Matches the backend's minimum gap between code sends.
 const RESEND_COOLDOWN_SECONDS = 60;
@@ -42,24 +43,16 @@ export function LoginForm() {
    window.location.href = hasExplicitRedirect ? redirectTo : `/dashboard/${loggedInUser.role || "user"}`;
  };

-  const getErrorMessage = (err: any) => {
-    if (!err) return "Login failed";
-
-    // If it's already a normal Error
-    if (err.message && typeof err.message === "string") {
-      // Handle case where message is accidentally JSON string
-      try {
-        const parsed = JSON.parse(err.message);
-        return parsed.message || err.message;
-      } catch {
-        return err.message;
-      }
+  const getErrorMessage = (err: unknown) => {
+    const msg = errorMessage(err);
+    if (!msg) return "Login failed";
+    // Handle case where message is accidentally a JSON string
+    try {
+      const parsed = JSON.parse(msg);
+      return parsed?.message || msg;
+    } catch {
+      return msg;
    }
-
-    // If API response object was thrown directly
-    if (err.message) return err.message;
-
-    return "Login failed";
  };

  const onSubmit = async (e: React.FormEvent) => {
@@ -77,7 +70,7 @@ export function LoginForm() {
        return;
      }
      goToDashboard(result);
-    } catch (err: any) {
+    } catch (err) {
      setError(getErrorMessage(err) || "Login failed. Please try again.");
    } finally {
      setLoading(false);
@@ -92,7 +85,7 @@ export function LoginForm() {

    try {
      goToDashboard(await verifyTwoFactor(challenge.challengeId, code, rememberDevice));
-    } catch (err: any) {
+    } catch (err) {
      setError(getErrorMessage(err) || "Verification failed. Please try again.");
    } finally {
      setLoading(false);
@@ -108,7 +101,7 @@ export function LoginForm() {
      setChallenge({ ...next, enrolling: challenge.enrolling });
      setCode("");
      setResendIn(RESEND_COOLDOWN_SECONDS);
-    } catch (err: any) {
+    } catch (err) {
      setError(getErrorMessage(err) || "Couldn't send a new code. Please try again.");
    }
  };
@@ -225,19 +218,19 @@ export function LoginForm() {
            </button>
          </div>
          <div className="mt-1">
-            <a
+            <Link
                href="/forgot-password"
                className="text-xs text-brand-600 hover:underline"
            >
              Forgot your password?
-            </a>
+            </Link>
          </div>
          <div className="mt-1">
            <a
                href={registerHref}
                className="text-xs text-brand-600 hover:underline"
            >
-              Don't have an account? Sign up here.
+              Don&apos;t have an account? Sign up here.
            </a>
          </div>
        </div>
@@ -5,6 +5,7 @@ import { useAuth } from "@/hooks/useAuth";
 import { useSearchParams } from "next/navigation";
 import Link from "next/link";
 import { isValidZAPhone } from "@/lib/phone";
+import { errorMessage } from "@/lib/utils";

 export function RegisterForm() {
    const { register } = useAuth();
@@ -23,24 +24,16 @@ export function RegisterForm() {

    const hasValidPhone = isValidZAPhone(phoneNumber);

-    const getErrorMessage = (err: any) => {
-        if (!err) return "Login failed";
-
-        // If it's already a normal Error
-        if (err.message && typeof err.message === "string") {
-            // Handle case where message is accidentally JSON string
-            try {
-                const parsed = JSON.parse(err.message);
-                return parsed.message || err.message;
-            } catch {
-                return err.message;
-            }
+    const getErrorMessage = (err: unknown) => {
+        const msg = errorMessage(err);
+        if (!msg) return "Registration failed. Please try again.";
+        // Handle case where message is accidentally a JSON string
+        try {
+            const parsed = JSON.parse(msg);
+            return parsed?.message || msg;
+        } catch {
+            return msg;
        }
-
-        // If API response object was thrown directly
-        if (err.message) return err.message;
-
-        return "Registration failed. Please try again.";
    };

    const onSubmit = async (e: React.FormEvent) => {
@@ -62,7 +55,7 @@ export function RegisterForm() {
                notificationPreference: hasValidPhone ? notificationPreference : "email",
            });
            window.location.href = redirectTo;
-        } catch (err: any) {
+        } catch (err) {
            setError(getErrorMessage(err) || "Registration failed. Please try again.");
        } finally {
            setLoading(false);
@@ -4,8 +4,9 @@ import React, { useState } from "react";
 import { ListPlus, X } from "lucide-react";
 import { apiFetch, ApiError } from "@/lib/api";
 import { useAuth } from "@/hooks/useAuth";
+import type { WaitlistLine } from "@/lib/waitlist";

-export type WaitlistLine = { eventOptionId: string; variantId?: string | null; label: string };
+export type { WaitlistLine };

 const inputCls = "w-full border rounded-lg px-3 py-2 text-sm focus:outline-none focus:ring-2 focus:ring-brand-400";

@@ -125,21 +126,3 @@ export function JoinWaitlistButton({ eventId, lines, guestsAllowed, initialLine,
 function keyOf(l?: WaitlistLine) {
  return l ? `${l.eventOptionId}::${l.variantId || ""}` : "";
 }
-
-/** The sold-out lines of an event, for the waitlist button. */
-export function soldOutLines(options: { id: string; name: string; stockLimit?: number; availableCount?: number | null; variants?: { id: string; name: string; stockLimit?: number; availableCount?: number | null }[] | null }[]): WaitlistLine[] {
-  const out: WaitlistLine[] = [];
-  for (const o of options || []) {
-    const optOut = (o.stockLimit ?? 0) > 0 && o.availableCount !== undefined && o.availableCount !== null && o.availableCount <= 0;
-    const variants = o.variants || [];
-    if (variants.length > 0) {
-      for (const v of variants) {
-        const vOut = (v.stockLimit ?? 0) > 0 && v.availableCount !== undefined && v.availableCount !== null && v.availableCount <= 0;
-        if (optOut || vOut) out.push({ eventOptionId: o.id, variantId: v.id, label: `${o.name} (${v.name})` });
-      }
-    } else if (optOut) {
-      out.push({ eventOptionId: o.id, label: o.name });
-    }
-  }
-  return out;
-}
@@ -4,6 +4,7 @@ import React, { useEffect, useState } from "react";
 import { HeartHandshake, X } from "lucide-react";
 import { apiFetch } from "@/lib/api";
 import { useAuth } from "@/hooks/useAuth";
+import { errorMessage } from "@/lib/utils";

 type Sponsorship = { enabled: boolean; open?: boolean; spotPrice?: number | null; showProgress?: boolean; goalSpots?: number | null; spotsFunded?: number | null; sponsors?: number | null };

@@ -63,8 +64,8 @@ export function SponsorSpot({ eventId, eventTitle }: { eventId: string; eventTit
        },
      });
      window.location.href = res.redirectUrl;
-    } catch (err: any) {
-      setError(err?.message || "Couldn't start the payment");
+    } catch (err) {
+      setError(errorMessage(err) || "Couldn't start the payment");
      setBusy(false);
    }
  };
@@ -3,6 +3,7 @@
 import React, { useRef, useState } from "react";
 import { useAuth } from "@/hooks/useAuth";
 import { apiFetch } from "@/lib/api";
+import { errorMessage } from "@/lib/utils";

 export function FileUploader({ onUploaded }: { onUploaded: (url: string) => void }) {
  const { token } = useAuth();
@@ -23,8 +24,8 @@ export function FileUploader({ onUploaded }: { onUploaded: (url: string) => void
        authToken: token,
      });
      onUploaded(data.url);
-    } catch (e: any) {
-      setError(e?.message || "Upload failed");
+    } catch (e) {
+      setError(errorMessage(e) || "Upload failed");
    } finally {
      setLoading(false);
    }
@@ -3,6 +3,7 @@
 import React, { useCallback, useEffect, useImperativeHandle, useMemo, useRef, useState } from "react";
 import Webcam from "react-webcam";
 import { useQRScanner } from "@/hooks/useQRScanner";
+import { errorMessage } from "@/lib/utils";

 export type QRScannerProps = {
  onResult?: (text: string) => void;
@@ -27,11 +28,10 @@ export const QRScanner = React.forwardRef<QRScannerHandle, QRScannerProps>(
    // Track the underlying HTMLVideoElement from react-webcam reliably
    const [videoEl, setVideoEl] = useState<HTMLVideoElement | null>(null);
    useEffect(() => {
-      let id: any;
+      let id: ReturnType<typeof setInterval> | undefined;
      if (showCam) {
        id = setInterval(() => {
-          const anyCam = webcamRef.current as any;
-          const v: HTMLVideoElement | null = anyCam?.video ?? null;
+          const v = webcamRef.current?.video ?? null;
          if (v) { setVideoEl(v); clearInterval(id); }
        }, 100);
      } else {
@@ -42,13 +42,14 @@ export const QRScanner = React.forwardRef<QRScannerHandle, QRScannerProps>(

    // Beep + cooldown state
    const lastScanRef = useRef<number>(0);
-    const audioCtxRef = useRef<any>(null);
+    const audioCtxRef = useRef<AudioContext | null>(null);
    const playBeep = () => {
      try {
-        const AC = (window as any).AudioContext || (window as any).webkitAudioContext;
+        // Older Safari only has the prefixed constructor.
+        const AC = window.AudioContext || (window as Window & { webkitAudioContext?: typeof AudioContext }).webkitAudioContext;
        if (!AC) return;
        if (!audioCtxRef.current) audioCtxRef.current = new AC();
-        const ctx = audioCtxRef.current as AudioContext;
+        const ctx = audioCtxRef.current;
        const oscillator = ctx.createOscillator();
        const gainNode = ctx.createGain();
        oscillator.type = "sine";
@@ -116,18 +117,20 @@ export const QRScanner = React.forwardRef<QRScannerHandle, QRScannerProps>(
    async function startScan() {
      const host = typeof window !== "undefined" ? window.location.hostname : "";
      const isLocal = host === "localhost" || host === "127.0.0.1";
-      if (!(navigator as any)?.mediaDevices?.getUserMedia) {
+      // mediaDevices is missing on insecure origins and some older browsers.
+      if (typeof navigator === "undefined" || !navigator.mediaDevices?.getUserMedia) {
        setLocalError("Camera API is not available in this browser.");
        return;
      }
      setLocalError(null);
      try {
-        const warmup = await navigator.mediaDevices.getUserMedia({ video: constraints, audio: false } as any);
+        const warmup = await navigator.mediaDevices.getUserMedia({ video: constraints, audio: false });
        try { warmup.getTracks().forEach(t => t.stop()); } catch {}
        setShowCam(true);
        if (!active) toggle();
-      } catch (e: any) {
-        const name = e?.name || e?.message;
+      } catch (e) {
+        // getUserMedia rejects with a DOMException whose `name` says why (NotAllowedError, ...).
+        const name = (e as { name?: string } | null)?.name || errorMessage(e);
        if (name === "NotAllowedError") {
          setLocalError("Camera permission denied. Please enable camera access in your browser settings.");
        } else if (name === "NotFoundError" || name === "OverconstrainedError") {
@@ -171,7 +174,7 @@ export const QRScanner = React.forwardRef<QRScannerHandle, QRScannerProps>(
              className="absolute inset-0 w-full h-full object-cover"
              onUserMedia={() => setLocalError(null)}
              onUserMediaError={(e) => {
-                const name = (e as any)?.name || (e as any)?.message;
+                const name = typeof e === "string" ? e : e.name || e.message;
                const protocol = typeof window !== "undefined" ? window.location.protocol : "";
                const host = typeof window !== "undefined" ? window.location.hostname : "";
                const isLocal = host === "localhost" || host === "127.0.0.1";
@@ -190,7 +193,7 @@ export const QRScanner = React.forwardRef<QRScannerHandle, QRScannerProps>(
            />
          ) : (
            <div className="absolute inset-0 flex items-center justify-center text-white/80 text-sm p-4 text-center">
-              Camera is off. Tap "Scan Ticket" to start using the back camera.
+              Camera is off. Tap &quot;Scan Ticket&quot; to start using the back camera.
            </div>
          )}
        </div>
@@ -42,7 +42,7 @@ export const REPORTS = [
  { key: "funnel", label: "Registration funnel", description: "Event page views → started → submitted → paid, with trend and sources", category: "Registration", icon: Filter, fields: 5 },
  { key: "feedbackSummary", label: "Feedback summary", description: "Post-event feedback: ratings, choices and comments; compare events", category: "Registration", icon: MessageSquareHeart, fields: 4 },
  { key: "medicalList", label: "Medical & emergency list", description: "Youth events: confidential list for leaders (audited)", category: "Registration", icon: HeartPulse, fields: 5 },
-  { key: "discounts", label: "Discounts (coupon codes)", description: "Uses and value given away per code and event", category: "Financial", icon: TicketPercent, fields: 4 },
+  { key: "discounts", label: "Discounts (codes & bundles)", description: "Uses and value given away per code, bundle deal and event", category: "Financial", icon: TicketPercent, fields: 4 },
 ] as const satisfies ReadonlyArray<{
  key: string;
  label: string;
@@ -1,7 +1,8 @@
 "use client";

 import React, { useMemo, useState } from "react";
-import { ArrowLeft, Search } from "lucide-react";
+import { Search } from "lucide-react";
+import { BackLink } from "@/components/shared/BackLink";
 import { REPORTS, REPORT_CATEGORIES, type ReportKey, type ReportCategory } from "./ReportCatalog";
 import EventsDropdown from "./EventsDropdown";

@@ -17,7 +18,7 @@ export default function ReportsShell({
  dateFrom, setDateFrom, dateTo, setDateTo,
  report, setReport,
  onViewReport, busy,
-  onBack,
+  backHref,
 }: {
  events: EventLite[]; isAdmin: boolean;
  showPastEvents: boolean; setShowPastEvents: (v: boolean) => void;
@@ -27,7 +28,7 @@ export default function ReportsShell({
  dateFrom: string; setDateFrom: (v: string) => void; dateTo: string; setDateTo: (v: string) => void;
  report: ReportKey; setReport: (r: ReportKey) => void;
  onViewReport: () => void; busy: boolean;
-  onBack?: () => void;
+  backHref?: string;
 }) {
  const [search, setSearch] = useState("");
  const [category, setCategory] = useState<"All" | ReportCategory>("All");
@@ -67,7 +68,8 @@ export default function ReportsShell({
    <div>
      <div className="flex flex-wrap items-start justify-between gap-3 sm:gap-4 mb-6">
        <div className="min-w-0">
-          <h1 className="text-2xl font-semibold text-gray-900">Reports</h1>
+          {backHref && <BackLink href={backHref} />}
+          <h1 className={"text-2xl font-semibold text-gray-900" + (backHref ? " mt-0.5" : "")}>Reports</h1>
          <p className="text-sm text-gray-500 mt-0.5">View, export, or email operational reports for events.</p>
        </div>
        <div className="flex items-center gap-3 w-full sm:w-auto">
@@ -80,11 +82,6 @@ export default function ReportsShell({
              onChange={e => setSearch(e.target.value)}
            />
          </div>
-          {onBack && (
-            <button type="button" className="shrink-0 flex items-center gap-1.5 px-3 py-2 text-sm rounded-lg bg-gray-100 hover:bg-gray-200 text-gray-800" onClick={onBack}>
-              <ArrowLeft className="w-4 h-4" /> Back
-            </button>
-          )}
        </div>
      </div>

@@ -4,6 +4,7 @@ import React, { useEffect, useState } from "react";
 import { Wifi, WifiOff, CloudUpload, Lock } from "lucide-react";
 import { apiFetch } from "@/lib/api";
 import type { OtherLock } from "./useOfflineScanning";
+import { errorMessage } from "@/lib/utils";

 type Offline = ReturnType<typeof import("./useOfflineScanning").useOfflineScanning>;

@@ -38,8 +39,8 @@ export function OfflineScanPanel({ offline, token, eventId, eventTitle, sectionI
    try {
      const n = await offline.enable(eventId, eventTitle, sectionId, sectionName);
      onInfo(`Offline mode on — ${n} ticket(s) downloaded. You can keep scanning without a connection.`);
-    } catch (e: any) {
-      onError(e?.message || "Couldn't turn on offline mode");
+    } catch (e) {
+      onError(errorMessage(e) || "Couldn't turn on offline mode");
    } finally {
      setBusy(false);
    }
@@ -49,8 +50,8 @@ export function OfflineScanPanel({ offline, token, eventId, eventTitle, sectionI
    try {
      await offline.release();
      onInfo("Offline mode ended and the section is unlocked.");
-    } catch (e: any) {
-      onError(e?.message || "Couldn't end offline mode");
+    } catch (e) {
+      onError(errorMessage(e) || "Couldn't end offline mode");
    } finally {
      setBusy(false);
    }
@@ -59,8 +60,8 @@ export function OfflineScanPanel({ offline, token, eventId, eventTitle, sectionI
    try {
      const r = await offline.sync();
      if (r) onInfo(`Synced ${r.accepted} scan(s)${r.conflicts ? ` — ${r.conflicts} need a supervisor to review` : ""}.`);
-    } catch (e: any) {
-      onError(e?.message || "Sync failed — scans are kept on this device and will retry.");
+    } catch (e) {
+      onError(errorMessage(e) || "Sync failed — scans are kept on this device and will retry.");
    }
  };

--- a/Show More
+++ b/Show More
Author	SHA1	Message	Date
joshuaandClaude Opus 5.5	15b73d5d9e	Merge branch 'feat/unified-ticket-design' Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>	2026-10-22 08:59:24 +02:00
joshuaandClaude Opus 5.5	c74a943709	Bump to 1.30.1 Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>	2026-10-22 08:59:21 +02:00
joshuaandClaude Opus 5.5	28c8fe9715	Use the dashboard ticket design for all tickets The emailed/WhatsApp ticket PDF and the staff and at-the-door print views now match the user dashboard's printed tickets: rounded cards with a light border and soft shadow. Printing goes through a shared helper in lib/ticketPrint.ts, which also escapes names in the print HTML. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>	2026-10-22 08:59:07 +02:00
joshuaandClaude Opus 5.5	2e7bf263ee	Merge branch 'feat/registration-donation' Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>	2026-10-22 08:29:17 +02:00
joshuaandClaude Opus 5.5	377630473d	Bump to 1.30.0 Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>	2026-10-22 08:29:11 +02:00
joshuaandClaude Opus 5.5	286cf09dd8	Add optional donation to registration; fix soldOutLines server crash The register form now offers a "Donation amount" (suggested amounts, custom, or none) under the ticket options. The donation is added to the Yoco checkout as its own line and the webhook records it as a separate donation payment linked to the registration payment. Move soldOutLines() out of the "use client" JoinWaitlistButton module into lib/waitlist.ts so the server-rendered event page can call it. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>	2026-10-22 08:27:47 +02:00
joshuaandClaude Opus 5.5	27c870d46d	Bump to 1.29.1 Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>	2026-10-21 16:36:17 +02:00
joshuaandClaude Opus 5.5	a0c5a6a98c	Merge branch 'feat/coupons-redesign' Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>	2026-10-21 16:36:16 +02:00
joshuaandClaude Opus 5.5	e7969429b6	Redesign the Coupon codes page to match Bundle deals Cards instead of the table, phone-friendly sheets for the form and the uses list, inactive codes hidden by default, and the events picker shows upcoming events only (with search and a Show past events option). Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>	2026-10-21 16:36:16 +02:00
joshuaandClaude Opus 5.5	4a492a8b16	Bump to 1.29.0 Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>	2026-10-21 16:21:05 +02:00
joshuaandClaude Opus 5.5	294fff0b41	Merge branch 'feat/bundle-types' Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>	2026-10-21 16:21:05 +02:00
joshuaandClaude Opus 5.5	f33d04a57c	Add bundle types: pick any, buy X get Y free, group discount Bundles get a kind: exact (as before), mix (any setSize of the qualifying tickets for a set price), free (cheapest freeCount in each set free) and group (setSize or more qualifying tickets at a per-ticket price or % off, applied once). The supervisor page has a type picker, buyers see a one-line description of each deal, and the Complete bundle cards handle every type. Demo: Family Fun Day adds a Lunch for four deal. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>	2026-10-21 16:21:05 +02:00
joshuaandClaude Opus 5.5	6b186b3481	Bump to 1.28.3 Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>	2026-10-21 16:03:22 +02:00
joshuaandClaude Opus 5.5	7ba40163db	Fix the bundle edit form's ticket rows The quantity input had both w-full and w-16; w-full won, filling the row and pushing the ticket picker off the side. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>	2026-10-21 16:03:21 +02:00
joshuaandClaude Opus 5.5	428b438251	Bump to 1.28.2 Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>	2026-10-21 15:56:04 +02:00
joshuaandClaude Opus 5.5	6ce59af0ea	Redesign the Bundle deals page Upcoming events only by default (with a Show past events option), bundles as cards instead of a table, and a mobile-friendly edit form. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>	2026-10-21 15:56:03 +02:00
joshuaandClaude Opus 5.5	53ed72d032	Add bundle deals to manual registration Lists the event's deals and shows the Complete bundle / + cards, as at the door and on the kiosk. Part of 1.28.1. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>	2026-10-21 15:32:17 +02:00
joshuaandClaude Opus 5.5	35d02c243b	Bump to 1.28.1 Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>	2026-10-21 15:22:49 +02:00
joshuaandClaude Opus 5.5	e2e6ec0e97	Merge branch 'feat/bundles-door-kiosk' Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>	2026-10-21 15:22:48 +02:00
joshuaandClaude Opus 5.5	92ab8065ef	Add bundle deals to at the door and the kiosk Both list the event's deals and show the Complete bundle / + cards from the register form. At the door gets the standard Back to dashboard link. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>	2026-10-21 15:22:48 +02:00
joshuaandClaude Opus 5.5	084e3c6679	Bump to 1.28.0 Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>	2026-10-21 15:14:53 +02:00
joshuaandClaude Opus 5.5	de196e34f2	Merge branch 'feat/bundle-deals' Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>	2026-10-21 15:14:53 +02:00
joshuaandClaude Opus 5.5	763b66ff56	Add bundle deals Sell a set of tickets together for one price (e.g. 5 Adult + 3 Child for R500). Bundles apply automatically, as many times as a registration's tickets allow, and only when cheaper than the prices actually charged. Coupons come off afterwards. - EventBundle/EventBundleItem/RegistrationBundle models and Registration.bundleDiscount - Supervisor "Bundle deals" page, quote endpoint, bundle lines on invoices, receipts, emails, WhatsApp and Yoco checkout, Discounts report rows - Register form shows started bundles with "Complete bundle" and "+" buttons - Demo: Family Fun Day sells a Family deal bundle instead of the Family pass ticket Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>	2026-10-21 15:14:53 +02:00
joshuaandClaude Opus 5.5	8f92a8c3e9	Bump to 1.27.1 Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>	2026-10-21 13:39:48 +02:00
joshua	6fc6c35214	Merge branch 'chore/demo-history'	2026-10-21 13:39:47 +02:00
joshuaandClaude Opus 5.5	be1d6f2e31	Add ten completed events to the demo data set-demo now also stages ten past events with door sales, staff cash counts, check-ins, refunds, donations and feedback. Their cashups run through the real cashup code after the insert and cover every path: quick close, full settlements (card fees, deposit fee, shortfall, cash on hand, an unaccounted amount), close-reopen-close, and pending EFT money received later or still outstanding. One recent event is left open with the cash counted for a live demo. Funnel sessions older than 90 days are rolled up into daily totals, as the app does. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>	2026-10-21 13:39:47 +02:00
joshuaandClaude Opus 5.5	dc02f6b9ff	Bump to 1.27.0 Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>	2026-10-21 13:29:29 +02:00
joshua	103c328a6a	Merge branch 'feat/cashup-settlement'	2026-10-21 13:29:28 +02:00
joshuaandClaude Opus 5.5	7446388bfa	Take cash deposit fees out of the counted cash A bank charge on a cash deposit comes out of cash that was counted and banked, so cash on hand is now the count less what reached the bank and any bank-charge write-off. Before, a deposit fee showed as money "more than expected". Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>	2026-10-21 13:29:17 +02:00
joshuaandClaude Opus 5.5	8a4c144f6d	Add cashup settlement and back links to the changelog Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>	2026-10-21 13:25:19 +02:00
joshuaandClaude Opus 5.5	3a68b24a0f	Settle cashups: where the money ended up A full cashup now records, per payment method, how much of the expected takings is in the bank, still on hand (cash) or pending (on the card report or with a POP), and writes off what was lost to card fees, bank charges or a shortfall. Whatever is left is shown as unaccounted; closing with an unaccounted amount is allowed after a warning. Pending money can be marked received or written off after the event is closed, without reopening it. Reopening starts the next cashup from the last one. Write-offs come off net profit and show as "Bank & card charges" in the cashup, finance and profit reports. The reports page also moves to the shared back link. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>	2026-10-21 13:25:04 +02:00
joshuaandClaude Opus 5.5	9be78c3c34	Use one back link style across the dashboards Every dashboard page now uses the shared BackLink, the small "← Back to dashboard" link above the page title that the Waitlist page already had, instead of a mix of grey Back buttons in different places. Pages that had no way back (site settings, profile, donate, manual registration) get one too. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>	2026-10-21 13:25:04 +02:00
joshuaandClaude Opus 5.5	d268236686	Bump to 1.26.1 Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>	2026-10-21 12:23:51 +02:00
joshua	95a8bd0796	Merge branch 'chore/demo-data'	2026-10-21 12:21:03 +02:00
joshuaandClaude Opus 5.5	101632e758	Add set-demo script for staging demo data npm run set-demo wipes the database, keeping the site settings and the admin account, and stages six upcoming events with registrations, payments, tickets, a waitlist, camp cabins, coupons, costs and funnel stats for showing the platform to other churches. Documented in backend/DEMO_DATA.md. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>	2026-10-21 12:21:03 +02:00
joshuaandClaude Opus 5.5	7cf5f79d01	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>	2026-10-21 11:16:38 +02:00
joshuaandClaude Opus 5.5	00464c086d	Bump to 1.26.0 Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>	2026-10-21 11:16:38 +02:00
joshuaandClaude Opus 5.5	4e07034bbd	Add frontend lint cleanup to the changelog Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>	2026-10-21 11:11:49 +02:00
joshuaandClaude Opus 5.5	2d6c840614	Type the reports page and turn lint back on in builds ReportsV2 gets typed API responses (funnel, feedback summary, coupon redemptions, cashup audit, consent) and derived rows. Master-order quantities move into a per-row map, so an option name can no longer overwrite a fixed column. Consent row types move to src/types. Removes unused export helpers and state. With the frontend now at zero lint errors and warnings, next build runs ESLint again (eslint.ignoreDuringBuilds is gone). Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>	2026-10-21 11:10:01 +02:00
joshuaandClaude Opus 5.5	235da5bf61	Type the at-the-door page and share pricing helpers Each door panel and modal gets typed props; unused setError/setInfo/ onCreated props are dropped. The current early-bird price helpers move to src/lib/pricing.ts (shared with manual registration), dead fallbacks for a legacy registration 'options' field are removed, and the refund history now shows a refund's reason (stored in its status field) instead of a 'reason' field that never exists. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>	2026-10-21 11:10:01 +02:00
joshuaandClaude Opus 5.5	f6581eb441	Type payments and user dashboard pages Moves the duplicated registration-option pricing helper into src/lib/pricing.ts and drops an unused users list from payments. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>	2026-10-21 11:10:01 +02:00
joshuaandClaude Opus 5.5	0a8788afff	Type supervisor forms, manual registration and events pages Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>	2026-10-21 11:10:01 +02:00
joshuaandClaude Opus 5.5	b560d0d340	Type registrations, email and WhatsApp messaging pages Adds typed payloads and results for the email/WhatsApp attendee and broadcast endpoints. The WhatsApp page's messageDirty flag becomes a ref (it only gated the template effect), and a no-op branch in the email template effect is removed. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>	2026-10-21 11:10:01 +02:00
joshuaandClaude Opus 5.5	b2439a781e	Type more frontend pages and fix their hook dependencies Cashup, users, profile, consent, allocations, event options, forms, event tickets, ticket scanning and manual registration now use real types. Data loaders are wrapped in useCallback and listed as effect dependencies. Also adds shared Attendee, Section and form response types. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>	2026-10-21 11:10:01 +02:00
joshuaandClaude Opus 5.5	545f3d913e	Add shared API types and type the smaller frontend pages Expand src/types with User, Event, EventOption, Registration, Payment, Ticket, paginated results and dashboard stats, modelled on the Prisma schema. apiFetch now defaults to unknown instead of any. Dashboard loaders are wrapped in useCallback so their effects can list them as dependencies. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>	2026-10-21 11:10:01 +02:00
joshuaandClaude Opus 5.5	619b5b9a93	Type caught errors as unknown in the frontend Replace `catch (e: any)` with `catch (e)` and read the message through a new errorMessage() helper. ApiError.data gets a real type, and useDismissingState's setter keeps one identity across renders. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>	2026-10-21 11:10:00 +02:00
joshuaandClaude Opus 5.5	958a5a5950	Fix frontend lint: links, unused code, quotes, img elements - Internal links use next/link instead of <a> (no full page reload). - Remove dead code: RegisterForm's unreachable Yoco checkout branch, the unused AttendeeForms on the registration success page, unused Geist fonts, and assorted unused variables and catch bindings. - Escape quotes in JSX text; replace @ts-ignore in apiFetch with a cast. - Keep the intentional raw <img> elements (data URLs, runtime API host) with a documented lint exception; the event editor uses ApiImage. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>	2026-10-21 11:10:00 +02:00
joshuaandClaude Opus 5.5	f2be3a8b45	Upgrade to Prisma 7 and clear npm audit advisories - Prisma 5.22 -> 7.10 using the @prisma/adapter-pg driver adapter; the datasource URL moves to backend/prisma.config.js. All clients are built in src/config/db.js, and index.js reuses the shared client. - Backend: patch follow-redirects, drop nodemon for `node --watch`, and use js-yaml 4 for the Jest coverage loader. npm audit reports 0. - Frontend: override postcss-selector-parser to 7.1.7 (Tailwind 3 output is unchanged). braces has no patched release and stays, build/lint only. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>	2026-10-21 09:58:11 +02:00
joshua	ce22f44f7c	Merge branch 'fix/mobile-cookie-banner'	2026-10-20 12:47:41 +02:00
joshuaandClaude Opus 5.5	30b567f091	Bump to 1.25.1 Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>	2026-10-20 12:47:36 +02:00
joshuaandClaude Opus 5.5	0b22eca0fb	Lift cookie banner and help button above mobile bottom nav The cookie consent banner was fixed at bottom-0 under the z-50 BottomNav, so on mobile it was hidden. It now sits above the nav (h-16 + safe-area) and publishes its height as --cookie-banner-h, which HelpFab adds to its offset so the banner no longer covers the help button either. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>	2026-10-20 12:47:13 +02:00