Bump to 1.17.0

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

CHANGELOG.md

@@ -7,6 +7,68 @@ and this project follows [Semantic Versioning](https://semver.org/).
 
 ## [Unreleased]
 
+## [1.17.0] - 2026-10-19
+
+### Added
+
+- Offline ticket scanning. While online, staff pick an event and section on the scanner and tap "Enable offline mode". The section (or the whole event) is locked to their device and its tickets are downloaded to the device.
+  - With no connection, scans are checked against that list and queued on the device.
+  - The panel shows when the list was downloaded and how many scans are waiting.
+  - Queued scans sync automatically when the device is back online (or with "Sync now"), and check-in messages go out then.
+  - "Release section" ends offline mode and deletes the list from the device.
+- Only one device can hold a section at a time (a whole-event lock clashes with every section). While a section is locked, other devices see who holds it and can't scan it, online or offline, so a ticket can never be redeemed twice by two offline devices.
+- Syncing is idempotent and never redeems more than is left on a ticket. Anything that needs a person to look goes into a sync report: tickets not found, cancelled registrations, used-up tickets, scans outside the locked section, and check-ins without consent.
+- Supervisor → Offline scanning page: active locks with force release (for a lost or flat phone; its scans still sync if it reconnects, and are flagged), and sync reports to review. Locks, releases, force-releases and syncs are recorded in the audit log.
+- The scanner is installable as an app (web app manifest), and a service worker caches the scanner page and its scripts so it opens with no connection.
+- The app now stays signed in with the last confirmed profile when it's reloaded without a connection, instead of sending the user to the login page.
+- New `/api/scan-locks` endpoints.
+  - Requires the `add_offline_scanning` database migration.
+
+### Changed
+
+- `POST /api/tickets/scan/:qrCode` now accepts `sectionId` and checks it on the server; this was previously only checked in the browser.
+  - It now refuses (423) scans in a section that another device has locked for offline scanning.
+
+## [1.16.0] - 2026-10-19
+
+### Added
+
+- Waitlist for sold-out tickets. A new event setting (event wizard → Visibility) turns it on, with how long offered places are held (24 hours by default) and whether someone can be offered fewer places than they asked for.
+  - Sold-out tickets show "Join waitlist" on the event page, the register page and the events list. Guests can join on events that allow guest registration.
+- When places free up, the next person is emailed/WhatsApped a claim link, and the places are held for them so nobody else can buy them. Places free up through a cancellation (by the person or staff), a smaller booking, or a raised stock limit.
+  - The claim link opens the register page with the places pre-selected, and works without logging in.
+  - Unclaimed offers expire (checked every 10 minutes) and move on to the next person.
+- People can leave a waitlist from My Events, which now lists their waitlists and any places held for them.
+- Supervisor → Waitlist page: the queue per event, with offer now (even over the stock limit), move up/down and remove.
+- The daily summary email shows each event's waitlist count.
+- New `/api/waitlist` endpoints. `POST /api/registrations` accepts `waitlistToken`.
+  - Requires the `add_waitlist` database migration.
+
+### Fixed
+
+- Manual registrations (Manual registration, At the door, the kiosk) and adding places to an existing booking never checked stock, so either could take an option over its stock limit. Both are now checked like a normal registration.
+- Stock is now counted in one place (`utils/stock.js`) for registration checks, `availableCount` and `isSoldOut`, including places held for waitlist offers.
+
+## [1.15.0] - 2026-10-19
+
+### Added
+
+- Parental consent for youth events. A new "Requires parental consent" event setting (event wizard → Visibility) has its own consent text and optional medical info, emergency contact and photo consent questions. It turns on named attendees automatically.
+  - Registering then needs a name and date of birth for every main-ticket place. Anyone under 18 on the event's start date needs a parent or guardian's name, email and phone.
+  - This applies on the registration page, manual registration, at the door, the kiosk, and when editing names in My Events.
+- The parent gets an email and a WhatsApp (always both) with a link to a new consent page (`/consent/<token>`). There they read the text, answer the optional questions, type their full name and confirm they're the parent or guardian, then give or decline.
+  - The system records the time, IP, device, signed name, and the exact consent text and version shown.
+  - Medical and emergency details are stored encrypted.
+  - The registrant and the event's notification recipients are told the outcome.
+- Tickets are still issued, but the scanner blocks check-in until consent is given, showing why. Supervisors can override, and the override is recorded in the audit log. On a youth event, a ticket with no named attendee counts as missing consent.
+- A daily 09:00 job reminds unanswered requests after 2 days, then every 3 days until the event. It also deletes medical and emergency details a set number of days after the event (Site Settings → Legal, default 30). `CONSENT_JOBS_ENABLED=false` turns it off.
+- Supervisor → Parental consent page: consent status per attendee, resend one or all pending requests, re-request consent after the consent text changes, and a printable, confidential medical & emergency list. Every view of the list is recorded in the audit log.
+- New reports: "Parental consent status" and "Medical & emergency list".
+- My Events shows each attendee's consent status, with a "Resend consent" button.
+- Anonymising or closing an account also clears that person's attendees' parent, date-of-birth, medical and emergency details.
+- New endpoints under `/api/consent`. `GET /api/tickets/scan-preview/:qrCode` now returns `consentStatus`, and `POST /api/tickets/scan/:qrCode` accepts `overrideConsent`.
+  - Requires the `add_parental_consent` database migration.
+
 ## [1.14.0] - 2026-10-19
 
 ### Added

FEATURES.md

@@ -134,6 +134,20 @@ Items & Pricing → Sections → Form → Visibility → Attachments**.
   added or changed later from My Events, and attendees can be sent a link to fill in
   their own form. Available on the registration page, manual registration, At the
   door and the kiosk.
+- **Waitlist** — on events with a waitlist, sold-out tickets show "Join waitlist"
+  (on the event page, the register page and the event list). When places free up — a
+  cancellation, a smaller booking or a higher stock limit — the next person is
+  emailed/WhatsApped a claim link and the places are held for them (24 hours by
+  default) so nobody else can buy them. Unclaimed offers expire and move on; people
+  who asked for more than came free can be offered what's free or skipped. Claiming
+  works without logging in. People can leave from My Events.
+- **Parental consent (youth events)** — on events that require it, every attendee
+  gives a date of birth; for anyone under 18, a parent or guardian gets an email and
+  a WhatsApp with a consent link. They read the event's consent text, optionally give
+  medical info, an emergency contact and photo consent, type their name to sign, and
+  give or decline. Tickets are issued but can't be checked in until consent is given
+  (supervisors can override, audited). Reminders go after 2 days, then every 3 days.
+  Medical details are encrypted and deleted a set number of days after the event.
 - **Coupon codes** — percentage, fixed-amount or free (comp) codes, entered under
   "Have a code?" on the registration page, in My Events (for unpaid registrations),
   manual registration, At the door and the kiosk. Codes can be limited to events,
@@ -186,6 +200,13 @@ Items & Pricing → Sections → Form → Visibility → Attachments**.
 - **Check-in confirmation** — holders get an email/WhatsApp saying how many were
   checked in and how many remain.
 - **Scan stats** — recent scans and per-event scan counts.
+- **Offline scanning** — while online, a staff member locks an event section (or the
+  whole event) to their device and downloads its tickets. They can then keep scanning
+  with no connection; scans are queued on the device and sync automatically when it's
+  back online (never redeeming more than is left). Only one device can hold a section,
+  and while it's locked nobody else can scan it, online or offline. Problems found
+  while syncing go into a report for a supervisor. Supervisors can force-release a
+  lost device. The scanner can be added to the home screen (PWA) and opens offline.
 - **Printing** — A4 sheets (8 tickets per page) and A6 single tickets.
 - **Resend** — send tickets to a different email/phone at the door.
 
@@ -285,6 +306,13 @@ logout controls. Disconnected sessions are recovered automatically.
   Reconcile (Yoco transactions), and Payment Link.
 - **Coupon codes** (`/dashboard/supervisor/coupons`) — create, edit and turn off
   discount codes, and see who used each one.
+- **Offline scanning** (`/dashboard/supervisor/offline-scans`) — devices holding
+  offline locks (with force release) and sync reports to review.
+- **Waitlist** (`/dashboard/supervisor/waitlist`) — the queue per event: offer a
+  place now, move people up or down, or remove them.
+- **Parental consent** (`/dashboard/supervisor/consent`) — consent status per
+  attendee on youth events, resend (one or all pending), re-request after the
+  consent text changes, and a printable medical & emergency list (audited).
 - **Email attendees / WhatsApp attendees** — bulk and scheduled messaging.
 - **Forms** — view, filter, edit and print form responses.
 - **Reports** — see [Reports](#reports).
@@ -338,7 +366,7 @@ a viewer with its own filters, stat tiles and bar charts.
 | Category | Reports |
 |----------|---------|
 | Financial | Payments between dates · Revenue summary (by method) · Revenue detailed · Finance report (revenue & costs, after discounts) · Profit report · Discounts (coupon codes) |
-| Registration | Attendees per event (grouped by option) · Registration type counts · Master orders breakdown · Registration status breakdown (count by registration or ticket quantity) |
+| Registration | Attendees per event (grouped by option) · Registration type counts · Master orders breakdown · Registration status breakdown (count by registration or ticket quantity) · Parental consent status · Medical & emergency list |
 | Ticketing | Ticket usage summary |
 | Donations | Donations breakdown (used / unused per event) |
 | Cashup | Cashup reconciliation · Cashup audit trail |
@@ -410,6 +438,8 @@ falling back to a general guide.
 |-----|----------|
 | Scheduled email/WhatsApp worker | Polls every 30 s (`SCHEDULED_EMAILS_INTERVAL_MS`) and purges sent jobs after 24 h |
 | Daily event summary email | 07:00 daily |
+| Waitlist: expire unclaimed offers, offer freed places | Every 10 minutes (`WAITLIST_JOB_ENABLED=false` to disable) |
+| Parental consent reminders, and deleting medical details after events | 09:00 daily (`CONSENT_JOBS_ENABLED=false` to disable) |
 | Database backup (`pg_dump`, gzipped, 14-day retention) | 02:00 daily (`BACKUP_ENABLED=false` to disable) |
 | Temp file cleanup (files older than 7 days in `/temp`) | Daily |
 
@@ -442,9 +472,11 @@ falling back to a general guide.
 | `/contact`, `/legal/terms`, `/legal/privacy`, `/lockdown-rules` | Public | Info pages |
 | `/login`, `/register`, `/forgot-password`, `/reset-password`, `/activate-account` | Public | Accounts |
 | `/setup` | First run | Setup wizard |
+| `/consent/[token]` | Parent/guardian | Give or decline parental consent |
+| `/waitlist/claim/[token]` | Public | Claim a waitlist place |
 | `/self-service` | Supervisor-unlocked | Kiosk |
 | `/set-banner` | Supervisor | Site banner |
 | `/dashboard/user` (+ `/payments`, `/donate`, `/forms`, `/profile`, `/reset-password`) | User | My Events |
 | `/dashboard/staff` (+ `/ticket-scanning`, `/event-tickets`) | Staff | Staff tools |
-| `/dashboard/supervisor` (+ `/events`, `/event-options`, `/at-the-door`, `/manual`, `/manual-registration`, `/payments`, `/coupons`, `/email-attendees`, `/whatsapp-attendees`, `/forms`, `/reports`) | Supervisor | Supervisor tools |
+| `/dashboard/supervisor` (+ `/events`, `/event-options`, `/at-the-door`, `/manual`, `/manual-registration`, `/payments`, `/coupons`, `/waitlist`, `/consent`, `/offline-scans`, `/email-attendees`, `/whatsapp-attendees`, `/forms`, `/reports`) | Supervisor | Supervisor tools |
 | `/dashboard/admin` (+ `/users`, `/registrations`, `/forms`, `/cashup`, `/cashup/[id]`, `/audit-log`, `/settings`) | Admin | Admin tools |

SETTINGS.md

@@ -66,6 +66,7 @@ or Branding tab has been saved even once — the wizard always writes
 | `legal_io_email` | `"io@example.com"` | Rendered as a `mailto:` link, so the placeholder stays a syntactically valid address on the IANA-reserved `example.com` domain rather than a bracketed non-email string that would break the link. |
 | `legal_website_url` | `"example.com"` | Same reasoning — used to build an `https://` link. |
 | `legal_effective_date` | `"[not yet set]"` | Plain text only, no link — a bracketed placeholder is fine here. |
+| `consent_medical_retention_days` | `30` | Youth events: medical and emergency details from parental consent forms are deleted this many days after the event ends (daily 09:00 job). The consent record itself — who agreed, when, to which text — is kept. Set under Site Settings → Legal. |
 | `org_email` (as used on legal pages specifically) | `"privacy@example.com"` | Different fallback than `org_email`'s general default (blank) — also rendered as a `mailto:` link, so it needs to stay a valid-looking address. |
 
 ## WhatsApp

backend/.env.example

@@ -52,6 +52,11 @@ WAWP_INSTANCE_ID=your_wawp_instance_id
 DAILY_SUMMARY_ENABLED=true
 SCHEDULED_EMAILS_ENABLED=true
 SCHEDULED_EMAILS_INTERVAL_MS=30000
+# Daily 09:00 parental-consent job: reminders, and deleting medical details after events
+CONSENT_JOBS_ENABLED=true
+# Waitlist: expire unclaimed offers and offer freed places (every 10 minutes by default)
+WAITLIST_JOB_ENABLED=true
+# WAITLIST_JOB_INTERVAL_MS=600000
 # Nightly database backup at 02:00 (requires the `pg_dump` binary on this host).
 # Retention count is set via Admin → Site Settings → Backups (default 14).
 BACKUP_ENABLED=true

backend/API_DOCUMENTATION.md

@@ -19,6 +19,9 @@ Tokens are issued by `POST /api/users/login`.
 - [Event Attachments](#event-attachments)
 - [Registrations](#registrations)
 - [Coupons](#coupons)
+- [Parental consent](#parental-consent)
+- [Waitlist](#waitlist)
+- [Offline scanning](#offline-scanning)
 - [Payments](#payments)
 - [Tickets](#tickets)
 - [Broadcasts (Email)](#broadcasts-email)
@@ -276,6 +279,76 @@ For unauthenticated (guest) registration on events with `requiresAuth: false`:
 
 ---
 
+## Offline scanning
+
+| Method | Path | Auth | Description |
+|--------|------|------|-------------|
+| GET | `/api/scan-locks?eventId=` | staff+ | Active offline locks for an event |
+| POST | `/api/scan-locks` | staff+ | Lock `{ eventId, sectionId?, deviceId, deviceName? }` to this device (409 if the scope is held elsewhere) |
+| GET | `/api/scan-locks/:id/snapshot?deviceId=` | staff+ | Tickets valid in the lock's scope (lock holder only) |
+| POST | `/api/scan-locks/:id/sync` | staff+ | `{ deviceId, scans: [{ clientScanId, qrCode, qty, scannedAt }] }` — idempotent; returns accepted, duplicates, conflicts |
+| DELETE | `/api/scan-locks/:id` | staff+ | Release (`{ deviceId }`, lock holder only) |
+| POST | `/api/scan-locks/:id/force-release` | supervisor+ | Release a lost device's lock |
+| GET | `/api/scan-locks/reports?eventId=&unreviewed=` | supervisor+ | Sync reports |
+| POST | `/api/scan-locks/reports/:id/review` | supervisor+ | Mark a report reviewed |
+
+How locks work:
+- One device per scope. A whole-event lock (`sectionId` null) clashes with every section lock on that event.
+- `POST /api/tickets/scan/:qrCode` now accepts `sectionId` and `deviceId`. It enforces the section on the server, and returns `423 { code: "SCAN_LOCKED" }` when another device holds a lock covering the ticket.
+
+How syncing works:
+- Synced scans never redeem more than is left on a ticket.
+- Conflicts are recorded in the sync report: `not_found`, `cancelled`, `wrong_scope`, `already_used`, `partly_used` and `consent`.
+- Check-in messages are sent after the sync.
+- Locks, releases, force-releases and syncs are written to the admin audit log.
+
+## Waitlist
+
+Events with `waitlistEnabled` (plus `waitlistOfferHours`, default 24, and `waitlistPartialOffers`, default true) take a queue for sold-out lines.
+
+| Method | Path | Auth | Description |
+|--------|------|------|-------------|
+| POST | `/api/waitlist` | optional | Join: `{ eventId, eventOptionId, variantId?, quantity }` (+ `guestName`, `guestEmail`, `guestPhone` when not logged in on a guest event). Only when the line can't cover the quantity |
+| GET | `/api/waitlist/mine` | user+ | My active entries |
+| DELETE | `/api/waitlist/:id` | user+ | Leave (an open offer moves on) |
+| GET | `/api/waitlist/claim/:token` | public | What a claim link offers |
+| GET | `/api/waitlist/events/:eventId` | staff+ | The queue for an event |
+| POST | `/api/waitlist/:id/offer` | supervisor+ | Offer now (`{ quantity? }`), even over the stock limit |
+| POST | `/api/waitlist/:id/move` | supervisor+ | `{ direction: "up" \| "down" }` |
+| POST | `/api/waitlist/:id/remove` | supervisor+ | Take someone off |
+
+How offers work:
+- Places held for a live offer count as taken everywhere stock is counted: `availableCount`, `isSoldOut` and registration stock checks.
+- Offers are made automatically when places free up: a cancellation, a smaller booking, or a raised stock limit.
+- A job every 10 minutes (`WAITLIST_JOB_ENABLED`, `WAITLIST_JOB_INTERVAL_MS`) expires unclaimed offers and re-offers.
+- Claiming means registering with `POST /api/registrations` plus `waitlistToken`. The token stands in for logging in, and the held places are released to the claimer.
+- Manual registration and adding places to an existing booking are now checked against stock too.
+
+## Parental consent
+
+Youth events (`requiresParentalConsent`, plus `consentText`, `consentCollectMedical`, `consentCollectEmergency` and `consentCollectPhoto` on the event) need every main place named with a `dateOfBirth`. Attendees under 18 on the start date also need `parentName`, `parentEmail` and `parentPhone`. Changing `consentText` bumps `consentTextVersion`.
+
+| Method | Path | Auth | Description |
+|--------|------|------|-------------|
+| GET | `/api/consent/:token` | public | What the parent sees: attendee, event, consent text, fields to fill in |
+| POST | `/api/consent/:token` | public | `{ decision: "give"\|"decline", signedName, isGuardian: true, medical?, emergency?, photoConsent? }` |
+| GET | `/api/consent/events/:eventId` | staff+ | Consent status per attendee, with counts |
+| POST | `/api/consent/requests/:id/resend` | user+ | Re-send one request with a new link (registrant or staff) |
+| POST | `/api/consent/events/:eventId/resend-pending` | supervisor+ | Re-send every pending request |
+| POST | `/api/consent/events/:eventId/rerequest` | supervisor+ | New requests for consent given on older text, and minors with none |
+| GET | `/api/consent/events/:eventId/medical` | supervisor+ | Decrypted medical & emergency list (audited as `medical_list_viewed`) |
+
+How requests work:
+- Requests go to the parent by both email and WhatsApp, whatever anyone's notification preference.
+- Links are random tokens; only an HMAC is stored. They expire when the event ends.
+- The answer stores the signed name, time, IP, device, and the exact text and version shown.
+- Medical and emergency details are AES-256-GCM encrypted. A daily job (09:00, `CONSENT_JOBS_ENABLED=false` to disable) sends reminders (day 2, then every 3 days) and deletes them `consent_medical_retention_days` (default 30) after the event.
+
+Check-in rules:
+- `GET /api/tickets/scan-preview/:qrCode` returns `consentStatus` (`not_required`, `missing`, `pending`, `given` or `declined`).
+- `POST /api/tickets/scan/:qrCode` returns `403 { code: "CONSENT_REQUIRED" }` unless consent is given.
+- Supervisors can pass `overrideConsent: true`, which is audited as `consent_override`.
+
 ## Coupons
 
 | Method | Path | Auth | Description |

backend/package-lock.json

@@ -1,12 +1,12 @@
 {
   "name": "event-management-backend",
-  "version": "1.14.0",
+  "version": "1.17.0",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
       "name": "event-management-backend",
-      "version": "1.14.0",
+      "version": "1.17.0",
       "hasInstallScript": true,
       "dependencies": {
         "@prisma/client": "^5.4.2",

backend/package.json

@@ -1,6 +1,6 @@
 {
   "name": "event-management-backend",
-  "version": "1.14.0",
+  "version": "1.17.0",
   "description": "Event Management System Backend",
   "main": "src/index.js",
   "scripts": {

backend/prisma/migrations/20261019121441_add_parental_consent/migration.sql

@@ -0,0 +1,71 @@
+-- CreateEnum
+CREATE TYPE "ConsentStatus" AS ENUM ('pending', 'given', 'declined');
+
+-- AlterEnum
+-- This migration adds more than one value to an enum.
+-- With PostgreSQL versions 11 and earlier, this is not possible
+-- in a single migration. This can be worked around by creating
+-- multiple migrations, each migration adding only one value to
+-- the enum.
+
+
+ALTER TYPE "AdminAuditAction" ADD VALUE 'consent_override';
+ALTER TYPE "AdminAuditAction" ADD VALUE 'consent_rerequested';
+ALTER TYPE "AdminAuditAction" ADD VALUE 'medical_list_viewed';
+
+-- AlterTable
+ALTER TABLE "Attendee" ADD COLUMN     "parentEmail" TEXT,
+ADD COLUMN     "parentName" TEXT,
+ADD COLUMN     "parentPhone" TEXT;
+
+-- AlterTable
+ALTER TABLE "Event" ADD COLUMN     "consentCollectEmergency" BOOLEAN NOT NULL DEFAULT false,
+ADD COLUMN     "consentCollectMedical" BOOLEAN NOT NULL DEFAULT false,
+ADD COLUMN     "consentCollectPhoto" BOOLEAN NOT NULL DEFAULT false,
+ADD COLUMN     "consentText" TEXT,
+ADD COLUMN     "consentTextVersion" INTEGER NOT NULL DEFAULT 1,
+ADD COLUMN     "requiresParentalConsent" BOOLEAN NOT NULL DEFAULT false;
+
+-- CreateTable
+CREATE TABLE "ConsentRequest" (
+    "id" TEXT NOT NULL,
+    "attendeeId" TEXT NOT NULL,
+    "eventId" TEXT NOT NULL,
+    "tokenHash" TEXT NOT NULL,
+    "status" "ConsentStatus" NOT NULL DEFAULT 'pending',
+    "textVersion" INTEGER NOT NULL,
+    "consentText" TEXT NOT NULL,
+    "parentName" TEXT,
+    "parentEmail" TEXT,
+    "parentPhone" TEXT,
+    "signedName" TEXT,
+    "ip" TEXT,
+    "device" TEXT,
+    "medical" TEXT,
+    "emergency" TEXT,
+    "photoConsent" BOOLEAN,
+    "respondedAt" TIMESTAMP(3),
+    "lastSentAt" TIMESTAMP(3) NOT NULL DEFAULT CURRENT_TIMESTAMP,
+    "remindersSent" INTEGER NOT NULL DEFAULT 0,
+    "expiresAt" TIMESTAMP(3) NOT NULL,
+    "medicalPurgedAt" TIMESTAMP(3),
+    "createdAt" TIMESTAMP(3) NOT NULL DEFAULT CURRENT_TIMESTAMP,
+
+    CONSTRAINT "ConsentRequest_pkey" PRIMARY KEY ("id")
+);
+
+-- CreateIndex
+CREATE UNIQUE INDEX "ConsentRequest_tokenHash_key" ON "ConsentRequest"("tokenHash");
+
+-- CreateIndex
+CREATE INDEX "ConsentRequest_attendeeId_createdAt_idx" ON "ConsentRequest"("attendeeId", "createdAt");
+
+-- CreateIndex
+CREATE INDEX "ConsentRequest_eventId_status_idx" ON "ConsentRequest"("eventId", "status");
+
+-- AddForeignKey
+ALTER TABLE "ConsentRequest" ADD CONSTRAINT "ConsentRequest_attendeeId_fkey" FOREIGN KEY ("attendeeId") REFERENCES "Attendee"("id") ON DELETE CASCADE ON UPDATE CASCADE;
+
+-- AddForeignKey
+ALTER TABLE "ConsentRequest" ADD CONSTRAINT "ConsentRequest_eventId_fkey" FOREIGN KEY ("eventId") REFERENCES "Event"("id") ON DELETE CASCADE ON UPDATE CASCADE;
+

backend/prisma/migrations/20261019132635_add_waitlist/migration.sql

@@ -0,0 +1,63 @@
+-- CreateEnum
+CREATE TYPE "WaitlistStatus" AS ENUM ('waiting', 'offered', 'claimed', 'expired', 'removed', 'left');
+
+-- AlterTable
+ALTER TABLE "Event" ADD COLUMN     "waitlistEnabled" BOOLEAN NOT NULL DEFAULT false,
+ADD COLUMN     "waitlistOfferHours" INTEGER NOT NULL DEFAULT 24,
+ADD COLUMN     "waitlistPartialOffers" BOOLEAN NOT NULL DEFAULT true;
+
+-- CreateTable
+CREATE TABLE "WaitlistEntry" (
+    "id" TEXT NOT NULL,
+    "eventId" TEXT NOT NULL,
+    "eventOptionId" TEXT NOT NULL,
+    "variantId" TEXT,
+    "userId" TEXT NOT NULL,
+    "quantity" INTEGER NOT NULL,
+    "position" INTEGER NOT NULL,
+    "status" "WaitlistStatus" NOT NULL DEFAULT 'waiting',
+    "offeredQuantity" INTEGER,
+    "offerTokenHash" TEXT,
+    "offeredAt" TIMESTAMP(3),
+    "offerExpiresAt" TIMESTAMP(3),
+    "claimedAt" TIMESTAMP(3),
+    "registrationId" TEXT,
+    "createdAt" TIMESTAMP(3) NOT NULL DEFAULT CURRENT_TIMESTAMP,
+    "updatedAt" TIMESTAMP(3) NOT NULL,
+
+    CONSTRAINT "WaitlistEntry_pkey" PRIMARY KEY ("id")
+);
+
+-- CreateIndex
+CREATE UNIQUE INDEX "WaitlistEntry_offerTokenHash_key" ON "WaitlistEntry"("offerTokenHash");
+
+-- CreateIndex
+CREATE INDEX "WaitlistEntry_eventId_status_position_idx" ON "WaitlistEntry"("eventId", "status", "position");
+
+-- CreateIndex
+CREATE INDEX "WaitlistEntry_eventOptionId_status_idx" ON "WaitlistEntry"("eventOptionId", "status");
+
+-- CreateIndex
+CREATE INDEX "WaitlistEntry_variantId_idx" ON "WaitlistEntry"("variantId");
+
+-- CreateIndex
+CREATE INDEX "WaitlistEntry_userId_idx" ON "WaitlistEntry"("userId");
+
+-- CreateIndex
+CREATE INDEX "WaitlistEntry_registrationId_idx" ON "WaitlistEntry"("registrationId");
+
+-- AddForeignKey
+ALTER TABLE "WaitlistEntry" ADD CONSTRAINT "WaitlistEntry_eventId_fkey" FOREIGN KEY ("eventId") REFERENCES "Event"("id") ON DELETE CASCADE ON UPDATE CASCADE;
+
+-- AddForeignKey
+ALTER TABLE "WaitlistEntry" ADD CONSTRAINT "WaitlistEntry_eventOptionId_fkey" FOREIGN KEY ("eventOptionId") REFERENCES "EventOption"("id") ON DELETE CASCADE ON UPDATE CASCADE;
+
+-- AddForeignKey
+ALTER TABLE "WaitlistEntry" ADD CONSTRAINT "WaitlistEntry_variantId_fkey" FOREIGN KEY ("variantId") REFERENCES "OptionVariant"("id") ON DELETE CASCADE ON UPDATE CASCADE;
+
+-- AddForeignKey
+ALTER TABLE "WaitlistEntry" ADD CONSTRAINT "WaitlistEntry_userId_fkey" FOREIGN KEY ("userId") REFERENCES "User"("id") ON DELETE CASCADE ON UPDATE CASCADE;
+
+-- AddForeignKey
+ALTER TABLE "WaitlistEntry" ADD CONSTRAINT "WaitlistEntry_registrationId_fkey" FOREIGN KEY ("registrationId") REFERENCES "Registration"("id") ON DELETE SET NULL ON UPDATE CASCADE;
+

backend/prisma/migrations/20261019134441_add_offline_scanning/migration.sql

@@ -0,0 +1,93 @@
+-- AlterEnum
+-- This migration adds more than one value to an enum.
+-- With PostgreSQL versions 11 and earlier, this is not possible
+-- in a single migration. This can be worked around by creating
+-- multiple migrations, each migration adding only one value to
+-- the enum.
+
+
+ALTER TYPE "AdminAuditAction" ADD VALUE 'scan_lock_acquired';
+ALTER TYPE "AdminAuditAction" ADD VALUE 'scan_lock_released';
+ALTER TYPE "AdminAuditAction" ADD VALUE 'scan_lock_force_released';
+ALTER TYPE "AdminAuditAction" ADD VALUE 'offline_sync';
+
+-- AlterTable
+ALTER TABLE "TicketUsage" ADD COLUMN     "clientScanId" TEXT,
+ADD COLUMN     "offline" BOOLEAN NOT NULL DEFAULT false,
+ADD COLUMN     "scanLockId" TEXT,
+ADD COLUMN     "syncedAt" TIMESTAMP(3);
+
+-- CreateTable
+CREATE TABLE "ScanLock" (
+    "id" TEXT NOT NULL,
+    "eventId" TEXT NOT NULL,
+    "sectionId" TEXT,
+    "deviceId" TEXT NOT NULL,
+    "deviceName" TEXT,
+    "userId" TEXT NOT NULL,
+    "lockedAt" TIMESTAMP(3) NOT NULL DEFAULT CURRENT_TIMESTAMP,
+    "snapshotAt" TIMESTAMP(3),
+    "lastSyncAt" TIMESTAMP(3),
+    "releasedAt" TIMESTAMP(3),
+    "forceReleasedById" TEXT,
+
+    CONSTRAINT "ScanLock_pkey" PRIMARY KEY ("id")
+);
+
+-- CreateTable
+CREATE TABLE "OfflineSyncReport" (
+    "id" TEXT NOT NULL,
+    "scanLockId" TEXT NOT NULL,
+    "accepted" INTEGER NOT NULL DEFAULT 0,
+    "duplicates" INTEGER NOT NULL DEFAULT 0,
+    "conflicts" JSONB NOT NULL DEFAULT '[]',
+    "afterForceRelease" BOOLEAN NOT NULL DEFAULT false,
+    "createdAt" TIMESTAMP(3) NOT NULL DEFAULT CURRENT_TIMESTAMP,
+    "reviewedAt" TIMESTAMP(3),
+    "reviewedById" TEXT,
+
+    CONSTRAINT "OfflineSyncReport_pkey" PRIMARY KEY ("id")
+);
+
+-- CreateIndex
+CREATE INDEX "ScanLock_eventId_releasedAt_idx" ON "ScanLock"("eventId", "releasedAt");
+
+-- CreateIndex
+CREATE INDEX "ScanLock_userId_idx" ON "ScanLock"("userId");
+
+-- CreateIndex
+CREATE INDEX "ScanLock_sectionId_idx" ON "ScanLock"("sectionId");
+
+-- CreateIndex
+CREATE INDEX "ScanLock_forceReleasedById_idx" ON "ScanLock"("forceReleasedById");
+
+-- CreateIndex
+CREATE INDEX "OfflineSyncReport_scanLockId_idx" ON "OfflineSyncReport"("scanLockId");
+
+-- CreateIndex
+CREATE INDEX "OfflineSyncReport_reviewedById_idx" ON "OfflineSyncReport"("reviewedById");
+
+-- CreateIndex
+CREATE UNIQUE INDEX "TicketUsage_clientScanId_key" ON "TicketUsage"("clientScanId");
+
+-- AddForeignKey
+ALTER TABLE "TicketUsage" ADD CONSTRAINT "TicketUsage_scanLockId_fkey" FOREIGN KEY ("scanLockId") REFERENCES "ScanLock"("id") ON DELETE SET NULL ON UPDATE CASCADE;
+
+-- AddForeignKey
+ALTER TABLE "ScanLock" ADD CONSTRAINT "ScanLock_eventId_fkey" FOREIGN KEY ("eventId") REFERENCES "Event"("id") ON DELETE CASCADE ON UPDATE CASCADE;
+
+-- AddForeignKey
+ALTER TABLE "ScanLock" ADD CONSTRAINT "ScanLock_sectionId_fkey" FOREIGN KEY ("sectionId") REFERENCES "Section"("id") ON DELETE CASCADE ON UPDATE CASCADE;
+
+-- AddForeignKey
+ALTER TABLE "ScanLock" ADD CONSTRAINT "ScanLock_userId_fkey" FOREIGN KEY ("userId") REFERENCES "User"("id") ON DELETE CASCADE ON UPDATE CASCADE;
+
+-- AddForeignKey
+ALTER TABLE "ScanLock" ADD CONSTRAINT "ScanLock_forceReleasedById_fkey" FOREIGN KEY ("forceReleasedById") REFERENCES "User"("id") ON DELETE SET NULL ON UPDATE CASCADE;
+
+-- AddForeignKey
+ALTER TABLE "OfflineSyncReport" ADD CONSTRAINT "OfflineSyncReport_scanLockId_fkey" FOREIGN KEY ("scanLockId") REFERENCES "ScanLock"("id") ON DELETE CASCADE ON UPDATE CASCADE;
+
+-- AddForeignKey
+ALTER TABLE "OfflineSyncReport" ADD CONSTRAINT "OfflineSyncReport_reviewedById_fkey" FOREIGN KEY ("reviewedById") REFERENCES "User"("id") ON DELETE SET NULL ON UPDATE CASCADE;
+

backend/prisma/schema.prisma

@@ -103,44 +103,62 @@ model User {
   couponsApplied    CouponRedemption[] @relation("CouponRedemptionAppliedBy")
 
   attendeeProfiles Attendee[]
-  heldTickets      Ticket[]   @relation("TicketHolder")
+  heldTickets      Ticket[]            @relation("TicketHolder")
+  waitlistEntries  WaitlistEntry[]
+  scanLocks        ScanLock[]          @relation("ScanLockOwner")
+  scanLocksForced  ScanLock[]          @relation("ScanLockForcedBy")
+  syncReportsDone  OfflineSyncReport[] @relation("SyncReportReviewer")
 
   twoFactorChallenges TwoFactorChallenge[]
   trustedDevices      TrustedDevice[]
 }
 
 model Event {
-  id                   String            @id @default(uuid())
-  title                String
-  description          String?
-  startDate            DateTime
-  endDate              DateTime
-  registrationDeadline DateTime?
-  goLiveAt             DateTime          @default(now())
-  price                Float
-  picture              String?
-  isActive             Boolean           @default(true)
-  isHidden             Boolean           @default(false)
-  requiresAuth         Boolean           @default(true)
-  requiresRegistration Boolean           @default(true)
+  id                      String            @id @default(uuid())
+  title                   String
+  description             String?
+  startDate               DateTime
+  endDate                 DateTime
+  registrationDeadline    DateTime?
+  goLiveAt                DateTime          @default(now())
+  price                   Float
+  picture                 String?
+  isActive                Boolean           @default(true)
+  isHidden                Boolean           @default(false)
+  requiresAuth            Boolean           @default(true)
+  requiresRegistration    Boolean           @default(true)
   // Lets a payer name each person on a group registration (one named ticket each).
-  allowNamedAttendees  Boolean           @default(false)
-  contactName          String?
-  contactPhone         String?
-  contactEmail         String?
-  location             String?
-  createdAt            DateTime          @default(now())
-  updatedAt            DateTime          @updatedAt
-  createdById          String?
-  createdBy            User?             @relation(fields: [createdById], references: [id], onDelete: SetNull)
-  redirectUrl          String?           @unique
-  eventOptions         EventOption[]
-  registrations        Registration[]
-  payments             Payment[]
-  tickets              Ticket[]
-  attachments          EventAttachment[]
-  form                 EventForm?
-  Section              Section[]
+  allowNamedAttendees     Boolean           @default(false)
+  // Youth event: every attendee gives a date of birth, and a parent/guardian must give
+  // consent for anyone under 18 before they can be checked in.
+  requiresParentalConsent Boolean           @default(false)
+  consentText             String?
+  consentTextVersion      Int               @default(1)
+  consentCollectMedical   Boolean           @default(false)
+  consentCollectEmergency Boolean           @default(false)
+  consentCollectPhoto     Boolean           @default(false)
+  // Waitlist for sold-out options: when places free up, the next person is offered
+  // them for waitlistOfferHours. waitlistPartialOffers: offer what's free even if it's
+  // fewer places than asked for (otherwise skip to the next person who fits).
+  waitlistEnabled         Boolean           @default(false)
+  waitlistOfferHours      Int               @default(24)
+  waitlistPartialOffers   Boolean           @default(true)
+  contactName             String?
+  contactPhone            String?
+  contactEmail            String?
+  location                String?
+  createdAt               DateTime          @default(now())
+  updatedAt               DateTime          @updatedAt
+  createdById             String?
+  createdBy               User?             @relation(fields: [createdById], references: [id], onDelete: SetNull)
+  redirectUrl             String?           @unique
+  eventOptions            EventOption[]
+  registrations           Registration[]
+  payments                Payment[]
+  tickets                 Ticket[]
+  attachments             EventAttachment[]
+  form                    EventForm?
+  Section                 Section[]
 
   cashupStatus     CashupStatus             @default(open)
   cashupDraft      Json?
@@ -156,8 +174,11 @@ model Event {
 
   // Users who should receive registration/payment/daily-summary notifications for this
   // event. Falls back to `createdBy` when empty (see backend/src/utils/notifications.js).
-  notifyRecipients User[]        @relation("EventNotifyRecipients")
+  notifyRecipients User[]           @relation("EventNotifyRecipients")
   coupons          CouponEvent[]
+  consentRequests  ConsentRequest[]
+  waitlistEntries  WaitlistEntry[]
+  scanLocks        ScanLock[]
 
   @@index([createdById])
   @@index([closedById])
@@ -180,6 +201,7 @@ model EventOption {
   variants            OptionVariant[]
   costs               EventCost[]
   couponScopes        CouponOption[]
+  waitlistEntries     WaitlistEntry[]
 
   @@index([eventId])
 }
@@ -214,6 +236,7 @@ model OptionVariant {
   registrationOptions RegistrationOption[]
   earlyBirdTiers      EarlyBirdTier[]
   couponScopes        CouponOption[]
+  waitlistEntries     WaitlistEntry[]
 
   @@index([eventOptionId])
 }
@@ -240,6 +263,7 @@ model Registration {
   formDrafts          FormDraft[]
   couponRedemptions   CouponRedemption[]
   attendees           Attendee[]
+  waitlistEntries     WaitlistEntry[]
 
   @@index([userId])
   @@index([eventId])
@@ -350,13 +374,20 @@ model Ticket {
 }
 
 model TicketUsage {
-  id               String   @id @default(uuid())
+  id               String    @id @default(uuid())
   ticketId         String
   scannedById      String
-  scannedAt        DateTime @default(now())
-  quantityRedeemed Int      @default(1)
-  ticket           Ticket   @relation(fields: [ticketId], references: [id], onDelete: Restrict)
-  scannedBy        User     @relation(fields: [scannedById], references: [id], onDelete: Restrict)
+  scannedAt        DateTime  @default(now())
+  quantityRedeemed Int       @default(1)
+  // Offline scanning: the device's id for the scan (makes syncing idempotent), and
+  // the offline lock it was made under.
+  clientScanId     String?   @unique
+  offline          Boolean   @default(false)
+  scanLockId       String?
+  syncedAt         DateTime?
+  ticket           Ticket    @relation(fields: [ticketId], references: [id], onDelete: Restrict)
+  scannedBy        User      @relation(fields: [scannedById], references: [id], onDelete: Restrict)
+  scanLock         ScanLock? @relation(fields: [scanLockId], references: [id], onDelete: SetNull)
 
   @@index([ticketId])
   @@index([scannedAt])
@@ -438,6 +469,13 @@ enum AdminAuditAction {
   coupon_updated
   coupon_disabled
   coupon_applied_manual
+  consent_override
+  consent_rerequested
+  medical_list_viewed
+  scan_lock_acquired
+  scan_lock_released
+  scan_lock_force_released
+  offline_sync
 }
 
 // Append-only audit trail for admin/supervisor-initiated actions with money or
@@ -578,6 +616,7 @@ model Section {
 
   event          Event           @relation(fields: [eventId], references: [id], onDelete: Cascade)
   allowedOptions SectionOption[]
+  scanLocks      ScanLock[]
 
   @@index([eventId])
 }
@@ -963,6 +1002,9 @@ model Attendee {
   userId               String? // existing account matched by email/phone
   dateOfBirth          DateTime?
   gender               String?
+  parentName           String?
+  parentEmail          String?
+  parentPhone          String?
   order                Int                 @default(0)
   createdAt            DateTime            @default(now())
   updatedAt            DateTime            @updatedAt
@@ -971,8 +1013,139 @@ model Attendee {
   user                 User?               @relation(fields: [userId], references: [id], onDelete: SetNull)
   ticket               Ticket?
   formResponses        FormResponse[]
+  consentRequests      ConsentRequest[]
 
   @@index([registrationId])
   @@index([registrationOptionId])
   @@index([userId])
 }
+
+// ─── Parental consent ─────────────────────────────────────────────────────────
+
+enum ConsentStatus {
+  pending
+  given
+  declined
+}
+
+// A request for a parent/guardian to consent for one under-18 attendee. Only the hash
+// of the link token is stored. A new request (e.g. after the consent text changes)
+// supersedes earlier ones for the same attendee; the latest one decides check-in.
+model ConsentRequest {
+  id              String        @id @default(uuid())
+  attendeeId      String
+  eventId         String
+  tokenHash       String        @unique
+  status          ConsentStatus @default(pending)
+  textVersion     Int
+  consentText     String // the exact text the parent was shown
+  parentName      String?
+  parentEmail     String?
+  parentPhone     String?
+  signedName      String?
+  ip              String?
+  device          String?
+  medical         String? // encrypted JSON (utils/encryption.js); purged after the event
+  emergency       String? // encrypted JSON; purged after the event
+  photoConsent    Boolean?
+  respondedAt     DateTime?
+  lastSentAt      DateTime      @default(now())
+  remindersSent   Int           @default(0)
+  expiresAt       DateTime
+  medicalPurgedAt DateTime?
+  createdAt       DateTime      @default(now())
+  attendee        Attendee      @relation(fields: [attendeeId], references: [id], onDelete: Cascade)
+  event           Event         @relation(fields: [eventId], references: [id], onDelete: Cascade)
+
+  @@index([attendeeId, createdAt])
+  @@index([eventId, status])
+}
+
+// ─── Waitlist ─────────────────────────────────────────────────────────────────
+
+enum WaitlistStatus {
+  waiting
+  offered // places held for them until offerExpiresAt
+  claimed // they registered with the offer
+  expired // the offer ran out
+  removed // taken off by staff
+  left // they left the waitlist
+}
+
+model WaitlistEntry {
+  id              String         @id @default(uuid())
+  eventId         String
+  eventOptionId   String
+  variantId       String?
+  userId          String
+  quantity        Int
+  position        Int
+  status          WaitlistStatus @default(waiting)
+  offeredQuantity Int?
+  offerTokenHash  String?        @unique
+  offeredAt       DateTime?
+  offerExpiresAt  DateTime?
+  claimedAt       DateTime?
+  registrationId  String?
+  createdAt       DateTime       @default(now())
+  updatedAt       DateTime       @updatedAt
+  event           Event          @relation(fields: [eventId], references: [id], onDelete: Cascade)
+  eventOption     EventOption    @relation(fields: [eventOptionId], references: [id], onDelete: Cascade)
+  variant         OptionVariant? @relation(fields: [variantId], references: [id], onDelete: Cascade)
+  user            User           @relation(fields: [userId], references: [id], onDelete: Cascade)
+  registration    Registration?  @relation(fields: [registrationId], references: [id], onDelete: SetNull)
+
+  @@index([eventId, status, position])
+  @@index([eventOptionId, status])
+  @@index([variantId])
+  @@index([userId])
+  @@index([registrationId])
+}
+
+// ─── Offline scanning ─────────────────────────────────────────────────────────
+
+// Locks a section (or the whole event, sectionId null) to one device for offline
+// scanning, so two devices can never redeem the same ticket while offline.
+// One active (releasedAt null) lock per scope — enforced in utils/scanLocks.js.
+model ScanLock {
+  id                String              @id @default(uuid())
+  eventId           String
+  sectionId         String?
+  deviceId          String
+  deviceName        String?
+  userId            String
+  lockedAt          DateTime            @default(now())
+  snapshotAt        DateTime?
+  lastSyncAt        DateTime?
+  releasedAt        DateTime?
+  forceReleasedById String?
+  event             Event               @relation(fields: [eventId], references: [id], onDelete: Cascade)
+  section           Section?            @relation(fields: [sectionId], references: [id], onDelete: Cascade)
+  user              User                @relation("ScanLockOwner", fields: [userId], references: [id], onDelete: Cascade)
+  forceReleasedBy   User?               @relation("ScanLockForcedBy", fields: [forceReleasedById], references: [id], onDelete: SetNull)
+  usages            TicketUsage[]
+  syncReports       OfflineSyncReport[]
+
+  @@index([eventId, releasedAt])
+  @@index([userId])
+  @@index([sectionId])
+  @@index([forceReleasedById])
+}
+
+// One sync of queued offline scans; `conflicts` lists scans that needed a person to look.
+model OfflineSyncReport {
+  id                String    @id @default(uuid())
+  scanLockId        String
+  accepted          Int       @default(0)
+  duplicates        Int       @default(0)
+  conflicts         Json      @default("[]")
+  afterForceRelease Boolean   @default(false)
+  createdAt         DateTime  @default(now())
+  reviewedAt        DateTime?
+  reviewedById      String?
+  scanLock          ScanLock  @relation(fields: [scanLockId], references: [id], onDelete: Cascade)
+  reviewedBy        User?     @relation("SyncReportReviewer", fields: [reviewedById], references: [id], onDelete: SetNull)
+
+  @@index([scanLockId])
+  @@index([reviewedById])
+}

backend/src/controllers/consentController.js

@@ -0,0 +1,264 @@
+const prisma = require('../config/db');
+const { safeErrorMessage } = require('../utils/errorUtils');
+const { logAdminAction } = require('../utils/adminAudit');
+const { getClientIp } = require('../utils/requestUtils');
+const { describeUserAgent } = require('../utils/userAgent');
+const {
+  isMinor, consentStatusFor, validateConsentAnswer, sealJson, openJson, latestRequestsFor,
+  findRequestByToken, resendConsentRequest, createConsentRequest,
+} = require('../utils/consent');
+
+const STAFF = ['admin', 'supervisor', 'staff'];
+const fail = (res, error) => res.status(error.statusCode || (res.statusCode === 200 ? 400 : res.statusCode)).json({ message: safeErrorMessage(error) });
+
+// What the parent sees — never the registrant's contact details or other attendees.
+function publicView(request) {
+  const ev = request.event;
+  const latestForAttendee = request._isLatest !== false;
+  return {
+    status: request.status,
+    superseded: !latestForAttendee,
+    expired: new Date(request.expiresAt) < new Date(),
+    respondedAt: request.respondedAt,
+    attendeeName: request.attendee.name,
+    parentName: request.parentName,
+    consentText: request.consentText,
+    textVersion: request.textVersion,
+    event: { title: ev.title, startDate: ev.startDate, endDate: ev.endDate, location: ev.location },
+    collect: { medical: ev.consentCollectMedical, emergency: ev.consentCollectEmergency, photo: ev.consentCollectPhoto },
+  };
+}
+
+// @desc    Consent page data for a parent/guardian
+// @route   GET /api/consent/:token
+// @access  Public (the token is the credential)
+const getConsent = async (req, res) => {
+  try {
+    const request = await findRequestByToken(req.params.token);
+    if (!request) { res.status(404); throw new Error('This consent link is not valid. It may have been replaced by a newer one — check your latest message.'); }
+    const latest = (await latestRequestsFor([request.attendeeId])).get(request.attendeeId);
+    res.json(publicView({ ...request, _isLatest: latest?.id === request.id }));
+  } catch (error) {
+    fail(res, error);
+  }
+};
+
+// @desc    Give or decline consent
+// @route   POST /api/consent/:token
+// @access  Public (the token is the credential)
+const answerConsent = async (req, res) => {
+  try {
+    const request = await findRequestByToken(req.params.token);
+    if (!request) { res.status(404); throw new Error('This consent link is not valid.'); }
+    if (request.status !== 'pending') { res.status(409); throw new Error(`Consent has already been ${request.status}.`); }
+    if (new Date(request.expiresAt) < new Date()) { res.status(410); throw new Error('This consent link has expired because the event has ended.'); }
+    const latest = (await latestRequestsFor([request.attendeeId])).get(request.attendeeId);
+    if (latest?.id !== request.id) { res.status(409); throw new Error('A newer consent request replaced this one — please use the link in your latest message.'); }
+
+    let answer;
+    try { answer = validateConsentAnswer(req.body || {}, request.event); } catch (e) { res.status(400); throw e; }
+
+    // Only flips pending → answered once, even if the form is submitted twice at once.
+    const updated = await prisma.consentRequest.updateMany({
+      where: { id: request.id, status: 'pending' },
+      data: {
+        status: answer.decision === 'give' ? 'given' : 'declined',
+        signedName: answer.signedName,
+        ip: getClientIp(req),
+        device: describeUserAgent(req.headers['user-agent']),
+        medical: sealJson(answer.medical),
+        emergency: sealJson(answer.emergency),
+        photoConsent: answer.photoConsent,
+        respondedAt: new Date(),
+      },
+    });
+    if (updated.count !== 1) { res.status(409); throw new Error('Consent has already been answered.'); }
+
+    notifyConsentAnswered(request.id).catch(e => console.error('[consent] notify failed:', e?.message || e));
+    res.json({ message: answer.decision === 'give' ? 'Thank you — consent has been given.' : 'Thank you — consent has been declined.', status: answer.decision === 'give' ? 'given' : 'declined' });
+  } catch (error) {
+    fail(res, error);
+  }
+};
+
+// Tells the registrant and the event's notify recipients how a parent answered.
+async function notifyConsentAnswered(requestId) {
+  const request = await prisma.consentRequest.findUnique({
+    where: { id: requestId },
+    include: {
+      attendee: { include: { registration: { include: { user: { select: { id: true, name: true, email: true, phoneNumber: true, notificationPreference: true } } } } } },
+      event: { include: { createdBy: { select: { id: true, name: true, email: true } }, notifyRecipients: { select: { id: true, name: true, email: true } } } },
+    },
+  });
+  if (!request) return;
+  const { sendMail, emailWrapper } = require('../utils/email');
+  const { shouldEmail, waText } = require('../utils/notify');
+  const { buildEventNotifyRecipientList } = require('../utils/notifications');
+  const given = request.status === 'given';
+  const verb = given ? 'given' : 'declined';
+  const who = request.attendee.name;
+  const ev = request.event.title;
+  const payer = request.attendee.registration.user;
+  const line = given
+    ? `${request.signedName} gave parental consent for ${who} for ${ev}.`
+    : `${request.signedName} declined parental consent for ${who} for ${ev}. ${who} can't be checked in — please contact the organisers about a refund.`;
+
+  const sends = [];
+  const payerHasEmail = payer?.email && !payer.email.endsWith('@guest.local') && !payer.email.endsWith('@deleted.invalid');
+  if (payerHasEmail && shouldEmail(payer) && payer.email !== request.parentEmail) {
+    sends.push(sendMail({ to: payer.email, subject: `Consent ${verb} for ${who}`, html: emailWrapper(`<p>${line}</p>`), text: line }));
+  }
+  if (payer) sends.push(waText(payer, line));
+  const staff = buildEventNotifyRecipientList(request.event);
+  if (staff.length) {
+    sends.push(sendMail({ to: staff.join(','), subject: `Consent ${verb}: ${who} — ${ev}`, html: emailWrapper(`<p>${line}</p>`), text: line }));
+  }
+  await Promise.allSettled(sends);
+}
+
+/** One row per attendee on the event, with consent state — for the consent tracker. */
+async function consentRows(eventId) {
+  const event = await prisma.event.findUnique({ where: { id: eventId } });
+  if (!event) return { event: null, rows: [] };
+  const attendees = await prisma.attendee.findMany({
+    where: { registration: { eventId, status: { not: 'cancelled' } } },
+    include: { registration: { select: { id: true, status: true, user: { select: { id: true, name: true, email: true } } } } },
+    orderBy: [{ registrationId: 'asc' }, { order: 'asc' }],
+  });
+  const latest = await latestRequestsFor(attendees.map(a => a.id));
+  const rows = attendees.map(a => {
+    const r = latest.get(a.id) || null;
+    return {
+      attendeeId: a.id,
+      name: a.name,
+      dateOfBirth: a.dateOfBirth,
+      minor: isMinor(a.dateOfBirth, event.startDate),
+      parentName: a.parentName, parentEmail: a.parentEmail, parentPhone: a.parentPhone,
+      registrationId: a.registrationId,
+      registrationStatus: a.registration.status,
+      bookedBy: a.registration.user,
+      status: consentStatusFor(a, event, r),
+      request: r && {
+        id: r.id, status: r.status, textVersion: r.textVersion, signedName: r.signedName, respondedAt: r.respondedAt,
+        lastSentAt: r.lastSentAt, remindersSent: r.remindersSent, photoConsent: r.photoConsent,
+        outdated: r.status === 'given' && r.textVersion < (event.consentTextVersion || 1),
+      },
+    };
+  });
+  return { event, rows };
+}
+
+// @desc    Consent status for every attendee on an event
+// @route   GET /api/consent/events/:eventId
+// @access  Private/Staff
+const listEventConsent = async (req, res) => {
+  try {
+    const { event, rows } = await consentRows(req.params.eventId);
+    if (!event) { res.status(404); throw new Error('Event not found'); }
+    const counts = rows.reduce((c, r) => { c[r.status] = (c[r.status] || 0) + 1; return c; }, {});
+    res.json({
+      event: { id: event.id, title: event.title, startDate: event.startDate, requiresParentalConsent: event.requiresParentalConsent, consentTextVersion: event.consentTextVersion },
+      counts,
+      rows,
+    });
+  } catch (error) {
+    fail(res, error);
+  }
+};
+
+// @desc    Re-send one consent request (with a fresh link)
+// @route   POST /api/consent/requests/:id/resend
+// @access  Private (the registrant, or staff)
+const resendRequest = async (req, res) => {
+  try {
+    const request = await prisma.consentRequest.findUnique({ where: { id: req.params.id }, include: { attendee: { include: { registration: true } } } });
+    if (!request) { res.status(404); throw new Error('Consent request not found'); }
+    if (request.attendee.registration.userId !== req.user.id && !STAFF.includes(req.user.role)) { res.status(403); throw new Error('Not authorized'); }
+    const latest = (await latestRequestsFor([request.attendeeId])).get(request.attendeeId);
+    if (latest?.id !== request.id) { res.status(400); throw new Error('A newer consent request has replaced this one.'); }
+    const sent = await resendConsentRequest(request.id);
+    res.json({ message: sent.length ? `Consent request re-sent by ${sent.join(' and ')}.` : 'The consent request could not be sent — check the parent\'s email and phone.' });
+  } catch (error) {
+    fail(res, error);
+  }
+};
+
+// @desc    Re-send every consent request still pending on an event
+// @route   POST /api/consent/events/:eventId/resend-pending
+// @access  Private/Supervisor
+const resendPending = async (req, res) => {
+  try {
+    const { rows } = await consentRows(req.params.eventId);
+    const pending = rows.filter(r => r.status === 'pending' && r.request);
+    let sent = 0;
+    for (const r of pending) {
+      try { if ((await resendConsentRequest(r.request.id)).length) sent += 1; } catch {}
+    }
+    res.json({ message: `Re-sent ${sent} of ${pending.length} pending request(s).`, sent, pending: pending.length });
+  } catch (error) {
+    fail(res, error);
+  }
+};
+
+// @desc    Ask again for consent where it was given on an older version of the text,
+//          and for minors who never got a request (e.g. names added later)
+// @route   POST /api/consent/events/:eventId/rerequest
+// @access  Private/Supervisor
+const rerequestConsent = async (req, res) => {
+  try {
+    const { event, rows } = await consentRows(req.params.eventId);
+    if (!event) { res.status(404); throw new Error('Event not found'); }
+    if (!event.requiresParentalConsent) { res.status(400); throw new Error('This event does not need parental consent.'); }
+    const targets = rows.filter(r => r.minor && r.registrationStatus !== 'cancelled' && (r.status === 'missing' || r.request?.outdated));
+    let created = 0;
+    for (const r of targets) {
+      if (!r.parentEmail && !r.parentPhone) continue;
+      const attendee = await prisma.attendee.findUnique({ where: { id: r.attendeeId } });
+      await createConsentRequest(attendee, event);
+      created += 1;
+    }
+    logAdminAction({
+      actorId: req.user.id, actorRole: req.user.role, action: 'consent_rerequested',
+      targetType: 'Event', targetId: event.id, metadata: { requests: created, textVersion: event.consentTextVersion },
+      ip: getClientIp(req),
+    });
+    res.json({ message: `Sent ${created} new consent request(s).`, created });
+  } catch (error) {
+    fail(res, error);
+  }
+};
+
+// @desc    Medical & emergency list for an event (decrypted) — every view is audited
+// @route   GET /api/consent/events/:eventId/medical
+// @access  Private/Supervisor
+const medicalList = async (req, res) => {
+  try {
+    const event = await prisma.event.findUnique({ where: { id: req.params.eventId } });
+    if (!event) { res.status(404); throw new Error('Event not found'); }
+    const { rows } = await consentRows(event.id);
+    const ids = rows.map(r => r.request?.id).filter(Boolean);
+    const full = ids.length ? await prisma.consentRequest.findMany({ where: { id: { in: ids } } }) : [];
+    const byId = new Map(full.map(r => [r.id, r]));
+    const list = rows
+      .filter(r => r.request && byId.get(r.request.id)?.status === 'given')
+      .map(r => {
+        const fr = byId.get(r.request.id);
+        return {
+          name: r.name, dateOfBirth: r.dateOfBirth,
+          parentName: r.parentName, parentPhone: r.parentPhone, parentEmail: r.parentEmail,
+          medical: openJson(fr.medical), emergency: openJson(fr.emergency), photoConsent: fr.photoConsent,
+          purged: !!fr.medicalPurgedAt,
+        };
+      });
+    logAdminAction({
+      actorId: req.user.id, actorRole: req.user.role, action: 'medical_list_viewed',
+      targetType: 'Event', targetId: event.id, metadata: { attendees: list.length },
+      ip: getClientIp(req),
+    });
+    res.json({ event: { id: event.id, title: event.title, startDate: event.startDate }, rows: list });
+  } catch (error) {
+    fail(res, error);
+  }
+};
+
+module.exports = { getConsent, answerConsent, listEventConsent, resendRequest, resendPending, rerequestConsent, medicalList };

backend/src/controllers/eventController.js

@@ -44,7 +44,7 @@ function toAbsoluteUrl(req, url) {
 // @access  Private/Admin
 const createEvent = async (req, res) => {
   try {
-    const { title, description, startDate, endDate, registrationDeadline, goLiveAt, price, picture, redirectUrl, isHidden, requiresAuth, requiresRegistration, allowNamedAttendees, contactName, contactPhone, contactEmail, location } = req.body;
+    const { title, description, startDate, endDate, registrationDeadline, goLiveAt, price, picture, redirectUrl, isHidden, requiresAuth, requiresRegistration, allowNamedAttendees, requiresParentalConsent, consentText, consentCollectMedical, consentCollectEmergency, consentCollectPhoto, waitlistEnabled, waitlistOfferHours, waitlistPartialOffers, contactName, contactPhone, contactEmail, location } = req.body;
 
     const data = {
       id: uuidv4(),
@@ -62,7 +62,16 @@ const createEvent = async (req, res) => {
       isHidden: isHidden === true || isHidden === 'true',
       requiresAuth: requiresAuth === false || requiresAuth === 'false' ? false : true,
       requiresRegistration: requiresRegistration === false || requiresRegistration === 'false' ? false : true,
-      allowNamedAttendees: allowNamedAttendees === true || allowNamedAttendees === 'true',
+      // A youth event needs names (with dates of birth), so it always takes them.
+      allowNamedAttendees: allowNamedAttendees === true || allowNamedAttendees === 'true' || requiresParentalConsent === true,
+      requiresParentalConsent: requiresParentalConsent === true,
+      consentText: consentText ? String(consentText) : null,
+      consentCollectMedical: consentCollectMedical === true,
+      consentCollectEmergency: consentCollectEmergency === true,
+      consentCollectPhoto: consentCollectPhoto === true,
+      waitlistEnabled: waitlistEnabled === true,
+      waitlistOfferHours: Math.min(168, Math.max(1, parseInt(waitlistOfferHours, 10) || 24)),
+      waitlistPartialOffers: waitlistPartialOffers !== false,
       contactName: contactName || null,
       contactPhone: contactPhone || null,
       contactEmail: contactEmail || null,
@@ -213,12 +222,8 @@ const getEvents = async (req, res) => {
         const limitedOpts = (ev.eventOptions || []).filter(o => (o.stockLimit || 0) > 0);
         let isSoldOut = false;
         if (limitedOpts.length > 0) {
-          const soldCounts = await Promise.all(limitedOpts.map(opt =>
-            prisma.registrationOption.aggregate({
-              where: { eventOptionId: opt.id, registration: { status: { not: 'cancelled' } } },
-              _sum: { quantity: true },
-            }).then(r => r._sum?.quantity || 0)
-          ));
+          const { takenCount } = require('../utils/stock');
+          const soldCounts = await Promise.all(limitedOpts.map(opt => takenCount({ eventOptionId: opt.id })));
           isSoldOut = limitedOpts.every((opt, i) => soldCounts[i] >= opt.stockLimit);
         }
         return { ...ev, picture: toAbsoluteUrl(req, ev.picture), isSoldOut };
@@ -419,22 +424,15 @@ const getEventById = async (req, res) => {
     try {
       if (canIncludeVariants) {
         eventOptionsWithStock = await Promise.all((event.eventOptions || []).map(async opt => {
-          // Total sold quantity for this option (all non-cancelled)
-          const soldAgg = await prisma.registrationOption.aggregate({
-            where: { eventOptionId: opt.id, registration: { status: { not: 'cancelled' } } },
-            _sum: { quantity: true }
-          });
-          const soldCount = soldAgg._sum?.quantity || 0;
+          // Taken = non-cancelled registrations + places held for live waitlist offers
+          const { takenCount } = require('../utils/stock');
+          const soldCount = await takenCount({ eventOptionId: opt.id });
           const availableCount = opt.stockLimit > 0 ? Math.max(0, opt.stockLimit - soldCount) : null;
 
           // Per-variant stock
           const variantsWithStock = await Promise.all((opt.variants || []).map(async v => {
             if (!v.stockLimit) return { ...v, soldCount: 0, availableCount: null };
-            const vAgg = await prisma.registrationOption.aggregate({
-              where: { variantId: v.id, registration: { status: { not: 'cancelled' } } },
-              _sum: { quantity: true }
-            });
-            const vSold = vAgg._sum?.quantity || 0;
+            const vSold = await takenCount({ eventOptionId: opt.id, variantId: v.id });
             return { ...v, soldCount: vSold, availableCount: Math.max(0, v.stockLimit - vSold) };
           }));
 
@@ -538,7 +536,7 @@ const updateEvent = async (req, res) => {
       ip: getClientIp(req),
     });
 
-    const { title, description, startDate, endDate, registrationDeadline, goLiveAt, price, picture, isActive, redirectUrl, isHidden, requiresAuth, requiresRegistration, allowNamedAttendees, contactName, contactPhone, contactEmail, location } = req.body;
+    const { title, description, startDate, endDate, registrationDeadline, goLiveAt, price, picture, isActive, redirectUrl, isHidden, requiresAuth, requiresRegistration, allowNamedAttendees, requiresParentalConsent, consentText, consentCollectMedical, consentCollectEmergency, consentCollectPhoto, waitlistEnabled, waitlistOfferHours, waitlistPartialOffers, contactName, contactPhone, contactEmail, location } = req.body;
 
     const data = {
       title: title || event.title,
@@ -553,7 +551,21 @@ const updateEvent = async (req, res) => {
       isHidden: isHidden !== undefined ? (isHidden === true || isHidden === 'true') : (event.isHidden ?? false),
       requiresAuth: requiresAuth !== undefined ? !(requiresAuth === false || requiresAuth === 'false') : (event.requiresAuth ?? true),
       requiresRegistration: requiresRegistration !== undefined ? !(requiresRegistration === false || requiresRegistration === 'false') : (event.requiresRegistration ?? true),
-      allowNamedAttendees: allowNamedAttendees !== undefined ? (allowNamedAttendees === true || allowNamedAttendees === 'true') : event.allowNamedAttendees,
+      allowNamedAttendees: (requiresParentalConsent ?? event.requiresParentalConsent) === true
+        ? true
+        : (allowNamedAttendees !== undefined ? (allowNamedAttendees === true || allowNamedAttendees === 'true') : event.allowNamedAttendees),
+      requiresParentalConsent: requiresParentalConsent !== undefined ? requiresParentalConsent === true : event.requiresParentalConsent,
+      consentCollectMedical: consentCollectMedical !== undefined ? consentCollectMedical === true : event.consentCollectMedical,
+      consentCollectEmergency: consentCollectEmergency !== undefined ? consentCollectEmergency === true : event.consentCollectEmergency,
+      consentCollectPhoto: consentCollectPhoto !== undefined ? consentCollectPhoto === true : event.consentCollectPhoto,
+      waitlistEnabled: waitlistEnabled !== undefined ? waitlistEnabled === true : event.waitlistEnabled,
+      waitlistOfferHours: waitlistOfferHours !== undefined ? Math.min(168, Math.max(1, parseInt(waitlistOfferHours, 10) || 24)) : event.waitlistOfferHours,
+      waitlistPartialOffers: waitlistPartialOffers !== undefined ? waitlistPartialOffers !== false : event.waitlistPartialOffers,
+      // Editing the consent text starts a new version; parents who already agreed keep
+      // their record of the old one (supervisors can re-request consent).
+      ...(consentText !== undefined && String(consentText || '') !== String(event.consentText || '')
+        ? { consentText: consentText ? String(consentText) : null, consentTextVersion: (event.consentTextVersion || 1) + 1 }
+        : {}),
       contactName: contactName !== undefined ? (contactName || null) : event.contactName,
       contactPhone: contactPhone !== undefined ? (contactPhone || null) : event.contactPhone,
       contactEmail: contactEmail !== undefined ? (contactEmail || null) : event.contactEmail,
@@ -882,6 +894,10 @@ const updateEventOption = async (req, res) => {
       }
     }
 
+    if (stockLimit !== undefined || variants !== undefined) {
+      require('../utils/waitlist').queueWaitlist(eventOption.eventId);
+    }
+
     const refreshed = await prisma.eventOption.findUnique({
       where: { id: updatedEventOption.id },
       include: { earlyBirdTiers: true, variants: { orderBy: { order: 'asc' } } }

backend/src/controllers/registrationController.js

@@ -10,11 +10,24 @@ const { getClientIp } = require('../utils/requestUtils');
 const { buildCouponLines, previewCoupon, applyCouponToRegistration, recalculateRegistrationDiscount, releaseRegistrationCoupons, describeCoupon } = require('../utils/coupons');
 const { lineKey, validateAttendees, createAttendees, namedPlacesByKey } = require('../utils/attendees');
 const { findAccountByContact } = require('../utils/accountMatch');
+const { ensureConsentRequests } = require('../utils/consent');
+const { takenCount } = require('../utils/stock');
+const { findOfferByToken, queueWaitlist } = require('../utils/waitlist');
+
+// Youth events: send parental consent requests for any new under-18 attendees. Runs in
+// the background so a slow mail/WhatsApp send never holds up the registration.
+function queueConsentRequests(registrationId) {
+  ensureConsentRequests(registrationId).catch(e => console.error('[consent] Failed to send requests:', e?.message || e));
+}
 
 // Named attendees for API responses, with whether their ticket has been issued/used.
 const ATTENDEES_INCLUDE = {
   orderBy: { order: 'asc' },
-  include: { ticket: { select: { id: true, isUsed: true } } },
+  include: {
+    ticket: { select: { id: true, isUsed: true } },
+    // Latest consent request (youth events) — it decides check-in.
+    consentRequests: { orderBy: { createdAt: 'desc' }, take: 1, select: { id: true, status: true, respondedAt: true, lastSentAt: true, textVersion: true } },
+  },
 };
 
 const TICKET_DELIVERY = ['payer', 'each'];
@@ -73,33 +86,22 @@ async function priceRequestedOption(eventOption, variantId, qty, buyer) {
 }
 
 /**
- * Check overall stock availability for an EventOption.
+ * Check overall stock availability for an EventOption. Places held for live waitlist
+ * offers count as taken, except the offer being claimed (`excludeEntryId`).
  * Returns { available: boolean, remaining: number|null }
  */
-async function checkOptionStock(option, requestedQty) {
+async function checkOptionStock(option, requestedQty, excludeEntryId = null) {
   if (!option.stockLimit || option.stockLimit === 0) return { available: true, remaining: null };
-
-  const soldAgg = await prisma.registrationOption.aggregate({
-    where: { eventOptionId: option.id, registration: { status: { not: 'cancelled' } } },
-    _sum: { quantity: true }
-  });
-  const sold = soldAgg._sum?.quantity || 0;
-  const remaining = option.stockLimit - sold;
+  const remaining = option.stockLimit - await takenCount({ eventOptionId: option.id }, { excludeEntryId });
   return { available: remaining >= requestedQty, remaining };
 }
 
 /**
- * Check stock availability for a specific variant.
+ * Check stock availability for a specific variant (same rules as checkOptionStock).
  */
-async function checkVariantStock(variant, requestedQty) {
+async function checkVariantStock(variant, requestedQty, excludeEntryId = null) {
   if (!variant.stockLimit || variant.stockLimit === 0) return { available: true, remaining: null };
-
-  const soldAgg = await prisma.registrationOption.aggregate({
-    where: { variantId: variant.id, registration: { status: { not: 'cancelled' } } },
-    _sum: { quantity: true }
-  });
-  const sold = soldAgg._sum?.quantity || 0;
-  const remaining = variant.stockLimit - sold;
+  const remaining = variant.stockLimit - await takenCount({ eventOptionId: variant.eventOptionId, variantId: variant.id }, { excludeEntryId });
   return { available: remaining >= requestedQty, remaining };
 }
 
@@ -108,7 +110,7 @@ async function checkVariantStock(variant, requestedQty) {
 // @access  Private
 const createRegistration = async (req, res) => {
   try {
-    const { eventId, options, guestName, guestEmail, guestPhone, couponCode, attendees, ticketDelivery } = req.body;
+    const { eventId, options, guestName, guestEmail, guestPhone, couponCode, attendees, ticketDelivery, waitlistToken } = req.body;
 
     // Check if event exists
     const canIncludeVariants = !!(prisma && prisma.optionVariant && typeof prisma.optionVariant.findMany === 'function');
@@ -136,15 +138,26 @@ const createRegistration = async (req, res) => {
       throw new Error('This event is closed and no longer accepting registrations.');
     }
 
+    // A waitlist claim link: its token identifies the person and releases the places
+    // held for them. It works without logging in, the same way a consent link does.
+    let waitlistOffer = null;
+    if (waitlistToken) {
+      waitlistOffer = await findOfferByToken(waitlistToken);
+      if (!waitlistOffer || waitlistOffer.eventId !== eventId) { res.status(400); throw new Error('This waitlist link is not valid.'); }
+      if (waitlistOffer.status !== 'offered') { res.status(400); throw new Error(`This waitlist offer has ${waitlistOffer.status === 'claimed' ? 'already been used' : 'expired'}.`); }
+      if (new Date(waitlistOffer.offerExpiresAt) < new Date()) { res.status(400); throw new Error('This waitlist offer has expired.'); }
+      if (req.user && req.user.id !== waitlistOffer.userId) { res.status(403); throw new Error('This waitlist offer belongs to someone else.'); }
+    }
+
     // Enforce auth unless event explicitly opts out
     const eventRequiresAuth = event.requiresAuth !== false;
-    if (eventRequiresAuth && !req.user) {
+    if (eventRequiresAuth && !req.user && !waitlistOffer) {
       res.status(401);
       throw new Error('Authentication required for this event');
     }
 
     // Unauthenticated guest registration is only permitted for free events
-    if (!req.user) {
+    if (!req.user && !waitlistOffer) {
       const totalDueCheck = (event.eventOptions || []).reduce((sum, eo) => sum + (eo.price || 0), 0);
       // Also check against the requested options specifically
       const requestedTotal = (options || []).reduce((sum, opt) => {
@@ -161,6 +174,8 @@ const createRegistration = async (req, res) => {
     let userId;
     if (req.user) {
       userId = req.user.id;
+    } else if (waitlistOffer) {
+      userId = waitlistOffer.userId;
     } else {
       // Guest registration: find existing user by email or create inactive placeholder
       if (!guestEmail || !guestName) {
@@ -223,7 +238,7 @@ const createRegistration = async (req, res) => {
 
       // Check overall option stock
       try {
-        const stockCheck = await checkOptionStock(eventOption, qty);
+        const stockCheck = await checkOptionStock(eventOption, qty, waitlistOffer?.id);
         if (!stockCheck.available) {
           const err = new Error(`"${eventOption.name}" is sold out or does not have enough stock (${stockCheck.remaining ?? 0} remaining).`);
           err.isStockError = true;
@@ -243,7 +258,7 @@ const createRegistration = async (req, res) => {
           throw new Error(`Variant not found for option "${eventOption.name}"`);
         }
         try {
-          const vStock = await checkVariantStock(variant, qty);
+          const vStock = await checkVariantStock(variant, qty, waitlistOffer?.id);
           if (!vStock.available) {
             const err = new Error(`Variant "${variant.name}" is sold out (${vStock.remaining ?? 0} remaining).`);
             err.isStockError = true;
@@ -260,7 +275,8 @@ const createRegistration = async (req, res) => {
       let priceSnapshot = null;
       let appliedTierId = null;
       if (canIncludeTiers) {
-        ({ priceSnapshot, appliedTierId } = await priceRequestedOption(eventOption, variantId, qty, req.user));
+        const buyer = req.user || (waitlistOffer ? await prisma.user.findUnique({ where: { id: waitlistOffer.userId }, select: { id: true, role: true } }) : null);
+        ({ priceSnapshot, appliedTierId } = await priceRequestedOption(eventOption, variantId, qty, buyer));
       } else {
         priceSnapshot = variantPrice !== null && variantPrice !== undefined ? variantPrice : null;
       }
@@ -399,7 +415,16 @@ const createRegistration = async (req, res) => {
       });
     }
 
-    if (cleanAttendees.length > 0) await createAttendees(registration.id, cleanAttendees);
+    if (cleanAttendees.length > 0) {
+      await createAttendees(registration.id, cleanAttendees);
+      queueConsentRequests(registration.id);
+    }
+    if (waitlistOffer) {
+      await prisma.waitlistEntry.update({
+        where: { id: waitlistOffer.id },
+        data: { status: 'claimed', claimedAt: new Date(), registrationId: registration.id, offerTokenHash: null },
+      });
+    }
     if (ticketDelivery) {
       await prisma.registration.update({ where: { id: registration.id }, data: { ticketDelivery } });
     }
@@ -724,6 +749,7 @@ const updateRegistrationStatus = async (req, res) => {
     // paths land under the one 'registration_cancelled' filter in the audit log.
     if (status === 'cancelled' && registration.status !== 'cancelled') {
       await releaseRegistrationCoupons(req.params.id);
+      queueWaitlist(registration.eventId);
       logAdminAction({
         actorId: req.user.id,
         actorRole: req.user.role,
@@ -809,6 +835,7 @@ const cancelRegistration = async (req, res) => {
       }
     });
     await releaseRegistrationCoupons(req.params.id);
+    queueWaitlist(registration.eventId);
 
     // Only log when staff cancels on someone else's behalf — a routine self-service
     // cancellation isn't an admin action worth cluttering the audit trail with.
@@ -918,7 +945,8 @@ const createManualRegistration = async (req, res) => {
       throw new Error('At least one option must be selected');
     }
 
-    // Validate each option up front, before any account is created or changed.
+    // Validate each option up front, before any account is created or changed —
+    // including stock, which staff registrations previously skipped.
     for (const option of options) {
       const eventOption = event.eventOptions.find(eo => eo.id === option.eventOptionId);
       if (!eventOption) {
@@ -929,6 +957,14 @@ const createManualRegistration = async (req, res) => {
         res.status(400);
         throw new Error('Quantity must be at least 1');
       }
+      const variant = option.variantId ? (eventOption.variants || []).find(v => v.id === option.variantId) : null;
+      const oStock = await checkOptionStock(eventOption, option.quantity);
+      const vStock = variant ? await checkVariantStock(variant, option.quantity) : { available: true };
+      if (!oStock.available || !vStock.available) {
+        res.status(400);
+        const left = Math.max(0, Math.min(oStock.remaining ?? Infinity, vStock.remaining ?? Infinity));
+        throw new Error(`"${eventOption.name}${variant ? ` (${variant.name})` : ''}" is sold out or does not have enough stock (${left} remaining). Raise the stock limit to add more.`);
+      }
     }
 
     // Pricing (appliedTierId + priceSnapshot) depends on who the attendee is — Staff and
@@ -1241,7 +1277,10 @@ const createManualRegistration = async (req, res) => {
 
     const registrationId = registration.id;
 
-    if (cleanAttendees.length > 0) await createAttendees(registrationId, cleanAttendees);
+    if (cleanAttendees.length > 0) {
+      await createAttendees(registrationId, cleanAttendees);
+      queueConsentRequests(registrationId);
+    }
     if (ticketDelivery) await prisma.registration.update({ where: { id: registrationId }, data: { ticketDelivery } });
 
     if (couponCode && !couponError) {
@@ -1491,6 +1530,15 @@ const updateRegistrationOptions = async (req, res) => {
       let removalPlan = null;
 
       if (delta > 0) {
+        // Adding places needs stock, like a new registration does.
+        const oStock = await checkOptionStock(eventOption, delta);
+        const variant = variantId ? (eventOption.variants || []).find(v => v.id === variantId) : null;
+        const vStock = variant ? await checkVariantStock(variant, delta) : { available: true };
+        if (!oStock.available || !vStock.available) {
+          res.status(400);
+          const left = Math.max(0, Math.min(oStock.remaining ?? Infinity, vStock.remaining ?? Infinity));
+          throw new Error(`Only ${left} more "${eventOption.name}${variant ? ` (${variant.name})` : ''}" available.`);
+        }
         ({ priceSnapshot, appliedTierId } = await priceRequestedOption(eventOption, variantId, delta, registration.user));
         newTotalDue += existingTotal + delta * (priceSnapshot || 0);
       } else if (delta < 0) {
@@ -1669,6 +1717,7 @@ const updateRegistrationOptions = async (req, res) => {
 
     const { sendRegistrationUpdatedEmails } = require('../utils/notifications');
     sendRegistrationUpdatedEmails(registrationId).catch(e => console.error('Failed to send registration updated emails:', e));
+    if (resolvedUpdateOptions.some(o => o.delta < 0) || oldByKey.size > newKeys.size) queueWaitlist(registration.eventId);
 
     // If registration is now paid, regenerate tickets and send them
     if (updated.status === 'paid') {
@@ -2171,6 +2220,7 @@ const updateAttendees = async (req, res) => {
             where: { id: a.id },
             data: {
               name: c.name, email: c.email, phone: c.phone,
+              dateOfBirth: c.dateOfBirth, parentName: c.parentName, parentEmail: c.parentEmail, parentPhone: c.parentPhone,
               ...(contactChanged ? { userId: match?.user?.id || null } : {}),
             },
           });
@@ -2182,6 +2232,8 @@ const updateAttendees = async (req, res) => {
       if (ticketDelivery) await tx.registration.update({ where: { id: registration.id }, data: { ticketDelivery } });
     });
 
+    queueConsentRequests(registration.id);
+
     // Paid registrations: re-sync tickets and send any new ones.
     if (registration.status === 'paid') {
       const created = await generateTicketsForRegistration(registration.id);

backend/src/controllers/scanLockController.js

@@ -0,0 +1,151 @@
+const prisma = require('../config/db');
+const { safeErrorMessage } = require('../utils/errorUtils');
+const { logAdminAction } = require('../utils/adminAudit');
+const { getClientIp } = require('../utils/requestUtils');
+const { LOCK_INCLUDE, activeLocks, acquireLock, snapshotFor, syncScans } = require('../utils/scanLocks');
+
+const SUPERVISORS = ['admin', 'supervisor'];
+const fail = (res, error) => res.status(error.statusCode || (res.statusCode === 200 ? 400 : res.statusCode)).json({ message: safeErrorMessage(error) });
+const audit = (req, action, lock, metadata = {}) => logAdminAction({
+  actorId: req.user.id, actorRole: req.user.role, action, targetType: 'ScanLock', targetId: lock.id,
+  metadata: { eventId: lock.eventId, sectionId: lock.sectionId, deviceName: lock.deviceName, ...metadata },
+  ip: getClientIp(req),
+});
+
+const lockView = (l) => ({
+  id: l.id, eventId: l.eventId, sectionId: l.sectionId, sectionName: l.section?.name || null,
+  deviceId: l.deviceId, deviceName: l.deviceName, user: l.user, lockedAt: l.lockedAt,
+  snapshotAt: l.snapshotAt, lastSyncAt: l.lastSyncAt, releasedAt: l.releasedAt,
+});
+
+/** The lock, if the caller is the person holding it on this device. */
+async function ownLock(req, res) {
+  const lock = await prisma.scanLock.findUnique({ where: { id: req.params.id }, include: LOCK_INCLUDE });
+  if (!lock) { res.status(404); throw new Error('Offline lock not found'); }
+  const deviceId = req.body?.deviceId || req.query?.deviceId;
+  if (lock.userId !== req.user.id || lock.deviceId !== deviceId) { res.status(403); throw new Error('This offline lock belongs to another device.'); }
+  return lock;
+}
+
+// @desc    Active offline locks for an event
+// @route   GET /api/scan-locks?eventId=
+// @access  Private/Staff
+const listLocks = async (req, res) => {
+  try {
+    if (!req.query.eventId) { res.status(400); throw new Error('eventId is required'); }
+    res.json((await activeLocks(String(req.query.eventId))).map(lockView));
+  } catch (error) {
+    fail(res, error);
+  }
+};
+
+// @desc    Lock a section (or the whole event) to this device for offline scanning
+// @route   POST /api/scan-locks   { eventId, sectionId?, deviceId, deviceName? }
+// @access  Private/Staff
+const createLock = async (req, res) => {
+  try {
+    const { eventId, sectionId, deviceId, deviceName } = req.body || {};
+    if (!eventId) { res.status(400); throw new Error('eventId is required'); }
+    const lock = await acquireLock({ eventId, sectionId: sectionId || null, deviceId, deviceName, userId: req.user.id });
+    audit(req, 'scan_lock_acquired', lock);
+    res.status(201).json(lockView(lock));
+  } catch (error) {
+    fail(res, error);
+  }
+};
+
+// @desc    Download the tickets valid for this lock, for offline scanning
+// @route   GET /api/scan-locks/:id/snapshot?deviceId=
+// @access  Private/Staff (lock holder)
+const getSnapshot = async (req, res) => {
+  try {
+    const lock = await ownLock(req, res);
+    if (lock.releasedAt) { res.status(410); throw new Error('This offline lock has been released.'); }
+    res.json({ lock: lockView(lock), ...(await snapshotFor(lock)) });
+  } catch (error) {
+    fail(res, error);
+  }
+};
+
+// @desc    Upload scans made offline
+// @route   POST /api/scan-locks/:id/sync   { deviceId, scans: [{ clientScanId, qrCode, qty, scannedAt }] }
+// @access  Private/Staff (lock holder — also after a release, so nothing made offline is lost)
+const syncLock = async (req, res) => {
+  try {
+    const lock = await ownLock(req, res);
+    const result = await syncScans(lock, req.body?.scans);
+    if (result.accepted || result.conflicts.length) {
+      audit(req, 'offline_sync', lock, { accepted: result.accepted, conflicts: result.conflicts.length, duplicates: result.duplicates, afterForceRelease: !!lock.forceReleasedById });
+    }
+    res.json({ accepted: result.accepted, duplicates: result.duplicates, conflicts: result.conflicts, reportId: result.report.id, released: !!lock.releasedAt });
+  } catch (error) {
+    fail(res, error);
+  }
+};
+
+// @desc    End offline mode (the device should sync first)
+// @route   DELETE /api/scan-locks/:id   { deviceId }
+// @access  Private/Staff (lock holder)
+const releaseLock = async (req, res) => {
+  try {
+    const lock = await ownLock(req, res);
+    if (!lock.releasedAt) {
+      await prisma.scanLock.update({ where: { id: lock.id }, data: { releasedAt: new Date() } });
+      audit(req, 'scan_lock_released', lock);
+    }
+    res.json({ message: 'Offline mode ended.' });
+  } catch (error) {
+    fail(res, error);
+  }
+};
+
+// @desc    Release someone else's lock (e.g. a lost or flat phone)
+// @route   POST /api/scan-locks/:id/force-release
+// @access  Private/Supervisor
+const forceRelease = async (req, res) => {
+  try {
+    const lock = await prisma.scanLock.findUnique({ where: { id: req.params.id }, include: LOCK_INCLUDE });
+    if (!lock) { res.status(404); throw new Error('Offline lock not found'); }
+    if (lock.releasedAt) return res.json({ message: 'Already released.' });
+    await prisma.scanLock.update({ where: { id: lock.id }, data: { releasedAt: new Date(), forceReleasedById: req.user.id } });
+    audit(req, 'scan_lock_force_released', lock, { heldBy: lock.user?.name });
+    res.json({ message: `Released. If ${lock.user?.name || 'that device'} reconnects, its offline scans will still sync and be flagged for review.` });
+  } catch (error) {
+    fail(res, error);
+  }
+};
+
+// @desc    Offline sync reports for an event (with anything that needs review)
+// @route   GET /api/scan-locks/reports?eventId=&unreviewed=true
+// @access  Private/Supervisor
+const listReports = async (req, res) => {
+  try {
+    const where = {
+      scanLock: { eventId: String(req.query.eventId || '') },
+      ...(req.query.unreviewed === 'true' ? { reviewedAt: null } : {}),
+    };
+    const reports = await prisma.offlineSyncReport.findMany({
+      where,
+      include: { scanLock: { include: LOCK_INCLUDE }, reviewedBy: { select: { name: true } } },
+      orderBy: { createdAt: 'desc' },
+      take: 200,
+    });
+    res.json(reports.map(r => ({ ...r, scanLock: lockView(r.scanLock) })));
+  } catch (error) {
+    fail(res, error);
+  }
+};
+
+// @desc    Mark a sync report as reviewed
+// @route   POST /api/scan-locks/reports/:id/review
+// @access  Private/Supervisor
+const reviewReport = async (req, res) => {
+  try {
+    const report = await prisma.offlineSyncReport.update({ where: { id: req.params.id }, data: { reviewedAt: new Date(), reviewedById: req.user.id } });
+    res.json(report);
+  } catch (error) {
+    fail(res, error);
+  }
+};
+
+module.exports = { SUPERVISORS, listLocks, createLock, getSnapshot, syncLock, releaseLock, forceRelease, listReports, reviewReport };

backend/src/controllers/ticketController.js

@@ -292,11 +292,14 @@ const getScanPreview = async (req, res) => {
     }
 
     const r = rows[0];
+    const { consentStatusForTickets } = require('../utils/consent');
+    const consentStatus = (await consentStatusForTickets([r.id])).get(r.id) || 'not_required';
     res.json({
       id:       r.id,
       quantity: Number(r.quantity),
       isUsed:   r.isUsed,
       eventId:  r.eventId,
+      consentStatus,
       registrationOption: {
         id: r.registrationOptionId,
         eventOption: { id: r.eventOptionId, name: r.eventOptionName },
@@ -369,6 +372,27 @@ const scanTicket = async (req, res) => {
       return res.status(400).json({ message: 'Ticket belongs to a different event', ticket });
     }
 
+    // Section checks used to happen only in the browser; enforce them here too.
+    const sectionId = String((req.query?.sectionId || req.body?.sectionId) || '').trim() || null;
+    if (sectionId) {
+      const section = await prisma.section.findUnique({ where: { id: sectionId }, include: { allowedOptions: true } });
+      if (!section || section.eventId !== ticket.eventId) {
+        return res.status(400).json({ message: 'Section not found for this event', ticket });
+      }
+      if (!section.allowedOptions.some(o => o.eventOptionId === r.eventOptionId)) {
+        return res.status(400).json({ message: 'This ticket is not valid for this section', ticket });
+      }
+    }
+
+    // A section (or the whole event) locked to another device for offline scanning
+    // can't be scanned online — those scans would be invisible to the offline device.
+    const { blockingLock } = require('../utils/scanLocks');
+    const lock = await blockingLock({ eventId: ticket.eventId, optionId: r.eventOptionId }, { sectionId, deviceId: req.body?.deviceId || null });
+    if (lock) {
+      const scope = lock.section ? `"${lock.section.name}"` : 'This event';
+      return res.status(423).json({ message: `${scope} is offline-locked by ${lock.user?.name || 'another device'}${lock.deviceName ? ` on ${lock.deviceName}` : ''}. Scan it on that device, or ask a supervisor to release the lock.`, code: 'SCAN_LOCKED' });
+    }
+
     // Compute how many have already been redeemed
     const totalRedeemed = (ticket.usages || []).reduce((s, u) => s + (u.quantityRedeemed || 1), 0);
     const remaining = (ticket.quantity || 1) - totalRedeemed;
@@ -381,6 +405,25 @@ const scanTicket = async (req, res) => {
       });
     }
 
+    // Youth events: no check-in without parental consent, unless a supervisor overrides.
+    const { consentStatusForTickets } = require('../utils/consent');
+    const consentStatus = (await consentStatusForTickets([ticket.id])).get(ticket.id) || 'not_required';
+    if (!['not_required', 'given'].includes(consentStatus)) {
+      const canOverride = ['admin', 'supervisor'].includes(req.user?.role);
+      if (!(req.body?.overrideConsent === true && canOverride)) {
+        const why = consentStatus === 'declined' ? 'Parental consent was declined' : consentStatus === 'pending' ? 'Parental consent is still pending' : 'Parental consent is missing';
+        return res.status(403).json({ message: `${why} — this ticket can't be checked in.`, code: 'CONSENT_REQUIRED', consentStatus, canOverride, ticket });
+      }
+      const { logAdminAction } = require('../utils/adminAudit');
+      const { getClientIp } = require('../utils/requestUtils');
+      logAdminAction({
+        actorId: req.user.id, actorRole: req.user.role, action: 'consent_override',
+        targetType: 'Ticket', targetId: ticket.id,
+        metadata: { consentStatus, eventId: ticket.eventId },
+        ip: getClientIp(req),
+      });
+    }
+
     // Determine how many to redeem this scan (defaults to all remaining)
     const requestedQty = parseInt(req.body?.qty || req.body?.quantity) || remaining;
     const qtyToRedeem = Math.min(Math.max(1, requestedQty), remaining);

backend/src/controllers/userController.js

@@ -888,6 +888,7 @@ const anonymizeUser = async (req, res) => {
       }
     });
     await clearTrustedDevices(req.params.id);
+    await require('../utils/consent').clearConsentDataForUser(req.params.id);
 
     res.json({ message: 'User data deleted' });
   } catch (error) {
@@ -1149,6 +1150,7 @@ const closeAccount = async (req, res) => {
         },
       });
       await clearTrustedDevices(req.user.id);
+      await require('../utils/consent').clearConsentDataForUser(req.user.id);
       // Send closure confirmation to the real address (before it was wiped)
       if (realEmail && !realEmail.endsWith('@deleted.invalid') && !realEmail.endsWith('@guest.local')) {
         const { sendMail, buildAccountClosedEmail } = require('../utils/email');

backend/src/controllers/waitlistController.js

@@ -0,0 +1,195 @@
+const prisma = require('../config/db');
+const { v4: uuidv4 } = require('uuid');
+const { safeErrorMessage } = require('../utils/errorUtils');
+const { findAccountByContact } = require('../utils/accountMatch');
+const { remainingFor } = require('../utils/stock');
+const { ACTIVE, makeOffer, queueWaitlist, findOfferByToken } = require('../utils/waitlist');
+
+const fail = (res, error) => res.status(error.statusCode || (res.statusCode === 200 ? 400 : res.statusCode)).json({ message: safeErrorMessage(error) });
+
+const ENTRY_INCLUDE = {
+  event: { select: { id: true, title: true, startDate: true, picture: true } },
+  eventOption: { select: { id: true, name: true } },
+  variant: { select: { id: true, name: true } },
+};
+
+// @desc    Join the waitlist for a sold-out option
+// @route   POST /api/waitlist
+// @access  Public (login needed when the event requires it)
+// Body: { eventId, eventOptionId, variantId?, quantity, guestName?, guestEmail?, guestPhone? }
+const joinWaitlist = async (req, res) => {
+  try {
+    const { eventId, eventOptionId, variantId = null, quantity, guestName, guestEmail, guestPhone } = req.body || {};
+    const qty = parseInt(quantity, 10);
+    if (!eventId || !eventOptionId || !(qty >= 1)) { res.status(400); throw new Error('eventId, eventOptionId and a quantity of at least 1 are required'); }
+
+    const event = await prisma.event.findUnique({ where: { id: eventId }, include: { eventOptions: { include: { variants: true } } } });
+    if (!event || !event.isActive) { res.status(404); throw new Error('Event not found'); }
+    if (!event.waitlistEnabled) { res.status(400); throw new Error('This event does not have a waitlist.'); }
+    if (event.cashupStatus === 'closed' || new Date(event.endDate) < new Date()) { res.status(400); throw new Error('This event is no longer taking registrations.'); }
+    const option = event.eventOptions.find(o => o.id === eventOptionId);
+    if (!option) { res.status(400); throw new Error('Unknown ticket option for this event'); }
+    const variant = variantId ? (option.variants || []).find(v => v.id === variantId) : null;
+    if (variantId && !variant) { res.status(400); throw new Error('Unknown variant for this option'); }
+
+    const free = await remainingFor(option, variant);
+    if (free === null || free >= qty) { res.status(400); throw new Error('There are places available — you can register now.'); }
+
+    // Who's joining
+    let userId = req.user?.id;
+    if (!userId) {
+      if (event.requiresAuth !== false) { res.status(401); throw new Error('Log in to join the waitlist for this event.'); }
+      if (!guestName || !guestEmail) { res.status(400); throw new Error('Name and email are required to join the waitlist'); }
+      const match = await findAccountByContact({ email: guestEmail, phone: guestPhone });
+      if (match.conflict) { res.status(409); throw new Error('This email and phone number belong to two different accounts. Please log in, or check your details.'); }
+      userId = match.user?.id || (await prisma.user.create({
+        data: { id: uuidv4(), name: String(guestName).trim(), email: String(guestEmail).trim(), password: '', phoneNumber: guestPhone || null, isActive: false, updatedAt: new Date() },
+      })).id;
+    }
+
+    const existing = await prisma.waitlistEntry.findFirst({ where: { userId, eventOptionId, variantId, status: { in: ACTIVE } } });
+    if (existing) { res.status(409); throw new Error('You\'re already on the waitlist for this.'); }
+
+    const last = await prisma.waitlistEntry.aggregate({ where: { eventId }, _max: { position: true } });
+    const entry = await prisma.waitlistEntry.create({
+      data: { eventId, eventOptionId, variantId, userId, quantity: qty, position: (last._max.position || 0) + 1 },
+      include: ENTRY_INCLUDE,
+    });
+    const ahead = await prisma.waitlistEntry.count({ where: { eventId, eventOptionId, variantId, status: 'waiting', position: { lt: entry.position } } });
+    res.status(201).json({ ...entry, ahead, message: `You're on the waitlist${ahead ? ` — ${ahead} ahead of you` : ''}. We'll email or WhatsApp you if a place opens up.` });
+  } catch (error) {
+    fail(res, error);
+  }
+};
+
+// @desc    The caller's waitlist entries
+// @route   GET /api/waitlist/mine
+// @access  Private
+const myWaitlist = async (req, res) => {
+  try {
+    const entries = await prisma.waitlistEntry.findMany({
+      where: { userId: req.user.id, status: { in: ACTIVE }, event: { endDate: { gte: new Date() } } },
+      include: ENTRY_INCLUDE,
+      orderBy: { createdAt: 'desc' },
+    });
+    res.json(entries);
+  } catch (error) {
+    fail(res, error);
+  }
+};
+
+// @desc    Leave the waitlist (an open offer is passed on)
+// @route   DELETE /api/waitlist/:id
+// @access  Private (owner)
+const leaveWaitlist = async (req, res) => {
+  try {
+    const entry = await prisma.waitlistEntry.findUnique({ where: { id: req.params.id } });
+    if (!entry || entry.userId !== req.user.id) { res.status(404); throw new Error('Waitlist entry not found'); }
+    if (!ACTIVE.includes(entry.status)) { res.status(400); throw new Error('You\'re no longer on this waitlist.'); }
+    await prisma.waitlistEntry.update({ where: { id: entry.id }, data: { status: 'left', offerTokenHash: null } });
+    if (entry.status === 'offered') queueWaitlist(entry.eventId);
+    res.json({ message: 'You\'ve left the waitlist.' });
+  } catch (error) {
+    fail(res, error);
+  }
+};
+
+// @desc    What a claim link offers
+// @route   GET /api/waitlist/claim/:token
+// @access  Public (the token is the credential)
+const claimInfo = async (req, res) => {
+  try {
+    const entry = await findOfferByToken(req.params.token);
+    if (!entry) { res.status(404); throw new Error('This waitlist link is not valid or has already been used.'); }
+    const expired = entry.status !== 'offered' || new Date(entry.offerExpiresAt) < new Date();
+    res.json({
+      status: expired ? 'expired' : 'offered',
+      eventId: entry.eventId,
+      eventTitle: entry.event.title,
+      eventStart: entry.event.startDate,
+      eventOptionId: entry.eventOptionId,
+      optionName: entry.eventOption.name,
+      variantId: entry.variantId,
+      variantName: entry.variant?.name || null,
+      quantity: entry.offeredQuantity,
+      requested: entry.quantity,
+      expiresAt: entry.offerExpiresAt,
+      name: entry.user?.name,
+    });
+  } catch (error) {
+    fail(res, error);
+  }
+};
+
+// @desc    The waitlist for an event
+// @route   GET /api/waitlist/events/:eventId
+// @access  Private/Staff
+const eventWaitlist = async (req, res) => {
+  try {
+    const entries = await prisma.waitlistEntry.findMany({
+      where: { eventId: req.params.eventId, ...(req.query.all === 'true' ? {} : { status: { in: [...ACTIVE, 'claimed', 'expired'] } }) },
+      include: { ...ENTRY_INCLUDE, user: { select: { id: true, name: true, email: true, phoneNumber: true } } },
+      orderBy: { position: 'asc' },
+    });
+    res.json(entries);
+  } catch (error) {
+    fail(res, error);
+  }
+};
+
+// @desc    Offer a place to someone on the waitlist now (even without free stock)
+// @route   POST /api/waitlist/:id/offer
+// @access  Private/Supervisor
+const offerManually = async (req, res) => {
+  try {
+    const entry = await prisma.waitlistEntry.findUnique({ where: { id: req.params.id } });
+    if (!entry) { res.status(404); throw new Error('Waitlist entry not found'); }
+    if (!['waiting', 'expired'].includes(entry.status)) { res.status(400); throw new Error(`This person is ${entry.status === 'offered' ? 'already holding an offer' : `no longer waiting (${entry.status})`}.`); }
+    const qty = Math.max(1, Math.min(entry.quantity, parseInt(req.body?.quantity, 10) || entry.quantity));
+    const updated = await makeOffer(entry.id, qty);
+    res.json({ ...updated, message: `Offered ${qty} place(s); the claim link has been sent.` });
+  } catch (error) {
+    fail(res, error);
+  }
+};
+
+// @desc    Move someone up or down the queue
+// @route   POST /api/waitlist/:id/move   { direction: 'up' | 'down' }
+// @access  Private/Supervisor
+const moveEntry = async (req, res) => {
+  try {
+    const entry = await prisma.waitlistEntry.findUnique({ where: { id: req.params.id } });
+    if (!entry) { res.status(404); throw new Error('Waitlist entry not found'); }
+    const up = req.body?.direction === 'up';
+    const neighbour = await prisma.waitlistEntry.findFirst({
+      where: { eventId: entry.eventId, status: 'waiting', position: up ? { lt: entry.position } : { gt: entry.position } },
+      orderBy: { position: up ? 'desc' : 'asc' },
+    });
+    if (!neighbour) return res.json({ message: 'Already at the ' + (up ? 'front.' : 'back.') });
+    await prisma.$transaction([
+      prisma.waitlistEntry.update({ where: { id: entry.id }, data: { position: neighbour.position } }),
+      prisma.waitlistEntry.update({ where: { id: neighbour.id }, data: { position: entry.position } }),
+    ]);
+    res.json({ message: 'Moved.' });
+  } catch (error) {
+    fail(res, error);
+  }
+};
+
+// @desc    Take someone off the waitlist (an open offer is passed on)
+// @route   POST /api/waitlist/:id/remove
+// @access  Private/Supervisor
+const removeEntry = async (req, res) => {
+  try {
+    const entry = await prisma.waitlistEntry.findUnique({ where: { id: req.params.id } });
+    if (!entry) { res.status(404); throw new Error('Waitlist entry not found'); }
+    if (!ACTIVE.includes(entry.status)) { res.status(400); throw new Error('This person is not on the waitlist any more.'); }
+    await prisma.waitlistEntry.update({ where: { id: entry.id }, data: { status: 'removed', offerTokenHash: null } });
+    if (entry.status === 'offered') queueWaitlist(entry.eventId);
+    res.json({ message: 'Removed from the waitlist.' });
+  } catch (error) {
+    fail(res, error);
+  }
+};
+
+module.exports = { joinWaitlist, myWaitlist, leaveWaitlist, claimInfo, eventWaitlist, offerManually, moveEntry, removeEntry };

backend/src/index.js

@@ -176,6 +176,9 @@ app.use('/api', costRoutes);
 app.use('/api/cashups', cashupRoutes);
 app.use('/api/admin', adminRoutes);
 app.use('/api/coupons', require('./routes/couponRoutes'));
+app.use('/api/consent', require('./routes/consentRoutes'));
+app.use('/api/waitlist', require('./routes/waitlistRoutes'));
+app.use('/api/scan-locks', require('./routes/scanLockRoutes'));
 app.use('/api/backups', backupRoutes);
 
 // Pre-warm the settings cache so synchronous helpers have DB values from startup
@@ -632,6 +635,44 @@ app.get('/docs', async (req, res) => {
         ]},
     ]},
 
+    { title: 'Offline scanning', base: '/api/scan-locks', endpoints: [
+      { method:'GET', path:'/api/scan-locks', auth:'staff+', desc:'Active offline locks for an event (?eventId=)' },
+      { method:'POST', path:'/api/scan-locks', auth:'staff+', desc:'Lock a section (or the whole event) to this device for offline scanning',
+        request:{ body:{ eventId:'ev-uuid-...', sectionId:'sec-uuid-...', deviceId:'device-uuid', deviceName:'Chrome on Android' }},
+        responses:[{ status:201, desc:'Locked', body:{ id:'lock-uuid-...', sectionName:'Main hall' }}, { status:409, desc:'Held elsewhere', body:{ message:'"Main hall" is offline-locked by Ann on Chrome on Android.' }}]},
+      { method:'GET', path:'/api/scan-locks/:id/snapshot', auth:'staff+', desc:'Tickets valid in the lock scope, for the device to keep offline (lock holder, ?deviceId=)' },
+      { method:'POST', path:'/api/scan-locks/:id/sync', auth:'staff+', desc:'Upload offline scans (idempotent by clientScanId; capped at what is left on each ticket)',
+        request:{ body:{ deviceId:'device-uuid', scans:[{ clientScanId:'scan-uuid', qrCode:'qr-uuid', qty:1, scannedAt:'2025-07-10T08:15:00.000Z' }] }},
+        responses:[{ status:200, desc:'Synced', body:{ accepted:1, duplicates:0, conflicts:[] }}]},
+      { method:'DELETE', path:'/api/scan-locks/:id', auth:'staff+', desc:'End offline mode (lock holder)' },
+      { method:'POST', path:'/api/scan-locks/:id/force-release', auth:'supervisor+', desc:'Release a lost device\'s lock' },
+      { method:'GET', path:'/api/scan-locks/reports', auth:'supervisor+', desc:'Offline sync reports for an event' },
+      { method:'POST', path:'/api/scan-locks/reports/:id/review', auth:'supervisor+', desc:'Mark a sync report reviewed' },
+    ]},
+    { title: 'Waitlist', base: '/api/waitlist', endpoints: [
+      { method:'POST', path:'/api/waitlist', auth:'public', desc:'Join the waitlist for a sold-out line (login needed when the event requires it)',
+        request:{ body:{ eventId:'ev-uuid-...', eventOptionId:'opt-uuid-...', quantity:2 }},
+        responses:[{ status:201, desc:'Joined', body:{ id:'wl-uuid-...', status:'waiting', ahead:3 }}, { status:400, desc:'Places available', body:{ message:'There are places available — you can register now.' }}]},
+      { method:'GET', path:'/api/waitlist/mine', auth:'user+', desc:'My active waitlist entries' },
+      { method:'DELETE', path:'/api/waitlist/:id', auth:'user+', desc:'Leave the waitlist' },
+      { method:'GET', path:'/api/waitlist/claim/:token', auth:'public', desc:'What a claim link offers (rate-limited)' },
+      { method:'GET', path:'/api/waitlist/events/:eventId', auth:'staff+', desc:'The queue for an event' },
+      { method:'POST', path:'/api/waitlist/:id/offer', auth:'supervisor+', desc:'Offer places now, even over the stock limit' },
+      { method:'POST', path:'/api/waitlist/:id/move', auth:'supervisor+', desc:'Move up or down the queue', request:{ body:{ direction:'up' }} },
+      { method:'POST', path:'/api/waitlist/:id/remove', auth:'supervisor+', desc:'Take someone off the waitlist' },
+    ]},
+    { title: 'Parental consent', base: '/api/consent', endpoints: [
+      { method:'GET', path:'/api/consent/:token', auth:'public', desc:'Consent page data for a parent/guardian (the link token is the credential; rate-limited)',
+        responses:[{ status:200, desc:'Success', body:{ status:'pending', attendeeName:'Sam Smith', consentText:'I give permission…', event:{ title:'Youth Camp' }, collect:{ medical:true, emergency:true, photo:true } }}, { status:404, desc:'Unknown or replaced link', body:{ message:'This consent link is not valid.' }}]},
+      { method:'POST', path:'/api/consent/:token', auth:'public', desc:'Give or decline consent. Records name, time, IP, device and the consent text version; medical/emergency details are stored encrypted.',
+        request:{ body:{ decision:'give', signedName:'Pat Smith', isGuardian:true, medical:{ allergies:'Peanuts' }, emergency:{ name:'Gran', phone:'0821234567' }, photoConsent:true }},
+        responses:[{ status:200, desc:'Answered', body:{ status:'given' }}, { status:409, desc:'Already answered', body:{ message:'Consent has already been given.' }}]},
+      { method:'GET', path:'/api/consent/events/:eventId', auth:'staff+', desc:'Consent status for every attendee on an event' },
+      { method:'POST', path:'/api/consent/requests/:id/resend', auth:'user+', desc:'Re-send a pending request with a fresh link (registrant or staff)' },
+      { method:'POST', path:'/api/consent/events/:eventId/resend-pending', auth:'supervisor+', desc:'Re-send every pending request on an event' },
+      { method:'POST', path:'/api/consent/events/:eventId/rerequest', auth:'supervisor+', desc:'Ask again where consent was given on an older version of the text, or never requested' },
+      { method:'GET', path:'/api/consent/events/:eventId/medical', auth:'supervisor+', desc:'Decrypted medical & emergency list; every view is written to the admin audit log' },
+    ]},
     { title: 'Coupons', base: '/api/coupons', endpoints: [
       { 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 }] }},
@@ -1295,6 +1336,59 @@ app.listen(PORT, () => {
     console.warn('[daily summaries] Not scheduled:', e?.message || e);
   }
 
+  // Waitlist job — expire unclaimed offers and offer any free places to the next people.
+  try {
+    const enabled = String(process.env.WAITLIST_JOB_ENABLED || 'true').toLowerCase() !== 'false';
+    if (enabled) {
+      const { runWaitlistJob } = require('./utils/waitlist');
+      const everyMs = parseInt(process.env.WAITLIST_JOB_INTERVAL_MS || String(10 * 60 * 1000), 10);
+      setInterval(async () => {
+        try {
+          const r = await runWaitlistJob();
+          if (r.expired || r.offers) console.log(`[waitlist] ${r.expired} event(s) with expired offers, ${r.offers} new offer(s).`);
+        } catch (e) {
+          console.warn('[waitlist] Job failed:', e?.message || e);
+        }
+      }, everyMs);
+      console.log(`[waitlist] Job every ${Math.round(everyMs / 60000)} min.`);
+    } else {
+      console.log('[waitlist] Job disabled by env WAITLIST_JOB_ENABLED=false');
+    }
+  } catch (e) {
+    console.warn('[waitlist] Not scheduled:', e?.message || e);
+  }
+
+  // Daily parental-consent job — reminders for unanswered requests, and purging
+  // medical/emergency details a set number of days after each event.
+  try {
+    const enabled = String(process.env.CONSENT_JOBS_ENABLED || 'true').toLowerCase() !== 'false';
+    if (enabled) {
+      const { sendConsentReminders, purgeConsentMedicalData } = require('./utils/consent');
+      const runConsentJobs = async () => {
+        try {
+          const reminded = await sendConsentReminders(new Date());
+          const purged = await purgeConsentMedicalData(new Date());
+          if (reminded || purged) console.log(`[consent] Sent ${reminded} reminder(s), purged medical details on ${purged} request(s).`);
+        } catch (e) {
+          console.warn('[consent] Daily job failed:', e?.message || e);
+        }
+      };
+      const scheduleConsent = () => {
+        const now = new Date();
+        const next = new Date(now);
+        next.setHours(9, 0, 0, 0);
+        if (next <= now) next.setDate(next.getDate() + 1);
+        setTimeout(async () => { await runConsentJobs(); scheduleConsent(); }, next.getTime() - now.getTime());
+      };
+      scheduleConsent();
+      console.log('[consent] Scheduler initialized (09:00 local time).');
+    } else {
+      console.log('[consent] Scheduler disabled by env CONSENT_JOBS_ENABLED=false');
+    }
+  } catch (e) {
+    console.warn('[consent] Not scheduled:', e?.message || e);
+  }
+
   // Daily temp-file cleanup — removes files older than 7 days from /temp
   try {
     const { cleanupTempFiles } = require('./utils/cleanupTemp');

backend/src/routes/consentRoutes.js

@@ -0,0 +1,20 @@
+const express = require('express');
+const rateLimit = require('express-rate-limit');
+const router = express.Router();
+const { getConsent, answerConsent, listEventConsent, resendRequest, resendPending, rerequestConsent, medicalList } = require('../controllers/consentController');
+const { protect, staff, supervisor } = require('../middleware/authMiddleware');
+
+// The token in the link is the parent's only credential, so keep guessing slow.
+const consentLimiter = rateLimit({ windowMs: 60 * 1000, max: 30, message: { message: 'Too many attempts. Please try again in a minute.' } });
+
+router.get('/events/:eventId', protect, staff, listEventConsent);
+router.post('/events/:eventId/resend-pending', protect, supervisor, resendPending);
+router.post('/events/:eventId/rerequest', protect, supervisor, rerequestConsent);
+router.get('/events/:eventId/medical', protect, supervisor, medicalList);
+router.post('/requests/:id/resend', protect, resendRequest);
+
+// Public consent page
+router.get('/:token', consentLimiter, getConsent);
+router.post('/:token', consentLimiter, answerConsent);
+
+module.exports = router;

backend/src/routes/scanLockRoutes.js

@@ -0,0 +1,15 @@
+const express = require('express');
+const router = express.Router();
+const { listLocks, createLock, getSnapshot, syncLock, releaseLock, forceRelease, listReports, reviewReport } = require('../controllers/scanLockController');
+const { protect, staff, supervisor } = require('../middleware/authMiddleware');
+
+router.get('/', protect, staff, listLocks);
+router.post('/', protect, staff, createLock);
+router.get('/reports', protect, supervisor, listReports);
+router.post('/reports/:id/review', protect, supervisor, reviewReport);
+router.get('/:id/snapshot', protect, staff, getSnapshot);
+router.post('/:id/sync', protect, staff, syncLock);
+router.post('/:id/force-release', protect, supervisor, forceRelease);
+router.delete('/:id', protect, staff, releaseLock);
+
+module.exports = router;

backend/src/routes/waitlistRoutes.js

@@ -0,0 +1,19 @@
+const express = require('express');
+const rateLimit = require('express-rate-limit');
+const router = express.Router();
+const { joinWaitlist, myWaitlist, leaveWaitlist, claimInfo, eventWaitlist, offerManually, moveEntry, removeEntry } = require('../controllers/waitlistController');
+const { protect, staff, supervisor, optionalAuth } = require('../middleware/authMiddleware');
+
+// Claim links are credentials, so keep guessing slow.
+const claimLimiter = rateLimit({ windowMs: 60 * 1000, max: 30, message: { message: 'Too many attempts. Please try again in a minute.' } });
+
+router.post('/', optionalAuth, joinWaitlist);
+router.get('/mine', protect, myWaitlist);
+router.get('/claim/:token', claimLimiter, claimInfo);
+router.get('/events/:eventId', protect, staff, eventWaitlist);
+router.post('/:id/offer', protect, supervisor, offerManually);
+router.post('/:id/move', protect, supervisor, moveEntry);
+router.post('/:id/remove', protect, supervisor, removeEntry);
+router.delete('/:id', protect, leaveWaitlist);
+
+module.exports = router;

backend/src/utils/attendees.js

@@ -11,10 +11,16 @@
  *   accounts, in which case nothing is linked.
  * - Registration.ticketDelivery = 'each' sends each attendee their own ticket by
  *   email/WhatsApp; attendees with no contact details fall back to the payer.
+ * - Youth events (requiresParentalConsent): every main place must be named with a date
+ *   of birth, and anyone under 18 on the start date needs a parent/guardian name, email
+ *   and phone (see utils/consent.js).
  */
 
 const prisma = require('../config/db');
 const { findAccountByContact } = require('./accountMatch');
+const { isMinor } = require('./consent');
+
+const EMAIL_RE = /^[^@\s]+@[^@\s]+\.[^@\s]+$/;
 
 const lineKey = (eventOptionId, variantId) => `${eventOptionId}::${variantId || ''}`;
 
@@ -34,27 +40,60 @@ function attendeeError(message) {
  * @param {object} [namedByKey] - places on those lines already named (and being kept)
  */
 function validateAttendees(event, placesByKey, attendees, namedByKey = {}) {
-  if (!attendees || attendees.length === 0) return [];
-  if (!event.allowNamedAttendees) throw attendeeError('This event doesn\'t take attendee names.');
-  if (!Array.isArray(attendees)) throw attendeeError('attendees must be a list');
+  const consent = !!event.requiresParentalConsent;
+  if ((!attendees || attendees.length === 0) && !consent) return [];
+  if (!event.allowNamedAttendees && !consent) throw attendeeError('This event doesn\'t take attendee names.');
+  if (!Array.isArray(attendees || [])) throw attendeeError('attendees must be a list');
 
   const countByKey = {};
-  return attendees.map((a, i) => {
+  const cleaned = (attendees || []).map((a, i) => {
     const option = (event.eventOptions || []).find(o => o.id === a?.eventOptionId);
     if (!option) throw attendeeError(`Attendee ${i + 1}: unknown ticket option.`);
     if (!option.isMainTicket) throw attendeeError(`Attendee ${i + 1}: names can only be given for "${option.name}" main tickets.`);
     const name = String(a.name || '').trim();
     if (!name) throw attendeeError(`Attendee ${i + 1}: enter a name.`);
     const email = String(a.email || '').trim() || null;
-    if (email && !/^[^@\s]+@[^@\s]+\.[^@\s]+$/.test(email)) throw attendeeError(`Attendee ${i + 1}: "${email}" isn't a valid email address.`);
+    if (email && !EMAIL_RE.test(email)) throw attendeeError(`Attendee ${i + 1}: "${email}" isn't a valid email address.`);
     const phone = String(a.phone || '').trim() || null;
     const key = lineKey(a.eventOptionId, a.variantId);
     countByKey[key] = (countByKey[key] || 0) + 1;
     if (countByKey[key] + (namedByKey[key] || 0) > (placesByKey[key] || 0)) {
       throw attendeeError(`More names than "${option.name}" tickets.`);
     }
-    return { eventOptionId: a.eventOptionId, variantId: a.variantId || null, name, email, phone };
+
+    // Date of birth (always kept if given) and, for youth events, parent details.
+    let dateOfBirth = null;
+    if (a.dateOfBirth) {
+      dateOfBirth = new Date(a.dateOfBirth);
+      if (isNaN(dateOfBirth.getTime()) || dateOfBirth > new Date()) throw attendeeError(`${name}: enter a valid date of birth.`);
+    } else if (consent) {
+      throw attendeeError(`${name}: enter a date of birth.`);
+    }
+    const parentName = String(a.parentName || '').trim() || null;
+    const parentEmail = String(a.parentEmail || '').trim() || null;
+    const parentPhone = String(a.parentPhone || '').trim() || null;
+    if (consent && isMinor(dateOfBirth, event.startDate)) {
+      if (!parentName || !parentEmail || !parentPhone) {
+        throw attendeeError(`${name} is under 18, so a parent or guardian's name, email and phone are needed for consent.`);
+      }
+      if (!EMAIL_RE.test(parentEmail)) throw attendeeError(`${name}: "${parentEmail}" isn't a valid parent email address.`);
+    }
+    return { eventOptionId: a.eventOptionId, variantId: a.variantId || null, name, email, phone, dateOfBirth, parentName, parentEmail, parentPhone };
   });
+
+  // Youth events need every main place named (with a date of birth).
+  if (consent) {
+    for (const o of event.eventOptions || []) {
+      if (!o.isMainTicket) continue;
+      for (const [key, places] of Object.entries(placesByKey)) {
+        if (!key.startsWith(`${o.id}::`)) continue;
+        if ((countByKey[key] || 0) + (namedByKey[key] || 0) < places) {
+          throw attendeeError(`This is a youth event — add a name and date of birth for every "${o.name}" ticket.`);
+        }
+      }
+    }
+  }
+  return cleaned;
 }
 
 /**
@@ -147,6 +186,10 @@ async function createAttendees(registrationId, attendees, db = prisma) {
         name: a.name,
         email: a.email,
         phone: a.phone,
+        dateOfBirth: a.dateOfBirth || null,
+        parentName: a.parentName || null,
+        parentEmail: a.parentEmail || null,
+        parentPhone: a.parentPhone || null,
         userId: match.user?.id || null,
         order,
       },

backend/src/utils/consent.js

@@ -0,0 +1,332 @@
+/**
+ * Parental consent for youth events.
+ *
+ * Rules:
+ * - On an event with requiresParentalConsent, every attendee gives a date of birth.
+ *   Anyone under 18 on the event's start date needs a parent/guardian (name, email,
+ *   phone), who is sent a consent request by email AND WhatsApp — regardless of anyone's
+ *   notification preference.
+ * - A request's link token is random; only its HMAC is stored. Links expire when the
+ *   event ends and can be re-sent (which issues a new token).
+ * - The parent's answer records the time, IP, device, typed name, and the exact consent
+ *   text and version they saw. Medical/emergency details are stored encrypted and purged
+ *   a set number of days after the event (setting consent_medical_retention_days).
+ * - Tickets are issued as normal but can't be checked in until consent is given — the
+ *   latest request for the attendee decides. On a consent event, a ticket with no named
+ *   attendee is treated as missing consent. Supervisors can override (audited).
+ * - Reminders go 2 days after the request, then every 3 days, until answered or the event.
+ */
+
+const crypto = require('crypto');
+const prisma = require('../config/db');
+
+const DAY = 24 * 60 * 60 * 1000;
+const FIRST_REMINDER_AFTER = 2 * DAY;
+const REMINDER_EVERY = 3 * DAY;
+const DEFAULT_RETENTION_DAYS = 30;
+
+function consentError(message, statusCode = 400) {
+  const err = new Error(message);
+  err.statusCode = statusCode;
+  return err;
+}
+
+// ─── Pure helpers ─────────────────────────────────────────────────────────────
+
+/** Whole years old on `onDate`. */
+function ageOn(dateOfBirth, onDate) {
+  const dob = new Date(dateOfBirth);
+  const on = new Date(onDate);
+  let age = on.getUTCFullYear() - dob.getUTCFullYear();
+  const beforeBirthday = on.getUTCMonth() < dob.getUTCMonth()
+    || (on.getUTCMonth() === dob.getUTCMonth() && on.getUTCDate() < dob.getUTCDate());
+  if (beforeBirthday) age -= 1;
+  return age;
+}
+
+/** Under 18 on the event's start date. */
+function isMinor(dateOfBirth, eventStart) {
+  if (!dateOfBirth) return false;
+  return ageOn(dateOfBirth, eventStart) < 18;
+}
+
+/**
+ * Consent state for one attendee: 'not_required' | 'missing' | 'pending' | 'given' | 'declined'.
+ * `latest` is the attendee's most recent ConsentRequest (or null).
+ */
+function consentStatusFor(attendee, event, latest) {
+  if (!event?.requiresParentalConsent) return 'not_required';
+  if (!attendee) return 'missing'; // unnamed place on a consent event
+  if (!isMinor(attendee.dateOfBirth, event.startDate)) return 'not_required';
+  if (!latest) return 'missing';
+  return latest.status;
+}
+
+/** Whether a pending request is due a reminder now. */
+function reminderDue(request, now = new Date()) {
+  if (!request || request.status !== 'pending') return false;
+  const t = new Date(now).getTime();
+  if (t >= new Date(request.expiresAt).getTime()) return false;
+  const gap = request.remindersSent === 0 ? FIRST_REMINDER_AFTER : REMINDER_EVERY;
+  return t - new Date(request.lastSentAt).getTime() >= gap;
+}
+
+const str = (v, max = 500) => String(v ?? '').trim().slice(0, max);
+
+/**
+ * Checks a parent's answer on the consent page. Pure. Returns the cleaned answer.
+ * @param {object} body  - { decision: 'give'|'decline', signedName, isGuardian, medical, emergency, photoConsent }
+ * @param {object} event - with consentCollectMedical / Emergency / Photo
+ */
+function validateConsentAnswer(body, event) {
+  const decision = body?.decision;
+  if (decision !== 'give' && decision !== 'decline') throw consentError('Choose to give or decline consent.');
+  const signedName = str(body.signedName, 200);
+  if (signedName.length < 2) throw consentError('Type your full name to sign.');
+  if (body.isGuardian !== true) throw consentError('Confirm that you are the parent or legal guardian.');
+
+  const out = { decision, signedName, medical: null, emergency: null, photoConsent: null };
+  if (decision === 'decline') return out;
+
+  if (event.consentCollectMedical) {
+    const m = body.medical || {};
+    out.medical = {
+      allergies: str(m.allergies), medication: str(m.medication),
+      conditions: str(m.conditions), medicalAid: str(m.medicalAid, 200),
+    };
+  }
+  if (event.consentCollectEmergency) {
+    const em = body.emergency || {};
+    out.emergency = { name: str(em.name, 200), phone: str(em.phone, 40), relationship: str(em.relationship, 100) };
+    if (!out.emergency.name || !out.emergency.phone) throw consentError('Add an emergency contact name and phone number.');
+  }
+  if (event.consentCollectPhoto) {
+    if (body.photoConsent !== true && body.photoConsent !== false) throw consentError('Answer the photo consent question.');
+    out.photoConsent = body.photoConsent;
+  }
+  return out;
+}
+
+// ─── Tokens ───────────────────────────────────────────────────────────────────
+
+const hashToken = (token) => crypto.createHmac('sha256', process.env.JWT_SECRET || '').update(`consent:${token}`).digest('hex');
+const newToken = () => crypto.randomBytes(24).toString('hex');
+
+function consentLink(token) {
+  const base = (process.env.FRONTEND_URL || process.env.APP_BASE_URL || 'http://localhost:3001').split(',')[0].trim().replace(/\/$/, '');
+  return `${base}/consent/${token}`;
+}
+
+// ─── Encryption of medical/emergency details ──────────────────────────────────
+
+function sealJson(value) {
+  if (!value) return null;
+  const { encrypt } = require('./encryption');
+  return encrypt(JSON.stringify(value));
+}
+
+function openJson(value) {
+  if (!value) return null;
+  try {
+    const { decrypt } = require('./encryption');
+    return JSON.parse(decrypt(value));
+  } catch {
+    return null;
+  }
+}
+
+// ─── Database helpers ─────────────────────────────────────────────────────────
+
+/** Latest request per attendee id. */
+async function latestRequestsFor(attendeeIds, db = prisma) {
+  if (!attendeeIds.length) return new Map();
+  const rows = await db.consentRequest.findMany({ where: { attendeeId: { in: attendeeIds } }, orderBy: { createdAt: 'desc' } });
+  const out = new Map();
+  for (const r of rows) if (!out.has(r.attendeeId)) out.set(r.attendeeId, r);
+  return out;
+}
+
+async function sendConsentMessage(request, token, { reminder = false } = {}) {
+  const { sendMail, emailWrapper, ctaButton, fallbackLink } = require('./email');
+  const { waTextAny } = require('./notify');
+  const { isValidZAPhone } = require('./whatsapp');
+  const { getSettingSync } = require('./settingsCache');
+  const orgName = getSettingSync('org_name', process.env.ORG_NAME || 'Cross Code');
+  const ff = `-apple-system,BlinkMacSystemFont,'Segoe UI',Roboto,Helvetica,Arial,sans-serif`;
+
+  const event = request.event || await prisma.event.findUnique({ where: { id: request.eventId } });
+  const attendee = request.attendee || await prisma.attendee.findUnique({ where: { id: request.attendeeId } });
+  const link = consentLink(token);
+  const when = event?.startDate ? new Date(event.startDate).toLocaleDateString('en-GB', { day: 'numeric', month: 'long', year: 'numeric' }) : '';
+  const subject = `${reminder ? 'Reminder: ' : ''}Consent needed for ${attendee.name} — ${event.title}`;
+  const intro = `${attendee.name} has been registered for <strong>${event.title}</strong>${when ? ` on <strong>${when}</strong>` : ''}. As their parent or guardian, please review the details and give (or decline) consent.`;
+  const sent = [];
+
+  if (request.parentEmail && request.parentEmail.includes('@')) {
+    const html = emailWrapper(`
+      <p style="font-size:22px;font-weight:800;color:#0f172a;margin:0 0 8px 0">${reminder ? 'A reminder: ' : ''}Parental consent needed</p>
+      <p style="margin:0 0 8px 0;color:#374151;font-family:${ff}">Hi <strong>${request.parentName || 'there'}</strong>,</p>
+      <p style="margin:0 0 24px 0;color:#374151;font-family:${ff}">${intro}</p>
+      ${ctaButton('Review and give consent', link)}
+      ${fallbackLink(link)}
+      <p style="font-size:13px;color:#64748b;margin:16px 0 0 0;font-family:${ff}">${attendee.name} can't be checked in at the event until consent is given.</p>
+    `, { preheader: `Consent needed for ${attendee.name}` });
+    try {
+      await sendMail({ to: request.parentEmail, subject, html, text: `Hi ${request.parentName || 'there'},\n\n${intro.replace(/<[^>]+>/g, '')}\n\nReview and give consent: ${link}\n\n${orgName}` });
+      sent.push('email');
+    } catch (e) {
+      console.warn('[consent] email failed:', e?.message || e);
+    }
+  }
+  if (request.parentPhone && isValidZAPhone(request.parentPhone)) {
+    await waTextAny({ name: request.parentName, phoneNumber: request.parentPhone },
+      `${reminder ? '⏰ Reminder: ' : ''}Hi ${request.parentName || 'there'}, ${attendee.name} has been registered for *${event.title}*${when ? ` on ${when}` : ''}. Please give (or decline) parental consent here: ${link}`);
+    sent.push('WhatsApp');
+  }
+  return sent;
+}
+
+/**
+ * Creates (and sends) a consent request for an attendee. Earlier requests stay as the
+ * record of what was agreed before; this one now decides check-in.
+ */
+async function createConsentRequest(attendee, event) {
+  const token = newToken();
+  const request = await prisma.consentRequest.create({
+    data: {
+      attendeeId: attendee.id,
+      eventId: event.id,
+      tokenHash: hashToken(token),
+      textVersion: event.consentTextVersion || 1,
+      consentText: event.consentText || '',
+      parentName: attendee.parentName,
+      parentEmail: attendee.parentEmail,
+      parentPhone: attendee.parentPhone,
+      expiresAt: event.endDate,
+    },
+  });
+  const sent = await sendConsentMessage({ ...request, event, attendee }, token);
+  return { request, sent };
+}
+
+/**
+ * Makes sure every under-18 attendee on a registration has a consent request — creates
+ * and sends one for anyone who has none yet, or whose parent details have changed since.
+ */
+async function ensureConsentRequests(registrationId) {
+  const reg = await prisma.registration.findUnique({ where: { id: registrationId }, include: { event: true, attendees: true } });
+  if (!reg || !reg.event.requiresParentalConsent || reg.status === 'cancelled') return 0;
+  const minors = reg.attendees.filter(a => isMinor(a.dateOfBirth, reg.event.startDate));
+  const latest = await latestRequestsFor(minors.map(a => a.id));
+  let created = 0;
+  for (const a of minors) {
+    const r = latest.get(a.id);
+    const parentChanged = r && (r.parentEmail !== a.parentEmail || r.parentPhone !== a.parentPhone);
+    if (!r || (parentChanged && r.status !== 'given')) {
+      await createConsentRequest(a, reg.event);
+      created += 1;
+    }
+  }
+  return created;
+}
+
+/** Re-sends a request with a fresh link (the old link stops working). */
+async function resendConsentRequest(requestId) {
+  const request = await prisma.consentRequest.findUnique({ where: { id: requestId }, include: { event: true, attendee: true } });
+  if (!request) throw consentError('Consent request not found', 404);
+  if (request.status !== 'pending') throw consentError(`Consent has already been ${request.status}.`);
+  if (new Date(request.expiresAt) < new Date()) throw consentError('This event has ended.');
+  const token = newToken();
+  await prisma.consentRequest.update({ where: { id: request.id }, data: { tokenHash: hashToken(token), lastSentAt: new Date() } });
+  return sendConsentMessage(request, token, { reminder: true });
+}
+
+async function findRequestByToken(token) {
+  if (!token || typeof token !== 'string' || token.length > 100) return null;
+  return prisma.consentRequest.findUnique({
+    where: { tokenHash: hashToken(token) },
+    include: { event: true, attendee: { include: { registration: { include: { user: { select: { id: true, name: true, email: true, phoneNumber: true, notificationPreference: true } } } } } } },
+  });
+}
+
+/**
+ * Consent state for each ticket id — for the scan gate and staff screens.
+ * @returns {Promise<Map<string, string>>} ticketId → consent status
+ */
+async function consentStatusForTickets(ticketIds) {
+  const tickets = await prisma.ticket.findMany({ where: { id: { in: ticketIds } }, include: { event: true, attendee: true } });
+  const latest = await latestRequestsFor(tickets.map(t => t.attendeeId).filter(Boolean));
+  const out = new Map();
+  for (const t of tickets) {
+    out.set(t.id, consentStatusFor(t.attendee, t.event, t.attendeeId ? latest.get(t.attendeeId) : null));
+  }
+  return out;
+}
+
+/** Daily job: reminders for unanswered requests. */
+async function sendConsentReminders(now = new Date()) {
+  const pending = await prisma.consentRequest.findMany({
+    where: { status: 'pending', expiresAt: { gt: now } },
+    include: { event: true, attendee: true },
+  });
+  // Only the latest request per attendee is still live.
+  const latest = await latestRequestsFor([...new Set(pending.map(r => r.attendeeId))]);
+  let sent = 0;
+  for (const r of pending) {
+    if (latest.get(r.attendeeId)?.id !== r.id || !reminderDue(r, now)) continue;
+    if (new Date(r.event.startDate) <= now) continue; // the event has started
+    const token = newToken();
+    await prisma.consentRequest.update({ where: { id: r.id }, data: { tokenHash: hashToken(token), lastSentAt: now, remindersSent: { increment: 1 } } });
+    await sendConsentMessage(r, token, { reminder: true }).catch(e => console.warn('[consent] reminder failed:', e?.message || e));
+    sent += 1;
+  }
+  return sent;
+}
+
+/** Daily job: delete medical/emergency details a set number of days after the event. */
+async function purgeConsentMedicalData(now = new Date()) {
+  const { getSettingSync } = require('./settingsCache');
+  const days = Math.max(0, parseInt(getSettingSync('consent_medical_retention_days', String(DEFAULT_RETENTION_DAYS)), 10) || DEFAULT_RETENTION_DAYS);
+  const cutoff = new Date(new Date(now).getTime() - days * DAY);
+  const res = await prisma.consentRequest.updateMany({
+    where: { medicalPurgedAt: null, event: { endDate: { lt: cutoff } }, OR: [{ medical: { not: null } }, { emergency: { not: null } }] },
+    data: { medical: null, emergency: null, medicalPurgedAt: now },
+  });
+  return res.count;
+}
+
+/** Clears parent, medical and emergency details for a person's registrations (anonymise). */
+async function clearConsentDataForUser(userId, db = prisma) {
+  const attendees = await db.attendee.findMany({ where: { OR: [{ userId }, { registration: { userId } }] }, select: { id: true } });
+  const ids = attendees.map(a => a.id);
+  if (!ids.length) return 0;
+  await db.attendee.updateMany({ where: { id: { in: ids } }, data: { parentName: null, parentEmail: null, parentPhone: null, dateOfBirth: null, email: null, phone: null } });
+  const res = await db.consentRequest.updateMany({
+    where: { attendeeId: { in: ids } },
+    data: { medical: null, emergency: null, parentName: null, parentEmail: null, parentPhone: null, ip: null, device: null, medicalPurgedAt: new Date() },
+  });
+  return res.count;
+}
+
+module.exports = {
+  DEFAULT_RETENTION_DAYS,
+  consentError,
+  ageOn,
+  isMinor,
+  consentStatusFor,
+  reminderDue,
+  validateConsentAnswer,
+  hashToken,
+  consentLink,
+  sealJson,
+  openJson,
+  latestRequestsFor,
+  createConsentRequest,
+  ensureConsentRequests,
+  resendConsentRequest,
+  findRequestByToken,
+  consentStatusForTickets,
+  sendConsentReminders,
+  purgeConsentMedicalData,
+  clearConsentDataForUser,
+};

backend/src/utils/notifications.js

@@ -832,7 +832,7 @@ function buildRefundEmail(payment) {
 
 // ─── Daily event summary ──────────────────────────────────────────────────────
 
-function buildDailySummary(ev, registrations, payments, now) {
+function buildDailySummary(ev, registrations, payments, now, waitlistCount = 0) {
   const org = getOrg();
   const subject = `Daily summary: ${ev.title} — ${new Date(now).toLocaleDateString('en-GB', { day: 'numeric', month: 'long', year: 'numeric' })}`;
 
@@ -917,6 +917,7 @@ function buildDailySummary(ev, registrations, payments, now) {
         ${statsRow('Total registrations', totalRegistrations)}
         ${statsRow('Confirmed paid', paidCount, '#059669')}
         ${statsRow('Awaiting payment', pendingCount, '#d97706')}
+        ${ev.waitlistEnabled ? statsRow('On the waitlist', waitlistCount, '#7c3aed') : ''}
         <td style="text-align:center;padding:16px">
           <div style="font-size:24px;font-weight:800;color:#2563eb;font-family:${ff}">${fmtAmount(totalRevenue)}</div>
           <div style="font-size:12px;color:#64748b;margin-top:4px;font-family:${ff}">Total collected</div>
@@ -939,7 +940,7 @@ function buildDailySummary(ev, registrations, payments, now) {
     `Daily Summary — ${ev.title}`,
     new Date(now).toLocaleDateString(),
     '',
-    `Registrations: ${totalRegistrations} | Paid: ${paidCount} | Pending: ${pendingCount} | Revenue: ${fmtAmount(totalRevenue)}`,
+    `Registrations: ${totalRegistrations} | Paid: ${paidCount} | Pending: ${pendingCount}${ev.waitlistEnabled ? ` | Waitlist: ${waitlistCount}` : ''} | Revenue: ${fmtAmount(totalRevenue)}`,
     '',
     'Registrations:',
     ...(regRows.length ? regRows.map(r => `  ${r.name} <${r.email}> — ${r.status} — due: ${fmtAmount(r.totalDue)} paid: ${fmtAmount(r.totalPaid)} balance: ${fmtAmount(r.balance)}`) : ['  (none)']),
@@ -1457,7 +1458,10 @@ async function sendDailyEventSummaries(now = new Date()) {
         orderBy: { createdAt: 'asc' },
       });
 
-      const { subject, text, html } = buildDailySummary(ev, registrations, payments, now);
+      const waitlistCount = ev.waitlistEnabled
+        ? await prisma.waitlistEntry.count({ where: { eventId: ev.id, status: { in: ['waiting', 'offered'] } } })
+        : 0;
+      const { subject, text, html } = buildDailySummary(ev, registrations, payments, now, waitlistCount);
       const to = buildEventNotifyRecipientList(ev);
       if (to.length) await sendMail({ to: to.join(','), subject, html, text });
     }));
@@ -1503,6 +1507,7 @@ async function sendAttendeeFormLinkMessage(attendee) {
 }
 
 module.exports = {
+  buildEventNotifyRecipientList,
   sendAttendeeFormLinkMessage,
   sendRegistrationEmails,
   sendRegistrationUpdatedEmails,

backend/src/utils/scanLocks.js

@@ -0,0 +1,213 @@
+/**
+ * Offline scanning — locks, snapshots and syncing.
+ *
+ * Rules:
+ * - Offline mode is per section (or the whole event), and only one device may hold a
+ *   scope at a time: while offline, devices can't see each other's scans, so two
+ *   devices on the same scope could redeem one ticket twice. A whole-event lock clashes
+ *   with every section of that event, and a section lock with the whole event.
+ * - While a scope is locked, other devices can't scan it online either.
+ * - The lock holder downloads a snapshot of valid tickets; scans made offline are
+ *   queued on the device and synced later. Syncing is idempotent (each scan carries a
+ *   clientScanId) and never redeems more than is left on a ticket.
+ * - Anything that needs a person to look — unknown ticket, cancelled registration, used
+ *   up, outside the locked scope, consent not given — goes into an OfflineSyncReport.
+ * - A supervisor can force-release a lock (lost phone). If that device syncs later its
+ *   scans are still recorded, and the report is flagged.
+ */
+
+const prisma = require('../config/db');
+
+function lockError(message, statusCode = 400) {
+  const err = new Error(message);
+  err.statusCode = statusCode;
+  return err;
+}
+
+// ─── Pure helpers ─────────────────────────────────────────────────────────────
+
+/** Whether a new lock on `sectionId` (null = whole event) clashes with `existing`. */
+function locksClash(existing, sectionId) {
+  if (!existing.sectionId || !sectionId) return true;
+  return existing.sectionId === sectionId;
+}
+
+/**
+ * Whether `lock` covers a scan of a ticket with option `optionId`. When the scanner has
+ * picked a section, only a lock on that section (or the whole event) covers it; with no
+ * section picked, any lock on a section that admits the ticket does.
+ * @param {object} lock - { sectionId, section?: { allowedOptions: [{ eventOptionId }] } }
+ */
+function lockCovers(lock, { sectionId = null, optionId }) {
+  if (!lock.sectionId) return true;
+  if (sectionId) return sectionId === lock.sectionId;
+  return (lock.section?.allowedOptions || []).some(o => o.eventOptionId === optionId);
+}
+
+/**
+ * What to do with one synced scan, given the ticket as the server sees it now. Pure.
+ * @param {object|null} ticket - { remaining, cancelled, inScope, consentOk }
+ * @param {number} qty - quantity the device redeemed
+ * @returns {{ redeem: number, conflict: string|null }}
+ */
+function judgeSyncedScan(ticket, qty) {
+  if (!ticket) return { redeem: 0, conflict: 'not_found' };
+  if (ticket.cancelled) return { redeem: 0, conflict: 'cancelled' };
+  if (!ticket.inScope) return { redeem: 0, conflict: 'wrong_scope' };
+  if (ticket.remaining <= 0) return { redeem: 0, conflict: 'already_used' };
+  const redeem = Math.min(Math.max(1, qty || 1), ticket.remaining);
+  if (!ticket.consentOk) return { redeem, conflict: 'consent' };
+  return { redeem, conflict: redeem < (qty || 1) ? 'partly_used' : null };
+}
+
+const CONFLICT_TEXT = {
+  not_found: 'Ticket not found (possibly transferred or reissued)',
+  cancelled: 'Registration was cancelled',
+  wrong_scope: 'Ticket is not valid for this section',
+  already_used: 'Ticket had already been fully used',
+  partly_used: 'Fewer places were left than were checked in offline',
+  consent: 'Checked in without parental consent',
+};
+
+// ─── Database helpers ─────────────────────────────────────────────────────────
+
+const LOCK_INCLUDE = {
+  section: { include: { allowedOptions: true } },
+  user: { select: { id: true, name: true } },
+};
+
+async function activeLocks(eventId, db = prisma) {
+  return db.scanLock.findMany({ where: { eventId, releasedAt: null }, include: LOCK_INCLUDE, orderBy: { lockedAt: 'asc' } });
+}
+
+/** Locks a scope to this device. Re-locking by the same device and person returns the existing lock. */
+async function acquireLock({ eventId, sectionId = null, deviceId, deviceName, userId }) {
+  if (!deviceId || typeof deviceId !== 'string' || deviceId.length > 100) throw lockError('A device id is required');
+  return prisma.$transaction(async (tx) => {
+    await tx.$executeRaw`SELECT pg_advisory_xact_lock(hashtext(${'scanlock:' + eventId}))`;
+    const event = await tx.event.findUnique({ where: { id: eventId } });
+    if (!event) throw lockError('Event not found', 404);
+    if (sectionId) {
+      const section = await tx.section.findUnique({ where: { id: sectionId } });
+      if (!section || section.eventId !== eventId) throw lockError('Section not found for this event', 404);
+    }
+    const existing = await activeLocks(eventId, tx);
+    const same = existing.find(l => (l.sectionId || null) === (sectionId || null) && l.deviceId === deviceId && l.userId === userId);
+    if (same) return same;
+    const clash = existing.find(l => locksClash(l, sectionId));
+    if (clash) {
+      const scope = clash.section ? `"${clash.section.name}"` : 'the whole event';
+      throw lockError(`${scope} is offline-locked by ${clash.user.name}${clash.deviceName ? ` on ${clash.deviceName}` : ''}.`, 409);
+    }
+    return tx.scanLock.create({ data: { eventId, sectionId: sectionId || null, deviceId, deviceName: deviceName ? String(deviceName).slice(0, 100) : null, userId }, include: LOCK_INCLUDE });
+  });
+}
+
+/**
+ * The lock (other than the scanner's own device) that stops this online scan, or null.
+ * @param {object} ticket - { eventId, optionId }
+ */
+async function blockingLock(ticket, { sectionId = null, deviceId = null } = {}) {
+  const locks = await activeLocks(ticket.eventId);
+  return locks.find(l => l.deviceId !== deviceId && lockCovers(l, { sectionId, optionId: ticket.optionId })) || null;
+}
+
+/** Tickets valid in a lock's scope, for the device to keep offline. */
+async function snapshotFor(lock) {
+  const optionIds = lock.section ? lock.section.allowedOptions.map(o => o.eventOptionId) : null;
+  const tickets = await prisma.ticket.findMany({
+    where: {
+      eventId: lock.eventId,
+      registrationOption: { registration: { status: { not: 'cancelled' } }, ...(optionIds ? { eventOptionId: { in: optionIds } } : {}) },
+    },
+    include: {
+      usages: { select: { quantityRedeemed: true } },
+      attendee: { select: { name: true } },
+      user: { select: { name: true } },
+      registrationOption: { include: { eventOption: { select: { id: true, name: true, isMainTicket: true } }, variant: { select: { name: true } } } },
+    },
+  });
+  const { consentStatusForTickets } = require('./consent');
+  const consent = await consentStatusForTickets(tickets.map(t => t.id));
+  const snapshotAt = new Date();
+  await prisma.scanLock.update({ where: { id: lock.id }, data: { snapshotAt } });
+  return {
+    snapshotAt,
+    tickets: tickets.map(t => {
+      const redeemed = t.usages.reduce((s, u) => s + (u.quantityRedeemed || 1), 0);
+      return {
+        id: t.id,
+        qrCode: t.qrCode,
+        holder: t.attendee?.name || t.user?.name || '',
+        bookedBy: t.attendee ? t.user?.name || '' : '',
+        option: t.registrationOption.eventOption.name,
+        variant: t.registrationOption.variant?.name || null,
+        quantity: t.quantity || 1,
+        remaining: Math.max(0, (t.quantity || 1) - redeemed),
+        consentStatus: consent.get(t.id) || 'not_required',
+      };
+    }),
+  };
+}
+
+/**
+ * Records queued offline scans. Each scan: { clientScanId, qrCode, qty, scannedAt }.
+ * @returns {Promise<{ accepted, duplicates, conflicts, report }>}
+ */
+async function syncScans(lock, scans) {
+  const results = { accepted: 0, duplicates: 0, conflicts: [] };
+  const optionIds = lock.section ? new Set(lock.section.allowedOptions.map(o => o.eventOptionId)) : null;
+  const { consentStatusForTickets } = require('./consent');
+  const checkIns = [];
+
+  for (const scan of (scans || []).slice(0, 2000)) {
+    const clientScanId = String(scan?.clientScanId || '').slice(0, 100);
+    if (!clientScanId) continue;
+    if (await prisma.ticketUsage.findUnique({ where: { clientScanId } })) { results.duplicates += 1; continue; }
+
+    const qty = Math.max(1, parseInt(scan.qty, 10) || 1);
+    const scannedAt = scan.scannedAt && !isNaN(new Date(scan.scannedAt)) ? new Date(scan.scannedAt) : new Date();
+    const ticket = await prisma.ticket.findUnique({
+      where: { qrCode: String(scan.qrCode || '') },
+      include: { usages: true, registrationOption: { include: { registration: { select: { status: true } }, eventOption: { select: { isMainTicket: true } } } } },
+    });
+    let state = null;
+    if (ticket && ticket.eventId === lock.eventId) {
+      const redeemed = ticket.usages.reduce((s, u) => s + (u.quantityRedeemed || 1), 0);
+      const consent = (await consentStatusForTickets([ticket.id])).get(ticket.id);
+      state = {
+        remaining: (ticket.quantity || 1) - redeemed,
+        cancelled: ticket.registrationOption.registration.status === 'cancelled',
+        inScope: !optionIds || optionIds.has(ticket.registrationOption.eventOptionId),
+        consentOk: ['not_required', 'given'].includes(consent),
+      };
+    }
+    const verdict = judgeSyncedScan(state, qty);
+    if (verdict.redeem > 0) {
+      await prisma.ticketUsage.create({
+        data: { ticketId: ticket.id, scannedById: lock.userId, scannedAt, quantityRedeemed: verdict.redeem, clientScanId, offline: true, scanLockId: lock.id, syncedAt: new Date() },
+      });
+      await prisma.ticket.update({ where: { id: ticket.id }, data: { isUsed: state.remaining - verdict.redeem <= 0, updatedAt: new Date() } });
+      results.accepted += 1;
+      if (ticket.registrationOption.eventOption.isMainTicket) {
+        checkIns.push({ ticketId: ticket.id, qty: verdict.redeem, total: (ticket.quantity || 1) - state.remaining + verdict.redeem, left: state.remaining - verdict.redeem });
+      }
+    }
+    if (verdict.conflict) {
+      results.conflicts.push({ clientScanId, qrCode: scan.qrCode, ticketId: ticket?.id || null, qty, redeemed: verdict.redeem, scannedAt, reason: verdict.conflict, message: CONFLICT_TEXT[verdict.conflict] });
+    }
+  }
+
+  await prisma.scanLock.update({ where: { id: lock.id }, data: { lastSyncAt: new Date() } });
+  const report = await prisma.offlineSyncReport.create({
+    data: { scanLockId: lock.id, accepted: results.accepted, duplicates: results.duplicates, conflicts: results.conflicts, afterForceRelease: !!lock.forceReleasedById },
+  });
+
+  // Check-in confirmations go out after sync, not at the moment of the offline scan.
+  const { sendCheckInEmails } = require('./notifications');
+  for (const c of checkIns) sendCheckInEmails(c.ticketId, c.qty, c.total, c.left).catch(() => {});
+
+  return { ...results, report };
+}
+
+module.exports = { lockError, locksClash, lockCovers, judgeSyncedScan, CONFLICT_TEXT, LOCK_INCLUDE, activeLocks, acquireLock, blockingLock, snapshotFor, syncScans };

backend/src/utils/stock.js

@@ -0,0 +1,52 @@
+/**
+ * Ticket stock — the one place that decides how many places are taken.
+ *
+ * Taken = places on registrations that aren't cancelled + places held for a live
+ * waitlist offer (until it expires). An option's stock limit covers all its variants;
+ * a variant can also have its own limit. 0 means unlimited.
+ */
+
+const prisma = require('../config/db');
+
+/**
+ * @param {{ eventOptionId: string, variantId?: string|null }} line - variantId given → that variant only
+ * @param {{ excludeEntryId?: string, db?: object }} [opts] - excludeEntryId: ignore this
+ *   waitlist offer's hold (the person claiming it)
+ */
+async function takenCount({ eventOptionId, variantId = null }, { excludeEntryId = null, db = prisma } = {}) {
+  const scope = variantId ? { variantId } : { eventOptionId };
+  const [registered, held] = await Promise.all([
+    db.registrationOption.aggregate({
+      where: { ...scope, registration: { status: { not: 'cancelled' } } },
+      _sum: { quantity: true },
+    }),
+    db.waitlistEntry.aggregate({
+      where: {
+        ...scope,
+        status: 'offered',
+        offerExpiresAt: { gt: new Date() },
+        ...(excludeEntryId ? { id: { not: excludeEntryId } } : {}),
+      },
+      _sum: { offeredQuantity: true },
+    }),
+  ]);
+  return (registered._sum?.quantity || 0) + (held._sum?.offeredQuantity || 0);
+}
+
+/**
+ * Places still free on a line: the tighter of the option and variant limits.
+ * @returns {Promise<number|null>} null when unlimited
+ */
+async function remainingFor(option, variant, opts = {}) {
+  const limits = [];
+  if (option?.stockLimit > 0) {
+    limits.push(option.stockLimit - await takenCount({ eventOptionId: option.id }, opts));
+  }
+  if (variant?.stockLimit > 0) {
+    limits.push(variant.stockLimit - await takenCount({ eventOptionId: option.id, variantId: variant.id }, opts));
+  }
+  if (limits.length === 0) return null;
+  return Math.max(0, Math.min(...limits));
+}
+
+module.exports = { takenCount, remainingFor };

backend/src/utils/waitlist.js

@@ -0,0 +1,201 @@
+/**
+ * Waitlist for sold-out ticket options.
+ *
+ * Rules:
+ * - Only on events with waitlistEnabled, and only for a line that's actually sold out.
+ * - When places free up (a cancellation, a smaller booking, a raised stock limit, or an
+ *   offer expiring), processWaitlist offers them to the next people in line. An offer
+ *   holds the places for event.waitlistOfferHours — they count as taken (utils/stock.js)
+ *   so the public site can't sell them — and sends a claim link by email/WhatsApp.
+ * - If fewer places are free than someone asked for: with waitlistPartialOffers they're
+ *   offered what's free; otherwise they're skipped for the next person who fits.
+ * - Claiming = registering with the link (createRegistration's waitlistToken). Early-bird
+ *   and coupon rules apply as usual. An unclaimed offer expires and moves on.
+ */
+
+const crypto = require('crypto');
+const prisma = require('../config/db');
+const { remainingFor } = require('./stock');
+
+const ACTIVE = ['waiting', 'offered'];
+
+function waitlistError(message, statusCode = 400) {
+  const err = new Error(message);
+  err.statusCode = statusCode;
+  return err;
+}
+
+const hashToken = (token) => crypto.createHmac('sha256', process.env.JWT_SECRET || '').update(`waitlist:${token}`).digest('hex');
+
+function claimLink(token) {
+  const base = (process.env.FRONTEND_URL || process.env.APP_BASE_URL || 'http://localhost:3001').split(',')[0].trim().replace(/\/$/, '');
+  return `${base}/waitlist/claim/${token}`;
+}
+
+/**
+ * Who gets offered what, given the free places on a line. Pure.
+ * @param {Array} waiting - entries in queue order [{ id, quantity }]
+ * @param {number} free - places free
+ * @param {boolean} partial - offer what's free when it's less than asked for
+ * @returns {Array<{ entryId: string, quantity: number }>}
+ */
+function pickOffers(waiting, free, partial) {
+  const offers = [];
+  let left = free;
+  for (const entry of waiting) {
+    if (left <= 0) break;
+    if (entry.quantity <= left) {
+      offers.push({ entryId: entry.id, quantity: entry.quantity });
+      left -= entry.quantity;
+    } else if (partial) {
+      // First in line gets what's free; nobody behind them jumps the queue.
+      offers.push({ entryId: entry.id, quantity: left });
+      left = 0;
+    }
+    // else: skip to the next person who fits
+  }
+  return offers;
+}
+
+async function notifyOffer(entry, token) {
+  const { sendMail, emailWrapper, ctaButton, fallbackLink } = require('./email');
+  const { shouldEmail, waText, waTextAny } = require('./notify');
+  const ff = `-apple-system,BlinkMacSystemFont,'Segoe UI',Roboto,Helvetica,Arial,sans-serif`;
+  const user = entry.user;
+  const link = claimLink(token);
+  const item = `${entry.eventOption.name}${entry.variant ? ` (${entry.variant.name})` : ''}`;
+  const until = new Date(entry.offerExpiresAt).toLocaleString('en-GB', { day: 'numeric', month: 'long', hour: '2-digit', minute: '2-digit' });
+  const partialNote = entry.offeredQuantity < entry.quantity
+    ? ` You asked for ${entry.quantity}; ${entry.offeredQuantity} came free, and you can take those now.` : '';
+  const line = `${entry.offeredQuantity} × ${item} for ${entry.event.title} ${entry.offeredQuantity === 1 ? 'is' : 'are'} now available for you.${partialNote} We'll hold ${entry.offeredQuantity === 1 ? 'it' : 'them'} until ${until}.`;
+
+  const hasEmail = user?.email && !user.email.endsWith('@guest.local') && !user.email.endsWith('@deleted.invalid');
+  const sends = [];
+  if (hasEmail && shouldEmail(user)) {
+    const html = emailWrapper(`
+      <p style="font-size:22px;font-weight:800;color:#0f172a;margin:0 0 8px 0">A place has opened up!</p>
+      <p style="margin:0 0 8px 0;color:#374151;font-family:${ff}">Hi <strong>${user.name}</strong>,</p>
+      <p style="margin:0 0 24px 0;color:#374151;font-family:${ff}">${line}</p>
+      ${ctaButton('Claim my place', link)}
+      ${fallbackLink(link)}
+    `, { preheader: `Your waitlist place for ${entry.event.title}` });
+    sends.push(sendMail({ to: user.email, subject: `A place is available: ${entry.event.title}`, html, text: `Hi ${user.name},\n\n${line}\n\nClaim it here: ${link}` }));
+  }
+  const wa = `🎟️ Hi ${user?.name || 'there'}, ${line} Claim it here: ${link}`;
+  sends.push(hasEmail ? waText(user, wa) : waTextAny(user, wa));
+  await Promise.allSettled(sends);
+}
+
+const OFFER_INCLUDE = { event: true, eventOption: true, variant: true, user: { select: { id: true, name: true, email: true, phoneNumber: true, notificationPreference: true } } };
+
+/** Puts an entry on offer (inside the caller's transaction); returns the raw token. */
+async function writeOffer(db, entry, quantity, hours) {
+  const token = crypto.randomBytes(24).toString('hex');
+  await db.waitlistEntry.update({
+    where: { id: entry.id },
+    data: {
+      status: 'offered',
+      offeredQuantity: quantity,
+      offerTokenHash: hashToken(token),
+      offeredAt: new Date(),
+      offerExpiresAt: new Date(Date.now() + (hours || 24) * 60 * 60 * 1000),
+    },
+  });
+  return token;
+}
+
+async function notifyOffers(offers) {
+  for (const { entryId, token } of offers) {
+    const entry = await prisma.waitlistEntry.findUnique({ where: { id: entryId }, include: OFFER_INCLUDE });
+    if (entry) notifyOffer(entry, token).catch(e => console.warn('[waitlist] notify failed:', e?.message || e));
+  }
+}
+
+/** Offers `quantity` places to one entry (e.g. a supervisor's manual offer) and notifies. */
+async function makeOffer(entryId, quantity) {
+  const entry = await prisma.waitlistEntry.findUnique({ where: { id: entryId }, include: { event: true } });
+  const token = await writeOffer(prisma, entry, quantity, entry.event.waitlistOfferHours);
+  await notifyOffers([{ entryId, token }]);
+  return prisma.waitlistEntry.findUnique({ where: { id: entryId } });
+}
+
+/**
+ * Offers any free places on an event to the people waiting for them. Safe to call any
+ * time places might have freed up; runs one event at a time under an advisory lock.
+ * @returns {Promise<number>} offers made
+ */
+async function processWaitlist(eventId) {
+  const event = await prisma.event.findUnique({
+    where: { id: eventId },
+    include: { eventOptions: { include: { variants: true } } },
+  });
+  if (!event || !event.waitlistEnabled || !event.isActive || event.cashupStatus === 'closed') return 0;
+  if (new Date(event.endDate) < new Date()) return 0;
+
+  const made = [];
+  await prisma.$transaction(async (tx) => {
+    await tx.$executeRaw`SELECT pg_advisory_xact_lock(hashtext(${'waitlist:' + eventId}))`;
+    const waiting = await tx.waitlistEntry.findMany({ where: { eventId, status: 'waiting' }, orderBy: { position: 'asc' } });
+    const lines = [...new Map(waiting.map(w => [`${w.eventOptionId}::${w.variantId || ''}`, w])).values()];
+    for (const sample of lines) {
+      const option = event.eventOptions.find(o => o.id === sample.eventOptionId);
+      const variant = sample.variantId ? (option?.variants || []).find(v => v.id === sample.variantId) : null;
+      if (!option) continue;
+      const free = await remainingFor(option, variant, { db: tx });
+      if (free === null || free <= 0) continue;
+      const queue = waiting.filter(w => w.eventOptionId === sample.eventOptionId && (w.variantId || null) === (sample.variantId || null));
+      for (const offer of pickOffers(queue, free, event.waitlistPartialOffers)) {
+        const token = await writeOffer(tx, { id: offer.entryId }, offer.quantity, event.waitlistOfferHours);
+        made.push({ entryId: offer.entryId, token });
+      }
+    }
+  }, { timeout: 20000 });
+  await notifyOffers(made);
+  return made.length;
+}
+
+/** Marks lapsed offers as expired. @returns event ids that now have places to re-offer. */
+async function expireOffers(now = new Date()) {
+  const lapsed = await prisma.waitlistEntry.findMany({ where: { status: 'offered', offerExpiresAt: { lte: now } }, select: { id: true, eventId: true } });
+  if (lapsed.length === 0) return [];
+  await prisma.waitlistEntry.updateMany({ where: { id: { in: lapsed.map(l => l.id) } }, data: { status: 'expired', offerTokenHash: null } });
+  return [...new Set(lapsed.map(l => l.eventId))];
+}
+
+/** Background job: expire lapsed offers, then re-offer free places everywhere waiting. */
+async function runWaitlistJob() {
+  const expiredEvents = await expireOffers();
+  const waitingEvents = await prisma.waitlistEntry.findMany({ where: { status: 'waiting' }, distinct: ['eventId'], select: { eventId: true } });
+  const ids = new Set([...expiredEvents, ...waitingEvents.map(w => w.eventId)]);
+  let offers = 0;
+  for (const id of ids) offers += await processWaitlist(id).catch(() => 0);
+  return { expired: expiredEvents.length, offers };
+}
+
+/** Fire-and-forget re-offer after something freed places on an event. */
+function queueWaitlist(eventId) {
+  if (!eventId) return;
+  processWaitlist(eventId).catch(e => console.warn('[waitlist] process failed:', e?.message || e));
+}
+
+/** A live offer from its claim token, or null. */
+async function findOfferByToken(token) {
+  if (!token || typeof token !== 'string' || token.length > 100) return null;
+  return prisma.waitlistEntry.findUnique({
+    where: { offerTokenHash: hashToken(token) },
+    include: { event: true, eventOption: true, variant: true, user: { select: { id: true, name: true } } },
+  });
+}
+
+module.exports = {
+  ACTIVE,
+  waitlistError,
+  hashToken,
+  pickOffers,
+  makeOffer,
+  processWaitlist,
+  expireOffers,
+  runWaitlistJob,
+  queueWaitlist,
+  findOfferByToken,
+};

backend/tests/attendees.test.js

@@ -15,7 +15,7 @@ describe('validateAttendees', () => {
       { eventOptionId: 'kid', name: '  Sam ', email: ' ', phone: '0821234567' },
       { eventOptionId: 'kid', name: 'Alex', email: 'alex@example.com' },
     ]);
-    expect(out).toEqual([
+    expect(out).toMatchObject([
       { eventOptionId: 'kid', variantId: null, name: 'Sam', email: null, phone: '0821234567' },
       { eventOptionId: 'kid', variantId: null, name: 'Alex', email: 'alex@example.com', phone: null },
     ]);

backend/tests/consent.test.js

@@ -0,0 +1,135 @@
+process.env.JWT_SECRET = 'test-secret';
+
+const { ageOn, isMinor, consentStatusFor, reminderDue, validateConsentAnswer, hashToken } = require('../src/utils/consent');
+const { validateAttendees, lineKey } = require('../src/utils/attendees');
+
+const START = new Date('2026-12-10T08:00:00Z');
+const DAY = 24 * 60 * 60 * 1000;
+
+describe('ageOn / isMinor', () => {
+  test('counts whole years, turning a year older on the birthday', () => {
+    expect(ageOn('2008-12-10', START)).toBe(18);
+    expect(ageOn('2008-12-11', START)).toBe(17);
+    expect(ageOn('2010-01-01', START)).toBe(16);
+  });
+
+  test('under 18 on the event start date', () => {
+    expect(isMinor('2008-12-11', START)).toBe(true);
+    expect(isMinor('2008-12-10', START)).toBe(false);
+    expect(isMinor(null, START)).toBe(false);
+  });
+});
+
+describe('consentStatusFor', () => {
+  const event = { requiresParentalConsent: true, startDate: START };
+  const kid = { dateOfBirth: '2012-05-01' };
+
+  test('only needed on youth events, for minors', () => {
+    expect(consentStatusFor(kid, { ...event, requiresParentalConsent: false }, null)).toBe('not_required');
+    expect(consentStatusFor({ dateOfBirth: '1990-01-01' }, event, null)).toBe('not_required');
+  });
+
+  test('a minor with no request, or an unnamed ticket, is missing consent', () => {
+    expect(consentStatusFor(kid, event, null)).toBe('missing');
+    expect(consentStatusFor(null, event, null)).toBe('missing');
+  });
+
+  test('otherwise the latest request decides', () => {
+    expect(consentStatusFor(kid, event, { status: 'pending' })).toBe('pending');
+    expect(consentStatusFor(kid, event, { status: 'given' })).toBe('given');
+    expect(consentStatusFor(kid, event, { status: 'declined' })).toBe('declined');
+  });
+});
+
+describe('reminderDue', () => {
+  const now = new Date('2026-12-01T10:00:00Z');
+  const req = (over) => ({ status: 'pending', remindersSent: 0, lastSentAt: new Date(now.getTime() - 1 * DAY), expiresAt: START, ...over });
+
+  test('first reminder 2 days after the request', () => {
+    expect(reminderDue(req({}), now)).toBe(false);
+    expect(reminderDue(req({ lastSentAt: new Date(now.getTime() - 2 * DAY) }), now)).toBe(true);
+  });
+
+  test('then every 3 days', () => {
+    expect(reminderDue(req({ remindersSent: 1, lastSentAt: new Date(now.getTime() - 2 * DAY) }), now)).toBe(false);
+    expect(reminderDue(req({ remindersSent: 1, lastSentAt: new Date(now.getTime() - 3 * DAY) }), now)).toBe(true);
+  });
+
+  test('never once answered or expired', () => {
+    expect(reminderDue(req({ status: 'given', lastSentAt: new Date(0) }), now)).toBe(false);
+    expect(reminderDue(req({ lastSentAt: new Date(0), expiresAt: new Date(now.getTime() - 1) }), now)).toBe(false);
+  });
+});
+
+describe('validateConsentAnswer', () => {
+  const event = { consentCollectMedical: true, consentCollectEmergency: true, consentCollectPhoto: true };
+  const ok = { decision: 'give', signedName: 'Pat Parent', isGuardian: true, medical: { allergies: 'Peanuts' }, emergency: { name: 'Gran', phone: '0821234567' }, photoConsent: false };
+
+  test('accepts a complete answer and keeps only known fields', () => {
+    const out = validateConsentAnswer({ ...ok, extra: 'x' }, event);
+    expect(out).toEqual({
+      decision: 'give', signedName: 'Pat Parent',
+      medical: { allergies: 'Peanuts', medication: '', conditions: '', medicalAid: '' },
+      emergency: { name: 'Gran', phone: '0821234567', relationship: '' },
+      photoConsent: false,
+    });
+  });
+
+  test('needs a decision, a typed name and the guardian tick', () => {
+    expect(() => validateConsentAnswer({ ...ok, decision: 'maybe' }, event)).toThrow(/give or decline/);
+    expect(() => validateConsentAnswer({ ...ok, signedName: ' ' }, event)).toThrow(/full name/);
+    expect(() => validateConsentAnswer({ ...ok, isGuardian: false }, event)).toThrow(/parent or legal guardian/);
+  });
+
+  test('needs an emergency contact and a photo answer when asked for', () => {
+    expect(() => validateConsentAnswer({ ...ok, emergency: {} }, event)).toThrow(/emergency contact/);
+    expect(() => validateConsentAnswer({ ...ok, photoConsent: undefined }, event)).toThrow(/photo/);
+  });
+
+  test('declining needs no extra details', () => {
+    expect(validateConsentAnswer({ decision: 'decline', signedName: 'Pat', isGuardian: true }, event))
+      .toEqual({ decision: 'decline', signedName: 'Pat', medical: null, emergency: null, photoConsent: null });
+  });
+});
+
+describe('hashToken', () => {
+  test('is stable and never the token itself', () => {
+    expect(hashToken('abc')).toBe(hashToken('abc'));
+    expect(hashToken('abc')).not.toContain('abc');
+    expect(hashToken('abc')).not.toBe(hashToken('abd'));
+  });
+});
+
+describe('validateAttendees on a youth event', () => {
+  const event = {
+    requiresParentalConsent: true, allowNamedAttendees: true, startDate: START,
+    eventOptions: [{ id: 'kid', name: 'Camper', isMainTicket: true }, { id: 'shirt', name: 'T-shirt', isMainTicket: false }],
+  };
+  const places = { [lineKey('kid', null)]: 2, [lineKey('shirt', null)]: 1 };
+  const parent = { parentName: 'Pat', parentEmail: 'pat@example.com', parentPhone: '0821234567' };
+
+  test('every main place must be named', () => {
+    expect(() => validateAttendees(event, places, [{ eventOptionId: 'kid', name: 'A', dateOfBirth: '1990-01-01' }])).toThrow(/every "Camper" ticket/);
+  });
+
+  test('a date of birth is required', () => {
+    expect(() => validateAttendees(event, places, [{ eventOptionId: 'kid', name: 'A' }, { eventOptionId: 'kid', name: 'B' }])).toThrow(/date of birth/);
+  });
+
+  test('minors need full parent details; adults do not', () => {
+    expect(() => validateAttendees(event, places, [
+      { eventOptionId: 'kid', name: 'Kid', dateOfBirth: '2014-03-03', parentName: 'Pat' },
+      { eventOptionId: 'kid', name: 'Leader', dateOfBirth: '1990-01-01' },
+    ])).toThrow(/under 18/);
+    const out = validateAttendees(event, places, [
+      { eventOptionId: 'kid', name: 'Kid', dateOfBirth: '2014-03-03', ...parent },
+      { eventOptionId: 'kid', name: 'Leader', dateOfBirth: '1990-01-01' },
+    ]);
+    expect(out[0]).toMatchObject({ name: 'Kid', parentEmail: 'pat@example.com' });
+    expect(out[0].dateOfBirth).toBeInstanceOf(Date);
+  });
+
+  test('a date of birth in the future is refused', () => {
+    expect(() => validateAttendees(event, { [lineKey('kid', null)]: 1 }, [{ eventOptionId: 'kid', name: 'A', dateOfBirth: '2999-01-01' }])).toThrow(/valid date of birth/);
+  });
+});

backend/tests/scanLocks.test.js

@@ -0,0 +1,54 @@
+const { locksClash, lockCovers, judgeSyncedScan } = require('../src/utils/scanLocks');
+
+describe('locksClash', () => {
+  test('a whole-event lock clashes with everything', () => {
+    expect(locksClash({ sectionId: null }, 'hall')).toBe(true);
+    expect(locksClash({ sectionId: 'hall' }, null)).toBe(true);
+  });
+
+  test('section locks only clash with the same section', () => {
+    expect(locksClash({ sectionId: 'hall' }, 'hall')).toBe(true);
+    expect(locksClash({ sectionId: 'hall' }, 'dinner')).toBe(false);
+  });
+});
+
+describe('lockCovers', () => {
+  const dinnerLock = { sectionId: 'dinner', section: { allowedOptions: [{ eventOptionId: 'meal' }] } };
+
+  test('a whole-event lock covers every scan', () => {
+    expect(lockCovers({ sectionId: null }, { sectionId: 'x', optionId: 'y' })).toBe(true);
+  });
+
+  test('with a section picked, only that section is covered', () => {
+    expect(lockCovers(dinnerLock, { sectionId: 'dinner', optionId: 'meal' })).toBe(true);
+    expect(lockCovers(dinnerLock, { sectionId: 'hall', optionId: 'meal' })).toBe(false);
+  });
+
+  test('with no section picked, tickets the locked section admits are covered', () => {
+    expect(lockCovers(dinnerLock, { optionId: 'meal' })).toBe(true);
+    expect(lockCovers(dinnerLock, { optionId: 'entry' })).toBe(false);
+  });
+});
+
+describe('judgeSyncedScan', () => {
+  const ok = { remaining: 2, cancelled: false, inScope: true, consentOk: true };
+
+  test('records a normal scan', () => {
+    expect(judgeSyncedScan(ok, 1)).toEqual({ redeem: 1, conflict: null });
+  });
+
+  test('never redeems more than is left', () => {
+    expect(judgeSyncedScan(ok, 3)).toEqual({ redeem: 2, conflict: 'partly_used' });
+    expect(judgeSyncedScan({ ...ok, remaining: 0 }, 1)).toEqual({ redeem: 0, conflict: 'already_used' });
+  });
+
+  test('flags unknown, cancelled and out-of-scope tickets without recording them', () => {
+    expect(judgeSyncedScan(null, 1)).toEqual({ redeem: 0, conflict: 'not_found' });
+    expect(judgeSyncedScan({ ...ok, cancelled: true }, 1)).toEqual({ redeem: 0, conflict: 'cancelled' });
+    expect(judgeSyncedScan({ ...ok, inScope: false }, 1)).toEqual({ redeem: 0, conflict: 'wrong_scope' });
+  });
+
+  test('records but flags a check-in without consent', () => {
+    expect(judgeSyncedScan({ ...ok, consentOk: false }, 1)).toEqual({ redeem: 1, conflict: 'consent' });
+  });
+});

backend/tests/waitlist.test.js

@@ -0,0 +1,31 @@
+const { pickOffers } = require('../src/utils/waitlist');
+
+const q = (...qs) => qs.map((quantity, i) => ({ id: `e${i + 1}`, quantity }));
+
+describe('pickOffers', () => {
+  test('offers people in order while places last', () => {
+    expect(pickOffers(q(1, 2, 1), 3, true)).toEqual([
+      { entryId: 'e1', quantity: 1 },
+      { entryId: 'e2', quantity: 2 },
+    ]);
+  });
+
+  test('nothing free, no offers', () => {
+    expect(pickOffers(q(1), 0, true)).toEqual([]);
+  });
+
+  test('partial offers: the first in line gets what is free, nobody jumps ahead', () => {
+    expect(pickOffers(q(3, 1), 2, true)).toEqual([{ entryId: 'e1', quantity: 2 }]);
+  });
+
+  test('without partial offers, skips to the next person who fits', () => {
+    expect(pickOffers(q(3, 1, 1), 2, false)).toEqual([
+      { entryId: 'e2', quantity: 1 },
+      { entryId: 'e3', quantity: 1 },
+    ]);
+  });
+
+  test('without partial offers, nobody fits', () => {
+    expect(pickOffers(q(3, 4), 2, false)).toEqual([]);
+  });
+});

frontend/package-lock.json

@@ -1,12 +1,12 @@
 {
   "name": "hope-events-frontend",
-  "version": "1.14.0",
+  "version": "1.17.0",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
       "name": "hope-events-frontend",
-      "version": "1.14.0",
+      "version": "1.17.0",
       "dependencies": {
         "@hookform/resolvers": "^5.2.1",
         "@radix-ui/react-accordion": "^1.2.11",
@@ -31,6 +31,7 @@
         "class-variance-authority": "^0.7.1",
         "clsx": "^2.1.1",
         "date-fns": "^4.1.0",
+        "idb": "^8.0.4",
         "lucide-react": "^0.536.0",
         "next": "^15.5.24",
         "qrcode": "^1.5.4",
@@ -869,9 +870,6 @@
       "cpu": [
         "arm"
       ],
-      "libc": [
-        "glibc"
-      ],
       "license": "LGPL-3.0-or-later",
       "optional": true,
       "os": [
@@ -888,9 +886,6 @@
       "cpu": [
         "arm64"
       ],
-      "libc": [
-        "glibc"
-      ],
       "license": "LGPL-3.0-or-later",
       "optional": true,
       "os": [
@@ -907,9 +902,6 @@
       "cpu": [
         "ppc64"
       ],
-      "libc": [
-        "glibc"
-      ],
       "license": "LGPL-3.0-or-later",
       "optional": true,
       "os": [
@@ -926,9 +918,6 @@
       "cpu": [
         "riscv64"
       ],
-      "libc": [
-        "glibc"
-      ],
       "license": "LGPL-3.0-or-later",
       "optional": true,
       "os": [
@@ -945,9 +934,6 @@
       "cpu": [
         "s390x"
       ],
-      "libc": [
-        "glibc"
-      ],
       "license": "LGPL-3.0-or-later",
       "optional": true,
       "os": [
@@ -964,9 +950,6 @@
       "cpu": [
         "x64"
       ],
-      "libc": [
-        "glibc"
-      ],
       "license": "LGPL-3.0-or-later",
       "optional": true,
       "os": [
@@ -983,9 +966,6 @@
       "cpu": [
         "arm64"
       ],
-      "libc": [
-        "musl"
-      ],
       "license": "LGPL-3.0-or-later",
       "optional": true,
       "os": [
@@ -1002,9 +982,6 @@
       "cpu": [
         "x64"
       ],
-      "libc": [
-        "musl"
-      ],
       "license": "LGPL-3.0-or-later",
       "optional": true,
       "os": [
@@ -1021,9 +998,6 @@
       "cpu": [
         "arm"
       ],
-      "libc": [
-        "glibc"
-      ],
       "license": "Apache-2.0",
       "optional": true,
       "os": [
@@ -1046,9 +1020,6 @@
       "cpu": [
         "arm64"
       ],
-      "libc": [
-        "glibc"
-      ],
       "license": "Apache-2.0",
       "optional": true,
       "os": [
@@ -1071,9 +1042,6 @@
       "cpu": [
         "ppc64"
       ],
-      "libc": [
-        "glibc"
-      ],
       "license": "Apache-2.0",
       "optional": true,
       "os": [
@@ -1096,9 +1064,6 @@
       "cpu": [
         "riscv64"
       ],
-      "libc": [
-        "glibc"
-      ],
       "license": "Apache-2.0",
       "optional": true,
       "os": [
@@ -1121,9 +1086,6 @@
       "cpu": [
         "s390x"
       ],
-      "libc": [
-        "glibc"
-      ],
       "license": "Apache-2.0",
       "optional": true,
       "os": [
@@ -1146,9 +1108,6 @@
       "cpu": [
         "x64"
       ],
-      "libc": [
-        "glibc"
-      ],
       "license": "Apache-2.0",
       "optional": true,
       "os": [
@@ -1171,9 +1130,6 @@
       "cpu": [
         "arm64"
       ],
-      "libc": [
-        "musl"
-      ],
       "license": "Apache-2.0",
       "optional": true,
       "os": [
@@ -1196,9 +1152,6 @@
       "cpu": [
         "x64"
       ],
-      "libc": [
-        "musl"
-      ],
       "license": "Apache-2.0",
       "optional": true,
       "os": [
@@ -1455,9 +1408,6 @@
       "cpu": [
         "arm64"
       ],
-      "libc": [
-        "glibc"
-      ],
       "license": "MIT",
       "optional": true,
       "os": [
@@ -1474,9 +1424,6 @@
       "cpu": [
         "arm64"
       ],
-      "libc": [
-        "musl"
-      ],
       "license": "MIT",
       "optional": true,
       "os": [
@@ -1493,9 +1440,6 @@
       "cpu": [
         "x64"
       ],
-      "libc": [
-        "glibc"
-      ],
       "license": "MIT",
       "optional": true,
       "os": [
@@ -1512,9 +1456,6 @@
       "cpu": [
         "x64"
       ],
-      "libc": [
-        "musl"
-      ],
       "license": "MIT",
       "optional": true,
       "os": [
@@ -6865,6 +6806,12 @@
         "node": ">= 6"
       }
     },
+    "node_modules/idb": {
+      "version": "8.0.4",
+      "resolved": "https://registry.npmjs.org/idb/-/idb-8.0.4.tgz",
+      "integrity": "sha512-jd0ITCrN+Zah4J7R/Z2jnR3W7A4BXDAjmo62MwWuSjxCiueUAf7X5rbodEdidWzeknwXHmLpdZkoiiCppNi30Q==",
+      "license": "ISC"
+    },
     "node_modules/ignore": {
       "version": "5.3.2",
       "resolved": "https://registry.npmjs.org/ignore/-/ignore-5.3.2.tgz",

frontend/package.json

@@ -1,6 +1,6 @@
 {
   "name": "hope-events-frontend",
-  "version": "1.14.0",
+  "version": "1.17.0",
   "private": true,
   "scripts": {
     "dev": "next dev --turbopack",
@@ -32,6 +32,7 @@
     "class-variance-authority": "^0.7.1",
     "clsx": "^2.1.1",
     "date-fns": "^4.1.0",
+    "idb": "^8.0.4",
     "lucide-react": "^0.536.0",
     "next": "^15.5.24",
     "qrcode": "^1.5.4",

frontend/public/sw.js

@@ -0,0 +1,67 @@
+/*
+ * Service worker for offline ticket scanning.
+ *
+ * Only the scanner page and the static files it needs are cached:
+ * - /_next/static/* (hashed, never change): cache-first.
+ * - The scanner page itself: network-first, falling back to the cached copy offline.
+ * - The page can ask (postMessage { type: 'cache-urls', urls }) for the files it has
+ *   loaded to be cached up front, so it works offline straight after "Enable offline mode".
+ * API calls are never cached — offline scans go through IndexedDB instead.
+ */
+const CACHE = 'hope-scanner-v1';
+const SCANNER_PATH = '/dashboard/staff/ticket-scanning';
+
+self.addEventListener('install', () => self.skipWaiting());
+self.addEventListener('activate', (event) => {
+  event.waitUntil((async () => {
+    const keys = await caches.keys();
+    await Promise.all(keys.filter(k => k.startsWith('hope-scanner-') && k !== CACHE).map(k => caches.delete(k)));
+    await self.clients.claim();
+  })());
+});
+
+self.addEventListener('message', (event) => {
+  const data = event.data || {};
+  if (data.type !== 'cache-urls' || !Array.isArray(data.urls)) return;
+  event.waitUntil((async () => {
+    const cache = await caches.open(CACHE);
+    const sameOrigin = data.urls.filter(u => {
+      try { return new URL(u, self.location.origin).origin === self.location.origin; } catch { return false; }
+    });
+    await Promise.all(sameOrigin.map(u => cache.add(u).catch(() => {})));
+  })());
+});
+
+self.addEventListener('fetch', (event) => {
+  const req = event.request;
+  if (req.method !== 'GET') return;
+  const url = new URL(req.url);
+  if (url.origin !== self.location.origin) return;
+
+  if (url.pathname.startsWith('/_next/static/')) {
+    event.respondWith((async () => {
+      const cache = await caches.open(CACHE);
+      const hit = await cache.match(req);
+      if (hit) return hit;
+      const res = await fetch(req);
+      if (res.ok) cache.put(req, res.clone());
+      return res;
+    })());
+    return;
+  }
+
+  if (url.pathname === SCANNER_PATH) {
+    event.respondWith((async () => {
+      const cache = await caches.open(CACHE);
+      try {
+        const res = await fetch(req);
+        if (res.ok) cache.put(SCANNER_PATH, res.clone());
+        return res;
+      } catch {
+        const hit = (await cache.match(req, { ignoreSearch: true })) || (await cache.match(SCANNER_PATH));
+        if (hit) return hit;
+        throw new Error('offline and not cached');
+      }
+    })());
+  }
+});

frontend/src/app/consent/[token]/page.tsx

@@ -0,0 +1,181 @@
+"use client";
+import React, { useEffect, useState } from "react";
+import { useParams } from "next/navigation";
+import { Navbar } from "@/components/layout/Navbar";
+import { Footer } from "@/components/layout/Footer";
+import { apiFetch, ApiError } from "@/lib/api";
+import { formatDate } from "@/lib/date";
+import { ShieldCheck, CheckCircle2, XCircle } from "lucide-react";
+
+type ConsentInfo = {
+  status: "pending" | "given" | "declined";
+  superseded: boolean;
+  expired: boolean;
+  respondedAt: string | null;
+  attendeeName: string;
+  parentName: string | null;
+  consentText: string;
+  event: { title: string; startDate: string; endDate: string; location: string | null };
+  collect: { medical: boolean; emergency: boolean; photo: boolean };
+};
+
+const inputCls = "w-full border rounded-lg px-3 py-2 text-sm focus:outline-none focus:ring-2 focus:ring-brand-400";
+
+/** Public page a parent/guardian opens from their consent email or WhatsApp. */
+export default function ConsentPage() {
+  const params = useParams<{ token: string }>();
+  const token = params?.token;
+  const [info, setInfo] = useState<ConsentInfo | null>(null);
+  const [loadError, setLoadError] = useState<string | null>(null);
+  const [error, setError] = useState<string | null>(null);
+  const [busy, setBusy] = useState(false);
+  const [done, setDone] = useState<"given" | "declined" | null>(null);
+
+  const [signedName, setSignedName] = useState("");
+  const [isGuardian, setIsGuardian] = useState(false);
+  const [medical, setMedical] = useState({ allergies: "", medication: "", conditions: "", medicalAid: "" });
+  const [emergency, setEmergency] = useState({ name: "", phone: "", relationship: "" });
+  const [photoConsent, setPhotoConsent] = useState<boolean | null>(null);
+
+  useEffect(() => {
+    if (!token) return;
+    apiFetch<ConsentInfo>(`/api/consent/${encodeURIComponent(token)}`)
+      .then(res => { setInfo(res); setSignedName(res.parentName || ""); })
+      .catch(e => setLoadError(e instanceof ApiError ? e.message : "Couldn't load this consent request."));
+  }, [token]);
+
+  const submit = async (decision: "give" | "decline") => {
+    if (!token || !info) return;
+    setError(null);
+    if (decision === "give" && info.collect.photo && photoConsent === null) { setError("Please answer the photo consent question."); return; }
+    setBusy(true);
+    try {
+      await apiFetch(`/api/consent/${encodeURIComponent(token)}`, {
+        method: "POST",
+        body: {
+          decision, signedName, isGuardian,
+          ...(decision === "give" && info.collect.medical ? { medical } : {}),
+          ...(decision === "give" && info.collect.emergency ? { emergency } : {}),
+          ...(decision === "give" && info.collect.photo ? { photoConsent } : {}),
+        },
+      });
+      setDone(decision === "give" ? "given" : "declined");
+    } catch (e) {
+      setError(e instanceof ApiError ? e.message : "Couldn't save your answer. Please try again.");
+    } finally {
+      setBusy(false);
+    }
+  };
+
+  const open = info && info.status === "pending" && !info.superseded && !info.expired && !done;
+
+  return (
+    <div className="min-h-screen flex flex-col">
+      <Navbar />
+      <main className="flex-1 px-4 py-10 max-w-2xl mx-auto w-full">
+        <div className="flex items-center gap-3 mb-4">
+          <div className="w-10 h-10 rounded-xl bg-brand-50 flex items-center justify-center shrink-0">
+            <ShieldCheck className="w-5 h-5 text-brand-600" />
+          </div>
+          <h1 className="text-2xl font-semibold text-gray-900">Parental consent</h1>
+        </div>
+
+        {loadError && <div className="border rounded-xl p-4 bg-red-50 text-red-800 text-sm">{loadError}</div>}
+        {!info && !loadError && <div className="text-sm text-gray-600">Loading…</div>}
+
+        {info && (
+          <div className="border rounded-xl p-5 bg-white shadow-sm space-y-4">
+            <div>
+              <div className="text-sm text-gray-500">Event</div>
+              <div className="font-semibold text-gray-900">{info.event.title}</div>
+              <div className="text-sm text-gray-600">
+                {formatDate(new Date(info.event.startDate))}{info.event.endDate ? ` – ${formatDate(new Date(info.event.endDate))}` : ""}
+                {info.event.location ? ` · ${info.event.location}` : ""}
+              </div>
+            </div>
+            <div>
+              <div className="text-sm text-gray-500">Attendee</div>
+              <div className="font-semibold text-gray-900">{info.attendeeName}</div>
+            </div>
+
+            {(done || info.status !== "pending") && (
+              <div className={`flex items-start gap-2 rounded-lg p-3 text-sm ${(done || info.status) === "given" ? "bg-green-50 text-green-800" : "bg-amber-50 text-amber-900"}`}>
+                {(done || info.status) === "given" ? <CheckCircle2 className="w-5 h-5 shrink-0" /> : <XCircle className="w-5 h-5 shrink-0" />}
+                <span>
+                  {(done || info.status) === "given" ? "Consent has been given. Thank you!" : "Consent has been declined. The organisers have been told."}
+                  {!done && info.respondedAt && ` (${formatDate(new Date(info.respondedAt))})`}
+                </span>
+              </div>
+            )}
+            {!done && info.status === "pending" && info.superseded && (
+              <div className="rounded-lg p-3 text-sm bg-amber-50 text-amber-900">A newer consent request has replaced this one. Please use the link in your latest message.</div>
+            )}
+            {!done && info.status === "pending" && info.expired && (
+              <div className="rounded-lg p-3 text-sm bg-gray-100 text-gray-700">This consent link has expired because the event has ended.</div>
+            )}
+
+            {open && (
+              <>
+                <div>
+                  <div className="text-sm font-medium text-gray-800 mb-1">Please read</div>
+                  <div className="text-sm text-gray-700 whitespace-pre-line border rounded-lg p-3 bg-gray-50 max-h-72 overflow-y-auto">{info.consentText || "The organisers haven't added any consent text."}</div>
+                </div>
+
+                {info.collect.medical && (
+                  <fieldset className="space-y-2">
+                    <legend className="text-sm font-medium text-gray-800">Medical information <span className="font-normal text-gray-500">(kept confidential and deleted after the event)</span></legend>
+                    <textarea className={inputCls} rows={2} placeholder="Allergies" value={medical.allergies} onChange={e => setMedical({ ...medical, allergies: e.target.value })} aria-label="Allergies" />
+                    <textarea className={inputCls} rows={2} placeholder="Medication" value={medical.medication} onChange={e => setMedical({ ...medical, medication: e.target.value })} aria-label="Medication" />
+                    <textarea className={inputCls} rows={2} placeholder="Medical conditions" value={medical.conditions} onChange={e => setMedical({ ...medical, conditions: e.target.value })} aria-label="Medical conditions" />
+                    <input className={inputCls} placeholder="Medical aid (scheme and number)" value={medical.medicalAid} onChange={e => setMedical({ ...medical, medicalAid: e.target.value })} aria-label="Medical aid" />
+                  </fieldset>
+                )}
+
+                {info.collect.emergency && (
+                  <fieldset className="space-y-2">
+                    <legend className="text-sm font-medium text-gray-800">Emergency contact</legend>
+                    <div className="grid grid-cols-1 sm:grid-cols-3 gap-2">
+                      <input className={inputCls} placeholder="Name" value={emergency.name} onChange={e => setEmergency({ ...emergency, name: e.target.value })} aria-label="Emergency contact name" />
+                      <input type="tel" className={inputCls} placeholder="Phone" value={emergency.phone} onChange={e => setEmergency({ ...emergency, phone: e.target.value })} aria-label="Emergency contact phone" />
+                      <input className={inputCls} placeholder="Relationship" value={emergency.relationship} onChange={e => setEmergency({ ...emergency, relationship: e.target.value })} aria-label="Relationship" />
+                    </div>
+                  </fieldset>
+                )}
+
+                {info.collect.photo && (
+                  <fieldset>
+                    <legend className="text-sm font-medium text-gray-800 mb-1">May {info.attendeeName} appear in event photos and videos?</legend>
+                    <label className="inline-flex items-center gap-2 text-sm mr-4"><input type="radio" name="photo" checked={photoConsent === true} onChange={() => setPhotoConsent(true)} /> Yes</label>
+                    <label className="inline-flex items-center gap-2 text-sm"><input type="radio" name="photo" checked={photoConsent === false} onChange={() => setPhotoConsent(false)} /> No</label>
+                  </fieldset>
+                )}
+
+                <div className="space-y-2 border-t pt-4">
+                  <label className="block text-sm font-medium text-gray-800">Type your full name to sign</label>
+                  <input className={inputCls} value={signedName} onChange={e => setSignedName(e.target.value)} aria-label="Your full name" />
+                  <label className="flex items-start gap-2 text-sm text-gray-700">
+                    <input type="checkbox" className="mt-0.5" checked={isGuardian} onChange={e => setIsGuardian(e.target.checked)} />
+                    <span>I am the parent or legal guardian of {info.attendeeName}.</span>
+                  </label>
+                </div>
+
+                {error && <div className="p-3 border rounded bg-red-50 text-red-800 text-sm">{error}</div>}
+
+                <div className="flex flex-wrap gap-3">
+                  <button onClick={() => submit("give")} disabled={busy || !isGuardian || signedName.trim().length < 2} className="px-4 py-2 rounded-lg bg-brand-600 text-white text-sm font-medium hover:bg-brand-700 disabled:opacity-50">
+                    {busy ? "Saving…" : "Give consent"}
+                  </button>
+                  <button onClick={() => submit("decline")} disabled={busy || !isGuardian || signedName.trim().length < 2} className="px-4 py-2 rounded-lg border border-gray-300 text-gray-700 text-sm font-medium hover:bg-gray-50 disabled:opacity-50">
+                    Decline
+                  </button>
+                </div>
+                <p className="text-xs text-gray-500">We record your typed name, the time, and the device you used, together with the text above.</p>
+              </>
+            )}
+          </div>
+        )}
+      </main>
+      <Footer />
+    </div>
+  );
+}

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

@@ -22,6 +22,13 @@ const ACTIONS = [
   "coupon_updated",
   "coupon_disabled",
   "coupon_applied_manual",
+  "consent_override",
+  "consent_rerequested",
+  "medical_list_viewed",
+  "scan_lock_acquired",
+  "scan_lock_released",
+  "scan_lock_force_released",
+  "offline_sync",
 ] as const;
 
 const ACTION_LABELS: Record<string, string> = {
@@ -38,6 +45,13 @@ const ACTION_LABELS: Record<string, string> = {
   coupon_updated: "Coupon edited",
   coupon_disabled: "Coupon turned off",
   coupon_applied_manual: "Coupon applied/removed by staff",
+  consent_override: "Consent overridden at check-in",
+  consent_rerequested: "Consent re-requested",
+  medical_list_viewed: "Medical list viewed",
+  scan_lock_acquired: "Offline scanning started",
+  scan_lock_released: "Offline scanning ended",
+  scan_lock_force_released: "Offline lock force-released",
+  offline_sync: "Offline scans synced",
 };
 
 interface AuditLogEntry {

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

@@ -8,7 +8,7 @@ import { useStableState } from "@/hooks/useStableState";
 import { useVisiblePolling } from "@/hooks/useVisiblePolling";
 import {
   Calendar, Banknote, Gift, Users, Ticket, QrCode, ClipboardList,
-  UserPlus, FileText, MessageCircle, BarChart2, Mail, Wallet, DoorOpen, History, TicketPercent,
+  UserPlus, FileText, MessageCircle, BarChart2, Mail, Wallet, DoorOpen, History, TicketPercent, ShieldCheck, ListChecks, WifiOff,
 } from "lucide-react";
 import { StatCard, StatCardRow } from "@/components/shared/StatCard";
 import { QuickActionTile, QuickActionGrid } from "@/components/shared/QuickActionTile";
@@ -27,6 +27,9 @@ const QUICK_ACTIONS = [
   { href: "/dashboard/supervisor/manual", label: "Manual registration", description: "Register a guest and issue tickets", icon: UserPlus },
   { href: "/dashboard/supervisor/at-the-door", label: "At the door", description: "Walk-ins, payments, ticket printing", icon: DoorOpen },
   { href: "/dashboard/supervisor/payments", label: "Payments & donations", description: "Manual payments and assignment", icon: Wallet },
+  { href: "/dashboard/supervisor/offline-scans", label: "Offline scanning", description: "Devices scanning offline and their synced scans", icon: WifiOff },
+  { href: "/dashboard/supervisor/waitlist", label: "Waitlist", description: "People waiting for sold-out tickets", icon: ListChecks },
+  { href: "/dashboard/supervisor/consent", label: "Parental consent", description: "Youth events: consent status and medical list", icon: ShieldCheck },
   { href: "/dashboard/supervisor/coupons", label: "Coupon codes", description: "Discounts for staff, leaders and promotions", icon: TicketPercent },
   { 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 },

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

@@ -136,6 +136,7 @@ function SiteSettingsPageInner() {
   const [legalIoEmail, setLegalIoEmail] = useState("");
   const [legalWebsiteUrl, setLegalWebsiteUrl] = useState("");
   const [legalEffectiveDate, setLegalEffectiveDate] = useState("");
+  const [consentRetentionDays, setConsentRetentionDays] = useState("30");
 
   // ── Load all settings once ────────────────────────────────────────────────
   useEffect(() => {
@@ -171,6 +172,7 @@ function SiteSettingsPageInner() {
         setLegalIoEmail(s.legal_io_email || "");
         setLegalWebsiteUrl(s.legal_website_url || "");
         setLegalEffectiveDate(s.legal_effective_date || "");
+        setConsentRetentionDays(s.consent_medical_retention_days || "30");
       })
       .catch((e: any) => setResult({ ok: false, message: e?.message || "Failed to load settings" }))
       .finally(() => setLoadingInitial(false));
@@ -319,6 +321,7 @@ function SiteSettingsPageInner() {
     legal_io_email:       legalIoEmail.trim(),
     legal_website_url:    legalWebsiteUrl.trim(),
     legal_effective_date: legalEffectiveDate.trim(),
+    consent_medical_retention_days: String(Math.max(0, parseInt(consentRetentionDays, 10) || 0)),
   });
 
   const handleTestSmtp = async () => {
@@ -658,6 +661,15 @@ function SiteSettingsPageInner() {
               </div>
             </div>
 
+            <div className="border-t pt-4">
+              <p className="text-sm font-medium text-gray-700 mb-3">Youth events</p>
+              <Field label="Delete medical & emergency details this many days after an event">
+                <input type="number" min="0" className={`${inputCls} sm:w-32`}
+                  value={consentRetentionDays} onChange={e => setConsentRetentionDays(e.target.value)} />
+              </Field>
+              <p className="text-xs text-gray-500 mt-1">Collected on parental consent forms. The consent record itself (who agreed, and when) is kept.</p>
+            </div>
+
             <SaveBar saving={saving} onSave={saveLegal} result={result} />
           </div>
         )}

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

@@ -7,6 +7,9 @@ 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";
 
 export default function TicketScanningPage() {
   const router = useRouter();
@@ -17,6 +20,7 @@ export default function TicketScanningPage() {
   const [alreadyUsedModal, setAlreadyUsedModal] = useState<{ message: string; ticket?: any } | 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 [loadingStats, setLoadingStats] = useState<boolean>(false);
@@ -34,8 +38,12 @@ export default function TicketScanningPage() {
     qrCode: string;
     ticket: any;
     remaining: number;
+    offlineTicket?: SnapshotTicket; // scanned against the downloaded list (offline mode)
   } | null>(null);
   const [confirmQty, setConfirmQty] = useState(1);
+  // Youth events: the preview says whether parental consent allows check-in.
+  const consentBlocked = !!confirmModal && !['not_required', 'given', undefined].includes(confirmModal.ticket?.consentStatus);
+  const canOverrideConsent = user?.role === 'admin' || user?.role === 'supervisor';
   const [confirmQtyRaw, setConfirmQtyRaw] = useState("1");
 
   // Event selection state
@@ -93,6 +101,16 @@ export default function TicketScanningPage() {
     })();
   }, [selectedEventId, token]);
 
+  // In offline mode the event and section are fixed to the locked scope.
+  useEffect(() => {
+    if (!offline.lock) return;
+    setSelectedEventId(offline.lock.eventId);
+  }, [offline.lock]);
+  useEffect(() => {
+    if (!offline.lock) return;
+    setSelectedSectionId(offline.lock.sectionId || "all");
+  }, [offline.lock, sections]);
+
   // Bug fix: stop the scanner when the event or section filter changes so stale scan
   // context is never used. The user must press "Scan Ticket" again to resume.
   const isFirstFilterRender = useRef(true);
@@ -111,6 +129,32 @@ export default function TicketScanningPage() {
         return;
       }
 
+      // Offline mode: check the ticket against the list downloaded to this device.
+      if (offline.lock) {
+        const t = await offline.findTicket(text);
+        if (!t) { setErrorModal("Not found in the offline ticket list. Check at the door desk."); return; }
+        if (t.remaining <= 0) { setAlreadyUsedModal({ message: "Ticket has already been fully used", ticket: { id: t.id } }); return; }
+        if (!["not_required", "given"].includes(t.consentStatus)) {
+          setErrorModal(t.consentStatus === "declined" ? "Parental consent was declined — this ticket can't be checked in." : "Parental consent is missing or pending — this ticket can't be checked in offline. Check at the door desk.");
+          return;
+        }
+        setConfirmQty(t.remaining);
+        setConfirmQtyRaw(String(t.remaining));
+        setConfirmModal({
+          qrCode: text,
+          remaining: t.remaining,
+          offlineTicket: t,
+          ticket: {
+            id: t.id, quantity: t.quantity, consentStatus: t.consentStatus,
+            event: { title: offline.lock.eventTitle },
+            registrationOption: { eventOption: { name: t.option }, variant: t.variant ? { name: t.variant } : null },
+            attendee: t.bookedBy ? { name: t.holder } : null,
+            user: { name: t.bookedBy || t.holder },
+          },
+        });
+        return;
+      }
+
       // 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;
@@ -165,11 +209,11 @@ export default function TicketScanningPage() {
     }
   }
 
-  async function commitScan() {
+  async function commitScan(overrideConsent = false) {
     if (!confirmModal || !token) return;
 
     // Capture everything before clearing modal state
-    const { qrCode, ticket, remaining } = confirmModal;
+    const { qrCode, ticket, remaining, offlineTicket } = confirmModal;
     const qty = confirmQty;
     const baseName = ticket?.registrationOption?.eventOption?.name || "Ticket";
     const variantName = ticket?.registrationOption?.variant?.name;
@@ -191,6 +235,17 @@ export default function TicketScanningPage() {
       total: ticket?.quantity || 1,
     });
 
+    // Offline mode: saved on this device, synced when there's a connection.
+    if (offlineTicket) {
+      try {
+        await offline.scanLocally(offlineTicket, qty);
+      } catch (e: any) {
+        setSuccessModal(null);
+        setErrorModal(e?.message || "Couldn't save the scan on this device");
+      }
+      return;
+    }
+
     // Background write — reverse the optimistic update on failure
     try {
       const url = `/api/tickets/scan/${encodeURIComponent(qrCode)}${
@@ -199,7 +254,12 @@ export default function TicketScanningPage() {
       await apiFetch<any>(url, {
         method: "POST",
         authToken: token,
-        body: { qty },
+        body: {
+          qty,
+          deviceId: offline.deviceId(),
+          ...(selectedSectionId && selectedSectionId !== "all" ? { sectionId: selectedSectionId } : {}),
+          ...(overrideConsent ? { overrideConsent: true } : {}),
+        },
       });
       refreshStatsAndRecent();
     } catch (e: any) {
@@ -267,8 +327,10 @@ export default function TicketScanningPage() {
               className="border rounded px-3 py-2 w-full sm:w-56 max-w-full"
               value={selectedEventId}
               onChange={(e) => setSelectedEventId(e.target.value)}
+              disabled={!!offline.lock}
             >
               <option value="all">All events</option>
+              {offline.lock && !events.some(ev => ev.id === offline.lock!.eventId) && <option value={offline.lock.eventId}>{offline.lock.eventTitle}</option>}
               {events.map((ev) => (
                 <option key={ev.id} value={ev.id}>{ev.title}</option>
               ))}
@@ -286,6 +348,7 @@ export default function TicketScanningPage() {
                 className="border rounded px-3 py-2 w-full sm:w-56 max-w-full"
                 value={selectedSectionId}
                 onChange={(e) => setSelectedSectionId(e.target.value)}
+                disabled={!!offline.lock}
               >
                 <option value="all">All sections</option>
                 {sections.map(section => (
@@ -296,6 +359,16 @@ export default function TicketScanningPage() {
             </div>
           )}
 
+          <OfflineScanPanel
+            offline={offline}
+            token={token}
+            eventId={selectedEventId}
+            eventTitle={events.find(ev => ev.id === selectedEventId)?.title || offline.lock?.eventTitle || ""}
+            sectionId={selectedSectionId !== "all" ? selectedSectionId : null}
+            sectionName={sections.find(s => s.id === selectedSectionId)?.name || null}
+            onError={setError}
+            onInfo={setScanInfo}
+          />
           <QRScanner
             ref={scannerRef}
             onResult={handleResult}
@@ -383,6 +456,17 @@ export default function TicketScanningPage() {
               <div><span className="font-medium">Remaining:</span> <span className={confirmModal.remaining < (confirmModal.ticket?.quantity || 1) ? 'text-amber-600 font-semibold' : 'text-green-700 font-semibold'}>{confirmModal.remaining}</span></div>
             </div>
 
+            {consentBlocked && (
+              <div className="mb-4 rounded-lg border border-red-200 bg-red-50 p-3 text-sm text-red-800">
+                <div className="font-semibold">
+                  {confirmModal.ticket?.consentStatus === 'declined' ? 'Parental consent was declined'
+                    : confirmModal.ticket?.consentStatus === 'pending' ? 'Parental consent is still pending'
+                    : 'Parental consent is missing'}
+                </div>
+                <div className="mt-1">This person can&apos;t be checked in until a parent or guardian gives consent.{canOverrideConsent ? ' As a supervisor you can override this — it is recorded in the audit log.' : ' Ask a supervisor.'}</div>
+              </div>
+            )}
+
             {(confirmModal.ticket?.quantity || 1) > 1 && (
               <div className="mb-4">
                 <label className="block text-sm font-medium text-gray-700 mb-1">Qty to redeem (max {confirmModal.remaining})</label>
@@ -411,12 +495,23 @@ export default function TicketScanningPage() {
               >
                 Cancel
               </button>
-              <button
-                onClick={commitScan}
-                className="flex-1 px-4 py-2 rounded-lg bg-brand-600 text-white text-sm font-semibold hover:bg-brand-700"
-              >
-                Confirm Scan
-              </button>
+              {consentBlocked ? (
+                canOverrideConsent && (
+                  <button
+                    onClick={() => commitScan(true)}
+                    className="flex-1 px-4 py-2 rounded-lg bg-red-600 text-white text-sm font-semibold hover:bg-red-700"
+                  >
+                    Override and check in
+                  </button>
+                )
+              ) : (
+                <button
+                  onClick={() => commitScan()}
+                  className="flex-1 px-4 py-2 rounded-lg bg-brand-600 text-white text-sm font-semibold hover:bg-brand-700"
+                >
+                  Confirm Scan
+                </button>
+              )}
             </div>
           </div>
         </div>

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

@@ -7,7 +7,7 @@ import { apiFetch } from "@/lib/api";
 import { scoreUser } from "@/lib/fuzzyMatch";
 import { useDismissingState } from "@/hooks/useDismissingState";
 import { CouponCodeField, AppliedCoupon } from "@/components/shared/CouponCodeField";
-import { AttendeeNamesEditor, AttendeeEntries, TicketDelivery, attendeesPayload } from "@/components/shared/AttendeeNamesEditor";
+import { AttendeeNamesEditor, AttendeeEntries, TicketDelivery, attendeesPayload, consentDetailsMissing } from "@/components/shared/AttendeeNamesEditor";
 import { DoorOpen, UserPlus, CreditCard, CheckSquare, Ticket, RotateCcw, type LucideIcon } from "lucide-react";
 
 type Mode = "registration" | "payment" | "checkin" | "tickets" | "refund";
@@ -104,6 +104,7 @@ export default function AtTheDoorPage() {
     const [pendingUser, setPendingUser] = useState<any | null>(null);
     const [doorCoupon, setDoorCoupon] = useState<AppliedCoupon | null>(null);
     const [doorAllowsNames, setDoorAllowsNames] = useState(false);
+    const [doorYouthStart, setDoorYouthStart] = useState<string | null>(null);
     const [doorNaming, setDoorNaming] = useState(false);
     const [doorEntries, setDoorEntries] = useState<AttendeeEntries>({});
     const [doorDelivery, setDoorDelivery] = useState<TicketDelivery>("payer");
@@ -160,7 +161,8 @@ export default function AtTheDoorPage() {
                 });
 
                 setEventOptions(ev.options || ev.eventOptions || []);
-                setDoorAllowsNames(!!ev.allowNamedAttendees);
+                setDoorAllowsNames(!!ev.allowNamedAttendees || !!ev.requiresParentalConsent);
+                setDoorYouthStart(ev.requiresParentalConsent ? ev.startDate : null);
             } catch {
                 setEventOptions([]);
             }
@@ -230,6 +232,11 @@ export default function AtTheDoorPage() {
             }
         }
 
+        if (!pendingEditReg && doorYouthStart) {
+            const missing = consentDetailsMissing(eventOptions, (o, v) => quantities[v ? `${o}::${v}` : o] || 0, doorEntries, doorYouthStart);
+            if (missing) { setError(missing); return; }
+        }
+
         setConfirming(true);
         try {
             if (pendingEditReg) {
@@ -272,7 +279,7 @@ export default function AtTheDoorPage() {
                         options: opts,
                         notificationPreference: pendingUser.notifPref,
                         ...(doorCoupon ? { couponCode: doorCoupon.code } : {}),
-                        ...(doorAllowsNames && doorNaming && attendeesPayload(eventOptions, (o, v) => quantities[v ? `${o}::${v}` : o] || 0, doorEntries).length > 0
+                        ...(doorAllowsNames && (doorNaming || doorYouthStart) && attendeesPayload(eventOptions, (o, v) => quantities[v ? `${o}::${v}` : o] || 0, doorEntries).length > 0
                             ? { attendees: attendeesPayload(eventOptions, (o, v) => quantities[v ? `${o}::${v}` : o] || 0, doorEntries), ticketDelivery: doorDelivery }
                             : {}),
                     }
@@ -505,6 +512,7 @@ export default function AtTheDoorPage() {
                     enabled: doorNaming, onEnabledChange: setDoorNaming,
                     entries: doorEntries, onEntriesChange: setDoorEntries,
                     delivery: doorDelivery, onDeliveryChange: setDoorDelivery,
+                    consentEventStart: doorYouthStart || undefined,
                 } : null}
             />
             <DonationModal

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

@@ -0,0 +1,251 @@
+"use client";
+
+import React, { useCallback, useEffect, useMemo, useState } from "react";
+import { useAuth } from "@/hooks/useAuth";
+import { useRouter, useSearchParams } from "next/navigation";
+import { apiFetch } from "@/lib/api";
+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";
+
+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" },
+  missing: { label: "No request", cls: "bg-red-100 text-red-800" },
+  pending: { label: "Pending", cls: "bg-amber-100 text-amber-800" },
+  given: { label: "Given", cls: "bg-green-100 text-green-800" },
+  declined: { label: "Declined", cls: "bg-red-100 text-red-800" },
+};
+
+const esc = (s: unknown) => String(s ?? "").replace(/[&<>"]/g, c => ({ "&": "&amp;", "<": "&lt;", ">": "&gt;", '"': "&quot;" }[c] as string));
+
+export default function ConsentTrackerPage() {
+  const { user, loading, token } = useAuth();
+  const router = useRouter();
+  const search = useSearchParams();
+  const canView = useMemo(() => ["admin", "supervisor", "staff"].includes(user?.role || ""), [user]);
+  const isSupervisor = user?.role === "admin" || user?.role === "supervisor";
+
+  useEffect(() => {
+    if (loading) return;
+    if (!user) router.replace("/login");
+  }, [user, loading, router]);
+
+  const [events, setEvents] = useState<any[]>([]);
+  const [eventId, setEventId] = useState<string>(search.get("eventId") || "");
+  const [data, setData] = useState<{ event: any; 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);
+  const [info, setInfo] = useDismissingState<string | null>(null);
+
+  useEffect(() => {
+    if (!token || !canView) return;
+    apiFetch<any[]>("/api/events/all?includePast=true", { authToken: token })
+      .then(evs => {
+        const youth = (evs || []).filter(e => e.requiresParentalConsent);
+        setEvents(youth);
+        if (!eventId && youth.length) setEventId(youth[youth.length - 1].id);
+      })
+      .catch(e => setError(e?.message || "Failed to load events"));
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+  }, [token, canView]);
+
+  const load = useCallback(async () => {
+    if (!token || !eventId) return;
+    setBusy(true);
+    try {
+      setData(await apiFetch(`/api/consent/events/${encodeURIComponent(eventId)}`, { authToken: token }));
+    } catch (e: any) {
+      setError(e?.message || "Failed to load consent status");
+    } finally {
+      setBusy(false);
+    }
+  }, [token, eventId, setError]);
+
+  useEffect(() => { load(); }, [load]);
+
+  const rows = useMemo(() => {
+    const all = data?.rows || [];
+    if (filter === "all") return all;
+    if (filter === "waiting") return all.filter(r => ["missing", "pending", "declined"].includes(r.status) || r.request?.outdated);
+    return all.filter(r => r.minor);
+  }, [data, filter]);
+
+  const outdatedCount = (data?.rows || []).filter(r => r.request?.outdated || (r.minor && r.status === "missing")).length;
+
+  const act = async (fn: () => Promise<{ message: string }>) => {
+    setBusy(true);
+    try {
+      const res = await fn();
+      setInfo(res.message);
+      await load();
+    } catch (e: any) {
+      setError(e?.message || "Something went wrong");
+    } finally {
+      setBusy(false);
+    }
+  };
+
+  const resendOne = (r: ConsentRow) => act(() => apiFetch(`/api/consent/requests/${r.request!.id}/resend`, { method: "POST", authToken: token! }));
+  const resendAll = () => act(() => apiFetch(`/api/consent/events/${eventId}/resend-pending`, { method: "POST", authToken: token! }));
+  const rerequest = () => act(() => apiFetch(`/api/consent/events/${eventId}/rerequest`, { method: "POST", authToken: token! }));
+
+  // 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 w = window.open("", "_blank");
+      if (!w) { setError("Allow pop-ups to print the medical list."); return; }
+      const rowsHtml = res.rows.map(r => `
+        <tr>
+          <td><strong>${esc(r.name)}</strong><br/><small>${r.dateOfBirth ? esc(formatDate(new Date(r.dateOfBirth))) : ""}</small></td>
+          <td>${r.purged ? "<em>Deleted after the event</em>" : `
+            ${r.medical?.allergies ? `<div><b>Allergies:</b> ${esc(r.medical.allergies)}</div>` : ""}
+            ${r.medical?.medication ? `<div><b>Medication:</b> ${esc(r.medical.medication)}</div>` : ""}
+            ${r.medical?.conditions ? `<div><b>Conditions:</b> ${esc(r.medical.conditions)}</div>` : ""}
+            ${r.medical?.medicalAid ? `<div><b>Medical aid:</b> ${esc(r.medical.medicalAid)}</div>` : ""}`}</td>
+          <td>${r.emergency ? `${esc(r.emergency.name)}${r.emergency.relationship ? ` (${esc(r.emergency.relationship)})` : ""}<br/>${esc(r.emergency.phone)}` : ""}</td>
+          <td>${esc(r.parentName)}<br/>${esc(r.parentPhone)}</td>
+          <td>${r.photoConsent === null ? "" : r.photoConsent ? "Yes" : "No"}</td>
+        </tr>`).join("");
+      w.document.write(`<!doctype html><html><head><meta charset="utf-8"/><title>Medical &amp; emergency list — ${esc(res.event.title)}</title>
+        <style>body{font-family:system-ui,sans-serif;margin:24px;font-size:12px}h1{font-size:18px;margin:0 0 4px}p{color:#555;margin:0 0 12px}
+        table{width:100%;border-collapse:collapse}th,td{border:1px solid #ccc;padding:6px;vertical-align:top;text-align:left}th{background:#f3f4f6}
+        .conf{color:#b91c1c;font-weight:600}</style></head><body>
+        <h1>Medical &amp; emergency list — ${esc(res.event.title)}</h1>
+        <p class="conf">Confidential — for event leaders only. Do not leave unattended; destroy after the event.</p>
+        <table><thead><tr><th>Attendee</th><th>Medical</th><th>Emergency contact</th><th>Parent / guardian</th><th>Photos</th></tr></thead>
+        <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");
+    }
+  };
+
+  return (
+    <div className="max-w-6xl mx-auto w-full p-6">
+      <div className="flex items-center gap-3 mb-4">
+        <div className="w-10 h-10 rounded-xl bg-brand-50 flex items-center justify-center shrink-0">
+          <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>
+          <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>
+      </div>
+
+      {!canView && <div className="p-3 border rounded bg-yellow-50 text-yellow-800 text-sm mb-4">You need staff access to view consent status.</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-wrap items-end gap-3 mb-4">
+            <div>
+              <label className="block text-xs text-gray-600 mb-1">Youth event</label>
+              <select className="border rounded-lg px-3 py-2 text-sm min-w-[16rem]" value={eventId} onChange={e => setEventId(e.target.value)}>
+                {events.length === 0 && <option value="">No youth events</option>}
+                {events.map(ev => <option key={ev.id} value={ev.id}>{ev.title} ({formatDate(new Date(ev.startDate))})</option>)}
+              </select>
+            </div>
+            <div>
+              <label className="block text-xs text-gray-600 mb-1">Show</label>
+              <select className="border rounded-lg px-3 py-2 text-sm" value={filter} onChange={e => setFilter(e.target.value as typeof filter)}>
+                <option value="minors">Under 18s</option>
+                <option value="waiting">Still to sort out</option>
+                <option value="all">Everyone</option>
+              </select>
+            </div>
+            {isSupervisor && eventId && (
+              <div className="flex flex-wrap gap-2 ml-auto">
+                <button onClick={resendAll} disabled={busy || !(data?.counts?.pending)} className="inline-flex items-center gap-1.5 px-3 py-2 rounded-lg border text-sm hover:bg-gray-50 disabled:opacity-50"><Send className="w-4 h-4" /> Resend to all pending</button>
+                <button onClick={rerequest} disabled={busy || outdatedCount === 0} title="For consent given on an older version of the text, or under 18s who never got a request" className="inline-flex items-center gap-1.5 px-3 py-2 rounded-lg border text-sm hover:bg-gray-50 disabled:opacity-50"><RefreshCw className="w-4 h-4" /> Re-request consent ({outdatedCount})</button>
+                <button onClick={printMedical} disabled={busy} className="inline-flex items-center gap-1.5 px-3 py-2 rounded-lg bg-brand-600 text-white text-sm hover:bg-brand-700 disabled:opacity-50"><HeartPulse className="w-4 h-4" /> <Printer className="w-4 h-4" /> Medical &amp; emergency list</button>
+              </div>
+            )}
+          </div>
+
+          {data && (
+            <div className="flex flex-wrap gap-2 mb-3 text-xs">
+              {(["given", "pending", "declined", "missing"] as const).map(s => (
+                <span key={s} className={`px-2 py-1 rounded-full font-medium ${STATUS_STYLE[s].cls}`}>{STATUS_STYLE[s].label}: {data.counts?.[s] || 0}</span>
+              ))}
+            </div>
+          )}
+
+          <div className="overflow-x-auto">
+            <Table>
+              <TableHeader>
+                <TableRow>
+                  <TableHead>Attendee</TableHead>
+                  <TableHead>Parent / guardian</TableHead>
+                  <TableHead>Consent</TableHead>
+                  <TableHead>Booked by</TableHead>
+                  <TableHead className="text-right">Actions</TableHead>
+                </TableRow>
+              </TableHeader>
+              <TableBody>
+                {rows.map(r => {
+                  const st = STATUS_STYLE[r.status];
+                  return (
+                    <TableRow key={r.attendeeId}>
+                      <TableCell>
+                        <div className="font-medium">{r.name}</div>
+                        <div className="text-xs text-gray-500">{r.dateOfBirth ? formatDate(new Date(r.dateOfBirth)) : "No date of birth"}</div>
+                      </TableCell>
+                      <TableCell className="text-sm">
+                        {r.parentName ? <>
+                          <div>{r.parentName}</div>
+                          <div className="text-xs text-gray-500">{[r.parentEmail, r.parentPhone].filter(Boolean).join(" · ")}</div>
+                        </> : <span className="text-gray-400">—</span>}
+                      </TableCell>
+                      <TableCell>
+                        <span className={`text-xs px-2 py-0.5 rounded-full font-medium ${st.cls}`}>{st.label}</span>
+                        {r.request?.outdated && <div className="text-xs text-amber-700 mt-1">Given on an older version of the text</div>}
+                        {r.request?.respondedAt && <div className="text-xs text-gray-500 mt-1">{r.request.signedName} · {formatDate(new Date(r.request.respondedAt))}</div>}
+                        {r.status === "pending" && r.request && <div className="text-xs text-gray-500 mt-1">Sent {formatDate(new Date(r.request.lastSentAt))}{r.request.remindersSent ? ` · ${r.request.remindersSent} reminder(s)` : ""}</div>}
+                      </TableCell>
+                      <TableCell className="text-sm">{r.bookedBy?.name}<div className="text-xs text-gray-500">{r.registrationStatus}</div></TableCell>
+                      <TableCell className="text-right">
+                        {r.status === "pending" && r.request && (
+                          <button onClick={() => resendOne(r)} disabled={busy} className="px-2 py-1 text-xs rounded border hover:bg-gray-50">Resend</button>
+                        )}
+                      </TableCell>
+                    </TableRow>
+                  );
+                })}
+                {!busy && rows.length === 0 && (
+                  <TableRow><TableCell colSpan={5} className="text-center text-sm text-gray-500 py-8">{eventId ? "No attendees to show." : "Pick a youth event."}</TableCell></TableRow>
+                )}
+              </TableBody>
+            </Table>
+          </div>
+          <p className="text-xs text-gray-500 mt-3">Reminders go out automatically 2 days after a request, then every 3 days until the event. Medical details are deleted a set number of days after the event (Site Settings → Legal).</p>
+        </div>
+      )}
+    </div>
+  );
+}

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

@@ -770,6 +770,9 @@ interface EventDraft {
   redirectUrl: string; isActive: boolean; isHidden: boolean; requiresAuth: boolean;
   requiresRegistration: boolean; contactName: string; contactPhone: string; contactEmail: string;
   location: string; allowNamedAttendees: boolean;
+  requiresParentalConsent: boolean; consentText: string;
+  consentCollectMedical: boolean; consentCollectEmergency: boolean; consentCollectPhoto: boolean;
+  waitlistEnabled: boolean; waitlistOfferHours: string; waitlistPartialOffers: boolean;
 }
 
 const blankDraft = (location = ""): EventDraft => ({
@@ -778,6 +781,9 @@ const blankDraft = (location = ""): EventDraft => ({
   redirectUrl: "", isActive: true, isHidden: false, requiresAuth: true,
   requiresRegistration: true, contactName: "", contactPhone: "", contactEmail: "",
   location, allowNamedAttendees: false,
+  requiresParentalConsent: false, consentText: "",
+  consentCollectMedical: true, consentCollectEmergency: true, consentCollectPhoto: true,
+  waitlistEnabled: false, waitlistOfferHours: "24", waitlistPartialOffers: true,
 });
 
 const blankOptions = (): OptionDraft[] => [
@@ -813,6 +819,9 @@ function EventModal({ mode, event: ev, onClose, onSuccess }: EventModalProps) {
     isActive: ev.isActive !== false, isHidden: !!ev.isHidden, requiresAuth: ev.requiresAuth !== false,
     requiresRegistration: ev.requiresRegistration !== false,
     allowNamedAttendees: !!ev.allowNamedAttendees,
+    requiresParentalConsent: !!ev.requiresParentalConsent, consentText: ev.consentText || "",
+    consentCollectMedical: !!ev.consentCollectMedical, consentCollectEmergency: !!ev.consentCollectEmergency, consentCollectPhoto: !!ev.consentCollectPhoto,
+    waitlistEnabled: !!ev.waitlistEnabled, waitlistOfferHours: String(ev.waitlistOfferHours ?? 24), waitlistPartialOffers: ev.waitlistPartialOffers !== false,
     contactName: ev.contactName || "", contactPhone: ev.contactPhone || "", contactEmail: ev.contactEmail || "",
     location: ev.location || "",
   } : blankDraft(settings.org_address || ""));
@@ -1086,7 +1095,15 @@ function EventModal({ mode, event: ev, onClose, onSuccess }: EventModalProps) {
         picture: draft.picture || undefined, isHidden: draft.isHidden, requiresAuth: draft.requiresAuth,
         redirectUrl: draft.redirectUrl?.trim().replace(/\s+/g, "-") || undefined,
         requiresRegistration: draft.requiresRegistration,
-        allowNamedAttendees: draft.allowNamedAttendees,
+        allowNamedAttendees: draft.allowNamedAttendees || draft.requiresParentalConsent,
+        requiresParentalConsent: draft.requiresParentalConsent,
+        consentText: draft.consentText,
+        consentCollectMedical: draft.consentCollectMedical,
+        consentCollectEmergency: draft.consentCollectEmergency,
+        consentCollectPhoto: draft.consentCollectPhoto,
+        waitlistEnabled: draft.waitlistEnabled,
+        waitlistOfferHours: parseInt(draft.waitlistOfferHours, 10) || 24,
+        waitlistPartialOffers: draft.waitlistPartialOffers,
         contactName: draft.contactName || undefined,
         contactPhone: draft.contactPhone || undefined,
         contactEmail: draft.contactEmail || undefined,
@@ -1352,6 +1369,49 @@ function EventModal({ mode, event: ev, onClose, onSuccess }: EventModalProps) {
                   </label>
                 )}
               </div>
+
+              <div className="border rounded-lg p-4 bg-gray-50 space-y-3">
+                <div className="text-xs font-semibold text-gray-500 uppercase tracking-wide mb-1">Waitlist</div>
+                <label className="flex items-start gap-2 text-sm cursor-pointer">
+                  <input type="checkbox" className="mt-0.5" checked={draft.waitlistEnabled} onChange={e => upd({ waitlistEnabled: e.target.checked })} />
+                  <span><strong>Waitlist for sold-out tickets</strong> — people can join a queue; when places free up, the next person is offered them and has a set time to claim</span>
+                </label>
+                {draft.waitlistEnabled && (
+                  <>
+                    <label className="flex items-center gap-2 text-sm">
+                      Hold offered places for
+                      <input type="number" min="1" max="168" className="border rounded px-2 py-1 text-sm w-20" value={draft.waitlistOfferHours} onChange={e => upd({ waitlistOfferHours: e.target.value })} />
+                      hours
+                    </label>
+                    <label className="flex items-start gap-2 text-sm cursor-pointer">
+                      <input type="checkbox" className="mt-0.5" checked={draft.waitlistPartialOffers} onChange={e => upd({ waitlistPartialOffers: e.target.checked })} />
+                      <span>When fewer places free up than someone asked for, offer them what&apos;s free (otherwise skip to the next person who fits)</span>
+                    </label>
+                  </>
+                )}
+              </div>
+
+              <div className="border rounded-lg p-4 bg-gray-50 space-y-3">
+                <div className="text-xs font-semibold text-gray-500 uppercase tracking-wide mb-1">Youth event</div>
+                <label className="flex items-start gap-2 text-sm cursor-pointer">
+                  <input type="checkbox" className="mt-0.5" checked={draft.requiresParentalConsent} onChange={e => upd({ requiresParentalConsent: e.target.checked, ...(e.target.checked ? { allowNamedAttendees: true } : {}) })} />
+                  <span><strong>Requires parental consent</strong> — every attendee gives a date of birth; for anyone under 18, a parent or guardian is asked by email and WhatsApp to give consent before they can be checked in</span>
+                </label>
+                {draft.requiresParentalConsent && (
+                  <>
+                    <div>
+                      <label className="block text-xs text-gray-600 mb-1">Consent text (shown to the parent)</label>
+                      <textarea className="w-full border rounded px-2 py-1.5 text-sm" rows={6} value={draft.consentText} onChange={e => upd({ consentText: e.target.value })}
+                        placeholder="e.g. I give permission for my child to take part in all activities, including transport, and for leaders to arrange medical treatment in an emergency." />
+                      {mode === "edit" && <p className="text-[11px] text-gray-500 mt-1">Changing this starts a new version. Parents who already agreed keep their record; use &quot;Re-request consent&quot; on the Parental consent page to ask them again.</p>}
+                    </div>
+                    <div className="text-xs text-gray-600">Also ask the parent for:</div>
+                    <label className="flex items-center gap-2 text-sm"><input type="checkbox" checked={draft.consentCollectMedical} onChange={e => upd({ consentCollectMedical: e.target.checked })} /> Medical info (allergies, medication, conditions, medical aid)</label>
+                    <label className="flex items-center gap-2 text-sm"><input type="checkbox" checked={draft.consentCollectEmergency} onChange={e => upd({ consentCollectEmergency: e.target.checked })} /> An emergency contact</label>
+                    <label className="flex items-center gap-2 text-sm"><input type="checkbox" checked={draft.consentCollectPhoto} onChange={e => upd({ consentCollectPhoto: e.target.checked })} /> Photo consent (yes/no)</label>
+                  </>
+                )}
+              </div>
             </div>
           )}
 

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

@@ -7,7 +7,7 @@ import { apiFetch, fetchAllUsers } from "@/lib/api";
 import { scoreUser } from "@/lib/fuzzyMatch";
 import { useDismissingState } from "@/hooks/useDismissingState";
 import { CouponCodeField, AppliedCoupon } from "@/components/shared/CouponCodeField";
-import { AttendeeNamesEditor, AttendeeEntries, TicketDelivery, attendeesPayload } from "@/components/shared/AttendeeNamesEditor";
+import { AttendeeNamesEditor, AttendeeEntries, TicketDelivery, attendeesPayload, consentDetailsMissing } from "@/components/shared/AttendeeNamesEditor";
 import { UserPlus, CreditCard } from "lucide-react";
 
 // ─── Pricing helpers ─────────────────────────────────────────────────────────
@@ -224,7 +224,9 @@ export default function ManualRegistrationPage() {
   const [attendeeEntries, setAttendeeEntries] = useState<AttendeeEntries>({});
   const [delivery, setDelivery] = useState<TicketDelivery>("payer");
   const manualQtyFor = (optionId: string, variantId: string | null) => quantities[variantId ? `${optionId}::${variantId}` : optionId] || 0;
-  const selectedEventAllowsNames = !!events.find(ev => ev.id === selectedEventId)?.allowNamedAttendees;
+  const selectedEv = events.find(ev => ev.id === selectedEventId);
+  const selectedIsYouth = !!selectedEv?.requiresParentalConsent;
+  const selectedEventAllowsNames = !!selectedEv?.allowNamedAttendees || selectedIsYouth;
   const [pickedUserId, setPickedUserId] = useState<string | null>(null);
 
   const selectUser = (u: any) => {
@@ -307,6 +309,10 @@ export default function ManualRegistrationPage() {
         return { eventOptionId, quantity, ...(variantId ? { variantId } : {}) };
       });
     if (opts.length === 0) { setError("Please select at least one ticket option."); return; }
+    if (selectedIsYouth) {
+      const missing = consentDetailsMissing(options, manualQtyFor, attendeeEntries, selectedEv.startDate);
+      if (missing) { setError(missing); return; }
+    }
 
     try {
       setSubmitting(true);
@@ -322,7 +328,7 @@ export default function ManualRegistrationPage() {
           user: guest,
           notificationPreference: resolvedPref,
           ...(coupon ? { couponCode: coupon.code } : {}),
-          ...(selectedEventAllowsNames && namingOthers && attendeesPayload(options, manualQtyFor, attendeeEntries).length > 0
+          ...(selectedEventAllowsNames && (namingOthers || selectedIsYouth) && attendeesPayload(options, manualQtyFor, attendeeEntries).length > 0
             ? { attendees: attendeesPayload(options, manualQtyFor, attendeeEntries), ticketDelivery: delivery }
             : {}),
         }
@@ -617,6 +623,7 @@ export default function ManualRegistrationPage() {
             delivery={delivery}
             onDeliveryChange={setDelivery}
             payerLabel="the person registering"
+            consentEventStart={selectedIsYouth ? selectedEv.startDate : undefined}
           />
         </div>
       )}

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

@@ -0,0 +1,163 @@
+"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 { formatDate } from "@/lib/date";
+import { useDismissingState } from "@/hooks/useDismissingState";
+import { WifiOff, Unlock, CheckCircle2 } from "lucide-react";
+
+type Lock = { id: string; sectionName: string | null; deviceName: string | null; user: { name: string }; lockedAt: string; snapshotAt: string | null; lastSyncAt: string | null };
+type Report = {
+  id: string; accepted: number; duplicates: number; afterForceRelease: boolean; createdAt: string; reviewedAt: string | null;
+  reviewedBy: { name: string } | null;
+  conflicts: { clientScanId: string; qrCode: string; qty: number; redeemed: number; scannedAt: string; reason: string; message: string }[];
+  scanLock: Lock;
+};
+
+const when = (iso: string | null) => (iso ? new Date(iso).toLocaleString() : "—");
+
+export default function OfflineScansPage() {
+  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 [events, setEvents] = useState<any[]>([]);
+  const [eventId, setEventId] = useState("");
+  const [locks, setLocks] = useState<Lock[]>([]);
+  const [reports, setReports] = useState<Report[]>([]);
+  const [onlyOpen, setOnlyOpen] = useState(true);
+  const [error, setError] = useDismissingState<string | null>(null);
+  const [info, setInfo] = useDismissingState<string | null>(null);
+
+  useEffect(() => {
+    if (!token || !canView) return;
+    apiFetch<any[]>("/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);
+        if (recent.length && !eventId) setEventId(recent[0].id);
+      })
+      .catch(e => setError(e?.message || "Failed to load events"));
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+  }, [token, canView]);
+
+  const load = useCallback(async () => {
+    if (!token || !eventId) return;
+    try {
+      const [l, r] = await Promise.all([
+        apiFetch<Lock[]>(`/api/scan-locks?eventId=${encodeURIComponent(eventId)}`, { authToken: token }),
+        apiFetch<Report[]>(`/api/scan-locks/reports?eventId=${encodeURIComponent(eventId)}${onlyOpen ? "&unreviewed=true" : ""}`, { authToken: token }),
+      ]);
+      setLocks(l);
+      setReports(r.filter(x => !onlyOpen || x.conflicts.length > 0 || x.afterForceRelease));
+    } catch (e: any) {
+      setError(e?.message || "Failed to load offline scanning");
+    }
+  }, [token, eventId, onlyOpen, setError]);
+  useEffect(() => { load(); }, [load]);
+
+  const forceRelease = async (l: Lock) => {
+    try {
+      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"); }
+  };
+  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"); }
+  };
+
+  return (
+    <div className="max-w-5xl mx-auto w-full p-6">
+      <div className="flex items-center gap-3 mb-4">
+        <div className="w-10 h-10 rounded-xl bg-brand-50 flex items-center justify-center shrink-0">
+          <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>
+          <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>
+      </div>
+
+      {!canView && <div className="p-3 border rounded bg-yellow-50 text-yellow-800 text-sm mb-4">You need supervisor access to manage offline scanning.</div>}
+      {error && <div className="mb-3 p-3 border rounded bg-red-50 text-red-800 text-sm">{error}</div>}
+      {info && <div className="mb-3 p-3 border rounded bg-green-50 text-green-800 text-sm">{info}</div>}
+
+      {canView && (
+        <div className="space-y-4">
+          <div className="flex flex-wrap items-end gap-3">
+            <div>
+              <label className="block text-xs text-gray-600 mb-1">Event</label>
+              <select className="border rounded-lg px-3 py-2 text-sm min-w-[16rem]" value={eventId} onChange={e => setEventId(e.target.value)}>
+                {events.map(ev => <option key={ev.id} value={ev.id}>{ev.title} ({formatDate(new Date(ev.startDate))})</option>)}
+              </select>
+            </div>
+            <label className="flex items-center gap-2 text-sm text-gray-700 pb-2">
+              <input type="checkbox" checked={onlyOpen} onChange={e => setOnlyOpen(e.target.checked)} /> Only reports that need review
+            </label>
+          </div>
+
+          <section className="border rounded-xl p-4 bg-white shadow-sm">
+            <h2 className="font-semibold mb-2">Locked sections</h2>
+            {locks.length === 0 ? <p className="text-sm text-gray-500">No device is scanning offline for this event.</p> : (
+              <ul className="divide-y">
+                {locks.map(l => (
+                  <li key={l.id} className="py-2 flex items-center justify-between gap-3 text-sm">
+                    <div>
+                      <div className="font-medium">{l.sectionName || "Whole event"} — {l.user.name}{l.deviceName ? ` on ${l.deviceName}` : ""}</div>
+                      <div className="text-xs text-gray-500">Locked {when(l.lockedAt)} · list downloaded {when(l.snapshotAt)} · last sync {when(l.lastSyncAt)}</div>
+                    </div>
+                    <button onClick={() => forceRelease(l)} className="inline-flex items-center gap-1 px-2.5 py-1 text-xs rounded border hover:bg-gray-50 shrink-0" title="For a lost or flat device. If it reconnects later, its scans still sync and are flagged here.">
+                      <Unlock className="w-3.5 h-3.5" /> Force release
+                    </button>
+                  </li>
+                ))}
+              </ul>
+            )}
+          </section>
+
+          <section className="border rounded-xl p-4 bg-white shadow-sm">
+            <h2 className="font-semibold mb-2">Sync reports</h2>
+            {reports.length === 0 ? <p className="text-sm text-gray-500">{onlyOpen ? "Nothing needs review." : "No offline scans have been synced for this event."}</p> : (
+              <div className="space-y-3">
+                {reports.map(r => (
+                  <div key={r.id} className={`border rounded-lg p-3 ${r.reviewedAt ? "opacity-60" : ""}`}>
+                    <div className="flex items-center justify-between gap-3 text-sm">
+                      <div>
+                        <span className="font-medium">{when(r.createdAt)}</span> — {r.scanLock.user?.name}{r.scanLock.deviceName ? ` on ${r.scanLock.deviceName}` : ""}{r.scanLock.sectionName ? `, ${r.scanLock.sectionName}` : ""}
+                        <div className="text-xs text-gray-500">{r.accepted} scan(s) recorded{r.duplicates ? ` · ${r.duplicates} already synced` : ""}{r.afterForceRelease ? " · synced after the lock was force-released" : ""}</div>
+                      </div>
+                      {r.reviewedAt
+                        ? <span className="text-xs text-gray-500 inline-flex items-center gap-1"><CheckCircle2 className="w-3.5 h-3.5" /> Reviewed by {r.reviewedBy?.name}</span>
+                        : <button onClick={() => review(r)} className="px-2.5 py-1 text-xs rounded bg-brand-600 text-white hover:bg-brand-700 shrink-0">Mark reviewed</button>}
+                    </div>
+                    {r.conflicts.length > 0 && (
+                      <ul className="mt-2 text-xs space-y-1">
+                        {r.conflicts.map(c => (
+                          <li key={c.clientScanId} className="text-red-800">
+                            {new Date(c.scannedAt).toLocaleTimeString()} · ticket {String(c.qrCode).slice(0, 8)}… · {c.message}{c.redeemed ? ` (recorded ${c.redeemed} of ${c.qty})` : " (not recorded)"}
+                          </li>
+                        ))}
+                      </ul>
+                    )}
+                  </div>
+                ))}
+              </div>
+            )}
+          </section>
+        </div>
+      )}
+    </div>
+  );
+}

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

@@ -8,7 +8,7 @@ import { useStableState } from "@/hooks/useStableState";
 import { useVisiblePolling } from "@/hooks/useVisiblePolling";
 import {
   Calendar, Banknote, Gift, Users, Ticket, QrCode, DoorOpen, Wallet,
-  UserPlus, FileText, MessageCircle, BarChart2, Mail, TicketPercent,
+  UserPlus, FileText, MessageCircle, BarChart2, Mail, TicketPercent, ShieldCheck, ListChecks, WifiOff,
 } from "lucide-react";
 import { StatCard, StatCardRow } from "@/components/shared/StatCard";
 import { QuickActionTile, QuickActionGrid } from "@/components/shared/QuickActionTile";
@@ -24,6 +24,9 @@ const QUICK_ACTIONS = [
   { href: "/dashboard/supervisor/manual", label: "Manual registration", description: "Register a guest and issue tickets", icon: UserPlus },
   { href: "/dashboard/supervisor/events", label: "Manage events", description: "Create, edit, and update ticket types", icon: Calendar },
   { href: "/dashboard/supervisor/payments", label: "Payments & donations", description: "Manual payments and assignment", icon: Wallet },
+  { href: "/dashboard/supervisor/offline-scans", label: "Offline scanning", description: "Devices scanning offline and their synced scans", icon: WifiOff },
+  { href: "/dashboard/supervisor/waitlist", label: "Waitlist", description: "People waiting for sold-out tickets", icon: ListChecks },
+  { href: "/dashboard/supervisor/consent", label: "Parental consent", description: "Youth events: consent status and medical list", icon: ShieldCheck },
   { href: "/dashboard/supervisor/coupons", label: "Coupon codes", description: "Discounts for staff, leaders and promotions", icon: TicketPercent },
   { 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 },

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

@@ -0,0 +1,190 @@
+"use client";
+
+import React, { useCallback, useEffect, useMemo, useState } from "react";
+import { useAuth } from "@/hooks/useAuth";
+import { useRouter, useSearchParams } from "next/navigation";
+import { apiFetch } from "@/lib/api";
+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";
+
+type Entry = {
+  id: string;
+  position: number;
+  quantity: number;
+  offeredQuantity: number | null;
+  offerExpiresAt: string | null;
+  status: "waiting" | "offered" | "claimed" | "expired" | "removed" | "left";
+  createdAt: string;
+  eventOption: { name: string };
+  variant: { name: string } | null;
+  user: { name: string; email: string; phoneNumber: string | null };
+};
+
+const STATUS: Record<Entry["status"], { label: string; cls: string }> = {
+  waiting: { label: "Waiting", cls: "bg-gray-100 text-gray-700" },
+  offered: { label: "Offered", cls: "bg-amber-100 text-amber-800" },
+  claimed: { label: "Claimed", cls: "bg-green-100 text-green-800" },
+  expired: { label: "Offer expired", cls: "bg-red-100 text-red-800" },
+  removed: { label: "Removed", cls: "bg-gray-100 text-gray-500" },
+  left: { label: "Left", cls: "bg-gray-100 text-gray-500" },
+};
+
+export default function WaitlistPage() {
+  const { user, loading, token } = useAuth();
+  const router = useRouter();
+  const search = useSearchParams();
+  const canView = useMemo(() => ["admin", "supervisor", "staff"].includes(user?.role || ""), [user]);
+  const canManage = user?.role === "admin" || user?.role === "supervisor";
+
+  useEffect(() => {
+    if (loading) return;
+    if (!user) router.replace("/login");
+  }, [user, loading, router]);
+
+  const [events, setEvents] = useState<any[]>([]);
+  const [eventId, setEventId] = useState(search.get("eventId") || "");
+  const [entries, setEntries] = useState<Entry[]>([]);
+  const [busy, setBusy] = useState(false);
+  const [error, setError] = useDismissingState<string | null>(null);
+  const [info, setInfo] = useDismissingState<string | null>(null);
+
+  useEffect(() => {
+    if (!token || !canView) return;
+    apiFetch<any[]>("/api/events/all", { authToken: token })
+      .then(evs => {
+        const withList = (evs || []).filter(e => e.waitlistEnabled);
+        setEvents(withList);
+        if (!eventId && withList.length) setEventId(withList[0].id);
+      })
+      .catch(e => setError(e?.message || "Failed to load events"));
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+  }, [token, canView]);
+
+  const load = useCallback(async () => {
+    if (!token || !eventId) return;
+    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");
+    } finally {
+      setBusy(false);
+    }
+  }, [token, eventId, setError]);
+  useEffect(() => { load(); }, [load]);
+
+  const act = async (path: string, body?: any) => {
+    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");
+    } finally {
+      setBusy(false);
+    }
+  };
+
+  const waitingCount = entries.filter(e => e.status === "waiting").length;
+  const selected = events.find(e => e.id === eventId);
+
+  return (
+    <div className="max-w-6xl mx-auto w-full p-6">
+      <div className="flex items-center gap-3 mb-4">
+        <div className="w-10 h-10 rounded-xl bg-brand-50 flex items-center justify-center shrink-0">
+          <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>
+          <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>
+      </div>
+
+      {!canView && <div className="p-3 border rounded bg-yellow-50 text-yellow-800 text-sm mb-4">You need staff access to view the waitlist.</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-wrap items-end gap-3 mb-4">
+            <div>
+              <label className="block text-xs text-gray-600 mb-1">Event</label>
+              <select className="border rounded-lg px-3 py-2 text-sm min-w-[16rem]" value={eventId} onChange={e => setEventId(e.target.value)}>
+                {events.length === 0 && <option value="">No events with a waitlist</option>}
+                {events.map(ev => <option key={ev.id} value={ev.id}>{ev.title} ({formatDate(new Date(ev.startDate))})</option>)}
+              </select>
+            </div>
+            {selected && (
+              <p className="text-xs text-gray-500">
+                {waitingCount} waiting · offers are held for {selected.waitlistOfferHours} hours · {selected.waitlistPartialOffers ? "partial offers on" : "only whole requests offered"}.
+                Turn the waitlist on or off in the event&apos;s Visibility step.
+              </p>
+            )}
+          </div>
+
+          <div className="overflow-x-auto">
+            <Table>
+              <TableHeader>
+                <TableRow>
+                  <TableHead>#</TableHead>
+                  <TableHead>Person</TableHead>
+                  <TableHead>Ticket</TableHead>
+                  <TableHead>Qty</TableHead>
+                  <TableHead>Joined</TableHead>
+                  <TableHead>Status</TableHead>
+                  {canManage && <TableHead className="text-right">Actions</TableHead>}
+                </TableRow>
+              </TableHeader>
+              <TableBody>
+                {entries.map((e, i) => {
+                  const st = STATUS[e.status];
+                  const active = e.status === "waiting" || e.status === "offered";
+                  return (
+                    <TableRow key={e.id} className={active ? "" : "opacity-60"}>
+                      <TableCell className="text-sm text-gray-500">{i + 1}</TableCell>
+                      <TableCell>
+                        <div className="text-sm font-medium">{e.user.name}</div>
+                        <div className="text-xs text-gray-500">{[e.user.email, e.user.phoneNumber].filter(Boolean).join(" · ")}</div>
+                      </TableCell>
+                      <TableCell className="text-sm">{e.eventOption.name}{e.variant ? ` (${e.variant.name})` : ""}</TableCell>
+                      <TableCell className="text-sm">{e.quantity}{e.status === "offered" && e.offeredQuantity !== e.quantity ? ` (${e.offeredQuantity} offered)` : ""}</TableCell>
+                      <TableCell className="text-xs text-gray-600">{formatDate(new Date(e.createdAt))}</TableCell>
+                      <TableCell>
+                        <span className={`text-xs px-2 py-0.5 rounded-full font-medium ${st.cls}`}>{st.label}</span>
+                        {e.status === "offered" && e.offerExpiresAt && <div className="text-xs text-gray-500 mt-1">until {new Date(e.offerExpiresAt).toLocaleString()}</div>}
+                      </TableCell>
+                      {canManage && (
+                        <TableCell className="text-right whitespace-nowrap">
+                          {e.status === "waiting" && (
+                            <>
+                              <button disabled={busy} onClick={() => act(`/api/waitlist/${e.id}/move`, { direction: "up" })} className="p-1 rounded border hover:bg-gray-50 mr-1" aria-label="Move up"><ArrowUp className="w-3.5 h-3.5" /></button>
+                              <button disabled={busy} onClick={() => act(`/api/waitlist/${e.id}/move`, { direction: "down" })} className="p-1 rounded border hover:bg-gray-50 mr-1" aria-label="Move down"><ArrowDown className="w-3.5 h-3.5" /></button>
+                            </>
+                          )}
+                          {(e.status === "waiting" || e.status === "expired") && (
+                            <button disabled={busy} onClick={() => act(`/api/waitlist/${e.id}/offer`)} className="px-2 py-1 text-xs rounded bg-brand-600 text-white hover:bg-brand-700 mr-1" title="Offer now, even if no place has freed up">Offer place</button>
+                          )}
+                          {active && (
+                            <button disabled={busy} onClick={() => act(`/api/waitlist/${e.id}/remove`)} className="px-2 py-1 text-xs rounded border hover:bg-gray-50">Remove</button>
+                          )}
+                        </TableCell>
+                      )}
+                    </TableRow>
+                  );
+                })}
+                {!busy && entries.length === 0 && (
+                  <TableRow><TableCell colSpan={7} className="text-center text-sm text-gray-500 py-8">{eventId ? "Nobody is on the waitlist." : "Pick an event."}</TableCell></TableRow>
+                )}
+              </TableBody>
+            </Table>
+          </div>
+          <p className="text-xs text-gray-500 mt-3">When places free up (a cancellation, a smaller booking, or a higher stock limit), the next people are offered them automatically. &quot;Offer place&quot; sends an offer straight away, even if it means going over the stock limit.</p>
+        </div>
+      )}
+    </div>
+  );
+}

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

@@ -9,6 +9,7 @@ import { QrImage } from "@/components/shared/QrImage";
 import { ApiImage } from "@/components/shared/ApiImage";
 import { useDismissingState } from "@/hooks/useDismissingState";
 import { AttendeesPanel } from "@/components/shared/AttendeesPanel";
+import { MyWaitlists } from "@/components/shared/MyWaitlists";
 import { ClipboardList, Calendar, Ticket, ChevronRight } from "lucide-react";
 
 // Helper formatters
@@ -871,6 +872,12 @@ export default function UserDashboardPage() {
         )}
       </section>
 
+      {token && (
+        <div className="mb-6">
+          <MyWaitlists token={token} onMessage={setInfo} />
+        </div>
+      )}
+
       <div className="grid lg:grid-cols-2 gap-6">
       <section className="mb-8 border rounded-xl p-5 bg-white shadow-sm">
         <div className="flex items-center gap-2 mb-3">

frontend/src/app/events/[id]/page.tsx

@@ -5,6 +5,7 @@ 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 { Calendar, Ticket, Paperclip, Sparkles } from "lucide-react";
 
 export const revalidate = 60;
@@ -40,6 +41,7 @@ type Event = {
   contactPhone?: string | null;
   contactEmail?: string | null;
   location?: string | null;
+  waitlistEnabled?: boolean;
 };
 
 import { apiFetch, ApiError, resolveToApiOrigin } from "@/lib/api";
@@ -93,6 +95,14 @@ function RegisterCta({ event }: { event: Event }) {
     );
   }
   if (eventSoldOut) {
+    if (event.waitlistEnabled) {
+      return (
+        <div className="space-y-2">
+          <div className="text-center text-sm font-medium text-red-700">Sold out</div>
+          <JoinWaitlistButton eventId={event.id} lines={soldOutLines(event.eventOptions || [])} guestsAllowed={event.requiresAuth === false} />
+        </div>
+      );
+    }
     return (
       <button disabled className="w-full bg-red-50 text-red-700 border border-red-200 px-4 py-2.5 rounded-lg cursor-not-allowed font-medium">
         Sold Out

frontend/src/app/manifest.ts

@@ -0,0 +1,17 @@
+import type { MetadataRoute } from "next";
+
+// Lets staff "Add to home screen" and open the ticket scanner like an app (it also
+// works offline once offline mode has been enabled — see public/sw.js).
+export default function manifest(): MetadataRoute.Manifest {
+  return {
+    name: "Ticket scanner",
+    short_name: "Scanner",
+    description: "Scan event tickets, online or offline",
+    start_url: "/dashboard/staff/ticket-scanning",
+    scope: "/",
+    display: "standalone",
+    background_color: "#ffffff",
+    theme_color: "#4F46E5",
+    icons: [{ src: "/favicon.ico", sizes: "any", type: "image/x-icon" }],
+  };
+}

frontend/src/app/register/[eventId]/RegisterForm.tsx

@@ -4,7 +4,8 @@ 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 { AttendeeNamesEditor, AttendeeEntries, TicketDelivery, attendeesPayload } from "@/components/shared/AttendeeNamesEditor";
+import { AttendeeNamesEditor, AttendeeEntries, TicketDelivery, attendeesPayload, consentDetailsMissing } from "@/components/shared/AttendeeNamesEditor";
+import { JoinWaitlistButton } from "@/components/events/JoinWaitlistButton";
 
 // Tiered low-stock threshold — mirrors events/[id]/page.tsx
 function lowStockThreshold(stockLimit: number): number {
@@ -42,8 +43,12 @@ type Event = {
   form?: { isRequired: boolean; fields?: any[] } | null;
   requiresAuth?: boolean;
   allowNamedAttendees?: boolean;
+  requiresParentalConsent?: boolean;
+  waitlistEnabled?: boolean;
 };
 
+type WaitlistOffer = { eventOptionId: string; variantId: string | null; quantity: number; expiresAt: string; optionName: string; variantName: string | null };
+
 // Key format: "optionId" for no-variant options, "optionId:variantId" for variant options
 type QtyMap = Record<string, number>;
 
@@ -127,10 +132,12 @@ function OptionCard({
   opt,
   quantities,
   onQtyChange,
+  waitlist,
 }: {
   opt: EventOption;
   quantities: QtyMap;
   onQtyChange: (key: string, val: number) => void;
+  waitlist?: { eventId: string; guestsAllowed: boolean } | null;
 }) {
   const hasVariants = Array.isArray(opt.variants) && opt.variants.length > 0;
   const isSoldOut = (opt.stockLimit ?? 0) > 0 && opt.availableCount !== undefined && opt.availableCount <= 0;
@@ -154,7 +161,13 @@ function OptionCard({
           </div>
           <div className="flex items-center gap-2">
             {isSoldOut ? (
-              <span className="text-xs font-medium text-red-600 bg-red-50 border border-red-200 rounded px-1.5 py-0.5">Sold out</span>
+              <>
+                <span className="text-xs font-medium text-red-600 bg-red-50 border border-red-200 rounded px-1.5 py-0.5">Sold out</span>
+                {waitlist && (
+                  <JoinWaitlistButton compact eventId={waitlist.eventId} guestsAllowed={waitlist.guestsAllowed}
+                    lines={variants.map(v => ({ eventOptionId: opt.id, variantId: v.id, label: `${opt.name} (${v.name})` }))} />
+                )}
+              </>
             ) : (
               <StockBadge stockLimit={opt.stockLimit} availableCount={opt.availableCount} />
             )}
@@ -178,6 +191,10 @@ function OptionCard({
                   <span className="text-sm">{variant.name}</span>
                   <span className="text-xs text-gray-500">R{unitPrice.toFixed(2)}</span>
                   <StockBadge stockLimit={variant.stockLimit} availableCount={variant.availableCount} />
+                  {waitlist && variantSoldOut && !isSoldOut && (
+                    <JoinWaitlistButton compact eventId={waitlist.eventId} guestsAllowed={waitlist.guestsAllowed}
+                      lines={[{ eventOptionId: opt.id, variantId: variant.id, label: `${opt.name} (${variant.name})` }]} />
+                  )}
                 </div>
                 <QtyControl
                   value={qty}
@@ -218,6 +235,9 @@ function OptionCard({
             <span>R{price.toFixed(2)}</span>
           )}
           <StockBadge stockLimit={opt.stockLimit} availableCount={opt.availableCount} />
+          {waitlist && isSoldOut && (
+            <JoinWaitlistButton compact eventId={waitlist.eventId} guestsAllowed={waitlist.guestsAllowed} lines={[{ eventOptionId: opt.id, label: opt.name }]} />
+          )}
         </div>
       </div>
       <QtyControl
@@ -230,9 +250,41 @@ function OptionCard({
   );
 }
 
-export default function RegisterForm({ event }: { event: Event }) {
+export default function RegisterForm({ event: baseEvent }: { event: Event }) {
   const { token, user } = useAuth();
-  const eventId = event.id;
+  const eventId = baseEvent.id;
+
+  // A waitlist claim link (?waitlist=<token>): the places held for this person are
+  // added back to what's available, so they can choose them.
+  const [waitlistToken, setWaitlistToken] = useState<string | null>(null);
+  const [offer, setOffer] = useState<WaitlistOffer | null>(null);
+  const [offerError, setOfferError] = useState<string | null>(null);
+  useEffect(() => {
+    const t = new URLSearchParams(window.location.search).get("waitlist");
+    if (!t) return;
+    apiFetch<WaitlistOffer & { status: string }>(`/api/waitlist/claim/${encodeURIComponent(t)}`)
+      .then(res => {
+        if (res.status !== "offered") { setOfferError("This waitlist offer has expired."); return; }
+        setWaitlistToken(t);
+        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."));
+  }, []);
+  const event = useMemo<Event>(() => {
+    if (!offer) return baseEvent;
+    return {
+      ...baseEvent,
+      eventOptions: (baseEvent.eventOptions || []).map(o => {
+        if (o.id !== offer.eventOptionId) return o;
+        return {
+          ...o,
+          availableCount: o.availableCount !== undefined ? o.availableCount + offer.quantity : o.availableCount,
+          variants: (o.variants || []).map(v => v.id === offer.variantId && v.availableCount !== undefined ? { ...v, availableCount: v.availableCount + offer.quantity } : v),
+        };
+      }),
+    };
+  }, [baseEvent, offer]);
 
   const [quantities, setQuantities] = useState<QtyMap>(() => {
     const initial: QtyMap = {};
@@ -254,7 +306,8 @@ export default function RegisterForm({ event }: { event: Event }) {
   const [attendeeEntries, setAttendeeEntries] = useState<AttendeeEntries>({});
   const [delivery, setDelivery] = useState<TicketDelivery>("payer");
   const qtyFor = (optionId: string, variantId: string | null) => quantities[variantId ? `${optionId}:${variantId}` : optionId] || 0;
-  const namedAttendees = () => (event.allowNamedAttendees && namingOthers
+  const isYouthEvent = !!event.requiresParentalConsent;
+  const namedAttendees = () => ((event.allowNamedAttendees && namingOthers) || isYouthEvent
     ? attendeesPayload(event.eventOptions || [], qtyFor, attendeeEntries)
     : []);
 
@@ -327,6 +380,28 @@ export default function RegisterForm({ event }: { event: Event }) {
       setError("Select at least one ticket.");
       return;
     }
+    if (isYouthEvent) {
+      const missing = consentDetailsMissing(event.eventOptions || [], qtyFor, attendeeEntries, event.startDate);
+      if (missing) { setError(missing); return; }
+    }
+
+    // Claim link without logging in: the link identifies the person.
+    if (waitlistToken && !isLoggedIn) {
+      try {
+        setError(null);
+        setCreatingRegistration(true);
+        const res = await apiFetch<{ id: string; totalDueComputed?: number }>("/api/registrations", {
+          method: "POST",
+          body: { eventId, options: items, waitlistToken, ...(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");
+      } finally {
+        setCreatingRegistration(false);
+      }
+      return;
+    }
 
     if (isLoggedIn) {
       if (!token) {
@@ -344,6 +419,7 @@ export default function RegisterForm({ event }: { event: Event }) {
             options: items,
             ...(coupon ? { couponCode: coupon.code } : {}),
             ...(namedAttendees().length > 0 ? { attendees: namedAttendees(), ticketDelivery: delivery } : {}),
+            ...(waitlistToken ? { waitlistToken } : {}),
           },
           authToken: token,
         });
@@ -430,13 +506,22 @@ export default function RegisterForm({ event }: { event: Event }) {
     <>
       <h1 className="text-2xl font-semibold mb-4">Register for {event.title}</h1>
 
-      {eventSoldOut && (
+      {offer && (
+        <div className="mb-4 p-4 border rounded-lg bg-green-50 border-green-200 text-sm text-green-900">
+          <strong>Your waitlist place:</strong> {offer.quantity} × {offer.optionName}{offer.variantName ? ` (${offer.variantName})` : ""} — held for you until {new Date(offer.expiresAt).toLocaleString()}.
+        </div>
+      )}
+      {offerError && (
+        <div className="mb-4 p-4 border rounded-lg bg-amber-50 border-amber-200 text-sm text-amber-900">{offerError}</div>
+      )}
+
+      {eventSoldOut && !event.waitlistEnabled && (
         <div className="mb-4 p-4 border rounded-lg bg-red-50 border-red-200 text-sm text-red-800 font-medium">
           This event is sold out. Registration is no longer available.
         </div>
       )}
 
-      {!isLoggedIn && !isGuestEligible && (
+      {!isLoggedIn && !isGuestEligible && !waitlistToken && (
         <div className="mb-4 p-4 border rounded-lg bg-amber-50 border-amber-200 text-sm text-amber-800">
           You need to <a href={`/login?redirect=/register/${eventId}`} className="font-semibold underline">log in</a> or <a href={`/register?redirect=/register/${eventId}`} className="font-semibold underline">create an account</a> to register for this event.
         </div>
@@ -483,6 +568,7 @@ export default function RegisterForm({ event }: { event: Event }) {
             opt={opt}
             quantities={quantities}
             onQtyChange={handleQtyChange}
+            waitlist={event.waitlistEnabled ? { eventId, guestsAllowed: event.requiresAuth === false } : null}
           />
         ))}
       </div>
@@ -505,7 +591,7 @@ export default function RegisterForm({ event }: { event: Event }) {
         );
       })()}
 
-      {event.allowNamedAttendees && !eventSoldOut && (isLoggedIn || showGuestForm) && (
+      {(event.allowNamedAttendees || isYouthEvent) && !eventSoldOut && (isLoggedIn || showGuestForm) && (
         <div className="mt-6">
           <AttendeeNamesEditor
             options={event.eventOptions || []}
@@ -516,6 +602,7 @@ export default function RegisterForm({ event }: { event: Event }) {
             onEntriesChange={setAttendeeEntries}
             delivery={delivery}
             onDeliveryChange={setDelivery}
+            consentEventStart={isYouthEvent ? event.startDate : undefined}
           />
         </div>
       )}
@@ -544,7 +631,7 @@ export default function RegisterForm({ event }: { event: Event }) {
           ) : (
           <button
             onClick={submitRegistration}
-            disabled={creatingRegistration || (!isLoggedIn && !isGuestEligible)}
+            disabled={creatingRegistration || (!isLoggedIn && !isGuestEligible && !waitlistToken)}
             className="bg-brand-600 text-white px-4 py-2 rounded hover:bg-brand-700 disabled:opacity-60"
           >
             {creatingRegistration ? "Registering..." : "Register"}

frontend/src/app/self-service/page.tsx

@@ -4,7 +4,7 @@ import React, { useCallback, useEffect, useMemo, useRef, useState } from "react"
 import { apiFetch } from "@/lib/api";
 import { TwoFactorChallenge, isTwoFactorChallenge } from "@/lib/auth";
 import { CouponCodeField, AppliedCoupon } from "@/components/shared/CouponCodeField";
-import { AttendeeNamesEditor, AttendeeEntries, TicketDelivery, attendeesPayload } from "@/components/shared/AttendeeNamesEditor";
+import { AttendeeNamesEditor, AttendeeEntries, TicketDelivery, attendeesPayload, consentDetailsMissing } from "@/components/shared/AttendeeNamesEditor";
 
 // ─── Types ────────────────────────────────────────────────────────────────────
 type EarlyBirdTier = { deadline: string; price: number; order?: number; variantId?: string | null };
@@ -41,6 +41,7 @@ type KioskEvent = {
   eventOptions?: EventOption[];
   form?: EventForm | null;
   allowNamedAttendees?: boolean;
+  requiresParentalConsent?: boolean;
 };
 
 type Screen = "setup" | "form" | "eventform" | "confirmation";
@@ -388,6 +389,10 @@ export default function SelfServicePage() {
       setFormError("The email and phone number entered belong to two different existing accounts. Please check and correct one of them before continuing.");
       return;
     }
+    if (selectedEvent?.requiresParentalConsent) {
+      const missing = consentDetailsMissing(selectedEvent.eventOptions || [], (o, v) => quantities[v ? `${o}::${v}` : o] || 0, attendeeEntries, selectedEvent.startDate);
+      if (missing) { setFormError(missing); return; }
+    }
     if (pendingChanges.length > 0) {
       setShowUpdateConfirm(true);
       return;
@@ -417,7 +422,7 @@ export default function SelfServicePage() {
         notificationPreference: notificationPref,
         ...(kioskCoupon ? { couponCode: kioskCoupon.code } : {}),
       };
-      const kioskNames = selectedEvent?.allowNamedAttendees && namingOthers
+      const kioskNames = (selectedEvent?.allowNamedAttendees && namingOthers) || selectedEvent?.requiresParentalConsent
         ? attendeesPayload(selectedEvent.eventOptions || [], (o, v) => quantities[v ? `${o}::${v}` : o] || 0, attendeeEntries)
         : [];
       if (kioskNames.length > 0) {
@@ -1008,7 +1013,7 @@ export default function SelfServicePage() {
                       );
                     })}
                   </div>
-                  {selectedEvent?.allowNamedAttendees && (
+                  {(selectedEvent?.allowNamedAttendees || selectedEvent?.requiresParentalConsent) && (
                     <div className="mt-4">
                       <AttendeeNamesEditor
                         options={selectedEvent.eventOptions || []}
@@ -1019,6 +1024,7 @@ export default function SelfServicePage() {
                         onEntriesChange={setAttendeeEntries}
                         delivery={delivery}
                         onDeliveryChange={setDelivery}
+                        consentEventStart={selectedEvent.requiresParentalConsent ? selectedEvent.startDate : undefined}
                       />
                     </div>
                   )}

frontend/src/app/waitlist/claim/[token]/page.tsx

@@ -0,0 +1,72 @@
+"use client";
+import React, { useEffect, useState } from "react";
+import { useParams } from "next/navigation";
+import { Navbar } from "@/components/layout/Navbar";
+import { Footer } from "@/components/layout/Footer";
+import { apiFetch, ApiError } from "@/lib/api";
+import { formatDate } from "@/lib/date";
+import { ListChecks } from "lucide-react";
+
+type Claim = {
+  status: "offered" | "expired";
+  eventId: string;
+  eventTitle: string;
+  eventStart: string;
+  optionName: string;
+  variantName: string | null;
+  quantity: number;
+  requested: number;
+  expiresAt: string;
+  name?: string;
+};
+
+/** Landing page for a waitlist offer link — shows what's held, then goes to registration. */
+export default function WaitlistClaimPage() {
+  const params = useParams<{ token: string }>();
+  const token = params?.token;
+  const [claim, setClaim] = useState<Claim | null>(null);
+  const [error, setError] = useState<string | null>(null);
+
+  useEffect(() => {
+    if (!token) return;
+    apiFetch<Claim>(`/api/waitlist/claim/${encodeURIComponent(token)}`)
+      .then(setClaim)
+      .catch(e => setError(e instanceof ApiError ? e.message : "Couldn't load this offer."));
+  }, [token]);
+
+  return (
+    <div className="min-h-screen flex flex-col">
+      <Navbar />
+      <main className="flex-1 px-4 py-10 max-w-xl mx-auto w-full">
+        <div className="flex items-center gap-3 mb-4">
+          <div className="w-10 h-10 rounded-xl bg-brand-50 flex items-center justify-center shrink-0">
+            <ListChecks className="w-5 h-5 text-brand-600" />
+          </div>
+          <h1 className="text-2xl font-semibold text-gray-900">Your waitlist place</h1>
+        </div>
+        {error && <div className="border rounded-xl p-4 bg-red-50 text-red-800 text-sm">{error}</div>}
+        {!claim && !error && <div className="text-sm text-gray-600">Loading…</div>}
+        {claim && (
+          <div className="border rounded-xl p-5 bg-white shadow-sm space-y-3">
+            <div className="font-semibold text-gray-900">{claim.eventTitle}</div>
+            <div className="text-sm text-gray-600">{formatDate(new Date(claim.eventStart))}</div>
+            {claim.status === "offered" ? (
+              <>
+                <p className="text-sm text-gray-700">
+                  {claim.name ? `Hi ${claim.name}, ` : ""}{claim.quantity} × {claim.optionName}{claim.variantName ? ` (${claim.variantName})` : ""} {claim.quantity === 1 ? "is" : "are"} being held for you until <strong>{new Date(claim.expiresAt).toLocaleString()}</strong>.
+                  {claim.quantity < claim.requested && ` You asked for ${claim.requested}; this is what came free.`}
+                </p>
+                <a href={`/register/${claim.eventId}?waitlist=${encodeURIComponent(token)}`} className="inline-block px-4 py-2 rounded-lg bg-brand-600 text-white text-sm font-medium hover:bg-brand-700">
+                  Claim and register
+                </a>
+              </>
+            ) : (
+              <p className="text-sm text-amber-900 bg-amber-50 border border-amber-200 rounded-lg p-3">This offer has expired, and the place has been offered to the next person on the waitlist.</p>
+            )}
+          </div>
+        )}
+      </main>
+      <Footer />
+    </div>
+  );
+}

frontend/src/components/events/EventCard.tsx

@@ -13,6 +13,7 @@ import { ContactButton } from "@/components/events/ContactButton";
    price: number;
    picture?: string;
    isSoldOut?: boolean;
+   waitlistEnabled?: boolean;
    requiresRegistration?: boolean;
    contactName?: string | null;
    contactPhone?: string | null;
@@ -88,6 +89,14 @@ export const EventCard = ({ event }: { event: Event }) => {
                           </button>
                         );
                       }
+                      if (event.isSoldOut && event.waitlistEnabled) {
+                        // Sold out with a waitlist: send them to the event page to join it.
+                        return (
+                          <a href={`/events/${event.id}`} className="flex-1 text-center text-sm text-brand-700 bg-white border border-brand-300 rounded-lg py-2 hover:bg-brand-50">
+                            Sold out — join waitlist
+                          </a>
+                        );
+                      }
                       if (event.isSoldOut) {
                         return (
                           <button disabled className="flex-1 text-center text-sm text-red-700 bg-red-50 border border-red-200 rounded-lg py-2 cursor-not-allowed">

frontend/src/components/events/JoinWaitlistButton.tsx

@@ -0,0 +1,145 @@
+"use client";
+
+import React, { useState } from "react";
+import { ListPlus, X } from "lucide-react";
+import { apiFetch, ApiError } from "@/lib/api";
+import { useAuth } from "@/hooks/useAuth";
+
+export type WaitlistLine = { eventOptionId: string; variantId?: string | null; label: string };
+
+const inputCls = "w-full border rounded-lg px-3 py-2 text-sm focus:outline-none focus:ring-2 focus:ring-brand-400";
+
+/**
+ * "Join waitlist" for sold-out options. Opens a small form: which option, how many,
+ * and (for guests on events that allow it) name and contact details.
+ */
+export function JoinWaitlistButton({ eventId, lines, guestsAllowed, initialLine, compact = false }: {
+  eventId: string;
+  lines: WaitlistLine[];
+  guestsAllowed: boolean;
+  initialLine?: WaitlistLine;
+  compact?: boolean;
+}) {
+  const { token, user } = useAuth();
+  const [open, setOpen] = useState(false);
+  const [lineKey, setLineKey] = useState(() => keyOf(initialLine || lines[0]));
+  const [qty, setQty] = useState(1);
+  const [guest, setGuest] = useState({ name: "", email: "", phone: "" });
+  const [busy, setBusy] = useState(false);
+  const [error, setError] = useState<string | null>(null);
+  const [done, setDone] = useState<string | null>(null);
+
+  if (lines.length === 0) return null;
+  const loggedIn = !!(token && user);
+  const line = lines.find(l => keyOf(l) === lineKey) || lines[0];
+
+  const submit = async (e: React.FormEvent) => {
+    e.preventDefault();
+    setBusy(true);
+    setError(null);
+    try {
+      const res = await apiFetch<{ message: string }>("/api/waitlist", {
+        method: "POST",
+        authToken: token || undefined,
+        body: {
+          eventId,
+          eventOptionId: line.eventOptionId,
+          ...(line.variantId ? { variantId: line.variantId } : {}),
+          quantity: qty,
+          ...(!loggedIn ? { guestName: guest.name.trim(), guestEmail: guest.email.trim(), guestPhone: guest.phone.trim() || undefined } : {}),
+        },
+      });
+      setDone(res.message);
+    } catch (err) {
+      setError(err instanceof ApiError ? err.message : "Couldn't join the waitlist. Please try again.");
+    } finally {
+      setBusy(false);
+    }
+  };
+
+  return (
+    <>
+      <button
+        type="button"
+        onClick={() => { setOpen(true); setDone(null); setError(null); }}
+        className={compact
+          ? "inline-flex items-center gap-1 text-xs font-medium text-brand-700 border border-brand-200 bg-brand-50 rounded px-2 py-0.5 hover:bg-brand-100"
+          : "w-full inline-flex items-center justify-center gap-2 bg-white text-brand-700 border border-brand-300 px-4 py-2.5 rounded-lg hover:bg-brand-50 font-medium"}
+      >
+        <ListPlus className={compact ? "w-3.5 h-3.5" : "w-4 h-4"} /> Join waitlist
+      </button>
+
+      {open && (
+        <div className="fixed inset-0 z-50 bg-black/40 flex items-center justify-center p-4" onClick={() => setOpen(false)}>
+          <form onSubmit={submit} className="bg-white rounded-xl shadow-xl w-full max-w-md p-5 space-y-4" onClick={e => e.stopPropagation()}>
+            <div className="flex items-center justify-between">
+              <h2 className="font-semibold">Join the waitlist</h2>
+              <button type="button" onClick={() => setOpen(false)} aria-label="Close"><X className="w-5 h-5 text-gray-500" /></button>
+            </div>
+
+            {done ? (
+              <>
+                <p className="text-sm text-green-800 bg-green-50 border border-green-200 rounded-lg p-3">{done}</p>
+                <button type="button" onClick={() => setOpen(false)} className="w-full px-4 py-2 rounded-lg bg-brand-600 text-white text-sm font-medium hover:bg-brand-700">Done</button>
+              </>
+            ) : !loggedIn && !guestsAllowed ? (
+              <p className="text-sm text-gray-700">
+                <a href={`/login?redirect=${encodeURIComponent(typeof window !== "undefined" ? window.location.pathname : "/events")}`} className="text-brand-600 font-medium underline">Log in</a> to join the waitlist for this event.
+              </p>
+            ) : (
+              <>
+                <p className="text-sm text-gray-600">If a place opens up, we&apos;ll email or WhatsApp you a link to claim it. We hold it for you for a limited time.</p>
+                {lines.length > 1 && (
+                  <div>
+                    <label className="block text-sm font-medium text-gray-700 mb-1">Ticket</label>
+                    <select className={inputCls} value={lineKey} onChange={e => setLineKey(e.target.value)}>
+                      {lines.map(l => <option key={keyOf(l)} value={keyOf(l)}>{l.label}</option>)}
+                    </select>
+                  </div>
+                )}
+                {lines.length === 1 && <p className="text-sm"><span className="text-gray-500">Ticket:</span> {line.label}</p>}
+                <div>
+                  <label className="block text-sm font-medium text-gray-700 mb-1">How many?</label>
+                  <input type="number" min={1} max={20} className={`${inputCls} w-24`} value={qty} onChange={e => setQty(Math.max(1, Math.min(20, parseInt(e.target.value, 10) || 1)))} />
+                </div>
+                {!loggedIn && (
+                  <div className="space-y-2">
+                    <input className={inputCls} placeholder="Full name *" value={guest.name} onChange={e => setGuest({ ...guest, name: e.target.value })} required aria-label="Full name" />
+                    <input type="email" className={inputCls} placeholder="Email *" value={guest.email} onChange={e => setGuest({ ...guest, email: e.target.value })} required aria-label="Email" />
+                    <input type="tel" className={inputCls} placeholder="Phone (optional)" value={guest.phone} onChange={e => setGuest({ ...guest, phone: e.target.value })} aria-label="Phone" />
+                  </div>
+                )}
+                {error && <p className="text-sm text-red-600">{error}</p>}
+                <button type="submit" disabled={busy} className="w-full px-4 py-2 rounded-lg bg-brand-600 text-white text-sm font-medium hover:bg-brand-700 disabled:opacity-50">
+                  {busy ? "Joining…" : "Join waitlist"}
+                </button>
+              </>
+            )}
+          </form>
+        </div>
+      )}
+    </>
+  );
+}
+
+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;
+}

frontend/src/components/reports/ReportCatalog.ts

@@ -14,6 +14,8 @@ import {
   BarChart3,
   ClipboardList,
   TicketPercent,
+  ShieldCheck,
+  HeartPulse,
 } from "lucide-react";
 
 export type ReportCategory = "Financial" | "Registration" | "Ticketing" | "Donations" | "Cashup" | "Other";
@@ -34,6 +36,8 @@ export const REPORTS = [
   { key: "financeReport", label: "Finance report (revenue & costs)", description: "Revenue & costs overview", category: "Financial", icon: FileBarChart, fields: 6 },
   { key: "profitReport", label: "Profit report", description: "View profit report", category: "Financial", icon: BarChart3, fields: 5 },
   { key: "cashupAudit", label: "Cashup audit trail", description: "Audit trail of cashup actions", category: "Cashup", icon: ClipboardList, fields: 6 },
+  { key: "consentStatus", label: "Parental consent status", description: "Youth events: consent per attendee", category: "Registration", icon: ShieldCheck, fields: 5 },
+  { 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 },
 ] as const satisfies ReadonlyArray<{
   key: string;

frontend/src/components/reports/ReportsV2.tsx

@@ -5,7 +5,7 @@ import { useSearchParams } from "next/navigation";
 import { useAuth } from "@/hooks/useAuth";
 import { apiFetch, API_BASE } from "@/lib/api";
 import { downloadReportExcel, emailReportPdf, whatsappReportPdf, viewReportPdf, type ReportPdfPayload } from "@/lib/export";
-import { Printer, Mail, FileSpreadsheet, MessageCircle, ShoppingCart, CreditCard, Gift, Clock, HandHeart, Search, TrendingUp, TicketPercent } from "lucide-react";
+import { Printer, Mail, FileSpreadsheet, MessageCircle, ShoppingCart, CreditCard, Gift, Clock, HandHeart, Search, TrendingUp, TicketPercent, ShieldCheck } from "lucide-react";
 import { REPORTS, type ReportKey } from "./ReportCatalog";
 import ReportsShell from "./ReportsShell";
 import ReportViewerModal, { ReportActionButton } from "./ReportViewerModal";
@@ -174,6 +174,9 @@ export default function ReportsV2({ onBack }: { onBack?: () => void } = {}) {
   const [financialsByEvent, setFinancialsByEvent] = useState<Record<string, any>>({});
   const [auditRows, setAuditRows] = useState<any[]>([]);
   const [discountRows, setDiscountRows] = useState<any[]>([]);
+  // Youth events (one row per attendee), each tagged with its event title.
+  const [consentRows, setConsentRows] = useState<any[]>([]);
+  const [medicalRows, setMedicalRows] = useState<any[]>([]);
 
   // Deep-linking: dashboards link here with ?report=<key>&range=trailing_month to jump
   // straight into a specific report, pre-filtered to every currently-visible event and the
@@ -296,6 +299,20 @@ export default function ReportsV2({ onBack }: { onBack?: () => void } = {}) {
     }
   };
 
+  const loadConsent = async (eventIds: string[], kind: "status" | "medical") => {
+    if (!token) return [] as any[];
+    const out: any[] = [];
+    for (const id of eventIds) {
+      const ev = filteredEvents.find((e: any) => e.id === id);
+      if (!ev?.requiresParentalConsent) continue;
+      try {
+        const res = await apiFetch<any>(`/api/consent/events/${encodeURIComponent(id)}${kind === "medical" ? "/medical" : ""}`, { authToken: token });
+        (res?.rows || []).forEach((r: any) => out.push({ ...r, eventTitle: ev.title }));
+      } catch { /* not allowed or not found — skip */ }
+    }
+    return out;
+  };
+
   const loadCashupAudit = async (eventIds: string[]) => {
     if (!token) return [] as any[];
     const query = new URLSearchParams();
@@ -390,6 +407,10 @@ export default function ReportsV2({ onBack }: { onBack?: () => void } = {}) {
         setAuditRows(rows);
       } else if (report === "discounts") {
         setDiscountRows(await loadDiscounts(selectedEventIds));
+      } else if (report === "consentStatus") {
+        setConsentRows(await loadConsent(selectedEventIds, "status"));
+      } else if (report === "medicalList") {
+        setMedicalRows(await loadConsent(selectedEventIds, "medical"));
       }
       setReady(true);
     } finally {
@@ -963,6 +984,34 @@ export default function ReportsV2({ onBack }: { onBack?: () => void } = {}) {
         table: { columns: ["Event", "Donations (R)", "Used (R)", "Unused (R)", "Count"], rows }
       };
     }
+    if (report === "consentStatus") {
+      const minors = consentRows.filter(r => r.minor);
+      const count = (s: string) => minors.filter(r => r.status === s).length;
+      return {
+        title: 'Parental consent status', subtitle, kind: 'table', orientation: 'landscape',
+        stats: [
+          { label: 'Given', value: String(count('given')), tone: 'green' },
+          { label: 'Pending', value: String(count('pending')), tone: 'amber' },
+          { label: 'Declined / missing', value: String(count('declined') + count('missing')), tone: 'rose' },
+        ],
+        note: 'Under-18 attendees on youth events. Pending, declined or missing consent blocks check-in.',
+        table: {
+          columns: ["Event", "Attendee", "Date of birth", "Parent / guardian", "Consent", "Answered"],
+          rows: minors.map(r => [r.eventTitle, r.name, r.dateOfBirth ? new Date(r.dateOfBirth).toLocaleDateString() : '', [r.parentName, r.parentPhone].filter(Boolean).join(' · '), r.status + (r.request?.outdated ? ' (older text)' : ''), r.request?.respondedAt ? `${r.request.signedName || ''} ${new Date(r.request.respondedAt).toLocaleDateString()}`.trim() : '']),
+        },
+      };
+    }
+    if (report === "medicalList") {
+      const fmt = (m: any) => m ? [m.allergies && `Allergies: ${m.allergies}`, m.medication && `Medication: ${m.medication}`, m.conditions && `Conditions: ${m.conditions}`, m.medicalAid && `Medical aid: ${m.medicalAid}`].filter(Boolean).join('; ') : '';
+      return {
+        title: 'Medical & emergency list', subtitle, kind: 'table', orientation: 'landscape',
+        note: 'CONFIDENTIAL — for event leaders only. Viewing this list is recorded in the audit log.',
+        table: {
+          columns: ["Event", "Attendee", "Medical", "Emergency contact", "Parent / guardian", "Photos"],
+          rows: medicalRows.map(r => [r.eventTitle, r.name, r.purged ? 'Deleted after the event' : fmt(r.medical), r.emergency ? `${r.emergency.name} ${r.emergency.phone}${r.emergency.relationship ? ` (${r.emergency.relationship})` : ''}` : '', [r.parentName, r.parentPhone].filter(Boolean).join(' · '), r.photoConsent === null || r.photoConsent === undefined ? '' : r.photoConsent ? 'Yes' : 'No']),
+        },
+      };
+    }
     if (report === "discounts") {
       return {
         title: 'Discounts (coupon codes)', subtitle, kind: 'table', orientation: 'portrait',
@@ -1168,6 +1217,8 @@ export default function ReportsV2({ onBack }: { onBack?: () => void } = {}) {
     profitReport: "Profit Report",
     cashupAudit: "Cashup Audit Trail",
     discounts: "Discounts Report",
+    consentStatus: "Parental Consent Status",
+    medicalList: "Medical & Emergency List",
   };
 
   const doPrintPdf = async () => {
@@ -1618,6 +1669,41 @@ export default function ReportsV2({ onBack }: { onBack?: () => void } = {}) {
               )}
             </div>
           )}
+          {(report === "consentStatus" || report === "medicalList") && (() => {
+            const payload: any = buildReportPayload();
+            const rows: any[] = payload?.table?.rows || [];
+            const cols: string[] = payload?.table?.columns || [];
+            return (
+              <div>
+                {report === "medicalList" && <div className="mb-3 text-sm text-red-700 font-medium">Confidential — for event leaders only. Viewing this list is recorded in the audit log.</div>}
+                {payload?.stats && (
+                  <StatTileRow>
+                    {payload.stats.map((s: any) => <StatTile key={s.label} icon={ShieldCheck} label={s.label} value={s.value} tone={s.tone} />)}
+                  </StatTileRow>
+                )}
+                {rows.length === 0 ? (
+                  <div className="text-sm text-gray-500 mt-3">Nothing to show — pick youth events (ones that need parental consent) in the filters.</div>
+                ) : (
+                  <div className="mt-4 overflow-auto border border-gray-100 rounded-xl">
+                    <table className="min-w-[760px] w-full text-sm">
+                      <thead>
+                        <tr className="text-left text-gray-500 text-xs uppercase tracking-wide bg-gray-50">
+                          {cols.map(c => <th key={c} className="py-2 px-3">{c}</th>)}
+                        </tr>
+                      </thead>
+                      <tbody>
+                        {rows.map((r, i) => (
+                          <tr key={i} className="border-t border-gray-100 align-top">
+                            {r.map((cell: any, j: number) => <td key={j} className="py-2 px-3">{String(cell ?? '')}</td>)}
+                          </tr>
+                        ))}
+                      </tbody>
+                    </table>
+                  </div>
+                )}
+              </div>
+            );
+          })()}
           {report === "discounts" && (
             <div>
               {discountSummary.rows.length === 0 ? (

frontend/src/components/scanner/OfflineScanPanel.tsx

@@ -0,0 +1,106 @@
+"use client";
+
+import React, { useEffect, useState } from "react";
+import { Wifi, WifiOff, CloudUpload, Lock } from "lucide-react";
+import { apiFetch } from "@/lib/api";
+import type { OtherLock } from "./useOfflineScanning";
+
+type Offline = ReturnType<typeof import("./useOfflineScanning").useOfflineScanning>;
+
+/**
+ * Offline-mode controls above the scanner: shows who holds which section, lets this
+ * device lock the selected section and download its tickets, and shows the sync queue.
+ */
+export function OfflineScanPanel({ offline, token, eventId, eventTitle, sectionId, sectionName, onError, onInfo }: {
+  offline: Offline;
+  token: string | null;
+  eventId: string;
+  eventTitle: string;
+  sectionId: string | null;
+  sectionName: string | null;
+  onError: (m: string) => void;
+  onInfo: (m: string) => void;
+}) {
+  const [locks, setLocks] = useState<OtherLock[]>([]);
+  const [busy, setBusy] = useState(false);
+  const { lock, pending, online, syncing } = offline;
+
+  useEffect(() => {
+    if (!token || !eventId || eventId === "all" || !online) { setLocks([]); return; }
+    apiFetch<OtherLock[]>(`/api/scan-locks?eventId=${encodeURIComponent(eventId)}`, { authToken: token })
+      .then(setLocks).catch(() => setLocks([]));
+  }, [token, eventId, online, lock]);
+
+  const others = locks.filter(l => l.deviceId !== offline.deviceId());
+
+  const enable = async () => {
+    setBusy(true);
+    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");
+    } finally {
+      setBusy(false);
+    }
+  };
+  const release = async () => {
+    setBusy(true);
+    try {
+      await offline.release();
+      onInfo("Offline mode ended and the section is unlocked.");
+    } catch (e: any) {
+      onError(e?.message || "Couldn't end offline mode");
+    } finally {
+      setBusy(false);
+    }
+  };
+  const syncNow = async () => {
+    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.");
+    }
+  };
+
+  return (
+    <div className={`rounded-xl border p-3 mb-4 text-sm ${lock ? "bg-amber-50 border-amber-200" : "bg-white"}`}>
+      <div className="flex flex-wrap items-center gap-2">
+        {online ? <Wifi className="w-4 h-4 text-green-600" /> : <WifiOff className="w-4 h-4 text-red-600" />}
+        <span className={online ? "text-green-700" : "text-red-700"}>{online ? "Online" : "Offline"}</span>
+        {lock ? (
+          <>
+            <span className="text-gray-400">·</span>
+            <span className="font-medium text-amber-900">Offline mode: {lock.eventTitle}{lock.sectionName ? ` — ${lock.sectionName}` : " — whole event"}</span>
+            <span className="text-xs text-gray-600">Ticket list downloaded at {new Date(lock.snapshotAt).toLocaleTimeString()}</span>
+            <span className="text-xs text-gray-600">· {pending} scan(s) waiting to sync</span>
+            <div className="ml-auto flex gap-2">
+              <button onClick={syncNow} disabled={!online || syncing || pending === 0} className="inline-flex items-center gap-1 px-2.5 py-1 rounded border bg-white text-xs disabled:opacity-50"><CloudUpload className="w-3.5 h-3.5" /> {syncing ? "Syncing…" : "Sync now"}</button>
+              <button onClick={release} disabled={!online || busy} className="px-2.5 py-1 rounded bg-amber-600 text-white text-xs disabled:opacity-50">Release section</button>
+            </div>
+          </>
+        ) : eventId && eventId !== "all" ? (
+          <div className="ml-auto">
+            <button onClick={enable} disabled={!online || busy || others.some(l => !l.sectionId || !sectionId || l.sectionId === sectionId)} className="px-2.5 py-1 rounded border border-brand-300 text-brand-700 text-xs hover:bg-brand-50 disabled:opacity-50" title="Lock this section to this device and download its tickets, so you can keep scanning if the connection drops">
+              {busy ? "Preparing…" : `Enable offline mode${sectionName ? ` for ${sectionName}` : " (whole event)"}`}
+            </button>
+          </div>
+        ) : (
+          <span className="text-xs text-gray-500 ml-1">Pick an event to use offline mode.</span>
+        )}
+      </div>
+      {others.length > 0 && (
+        <ul className="mt-2 space-y-0.5">
+          {others.map(l => (
+            <li key={l.id} className="flex items-center gap-1.5 text-xs text-gray-700">
+              <Lock className="w-3.5 h-3.5 text-amber-600" />
+              {l.sectionName ? `"${l.sectionName}"` : "The whole event"} is offline-locked by {l.user.name}{l.deviceName ? ` on ${l.deviceName}` : ""} — scan it on that device.
+            </li>
+          ))}
+        </ul>
+      )}
+      {lock && !online && <p className="mt-2 text-xs text-amber-900">Scans are saved on this device and will sync when the connection is back. Tickets bought after the download time won&apos;t be on the list.</p>}
+    </div>
+  );
+}

frontend/src/components/scanner/useOfflineScanning.ts

@@ -0,0 +1,115 @@
+"use client";
+
+import { useCallback, useEffect, useRef, useState } from "react";
+import { apiFetch } from "@/lib/api";
+import {
+  OfflineLock, SnapshotTicket, clearOffline, deviceId, deviceName, findTicket, getOfflineLock,
+  queuedScans, recordScan, removeQueued, startOffline,
+} from "@/lib/offlineScan";
+
+export type OtherLock = { id: string; sectionId: string | null; sectionName: string | null; deviceId: string; deviceName: string | null; user: { name: string } };
+
+/**
+ * Offline mode for the ticket scanner: lock a section to this device, download its
+ * tickets, scan against them with no connection, and sync the queued scans whenever
+ * the device is back online.
+ */
+export function useOfflineScanning(token: string | null) {
+  const [lock, setLock] = useState<OfflineLock | null>(null);
+  const [pending, setPending] = useState(0);
+  const [online, setOnline] = useState(true);
+  const [syncing, setSyncing] = useState(false);
+  const [lastSync, setLastSync] = useState<{ accepted: number; conflicts: number; at: string } | null>(null);
+  const syncingRef = useRef(false);
+
+  const refreshPending = useCallback(async () => {
+    try { setPending((await queuedScans()).length); } catch { setPending(0); }
+  }, []);
+
+  useEffect(() => {
+    setLock(getOfflineLock());
+    refreshPending();
+    setOnline(typeof navigator === "undefined" ? true : navigator.onLine);
+    const up = () => setOnline(true);
+    const down = () => setOnline(false);
+    window.addEventListener("online", up);
+    window.addEventListener("offline", down);
+    // Cache the scanner page and everything it has loaded, so it opens offline.
+    if ("serviceWorker" in navigator) {
+      navigator.serviceWorker.register("/sw.js").then(async () => {
+        const reg = await navigator.serviceWorker.ready;
+        const urls = [window.location.pathname, ...performance.getEntriesByType("resource").map(e => e.name)];
+        reg.active?.postMessage({ type: "cache-urls", urls });
+      }).catch(() => {});
+    }
+    return () => { window.removeEventListener("online", up); window.removeEventListener("offline", down); };
+  }, [refreshPending]);
+
+  /** Uploads queued scans. Returns the server's verdict, or null when nothing was sent. */
+  const sync = useCallback(async () => {
+    if (!token || syncingRef.current) return null;
+    const queue = await queuedScans();
+    if (queue.length === 0) return null;
+    syncingRef.current = true;
+    setSyncing(true);
+    try {
+      const byLock = new Map<string, typeof queue>();
+      queue.forEach(q => byLock.set(q.lockId, [...(byLock.get(q.lockId) || []), q]));
+      let accepted = 0, conflicts = 0;
+      for (const [lockId, scans] of byLock) {
+        const res = await apiFetch<{ accepted: number; duplicates: number; conflicts: any[] }>(`/api/scan-locks/${lockId}/sync`, {
+          method: "POST", authToken: token, body: { deviceId: deviceId(), scans },
+        });
+        accepted += res.accepted;
+        conflicts += res.conflicts.length;
+        // Synced (or already on the server) — either way they're done on this device.
+        await removeQueued(scans.map(s => s.clientScanId));
+      }
+      const result = { accepted, conflicts, at: new Date().toISOString() };
+      setLastSync(result);
+      return result;
+    } finally {
+      syncingRef.current = false;
+      setSyncing(false);
+      refreshPending();
+    }
+  }, [token, refreshPending]);
+
+  // Sync as soon as the connection is back, and every 30 seconds while online.
+  useEffect(() => {
+    if (!online || !token) return;
+    sync().catch(() => {});
+    const t = setInterval(() => { if (navigator.onLine) sync().catch(() => {}); }, 30000);
+    return () => clearInterval(t);
+  }, [online, token, sync]);
+
+  const enable = useCallback(async (eventId: string, eventTitle: string, sectionId: string | null, sectionName: string | null) => {
+    if (!token) throw new Error("Log in first.");
+    const created = await apiFetch<{ id: string }>("/api/scan-locks", {
+      method: "POST", authToken: token, body: { eventId, sectionId, deviceId: deviceId(), deviceName: deviceName() },
+    });
+    const snap = await apiFetch<{ snapshotAt: string; tickets: SnapshotTicket[] }>(`/api/scan-locks/${created.id}/snapshot?deviceId=${encodeURIComponent(deviceId())}`, { authToken: token });
+    const next: OfflineLock = { lockId: created.id, eventId, eventTitle, sectionId, sectionName, snapshotAt: snap.snapshotAt };
+    await startOffline(next, snap.tickets);
+    setLock(next);
+    return snap.tickets.length;
+  }, [token]);
+
+  const release = useCallback(async () => {
+    if (!lock || !token) return;
+    await sync();
+    if ((await queuedScans()).length > 0) throw new Error("Some scans haven't synced yet. Try again when you're online.");
+    await apiFetch(`/api/scan-locks/${lock.lockId}`, { method: "DELETE", authToken: token, body: { deviceId: deviceId() } });
+    await clearOffline();
+    setLock(null);
+  }, [lock, token, sync]);
+
+  const scanLocally = useCallback(async (ticket: SnapshotTicket, qty: number) => {
+    if (!lock) throw new Error("Offline mode is not on.");
+    await recordScan(lock.lockId, ticket, qty);
+    await refreshPending();
+    if (navigator.onLine) sync().catch(() => {});
+  }, [lock, refreshPending, sync]);
+
+  return { lock, pending, online, syncing, lastSync, enable, release, sync, scanLocally, findTicket, deviceId };
+}

frontend/src/components/shared/AttendeeNamesEditor.tsx

@@ -10,11 +10,28 @@ export type AttendeeOption = {
   variants?: { id: string; name: string }[] | null;
 };
 
-export type AttendeeEntry = { name: string; email: string; phone: string };
+export type AttendeeEntry = {
+  name: string; email: string; phone: string;
+  dateOfBirth?: string; parentName?: string; parentEmail?: string; parentPhone?: string;
+};
 export type AttendeeEntries = Record<string, AttendeeEntry>;
 export type TicketDelivery = "payer" | "each";
 
-export type AttendeePayload = { eventOptionId: string; variantId?: string | null; name: string; email?: string; phone?: string };
+export type AttendeePayload = {
+  eventOptionId: string; variantId?: string | null; name: string; email?: string; phone?: string;
+  dateOfBirth?: string; parentName?: string; parentEmail?: string; parentPhone?: string;
+};
+
+/** Under 18 on the event's start date (mirrors backend utils/consent.js isMinor). */
+export function isMinorOn(dateOfBirth: string | undefined, eventStart: string | undefined): boolean {
+  if (!dateOfBirth || !eventStart) return false;
+  const dob = new Date(dateOfBirth);
+  const on = new Date(eventStart);
+  if (isNaN(dob.getTime()) || isNaN(on.getTime())) return false;
+  let age = on.getUTCFullYear() - dob.getUTCFullYear();
+  if (on.getUTCMonth() < dob.getUTCMonth() || (on.getUTCMonth() === dob.getUTCMonth() && on.getUTCDate() < dob.getUTCDate())) age -= 1;
+  return age < 18;
+}
 
 type Slot = { key: string; eventOptionId: string; variantId: string | null; label: string };
 
@@ -49,9 +66,29 @@ export function attendeesPayload(options: AttendeeOption[], qtyFor: (optionId: s
       name: e.name.trim(),
       ...(e.email.trim() ? { email: e.email.trim() } : {}),
       ...(e.phone.trim() ? { phone: e.phone.trim() } : {}),
+      ...(e.dateOfBirth ? { dateOfBirth: e.dateOfBirth } : {}),
+      ...(e.parentName?.trim() ? { parentName: e.parentName.trim() } : {}),
+      ...(e.parentEmail?.trim() ? { parentEmail: e.parentEmail.trim() } : {}),
+      ...(e.parentPhone?.trim() ? { parentPhone: e.parentPhone.trim() } : {}),
     }));
 }
 
+/**
+ * Youth events: what's still missing before registering (every place named with a date of
+ * birth; parent details for minors). Empty when everything's in.
+ */
+export function consentDetailsMissing(options: AttendeeOption[], qtyFor: (optionId: string, variantId: string | null) => number, entries: AttendeeEntries, eventStart: string): string | null {
+  for (const s of slotsFor(options, qtyFor)) {
+    const e = entries[s.key];
+    if (!e?.name.trim()) return `Add a name for ${s.label}.`;
+    if (!e.dateOfBirth) return `Add a date of birth for ${e.name.trim()}.`;
+    if (isMinorOn(e.dateOfBirth, eventStart) && (!e.parentName?.trim() || !e.parentEmail?.trim() || !e.parentPhone?.trim())) {
+      return `${e.name.trim()} is under 18 — add a parent or guardian's name, email and phone.`;
+    }
+  }
+  return null;
+}
+
 /**
  * "Registering for other people?" — a name (and optional email/phone) for each main
  * ticket place, plus who gets the tickets. Named places get their own ticket; any left
@@ -67,6 +104,7 @@ export function AttendeeNamesEditor({
   delivery,
   onDeliveryChange,
   payerLabel = "me",
+  consentEventStart,
 }: {
   options: AttendeeOption[];
   qtyFor: (optionId: string, variantId: string | null) => number;
@@ -77,28 +115,40 @@ export function AttendeeNamesEditor({
   delivery: TicketDelivery;
   onDeliveryChange: (v: TicketDelivery) => void;
   payerLabel?: string;
+  /** Set for youth events: names are required, with a date of birth, and parent details for minors. */
+  consentEventStart?: string;
 }) {
+  const consent = !!consentEventStart;
   const slots = slotsFor(options, qtyFor);
   const set = (key: string, field: keyof AttendeeEntry, value: string) => {
-    const prev = entries[key] || { name: "", email: "", phone: "" };
+    const prev: AttendeeEntry = entries[key] || { name: "", email: "", phone: "" };
     onEntriesChange({ ...entries, [key]: { ...prev, [field]: value } });
   };
   const inputCls = "w-full border rounded-lg px-3 py-2 text-sm focus:outline-none focus:ring-2 focus:ring-brand-400";
 
   return (
     <div className="border rounded-xl p-4 bg-white shadow-sm">
-      <label className="flex items-center gap-2 text-sm font-medium text-gray-800 cursor-pointer">
-        <input type="checkbox" checked={enabled} onChange={e => onEnabledChange(e.target.checked)} />
-        <Users className="w-4 h-4 text-brand-600" />
-        Registering for other people?
-      </label>
-      {enabled && (
+      {consent ? (
+        <div>
+          <div className="flex items-center gap-2 text-sm font-medium text-gray-800">
+            <Users className="w-4 h-4 text-brand-600" /> Who&apos;s coming?
+          </div>
+          <p className="text-xs text-gray-500 mt-1">This is a youth event: add each person&apos;s name and date of birth. For anyone under 18, a parent or guardian will be asked to give consent by email and WhatsApp before they can be checked in.</p>
+        </div>
+      ) : (
+        <label className="flex items-center gap-2 text-sm font-medium text-gray-800 cursor-pointer">
+          <input type="checkbox" checked={enabled} onChange={e => onEnabledChange(e.target.checked)} />
+          <Users className="w-4 h-4 text-brand-600" />
+          Registering for other people?
+        </label>
+      )}
+      {(enabled || consent) && (
         <div className="mt-3 space-y-3">
           {slots.length === 0 ? (
             <p className="text-sm text-gray-500">Choose how many tickets first, then add a name for each person.</p>
           ) : (
             <>
-              <p className="text-xs text-gray-500">Each named person gets their own ticket and their own attendee form. Leave a name blank to keep that ticket with the others.</p>
+              {!consent && <p className="text-xs text-gray-500">Each named person gets their own ticket and their own attendee form. Leave a name blank to keep that ticket with the others.</p>}
               {slots.map(s => {
                 const e = entries[s.key] || { name: "", email: "", phone: "" };
                 return (
@@ -109,6 +159,22 @@ export function AttendeeNamesEditor({
                       <input type="email" className={inputCls} placeholder="Email (optional)" value={e.email} onChange={ev => set(s.key, "email", ev.target.value)} aria-label={`${s.label} email`} />
                       <input type="tel" className={inputCls} placeholder="Phone (optional)" value={e.phone} onChange={ev => set(s.key, "phone", ev.target.value)} aria-label={`${s.label} phone`} />
                     </div>
+                    {consent && (
+                      <div className="mt-2">
+                        <label className="block text-xs text-gray-600 mb-1">Date of birth</label>
+                        <input type="date" className={`${inputCls} sm:w-48`} value={e.dateOfBirth || ""} max={new Date().toISOString().slice(0, 10)} onChange={ev => set(s.key, "dateOfBirth", ev.target.value)} aria-label={`${s.label} date of birth`} />
+                        {isMinorOn(e.dateOfBirth, consentEventStart) && (
+                          <div className="mt-2 rounded-lg bg-amber-50 border border-amber-200 p-2">
+                            <div className="text-xs font-medium text-amber-900 mb-1">Parent or guardian (they&apos;ll be asked for consent)</div>
+                            <div className="grid grid-cols-1 sm:grid-cols-3 gap-2">
+                              <input className={inputCls} placeholder="Parent/guardian name" value={e.parentName || ""} onChange={ev => set(s.key, "parentName", ev.target.value)} aria-label={`${s.label} parent name`} />
+                              <input type="email" className={inputCls} placeholder="Parent email" value={e.parentEmail || ""} onChange={ev => set(s.key, "parentEmail", ev.target.value)} aria-label={`${s.label} parent email`} />
+                              <input type="tel" className={inputCls} placeholder="Parent phone" value={e.parentPhone || ""} onChange={ev => set(s.key, "parentPhone", ev.target.value)} aria-label={`${s.label} parent phone`} />
+                            </div>
+                          </div>
+                        )}
+                      </div>
+                    )}
                   </div>
                 );
               })}

frontend/src/components/shared/AttendeesPanel.tsx

@@ -3,9 +3,24 @@
 import React, { useMemo, useState } from "react";
 import { Users, Send } from "lucide-react";
 import { apiFetch } from "@/lib/api";
+import { isMinorOn } from "@/components/shared/AttendeeNamesEditor";
 
-type Attendee = { id: string; eventOptionId: string; variantId: string | null; name: string; email: string | null; phone: string | null; ticket?: { id: string; isUsed: boolean } | null };
-type Row = { id?: string; eventOptionId: string; variantId: string | null; label: string; name: string; email: string; phone: string; locked: boolean };
+const CONSENT_LABEL: Record<string, { text: string; cls: string }> = {
+  pending: { text: "consent pending", cls: "text-amber-700" },
+  given: { text: "consent given", cls: "text-green-700" },
+  declined: { text: "consent declined", cls: "text-red-700" },
+};
+
+type Attendee = {
+  id: string; eventOptionId: string; variantId: string | null; name: string; email: string | null; phone: string | null;
+  dateOfBirth?: string | null; parentName?: string | null; parentEmail?: string | null; parentPhone?: string | null;
+  ticket?: { id: string; isUsed: boolean } | null;
+  consentRequests?: { id: string; status: "pending" | "given" | "declined" }[];
+};
+type Row = {
+  id?: string; eventOptionId: string; variantId: string | null; label: string; name: string; email: string; phone: string; locked: boolean;
+  dateOfBirth: string; parentName: string; parentEmail: string; parentPhone: string;
+};
 
 /**
  * Named attendees on a registration (group tickets): shows who each main-ticket place
@@ -21,6 +36,8 @@ export function AttendeesPanel({ registration, token, canEdit, hasForm, onSaved,
   onMessage: (msg: string) => void;
 }) {
   const attendees: Attendee[] = registration.attendees || [];
+  const youth = !!registration.event?.requiresParentalConsent;
+  const eventStart: string | undefined = registration.event?.startDate;
   const [editing, setEditing] = useState(false);
   const [rows, setRows] = useState<Row[]>([]);
   const [delivery, setDelivery] = useState<"payer" | "each">(registration.ticketDelivery || "payer");
@@ -39,6 +56,8 @@ export function AttendeesPanel({ registration, token, canEdit, hasForm, onSaved,
         out.push({
           id: a?.id, eventOptionId: ro.eventOptionId, variantId: ro.variantId || null, label: `${label} ${i + 1}`,
           name: a?.name || "", email: a?.email || "", phone: a?.phone || "",
+          dateOfBirth: a?.dateOfBirth ? String(a.dateOfBirth).slice(0, 10) : "",
+          parentName: a?.parentName || "", parentEmail: a?.parentEmail || "", parentPhone: a?.parentPhone || "",
           locked: !!a?.ticket?.isUsed,
         });
       }
@@ -46,10 +65,11 @@ export function AttendeesPanel({ registration, token, canEdit, hasForm, onSaved,
     return out;
   }, [registration, attendees]);
 
-  if (!registration.event?.allowNamedAttendees && attendees.length === 0) return null;
+  if (!registration.event?.allowNamedAttendees && !youth && attendees.length === 0) return null;
 
   const startEdit = () => { setRows(buildRows()); setDelivery(registration.ticketDelivery || "payer"); setError(null); setEditing(true); };
-  const update = (i: number, field: "name" | "email" | "phone", value: string) => setRows(prev => prev.map((r, j) => (j === i ? { ...r, [field]: value } : r)));
+  const update = (i: number, field: "name" | "email" | "phone" | "dateOfBirth" | "parentName" | "parentEmail" | "parentPhone", value: string) =>
+    setRows(prev => prev.map((r, j) => (j === i ? { ...r, [field]: value } : r)));
 
   const save = async () => {
     setBusy(true);
@@ -67,6 +87,10 @@ export function AttendeesPanel({ registration, token, canEdit, hasForm, onSaved,
             name: r.name.trim(),
             email: r.email.trim() || undefined,
             phone: r.phone.trim() || undefined,
+            ...(r.dateOfBirth ? { dateOfBirth: r.dateOfBirth } : {}),
+            ...(r.parentName.trim() ? { parentName: r.parentName.trim() } : {}),
+            ...(r.parentEmail.trim() ? { parentEmail: r.parentEmail.trim() } : {}),
+            ...(r.parentPhone.trim() ? { parentPhone: r.parentPhone.trim() } : {}),
           })),
         },
       });
@@ -91,6 +115,15 @@ export function AttendeesPanel({ registration, token, canEdit, hasForm, onSaved,
 
   const answered = new Set((registration.formResponses || []).map((r: any) => r.attendeeId).filter(Boolean));
 
+  const resendConsent = async (requestId: string) => {
+    try {
+      const res = await apiFetch<{ message: string }>(`/api/consent/requests/${encodeURIComponent(requestId)}/resend`, { method: "POST", authToken: token });
+      onMessage(res.message);
+    } catch (e: any) {
+      setError(e?.message || "Couldn't re-send the consent request");
+    }
+  };
+
   return (
     <div>
       <div className="font-medium mb-1 flex items-center justify-between">
@@ -112,7 +145,13 @@ export function AttendeesPanel({ registration, token, canEdit, hasForm, onSaved,
                     {a.name}
                     {(a.email || a.phone) && <span className="text-xs text-gray-500"> · {[a.email, a.phone].filter(Boolean).join(" · ")}</span>}
                     {hasForm && <span className={`ml-2 text-xs ${answered.has(a.id) ? "text-green-700" : "text-amber-700"}`}>{answered.has(a.id) ? "form done" : "form to do"}</span>}
+                    {youth && a.consentRequests?.[0] && (
+                      <span className={`ml-2 text-xs ${CONSENT_LABEL[a.consentRequests[0].status]?.cls}`}>{CONSENT_LABEL[a.consentRequests[0].status]?.text}</span>
+                    )}
                   </span>
+                  {canEdit && youth && a.consentRequests?.[0]?.status === "pending" && (
+                    <button onClick={() => resendConsent(a.consentRequests![0].id)} className="text-xs text-brand-700 hover:underline shrink-0 inline-flex items-center gap-1"><Send className="w-3 h-3" /> Resend consent</button>
+                  )}
                   {canEdit && hasForm && !answered.has(a.id) && (a.email || a.phone) && (
                     <button onClick={() => sendLink(a)} className="text-xs text-brand-700 hover:underline shrink-0 inline-flex items-center gap-1"><Send className="w-3 h-3" /> Send form link</button>
                   )}
@@ -132,6 +171,18 @@ export function AttendeesPanel({ registration, token, canEdit, hasForm, onSaved,
                 <input className="border rounded px-2 py-1 text-sm" placeholder="Email (optional)" value={r.email} disabled={r.locked} onChange={e => update(i, "email", e.target.value)} aria-label={`${r.label} email`} />
                 <input className="border rounded px-2 py-1 text-sm" placeholder="Phone (optional)" value={r.phone} disabled={r.locked} onChange={e => update(i, "phone", e.target.value)} aria-label={`${r.label} phone`} />
               </div>
+              {youth && (
+                <div className="mt-1 space-y-1">
+                  <input type="date" className="border rounded px-2 py-1 text-sm" value={r.dateOfBirth} disabled={r.locked} onChange={e => update(i, "dateOfBirth", e.target.value)} aria-label={`${r.label} date of birth`} />
+                  {isMinorOn(r.dateOfBirth, eventStart) && (
+                    <div className="grid grid-cols-1 sm:grid-cols-3 gap-2">
+                      <input className="border rounded px-2 py-1 text-sm" placeholder="Parent/guardian name" value={r.parentName} disabled={r.locked} onChange={e => update(i, "parentName", e.target.value)} aria-label={`${r.label} parent name`} />
+                      <input className="border rounded px-2 py-1 text-sm" placeholder="Parent email" value={r.parentEmail} disabled={r.locked} onChange={e => update(i, "parentEmail", e.target.value)} aria-label={`${r.label} parent email`} />
+                      <input className="border rounded px-2 py-1 text-sm" placeholder="Parent phone" value={r.parentPhone} disabled={r.locked} onChange={e => update(i, "parentPhone", e.target.value)} aria-label={`${r.label} parent phone`} />
+                    </div>
+                  )}
+                </div>
+              )}
             </div>
           ))}
           <div className="text-sm pt-1">

frontend/src/components/shared/MyWaitlists.tsx

@@ -0,0 +1,63 @@
+"use client";
+
+import React, { useCallback, useEffect, useState } from "react";
+import { ListChecks } from "lucide-react";
+import { apiFetch } from "@/lib/api";
+
+type Entry = {
+  id: string;
+  status: "waiting" | "offered";
+  quantity: number;
+  offeredQuantity: number | null;
+  offerExpiresAt: string | null;
+  event: { id: string; title: string; startDate: string };
+  eventOption: { name: string };
+  variant: { name: string } | null;
+};
+
+/** My Events: the waitlists I'm on, with Leave (and a note when a place is on offer). */
+export function MyWaitlists({ token, onMessage }: { token: string; onMessage: (m: string) => void }) {
+  const [entries, setEntries] = useState<Entry[]>([]);
+  const load = useCallback(() => {
+    apiFetch<Entry[]>("/api/waitlist/mine", { authToken: token }).then(setEntries).catch(() => setEntries([]));
+  }, [token]);
+  useEffect(() => { load(); }, [load]);
+
+  if (entries.length === 0) return null;
+
+  const leave = async (id: string) => {
+    try {
+      const res = await apiFetch<{ message: string }>(`/api/waitlist/${encodeURIComponent(id)}`, { method: "DELETE", authToken: token });
+      onMessage(res.message);
+      load();
+    } catch (e: any) {
+      onMessage(e?.message || "Couldn't leave the waitlist");
+    }
+  };
+
+  return (
+    <section className="border rounded-xl p-4 bg-white shadow-sm">
+      <div className="flex items-center gap-2 font-semibold text-gray-900 mb-2">
+        <ListChecks className="w-4 h-4 text-brand-600" /> Waitlists
+      </div>
+      <ul className="divide-y">
+        {entries.map(e => (
+          <li key={e.id} className="py-2 flex items-center justify-between gap-3 text-sm">
+            <div>
+              <div className="font-medium">{e.event.title}</div>
+              <div className="text-xs text-gray-500">{e.quantity} × {e.eventOption.name}{e.variant ? ` (${e.variant.name})` : ""}</div>
+              {e.status === "offered" ? (
+                <div className="text-xs text-green-700 mt-0.5">
+                  {e.offeredQuantity} place(s) held for you until {e.offerExpiresAt ? new Date(e.offerExpiresAt).toLocaleString() : ""} — use the link we sent you to claim.
+                </div>
+              ) : (
+                <div className="text-xs text-gray-500 mt-0.5">Waiting — we&apos;ll email or WhatsApp you if a place opens up.</div>
+              )}
+            </div>
+            <button onClick={() => leave(e.id)} className="px-2.5 py-1 text-xs rounded border hover:bg-gray-50 shrink-0">Leave</button>
+          </li>
+        ))}
+      </ul>
+    </section>
+  );
+}

frontend/src/content/help/event-detail.tsx

@@ -23,10 +23,10 @@ export const eventDetailHelpContent: HelpContent = {
               If a discounted price is shown with the original struck through, an early-bird window is active — the price rises automatically once it ends. Got a discount code? Enter it on the registration page under "Have a code?" (you need to be logged in).
             </GuideItem>
             <GuideItem icon={Ticket} title="Availability badges" tone="brand">
-              &quot;N remaining&quot; appears once stock runs low, and &quot;Sold out&quot; once an option is fully booked.
+              &quot;N remaining&quot; appears once stock runs low, and &quot;Sold out&quot; once an option is fully booked. Some events have a waitlist: tap &quot;Join waitlist&quot; and you&apos;ll be emailed or WhatsApped a link to claim a place if one opens up (it&apos;s held for you for a limited time).
             </GuideItem>
             <GuideItem icon={Users} title="Registering for other people?" tone="violet">
-              Some events let you name each person you&apos;re booking for. Each named person gets their own ticket and their own attendee form, and you can choose to have every ticket sent to you or each person their own.
+              Some events let you name each person you&apos;re booking for. Each named person gets their own ticket and their own attendee form, and you can choose to have every ticket sent to you or each person their own. On youth events, you&apos;ll give each person&apos;s date of birth; for anyone under 18, their parent or guardian is asked to give consent by email and WhatsApp before they can be checked in.
             </GuideItem>
           </div>
         </div>

frontend/src/content/help/registry.ts

@@ -22,6 +22,9 @@ import { supervisorAtTheDoorHelpContent } from "./supervisor-at-the-door";
 import { supervisorPaymentsHelpContent } from "./supervisor-payments";
 import { supervisorFormsHelpContent } from "./supervisor-forms";
 import { supervisorCouponsHelpContent } from "./supervisor-coupons";
+import { supervisorConsentHelpContent } from "./supervisor-consent";
+import { supervisorWaitlistHelpContent } from "./supervisor-waitlist";
+import { supervisorOfflineScansHelpContent } from "./supervisor-offline-scans";
 import { supervisorEmailAttendeesHelpContent } from "./supervisor-email-attendees";
 import { supervisorWhatsappAttendeesHelpContent } from "./supervisor-whatsapp-attendees";
 import { staffEventTicketsHelpContent } from "./staff-event-tickets";
@@ -148,6 +151,21 @@ const REGISTRY: HelpRegistryEntry[] = [
     matches: pathname => pathname === "/dashboard/supervisor/payments",
     content: supervisorPaymentsHelpContent,
   },
+  {
+    slug: "supervisor-offline-scans",
+    matches: pathname => pathname === "/dashboard/supervisor/offline-scans",
+    content: supervisorOfflineScansHelpContent,
+  },
+  {
+    slug: "supervisor-waitlist",
+    matches: pathname => pathname === "/dashboard/supervisor/waitlist",
+    content: supervisorWaitlistHelpContent,
+  },
+  {
+    slug: "supervisor-consent",
+    matches: pathname => pathname === "/dashboard/supervisor/consent",
+    content: supervisorConsentHelpContent,
+  },
   {
     slug: "supervisor-coupons",
     matches: pathname => pathname === "/dashboard/supervisor/coupons",

frontend/src/content/help/staff-ticket-scanning.tsx

@@ -1,5 +1,5 @@
 import React from "react";
-import { QrCode, Filter, CheckCircle2 } from "lucide-react";
+import { QrCode, Filter, CheckCircle2, ShieldAlert, WifiOff } from "lucide-react";
 import { GuideItem } from "@/components/shared/GuideItem";
 import type { HelpContent } from "./types";
 
@@ -19,6 +19,12 @@ export const staffTicketScanningHelpContent: HelpContent = {
             <GuideItem icon={CheckCircle2} title="Outcomes" tone="green">
               You&apos;ll see Success (with redeemed/remaining counts), Already Used, or an Error if something&apos;s wrong with the ticket.
             </GuideItem>
+            <GuideItem icon={WifiOff} title="Offline mode" tone="amber">
+              Worried about the venue Wi-Fi? While you&apos;re online, pick the event and section and tap &quot;Enable offline mode&quot;. The section is locked to your device and its tickets are downloaded, so you can keep scanning with no connection. Scans sync automatically when you&apos;re back online. Tickets bought after the download won&apos;t be on your list — send those people to the door desk. Tap &quot;Release section&quot; when you&apos;re done. Tip: add this page to your home screen so it opens offline.
+            </GuideItem>
+            <GuideItem icon={ShieldAlert} title="Parental consent" tone="rose">
+              On youth events, the confirm screen warns when a parent hasn&apos;t given consent yet (or declined). That person can&apos;t be checked in; a supervisor can override, and the override is recorded in the audit log.
+            </GuideItem>
           </div>
         </div>
       ),

frontend/src/content/help/supervisor-consent.tsx

@@ -0,0 +1,58 @@
+import React from "react";
+import { ShieldCheck, Send, RefreshCw, HeartPulse, Ban, Clock, QrCode } from "lucide-react";
+import { GuideItem } from "@/components/shared/GuideItem";
+import type { HelpContent } from "./types";
+
+/** Help content for /dashboard/supervisor/consent. */
+export const supervisorConsentHelpContent: HelpContent = {
+  title: "Parental consent",
+  subtitle: "Youth events: who still needs a parent's consent before check-in.",
+  tabs: [
+    {
+      key: "how",
+      label: "How it works",
+      icon: ShieldCheck,
+      content: (
+        <div className="space-y-4">
+          <div className="space-y-4">
+            <GuideItem icon={ShieldCheck} title="Turning it on" tone="brand">
+              In the event wizard&apos;s Visibility step, tick &quot;Requires parental consent&quot;, write the consent text, and choose whether to ask for medical info, an emergency contact and photo consent.
+            </GuideItem>
+            <GuideItem icon={Send} title="Requests" tone="green">
+              Everyone registering gives a date of birth for each attendee. For anyone under 18 on the event&apos;s start date, the parent or guardian is sent a consent link by email and WhatsApp. They read the text, fill in any medical details, type their name to sign, and give or decline consent.
+            </GuideItem>
+            <GuideItem icon={Clock} title="Reminders" tone="amber">
+              Unanswered requests are reminded automatically 2 days later, then every 3 days until the event. Links stop working when the event ends.
+            </GuideItem>
+            <GuideItem icon={QrCode} title="At check-in" tone="rose">
+              Tickets are sent as normal, but the scanner won&apos;t check someone in until consent is given. Supervisors can override, which is recorded in the audit log.
+            </GuideItem>
+            <GuideItem icon={Ban} title="Declined" tone="gray">
+              The registrant and the event&apos;s notification recipients are told. The registration stays, but can&apos;t be checked in — handle any refund from Payments.
+            </GuideItem>
+          </div>
+        </div>
+      ),
+    },
+    {
+      key: "tools",
+      label: "This page",
+      icon: RefreshCw,
+      content: (
+        <div className="space-y-4">
+          <div className="space-y-4">
+            <GuideItem icon={Send} title="Resend" tone="brand">
+              Resend one request, or every pending one at once. Each resend issues a new link; old links stop working.
+            </GuideItem>
+            <GuideItem icon={RefreshCw} title="Re-request consent" tone="violet">
+              If you change the consent text, parents who already agreed keep their record of the old version. &quot;Re-request consent&quot; asks them again on the new text, and also sends requests to under-18s who never got one (for example, names added later).
+            </GuideItem>
+            <GuideItem icon={HeartPulse} title="Medical & emergency list" tone="rose">
+              A printable, confidential list for camp leaders, for attendees whose consent has been given. Every time it&apos;s opened is recorded in the audit log. Medical details are deleted a set number of days after the event (Site Settings → Legal).
+            </GuideItem>
+          </div>
+        </div>
+      ),
+    },
+  ],
+};

frontend/src/content/help/supervisor-events.tsx

@@ -44,7 +44,7 @@ export const supervisorEventsHelpContent: HelpContent = {
               Build a custom registration form — text, number, date, yes/no, statement, and heading fields, reorderable, optionally required before tickets are generated.
             </GuideItem>
             <GuideItem icon={Eye} title="Visibility" tone="gray">
-              Hide the event, allow guest (no-account) registration, turn on named attendees (group tickets — each named person gets their own ticket and form), or toggle it active.
+              Hide the event, allow guest (no-account) registration, turn on named attendees (group tickets — each named person gets their own ticket and form), make it a youth event that needs parental consent for under-18s, turn on a waitlist for sold-out tickets, or toggle it active.
             </GuideItem>
             <GuideItem icon={Bell} title="Notifications" tone="blue">
               Choose which staff get registration, payment, and daily-summary emails for this event.

frontend/src/content/help/supervisor-offline-scans.tsx

@@ -0,0 +1,32 @@
+import React from "react";
+import { WifiOff, Unlock, CheckCircle2, Lock } from "lucide-react";
+import { GuideItem } from "@/components/shared/GuideItem";
+import type { HelpContent } from "./types";
+
+/** Help content for /dashboard/supervisor/offline-scans. */
+export const supervisorOfflineScansHelpContent: HelpContent = {
+  title: "Offline scanning",
+  subtitle: "Devices scanning without a connection, and what they synced.",
+  tabs: [
+    {
+      key: "page",
+      label: "This page",
+      icon: WifiOff,
+      content: (
+        <div className="space-y-4">
+          <div className="space-y-4">
+            <GuideItem icon={Lock} title="Locked sections" tone="brand">
+              Each section (or the whole event) in offline mode is locked to one device, so two devices can never check in the same ticket while offline. You can see who holds each lock, when their ticket list was downloaded, and when they last synced.
+            </GuideItem>
+            <GuideItem icon={Unlock} title="Force release" tone="amber">
+              For a lost or flat device. The section is unlocked straight away. If the device reconnects later, its offline scans still sync and are flagged here.
+            </GuideItem>
+            <GuideItem icon={CheckCircle2} title="Sync reports" tone="rose">
+              Scans that need a person to look: tickets not found (e.g. transferred), cancelled registrations, tickets already used up, scans outside the locked section, or check-ins without parental consent. Mark each report reviewed once it&apos;s been dealt with.
+            </GuideItem>
+          </div>
+        </div>
+      ),
+    },
+  ],
+};

frontend/src/content/help/supervisor-waitlist.tsx

@@ -0,0 +1,56 @@
+import React from "react";
+import { ListChecks, Send, Clock, ArrowUpDown, UserMinus, Settings } from "lucide-react";
+import { GuideItem } from "@/components/shared/GuideItem";
+import type { HelpContent } from "./types";
+
+/** Help content for /dashboard/supervisor/waitlist. */
+export const supervisorWaitlistHelpContent: HelpContent = {
+  title: "Waitlist",
+  subtitle: "People waiting for sold-out tickets.",
+  tabs: [
+    {
+      key: "how",
+      label: "How it works",
+      icon: ListChecks,
+      content: (
+        <div className="space-y-4">
+          <div className="space-y-4">
+            <GuideItem icon={Settings} title="Turning it on" tone="brand">
+              In the event wizard&apos;s Visibility step, tick &quot;Waitlist for sold-out tickets&quot;, set how long offered places are held (24 hours by default), and whether someone can be offered fewer places than they asked for.
+            </GuideItem>
+            <GuideItem icon={ListChecks} title="Joining" tone="green">
+              When a ticket is sold out, the event and registration pages show &quot;Join waitlist&quot;. People pick the ticket and how many, and can leave again from My Events.
+            </GuideItem>
+            <GuideItem icon={Send} title="Offers" tone="violet">
+              When places free up — a cancellation, a smaller booking, or a higher stock limit — the next person in line is emailed or WhatsApped a claim link. The places are held for them, so nobody else can buy them in the meantime.
+            </GuideItem>
+            <GuideItem icon={Clock} title="Expiry" tone="amber">
+              If the offer isn&apos;t claimed in time, it expires and the places go to the next person. Claiming goes through normal registration and payment, with early-bird and coupon rules as usual.
+            </GuideItem>
+          </div>
+        </div>
+      ),
+    },
+    {
+      key: "tools",
+      label: "This page",
+      icon: ArrowUpDown,
+      content: (
+        <div className="space-y-4">
+          <div className="space-y-4">
+            <GuideItem icon={Send} title="Offer place" tone="brand">
+              Send someone an offer straight away, even if no place has freed up (this can take the event over its stock limit).
+            </GuideItem>
+            <GuideItem icon={ArrowUpDown} title="Reorder" tone="green">
+              Move someone up or down the queue.
+            </GuideItem>
+            <GuideItem icon={UserMinus} title="Remove" tone="rose">
+              Take someone off the waitlist. If they were holding an offer, it goes to the next person.
+            </GuideItem>
+          </div>
+          <p className="text-xs text-gray-500">The daily summary email shows how many people are on each event&apos;s waitlist.</p>
+        </div>
+      ),
+    },
+  ],
+};

frontend/src/contexts/AuthContext.tsx

@@ -18,6 +18,25 @@ export type AuthContextValue = {
 
 const AuthContext = createContext<AuthContextValue | undefined>(undefined);
 
+// The last profile the server confirmed, so a page reloaded with no connection (e.g. the
+// ticket scanner in offline mode) still knows who's signed in. The server checks the
+// token on every API call regardless, so this never grants anything by itself.
+const USER_CACHE_KEY = "hope_events_user_cache";
+function cacheUser(u: AuthUser | null) {
+  try {
+    if (u) localStorage.setItem(USER_CACHE_KEY, JSON.stringify(u));
+    else localStorage.removeItem(USER_CACHE_KEY);
+  } catch { /* storage unavailable */ }
+}
+function cachedUser(): AuthUser | null {
+  try {
+    const raw = localStorage.getItem(USER_CACHE_KEY);
+    return raw ? JSON.parse(raw) : null;
+  } catch {
+    return null;
+  }
+}
+
 export function AuthProvider({ children }: { children: React.ReactNode }) {
   const [token, setToken] = useState<string | null>(null);
   const [user, setUser] = useState<AuthUser | null>(null);
@@ -34,6 +53,7 @@ export function AuthProvider({ children }: { children: React.ReactNode }) {
           const me = await apiFetch<AuthUser>("/api/users/profile", { authToken: t });
           setToken(t);
           setUser(me);
+          cacheUser(me);
         }
       } catch (e) {
         // Only wipe the stored token when the server explicitly rejects it (401).
@@ -41,8 +61,17 @@ export function AuthProvider({ children }: { children: React.ReactNode }) {
         // token stays in localStorage so the next page load can retry.
         if (e instanceof ApiError && e.status === 401) {
           clearToken();
+          cacheUser(null);
           setToken(null);
           setUser(null);
+        } else {
+          // No connection: carry on as the last confirmed user.
+          const t = getToken();
+          const cached = cachedUser();
+          if (t && cached) {
+            setToken(t);
+            setUser(cached);
+          }
         }
       } finally {
         setLoading(false);
@@ -57,6 +86,7 @@ export function AuthProvider({ children }: { children: React.ReactNode }) {
     saveToken(token);
     setToken(token);
     setUser(loggedInUser);
+    cacheUser(loggedInUser);
     return loggedInUser;
   }, []);
 
@@ -99,6 +129,7 @@ export function AuthProvider({ children }: { children: React.ReactNode }) {
 
   const logout = useCallback(() => {
     clearToken();
+    cacheUser(null);
     setToken(null);
     setUser(null);
   }, []);

frontend/src/lib/api.ts

@@ -121,6 +121,7 @@ export async function apiFetch<T = any>(path: string, options: ApiOptions = {}):
     // end it and send them to log in, where they enrol.
     if (res.status === 401 && data?.code === "TWO_FACTOR_REQUIRED" && typeof window !== "undefined") {
       localStorage.removeItem("hope_events_token");
+      localStorage.removeItem("hope_events_user_cache");
       if (!window.location.pathname.startsWith("/login")) {
         const back = window.location.pathname + window.location.search;
         window.location.href = `/login?reason=2fa&redirect=${encodeURIComponent(back)}`;

frontend/src/lib/offlineScan.ts

@@ -0,0 +1,130 @@
+"use client";
+
+/**
+ * Offline scanning on this device: the ticket snapshot for a locked section and the
+ * queue of scans waiting to sync, both kept in IndexedDB (via `idb`). The active lock
+ * itself is in localStorage so the scanner page knows it's in offline mode after a
+ * reload with no connection.
+ */
+import { openDB, type IDBPDatabase } from "idb";
+
+export type SnapshotTicket = {
+  id: string;
+  qrCode: string;
+  holder: string;
+  bookedBy: string;
+  option: string;
+  variant: string | null;
+  quantity: number;
+  remaining: number;
+  consentStatus: string;
+};
+
+export type QueuedScan = { clientScanId: string; lockId: string; qrCode: string; qty: number; scannedAt: string };
+
+export type OfflineLock = {
+  lockId: string;
+  eventId: string;
+  eventTitle: string;
+  sectionId: string | null;
+  sectionName: string | null;
+  snapshotAt: string;
+};
+
+const DB_NAME = "hope-events-offline-scan";
+const LOCK_KEY = "hope_events_offline_lock";
+const DEVICE_KEY = "hope_events_scan_device";
+
+let dbPromise: Promise<IDBPDatabase> | null = null;
+function db() {
+  if (!dbPromise) {
+    dbPromise = openDB(DB_NAME, 1, {
+      upgrade(d) {
+        d.createObjectStore("tickets", { keyPath: "qrCode" });
+        d.createObjectStore("queue", { keyPath: "clientScanId" });
+      },
+    });
+  }
+  return dbPromise;
+}
+
+/** A stable id for this browser, used to tie an offline lock to one device. */
+export function deviceId(): string {
+  try {
+    let id = localStorage.getItem(DEVICE_KEY);
+    if (!id) {
+      id = crypto.randomUUID();
+      localStorage.setItem(DEVICE_KEY, id);
+    }
+    return id;
+  } catch {
+    return "unknown-device";
+  }
+}
+
+/** A short, human name for this device ("Chrome on Android"). */
+export function deviceName(): string {
+  const ua = typeof navigator !== "undefined" ? navigator.userAgent : "";
+  const browser = /Edg\//.test(ua) ? "Edge" : /Chrome\//.test(ua) ? "Chrome" : /Firefox\//.test(ua) ? "Firefox" : /Safari\//.test(ua) ? "Safari" : "Browser";
+  const os = /Android/.test(ua) ? "Android" : /iPhone|iPad/.test(ua) ? "iOS" : /Windows/.test(ua) ? "Windows" : /Mac OS/.test(ua) ? "Mac" : "device";
+  return `${browser} on ${os}`;
+}
+
+export function getOfflineLock(): OfflineLock | null {
+  try {
+    const raw = localStorage.getItem(LOCK_KEY);
+    return raw ? JSON.parse(raw) : null;
+  } catch {
+    return null;
+  }
+}
+
+function setOfflineLock(lock: OfflineLock | null) {
+  try {
+    if (lock) localStorage.setItem(LOCK_KEY, JSON.stringify(lock));
+    else localStorage.removeItem(LOCK_KEY);
+  } catch { /* storage unavailable */ }
+}
+
+/** Keeps the downloaded ticket list and marks this device as in offline mode. */
+export async function startOffline(lock: OfflineLock, tickets: SnapshotTicket[]) {
+  const d = await db();
+  const tx = d.transaction("tickets", "readwrite");
+  await tx.store.clear();
+  for (const t of tickets) await tx.store.put(t);
+  await tx.done;
+  setOfflineLock(lock);
+}
+
+export async function findTicket(qrCode: string): Promise<SnapshotTicket | undefined> {
+  return (await db()).get("tickets", qrCode);
+}
+
+/** Records a scan locally: lowers the ticket's remaining count and queues it for sync. */
+export async function recordScan(lockId: string, ticket: SnapshotTicket, qty: number): Promise<QueuedScan> {
+  const d = await db();
+  const scan: QueuedScan = { clientScanId: crypto.randomUUID(), lockId, qrCode: ticket.qrCode, qty, scannedAt: new Date().toISOString() };
+  const tx = d.transaction(["tickets", "queue"], "readwrite");
+  await tx.objectStore("tickets").put({ ...ticket, remaining: Math.max(0, ticket.remaining - qty) });
+  await tx.objectStore("queue").put(scan);
+  await tx.done;
+  return scan;
+}
+
+export async function queuedScans(): Promise<QueuedScan[]> {
+  return (await db()).getAll("queue");
+}
+
+export async function removeQueued(ids: string[]) {
+  const d = await db();
+  const tx = d.transaction("queue", "readwrite");
+  for (const id of ids) await tx.store.delete(id);
+  await tx.done;
+}
+
+/** Ends offline mode on this device: the ticket list is deleted (the queue must be empty). */
+export async function clearOffline() {
+  const d = await db();
+  await d.clear("tickets");
+  setOfflineLock(null);
+}

info.md

@@ -13,6 +13,8 @@ It runs in any web browser — on a phone, tablet, or computer — with nothing
 ### For your congregation
 
 - **Browse events** — a clean, mobile-friendly listing of upcoming events with photos, descriptions, dates, and location (with a map and directions). Fully booked events show a "Sold Out" badge, and popular tickets show how many are left.
+- **Waitlists** — when an event sells out, people can join a waitlist and are offered places automatically as they free up.
+- **Parental consent for youth events** — parents receive an email and WhatsApp to give consent online (with medical details and an emergency contact); children can't be checked in until they have. Reminders go out automatically.
 - **Group bookings** — a parent can register several children at once, naming each one so they get their own ticket and their own form, with the tickets sent to the parent or to each person.
 - **Discount codes** — enter a code for a staff, leader or promotional discount, shown on the invoice and receipt.
 - **Register online** — choose from multiple ticket types (e.g. adult, child, family, dinner, T-shirt sizes) at different prices, including early-bird pricing. People can register as a guest or with an account, depending on how you set up the event.
@@ -28,6 +30,7 @@ It runs in any web browser — on a phone, tablet, or computer — with nothing
 ### For staff on the day
 
 - **QR code scanner** — check people in by scanning their ticket with any phone camera. A single ticket can cover a whole family and be checked in a few people at a time.
+- **Works without Wi-Fi** — lock a check-in point to a phone and keep scanning with no signal; scans sync automatically when the connection is back.
 - **Scan points** — set up separate check-in points (e.g. main hall, dinner) that only accept the right tickets.
 - **At-the-door desk** — search by name, phone, or ticket number; register walk-ins; take cash, card, or EFT payments; check people in; and print or resend tickets on the spot.
 - **Self-service kiosk** — set up a tablet where visitors register themselves. Returning visitors are recognised by their email or phone number.
@@ -42,7 +45,7 @@ It runs in any web browser — on a phone, tablet, or computer — with nothing
 - **Messaging** — send emails or WhatsApp messages to attendees, filtered by who has paid or still owes. Personalise messages with each person's name, balance, or their own payment link. Schedule reminders, thank-you messages, and promotions in advance.
 - **Daily summary** — the event team gets a daily email with registrations, payments, and outstanding balances in the run-up to each event.
 - **Forms** — view, filter, and print attendee form responses.
-- **Reports** — 15 ready-made reports covering payments, revenue, attendees, ticket usage, registration status, donations, discounts, costs, and profit. Each can be printed or exported to PDF, Excel, email, or WhatsApp.
+- **Reports** — 17 ready-made reports covering payments, revenue, attendees, ticket usage, registration status, donations, discounts, parental consent, medical lists, costs, and profit. Each can be printed or exported to PDF, Excel, email, or WhatsApp.
 - **Dashboard** — revenue, donations, registrations, and tickets sold at a glance, compared with the previous month.
 
 ### For administrators and treasurers

package-lock.json

@@ -1,12 +1,12 @@
 {
   "name": "hope-events",
-  "version": "1.14.0",
+  "version": "1.17.0",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
       "name": "hope-events",
-      "version": "1.14.0",
+      "version": "1.17.0",
       "license": "ISC",
       "devDependencies": {
         "concurrently": "^9.2.1"

package.json

@@ -1,6 +1,6 @@
 {
   "name": "hope-events",
-  "version": "1.14.0",
+  "version": "1.17.0",
   "main": "index.js",
   "scripts": {
     "dev:backend": "cd backend && npm run dev",