Merge pull request 'Bump version to 1.5.1' (#169) from release/bump-1.5.1 into main

Reviewed-on: #169

.claude/settings.local.json

@@ -5,7 +5,8 @@
       "Bash(composer lint *)",
       "Bash(tea actions:*)",
       "Bash(tea issue *)",
-      "Bash(tea label *)"
+      "Bash(tea label *)",
+      "Bash(composer cs *)"
     ]
   }
 }

CHANGELOG.md

@@ -11,6 +11,89 @@ When a `v*` tag is pushed, `.gitea/workflows/release.yml` publishes the matching
 the plugin to the next patch version and adds a fresh section here for it. Record
 each change under the current top section as you work.
 
+## [1.5.1]
+
+## [1.5.0]
+
+### Added
+- **A registration question can now be asked of students only, and can be required of a student without being required of the account holder.** Every account-signup question was asked of everybody who registered, on the same terms — so "School and grade" had to be put to the adult signing themselves up, and a question a studio needed answered for a child could only be made required by demanding it of everyone. Each question now says who it is asked of — everyone, or only the students you register on behalf of — and carries its own **Required** setting for each: optional for you, required for every student you enrol, is now a thing a studio can ask for. Existing questions are untouched: they stay asked of everyone, and one that was required stays required of everyone.
+- **You can now edit your own details on the profile page**, not just your students'. The page is called **Your profile**, and until now the one person on it you could not change was yourself: a mistyped name at signup, or a name that had since changed, meant asking the studio to fix it. **Your details** now sits at the top of the page with your name, your birth year, and whether you take lessons yourself. Your email address is shown but not editable — it is also how you sign in, so changing it stays a studio-side job.
+- **"I take lessons myself" can be corrected after signup.** Signup asks whether you are registering just yourself, only on behalf of students, or both, and the answer decides whether you are offered as a student when booking. Choosing wrongly — or taking up lessons later alongside the children you book for — used to leave you asking the studio to change it. Ticking the box makes you bookable again and asks for your birth year like any other student; unticking it takes you back off the list without discarding the birth year you already gave, so ticking it back on costs you nothing.
+
+### Fixed
+- **A recurring lesson now shows the policies the student accepted on every week of it, not just the first.** Booking a weekly lesson reserves a series of them, and the student answers the intake questions and agrees to the studio's policies once, for the whole reservation. Opening any week after the first showed no answers and no policies accepted — as though nothing had been agreed to. Nothing was ever missing: the agreement was recorded against the first lesson of the series and every other week was looking for one of its own. Each week of a series now shows the intake answers and the full acceptance record — policy, version, when it was accepted, and from where — captured when the reservation was booked. Existing bookings read correctly straight away; there is nothing to re-collect from anyone.
+
+## [1.4.1]
+
+### Added
+- **Group classes now appear in "Your upcoming lessons".** A class is stored as a term rather than as bookable slots, so nothing that listed lessons could ever show one — a student whose whole term was a group class saw an empty schedule, and an instructor teaching one saw nothing on their My Lessons page. Each remaining session of a class you are enrolled in now sorts in among your lessons by date, labelled **group class**; instructors see every session of the classes they teach, one row per session however many students are in it. A session has no Cancel button, because there is no such thing as cancelling one date of a term — withdrawing from the class is still done from the class page.
+- A class you are enrolled in shows up **whether or not its schedule is pinned to a clock**. Class time and duration are both optional on the offering form, and the schedule note is there so a studio can simply write "Tuesdays 4:00pm" — so a class with a time but no duration lists its dates and says when each session starts rather than guessing when it ends, and a class with no time at all gets a single row carrying its schedule note (or its term dates) where the time would go. Only a class whose last day has passed drops off the list.
+- A student's admin detail page now shows **Booked by** in the Account section — the name of the parent or guardian who books and pays for them, linked to their own page. It was only stated further down under Profile, and only when there was one; the row is now always there, saying in words when a student books for themselves.
+- The same group-class sessions now appear in **Upcoming lessons** on a student's admin detail page, so one table answers "what are they booked into next week?". Only upcoming ones — the **Group-class enrolments** table below already holds the history.
+- **A policy can be renamed.** The title was fixed at creation, so a typo or a change of wording meant creating a second policy and re-collecting everyone's acceptance. Renaming changes only what students read above the policy text: the slug stays put, so every version already accepted stays attached.
+
+### Fixed
+- **People are named by their name again, not their email address.** Anywhere the plugin named a person it could show their email instead — "Managed by grace@example.com" in the students table, the same under **Booked by**, and instructor names on the class pages. WordPress starts a new account's nickname off as its username, and signup uses the email address as the username, so the address became the nickname of every self-registered account; the name they had typed was sitting in the account's display name the whole time. Names are now read from there when the nickname turns out to be an address, so existing accounts read correctly with nothing to fix by hand, and new signups store the name properly in the first place. Students added by a parent were never affected.
+- **Deleting a parent now removes the students they booked for.** A managed student account has no login of its own and exists only so its parent has somebody to book for — with the parent gone nobody can reach it, book for it, or be billed for it, so it was left stranded on the roster still holding lesson times. Deleting a parent now releases each of their students' upcoming lessons and enrolments on the same terms as their own, and deletes the accounts. Removing a student from the family screen is unchanged and still refuses one with lessons on record.
+- **The upcoming-lessons panel no longer collapses onto itself in some themes.** Rows could render on top of one another and the status badge's colour could stop short of the text inside it. Both came from the same thing: the panel never stated its own line spacing, so a theme setting a line height of zero anywhere above it — a common icon-font reset — was inherited straight through, leaving each line of text taller than the space allotted to it. The panel now sets its own.
+- **Deleting a student now gives back what they had booked.** WordPress deletes a user without knowing anything about lessons, so their bookings were left behind: the times stayed marked as booked and nobody else could take them, the lessons stayed on the instructor's schedule under a name that no longer resolved, and a group class kept a seat filled by nobody. Deleting an account now cancels each of its upcoming lessons, frees the time for rebooking, cancels its active class enrolments, and voids any payment still pending on them. Past lessons are left exactly as they are — they happened, and the payment report has to keep adding up. A paid lesson is not credited back: a credit could only be spent on the account being deleted, so a refund owed to someone who has left stays the studio's decision to make.
+- **A weak password is now caught before the form is submitted, not after.** The strength meter scores the password as you type, but zxcvbn's dictionary arrives a moment after the page loads — so a password typed straight away was never scored at all, and the first you heard of it was the server rejecting the whole form. The password is now re-scored on submit, so the verdict is always the one your password actually earns.
+
+### Changed
+- **Signup is one page again.** The studio's registration questions used to be a second step behind a **Next** button; they are now asked on the main form, in an **About you** panel above the students you are adding. What the studio needs to know about you is part of registering, not a sequel to it — and there is now one submit rather than three.
+- **Signup asks an adult student for their birth year**, the same four-digit year already asked of every student being registered on someone else's behalf. It is asked only when you are a student yourself — choosing **on behalf of one or more students** leaves the whole **About you** panel out, since those questions describe a student and in that case you are not one.
+
+## [1.4.0]
+
+### Added
+- An **Account** block (`[us_account]`) showing who is signed in — their name and their email — and a **Sign out** link. Signing out returns to the login page chosen in the block, or to the page the visitor was already on when none is set, so putting it in a site header does not also move people somewhere. To a signed-out visitor it shows a **Sign in** link when a login page is chosen, and nothing at all when one is not: a panel about who is signed in has nothing to tell a stranger, and a notice they cannot act on is just clutter in a header.
+
+### Security
+- Signup now checks the password properly. The form scores it as you type with the same zxcvbn meter wp-admin uses and will not submit a weak one, and the server refuses — regardless of what the browser allowed — anything shorter than 8 characters, one of the well-known leaked passwords, one built from barely any distinct characters, or one containing your own name or email address. Composition rules ("must contain a symbol") are deliberately not imposed: they mostly produce predictable substitutions. Email addresses are validated on the server on every signup path, with a clear message when one is already registered.
+
+### Changed
+- Signup now asks **"Who are you registering?"** as a three-way choice — **just myself**, **on behalf of one or more students**, or **both** — in place of the single parent/guardian tick. The tick could only ever say "I have children to add"; it could not say whether the account holder was a student themselves, so every account was offered its own name in the **Who is this for?** picker whether or not anyone meant to book them a lesson. Choosing *on behalf of* now leaves the account holder out of that picker. Existing accounts are unaffected and stay bookable, since the flag records only the new "not a student" case.
+- The studio's **account-signup questions are now asked of anyone registering as a student**, including someone registering themselves alongside their children. Choosing **both** previously collected the questions per child only, so the account holder's own instrument, level and the rest were never asked for or stored, even though they could book lessons. Their answers are recorded against their own account, and a blank required answer now names them rather than blaming "each student".
+- A student's **name and birth year are now required**, marked in the form the same way a required registration question is and enforced on the server whichever way they were submitted. On signup the requirement applies only once the parent/guardian box is ticked, so registering for yourself is unaffected. A student block you have started filling in is now reported back to you rather than silently dropped when the name is missing — only a completely untouched spare block is still ignored.
+- Signup and the profile page now ask for a **birth year** rather than a full date of birth — a four-digit year between 1900 and the current year, with anything else discarded rather than stored. Students added before this change keep showing a birth year, derived from the date already on file; that old full date is then dropped the first time the record is saved, so the studio ends up holding only what it now asks for. No bulk purge runs, so a site wanting the remaining old dates gone should clear the `us_date_of_birth` user meta directly.
+- The interface now says **student** where it said "child" and **profile** where it said "family". The `[us_family]` page is headed **Your profile**, its form is **Add a student**, signup asks for a **Student's name**, and the wp-admin students list and student screen both label the relationship **Profile**. Two strings were reworded rather than swapped: the students list reads **Managed by _name_** (a bare "Student of _name_" would read as a teacher's pupil), and a managed account is described as a **managed student account** so it is not confused with the account holder. Internal names — database columns, request parameters, form field names, the `us_family` shortcode and the `us-scheduler/family` block — are unchanged, since they are contracts with existing installs and saved post content.
+
+### Fixed
+- **Booking a lesson no longer dead-ends on the confirmation.** The confirmation used to replace the calendar entirely, leaving a student who wanted a second lesson with nothing to click and no way back short of reloading the page. It is now a dismissible notice sitting above a freshly loaded calendar — the slot just taken already gone from it, the upcoming-lessons panel already updated — so "it worked" and "book another" are the same screen. Enrolling in a group class did the same thing and is fixed the same way.
+- Upcoming lesson rows no longer render on top of each other. The row's text sits in inline elements that a theme can pull out of normal flow, which dropped the date and time onto the lesson title and the status pill onto the Cancel button; those elements are now pinned into flow alongside the rest of the panel's theme-proofing. The rows held behind **Show all** also stayed visible under the `div { display: block }` reset that many themes still carry, since `[hidden]` is only a browser default — they are now hidden for real.
+
+## [1.3.0]
+
+### Added
+- **Parent and guardian accounts.** A parent registers once and manages lessons for one or more children, who need no login of their own. The signup form gains an **"I'm registering as a parent or guardian"** tick that reveals a block per child — name, date of birth, and the studio's account-signup questions asked **per child**, since those describe the student rather than the account holder. Signup policies are recorded once per child with the guardian named as the person who agreed, which is the record that actually means something: "this guardian accepted version N on behalf of this child, at this time, from this address." A guardian can also be a student themselves and book their own lessons from the same account.
+- A **"Who is this for?"** picker on the booking and group-class forms, listing **children first** and the account holder last — so the default selection is never the parent, and a lesson meant for a child is not quietly booked and billed in the parent's name. An account with only itself on the list sees no picker and behaves exactly as before. A guardian's upcoming-lessons panel covers the whole household, each row naming whose lesson it is, and they can cancel or withdraw for any of their children.
+- A **Family** page for guardians (`[us_family]`, or the **Family** block) to add, edit and remove children after signup. Removing a child is refused once they have lessons or enrolments on record — that history belongs to them, and the studio unpicks it by hand rather than the page orphaning it.
+- **One family, one bill.** Payments record the child the lesson was for *and* the guardian who owes it, so per-child reporting is unchanged while notices, receipts and the payment step all go to the parent. Account credit is held by the payer, so a credit from one child's cancelled lesson can settle a sibling's next charge, and the billing-method override (comp / card / e-transfer) is one setting on the guardian rather than one per child. The daily billing scan sends a guardian **one** notice covering every child, with each line naming whose lesson it is.
+- **Students** in wp-admin gains a **Family** column linking a child to their guardian and a guardian to their children, and the student screen gains a **Family** panel. A child's row shows the guardian's email — a child's own address is a placeholder that can never receive mail — and their credit balance is labelled with whose account actually holds it.
+
+### Changed
+- Child accounts **cannot be signed in to**. They hold the student role so every existing lookup keeps working, but authentication is refused outright and the booking capability is withheld, so the only route to a lesson in a child's name is their guardian's authorised booking.
+
+## [1.2.4]
+
+### Fixed
+- **Adding availability no longer fails in silence.** Entering a window shorter than the chosen lesson length — 5:30–6:00 PM with the lesson length left on its default of 60 minutes, say — saved nothing and said nothing: the page just reloaded, whether the window was one-off or set to repeat for 41 weeks. The **Lesson length** menu now offers only the lengths that actually fit the window you have entered, and the form refuses to submit when none of them do. Every other way the form could quietly do nothing now explains itself too — an unreadable date, an end time before the start, a window running past midnight into the next day — and a successful save says how many bookable slots it created. Deleting says whether the slot went, and tells you when one is refused because it is already booked. Availability added through the API is checked against exactly the same rules, which it previously enforced slightly differently.
+- A student's **upcoming lessons no longer pile on top of each other**. On the booking page, the lesson name, its date and time, the status badge and the **Cancel** button could render over one another instead of sitting in a tidy row — worst with a long lesson-type name, and on narrow screens, where the row had no phone layout at all. The panel now keeps its shape whatever the theme around it does, long names wrap instead of shoving the Cancel button out of the row, and on a phone the lesson details stack above the buttons.
+- The registration page **no longer dead-ends a visitor who is already signed in**. It used to greet them with "You already have an account and are logged in." and nothing else, leaving them to find their own way to the studio. They now get a link onward to the page chosen under the block's **After registration** panel, and the link names it — "Continue to Book a Lesson" rather than the vaguer wording an invited student used to see. With no page chosen, the message appears on its own as before, because sending someone who is already signed in to the sign-in screen helps nobody.
+
+## [1.2.3]
+
+### Changed
+- A **monthly group class is now billed its price once per month**, however many times the class meets in that month. Previously the monthly charge multiplied the price by the number of sessions in the month — a class priced at `40.00 CAD` meeting weekly was billed `160.00 CAD` on the 1st — which no studio could quote honestly on a class card. A monthly **private lesson** is unchanged: its price is a per-lesson fee and the month is still billed one fee per lesson, which is why it is quoted per lesson. Studios running a monthly group class should check the class price now reads as the monthly fee they intend to charge.
+
+### Added
+- Every price a student sees now says **when** it is due. Lesson types in the booking form read `50.00 CAD at booking`, and group-class cards read `120.00 CAD up front`, `40.00 CAD weekly` or `40.00 CAD monthly` — the offering's billing mode, in the student's words. A monthly **private lesson** is quoted per lesson (`50.00 CAD per lesson monthly`), since its monthly charge covers every lesson booked that month; a monthly group class is quoted as the monthly figure it is. A free offering still just reads **Free**.
+- The **Policies** admin page can now **show you what is actually in a version**. Every row in the versions table has a **View** button that opens that version's text below the table, rendered exactly as students see it at booking and signup, whether the version is the published one, an old archived one, or a draft nobody has seen yet. The text is editable straight from the viewer, and what happens when you save depends on the version: a draft is simply updated in place, while editing a **published or archived version saves your text as a new draft version** and leaves the original exactly as students accepted it. The new draft then opens in the viewer ready to publish. Nothing a student has agreed to is ever rewritten.
+- Booking a lesson and enrolling in a class now take a **second confirmation that the student agrees to pay**. Above the Confirm button the form restates the price with its cadence, spells out how it is collected ("Charged on the 1st of each month, for that month's lessons"), adds the studio's HST so the figure matches the total actually billed, and requires a tick on "I agree to pay 56.50 CAD at booking." before it will submit — separate from, and in addition to, the studio policies the student accepts above it. Reserving a time weekly quotes the per-lesson fee and the most it can add up to ("up to 12 lessons, 678.00 CAD in total"), since a week another student takes first is simply not booked. Free offerings have nothing to agree to and show no price block.
+
+### Fixed
+- Policies are **readable where students have to accept them**. A policy typed as plain paragraphs — the normal way to write one, with no HTML — was being dropped into the booking, enrolment, and signup forms unformatted, collapsing the whole document into a single squashed line with a horizontal scrollbar and words piling on top of each other. Policy text is now formatted the same way WordPress formats post content, so blank lines become real paragraphs, and the acceptance box is styled as a proper bounded reading panel: long policies scroll vertically instead of running off the side of the page, long pasted links wrap rather than forcing the page sideways, and the "I have read and agree" tick stays in view. Policies written with HTML are unaffected. The studio registration page was also missing the plugin's stylesheet entirely, which is why the problem was at its worst there.
+
 ## [1.2.2]
 
 ### Added

CLAUDE.md

@@ -4,100 +4,23 @@ This file provides guidance to Claude Code (claude.ai/code) when working with co
 
 ## Commands
 
-```bash
-composer install                  # Install all dependencies
-
-composer test                     # Run the full test suite (required after every change)
-composer lint                     # PHPStan static analysis
-composer cs                       # PHPCS coding standards check
-composer cs:fix                   # Auto-fix coding standards
-
-# Run a single test file
-./vendor/bin/phpunit tests/Unit/Availability/AvailabilityRepositoryTest.php
-
-# Run a single test by name
-./vendor/bin/phpunit --filter testInsertCallsWpdbInsertAndReturnsId
-```
-
 **Run `composer test` after every code change before considering a task complete.**
 
 ## Architecture
 
-### Plugin Bootstrap
-`unsupervised-schedular.php` defines constants (`USC_VERSION`, `USC_PLUGIN_DIR`, `USC_PLUGIN_URL`), registers activation/deactivation hooks, then calls `Plugin::boot()` on `plugins_loaded`. No logic lives in the root file.
-
-### Directory Structure
-```
-src/                  — All plugin PHP (PSR-4 namespace: Unsupervised\Schedular\)
-  Availability/       — Availability slots: value object, repository, controller, REST endpoint
-  Booking/            — Lessons/bookings: value object, repository, controller, REST endpoint, shortcode page
-  Auth/               — Roles, capabilities, login page
-  Plugin.php          — Wires all components together on plugins_loaded
-  Installer.php       — Creates DB tables and roles on activation
-  Schema.php          — CREATE TABLE SQL for dbDelta
-  AdminMenu.php       — Registers wp-admin menu pages
-  RestRegistrar.php   — Registers all REST routes under us-scheduler/v1
-  ShortcodeRegistrar.php — Registers [us_booking] and [us_student_login] shortcodes
-  BlockRegistrar.php  — Registers Gutenberg dynamic-block wrappers for the shortcodes
-  BlockPreview.php    — Static editor-preview markup for the blocks
-templates/            — PHP view files included by controllers/shortcodes
-assets/               — CSS and JS (vanilla JS, no build step)
-tests/Unit/           — PHPUnit unit tests (PSR-4: Unsupervised\Schedular\Tests\)
-  Availability/       — Tests for src/Availability/
-  Booking/            — Tests for src/Booking/
-  Auth/               — Tests for src/Auth/
-docs/features/        — One markdown file per feature describing data model, API, and test locations
-```
-
-**Code is organised package-by-domain** (Availability, Booking, Auth). Each domain package contains everything related to that domain: value objects, repositories, controllers, REST endpoints, and shortcode pages. Cross-cutting wiring classes (Plugin, AdminMenu, RestRegistrar, ShortcodeRegistrar, Schema) live directly under `src/`.
+### Code organisation
+**Code is organised package-by-domain.** Each domain package under `src/<Domain>/` contains everything related to that domain: value objects, repositories, controllers, REST endpoints, and shortcode pages. Cross-cutting wiring classes (Plugin, AdminMenu, RestRegistrar, ShortcodeRegistrar, Schema) live directly under `src/`.
 
 ### Data Storage
-Two custom database tables (created via `dbDelta` on activation):
-- `{prefix}us_availability` — instructor availability windows
-- `{prefix}us_lessons` — booked lessons
+Custom database tables are created via `dbDelta` on activation; `Schema.php` holds the SQL.
 
 All database access goes through repository classes within their domain package. No direct `$wpdb` calls outside repositories.
 
-### Key Classes
-
-| Class | Responsibility |
-|---|---|
-| `Plugin` | Wires all components together on `plugins_loaded` |
-| `Installer` | Creates DB tables and roles on activation |
-| `Schema` | CREATE TABLE SQL strings for dbDelta |
-| `AdminMenu` | Registers wp-admin menu pages |
-| `RestRegistrar` | Registers all REST routes under `us-scheduler/v1` |
-| `ShortcodeRegistrar` | Registers `[us_booking]` and `[us_student_login]` shortcodes |
-| `BlockRegistrar` | Registers Gutenberg dynamic-block wrappers for the shortcodes |
-| `BlockPreview` | Static editor-preview markup for the blocks |
-| `Val` | Runtime coercion of untyped WP boundary values (wpdb rows, REST params, superglobals) |
-| `Auth\RoleManager` | Registers `us_instructor` and `us_student` roles with custom caps |
-| `Auth\LoginPage` | Renders front-end student login form |
-| `Availability\AvailabilitySlot` | Immutable value object for a slot row |
-| `Availability\AvailabilityRepository` | CRUD for availability slots |
-| `Availability\AvailabilityController` | Instructor availability management page |
-| `Availability\AvailabilityEndpoint` | REST handlers for availability CRUD |
-| `Booking\Lesson` | Immutable value object for a lesson row |
-| `Booking\BookingRepository` | CRUD for lesson bookings |
-| `Booking\BookingEndpoint` | REST handlers for booking and status updates |
-| `Booking\BookingPage` | Renders student booking UI shell (JS takes over) |
-| `Booking\LessonController` | Admin and instructor lesson list pages |
-
 ### REST API Namespace
 All endpoints live under `/wp-json/us-scheduler/v1/`. Permissions are enforced via `permission_callback` using capability checks (`manage_availability`, `book_lesson`), never role name checks.
 
 ### Testing Approach
-Tests use [Brain\Monkey](https://brain-wp.github.io/BrainMonkey/) to stub WordPress functions without a full WP installation, and Mockery to mock `$wpdb` and other dependencies.
-
-All test classes extend `tests/Unit/TestCase.php`, which handles `Monkey\setUp()` / `Monkey\tearDown()` and stubs all WP translation/escape functions automatically.
-
-**Brain\Monkey API notes:**
-- `Functions\when('fn')->alias(fn() => ...)` — stub with a closure (NOT `returnUsing()`)
-- `Functions\when('fn')->justReturn($val)` — stub returning a fixed value
-- `Functions\expect('fn')->once()->with(...)` — assert call count and arguments
-- Use `Functions\when()` (not `Functions\expect()`) when you need argument-routing (e.g. `get_role` returning different values per argument) to avoid chaining ambiguity
-- Mockery matchers (e.g. `\Mockery::type()`) inside plain PHP arrays do not work with `with()` — use `\Mockery::on(fn($arr) => ...)` or `\Mockery::any()` instead
-- When mocking `$wpdb`, set `$mock->prefix = 'wp_'` explicitly — it is a public property, not a method
+Tests stub WordPress with Brain\Monkey rather than booting a real WP install. The setup and the Brain\Monkey/Mockery API gotchas are in `tests/CLAUDE.md`.
 
 ### Adding a Feature
 0. **If the feature touches `Schema.php`, bump both the `Version:` header and `USC_VERSION` in `unsupervised-schedular.php`.** `Plugin::boot()` only re-runs `Installer`/`dbDelta` when the stored `us_schedular_version` differs, so a schema change without a version bump never reaches existing sites and inserts into new columns fail silently.
@@ -106,10 +29,3 @@ All test classes extend `tests/Unit/TestCase.php`, which handles `Monkey\setUp()
 3. Add template(s) under `templates/` if needed.
 4. Write unit tests under `tests/Unit/<Domain>/` mirroring the `src/<Domain>/` structure.
 5. Run `composer test` — all tests must pass before the feature is complete.
-
-### CI
-Gitea Actions (`.gitea/workflows/ci.yml`) runs on every push and pull request:
-- **lint** — PHPCS WordPress coding standards
-- **static-analysis** — PHPStan level 10
-- **test** — PHPUnit on PHP 8.1, 8.2, 8.3
-- **no-debug** — rejects commits with `var_dump`, `error_log`, etc. in `src/`

assets/css/frontend.css

@@ -34,47 +34,125 @@
     margin-top: 8px;
 }
 
-.us-my-lessons {
+/*
+ * The upcoming-lessons panel. Every rule here is scoped under #us-booking-app —
+ * the same id-level specificity .us-slot above uses — because these rows sit in
+ * whatever layout the theme provides and carry more content than a calendar
+ * cell. Bare class selectors lost to theme rules on div/span/strong, which
+ * collapsed the flex layout and piled the details on top of the actions.
+ */
+#us-booking-app .us-my-lessons {
     margin-bottom: 24px;
 }
 
-.us-my-lesson {
+#us-booking-app .us-my-lesson {
+    box-sizing: border-box;
+    max-width: 100%;
     border: 1px solid #ddd;
     border-radius: 4px;
     padding: 12px 16px;
     margin-bottom: 8px;
     display: flex;
+    flex-wrap: wrap;
     justify-content: space-between;
     align-items: center;
-    gap: 12px;
+    gap: 8px 12px;
 }
 
-.us-my-lesson-info {
+/*
+ * `min-width: 0` lets the title column shrink below its content width — without
+ * it a long offering title cannot compress and shoves the status pill and
+ * Cancel button out of the row. The flex-basis keeps the details and the
+ * actions on one line while there is room, and wraps them once there is not.
+ */
+#us-booking-app .us-my-lesson-info {
     display: flex;
     flex-direction: column;
     gap: 2px;
+    flex: 1 1 14em;
+    min-width: 0;
 }
 
-.us-my-lesson-title {
+#us-booking-app .us-my-lesson-title,
+#us-booking-app .us-my-lesson-when {
+    overflow-wrap: break-word;
+    word-break: break-word;
+}
+
+#us-booking-app .us-my-lesson-title {
     font-size: 1.05em;
 }
 
-.us-my-lesson-duration {
+#us-booking-app .us-my-lesson-duration {
     font-weight: normal;
     color: #666;
 }
 
-.us-my-lesson-when {
+#us-booking-app .us-my-lesson-when {
     color: #555;
 }
 
-.us-my-lesson-actions {
+#us-booking-app .us-my-lesson-actions {
     display: flex;
-    gap: 12px;
+    flex-wrap: wrap;
+    gap: 8px 12px;
     align-items: center;
 }
 
-.us-show-all-lessons {
+/*
+ * Theme-proofing for the leaf text. The row and its two columns are divs with
+ * explicit flex rules above, but the text itself still sits in inline elements
+ * a theme is free to take out of normal flow — an absolutely positioned,
+ * floated or negatively offset span drops the date/time on top of the title and
+ * the status pill on top of the Cancel button. Pinning the properties that
+ * would have to change keeps the leaves in flow, at the same id-level
+ * specificity the rules above rely on.
+ *
+ * `line-height` is pinned for the same reason and is the subtler one, because a
+ * theme does not have to target this panel to break it — it is inherited, so a
+ * `line-height: 0` anywhere above (the usual icon-font or sprite reset) reaches
+ * these elements untouched. Below 1 it produces both halves of the same bug: a
+ * line box shorter than its glyphs, so stacked lines in the details column
+ * overlap, and an inline-block pill whose background is shorter than the text
+ * sitting in it. Nothing here should ever inherit a line-height, so the panel
+ * states its own.
+ */
+#us-booking-app .us-my-lesson,
+#us-booking-app .us-my-lesson-info,
+#us-booking-app .us-my-lesson-actions,
+#us-booking-app .us-my-lesson-title,
+#us-booking-app .us-my-lesson-when,
+#us-booking-app .us-my-lesson-duration,
+#us-booking-app .us-my-lesson-who,
+#us-booking-app .us-my-lesson-kind,
+#us-booking-app .us-lesson-status {
+    line-height: 1.45;
+}
+
+#us-booking-app .us-my-lesson-title,
+#us-booking-app .us-my-lesson-when,
+#us-booking-app .us-my-lesson-duration,
+#us-booking-app .us-my-lesson-who,
+#us-booking-app .us-my-lesson-kind,
+#us-booking-app .us-lesson-status {
+    position: static;
+    float: none;
+    margin: 0;
+    vertical-align: middle;
+}
+
+/*
+ * The rows the "Show all" button reveals. `[hidden]` is only a UA-stylesheet
+ * rule, so any author rule setting a display on div beats it — the html5-reset
+ * `div { display: block }` is still widespread in themes — and the rows the
+ * button is meant to gate render anyway. An author !important is the only way
+ * to win that cascade.
+ */
+#us-booking-app [hidden] {
+    display: none !important;
+}
+
+#us-booking-app .us-show-all-lessons {
     background: transparent;
     border: 1px solid #ccc;
     border-radius: 4px;
@@ -82,11 +160,11 @@
     cursor: pointer;
 }
 
-.us-show-all-lessons:hover {
+#us-booking-app .us-show-all-lessons:hover {
     border-color: #888;
 }
 
-.us-cancel-lesson {
+#us-booking-app .us-cancel-lesson {
     background: transparent;
     border: 1px solid #ccc;
     border-radius: 4px;
@@ -95,24 +173,26 @@
     color: #c00;
 }
 
-.us-cancel-lesson:hover {
+#us-booking-app .us-cancel-lesson:hover {
     border-color: #c00;
 }
 
-.us-lesson-status {
+#us-booking-app .us-lesson-status {
+    display: inline-block;
     font-size: 0.85em;
     font-weight: 600;
     padding: 2px 10px;
     border-radius: 10px;
     background: #eee;
+    white-space: nowrap;
 }
 
-.us-lesson-status-confirmed {
+#us-booking-app .us-lesson-status-confirmed {
     background: #e2f5e5;
     color: #1a7d2e;
 }
 
-.us-lesson-status-pending {
+#us-booking-app .us-lesson-status-pending {
     background: #fdf3d7;
     color: #8a6d1a;
 }
@@ -241,6 +321,102 @@
     opacity: 0.4;
 }
 
+/* The price and pay agreement on a booking / enrolment form. */
+.us-price {
+    border: 1px solid #ddd;
+    border-radius: 4px;
+    padding: 12px 16px;
+    margin: 16px 0;
+}
+
+.us-price h4 {
+    margin: 0 0 8px;
+}
+
+.us-price p {
+    margin: 0 0 4px;
+}
+
+.us-price-amount strong {
+    font-size: 1.15em;
+}
+
+.us-price-cadence {
+    margin-left: 4px;
+}
+
+.us-price-tax,
+.us-price-note {
+    font-size: 0.9em;
+    opacity: 0.8;
+}
+
+.us-price-agree {
+    display: block;
+    margin-top: 12px;
+    font-weight: 600;
+}
+
+/* The cadence-carrying price on a group-class card. */
+.us-class-price {
+    font-weight: 600;
+}
+
+/* Policy acceptance — booking, enrolment, and signup all render this markup. */
+.us-policy {
+    margin: 16px 0;
+}
+
+.us-policy h4 {
+    margin: 0 0 6px;
+}
+
+/*
+ * The body is admin-authored HTML sitting inside whatever layout the theme
+ * provides, so it gets an explicit reading box rather than inheriting one.
+ * `overflow-wrap` breaks pasted URLs instead of letting one long token force
+ * the horizontal scrollbar, and the bounded height keeps a long policy from
+ * pushing the accept checkbox off the screen.
+ */
+.us-policy-body {
+    box-sizing: border-box;
+    max-width: 100%;
+    max-height: 260px;
+    overflow-y: auto;
+    overflow-x: hidden;
+    padding: 12px 14px;
+    margin-bottom: 8px;
+    border: 1px solid #ddd;
+    border-radius: 4px;
+    background: #fafafa;
+    white-space: normal;
+    overflow-wrap: break-word;
+    word-break: break-word;
+    line-height: 1.5;
+    text-align: left;
+}
+
+.us-policy-body p,
+.us-policy-body ul,
+.us-policy-body ol {
+    margin: 0 0 0.75em;
+    max-width: 100%;
+}
+
+.us-policy-body ul,
+.us-policy-body ol {
+    padding-left: 1.5em;
+}
+
+.us-policy-body > :last-child {
+    margin-bottom: 0;
+}
+
+.us-policy-accept,
+.us-policies input[type="checkbox"] {
+    margin-right: 6px;
+}
+
 @media (max-width: 640px) {
     .us-week-grid {
         grid-template-columns: 1fr;
@@ -249,6 +425,268 @@
     .us-week-day {
         min-height: 0;
     }
+
+    /*
+     * A lesson row carries a title, a date/time, a status pill and a button —
+     * more than fits one narrow line, so stack the details above the actions
+     * rather than letting them wrap into each other.
+     */
+    #us-booking-app .us-my-lesson {
+        flex-direction: column;
+        align-items: stretch;
+    }
+
+    #us-booking-app .us-my-lesson-info {
+        flex: 0 0 auto;
+    }
+}
+
+/*
+ * "Who is this for?" picker — booking and enrolment. Present only on an account
+ * that books for more than one person, so it is styled as a normal field rather
+ * than a callout.
+ */
+.us-student-picker select {
+    max-width: 100%;
+}
+
+/*
+ * Whose lesson a row in the upcoming panel is — only shown on an account that
+ * books for more than one person. Scoped under #us-booking-app like the rest of
+ * the panel; as a bare class it was the one rule in the group a theme could
+ * outrank on a plain span.
+ */
+#us-booking-app .us-my-lesson-who {
+    font-weight: normal;
+    opacity: 0.75;
+}
+
+/*
+ * Marks a row in the upcoming panel as a group-class session. The list mixes
+ * one-to-one lessons and classes, and only the class rows have no Cancel button
+ * — without a label that reads as a missing button rather than a different kind
+ * of thing.
+ */
+#us-booking-app .us-my-lesson-kind {
+    display: inline-block;
+    margin-left: 6px;
+    padding: 1px 6px;
+    border-radius: 10px;
+    background: #eef1f5;
+    color: #3c434a;
+    font-size: 0.75em;
+    font-weight: 600;
+    text-transform: uppercase;
+    letter-spacing: 0.03em;
+    vertical-align: middle;
+}
+
+/*
+ * The signup form's grouped sections: who you are registering, your own
+ * details, and the students you are adding. One box style for all three so the
+ * form reads as a short list of decisions rather than an undifferentiated
+ * column of fields.
+ */
+.us-reg-group {
+    margin: 16px 0;
+    padding: 12px 14px;
+    border: 1px solid #ddd;
+    border-radius: 4px;
+}
+
+.us-reg-group legend {
+    padding: 0 6px;
+    font-weight: 600;
+}
+
+.us-children-intro {
+    margin-top: 0;
+    font-size: 0.9em;
+    opacity: 0.8;
+}
+
+/*
+ * Each child is a bordered group so a family of three does not read as one long
+ * undifferentiated column of fields.
+ */
+.us-child {
+    margin-bottom: 12px;
+    padding: 10px 12px;
+    border-left: 3px solid #ddd;
+    background: #fafafa;
+}
+
+.us-child > p:last-child {
+    margin-bottom: 0;
+}
+
+/* The guardian's manage-children screen ([us_family]). */
+
+/*
+ * The account holder's own details, set off from the students below so the two
+ * halves of the page do not read as one long form.
+ */
+.us-family-self {
+    margin-bottom: 24px;
+    padding-bottom: 16px;
+    border-bottom: 1px solid #eee;
+}
+
+.us-family-self-email span {
+    font-weight: 600;
+}
+
+/*
+ * Guidance under a control, not a label: it explains when a field matters
+ * rather than naming it, so it is sized down and reads after the input.
+ */
+.us-field-hint {
+    display: block;
+    margin-top: 4px;
+    font-size: 0.9em;
+    opacity: 0.75;
+}
+
+.us-family-list {
+    margin: 0 0 20px;
+    padding: 0;
+    list-style: none;
+}
+
+.us-family-child {
+    display: flex;
+    flex-wrap: wrap;
+    gap: 8px 12px;
+    align-items: baseline;
+    padding: 10px 0;
+    border-bottom: 1px solid #eee;
+}
+
+.us-family-child-name {
+    font-weight: 600;
+}
+
+.us-family-child-birth-year {
+    font-size: 0.9em;
+    opacity: 0.75;
+}
+
+/*
+ * The actions sit at the far end of the row. Remove is its own form (it posts),
+ * so it is forced inline rather than taking a block of its own.
+ */
+.us-family-child-actions {
+    display: flex;
+    gap: 10px;
+    align-items: baseline;
+    margin-left: auto;
+}
+
+.us-family-remove {
+    display: inline;
+}
+
+/* The editing row replaces the child's line, so it spans the whole width. */
+.us-family-edit {
+    width: 100%;
+}
+
+@media (max-width: 640px) {
+    /* A name, a date and two actions do not fit one narrow line. */
+    .us-family-child-actions {
+        margin-left: 0;
+        width: 100%;
+    }
+}
+
+/*
+ * The live password verdict under the signup field. Colour is a reinforcement,
+ * not the message — the text says what is wrong on its own, so this still reads
+ * correctly to anyone who cannot separate the hues.
+ */
+.us-password-strength {
+    display: block;
+    margin-top: 4px;
+    font-size: 0.85em;
+}
+
+.us-password-strength.is-short,
+.us-password-strength.is-weak {
+    color: #c00;
+}
+
+.us-password-strength.is-medium {
+    color: #7a5c00;
+}
+
+.us-password-strength.is-strong {
+    color: #1a7d2e;
+}
+
+/*
+ * The account panel: who is signed in, and the way out. Sized to sit in a
+ * header or sidebar, so the rules stay minimal and inherit the theme's type —
+ * a block that lands in a site header should look like it belongs there.
+ */
+.us-account p {
+    margin: 0 0 4px;
+}
+
+.us-account-name {
+    font-weight: 600;
+}
+
+.us-account-email {
+    display: block;
+    font-size: 0.9em;
+    opacity: 0.75;
+}
+
+.us-account-actions {
+    margin-top: 8px;
+}
+
+/*
+ * `[hidden]` is a UA-stylesheet rule, so the widespread `div { display: block }`
+ * theme reset outranks it — the same trap the upcoming-lessons panel hit. An
+ * author !important is the only way to win, and it has to sit before the
+ * display rule it guards against.
+ */
+.us-notice[hidden] {
+    display: none !important;
+}
+
+/*
+ * The "you're booked" / "you're enrolled" notice. It sits above the calendar
+ * or class list rather than replacing it, so it needs to read as a banner
+ * about something that just happened — not as the page's content.
+ */
+.us-notice {
+    display: flex;
+    flex-wrap: wrap;
+    justify-content: space-between;
+    align-items: center;
+    gap: 8px 16px;
+    margin-bottom: 16px;
+    padding: 12px 16px;
+    border: 1px solid #b7dfc0;
+    border-left-width: 4px;
+    border-radius: 4px;
+    background: #f2faf4;
+    color: #1a5c2a;
+}
+
+.us-notice p {
+    margin: 0;
+}
+
+.us-notice-dismiss {
+    background: transparent;
+    border: 1px solid currentColor;
+    border-radius: 4px;
+    padding: 4px 12px;
+    color: inherit;
+    cursor: pointer;
 }
 
 /* Shown only in block-editor previews (see BlockPreview). */

assets/js/availability-admin.js

@@ -0,0 +1,98 @@
+/**
+ * Availability form: keep the lesson-length choices honest.
+ *
+ * A window is stored as consecutive lesson-length slots, so one shorter than the
+ * chosen lesson length holds no slots at all and saves nothing. Picking 5:30–6:00
+ * PM while the length select sat on its default of 60 minutes used to do exactly
+ * that, silently. The server now rejects it with a message; this narrows the
+ * choices first so the mistake is hard to make.
+ *
+ * This is a convenience only — AvailabilityController and the REST endpoint both
+ * validate the same window server-side regardless of what happens here.
+ */
+(function () {
+    'use strict';
+
+    const form = document.getElementById('usc-add-availability');
+    if (!form) return;
+
+    const startEl    = document.getElementById('start_dt');
+    const endEl      = document.getElementById('end_dt');
+    const durationEl = document.getElementById('duration_minutes');
+    const warningEl  = document.getElementById('usc-duration-warning');
+    const submitEl   = form.querySelector('input[type="submit"], button[type="submit"]');
+
+    if (!startEl || !endEl || !durationEl) return;
+
+    /**
+     * Minutes between the two datetime-local inputs, or 0 when the pair is not a
+     * usable window yet — empty, unparseable, backwards, or spanning two days
+     * (which the server rejects on its own terms, with its own message).
+     */
+    function windowMinutes() {
+        const start = new Date(startEl.value);
+        const end   = new Date(endEl.value);
+
+        if (!startEl.value || !endEl.value || isNaN(start) || isNaN(end)) return 0;
+        if (end <= start) return 0;
+        if (startEl.value.slice(0, 10) !== endEl.value.slice(0, 10)) return 0;
+
+        return Math.round((end - start) / 60000);
+    }
+
+    function refresh() {
+        const minutes = windowMinutes();
+        const options = Array.from(durationEl.options);
+
+        // No usable window yet: leave every choice alone rather than fighting
+        // someone part-way through typing a date.
+        if (minutes === 0) {
+            options.forEach((option) => {
+                option.hidden   = false;
+                option.disabled = false;
+            });
+            setBlocked(false);
+            return;
+        }
+
+        let fits = [];
+
+        options.forEach((option) => {
+            const tooLong = Number(option.value) > minutes;
+
+            option.hidden   = tooLong;
+            option.disabled = tooLong;
+
+            if (!tooLong) fits.push(option);
+        });
+
+        if (fits.length === 0) {
+            // Nothing bookable fits, so the form cannot produce a single slot.
+            setBlocked(true);
+            return;
+        }
+
+        setBlocked(false);
+
+        // The selection may have just been hidden — fall back to the longest
+        // length that still fits, which is what the instructor most likely wants.
+        if (durationEl.selectedOptions[0] && durationEl.selectedOptions[0].disabled) {
+            durationEl.value = fits.reduce(
+                (longest, option) => (Number(option.value) > Number(longest.value) ? option : longest),
+                fits[0]
+            ).value;
+        }
+    }
+
+    function setBlocked(blocked) {
+        if (warningEl) warningEl.hidden = !blocked;
+        if (submitEl) submitEl.disabled = blocked;
+    }
+
+    startEl.addEventListener('change', refresh);
+    startEl.addEventListener('input', refresh);
+    endEl.addEventListener('change', refresh);
+    endEl.addEventListener('input', refresh);
+
+    refresh();
+}());

assets/js/blocks.js

@@ -282,6 +282,53 @@
                 })
             ),
         },
+        {
+            name: 'us-scheduler/family',
+            title: __('Profile', 'unsupervised-schedular'),
+            description: __('Lets a parent or guardian add, edit and remove the students they book lessons for.', 'unsupervised-schedular'),
+            icon: 'groups',
+            // 'family' and 'children' are kept as search terms only — they are
+            // never displayed, and the block answered to them before it was
+            // renamed, so anyone reaching for the old word still finds it.
+            keywords: ['profile', 'students', 'family', 'children', 'guardian', 'parent'],
+            shortcode: 'us_family',
+            attributes: {
+                loginPageId: { type: 'number', default: 0 },
+            },
+            inspector: (attributes, setAttributes) => el(
+                PanelBody,
+                { title: __('Logged-out visitors', 'unsupervised-schedular') },
+                el(PageSelect, {
+                    label: __('Login page', 'unsupervised-schedular'),
+                    help: __('Where visitors who are not signed in are sent to log in.', 'unsupervised-schedular'),
+                    defaultLabel: __('WordPress login screen', 'unsupervised-schedular'),
+                    value: attributes.loginPageId,
+                    onChange: (loginPageId) => setAttributes({ loginPageId }),
+                })
+            ),
+        },
+        {
+            name: 'us-scheduler/account',
+            title: __('Account', 'unsupervised-schedular'),
+            description: __('Shows the name and email of whoever is signed in, with a sign out link. Renders nothing for signed-out visitors unless a login page is chosen.', 'unsupervised-schedular'),
+            icon: 'admin-users',
+            keywords: ['account', 'sign out', 'log out', 'signed in', 'profile'],
+            shortcode: 'us_account',
+            attributes: {
+                loginPageId: { type: 'number', default: 0 },
+            },
+            inspector: (attributes, setAttributes) => el(
+                PanelBody,
+                { title: __('Signing in and out', 'unsupervised-schedular') },
+                el(PageSelect, {
+                    label: __('Login page', 'unsupervised-schedular'),
+                    help: __('Where signing out returns to, and where signed-out visitors are offered a link to sign in. Without one, signing out returns to the current page and signed-out visitors see nothing.', 'unsupervised-schedular'),
+                    defaultLabel: __('Stay on the current page', 'unsupervised-schedular'),
+                    value: attributes.loginPageId,
+                    onChange: (loginPageId) => setAttributes({ loginPageId }),
+                })
+            ),
+        },
     ];
 
     blocks.forEach((def) => {

assets/js/booking.js

@@ -16,6 +16,11 @@
     const pinnedTypeId  = Number(app.dataset.lessonType) || 0;
     const filterEnabled = app.dataset.typeFilter !== '0';
 
+    // Who this account may book for — children first, the account holder last,
+    // so a guardian's default selection is a child rather than themselves. A
+    // single-student account has one entry and gets no picker.
+    const students = window.usGuardian.parseStudents(app.dataset.students);
+
     function apiFetch(path, options = {}) {
         return fetch(restUrl + path, {
             ...options,
@@ -330,7 +335,12 @@
 
         slotList.querySelectorAll('.us-book-btn[data-slot-id]').forEach((btn) => {
             const slot = allSlots.find((s) => String(s.id) === btn.dataset.slotId);
-            if (slot) btn.addEventListener('click', () => openRegistration(slot));
+            if (slot) {
+                btn.addEventListener('click', () => {
+                    hideConfirmation();
+                    openRegistration(slot);
+                });
+            }
         });
     }
 
@@ -360,13 +370,27 @@
             </div>`;
     }
 
-    // "Piano Lesson (60 min — $50.00 CAD)" / "Trial Lesson (Free)"
+    // "Piano Lesson (60 min — 50.00 CAD at booking)" / "Trial Lesson (Free)"
     function offeringLabel(o) {
         const duration = o.duration_minutes ? `${o.duration_minutes} min — ` : '';
-        const price = Number(o.price) > 0
-            ? `$${Number(o.price).toFixed(2)} ${o.currency}`
-            : 'Free';
-        return `${o.title} (${duration}${price})`;
+        return `${o.title} (${duration}${window.usPricing.priceLabel(o)})`;
+    }
+
+    // How many lessons a weekly reservation can claim, mirroring
+    // BookingEndpoint::MAX_WEEKLY_OCCURRENCES so the quoted total is never
+    // higher than the server will actually charge for.
+    const MAX_WEEKLY_OCCURRENCES = 12;
+
+    // The open times a weekly reservation of this slot would claim: every
+    // still-unbooked slot of its recurring group, capped the way the server
+    // caps it. Some may be taken by another student first, so this is the
+    // upper bound on what will be booked, not a guarantee.
+    function weeklyOccurrences(slot) {
+        if (!slot.recurrence_group) return 1;
+
+        const inGroup = allSlots.filter((s) => s.recurrence_group === slot.recurrence_group).length;
+
+        return Math.min(Math.max(inGroup, 1), MAX_WEEKLY_OCCURRENCES);
     }
 
     function openRegistration(slot) {
@@ -439,10 +463,12 @@
             <div class="us-register">
                 <h3>${escHtml(dayLabel(dayKey(slot.start_dt)))} · ${escHtml(timeOf(slot.start_dt))}–${escHtml(timeOf(slot.end_dt))}</h3>
                 <form id="us-register-form">
+                    ${window.usGuardian.selectorHtml(students, 'us-booking-student')}
                     ${offeringFieldHtml(tied, tiedId, choices)}
                     <div id="us-questions"></div>
                     ${policies.map(policyField).join('')}
                     ${weekly}
+                    <div id="us-price-summary"></div>
                     <p>
                         <button type="submit" class="us-book-btn">Confirm Booking</button>
                         <button type="button" id="us-cancel" class="us-cancel-btn">Back</button>
@@ -458,6 +484,27 @@
         let questions  = [];
 
         const questionsBox = document.getElementById('us-questions');
+        const priceBox     = document.getElementById('us-price-summary');
+        const weeklyEl     = document.getElementById('us-weekly');
+
+        // What the booking will cost and the agreement to pay it, restated
+        // whenever the choices that decide the amount change: the lesson type
+        // carries the price, and a weekly reservation multiplies a per-lesson
+        // one-time price by every week it claims. A slot tied to a type the
+        // catalog no longer carries has no price to quote, so it shows nothing
+        // rather than a figure it cannot stand behind.
+        function renderPrice() {
+            const offering = selectedId ? catalog.find((o) => Number(o.id) === selectedId) : null;
+            priceBox.innerHTML = offering
+                ? window.usPricing.summaryHtml({
+                    price: offering.price,
+                    currency: offering.currency,
+                    billing_mode: offering.billing_mode,
+                    kind: offering.kind,
+                    occurrences: weeklyEl && weeklyEl.checked ? weeklyOccurrences(slot) : 1,
+                })
+                : '';
+        }
 
         function loadQuestions() {
             questions = [];
@@ -475,10 +522,14 @@
             document.getElementById('us-offering').addEventListener('change', (e) => {
                 selectedId = Number(e.target.value) || 0;
                 loadQuestions();
+                renderPrice();
             });
         }
 
+        if (weeklyEl) weeklyEl.addEventListener('change', renderPrice);
+
         loadQuestions();
+        renderPrice();
 
         document.getElementById('us-cancel').addEventListener('click', loadSlots);
         document.getElementById('us-register-form').addEventListener('submit', (e) => {
@@ -487,6 +538,10 @@
                 showError('Please choose a lesson type.');
                 return;
             }
+            if (!window.usPricing.agreed(e.target)) {
+                showError(window.usPricing.AGREE_REQUIRED);
+                return;
+            }
             submitBooking(e.target, slot, selectedId, questions);
         });
     }
@@ -509,6 +564,7 @@
             body: JSON.stringify({
                 slot_id: slot.id,
                 offering_id: offeringId,
+                student_id: window.usGuardian.selectedId('us-booking-student'),
                 recurrence: weeklyEl && weeklyEl.checked ? 'weekly' : 'single',
                 answers,
                 accepted_policy_version_ids: accepted,
@@ -520,8 +576,11 @@
                 ? window.usPayment.collect('lesson', (res.ids || [])[0], slotList)
                 : null))
             .then((result) => {
-                loadMyLessons();
-                showConfirmation(window.usPayment.message(result));
+                const message = window.usPayment.message(result);
+
+                // Order matters: loadSlots() clears any standing notice, and it
+                // is what puts the calendar back with the booked slot gone.
+                return loadSlots().then(() => showConfirmation(message));
             })
             .catch((err) => showError(err.message));
     }
@@ -529,25 +588,65 @@
     function lessonStatusLabel(status) {
         if (status === 'pending') return 'Pending payment';
         if (status === 'confirmed') return 'Confirmed';
+        // A group-class session carries its enrolment's status, and "active"
+        // reads as jargon next to "Confirmed".
+        if (status === 'active') return 'Enrolled';
         return status.charAt(0).toUpperCase() + status.slice(1);
     }
 
     // How many upcoming lessons to show before the "Show all" reveal.
     const INITIAL_LESSON_COUNT = 5;
 
+    // Whose lesson this is. Only shown on an account that books for more than
+    // one person — on a single-student account the name is on every row and says
+    // nothing.
+    function lessonWhoHtml(l) {
+        if (students.length < 2 || !l.student_name) return '';
+
+        return ` <span class="us-my-lesson-who">— ${escHtml(String(l.student_name))}</span>`;
+    }
+
+    // A group-class session is a date in a term, not a booked slot: there is no
+    // lesson to cancel and no time to release, so it carries no Cancel button.
+    // Withdrawing from the class is a separate decision, made on the class page.
+    function isGroupSession(l) {
+        return l.kind === 'group_class';
+    }
+
+    // When a row meets. A class with no class time set has no clock to put it on,
+    // so it carries `schedule` — the studio's own wording, or its term dates — and
+    // that is shown verbatim in place of a date and time. A dated row with no
+    // duration knows when it starts but not when it ends, and says only that
+    // rather than inventing a finish.
+    function lessonWhenHtml(l) {
+        if (l.schedule) {
+            return escHtml(String(l.schedule));
+        }
+
+        const when = `${escHtml(dayLabel(dayKey(l.start_dt)))} · ${escHtml(timeOf(l.start_dt))}`;
+
+        return l.end_dt ? `${when}–${escHtml(timeOf(l.end_dt))}` : when;
+    }
+
     function lessonRowHtml(l) {
-        const title    = l.offering_title ? escHtml(String(l.offering_title)) : 'Lesson';
+        const group    = isGroupSession(l);
+        const title    = l.offering_title ? escHtml(String(l.offering_title)) : (group ? 'Group class' : 'Lesson');
         const duration = l.duration_minutes ? ` <span class="us-my-lesson-duration">(${escHtml(String(l.duration_minutes))} min)</span>` : '';
+        const badge    = group ? ' <span class="us-my-lesson-kind">Group class</span>' : '';
+        const action   = group ? '' : `<button type="button" class="us-cancel-lesson" data-lesson-id="${l.id}">Cancel</button>`;
+        // The two columns are divs, not spans: as spans the layout only held up
+        // while the stylesheet's display:flex won, and a theme rule on span
+        // collapsed the row onto itself.
         return `
             <div class="us-my-lesson">
-                <span class="us-my-lesson-info">
-                    <strong class="us-my-lesson-title">${title}${duration}</strong>
-                    <span class="us-my-lesson-when">${escHtml(dayLabel(dayKey(l.start_dt)))} · ${escHtml(timeOf(l.start_dt))}–${escHtml(timeOf(l.end_dt))}</span>
-                </span>
-                <span class="us-my-lesson-actions">
+                <div class="us-my-lesson-info">
+                    <strong class="us-my-lesson-title">${title}${duration}${badge}${lessonWhoHtml(l)}</strong>
+                    <span class="us-my-lesson-when">${lessonWhenHtml(l)}</span>
+                </div>
+                <div class="us-my-lesson-actions">
                     <span class="us-lesson-status us-lesson-status-${escHtml(String(l.status))}">${escHtml(lessonStatusLabel(String(l.status)))}</span>
-                    <button type="button" class="us-cancel-lesson" data-lesson-id="${l.id}">Cancel</button>
-                </span>
+                    ${action}
+                </div>
             </div>`;
     }
 
@@ -563,13 +662,19 @@
         const visible = upcoming.slice(0, INITIAL_LESSON_COUNT);
         const hidden  = upcoming.slice(INITIAL_LESSON_COUNT);
 
+        // Named for what the list actually holds now that group-class sessions
+        // sit in it alongside booked lessons.
+        const heading = upcoming.some(isGroupSession)
+            ? 'Your upcoming lessons and classes'
+            : 'Your upcoming lessons';
+
         myLessons.innerHTML = `
             <div class="us-my-lessons">
-                <h3>Your upcoming lessons</h3>
+                <h3>${heading}</h3>
                 ${visible.map(lessonRowHtml).join('')}
                 ${hidden.length ? `
                     <div class="us-my-lessons-more" hidden>${hidden.map(lessonRowHtml).join('')}</div>
-                    <button type="button" class="us-show-all-lessons">Show all ${upcoming.length} lessons</button>
+                    <button type="button" class="us-show-all-lessons">Show all ${upcoming.length}</button>
                 ` : ''}
             </div>`;
 
@@ -605,10 +710,43 @@
             .catch(() => { myLessons.innerHTML = ''; });
     }
 
+    /**
+     * Report a completed booking without taking the calendar away.
+     *
+     * This used to hide the slot list and leave the confirmation as the whole
+     * page, which is a dead end: the student had nothing to click and no way
+     * back to booking short of reloading. The notice now sits above a freshly
+     * loaded calendar, so "it worked" and "you can book again" are the same
+     * screen.
+     *
+     * Built from nodes rather than innerHTML because the message can carry a
+     * studio's e-transfer address.
+     */
     function showConfirmation(message) {
-        confirm.textContent = message;
-        slotList.style.display = 'none';
-        confirm.style.display = 'block';
+        confirm.textContent = '';
+
+        const text = document.createElement('p');
+        text.textContent = message;
+
+        const dismiss = document.createElement('button');
+        dismiss.type = 'button';
+        dismiss.className = 'us-notice-dismiss';
+        dismiss.textContent = 'Dismiss';
+        dismiss.addEventListener('click', hideConfirmation);
+
+        confirm.appendChild(text);
+        confirm.appendChild(dismiss);
+
+        // The `hidden` attribute rather than an inline display, which would
+        // outrank the stylesheet's `display: flex` and stack the notice's
+        // parts instead of laying them out in a row.
+        confirm.hidden = false;
+    }
+
+    function hideConfirmation() {
+        if (!confirm) return;
+        confirm.hidden = true;
+        confirm.textContent = '';
     }
 
     // The private-lesson catalog drives both the filter and the registration
@@ -633,16 +771,17 @@
         });
     }
 
+    /** Returns the load, so a caller can act once the calendar is back. */
     function loadSlots() {
         clearError();
         loadMyLessons();
 
         // An upcoming-lessons-only embed has no calendar to fill.
-        if (!slotList) return;
+        if (!slotList) return Promise.resolve();
 
-        slotList.style.display = 'block';
-        confirm.style.display = 'none';
-        Promise.all([apiFetch('availability'), loadCatalog()])
+        hideConfirmation();
+
+        return Promise.all([apiFetch('availability'), loadCatalog()])
             .then(([slots]) => {
                 allSlots = slots;
                 render();

assets/js/group-classes.js

@@ -17,6 +17,10 @@
     // enrolment controls.
     const singleOfferingId = Number(app.dataset.offering || 0);
 
+    // Who this account may enrol — children first, the account holder last, so a
+    // guardian's default selection is a child. One entry means no picker.
+    const students = window.usGuardian.parseStudents(app.dataset.students);
+
     function apiFetch(path, options = {}) {
         return fetch(restUrl + path, {
             ...options,
@@ -152,7 +156,7 @@
                 ${o.instructor_name ? `<p class="us-class-instructor">With ${escHtml(o.instructor_name)}</p>` : ''}
                 ${o.schedule_note ? `<p>${escHtml(o.schedule_note)}</p>` : ''}
                 ${!singleOfferingId && o.description ? `<p>${escHtml(o.description)}</p>` : ''}
-                <p>${escHtml(Number(o.price).toFixed(2))} ${escHtml(o.currency)}</p>
+                <p class="us-class-price">${escHtml(window.usPricing.priceLabel(o))}</p>
                 ${!enrolledMap.has(Number(o.id)) && isEnrollmentOpen(o) && enrolmentDeadline(o)
         ? `<p class="us-enrol-deadline">Enrol by ${escHtml(formatDate(enrolmentDeadline(o)))}</p>`
         : ''}
@@ -169,7 +173,10 @@
 
         list.querySelectorAll('.us-enrol-btn').forEach((btn) => {
             const offering = groups.find((o) => String(o.id) === btn.dataset.offeringId);
-            btn.addEventListener('click', () => openEnrolment(offering));
+            btn.addEventListener('click', () => {
+                hideConfirmation();
+                openEnrolment(offering);
+            });
         });
 
         list.querySelectorAll('.us-withdraw-btn').forEach((btn) => {
@@ -202,8 +209,10 @@
             <div class="us-register">
                 <h3>${escHtml(offering.title)}</h3>
                 <form id="us-enrol-form">
+                    ${window.usGuardian.selectorHtml(students, 'us-enrol-student')}
                     ${questions.map(questionField).join('')}
                     ${policies.map(policyField).join('')}
+                    ${window.usPricing.summaryHtml(offering)}
                     <p>
                         <button type="submit" class="us-enrol-btn">Confirm Enrolment</button>
                         <button type="button" id="us-group-cancel" class="us-cancel-btn">Back</button>
@@ -214,6 +223,10 @@
         document.getElementById('us-group-cancel').addEventListener('click', loadClasses);
         document.getElementById('us-enrol-form').addEventListener('submit', (e) => {
             e.preventDefault();
+            if (!window.usPricing.agreed(e.target)) {
+                showError(window.usPricing.AGREE_REQUIRED);
+                return;
+            }
             submitEnrolment(e.target, offering, questions);
         });
     }
@@ -234,6 +247,7 @@
             method: 'POST',
             body: JSON.stringify({
                 offering_id: offering.id,
+                student_id: window.usGuardian.selectedId('us-enrol-student'),
                 answers,
                 accepted_policy_version_ids: accepted,
             }),
@@ -243,25 +257,60 @@
             .then((res) => (res.payment
                 ? window.usPayment.collect('enrollment', res.id, list)
                 : null))
-            .then((result) => showConfirmation(window.usPayment.message(result)))
+            .then((result) => {
+                const message = window.usPayment.message(result);
+
+                // Order matters: loadClasses() clears any standing notice, and
+                // it is what puts the list back showing the new enrolment.
+                return loadClasses().then(() => showConfirmation(message));
+            })
             .catch((err) => showError(err.message));
     }
 
+    /**
+     * Report a completed enrolment without taking the class list away. Hiding
+     * the list left the student on a dead-end screen with no way back to
+     * browsing short of a reload; the notice now sits above a freshly loaded
+     * list instead. Mirrors booking.js.
+     *
+     * Built from nodes rather than innerHTML because the message can carry a
+     * studio's e-transfer address.
+     */
     function showConfirmation(message) {
-        confirm.textContent = message;
-        list.style.display = 'none';
-        confirm.style.display = 'block';
+        confirm.textContent = '';
+
+        const text = document.createElement('p');
+        text.textContent = message;
+
+        const dismiss = document.createElement('button');
+        dismiss.type = 'button';
+        dismiss.className = 'us-notice-dismiss';
+        dismiss.textContent = 'Dismiss';
+        dismiss.addEventListener('click', hideConfirmation);
+
+        confirm.appendChild(text);
+        confirm.appendChild(dismiss);
+
+        // The `hidden` attribute rather than an inline display, which would
+        // outrank the stylesheet's `display: flex` and stack the notice's
+        // parts instead of laying them out in a row.
+        confirm.hidden = false;
     }
 
+    function hideConfirmation() {
+        confirm.hidden = true;
+        confirm.textContent = '';
+    }
+
+    /** Returns the load, so a caller can act once the list is back. */
     function loadClasses() {
         clearError();
-        list.style.display = 'block';
-        confirm.style.display = 'none';
+        hideConfirmation();
         // The student's own enrolments are fetched alongside the catalog so a
         // class they already have an active enrolment in shows its status
         // instead of offering to enrol them again (the API would reject the
         // duplicate anyway). A cancelled enrolment does not block re-enrolling.
-        Promise.all([
+        return Promise.all([
             apiFetch('offerings?kind=group_class'),
             apiFetch('enrollments'),
         ])

assets/js/guardian.js

@@ -0,0 +1,68 @@
+/**
+ * "Who is this for?" picker, shared by the lesson-booking and group-class
+ * registration forms.
+ *
+ * The list arrives from the server already ordered children-first, with the
+ * account holder last, and this module preserves that order: a guardian's
+ * default selection is their first child, never themselves. Booking for the
+ * wrong child is a correctable mistake; quietly enrolling the parent in a class
+ * meant for their kid is not.
+ */
+(function () {
+    'use strict';
+
+    function escHtml(str) {
+        return String(str)
+            .replace(/&/g, '&')
+            .replace(/</g, '&lt;')
+            .replace(/>/g, '&gt;')
+            .replace(/"/g, '&quot;');
+    }
+
+    /**
+     * Read the server-rendered student list off a `data-students` attribute.
+     * Anything unparseable degrades to an empty list, which renders no picker
+     * and books for the signed-in user — the pre-guardian behaviour.
+     */
+    function parseStudents(raw) {
+        if (!raw) return [];
+        try {
+            const list = JSON.parse(raw);
+            return Array.isArray(list) ? list : [];
+        } catch (e) {
+            return [];
+        }
+    }
+
+    /**
+     * The picker's markup, or an empty string when there is nothing to choose:
+     * an account with only itself on the list never sees the question.
+     */
+    function selectorHtml(students, id) {
+        if (!students || students.length < 2) return '';
+
+        const options = students.map((s) => {
+            // The account holder reads as "Myself" — their own name next to their
+            // children's is ambiguous about which row is the parent.
+            const label = s.is_self ? `Myself (${s.name})` : s.name;
+            return `<option value="${Number(s.id)}">${escHtml(label)}</option>`;
+        }).join('');
+
+        return `
+            <p class="us-student-picker">
+                <label for="${id}">Who is this for?<br>
+                <select id="${id}" required>${options}</select></label>
+            </p>`;
+    }
+
+    /**
+     * The chosen student id, or 0 when no picker was rendered — the server
+     * reads 0 as "the caller books for themselves".
+     */
+    function selectedId(id) {
+        const el = document.getElementById(id);
+        return el ? Number(el.value) || 0 : 0;
+    }
+
+    window.usGuardian = { parseStudents, selectorHtml, selectedId };
+}());

assets/js/pricing.js

@@ -0,0 +1,170 @@
+/* global usScheduler */
+(function () {
+    'use strict';
+
+    // Cadence wording for each offering billing mode, in the phrasing a student
+    // sees beside a price. Mirrors Offering::VALID_BILLING_MODES.
+    const CADENCE = {
+        one_time: 'at booking',
+        full_term: 'up front',
+        weekly: 'weekly',
+        monthly: 'monthly',
+    };
+
+    // How each cadence is actually collected, spelled out beneath the price so
+    // the one-word cadence is never the only thing a student has to go on.
+    const CADENCE_NOTE = {
+        one_time: 'Charged once, when you book.',
+        full_term: 'Charged once, up front, for the whole term.',
+        weekly: 'Charged for each lesson, 24 hours before it starts.',
+        monthly: 'Charged on the 1st of each month, for that month’s lessons.',
+    };
+
+    // The billing modes whose price is a per-lesson fee billed again and again,
+    // rather than a single charge. Mirrors Offering::SCHEDULED_BILLING_MODES.
+    const RECURRING = ['weekly', 'monthly'];
+
+    function escHtml(str) {
+        return String(str)
+            .replace(/&/g, '&')
+            .replace(/</g, '&lt;')
+            .replace(/>/g, '&gt;')
+            .replace(/"/g, '&quot;');
+    }
+
+    function mode(billingMode) {
+        return CADENCE[billingMode] ? billingMode : 'one_time';
+    }
+
+    // A monthly charge rolls up every lesson that falls in the month, so a
+    // private lesson's monthly price is quoted *per lesson* — the fee is
+    // multiplied by the lessons booked that month. A group class is enrolled in
+    // once, as one schedule, so its monthly figure is quoted as it stands.
+    function isPerLessonMonthly(billingMode, kind) {
+        return 'monthly' === billingMode && 'group_class' !== kind;
+    }
+
+    // "50.00 CAD" — amount then currency code, the format used throughout the
+    // ledger, receipts and payment notices.
+    function money(amount, currency) {
+        return `${(Number(amount) || 0).toFixed(2)} ${String(currency || '')}`.trim();
+    }
+
+    // The studio's HST rate as a percentage, frozen onto every payment at
+    // booking time (comped students are the one exception — they are not taxed).
+    function taxRate() {
+        return Number(usScheduler.taxRate) || 0;
+    }
+
+    // Tax on a pre-tax amount, rounded the same way PaymentService does.
+    function tax(amount) {
+        return Math.round((Number(amount) || 0) * taxRate()) / 100;
+    }
+
+    function total(amount) {
+        return (Number(amount) || 0) + tax(amount);
+    }
+
+    // "50.00 CAD at booking" / "50.00 CAD per lesson monthly" / "Free" — the
+    // catalogue label, always carrying the cadence so a price is never shown
+    // without saying when it is due.
+    function priceLabel(offering) {
+        const price = Number(offering.price) || 0;
+        if (price <= 0) {
+            return 'Free';
+        }
+
+        const billingMode = mode(offering.billing_mode);
+        const perLesson   = isPerLessonMonthly(billingMode, offering.kind) ? 'per lesson ' : '';
+
+        return `${money(price, offering.currency)} ${perLesson}${CADENCE[billingMode]}`;
+    }
+
+    // The price block shown on a booking/enrolment form, followed by the
+    // agreement the student must tick to confirm they will pay it. A free
+    // offering has nothing to agree to, so it renders nothing at all.
+    //
+    // opts: { price, currency, billing_mode, kind, occurrences }
+    // `occurrences` is how many lessons a one-time price is charged for in this
+    // one registration (a weekly reservation claims several at once); it is
+    // ignored for the other modes, whose price is charged per period regardless.
+    function summaryHtml(opts) {
+        const price = Number(opts.price) || 0;
+        if (price <= 0) {
+            return '';
+        }
+
+        const billingMode = mode(opts.billing_mode);
+        const currency    = opts.currency;
+        const each        = total(price);
+        const count       = 'one_time' === billingMode ? Math.max(1, Number(opts.occurrences) || 1) : 1;
+
+        const taxLine = taxRate() > 0
+            ? `<p class="us-price-tax">${escHtml(`Plus ${taxRate()}% HST — ${money(each, currency)}${count > 1 ? ' per lesson' : ''}.`)}</p>`
+            : '';
+
+        return `
+            <div class="us-price">
+                <h4>Price</h4>
+                <p class="us-price-amount">
+                    <strong>${escHtml(money(price, currency))}</strong>
+                    <span class="us-price-cadence">${escHtml(cadenceLabel(billingMode, opts.kind))}</span>
+                </p>
+                ${taxLine}
+                <p class="us-price-note">${escHtml(count > 1
+                    ? 'Charged once, when you book — for every week reserved.'
+                    : CADENCE_NOTE[billingMode])}</p>
+                <label class="us-price-agree">
+                    <input type="checkbox" class="us-price-accept" required>
+                    ${escHtml(agreeText(each, currency, billingMode, count, opts.kind))}
+                </label>
+            </div>`;
+    }
+
+    // The cadence as it reads beside an amount: a private lesson billed monthly
+    // adds "per lesson", since the month's charge is that fee times the lessons
+    // it covers.
+    function cadenceLabel(billingMode, kind) {
+        return isPerLessonMonthly(billingMode, kind)
+            ? `per lesson ${CADENCE[billingMode]}`
+            : CADENCE[billingMode];
+    }
+
+    // What the student is ticking: the amount actually billed (tax included),
+    // and when. A weekly reservation is charged per lesson for every week it
+    // claims, and the claim can come up short when another student takes one of
+    // the times first — so its total is stated as a ceiling, never a promise.
+    function agreeText(each, currency, billingMode, count, kind) {
+        if (RECURRING.indexOf(billingMode) !== -1) {
+            // A monthly group class is enrolled in once and quoted as it stands;
+            // everything else recurring is a per-lesson fee.
+            return 'monthly' === billingMode && !isPerLessonMonthly(billingMode, kind)
+                ? `I agree to pay ${money(each, currency)} monthly.`
+                : `I agree to pay ${money(each, currency)} per lesson, billed ${CADENCE[billingMode]}.`;
+        }
+
+        if (count > 1) {
+            return `I agree to pay ${money(each, currency)} per lesson at booking — `
+                + `up to ${count} lessons, ${money(each * count, currency)} in total.`;
+        }
+
+        return `I agree to pay ${money(each, currency)} ${CADENCE[billingMode]}.`;
+    }
+
+    // Whether the payment agreement has been ticked. A form without one (a free
+    // offering) has nothing outstanding, so it counts as agreed.
+    function agreed(root) {
+        const box = root.querySelector('.us-price-accept');
+
+        return !box || box.checked;
+    }
+
+    // Shared by the booking and group-class flows so a price reads the same
+    // wherever a student meets it.
+    window.usPricing = {
+        priceLabel,
+        summaryHtml,
+        agreed,
+        AGREE_REQUIRED: 'Please confirm you agree to pay the amount shown.',
+    };
+}());

assets/js/register.js

@@ -1,57 +1,258 @@
 /**
- * Progressive enhancement for the two-step student registration form.
+ * Progressive enhancement for the student registration form.
  *
- * When account-signup questions are configured the form renders two panels
- * (`[data-step="1"]` account details, `[data-step="2"]` the questions) inside a
- * single form marked `data-steps="1"`. This script hides step two behind a
- * "Next" button that only advances once step one passes native validation.
- * Without JS both panels stay visible and the single submit still works.
+ * Two independent behaviours, both optional — without JS every panel stays
+ * visible and the single submit still works:
+ *
+ * 1. **Who are you registering?** The student section is hidden until the
+ *    choice is "on behalf of students" or "both", and "Add another student"
+ *    clones the student block. "On behalf of students" *alone* also takes the
+ *    account holder's own **About you** panel out of play — they are not a
+ *    student in that case, so the server ignores their birth year and answers
+ *    and the browser must not demand them. Under "both" they are a student and
+ *    do fill it in.
+ * 2. **Password strength.** The password is scored with zxcvbn (via WordPress's
+ *    own `wp.passwordStrength`) and a weak one is refused. The server applies
+ *    its own, coarser rule regardless — see `Auth\PasswordPolicy`.
  */
 (function () {
 	'use strict';
 
-	function enhance(form) {
-		var step1 = form.querySelector('[data-step="1"]');
-		var step2 = form.querySelector('[data-step="2"]');
-		var next = form.querySelector('.us-reg-next');
-		var back = form.querySelector('.us-reg-back');
+	var PASSWORD = window.usSchedulerPassword || {};
 
-		if (!step1 || !step2 || !next) {
+	/**
+	 * Gate the form on password strength.
+	 *
+	 * The verdict is attached to the field with `setCustomValidity()` rather than
+	 * by disabling the submit button: an invalid field blocks the submit without
+	 * the button having to know why.
+	 *
+	 * It is also re-scored on submit, which is the case the input handler alone
+	 * misses. zxcvbn's dictionary arrives after page load, and until it does the
+	 * meter has no opinion and the field is left valid — so a password typed in
+	 * the first second and submitted straight away would otherwise never be
+	 * scored at all, and the first the student heard of it would be the server
+	 * rejecting the whole form.
+	 */
+	function enhancePassword(form) {
+		var field = form.querySelector('#us-reg-pass');
+		var output = form.querySelector('#us-reg-pass-strength');
+		var strings = PASSWORD.strings || {};
+
+		if (!field || !PASSWORD.minScore) {
 			return;
 		}
 
-		function show(step) {
-			step1.hidden = step !== 1;
-			step2.hidden = step !== 2;
+		// What the password must not simply repeat back. Mirrors the identity
+		// check PasswordPolicy makes server-side.
+		function identity() {
+			var out = [];
+			var sources = form.querySelectorAll('#us-reg-email, #us-reg-name');
+
+			for (var i = 0; i < sources.length; i++) {
+				var value = (sources[i].value || '').trim();
+				if (value) {
+					out.push(value);
+					if (value.indexOf('@') > 0) {
+						out.push(value.split('@')[0]);
+					}
+				}
 			}
 
-		show(1);
+			return out;
+		}
 
-		next.addEventListener('click', function () {
-			var fields = step1.querySelectorAll('input, select, textarea');
+		function assess() {
+			var value = field.value || '';
 
-			for (var i = 0; i < fields.length; i++) {
-				if (!fields[i].checkValidity()) {
-					fields[i].reportValidity();
+			if (!value) {
+				report('', '');
 				return;
 			}
+
+			if (value.length < (PASSWORD.minLength || 8)) {
+				report(strings.short, 'short');
+				return;
 			}
 
-			show(2);
+			// zxcvbn's dictionary is fetched after load, and wp.passwordStrength
+			// reports -1 until it arrives. Say nothing and allow the submit in that
+			// window — the server still checks, and the next keystroke re-runs this
+			// once the dictionary is in.
+			if (!window.wp || !window.wp.passwordStrength || typeof window.zxcvbn === 'undefined') {
+				report('', '');
+				return;
+			}
+
+			var score = window.wp.passwordStrength.meter(value, identity(), '');
+
+			if (score < 0) {
+				report('', '');
+				return;
+			}
+
+			if (score >= 3) {
+				report(strings.strong, 'strong');
+			} else if (score >= PASSWORD.minScore) {
+				report(strings.medium, 'medium');
+			} else {
+				report(score <= 0 ? strings.veryWeak : strings.weak, 'weak');
+			}
+		}
+
+		/** Show the verdict, and make it the field's validity at the same time. */
+		function report(message, level) {
+			var acceptable = '' === level || 'medium' === level || 'strong' === level;
+
+			if (output) {
+				output.textContent = message || '';
+				output.className = 'us-password-strength' + (level ? ' is-' + level : '');
+			}
+
+			field.setCustomValidity(acceptable ? '' : message || '');
+		}
+
+		field.addEventListener('input', assess);
+		field.addEventListener('blur', assess);
+
+		// The identity check depends on these, so a password typed first and an
+		// email typed second is still caught.
+		var sources = form.querySelectorAll('#us-reg-email, #us-reg-name');
+		for (var i = 0; i < sources.length; i++) {
+			sources[i].addEventListener('change', assess);
+		}
+
+		// Native validation has already run by the time `submit` fires, so a
+		// verdict reached here has to stop the submit by hand.
+		form.addEventListener('submit', function (event) {
+			assess();
+
+			if (!field.checkValidity()) {
+				event.preventDefault();
+				field.reportValidity();
+			}
 		});
+	}
 
-		if (back) {
-			back.addEventListener('click', function () {
-				show(1);
+	/**
+	 * Rewrite a cloned child block's `children[0][…]` names and ids to the new
+	 * index, and clear the values carried over from the block it was cloned from.
+	 */
+	function reindex(block, index) {
+		block.setAttribute('data-child-index', String(index));
+
+		var fields = block.querySelectorAll('input, select, textarea');
+		for (var i = 0; i < fields.length; i++) {
+			var field = fields[i];
+
+			if (field.name) {
+				field.name = field.name.replace(/^children\[\d+\]/, 'children[' + index + ']');
+			}
+
+			var oldId = field.id;
+			if (oldId) {
+				field.id = oldId.replace(/^us-child-\d+-/, 'us-child-' + index + '-');
+
+				var label = block.querySelector('label[for="' + oldId + '"]');
+				if (label) {
+					label.setAttribute('for', field.id);
+				}
+			}
+
+			if (field.type === 'checkbox' || field.type === 'radio') {
+				field.checked = false;
+			} else {
+				field.value = '';
+			}
+		}
+	}
+
+	function enhanceGuardian(form) {
+		var choices = form.querySelectorAll('.us-registering-for');
+		var children = form.querySelector('#us-children');
+		var self = form.querySelector('#us-reg-self');
+
+		if (!choices.length || !children) {
+			return;
+		}
+
+		var addButton = children.querySelector('.us-add-child');
+		var nextIndex = 1;
+
+		/** The selected "who are you registering?" value; 'self' if somehow none is. */
+		function mode() {
+			for (var i = 0; i < choices.length; i++) {
+				if (choices[i].checked) return choices[i].value;
+			}
+			return 'self';
+		}
+
+		/**
+		 * Keep the form in step with the choice.
+		 *
+		 * Two independent questions, which is why "both" needs its own answer to
+		 * each:
+		 *
+		 * - Are student blocks in play? For "students" and "both".
+		 * - Is the account holder a student themselves? For "self" and "both" —
+		 *   only then are they asked for their own birth year and answers. A pure
+		 *   guardian gives those per student instead.
+		 *
+		 * Each panel is disabled as well as hidden. Disabling is what actually
+		 * settles it: a `required` field inside a hidden container makes the form
+		 * unsubmittable with no way to reach the offending control, and a disabled
+		 * fieldset is neither validated nor submitted. The server enforces the
+		 * same rules either way.
+		 */
+		function sync() {
+			var current = mode();
+			var wantsStudents = current !== 'self';
+			var asksSelf = current !== 'students';
+
+			children.hidden = !wantsStudents;
+			children.disabled = !wantsStudents;
+
+			// Belt and braces alongside the disabled fieldset, so the required
+			// state is right if a browser ever renders the block on its own.
+			var required = children.querySelectorAll('[data-us-child-required]');
+			for (var r = 0; r < required.length; r++) {
+				required[r].required = wantsStudents;
+			}
+
+			if (self) {
+				self.hidden = !asksSelf;
+				self.disabled = !asksSelf;
+			}
+		}
+
+		for (var c = 0; c < choices.length; c++) {
+			choices[c].addEventListener('change', sync);
+		}
+		sync();
+
+		if (addButton) {
+			addButton.addEventListener('click', function () {
+				var blocks = children.querySelectorAll('.us-child');
+				var clone = blocks[blocks.length - 1].cloneNode(true);
+
+				reindex(clone, nextIndex);
+				nextIndex += 1;
+
+				children.insertBefore(clone, addButton.parentNode);
+
+				// The clone carries the data attribute but not necessarily the
+				// current required state, so settle it the same way as the rest.
+				sync();
 			});
 		}
 	}
 
 	document.addEventListener('DOMContentLoaded', function () {
-		var forms = document.querySelectorAll('.us-register-form form[data-steps="1"]');
+		var forms = document.querySelectorAll('.us-register-form form');
 
 		for (var i = 0; i < forms.length; i++) {
-			enhance(forms[i]);
+			enhanceGuardian(forms[i]);
+			enhancePassword(forms[i]);
 		}
 	});
 })();

docs/features/account-registration.md

@@ -77,14 +77,62 @@ confirmation token's SHA-256 hash is stored; the token expires after 48h
 | `accepted_at`      | DATETIME         | When accepted; NULL while pending / for group links     |
 | `expires_at`       | DATETIME         | Explicit expiry (end of the chosen day); set on every group link, NULL for personal invites (which expire 14 days after creation) |
 
-## Registration Questions (signup step two)
+## Email and password validation
+
+Both are checked on the server on every signup path, and the browser is given a
+matching but *stricter* job so a bad password is caught before submitting.
+
+**Email** — `type="email"` and `required` in the markup, `is_email()` on the
+server, then `email_exists()` for "an account already exists for this email". A
+personal invite fixes the address and the server always uses the invite's own
+value, so a tampered field is ignored rather than validated.
+
+**Password** — `Auth\PasswordPolicy` is the authority. It deliberately does
+*not* try to reproduce a strength score in PHP; it rejects the categorically
+bad, which is what a server can check without shipping a dictionary:
+
+- shorter than `PasswordPolicy::MIN_LENGTH` (8 — NIST SP 800-63B's floor;
+  composition rules like "must contain a symbol" are deliberately **not** used,
+  as they push people towards predictable substitutions),
+- one of the well-known leaked passwords,
+- built from fewer than four distinct characters (`aaaaaaaa`, `abababab`),
+- containing the user's own display name, email, or the part before the `@`.
+
+The nuance happens in the browser. `register.js` scores the password with
+zxcvbn through WordPress's own `password-strength-meter` script and refuses to
+submit below `PasswordPolicy::MIN_SCORE` (2 of 4 — "medium"; enough to stop a
+guessable password without demanding a passphrase to book a piano lesson). The
+thresholds reach JavaScript via `wp_localize_script()` from the same constants
+the server enforces, so the two cannot drift apart.
+
+The verdict is applied with `setCustomValidity()` on the password field rather
+than by disabling a button: an invalid field stops the submit without the button
+needing to know why. zxcvbn's dictionary loads asynchronously, so the gate stays
+open until it arrives — the server is the check that always runs.
+
+The password is also **re-scored on submit**, not only as it is typed. Native
+validation has already run by the time the `submit` event fires, so a verdict
+reached there stops the submit by hand (`preventDefault()` + `reportValidity()`).
+Without that, a password typed in the second before the dictionary arrived was
+never scored at all, and the first the person heard of it was the server
+rejecting the whole form.
+
+## Registration Questions
 When the studio has configured **account-scope** registration questions
-(**Offerings → Questions → "Account signup"**, see `registration-questions.md`), the
-registration form becomes two steps: name/email/password/policies first, then the required
-questions. This applies to **every** signup path (invite, group link, self-approval).
-Required answers are validated before the account is created, and are stored against the new
-user (`us_question_answers`, `registration_type = 'account'`). A studio admin reviews them
-under **Registration Information** on the student's admin screen.
+(**Offerings → Questions → "Account signup"**, see `registration-questions.md`), they
+are asked on the main form in an **About you** panel — alongside the account
+holder's birth year, above the students they are adding, and only when they are a
+student themselves (`self` or `both`). This applies to **every** signup path
+(invite, group link, self-approval). Required answers are validated before the
+account is created, and are stored against the new user (`us_question_answers`,
+`registration_type = 'account'`). A studio admin reviews them under **Registration
+Information** on the student's admin screen.
+
+The form is one page with one submit. The questions used to be a second step
+behind a "Next" button; that put what the studio needs to know about an adult
+student on a screen reached only after everything else, and the two-step gate is
+what made a weak password reachable — it advanced on a `checkValidity()` that had
+not yet scored anything.
 
 ## Policy Acceptance Scope
 Policies declare **when** they must be accepted via `us_policies.acceptance_scope`:
@@ -132,7 +180,7 @@ recorded in `us_policy_acceptances` with `registration_type = account` and
 The block's **After registration** panel picks the page a student continues to once
 registration finishes, and whether they get there by hand or automatically.
 
-- **Sign-in page** (`loginPageId` / `login_page_id`) — the target of the "Sign in to your account" link shown after email confirmation (`?us_confirmed=1|ready`, falling back to the WordPress login screen) and of the "Continue to your account" link an invited student sees on the spot (`?us_registered=invite`; no link at all with no page chosen, since an already-signed-in student has no use for the login screen).
+- **Sign-in page** (`loginPageId` / `login_page_id`) — the target of the "Sign in to your account" link shown after email confirmation (`?us_confirmed=1|ready`, falling back to the WordPress login screen) and of the **"Continue to _<page title>_"** link every **logged-in** visitor gets (`RegistrationPage::continueLink()`): an invited student who just finished signing up (`?us_registered=invite`), and anyone who simply arrives at the registration page already signed in. The link names the chosen page (via `get_the_title()`) so the visitor knows where it goes; an untitled page falls back to "Continue to your account" rather than reading "Continue to ". Neither gets the WordPress-login-screen fallback — with no page chosen there is no link at all, since sending someone already signed in to the login screen is the same dead end with extra steps.
 - **Redirect automatically** (`autoRedirect`, block only) — sends the student to that page instead of showing the link, via `BlockRegistrar::maybeAutoRedirect()` on `template_redirect`. It fires only on those two finished states (`RegistrationPage::isRegistrationComplete()`), so the "check your email" step, a validation error, and an `expired` confirmation link are always shown rather than redirected past. With no page chosen nothing happens — there is deliberately no login-screen fallback for the redirect. See `editor-blocks.md`.
 
 ## Token Redirect
@@ -165,3 +213,12 @@ No-op when no registration page is set.
 - `tests/Unit/Auth/RegistrationApprovalControllerTest.php`
 - `tests/Unit/Auth/RegistrationMailerTest.php`
 - `tests/Unit/Payment/StudioSettingsTest.php`
+
+## Parent/Guardian Signup
+The registration form asks **"Who are you registering?"** — just myself, on behalf
+of one or more students, or both — and the student-bearing choices reveal a
+repeatable child block (name, birth year, and the account-scope questions asked
+**per child**). Each child becomes a login-less `us_student` user linked to the
+guardian, and the signup policies are recorded once per child with the guardian as
+the acceptor. Available on every signup path — personal invite, group link, and
+self-approval. See `parent-guardian-accounts.md`.

docs/features/availability-management.md

@@ -25,8 +25,9 @@ A slot's `duration_minutes` is matched against the offering a student picks: a
 `AvailabilitySlot::splitByDuration()` chunks a submitted window into consecutive
 `duration_minutes` slots; `AvailabilityRepository::createFromWindow()` persists
 one row per chunk. A trailing remainder shorter than the lesson length is
-dropped. Windows must start and end on the same day and fit at least one lesson
-(REST responds `400 invalid_window` otherwise; the admin form is a no-op).
+dropped. Windows must start and end on the same day and fit at least one lesson;
+both the REST endpoint and the admin form reject one that does not, with a
+message saying so (see **REST API** below).
 `AvailabilityRepository::splitOversizedWindows()` is a data migration (run by
 `Installer` on activation or version change) that rewrites pre-split rows.
 
@@ -44,6 +45,27 @@ Instructors access **My Availability** in wp-admin (`?page=us-availability`).
 - Bulk delete: the list view has a checkbox per unbooked slot (with a select-all header checkbox) and a **Delete selected** button (`usc_action=bulk_delete`, `slot_ids[]`); each id is ownership-checked, and booked slots are refused at the repository level
 - Current slots can be shown as a **weekly calendar** (the default, navigated with `usc_week=Y-m-d`) or a **list** (`usc_view=list`); the grid honours the site's `start_of_week` option via `Availability\WeekCalendar`
 
+### Feedback
+Every submitted action reports its outcome as a wp-admin notice — a success
+notice naming the number of slots created or deleted, or an error explaining the
+refusal. `AvailabilityController::handleFormAction()` returns a
+`[$notice, $error]` pair that `templates/admin/availability.php` renders.
+
+This matters because the form used to fail **silently**: a window shorter than
+the chosen lesson length splits into no slots, so nothing was written, nothing
+was said, and the page simply reloaded. Submitting 5:30–6:00 PM with the length
+select on its 60-minute default was the reported case. Invalid datetimes, an end
+before the start, a window spanning two days, and an offering belonging to
+another instructor were all silent in the same way.
+
+### Lesson-length choices
+`assets/js/availability-admin.js` (enqueued by `AdminMenu::enqueueAssets()` on
+this screen only) hides any lesson length longer than the entered window, falls
+back to the longest one that still fits when the current pick is hidden, and
+disables the submit button when nothing fits. It is a convenience, not a
+guarantee — the server validates the same window regardless. The choices come
+from `AvailabilitySlot::DURATION_CHOICES`.
+
 ## Public Calendar
 The front-end booking shortcode renders open slots from `GET /availability`
 either as an agenda-style list grouped by day or as a **weekly calendar** with
@@ -62,12 +84,29 @@ with the **Show Only** lesson-type filter — see `lesson-booking.md`.
 `GET` supports query params: `instructor_id`, `offering_id`, `duration_minutes`, `from` (datetime), `to` (datetime).
 Slots whose start has already passed are never returned.
 
-`POST` validates `start_dt`/`end_dt` (admin form and REST alike) via
-`AvailabilitySlot::normalizeDateTime()`: the canonical `Y-m-d H:i[:s]` and HTML
-`datetime-local` (`Y-m-d\TH:i[:s]`) forms are normalised to `Y-m-d H:i:s`;
-anything else — or an end not after the start — is rejected (REST responds
-`400 invalid_datetime`; the admin form is a no-op). A valid window is stored as
+`POST` runs every submitted window — admin form and REST alike — through
+`Availability\WindowValidator`, which returns either the window ready to persist
+or a `WP_Error`. The REST endpoint returns that error directly (its `status`
+data makes it a 400); the admin screen shows `get_error_message()` in a notice.
+Sharing one validator is deliberate: the two paths previously checked the same
+rules separately, and the admin copy was both laxer (no offering-ownership
+check) and mute (a bare `return` on every rejection).
+
+| Rejection | Code |
+|---|---|
+| Start or end not a real datetime | `invalid_datetime` |
+| End at or before the start | `invalid_datetime` |
+| Window spans two days | `invalid_window` |
+| Window shorter than the lesson length (so it holds no slots) | `invalid_window` |
+| Offering missing, or owned by another instructor | `invalid_offering` |
+
+`start_dt`/`end_dt` are normalised by `AvailabilitySlot::normalizeDateTime()`:
+the canonical `Y-m-d H:i[:s]` and HTML `datetime-local` (`Y-m-d\TH:i[:s]`) forms
+become `Y-m-d H:i:s`; anything else is rejected. A valid window is stored as
 lesson-length slots and `201` returns `{ "ids": [...] }` for every row created.
+`weeks` is clamped to `AvailabilitySlot::MAX_WEEKLY_OCCURRENCES` in the
+repository, so the form's `max` cannot be bypassed by posting directly. A write
+that fails entirely returns `500 not_saved` rather than a `201` listing no ids.
 
 Times are displayed in 12-hour AM/PM form in the booking calendar and wp-admin
 lists.
@@ -78,6 +117,8 @@ lists.
 - Week bucketing: `Unsupervised\Schedular\Availability\WeekCalendar`
 - Admin controller: `Unsupervised\Schedular\Availability\AvailabilityController`
 - REST endpoint: `Unsupervised\Schedular\Availability\AvailabilityEndpoint`
+- Shared window validation: `Unsupervised\Schedular\Availability\WindowValidator`
+- Admin form script: `assets/js/availability-admin.js`, enqueued by `AdminMenu::enqueueAssets()`
 
 ## Tests
 - `tests/Unit/Availability/AvailabilityControllerTest.php`
@@ -85,3 +126,4 @@ lists.
 - `tests/Unit/Availability/AvailabilitySlotTest.php`
 - `tests/Unit/Availability/AvailabilityEndpointTest.php`
 - `tests/Unit/Availability/WeekCalendarTest.php`
+- `tests/Unit/Availability/WindowValidatorTest.php`

docs/features/credits.md

@@ -121,3 +121,12 @@ refund of a shared payment.
 - `tests/Unit/Payment/PaymentTest.php` (`netDue`)
 - `tests/Unit/Booking/BookingEndpointTest.php` (credit issued on cancel)
 - `tests/Unit/Auth/StudentHistoryTest.php` (`creditBalance`, `credits`)
+
+## Family Balances
+A credit records the student it was earned for (`student_id`) and the account
+that **holds** it (`payer_id`). Balance lookups — `availableBalance()`,
+`findAvailableByPayer()`, `consume()` — key on the payer, so a family shares one
+balance and a credit from one child's cancelled lesson can settle a sibling's
+next charge. A child's admin screen still lists the credits their own
+cancellations produced, labelled with whose account holds the balance. See
+`parent-guardian-accounts.md`.

docs/features/editor-blocks.md

@@ -1,8 +1,8 @@
 # Editor Blocks
 
-Gutenberg dynamic-block wrappers for the plugin's four front-end shortcodes,
-so the pages can be previewed and styled inside the block editor instead of
-appearing as grey shortcode text.
+Gutenberg dynamic-block wrappers for the plugin's front-end shortcodes, so the
+pages can be previewed and styled inside the block editor instead of appearing
+as grey shortcode text.
 
 ## Blocks
 
@@ -12,6 +12,8 @@ appearing as grey shortcode text.
 | `us-scheduler/student-login` | `[us_student_login]` | `Auth\LoginPage::render()` |
 | `us-scheduler/student-register` | `[us_student_register]` | `Auth\RegistrationPage::render()` |
 | `us-scheduler/group-classes` | `[us_group_classes]` | `GroupClass\GroupClassPage::render()` |
+| `us-scheduler/family` | `[us_family]` | `Guardian\FamilyPage::render()` |
+| `us-scheduler/account` | `[us_account]` | `Auth\AccountPage::render()` |
 
 The shortcodes remain registered for back-compat; blocks and shortcodes share
 the same page objects (constructed once in `Plugin::boot()`), so front-end
@@ -21,7 +23,7 @@ transform.
 
 ## Block options
 
-Four blocks have sidebar (inspector) options:
+Most blocks have sidebar (inspector) options:
 
 | Block | Attribute | Default | Effect |
 |---|---|---|---|
@@ -34,6 +36,8 @@ Four blocks have sidebar (inspector) options:
 | `us-scheduler/student-login` | `autoRedirect` (boolean) | `false` | Send logged-in visitors straight to the booking page instead of showing the link. Does nothing until a booking page is chosen. |
 | `us-scheduler/student-register` | `loginPageId` (number) | `0` | Page students continue to once registration finishes — the "Sign in to your account" link after they confirm their email, and the "Continue to your account" link an invited student gets on the spot. `0` = the WordPress login screen for the confirmation link, and no link at all for the (already signed-in) invited student. Shortcode equivalent: `[us_student_register login_page_id="…"]`. |
 | `us-scheduler/student-register` | `autoRedirect` (boolean) | `false` | Send students straight to that page instead of showing the link. Does nothing until a page is chosen — there is no login-screen fallback here. |
+| `us-scheduler/family` | `loginPageId` (number) | `0` | Where visitors who are not signed in are sent to log in. Shortcode equivalent: `[us_family login_page_id="…"]`. |
+| `us-scheduler/account` | `loginPageId` (number) | `0` | Where signing out returns to, and where a signed-out visitor is offered a **Sign in** link. `0` = signing out returns to the current page, and a signed-out visitor sees **nothing at all** — see below. Shortcode equivalent: `[us_account login_page_id="…"]`. |
 | `us-scheduler/group-classes` | `offeringId` (number) | `0` | Restrict the page to a single group class, for embedding on a page dedicated to that class. The class description is then omitted — only the schedule, instructor, price and enrolment controls are shown, so the surrounding page's own copy is not repeated. `0` = browse all classes, descriptions included. Shortcode equivalent: `[us_group_classes offering="…"]`. |
 
 The page selects list all published pages; if a chosen page is later deleted,
@@ -105,6 +109,10 @@ placeholder content:
 - **Login** — the real `templates/frontend/login-page.php` template (it has
   no request-state dependencies).
 - **Registration** — a disabled sample of the `.us-register-form` fields.
+- **Account** — a populated sample panel. Deliberately populated whatever the
+  editor user's own state: on the published page a signed-out visitor may see
+  nothing at all, and an empty box tells the person placing the block nothing
+  about where it will sit.
 
 Each preview starts with a `.us-editor-note` paragraph explaining what the
 published page shows instead. The note class only appears in editor previews.
@@ -118,5 +126,22 @@ published page shows instead. The note class only appears in editor previews.
   and fallbacks.
 - `tests/Unit/Auth/LoginPageTest.php` — logged-in booking-link targets and
   fallbacks.
+- `tests/Unit/Auth/AccountPageTest.php` — what each visitor sees, the
+  sign-out redirect target, and the signed-out empty render.
 - `tests/Unit/BlockPreviewTest.php` — preview markup mirrors the live CSS
   classes/ids and includes the editor note.
+
+## The account block's signed-out behaviour
+
+`us-scheduler/account` is the one block that can render **nothing**. It is meant
+for a header, sidebar or account page, and its whole subject is the person
+signed in — which a stranger is not. A bare "you are not signed in" in a site
+header is noise that cannot be acted on, so:
+
+- **No login page chosen** → empty string for signed-out visitors.
+- **Login page chosen** → a single **Sign in** link.
+
+Signed in, it shows the display name (`Auth\UserName::format()`, so a username
+is never exposed), the account email, and a **Sign out** link — deliberately
+nothing else. Signing out returns to the chosen login page, or to the current page when there
+is none, so a header sign-out does not also navigate the visitor somewhere.

docs/features/group-classes.md

@@ -31,6 +31,55 @@ Assigning an instructor to a scheduled class removes that instructor's open
 booking slots at the class time and flags any already-booked lesson that clashes;
 see **Instructor assignment** in `offerings.md`.
 
+### Sessions in the "upcoming" views
+`GroupClass\SessionSchedule` turns an enrolment into the dated sessions behind it,
+so a class appears alongside one-to-one lessons wherever upcoming lessons are
+listed. A class is a term, not rows in `us_availability`, so an enrolment carries
+no date of its own — the concrete windows come from `Offering::sessionWindows()`,
+the same derivation the billing scan and the class-slot reconciler use, which is
+what keeps a student's list, an instructor's list and the invoice agreeing on when
+the class meets.
+
+- `upcomingForStudent()` — every not-yet-started session of each enrolment that is
+  not `cancelled`. `completed` is a *billing* state and says nothing about the
+  calendar, so those sessions stay listed.
+- `upcomingForInstructor()` — every session of each active group class they own,
+  one row per session however many students are enrolled; enrolments are not
+  consulted, because a class still has to be taught if nobody has signed up yet.
+
+**A class you are enrolled in must never silently vanish from these lists.** Both
+the class time and the duration are optional on the offering form, and the
+schedule note exists precisely so a studio can write "Tuesdays 4:00pm" rather than
+pin the class to a clock. So the schedule degrades instead of disappearing:
+
+| Class has | What the list gets |
+|---|---|
+| date + time + duration | one dated row per remaining session, with an end time |
+| date + time, no duration | one dated row per remaining session, `end_dt` empty — when it starts is worth showing without guessing when it ends |
+| no class time | **one** row for the class as a whole, sorted by term start (or by "now" once the term is under way), with `schedule` text from `Offering::scheduleLabel()` — the studio's note, else the term dates, else "Schedule to be confirmed" |
+| a term whose last day has passed | nothing |
+
+`schedule` is the tell: non-null means "a class, described in words, not a session
+at a known time", and every renderer shows that text in place of a date and time.
+An undated row's `start_dt` is a **sort key only** — never displayed.
+
+`Offering::sessionStarts()` is the split that makes this work: it needs only the
+date and the time, because knowing *when* a class meets is a separate question
+from knowing how long it runs. `sessionWindows()` is that plus the duration, and
+still returns nothing without one — availability blocking and per-session billing
+need both ends of a window.
+
+Consumers mark these rows `kind = 'group_class'` (`SessionSchedule::KIND`) and
+withhold the per-lesson actions from them: a session is one date in a term, not a
+booked slot, so there is nothing to cancel session by session and no slot to
+release. Withdrawing from the class is the separate, whole-enrolment decision.
+
+Where they show up: the `[us_scheduler]` upcoming panel via `GET /bookings`
+(students and instructors both), and the **Upcoming lessons** table on the admin
+student detail page. Only *upcoming* sessions are added there — the
+**Group-class enrolments** table below already records the whole history, and a
+term's worth of past dates would bury the lessons under "Past lessons".
+
 ## Enrolment Flow
 The class list is loaded together with the student's own enrolments
 (`GET /enrollments`); a class the student already has an `active` enrolment in
@@ -38,12 +87,13 @@ shows "You are enrolled in this class." instead of the Enrol button (the
 server would reject the duplicate with `409 already_enrolled` regardless — a
 cancelled enrolment does not block re-enrolling).
 
-1. Student opens a group class from the offering catalog.
+1. Student opens a group class from the offering catalog. Each class card shows its price with the **cadence** it is billed on — `120.00 CAD up front`, `40.00 CAD monthly`, and so on.
 2. Student answers the offering's questions (`GET /offerings/{id}/questions`).
 3. Student accepts the current published policy versions (`GET /policies`) — required to continue.
-4. Full-term payment is taken per the student's billing method (card by default; `pending` for e-transfer; skipped for comp). See `payments.md`.
-5. `POST /enrollments` creates the enrolment (`status = active`), records answers and policy acceptances, and links the payment — but only if the offering's `capacity` has not been reached.
-6. On successful payment (or comp) a receipt is emailed.
+4. The enrolment form restates the price (with HST) and requires a second, separate agreement to pay that amount before it will submit. See **Price Display and the Pay Agreement** in `payments.md`.
+5. Full-term payment is taken per the student's billing method (card by default; `pending` for e-transfer; skipped for comp). See `payments.md`.
+6. `POST /enrollments` creates the enrolment (`status = active`), records answers and policy acceptances, and links the payment — but only if the offering's `capacity` has not been reached.
+7. On successful payment (or comp) a receipt is emailed.
 
 Capacity is enforced at enrolment time by counting `active` rows for the offering;
 a class at capacity rejects further enrolments.
@@ -174,6 +224,7 @@ class becomes enrollable for them — they choose whether to enrol.
 - Repository: `Unsupervised\Schedular\GroupClass\EnrollmentRepository` (`countActiveForOffering`/`hasActiveEnrollment` enforce capacity and prevent duplicates)
 - Access grants: `Unsupervised\Schedular\GroupClass\GroupAccess` + `GroupAccessRepository` (`hasGrant`, `findGrantedOfferingIds`, `markEnrolled`, `linkStudentByEmail`)
 - Model: `Unsupervised\Schedular\GroupClass\Enrollment`
+- Sessions: `Unsupervised\Schedular\GroupClass\SessionSchedule` (`upcomingForStudent`, `upcomingForInstructor`) — consumed by `Booking\BookingEndpoint::myLessons()` and `Auth\StudentController`
 - Admin controller: `Unsupervised\Schedular\GroupClass\GroupClassController` — `renderPage` (studio admin per-class summary, `view_all_lessons`) and `renderInstructorPage` (instructor summary + `?class_id` roster detail, `view_own_lessons`)
 - REST endpoint: `Unsupervised\Schedular\GroupClass\EnrollmentEndpoint`
 - Frontend: `Unsupervised\Schedular\GroupClass\GroupClassPage` (`[us_group_classes]` shortcode; `offering="…"` restricts it to a single class for embedding on a dedicated page — the block equivalent is the `offeringId` attribute). In single-class mode `assets/js/group-classes.js` leaves the class description out of the card, since the page it is embedded on already describes the class; the schedule, instructor, schedule note, price and enrolment controls are still shown.
@@ -192,4 +243,11 @@ class becomes enrollable for them — they choose whether to enrol.
 - `tests/Unit/GroupClass/GroupAccessTest.php`
 - `tests/Unit/GroupClass/GroupAccessRepositoryTest.php`
 - `tests/Unit/GroupClass/GroupClassPageTest.php`
+- `tests/Unit/GroupClass/SessionScheduleTest.php`
 - `tests/Unit/Offering/OfferingEndpointTest.php` (catalog merges granted invite-only classes)
+
+## Enrolling A Child
+`POST /enrollments` accepts the same optional **`student_id`** as booking,
+authorised through `Guardian\GuardianService::canActFor()`; `GET /enrollments`
+covers the guardian's whole household, and a guardian may withdraw any of their
+children. See `parent-guardian-accounts.md`.

docs/features/lesson-booking.md

@@ -25,11 +25,13 @@ Students register for a private lesson by choosing an offering, picking a time (
 3. For a `weekly` reservation, the same weekday/time is held for the rest of the offering's term.
 4. Student answers the offering's questions (`GET /offerings/{id}/questions`).
 5. Student accepts the current published policy versions (`GET /policies`) — required to continue.
-6. Payment is taken per the student's billing method (card by default; `pending` for e-transfer; skipped for comp). See `payments.md`.
-7. `POST /bookings` creates the lesson row(s) (`status = pending`), records answers and policy acceptances, marks `us_availability.is_booked = 1`, and links the payment. A booking with nothing owed (a free offering) creates no payment and is `confirmed` immediately.
-8. On successful payment (or comp) the lesson is `confirmed` and a receipt is emailed.
-9. Instructor sees the booking under **My Lessons** and may update status via `PATCH /bookings/{id}/status`.
-10. The booking page also shows the student their upcoming lessons (`GET /bookings`) — each with the booked offering's name and length, when it happens, a per-lesson status badge (pending payment / confirmed), and a **Cancel** button. Only the soonest five are shown; a **Show all** control reveals the rest. `GET /bookings` includes `offering_title` and `duration_minutes` for each lesson so the list needs no extra request.
+6. Student is shown what the booking costs — the offering's price with its **cadence** (at booking / up front / weekly / monthly), plus HST — and must tick a second, separate agreement to pay that amount before the form will submit. A weekly reservation quotes the per-lesson fee and the ceiling on the total it can claim. A free offering shows no price block. See **Price Display and the Pay Agreement** in `payments.md`.
+7. Payment is taken per the student's billing method (card by default; `pending` for e-transfer; skipped for comp). See `payments.md`.
+8. `POST /bookings` creates the lesson row(s) (`status = pending`), records answers and policy acceptances, marks `us_availability.is_booked = 1`, and links the payment. A booking with nothing owed (a free offering) creates no payment and is `confirmed` immediately.
+9. On successful payment (or comp) the lesson is `confirmed` and a receipt is emailed.
+10. Instructor sees the booking under **My Lessons** and may update status via `PATCH /bookings/{id}/status`.
+11. The confirmation is a **dismissible notice above the calendar**, not a screen of its own. The calendar is reloaded first — so the slot just taken is gone and the upcoming-lessons panel is current — and the notice is shown over it. Booking again therefore needs no page reload. The notice clears when it is dismissed, when another slot's booking form is opened, and on any reload of the calendar. `group-classes.js` does the same for enrolments.
+12. The booking page also shows the student their upcoming lessons (`GET /bookings`) — each with the booked offering's name and length, when it happens, a per-lesson status badge (pending payment / confirmed), and a **Cancel** button. Only the soonest five are shown; a **Show all** control reveals the rest. `GET /bookings` includes `offering_title` and `duration_minutes` for each lesson so the list needs no extra request.
 
 ## Lesson-Type Filter
 Not every open slot can be booked as every private-lesson type — a slot tied to
@@ -124,12 +126,20 @@ active `private_lesson` offerings whose `duration_minutes` matches the slot.
 for students; the instructor's for callers with `manage_availability`), each
 with the slot's `start_dt`/`end_dt`.
 
+It also returns **upcoming group-class sessions**, sorted in among the lessons by
+start time (`GroupClass\SessionSchedule`). A student gets every remaining session
+of every class they are enrolled in; an instructor gets every session of the
+classes they teach. These rows carry `kind: "group_class"` — a session is a date
+in a term rather than a booked slot, so `booking.js` labels it and gives it no
+Cancel button. Lesson rows carry no `kind`, and that absence is what marks them
+cancellable.
+
 Group classes follow the same registration flow but enrol against an offering of
 kind `group_class`; see `group-classes.md`.
 
 ## Admin Interface
 - **Scheduler** (`view_all_lessons` — studio admin / administrators): all upcoming lessons across all instructors
-- **My Lessons** (`view_own_lessons`): upcoming lessons for the logged-in instructor. Hidden for users who also hold `view_all_lessons` — Scheduler is a superset, so the menu item would only duplicate it.
+- **My Lessons** (`view_own_lessons`): upcoming lessons — and upcoming sessions of the instructor's own group classes — for the logged-in instructor. Hidden for users who also hold `view_all_lessons` — Scheduler is a superset, so the menu item would only duplicate it.
 
 Both pages open in a **Week** calendar view by default (`usc_view`/`usc_week`
 query params, same pattern as the availability page, bucketed via
@@ -150,9 +160,10 @@ instructor may only open their own lessons; the studio **Scheduler** may open an
 - Model: `Unsupervised\Schedular\Booking\Lesson`
 - Registration gate: `Unsupervised\Schedular\Registration\RegistrationGate` — validates and records intake answers + booking-scoped policy acceptances; shared with group enrolment
 - Admin controller: `Unsupervised\Schedular\Booking\LessonController`
-- Admin lesson detail presenter: `Unsupervised\Schedular\Booking\LessonDetail` (per-lesson intake answers + policy acceptances), template `templates/admin/lesson-detail.php`
+- Admin lesson detail presenter: `Unsupervised\Schedular\Booking\LessonDetail` (per-lesson intake answers + policy acceptances), template `templates/admin/lesson-detail.php`. A weekly series is answered for and agreed to once, against the anchor lesson, so the presenter reads `series_id ?? id` — every occurrence shows the same intake and audit trail, not just the first.
 - REST endpoint: `Unsupervised\Schedular\Booking\BookingEndpoint`
 - Frontend: `Unsupervised\Schedular\Booking\BookingPage`, `Unsupervised\Schedular\Auth\LoginPage`
+- Upcoming-lessons panel: rendered client-side into `#us-my-lessons` by `assets/js/booking.js` (`lessonRowHtml`/`renderMyLessons`), mirrored for the editor by `BlockPreview::upcomingLessons()` — keep the two markup shapes in step.
 
 > **Payment seam:** a priced booking is created with `status = pending` and its
 > payment linked via `payment_id`; the lesson is confirmed when the payment is
@@ -160,6 +171,14 @@ instructor may only open their own lessons; the studio **Scheduler** may open an
 > Unpriced bookings skip the seam entirely and are confirmed at creation.
 > `GET /policies?scope=booking` returns just the booking-gate policies the form
 > must collect.
+>
+> **Frontend CSS scoping:** every rule for the booking page's own markup is
+> written under `#us-booking-app` (`assets/css/frontend.css`). These panels sit
+> inside whatever layout the active theme provides, and bare class selectors lose
+> to theme rules on `div`/`span`/`strong` — which flattens the flex layout and
+> renders the lesson details on top of the actions. The row's two columns are
+> `div`s for the same reason: the layout must not depend on overriding the
+> inline default. New booking-page rules should follow both conventions.
 
 ## Tests
 - `tests/Unit/Booking/BookingRepositoryTest.php`
@@ -167,3 +186,12 @@ instructor may only open their own lessons; the studio **Scheduler** may open an
 - `tests/Unit/Booking/LessonControllerTest.php`
 - `tests/Unit/Booking/LessonDetailTest.php`
 - `tests/Unit/Booking/BookingEndpointTest.php`
+
+## Booking For Someone Else
+A guardian books for their children from their own account. `POST /bookings`
+accepts an optional **`student_id`**, honoured only when
+`Guardian\GuardianService::canActFor()` confirms the caller is that student's
+guardian — anything else is a `403`. The booking form's "Who is this for?" picker
+lists **children first**, so the default selection is never the parent.
+`GET /bookings` returns the whole household, and a guardian may cancel any of
+their children's lessons. See `parent-guardian-accounts.md`.

docs/features/offerings.md

@@ -33,7 +33,12 @@ An offering is anything a student can register for: a private-lesson type (30 or
 - `one_time` — charged once at booking (a single private lesson).
 - `full_term` — charged in full upfront at registration (a weekly private reservation or a year-long group class). See `payments.md`.
 - `weekly` — **not** charged at registration; a pending payment for one lesson's fee is generated **24 hours before each lesson** by the daily billing scan.
-- `monthly` — **not** charged at registration; on the **1st of each month** a single pending payment is generated for every lesson that falls in that month (4 lessons ⇒ 4 × fee).
+- `monthly` — **not** charged at registration; on the **1st of each month** a single pending payment is generated for that month. A **private lesson**'s price is a per-lesson fee, so the month is billed (#lessons in the month) × fee; a **group class**'s price is the monthly fee itself, billed once for the month however many times the class meets in it.
+
+Students see the mode as a **cadence** beside every price on the front end — *at
+booking*, *up front*, *weekly*, *monthly* — and confirm it explicitly before a
+booking or enrolment goes through. See **Price Display and the Pay Agreement** in
+`payments.md`.
 
 `weekly` and `monthly` are *scheduled* billing (`Offering::isScheduledBilling()`): the
 booking/enrolment succeeds with no payment step, and payments are created later by the

docs/features/parent-guardian-accounts.md

@@ -0,0 +1,452 @@
+# Feature: Parent/Guardian Accounts
+
+## Overview
+A parent or guardian registers **once** and manages lessons for **one or more
+children**, without each child needing their own login. The guardian signs in,
+picks which child a booking is for, and pays for all of them from one account.
+
+A guardian may also be a student in their own right — they appear in their own
+"who is this for?" selector alongside their children, so a parent taking lessons
+next to their kids needs only the one account.
+
+## Vocabulary: "child" in the code, "student" in the UI
+
+The interface says **student** and **profile**; the code says **child** and
+**family**. This is deliberate, not drift. Every identifier below — the
+`us_guardian_links` columns, `GuardianService::createChild()`, the `children[]`
+request parameters, the `child_name` form fields, the `us-scheduler/family`
+block name and the `[us_family]` shortcode — is a stable contract with the
+database, saved post content and existing installs, so renaming them would break
+sites for no user-visible gain. Only the strings a person reads were changed.
+
+When adding to this feature, keep the split: internal names follow the
+data model, translatable strings follow the interface.
+
+## Core Decision: children are accountless WordPress users
+
+Every `student_id` column in `src/Schema.php` (`us_lessons`, `us_payments`,
+`us_credits`, `us_group_enrollments`, `us_question_answers`,
+`us_policy_acceptances`, `us_group_access`) is a `wp_users` id, and booking,
+billing, credits, policies and registration answers all resolve it directly.
+
+Rather than change what `student_id` means, **a child is a real `wp_users` row**
+with the `us_student` role, created without a usable login:
+
+- no password (`wp_generate_password()` is used and discarded — nothing is ever
+  emailed, so it cannot be guessed into a session),
+- no real email address; a child gets a placeholder login on the RFC 2606
+  reserved `.invalid` TLD (`us-child-<random>@child.invalid`, see
+  `GuardianService::childEmail()`) — a well-formed address that can never
+  resolve, so nothing about a child's account can be emailed somewhere real,
+- the `us_child` user meta flag set to `1`, which
+  `Guardian\ChildLoginGate` uses to block authentication outright.
+
+Consequences:
+
+- `us_lessons`, `us_group_enrollments`, `us_question_answers` and
+  `us_group_access` are **unchanged** — a child books like any other student.
+- A child can be promoted to their own login later by setting a password and a
+  real email and clearing `us_child`; no data migrates.
+- A `us_guardians` link table maps guardian → child.
+
+The alternative — a standalone `us_students` table decoupled from `wp_users` —
+was rejected for v1: it changes the meaning of `student_id` on seven tables and
+requires migrating every existing row.
+
+## Data Model — `{prefix}us_guardians`
+
+| Column         | Type            | Notes                                                     |
+|----------------|-----------------|-----------------------------------------------------------|
+| `id`           | BIGINT UNSIGNED | Primary key                                               |
+| `guardian_id`  | BIGINT UNSIGNED | WordPress user ID of the parent/guardian                  |
+| `student_id`   | BIGINT UNSIGNED | WordPress user ID of the child                            |
+| `relationship` | VARCHAR(50)     | Free text shown in admin (e.g. "Parent", "Grandparent"); may be empty |
+| `created_at`   | DATETIME        | Insertion time                                            |
+
+`UNIQUE KEY guardian_student (guardian_id, student_id)` — the same pair can
+never be linked twice.
+
+The table is a link table, not a child record: the child's **name** is their
+`display_name` on `wp_users`, and their birth year is the `us_birth_year`
+user meta. Keeping them on the user row means the admin student screens,
+`get_users()` ordering, and every existing `student_id` lookup keep working with
+no special-casing.
+
+### The legacy `us_date_of_birth` meta
+
+This feature originally collected a full date of birth in `us_date_of_birth`.
+Nothing writes that key any more. It is handled entirely inside
+`GuardianService`:
+
+- **Read** — `birthYear()` falls back to the year of the old date when
+  `us_birth_year` is absent, so a child added before the change still shows one
+  without a migration step.
+- **Write** — `setBirthYear()` deletes `us_date_of_birth` on *every* save,
+  including a save that clears the year. Without that the fallback would
+  resurrect the old date on the next read and the year could never be cleared.
+
+The upshot is a lazy migration: a child's full date survives until their record
+is next edited, then goes for good. There is no bulk purge — a site that wants
+the remaining old dates gone should delete the `us_date_of_birth` meta directly.
+
+v1 is deliberately **one guardian per child**: `GuardianRepository::insert()`
+refuses to link a child that already has a guardian. The unique key and the
+guardian-side lookups already support many-to-many, so adding a second guardian
+(separated parents) later is an insert, not a migration.
+
+## Schema changes to existing tables
+
+| Table | Change | Why |
+|---|---|---|
+| `us_payments` | `payer_id BIGINT UNSIGNED NOT NULL DEFAULT 0` + `KEY payer_id` | Who owes the money, when that is not the student |
+| `us_credits` | `payer_id BIGINT UNSIGNED NOT NULL DEFAULT 0` + `KEY payer_id` | Which account holds the balance |
+| `us_policy_acceptances` | `accepted_by BIGINT UNSIGNED NOT NULL DEFAULT 0` | Who actually clicked, when that is not the student |
+
+All three default to `0`, read back as "same as `student_id`" (see
+`Payment::payerOrStudent()`, `Credit::payerOrStudent()`,
+`PolicyAcceptance::acceptorOrStudent()`), so **an existing row keeps its current
+meaning whatever happens** — a pre-guardian payment is still owed by, and was
+still accepted by, the student it names.
+
+The installer additionally backfills them (`PaymentRepository::backfillPayerIds()`,
+`CreditRepository::backfillPayerIds()`, `AcceptanceRepository::backfillAcceptedBy()`,
+run from `Installer::migrateData()`), because the *balance* lookups key on
+`payer_id` directly and an indexed `WHERE payer_id = 5` would not see a legacy row
+still holding `0`. The backfill is idempotent — it only touches rows still at `0` —
+and the `payerOrStudent()` fallbacks remain as the belt to its braces.
+
+## Billing: the guardian is the payer, the child is the subject
+
+- `us_payments.student_id` keeps naming **the child the lesson was for**, so
+  per-child payment reporting is unchanged.
+- `us_payments.payer_id` names **the guardian who owes it**. Payment notices,
+  receipts and the Stripe intent all resolve the payer.
+- `us_credits.payer_id` is where a **family balance** lives. A credit from one
+  child's cancelled lesson is held by the guardian and can settle a sibling's
+  charge; `CreditRepository::availableBalance()` and `consume()` operate on the
+  payer.
+- The **billing-method override** (`comp` / `card` / `etransfer`, user meta read
+  by `BillingMethodResolver`) resolves against the payer, so comping a family is
+  one setting on the guardian rather than one per child.
+
+`PaymentService::createForRegistration()` takes the payer id alongside the
+student id; `BookingEndpoint` and `ScheduledBillingRunner` both pass
+`GuardianService::payerFor( $studentId )` — the child's guardian when they have
+one, otherwise the student themselves.
+
+Family discounts are **out of scope** for v1 but are not designed out: with the
+payer on both the payment and the credit ledger, a discount rule has a family to
+apply to.
+
+## Registration
+
+A **"Who are you registering?"** choice on the existing `[us_student_register]`
+form (all three signup paths — personal invite, group link, self-approval), as
+three radios:
+
+| Choice | `us_registering_for` | Student blocks | Account holder is a student | Answers the studio's questions |
+|---|---|---|---|---|
+| Just myself | `self` | no | yes | for themselves |
+| On behalf of one or more students | `students` | yes | **no** | per student only |
+| Both — myself and one or more students | `both` | yes | yes | **per student *and* for themselves** |
+
+The last column follows from the third, and is the whole of it: the
+account-scope questions describe a *student* — instrument, level, school — so
+they are asked of everyone being registered as one. Under `both` that is each
+student **and** the account holder, whose answers are stored against their own
+user id, not shared with anyone. Under `students` the account holder is not a
+student, so anything posted for them is ignored outright.
+
+Required answers are checked in two passes rather than one, so the error can say
+whose are missing: `both` would otherwise have to blame "each student" for the
+account holder's own blank field.
+
+Radios rather than checkboxes because the three answers are mutually exclusive:
+"both" only means anything as a third choice alongside the other two. Either
+student-bearing choice requires at least one student name.
+
+Anything unrecognised — a form posted without the field, an old cached page, a
+crafted request — is read as `self`, the choice that collects the least and
+grants the least. A missing radio must never be taken as "register these
+children".
+
+### The account holder as a student
+
+This replaced a single "I'm registering as a parent or guardian" checkbox, which
+could only say *whether there were children to add*. It could not say whether the
+**account holder** was a student, so `bookableStudents()` always offered them
+their own name and every guardian could book themselves a lesson nobody intended
+to sell.
+
+`students` now records `us_guardian_only = 1` and `bookableStudents()` leaves the
+account holder out. The flag is stored as the **negative** deliberately: every
+account predating the choice is a bookable student, and absence has to keep
+meaning exactly that, or the picker would silently stop offering people
+themselves on upgrade. `GuardianService::setGuardianOnly()` clears the key rather
+than writing `0`, so "not set" stays the one spelling of "yes, a student".
+
+One guard: a guardian-only account with **nobody linked to it** is still offered
+itself, because an empty picker is no way to book at all. They can put the
+account right from the profile page — see **Your details** below, where the flag
+is editable as "I take lessons myself".
+
+Per child the form collects:
+- **Name** (required)
+- **Birth year** (required, `us_birth_year` meta) — a four-digit year between
+  1900 and the current year. `GuardianService::normaliseBirthYear()` is the one
+  definition of what counts, shared by the signup form's up-front validation and
+  by `createChild()`/`updateChild()` themselves, so a bad year is refused rather
+  than quietly discarded and a typo cannot leave a nonsense age on the record.
+- **Every account-scope registration question** (`Registration\Question`,
+  `SCOPE_ACCOUNT`) — asked once per child, not once per guardian, because in
+  practice they describe the student (instrument, level, school). The guardian
+  answers them on the child's behalf; the answer row's `student_id` is the child.
+
+### What the account holder gives when they are a student
+
+Under `self` and `both` the account holder is a student too, so the **About you**
+panel asks them for exactly the same two things every other student gives: their
+**birth year** (`us_birth_year`, the same meta key and the same
+`normaliseBirthYear()` rule — `GuardianService::setBirthYear()` writes both cases)
+and the **account-scope questions**. Both are stored against their own user id.
+
+The panel sits on the main form, above the students, rather than behind a "Next".
+The questions used to be a second step, which put what the studio needs to know
+about an adult student on a screen they reached only after everything else; now
+one page holds one decision each — who you are registering, about you, about
+them.
+
+`register.js` takes the whole **About you** fieldset out of play under
+`students`, by `disabled` as well as `hidden`: a disabled fieldset is neither
+validated nor submitted, so a `required` field cannot block a form on a control
+nobody can reach. The students block is toggled the same way, and the server
+enforces both rules regardless — which is what makes them hold with JavaScript
+off. The profile screen has no such problem: its forms are always visible, so the
+attribute is static there.
+
+Name and birth year are marked required in the labels the same way a required
+question is; `[data-us-child-required]` keeps the attribute on the child fields
+in step with the block they live in.
+
+Order of operations in `RegistrationPage::handleSubmit()`:
+
+1. Validate the account holder's own fields (email, password, policies, and —
+   when they are a student — their birth year and answers).
+2. Validate **every** child block — a missing name, a missing or unusable birth
+   year, or a missing required per-child answer fails the whole submission
+   **before** any user is created, so a half-registered family is never left
+   behind. An **entirely empty** block is dropped instead, because the form
+   always renders one spare for "add another"; a block with anything at all
+   typed into it is kept and reported on, rather than silently discarding what
+   the guardian entered.
+3. Create the guardian user, and record `us_guardian_only` and (when they are a
+   student) their birth year against it.
+4. For each child: create the accountless user, link it, record its answers, and
+   record the signup policy acceptances **against the child** with
+   `accepted_by = <guardian>`.
+5. Roll back — every child user created so far is deleted and the guardian user
+   with them — if any child creation fails, so a partial family never persists.
+
+A guardian who does not tick the box registers exactly as before; nothing about
+the single-student flow changes.
+
+### Policy acceptance
+
+`us_policy_acceptances` records **one row per child** for each signup-scoped
+policy, with:
+
+- `student_id` = the child (who the policy binds),
+- `accepted_by` = the guardian (who actually agreed),
+- `registration_type = 'account'`, `registration_id` = the child's user ID.
+
+The guardian also gets their own acceptance row (`student_id = accepted_by =
+guardian`) whether or not they book for themselves — they agreed to the terms as
+an account holder. This is the legally meaningful record: "guardian X accepted
+policy version N on behalf of child Y at time T from IP Z".
+
+Booking-scope policies are accepted at booking time by whoever is signed in;
+`BookingEndpoint` passes the same `accepted_by` when a guardian books for a
+child.
+
+## Managing the account
+
+### Your details
+
+The profile screen opens with the account holder's own record, because the
+alternative was a page called **Your profile** on which the one person who could
+not be edited was you. The form saves through
+`GuardianService::updateSelf()` and holds:
+
+- **Your name** — `display_name` and `nickname`, written together for the reason
+  `updateChild()` does: `UserName` reads the nickname first, and leaving it
+  behind would put the account's email address back on every screen that names a
+  person.
+- **I take lessons myself** — the positive of `us_guardian_only`, so the form
+  asks the question the way a person answers it and `updateSelf()` is the one
+  place the sense is flipped. This is what makes good on "they can put the
+  account right from the profile page": an account that registered as a pure
+  guardian and later took up lessons — or ticked the wrong radio at signup — can
+  now correct itself instead of asking the studio to.
+- **Your birth year** — `us_birth_year`, the same meta and the same
+  `normaliseBirthYear()` rule every student is held to.
+
+Two decisions worth keeping:
+
+- The birth-year field carries **no `required` attribute**. It is asked of a
+  student only, and the family screen loads no JavaScript, so a browser-enforced
+  `required` would leave a guardian who books solely for other people unable to
+  submit the form at all. `FamilyPage::handleSelf()` enforces it against the
+  checkbox instead, which is where the condition actually lives.
+- Unticking **I take lessons myself** does **not** clear a stored birth year.
+  The box says who books, not "forget what you know about me", and someone who
+  ticks it back on the next visit should find their details as they left them.
+
+The **email** is shown but not editable: it is the account's `user_login` as
+well as its address, so changing it is a studio-side job rather than a
+profile-screen one.
+
+The account-scope questions are not re-asked here, in either direction — the
+child rows do not offer them on edit either, and a studio that needs a newly
+self-declared student's answers asks for them the same way it would for any
+other change of circumstance.
+
+### Managing children
+
+The rest of `[us_family]` (block: **Profile**) is the manage-children screen:
+list the children, add one, edit a name/birth year, remove one.
+
+- **Add** creates another accountless child user and links it. Account-scope
+  questions are asked here too, so a child added later carries the same
+  information as one added at signup.
+- **Edit** updates `display_name` and `us_birth_year`.
+- **Remove** unlinks the child and **deletes the child user**, but only when the
+  child has no lessons and no enrolments — a child with history is refused, so
+  removing one can never orphan a lesson, payment or credit
+  (`GuardianService::removeChild()`). The guardian is told to contact the studio
+  instead.
+
+Submissions are processed on `template_redirect` (like registration) and
+post/redirect/get back to the page, so a refresh cannot resubmit.
+
+## Booking
+
+`GET /bookings` returns the lessons of the signed-in user **and of every child
+they are guardian for**, each row carrying `student_id` and `student_name` so
+the list can be grouped by child.
+
+`POST /bookings` takes an optional **`student_id`**:
+
+- absent or `0` → the current user books for themselves (unchanged),
+- a child's id → the endpoint verifies with `GuardianService::canActFor()` that
+  the current user is that child's guardian, and returns `403 forbidden` when
+  they are not. **This is the authorisation boundary of the feature**: without
+  it any student could book, and bill, against any user id they cared to send.
+
+The booking form gains a "Who is this for?" `<select>`, rendered only when the
+account has more than one person on it, so a single-student account's form is
+unchanged.
+
+**Children are listed first and the account holder last**
+(`GuardianService::bookableStudents()`). The order is the whole point: a
+guardian's normal case is booking for a child, so the default selection — the
+one a parent gets by not touching the picker at all — is a child, never
+themselves. Booking for the wrong child is a correctable inconvenience; silently
+billing a parent's account for a lesson meant for their kid is the error worth
+designing out. The guardian is still offered, last, so a parent taking lessons
+alongside their children can book for themselves.
+
+The list is rendered server-side into `data-students` on the page wrapper and
+read by `assets/js/guardian.js`, which both the booking and group-class scripts
+share.
+
+`POST /bookings/<id>/cancel` accepts a cancellation from the lesson's student
+**or** their guardian, subject to the same cancellation cutoff.
+
+## Group classes
+
+`POST /enrollments` carries the same optional `student_id` and the same
+`canActFor()` check, `GET /enrollments` covers the household, and
+`POST /enrollments/<id>/withdraw` accepts the guardian — group enrolment is the
+other place a family books and pays, so it gets the identical treatment rather
+than being left as a single-student-only path.
+
+## Admin
+
+- **Students list** gains a **Profile** column: a child links to its
+  guardian's detail screen, a guardian lists its children as links. Children are
+  listed alongside every other student rather than nested, so nothing about
+  finding a student changes.
+- **Student detail** gains a **Profile** panel — the guardian (for a child) or
+  the children (for a guardian), each a link to the other's screen — and the
+  credit balance shown is the **payer's** balance, labelled with whose it is, so
+  an admin looking at a child sees the family balance that will actually settle
+  their charges rather than an empty per-child one.
+- Registration answers and policy acceptances on a child's screen show
+  "accepted by <guardian>" where the acceptor differs from the student.
+
+Creating or attaching a child from wp-admin is **out of scope** for v1; a studio
+admin adds children through the guardian's own family screen or asks the
+guardian to.
+
+## Capabilities
+
+No new capability. A child user holds the `us_student` role (so every existing
+`student_id` capability check keeps working) but can never sign in
+(`Guardian\ChildLoginGate` blocks `wp_authenticate_user` and forces
+`user_has_cap` to withhold `book_lesson` from a child), so the role grants them
+nothing in practice. Guardians act for children through
+`GuardianService::canActFor()`, checked at every REST and form boundary, rather
+than through a capability.
+
+## Instructor view
+
+Lesson lists show the student's name. Where that student is a child, the
+instructor also sees the guardian's name and email — the contact they actually
+need — via `GuardianService::contactFor()`.
+
+## Implementation
+
+- Models: `Unsupervised\Schedular\Guardian\GuardianLink`
+- Repository: `Unsupervised\Schedular\Guardian\GuardianRepository`
+- Service: `Unsupervised\Schedular\Guardian\GuardianService` (child creation,
+  `canActFor()`, `payerFor()`, `contactFor()`, removal rules, and the account
+  holder's own record via `accountHolder()`/`updateSelf()`)
+- Login block: `Unsupervised\Schedular\Guardian\ChildLoginGate`
+- Frontend: `Unsupervised\Schedular\Guardian\FamilyPage` (`[us_family]`)
+- Shared question field: `Unsupervised\Schedular\Registration\QuestionField`
+  (one question rendered under a caller-supplied input name, so the same
+  question can appear once per child without colliding)
+- Front-end script: `assets/js/guardian.js` (the shared picker),
+  `assets/js/register.js` (guardian toggle + "add another child")
+- Extended: `Auth\RegistrationPage` (guardian checkbox, child blocks, per-child
+  answers/acceptances, rollback), `Booking\BookingEndpoint` and
+  `GroupClass\EnrollmentEndpoint` (`student_id` param + guardian
+  authorisation, household listings), `Booking\BookingPage`,
+  `GroupClass\GroupClassPage`, `Payment\PaymentService`,
+  `Payment\PaymentRepository`, `Payment\CreditRepository`,
+  `Payment\ScheduledBillingRunner` (one notice per payer),
+  `Policy\AcceptanceRepository`, `Registration\RegistrationGate`,
+  `Auth\StudentController`, `Installer` (backfills)
+- Schema: `us_guardians`; `us_payments.payer_id`; `us_credits.payer_id`;
+  `us_policy_acceptances.accepted_by`
+
+## Tests
+
+- `tests/Unit/Guardian/GuardianLinkTest.php`
+- `tests/Unit/Guardian/GuardianRepositoryTest.php`
+- `tests/Unit/Guardian/GuardianServiceTest.php`
+- `tests/Unit/Guardian/ChildLoginGateTest.php`
+- `tests/Unit/Guardian/FamilyPageTest.php`
+- `tests/Unit/Auth/RegistrationPageTest.php` (guardian signup path)
+- `tests/Unit/Booking/BookingEndpointTest.php` and
+  `tests/Unit/GroupClass/EnrollmentEndpointTest.php` (booking/enrolling for a
+  child, and the 403 when the caller is not the guardian)
+- `tests/Unit/Booking/BookingPageTest.php` (children lead the embedded list)
+- `tests/Unit/Payment/PaymentServiceTest.php`, `CreditRepositoryTest.php`,
+  `ScheduledBillingRunnerTest.php` (payer, family balance, one notice)
+
+## Related
+
+`account-registration.md`, `lesson-booking.md`, `payments.md`, `credits.md`,
+`group-classes.md`, `student-administration.md`, `policies.md`,
+`registration-questions.md`.

docs/features/payments.md

@@ -98,6 +98,59 @@ After booking, the destination on a payment can be corrected per booking:
 | `created_at`               | DATETIME         | Insertion time                                        |
 | `paid_at`                  | DATETIME         | When marked `paid`; NULL otherwise                    |
 
+## Price Display and the Pay Agreement
+Every price a student is shown on the front end carries its **cadence** — the
+offering's `billing_mode` in the words the student needs:
+
+| `billing_mode` | Shown as                          | Explained beneath as                                       |
+|----------------|-----------------------------------|------------------------------------------------------------|
+| `one_time`     | `at booking`                      | Charged once, when you book.                               |
+| `full_term`    | `up front`                        | Charged once, up front, for the whole term.                |
+| `weekly`       | `weekly`                          | Charged for each lesson, 24 hours before it starts.        |
+| `monthly`      | `per lesson monthly` / `monthly`  | Charged on the 1st of each month, for that month's lessons.|
+
+So a lesson type reads `50.00 CAD at booking` in the booking form's type picker,
+and a group class card reads `120.00 CAD up front`. A free offering shows `Free`.
+
+**`monthly` reads differently per offering kind, because it *bills* differently.**
+A private lesson's price is a per-lesson fee and its monthly charge is that
+month's lessons × the fee, so the fee is quoted **per lesson**
+(`50.00 CAD per lesson monthly`). A monthly group class is priced **per month** —
+`ScheduledBillingRunner::billGroupMonthly()` charges the fee once for the month
+however many times the class meets in it — so its figure is quoted as it stands
+(`120.00 CAD monthly`). The display split is `isPerLessonMonthly()` in
+`assets/js/pricing.js`; the billing split is the one place the monthly rule
+differs between the two kinds.
+
+Before a booking or enrolment can be submitted, the form shows the price again as
+a summary block with a **required agreement checkbox** — the second confirmation,
+distinct from the policy acceptances above it:
+
+> ☐ I agree to pay 56.50 CAD at booking.
+
+The agreed figure is the amount actually billed, so the studio **HST rate** is
+added to it (`usScheduler.taxRate`, localized from `us_hst_rate`) and broken out
+above the checkbox — matching the total `Payment::total()` charges. A comped
+student is not taxed and is not charged at all, so for them the quoted figure is
+an upper bound. A free offering has nothing to agree to and shows no block.
+
+Cadence-specific wording:
+
+- **Weekly reservation of a `one_time` lesson type** — the fee is charged once per
+  week claimed, so the agreement states the per-lesson amount and the total as a
+  ceiling ("up to 12 lessons, 678.00 CAD in total"). The occurrence count mirrors
+  `BookingEndpoint::MAX_WEEKLY_OCCURRENCES`; a slot another student takes first is
+  simply not claimed, so the real charge can come in under it.
+- **`weekly` / `monthly`** — nothing is taken at registration, so the agreement is
+  to the recurring charge: "I agree to pay 56.50 CAD per lesson, billed monthly."
+  A monthly **group class** agrees to its monthly figure instead ("I agree to pay
+  138.00 CAD monthly."), matching how its price is quoted on the card.
+
+All of this lives in `assets/js/pricing.js` (`window.usPricing`), shared by the
+booking and group-class flows so a price reads the same wherever it is met. The
+script is registered as `us-scheduler-pricing` and is a dependency of both
+`us-scheduler` and `us-scheduler-group`.
+
 ## Payment Flow
 1. During registration the front-end calls `POST /payments/intent` — but only when the registration response carried a `payment` summary (unpriced registrations return `payment: null` and skip the payment step). The intent call creates a Stripe PaymentIntent for a `card` student and returns the client secret. (`etransfer` returns a `pending` payment; `comp` returns none.)
 2. The browser confirms the card payment with Stripe.
@@ -139,9 +192,19 @@ See `payment-reporting.md` for the monthly report and CSV export endpoints.
 - Receipts: `Unsupervised\Schedular\Payment\ReceiptMailer`
 - Settings page: `Unsupervised\Schedular\Payment\StudioSettings`
 - REST endpoint: `Unsupervised\Schedular\Payment\PaymentEndpoint`
+- Front-end price display + pay agreement: `assets/js/pricing.js` (`window.usPricing`), registered and localized with `taxRate` by `Unsupervised\Schedular\ShortcodeRegistrar`
 
 ## Tests
+- `tests/Unit/ShortcodeRegistrarTest.php` (pricing helper registration + localized `taxRate`)
 - `tests/Unit/Payment/PaymentRepositoryTest.php`
 - `tests/Unit/Payment/PaymentTest.php`
 - `tests/Unit/Payment/StripeGatewayTest.php`
 - `tests/Unit/Payment/ReceiptMailerTest.php`
+
+## Who Pays
+`us_payments.student_id` names the student the charge is *for*;
+`us_payments.payer_id` names who **owes** it — a child's guardian, or 0 meaning
+the student pays for themselves (`Payment::payerOrStudent()`). The billing
+method, receipts, payment notices and the Stripe payment step all resolve the
+payer, so a family is billed and comped as one account while per-child reporting
+is unchanged. See `parent-guardian-accounts.md`.

docs/features/policies.md

@@ -40,14 +40,23 @@ The studio admin drafts, versions, and publishes policies (e.g. cancellation, pa
 
 ## Versioning & Acceptance Rules
 - Editing a published policy creates a new `draft` version; the old version stays `published` until the draft is published.
+- Editing a `draft` version rewrites it in place — nobody has accepted it yet, so there is nothing to preserve and no new version is created. `PATCH /policies/{id}/versions/{vid}` allows only this case; the admin page also accepts an edit to a `published` or `archived` version and branches a new draft from it.
 - Publishing a draft sets it `published`, stamps `published_at`, archives the prior version, and points `us_policies.current_version_id` at it.
 - The registration gate requires acceptance of the `current_version_id` of every policy. Because acceptance is tied to `policy_version_id`, a newly published version is unaccepted and must be re-accepted at the student's next booking.
 
 ## Admin Interface
 **Policies** in wp-admin (`manage_policies`, studio admin only):
-- Create a policy; draft and edit version bodies
+- Create a policy; draft version bodies
+- **Rename** the selected policy (`rename_policy`, `PolicyRepository::updateTitle()`). Only the title changes: the slug is the identifier `findBySlug()` and the gates resolve policies by, so renaming can never detach a policy from versions students have already accepted. A blank title, or one longer than `Policy::MAX_TITLE_LENGTH`, is ignored
+- View the content of any version (`?page=us-policies&policy_id={id}&version_id={vid}`), whatever its status
+- Edit from the viewer: a draft is saved in place; editing a published or archived version instead saves the text as a **new draft version** (the viewer follows to it), so text students have already accepted is never rewritten
 - Publish a draft version; view acceptance history per version
 
+## Rendering a Policy Body
+Bodies are typed into a plain textarea, so most are written as blank-line-separated prose with no markup. `PolicyVersion::bodyHtml()` is the single render path — `wp_kses_post()` then `wpautop()`, the same treatment WordPress gives post content — so unmarked-up text arrives as real paragraphs and bodies that do carry markup are left alone. It feeds the booking/enrolment JSON (`GET /policies`), the signup form, and the admin version viewer, which therefore previews exactly what students see.
+
+The acceptance markup (`.us-policy` / `.us-policy-body`) is styled in `assets/css/frontend.css` as a bounded, vertically scrolling reading box with `overflow-wrap: break-word`, so a long policy or a pasted URL cannot force a horizontal scrollbar or push the accept checkbox out of view. `RegistrationPage` enqueues that stylesheet for the signup gate; `BookingPage` and `GroupClassPage` already did.
+
 ## REST API
 | Method   | Endpoint                                                        | Permission        |
 |----------|-----------------------------------------------------------------|-------------------|
@@ -74,3 +83,11 @@ cover every policy's current version or the registration is rejected.
 - `tests/Unit/Policy/PolicyVersionRepositoryTest.php`
 - `tests/Unit/Policy/AcceptanceRepositoryTest.php`
 - `tests/Unit/Policy/PolicyServiceTest.php`
+- `tests/Unit/Policy/PolicyControllerTest.php`
+- `tests/Unit/Policy/PolicyEndpointTest.php`
+
+## Who Accepted
+`us_policy_acceptances.accepted_by` records the person who actually ticked the
+box, where that differs from `student_id` — a guardian agreeing on a child's
+behalf. It defaults to 0, read back as "the student agreed for themselves"
+(`PolicyAcceptance::acceptorOrStudent()`). See `parent-guardian-accounts.md`.

docs/features/registration-questions.md

@@ -7,8 +7,8 @@ Questions come in two **scopes**:
   booking a specific offering; authored per offering by the studio admin or the owning
   instructor, and stored against the resulting lesson or group enrolment.
 - **Account scope** (`scope = 'account'`) — studio-wide questions every new student answers
-  **once at account signup**, as a required second step after choosing their name and
-  password. Authored by the studio admin only, and stored against the new user account.
+  **once at account signup**, on the same page as their name and password. Authored by the
+  studio admin only, and stored against the new user account.
 
 Both scopes share the `us_questions` / `us_question_answers` tables, the same field types,
 and the same authoring page (**Offerings → Questions**).
@@ -23,11 +23,32 @@ and the same authoring page (**Offerings → Questions**).
 | `label`       | VARCHAR(255)     | The question text shown to the registrant                   |
 | `field_type`  | VARCHAR(20)      | `text` / `textarea` / `select` / `checkbox`                 |
 | `options`     | TEXT             | JSON array of choices (for `select`); NULL otherwise        |
-| `is_required` | TINYINT(1)       | 1 = registrant must answer to continue                      |
+| `audience`    | VARCHAR(20)      | `all` (default) or `child` — who the question is asked of (account scope) |
+| `is_required` | TINYINT(1)       | 1 = the **account holder** must answer to continue          |
+| `is_required_child` | TINYINT(1) | 1 = each **student being registered** must answer to continue |
 | `sort_order`  | INT              | Display order within the scope                              |
 | `is_active`   | TINYINT(1)       | 0 = retired, 1 = shown on the form                          |
 | `created_at`  | DATETIME         | Insertion time                                             |
 
+## Audience and Required-ness (account scope)
+An account-scope question is asked in two places, and the two are configured separately:
+
+- **The account holder's own "About you" panel** — shown when they are registering
+  themselves (`self` or `both`). Governed by `audience` (a `child` question is not asked
+  here at all) and by `is_required`.
+- **Each student block** — one per person they are registering on behalf of, on the signup
+  form and on the guardian's family screen. Every question is asked here regardless of
+  `audience`; `is_required_child` decides whether it blocks submission.
+
+That split is what lets a studio ask "School and grade" of children only, or make
+"Previous experience" optional for an adult signing themselves up but required for every
+child they enrol. `audience = 'child'` leaves `is_required` moot — the question never
+reaches the account holder's panel.
+
+`audience` and `is_required_child` are ignored for offering-scope questions: booking and
+enrolment ask their intake questions once, about the student being booked, with no separate
+account-holder form to differ from.
+
 ## Data Model — `{prefix}us_question_answers`
 
 | Column              | Type             | Notes                                                  |
@@ -49,21 +70,26 @@ lesson, a group enrolment, or an account signup (`account` + the user ID).
 2. Required questions block submission until answered.
 3. Answers are sent in the `answers[]` array on `POST /bookings` or `POST /enrollments` and written to `us_question_answers` alongside the new registration row.
 
-## Account-scope Flow (signup step two)
+## Account-scope Flow (signup)
 1. The `[us_student_register]` page (`Auth\RegistrationPage`) loads active account-scope questions via `QuestionRepository::findByScope('account')`.
-2. The form renders as two steps: step one is email/name/password/policies, step two is the questions. `assets/js/register.js` reveals step two behind a "Next" button (progressive enhancement — without JS both steps show and the single submit still works). This applies to **every** signup path (invite, group link, self-approval).
-3. On submit, required answers are validated **before** the user is created (a missing answer returns an error and creates no account); after creation each answered question is written to `us_question_answers` with `registration_type = 'account'`, `registration_id = student_id = <new user ID>`.
+2. The form is a single page. The questions sit in an **About you** panel, alongside the account holder's birth year, between the "Who are you registering?" choice and the students being added — minus any `audience = 'child'` question, which is never asked of the account holder. `assets/js/register.js` disables and hides that whole panel when the choice is "on behalf of students" — the questions describe a student and a pure guardian is not one — and puts the full question set in every child block instead. Progressive enhancement: without JS every panel shows and the single submit still works. This applies to **every** signup path (invite, group link, self-approval).
+3. On submit, required answers are validated **before** the user is created (a missing answer returns an error and creates no account) — `is_required` against the account holder's panel, `is_required_child` against each student block; after creation each answered question is written to `us_question_answers` with `registration_type = 'account'`, `registration_id = student_id = <new user ID>`. An answer posted for a `child`-audience question against the account holder is discarded, not stored.
 4. A studio admin reviews the answers on the student's admin screen under **Registration Information** (`Auth\StudentHistory::registrationInfo()` lists every account question paired with the student's answer, "—" when unanswered). These rows are excluded from the offering-scope "Intake answers" table.
 
 ## Admin Interface
 Both scopes are edited from **Offerings → Questions** (`Registration\QuestionController`):
 - Pick an offering to edit its questions, or **"Account signup (all registrations)"** for the account-scope questions.
+- The account-scope form adds **Asked of** (everyone / students only) and a second **Required** checkbox for students; both are hidden for offering scope, where they have no meaning.
 - Studio admin (`manage_questions` + `manage_instructors`) edits any offering's questions and the account-scope questions.
 - Instructor (`manage_questions`) edits questions only on their own offerings; the account-scope option is hidden.
 
 ## REST API
 Only offering-scope questions are exposed over REST. Account-scope questions are managed
-through the server-rendered admin page and read directly by `RegistrationPage`.
+through the server-rendered admin page and read directly by `RegistrationPage` — a request
+naming one is turned away as not found, since the owner check has no offering to check
+against, so REST can neither read nor overwrite an `audience`. An offering question written
+over REST mirrors its single `is_required` into `is_required_child`, as the admin form and
+the upgrade backfill both do.
 
 | Method   | Endpoint                                          | Permission           |
 |----------|---------------------------------------------------|----------------------|
@@ -74,12 +100,13 @@ through the server-rendered admin page and read directly by `RegistrationPage`.
 
 ## Implementation
 - Repositories: `Unsupervised\Schedular\Registration\QuestionRepository` (`findByOffering`, `findByScope`), `Unsupervised\Schedular\Registration\AnswerRepository`
-- Models: `Unsupervised\Schedular\Registration\Question` (`scope`, nullable `offeringId`), `Unsupervised\Schedular\Registration\Answer` (`REG_ACCOUNT`)
+- Models: `Unsupervised\Schedular\Registration\Question` (`scope`, nullable `offeringId`, `audience`, `isRequiredChild`, and the `askedOfSelf()` / `isRequiredForSelf()` / `isRequiredForChild()` readers every caller uses instead of touching `isRequired` directly), `Unsupervised\Schedular\Registration\Answer` (`REG_ACCOUNT`)
 - Admin controller: `Unsupervised\Schedular\Registration\QuestionController`
 - REST endpoint: `Unsupervised\Schedular\Registration\QuestionEndpoint` (offering scope only)
-- Signup step two: `Unsupervised\Schedular\Auth\RegistrationPage`, `templates/frontend/register-page.php`, `assets/js/register.js`
+- Signup form: `Unsupervised\Schedular\Auth\RegistrationPage`, `templates/frontend/register-page.php`, `assets/js/register.js`
 - Admin review: `Unsupervised\Schedular\Auth\StudentHistory::registrationInfo()`, `templates/admin/student-detail.php`
-- Schema: `us_questions.scope` + nullable `us_questions.offering_id` (requires a plugin version bump so `dbDelta` runs)
+- Schema: `us_questions.scope` + nullable `us_questions.offering_id`, `us_questions.audience`, `us_questions.is_required_child` (each requires a plugin version bump so `dbDelta` runs)
+- Required-for-students backfill: `is_required_child` arrives with `DEFAULT 0`, which would quietly make every existing required question optional for students. `QuestionRepository::backfillChildRequired()` copies `is_required` into it once; `Plugin::boot()` runs it guarded by the `us_questions_child_required_backfilled` option, after the version gate has let `dbDelta` add the column
 - Nullability repair: `dbDelta` does **not** reliably relax a column from `NOT NULL` to `NULL`, so sites created before account-scope questions kept `offering_id NOT NULL` and rejected account inserts. `QuestionRepository::ensureOfferingNullable()` re-applies the nullable definition (idempotent `ALTER … MODIFY`); `Plugin::boot()` runs it once, guarded by the `us_questions_offering_nullable` option rather than the version gate (affected sites may already be on the current version)
 
 ## Tests
@@ -87,5 +114,16 @@ through the server-rendered admin page and read directly by `RegistrationPage`.
 - `tests/Unit/Registration/AnswerRepositoryTest.php`
 - `tests/Unit/Registration/QuestionTest.php`
 - `tests/Unit/Registration/AnswerTest.php`
+- `tests/Unit/Registration/QuestionFieldTest.php`
 - `tests/Unit/Auth/RegistrationPageTest.php`
 - `tests/Unit/Auth/StudentHistoryTest.php`
+- `tests/Unit/Guardian/FamilyPageTest.php`
+
+## Per-Child Answers
+For a parent/guardian signup, **account-scope** questions are asked **once per
+child** rather than once per guardian — in practice they describe the student
+(instrument, level, school), not the account holder. Each answer's `student_id`
+and `registration_id` are the child's user ID, so a studio admin reading a
+child's screen sees the information that describes them. The guardian's family
+screen asks the same questions when a child is added later, under the same
+`is_required_child` rule as the signup form. See `parent-guardian-accounts.md`.

docs/features/scheduled-billing.md

@@ -6,7 +6,9 @@ payments on a recurring schedule:
 
 - **`weekly`** — one payment per lesson, due **24 hours before** that lesson.
 - **`monthly`** — one payment per calendar month, due on the **1st**, covering every
-  lesson that falls in the month (4 lessons ⇒ 4 × fee).
+  lesson that falls in the month. A **private lesson**'s fee is per lesson, so the
+  month costs (#lessons) × fee. A **group class**'s fee is per month: the class is
+  billed that fee once for the month, however many times it meets in it.
 
 Both apply to **private lessons** and **group classes**. At registration the
 booking/enrolment succeeds with `payment: null` (no payment step); the lesson is
@@ -29,7 +31,7 @@ method resolution, e-transfer freezing, comp auto-pay reused) with a `due_date`
 | **Private weekly** | lesson `start_dt` ≤ now + 24h | 1 × fee | `us_lessons.payment_id` set on the lesson |
 | **Private monthly** | the lesson's month's 1st ≤ today | (#lessons in month) × fee | `payment_id` set on every lesson in the month |
 | **Group weekly** | session (from `Offering::sessionWindows()`) − 1 day ≤ now | 1 × fee | `us_payments.period_key` = session date |
-| **Group monthly** | the month's 1st ≤ today | (#sessions in month) × fee | `period_key` = `YYYY-MM` |
+| **Group monthly** | the month's 1st ≤ today | 1 × fee (a monthly class is priced per month, not per session) | `period_key` = `YYYY-MM` |
 
 - Private lessons dedup on `us_lessons.payment_id IS NULL` — a lesson with no payment is
   unbilled. A monthly group links its earliest lesson via `createForRegistration` and the
@@ -92,3 +94,10 @@ applies that credit against their due charges before emailing the notice
 - `tests/Unit/Payment/PaymentRepositoryTest.php` (`existsForPeriod`, `due_date`/`period_key`)
 - `tests/Unit/Payment/PaymentServiceTest.php` (`voidPending` skips scheduled)
 - `tests/Unit/Booking/BookingEndpointTest.php` / `tests/Unit/GroupClass/EnrollmentEndpointTest.php` (deferred payment)
+
+## One Notice Per Family
+Charges are bucketed by **payer**, not student, so a guardian gets a single
+notice covering every child rather than one email per child. Each line names the
+student it is for when that is not the payer ("Ada: Piano Lesson — Mar 3, 2026"),
+and account credit is applied across the whole bucket from the family balance.
+See `parent-guardian-accounts.md`.

docs/features/student-administration.md

@@ -24,9 +24,17 @@ No new tables. The views are composed from existing data:
   quick counts (upcoming lessons, active group enrolments). Each row links to the
   detail view.
 - **Detail** (`?student_id=`):
-  - **Account** — display name, email, registered date.
+  - **Account** — display name, email, registered date, and **Booked by**: the
+    name of the parent/guardian who books and pays for this student, linked to
+    their own detail page. Always rendered — a student who books for themselves
+    says so in words, so an empty row can never be mistaken for a lookup that
+    failed.
   - **Upcoming lessons** and **Past lessons** — split by the linked availability
     slot's `start_dt`; each shows date/time, offering, instructor, and status.
+    **Upcoming lessons** also lists the student's upcoming group-class sessions
+    (`GroupClass\SessionSchedule`, marked "group class"), so one table answers
+    "what are they booked into next week?". Only upcoming ones: past dates would
+    bury the lessons, and the enrolment table below already holds the history.
   - **Group-class enrolments** — active/past, with offering title and status.
   - **Policy acceptances** — every acceptance the student has recorded, newest
     first: policy title, version, context (account signup / lesson / enrolment),
@@ -51,7 +59,38 @@ All actions are nonce-protected POSTs handled on the detail page:
   voided. A paid lesson is credited back to the student's account (see
   `credits.md`) rather than refunded.
 - **Withdraw** — on an active group-class enrolment: marked `cancelled` (freeing
-  its capacity seat), with the same pending-payment voiding.
+  its capacity seat), with the same pending-payment voiding. This is the only way
+  to remove a class; the group-class rows in **Upcoming lessons** carry no Cancel
+  action, because there is no such thing as cancelling one session of a term.
+
+## Deleting a user
+Deleting a WordPress user is a core action that knows nothing about lessons, so
+`Auth\DeletedUserCleanup` hooks `delete_user` (and `wpmu_delete_user`) and gives
+back what the account was holding: every **upcoming** lesson is marked
+`cancelled`, its availability slot released for rebooking, and its still-pending
+payment voided; every **active** group-class enrolment is cancelled and its
+pending payment voided. Without it the slots stayed marked booked and unbookable
+by anyone else, the lessons stayed on the instructor's schedule under a name that
+no longer resolved, and a class kept a seat filled by nobody.
+
+**A guardian takes their children with them.** A child account is login-less and
+exists only so the guardian has somebody to book for; without the guardian nobody
+can reach it, book for it, or be billed for it, so leaving it behind leaves an
+unreachable student on the roster holding slots that will never be used. Each
+child's bookings are released on the same terms, the `us_guardians` link row is
+deleted, and the account goes. Deleting a child fires `delete_user` again and
+re-enters the same handler; a `handled` set of user ids makes that a no-op and
+also stops a self-referential or circular link recursing.
+
+(This is a different rule from the family screen's **Remove**, which still refuses
+a child with any lesson or enrolment history — that is a guardian tidying up, not
+an admin deleting an account, and `GuardianService::removeChild()` is unchanged.)
+
+Past lessons are deliberately untouched: they happened, they may have been paid
+for, and the payment report has to keep adding up. No account credit is issued
+for a paid lesson either, unlike a cancellation the student asks for — a credit
+can only be spent on the account being deleted, so a refund owed to someone who
+has left is the studio's decision to make and record.
 
 ## Capabilities
 - `manage_students` — studio admin (administrators inherit it via the
@@ -73,6 +112,8 @@ All actions are nonce-protected POSTs handled on the detail page:
   refuse records that don't belong to the student, and reuse
   `Payment\PaymentService::voidPending`) and account updates via
   `wp_update_user` (unit-tested with mocked repositories).
+- Group-class sessions in the upcoming table: `GroupClass\SessionSchedule::upcomingForStudent()`
+- Deletion cleanup: `Auth\DeletedUserCleanup` (hooked in `Plugin::boot()`)
 - Upcoming/past split: `Auth\StudentSchedule::partition()` (pure, unit-tested)
 - The upcoming/past split is extracted into a small pure helper so it is
   unit-testable (the controller itself follows the repo convention of not being
@@ -80,9 +121,17 @@ All actions are nonce-protected POSTs handled on the detail page:
 
 ## Tests
 - `tests/Unit/Auth/StudentScheduleTest.php` (the pure upcoming/past split helper)
+- `tests/Unit/Auth/DeletedUserCleanupTest.php` (release on user deletion)
 - `tests/Unit/Auth/StudentHistoryTest.php` (history display rows + fallbacks)
 - `tests/Unit/Auth/StudentActionsTest.php` (cancel/withdraw guards + side
   effects, account validation)
 - `findByStudent` coverage in `tests/Unit/Policy/AcceptanceRepositoryTest.php`,
   `tests/Unit/Registration/AnswerRepositoryTest.php`, and
   `tests/Unit/Payment/PaymentRepositoryTest.php`
+
+## Family Relationships
+The students list gains a **Profile** column — a child links to their guardian,
+a guardian lists their children — and the student screen a **Profile** panel. A
+child's listed email is their guardian's, since a child's own address is an
+undeliverable placeholder, and the credit balance shown is the payer's, labelled
+with whose account holds it. See `parent-guardian-accounts.md`.

phpstan.neon

@@ -3,6 +3,13 @@ includes:
 
 parameters:
     level: 10
+    # Analyse against the whole supported range, not whatever PHP happens to be
+    # running. Without this, syntax newer than the `Requires PHP: 8.1` header
+    # promises passes lint on a modern local PHP and only fails in the 8.1 test
+    # job — which is how a PHP 8.2 `true` return type once reached CI.
+    phpVersion:
+        min: 80100
+        max: 80300
     paths:
         - src
     bootstrapFiles:

src/AdminMenu.php

@@ -5,6 +5,7 @@ namespace Unsupervised\Schedular;
 
 use Unsupervised\Schedular\Availability\AvailabilityController;
 use Unsupervised\Schedular\Availability\AvailabilityRepository;
+use Unsupervised\Schedular\Availability\WindowValidator;
 use Unsupervised\Schedular\Auth\AccessSettings;
 use Unsupervised\Schedular\Auth\InstructorController;
 use Unsupervised\Schedular\Auth\InviteRepository;
@@ -14,6 +15,7 @@ use Unsupervised\Schedular\Auth\RegistrationMailer;
 use Unsupervised\Schedular\Auth\RoleManager;
 use Unsupervised\Schedular\Auth\StudentActions;
 use Unsupervised\Schedular\Auth\StudentController;
+use Unsupervised\Schedular\Guardian\GuardianService;
 use Unsupervised\Schedular\Auth\StudentHistory;
 use Unsupervised\Schedular\Booking\BookingRepository;
 use Unsupervised\Schedular\Booking\LessonController;
@@ -21,6 +23,7 @@ use Unsupervised\Schedular\Booking\LessonDetail;
 use Unsupervised\Schedular\GroupClass\EnrollmentRepository;
 use Unsupervised\Schedular\GroupClass\GroupAccessRepository;
 use Unsupervised\Schedular\GroupClass\GroupClassController;
+use Unsupervised\Schedular\GroupClass\SessionSchedule;
 use Unsupervised\Schedular\Offering\ClassSlotReconciler;
 use Unsupervised\Schedular\Offering\OfferingController;
 use Unsupervised\Schedular\Offering\OfferingRepository;
@@ -42,6 +45,12 @@ use Unsupervised\Schedular\Registration\QuestionRepository;
 
 class AdminMenu {
 
+	/**
+	 * Hook suffix of the availability screen, captured when the page is added so
+	 * its script loads on that screen only.
+	 */
+	private string $availabilityHook = '';
+
 	private AvailabilityController $availabilityController;
 	private LessonController $lessonController;
 	private OfferingController $offeringController;
@@ -57,8 +66,8 @@ class AdminMenu {
 	private PaymentController $paymentController;
 	private PaymentReportController $paymentReportController;
 
-	public function __construct( AvailabilityRepository $availability, BookingRepository $bookings, OfferingRepository $offerings, QuestionRepository $questions, AnswerRepository $answers, PolicyRepository $policies, PolicyVersionRepository $policyVersions, PolicyService $policyService, AcceptanceRepository $acceptances, InviteRepository $invites, EnrollmentRepository $enrollments, GroupAccessRepository $groupAccess, StudioSettings $settings, PaymentRepository $payments, PaymentService $paymentService, BillingMethodResolver $resolver, RegistrationMailer $registrationMailer, CreditRepository $credits ) {
-		$this->availabilityController         = new AvailabilityController( $availability, $offerings );
+	public function __construct( AvailabilityRepository $availability, BookingRepository $bookings, OfferingRepository $offerings, QuestionRepository $questions, AnswerRepository $answers, PolicyRepository $policies, PolicyVersionRepository $policyVersions, PolicyService $policyService, AcceptanceRepository $acceptances, InviteRepository $invites, EnrollmentRepository $enrollments, GroupAccessRepository $groupAccess, StudioSettings $settings, PaymentRepository $payments, PaymentService $paymentService, BillingMethodResolver $resolver, RegistrationMailer $registrationMailer, CreditRepository $credits, GuardianService $guardians ) {
+		$this->availabilityController         = new AvailabilityController( $availability, $offerings, new WindowValidator( $offerings ) );
 		$this->lessonController               = new LessonController( $bookings, $payments, $availability, $offerings, new LessonDetail( $answers, $questions, $acceptances, $policies, $policyVersions ) );
 		$this->offeringController             = new OfferingController( $offerings, new ClassSlotReconciler( $availability ) );
 		$this->questionController             = new QuestionController( $questions, $offerings );
@@ -66,7 +75,7 @@ class AdminMenu {
 		$this->registrationController         = new RegistrationController( $invites );
 		$this->registrationApprovalController = new RegistrationApprovalController( $registrationMailer );
 		$this->groupClassController           = new GroupClassController( $enrollments, $offerings, $payments, $groupAccess, $paymentService, $invites, $registrationMailer );
-		$this->studentController              = new StudentController( $bookings, $availability, $offerings, $enrollments, $resolver, new StudentHistory( $acceptances, $policies, $policyVersions, $answers, $questions, $payments, $credits ), new StudentActions( $bookings, $availability, $enrollments, $paymentService ) );
+		$this->studentController              = new StudentController( $bookings, $availability, $offerings, $enrollments, $resolver, new StudentHistory( $acceptances, $policies, $policyVersions, $answers, $questions, $payments, $credits ), new StudentActions( $bookings, $availability, $enrollments, $paymentService ), $guardians, new SessionSchedule( $enrollments, $offerings ) );
 		$this->instructorController           = new InstructorController();
 		$this->settings                       = $settings;
 		$this->accessSettings                 = new AccessSettings();
@@ -76,9 +85,29 @@ class AdminMenu {
 
 	public function register(): void {
 		add_action( 'admin_menu', [ $this, 'addPages' ] );
+		add_action( 'admin_enqueue_scripts', [ $this, 'enqueueAssets' ] );
 		add_action( 'admin_post_' . PaymentReportController::EXPORT_ACTION, [ $this->paymentReportController, 'export' ] );
 	}
 
+	/**
+	 * Load a screen's script on that screen only.
+	 *
+	 * @param string $hookSuffix Screen the enqueue is running for.
+	 */
+	public function enqueueAssets( string $hookSuffix ): void {
+		if ( '' === $this->availabilityHook || $hookSuffix !== $this->availabilityHook ) {
+			return;
+		}
+
+		wp_enqueue_script(
+			'us-scheduler-availability-admin',
+			USC_PLUGIN_URL . 'assets/js/availability-admin.js',
+			[],
+			USC_VERSION,
+			true
+		);
+	}
+
 	public function addPages(): void {
 		$this->addStudioSeparators();
 
@@ -94,7 +123,7 @@ class AdminMenu {
 		);
 
 		// Instructor: manage their own availability.
-		add_menu_page(
+		$this->availabilityHook = (string) add_menu_page(
 			__( 'My Availability', 'unsupervised-schedular' ),
 			__( 'My Availability', 'unsupervised-schedular' ),
 			RoleManager::CAP_MANAGE_AVAILABILITY,

src/Auth/AccountPage.php

@@ -0,0 +1,78 @@
+<?php
+declare(strict_types=1);
+
+namespace Unsupervised\Schedular\Auth;
+
+use Unsupervised\Schedular\Val;
+
+/**
+ * Who is signed in, and the way out.
+ *
+ * Meant for a header, sidebar or account page — somewhere it sits alongside
+ * other content rather than being the whole of it. That shapes the two
+ * decisions below.
+ */
+class AccountPage {
+
+	/**
+	 * Renders the account shortcode/block output.
+	 *
+	 * Signed out, this renders a sign-in link when a login page is configured and
+	 * **nothing at all** when one is not. A block whose whole job is "you are
+	 * signed in as X" has nothing to say to a stranger, and a bare "you are not
+	 * signed in" in a site header is noise with no way to act on it. The editor
+	 * preview shows the populated state regardless, so the block is never
+	 * invisible to the person placing it.
+	 *
+	 * @param array<int|string, mixed> $atts Block attributes (`loginPageId`) or
+	 *                                       shortcode attributes (`login_page_id`).
+	 */
+	public function render( array $atts ): string {
+		$loginPageId = Val::int( $atts['loginPageId'] ?? $atts['login_page_id'] ?? 0 );
+		$loginUrl    = $this->pageUrl( $loginPageId );
+
+		wp_enqueue_style( 'us-scheduler' );
+
+		if ( ! is_user_logged_in() ) {
+			if ( null === $loginUrl ) {
+				return '';
+			}
+
+			return sprintf(
+				'<div class="us-account us-account-out"><a class="us-account-signin" href="%s">%s</a></div>',
+				esc_url( $loginUrl ),
+				esc_html__( 'Sign in', 'unsupervised-schedular' )
+			);
+		}
+
+		// Always a WP_User here — is_user_logged_in() above rules out the
+		// id-0 placeholder wp_get_current_user() returns for a visitor.
+		$user = wp_get_current_user();
+
+		$name  = UserName::format( $user, get_current_user_id() );
+		$email = $user->user_email;
+
+		// Back to where they were, so signing out of a header link does not also
+		// navigate them somewhere. The login page is the better landing spot when
+		// one is configured, since the current page may be members-only.
+		$logoutUrl = wp_logout_url( $loginUrl ?? (string) get_permalink() );
+
+		ob_start();
+		include USC_PLUGIN_DIR . 'templates/frontend/account-page.php';
+		return (string) ob_get_clean();
+	}
+
+	/**
+	 * Permalink of a configured page, or null when none is chosen or the chosen
+	 * page has since been deleted.
+	 */
+	private function pageUrl( int $pageId ): ?string {
+		if ( $pageId <= 0 ) {
+			return null;
+		}
+
+		$url = get_permalink( $pageId );
+
+		return is_string( $url ) ? $url : null;
+	}
+}

src/Auth/DeletedUserCleanup.php

@@ -0,0 +1,130 @@
+<?php
+declare(strict_types=1);
+
+namespace Unsupervised\Schedular\Auth;
+
+use Unsupervised\Schedular\Availability\AvailabilityRepository;
+use Unsupervised\Schedular\Booking\BookingRepository;
+use Unsupervised\Schedular\Booking\Lesson;
+use Unsupervised\Schedular\GroupClass\Enrollment;
+use Unsupervised\Schedular\GroupClass\EnrollmentRepository;
+use Unsupervised\Schedular\Guardian\GuardianRepository;
+use Unsupervised\Schedular\Guardian\GuardianService;
+use Unsupervised\Schedular\Payment\PaymentService;
+
+/**
+ * Gives back what a deleted account was holding, and takes the accounts that
+ * only existed underneath it with it.
+ *
+ * WordPress deletes a user without knowing anything about lessons, so a student
+ * removed from **Users → Delete** used to leave their bookings behind: the
+ * availability slots stayed marked booked and unbookable by anyone else, the
+ * lessons stayed on the instructor's schedule under a name that no longer
+ * resolved, and a group class kept a seat filled by nobody.
+ *
+ * So each upcoming booking is cancelled the same way a real cancellation is —
+ * marked cancelled, its slot released, its still-pending payment voided. Past
+ * lessons are deliberately left alone: they happened, they may have been paid
+ * for, and the payment report has to keep adding up.
+ *
+ * A **guardian** takes their children with them. A child account is login-less
+ * and exists only so the guardian has somebody to book for; without the
+ * guardian nobody can reach it, book for it, or be billed for it, so leaving it
+ * behind leaves an unreachable student on the roster holding slots that will
+ * never be used. Each child's bookings are released on the same terms, the link
+ * row goes, and the account is deleted.
+ *
+ * No account credit is issued for a paid lesson, unlike a cancellation the
+ * student asks for. A credit only has value against future billing on the
+ * account it belongs to, and that account is being deleted; a refund owed to
+ * someone who has left is a decision for the studio to make and record, not one
+ * to silently write into a table nobody will read again.
+ */
+class DeletedUserCleanup {
+
+	/**
+	 * Accounts already dealt with this request, so deleting a guardian's child
+	 * — which fires `delete_user` again and re-enters this very handler — cannot
+	 * loop or redo work. It also makes a self-referential or circular guardian
+	 * link, however it got into the table, terminate rather than recurse.
+	 *
+	 * @var array<int, true>
+	 */
+	private array $handled = [];
+
+	public function __construct(
+		private BookingRepository $bookings,
+		private AvailabilityRepository $availability,
+		private EnrollmentRepository $enrollments,
+		private PaymentService $payments,
+		private GuardianRepository $links,
+		private GuardianService $guardians,
+	) {}
+
+	public function register(): void {
+		// `delete_user` fires before the row goes, which is what lets the lookups
+		// below still find the account's bookings and children. `wpmu_delete_user`
+		// is the multisite equivalent for a user removed from the network entirely.
+		add_action( 'delete_user', [ $this, 'releaseBookings' ] );
+		add_action( 'wpmu_delete_user', [ $this, 'releaseBookings' ] );
+	}
+
+	/**
+	 * Release everything the account had booked ahead of it, then remove any
+	 * children that only existed to be booked for.
+	 */
+	public function releaseBookings( int $userId ): void {
+		if ( $userId <= 0 || isset( $this->handled[ $userId ] ) ) {
+			return;
+		}
+
+		$this->handled[ $userId ] = true;
+
+		$this->release( $userId );
+		$this->removeChildren( $userId );
+	}
+
+	/**
+	 * Cancel one account's upcoming lessons and active enrolments, freeing the
+	 * slot and voiding the pending payment behind each.
+	 */
+	private function release( int $studentId ): void {
+		// Upcoming and not already cancelled — the only bookings that are still
+		// holding anything.
+		foreach ( $this->bookings->findUpcomingForStudent( $studentId ) as $lesson ) {
+			$this->bookings->updateStatus( (int) $lesson->id, Lesson::STATUS_CANCELLED );
+			$this->availability->release( $lesson->slotId );
+			$this->payments->voidPending( $lesson->paymentId );
+		}
+
+		foreach ( $this->enrollments->findByStudent( $studentId ) as $enrollment ) {
+			if ( Enrollment::STATUS_ACTIVE !== $enrollment->status ) {
+				continue;
+			}
+
+			$this->enrollments->updateStatus( (int) $enrollment->id, Enrollment::STATUS_CANCELLED );
+			$this->payments->voidPending( $enrollment->paymentId );
+		}
+	}
+
+	/**
+	 * Delete every child linked to a departing guardian, releasing what each was
+	 * holding first. Each child is marked handled *before* it is deleted, so the
+	 * `delete_user` this fires re-enters and returns without redoing the release.
+	 */
+	private function removeChildren( int $guardianId ): void {
+		foreach ( $this->links->findByGuardian( $guardianId ) as $link ) {
+			$childId = $link->studentId;
+
+			if ( $childId <= 0 || $childId === $guardianId || isset( $this->handled[ $childId ] ) ) {
+				continue;
+			}
+
+			$this->handled[ $childId ] = true;
+
+			$this->release( $childId );
+			$this->links->delete( $guardianId, $childId );
+			$this->guardians->deleteUser( $childId );
+		}
+	}
+}

src/Auth/PasswordPolicy.php

@@ -0,0 +1,165 @@
+<?php
+declare(strict_types=1);
+
+namespace Unsupervised\Schedular\Auth;
+
+/**
+ * What counts as an acceptable signup password.
+ *
+ * The check is deliberately split across the two sides, because the two sides
+ * can do different things:
+ *
+ * - **The browser** runs zxcvbn (WordPress ships it as `password-strength-meter`)
+ *   and gates the submit button on {@see MIN_SCORE}. That is the nuanced test —
+ *   it knows that `Tr0ub4dor&3` is weaker than `correct horse battery staple` —
+ *   but it is only advice, because anything in a browser can be turned off.
+ * - **This class** runs on the server and is the rule that actually holds. It
+ *   cannot score a password the way zxcvbn does without shipping a dictionary,
+ *   so it does not pretend to: it rejects the categorically bad — too short,
+ *   the user's own name or email, a password from the well-known lists, or one
+ *   built from almost no distinct characters.
+ *
+ * Neither half is sufficient alone, which is the point. A password that clears
+ * both is not guaranteed strong; one that fails either is definitely not.
+ */
+class PasswordPolicy {
+
+	/**
+	 * Minimum length. NIST SP 800-63B puts the floor at 8 and explicitly advises
+	 * against composition rules ("must contain a symbol") on the grounds that they
+	 * push people towards predictable substitutions. Length plus the checks below
+	 * does more for less annoyance.
+	 */
+	public const MIN_LENGTH = 8;
+
+	/**
+	 * The zxcvbn score the browser demands before it will let the form submit,
+	 * on WordPress's 0-4 scale: 0-1 weak, 2 medium, 3-4 strong. Two rejects the
+	 * passwords a stranger would guess while still accepting an ordinary
+	 * memorable one — a studio signup form is not a bank.
+	 */
+	public const MIN_SCORE = 2;
+
+	/**
+	 * How much of the user's own identity has to appear in the password before it
+	 * is refused. Short enough to catch a name inside a longer password, long
+	 * enough that a two- or three-letter coincidence does not trip it.
+	 */
+	private const IDENTITY_FRAGMENT_LENGTH = 4;
+
+	/** Fewest distinct characters a password may be built from. */
+	private const MIN_DISTINCT_CHARACTERS = 4;
+
+	/**
+	 * Why this password is unacceptable, or null when it passes.
+	 *
+	 * `$email` and `$displayName` are what the same submission is claiming as an
+	 * identity, so they can be checked against the password before either exists
+	 * as a user.
+	 */
+	public static function validate( string $password, string $email = '', string $displayName = '' ): ?string {
+		// Not trimmed: a leading or trailing space is a legitimate character, and
+		// silently changing what someone typed would lock them out later.
+		if ( strlen( $password ) < self::MIN_LENGTH ) {
+			return sprintf(
+				/* translators: %d: minimum number of characters. */
+				__( 'Please choose a password of at least %d characters.', 'unsupervised-schedular' ),
+				self::MIN_LENGTH
+			);
+		}
+
+		$lower = strtolower( $password );
+
+		if ( in_array( $lower, self::commonPasswords(), true ) ) {
+			return __( 'That password is one of the most commonly used ones. Please choose something less guessable.', 'unsupervised-schedular' );
+		}
+
+		if ( count( array_unique( str_split( $lower ) ) ) < self::MIN_DISTINCT_CHARACTERS ) {
+			return __( 'Please choose a password built from more than a few repeated characters.', 'unsupervised-schedular' );
+		}
+
+		if ( self::echoesIdentity( $lower, $email, $displayName ) ) {
+			return __( 'Please choose a password that does not contain your name or email address.', 'unsupervised-schedular' );
+		}
+
+		return null;
+	}
+
+	/**
+	 * Whether the password contains the user's display name, their email address,
+	 * or the part of it before the `@` — the first things anyone guessing would
+	 * try, and the reason "grace2019" is worse than its length suggests.
+	 */
+	private static function echoesIdentity( string $lowerPassword, string $email, string $displayName ): bool {
+		$email     = strtolower( trim( $email ) );
+		$localPart = '' !== $email ? (string) strstr( $email . '@', '@', true ) : '';
+
+		$fragments = [ $email, $localPart, strtolower( trim( $displayName ) ) ];
+
+		foreach ( $fragments as $fragment ) {
+			if ( strlen( $fragment ) >= self::IDENTITY_FRAGMENT_LENGTH && str_contains( $lowerPassword, $fragment ) ) {
+				return true;
+			}
+		}
+
+		return false;
+	}
+
+	/**
+	 * Passwords common enough that a guess costs nothing. Only entries at least
+	 * {@see MIN_LENGTH} long are worth listing — anything shorter is already
+	 * refused — so this is the long tail of the usual leaked-password lists
+	 * rather than the whole of it. zxcvbn in the browser covers the rest.
+	 *
+	 * @return list<string>
+	 */
+	private static function commonPasswords(): array {
+		return [
+			'password',
+			'password1',
+			'password12',
+			'password123',
+			'passw0rd',
+			'p@ssword',
+			'p@ssw0rd',
+			'12345678',
+			'123456789',
+			'1234567890',
+			'123123123',
+			'qwertyui',
+			'qwertyuiop',
+			'qwerty123',
+			'qwerty12',
+			'1qaz2wsx',
+			'zaq12wsx',
+			'iloveyou',
+			'princess',
+			'sunshine',
+			'football',
+			'baseball',
+			'basketball',
+			'superman',
+			'batman123',
+			'trustno1',
+			'welcome1',
+			'welcome123',
+			'letmein1',
+			'letmein123',
+			'admin123',
+			'administrator',
+			'abc12345',
+			'abcd1234',
+			'monkey123',
+			'dragon123',
+			'michael1',
+			'jennifer',
+			'starwars',
+			'computer',
+			'whatever',
+			'freedom1',
+			'changeme',
+			'secret123',
+			'login123',
+		];
+	}
+}

src/Auth/RegistrationPage.php

@@ -4,6 +4,7 @@ declare(strict_types=1);
 namespace Unsupervised\Schedular\Auth;
 
 use Unsupervised\Schedular\GroupClass\GroupAccessRepository;
+use Unsupervised\Schedular\Guardian\GuardianService;
 use Unsupervised\Schedular\Payment\StudioSettings;
 use Unsupervised\Schedular\Policy\AcceptanceRepository;
 use Unsupervised\Schedular\Policy\Policy;
@@ -18,6 +19,15 @@ use Unsupervised\Schedular\Val;
 
 class RegistrationPage {
 
+	/** "Who are you registering?": the account holder, and nobody else. */
+	public const FOR_SELF = 'self';
+
+	/** Only other people — the account holder is not a student. */
+	public const FOR_STUDENTS = 'students';
+
+	/** The account holder *and* other people. */
+	public const FOR_BOTH = 'both';
+
 	/** Success signal: an invited student was created and logged in. */
 	private const RESULT_INVITE = 'invite';
 
@@ -47,6 +57,7 @@ class RegistrationPage {
 		private QuestionRepository $questions,
 		private AnswerRepository $answers,
 		private GroupAccessRepository $access,
+		private GuardianService $guardians,
 	) {}
 
 	/**
@@ -65,24 +76,21 @@ class RegistrationPage {
 		$registered = sanitize_key( Val::string( wp_unslash( $_GET['us_registered'] ?? '' ) ) );
 
 		if ( is_user_logged_in() ) {
-			if ( self::RESULT_INVITE === $registered ) {
-				// An invited student is done the moment they land here logged in,
-				// so this is where their "continue" link belongs. The sign-in-page
-				// fallback is deliberately not used: pointing someone who is
-				// already signed in at the login screen helps nobody.
-				$continue = $this->continueUrl( $this->successPageId( $atts ) );
-				$link     = null === $continue
-					? ''
-					: '<p><a href="' . esc_url( $continue ) . '">'
-						. esc_html__( 'Continue to your account', 'unsupervised-schedular' )
-						. '</a></p>';
+			// Both logged-in outcomes are dead ends without somewhere to go next,
+			// so both offer the same "continue" link to the configured page.
+			wp_enqueue_style( 'us-scheduler' );
+			$link = $this->continueLink( $atts );
 
+			if ( self::RESULT_INVITE === $registered ) {
+				// An invited student is done the moment they land here logged in.
 				return '<div class="us-register-form"><p class="us-success">'
 					. esc_html__( 'Your account has been created and you are now logged in.', 'unsupervised-schedular' )
 					. '</p>' . $link . '</div>';
 			}
 
-			return '<p>' . esc_html__( 'You already have an account and are logged in.', 'unsupervised-schedular' ) . '</p>';
+			return '<div class="us-register-form"><p>'
+				. esc_html__( 'You already have an account and are logged in.', 'unsupervised-schedular' )
+				. '</p>' . $link . '</div>';
 		}
 
 		// phpcs:ignore WordPress.Security.NonceVerification.Recommended -- token identifies the invite; the form submit is nonce-checked in maybeHandleSubmit.
@@ -116,9 +124,38 @@ class RegistrationPage {
 		$canRegister       = $open || $inviteValid;
 		$inviteOnlyMessage = $this->inviteOnlyMessage( $atts );
 
-		// The two-step script only matters when there is a second step to reveal.
-		if ( $canRegister && '' === $successType && [] !== $accountQuestions ) {
+		// The signup form carries the same policy-acceptance markup as the booking
+		// gate, so it needs the plugin stylesheet that formats it.
+		wp_enqueue_style( 'us-scheduler' );
+
+		// The script drives the parent/guardian section (revealing it, taking the
+		// account holder's own panel out of play, and cloning the child block for
+		// "add another") and the password meter, so it is needed whenever the form
+		// itself is on screen.
+		if ( $canRegister && '' === $successType ) {
 			wp_enqueue_script( 'us-scheduler-register' );
+
+			// The browser gate reads the same numbers the server enforces, so the
+			// two cannot drift into disagreeing about what it accepted.
+			wp_localize_script(
+				'us-scheduler-register',
+				'usSchedulerPassword',
+				[
+					'minLength' => PasswordPolicy::MIN_LENGTH,
+					'minScore'  => PasswordPolicy::MIN_SCORE,
+					'strings'   => [
+						'short'    => sprintf(
+							/* translators: %d: minimum number of characters. */
+							__( 'At least %d characters, please.', 'unsupervised-schedular' ),
+							PasswordPolicy::MIN_LENGTH
+						),
+						'veryWeak' => __( 'Too weak — a stranger could guess this.', 'unsupervised-schedular' ),
+						'weak'     => __( 'Still too weak. Try a longer phrase.', 'unsupervised-schedular' ),
+						'medium'   => __( 'Good enough.', 'unsupervised-schedular' ),
+						'strong'   => __( 'Strong password.', 'unsupervised-schedular' ),
+					],
+				]
+			);
 		}
 
 		ob_start();
@@ -243,10 +280,6 @@ class RegistrationPage {
 		$password    = Val::string( wp_unslash( $_POST['password'] ?? '' ) );
 		$displayName = sanitize_text_field( Val::string( wp_unslash( $_POST['display_name'] ?? '' ) ) );
 
-		if ( strlen( $password ) < 8 ) {
-			return esc_html__( 'Please choose a password of at least 8 characters.', 'unsupervised-schedular' );
-		}
-
 		// The email is fixed by a personal invite; group-link signups and
 		// self-signups supply their own.
 		if ( $inviteValid && ! $invite->isGroup() ) {
@@ -258,6 +291,15 @@ class RegistrationPage {
 			}
 		}
 
+		// After the email, so the password can be checked against it. The browser
+		// scores the password with zxcvbn and refuses to submit a weak one, but
+		// that is advice a client can decline to take — this is the check that
+		// holds. See PasswordPolicy for why the two halves differ.
+		$passwordError = PasswordPolicy::validate( $password, $email, $displayName );
+		if ( null !== $passwordError ) {
+			return esc_html( $passwordError );
+		}
+
 		$policyForms = $this->signupPolicies();
 		// phpcs:ignore WordPress.Security.ValidatedSanitizedInput.MissingUnslash, WordPress.Security.ValidatedSanitizedInput.InputNotSanitized -- each element is coerced to a positive int in the array_map callback; slashes cannot survive integer coercion.
 		$accepted = array_map( static fn( mixed $v ): int => absint( Val::int( $v ) ), (array) ( $_POST['accept'] ?? [] ) );
@@ -269,27 +311,94 @@ class RegistrationPage {
 			}
 		}
 
-		// Account-signup questions (step two) — validate before creating the user so
-		// a missing required answer never leaves a half-registered account behind.
 		$accountQuestions = $this->questions->findByScope( Question::SCOPE_ACCOUNT, activeOnly: true );
-		$answers          = $this->submittedAnswers();
 
-		foreach ( $accountQuestions as $question ) {
-			if ( $question->isRequired && '' === trim( (string) ( $answers[ (int) $question->id ] ?? '' ) ) ) {
-				return esc_html__( 'Please answer all required registration questions.', 'unsupervised-schedular' );
+		// The account-signup questions describe a *student* — instrument, level,
+		// school — not whoever holds the account. So they are asked of each
+		// student being added, and of the account holder only when they are a
+		// student themselves. "Both" is both.
+		$registeringFor = $this->submittedRegisteringFor();
+
+		// A "students only" question is never put to the account holder, so it is
+		// dropped before their answers are validated or stored — a crafted post
+		// cannot file one against them.
+		$selfQuestions = array_values(
+			array_filter( $accountQuestions, static fn( Question $question ): bool => $question->askedOfSelf() )
+		);
+
+		// "Students" and "both" collect student blocks; only "self" does not.
+		$isGuardian = self::FOR_SELF !== $registeringFor;
+
+		// "Self" and "both" make the account holder a student, so they answer the
+		// questions in their own right. Only a pure guardian does not.
+		$asksSelf = self::FOR_STUDENTS !== $registeringFor;
+
+		$children = $isGuardian ? $this->submittedChildren() : [];
+		$answers  = $asksSelf ? $this->submittedAnswers() : [];
+
+		// phpcs:ignore WordPress.Security.NonceVerification.Missing -- verified by the caller.
+		$birthYear = $asksSelf ? trim( sanitize_text_field( Val::string( wp_unslash( $_POST['birth_year'] ?? '' ) ) ) ) : '';
+
+		// Everything is validated before a single user is created, so a bad child
+		// block never leaves a half-registered family behind.
+		if ( $isGuardian && [] === $children ) {
+			return esc_html__( 'Please add at least one student, or choose "Just myself" instead.', 'unsupervised-schedular' );
 		}
+
+		// Name and birth year are required per student, and are checked here for
+		// the same reason the questions below are: the child blocks are hidden
+		// until the guardian box is ticked, so the browser cannot be asked to
+		// enforce them without blocking a signup that has no children at all.
+		foreach ( $children as $child ) {
+			if ( '' === $child['name'] ) {
+				return esc_html__( 'Please give each student a name.', 'unsupervised-schedular' );
+			}
+
+			if ( 0 === GuardianService::normaliseBirthYear( $child['birth_year'] ) ) {
+				return esc_html( GuardianService::birthYearError() );
+			}
+		}
+
+		// Checked as two passes rather than one so the message can say *whose*
+		// answers are missing — under "both" a single message could not.
+		foreach ( array_column( $children, 'answers' ) as $set ) {
+			if ( $this->hasUnansweredRequired( $accountQuestions, $set, forChild: true ) ) {
+				return esc_html__( 'Please answer all required registration questions for each student.', 'unsupervised-schedular' );
+			}
+		}
+
+		// The account holder is a student too under "self" and "both", so the same
+		// birth year every other student gives is asked of them — and checked
+		// here rather than left to the browser, for the same reason as the
+		// children's: the panel is hidden for a pure guardian, so `required`
+		// alone cannot be trusted to have applied.
+		if ( $asksSelf && 0 === GuardianService::normaliseBirthYear( $birthYear ) ) {
+			return esc_html( GuardianService::ownBirthYearError() );
+		}
+
+		if ( $asksSelf && $this->hasUnansweredRequired( $selfQuestions, $answers ) ) {
+			return esc_html__( 'Please answer all required registration questions.', 'unsupervised-schedular' );
 		}
 
 		if ( email_exists( $email ) ) {
 			return esc_html__( 'An account already exists for this email.', 'unsupervised-schedular' );
 		}
 
+		// Nickname as well as display name. WordPress defaults nickname to
+		// `user_login`, which here is the email address — so without this the
+		// account's own address became its nickname, and every screen that names
+		// a person through `UserName` showed the address instead of the name they
+		// had just typed. `UserName` copes with the accounts already created that
+		// way; this stops any more of them.
+		$name = '' !== $displayName ? $displayName : $email;
+
 		$userId = wp_insert_user(
 			[
 				'user_login'   => $email,
 				'user_email'   => $email,
 				'user_pass'    => $password,
-				'display_name' => '' !== $displayName ? $displayName : $email,
+				'display_name' => $name,
+				'nickname'     => $name,
 				'role'         => $inviteValid ? $invite->role : RoleManager::STUDENT,
 			]
 		);
@@ -298,8 +407,28 @@ class RegistrationPage {
 			return esc_html__( 'Could not create the account. Please contact the studio.', 'unsupervised-schedular' );
 		}
 
-		$this->recordAcceptances( $policyForms, (int) $userId );
-		$this->recordAnswers( $accountQuestions, $answers, (int) $userId );
+		$this->recordAcceptances( $policyForms, (int) $userId, (int) $userId );
+
+		// Only "students" means the account holder is not a student themselves;
+		// "both" registers them alongside the people they book for.
+		$this->guardians->setGuardianOnly( (int) $userId, self::FOR_STUDENTS === $registeringFor );
+
+		if ( $asksSelf ) {
+			$this->guardians->setBirthYear( (int) $userId, $birthYear );
+		}
+
+		if ( $isGuardian ) {
+			$failure = $this->createChildren( $children, $accountQuestions, $policyForms, (int) $userId );
+			if ( '' !== $failure ) {
+				return $failure;
+			}
+		}
+
+		// After the children, so a rollback that deletes this account cannot
+		// leave its answers behind pointing at a user that no longer exists.
+		if ( $asksSelf ) {
+			$this->recordAnswers( $selfQuestions, $answers, (int) $userId );
+		}
 
 		if ( $inviteValid && ! $invite->isGroup() ) {
 			$this->invites->markAccepted( (int) $invite->id, (int) $userId );
@@ -349,6 +478,40 @@ class RegistrationPage {
 		return $this->continueUrl( $loginPageId ) ?? wp_login_url();
 	}
 
+	/**
+	 * The "continue" paragraph shown to a logged-in visitor, or an empty string
+	 * when no destination page is configured. The link names the chosen page, so
+	 * the visitor knows where it goes before clicking; an untitled page falls
+	 * back to generic wording rather than reading "Continue to ".
+	 *
+	 * The sign-in-page fallback {@see loginUrl()} applies is deliberately not
+	 * used here: pointing someone who is already signed in at the login screen is
+	 * the same dead end with extra steps, so no link is better than that one.
+	 *
+	 * @param array<int|string, mixed> $atts
+	 */
+	private function continueLink( array $atts ): string {
+		$pageId   = $this->successPageId( $atts );
+		$continue = $this->continueUrl( $pageId );
+
+		if ( null === $continue ) {
+			return '';
+		}
+
+		$title = trim( Val::string( get_the_title( $pageId ) ) );
+		$label = '' === $title
+			? esc_html__( 'Continue to your account', 'unsupervised-schedular' )
+			: esc_html(
+				sprintf(
+					/* translators: %s: title of the page the student continues to. */
+					__( 'Continue to %s', 'unsupervised-schedular' ),
+					$title
+				)
+			);
+
+		return '<p><a href="' . esc_url( $continue ) . '">' . $label . '</a></p>';
+	}
+
 	/**
 	 * The chosen post-registration page's URL, or null when none is configured
 	 * (or it has since been deleted). Unlike {@see loginUrl()} this has no
@@ -405,6 +568,131 @@ class RegistrationPage {
 		return add_query_arg( 'us_confirm', rawurlencode( $rawToken ), $base );
 	}
 
+	/**
+	 * Whether any required question in `$questions` is left blank in `$answers`.
+	 *
+	 * `$forChild` picks which required-ness applies: a question can be optional
+	 * for the account holder answering about themselves and still required of
+	 * every student they register.
+	 *
+	 * @param list<Question>      $questions
+	 * @param array<int, string>  $answers
+	 */
+	private function hasUnansweredRequired( array $questions, array $answers, bool $forChild = false ): bool {
+		foreach ( $questions as $question ) {
+			$required = $forChild ? $question->isRequiredForChild() : $question->isRequiredForSelf();
+
+			if ( $required && '' === trim( (string) ( $answers[ (int) $question->id ] ?? '' ) ) ) {
+				return true;
+			}
+		}
+
+		return false;
+	}
+
+	/**
+	 * Who this signup is for: {@see FOR_SELF}, {@see FOR_STUDENTS} or
+	 * {@see FOR_BOTH}.
+	 *
+	 * Anything unrecognised — including a form posted without the field at all —
+	 * falls back to "just myself", the choice that collects the least and grants
+	 * the least. A missing radio must not be read as "register these children".
+	 */
+	private function submittedRegisteringFor(): string {
+		// The submit nonce is verified by the caller before this runs.
+		// phpcs:ignore WordPress.Security.NonceVerification.Missing
+		$value = sanitize_key( Val::string( wp_unslash( $_POST['us_registering_for'] ?? '' ) ) );
+
+		return in_array( $value, [ self::FOR_STUDENTS, self::FOR_BOTH ], true ) ? $value : self::FOR_SELF;
+	}
+
+	/**
+	 * The child blocks submitted with a guardian signup, as
+	 * `children[<n>][name|birth_year|answers]`.
+	 *
+	 * An **entirely empty** block is dropped rather than rejected — the form always
+	 * renders one spare for "add another", and an untouched spare is not a mistake
+	 * the guardian needs telling about. A block with anything at all filled in is
+	 * kept, so {@see handleSubmit()} can reject it for the missing name or birth
+	 * year rather than silently discarding what they typed.
+	 *
+	 * @return list<array{name: string, birth_year: string, answers: array<int, string>}>
+	 */
+	private function submittedChildren(): array {
+		// The submit nonce is verified by the caller before this runs.
+		// phpcs:ignore WordPress.Security.NonceVerification.Missing, WordPress.Security.ValidatedSanitizedInput.InputNotSanitized, WordPress.Security.ValidatedSanitizedInput.MissingUnslash -- each field is unslashed and sanitized below.
+		$raw = $_POST['children'] ?? [];
+		if ( ! is_array( $raw ) ) {
+			return [];
+		}
+
+		$out = [];
+		foreach ( $raw as $child ) {
+			if ( ! is_array( $child ) ) {
+				continue;
+			}
+
+			$name      = trim( sanitize_text_field( Val::string( wp_unslash( $child['name'] ?? '' ) ) ) );
+			$birthYear = trim( sanitize_text_field( Val::string( wp_unslash( $child['birth_year'] ?? '' ) ) ) );
+
+			$answers = [];
+			foreach ( (array) ( $child['answers'] ?? [] ) as $questionId => $value ) {
+				$answers[ absint( Val::int( $questionId ) ) ] = sanitize_textarea_field( Val::string( wp_unslash( $value ) ) );
+			}
+
+			if ( '' === $name && '' === $birthYear && '' === trim( implode( '', $answers ) ) ) {
+				continue;
+			}
+
+			$out[] = [
+				'name'       => $name,
+				'birth_year' => $birthYear,
+				'answers'    => $answers,
+			];
+		}
+
+		return $out;
+	}
+
+	/**
+	 * Create each child of a guardian signup: the login-less account, its answers
+	 * to the per-child questions, and a signup-policy acceptance recorded against
+	 * the child but attributed to the guardian who agreed for them.
+	 *
+	 * Returns an empty string on success, or an error message after rolling the
+	 * whole family back — every child created so far *and* the guardian. A signup
+	 * that half-worked would leave the guardian with an account they cannot
+	 * re-register and children they never confirmed, so it is undone entirely and
+	 * they simply try again.
+	 *
+	 * @param list<array{name: string, birth_year: string, answers: array<int, string>}>           $children
+	 * @param list<Question>                                                                       $questions
+	 * @param list<array{policy: Policy, version: \Unsupervised\Schedular\Policy\PolicyVersion}>   $policyForms
+	 */
+	private function createChildren( array $children, array $questions, array $policyForms, int $guardianId ): string {
+		$created = [];
+
+		foreach ( $children as $child ) {
+			$childId = $this->guardians->createChild( $guardianId, $child['name'], $child['birth_year'] );
+
+			if ( $childId instanceof \WP_Error ) {
+				foreach ( $created as $id ) {
+					$this->guardians->deleteUser( $id );
+				}
+				$this->guardians->deleteUser( $guardianId );
+
+				return esc_html__( 'Could not create the account. Please contact the studio.', 'unsupervised-schedular' );
+			}
+
+			$created[] = $childId;
+
+			$this->recordAnswers( $questions, $child['answers'], $childId );
+			$this->recordAcceptances( $policyForms, $childId, $guardianId );
+		}
+
+		return '';
+	}
+
 	/**
 	 * The account-question answers submitted with the form, keyed by question id.
 	 *
@@ -454,9 +742,15 @@ class RegistrationPage {
 	/**
 	 * Record account-time acceptances for each signup policy version.
 	 *
+	 * `$userId` is who the policy binds — the guardian for their own acceptance,
+	 * or the child for one accepted on their behalf — and `$acceptedBy` is who
+	 * actually ticked the box. Recording both is what makes the row legally
+	 * meaningful: "guardian X agreed to version N for child Y, at this time, from
+	 * this IP".
+	 *
 	 * @param list<array{policy: Policy, version: \Unsupervised\Schedular\Policy\PolicyVersion}> $policyForms
 	 */
-	private function recordAcceptances( array $policyForms, int $userId ): void {
+	private function recordAcceptances( array $policyForms, int $userId, int $acceptedBy ): void {
 		// phpcs:ignore WordPress.Security.ValidatedSanitizedInput.InputNotSanitized, WordPress.Security.ValidatedSanitizedInput.MissingUnslash -- IP is stored verbatim for audit.
 		$ip = sanitize_text_field( Val::string( wp_unslash( $_SERVER['REMOTE_ADDR'] ?? '' ) ) );
 
@@ -467,6 +761,7 @@ class RegistrationPage {
 					studentId:        $userId,
 					registrationType: PolicyAcceptance::REG_ACCOUNT,
 					registrationId:   $userId,
+					acceptedBy:       $acceptedBy,
 					ipAddress:        '' !== $ip ? $ip : null,
 				)
 			);

src/Auth/StudentController.php

@@ -8,6 +8,8 @@ use Unsupervised\Schedular\Booking\BookingRepository;
 use Unsupervised\Schedular\Booking\Lesson;
 use Unsupervised\Schedular\GroupClass\Enrollment;
 use Unsupervised\Schedular\GroupClass\EnrollmentRepository;
+use Unsupervised\Schedular\GroupClass\SessionSchedule;
+use Unsupervised\Schedular\Guardian\GuardianService;
 use Unsupervised\Schedular\Offering\OfferingRepository;
 use Unsupervised\Schedular\Payment\BillingMethodResolver;
 use Unsupervised\Schedular\Payment\Payment;
@@ -23,6 +25,8 @@ class StudentController {
 		private BillingMethodResolver $resolver,
 		private StudentHistory $history,
 		private StudentActions $actions,
+		private GuardianService $guardians,
+		private SessionSchedule $sessions,
 	) {}
 
 	public function renderPage(): void {
@@ -43,10 +47,14 @@ class StudentController {
 			fn( \WP_User $user ): array => [
 				'id'         => (int) $user->ID,
 				'name'       => $user->display_name,
-				'email'      => $user->user_email,
+				// A child's own address is an undeliverable placeholder, so the
+				// list shows the guardian's — the address an admin would use.
+				'email'      => $this->guardians->contactFor( (int) $user->ID )['email'],
 				'registered' => $user->user_registered,
 				'upcoming'   => $this->bookings->countUpcomingForStudent( (int) $user->ID ),
 				'enrolments' => $this->enrollments->countActiveForStudent( (int) $user->ID ),
+				'guardian'   => $this->guardians->guardianOf( (int) $user->ID ),
+				'children'   => $this->guardians->children( (int) $user->ID ),
 			],
 			array_filter(
 				get_users(
@@ -128,7 +136,15 @@ class StudentController {
 			$this->bookings->findByStudent( (int) $student->ID )
 		);
 
-		$schedule = StudentSchedule::partition( $rows, $now );
+		// Group classes join the upcoming table so "what is this student booked
+		// into next week?" has one answer instead of two. Only their upcoming
+		// sessions are added: the enrolment table below already records the whole
+		// history, and a term's worth of past dates would bury the lessons under
+		// "Past lessons".
+		$schedule = StudentSchedule::partition(
+			array_merge( $rows, $this->groupSessionRows( (int) $student->ID, $now ) ),
+			$now
+		);
 		$upcoming = $schedule['upcoming'];
 		$past     = $schedule['past'];
 
@@ -150,10 +166,19 @@ class StudentController {
 		$intake           = $this->history->intakeAnswers( (int) $student->ID );
 		$payments         = $canBilling ? $this->history->payments( (int) $student->ID ) : [];
 		$credits          = $canBilling ? $this->history->credits( (int) $student->ID ) : [];
-		$creditBalance    = $canBilling ? $this->history->creditBalance( (int) $student->ID ) : 0.0;
 		$creditCurrency   = $this->creditCurrency( $credits );
 
+		// The family panel, and the account whose balance actually settles this
+		// student's charges — a child's is their guardian's, so showing the
+		// child's own (always empty) balance would be actively misleading.
+		$guardian = $this->guardians->guardianOf( (int) $student->ID );
+		$children = $this->guardians->children( (int) $student->ID );
+		$payer    = $this->guardians->contactFor( (int) $student->ID );
+
+		$creditBalance = $canBilling ? $this->history->creditBalance( $payer['id'] ) : 0.0;
+
 		$backUrl  = admin_url( 'admin.php?page=us-students' );
+		$pageSlug = 'us-students';
 		include USC_PLUGIN_DIR . 'templates/admin/student-detail.php';
 	}
 
@@ -179,6 +204,8 @@ class StudentController {
 
 		return [
 			'id'         => (int) $lesson->id,
+			'kind'       => 'lesson',
+			'schedule'   => null,
 			'start_dt'   => $slot ? $slot->startDt : '',
 			'end_dt'     => $slot ? $slot->endDt : '',
 			'offering'   => $offering ? $offering->title : '—',
@@ -186,4 +213,34 @@ class StudentController {
 			'status'     => $lesson->status,
 		];
 	}
+
+	/**
+	 * The student's upcoming group-class sessions, shaped like the lesson rows
+	 * they sit beside. `kind` is what keeps the table honest: a session is a date
+	 * in a term, not a booked slot, so the row offers no "Cancel" — withdrawing
+	 * is done from the enrolment table, which removes the whole class at once.
+	 *
+	 * @return list<array<string, mixed>>
+	 */
+	private function groupSessionRows( int $studentId, string $now ): array {
+		return array_map(
+			static function ( array $session ): array {
+				$instructor = get_userdata( $session['instructor_id'] );
+
+				return [
+					'id'         => $session['enrollment_id'],
+					'kind'       => SessionSchedule::KIND,
+					'start_dt'   => $session['start_dt'],
+					'end_dt'     => $session['end_dt'],
+					// Set when the class has no time to put on a clock; shown in the
+					// When column in place of a date. See GroupClass\SessionSchedule.
+					'schedule'   => $session['schedule'],
+					'offering'   => $session['offering_title'],
+					'instructor' => $instructor ? $instructor->display_name : (string) $session['instructor_id'],
+					'status'     => $session['status'],
+				];
+			},
+			$this->sessions->upcomingForStudent( $studentId, $now )
+		);
+	}
 }

src/Auth/UserName.php

@@ -5,15 +5,25 @@ namespace Unsupervised\Schedular\Auth;
 
 /**
  * Resolves a person's public-facing name for display. Prefers their real name
- * (first + last), then their nickname — deliberately avoiding the account's
- * login/username, which `display_name` can otherwise expose.
+ * (first + last), then their nickname, then the display name — skipping any of
+ * them that is really the account's login or email address, which is the thing
+ * this class exists to keep off the screen.
  */
 class UserName {
 
 	/**
-	 * The display name for a user: "First Last" when a real name is set,
-	 * otherwise the WordPress nickname. Falls back to the numeric id (or an empty
-	 * string when none is given) when the user cannot be loaded or has no name.
+	 * The display name for a user: "First Last" when a real name is set, else the
+	 * first of nickname / display name that is an actual name. Falls back to the
+	 * numeric id (or an empty string when none is given) when the user cannot be
+	 * loaded or has nothing but identifiers on file.
+	 *
+	 * Display name is consulted at all because WordPress defaults **nickname** to
+	 * `user_login`, and signup uses the email address as the login — so a
+	 * self-registered account carries its own email as its nickname, and every
+	 * screen naming that person showed the address instead. The name they typed
+	 * was on file the whole time, in `display_name`. (Accounts created by a
+	 * guardian never hit this: `GuardianService::createChild()` sets `nickname`
+	 * outright, which is why children read correctly and their parents did not.)
 	 */
 	public static function format( ?\WP_User $user, int $fallbackId = 0 ): string {
 		if ( ! $user instanceof \WP_User ) {
@@ -25,11 +35,25 @@ class UserName {
 			return $full;
 		}
 
-		$nickname = trim( $user->nickname );
-		if ( '' !== $nickname ) {
-			return $nickname;
+		foreach ( [ $user->nickname, $user->display_name ] as $candidate ) {
+			$candidate = trim( (string) $candidate );
+
+			if ( '' !== $candidate && ! self::isIdentifier( $candidate, $user ) ) {
+				return $candidate;
+			}
 		}
 
 		return $fallbackId > 0 ? (string) $fallbackId : '';
 	}
+
+	/**
+	 * Whether a candidate name is really the account's login or email address
+	 * wearing a name's clothing — the case this class must never pass through.
+	 */
+	private static function isIdentifier( string $candidate, \WP_User $user ): bool {
+		$candidate = strtolower( $candidate );
+
+		return strtolower( (string) $user->user_login ) === $candidate
+			|| strtolower( (string) $user->user_email ) === $candidate;
+	}
 }

src/Availability/AvailabilityController.php

@@ -13,6 +13,7 @@ class AvailabilityController {
 	public function __construct(
 		private AvailabilityRepository $repository,
 		private OfferingRepository $offerings,
+		private WindowValidator $validator,
 	) {}
 
 	public function renderPage(): void {
@@ -21,9 +22,11 @@ class AvailabilityController {
 		}
 
 		$instructorId = get_current_user_id();
+		$notice       = '';
+		$error        = '';
 
 		if ( isset( $_POST['usc_action'] ) && check_admin_referer( 'usc_availability_action' ) ) {
-			$this->handleFormAction( $instructorId );
+			[ $notice, $error ] = $this->handleFormAction( $instructorId );
 		}
 
 		$slots           = $this->repository->findByInstructor( $instructorId );
@@ -44,17 +47,27 @@ class AvailabilityController {
 		include USC_PLUGIN_DIR . 'templates/admin/availability.php';
 	}
 
-	private function handleFormAction( int $instructorId ): void {
+	/**
+	 * Run the submitted action and report what happened. Every branch returns a
+	 * message: a form that silently reloads leaves the instructor unable to tell
+	 * "saved 41 slots" from "saved nothing".
+	 *
+	 * @return array{string, string} Success notice and error message; each is
+	 *                               empty when it does not apply.
+	 */
+	private function handleFormAction( int $instructorId ): array {
 		// Nonce is verified by the caller (renderPage) before this method runs.
 		// phpcs:disable WordPress.Security.NonceVerification.Missing
 		$action = sanitize_key( Val::string( wp_unslash( $_POST['usc_action'] ?? '' ) ) );
 
 		if ( 'add' === $action ) {
-			$this->addSlot( $instructorId );
+			return $this->addSlot( $instructorId );
 		}
 
 		if ( 'delete' === $action ) {
-			$this->deleteOwnSlot( absint( Val::int( $_POST['slot_id'] ?? 0 ) ), $instructorId );
+			return $this->deleteOwnSlot( absint( Val::int( $_POST['slot_id'] ?? 0 ) ), $instructorId )
+				? [ __( 'Availability slot deleted.', 'unsupervised-schedular' ), '' ]
+				: [ '', __( 'That slot could not be deleted. It may already be booked, or belong to someone else.', 'unsupervised-schedular' ) ];
 		}
 
 		if ( 'bulk_delete' === $action ) {
@@ -62,54 +75,116 @@ class AvailabilityController {
 			// absint-sanitized individually below.
 			// phpcs:ignore WordPress.Security.ValidatedSanitizedInput
 			$rawIds  = $_POST['slot_ids'] ?? [];
+			$deleted = 0;
+			$failed  = 0;
+
 			foreach ( is_array( $rawIds ) ? $rawIds : [] as $rawId ) {
-				$this->deleteOwnSlot( absint( Val::int( $rawId ) ), $instructorId );
+				if ( $this->deleteOwnSlot( absint( Val::int( $rawId ) ), $instructorId ) ) {
+					++$deleted;
+					continue;
 				}
+
+				++$failed;
+			}
+
+			return $this->bulkDeleteResult( $deleted, $failed );
 		}
 		// phpcs:enable WordPress.Security.NonceVerification.Missing
+
+		return [ '', '' ];
+	}
+
+	/**
+	 * Wording for a bulk delete, which can partly succeed.
+	 *
+	 * @return array{string, string}
+	 */
+	private function bulkDeleteResult( int $deleted, int $failed ): array {
+		$notice = $deleted > 0
+			? sprintf(
+				/* translators: %d: number of availability slots deleted. */
+				_n( '%d slot deleted.', '%d slots deleted.', $deleted, 'unsupervised-schedular' ),
+				$deleted
+			)
+			: '';
+
+		$error = $failed > 0
+			? sprintf(
+				/* translators: %d: number of slots that could not be deleted. */
+				_n(
+					'%d slot could not be deleted — it may already be booked.',
+					'%d slots could not be deleted — they may already be booked.',
+					$failed,
+					'unsupervised-schedular'
+				),
+				$failed
+			)
+			: '';
+
+		if ( 0 === $deleted && 0 === $failed ) {
+			$error = __( 'No slots were selected.', 'unsupervised-schedular' );
+		}
+
+		return [ $notice, $error ];
 	}
 
 	/**
 	 * Delete a slot only when it exists and belongs to the given instructor.
-	 * The repository additionally refuses to delete booked slots.
+	 * The repository additionally refuses to delete booked slots. Returns whether
+	 * the row actually went away.
 	 */
-	private function deleteOwnSlot( int $slotId, int $instructorId ): void {
+	private function deleteOwnSlot( int $slotId, int $instructorId ): bool {
 		if ( $slotId <= 0 ) {
-			return;
+			return false;
 		}
 
 		$slot = $this->repository->findById( $slotId );
-		if ( $slot && $slot->instructorId === $instructorId ) {
-			$this->repository->delete( $slotId );
-		}
+
+		if ( null === $slot || $slot->instructorId !== $instructorId ) {
+			return false;
 		}
 
-	private function addSlot( int $instructorId ): void {
+		return $this->repository->delete( $slotId );
+	}
+
+	/**
+	 * Validate and persist a submitted window.
+	 *
+	 * @return array{string, string}
+	 */
+	private function addSlot( int $instructorId ): array {
 		// phpcs:disable WordPress.Security.NonceVerification.Missing
-		$startDt = AvailabilitySlot::normalizeDateTime( sanitize_text_field( Val::string( wp_unslash( $_POST['start_dt'] ?? '' ) ) ) );
-		$endDt   = AvailabilitySlot::normalizeDateTime( sanitize_text_field( Val::string( wp_unslash( $_POST['end_dt'] ?? '' ) ) ) );
-
-		// A window must start and end on the same day (weekly repeat covers longer
-		// ranges) and fit at least one lesson; it is stored as lesson-length slots.
-		if ( null === $startDt || null === $endDt || $endDt <= $startDt || substr( $startDt, 0, 10 ) !== substr( $endDt, 0, 10 ) ) {
-			return;
-		}
-
-		$offeringId = absint( Val::int( $_POST['offering_id'] ?? 0 ) );
-		$duration   = absint( Val::int( $_POST['duration_minutes'] ?? 0 ) );
-
-		$window = new AvailabilitySlot(
-			instructorId:    $instructorId,
-			startDt:         $startDt,
-			endDt:           $endDt,
-			durationMinutes: $duration > 0 ? $duration : 60,
-			offeringId:      $offeringId > 0 ? $offeringId : null,
+		$window = $this->validator->validate(
+			$instructorId,
+			sanitize_text_field( Val::string( wp_unslash( $_POST['start_dt'] ?? '' ) ) ),
+			sanitize_text_field( Val::string( wp_unslash( $_POST['end_dt'] ?? '' ) ) ),
+			absint( Val::int( $_POST['duration_minutes'] ?? 0 ) ),
+			absint( Val::int( $_POST['offering_id'] ?? 0 ) ),
 		);
 
+		if ( $window instanceof \WP_Error ) {
+			return [ '', $window->get_error_message() ];
+		}
+
 		$recurrence = sanitize_key( Val::string( wp_unslash( $_POST['recurrence'] ?? 'single' ) ) );
 		$weeks      = absint( Val::int( $_POST['weeks'] ?? 1 ) );
-
-		$this->repository->createFromWindow( $window, 'weekly' === $recurrence, $weeks );
 		// phpcs:enable WordPress.Security.NonceVerification.Missing
+
+		$ids = $this->repository->createFromWindow( $window, 'weekly' === $recurrence, $weeks );
+
+		// The window was valid, so it split into at least one slot — an empty
+		// result means every insert failed.
+		if ( [] === $ids ) {
+			return [ '', __( 'The availability could not be saved. Please try again.', 'unsupervised-schedular' ) ];
+		}
+
+		return [
+			sprintf(
+				/* translators: %d: number of bookable slots created. */
+				_n( 'Added %d bookable slot.', 'Added %d bookable slots.', count( $ids ), 'unsupervised-schedular' ),
+				count( $ids )
+			),
+			'',
+		];
 	}
 }

src/Availability/AvailabilityEndpoint.php

@@ -4,14 +4,13 @@ declare(strict_types=1);
 namespace Unsupervised\Schedular\Availability;
 
 use Unsupervised\Schedular\Auth\RoleManager;
-use Unsupervised\Schedular\Offering\OfferingRepository;
 use Unsupervised\Schedular\Val;
 
 class AvailabilityEndpoint {
 
 	public function __construct(
 		private AvailabilityRepository $repository,
-		private OfferingRepository $offerings,
+		private WindowValidator $validator,
 	) {}
 
 	/**
@@ -113,40 +112,18 @@ class AvailabilityEndpoint {
 	}
 
 	public function create( \WP_REST_Request $request ): \WP_REST_Response|\WP_Error {
-		$instructorId = get_current_user_id();
-		$offeringId   = absint( Val::int( $request->get_param( 'offering_id' ) ) );
-		$duration     = absint( Val::int( $request->get_param( 'duration_minutes' ) ) );
-
-		// A slot may only be tied to an offering the instructor owns, so it can
-		// never inherit another instructor's price or payment routing at booking.
-		if ( $offeringId > 0 ) {
-			$offering = $this->offerings->findById( $offeringId );
-			if ( null === $offering || $offering->instructorId !== $instructorId ) {
-				return new \WP_Error( 'invalid_offering', __( 'That offering is not available.', 'unsupervised-schedular' ), [ 'status' => 400 ] );
-			}
-		}
-
-		$startDt = AvailabilitySlot::normalizeDateTime( Val::string( $request->get_param( 'start_dt' ) ) );
-		$endDt   = AvailabilitySlot::normalizeDateTime( Val::string( $request->get_param( 'end_dt' ) ) );
-
-		if ( null === $startDt || null === $endDt || $endDt <= $startDt ) {
-			return new \WP_Error( 'invalid_datetime', __( 'Provide a valid start and end, with the end after the start.', 'unsupervised-schedular' ), [ 'status' => 400 ] );
-		}
-
-		if ( substr( $startDt, 0, 10 ) !== substr( $endDt, 0, 10 ) ) {
-			return new \WP_Error( 'invalid_window', __( 'Availability must start and end on the same day. Use the weekly repeat to cover multiple weeks.', 'unsupervised-schedular' ), [ 'status' => 400 ] );
-		}
-
-		$window = new AvailabilitySlot(
-			instructorId:    $instructorId,
-			startDt:         $startDt,
-			endDt:           $endDt,
-			durationMinutes: $duration > 0 ? $duration : 60,
-			offeringId:      $offeringId > 0 ? $offeringId : null,
+		// Validation lives in WindowValidator so this endpoint and the admin form
+		// enforce exactly the same rules.
+		$window = $this->validator->validate(
+			get_current_user_id(),
+			Val::string( $request->get_param( 'start_dt' ) ),
+			Val::string( $request->get_param( 'end_dt' ) ),
+			absint( Val::int( $request->get_param( 'duration_minutes' ) ) ),
+			absint( Val::int( $request->get_param( 'offering_id' ) ) ),
 		);
 
-		if ( [] === $window->splitByDuration() ) {
-			return new \WP_Error( 'invalid_window', __( 'The availability window is shorter than the lesson length.', 'unsupervised-schedular' ), [ 'status' => 400 ] );
+		if ( $window instanceof \WP_Error ) {
+			return $window;
 		}
 
 		$ids = $this->repository->createFromWindow(
@@ -155,6 +132,12 @@ class AvailabilityEndpoint {
 			absint( Val::int( $request->get_param( 'weeks' ) ) )
 		);
 
+		// A valid window splits into at least one slot, so nothing written means
+		// every insert failed.
+		if ( [] === $ids ) {
+			return new \WP_Error( 'not_saved', __( 'The availability could not be saved.', 'unsupervised-schedular' ), [ 'status' => 500 ] );
+		}
+
 		return new \WP_REST_Response( [ 'ids' => $ids ], 201 );
 	}
 

src/Availability/AvailabilityRepository.php

@@ -11,8 +11,14 @@ class AvailabilityRepository {
 		$this->table = $db->prefix . 'us_availability';
 	}
 
+	/**
+	 * Insert one slot row. Returns its id, or 0 when the write failed —
+	 * `insert_id` still holds the *previous* statement's id after a failed
+	 * insert, so returning it unconditionally made a failed write look like a
+	 * successful one.
+	 */
 	public function insert( AvailabilitySlot $slot ): int {
-		$this->db->insert(
+		$written = $this->db->insert(
 			$this->table,
 			[
 				'instructor_id'    => $slot->instructorId,
@@ -27,7 +33,7 @@ class AvailabilityRepository {
 			[ '%d', '%d', '%s', '%s', '%d', '%d', '%d', '%s' ]
 		);
 
-		return $this->db->insert_id;
+		return false === $written ? 0 : $this->db->insert_id;
 	}
 
 	/**
@@ -42,9 +48,17 @@ class AvailabilityRepository {
 		$ids = [];
 
 		foreach ( $window->splitByDuration() as $slot ) {
-			$ids = $weekly
-				? array_merge( $ids, $this->createWeeklySeries( $slot, $weeks ) )
-				: [ ...$ids, $this->insert( $slot ) ];
+			if ( $weekly ) {
+				$ids = array_merge( $ids, $this->createWeeklySeries( $slot, $weeks ) );
+				continue;
+			}
+
+			$id = $this->insert( $slot );
+
+			// A failed insert returns 0; it must not reach the caller as an id.
+			if ( $id > 0 ) {
+				$ids[] = $id;
+			}
 		}
 
 		return $ids;
@@ -55,10 +69,14 @@ class AvailabilityRepository {
 	 * separate row one week apart, all sharing a `recurrence_group` (the id of the
 	 * first row).
 	 *
+	 * The count is clamped to `AvailabilitySlot::MAX_WEEKLY_OCCURRENCES`. The
+	 * form's `max` attribute says the same, but only this is binding — a
+	 * hand-crafted POST used to be able to ask for an unbounded number of rows.
+	 *
 	 * @return list<int> Inserted slot IDs.
 	 */
 	public function createWeeklySeries( AvailabilitySlot $first, int $occurrences ): array {
-		$occurrences = max( 1, $occurrences );
+		$occurrences = max( 1, min( AvailabilitySlot::MAX_WEEKLY_OCCURRENCES, $occurrences ) );
 		$start       = new \DateTimeImmutable( $first->startDt );
 		$end         = new \DateTimeImmutable( $first->endDt );
 
@@ -79,6 +97,13 @@ class AvailabilityRepository {
 				)
 			);
 
+			// A failed insert returns 0. Skipping it keeps a bogus id out of the
+			// returned list and, more importantly, stops 0 becoming the series'
+			// recurrence group — which would orphan every later occurrence.
+			if ( $id <= 0 ) {
+				continue;
+			}
+
 			if ( 0 === $groupId ) {
 				$groupId = $id;
 				$this->setRecurrenceGroup( $id, $groupId );

src/Availability/AvailabilitySlot.php

@@ -7,6 +7,23 @@ use Unsupervised\Schedular\Val;
 
 class AvailabilitySlot {
 
+	/** Lesson length used when none was submitted. */
+	public const DEFAULT_DURATION_MINUTES = 60;
+
+	/**
+	 * Lesson lengths a window can be split into, offered by the availability
+	 * form. The form hides the ones a given window is too short for.
+	 *
+	 * @var list<int>
+	 */
+	public const DURATION_CHOICES = [ 30, 60 ];
+
+	/**
+	 * Ceiling on a weekly series, matching the form's `max`. Enforced in the
+	 * repository too, so a hand-crafted POST cannot ask for ten thousand rows.
+	 */
+	public const MAX_WEEKLY_OCCURRENCES = 52;
+
 	public function __construct(
 		public readonly int $instructorId,
 		public readonly string $startDt,

src/Availability/WindowValidator.php

@@ -0,0 +1,105 @@
+<?php
+declare(strict_types=1);
+
+namespace Unsupervised\Schedular\Availability;
+
+use Unsupervised\Schedular\Offering\OfferingRepository;
+
+/**
+ * Validates a submitted availability window.
+ *
+ * The admin form and the REST endpoint both accept the same window, and used to
+ * check it independently — the endpoint returning a specific 400 for each
+ * failure while the form simply returned, saving nothing and saying nothing. A
+ * 30-minute window submitted with the default 60-minute lesson length was the
+ * visible symptom: no rows, no error, no clue. Both callers now come through
+ * here, so neither can drift from the other again.
+ *
+ * Every rejection is a `WP_Error` carrying a message written for the person who
+ * submitted the form: the endpoint returns it as-is (the `status` data makes it
+ * a 400), and the admin screen shows `get_error_message()` in a notice.
+ */
+class WindowValidator {
+
+	public function __construct( private OfferingRepository $offerings ) {}
+
+	/**
+	 * Check a submitted window and return it ready to persist.
+	 *
+	 * @param int    $instructorId    Instructor the window belongs to.
+	 * @param string $rawStart        Submitted start, in any form {@see AvailabilitySlot::normalizeDateTime()} accepts.
+	 * @param string $rawEnd          Submitted end, likewise.
+	 * @param int    $durationMinutes Lesson length the window is split into; 0 falls back to the 60-minute default.
+	 * @param int    $offeringId      Offering the slots are tied to, or 0 for any private lesson.
+	 *
+	 * @return AvailabilitySlot|\WP_Error The window, or why it was rejected.
+	 */
+	public function validate( int $instructorId, string $rawStart, string $rawEnd, int $durationMinutes, int $offeringId ): AvailabilitySlot|\WP_Error {
+		$startDt = AvailabilitySlot::normalizeDateTime( $rawStart );
+		$endDt   = AvailabilitySlot::normalizeDateTime( $rawEnd );
+
+		if ( null === $startDt || null === $endDt ) {
+			return new \WP_Error(
+				'invalid_datetime',
+				__( 'Enter a valid start and end date and time.', 'unsupervised-schedular' ),
+				[ 'status' => 400 ]
+			);
+		}
+
+		if ( $endDt <= $startDt ) {
+			return new \WP_Error(
+				'invalid_datetime',
+				__( 'The end time must be after the start time.', 'unsupervised-schedular' ),
+				[ 'status' => 400 ]
+			);
+		}
+
+		if ( substr( $startDt, 0, 10 ) !== substr( $endDt, 0, 10 ) ) {
+			return new \WP_Error(
+				'invalid_window',
+				__( 'Availability must start and end on the same day. Use the weekly repeat to cover multiple weeks.', 'unsupervised-schedular' ),
+				[ 'status' => 400 ]
+			);
+		}
+
+		// A slot may only be tied to an offering the instructor owns, so it can
+		// never inherit another instructor's price or payment routing at booking.
+		if ( $offeringId > 0 ) {
+			$offering = $this->offerings->findById( $offeringId );
+
+			if ( null === $offering || $offering->instructorId !== $instructorId ) {
+				return new \WP_Error(
+					'invalid_offering',
+					__( 'That offering is not available.', 'unsupervised-schedular' ),
+					[ 'status' => 400 ]
+				);
+			}
+		}
+
+		$duration = $durationMinutes > 0 ? $durationMinutes : AvailabilitySlot::DEFAULT_DURATION_MINUTES;
+
+		$window = new AvailabilitySlot(
+			instructorId:    $instructorId,
+			startDt:         $startDt,
+			endDt:           $endDt,
+			durationMinutes: $duration,
+			offeringId:      $offeringId > 0 ? $offeringId : null,
+		);
+
+		// The window is stored as lesson-length slots, so one that cannot fit a
+		// single lesson would persist nothing at all.
+		if ( [] === $window->splitByDuration() ) {
+			return new \WP_Error(
+				'invalid_window',
+				sprintf(
+					/* translators: %d: the selected lesson length, in minutes. */
+					__( 'This window is shorter than the %d-minute lesson length, so it holds no bookable slots. Choose a shorter lesson length or a longer window.', 'unsupervised-schedular' ),
+					$duration
+				),
+				[ 'status' => 400 ]
+			);
+		}
+
+		return $window;
+	}
+}

src/BlockPreview.php

@@ -15,6 +15,12 @@ namespace Unsupervised\Schedular;
  */
 class BlockPreview {
 
+	/**
+	 * The marker a required field's label carries, matching the one
+	 * {@see Registration\QuestionField::render()} puts on a required question.
+	 */
+	private const REQUIRED_MARK = ' <span class="us-required" aria-hidden="true">*</span>';
+
 	/**
 	 * Sample booking page.
 	 *
@@ -86,13 +92,13 @@ class BlockPreview {
 	private static function upcomingLessons(): string {
 		return sprintf(
 			'<div class="us-my-lessons"><h3>%s</h3>'
-			. '<div class="us-my-lesson"><span class="us-my-lesson-info">'
+			. '<div class="us-my-lesson"><div class="us-my-lesson-info">'
 			. '<strong class="us-my-lesson-title">%s <span class="us-my-lesson-duration">(30 min)</span></strong>'
-			. '<span class="us-my-lesson-when">%s</span></span>'
-			. '<span class="us-my-lesson-actions">'
+			. '<span class="us-my-lesson-when">%s</span></div>'
+			. '<div class="us-my-lesson-actions">'
 			. '<span class="us-lesson-status us-lesson-status-confirmed">%s</span>'
 			. '<button type="button" class="us-cancel-lesson" disabled>%s</button>'
-			. '</span></div></div>',
+			. '</div></div></div>',
 			esc_html__( 'Your upcoming lessons', 'unsupervised-schedular' ),
 			esc_html__( 'Piano Lesson', 'unsupervised-schedular' ),
 			esc_html__( 'Monday · 4:00 PM–4:30 PM', 'unsupervised-schedular' ),
@@ -118,11 +124,13 @@ class BlockPreview {
 			: '<p>' . esc_html__( 'A sample class shown so the page can be styled.', 'unsupervised-schedular' ) . '</p>';
 
 		return sprintf(
-			'<div id="us-group-app">%s<div id="us-group-list"><div class="us-class"><h3>%s</h3><p class="us-class-when">%s</p>%s<p>25.00 CAD</p><p class="us-enrol-deadline">%s</p><button type="button" class="us-enrol-btn" disabled>%s</button></div></div></div>',
+			'<div id="us-group-app">%s<div id="us-group-list"><div class="us-class"><h3>%s</h3><p class="us-class-when">%s</p>%s<p class="us-class-price">%s</p><p class="us-enrol-deadline">%s</p><button type="button" class="us-enrol-btn" disabled>%s</button></div></div></div>',
 			self::note( $note ),
 			esc_html__( 'Beginner Group Class', 'unsupervised-schedular' ),
 			esc_html__( 'Saturdays 10:00 AM–11:00 AM', 'unsupervised-schedular' ),
 			$description,
+			// Prices on the live page always carry their cadence, so the sample does too.
+			esc_html__( '25.00 CAD up front', 'unsupervised-schedular' ),
 			esc_html__( 'Enrol by Sep 6, 2026', 'unsupervised-schedular' ),
 			esc_html__( 'Enrol', 'unsupervised-schedular' )
 		);
@@ -167,6 +175,78 @@ class BlockPreview {
 		);
 	}
 
+	/**
+	 * Sample family page: the account holder's own details, two representative
+	 * children and the add form, with the controls inert so the editor preview
+	 * cannot post.
+	 */
+	public static function family(): string {
+		$self = sprintf(
+			'<h4>%s</h4><p class="us-family-self-email">%s <span>[email protected]</span></p>'
+				. '<p><label for="us-own-name">%s' . self::REQUIRED_MARK . '</label><input type="text" id="us-own-name" value="%s"></p>'
+				. '<p><label><input type="checkbox" checked disabled> %s</label></p>'
+				. '<p><label for="us-own-birth-year">%s</label><input type="number" id="us-own-birth-year" placeholder="YYYY"></p>'
+				. '<p><button type="button" disabled>%s</button></p>',
+			esc_html__( 'Your details', 'unsupervised-schedular' ),
+			esc_html__( 'Email', 'unsupervised-schedular' ),
+			esc_html__( 'Your name', 'unsupervised-schedular' ),
+			esc_attr__( 'Grace Hopper', 'unsupervised-schedular' ),
+			esc_html__( 'I take lessons myself', 'unsupervised-schedular' ),
+			esc_html__( 'Your birth year', 'unsupervised-schedular' ),
+			esc_html__( 'Save my details', 'unsupervised-schedular' )
+		);
+
+		$children = '';
+		foreach ( [ 'Ada Lovelace', 'Alan Turing' ] as $name ) {
+			$children .= sprintf(
+				'<li class="us-family-child"><span class="us-family-child-name">%s</span>'
+					. '<span class="us-family-child-actions"><a href="#">%s</a> <button type="button" disabled>%s</button></span></li>',
+				esc_html( $name ),
+				esc_html__( 'Edit', 'unsupervised-schedular' ),
+				esc_html__( 'Remove', 'unsupervised-schedular' )
+			);
+		}
+
+		$add = sprintf(
+			'<h4>%s</h4><p><label for="us-child-name">%s' . self::REQUIRED_MARK . '</label><input type="text" id="us-child-name"></p>'
+				. '<p><label for="us-child-birth-year">%s' . self::REQUIRED_MARK . '</label><input type="number" id="us-child-birth-year" placeholder="YYYY"></p>'
+				. '<p><button type="button" disabled>%s</button></p>',
+			esc_html__( 'Add a student', 'unsupervised-schedular' ),
+			esc_html__( 'Name', 'unsupervised-schedular' ),
+			esc_html__( 'Birth year', 'unsupervised-schedular' ),
+			esc_html__( 'Add student', 'unsupervised-schedular' )
+		);
+
+		return sprintf(
+			'<div class="us-family">%s<h3>%s</h3><form class="us-family-self">%s</form>'
+				. '<h4>%s</h4><ul class="us-family-list">%s</ul><form class="us-family-add">%s</form></div>',
+			self::note( __( 'Editor preview — signed-in visitors see and manage their own details and students here.', 'unsupervised-schedular' ) ),
+			esc_html__( 'Your profile', 'unsupervised-schedular' ),
+			$self,
+			esc_html__( 'Your students', 'unsupervised-schedular' ),
+			$children,
+			$add
+		);
+	}
+
+	/**
+	 * Sample account panel. Shown populated whatever the editor's own login
+	 * state, since on the published page a signed-out visitor may see nothing at
+	 * all and an empty box tells the person placing the block nothing.
+	 */
+	public static function account(): string {
+		return sprintf(
+			'<div class="us-account">%s'
+				. '<p class="us-account-who"><span class="us-account-name">%s</span>'
+				. '<span class="us-account-email">%s</span></p>'
+				. '<p class="us-account-actions"><a class="us-account-signout" href="#">%s</a></p></div>',
+			self::note( __( 'Editor preview — each visitor sees their own account here.', 'unsupervised-schedular' ) ),
+			esc_html__( 'Grace Hopper', 'unsupervised-schedular' ),
+			esc_html__( '[email protected]', 'unsupervised-schedular' ),
+			esc_html__( 'Sign out', 'unsupervised-schedular' )
+		);
+	}
+
 	private static function note( string $text ): string {
 		return '<p class="us-editor-note">' . esc_html( $text ) . '</p>';
 	}

src/BlockRegistrar.php

@@ -3,10 +3,12 @@ declare(strict_types=1);
 
 namespace Unsupervised\Schedular;
 
+use Unsupervised\Schedular\Auth\AccountPage;
 use Unsupervised\Schedular\Auth\LoginPage;
 use Unsupervised\Schedular\Auth\RegistrationPage;
 use Unsupervised\Schedular\Booking\BookingPage;
 use Unsupervised\Schedular\GroupClass\GroupClassPage;
+use Unsupervised\Schedular\Guardian\FamilyPage;
 
 /**
  * Registers Gutenberg dynamic-block wrappers for the front-end shortcodes so
@@ -28,6 +30,8 @@ class BlockRegistrar {
 		private LoginPage $loginPage,
 		private RegistrationPage $registrationPage,
 		private GroupClassPage $groupClassPage,
+		private FamilyPage $familyPage,
+		private AccountPage $accountPage,
 	) {}
 
 	public function register(): void {
@@ -137,6 +141,24 @@ class BlockRegistrar {
 					],
 				],
 			],
+			'us-scheduler/family'           => [
+				'render'     => [ $this, 'renderFamily' ],
+				'attributes' => [
+					'loginPageId' => [
+						'type'    => 'number',
+						'default' => 0,
+					],
+				],
+			],
+			'us-scheduler/account'          => [
+				'render'     => [ $this, 'renderAccount' ],
+				'attributes' => [
+					'loginPageId' => [
+						'type'    => 'number',
+						'default' => 0,
+					],
+				],
+			],
 		];
 	}
 
@@ -184,6 +206,24 @@ class BlockRegistrar {
 		return BlockPreview::groupClasses( Val::int( $attributes['offeringId'] ?? 0 ) > 0 );
 	}
 
+	/**
+	 * Renders the account (who is signed in) block.
+	 *
+	 * @param array<string, mixed> $attributes Block attributes.
+	 */
+	public function renderAccount( array $attributes = [] ): string {
+		return $this->isEditorPreview() ? BlockPreview::account() : $this->accountPage->render( $attributes );
+	}
+
+	/**
+	 * Renders the family (manage-children) block.
+	 *
+	 * @param array<string, mixed> $attributes Block attributes.
+	 */
+	public function renderFamily( array $attributes = [] ): string {
+		return $this->isEditorPreview() ? BlockPreview::family() : $this->familyPage->render( $attributes );
+	}
+
 	/**
 	 * Server-side auto-redirect for blocks that opt in via their autoRedirect
 	 * attribute: logged-out visitors on a page containing the booking block

src/Booking/BookingEndpoint.php

@@ -5,6 +5,8 @@ namespace Unsupervised\Schedular\Booking;
 
 use Unsupervised\Schedular\Availability\AvailabilityRepository;
 use Unsupervised\Schedular\Auth\RoleManager;
+use Unsupervised\Schedular\GroupClass\SessionSchedule;
+use Unsupervised\Schedular\Guardian\GuardianService;
 use Unsupervised\Schedular\Offering\Offering;
 use Unsupervised\Schedular\Offering\OfferingRepository;
 use Unsupervised\Schedular\Payment\Payment;
@@ -28,6 +30,8 @@ class BookingEndpoint {
 		private RegistrationGate $gate,
 		private PaymentService $payments,
 		private CancellationPolicy $cancellationPolicy,
+		private GuardianService $guardians,
+		private SessionSchedule $sessions,
 	) {}
 
 	/**
@@ -59,6 +63,13 @@ class BookingEndpoint {
 							'type'    => 'integer',
 							'default' => 0,
 						],
+						// Who the lesson is for. 0/absent means the caller books for
+						// themselves; a child's id is honoured only for their guardian.
+						'student_id'                  => [
+							'type'              => 'integer',
+							'default'           => 0,
+							'sanitize_callback' => 'absint',
+						],
 						'recurrence'                  => [
 							'type'    => 'string',
 							'default' => 'single',
@@ -115,11 +126,57 @@ class BookingEndpoint {
 
 	public function myLessons( \WP_REST_Request $request ): \WP_REST_Response { // phpcs:ignore Generic.CodeAnalysis.UnusedFunctionParameter.Found
 		$userId = get_current_user_id();
-		$lessons = current_user_can( RoleManager::CAP_MANAGE_AVAILABILITY )
-			? $this->bookings->findUpcomingForInstructor( $userId )
-			: $this->bookings->findUpcomingForStudent( $userId );
+		$now    = current_time( 'mysql' );
 
-		return new \WP_REST_Response( array_map( fn( Lesson $l ): array => $this->lessonWithTimes( $l ), $lessons ), 200 );
+		// Group classes are listed here too. A term-based class has no row in
+		// us_availability, so nothing that only read lessons could show one, and a
+		// student whose whole week was a group class saw an empty schedule.
+		if ( current_user_can( RoleManager::CAP_MANAGE_AVAILABILITY ) ) {
+			$lessons = $this->bookings->findUpcomingForInstructor( $userId );
+
+			// One row per session the instructor teaches, not per student in it.
+			$sessions = array_map(
+				static fn( array $session ): array => $session + [ 'kind' => SessionSchedule::KIND ],
+				$this->sessions->upcomingForInstructor( $userId, $now )
+			);
+		} else {
+			// A guardian's list covers the whole household — their own lessons and
+			// every child's — merged and re-sorted so the soonest is first
+			// regardless of whose it is.
+			$lessons  = [];
+			$sessions = [];
+			foreach ( $this->guardians->householdIds( $userId ) as $studentId ) {
+				$lessons  = array_merge( $lessons, $this->bookings->findUpcomingForStudent( $studentId ) );
+				$sessions = array_merge( $sessions, $this->sessionRows( $studentId, $now ) );
+			}
+		}
+
+		$rows = array_merge(
+			array_map( fn( Lesson $l ): array => $this->lessonWithTimes( $l ), $lessons ),
+			$sessions
+		);
+
+		// usort reindexes in place, so the response is already a list.
+		usort( $rows, static fn( array $a, array $b ): int => Val::string( $a['start_dt'] ?? '' ) <=> Val::string( $b['start_dt'] ?? '' ) );
+
+		return new \WP_REST_Response( $rows, 200 );
+	}
+
+	/**
+	 * One student's upcoming group-class sessions, shaped like the lesson rows
+	 * beside them so a single list renders both. `kind` is what tells them apart:
+	 * a session is not a booked slot, so it carries no cancel action.
+	 *
+	 * @return list<array<string, mixed>>
+	 */
+	private function sessionRows( int $studentId, string $now ): array {
+		return array_map(
+			fn( array $session ): array => $session + [
+				'kind'         => SessionSchedule::KIND,
+				'student_name' => $this->guardians->studentName( $studentId ),
+			],
+			$this->sessions->upcomingForStudent( $studentId, $now )
+		);
 	}
 
 	/**
@@ -144,10 +201,21 @@ class BookingEndpoint {
 			'end_dt'           => $slot?->endDt,
 			'offering_title'   => $offering?->title,
 			'duration_minutes' => $duration,
+			// Whose lesson it is, so a guardian's merged list can say which child
+			// each row belongs to.
+			'student_name'     => $this->guardians->studentName( $lesson->studentId ),
 		];
 	}
 
 	public function book( \WP_REST_Request $request ): \WP_REST_Response|\WP_Error {
+		// Who the lesson is for is settled before anything else is touched: an
+		// unauthorised student id must never get as far as claiming a slot, and
+		// certainly never as far as raising a payment against someone's account.
+		$studentId = $this->resolveStudent( $request );
+		if ( $studentId instanceof \WP_Error ) {
+			return $studentId;
+		}
+
 		$slotId = Val::int( $request->get_param( 'slot_id' ) );
 		$slot   = $this->availability->findById( $slotId );
 
@@ -214,7 +282,6 @@ class BookingEndpoint {
 			return $gateError;
 		}
 
-		$studentId  = get_current_user_id();
 		$notes      = Val::string( $request->get_param( 'notes' ) );
 		$recurrence = Lesson::RECURRENCE_WEEKLY === $request->get_param( 'recurrence' )
 			? Lesson::RECURRENCE_WEEKLY
@@ -254,7 +321,9 @@ class BookingEndpoint {
 			$ids      = [ $anchorId ];
 		}
 
-		$this->gate->record( PolicyAcceptance::REG_LESSON, $anchorId, $studentId, $offeringId, $answers, $acceptedVersionIds, $this->clientIp() );
+		// The acceptance binds the student but is attributed to whoever actually
+		// ticked the boxes — the guardian, when they booked for a child.
+		$this->gate->record( PolicyAcceptance::REG_LESSON, $anchorId, $studentId, $offeringId, $answers, $acceptedVersionIds, $this->clientIp(), get_current_user_id() );
 
 		$payment = null;
 		$status  = Lesson::STATUS_PENDING;
@@ -276,7 +345,16 @@ class BookingEndpoint {
 				? $offering->price
 				: $offering->price * count( $ids );
 
-			$payment = $this->payments->createForRegistration( Payment::REG_LESSON, $anchorId, $studentId, $slot->instructorId, $amount, $offering->currency, $offering->etransferEmail );
+			$payment = $this->payments->createForRegistration(
+				Payment::REG_LESSON,
+				$anchorId,
+				$studentId,
+				$slot->instructorId,
+				$amount,
+				$offering->currency,
+				$offering->etransferEmail,
+				payerId: $this->guardians->payerFor( $studentId )
+			);
 
 			if ( null !== $payment && $payment->isPaid() ) {
 				$status = Lesson::STATUS_CONFIRMED;
@@ -303,6 +381,35 @@ class BookingEndpoint {
 		);
 	}
 
+	/**
+	 * Who this booking is for: the caller by default, or one of their children
+	 * when a `student_id` is supplied and they are that child's guardian.
+	 *
+	 * This is the authorisation boundary of guardian booking — without it any
+	 * signed-in student could book, and bill, against any user id they chose to
+	 * send. An id the caller may not act for is a 403, never a silent fallback to
+	 * themselves: a guardian who picked the wrong child needs to be told, not to
+	 * have the lesson quietly booked in their own name.
+	 */
+	private function resolveStudent( \WP_REST_Request $request ): int|\WP_Error {
+		$userId    = get_current_user_id();
+		$requested = absint( Val::int( $request->get_param( 'student_id' ) ) );
+
+		if ( $requested <= 0 || $requested === $userId ) {
+			return $userId;
+		}
+
+		if ( ! $this->guardians->canActFor( $userId, $requested ) ) {
+			return new \WP_Error(
+				'forbidden',
+				__( 'You cannot book on behalf of that student.', 'unsupervised-schedular' ),
+				[ 'status' => 403 ]
+			);
+		}
+
+		return $requested;
+	}
+
 	/**
 	 * Extract a question_id => value map from the request.
 	 *
@@ -342,7 +449,8 @@ class BookingEndpoint {
 	}
 
 	/**
-	 * Student-initiated cancellation of their own lesson: marks it cancelled,
+	 * Student-initiated cancellation of their own lesson — or a guardian's, of one
+	 * of their children's: marks it cancelled,
 	 * frees the slot for rebooking, and voids any still-pending payment. A lesson
 	 * already paid for is credited back to the student's account (a per-lesson
 	 * share of the covering payment) to offset their future scheduled billing.
@@ -355,7 +463,7 @@ class BookingEndpoint {
 			return new \WP_Error( 'not_found', __( 'Booking not found.', 'unsupervised-schedular' ), [ 'status' => 404 ] );
 		}
 
-		if ( get_current_user_id() !== $lesson->studentId ) {
+		if ( ! $this->guardians->canActFor( get_current_user_id(), $lesson->studentId ) ) {
 			return new \WP_Error( 'forbidden', __( 'You cannot cancel this booking.', 'unsupervised-schedular' ), [ 'status' => 403 ] );
 		}
 

src/Booking/BookingPage.php

@@ -5,6 +5,7 @@ namespace Unsupervised\Schedular\Booking;
 
 use Unsupervised\Schedular\Auth\RegistrationStatus;
 use Unsupervised\Schedular\Auth\RoleManager;
+use Unsupervised\Schedular\Guardian\GuardianService;
 use Unsupervised\Schedular\Val;
 
 class BookingPage {
@@ -18,6 +19,8 @@ class BookingPage {
 	/** The student's upcoming lessons only — nothing bookable. */
 	public const MODE_UPCOMING = 'upcoming';
 
+	public function __construct( private GuardianService $guardians ) {}
+
 	/**
 	 * Renders the booking shortcode/block output.
 	 *
@@ -64,6 +67,11 @@ class BookingPage {
 		$showBooking  = self::MODE_UPCOMING !== $mode;
 		$showUpcoming = self::MODE_BOOKING !== $mode;
 
+		// Who this account may book for. A single-student account gets one entry
+		// (themselves) and no selector at all; a guardian's list leads with their
+		// children, so the default choice is never the parent.
+		$students = $this->guardians->bookableStudents( get_current_user_id() );
+
 		ob_start();
 		include USC_PLUGIN_DIR . 'templates/frontend/booking-page.php';
 		return (string) ob_get_clean();

src/Booking/LessonController.php

@@ -75,8 +75,8 @@ class LessonController {
 			$accepts = [];
 		} else {
 			$row     = $this->row( $lesson );
-			$answers = $this->detail->answers( $lessonId );
-			$accepts = $this->detail->acceptances( $lessonId );
+			$answers = $this->detail->answers( $lesson );
+			$accepts = $this->detail->acceptances( $lesson );
 		}
 
 		include USC_PLUGIN_DIR . 'templates/admin/lesson-detail.php';

src/Booking/LessonDetail.php

@@ -17,6 +17,12 @@ use Unsupervised\Schedular\Registration\QuestionRepository;
  *
  * Scoped to a single lesson (the `lesson` registration type), mirroring the
  * per-student history in {@see \Unsupervised\Schedular\Auth\StudentHistory}.
+ *
+ * A weekly reservation is answered for and agreed to once, so its answers and
+ * acceptances hang off the series anchor. Every occurrence therefore reads its
+ * series' registration, not its own id — otherwise only the first lesson of a
+ * series showed the intake and the audit trail, and the rest looked as though
+ * nothing had been accepted.
  */
 class LessonDetail {
 
@@ -33,7 +39,7 @@ class LessonDetail {
 	 *
 	 * @return list<array{question: string, answer: string}>
 	 */
-	public function answers( int $lessonId ): array {
+	public function answers( Lesson $lesson ): array {
 		return array_map(
 			function ( Answer $answer ): array {
 				$question = $this->questions->findById( $answer->questionId );
@@ -44,7 +50,7 @@ class LessonDetail {
 					'answer'   => '' === $value ? '—' : $value,
 				];
 			},
-			$this->answers->findByRegistration( Answer::REG_LESSON, $lessonId )
+			$this->answers->findByRegistration( Answer::REG_LESSON, $this->registrationId( $lesson ) )
 		);
 	}
 
@@ -54,7 +60,7 @@ class LessonDetail {
 	 *
 	 * @return list<array{policy: string, version: string, accepted_at: string, ip: string}>
 	 */
-	public function acceptances( int $lessonId ): array {
+	public function acceptances( Lesson $lesson ): array {
 		return array_map(
 			function ( PolicyAcceptance $acceptance ): array {
 				$version = $this->versions->findById( $acceptance->policyVersionId );
@@ -67,7 +73,15 @@ class LessonDetail {
 					'ip'          => $acceptance->ipAddress ?? '',
 				];
 			},
-			$this->acceptances->findByRegistration( PolicyAcceptance::REG_LESSON, $lessonId )
+			$this->acceptances->findByRegistration( PolicyAcceptance::REG_LESSON, $this->registrationId( $lesson ) )
 		);
 	}
+
+	/**
+	 * The lesson id the booking's answers and acceptances were recorded against:
+	 * the series anchor for a weekly reservation, the lesson itself otherwise.
+	 */
+	private function registrationId( Lesson $lesson ): int {
+		return $lesson->seriesId ?? (int) $lesson->id;
+	}
 }

src/GroupClass/EnrollmentEndpoint.php

@@ -4,6 +4,7 @@ declare(strict_types=1);
 namespace Unsupervised\Schedular\GroupClass;
 
 use Unsupervised\Schedular\Auth\RoleManager;
+use Unsupervised\Schedular\Guardian\GuardianService;
 use Unsupervised\Schedular\Offering\Offering;
 use Unsupervised\Schedular\Offering\OfferingRepository;
 use Unsupervised\Schedular\Payment\Payment;
@@ -20,6 +21,7 @@ class EnrollmentEndpoint {
 		private RegistrationGate $gate,
 		private PaymentService $payments,
 		private GroupAccessRepository $access,
+		private GuardianService $guardians,
 	) {}
 
 	/**
@@ -47,6 +49,13 @@ class EnrollmentEndpoint {
 							'required'          => true,
 							'sanitize_callback' => 'absint',
 						],
+						// Who is being enrolled. 0/absent means the caller enrols
+						// themselves; a child's id is honoured only for their guardian.
+						'student_id'                  => [
+							'type'              => 'integer',
+							'default'           => 0,
+							'sanitize_callback' => 'absint',
+						],
 						'answers'                     => [
 							'type'    => 'object',
 							'default' => [],
@@ -81,13 +90,25 @@ class EnrollmentEndpoint {
 		} elseif ( current_user_can( RoleManager::CAP_MANAGE_AVAILABILITY ) ) {
 			$enrollments = $this->enrollments->findByInstructor( $userId );
 		} else {
-			$enrollments = $this->enrollments->findByStudent( $userId );
+			// A guardian sees the whole household's enrolments — their own and
+			// every child's — so one account covers the family.
+			$enrollments = [];
+			foreach ( $this->guardians->householdIds( $userId ) as $studentId ) {
+				$enrollments = array_merge( $enrollments, $this->enrollments->findByStudent( $studentId ) );
+			}
 		}
 
 		return new \WP_REST_Response( array_map( fn( Enrollment $e ) => $e->toArray(), $enrollments ), 200 );
 	}
 
 	public function enroll( \WP_REST_Request $request ): \WP_REST_Response|\WP_Error {
+		// Who is being enrolled is settled before anything else, so an
+		// unauthorised student id never reaches a seat claim or a charge.
+		$studentId = $this->resolveStudent( $request );
+		if ( $studentId instanceof \WP_Error ) {
+			return $studentId;
+		}
+
 		$offeringId = absint( Val::int( $request->get_param( 'offering_id' ) ) );
 		$offering   = $this->offerings->findById( $offeringId );
 
@@ -95,8 +116,6 @@ class EnrollmentEndpoint {
 			return new \WP_Error( 'invalid_offering', __( 'Group class not found.', 'unsupervised-schedular' ), [ 'status' => 404 ] );
 		}
 
-		$studentId = get_current_user_id();
-
 		if ( $this->enrollments->hasActiveEnrollment( $offeringId, $studentId ) ) {
 			return new \WP_Error( 'already_enrolled', __( 'You are already enrolled in this class.', 'unsupervised-schedular' ), [ 'status' => 409 ] );
 		}
@@ -133,7 +152,9 @@ class EnrollmentEndpoint {
 			)
 		);
 
-		$this->gate->record( PolicyAcceptance::REG_ENROLLMENT, $id, $studentId, $offeringId, $answers, $acceptedVersionIds, $this->clientIp() );
+		// The acceptance binds the student but is attributed to whoever ticked the
+		// boxes — the guardian, when they enrolled a child.
+		$this->gate->record( PolicyAcceptance::REG_ENROLLMENT, $id, $studentId, $offeringId, $answers, $acceptedVersionIds, $this->clientIp(), get_current_user_id() );
 
 		// Mark the access grant used so instructor rosters distinguish invited
 		// students from enrolled ones (a no-op for public classes).
@@ -146,7 +167,16 @@ class EnrollmentEndpoint {
 		// regardless of payment.
 		$payment = null;
 		if ( $offering->price > 0.0 && ! $offering->isScheduledBilling() ) {
-			$payment = $this->payments->createForRegistration( Payment::REG_ENROLLMENT, $id, $studentId, $offering->instructorId, $offering->price, $offering->currency, $offering->etransferEmail );
+			$payment = $this->payments->createForRegistration(
+				Payment::REG_ENROLLMENT,
+				$id,
+				$studentId,
+				$offering->instructorId,
+				$offering->price,
+				$offering->currency,
+				$offering->etransferEmail,
+				payerId: $this->guardians->payerFor( $studentId )
+			);
 		}
 
 		// `payment: null` tells the front end to skip the payment step entirely.
@@ -176,7 +206,7 @@ class EnrollmentEndpoint {
 			return new \WP_Error( 'not_found', __( 'Enrolment not found.', 'unsupervised-schedular' ), [ 'status' => 404 ] );
 		}
 
-		if ( get_current_user_id() !== $enrollment->studentId ) {
+		if ( ! $this->guardians->canActFor( get_current_user_id(), $enrollment->studentId ) ) {
 			return new \WP_Error( 'forbidden', __( 'You cannot withdraw from this class.', 'unsupervised-schedular' ), [ 'status' => 403 ] );
 		}
 
@@ -212,6 +242,30 @@ class EnrollmentEndpoint {
 		return is_user_logged_in() && current_user_can( RoleManager::CAP_BOOK_LESSON );
 	}
 
+	/**
+	 * Who this enrolment is for: the caller by default, or one of their children
+	 * when a `student_id` is supplied and they are that child's guardian. An id
+	 * the caller may not act for is a 403, never a silent fallback to themselves.
+	 */
+	private function resolveStudent( \WP_REST_Request $request ): int|\WP_Error {
+		$userId    = get_current_user_id();
+		$requested = absint( Val::int( $request->get_param( 'student_id' ) ) );
+
+		if ( $requested <= 0 || $requested === $userId ) {
+			return $userId;
+		}
+
+		if ( ! $this->guardians->canActFor( $userId, $requested ) ) {
+			return new \WP_Error(
+				'forbidden',
+				__( 'You cannot enrol that student.', 'unsupervised-schedular' ),
+				[ 'status' => 403 ]
+			);
+		}
+
+		return $requested;
+	}
+
 	/**
 	 * Extract a question_id => value map from the request.
 	 *

src/GroupClass/GroupClassPage.php

@@ -4,10 +4,13 @@ declare(strict_types=1);
 namespace Unsupervised\Schedular\GroupClass;
 
 use Unsupervised\Schedular\Auth\RoleManager;
+use Unsupervised\Schedular\Guardian\GuardianService;
 use Unsupervised\Schedular\Val;
 
 class GroupClassPage {
 
+	public function __construct( private GuardianService $guardians ) {}
+
 	/**
 	 * Renders the group-class enrolment shortcode output.
 	 *
@@ -39,6 +42,10 @@ class GroupClassPage {
 
 		$offeringId = absint( Val::int( $atts['offering'] ?? $atts['offeringId'] ?? 0 ) );
 
+		// Who this account may enrol — children first, the account holder last, so
+		// a guardian's default choice is a child rather than themselves.
+		$students = $this->guardians->bookableStudents( get_current_user_id() );
+
 		ob_start();
 		include USC_PLUGIN_DIR . 'templates/frontend/group-classes-page.php';
 		return (string) ob_get_clean();

src/GroupClass/SessionSchedule.php

@@ -0,0 +1,214 @@
+<?php
+declare(strict_types=1);
+
+namespace Unsupervised\Schedular\GroupClass;
+
+use Unsupervised\Schedular\Offering\Offering;
+use Unsupervised\Schedular\Offering\OfferingRepository;
+
+/**
+ * Turns group-class enrolments into dated sessions, so a class can appear
+ * alongside one-to-one lessons in every "upcoming" view.
+ *
+ * A group class is stored as a term (`term_start`, `term_end`, `class_time`)
+ * rather than as rows in `us_availability`, which is why an enrolment on its own
+ * has no date on it and why nothing that listed lessons ever showed one. The
+ * dates come from {@see Offering::sessionStarts()} — the same derivation the
+ * billing scan and the class-slot reconciler build on, so a student's list, an
+ * instructor's list and the invoice all agree on when the class meets.
+ *
+ * **A class you are enrolled in must never silently vanish from the list.** Both
+ * the class time and the duration are optional on the offering form, and the
+ * schedule note exists precisely so a studio can write "Tuesdays 4:00pm" instead
+ * of pinning the class to a clock. So the schedule degrades rather than
+ * disappearing:
+ *
+ * - date **and** time set — one dated row per remaining session, closed off with
+ *   the duration when there is one and left open-ended when there is not;
+ * - no time to derive dates from — a single row for the class as a whole, sorted
+ *   by when the term starts and labelled with `schedule` text
+ *   ({@see Offering::scheduleLabel()}) in place of a time.
+ *
+ * A row's `schedule` is the tell: non-null means "this is a class, described in
+ * words, not a session at a known time", and every renderer shows that text
+ * instead of a date and time.
+ */
+class SessionSchedule {
+
+	/**
+	 * Marks a row as a group-class session rather than a one-to-one lesson.
+	 * Callers use it to withhold the per-lesson actions (cancel, detail links)
+	 * that only mean something for a booked slot.
+	 */
+	public const KIND = 'group_class';
+
+	public function __construct(
+		private EnrollmentRepository $enrollments,
+		private OfferingRepository $offerings,
+	) {}
+
+	/**
+	 * Upcoming sessions of every class a student is enrolled in, soonest first.
+	 *
+	 * A withdrawn (cancelled) enrolment contributes nothing; a completed one is
+	 * kept, since "completed" describes the enrolment's billing state and says
+	 * nothing about whether the class has met yet.
+	 *
+	 * @return list<array{enrollment_id: int, offering_id: int, offering_title: string, instructor_id: int, status: string, start_dt: string, end_dt: string, duration_minutes: int|null, schedule: string|null}>
+	 */
+	public function upcomingForStudent( int $studentId, string $now ): array {
+		$rows = [];
+
+		foreach ( $this->enrollments->findByStudent( $studentId ) as $enrollment ) {
+			if ( Enrollment::STATUS_CANCELLED === $enrollment->status ) {
+				continue;
+			}
+
+			$offering = $this->offerings->findById( $enrollment->offeringId );
+			if ( null === $offering ) {
+				continue;
+			}
+
+			$rows = array_merge(
+				$rows,
+				$this->rowsFor( $offering, $now, (int) $enrollment->id, $enrollment->instructorId, $enrollment->status )
+			);
+		}
+
+		return self::sortedByStart( $rows );
+	}
+
+	/**
+	 * Upcoming sessions of every active group class an instructor teaches,
+	 * soonest first — one row per session, not per enrolled student. Enrolments
+	 * are not consulted at all: a class the instructor has to turn up and teach
+	 * belongs on their schedule whether or not anyone has signed up yet.
+	 *
+	 * @return list<array{enrollment_id: int, offering_id: int, offering_title: string, instructor_id: int, status: string, start_dt: string, end_dt: string, duration_minutes: int|null, schedule: string|null}>
+	 */
+	public function upcomingForInstructor( int $instructorId, string $now ): array {
+		$rows = [];
+
+		$classes = $this->offerings->findAll( $instructorId, Offering::KIND_GROUP_CLASS, activeOnly: true );
+
+		foreach ( $classes as $offering ) {
+			$rows = array_merge( $rows, $this->rowsFor( $offering, $now, 0, $instructorId, Enrollment::STATUS_ACTIVE ) );
+		}
+
+		return self::sortedByStart( $rows );
+	}
+
+	/**
+	 * One class's contribution to an upcoming list: its remaining dated sessions,
+	 * or — when it has no time to derive dates from — a single row describing the
+	 * class in words. Empty only when the class has demonstrably finished.
+	 *
+	 * @return list<array{enrollment_id: int, offering_id: int, offering_title: string, instructor_id: int, status: string, start_dt: string, end_dt: string, duration_minutes: int|null, schedule: string|null}>
+	 */
+	private function rowsFor( Offering $offering, string $now, int $enrollmentId, int $instructorId, string $status ): array {
+		$base = [
+			'enrollment_id'    => $enrollmentId,
+			'offering_id'      => (int) $offering->id,
+			'offering_title'   => $offering->title,
+			'instructor_id'    => $instructorId,
+			'status'           => $status,
+			'duration_minutes' => $offering->durationMinutes,
+		];
+
+		$starts = $offering->sessionStarts();
+
+		// Dated: the class says exactly when it meets, so list what is left of it
+		// — and nothing at all once the term is over.
+		if ( [] !== $starts ) {
+			$rows = [];
+
+			foreach ( $starts as $start ) {
+				if ( $start < $now ) {
+					continue;
+				}
+
+				$rows[] = $base + [
+					'start_dt' => $start,
+					// Left open when no duration is set. Knowing a class starts at
+					// four o'clock is worth showing even without knowing when it
+					// ends; guessing an end time is not.
+					'end_dt'   => $this->endOf( $offering, $start ),
+					'schedule' => null,
+				];
+			}
+
+			return $rows;
+		}
+
+		// Undated: no class time, so there is nothing to put on a clock. The class
+		// still gets a row — it is enrolled in and running — described by the
+		// studio's own schedule note or its term dates.
+		if ( ! $this->isStillRunning( $offering, $now ) ) {
+			return [];
+		}
+
+		return [
+			$base + [
+				// A sort key, not a claim about when the class meets: a class yet to
+				// start sorts to its first day, one already under way to right now.
+				// `schedule` is what any renderer actually shows.
+				'start_dt' => $this->sortKeyFor( $offering, $now ),
+				'end_dt'   => '',
+				'schedule' => $offering->scheduleLabel(),
+			],
+		];
+	}
+
+	/**
+	 * When a session that starts at `$start` finishes, or an empty string when the
+	 * class has no duration to close it off with.
+	 */
+	private function endOf( Offering $offering, string $start ): string {
+		if ( null === $offering->durationMinutes || $offering->durationMinutes <= 0 ) {
+			return '';
+		}
+
+		return ( new \DateTimeImmutable( $start ) )
+			->add( new \DateInterval( 'PT' . $offering->durationMinutes . 'M' ) )
+			->format( 'Y-m-d H:i:s' );
+	}
+
+	/**
+	 * Whether an undated class still has life in it: its last day has not passed,
+	 * or it has no dates at all (in which case nothing says it has ended, and
+	 * dropping it would be the very disappearance this class exists to prevent).
+	 */
+	private function isStillRunning( Offering $offering, string $now ): bool {
+		$lastDay = $offering->lastClassDay();
+
+		return null === $lastDay || $lastDay >= substr( $now, 0, 10 );
+	}
+
+	/**
+	 * Where an undated class sits in a list ordered by time: at its first day when
+	 * that is still ahead, otherwise at `$now`, so a term already under way reads
+	 * as current rather than as ancient history.
+	 */
+	private function sortKeyFor( Offering $offering, string $now ): string {
+		if ( null === $offering->termStart ) {
+			return $now;
+		}
+
+		$firstDay = $offering->termStart . ' 00:00:00';
+
+		return $firstDay > $now ? $firstDay : $now;
+	}
+
+	/**
+	 * Soonest session first, so classes from separate enrolments interleave by
+	 * date rather than arriving grouped by class.
+	 *
+	 * @param  list<array{enrollment_id: int, offering_id: int, offering_title: string, instructor_id: int, status: string, start_dt: string, end_dt: string, duration_minutes: int|null, schedule: string|null}> $rows
+	 * @return list<array{enrollment_id: int, offering_id: int, offering_title: string, instructor_id: int, status: string, start_dt: string, end_dt: string, duration_minutes: int|null, schedule: string|null}>
+	 */
+	private static function sortedByStart( array $rows ): array {
+		usort( $rows, static fn( array $a, array $b ): int => strcmp( $a['start_dt'], $b['start_dt'] ) );
+
+		return $rows;
+	}
+}

src/Guardian/ChildLoginGate.php

@@ -0,0 +1,62 @@
+<?php
+declare(strict_types=1);
+
+namespace Unsupervised\Schedular\Guardian;
+
+use Unsupervised\Schedular\Auth\RoleManager;
+
+/**
+ * Keeps child accounts unusable as logins. A child holds the `us_student` role
+ * so every `student_id` lookup in the schema keeps working, but nobody is ever
+ * given its credentials — this closes the door the role would otherwise leave
+ * open:
+ *
+ * - authentication is refused outright, and
+ * - the booking capability is withheld, so nothing that reaches a capability
+ *   check on a child's own session (there should be none) can book as them.
+ *
+ * Both key off the `us_child` meta, so ordinary students are untouched.
+ */
+class ChildLoginGate {
+
+	public function register(): void {
+		add_filter( 'wp_authenticate_user', [ $this, 'blockChildLogin' ], 10, 1 );
+		add_filter( 'user_has_cap', [ $this, 'withholdBooking' ], 10, 4 );
+	}
+
+	/**
+	 * Refuse authentication for a child account. Runs after password
+	 * verification, so it holds even if a password were somehow set on one.
+	 *
+	 * @param \WP_User|\WP_Error $user Authenticating user, or an earlier error.
+	 * @return \WP_User|\WP_Error
+	 */
+	public function blockChildLogin( $user ) {
+		if ( $user instanceof \WP_User && GuardianService::isChild( (int) $user->ID ) ) {
+			return new \WP_Error(
+				'us_child_account',
+				esc_html__( 'This is a managed student account and cannot be signed in to. Please sign in with the parent or guardian account.', 'unsupervised-schedular' )
+			);
+		}
+
+		return $user;
+	}
+
+	/**
+	 * Strip the booking capability from a child account, so the only route to a
+	 * lesson in their name is their guardian's authorised booking.
+	 *
+	 * @param array<string, bool> $allcaps All capabilities currently held.
+	 * @param array<int, string>  $caps    Required capabilities (unused).
+	 * @param array<int, mixed>   $args    Callback args (unused).
+	 * @param mixed               $user    The user being checked (a WP_User in practice).
+	 * @return array<string, bool>
+	 */
+	public function withholdBooking( array $allcaps, array $caps, array $args, mixed $user ): array {
+		if ( $user instanceof \WP_User && GuardianService::isChild( (int) $user->ID ) ) {
+			unset( $allcaps[ RoleManager::CAP_BOOK_LESSON ] );
+		}
+
+		return $allcaps;
+	}
+}

src/Guardian/FamilyPage.php

@@ -0,0 +1,307 @@
+<?php
+declare(strict_types=1);
+
+namespace Unsupervised\Schedular\Guardian;
+
+use Unsupervised\Schedular\Registration\Answer;
+use Unsupervised\Schedular\Registration\AnswerRepository;
+use Unsupervised\Schedular\Registration\Question;
+use Unsupervised\Schedular\Registration\QuestionRepository;
+use Unsupervised\Schedular\Val;
+
+/**
+ * The guardian's "my family" screen (`[us_family]`): their own details, plus
+ * list, add, edit and remove the children they book for.
+ *
+ * Submissions are processed on `template_redirect` — before any output — and
+ * post/redirect/get back to the page, so a refresh cannot resubmit and add the
+ * same child twice.
+ */
+class FamilyPage {
+
+	/** Query flag carrying a completed action back to {@see render()}. */
+	private const RESULT_ADDED   = 'added';
+	private const RESULT_UPDATED = 'updated';
+	private const RESULT_REMOVED = 'removed';
+	private const RESULT_SELF    = 'self';
+
+	/**
+	 * Error from the most recent submission processed on `template_redirect`,
+	 * carried over to {@see render()} so it can be shown inline with the form.
+	 */
+	private string $submitError = '';
+
+	public function __construct(
+		private GuardianService $guardians,
+		private QuestionRepository $questions,
+		private AnswerRepository $answers,
+	) {}
+
+	/**
+	 * Renders the family shortcode/block output.
+	 *
+	 * @param array<int|string, mixed> $atts Block attributes (`loginPageId`) or
+	 *                                       shortcode attributes (`login_page_id`).
+	 */
+	public function render( array $atts ): string {
+		if ( ! is_user_logged_in() ) {
+			$loginPageId = Val::int( $atts['loginPageId'] ?? $atts['login_page_id'] ?? 0 );
+
+			return sprintf(
+				'<p>%s <a href="%s">%s</a>.</p>',
+				esc_html__( 'Please', 'unsupervised-schedular' ),
+				esc_url( $this->loginUrl( $loginPageId ) ),
+				esc_html__( 'log in to manage your profile', 'unsupervised-schedular' )
+			);
+		}
+
+		wp_enqueue_style( 'us-scheduler' );
+
+		$userId = get_current_user_id();
+
+		$self      = $this->guardians->accountHolder( $userId );
+		$children  = $this->guardians->children( $userId );
+		$questions = $this->questions->findByScope( Question::SCOPE_ACCOUNT, activeOnly: true );
+		$error     = $this->submitError;
+
+		// phpcs:ignore WordPress.Security.NonceVerification.Recommended -- read-only display flag; the submit that set it was nonce-checked.
+		$result = sanitize_key( Val::string( wp_unslash( $_GET['us_family'] ?? '' ) ) );
+		$notice = $this->noticeFor( $result );
+
+		// Which child the "edit" link opened, if any — the row is swapped for an
+		// editable form rather than every row carrying one.
+		// phpcs:ignore WordPress.Security.NonceVerification.Recommended -- read-only routing; the edit submit is nonce-checked.
+		$editingId = absint( Val::int( $_GET['us_edit_child'] ?? 0 ) );
+
+		ob_start();
+		include USC_PLUGIN_DIR . 'templates/frontend/family-page.php';
+		return (string) ob_get_clean();
+	}
+
+	/**
+	 * Process an add/edit/remove submission on `template_redirect`, before any
+	 * page output, then post/redirect/get back to the page. An error is stashed
+	 * for {@see render()} to show inline with the form.
+	 */
+	public function maybeHandleSubmit(): void {
+		// phpcs:ignore WordPress.Security.NonceVerification.Missing -- routing only; the action is nonce-checked immediately below.
+		$action = sanitize_key( Val::string( wp_unslash( $_POST['us_family_action'] ?? '' ) ) );
+
+		if ( '' === $action || ! is_user_logged_in() ) {
+			return;
+		}
+
+		if ( ! check_admin_referer( 'us_family' ) ) {
+			return;
+		}
+
+		$userId = get_current_user_id();
+
+		$result = match ( $action ) {
+			'add'    => $this->handleAdd( $userId ),
+			'edit'   => $this->handleEdit( $userId ),
+			'remove' => $this->handleRemove( $userId ),
+			'self'   => $this->handleSelf( $userId ),
+			default  => new \WP_Error( 'unknown_action', __( 'Unrecognised request.', 'unsupervised-schedular' ) ),
+		};
+
+		if ( $result instanceof \WP_Error ) {
+			$this->submitError = $result->get_error_message();
+			return;
+		}
+
+		$this->redirect( add_query_arg( 'us_family', $result, $this->currentUrl() ) );
+	}
+
+	/**
+	 * Add a child, then record their answers to the account-signup questions —
+	 * asked per child, since they describe the student rather than the account.
+	 *
+	 * Required answers are validated *before* the child is created, so a missing
+	 * one never leaves a nameless half-added child behind.
+	 */
+	private function handleAdd( int $guardianId ): string|\WP_Error {
+		$name         = $this->postString( 'child_name' );
+		$birthYear    = $this->postString( 'child_birth_year' );
+		$relationship = $this->postString( 'child_relationship' );
+
+		$questions = $this->questions->findByScope( Question::SCOPE_ACCOUNT, activeOnly: true );
+		$answers   = $this->submittedAnswers();
+
+		$missing = $this->firstMissingAnswer( $questions, $answers );
+		if ( null !== $missing ) {
+			return $missing;
+		}
+
+		$childId = $this->guardians->createChild( $guardianId, $name, $birthYear, $relationship );
+		if ( $childId instanceof \WP_Error ) {
+			return $childId;
+		}
+
+		$this->recordAnswers( $questions, $answers, $childId );
+
+		return self::RESULT_ADDED;
+	}
+
+	private function handleEdit( int $guardianId ): string|\WP_Error {
+		// phpcs:ignore WordPress.Security.NonceVerification.Missing -- nonce checked by the caller.
+		$childId = absint( Val::int( $_POST['child_id'] ?? 0 ) );
+
+		$error = $this->guardians->updateChild( $guardianId, $childId, $this->postString( 'child_name' ), $this->postString( 'child_birth_year' ) );
+
+		return $error ?? self::RESULT_UPDATED;
+	}
+
+	/**
+	 * Save the account holder's own details. The birth year is only asked of a
+	 * student, so it is the checkbox — not the browser — that decides whether one
+	 * is required; the field carries no `required` attribute, or a guardian who
+	 * books only for other people could never submit the form at all.
+	 */
+	private function handleSelf( int $userId ): string|\WP_Error {
+		// phpcs:ignore WordPress.Security.NonceVerification.Missing -- nonce checked by the caller.
+		$isStudent = isset( $_POST['is_student'] );
+
+		$error = $this->guardians->updateSelf( $userId, $this->postString( 'own_name' ), $this->postString( 'own_birth_year' ), $isStudent );
+
+		return $error ?? self::RESULT_SELF;
+	}
+
+	private function handleRemove( int $guardianId ): string|\WP_Error {
+		// phpcs:ignore WordPress.Security.NonceVerification.Missing -- nonce checked by the caller.
+		$childId = absint( Val::int( $_POST['child_id'] ?? 0 ) );
+
+		$error = $this->guardians->removeChild( $guardianId, $childId );
+
+		return $error ?? self::RESULT_REMOVED;
+	}
+
+	/**
+	 * The first required question left unanswered, as the error to show — or null
+	 * when every required question has a value.
+	 *
+	 * This screen only ever adds a student the guardian registers, so the
+	 * students' required-ness is the one that applies — the same rule the child
+	 * blocks on the signup form are held to.
+	 *
+	 * @param list<Question>     $questions
+	 * @param array<int, string> $answers   question_id => submitted value
+	 */
+	private function firstMissingAnswer( array $questions, array $answers ): ?\WP_Error {
+		foreach ( $questions as $question ) {
+			if ( $question->isRequiredForChild() && '' === trim( (string) ( $answers[ (int) $question->id ] ?? '' ) ) ) {
+				return new \WP_Error( 'missing_answer', __( 'Please answer all required questions for this student.', 'unsupervised-schedular' ) );
+			}
+		}
+
+		return null;
+	}
+
+	/**
+	 * Persist a child's answers to the account-signup questions. The answer is
+	 * recorded against the child, not the guardian, so a studio admin reading a
+	 * child's screen sees the information that describes them.
+	 *
+	 * @param list<Question>     $questions
+	 * @param array<int, string> $answers   question_id => submitted value
+	 */
+	private function recordAnswers( array $questions, array $answers, int $childId ): void {
+		foreach ( $questions as $question ) {
+			$value = trim( (string) ( $answers[ (int) $question->id ] ?? '' ) );
+			if ( '' === $value ) {
+				continue;
+			}
+
+			$this->answers->insert(
+				new Answer(
+					questionId:       (int) $question->id,
+					registrationType: Answer::REG_ACCOUNT,
+					registrationId:   $childId,
+					studentId:        $childId,
+					answerValue:      $value,
+				)
+			);
+		}
+	}
+
+	/**
+	 * The account-question answers submitted with the form, keyed by question id.
+	 *
+	 * @return array<int, string>
+	 */
+	private function submittedAnswers(): array {
+		// phpcs:ignore WordPress.Security.NonceVerification.Missing, WordPress.Security.ValidatedSanitizedInput.InputNotSanitized, WordPress.Security.ValidatedSanitizedInput.MissingUnslash -- nonce checked by the caller; each value is unslashed and sanitized in the loop below.
+		$raw = $_POST['us_answers'] ?? [];
+		if ( ! is_array( $raw ) ) {
+			return [];
+		}
+
+		$out = [];
+		foreach ( $raw as $questionId => $value ) {
+			$out[ absint( Val::int( $questionId ) ) ] = sanitize_textarea_field( Val::string( wp_unslash( $value ) ) );
+		}
+
+		return $out;
+	}
+
+	/**
+	 * A sanitized text field from the submission. The caller has already verified
+	 * the nonce.
+	 */
+	private function postString( string $key ): string {
+		// phpcs:ignore WordPress.Security.NonceVerification.Missing -- nonce checked by the caller.
+		return sanitize_text_field( Val::string( wp_unslash( $_POST[ $key ] ?? '' ) ) );
+	}
+
+	/**
+	 * The confirmation to show for a completed action, or an empty string when
+	 * the flag is absent or unrecognised.
+	 */
+	private function noticeFor( string $result ): string {
+		return match ( $result ) {
+			self::RESULT_ADDED   => __( 'Student added.', 'unsupervised-schedular' ),
+			self::RESULT_UPDATED => __( 'Details updated.', 'unsupervised-schedular' ),
+			self::RESULT_REMOVED => __( 'Student removed.', 'unsupervised-schedular' ),
+			self::RESULT_SELF    => __( 'Your details have been updated.', 'unsupervised-schedular' ),
+			default              => '',
+		};
+	}
+
+	/**
+	 * The current page's clean permalink, used as the post/redirect/get target so
+	 * the edit flag and any stale notice are dropped from the URL.
+	 */
+	private function currentUrl(): string {
+		$url = get_permalink();
+
+		return is_string( $url ) ? $url : home_url( '/' );
+	}
+
+	/**
+	 * Issues the post-submit redirect and stops the request. Split out so tests
+	 * can observe the target without the process exiting.
+	 */
+	protected function redirect( string $url ): void {
+		wp_safe_redirect( $url );
+		exit;
+	}
+
+	/**
+	 * URL the logged-out prompt sends visitors to: the chosen login page when one
+	 * is configured (and still exists), otherwise the WordPress login screen with
+	 * a redirect back to the current page.
+	 */
+	public function loginUrl( int $loginPageId ): string {
+		if ( $loginPageId > 0 ) {
+			$url = get_permalink( $loginPageId );
+
+			if ( is_string( $url ) ) {
+				return $url;
+			}
+		}
+
+		$permalink = get_permalink();
+
+		return wp_login_url( false === $permalink ? '' : $permalink );
+	}
+}

src/Guardian/GuardianLink.php

@@ -0,0 +1,47 @@
+<?php
+declare(strict_types=1);
+
+namespace Unsupervised\Schedular\Guardian;
+
+use Unsupervised\Schedular\Val;
+
+/**
+ * One parent/guardian ↔ child link. The child is a real (login-less) WordPress
+ * user, so `studentId` is a `wp_users` ID exactly like every other student id in
+ * the schema — this row only records who books and pays on their behalf.
+ */
+class GuardianLink {
+
+	public function __construct(
+		public readonly int $guardianId,
+		public readonly int $studentId,
+		public readonly string $relationship = '',
+		public readonly ?string $createdAt = null,
+		public readonly ?int $id = null,
+	) {}
+
+	public static function fromRow( \stdClass $row ): self {
+		return new self(
+			guardianId:   Val::int( $row->guardian_id ),
+			studentId:    Val::int( $row->student_id ),
+			relationship: Val::string( $row->relationship ?? '' ),
+			createdAt:    Val::stringOrNull( $row->created_at ?? null ),
+			id:           Val::int( $row->id ),
+		);
+	}
+
+	/**
+	 * Returns a plain array representation of the link.
+	 *
+	 * @return array<string, mixed>
+	 */
+	public function toArray(): array {
+		return [
+			'id'           => $this->id,
+			'guardian_id'  => $this->guardianId,
+			'student_id'   => $this->studentId,
+			'relationship' => $this->relationship,
+			'created_at'   => $this->createdAt,
+		];
+	}
+}

src/Guardian/GuardianRepository.php

@@ -0,0 +1,122 @@
+<?php
+declare(strict_types=1);
+
+namespace Unsupervised\Schedular\Guardian;
+
+class GuardianRepository {
+
+	private string $table;
+
+	public function __construct( private \wpdb $db ) {
+		$this->table = $db->prefix . 'us_guardians';
+	}
+
+	/**
+	 * Link a child to a guardian. Returns 0 without inserting when the child
+	 * already has a guardian: v1 is one guardian per child, and the check lives
+	 * here so every caller (signup, the family screen, admin) gets it.
+	 */
+	public function insert( GuardianLink $link ): int {
+		if ( null !== $this->findByStudent( $link->studentId ) ) {
+			return 0;
+		}
+
+		$this->db->insert(
+			$this->table,
+			[
+				'guardian_id'  => $link->guardianId,
+				'student_id'   => $link->studentId,
+				'relationship' => $link->relationship,
+				'created_at'   => current_time( 'mysql' ),
+			],
+			[ '%d', '%d', '%s', '%s' ]
+		);
+
+		return $this->db->insert_id;
+	}
+
+	/**
+	 * The link naming this child's guardian, or null when they book for
+	 * themselves.
+	 */
+	public function findByStudent( int $studentId ): ?GuardianLink {
+		$row = $this->db->get_row(
+			$this->db->prepare(
+				'SELECT * FROM %i WHERE student_id = %d LIMIT 1',
+				$this->table,
+				$studentId
+			)
+		);
+
+		return $row ? GuardianLink::fromRow( $row ) : null;
+	}
+
+	/**
+	 * Every child linked to a guardian, oldest link first — the order they are
+	 * offered in the booking selector, so it stays stable as children are added.
+	 *
+	 * @return list<GuardianLink>
+	 */
+	public function findByGuardian( int $guardianId ): array {
+		$rows = $this->db->get_results(
+			$this->db->prepare(
+				'SELECT * FROM %i WHERE guardian_id = %d ORDER BY created_at ASC, id ASC',
+				$this->table,
+				$guardianId
+			)
+		);
+
+		return array_map( GuardianLink::fromRow( ... ), $rows ?? [] );
+	}
+
+	/**
+	 * Whether this exact guardian↔child pair is linked — the authorisation check
+	 * behind every "act for this student" boundary.
+	 */
+	public function isGuardianOf( int $guardianId, int $studentId ): bool {
+		$found = $this->db->get_var(
+			$this->db->prepare(
+				'SELECT id FROM %i WHERE guardian_id = %d AND student_id = %d LIMIT 1',
+				$this->table,
+				$guardianId,
+				$studentId
+			)
+		);
+
+		return null !== $found;
+	}
+
+	/**
+	 * Remove the link between a guardian and one of their children. Deleting the
+	 * child user itself is the caller's decision ({@see GuardianService::removeChild()});
+	 * this only unlinks.
+	 */
+	public function delete( int $guardianId, int $studentId ): bool {
+		$deleted = $this->db->delete(
+			$this->table,
+			[
+				'guardian_id' => $guardianId,
+				'student_id'  => $studentId,
+			],
+			[ '%d', '%d' ]
+		);
+
+		return (int) $deleted > 0;
+	}
+
+	/**
+	 * How many children a guardian has — enough to decide whether the booking
+	 * page needs a "who is this for?" selector at all.
+	 */
+	public function countChildren( int $guardianId ): int {
+		$count = $this->db->get_var(
+			$this->db->prepare(
+				'SELECT COUNT(*) FROM %i WHERE guardian_id = %d',
+				$this->table,
+				$guardianId
+			)
+		);
+
+		return (int) $count;
+	}
+}

src/Guardian/GuardianService.php

@@ -0,0 +1,565 @@
+<?php
+declare(strict_types=1);
+
+namespace Unsupervised\Schedular\Guardian;
+
+use Unsupervised\Schedular\Auth\RoleManager;
+use Unsupervised\Schedular\Auth\UserName;
+use Unsupervised\Schedular\Booking\BookingRepository;
+use Unsupervised\Schedular\GroupClass\EnrollmentRepository;
+use Unsupervised\Schedular\Val;
+
+/**
+ * Everything a guardian does on a child's behalf: creating the child's
+ * login-less account, deciding who may act for whom, and resolving the payer and
+ * contact behind a student id.
+ */
+class GuardianService {
+
+	/**
+	 * Marks a `wp_users` row as a child account: created by a guardian, holding
+	 * the student role so every `student_id` lookup keeps working, but with no
+	 * usable login. {@see ChildLoginGate} enforces the "no login" half.
+	 */
+	public const META_CHILD = 'us_child';
+
+	/** A child's birth year (`YYYY`), collected at signup and editable after. */
+	public const META_BIRTH_YEAR = 'us_birth_year';
+
+	/**
+	 * The full date of birth this feature used to collect. Nothing writes it any
+	 * more: it is read once, to derive a birth year for a child who predates the
+	 * change, and cleared the moment that child's record is next saved. Kept
+	 * public so a site that wants to purge the old dates outright can find them.
+	 */
+	public const META_DOB = 'us_date_of_birth';
+
+	/**
+	 * Set on an account that registered **only** to book for other people, so it
+	 * is not offered as a student in its own right.
+	 *
+	 * Stored as the negative on purpose. Every account that existed before this
+	 * choice was offered is a bookable student, and absence of the flag has to
+	 * keep meaning exactly that — otherwise the picker would quietly stop
+	 * offering people themselves on upgrade.
+	 */
+	public const META_GUARDIAN_ONLY = 'us_guardian_only';
+
+	/**
+	 * The earliest birth year the form will accept. Old enough for any student a
+	 * studio will ever enrol, and late enough to reject a typo like `19` or `190`
+	 * that would otherwise be stored as a plausible-looking year.
+	 */
+	private const MIN_BIRTH_YEAR = 1900;
+
+	/**
+	 * Domain used for a child's placeholder login address. `.invalid` is reserved
+	 * by RFC 2606 and can never resolve, so a child's address is guaranteed
+	 * undeliverable — nothing about a child's account can ever be emailed to
+	 * somewhere real by mistake.
+	 */
+	private const CHILD_EMAIL_DOMAIN = 'child.invalid';
+
+	public function __construct(
+		private GuardianRepository $guardians,
+		private BookingRepository $bookings,
+		private EnrollmentRepository $enrollments,
+	) {}
+
+	/**
+	 * Create a login-less child account and link it to its guardian. The password
+	 * is random and discarded — it is never stored anywhere readable, emailed, or
+	 * shown — so the account cannot be signed into even if the gate were removed.
+	 *
+	 * Returns the new user ID, or a `WP_Error` when the name is blank, the birth
+	 * year is missing or unusable, or WordPress refuses the insert.
+	 */
+	public function createChild( int $guardianId, string $name, string $birthYear = '', string $relationship = '' ): int|\WP_Error {
+		$name = trim( $name );
+		if ( '' === $name ) {
+			return new \WP_Error( 'missing_name', __( 'Please give each student a name.', 'unsupervised-schedular' ) );
+		}
+
+		if ( 0 === self::normaliseBirthYear( $birthYear ) ) {
+			return new \WP_Error( 'missing_birth_year', self::birthYearError() );
+		}
+
+		$email  = $this->childEmail();
+		$userId = wp_insert_user(
+			[
+				'user_login'   => $email,
+				'user_email'   => $email,
+				'user_pass'    => wp_generate_password( 24, true, true ),
+				'display_name' => $name,
+				'nickname'     => $name,
+				'role'         => RoleManager::STUDENT,
+			]
+		);
+
+		if ( is_wp_error( $userId ) ) {
+			return $userId;
+		}
+
+		$userId = (int) $userId;
+
+		update_user_meta( $userId, self::META_CHILD, '1' );
+		$this->setBirthYear( $userId, $birthYear );
+
+		$linkId = $this->guardians->insert(
+			new GuardianLink(
+				guardianId:   $guardianId,
+				studentId:    $userId,
+				relationship: trim( $relationship ),
+			)
+		);
+
+		// The child was just created, so it cannot already be linked — a failure
+		// here means the insert itself failed, and leaving an unreachable orphan
+		// user behind would be worse than reporting it.
+		if ( $linkId <= 0 ) {
+			$this->deleteUser( $userId );
+
+			return new \WP_Error( 'link_failed', __( 'Could not add this student. Please contact the studio.', 'unsupervised-schedular' ) );
+		}
+
+		return $userId;
+	}
+
+	/**
+	 * Rename a child and update their birth year. Refuses a student the caller
+	 * is not the guardian of, so the family screen cannot be turned into an
+	 * arbitrary user editor by posting someone else's id.
+	 *
+	 * Returns null on success, mirroring {@see \Unsupervised\Schedular\Registration\RegistrationGate::validate()}.
+	 */
+	public function updateChild( int $guardianId, int $studentId, string $name, string $birthYear = '' ): ?\WP_Error {
+		if ( ! $this->guardians->isGuardianOf( $guardianId, $studentId ) ) {
+			return new \WP_Error( 'forbidden', __( 'That is not one of your students.', 'unsupervised-schedular' ) );
+		}
+
+		$name = trim( $name );
+		if ( '' === $name ) {
+			return new \WP_Error( 'missing_name', __( 'Please give each student a name.', 'unsupervised-schedular' ) );
+		}
+
+		if ( 0 === self::normaliseBirthYear( $birthYear ) ) {
+			return new \WP_Error( 'missing_birth_year', self::birthYearError() );
+		}
+
+		$result = wp_update_user(
+			[
+				'ID'           => $studentId,
+				'display_name' => $name,
+				'nickname'     => $name,
+			]
+		);
+
+		if ( is_wp_error( $result ) ) {
+			return $result;
+		}
+
+		$this->setBirthYear( $studentId, $birthYear );
+
+		return null;
+	}
+
+	/**
+	 * Update the account holder's own details from the profile screen: their
+	 * name, whether they are a student in their own right, and — when they are —
+	 * their birth year.
+	 *
+	 * `$isStudent` is the positive of what {@see META_GUARDIAN_ONLY} stores, so
+	 * the form can ask the question the way a person would answer it and this is
+	 * the single place the sense is flipped.
+	 *
+	 * Returns null on success, mirroring {@see updateChild()}.
+	 */
+	public function updateSelf( int $userId, string $name, string $birthYear, bool $isStudent ): ?\WP_Error {
+		$name = trim( $name );
+		if ( '' === $name ) {
+			return new \WP_Error( 'missing_name', __( 'Please give your name.', 'unsupervised-schedular' ) );
+		}
+
+		if ( $isStudent && 0 === self::normaliseBirthYear( $birthYear ) ) {
+			return new \WP_Error( 'missing_birth_year', self::ownBirthYearError() );
+		}
+
+		$result = wp_update_user(
+			[
+				'ID'           => $userId,
+				'display_name' => $name,
+				'nickname'     => $name,
+			]
+		);
+
+		if ( is_wp_error( $result ) ) {
+			return $result;
+		}
+
+		$this->setGuardianOnly( $userId, ! $isStudent );
+
+		// Only written when they are a student. Saying "I only book for other
+		// people" is a statement about who books, not an instruction to forget a
+		// year already on file — and someone who ticks the box back on the next
+		// visit should find their own details as they left them.
+		if ( $isStudent ) {
+			$this->setBirthYear( $userId, $birthYear );
+		}
+
+		return null;
+	}
+
+	/**
+	 * Unlink a child and delete their account. Refused once the child has any
+	 * lesson or enrolment history: their id is referenced by lessons, payments and
+	 * credits, and deleting the user would orphan all of it. A studio admin
+	 * handles those cases by hand.
+	 *
+	 * Returns null on success.
+	 */
+	public function removeChild( int $guardianId, int $studentId ): ?\WP_Error {
+		if ( ! $this->guardians->isGuardianOf( $guardianId, $studentId ) ) {
+			return new \WP_Error( 'forbidden', __( 'That is not one of your students.', 'unsupervised-schedular' ) );
+		}
+
+		if ( [] !== $this->bookings->findByStudent( $studentId ) || [] !== $this->enrollments->findByStudent( $studentId ) ) {
+			return new \WP_Error(
+				'has_history',
+				__( 'This student has lessons or enrolments on record and cannot be removed here. Please contact the studio.', 'unsupervised-schedular' )
+			);
+		}
+
+		$this->guardians->delete( $guardianId, $studentId );
+		$this->deleteUser( $studentId );
+
+		return null;
+	}
+
+	/**
+	 * Whether `$actorId` may book, cancel and pay as `$studentId` — true for
+	 * themselves, and for a guardian acting as one of their own children. This is
+	 * the authorisation boundary the REST endpoints and form handlers check before
+	 * honouring a submitted student id.
+	 */
+	public function canActFor( int $actorId, int $studentId ): bool {
+		if ( $actorId <= 0 || $studentId <= 0 ) {
+			return false;
+		}
+
+		return $actorId === $studentId || $this->guardians->isGuardianOf( $actorId, $studentId );
+	}
+
+	/**
+	 * Who owes a student's charges: their guardian when they have one, otherwise
+	 * themselves. Payments, credits and the billing-method override all resolve
+	 * through this, so a family shares one balance and one billing setting.
+	 */
+	public function payerFor( int $studentId ): int {
+		$link = $this->guardians->findByStudent( $studentId );
+
+		return null !== $link ? $link->guardianId : $studentId;
+	}
+
+	/**
+	 * The student ids whose lessons `$userId` may see: their own plus every child
+	 * they are guardian for.
+	 *
+	 * @return list<int>
+	 */
+	public function householdIds( int $userId ): array {
+		$ids = [ $userId ];
+
+		foreach ( $this->guardians->findByGuardian( $userId ) as $link ) {
+			$ids[] = $link->studentId;
+		}
+
+		return array_values( array_unique( $ids ) );
+	}
+
+	/**
+	 * The people a user may book or enrol for: **children first**, then
+	 * themselves. The order is the point — a guardian's normal case is booking for
+	 * a child, so the first option (and hence the default selection) is a child,
+	 * never the parent. Booking for a child by mistake is a correctable
+	 * inconvenience; silently billing a parent's account for a lesson meant for
+	 * their kid is the error worth designing out.
+	 *
+	 * The guardian is still offered, last, so a parent taking lessons alongside
+	 * their children can book for themselves from the same account — unless they
+	 * said at signup that they are not a student, in which case offering them is
+	 * an invitation to book a lesson nobody meant to buy.
+	 *
+	 * @return list<array{id: int, name: string, is_self: bool}>
+	 */
+	public function bookableStudents( int $userId ): array {
+		$out = [];
+
+		foreach ( $this->children( $userId ) as $child ) {
+			$out[] = [
+				'id'      => $child['id'],
+				'name'    => $child['name'],
+				'is_self' => false,
+			];
+		}
+
+		// A guardian-only account with nobody linked to it would otherwise get an
+		// empty list and no way to book at all. Offering them themselves is the
+		// lesser wrong: they can still correct the account from the profile page.
+		if ( self::isGuardianOnly( $userId ) && [] !== $out ) {
+			return $out;
+		}
+
+		$self = get_userdata( $userId );
+
+		$out[] = [
+			'id'      => $userId,
+			'name'    => UserName::format( $self instanceof \WP_User ? $self : null, $userId ),
+			'is_self' => true,
+		];
+
+		return $out;
+	}
+
+	/**
+	 * Whether this account books only for other people. False for every account
+	 * that predates the choice — see {@see META_GUARDIAN_ONLY}.
+	 */
+	public static function isGuardianOnly( int $userId ): bool {
+		return '1' === Val::string( get_user_meta( $userId, self::META_GUARDIAN_ONLY, true ) );
+	}
+
+	/**
+	 * Record whether this account is a student in its own right. Clears the flag
+	 * rather than storing a `0`, so "not set" stays the single meaning of "yes,
+	 * they are a student".
+	 */
+	public function setGuardianOnly( int $userId, bool $guardianOnly ): void {
+		if ( $guardianOnly ) {
+			update_user_meta( $userId, self::META_GUARDIAN_ONLY, '1' );
+			return;
+		}
+
+		delete_user_meta( $userId, self::META_GUARDIAN_ONLY );
+	}
+
+	/**
+	 * A guardian's children, in link order, with the details the family and admin
+	 * screens display.
+	 *
+	 * @return list<array{id: int, name: string, birth_year: string, relationship: string}>
+	 */
+	public function children( int $guardianId ): array {
+		$out = [];
+
+		foreach ( $this->guardians->findByGuardian( $guardianId ) as $link ) {
+			$user = get_userdata( $link->studentId );
+
+			$out[] = [
+				'id'           => $link->studentId,
+				'name'         => UserName::format( $user instanceof \WP_User ? $user : null, $link->studentId ),
+				'birth_year'   => $this->birthYear( $link->studentId ),
+				'relationship' => $link->relationship,
+			];
+		}
+
+		return $out;
+	}
+
+	/**
+	 * The account holder's own details, as the profile screen's form needs them.
+	 * The counterpart to {@see children()} for the person reading the page.
+	 *
+	 * `is_student` is the positive of {@see META_GUARDIAN_ONLY} — see
+	 * {@see updateSelf()}, which reads it back the same way round.
+	 *
+	 * @return array{name: string, email: string, birth_year: string, is_student: bool}
+	 */
+	public function accountHolder( int $userId ): array {
+		$user = get_userdata( $userId );
+
+		return [
+			'name'       => UserName::format( $user instanceof \WP_User ? $user : null, $userId ),
+			'email'      => $user instanceof \WP_User ? $user->user_email : '',
+			'birth_year' => $this->birthYear( $userId ),
+			'is_student' => ! self::isGuardianOnly( $userId ),
+		];
+	}
+
+	/**
+	 * The guardian behind a child, or null when the student books for themselves.
+	 *
+	 * @return array{id: int, name: string, email: string}|null
+	 */
+	public function guardianOf( int $studentId ): ?array {
+		$link = $this->guardians->findByStudent( $studentId );
+		if ( null === $link ) {
+			return null;
+		}
+
+		$user = get_userdata( $link->guardianId );
+
+		return [
+			'id'    => $link->guardianId,
+			'name'  => UserName::format( $user instanceof \WP_User ? $user : null, $link->guardianId ),
+			'email' => $user instanceof \WP_User ? $user->user_email : '',
+		];
+	}
+
+	/**
+	 * Who to contact about a student: their guardian when they have one, otherwise
+	 * the student. What an instructor looking at a child's lesson actually needs —
+	 * a child's own address is an undeliverable placeholder.
+	 *
+	 * @return array{id: int, name: string, email: string}
+	 */
+	public function contactFor( int $studentId ): array {
+		$guardian = $this->guardianOf( $studentId );
+		if ( null !== $guardian ) {
+			return $guardian;
+		}
+
+		$user = get_userdata( $studentId );
+
+		return [
+			'id'    => $studentId,
+			'name'  => UserName::format( $user instanceof \WP_User ? $user : null, $studentId ),
+			'email' => $user instanceof \WP_User ? $user->user_email : '',
+		];
+	}
+
+	/**
+	 * A student's display name, or an empty string when the user is gone. Used
+	 * wherever a charge or lesson has to say whose it is.
+	 */
+	public function studentName( int $studentId ): string {
+		$user = get_userdata( $studentId );
+
+		return UserName::format( $user instanceof \WP_User ? $user : null );
+	}
+
+	/**
+	 * Whether a user is a child account (created by a guardian, cannot sign in).
+	 */
+	public static function isChild( int $userId ): bool {
+		return '1' === Val::string( get_user_meta( $userId, self::META_CHILD, true ) );
+	}
+
+	/**
+	 * Delete a child's user account. Split out so the front-end paths pull in the
+	 * admin user functions `wp_delete_user()` lives in — it is not loaded on the
+	 * front end, where the family screen runs.
+	 */
+	public function deleteUser( int $userId ): void {
+		if ( ! function_exists( 'wp_delete_user' ) ) {
+			require_once ABSPATH . 'wp-admin/includes/user.php';
+		}
+
+		wp_delete_user( $userId );
+	}
+
+	/**
+	 * Store a student's birth year, or clear it when blank or out of range. Used
+	 * for a child added by their guardian and for an account holder who is a
+	 * student in their own right — the same fact about the same kind of person,
+	 * so the same meta key holds both.
+	 *
+	 * Either way the legacy full date of birth goes with it. That is what makes
+	 * the read fallback in {@see birthYear()} safe: without it, clearing the year
+	 * on a child who predates this change would leave the old date behind for the
+	 * fallback to resurrect on the very next read.
+	 */
+	public function setBirthYear( int $userId, string $birthYear ): void {
+		delete_user_meta( $userId, self::META_DOB );
+
+		$year = self::normaliseBirthYear( $birthYear );
+
+		if ( 0 === $year ) {
+			delete_user_meta( $userId, self::META_BIRTH_YEAR );
+			return;
+		}
+
+		update_user_meta( $userId, self::META_BIRTH_YEAR, (string) $year );
+	}
+
+	/**
+	 * A submitted birth year as an integer, or 0 when it is blank, not a number,
+	 * or outside {@see MIN_BIRTH_YEAR}..this year. A year in the future is a typo
+	 * every time, so it is refused rather than stored.
+	 *
+	 * Public and static so the signup form can reject a bad year up front, before
+	 * it creates any users, without a second copy of the rule to keep in step.
+	 */
+	public static function normaliseBirthYear( string $birthYear ): int {
+		$birthYear = trim( $birthYear );
+
+		if ( '' === $birthYear || 1 !== preg_match( '/^\d{4}$/', $birthYear ) ) {
+			return 0;
+		}
+
+		$year = (int) $birthYear;
+
+		if ( $year < self::MIN_BIRTH_YEAR || $year > (int) current_time( 'Y' ) ) {
+			return 0;
+		}
+
+		return $year;
+	}
+
+	/**
+	 * The message shown when a birth year is missing or unusable. One phrasing,
+	 * shared by the signup form and the profile screen, so a guardian is told the
+	 * same thing whichever way they got there.
+	 */
+	public static function birthYearError(): string {
+		return sprintf(
+			/* translators: %d: the earliest birth year the form accepts. */
+			__( 'Please give each student a birth year, as four digits from %d onwards.', 'unsupervised-schedular' ),
+			self::MIN_BIRTH_YEAR
+		);
+	}
+
+	/**
+	 * The same message for the account holder's own birth year. Separate wording
+	 * because "each student" is nobody when the student in question is the person
+	 * reading it.
+	 */
+	public static function ownBirthYearError(): string {
+		return sprintf(
+			/* translators: %d: the earliest birth year the form accepts. */
+			__( 'Please give your birth year, as four digits from %d onwards.', 'unsupervised-schedular' ),
+			self::MIN_BIRTH_YEAR
+		);
+	}
+
+	/**
+	 * A child's birth year, or an empty string when none is recorded.
+	 *
+	 * Falls back to the year of the full date of birth this feature used to
+	 * collect, so a child added before the change still shows one. The fallback
+	 * is read-only and one-way: {@see setBirthYear()} drops the old date as soon
+	 * as the record is saved again.
+	 */
+	private function birthYear( int $userId ): string {
+		$year = Val::string( get_user_meta( $userId, self::META_BIRTH_YEAR, true ) );
+		if ( '' !== $year ) {
+			return $year;
+		}
+
+		$legacy = Val::string( get_user_meta( $userId, self::META_DOB, true ) );
+
+		return 1 === preg_match( '/^(\d{4})-/', $legacy, $m ) ? $m[1] : '';
+	}
+
+	/**
+	 * An unused placeholder address for a child's account. WordPress requires a
+	 * unique email per user, so the random suffix is retried against
+	 * `email_exists()` rather than assumed unique.
+	 */
+	private function childEmail(): string {
+		do {
+			$email = 'us-child-' . wp_generate_password( 12, false, false ) . '@' . self::CHILD_EMAIL_DOMAIN;
+		} while ( false !== email_exists( $email ) );
+
+		return strtolower( $email );
+	}
+}

src/Installer.php

@@ -5,7 +5,10 @@ namespace Unsupervised\Schedular;
 
 use Unsupervised\Schedular\Auth\RoleManager;
 use Unsupervised\Schedular\Availability\AvailabilityRepository;
+use Unsupervised\Schedular\Payment\CreditRepository;
+use Unsupervised\Schedular\Payment\PaymentRepository;
 use Unsupervised\Schedular\Payment\ScheduledBillingRunner;
+use Unsupervised\Schedular\Policy\AcceptanceRepository;
 
 class Installer {
 
@@ -50,5 +53,13 @@ class Installer {
 		}
 
 		( new AvailabilityRepository( $wpdb ) )->splitOversizedWindows();
+
+		// Guardian accounts introduced "who pays" / "who agreed" alongside "who the
+		// student is". Every row written before then had them one and the same, so
+		// point the new columns at the student rather than leaving them 0 — the
+		// balance and acceptance lookups key on them directly.
+		( new PaymentRepository( $wpdb ) )->backfillPayerIds();
+		( new CreditRepository( $wpdb ) )->backfillPayerIds();
+		( new AcceptanceRepository( $wpdb ) )->backfillAcceptedBy();
 	}
 }

src/Offering/Offering.php

@@ -175,22 +175,19 @@ class Offering {
 	}
 
 	/**
-	 * The concrete start/end datetimes of every session of this group class,
-	 * derived from the class date(s), the class time, and the duration. A weekly
-	 * class yields one window per week from `term_start` through `term_end`; a
-	 * one-off class yields a single window. Returns an empty list unless the
-	 * schedule is fully specified (date, time, and a positive duration), so it can
-	 * never fabricate a session window from partial data.
+	 * The datetime each session of this group class starts, derived from the class
+	 * date(s) and the class time. A weekly class yields one per week from
+	 * `term_start` through `term_end`; a one-off class yields a single one.
 	 *
-	 * @return list<array{start: string, end: string}>
+	 * Deliberately does **not** need a duration: knowing *when* a class meets is a
+	 * separate question from knowing how long it runs, and a studio can quite
+	 * reasonably set the first without the second. Returns an empty list when
+	 * there is no date or no time, since neither can be invented.
+	 *
+	 * @return list<string> `Y-m-d H:i:s` starts, earliest first.
 	 */
-	public function sessionWindows(): array {
-		if (
-			null === $this->termStart
-			|| null === $this->classTime
-			|| null === $this->durationMinutes
-			|| $this->durationMinutes <= 0
-		) {
+	public function sessionStarts(): array {
+		if ( null === $this->termStart || null === $this->classTime ) {
 			return [];
 		}
 
@@ -200,25 +197,85 @@ class Offering {
 		}
 
 		$lastDay = null !== $this->termEnd ? $this->termEnd : $this->termStart;
-		$step    = new \DateInterval( 'PT' . $this->durationMinutes . 'M' );
 
-		$windows   = [];
+		$starts    = [];
 		$cursor    = $first;
 		$cursorDay = $cursor->format( 'Y-m-d' );
 
 		// Cap the walk at ten years of weeks so a term_end before term_start (or a
 		// bad value) can never spin into an unbounded loop.
 		for ( $i = 0; $i < 520 && $cursorDay <= $lastDay; $i++ ) {
-			$windows[] = [
-				'start' => $cursor->format( 'Y-m-d H:i:s' ),
-				'end'   => $cursor->add( $step )->format( 'Y-m-d H:i:s' ),
-			];
+			$starts[] = $cursor->format( 'Y-m-d H:i:s' );
 
 			$cursor    = $cursor->modify( '+7 days' );
 			$cursorDay = $cursor->format( 'Y-m-d' );
 		}
 
-		return $windows;
+		return $starts;
+	}
+
+	/**
+	 * The concrete start/end datetimes of every session of this group class:
+	 * {@see sessionStarts()} closed off with the class duration. Returns an empty
+	 * list unless the schedule is fully specified (date, time, *and* a positive
+	 * duration), so it can never fabricate a session window from partial data —
+	 * callers that block availability or bill per session need both ends.
+	 *
+	 * @return list<array{start: string, end: string}>
+	 */
+	public function sessionWindows(): array {
+		if ( null === $this->durationMinutes || $this->durationMinutes <= 0 ) {
+			return [];
+		}
+
+		$step = new \DateInterval( 'PT' . $this->durationMinutes . 'M' );
+
+		return array_map(
+			static fn( string $start ): array => [
+				'start' => $start,
+				'end'   => ( new \DateTimeImmutable( $start ) )->add( $step )->format( 'Y-m-d H:i:s' ),
+			],
+			$this->sessionStarts()
+		);
+	}
+
+	/**
+	 * The last day this class meets, or null when it has no dates at all.
+	 */
+	public function lastClassDay(): ?string {
+		return $this->termEnd ?? $this->termStart;
+	}
+
+	/**
+	 * Plain-language wording for when this class meets, for the places that have
+	 * to say something about a class whose schedule cannot be resolved to dates.
+	 * Prefers the studio's own note ("Tuesdays 4:00pm") — that field exists
+	 * precisely so a class can describe its schedule without pinning it to a
+	 * time — then the term dates, and finally an honest admission that nothing
+	 * has been set.
+	 */
+	public function scheduleLabel(): string {
+		$note = null !== $this->scheduleNote ? trim( $this->scheduleNote ) : '';
+		if ( '' !== $note ) {
+			return $note;
+		}
+
+		if ( null === $this->termStart ) {
+			return __( 'Schedule to be confirmed', 'unsupervised-schedular' );
+		}
+
+		$start = (string) mysql2date( 'M j, Y', $this->termStart );
+
+		if ( null === $this->termEnd || $this->termEnd === $this->termStart ) {
+			return $start;
+		}
+
+		return sprintf(
+			/* translators: 1: first class date, 2: last class date. */
+			__( '%1$s – %2$s', 'unsupervised-schedular' ),
+			$start,
+			(string) mysql2date( 'M j, Y', $this->termEnd )
+		);
 	}
 
 	public static function fromRow( \stdClass $row ): self {

src/Payment/Credit.php

@@ -26,6 +26,12 @@ class Credit {
 		public readonly int $studentId,
 		public readonly float $amount,
 		public readonly float $remaining,
+		/**
+		 * The account holding this balance — a child's guardian, or 0 meaning
+		 * "the student themselves". A family's credits all sit on the guardian,
+		 * so one child's cancellation can settle a sibling's charge.
+		 */
+		public readonly int $payerId = 0,
 		public readonly string $currency = 'CAD',
 		public readonly ?int $sourcePaymentId = null,
 		public readonly ?int $sourceLessonId = null,
@@ -41,6 +47,7 @@ class Credit {
 			studentId:       Val::int( $row->student_id ),
 			amount:          Val::float( $row->amount ),
 			remaining:       Val::float( $row->remaining ),
+			payerId:         Val::int( $row->payer_id ?? 0 ),
 			currency:        Val::string( $row->currency ),
 			sourcePaymentId: Val::intOrNull( $row->source_payment_id ?? null ),
 			sourceLessonId:  Val::intOrNull( $row->source_lesson_id ?? null ),
@@ -56,6 +63,15 @@ class Credit {
 		return self::STATUS_AVAILABLE === $this->status && $this->remaining > 0.0;
 	}
 
+	/**
+	 * Whose balance this credit sits in: the recorded payer, falling back to the
+	 * student. Callers go through here rather than reading `payerId`, so the `0`
+	 * default of a pre-guardian credit never leaks out as a user id.
+	 */
+	public function payerOrStudent(): int {
+		return $this->payerId > 0 ? $this->payerId : $this->studentId;
+	}
+
 	/**
 	 * Returns a plain array representation of the credit.
 	 *
@@ -65,6 +81,7 @@ class Credit {
 		return [
 			'id'                => $this->id,
 			'student_id'        => $this->studentId,
+			'payer_id'          => $this->payerOrStudent(),
 			'amount'            => $this->amount,
 			'remaining'         => $this->remaining,
 			'currency'          => $this->currency,

src/Payment/CreditRepository.php

@@ -16,6 +16,7 @@ class CreditRepository {
 			$this->table,
 			[
 				'student_id'        => $credit->studentId,
+				'payer_id'          => $credit->payerOrStudent(),
 				'amount'            => $credit->amount,
 				'remaining'         => $credit->remaining,
 				'currency'          => $credit->currency,
@@ -25,7 +26,7 @@ class CreditRepository {
 				'status'            => $credit->status,
 				'created_at'        => current_time( 'mysql' ),
 			],
-			[ '%d', '%f', '%f', '%s', '%d', '%d', '%s', '%s', '%s' ]
+			[ '%d', '%d', '%f', '%f', '%s', '%d', '%d', '%s', '%s', '%s' ]
 		);
 
 		return $this->db->insert_id;
@@ -56,15 +57,16 @@ class CreditRepository {
 	}
 
 	/**
-	 * A student's total unused credit balance (sum of the remaining amounts of every
-	 * still-available credit).
+	 * A payer's total unused credit balance (sum of the remaining amounts of every
+	 * still-available credit). Keyed on the payer, so a guardian's balance covers
+	 * credits earned by any of their children — one family, one balance.
 	 */
-	public function availableBalance( int $studentId ): float {
+	public function availableBalance( int $payerId ): float {
 		$total = $this->db->get_var(
 			$this->db->prepare(
-				'SELECT COALESCE( SUM( remaining ), 0 ) FROM %i WHERE student_id = %d AND status = %s',
+				'SELECT COALESCE( SUM( remaining ), 0 ) FROM %i WHERE payer_id = %d AND status = %s',
 				$this->table,
-				$studentId,
+				$payerId,
 				Credit::STATUS_AVAILABLE
 			)
 		);
@@ -73,17 +75,17 @@ class CreditRepository {
 	}
 
 	/**
-	 * A student's still-available credits, oldest first — the FIFO order they are
+	 * A payer's still-available credits, oldest first — the FIFO order they are
 	 * consumed in.
 	 *
 	 * @return list<Credit>
 	 */
-	public function findAvailableByStudent( int $studentId ): array {
+	public function findAvailableByPayer( int $payerId ): array {
 		$rows = $this->db->get_results(
 			$this->db->prepare(
-				'SELECT * FROM %i WHERE student_id = %d AND status = %s AND remaining > 0 ORDER BY created_at ASC, id ASC',
+				'SELECT * FROM %i WHERE payer_id = %d AND status = %s AND remaining > 0 ORDER BY created_at ASC, id ASC',
 				$this->table,
-				$studentId,
+				$payerId,
 				Credit::STATUS_AVAILABLE
 			)
 		);
@@ -92,7 +94,10 @@ class CreditRepository {
 	}
 
 	/**
-	 * Every credit for a student, newest first (admin history).
+	 * Every credit earned by a student, newest first — the admin history on their
+	 * own screen. Unlike the balance this is keyed on the student, so a child's
+	 * screen shows the credits their cancellations produced even though the
+	 * balance itself sits with their guardian.
 	 *
 	 * @return list<Credit>
 	 */
@@ -109,17 +114,30 @@ class CreditRepository {
 	}
 
 	/**
-	 * Draw down a student's credit balance by $amount, consuming their available
+	 * Backfill `payer_id` on credits written before guardian accounts existed,
+	 * where the student was always the payer. Run once from the installer so the
+	 * payer-keyed balance queries see those rows.
+	 */
+	public function backfillPayerIds(): void {
+		$sql = $this->db->prepare( 'UPDATE %i SET payer_id = student_id WHERE payer_id = 0', $this->table );
+
+		if ( null !== $sql ) {
+			$this->db->query( $sql );
+		}
+	}
+
+	/**
+	 * Draw down a payer's credit balance by $amount, consuming their available
 	 * credits oldest first and marking each fully-spent credit `consumed`. Stops once
 	 * the amount is exhausted; a balance shorter than $amount simply drains to zero.
 	 */
-	public function consume( int $studentId, float $amount ): void {
+	public function consume( int $payerId, float $amount ): void {
 		$remaining = round( $amount, 2 );
 		if ( $remaining <= 0.0 ) {
 			return;
 		}
 
-		foreach ( $this->findAvailableByStudent( $studentId ) as $credit ) {
+		foreach ( $this->findAvailableByPayer( $payerId ) as $credit ) {
 			if ( $remaining <= 0.0 ) {
 				break;
 			}

src/Payment/Payment.php

@@ -39,6 +39,13 @@ class Payment {
 		public readonly string $registrationType,
 		public readonly int $registrationId,
 		public readonly float $amount,
+		/**
+		 * The account that owes this charge — a child's guardian, or 0 meaning
+		 * "the student themselves". Zero rather than a copy of `studentId` so
+		 * every payment written before guardian accounts existed reads back with
+		 * its original meaning without a data migration.
+		 */
+		public readonly int $payerId = 0,
 		public readonly string $currency = 'CAD',
 		public readonly string $method = self::METHOD_ETRANSFER,
 		public readonly string $status = self::STATUS_PENDING,
@@ -64,6 +71,7 @@ class Payment {
 			registrationType:      Val::string( $row->registration_type ),
 			registrationId:        Val::int( $row->registration_id ),
 			amount:                Val::float( $row->amount ),
+			payerId:               Val::int( $row->payer_id ?? 0 ),
 			currency:              Val::string( $row->currency ),
 			method:                Val::string( $row->method ),
 			status:                Val::string( $row->status ),
@@ -87,6 +95,25 @@ class Payment {
 		return self::STATUS_PAID === $this->status;
 	}
 
+	/**
+	 * Who actually owes this charge: the recorded payer, falling back to the
+	 * student. Every caller that needs a person to bill, receipt or credit goes
+	 * through here rather than reading `payerId` directly, so the `0` default
+	 * never leaks out as a user id.
+	 */
+	public function payerOrStudent(): int {
+		return $this->payerId > 0 ? $this->payerId : $this->studentId;
+	}
+
+	/**
+	 * Whether someone other than the student is paying — a guardian. Drives the
+	 * "paid by" line on admin screens, which is noise when they are the same
+	 * person.
+	 */
+	public function hasSeparatePayer(): bool {
+		return $this->payerId > 0 && $this->payerId !== $this->studentId;
+	}
+
 	/**
 	 * Whether this payment was generated by the daily billing scan (weekly /
 	 * monthly) rather than taken at registration. Scheduled payments carry a due
@@ -134,6 +161,7 @@ class Payment {
 		return [
 			'id'                => $this->id,
 			'student_id'        => $this->studentId,
+			'payer_id'          => $this->payerOrStudent(),
 			'instructor_id'     => $this->instructorId,
 			'registration_type' => $this->registrationType,
 			'etransfer_email'   => $this->etransferEmail,

src/Payment/PaymentRepository.php

@@ -16,6 +16,7 @@ class PaymentRepository {
 			$this->table,
 			[
 				'student_id'               => $payment->studentId,
+				'payer_id'                 => $payment->payerOrStudent(),
 				'instructor_id'            => $payment->instructorId,
 				'registration_type'        => $payment->registrationType,
 				'registration_id'          => $payment->registrationId,
@@ -36,12 +37,24 @@ class PaymentRepository {
 				'paid_at'                  => $payment->paidAt,
 				'created_at'               => current_time( 'mysql' ),
 			],
-			[ '%d', '%d', '%s', '%d', '%f', '%s', '%s', '%s', '%f', '%f', '%f', '%s', '%s', '%s', '%s', '%s', '%s', '%s', '%s', '%s' ]
+			[ '%d', '%d', '%d', '%s', '%d', '%f', '%s', '%s', '%s', '%f', '%f', '%f', '%s', '%s', '%s', '%s', '%s', '%s', '%s', '%s', '%s' ]
 		);
 
 		return $this->db->insert_id;
 	}
 
+	/**
+	 * Backfill `payer_id` on payments written before guardian accounts existed,
+	 * where the student was always the payer. Run once from the installer.
+	 */
+	public function backfillPayerIds(): void {
+		$sql = $this->db->prepare( 'UPDATE %i SET payer_id = student_id WHERE payer_id = 0', $this->table );
+
+		if ( null !== $sql ) {
+			$this->db->query( $sql );
+		}
+	}
+
 	/**
 	 * Attach the Stripe PaymentIntent id created for a card payment so the webhook
 	 * can later reconcile the charge back to this row.

src/Payment/PaymentService.php

@@ -34,13 +34,18 @@ class PaymentService {
 	 * A `$dueDate`/`$periodKey` mark a payment generated later by the daily billing
 	 * scan (weekly / monthly) rather than taken at registration; both stay null for
 	 * the pay-now flow.
+	 *
+	 * `$payerId` is who owes it — a child's guardian, or 0 (the default) when the
+	 * student pays for themselves. The billing method resolves against the payer,
+	 * so comping or card-billing a family is one setting on the guardian.
 	 */
-	public function createForRegistration( string $type, int $registrationId, int $studentId, int $instructorId, float $amount, string $currency, ?string $offeringEtransferEmail = null, ?string $dueDate = null, ?string $periodKey = null ): ?Payment {
+	public function createForRegistration( string $type, int $registrationId, int $studentId, int $instructorId, float $amount, string $currency, ?string $offeringEtransferEmail = null, ?string $dueDate = null, ?string $periodKey = null, int $payerId = 0 ): ?Payment {
 		if ( $amount <= 0.0 ) {
 			return null;
 		}
 
-		$method = $this->resolver->resolve( $studentId );
+		$payerId = $payerId > 0 ? $payerId : $studentId;
+		$method  = $this->resolver->resolve( $payerId );
 		$status  = Payment::METHOD_COMP === $method ? Payment::STATUS_PAID : Payment::STATUS_PENDING;
 
 		$etransferEmail = null !== $offeringEtransferEmail && '' !== $offeringEtransferEmail
@@ -58,6 +63,7 @@ class PaymentService {
 				registrationType: $type,
 				registrationId:   $registrationId,
 				amount:           $amount,
+				payerId:          $payerId,
 				currency:         $currency,
 				method:           $method,
 				status:           $status,
@@ -72,7 +78,9 @@ class PaymentService {
 		$this->linkPayment( $type, $registrationId, $id );
 
 		if ( Payment::STATUS_PAID === $status ) {
-			$this->finalizePaid( $id, $type, $registrationId, $studentId );
+			// The receipt goes to whoever paid, which for a child's lesson is the
+			// guardian — a child's own address is an undeliverable placeholder.
+			$this->finalizePaid( $id, $type, $registrationId, $payerId );
 		}
 
 		return $this->payments->findById( $id );
@@ -111,7 +119,7 @@ class PaymentService {
 			return true;
 		}
 
-		$this->finalizePaid( $paymentId, $payment->registrationType, $payment->registrationId, $payment->studentId );
+		$this->finalizePaid( $paymentId, $payment->registrationType, $payment->registrationId, $payment->payerOrStudent() );
 
 		return true;
 	}
@@ -174,11 +182,15 @@ class PaymentService {
 			return null;
 		}
 
+		// The credit records the child it was earned for, but the balance itself
+		// lands on whoever paid — so a family's credits pool on the guardian and
+		// one child's cancellation can settle a sibling's next charge.
 		$id = $this->credits->insert(
 			new Credit(
 				studentId:       $payment->studentId,
 				amount:          $share,
 				remaining:       $share,
+				payerId:         $payment->payerOrStudent(),
 				currency:        $payment->currency,
 				sourcePaymentId: $payment->id,
 				sourceLessonId:  $lesson->id,
@@ -209,19 +221,22 @@ class PaymentService {
 	}
 
 	/**
-	 * Apply a student's available credit balance against a set of freshly-created
+	 * Apply a payer's available credit balance against a set of freshly-created
 	 * pending payments (the ones a billing scan just generated for them), oldest
 	 * charge first. Each payment's `credit_applied` is raised by the amount covered;
 	 * a payment fully covered is marked paid-by-credit and its registration confirmed
 	 * so it leaves the confirmation queue. The credit ledger is drawn down by the
 	 * total applied. Returns a map of payment id to the credit applied to it, so the
-	 * caller can reflect the reduction on the student's notice.
+	 * caller can reflect the reduction on the payer's notice.
+	 *
+	 * Keyed on the payer, so a guardian's balance settles charges raised against
+	 * any of their children — the payments passed in may name several students.
 	 *
 	 * @param list<Payment> $payments
 	 * @return array<int, float>
 	 */
-	public function applyCredits( int $studentId, array $payments ): array {
-		$balance = $this->credits->availableBalance( $studentId );
+	public function applyCredits( int $payerId, array $payments ): array {
+		$balance = $this->credits->availableBalance( $payerId );
 		if ( $balance <= 0.0 ) {
 			return [];
 		}
@@ -258,7 +273,7 @@ class PaymentService {
 		}
 
 		if ( $consumed > 0.0 ) {
-			$this->credits->consume( $studentId, $consumed );
+			$this->credits->consume( $payerId, $consumed );
 		}
 
 		return $applied;
@@ -272,11 +287,19 @@ class PaymentService {
 	 * needs no further action. Returns null when the registration has no payment,
 	 * the caller does not own it, or Stripe could not create the intent.
 	 *
+	 * `$userId` is the caller: either the student the registration is for, or the
+	 * guardian who owes it — anyone else gets null rather than a payment step for
+	 * a charge that is not theirs.
+	 *
 	 * @return array<string, mixed>|null
 	 */
-	public function createIntent( string $type, int $registrationId, int $studentId ): ?array {
+	public function createIntent( string $type, int $registrationId, int $userId ): ?array {
 		$payment = $this->payments->findByRegistration( $type, $registrationId );
-		if ( null === $payment || null === $payment->id || $payment->studentId !== $studentId ) {
+		if ( null === $payment || null === $payment->id ) {
+			return null;
+		}
+
+		if ( $payment->studentId !== $userId && $payment->payerOrStudent() !== $userId ) {
 			return null;
 		}
 
@@ -334,7 +357,7 @@ class PaymentService {
 		}
 
 		if ( 'payment_intent.succeeded' === $event->type && ! $payment->isPaid() ) {
-			$this->finalizePaid( $payment->id, $payment->registrationType, $payment->registrationId, $payment->studentId );
+			$this->finalizePaid( $payment->id, $payment->registrationType, $payment->registrationId, $payment->payerOrStudent() );
 		} elseif ( 'payment_intent.payment_failed' === $event->type && ! $payment->isPaid() ) {
 			$this->payments->updateStatus( $payment->id, Payment::STATUS_FAILED );
 		}
@@ -342,12 +365,12 @@ class PaymentService {
 		return true;
 	}
 
-	private function finalizePaid( int $paymentId, string $type, int $registrationId, int $studentId ): void {
+	private function finalizePaid( int $paymentId, string $type, int $registrationId, int $payerId ): void {
 		$this->payments->markPaid( $paymentId, 'USC-' . $paymentId );
 		$this->confirmRegistration( $type, $registrationId );
 
 		$paid = $this->payments->findById( $paymentId );
-		$user = get_userdata( $studentId );
+		$user = get_userdata( $payerId );
 		if ( null !== $paid && $this->mailer->send( $paid, $user instanceof \WP_User ? $user : null ) ) {
 			$this->payments->markReceiptSent( $paymentId );
 		}

src/Payment/ScheduledBillingRunner.php

@@ -6,13 +6,14 @@ namespace Unsupervised\Schedular\Payment;
 use Unsupervised\Schedular\Booking\BookingRepository;
 use Unsupervised\Schedular\GroupClass\Enrollment;
 use Unsupervised\Schedular\GroupClass\EnrollmentRepository;
+use Unsupervised\Schedular\Guardian\GuardianService;
 use Unsupervised\Schedular\Offering\Offering;
 use Unsupervised\Schedular\Offering\OfferingRepository;
 use Unsupervised\Schedular\Val;
 
 /**
  * Generates the pending payments that scheduled-billing offerings (weekly /
- * monthly) owe as they come due, then emails each student one itemised notice.
+ * monthly) owe as they come due, then emails each payer one itemised notice.
  *
  * Runs from the daily WP-Cron action `us_generate_due_payments`. It is
  * self-healing: every run re-scans from the current ledger state, so a missed
@@ -30,6 +31,7 @@ class ScheduledBillingRunner {
 		private EnrollmentRepository $enrollments,
 		private OfferingRepository $offerings,
 		private PaymentDueMailer $mailer,
+		private GuardianService $guardians,
 	) {}
 
 	public function register(): void {
@@ -42,12 +44,13 @@ class ScheduledBillingRunner {
 	public function run(): void {
 		$now = $this->now();
 
-		// One notice bucket per student, filled as pending payments are created and
-		// flushed to a single email at the end, so a student billed for several
-		// lessons on one day is emailed once — never once per lesson. Each entry keeps
-		// the created payment and its label; credits are applied across the whole
-		// bucket before the notice is built, so a student's account credit offsets the
-		// run's charges oldest-first.
+		// One notice bucket per *payer*, filled as pending payments are created and
+		// flushed to a single email at the end, so a payer billed for several
+		// lessons on one day is emailed once — never once per lesson, and a guardian
+		// gets one notice covering every child rather than one per child. Each entry
+		// keeps the created payment and its label; credits are applied across the
+		// whole bucket before the notice is built, so the family's account credit
+		// offsets the run's charges oldest-first.
 		$buckets = [];
 
 		$this->billPrivateLessons( $now, $buckets );
@@ -251,11 +254,18 @@ class ScheduledBillingRunner {
 	/**
 	 * Bill one payment per calendar month of a group class, once its 1st arrives.
 	 *
+	 * A monthly group class is priced **per month**, not per session: the fee is
+	 * charged once for the month however many times the class meets in it. This is
+	 * what the student is quoted and agrees to on the way in ("40.00 CAD monthly"),
+	 * and it is the one place the monthly rule differs from private lessons, whose
+	 * per-lesson fee is multiplied by the lessons that fall in the month.
+	 *
 	 * @param list<array{start: string, end: string}> $windows
 	 * @param array<int, list<array{payment: Payment, label: string}>> $buckets
 	 */
 	private function billGroupMonthly( \DateTimeImmutable $now, string $today, Enrollment $enrollment, Offering $offering, array $windows, array &$buckets ): void { // phpcs:ignore Generic.CodeAnalysis.UnusedFunctionParameter.Found
-		// Count this enrolment's sessions per calendar month.
+		// Count this enrolment's sessions per calendar month. The count does not
+		// price the month — it names it on the student's notice ("3 sessions").
 		$months = [];
 		foreach ( $windows as $window ) {
 			$start                             = new \DateTimeImmutable( $window['start'] );
@@ -278,7 +288,7 @@ class ScheduledBillingRunner {
 				(int) $enrollment->id,
 				$enrollment->studentId,
 				$enrollment->instructorId,
-				$offering->price * $count,
+				$offering->price,
 				$offering->currency,
 				$offering->etransferEmail,
 				$monthStart,
@@ -296,19 +306,24 @@ class ScheduledBillingRunner {
 
 	/**
 	 * Create one scheduled payment and, when it is pending (not a comp auto-pay),
-	 * add it to the student's notice bucket with the label to show on the notice.
+	 * add it to the payer's notice bucket with the label to show on the notice.
 	 * Credits are applied later, once the whole bucket is known. Returns the created
 	 * payment, or null when there was nothing to charge.
 	 *
+	 * The charge is bucketed against whoever owes it, so a guardian's notice covers
+	 * all their children; the label names the child when that differs from the
+	 * payer, or a parent cannot tell whose lesson each line is.
+	 *
 	 * @param array<int, list<array{payment: Payment, label: string}>> $buckets
 	 */
 	private function bill( array &$buckets, string $type, int $registrationId, int $studentId, int $instructorId, float $amount, string $currency, ?string $etransferEmail, string $dueDate, string $periodKey, string $label ): ?Payment {
-		$payment = $this->payments->createForRegistration( $type, $registrationId, $studentId, $instructorId, $amount, $currency, $etransferEmail, $dueDate, $periodKey );
+		$payerId = $this->guardians->payerFor( $studentId );
+		$payment = $this->payments->createForRegistration( $type, $registrationId, $studentId, $instructorId, $amount, $currency, $etransferEmail, $dueDate, $periodKey, $payerId );
 
 		if ( null !== $payment && null !== $payment->id && Payment::STATUS_PENDING === $payment->status ) {
-			$buckets[ $studentId ][] = [
+			$buckets[ $payerId ][] = [
 				'payment' => $payment,
-				'label'   => $label,
+				'label'   => $payerId === $studentId ? $label : $this->labelFor( $studentId, $label ),
 			];
 		}
 
@@ -316,7 +331,17 @@ class ScheduledBillingRunner {
 	}
 
 	/**
-	 * For each student, apply any account credit they hold against the run's charges,
+	 * Prefix a notice line with the student it is for — "Ada: Piano Lesson —
+	 * Mar 3, 2026" — used only when the payer is not the student.
+	 */
+	private function labelFor( int $studentId, string $label ): string {
+		$name = $this->guardians->studentName( $studentId );
+
+		return '' === $name ? $label : $name . ': ' . $label;
+	}
+
+	/**
+	 * For each payer, apply any account credit they hold against the run's charges,
 	 * tag the payments they still owe with a shared batch reference, and email them
 	 * one itemised notice. The notice lists each charge at its full amount, then the
 	 * credit applied and the reduced total due; a charge fully covered by credit is
@@ -326,9 +351,9 @@ class ScheduledBillingRunner {
 	 * @param array<int, list<array{payment: Payment, label: string}>> $buckets
 	 */
 	private function sendNotices( array $buckets ): void {
-		foreach ( $buckets as $studentId => $entries ) {
+		foreach ( $buckets as $payerId => $entries ) {
 			$payments = array_map( static fn( array $entry ): Payment => $entry['payment'], $entries );
-			$applied  = $this->payments->applyCredits( $studentId, $payments );
+			$applied  = $this->payments->applyCredits( $payerId, $payments );
 
 			$items       = [];
 			$batchIds    = [];
@@ -359,7 +384,7 @@ class ScheduledBillingRunner {
 			$reference = [] !== $batchIds ? $this->reference() : '';
 			$this->payments->assignNoticeBatch( $batchIds, $reference );
 
-			$user = get_userdata( $studentId );
+			$user = get_userdata( $payerId );
 			if ( $user instanceof \WP_User ) {
 				$this->mailer->send( $user, $items, $reference, round( $creditTotal, 2 ) );
 			}

src/Plugin.php

@@ -3,8 +3,10 @@ declare(strict_types=1);
 
 namespace Unsupervised\Schedular;
 
+use Unsupervised\Schedular\Auth\DeletedUserCleanup;
 use Unsupervised\Schedular\Auth\EmailConfirmationHandler;
 use Unsupervised\Schedular\Auth\InviteRepository;
+use Unsupervised\Schedular\Auth\AccountPage;
 use Unsupervised\Schedular\Auth\LoginPage;
 use Unsupervised\Schedular\Auth\RegistrationLoginGate;
 use Unsupervised\Schedular\Auth\RegistrationMailer;
@@ -17,6 +19,10 @@ use Unsupervised\Schedular\Booking\BookingRepository;
 use Unsupervised\Schedular\GroupClass\EnrollmentRepository;
 use Unsupervised\Schedular\GroupClass\GroupAccessRepository;
 use Unsupervised\Schedular\GroupClass\GroupClassPage;
+use Unsupervised\Schedular\Guardian\ChildLoginGate;
+use Unsupervised\Schedular\Guardian\FamilyPage;
+use Unsupervised\Schedular\Guardian\GuardianRepository;
+use Unsupervised\Schedular\Guardian\GuardianService;
 use Unsupervised\Schedular\Offering\OfferingRepository;
 use Unsupervised\Schedular\Payment\BillingMethodResolver;
 use Unsupervised\Schedular\Payment\CreditRepository;
@@ -66,6 +72,15 @@ class Plugin {
 			update_option( 'us_questions_offering_nullable', '1' );
 		}
 
+		// One-time backfill of us_questions.is_required_child, which dbDelta adds
+		// defaulting to 0 — leaving every question that *was* required no longer
+		// required of the students a guardian registers. Runs after the version
+		// gate above, so the column it writes to exists. Guarded so a question
+		// later made optional for students stays that way.
+		if ( '1' !== get_option( 'us_questions_child_required_backfilled', '' ) && $questions->backfillChildRequired() ) {
+			update_option( 'us_questions_child_required_backfilled', '1' );
+		}
+
 		$answers          = new AnswerRepository( $wpdb );
 		$policies         = new PolicyRepository( $wpdb );
 		$policyVersions   = new PolicyVersionRepository( $wpdb );
@@ -76,6 +91,9 @@ class Plugin {
 		$groupAccess      = new GroupAccessRepository( $wpdb );
 		$registrationGate = new RegistrationGate( $questions, $answers, $policies, $policyVersions, $acceptances );
 
+		$guardianRepo = new GuardianRepository( $wpdb );
+		$guardians    = new GuardianService( $guardianRepo, $bookings, $enrollments );
+
 		$paymentRepo    = new PaymentRepository( $wpdb );
 		$creditRepo     = new CreditRepository( $wpdb );
 		$settings       = new StudioSettings();
@@ -87,21 +105,25 @@ class Plugin {
 		// front-end output is identical whichever way a page embeds them.
 		$registrationMailer = new RegistrationMailer();
 
-		$bookingPage      = new BookingPage();
+		$bookingPage      = new BookingPage( $guardians );
 		$loginPage        = new LoginPage();
-		$registrationPage = new RegistrationPage( $invites, $policies, $policyVersions, $acceptances, $settings, $registrationMailer, $questions, $answers, $groupAccess );
-		$groupClassPage   = new GroupClassPage();
+		$registrationPage = new RegistrationPage( $invites, $policies, $policyVersions, $acceptances, $settings, $registrationMailer, $questions, $answers, $groupAccess, $guardians );
+		$groupClassPage   = new GroupClassPage( $guardians );
+		$familyPage       = new FamilyPage( $guardians, $questions, $answers );
+		$accountPage      = new AccountPage();
 
-		( new ScheduledBillingRunner( $paymentService, $bookings, $enrollments, $offerings, new PaymentDueMailer() ) )->register();
+		( new ScheduledBillingRunner( $paymentService, $bookings, $enrollments, $offerings, new PaymentDueMailer(), $guardians ) )->register();
 
 		( new UpdateChecker() )->register();
 		( new RoleManager() )->register();
 		( new RegistrationLoginGate() )->register();
+		( new ChildLoginGate() )->register();
 		( new StudentAdminGuard() )->register();
+		( new DeletedUserCleanup( $bookings, $availability, $enrollments, $paymentService, $guardianRepo, $guardians ) )->register();
 		( new EmailConfirmationHandler( $settings, $registrationMailer ) )->register();
-		( new AdminMenu( $availability, $bookings, $offerings, $questions, $answers, $policies, $policyVersions, $policyService, $acceptances, $invites, $enrollments, $groupAccess, $settings, $paymentRepo, $paymentService, $resolver, $registrationMailer, $creditRepo ) )->register();
-		( new RestRegistrar( $availability, $bookings, $offerings, $questions, $policies, $policyVersions, $policyService, $registrationGate, $enrollments, $groupAccess, $paymentService ) )->register();
-		( new ShortcodeRegistrar( $bookingPage, $loginPage, $registrationPage, $groupClassPage ) )->register();
-		( new BlockRegistrar( $bookingPage, $loginPage, $registrationPage, $groupClassPage ) )->register();
+		( new AdminMenu( $availability, $bookings, $offerings, $questions, $answers, $policies, $policyVersions, $policyService, $acceptances, $invites, $enrollments, $groupAccess, $settings, $paymentRepo, $paymentService, $resolver, $registrationMailer, $creditRepo, $guardians ) )->register();
+		( new RestRegistrar( $availability, $bookings, $offerings, $questions, $policies, $policyVersions, $policyService, $registrationGate, $enrollments, $groupAccess, $paymentService, $guardians ) )->register();
+		( new ShortcodeRegistrar( $bookingPage, $loginPage, $registrationPage, $groupClassPage, $familyPage, $accountPage ) )->register();
+		( new BlockRegistrar( $bookingPage, $loginPage, $registrationPage, $groupClassPage, $familyPage, $accountPage ) )->register();
 	}
 }

src/Policy/AcceptanceRepository.php

@@ -17,12 +17,13 @@ class AcceptanceRepository {
 			[
 				'policy_version_id' => $acceptance->policyVersionId,
 				'student_id'        => $acceptance->studentId,
+				'accepted_by'       => $acceptance->acceptorOrStudent(),
 				'registration_type' => $acceptance->registrationType,
 				'registration_id'   => $acceptance->registrationId,
 				'ip_address'        => $acceptance->ipAddress,
 				'accepted_at'       => current_time( 'mysql' ),
 			],
-			[ '%d', '%d', '%s', '%d', '%s', '%s' ]
+			[ '%d', '%d', '%d', '%s', '%d', '%s', '%s' ]
 		);
 
 		return $this->db->insert_id;
@@ -38,6 +39,19 @@ class AcceptanceRepository {
 		return array_map( fn( PolicyAcceptance $a ): int => $this->insert( $a ), $acceptances );
 	}
 
+	/**
+	 * Backfill `accepted_by` on acceptances recorded before guardian accounts
+	 * existed, where the student always agreed for themselves. Run once from the
+	 * installer so the acceptor is a real user id on every row.
+	 */
+	public function backfillAcceptedBy(): void {
+		$sql = $this->db->prepare( 'UPDATE %i SET accepted_by = student_id WHERE accepted_by = 0', $this->table );
+
+		if ( null !== $sql ) {
+			$this->db->query( $sql );
+		}
+	}
+
 	/**
 	 * Find all acceptances attached to a registration (lesson or enrolment).
 	 *

src/Policy/PolicyAcceptance.php

@@ -24,6 +24,13 @@ class PolicyAcceptance {
 		public readonly int $studentId,
 		public readonly string $registrationType,
 		public readonly int $registrationId,
+		/**
+		 * Who actually clicked "I agree" — a child's guardian, or 0 meaning the
+		 * student agreed for themselves. Zero rather than a copy of `studentId`
+		 * so every acceptance recorded before guardian accounts existed keeps its
+		 * original meaning.
+		 */
+		public readonly int $acceptedBy = 0,
 		public readonly ?string $ipAddress = null,
 		public readonly ?string $acceptedAt = null,
 		public readonly ?int $id = null,
@@ -35,12 +42,31 @@ class PolicyAcceptance {
 			studentId:        Val::int( $row->student_id ),
 			registrationType: Val::string( $row->registration_type ),
 			registrationId:   Val::int( $row->registration_id ),
+			acceptedBy:       Val::int( $row->accepted_by ?? 0 ),
 			ipAddress:        Val::stringOrNull( $row->ip_address ),
 			acceptedAt:       Val::stringOrNull( $row->accepted_at ),
 			id:               Val::int( $row->id ),
 		);
 	}
 
+	/**
+	 * Who this acceptance is legally attributable to: the recorded acceptor,
+	 * falling back to the student. Callers go through here so the `0` default of a
+	 * pre-guardian acceptance never leaks out as a user id.
+	 */
+	public function acceptorOrStudent(): int {
+		return $this->acceptedBy > 0 ? $this->acceptedBy : $this->studentId;
+	}
+
+	/**
+	 * Whether someone other than the student agreed — a guardian accepting on a
+	 * child's behalf. Drives the "accepted by" line on the admin screen, which is
+	 * noise when they are the same person.
+	 */
+	public function acceptedOnBehalf(): bool {
+		return $this->acceptedBy > 0 && $this->acceptedBy !== $this->studentId;
+	}
+
 	/**
 	 * Returns a plain array representation of the acceptance.
 	 *
@@ -51,6 +77,7 @@ class PolicyAcceptance {
 			'id'                => $this->id,
 			'policy_version_id' => $this->policyVersionId,
 			'student_id'        => $this->studentId,
+			'accepted_by'       => $this->acceptorOrStudent(),
 			'registration_type' => $this->registrationType,
 			'registration_id'   => $this->registrationId,
 			'ip_address'        => $this->ipAddress,

src/Policy/PolicyController.php

@@ -19,20 +19,35 @@ class PolicyController {
 			wp_die( esc_html__( 'You do not have permission to manage policies.', 'unsupervised-schedular' ) );
 		}
 
+		$notice        = '';
+		$viewVersionId = 0;
+
 		if ( isset( $_POST['usc_action'] ) && check_admin_referer( 'usc_policy_action' ) ) {
-			$this->handleFormAction();
+			[ $notice, $viewVersionId ] = $this->handleFormAction();
 		}
 
-		// phpcs:ignore WordPress.Security.NonceVerification.Recommended -- read-only policy selector.
+		// phpcs:disable WordPress.Security.NonceVerification.Recommended -- read-only policy/version selectors.
 		$policyId = absint( Val::int( $_GET['policy_id'] ?? 0 ) );
+		if ( 0 === $viewVersionId ) {
+			$viewVersionId = absint( Val::int( $_GET['version_id'] ?? 0 ) );
+		}
+		// phpcs:enable WordPress.Security.NonceVerification.Recommended
+
 		$policyList     = $this->policies->findAll();
 		$selectedPolicy = $policyId > 0 ? $this->policies->findById( $policyId ) : null;
 		$policyVersions = null !== $selectedPolicy ? $this->versions->findByPolicy( (int) $selectedPolicy->id ) : null;
+		$viewedVersion  = null !== $selectedPolicy ? $this->loadVersionForPolicy( (int) $selectedPolicy->id, $viewVersionId ) : null;
 
 		include USC_PLUGIN_DIR . 'templates/admin/policies.php';
 	}
 
-	private function handleFormAction(): void {
+	/**
+	 * Process the posted action.
+	 *
+	 * @return array{string, int} Status notice, and the version to open in the
+	 *                            viewer (0 to leave the current selection alone).
+	 */
+	private function handleFormAction(): array {
 		// Nonce is verified by the caller (renderPage) before this method runs.
 		// phpcs:disable WordPress.Security.NonceVerification.Missing
 		$action = sanitize_key( Val::string( wp_unslash( $_POST['usc_action'] ?? '' ) ) );
@@ -53,12 +68,31 @@ class PolicyController {
 				$this->service->createPolicy( $title, $slug, $scope );
 			}
 
-			return;
+			return [ '', 0 ];
 		}
 
 		$policyId = absint( Val::int( $_POST['policy_id'] ?? 0 ) );
 		if ( $policyId <= 0 || null === $this->policies->findById( $policyId ) ) {
-			return;
+			return [ '', 0 ];
+		}
+
+		if ( 'rename_policy' === $action ) {
+			$title = trim( sanitize_text_field( Val::string( wp_unslash( $_POST['title'] ?? '' ) ) ) );
+
+			if ( '' === $title || mb_strlen( $title ) > Policy::MAX_TITLE_LENGTH ) {
+				return [ '', 0 ];
+			}
+
+			$this->policies->updateTitle( $policyId, $title );
+
+			return [
+				sprintf(
+					/* translators: %s: the policy's new title. */
+					__( 'Policy renamed to "%s".', 'unsupervised-schedular' ),
+					$title
+				),
+				0,
+			];
 		}
 
 		if ( 'add_version' === $action ) {
@@ -66,6 +100,40 @@ class PolicyController {
 			$this->service->addDraftVersion( $policyId, $body );
 		}
 
+		if ( 'edit_version' === $action ) {
+			$source = $this->loadVersionForPolicy( $policyId, absint( Val::int( $_POST['version_id'] ?? 0 ) ) );
+			if ( null === $source ) {
+				return [ '', 0 ];
+			}
+
+			$body = wp_kses_post( Val::string( wp_unslash( $_POST['body'] ?? '' ) ) );
+
+			// A draft has never been shown to a student, so it is edited in place.
+			// A published (or archived) version is what students accepted, so an
+			// edit branches a new draft and leaves the original untouched.
+			if ( PolicyVersion::STATUS_DRAFT === $source->status ) {
+				$this->versions->updateBody( (int) $source->id, $body );
+
+				return [
+					sprintf(
+						/* translators: %d: the edited version number. */
+						__( 'Draft version %d was updated.', 'unsupervised-schedular' ),
+						$source->versionNumber
+					),
+					(int) $source->id,
+				];
+			}
+
+			return [
+				sprintf(
+					/* translators: %d: the version number the edit was based on. */
+					__( 'Your changes to version %d were saved as a new draft version.', 'unsupervised-schedular' ),
+					$source->versionNumber
+				),
+				$this->service->addDraftVersion( $policyId, $body ),
+			];
+		}
+
 		if ( 'publish_version' === $action ) {
 			$versionId = absint( Val::int( $_POST['version_id'] ?? 0 ) );
 			if ( $versionId > 0 ) {
@@ -73,5 +141,20 @@ class PolicyController {
 			}
 		}
 		// phpcs:enable WordPress.Security.NonceVerification.Missing
+
+		return [ '', 0 ];
+	}
+
+	/**
+	 * Load a version by id, confirming it belongs to the given policy.
+	 */
+	private function loadVersionForPolicy( int $policyId, int $versionId ): ?PolicyVersion {
+		if ( $versionId <= 0 ) {
+			return null;
+		}
+
+		$version = $this->versions->findById( $versionId );
+
+		return null !== $version && $version->policyId === $policyId ? $version : null;
 	}
 }

src/Policy/PolicyEndpoint.php

@@ -104,9 +104,9 @@ class PolicyEndpoint {
 				'policy_version_id' => $version->id,
 				'version_number'    => $version->versionNumber,
 				// Bodies are kses'd on every write path, but the booking JS renders
-				// this HTML raw — sanitise at output too so a missed write path can
-				// never become stored XSS.
-				'body'              => wp_kses_post( (string) $version->body ),
+				// this HTML raw — bodyHtml() sanitises at output too, so a missed
+				// write path can never become stored XSS.
+				'body'              => $version->bodyHtml(),
 			];
 		}
 

src/Policy/PolicyRepository.php

@@ -46,6 +46,22 @@ class PolicyRepository {
 		return array_map( Policy::fromRow( ... ), $rows ?? [] );
 	}
 
+	/**
+	 * Rename a policy. Only the title moves: the slug is the identifier the
+	 * booking and signup gates look policies up by, so renaming "Studio Policy"
+	 * to "Terms of Enrolment" must not quietly detach it from the versions
+	 * students have already accepted.
+	 */
+	public function updateTitle( int $policyId, string $title ): bool {
+		return false !== $this->db->update(
+			$this->table,
+			[ 'title' => $title ],
+			[ 'id' => $policyId ],
+			[ '%s' ],
+			[ '%d' ]
+		);
+	}
+
 	public function updateCurrentVersion( int $policyId, int $versionId ): bool {
 		return false !== $this->db->update(
 			$this->table,

src/Policy/PolicyVersion.php

@@ -42,6 +42,19 @@ class PolicyVersion {
 		return self::STATUS_PUBLISHED === $this->status;
 	}
 
+	/**
+	 * The body as display-ready HTML.
+	 *
+	 * Policy bodies are typed into a plain textarea, so most are written as
+	 * blank-line-separated prose with no markup at all — dropped into a page
+	 * as-is that collapses into one unreadable run of text. Running the same
+	 * `wpautop()` WordPress applies to post content turns those breaks into
+	 * paragraphs, and leaves bodies that do carry markup alone.
+	 */
+	public function bodyHtml(): string {
+		return wpautop( wp_kses_post( (string) $this->body ) );
+	}
+
 	/**
 	 * Returns a plain array representation of the version.
 	 *

src/Registration/Question.php

@@ -21,6 +21,16 @@ class Question {
 	/** Question is studio-wide, asked once at account signup (no offering). */
 	public const SCOPE_ACCOUNT = 'account';
 
+	/** Asked of everyone: the account holder as a student, and each student they register. */
+	public const AUDIENCE_ALL = 'all';
+
+	/**
+	 * Asked only of the students someone registers on behalf of — never of the
+	 * account holder's own "About you" panel. For the questions that only make
+	 * sense about a child ("school and grade", "who may collect them").
+	 */
+	public const AUDIENCE_CHILD = 'child';
+
 	/**
 	 * All valid field types.
 	 *
@@ -43,9 +53,29 @@ class Question {
 		self::SCOPE_ACCOUNT,
 	];
 
+	/**
+	 * All valid audiences.
+	 *
+	 * @var list<string>
+	 */
+	public const VALID_AUDIENCES = [
+		self::AUDIENCE_ALL,
+		self::AUDIENCE_CHILD,
+	];
+
 	/**
 	 * Build an intake question value object.
 	 *
+	 * `$isRequired` and `$isRequiredChild` are deliberately separate: a studio may
+	 * want an answer from every student it enrols without demanding the same of an
+	 * adult signing themselves up. Read them through {@see isRequiredForSelf()} and
+	 * {@see isRequiredForChild()} rather than directly, so the audience is applied
+	 * with them.
+	 *
+	 * Both `$audience` and `$isRequiredChild` are meaningless for offering scope,
+	 * where a booking asks its questions once about the student being booked and
+	 * there is no separate account-holder form to differ from.
+	 *
 	 * @param int|null          $offeringId The owning offering, or null for account-scoped questions.
 	 * @param list<string>|null $options    Choices for a `select` field.
 	 */
@@ -58,9 +88,36 @@ class Question {
 		public readonly int $sortOrder = 0,
 		public readonly bool $isActive = true,
 		public readonly string $scope = self::SCOPE_OFFERING,
+		public readonly string $audience = self::AUDIENCE_ALL,
+		public readonly bool $isRequiredChild = false,
 		public readonly ?int $id = null,
 	) {}
 
+	/**
+	 * Whether the account holder is asked this question in their own right — true
+	 * for everything except a child-audience question.
+	 */
+	public function askedOfSelf(): bool {
+		return self::AUDIENCE_CHILD !== $this->audience;
+	}
+
+	/**
+	 * Whether the account holder must answer before the form will submit. A
+	 * child-audience question never reaches them, so it can never block them.
+	 */
+	public function isRequiredForSelf(): bool {
+		return $this->isRequired && $this->askedOfSelf();
+	}
+
+	/**
+	 * Whether each student being registered must answer before the form will
+	 * submit. Every question is asked in the student blocks whatever its audience,
+	 * so this stands on its own.
+	 */
+	public function isRequiredForChild(): bool {
+		return $this->isRequiredChild;
+	}
+
 	public static function fromRow( \stdClass $row ): self {
 		$options = null;
 		if ( null !== $row->options && '' !== $row->options ) {
@@ -70,6 +127,13 @@ class Question {
 				: null;
 		}
 
+		// `audience` and `is_required_child` arrived after the table did, so a row
+		// read on a site whose dbDelta has not run yet simply lacks them: the
+		// pre-existing behaviour (asked of everyone, required of nobody in
+		// particular) is the right reading of a question authored before the
+		// distinction existed.
+		$audience = Val::string( $row->audience ?? '' );
+
 		return new self(
 			offeringId:      Val::intOrNull( $row->offering_id ),
 			label:           Val::string( $row->label ),
@@ -79,6 +143,8 @@ class Question {
 			sortOrder:       Val::int( $row->sort_order ),
 			isActive:        Val::bool( $row->is_active ),
 			scope:           Val::string( $row->scope ),
+			audience:        in_array( $audience, self::VALID_AUDIENCES, true ) ? $audience : self::AUDIENCE_ALL,
+			isRequiredChild: Val::bool( $row->is_required_child ?? false ),
 			id:              Val::int( $row->id ),
 		);
 	}
@@ -96,7 +162,9 @@ class Question {
 			'label'             => $this->label,
 			'field_type'        => $this->fieldType,
 			'options'           => $this->options,
+			'audience'          => $this->audience,
 			'is_required'       => $this->isRequired,
+			'is_required_child' => $this->isRequiredChild,
 			'sort_order'        => $this->sortOrder,
 			'is_active'         => $this->isActive,
 		];

src/Registration/QuestionController.php

@@ -89,15 +89,25 @@ class QuestionController {
 			return;
 		}
 
+		// Audience and the students' own required-ness are asked for on the
+		// account-scope form only; an offering's questions are answered once about
+		// the student being booked, so there is no second audience to differ from.
+		// An offering question therefore mirrors its single "required" into both
+		// columns rather than storing a distinction it does not have.
+		$accountScope = null === $offering;
+		$audience     = sanitize_key( Val::string( wp_unslash( $_POST['audience'] ?? '' ) ) );
+
 		$this->questions->insert(
 			new Question(
-				offeringId: null === $offering ? null : (int) $offering->id,
+				offeringId:      $accountScope ? null : (int) $offering->id,
 				label:           $label,
 				fieldType:       $fieldType,
 				options:         $this->parseOptions( sanitize_textarea_field( Val::string( wp_unslash( $_POST['options'] ?? '' ) ) ) ),
 				isRequired:      isset( $_POST['is_required'] ),
 				sortOrder:       absint( Val::int( $_POST['sort_order'] ?? 0 ) ),
-				scope:      null === $offering ? Question::SCOPE_ACCOUNT : Question::SCOPE_OFFERING,
+				scope:           $accountScope ? Question::SCOPE_ACCOUNT : Question::SCOPE_OFFERING,
+				audience:        $accountScope && in_array( $audience, Question::VALID_AUDIENCES, true ) ? $audience : Question::AUDIENCE_ALL,
+				isRequiredChild: $accountScope ? isset( $_POST['is_required_child'] ) : isset( $_POST['is_required'] ),
 			)
 		);
 		// phpcs:enable WordPress.Security.NonceVerification.Missing

src/Registration/QuestionEndpoint.php

@@ -88,14 +88,21 @@ class QuestionEndpoint {
 			return $this->invalid( __( 'Invalid field type.', 'unsupervised-schedular' ) );
 		}
 
+		$isRequired = (bool) $request->get_param( 'is_required' );
+
 		$question = new Question(
 			offeringId:      $offeringId,
 			label:           $label,
 			fieldType:       $fieldType,
 			options:         $this->sanitizeOptions( $request->get_param( 'options' ) ),
-			isRequired: (bool) $request->get_param( 'is_required' ),
+			isRequired:      $isRequired,
 			sortOrder:       Val::int( $request->get_param( 'sort_order' ) ),
 			isActive:        null === $request->get_param( 'is_active' ) ? true : (bool) $request->get_param( 'is_active' ),
+			// An offering asks its questions once, about the student being booked,
+			// so there is no second audience to differ from: the single "required"
+			// stands for both, the same way the upgrade backfill left every
+			// question authored before the two could differ.
+			isRequiredChild: $isRequired,
 		);
 
 		$id = $this->questions->insert( $question );
@@ -129,15 +136,22 @@ class QuestionEndpoint {
 			return $this->invalid( $this->tooLongMessage( __( 'question', 'unsupervised-schedular' ), Question::MAX_LABEL_LENGTH ) );
 		}
 
+		// Only offering-scope questions reach here — an account-scope one has no
+		// offering to own it and is turned away as not found above — so the same
+		// single "required" applies to everyone asked. See create().
+		$isRequired = $request->has_param( 'is_required' ) ? (bool) $request->get_param( 'is_required' ) : $existing->isRequired;
+
 		$question = new Question(
 			offeringId:      $existing->offeringId,
 			label:           $label,
 			fieldType:       $fieldType,
 			options:         $request->has_param( 'options' ) ? $this->sanitizeOptions( $request->get_param( 'options' ) ) : $existing->options,
-			isRequired: $request->has_param( 'is_required' ) ? (bool) $request->get_param( 'is_required' ) : $existing->isRequired,
+			isRequired:      $isRequired,
 			sortOrder:       $request->has_param( 'sort_order' ) ? Val::int( $request->get_param( 'sort_order' ) ) : $existing->sortOrder,
 			isActive:        $request->has_param( 'is_active' ) ? (bool) $request->get_param( 'is_active' ) : $existing->isActive,
 			scope:           $existing->scope,
+			audience:        $existing->audience,
+			isRequiredChild: $isRequired,
 			id:              $id,
 		);
 

src/Registration/QuestionField.php

@@ -0,0 +1,67 @@
+<?php
+declare(strict_types=1);
+
+namespace Unsupervised\Schedular\Registration;
+
+/**
+ * Renders one registration question as a form field. Shared by the signup form
+ * and the guardian's family screen, which ask the same account-scope questions —
+ * once per guardian at signup, and once per child either way.
+ */
+class QuestionField {
+
+	/**
+	 * The field's markup, escaped and ready to echo.
+	 *
+	 * `$name` is the full input name (e.g. `us_answers[7]`), and `$id` the DOM id
+	 * the label points at — both supplied by the caller so the same question can
+	 * appear more than once on a page (one block per child) without colliding.
+	 *
+	 * `$enforceRequired` false keeps the required marker in the label but drops
+	 * the HTML attribute, for a block the browser must not block submission on
+	 * because it may not apply at all — the child blocks, which only count when
+	 * the parent/guardian box is ticked. The server validates those either way.
+	 *
+	 * `$isRequired` overrides which of the question's two required flags applies
+	 * here — a question can be optional for the account holder and required for
+	 * each student they register, and only the caller knows which block this is.
+	 * Null falls back to the question's own {@see Question::$isRequired}.
+	 */
+	public static function render( Question $question, string $name, string $id, bool $enforceRequired = true, ?bool $isRequired = null ): string {
+		$mustAnswer = $isRequired ?? $question->isRequired;
+		$required   = $mustAnswer && $enforceRequired ? ' required' : '';
+
+		$label = '<label for="' . esc_attr( $id ) . '">' . esc_html( $question->label )
+			. ( $mustAnswer ? ' <span class="us-required" aria-hidden="true">*</span>' : '' )
+			. '</label>';
+
+		return '<p>' . $label . self::input( $question, $name, $id, $required ) . '</p>';
+	}
+
+	/**
+	 * The input element itself, chosen by the question's field type. `$required`
+	 * is a literal attribute string (' required' or ''), not user input.
+	 */
+	private static function input( Question $question, string $name, string $id, string $required ): string {
+		$common = ' name="' . esc_attr( $name ) . '" id="' . esc_attr( $id ) . '"' . $required;
+
+		if ( Question::FIELD_TEXTAREA === $question->fieldType ) {
+			return '<textarea' . $common . ' rows="4"></textarea>';
+		}
+
+		if ( Question::FIELD_SELECT === $question->fieldType ) {
+			$options = '<option value="">' . esc_html__( '— Select —', 'unsupervised-schedular' ) . '</option>';
+			foreach ( (array) $question->options as $option ) {
+				$options .= '<option value="' . esc_attr( (string) $option ) . '">' . esc_html( (string) $option ) . '</option>';
+			}
+
+			return '<select' . $common . '>' . $options . '</select>';
+		}
+
+		if ( Question::FIELD_CHECKBOX === $question->fieldType ) {
+			return '<input type="checkbox"' . $common . ' value="1">';
+		}
+
+		return '<input type="text"' . $common . '>';
+	}
+}

src/Registration/QuestionRepository.php

@@ -15,7 +15,7 @@ class QuestionRepository {
 		$this->db->insert(
 			$this->table,
 			$this->columns( $question ) + [ 'created_at' => current_time( 'mysql' ) ],
-			[ '%d', '%s', '%s', '%s', '%s', '%d', '%d', '%d', '%s' ]
+			[ '%d', '%s', '%s', '%s', '%s', '%s', '%d', '%d', '%d', '%d', '%s' ]
 		);
 
 		return $this->db->insert_id;
@@ -26,7 +26,7 @@ class QuestionRepository {
 			$this->table,
 			$this->columns( $question ),
 			[ 'id' => $id ],
-			[ '%d', '%s', '%s', '%s', '%s', '%d', '%d', '%d' ],
+			[ '%d', '%s', '%s', '%s', '%s', '%s', '%d', '%d', '%d', '%d' ],
 			[ '%d' ]
 		);
 	}
@@ -43,7 +43,9 @@ class QuestionRepository {
 			'label'             => $question->label,
 			'field_type'        => $question->fieldType,
 			'options'           => null === $question->options ? null : (string) wp_json_encode( $question->options ),
+			'audience'          => $question->audience,
 			'is_required'       => $question->isRequired ? 1 : 0,
+			'is_required_child' => $question->isRequiredChild ? 1 : 0,
 			'sort_order'        => $question->sortOrder,
 			'is_active'         => $question->isActive ? 1 : 0,
 		];
@@ -128,4 +130,30 @@ class QuestionRepository {
 
 		return null !== $sql && false !== $this->db->query( $sql );
 	}
+
+	/**
+	 * Give every question authored before students had a required-ness of their
+	 * own the one it used to have.
+	 *
+	 * `is_required_child` arrives with `DEFAULT 0`, so without this a question the
+	 * studio had marked required would quietly stop being required of the students
+	 * a guardian registers — the case it most likely existed for. Copying
+	 * `is_required` across preserves exactly the old behaviour: required of
+	 * everyone, or of nobody.
+	 *
+	 * Run once, guarded by an option in {@see \Unsupervised\Schedular\Plugin::boot()},
+	 * so a question deliberately made optional for students afterwards is not
+	 * quietly made required again.
+	 *
+	 * @return bool True when the statement ran, false if it could not be prepared
+	 *              or the query failed.
+	 */
+	public function backfillChildRequired(): bool {
+		$sql = $this->db->prepare(
+			'UPDATE %i SET is_required_child = 1 WHERE is_required = 1',
+			$this->table
+		);
+
+		return null !== $sql && false !== $this->db->query( $sql );
+	}
 }

src/Registration/RegistrationGate.php

@@ -58,10 +58,14 @@ class RegistrationGate {
 	/**
 	 * Persist answers and policy acceptances for a created registration.
 	 *
+	 * `$acceptedBy` is who actually agreed, when that is not the student — a
+	 * guardian booking for a child. It defaults to 0, read back as "the student
+	 * agreed for themselves".
+	 *
 	 * @param array<int, string> $answers            question_id => answer value
 	 * @param list<int>          $acceptedVersionIds Accepted policy version IDs
 	 */
-	public function record( string $registrationType, int $registrationId, int $studentId, int $offeringId, array $answers, array $acceptedVersionIds, ?string $ipAddress = null ): void {
+	public function record( string $registrationType, int $registrationId, int $studentId, int $offeringId, array $answers, array $acceptedVersionIds, ?string $ipAddress = null, int $acceptedBy = 0 ): void {
 		foreach ( $this->questions->findByOffering( $offeringId, true ) as $question ) {
 			$value = (string) ( $answers[ (int) $question->id ] ?? '' );
 			if ( '' === $value ) {
@@ -90,6 +94,7 @@ class RegistrationGate {
 					studentId:        $studentId,
 					registrationType: $registrationType,
 					registrationId:   $registrationId,
+					acceptedBy:       $acceptedBy > 0 ? $acceptedBy : $studentId,
 					ipAddress:        $ipAddress,
 				)
 			);

src/RestRegistrar.php

@@ -5,12 +5,15 @@ namespace Unsupervised\Schedular;
 
 use Unsupervised\Schedular\Availability\AvailabilityEndpoint;
 use Unsupervised\Schedular\Availability\AvailabilityRepository;
+use Unsupervised\Schedular\Availability\WindowValidator;
 use Unsupervised\Schedular\Booking\BookingEndpoint;
 use Unsupervised\Schedular\Booking\BookingRepository;
 use Unsupervised\Schedular\Booking\CancellationPolicy;
 use Unsupervised\Schedular\GroupClass\EnrollmentEndpoint;
 use Unsupervised\Schedular\GroupClass\GroupAccessRepository;
 use Unsupervised\Schedular\GroupClass\EnrollmentRepository;
+use Unsupervised\Schedular\GroupClass\SessionSchedule;
+use Unsupervised\Schedular\Guardian\GuardianService;
 use Unsupervised\Schedular\Offering\OfferingEndpoint;
 use Unsupervised\Schedular\Offering\OfferingRepository;
 use Unsupervised\Schedular\Payment\PaymentEndpoint;
@@ -36,13 +39,13 @@ class RestRegistrar {
 	private EnrollmentEndpoint $enrollmentEndpoint;
 	private PaymentEndpoint $paymentEndpoint;
 
-	public function __construct( AvailabilityRepository $availability, BookingRepository $bookings, OfferingRepository $offerings, QuestionRepository $questions, PolicyRepository $policies, PolicyVersionRepository $policyVersions, PolicyService $policyService, RegistrationGate $gate, EnrollmentRepository $enrollments, GroupAccessRepository $groupAccess, PaymentService $paymentService ) {
-		$this->availabilityEndpoint = new AvailabilityEndpoint( $availability, $offerings );
-		$this->bookingEndpoint      = new BookingEndpoint( $availability, $bookings, $offerings, $gate, $paymentService, new CancellationPolicy( new StudioSettings() ) );
+	public function __construct( AvailabilityRepository $availability, BookingRepository $bookings, OfferingRepository $offerings, QuestionRepository $questions, PolicyRepository $policies, PolicyVersionRepository $policyVersions, PolicyService $policyService, RegistrationGate $gate, EnrollmentRepository $enrollments, GroupAccessRepository $groupAccess, PaymentService $paymentService, GuardianService $guardians ) {
+		$this->availabilityEndpoint = new AvailabilityEndpoint( $availability, new WindowValidator( $offerings ) );
+		$this->bookingEndpoint      = new BookingEndpoint( $availability, $bookings, $offerings, $gate, $paymentService, new CancellationPolicy( new StudioSettings() ), $guardians, new SessionSchedule( $enrollments, $offerings ) );
 		$this->offeringEndpoint     = new OfferingEndpoint( $offerings, $groupAccess );
 		$this->questionEndpoint     = new QuestionEndpoint( $questions, $offerings );
 		$this->policyEndpoint       = new PolicyEndpoint( $policies, $policyVersions, $policyService );
-		$this->enrollmentEndpoint   = new EnrollmentEndpoint( $enrollments, $offerings, $gate, $paymentService, $groupAccess );
+		$this->enrollmentEndpoint   = new EnrollmentEndpoint( $enrollments, $offerings, $gate, $paymentService, $groupAccess, $guardians );
 		$this->paymentEndpoint      = new PaymentEndpoint( $paymentService );
 	}
 

src/Schema.php

@@ -85,7 +85,9 @@ class Schema {
                 label       VARCHAR(255)    NOT NULL,
                 field_type  VARCHAR(20)     NOT NULL DEFAULT 'text',
                 options     TEXT,
+                audience    VARCHAR(20)     NOT NULL DEFAULT 'all',
                 is_required TINYINT(1)      NOT NULL DEFAULT 0,
+                is_required_child TINYINT(1) NOT NULL DEFAULT 0,
                 sort_order  INT             NOT NULL DEFAULT 0,
                 is_active   TINYINT(1)      NOT NULL DEFAULT 1,
                 created_at  DATETIME        NOT NULL,
@@ -138,6 +140,7 @@ class Schema {
                 id                BIGINT UNSIGNED NOT NULL AUTO_INCREMENT,
                 policy_version_id BIGINT UNSIGNED NOT NULL,
                 student_id        BIGINT UNSIGNED NOT NULL,
+                accepted_by       BIGINT UNSIGNED NOT NULL DEFAULT 0,
                 registration_type VARCHAR(20)     NOT NULL,
                 registration_id   BIGINT UNSIGNED NOT NULL,
                 accepted_at       DATETIME        NOT NULL,
@@ -145,12 +148,14 @@ class Schema {
                 PRIMARY KEY (id),
                 KEY policy_version_id (policy_version_id),
                 KEY student_id (student_id),
+                KEY accepted_by (accepted_by),
                 KEY registration (registration_type, registration_id)
             ) {$charset};",
 
 			"CREATE TABLE {$prefix}us_payments (
                 id                       BIGINT UNSIGNED NOT NULL AUTO_INCREMENT,
                 student_id               BIGINT UNSIGNED NOT NULL,
+                payer_id                 BIGINT UNSIGNED NOT NULL DEFAULT 0,
                 instructor_id            BIGINT UNSIGNED NOT NULL,
                 registration_type        VARCHAR(20)     NOT NULL,
                 registration_id          BIGINT UNSIGNED NOT NULL,
@@ -172,6 +177,7 @@ class Schema {
                 paid_at                  DATETIME        DEFAULT NULL,
                 PRIMARY KEY (id),
                 KEY student_id (student_id),
+                KEY payer_id (payer_id),
                 KEY instructor_id (instructor_id),
                 KEY registration (registration_type, registration_id),
                 KEY status (status)
@@ -180,6 +186,7 @@ class Schema {
 			"CREATE TABLE {$prefix}us_credits (
                 id                BIGINT UNSIGNED NOT NULL AUTO_INCREMENT,
                 student_id        BIGINT UNSIGNED NOT NULL,
+                payer_id          BIGINT UNSIGNED NOT NULL DEFAULT 0,
                 amount            DECIMAL(10,2)   NOT NULL DEFAULT 0,
                 remaining         DECIMAL(10,2)   NOT NULL DEFAULT 0,
                 currency          VARCHAR(3)      NOT NULL DEFAULT 'CAD',
@@ -191,6 +198,7 @@ class Schema {
                 updated_at        DATETIME        DEFAULT NULL,
                 PRIMARY KEY (id),
                 KEY student_id (student_id),
+                KEY payer_id (payer_id),
                 KEY status (status),
                 KEY source_lesson_id (source_lesson_id)
             ) {$charset};",
@@ -229,6 +237,21 @@ class Schema {
                 KEY status (status)
             ) {$charset};",
 
+			// Links a parent/guardian account to a child who books through it. The
+			// child is a real (login-less) wp_users row, so student_id keeps meaning
+			// "a WordPress user" on every other table.
+			"CREATE TABLE {$prefix}us_guardians (
+                id           BIGINT UNSIGNED NOT NULL AUTO_INCREMENT,
+                guardian_id  BIGINT UNSIGNED NOT NULL,
+                student_id   BIGINT UNSIGNED NOT NULL,
+                relationship VARCHAR(50)     NOT NULL DEFAULT '',
+                created_at   DATETIME        NOT NULL,
+                PRIMARY KEY (id),
+                UNIQUE KEY guardian_student (guardian_id, student_id),
+                KEY guardian_id (guardian_id),
+                KEY student_id (student_id)
+            ) {$charset};",
+
 			"CREATE TABLE {$prefix}us_group_access (
                 id            BIGINT UNSIGNED NOT NULL AUTO_INCREMENT,
                 offering_id   BIGINT UNSIGNED NOT NULL,

src/ShortcodeRegistrar.php

@@ -3,10 +3,12 @@ declare(strict_types=1);
 
 namespace Unsupervised\Schedular;
 
+use Unsupervised\Schedular\Auth\AccountPage;
 use Unsupervised\Schedular\Auth\LoginPage;
 use Unsupervised\Schedular\Auth\RegistrationPage;
 use Unsupervised\Schedular\Booking\BookingPage;
 use Unsupervised\Schedular\GroupClass\GroupClassPage;
+use Unsupervised\Schedular\Guardian\FamilyPage;
 use Unsupervised\Schedular\Payment\StudioSettings;
 
 class ShortcodeRegistrar {
@@ -16,6 +18,8 @@ class ShortcodeRegistrar {
 		private LoginPage $loginPage,
 		private RegistrationPage $registrationPage,
 		private GroupClassPage $groupClassPage,
+		private FamilyPage $familyPage,
+		private AccountPage $accountPage,
 	) {}
 
 	public function register(): void {
@@ -23,10 +27,15 @@ class ShortcodeRegistrar {
 		add_shortcode( 'us_student_login', self::shortcode( [ $this->loginPage, 'render' ] ) );
 		add_shortcode( 'us_student_register', self::shortcode( [ $this->registrationPage, 'render' ] ) );
 		add_shortcode( 'us_group_classes', self::shortcode( [ $this->groupClassPage, 'render' ] ) );
+		add_shortcode( 'us_family', self::shortcode( [ $this->familyPage, 'render' ] ) );
+		add_shortcode( 'us_account', self::shortcode( [ $this->accountPage, 'render' ] ) );
 		// Process registration submissions before output so the invite branch's
 		// auth cookie is actually sent (render() runs too late, during the_content).
 		add_action( 'template_redirect', [ $this->registrationPage, 'maybeHandleSubmit' ] );
 		add_action( 'template_redirect', [ $this->registrationPage, 'maybeRedirectToRegistrationPage' ] );
+		// Same reason as registration: the family form redirects after handling,
+		// which render() (running during the_content) is too late to do.
+		add_action( 'template_redirect', [ $this->familyPage, 'maybeHandleSubmit' ] );
 		add_action( 'wp_enqueue_scripts', [ $this, 'enqueueAssets' ] );
 	}
 
@@ -64,16 +73,39 @@ class ShortcodeRegistrar {
 			'nonce'       => wp_create_nonce( 'wp_rest' ),
 			'stripeKey'   => $settings->publishableKey(),
 			'startOfWeek' => Val::int( get_option( 'start_of_week', 1 ) ),
+			// The studio HST rate, so a price quoted to a student on the way in
+			// matches the total they are actually billed.
+			'taxRate'     => $settings->hstRate(),
 		];
 
 		// Attach the shared config to the payment helper so it is defined before the
 		// booking/group scripts (which depend on it) run.
 		wp_localize_script( 'us-scheduler-payment', 'usScheduler', $data );
 
-		wp_register_script( 'us-scheduler', USC_PLUGIN_URL . 'assets/js/booking.js', [ 'us-scheduler-payment' ], USC_VERSION, true );
-		wp_register_script( 'us-scheduler-group', USC_PLUGIN_URL . 'assets/js/group-classes.js', [ 'us-scheduler-payment' ], USC_VERSION, true );
+		// Price formatting and the pay agreement, shared by booking and enrolment.
+		wp_register_script( 'us-scheduler-pricing', USC_PLUGIN_URL . 'assets/js/pricing.js', [ 'us-scheduler-payment' ], USC_VERSION, true );
 
-		// Progressive enhancement for the two-step registration form (no dependencies).
-		wp_register_script( 'us-scheduler-register', USC_PLUGIN_URL . 'assets/js/register.js', [], USC_VERSION, true );
+		// The "who is this for?" picker, shared by booking and enrolment.
+		wp_register_script( 'us-scheduler-guardian', USC_PLUGIN_URL . 'assets/js/guardian.js', [], USC_VERSION, true );
+
+		wp_register_script( 'us-scheduler', USC_PLUGIN_URL . 'assets/js/booking.js', [ 'us-scheduler-pricing', 'us-scheduler-guardian' ], USC_VERSION, true );
+		wp_register_script( 'us-scheduler-group', USC_PLUGIN_URL . 'assets/js/group-classes.js', [ 'us-scheduler-pricing', 'us-scheduler-guardian' ], USC_VERSION, true );
+
+		/*
+		 * Progressive enhancement for the registration form.
+		 *
+		 * `password-strength-meter` is WordPress's own wrapper around zxcvbn, so
+		 * the signup form scores a password exactly the way wp-admin does rather
+		 * than inventing a second opinion. It pulls in `zxcvbn-async`, which
+		 * fetches the (large) dictionary only once the page has loaded — hence
+		 * the guard in register.js for the window where it is not there yet.
+		 */
+		wp_register_script(
+			'us-scheduler-register',
+			USC_PLUGIN_URL . 'assets/js/register.js',
+			[ 'password-strength-meter' ],
+			USC_VERSION,
+			true
+		);
 	}
 }

templates/admin/availability.php

@@ -13,8 +13,12 @@ if (! defined('ABSPATH')) {
  * @var list<array{date: string, slots: list<\Unsupervised\Schedular\Availability\AvailabilitySlot>}> $weekDays
  * @var string $prevWeek
  * @var string $nextWeek
+ * @var string $notice Success message from the submitted action; empty when none.
+ * @var string $error  Failure message from the submitted action; empty when none.
  */
 
+use Unsupervised\Schedular\Availability\AvailabilitySlot;
+
 $baseUrl = admin_url('admin.php?page=us-availability');
 
 $deleteForm = static function (\Unsupervised\Schedular\Availability\AvailabilitySlot $slot): void {
@@ -33,9 +37,16 @@ $deleteForm = static function (\Unsupervised\Schedular\Availability\Availability
 <div class="wrap">
     <h1><?php esc_html_e('My Availability', 'unsupervised-schedular'); ?></h1>
 
+    <?php if ('' !== $notice) : ?>
+        <div class="notice notice-success is-dismissible"><p><?php echo esc_html($notice); ?></p></div>
+    <?php endif; ?>
+    <?php if ('' !== $error) : ?>
+        <div class="notice notice-error is-dismissible"><p><?php echo esc_html($error); ?></p></div>
+    <?php endif; ?>
+
     <h2><?php esc_html_e('Add Availability', 'unsupervised-schedular'); ?></h2>
     <p><?php esc_html_e('The window must start and end on the same day. It is split into bookable slots of the chosen lesson length — for example, 9:00 AM–4:00 PM with 60-minute lessons creates seven slots.', 'unsupervised-schedular'); ?></p>
-    <form method="post">
+    <form method="post" id="usc-add-availability">
         <?php wp_nonce_field('usc_availability_action'); ?>
         <input type="hidden" name="usc_action" value="add">
         <table class="form-table">
@@ -51,9 +62,20 @@ $deleteForm = static function (\Unsupervised\Schedular\Availability\Availability
                 <th><label for="duration_minutes"><?php esc_html_e('Lesson length (minutes)', 'unsupervised-schedular'); ?></label></th>
                 <td>
                     <select name="duration_minutes" id="duration_minutes">
-                        <option value="30">30</option>
-                        <option value="60" selected>60</option>
+                        <?php foreach (AvailabilitySlot::DURATION_CHOICES as $choice) : ?>
+                            <option value="<?php echo esc_attr((string) $choice); ?>" <?php selected($choice, AvailabilitySlot::DEFAULT_DURATION_MINUTES); ?>>
+                                <?php echo esc_html((string) $choice); ?>
+                            </option>
+                        <?php endforeach; ?>
                     </select>
+                    <?php
+                    // Filled and revealed by availability-admin.js when the entered
+                    // window is too short for every lesson length. The wording lives
+                    // here so it stays translatable.
+                    ?>
+                    <p class="description usc-duration-warning" id="usc-duration-warning" hidden>
+                        <?php esc_html_e('This window is too short for any lesson length. Lengthen the window or it cannot be saved.', 'unsupervised-schedular'); ?>
+                    </p>
                 </td>
             </tr>
             <tr>
@@ -73,7 +95,7 @@ $deleteForm = static function (\Unsupervised\Schedular\Availability\Availability
                     <label><input type="radio" name="recurrence" value="single" checked> <?php esc_html_e('One-off', 'unsupervised-schedular'); ?></label>
                     &nbsp;
                     <label><input type="radio" name="recurrence" value="weekly"> <?php esc_html_e('Weekly for', 'unsupervised-schedular'); ?></label>
-                    <input type="number" name="weeks" min="1" max="52" value="12" style="width:5em;"> <?php esc_html_e('weeks', 'unsupervised-schedular'); ?>
+                    <input type="number" name="weeks" min="1" max="<?php echo esc_attr((string) AvailabilitySlot::MAX_WEEKLY_OCCURRENCES); ?>" value="12" style="width:5em;"> <?php esc_html_e('weeks', 'unsupervised-schedular'); ?>
                 </td>
             </tr>
         </table>

templates/admin/policies.php

@@ -12,11 +12,17 @@ if (! defined('ABSPATH')) {
  * @var list<\Unsupervised\Schedular\Policy\Policy>        $policyList
  * @var \Unsupervised\Schedular\Policy\Policy|null         $selectedPolicy
  * @var list<\Unsupervised\Schedular\Policy\PolicyVersion>|null $policyVersions
+ * @var \Unsupervised\Schedular\Policy\PolicyVersion|null  $viewedVersion  Version opened in the viewer, if any.
+ * @var string                                            $notice         Status message from the last save.
  */
 ?>
 <div class="wrap">
     <h1><?php esc_html_e('Policies', 'unsupervised-schedular'); ?></h1>
 
+    <?php if ('' !== $notice) : ?>
+        <div class="notice notice-success is-dismissible"><p><?php echo esc_html($notice); ?></p></div>
+    <?php endif; ?>
+
     <h2><?php esc_html_e('Add Policy', 'unsupervised-schedular'); ?></h2>
     <form method="post">
         <?php wp_nonce_field('usc_policy_action'); ?>
@@ -64,6 +70,22 @@ if (! defined('ABSPATH')) {
     <?php if (null !== $selectedPolicy) : ?>
         <h2><?php echo esc_html(sprintf(/* translators: %s: policy title */ __('Versions of "%s"', 'unsupervised-schedular'), $selectedPolicy->title)); ?></h2>
 
+        <h3><?php esc_html_e('Rename', 'unsupervised-schedular'); ?></h3>
+        <p class="description">
+            <?php
+            /* translators: %s: the policy's slug. */
+            echo esc_html(sprintf(__('The title is what students see above the policy text. Its slug (%s) does not change, so every version already accepted stays attached to this policy.', 'unsupervised-schedular'), $selectedPolicy->slug));
+            ?>
+        </p>
+        <form method="post">
+            <?php wp_nonce_field('usc_policy_action'); ?>
+            <input type="hidden" name="usc_action" value="rename_policy">
+            <input type="hidden" name="policy_id" value="<?php echo esc_attr((string) $selectedPolicy->id); ?>">
+            <label class="screen-reader-text" for="usc-policy-title"><?php esc_html_e('Title', 'unsupervised-schedular'); ?></label>
+            <input type="text" name="title" id="usc-policy-title" class="regular-text" maxlength="<?php echo esc_attr((string) Policy::MAX_TITLE_LENGTH); ?>" value="<?php echo esc_attr($selectedPolicy->title); ?>" required>
+            <?php submit_button(esc_html__('Save Title', 'unsupervised-schedular'), 'secondary', 'submit', false); ?>
+        </form>
+
         <h3><?php esc_html_e('Add Draft Version', 'unsupervised-schedular'); ?></h3>
         <form method="post">
             <?php wp_nonce_field('usc_policy_action'); ?>
@@ -98,6 +120,18 @@ if (! defined('ABSPATH')) {
                             <td><?php echo esc_html($version->status); ?></td>
                             <td><?php echo $version->publishedAt ? esc_html($version->publishedAt) : '&mdash;'; ?></td>
                             <td>
+                                <a href="<?php echo esc_url(
+                                    add_query_arg(
+                                        [
+                                            'page'      => 'us-policies',
+                                            'policy_id' => (string) $selectedPolicy->id,
+                                            'version_id' => (string) $version->id,
+                                        ],
+                                        admin_url('admin.php')
+                                    )
+                                ); ?>" class="button button-small">
+                                    <?php esc_html_e('View', 'unsupervised-schedular'); ?>
+                                </a>
                                 <?php if (PolicyVersion::STATUS_PUBLISHED !== $version->status) : ?>
                                     <form method="post" style="display:inline;">
                                         <?php wp_nonce_field('usc_policy_action'); ?>
@@ -117,5 +151,48 @@ if (! defined('ABSPATH')) {
                 </tbody>
             </table>
         <?php endif; ?>
+
+        <?php if (null !== $viewedVersion) : ?>
+            <hr>
+            <h3>
+                <?php echo esc_html(sprintf(
+                    /* translators: 1: version number, 2: version status. */
+                    __('Version %1$d (%2$s)', 'unsupervised-schedular'),
+                    $viewedVersion->versionNumber,
+                    $viewedVersion->status
+                )); ?>
+            </h3>
+
+            <?php // Rendered exactly as the booking and signup gates render it, so this doubles as a preview. ?>
+            <div class="us-policy-version-body" style="background:#fff;border:1px solid #c3c4c7;padding:0 1em;max-width:50em;overflow-wrap:break-word;">
+                <?php echo wp_kses_post($viewedVersion->bodyHtml()); ?>
+            </div>
+
+            <?php $editingDraft = PolicyVersion::STATUS_DRAFT === $viewedVersion->status; ?>
+            <h4><?php esc_html_e('Edit', 'unsupervised-schedular'); ?></h4>
+            <p class="description">
+                <?php
+                echo esc_html(
+                    $editingDraft
+                        ? __('This version is still a draft, so your changes are saved to it directly.', 'unsupervised-schedular')
+                        : __('This version has been published, so saving an edit creates a new draft version from this text and leaves the published one untouched.', 'unsupervised-schedular')
+                );
+                ?>
+            </p>
+            <form method="post">
+                <?php wp_nonce_field('usc_policy_action'); ?>
+                <input type="hidden" name="usc_action" value="edit_version">
+                <input type="hidden" name="policy_id" value="<?php echo esc_attr((string) $selectedPolicy->id); ?>">
+                <input type="hidden" name="version_id" value="<?php echo esc_attr((string) $viewedVersion->id); ?>">
+                <textarea name="body" rows="12" class="large-text"><?php echo esc_textarea((string) $viewedVersion->body); ?></textarea>
+                <?php
+                submit_button(
+                    $editingDraft
+                        ? esc_html__('Save Draft', 'unsupervised-schedular')
+                        : esc_html__('Save as New Draft', 'unsupervised-schedular')
+                );
+                ?>
+            </form>
+        <?php endif; ?>
     <?php endif; ?>
 </div>

templates/admin/questions.php

@@ -41,7 +41,7 @@ if (! defined('ABSPATH')) {
     <?php else : ?>
         <?php if ($accountScope) : ?>
             <h2><?php esc_html_e('Account signup questions', 'unsupervised-schedular'); ?></h2>
-            <p><?php esc_html_e('Every new student answers these required-if-marked questions as a second step after choosing their name and password.', 'unsupervised-schedular'); ?></p>
+            <p><?php esc_html_e('Every new student answers these questions when they register — the account holder on the signup form itself, and once per student they are registering on behalf of. Each question says who it is asked of, and can be required of the account holder, of the students, or of both.', 'unsupervised-schedular'); ?></p>
         <?php else : ?>
             <h2><?php echo esc_html(sprintf(/* translators: %s: offering title */ __('Questions for "%s"', 'unsupervised-schedular'), $selectedOffering->title)); ?></h2>
         <?php endif; ?>
@@ -76,10 +76,31 @@ if (! defined('ABSPATH')) {
                     <th><label for="sort_order"><?php esc_html_e('Sort order', 'unsupervised-schedular'); ?></label></th>
                     <td><input type="number" name="sort_order" id="sort_order" min="0" step="1" value="0"></td>
                 </tr>
+                <?php if ($accountScope) : ?>
+                    <tr>
+                        <th><label for="audience"><?php esc_html_e('Asked of', 'unsupervised-schedular'); ?></label></th>
+                        <td>
+                            <select name="audience" id="audience">
+                                <option value="<?php echo esc_attr(Question::AUDIENCE_ALL); ?>"><?php esc_html_e('Everyone registering', 'unsupervised-schedular'); ?></option>
+                                <option value="<?php echo esc_attr(Question::AUDIENCE_CHILD); ?>"><?php esc_html_e('Students only — not the account holder', 'unsupervised-schedular'); ?></option>
+                            </select>
+                            <p class="description"><?php esc_html_e('"Students only" leaves the question off the account holder\'s own section, for anything that only makes sense about a student someone is registering on behalf of.', 'unsupervised-schedular'); ?></p>
+                        </td>
+                    </tr>
+                    <tr>
+                        <th><?php esc_html_e('Required', 'unsupervised-schedular'); ?></th>
+                        <td>
+                            <label><input type="checkbox" name="is_required" value="1"> <?php esc_html_e('The account holder must answer for themselves', 'unsupervised-schedular'); ?></label><br>
+                            <label><input type="checkbox" name="is_required_child" value="1"> <?php esc_html_e('Each student they register must answer', 'unsupervised-schedular'); ?></label>
+                            <p class="description"><?php esc_html_e('Tick either, both, or neither — a question can be optional for an adult signing themselves up and still required for every student they enrol.', 'unsupervised-schedular'); ?></p>
+                        </td>
+                    </tr>
+                <?php else : ?>
                     <tr>
                         <th><?php esc_html_e('Required', 'unsupervised-schedular'); ?></th>
                         <td><label><input type="checkbox" name="is_required" value="1"> <?php esc_html_e('Registrant must answer', 'unsupervised-schedular'); ?></label></td>
                     </tr>
+                <?php endif; ?>
             </table>
             <?php submit_button(esc_html__('Add Question', 'unsupervised-schedular')); ?>
         </form>
@@ -94,7 +115,12 @@ if (! defined('ABSPATH')) {
                         <th><?php esc_html_e('Order', 'unsupervised-schedular'); ?></th>
                         <th><?php esc_html_e('Question', 'unsupervised-schedular'); ?></th>
                         <th><?php esc_html_e('Type', 'unsupervised-schedular'); ?></th>
+                        <?php if ($accountScope) : ?>
+                            <th><?php esc_html_e('Asked of', 'unsupervised-schedular'); ?></th>
+                            <th><?php esc_html_e('Required of', 'unsupervised-schedular'); ?></th>
+                        <?php else : ?>
                             <th><?php esc_html_e('Required', 'unsupervised-schedular'); ?></th>
+                        <?php endif; ?>
                         <th><?php esc_html_e('Actions', 'unsupervised-schedular'); ?></th>
                     </tr>
                 </thead>
@@ -104,7 +130,32 @@ if (! defined('ABSPATH')) {
                             <td><?php echo esc_html((string) $question->sortOrder); ?></td>
                             <td><?php echo esc_html($question->label); ?></td>
                             <td><?php echo esc_html($question->fieldType); ?></td>
+                            <?php if ($accountScope) : ?>
+                                <td>
+                                    <?php
+                                    echo $question->askedOfSelf()
+                                        ? esc_html__('Everyone', 'unsupervised-schedular')
+                                        : esc_html__('Students only', 'unsupervised-schedular');
+                                    ?>
+                                </td>
+                                <td>
+                                    <?php
+                                    // Named rather than two ticks, so "required of the
+                                    // students but not of you" reads as the deliberate
+                                    // setting it is rather than as a half-filled row.
+                                    $requiredOf = [];
+                                    if ($question->isRequiredForSelf()) {
+                                        $requiredOf[] = __('account holder', 'unsupervised-schedular');
+                                    }
+                                    if ($question->isRequiredForChild()) {
+                                        $requiredOf[] = __('students', 'unsupervised-schedular');
+                                    }
+                                    echo esc_html([] === $requiredOf ? __('—', 'unsupervised-schedular') : implode(', ', $requiredOf));
+                                    ?>
+                                </td>
+                            <?php else : ?>
                                 <td><?php echo $question->isRequired ? esc_html__('Yes', 'unsupervised-schedular') : esc_html__('No', 'unsupervised-schedular'); ?></td>
+                            <?php endif; ?>
                             <td>
                                 <form method="post" style="display:inline;">
                                     <?php wp_nonce_field('usc_question_action'); ?>

templates/admin/student-detail.php

@@ -5,18 +5,24 @@ if (! defined('ABSPATH')) {
     exit;
 }
 
+use Unsupervised\Schedular\GroupClass\SessionSchedule;
+
 /**
  * @var \WP_User $student
- * @var list<array{id: int, start_dt: string, end_dt: string, offering: string, instructor: string, status: string}> $upcoming
- * @var list<array{id: int, start_dt: string, end_dt: string, offering: string, instructor: string, status: string}> $past
+ * @var list<array{id: int, kind: string, schedule: string|null, start_dt: string, end_dt: string, offering: string, instructor: string, status: string}> $upcoming Booked lessons and upcoming group-class sessions, soonest first. `schedule` is wording to show instead of a date, for a class with no class time set.
+ * @var list<array{id: int, kind: string, schedule: string|null, start_dt: string, end_dt: string, offering: string, instructor: string, status: string}> $past
  * @var list<array{id: int, offering: string, status: string}> $enrolments
  * @var list<array{policy: string, version: string, context: string, accepted_at: string}> $acceptances
  * @var list<array{question: string, answer: string, required: bool}> $registrationInfo
  * @var list<array{question: string, answer: string, context: string}> $intake
  * @var list<array{created_at: string, context: string, method: string, status: string, amount: float, tax_amount: float, total: float, currency: string, receipt: string}> $payments
  * @var list<array{created_at: string, amount: float, remaining: float, currency: string, reason: string, status: string}> $credits
- * @var float  $creditBalance
+ * @var float  $creditBalance Balance of the account that settles this student's charges — the guardian's for a child.
  * @var string $creditCurrency
+ * @var array{id: int, name: string, email: string}|null $guardian The parent/guardian who books for this student, or null when they book for themselves.
+ * @var list<array{id: int, name: string, birth_year: string, relationship: string}> $children Children this student books for.
+ * @var array{id: int, name: string, email: string} $payer Who is billed for this student — themselves, or their guardian.
+ * @var string $pageSlug
  * @var string $backUrl
  * @var bool   $canBilling
  * @var string $billingOverride
@@ -45,14 +51,38 @@ $renderLessons = static function (array $rows, bool $withActions = false): void
         </thead>
         <tbody>
             <?php foreach ($rows as $row) : ?>
+                <?php $isGroupSession = ($row['kind'] ?? 'lesson') === SessionSchedule::KIND; ?>
                 <tr>
-                    <td><?php echo esc_html($row['start_dt'] !== '' ? (string) mysql2date('M j, Y g:i A', $row['start_dt']) : '—'); ?></td>
-                    <td><?php echo esc_html($row['offering']); ?></td>
+                    <td>
+                        <?php
+                        // A class with no class time set has no clock to put it on,
+                        // so it carries wording ("Tuesdays 4:00pm", or its term
+                        // dates) that stands in for the date entirely.
+                        if (($row['schedule'] ?? null) !== null && $row['schedule'] !== '') {
+                            echo esc_html((string) $row['schedule']);
+                        } else {
+                            echo esc_html($row['start_dt'] !== '' ? (string) mysql2date('M j, Y g:i A', $row['start_dt']) : '—');
+                        }
+                        ?>
+                    </td>
+                    <td>
+                        <?php echo esc_html($row['offering']); ?>
+                        <?php if ($isGroupSession) : ?>
+                            <span class="description">— <?php esc_html_e('group class', 'unsupervised-schedular'); ?></span>
+                        <?php endif; ?>
+                    </td>
                     <td><?php echo esc_html($row['instructor']); ?></td>
                     <td><?php echo esc_html($row['status']); ?></td>
                     <?php if ($withActions) : ?>
                         <td>
-                            <?php if ($row['status'] !== 'cancelled') : ?>
+                            <?php
+                            /*
+                             * A group-class session is one date in a term, not a booked
+                             * slot: there is nothing to cancel session by session. The
+                             * whole enrolment is withdrawn from the table below.
+                             */
+                            ?>
+                            <?php if (! $isGroupSession && $row['status'] !== 'cancelled') : ?>
                                 <form method="post" style="display:inline">
                                     <?php wp_nonce_field('usc_student_actions'); ?>
                                     <input type="hidden" name="usc_action" value="cancel_lesson">
@@ -84,6 +114,8 @@ $renderLessons = static function (array $rows, bool $withActions = false): void
         <div class="notice notice-error is-dismissible"><p><?php echo esc_html($error); ?></p></div>
     <?php endif; ?>
 
+    <?php $detailUrl = static fn(int $id): string => add_query_arg(['page' => $pageSlug, 'student_id' => $id], admin_url('admin.php')); ?>
+
     <h2><?php esc_html_e('Account', 'unsupervised-schedular'); ?></h2>
     <form method="post">
         <?php wp_nonce_field('usc_student_actions'); ?>
@@ -101,10 +133,49 @@ $renderLessons = static function (array $rows, bool $withActions = false): void
                 <th><?php esc_html_e('Registered', 'unsupervised-schedular'); ?></th>
                 <td><?php echo esc_html($student->user_registered); ?></td>
             </tr>
+            <?php
+            /*
+             * Always rendered, both ways round. "Books for themselves" is a fact
+             * worth stating outright: an empty row would be indistinguishable
+             * from a guardian the page failed to look up.
+             */
+            ?>
+            <tr>
+                <th><?php esc_html_e('Booked by', 'unsupervised-schedular'); ?></th>
+                <td>
+                    <?php if ($guardian !== null) : ?>
+                        <?php // The name alone. Their address is one click away on their own page, and repeating it here only makes the row harder to scan. ?>
+                        <a href="<?php echo esc_url($detailUrl($guardian['id'])); ?>"><?php echo esc_html($guardian['name']); ?></a>
+                    <?php else : ?>
+                        <span class="description"><?php esc_html_e('Nobody — this student books and pays for themselves.', 'unsupervised-schedular'); ?></span>
+                    <?php endif; ?>
+                </td>
+            </tr>
         </table>
         <?php submit_button(esc_html__('Save account details', 'unsupervised-schedular'), 'secondary', 'submit', false); ?>
     </form>
 
+    <?php if ($guardian !== null || ! empty($children)) : ?>
+        <h2><?php esc_html_e('Profile', 'unsupervised-schedular'); ?></h2>
+        <?php if ($guardian !== null) : ?>
+            <?php // Who they book through is up in Account; this explains the placeholder email. ?>
+            <p class="description"><?php esc_html_e('This is a managed student account: it has no login of its own, and its email address is a placeholder that cannot receive mail.', 'unsupervised-schedular'); ?></p>
+        <?php endif; ?>
+        <?php if (! empty($children)) : ?>
+            <p><?php esc_html_e('Books and pays for:', 'unsupervised-schedular'); ?></p>
+            <ul class="ul-disc">
+                <?php foreach ($children as $child) : ?>
+                    <li>
+                        <a href="<?php echo esc_url($detailUrl($child['id'])); ?>"><?php echo esc_html($child['name']); ?></a>
+                        <?php if ($child['birth_year'] !== '') : ?>
+                            <span class="description"><?php echo esc_html($child['birth_year']); ?></span>
+                        <?php endif; ?>
+                    </li>
+                <?php endforeach; ?>
+            </ul>
+        <?php endif; ?>
+    <?php endif; ?>
+
     <h2><?php esc_html_e('Registration Information', 'unsupervised-schedular'); ?></h2>
     <?php if (empty($registrationInfo)) : ?>
         <p><?php esc_html_e('No registration questions are configured.', 'unsupervised-schedular'); ?></p>
@@ -253,6 +324,17 @@ $renderLessons = static function (array $rows, bool $withActions = false): void
                 '<strong>' . esc_html(number_format_i18n($creditBalance, 2) . ' ' . $creditCurrency) . '</strong>'
             );
             ?>
+            <?php if ($payer['id'] !== (int) $student->ID) : ?>
+                <span class="description">
+                    <?php
+                    printf(
+                        /* translators: %s: name of the parent/guardian whose account holds the balance. */
+                        esc_html__('Held on %s’s account — the profile shares one balance.', 'unsupervised-schedular'),
+                        esc_html($payer['name'])
+                    );
+                    ?>
+                </span>
+            <?php endif; ?>
             <span class="description"><?php esc_html_e('Credit from cancelled paid lessons is applied automatically to upcoming scheduled billing.', 'unsupervised-schedular'); ?></span>
         </p>
         <?php if (! empty($credits)) : ?>

templates/admin/students.php

@@ -6,9 +6,39 @@ if (! defined('ABSPATH')) {
 }
 
 /**
- * @var list<array{id: int, name: string, email: string, registered: string, upcoming: int, enrolments: int}> $students
+ * @var list<array{id: int, name: string, email: string, registered: string, upcoming: int, enrolments: int, guardian: array{id: int, name: string, email: string}|null, children: list<array{id: int, name: string, birth_year: string, relationship: string}>}> $students
  * @var string $pageSlug
  */
+
+/**
+ * The Family cell: for a child, the guardian who books for them; for a guardian,
+ * the children they book for. Both link to the other person's detail screen so
+ * an admin can move between a family without going back to the list.
+ */
+$familyCell = static function (array $student) use ($pageSlug): string {
+    $link = static fn(int $id, string $name): string => sprintf(
+        '<a href="%s">%s</a>',
+        esc_url(add_query_arg(['page' => $pageSlug, 'student_id' => $id], admin_url('admin.php'))),
+        esc_html($name)
+    );
+
+    if ($student['guardian'] !== null) {
+        return sprintf(
+            /* translators: %s: linked name of the parent/guardian who books for this student. */
+            esc_html__('Managed by %s', 'unsupervised-schedular'),
+            $link($student['guardian']['id'], $student['guardian']['name'])
+        );
+    }
+
+    if ($student['children'] === []) {
+        return '—';
+    }
+
+    return implode(', ', array_map(
+        static fn(array $child): string => $link($child['id'], $child['name']),
+        $student['children']
+    ));
+};
 ?>
 <div class="wrap">
     <h1><?php esc_html_e('Students', 'unsupervised-schedular'); ?></h1>
@@ -21,6 +51,7 @@ if (! defined('ABSPATH')) {
                 <tr>
                     <th><?php esc_html_e('Name', 'unsupervised-schedular'); ?></th>
                     <th><?php esc_html_e('Email', 'unsupervised-schedular'); ?></th>
+                    <th><?php esc_html_e('Profile', 'unsupervised-schedular'); ?></th>
                     <th><?php esc_html_e('Registered', 'unsupervised-schedular'); ?></th>
                     <th><?php esc_html_e('Upcoming lessons', 'unsupervised-schedular'); ?></th>
                     <th><?php esc_html_e('Active enrolments', 'unsupervised-schedular'); ?></th>
@@ -32,6 +63,12 @@ if (! defined('ABSPATH')) {
                     <tr>
                         <td><a href="<?php echo esc_url($detailUrl); ?>"><?php echo esc_html($student['name']); ?></a></td>
                         <td><?php echo esc_html($student['email']); ?></td>
+                        <td>
+                            <?php
+                            // phpcs:ignore WordPress.Security.EscapeOutput.OutputNotEscaped -- $familyCell escapes every name and URL it interpolates.
+                            echo $familyCell($student);
+                            ?>
+                        </td>
                         <td><?php echo esc_html($student['registered']); ?></td>
                         <td><?php echo esc_html((string) $student['upcoming']); ?></td>
                         <td><?php echo esc_html((string) $student['enrolments']); ?></td>

templates/frontend/account-page.php

@@ -0,0 +1,25 @@
+<?php
+declare(strict_types=1);
+
+if (! defined('ABSPATH')) {
+    exit;
+}
+
+/**
+ * @var string       $name      Display name of the signed-in visitor.
+ * @var string       $email     Their account email.
+ * @var string       $logoutUrl Nonced sign-out URL, already carrying its redirect.
+ */
+?>
+<div class="us-account">
+    <p class="us-account-who">
+        <span class="us-account-name"><?php echo esc_html($name); ?></span>
+        <?php if ($email !== '') : ?>
+            <span class="us-account-email"><?php echo esc_html($email); ?></span>
+        <?php endif; ?>
+    </p>
+
+    <p class="us-account-actions">
+        <a class="us-account-signout" href="<?php echo esc_url($logoutUrl); ?>"><?php esc_html_e('Sign out', 'unsupervised-schedular'); ?></a>
+    </p>
+</div>

templates/frontend/booking-page.php

@@ -9,18 +9,29 @@ if (! defined('ABSPATH')) {
 /** @var bool $showTypeFilter Whether the "Show Only" lesson-type filter is offered. */
 /** @var bool $showBooking Whether the booking calendar is part of this embed. */
 /** @var bool $showUpcoming Whether the student's upcoming-lessons panel is part of this embed. */
+/** @var list<array{id: int, name: string, is_self: bool}> $students Who this account may book for — children first, the account holder last. */
+
+// The booking script reads the list as JSON rather than rendering a <select>
+// here: the picker belongs inside the booking form it builds, and it is the same
+// list the group-classes script needs.
+$studentsJson = wp_json_encode(array_values($students));
 ?>
-<div id="us-booking-app" data-nonce="<?php echo esc_attr(wp_create_nonce('wp_rest')); ?>"<?php echo $lessonTypeId > 0 ? ' data-lesson-type="' . esc_attr((string) $lessonTypeId) . '"' : ''; ?><?php echo $showTypeFilter ? '' : ' data-type-filter="0"'; ?>>
+<div id="us-booking-app" data-nonce="<?php echo esc_attr(wp_create_nonce('wp_rest')); ?>" data-students="<?php echo esc_attr(is_string($studentsJson) ? $studentsJson : '[]'); ?>"<?php echo $lessonTypeId > 0 ? ' data-lesson-type="' . esc_attr((string) $lessonTypeId) . '"' : ''; ?><?php echo $showTypeFilter ? '' : ' data-type-filter="0"'; ?>>
     <?php if ($showUpcoming) : ?>
     <div id="us-my-lessons"></div>
     <?php endif; ?>
     <?php if ($showBooking) : ?>
+    <?php
+    /*
+     * Above the calendar, because it reports on what the student just did and
+     * the calendar below it is what they do next. Filled and shown by
+     * booking.js; empty and hidden until then.
+     */
+    ?>
+    <div id="us-booking-confirmation" class="us-notice" role="status" aria-live="polite" hidden></div>
     <div id="us-slot-list">
         <p><?php esc_html_e('Loading available slots…', 'unsupervised-schedular'); ?></p>
     </div>
-    <div id="us-booking-confirmation" style="display:none;">
-        <p><?php esc_html_e('Your lesson has been booked. The instructor will confirm shortly.', 'unsupervised-schedular'); ?></p>
-    </div>
     <?php endif; ?>
     <div id="us-booking-error" style="display:none;" role="alert"></div>
 </div>

templates/frontend/family-page.php

@@ -0,0 +1,159 @@
+<?php
+declare(strict_types=1);
+
+use Unsupervised\Schedular\Registration\QuestionField;
+
+if (! defined('ABSPATH')) {
+    exit;
+}
+
+/**
+ * @var array{name: string, email: string, birth_year: string, is_student: bool} $self The account holder's own details.
+ * @var list<array{id: int, name: string, birth_year: string, relationship: string}> $children
+ * @var list<\Unsupervised\Schedular\Registration\Question> $questions Account-scope questions, asked once per child.
+ * @var string $error  Validation error from the last submission, if any.
+ * @var string $notice Confirmation of a completed add/edit/remove, if any.
+ * @var int    $editingId Child whose row is open for editing; 0 for none.
+ */
+?>
+<div class="us-family">
+    <h3><?php esc_html_e('Your profile', 'unsupervised-schedular'); ?></h3>
+
+    <?php if ($notice !== '') : ?>
+        <p class="us-success"><?php echo esc_html($notice); ?></p>
+    <?php endif; ?>
+
+    <?php if ($error !== '') : ?>
+        <p class="us-error" role="alert"><?php echo esc_html($error); ?></p>
+    <?php endif; ?>
+
+    <form method="post" action="" class="us-family-self">
+        <?php wp_nonce_field('us_family'); ?>
+        <input type="hidden" name="us_family_action" value="self">
+
+        <h4><?php esc_html_e('Your details', 'unsupervised-schedular'); ?></h4>
+
+        <?php if ($self['email'] !== '') : ?>
+            <?php /* Shown, not editable: the address is the account's login, and changing it is a studio-side job. */ ?>
+            <p class="us-family-self-email">
+                <?php esc_html_e('Email', 'unsupervised-schedular'); ?>
+                <span><?php echo esc_html($self['email']); ?></span>
+            </p>
+        <?php endif; ?>
+
+        <p>
+            <label for="us-own-name"><?php esc_html_e('Your name', 'unsupervised-schedular'); ?> <span class="us-required" aria-hidden="true">*</span></label>
+            <input type="text" name="own_name" id="us-own-name" autocomplete="name" required value="<?php echo esc_attr($self['name']); ?>">
+        </p>
+        <p>
+            <label>
+                <input type="checkbox" name="is_student" value="1"<?php checked($self['is_student']); ?>>
+                <?php esc_html_e('I take lessons myself', 'unsupervised-schedular'); ?>
+            </label>
+            <span class="us-field-hint"><?php esc_html_e('Leave this unticked if you only book for the students below — you will not be offered as a student yourself.', 'unsupervised-schedular'); ?></span>
+        </p>
+        <?php
+        /*
+         * Asked of a student only, so `required` is deliberately absent: the box
+         * above is what decides, and the browser cannot be told to enforce a
+         * field conditionally without JavaScript this page does not load.
+         * `handleSelf()` enforces it on the server either way.
+         */
+        ?>
+        <p>
+            <label for="us-own-birth-year"><?php esc_html_e('Your birth year', 'unsupervised-schedular'); ?></label>
+            <input type="number" name="own_birth_year" id="us-own-birth-year" value="<?php echo esc_attr($self['birth_year']); ?>" min="1900" max="<?php echo esc_attr(current_time('Y')); ?>" step="1" inputmode="numeric" autocomplete="bday-year" placeholder="<?php esc_attr_e('YYYY', 'unsupervised-schedular'); ?>" aria-describedby="us-own-birth-year-hint">
+            <span class="us-field-hint" id="us-own-birth-year-hint"><?php esc_html_e('Needed only if you take lessons yourself.', 'unsupervised-schedular'); ?></span>
+        </p>
+
+        <p>
+            <button type="submit"><?php esc_html_e('Save my details', 'unsupervised-schedular'); ?></button>
+        </p>
+    </form>
+
+    <h4><?php esc_html_e('Your students', 'unsupervised-schedular'); ?></h4>
+
+    <?php if (empty($children)) : ?>
+        <p><?php esc_html_e('You have not added any students yet. Add one below to start booking lessons for them.', 'unsupervised-schedular'); ?></p>
+    <?php else : ?>
+        <ul class="us-family-list">
+            <?php foreach ($children as $child) : ?>
+                <li class="us-family-child">
+                    <?php if ($editingId === $child['id']) : ?>
+                        <form method="post" action="" class="us-family-edit">
+                            <?php wp_nonce_field('us_family'); ?>
+                            <input type="hidden" name="us_family_action" value="edit">
+                            <input type="hidden" name="child_id" value="<?php echo esc_attr((string) $child['id']); ?>">
+                            <p>
+                                <label for="us-edit-name-<?php echo esc_attr((string) $child['id']); ?>"><?php esc_html_e('Name', 'unsupervised-schedular'); ?> <span class="us-required" aria-hidden="true">*</span></label>
+                                <input type="text" name="child_name" id="us-edit-name-<?php echo esc_attr((string) $child['id']); ?>" value="<?php echo esc_attr($child['name']); ?>" required>
+                            </p>
+                            <p>
+                                <label for="us-edit-birth-year-<?php echo esc_attr((string) $child['id']); ?>"><?php esc_html_e('Birth year', 'unsupervised-schedular'); ?> <span class="us-required" aria-hidden="true">*</span></label>
+                                <input type="number" name="child_birth_year" required id="us-edit-birth-year-<?php echo esc_attr((string) $child['id']); ?>" value="<?php echo esc_attr($child['birth_year']); ?>" min="1900" max="<?php echo esc_attr(current_time('Y')); ?>" step="1" inputmode="numeric" placeholder="<?php esc_attr_e('YYYY', 'unsupervised-schedular'); ?>">
+                            </p>
+                            <p>
+                                <button type="submit"><?php esc_html_e('Save', 'unsupervised-schedular'); ?></button>
+                                <a href="<?php echo esc_url((string) get_permalink()); ?>"><?php esc_html_e('Cancel', 'unsupervised-schedular'); ?></a>
+                            </p>
+                        </form>
+                    <?php else : ?>
+                        <span class="us-family-child-name"><?php echo esc_html($child['name']); ?></span>
+                        <?php if ($child['birth_year'] !== '') : ?>
+                            <span class="us-family-child-birth-year"><?php echo esc_html($child['birth_year']); ?></span>
+                        <?php endif; ?>
+                        <span class="us-family-child-actions">
+                            <a href="<?php echo esc_url(add_query_arg('us_edit_child', $child['id'], (string) get_permalink())); ?>"><?php esc_html_e('Edit', 'unsupervised-schedular'); ?></a>
+                            <form method="post" action="" class="us-family-remove">
+                                <?php wp_nonce_field('us_family'); ?>
+                                <input type="hidden" name="us_family_action" value="remove">
+                                <input type="hidden" name="child_id" value="<?php echo esc_attr((string) $child['id']); ?>">
+                                <button type="submit"><?php esc_html_e('Remove', 'unsupervised-schedular'); ?></button>
+                            </form>
+                        </span>
+                    <?php endif; ?>
+                </li>
+            <?php endforeach; ?>
+        </ul>
+    <?php endif; ?>
+
+    <form method="post" action="" class="us-family-add">
+        <?php wp_nonce_field('us_family'); ?>
+        <input type="hidden" name="us_family_action" value="add">
+
+        <h4><?php esc_html_e('Add a student', 'unsupervised-schedular'); ?></h4>
+        <p>
+            <label for="us-child-name"><?php esc_html_e('Name', 'unsupervised-schedular'); ?> <span class="us-required" aria-hidden="true">*</span></label>
+            <input type="text" name="child_name" id="us-child-name" required>
+        </p>
+        <p>
+            <label for="us-child-birth-year"><?php esc_html_e('Birth year', 'unsupervised-schedular'); ?> <span class="us-required" aria-hidden="true">*</span></label>
+            <input type="number" name="child_birth_year" id="us-child-birth-year" required min="1900" max="<?php echo esc_attr(current_time('Y')); ?>" step="1" inputmode="numeric" placeholder="<?php esc_attr_e('YYYY', 'unsupervised-schedular'); ?>">
+        </p>
+        <p>
+            <label for="us-child-relationship"><?php esc_html_e('Your relationship to them', 'unsupervised-schedular'); ?></label>
+            <input type="text" name="child_relationship" id="us-child-relationship" placeholder="<?php esc_attr_e('Parent', 'unsupervised-schedular'); ?>">
+        </p>
+
+        <?php if (! empty($questions)) : ?>
+            <fieldset class="us-reg-questions">
+                <legend><?php esc_html_e('About this student', 'unsupervised-schedular'); ?></legend>
+                <?php foreach ($questions as $question) : ?>
+                    <?php
+                    // phpcs:ignore WordPress.Security.EscapeOutput.OutputNotEscaped -- QuestionField::render() escapes every interpolated value.
+                    echo QuestionField::render(
+                        $question,
+                        'us_answers[' . (int) $question->id . ']',
+                        'us-family-q-' . (int) $question->id,
+                        isRequired: $question->isRequiredForChild()
+                    );
+                    ?>
+                <?php endforeach; ?>
+            </fieldset>
+        <?php endif; ?>
+
+        <p>
+            <button type="submit"><?php esc_html_e('Add student', 'unsupervised-schedular'); ?></button>
+        </p>
+    </form>
+</div>

templates/frontend/group-classes-page.php

@@ -6,13 +6,17 @@ if (! defined('ABSPATH')) {
 }
 
 /** @var int $offeringId Offering id when the page is restricted to a single class; 0 for the full catalog. */
+/** @var list<array{id: int, name: string, is_self: bool}> $students Who this account may enrol — children first, the account holder last. */
+
+// The enrolment script reads the list as JSON, so the picker can be built inside
+// the enrolment form it renders.
+$studentsJson = wp_json_encode(array_values($students));
 ?>
-<div id="us-group-app"<?php echo $offeringId > 0 ? ' data-offering="' . esc_attr((string) $offeringId) . '"' : ''; ?>>
+<div id="us-group-app" data-students="<?php echo esc_attr(is_string($studentsJson) ? $studentsJson : '[]'); ?>"<?php echo $offeringId > 0 ? ' data-offering="' . esc_attr((string) $offeringId) . '"' : ''; ?>>
+    <?php /* Above the list, for the same reason as the booking page. */ ?>
+    <div id="us-group-confirmation" class="us-notice" role="status" aria-live="polite" hidden></div>
     <div id="us-group-list">
         <p><?php esc_html_e('Loading group classes…', 'unsupervised-schedular'); ?></p>
     </div>
-    <div id="us-group-confirmation" style="display:none;">
-        <p><?php esc_html_e('You are enrolled. The studio will be in touch.', 'unsupervised-schedular'); ?></p>
-    </div>
     <div id="us-group-error" style="display:none;" role="alert"></div>
 </div>

templates/frontend/register-page.php

@@ -1,7 +1,10 @@
 <?php
 declare(strict_types=1);
 
+use Unsupervised\Schedular\Auth\PasswordPolicy;
+use Unsupervised\Schedular\Auth\RegistrationPage;
 use Unsupervised\Schedular\Registration\Question;
+use Unsupervised\Schedular\Registration\QuestionField;
 
 if (! defined('ABSPATH')) {
     exit;
@@ -19,42 +22,9 @@ if (! defined('ABSPATH')) {
  * @var string $loginUrl Where the post-confirmation sign-in link points.
  * @var string $error
  * @var list<array{policy: \Unsupervised\Schedular\Policy\Policy, version: \Unsupervised\Schedular\Policy\PolicyVersion}> $policyForms
- * @var list<Question> $accountQuestions Studio-wide questions answered as step two.
+ * @var list<Question> $accountQuestions Studio-wide questions, asked of every student being registered — the account holder included when they are one, unless the question is for students only.
  */
 
-/**
- * Render one account-signup question's input, named `us_answers[<id>]`.
- */
-$renderQuestionField = static function (Question $question): void {
-    $id       = (int) $question->id;
-    $name     = 'us_answers[' . $id . ']';
-    $fieldId  = 'us-reg-q-' . $id;
-    $required = $question->isRequired ? ' required' : '';
-    ?>
-    <p>
-        <label for="<?php echo esc_attr($fieldId); ?>">
-            <?php echo esc_html($question->label); ?>
-            <?php if ($question->isRequired) : ?>
-                <span class="us-required" aria-hidden="true">*</span>
-            <?php endif; ?>
-        </label>
-        <?php if ($question->fieldType === Question::FIELD_TEXTAREA) : ?>
-            <textarea name="<?php echo esc_attr($name); ?>" id="<?php echo esc_attr($fieldId); ?>" rows="4"<?php echo $required; // phpcs:ignore WordPress.Security.EscapeOutput.OutputNotEscaped -- literal attribute string. ?>></textarea>
-        <?php elseif ($question->fieldType === Question::FIELD_SELECT) : ?>
-            <select name="<?php echo esc_attr($name); ?>" id="<?php echo esc_attr($fieldId); ?>"<?php echo $required; // phpcs:ignore WordPress.Security.EscapeOutput.OutputNotEscaped -- literal attribute string. ?>>
-                <option value=""><?php esc_html_e('— Select —', 'unsupervised-schedular'); ?></option>
-                <?php foreach ((array) $question->options as $option) : ?>
-                    <option value="<?php echo esc_attr((string) $option); ?>"><?php echo esc_html((string) $option); ?></option>
-                <?php endforeach; ?>
-            </select>
-        <?php elseif ($question->fieldType === Question::FIELD_CHECKBOX) : ?>
-            <input type="checkbox" name="<?php echo esc_attr($name); ?>" id="<?php echo esc_attr($fieldId); ?>" value="1"<?php echo $required; // phpcs:ignore WordPress.Security.EscapeOutput.OutputNotEscaped -- literal attribute string. ?>>
-        <?php else : ?>
-            <input type="text" name="<?php echo esc_attr($name); ?>" id="<?php echo esc_attr($fieldId); ?>"<?php echo $required; // phpcs:ignore WordPress.Security.EscapeOutput.OutputNotEscaped -- literal attribute string. ?>>
-        <?php endif; ?>
-    </p>
-    <?php
-};
 ?>
 <div class="us-register-form">
     <?php if ($successType === 'confirm') : ?>
@@ -79,12 +49,10 @@ $renderQuestionField = static function (Question $question): void {
                 <p class="us-error" role="alert"><?php echo esc_html($error); ?></p>
             <?php endif; ?>
 
-            <?php $hasQuestions = ! empty($accountQuestions); ?>
-            <form method="post" action="" <?php echo $hasQuestions ? 'data-steps="1"' : ''; ?>>
+            <form method="post" action="">
                 <?php wp_nonce_field('us_student_register'); ?>
                 <input type="hidden" name="us_invite" value="<?php echo esc_attr($token); ?>">
 
-                <div class="us-reg-step" data-step="1">
                 <p>
                     <label for="us-reg-email"><?php esc_html_e('Email', 'unsupervised-schedular'); ?></label>
                     <?php if ($inviteValid && $invite !== null && ! $invite->isGroup()) : ?>
@@ -99,16 +67,120 @@ $renderQuestionField = static function (Question $question): void {
                 </p>
                 <p>
                     <label for="us-reg-pass"><?php esc_html_e('Password', 'unsupervised-schedular'); ?></label>
-                        <input type="password" name="password" id="us-reg-pass" autocomplete="new-password" minlength="8" required>
+                    <input type="password" name="password" id="us-reg-pass" autocomplete="new-password" minlength="<?php echo esc_attr((string) PasswordPolicy::MIN_LENGTH); ?>" required aria-describedby="us-reg-pass-strength">
+                    <?php
+                    /*
+                     * Filled in by register.js. `aria-live` announces the verdict as
+                     * it changes, and it starts empty so nothing is announced — or
+                     * takes up space — before anything has been typed.
+                     */
+                    ?>
+                    <span class="us-password-strength" id="us-reg-pass-strength" role="status" aria-live="polite"></span>
                 </p>
 
+                <fieldset class="us-reg-group">
+                    <legend><?php esc_html_e('Who are you registering?', 'unsupervised-schedular'); ?></legend>
+                    <?php
+                    /*
+                     * Radios, not checkboxes: the three answers are mutually
+                     * exclusive, and "both" only means anything as a third
+                     * choice alongside the other two. "Just myself" is
+                     * pre-selected because it is the commonest signup and the
+                     * one that collects the least.
+                     */
+                    $registeringForChoices = [
+                        RegistrationPage::FOR_SELF     => __('Just myself', 'unsupervised-schedular'),
+                        RegistrationPage::FOR_STUDENTS => __('On behalf of one or more students', 'unsupervised-schedular'),
+                        RegistrationPage::FOR_BOTH     => __('Both — myself and one or more students', 'unsupervised-schedular'),
+                    ];
+                    ?>
+                    <?php foreach ($registeringForChoices as $value => $label) : ?>
+                        <p>
+                            <label>
+                                <input type="radio" name="us_registering_for" value="<?php echo esc_attr($value); ?>" class="us-registering-for"<?php checked($value, RegistrationPage::FOR_SELF); ?>>
+                                <?php echo esc_html($label); ?>
+                            </label>
+                        </p>
+                    <?php endforeach; ?>
+                </fieldset>
+
+                <?php
+                /*
+                 * The account holder's own student details, asked on the same page
+                 * as everything else rather than behind a "Next": what the studio
+                 * needs to know about them is part of registering, not a sequel to
+                 * it. Taken out of play by register.js when they say they are
+                 * registering *only* on behalf of other people — the questions
+                 * describe a student, and in that case they are not one.
+                 */
+                ?>
+                <fieldset class="us-reg-group us-reg-self" id="us-reg-self">
+                    <legend><?php esc_html_e('About you', 'unsupervised-schedular'); ?></legend>
+                    <p>
+                        <label for="us-reg-birth-year"><?php esc_html_e('Birth year', 'unsupervised-schedular'); ?> <span class="us-required" aria-hidden="true">*</span></label>
+                        <input type="number" name="birth_year" id="us-reg-birth-year" aria-required="true" required min="1900" max="<?php echo esc_attr(current_time('Y')); ?>" step="1" inputmode="numeric" autocomplete="bday-year" placeholder="<?php esc_attr_e('YYYY', 'unsupervised-schedular'); ?>">
+                    </p>
+                    <?php foreach ($accountQuestions as $question) : ?>
+                        <?php
+                        // A "students only" question describes a child being registered,
+                        // so it is never put to the account holder about themselves.
+                        if (! $question->askedOfSelf()) {
+                            continue;
+                        }
+                        ?>
+                        <?php
+                        // phpcs:ignore WordPress.Security.EscapeOutput.OutputNotEscaped -- QuestionField::render() escapes every interpolated value.
+                        echo QuestionField::render(
+                            $question,
+                            'us_answers[' . (int) $question->id . ']',
+                            'us-reg-q-' . (int) $question->id,
+                            isRequired: $question->isRequiredForSelf()
+                        );
+                        ?>
+                    <?php endforeach; ?>
+                </fieldset>
+
+                <?php /* Revealed by the two student-bearing choices; without JS it is simply always visible. */ ?>
+                <fieldset class="us-reg-group us-children" id="us-children">
+                    <legend><?php esc_html_e('Students', 'unsupervised-schedular'); ?></legend>
+                    <p class="us-children-intro"><?php esc_html_e('Add each student you will be booking lessons for. They do not need their own login — you book and pay for them from this account.', 'unsupervised-schedular'); ?></p>
+
+                    <?php /* The first block is the template the "Add another student" button clones. */ ?>
+                    <div class="us-child" data-child-index="0">
+                        <p>
+                            <label for="us-child-0-name"><?php esc_html_e("Student's name", 'unsupervised-schedular'); ?> <span class="us-required" aria-hidden="true">*</span></label>
+                            <input type="text" name="children[0][name]" id="us-child-0-name" aria-required="true" data-us-child-required>
+                        </p>
+                        <p>
+                            <label for="us-child-0-birth-year"><?php esc_html_e('Birth year', 'unsupervised-schedular'); ?> <span class="us-required" aria-hidden="true">*</span></label>
+                            <input type="number" name="children[0][birth_year]" id="us-child-0-birth-year" aria-required="true" data-us-child-required min="1900" max="<?php echo esc_attr(current_time('Y')); ?>" step="1" inputmode="numeric" placeholder="<?php esc_attr_e('YYYY', 'unsupervised-schedular'); ?>">
+                        </p>
+                        <?php foreach ($accountQuestions as $question) : ?>
+                            <?php
+                            // phpcs:ignore WordPress.Security.EscapeOutput.OutputNotEscaped -- QuestionField::render() escapes every interpolated value.
+                            echo QuestionField::render(
+                                $question,
+                                'children[0][answers][' . (int) $question->id . ']',
+                                'us-child-0-q-' . (int) $question->id,
+                                enforceRequired: false,
+                                isRequired: $question->isRequiredForChild()
+                            );
+                            ?>
+                        <?php endforeach; ?>
+                    </div>
+
+                    <p>
+                        <button type="button" class="us-add-child"><?php esc_html_e('Add another student', 'unsupervised-schedular'); ?></button>
+                    </p>
+                </fieldset>
+
                 <?php if (! empty($policyForms)) : ?>
                     <fieldset class="us-policies">
                         <legend><?php esc_html_e('Policies', 'unsupervised-schedular'); ?></legend>
                         <?php foreach ($policyForms as $form) : ?>
                             <div class="us-policy">
                                 <h4><?php echo esc_html($form['policy']->title); ?></h4>
-                                    <div class="us-policy-body"><?php echo wp_kses_post((string) $form['version']->body); ?></div>
+                                <div class="us-policy-body"><?php echo wp_kses_post($form['version']->bodyHtml()); ?></div>
                                 <label>
                                     <input type="checkbox" name="accept[]" value="<?php echo esc_attr((string) $form['version']->id); ?>" required>
                                     <?php
@@ -121,31 +193,9 @@ $renderQuestionField = static function (Question $question): void {
                     </fieldset>
                 <?php endif; ?>
 
-                    <?php if ($hasQuestions) : ?>
-                        <p>
-                            <button type="button" class="us-reg-next"><?php esc_html_e('Next', 'unsupervised-schedular'); ?></button>
-                        </p>
-                    <?php else : ?>
                 <p>
                     <input type="submit" name="us_register" value="<?php esc_attr_e('Create Account', 'unsupervised-schedular'); ?>">
                 </p>
-                    <?php endif; ?>
-                </div>
-
-                <?php if ($hasQuestions) : ?>
-                    <div class="us-reg-step" data-step="2">
-                        <fieldset class="us-reg-questions">
-                            <legend><?php esc_html_e('Registration information', 'unsupervised-schedular'); ?></legend>
-                            <?php foreach ($accountQuestions as $question) : ?>
-                                <?php $renderQuestionField($question); ?>
-                            <?php endforeach; ?>
-                        </fieldset>
-                        <p>
-                            <button type="button" class="us-reg-back"><?php esc_html_e('Back', 'unsupervised-schedular'); ?></button>
-                            <input type="submit" name="us_register" value="<?php esc_attr_e('Create Account', 'unsupervised-schedular'); ?>">
-                        </p>
-                    </div>
-                <?php endif; ?>
             </form>
         <?php endif; ?>
     <?php endif; ?>

tests/CLAUDE.md

@@ -0,0 +1,14 @@
+# Writing tests
+
+Tests use [Brain\Monkey](https://brain-wp.github.io/BrainMonkey/) to stub WordPress functions without a full WP installation, and Mockery to mock `$wpdb` and other dependencies.
+
+All test classes extend `tests/Unit/TestCase.php`, which handles `Monkey\setUp()` / `Monkey\tearDown()` and stubs all WP translation/escape functions automatically.
+
+**Brain\Monkey API notes:**
+
+- `Functions\when('fn')->alias(fn() => ...)` — stub with a closure (NOT `returnUsing()`)
+- `Functions\when('fn')->justReturn($val)` — stub returning a fixed value
+- `Functions\expect('fn')->once()->with(...)` — assert call count and arguments
+- Use `Functions\when()` (not `Functions\expect()`) when you need argument-routing (e.g. `get_role` returning different values per argument) to avoid chaining ambiguity
+- Mockery matchers (e.g. `\Mockery::type()`) inside plain PHP arrays do not work with `with()` — use `\Mockery::on(fn($arr) => ...)` or `\Mockery::any()` instead
+- When mocking `$wpdb`, set `$mock->prefix = 'wp_'` explicitly — it is a public property, not a method

tests/Unit/Auth/AccountPageTest.php

@@ -0,0 +1,117 @@
+<?php
+declare(strict_types=1);
+
+namespace Unsupervised\Schedular\Tests\Unit\Auth;
+
+use Brain\Monkey\Functions;
+use Mockery;
+use Unsupervised\Schedular\Auth\AccountPage;
+use Unsupervised\Schedular\Tests\Unit\TestCase;
+
+class AccountPageTest extends TestCase
+{
+    private AccountPage $page;
+
+    protected function setUp(): void
+    {
+        parent::setUp();
+
+        $this->page = new AccountPage();
+
+        Functions\when('is_user_logged_in')->justReturn(true);
+        Functions\when('get_current_user_id')->justReturn(5);
+        Functions\when('wp_enqueue_style')->justReturn(null);
+        Functions\when('get_permalink')->alias(
+            static fn (int $id = 0): string => $id > 0
+                ? 'https://studio.test/sign-in/'
+                : 'https://studio.test/current/'
+        );
+        Functions\when('wp_logout_url')->alias(
+            static fn (string $redirect): string => 'https://studio.test/wp-login.php?action=logout&redirect_to=' . rawurlencode($redirect)
+        );
+        Functions\when('wp_get_current_user')->justReturn($this->user('Grace', 'Hopper', '[email protected]'));
+    }
+
+    private function user(string $first, string $last, string $email): \WP_User
+    {
+        $user             = Mockery::mock(\WP_User::class);
+        $user->ID         = 5;
+        $user->first_name = $first;
+        $user->last_name  = $last;
+        $user->nickname   = '';
+        $user->user_email = $email;
+
+        return $user;
+    }
+
+    public function testShowsTheSignedInNameAndEmail(): void
+    {
+        $html = $this->page->render([]);
+
+        self::assertStringContainsString('Grace Hopper', $html);
+        self::assertStringContainsString('[email protected]', $html);
+        self::assertStringContainsString('Sign out', $html);
+    }
+
+    public function testSigningOutReturnsToTheConfiguredLoginPage(): void
+    {
+        self::assertStringContainsString(
+            rawurlencode('https://studio.test/sign-in/'),
+            $this->page->render(['loginPageId' => 9])
+        );
+    }
+
+    /**
+     * With no page chosen, signing out from a header link should leave the
+     * visitor where they were rather than navigating them somewhere.
+     */
+    public function testSigningOutReturnsToTheCurrentPageWhenNoLoginPageIsSet(): void
+    {
+        self::assertStringContainsString(
+            rawurlencode('https://studio.test/current/'),
+            $this->page->render([])
+        );
+    }
+
+    public function testTheShortcodeAttributeNameIsAccepted(): void
+    {
+        self::assertStringContainsString(
+            rawurlencode('https://studio.test/sign-in/'),
+            $this->page->render(['login_page_id' => 9])
+        );
+    }
+
+    /**
+     * A block whose whole job is "you are signed in as X" has nothing to say to
+     * a stranger, and a bare notice in a site header cannot be acted on.
+     */
+    public function testRendersNothingForASignedOutVisitorWithNoLoginPage(): void
+    {
+        Functions\when('is_user_logged_in')->justReturn(false);
+
+        self::assertSame('', $this->page->render([]));
+    }
+
+    public function testOffersASignInLinkToASignedOutVisitorWhenAPageIsChosen(): void
+    {
+        Functions\when('is_user_logged_in')->justReturn(false);
+
+        $html = $this->page->render(['loginPageId' => 9]);
+
+        self::assertStringContainsString('https://studio.test/sign-in/', $html);
+        self::assertStringContainsString('Sign in', $html);
+        self::assertStringNotContainsString('Sign out', $html);
+    }
+
+    /**
+     * A page can be deleted after it has been chosen in the block, which
+     * get_permalink() reports as false.
+     */
+    public function testTreatsADeletedLoginPageAsNoneChosen(): void
+    {
+        Functions\when('is_user_logged_in')->justReturn(false);
+        Functions\when('get_permalink')->justReturn(false);
+
+        self::assertSame('', $this->page->render(['loginPageId' => 9]));
+    }
+}

tests/Unit/Auth/DeletedUserCleanupTest.php

@@ -0,0 +1,234 @@
+<?php
+declare(strict_types=1);
+
+namespace Unsupervised\Schedular\Tests\Unit\Auth;
+
+use Brain\Monkey\Actions;
+use Mockery;
+use Unsupervised\Schedular\Auth\DeletedUserCleanup;
+use Unsupervised\Schedular\Availability\AvailabilityRepository;
+use Unsupervised\Schedular\Booking\BookingRepository;
+use Unsupervised\Schedular\Booking\Lesson;
+use Unsupervised\Schedular\GroupClass\Enrollment;
+use Unsupervised\Schedular\GroupClass\EnrollmentRepository;
+use Unsupervised\Schedular\Guardian\GuardianLink;
+use Unsupervised\Schedular\Guardian\GuardianRepository;
+use Unsupervised\Schedular\Guardian\GuardianService;
+use Unsupervised\Schedular\Payment\PaymentService;
+use Unsupervised\Schedular\Tests\Unit\TestCase;
+
+class DeletedUserCleanupTest extends TestCase
+{
+    private BookingRepository&Mockery\MockInterface $bookings;
+    private AvailabilityRepository&Mockery\MockInterface $availability;
+    private EnrollmentRepository&Mockery\MockInterface $enrollments;
+    private PaymentService&Mockery\MockInterface $payments;
+    private GuardianRepository&Mockery\MockInterface $links;
+    private GuardianService&Mockery\MockInterface $guardians;
+    private DeletedUserCleanup $cleanup;
+
+    protected function setUp(): void
+    {
+        parent::setUp();
+
+        $this->bookings     = Mockery::mock(BookingRepository::class);
+        $this->availability = Mockery::mock(AvailabilityRepository::class);
+        $this->enrollments  = Mockery::mock(EnrollmentRepository::class);
+        $this->payments     = Mockery::mock(PaymentService::class);
+        $this->links        = Mockery::mock(GuardianRepository::class);
+        $this->guardians    = Mockery::mock(GuardianService::class);
+
+        // Most accounts have nobody linked to them; the guardian tests say so.
+        $this->links->shouldReceive('findByGuardian')->andReturn([])->byDefault();
+
+        $this->cleanup = new DeletedUserCleanup(
+            $this->bookings,
+            $this->availability,
+            $this->enrollments,
+            $this->payments,
+            $this->links,
+            $this->guardians
+        );
+    }
+
+    public function testHooksBothSingleSiteAndNetworkDeletion(): void
+    {
+        Actions\expectAdded('delete_user')->once();
+        Actions\expectAdded('wpmu_delete_user')->once();
+
+        $this->cleanup->register();
+    }
+
+    public function testEachUpcomingLessonIsCancelledItsSlotFreedAndItsPendingPaymentVoided(): void
+    {
+        $this->bookings->shouldReceive('findUpcomingForStudent')->with(5)->andReturn([
+            new Lesson(slotId: 7, studentId: 5, instructorId: 3, status: Lesson::STATUS_PENDING, paymentId: 40, id: 12),
+            new Lesson(slotId: 8, studentId: 5, instructorId: 3, status: Lesson::STATUS_CONFIRMED, paymentId: null, id: 13),
+        ]);
+        $this->enrollments->shouldReceive('findByStudent')->with(5)->andReturn([]);
+
+        $this->bookings->shouldReceive('updateStatus')->once()->with(12, Lesson::STATUS_CANCELLED)->andReturn(true);
+        $this->bookings->shouldReceive('updateStatus')->once()->with(13, Lesson::STATUS_CANCELLED)->andReturn(true);
+
+        // The point of the whole exercise: the times go back on sale.
+        $this->availability->shouldReceive('release')->once()->with(7)->andReturn(true);
+        $this->availability->shouldReceive('release')->once()->with(8)->andReturn(true);
+
+        $this->payments->shouldReceive('voidPending')->once()->with(40);
+        $this->payments->shouldReceive('voidPending')->once()->with(null);
+
+        $this->cleanup->releaseBookings(5);
+    }
+
+    /**
+     * A paid lesson is not credited back. The credit could only ever be spent on
+     * the account being deleted, so writing one would be book-keeping nobody can
+     * act on — a refund is the studio's call to make and record.
+     */
+    public function testNoCreditIsIssuedForAPaidLesson(): void
+    {
+        $this->bookings->shouldReceive('findUpcomingForStudent')->with(5)->andReturn([
+            new Lesson(slotId: 7, studentId: 5, instructorId: 3, status: Lesson::STATUS_CONFIRMED, paymentId: 40, id: 12),
+        ]);
+        $this->enrollments->shouldReceive('findByStudent')->with(5)->andReturn([]);
+
+        $this->bookings->shouldReceive('updateStatus')->andReturn(true);
+        $this->availability->shouldReceive('release')->andReturn(true);
+        $this->payments->shouldReceive('voidPending');
+
+        $this->payments->shouldNotReceive('creditForCancelledLesson');
+
+        $this->cleanup->releaseBookings(5);
+    }
+
+    public function testActiveEnrolmentsAreCancelledAndTheirPendingPaymentsVoided(): void
+    {
+        $this->bookings->shouldReceive('findUpcomingForStudent')->with(5)->andReturn([]);
+        $this->enrollments->shouldReceive('findByStudent')->with(5)->andReturn([
+            new Enrollment(offeringId: 8, studentId: 5, instructorId: 3, paymentId: 41, id: 40),
+            new Enrollment(
+                offeringId: 9,
+                studentId: 5,
+                instructorId: 3,
+                status: Enrollment::STATUS_CANCELLED,
+                paymentId: 42,
+                id: 41,
+            ),
+        ]);
+
+        // Only the active one: a withdrawn enrolment is already holding nothing.
+        $this->enrollments->shouldReceive('updateStatus')->once()->with(40, Enrollment::STATUS_CANCELLED)->andReturn(true);
+        $this->payments->shouldReceive('voidPending')->once()->with(41);
+
+        $this->cleanup->releaseBookings(5);
+    }
+
+    /**
+     * Past lessons happened and may have been paid for, so they stay exactly as
+     * they are — `findUpcomingForStudent` is what draws that line.
+     */
+    public function testNothingHappensWhenTheAccountHasNothingBookedAhead(): void
+    {
+        $this->bookings->shouldReceive('findUpcomingForStudent')->with(5)->andReturn([]);
+        $this->enrollments->shouldReceive('findByStudent')->with(5)->andReturn([]);
+
+        $this->bookings->shouldNotReceive('updateStatus');
+        $this->availability->shouldNotReceive('release');
+        $this->enrollments->shouldNotReceive('updateStatus');
+
+        $this->cleanup->releaseBookings(5);
+    }
+
+    public function testAnInvalidUserIdIsIgnored(): void
+    {
+        $this->bookings->shouldNotReceive('findUpcomingForStudent');
+        $this->enrollments->shouldNotReceive('findByStudent');
+
+        $this->cleanup->releaseBookings(0);
+    }
+
+    /**
+     * A child account is login-less and exists only so its guardian has somebody
+     * to book for. Without the guardian nobody can reach it, book for it, or be
+     * billed for it — so it goes too, and what it was holding goes back.
+     */
+    public function testDeletingAGuardianReleasesAndDeletesEachChild(): void
+    {
+        $this->bookings->shouldReceive('findUpcomingForStudent')->with(5)->andReturn([]);
+        $this->enrollments->shouldReceive('findByStudent')->with(5)->andReturn([]);
+
+        $this->links->shouldReceive('findByGuardian')->with(5)->andReturn([
+            new GuardianLink(guardianId: 5, studentId: 42, id: 1),
+            new GuardianLink(guardianId: 5, studentId: 43, id: 2),
+        ]);
+
+        $this->bookings->shouldReceive('findUpcomingForStudent')->with(42)->andReturn([
+            new Lesson(slotId: 7, studentId: 42, instructorId: 3, status: Lesson::STATUS_CONFIRMED, paymentId: 40, id: 12),
+        ]);
+        $this->bookings->shouldReceive('findUpcomingForStudent')->with(43)->andReturn([]);
+        $this->enrollments->shouldReceive('findByStudent')->with(42)->andReturn([]);
+        $this->enrollments->shouldReceive('findByStudent')->with(43)->andReturn([
+            new Enrollment(offeringId: 8, studentId: 43, instructorId: 3, paymentId: 41, id: 40),
+        ]);
+
+        // The child's lesson is cancelled and its time freed, exactly as the
+        // guardian's own would have been.
+        $this->bookings->shouldReceive('updateStatus')->once()->with(12, Lesson::STATUS_CANCELLED)->andReturn(true);
+        $this->availability->shouldReceive('release')->once()->with(7)->andReturn(true);
+        $this->enrollments->shouldReceive('updateStatus')->once()->with(40, Enrollment::STATUS_CANCELLED)->andReturn(true);
+        $this->payments->shouldReceive('voidPending')->with(40)->once();
+        $this->payments->shouldReceive('voidPending')->with(41)->once();
+
+        // Then the link row and the account itself.
+        $this->links->shouldReceive('delete')->once()->with(5, 42)->andReturn(true);
+        $this->links->shouldReceive('delete')->once()->with(5, 43)->andReturn(true);
+        $this->guardians->shouldReceive('deleteUser')->once()->with(42);
+        $this->guardians->shouldReceive('deleteUser')->once()->with(43);
+
+        $this->cleanup->releaseBookings(5);
+    }
+
+    /**
+     * Deleting a child fires `delete_user` again, which lands back in this same
+     * handler. It must return without redoing the release — and a self-link,
+     * however it got into the table, must not recurse for ever.
+     */
+    public function testAChildAlreadyDealtWithIsNotProcessedTwice(): void
+    {
+        $this->bookings->shouldReceive('findUpcomingForStudent')->with(5)->andReturn([]);
+        $this->enrollments->shouldReceive('findByStudent')->with(5)->andReturn([]);
+
+        $this->links->shouldReceive('findByGuardian')->with(5)->andReturn([
+            new GuardianLink(guardianId: 5, studentId: 42, id: 1),
+            // A duplicate row, and a self-link: neither may cause a second pass.
+            new GuardianLink(guardianId: 5, studentId: 42, id: 2),
+            new GuardianLink(guardianId: 5, studentId: 5, id: 3),
+        ]);
+
+        $this->bookings->shouldReceive('findUpcomingForStudent')->with(42)->once()->andReturn([]);
+        $this->enrollments->shouldReceive('findByStudent')->with(42)->once()->andReturn([]);
+        $this->links->shouldReceive('delete')->once()->with(5, 42)->andReturn(true);
+        $this->guardians->shouldReceive('deleteUser')->once()->with(42);
+
+        $this->cleanup->releaseBookings(5);
+
+        // The re-entrant call the child's own deletion triggers is a no-op.
+        $this->cleanup->releaseBookings(42);
+    }
+
+    /**
+     * A child's own deletion (from the family screen, say) touches nothing but
+     * that child — they have nobody linked beneath them.
+     */
+    public function testDeletingAStudentWithNoChildrenDeletesNobodyElse(): void
+    {
+        $this->bookings->shouldReceive('findUpcomingForStudent')->with(42)->andReturn([]);
+        $this->enrollments->shouldReceive('findByStudent')->with(42)->andReturn([]);
+        $this->links->shouldReceive('findByGuardian')->with(42)->andReturn([]);
+
+        $this->guardians->shouldNotReceive('deleteUser');
+        $this->links->shouldNotReceive('delete');
+
+        $this->cleanup->releaseBookings(42);
+    }
+}

tests/Unit/Auth/PasswordPolicyTest.php

@@ -0,0 +1,118 @@
+<?php
+declare(strict_types=1);
+
+namespace Unsupervised\Schedular\Tests\Unit\Auth;
+
+use Unsupervised\Schedular\Auth\PasswordPolicy;
+use Unsupervised\Schedular\Tests\Unit\TestCase;
+
+class PasswordPolicyTest extends TestCase
+{
+    public function testAcceptsAnOrdinaryMemorablePassword(): void
+    {
+        self::assertNull(PasswordPolicy::validate('thistle-marrow-42', '[email protected]', 'Grace Hopper'));
+    }
+
+    /**
+     * A leading or trailing space is a character like any other. Trimming it
+     * would accept a password the user could then never type back.
+     */
+    public function testCountsSurroundingSpaceAsPartOfThePassword(): void
+    {
+        self::assertNull(PasswordPolicy::validate('  spaced-out-phrase  '));
+
+        // Seven characters counting both spaces: one short, and still one short
+        // after the spaces are counted rather than stripped.
+        self::assertNotNull(PasswordPolicy::validate(' short '));
+    }
+
+    /**
+     * @dataProvider tooShort
+     */
+    public function testRejectsAPasswordShorterThanTheMinimum(string $password): void
+    {
+        self::assertStringContainsString('at least', (string) PasswordPolicy::validate($password));
+    }
+
+    /** @return array<string, array{string}> */
+    public static function tooShort(): array
+    {
+        return [
+            'empty'       => [''],
+            'one short'   => ['sevench'],
+            'a few chars' => ['abc'],
+        ];
+    }
+
+    /**
+     * @dataProvider commonPasswords
+     */
+    public function testRejectsAWellKnownPassword(string $password): void
+    {
+        self::assertStringContainsString('commonly used', (string) PasswordPolicy::validate($password));
+    }
+
+    /** @return array<string, array{string}> */
+    public static function commonPasswords(): array
+    {
+        return [
+            'password123'      => ['password123'],
+            'shouting'         => ['PASSWORD123'],
+            'mixed case'       => ['PassWord123'],
+            'a keyboard walk'  => ['qwertyuiop'],
+            'digits in a row'  => ['123456789'],
+            'the classic'      => ['iloveyou'],
+        ];
+    }
+
+    /**
+     * @dataProvider tooFewDistinctCharacters
+     */
+    public function testRejectsAPasswordBuiltFromAlmostNoDistinctCharacters(string $password): void
+    {
+        self::assertStringContainsString('repeated characters', (string) PasswordPolicy::validate($password));
+    }
+
+    /** @return array<string, array{string}> */
+    public static function tooFewDistinctCharacters(): array
+    {
+        return [
+            'one character'  => ['aaaaaaaaaa'],
+            'two alternating' => ['abababababab'],
+            'three'          => ['abcabcabcabc'],
+        ];
+    }
+
+    /**
+     * @dataProvider identityEchoes
+     */
+    public function testRejectsAPasswordContainingTheUsersOwnDetails(string $password, string $email, string $name): void
+    {
+        self::assertStringContainsString('name or email', (string) PasswordPolicy::validate($password, $email, $name));
+    }
+
+    /** @return array<string, array{string, string, string}> */
+    public static function identityEchoes(): array
+    {
+        return [
+            'the whole email'    => ['[email protected]!', '[email protected]', 'Grace'],
+            'the local part'     => ['grace-hopper-1906', '[email protected]', ''],
+            'the display name'   => ['xxhopperxx-2019', '[email protected]', 'Hopper'],
+            'differing in case'  => ['MyGRACEpassword', '[email protected]', ''],
+        ];
+    }
+
+    /**
+     * A two- or three-letter overlap with a name is coincidence, not a weakness,
+     * and refusing it would be baffling to the person typing.
+     */
+    public function testShortIdentityFragmentsDoNotTripTheCheck(): void
+    {
+        self::assertNull(PasswordPolicy::validate('bramble-thicket', '[email protected]', 'Bo'));
+    }
+
+    public function testAnEmptyIdentityIsNotTreatedAsContainedInEverything(): void
+    {
+        self::assertNull(PasswordPolicy::validate('bramble-thicket', '', ''));
+    }
+}

tests/Unit/Auth/RegistrationPageTest.php

@@ -10,9 +10,11 @@ use Unsupervised\Schedular\Auth\InviteRepository;
 use Unsupervised\Schedular\Auth\RegistrationMailer;
 use Unsupervised\Schedular\Auth\RegistrationPage;
 use Unsupervised\Schedular\GroupClass\GroupAccessRepository;
+use Unsupervised\Schedular\Guardian\GuardianService;
 use Unsupervised\Schedular\Payment\StudioSettings;
 use Unsupervised\Schedular\Policy\AcceptanceRepository;
 use Unsupervised\Schedular\Policy\Policy;
+use Unsupervised\Schedular\Policy\PolicyAcceptance;
 use Unsupervised\Schedular\Policy\PolicyRepository;
 use Unsupervised\Schedular\Policy\PolicyVersion;
 use Unsupervised\Schedular\Policy\PolicyVersionRepository;
@@ -33,10 +35,22 @@ class RegistrationPageTest extends TestCase
 
         Functions\when('wp_unslash')->alias(static fn ($v) => $v);
         Functions\when('sanitize_text_field')->alias(static fn ($v) => $v);
+        // Every submit reads the "who are you registering?" radio through it.
+        Functions\when('sanitize_key')->alias(static fn ($v) => strtolower((string) $v));
         Functions\when('sanitize_textarea_field')->alias(static fn ($v) => $v);
         Functions\when('sanitize_email')->alias(static fn ($v) => $v);
+        // Reached on every submit now that the email is validated before the
+        // password, so the password can be checked against it.
+        Functions\when('is_email')->alias(static fn (string $v): bool => (bool) preg_match('/^[^@\s]+@[^@\s]+\.[^@\s]+$/', $v));
         Functions\when('absint')->alias(static fn ($v) => (int) $v);
-        Functions\when('current_time')->justReturn('2024-01-01 00:00:00');
+        // The birth-year check reads current_time('Y'), so answer that format
+        // properly rather than leaving it to cast out of the datetime string.
+        Functions\when('current_time')->alias(
+            static fn (string $type = 'mysql'): string => 'Y' === $type ? '2024' : '2024-01-01 00:00:00'
+        );
+        Functions\when('wp_enqueue_style')->justReturn(null);
+        Functions\when('wp_enqueue_script')->justReturn(null);
+        Functions\when('wp_localize_script')->justReturn(true);
 
         $invites   = Mockery::mock(InviteRepository::class);
         $policies  = Mockery::mock(PolicyRepository::class);
@@ -61,6 +75,10 @@ class RegistrationPageTest extends TestCase
 
         $this->ctx['versions']    = Mockery::mock(PolicyVersionRepository::class);
         $this->ctx['acceptances'] = Mockery::mock(AcceptanceRepository::class);
+        $this->ctx['guardians']   = Mockery::mock(GuardianService::class);
+        // Recorded on every successful signup; the tests that care assert on it.
+        $this->ctx['guardians']->shouldReceive('setGuardianOnly')->byDefault();
+        $this->ctx['guardians']->shouldReceive('setBirthYear')->byDefault();
 
         $this->ctx['page'] = new RegistrationPage(
             $invites,
@@ -72,6 +90,7 @@ class RegistrationPageTest extends TestCase
             $questions,
             $answers,
             $access,
+            $this->ctx['guardians'],
         );
 
         $_POST = [];
@@ -95,6 +114,17 @@ class RegistrationPageTest extends TestCase
         $this->ctx['settings']->shouldReceive('openRegistrationEnabled')->andReturn(true);
     }
 
+    /** Everything the invite success branch touches once the account is created. */
+    private function stubInviteSuccess(): void
+    {
+        Functions\when('email_exists')->justReturn(false);
+        Functions\when('wp_insert_user')->justReturn(42);
+        Functions\when('is_wp_error')->alias(static fn ($thing): bool => $thing instanceof \WP_Error);
+        Functions\when('wp_set_current_user')->justReturn(null);
+        Functions\when('wp_set_auth_cookie')->justReturn(null);
+        $this->ctx['invites']->shouldReceive('markAccepted')->once();
+    }
+
     private function submit(?Invite $invite, bool $open): string
     {
         $method = new \ReflectionMethod(RegistrationPage::class, 'handleSubmit');
@@ -104,7 +134,7 @@ class RegistrationPageTest extends TestCase
 
     public function testInviteBranchCreatesAndLogsInTheStudent(): void
     {
-        $_POST = [ 'password' => 'password123', 'display_name' => 'Ada' ];
+        $_POST = [ 'password' => 'thistle-marrow-42', 'display_name' => 'Ada', 'birth_year' => '1990' ];
 
         Functions\when('email_exists')->justReturn(false);
         Functions\when('wp_insert_user')->justReturn(42);
@@ -121,7 +151,7 @@ class RegistrationPageTest extends TestCase
 
     public function testInviteAcceptanceLinksClassGrantForTheEmail(): void
     {
-        $_POST = [ 'password' => 'password123', 'display_name' => 'Ada' ];
+        $_POST = [ 'password' => 'thistle-marrow-42', 'display_name' => 'Ada', 'birth_year' => '1990' ];
 
         Functions\when('email_exists')->justReturn(false);
         Functions\when('wp_insert_user')->justReturn(42);
@@ -141,7 +171,7 @@ class RegistrationPageTest extends TestCase
 
     public function testOpenBranchCreatesPendingWithoutLoginAndEmails(): void
     {
-        $_POST = [ 'password' => 'password123', 'display_name' => 'Ada', 'email' => '[email protected]' ];
+        $_POST = [ 'password' => 'thistle-marrow-42', 'display_name' => 'Ada', 'email' => '[email protected]', 'birth_year' => '1990' ];
 
         Functions\when('is_email')->justReturn(true);
         Functions\when('email_exists')->justReturn(false);
@@ -168,7 +198,7 @@ class RegistrationPageTest extends TestCase
 
     public function testGroupInviteCreatesPendingAutoApproveAccountEvenWhenClosed(): void
     {
-        $_POST = [ 'password' => 'password123', 'display_name' => 'Ada', 'email' => '[email protected]' ];
+        $_POST = [ 'password' => 'thistle-marrow-42', 'display_name' => 'Ada', 'email' => '[email protected]', 'birth_year' => '1990' ];
 
         Functions\when('is_email')->justReturn(true);
         Functions\when('email_exists')->justReturn(false);
@@ -336,7 +366,7 @@ class RegistrationPageTest extends TestCase
 
     public function testRejectsWhenARequiredPolicyIsUnaccepted(): void
     {
-        $_POST = [ 'password' => 'password123', 'display_name' => 'Ada', 'email' => '[email protected]' ];
+        $_POST = [ 'password' => 'thistle-marrow-42', 'display_name' => 'Ada', 'email' => '[email protected]', 'birth_year' => '1990' ];
 
         Functions\when('is_email')->justReturn(true);
 
@@ -355,7 +385,7 @@ class RegistrationPageTest extends TestCase
 
     public function testRejectsWhenARequiredAccountQuestionIsUnanswered(): void
     {
-        $_POST = [ 'password' => 'password123', 'display_name' => 'Ada', 'email' => '[email protected]' ];
+        $_POST = [ 'password' => 'thistle-marrow-42', 'display_name' => 'Ada', 'email' => '[email protected]', 'birth_year' => '1990' ];
 
         Functions\when('is_email')->justReturn(true);
 
@@ -375,8 +405,9 @@ class RegistrationPageTest extends TestCase
     public function testRecordsAccountAnswersOnSuccess(): void
     {
         $_POST = [
-            'password'     => 'password123',
+            'password'     => 'thistle-marrow-42',
             'display_name' => 'Ada',
+            'birth_year'   => '1990',
             'us_answers'   => [ '5' => 'By a friend' ],
         ];
 
@@ -409,7 +440,7 @@ class RegistrationPageTest extends TestCase
 
     public function testMaybeHandleSubmitLogsInInviteAndRedirects(): void
     {
-        $_POST    = [ 'us_register' => '1', 'password' => 'password123', 'display_name' => 'Ada' ];
+        $_POST    = [ 'us_register' => '1', 'password' => 'thistle-marrow-42', 'display_name' => 'Ada', 'birth_year' => '1990' ];
         $_REQUEST = [ 'us_invite' => 'raw-token' ];
 
         Functions\when('is_user_logged_in')->justReturn(false);
@@ -442,6 +473,7 @@ class RegistrationPageTest extends TestCase
                 $this->ctx['questions'],
                 $this->ctx['answers'],
                 $this->ctx['access'],
+                $this->ctx['guardians'],
             ]
         )->makePartial()->shouldAllowMockingProtectedMethods();
 
@@ -495,11 +527,61 @@ class RegistrationPageTest extends TestCase
         Functions\when('is_user_logged_in')->justReturn(true);
         Functions\when('sanitize_key')->alias(static fn ($v) => strtolower((string) $v));
         Functions\expect('get_permalink')->once()->with(4)->andReturn('http://home.test/welcome/');
+        Functions\when('get_the_title')->justReturn('Book a Lesson');
 
         $html = $this->ctx['page']->render([ 'loginPageId' => 4 ]);
 
         self::assertStringContainsString('now logged in', $html);
         self::assertStringContainsString('href="http://home.test/welcome/"', $html);
+        // The link names its destination rather than saying "your account".
+        self::assertStringContainsString('Continue to Book a Lesson', $html);
+    }
+
+    public function testContinueLinkFallsBackToGenericWordingForAnUntitledPage(): void
+    {
+        Functions\when('is_user_logged_in')->justReturn(true);
+        Functions\when('sanitize_key')->alias(static fn ($v) => strtolower((string) $v));
+        Functions\when('get_permalink')->justReturn('http://home.test/welcome/');
+        Functions\when('get_the_title')->justReturn('  ');
+
+        // An untitled page must not produce a link reading "Continue to ".
+        $html = $this->ctx['page']->render([ 'loginPageId' => 4 ]);
+
+        self::assertStringContainsString('Continue to your account', $html);
+        self::assertStringContainsString('href="http://home.test/welcome/"', $html);
+    }
+
+    public function testAlreadyLoggedInVisitorIsLinkedToTheChosenPage(): void
+    {
+        // No us_registered flag: someone who simply happens to be signed in and
+        // lands on the registration page. They still need a way onward.
+        Functions\when('is_user_logged_in')->justReturn(true);
+        Functions\when('sanitize_key')->alias(static fn ($v) => strtolower((string) $v));
+        Functions\expect('get_permalink')->once()->with(4)->andReturn('http://home.test/welcome/');
+        Functions\when('get_the_title')->justReturn('Book a Lesson');
+
+        $html = $this->ctx['page']->render([ 'loginPageId' => 4 ]);
+
+        self::assertStringContainsString('already have an account', $html);
+        self::assertStringContainsString('href="http://home.test/welcome/"', $html);
+        self::assertStringContainsString('Continue to Book a Lesson', $html);
+        // Not the just-registered message — that branch needs its own flag.
+        self::assertStringNotContainsString('us-success', $html);
+    }
+
+    public function testAlreadyLoggedInVisitorGetsNoLinkWithoutAChosenPage(): void
+    {
+        Functions\when('is_user_logged_in')->justReturn(true);
+        Functions\when('sanitize_key')->alias(static fn ($v) => strtolower((string) $v));
+        Functions\when('get_permalink')->justReturn(false);
+
+        // A deleted page resolves to false, which must not become a broken link.
+        $html = $this->ctx['page']->render([ 'loginPageId' => 4 ]);
+
+        self::assertStringContainsString('already have an account', $html);
+        self::assertStringNotContainsString('<a href', $html);
+
+        self::assertStringNotContainsString('<a href', $this->ctx['page']->render([]));
     }
 
     public function testContinueUrlIsNullWithoutAResolvablePage(): void
@@ -548,4 +630,774 @@ class RegistrationPageTest extends TestCase
         self::assertStringContainsString('Ask the front desk for a link.', $html);
         self::assertStringNotContainsString('by invitation only', $html);
     }
+
+    /**
+     * A guardian's signup creates one login-less child per filled block, links
+     * them, and records each child's answers against the child rather than the
+     * account holder — the questions describe the student, not the parent.
+     */
+    public function testGuardianSignupCreatesEachChildAndRecordsTheirAnswers(): void
+    {
+        $_POST = [
+            'password'       => 'thistle-marrow-42',
+            'display_name'   => 'Grace',
+            'us_registering_for' => RegistrationPage::FOR_STUDENTS,
+            'children'       => [
+                ['name' => 'Ada', 'birth_year' => '2015', 'answers' => [7 => 'Piano']],
+                ['name' => 'Alan', 'birth_year' => '2017', 'answers' => [7 => 'Violin']],
+                // An untouched spare block is dropped, not rejected.
+                ['name' => '  ', 'birth_year' => '', 'answers' => []],
+            ],
+        ];
+
+        $this->ctx['questions']->shouldReceive('findByScope')->andReturn([
+            new Question(offeringId: null, label: 'Instrument', isRequired: true, scope: Question::SCOPE_ACCOUNT, id: 7),
+        ]);
+
+        Functions\when('email_exists')->justReturn(false);
+        Functions\when('wp_insert_user')->justReturn(42);
+        Functions\when('is_wp_error')->alias(static fn ($thing): bool => $thing instanceof \WP_Error);
+
+        $this->ctx['guardians']->shouldReceive('createChild')->once()->with(42, 'Ada', '2015')->andReturn(101);
+        $this->ctx['guardians']->shouldReceive('createChild')->once()->with(42, 'Alan', '2017')->andReturn(102);
+
+        $recorded = [];
+        $this->ctx['answers']->shouldReceive('insert')->andReturnUsing(
+            static function (Answer $a) use (&$recorded): int {
+                $recorded[] = [$a->studentId, $a->answerValue];
+                return 1;
+            }
+        );
+
+        $this->ctx['invites']->shouldReceive('markAccepted')->once();
+        Functions\expect('wp_set_current_user')->once()->with(42);
+        Functions\expect('wp_set_auth_cookie')->once()->with(42);
+
+        self::assertSame('invite', $this->submit(new Invite(email: '[email protected]', token: 'hash'), false));
+        self::assertSame([[101, 'Piano'], [102, 'Violin']], $recorded);
+    }
+
+    /**
+     * The browser gates on zxcvbn, but that is advice a client can decline to
+     * take. Nothing is created for a password the server refuses.
+     *
+     * @dataProvider refusedPasswords
+     */
+    public function testSignupRefusesAPasswordThePolicyRejects(string $password, string $expected): void
+    {
+        $_POST = [
+            'email'        => '[email protected]',
+            'password'     => $password,
+            'display_name' => 'Grace Hopper',
+        ];
+
+        Functions\when('email_exists')->justReturn(false);
+        Functions\expect('wp_insert_user')->never();
+
+        self::assertStringContainsString(
+            $expected,
+            $this->submit(new Invite(email: '[email protected]', token: 'hash'), false)
+        );
+    }
+
+    /** @return array<string, array{string, string}> */
+    public static function refusedPasswords(): array
+    {
+        return [
+            'too short'         => ['abc123', 'at least'],
+            'a known password'  => ['password123', 'commonly used'],
+            'barely any variety' => ['ababababab', 'repeated characters'],
+            'their own name'    => ['grace-hopper-1906', 'name or email'],
+        ];
+    }
+
+    public function testSignupRefusesAnAddressThatIsNotAnEmail(): void
+    {
+        $_POST = [
+            'email'        => 'not-an-email',
+            'password'     => 'thistle-marrow-42',
+            'display_name' => 'Grace',
+        ];
+
+        Functions\when('email_exists')->justReturn(false);
+        Functions\expect('wp_insert_user')->never();
+
+        self::assertStringContainsString(
+            'valid email address',
+            $this->submit(null, true)
+        );
+    }
+
+    /**
+     * "On behalf of students" is the one choice that says the account holder is
+     * not a student, so it is the one that sets the flag.
+     */
+    public function testRegisteringOnlyForStudentsMarksTheAccountGuardianOnly(): void
+    {
+        $_POST = [
+            'password'           => 'thistle-marrow-42',
+            'display_name'       => 'Grace',
+            'us_registering_for' => RegistrationPage::FOR_STUDENTS,
+            'children'           => [['name' => 'Ada', 'birth_year' => '2015', 'answers' => []]],
+        ];
+
+        $this->ctx['questions']->shouldReceive('findByScope')->andReturn([]);
+        $this->ctx['guardians']->shouldReceive('createChild')->once()->andReturn(101);
+        $this->stubInviteSuccess();
+
+        $this->ctx['guardians']->shouldReceive('setGuardianOnly')->once()->with(42, true);
+
+        self::assertSame('invite', $this->submit(new Invite(email: '[email protected]', token: 'hash'), false));
+    }
+
+    /**
+     * @dataProvider modesThatKeepTheAccountHolderAStudent
+     */
+    public function testTheAccountHolderStaysAStudentForTheOtherTwoChoices(string $mode, bool $withChildren): void
+    {
+        $_POST = [
+            'password'           => 'thistle-marrow-42',
+            'display_name'       => 'Grace',
+            'birth_year'         => '1990',
+            'us_registering_for' => $mode,
+        ];
+
+        if ($withChildren) {
+            $_POST['children'] = [['name' => 'Ada', 'birth_year' => '2015', 'answers' => []]];
+            $this->ctx['guardians']->shouldReceive('createChild')->once()->andReturn(101);
+        }
+
+        $this->ctx['questions']->shouldReceive('findByScope')->andReturn([]);
+        $this->stubInviteSuccess();
+
+        $this->ctx['guardians']->shouldReceive('setGuardianOnly')->once()->with(42, false);
+
+        self::assertSame('invite', $this->submit(new Invite(email: '[email protected]', token: 'hash'), false));
+    }
+
+    /** @return array<string, array{string, bool}> */
+    public static function modesThatKeepTheAccountHolderAStudent(): array
+    {
+        return [
+            'just myself'          => [RegistrationPage::FOR_SELF, false],
+            'myself and students'  => [RegistrationPage::FOR_BOTH, true],
+        ];
+    }
+
+    /**
+     * "Both" collects students exactly as "on behalf of" does — the only
+     * difference is whether the account holder is one of them.
+     */
+    public function testBothStillRequiresAtLeastOneStudent(): void
+    {
+        $_POST = [
+            'password'           => 'thistle-marrow-42',
+            'display_name'       => 'Grace',
+            'us_registering_for' => RegistrationPage::FOR_BOTH,
+            'children'           => [],
+        ];
+
+        $this->ctx['questions']->shouldReceive('findByScope')->andReturn([]);
+        Functions\when('email_exists')->justReturn(false);
+        Functions\expect('wp_insert_user')->never();
+
+        self::assertStringContainsString('at least one student', $this->submit(new Invite(email: '[email protected]', token: 'hash'), false));
+    }
+
+    /**
+     * A form posted without the radio — an old cached page, or a crafted
+     * request — must fall to the choice that collects and grants the least,
+     * never be read as "register these children".
+     */
+    public function testAMissingOrUnknownChoiceFallsBackToJustMyself(): void
+    {
+        $_POST = [
+            'password'           => 'thistle-marrow-42',
+            'display_name'       => 'Grace',
+            'birth_year'         => '1990',
+            'us_registering_for' => 'something-else',
+            'children'           => [['name' => 'Ada', 'birth_year' => '2015', 'answers' => []]],
+        ];
+
+        $this->ctx['questions']->shouldReceive('findByScope')->andReturn([]);
+        $this->stubInviteSuccess();
+
+        // No student is created from children[] the caller never asked to register.
+        $this->ctx['guardians']->shouldNotReceive('createChild');
+        $this->ctx['guardians']->shouldReceive('setGuardianOnly')->once()->with(42, false);
+
+        self::assertSame('invite', $this->submit(new Invite(email: '[email protected]', token: 'hash'), false));
+    }
+
+    /**
+     * Under "both" the account holder is a student too, so the studio's
+     * questions are asked of them as well as of each student they add. Before
+     * this they were asked per student only, and the account holder's own
+     * answers were never collected or stored.
+     */
+    public function testBothRecordsAnswersForTheAccountHolderAndEachStudent(): void
+    {
+        $_POST = [
+            'password'           => 'thistle-marrow-42',
+            'display_name'       => 'Grace',
+            'birth_year'         => '1990',
+            'us_registering_for' => RegistrationPage::FOR_BOTH,
+            'us_answers'         => ['7' => 'Cello'],
+            'children'           => [['name' => 'Ada', 'birth_year' => '2015', 'answers' => [7 => 'Piano']]],
+        ];
+
+        $question = new Question(null, 'Instrument', isRequired: true, scope: Question::SCOPE_ACCOUNT, id: 7);
+        $this->ctx['questions']->shouldReceive('findByScope')->andReturn([$question]);
+        $this->ctx['guardians']->shouldReceive('createChild')->once()->andReturn(101);
+        $this->stubInviteSuccess();
+
+        $recorded = [];
+        $this->ctx['answers']->shouldReceive('insert')->andReturnUsing(
+            static function (Answer $answer) use (&$recorded): int {
+                $recorded[] = [$answer->studentId, $answer->answerValue];
+                return 1;
+            }
+        );
+
+        self::assertSame('invite', $this->submit(new Invite(email: '[email protected]', token: 'hash'), false));
+
+        // The student's answer against the student, the account holder's against
+        // themselves — not one answer shared between them.
+        self::assertEqualsCanonicalizing([[101, 'Piano'], [42, 'Cello']], $recorded);
+    }
+
+    public function testBothRejectsAnUnansweredQuestionForTheAccountHolder(): void
+    {
+        $_POST = [
+            'password'           => 'thistle-marrow-42',
+            'display_name'       => 'Grace',
+            'birth_year'         => '1990',
+            'us_registering_for' => RegistrationPage::FOR_BOTH,
+            'us_answers'         => ['7' => '   '],
+            'children'           => [['name' => 'Ada', 'birth_year' => '2015', 'answers' => [7 => 'Piano']]],
+        ];
+
+        $question = new Question(null, 'Instrument', isRequired: true, scope: Question::SCOPE_ACCOUNT, id: 7);
+        $this->ctx['questions']->shouldReceive('findByScope')->andReturn([$question]);
+        Functions\when('email_exists')->justReturn(false);
+        Functions\expect('wp_insert_user')->never();
+
+        $result = $this->submit(new Invite(email: '[email protected]', token: 'hash'), false);
+
+        // The message names nobody else — the student's answer was fine.
+        self::assertStringContainsString('Please answer all required registration questions.', $result);
+        self::assertStringNotContainsString('for each student', $result);
+    }
+
+    /**
+     * A pure guardian is not a student, so the questions are theirs to answer
+     * per student and never about them. Anything posted for them is ignored.
+     */
+    public function testRegisteringOnlyForStudentsStoresNoAnswersForTheAccountHolder(): void
+    {
+        $_POST = [
+            'password'           => 'thistle-marrow-42',
+            'display_name'       => 'Grace',
+            'us_registering_for' => RegistrationPage::FOR_STUDENTS,
+            'us_answers'         => ['7' => 'Should be ignored'],
+            'children'           => [['name' => 'Ada', 'birth_year' => '2015', 'answers' => [7 => 'Piano']]],
+        ];
+
+        $question = new Question(null, 'Instrument', isRequired: true, scope: Question::SCOPE_ACCOUNT, id: 7);
+        $this->ctx['questions']->shouldReceive('findByScope')->andReturn([$question]);
+        $this->ctx['guardians']->shouldReceive('createChild')->once()->andReturn(101);
+        $this->stubInviteSuccess();
+
+        $students = [];
+        $this->ctx['answers']->shouldReceive('insert')->andReturnUsing(
+            static function (Answer $answer) use (&$students): int {
+                $students[] = $answer->studentId;
+                return 1;
+            }
+        );
+
+        self::assertSame('invite', $this->submit(new Invite(email: '[email protected]', token: 'hash'), false));
+        self::assertSame([101], $students);
+    }
+
+    public function testGuardianSignupWithNoChildrenIsRejected(): void
+    {
+        $_POST = [
+            'password'       => 'thistle-marrow-42',
+            'display_name'   => 'Grace',
+            'us_registering_for' => RegistrationPage::FOR_STUDENTS,
+            'children'       => [['name' => '', 'birth_year' => '', 'answers' => []]],
+        ];
+
+        Functions\when('email_exists')->justReturn(false);
+        Functions\expect('wp_insert_user')->never();
+        $this->ctx['guardians']->shouldNotReceive('createChild');
+
+        $result = $this->submit(new Invite(email: '[email protected]', token: 'hash'), false);
+
+        self::assertStringContainsString('at least one student', $result);
+    }
+
+    /**
+     * A block the guardian actually typed into is theirs to correct, not ours to
+     * discard — only a wholly untouched spare is dropped. Losing the birth year
+     * they filled in and registering a nameless student would be worse than
+     * telling them what is missing.
+     */
+    public function testGuardianSignupRejectsAHalfFilledChildRatherThanDroppingIt(): void
+    {
+        $_POST = [
+            'password'       => 'thistle-marrow-42',
+            'display_name'   => 'Grace',
+            'us_registering_for' => RegistrationPage::FOR_STUDENTS,
+            'children'       => [
+                ['name' => 'Ada', 'birth_year' => '2015', 'answers' => []],
+                ['name' => '', 'birth_year' => '2017', 'answers' => []],
+            ],
+        ];
+
+        $this->ctx['questions']->shouldReceive('findByScope')->andReturn([]);
+        Functions\when('email_exists')->justReturn(false);
+        Functions\expect('wp_insert_user')->never();
+        $this->ctx['guardians']->shouldNotReceive('createChild');
+
+        self::assertStringContainsString(
+            'give each student a name',
+            $this->submit(new Invite(email: '[email protected]', token: 'hash'), false)
+        );
+    }
+
+    /**
+     * @dataProvider rejectedBirthYears
+     */
+    public function testGuardianSignupRejectsAChildWithoutAUsableBirthYear(string $submitted): void
+    {
+        $_POST = [
+            'password'       => 'thistle-marrow-42',
+            'display_name'   => 'Grace',
+            'us_registering_for' => RegistrationPage::FOR_STUDENTS,
+            'children'       => [['name' => 'Ada', 'birth_year' => $submitted, 'answers' => []]],
+        ];
+
+        $this->ctx['questions']->shouldReceive('findByScope')->andReturn([]);
+        Functions\when('email_exists')->justReturn(false);
+        Functions\expect('wp_insert_user')->never();
+        $this->ctx['guardians']->shouldNotReceive('createChild');
+
+        self::assertStringContainsString(
+            'birth year',
+            $this->submit(new Invite(email: '[email protected]', token: 'hash'), false)
+        );
+    }
+
+    /** @return array<string, array{string}> */
+    public static function rejectedBirthYears(): array
+    {
+        return [
+            'left blank'  => [''],
+            'a full date' => ['2015-04-02'],
+            'in the future' => ['2027'],
+        ];
+    }
+
+    /**
+     * Required per-child answers are validated before any user exists, so a
+     * missing one never leaves a half-registered family behind.
+     */
+    public function testGuardianSignupRejectsAChildMissingARequiredAnswer(): void
+    {
+        $_POST = [
+            'password'       => 'thistle-marrow-42',
+            'display_name'   => 'Grace',
+            'us_registering_for' => RegistrationPage::FOR_STUDENTS,
+            'children'       => [
+                ['name' => 'Ada', 'birth_year' => '2015', 'answers' => [7 => 'Piano']],
+                ['name' => 'Alan', 'birth_year' => '2017', 'answers' => [7 => '  ']],
+            ],
+        ];
+
+        $this->ctx['questions']->shouldReceive('findByScope')->andReturn([
+            new Question(offeringId: null, label: 'Instrument', isRequired: true, scope: Question::SCOPE_ACCOUNT, isRequiredChild: true, id: 7),
+        ]);
+
+        Functions\when('email_exists')->justReturn(false);
+        Functions\expect('wp_insert_user')->never();
+        $this->ctx['guardians']->shouldNotReceive('createChild');
+
+        self::assertStringContainsString('for each student', $this->submit(new Invite(email: '[email protected]', token: 'hash'), false));
+    }
+
+    /**
+     * A family that half-created would leave the guardian unable to re-register
+     * and their children unconfirmed, so the whole signup is undone.
+     */
+    public function testAFailedChildRollsBackEveryUserCreatedIncludingTheGuardian(): void
+    {
+        $_POST = [
+            'password'       => 'thistle-marrow-42',
+            'display_name'   => 'Grace',
+            'us_registering_for' => RegistrationPage::FOR_STUDENTS,
+            'children'       => [
+                ['name' => 'Ada', 'birth_year' => '2015', 'answers' => []],
+                ['name' => 'Alan', 'birth_year' => '2017', 'answers' => []],
+            ],
+        ];
+
+        Functions\when('email_exists')->justReturn(false);
+        Functions\when('wp_insert_user')->justReturn(42);
+        Functions\when('is_wp_error')->alias(static fn ($thing): bool => $thing instanceof \WP_Error);
+
+        $this->ctx['guardians']->shouldReceive('createChild')->once()->with(42, 'Ada', '2015')->andReturn(101);
+        $this->ctx['guardians']->shouldReceive('createChild')->once()->with(42, 'Alan', '2017')
+            ->andReturn(new \WP_Error('link_failed', 'Nope.'));
+
+        $deleted = [];
+        $this->ctx['guardians']->shouldReceive('deleteUser')->andReturnUsing(
+            static function (int $id) use (&$deleted): void {
+                $deleted[] = $id;
+            }
+        );
+
+        $result = $this->submit(new Invite(email: '[email protected]', token: 'hash'), false);
+
+        self::assertStringContainsString('Could not create the account', $result);
+        self::assertSame([101, 42], $deleted);
+    }
+
+    /**
+     * The child is who the policy binds; the guardian is who agreed. Both are
+     * recorded, which is what makes the acceptance legally meaningful.
+     */
+    public function testSignupPoliciesAreAcceptedPerChildAndAttributedToTheGuardian(): void
+    {
+        $_POST = [
+            'password'       => 'thistle-marrow-42',
+            'display_name'   => 'Grace',
+            'us_registering_for' => RegistrationPage::FOR_STUDENTS,
+            'accept'         => [3],
+            'children'       => [['name' => 'Ada', 'birth_year' => '2015', 'answers' => []]],
+        ];
+
+        $version = new PolicyVersion(policyId: 1, versionNumber: 1, body: 'Terms', status: PolicyVersion::STATUS_PUBLISHED, id: 3);
+        $this->ctx['policies']->shouldReceive('findForScope')->andReturn([
+            new Policy(title: 'Studio Terms', slug: 'terms', currentVersionId: 3, id: 1),
+        ]);
+        $this->ctx['versions']->shouldReceive('findById')->with(3)->andReturn($version);
+
+        Functions\when('email_exists')->justReturn(false);
+        Functions\when('wp_insert_user')->justReturn(42);
+        Functions\when('is_wp_error')->alias(static fn ($thing): bool => $thing instanceof \WP_Error);
+
+        $this->ctx['guardians']->shouldReceive('createChild')->once()->andReturn(101);
+
+        $recorded = [];
+        $this->ctx['acceptances']->shouldReceive('insert')->andReturnUsing(
+            static function (PolicyAcceptance $a) use (&$recorded): int {
+                $recorded[] = [$a->studentId, $a->acceptedBy];
+                return 1;
+            }
+        );
+
+        $this->ctx['invites']->shouldReceive('markAccepted')->once();
+        Functions\expect('wp_set_current_user')->once();
+        Functions\expect('wp_set_auth_cookie')->once();
+
+        self::assertSame('invite', $this->submit(new Invite(email: '[email protected]', token: 'hash'), false));
+
+        // The guardian agreed for themselves as an account holder, and for the child.
+        self::assertSame([[42, 42], [101, 42]], $recorded);
+    }
+
+    public function testANonGuardianSignupIsUnchangedAndCreatesNoChildren(): void
+    {
+        $_POST = ['password' => 'thistle-marrow-42', 'display_name' => 'Ada', 'birth_year' => '1990'];
+
+        Functions\when('email_exists')->justReturn(false);
+        Functions\when('wp_insert_user')->justReturn(42);
+        Functions\when('is_wp_error')->justReturn(false);
+
+        $this->ctx['guardians']->shouldNotReceive('createChild');
+        $this->ctx['invites']->shouldReceive('markAccepted')->once();
+        Functions\expect('wp_set_current_user')->once();
+        Functions\expect('wp_set_auth_cookie')->once();
+
+        self::assertSame('invite', $this->submit(new Invite(email: '[email protected]', token: 'hash'), false));
+    }
+
+    /**
+     * The account holder is a student under "self" and "both", so they give the
+     * same birth year every other student does — and it is stored against their
+     * own account under the same meta key a child's uses.
+     *
+     * @dataProvider modesWhereTheAccountHolderIsAStudent
+     */
+    public function testTheAccountHoldersBirthYearIsRecordedWhenTheyAreAStudent(string $mode, bool $withChildren): void
+    {
+        $_POST = [
+            'password'           => 'thistle-marrow-42',
+            'display_name'       => 'Grace',
+            'birth_year'         => '1988',
+            'us_registering_for' => $mode,
+        ];
+
+        if ($withChildren) {
+            $_POST['children'] = [['name' => 'Ada', 'birth_year' => '2015', 'answers' => []]];
+            $this->ctx['guardians']->shouldReceive('createChild')->once()->andReturn(101);
+        }
+
+        $this->stubInviteSuccess();
+
+        $this->ctx['guardians']->shouldReceive('setBirthYear')->once()->with(42, '1988');
+
+        self::assertSame('invite', $this->submit(new Invite(email: '[email protected]', token: 'hash'), false));
+    }
+
+    /** @return array<string, array{string, bool}> */
+    public static function modesWhereTheAccountHolderIsAStudent(): array
+    {
+        return [
+            'just myself'         => [RegistrationPage::FOR_SELF, false],
+            'myself and students' => [RegistrationPage::FOR_BOTH, true],
+        ];
+    }
+
+    /**
+     * Missing or nonsense years are refused before a single user is created, the
+     * same way a student's is — the browser's `required` cannot be trusted here
+     * because the panel is hidden for a pure guardian.
+     *
+     * @dataProvider unusableBirthYears
+     */
+    public function testAnUnusableBirthYearForTheAccountHolderIsRejected(string $submitted): void
+    {
+        $_POST = [
+            'password'     => 'thistle-marrow-42',
+            'display_name' => 'Grace',
+            'birth_year'   => $submitted,
+        ];
+
+        Functions\when('email_exists')->justReturn(false);
+        Functions\expect('wp_insert_user')->never();
+
+        $result = $this->submit(new Invite(email: '[email protected]', token: 'hash'), false);
+
+        // Addressed to the person filling the form in, not to "each student".
+        self::assertStringContainsString('Please give your birth year', $result);
+        self::assertStringNotContainsString('each student', $result);
+    }
+
+    /** @return array<string, array{string}> */
+    public static function unusableBirthYears(): array
+    {
+        return [
+            'missing'    => [''],
+            'two digits' => ['88'],
+            'not a year' => ['nineteen'],
+            'in future'  => ['3000'],
+        ];
+    }
+
+    /**
+     * A pure guardian is not a student, so no birth year is asked of them and
+     * none is stored — anything posted for one is ignored, exactly as their
+     * answers are.
+     */
+    public function testNoBirthYearIsStoredForAGuardianWhoIsNotAStudent(): void
+    {
+        $_POST = [
+            'password'           => 'thistle-marrow-42',
+            'display_name'       => 'Grace',
+            'birth_year'         => 'should be ignored',
+            'us_registering_for' => RegistrationPage::FOR_STUDENTS,
+            'children'           => [['name' => 'Ada', 'birth_year' => '2015', 'answers' => []]],
+        ];
+
+        $this->ctx['guardians']->shouldReceive('createChild')->once()->andReturn(101);
+        $this->stubInviteSuccess();
+
+        $this->ctx['guardians']->shouldNotReceive('setBirthYear');
+
+        self::assertSame('invite', $this->submit(new Invite(email: '[email protected]', token: 'hash'), false));
+    }
+
+    /**
+     * Everything the studio needs is asked on one page: the account holder's own
+     * birth year and questions sit above the students they are adding, and there
+     * is no second step to advance to.
+     */
+    public function testTheFormAsksTheAccountHoldersQuestionsAboveTheStudents(): void
+    {
+        $this->stubRenderContext();
+
+        $question = new Question(null, 'Instrument', isRequired: true, scope: Question::SCOPE_ACCOUNT, id: 7);
+        $this->ctx['questions']->shouldReceive('findByScope')->with(Question::SCOPE_ACCOUNT, Mockery::any())->andReturn([$question]);
+
+        $html = $this->ctx['page']->render([]);
+
+        self::assertStringContainsString('name="birth_year"', $html);
+        self::assertStringContainsString('name="us_answers[7]"', $html);
+
+        // One page, one submit: no "Next", no step panels.
+        self::assertStringNotContainsString('us-reg-next', $html);
+        self::assertStringNotContainsString('data-step', $html);
+
+        self::assertLessThan(
+            strpos($html, 'id="us-children"'),
+            strpos($html, 'name="us_answers[7]"'),
+            'The account holder answers the questions above the students they are adding.'
+        );
+    }
+
+    /**
+     * A "students only" question describes a child being registered, so it is put
+     * to each student and never to the account holder about themselves.
+     */
+    public function testAStudentsOnlyQuestionIsAskedOfTheStudentsAndNotOfTheAccountHolder(): void
+    {
+        $this->stubRenderContext();
+
+        $question = new Question(
+            null,
+            'School and grade',
+            scope: Question::SCOPE_ACCOUNT,
+            audience: Question::AUDIENCE_CHILD,
+            isRequiredChild: true,
+            id: 7
+        );
+        $this->ctx['questions']->shouldReceive('findByScope')->with(Question::SCOPE_ACCOUNT, Mockery::any())->andReturn([$question]);
+
+        $html = $this->ctx['page']->render([]);
+
+        self::assertStringNotContainsString('name="us_answers[7]"', $html);
+        self::assertStringContainsString('name="children[0][answers][7]"', $html);
+    }
+
+    /**
+     * The two required flags are read where each applies: the browser is asked to
+     * enforce the account holder's, and the students' block carries the marker
+     * without the attribute (it may not be in play at all).
+     */
+    public function testTheFormMarksAQuestionRequiredWhereItActuallyIs(): void
+    {
+        $this->stubRenderContext();
+
+        $question = new Question(
+            null,
+            'Previous experience',
+            scope: Question::SCOPE_ACCOUNT,
+            isRequired: false,
+            isRequiredChild: true,
+            id: 7
+        );
+        $this->ctx['questions']->shouldReceive('findByScope')->with(Question::SCOPE_ACCOUNT, Mockery::any())->andReturn([$question]);
+
+        $html = $this->ctx['page']->render([]);
+
+        // No `required` attribute on the account holder's copy, and no marker on
+        // its label — they may leave it blank.
+        self::assertStringContainsString('<input type="text" name="us_answers[7]" id="us-reg-q-7">', $html);
+        self::assertStringContainsString('<label for="us-reg-q-7">Previous experience</label>', $html);
+
+        // The student's copy is marked required, without the attribute: the block
+        // may not be in play at all, so the server is what enforces it.
+        self::assertStringContainsString('<label for="us-child-0-q-7">Previous experience <span class="us-required" aria-hidden="true">*</span></label>', $html);
+        self::assertStringContainsString('<input type="text" name="children[0][answers][7]" id="us-child-0-q-7">', $html);
+    }
+
+    /**
+     * The point of the two flags: an adult signing themselves up can leave the
+     * question blank, while every student they enrol must answer it.
+     */
+    public function testAQuestionOptionalForYouIsStillRequiredOfEachStudent(): void
+    {
+        $_POST = [
+            'password'           => 'thistle-marrow-42',
+            'display_name'       => 'Grace',
+            'birth_year'         => '1990',
+            'us_registering_for' => RegistrationPage::FOR_BOTH,
+            'us_answers'         => ['7' => '  '],
+            'children'           => [['name' => 'Ada', 'birth_year' => '2015', 'answers' => [7 => '  ']]],
+        ];
+
+        $question = new Question(null, 'Instrument', isRequired: false, scope: Question::SCOPE_ACCOUNT, isRequiredChild: true, id: 7);
+        $this->ctx['questions']->shouldReceive('findByScope')->andReturn([$question]);
+        Functions\when('email_exists')->justReturn(false);
+        Functions\expect('wp_insert_user')->never();
+
+        $result = $this->submit(new Invite(email: '[email protected]', token: 'hash'), false);
+
+        // The student's blank is what stopped it — the account holder's was fine.
+        self::assertStringContainsString('for each student', $result);
+    }
+
+    public function testTheAccountHolderMayLeaveBlankWhatTheirStudentsMustAnswer(): void
+    {
+        $_POST = [
+            'password'           => 'thistle-marrow-42',
+            'display_name'       => 'Grace',
+            'birth_year'         => '1990',
+            'us_registering_for' => RegistrationPage::FOR_BOTH,
+            'us_answers'         => ['7' => '  '],
+            'children'           => [['name' => 'Ada', 'birth_year' => '2015', 'answers' => [7 => 'Piano']]],
+        ];
+
+        $question = new Question(null, 'Instrument', isRequired: false, scope: Question::SCOPE_ACCOUNT, isRequiredChild: true, id: 7);
+        $this->ctx['questions']->shouldReceive('findByScope')->andReturn([$question]);
+        $this->ctx['guardians']->shouldReceive('createChild')->once()->andReturn(101);
+        $this->stubInviteSuccess();
+
+        $students = [];
+        $this->ctx['answers']->shouldReceive('insert')->andReturnUsing(
+            static function (Answer $answer) use (&$students): int {
+                $students[] = $answer->studentId;
+                return 1;
+            }
+        );
+
+        self::assertSame('invite', $this->submit(new Invite(email: '[email protected]', token: 'hash'), false));
+
+        // Only the student answered, so only the student has an answer stored.
+        self::assertSame([101], $students);
+    }
+
+    /**
+     * A question the account holder is never shown cannot be one they are held
+     * to, nor one an answer can be filed against them for — a crafted post that
+     * supplies both is ignored on both counts.
+     */
+    public function testAStudentsOnlyQuestionNeitherBlocksNorStoresAgainstTheAccountHolder(): void
+    {
+        $_POST = [
+            'password'           => 'thistle-marrow-42',
+            'display_name'       => 'Grace',
+            'birth_year'         => '1990',
+            'us_registering_for' => RegistrationPage::FOR_BOTH,
+            'us_answers'         => ['7' => 'Crafted by hand'],
+            'children'           => [['name' => 'Ada', 'birth_year' => '2015', 'answers' => [7 => 'Grade 4']]],
+        ];
+
+        $question = new Question(
+            null,
+            'School and grade',
+            isRequired: true,
+            scope: Question::SCOPE_ACCOUNT,
+            audience: Question::AUDIENCE_CHILD,
+            isRequiredChild: true,
+            id: 7
+        );
+        $this->ctx['questions']->shouldReceive('findByScope')->andReturn([$question]);
+        $this->ctx['guardians']->shouldReceive('createChild')->once()->andReturn(101);
+        $this->stubInviteSuccess();
+
+        $recorded = [];
+        $this->ctx['answers']->shouldReceive('insert')->andReturnUsing(
+            static function (Answer $answer) use (&$recorded): int {
+                $recorded[] = [$answer->studentId, $answer->answerValue];
+                return 1;
+            }
+        );
+
+        self::assertSame('invite', $this->submit(new Invite(email: '[email protected]', token: 'hash'), false));
+        self::assertSame([[101, 'Grade 4']], $recorded);
+    }
 }

tests/Unit/Auth/StudentHistoryTest.php

@@ -58,7 +58,7 @@ class StudentHistoryTest extends TestCase
     public function testPolicyAcceptancesResolvePolicyTitleAndVersion(): void
     {
         $this->acceptances->shouldReceive('findByStudent')->once()->with(5)->andReturn([
-            new PolicyAcceptance(9, 5, PolicyAcceptance::REG_ACCOUNT, 5, null, '2026-06-02 09:00:00', 1),
+            new PolicyAcceptance(9, 5, PolicyAcceptance::REG_ACCOUNT, 5, ipAddress: null, acceptedAt: '2026-06-02 09:00:00', id: 1),
         ]);
         $this->policyVersions->shouldReceive('findById')->with(9)
             ->andReturn(new PolicyVersion(2, 3, null, PolicyVersion::STATUS_PUBLISHED, id: 9));
@@ -177,9 +177,9 @@ class StudentHistoryTest extends TestCase
                 Payment::REG_LESSON,
                 12,
                 100.00,
-                'CAD',
-                Payment::METHOD_CARD,
-                Payment::STATUS_PAID,
+                currency: 'CAD',
+                method: Payment::METHOD_CARD,
+                status: Payment::STATUS_PAID,
                 taxRate: 13.0,
                 taxAmount: 13.00,
                 receiptNumber: 'USC-7',
@@ -231,7 +231,7 @@ class StudentHistoryTest extends TestCase
     public function testCreditsBuildDisplayRows(): void
     {
         $this->credits->shouldReceive('findByStudent')->once()->with(5)->andReturn([
-            new Credit(5, 33.00, 13.00, 'CAD', 12, 77, 'Credit for cancelled lesson #77', Credit::STATUS_AVAILABLE, '2026-07-01 09:00:00', id: 300),
+            new Credit(5, 33.00, 13.00, currency: 'CAD', sourcePaymentId: 12, sourceLessonId: 77, reason: 'Credit for cancelled lesson #77', status: Credit::STATUS_AVAILABLE, createdAt: '2026-07-01 09:00:00', id: 300),
         ]);
 
         $rows = $this->history->credits(5);

tests/Unit/Auth/UserNameTest.php

@@ -9,12 +9,21 @@ use Unsupervised\Schedular\Tests\Unit\TestCase;
 
 class UserNameTest extends TestCase
 {
-    private function user(string $first, string $last, string $nickname): \WP_User
-    {
+    private function user(
+        string $first,
+        string $last,
+        string $nickname,
+        string $displayName = '',
+        string $login = 'ada_login',
+        string $email = '[email protected]',
+    ): \WP_User {
         $user = Mockery::mock(\WP_User::class);
         $user->first_name   = $first;
         $user->last_name    = $last;
         $user->nickname     = $nickname;
+        $user->display_name = $displayName;
+        $user->user_login   = $login;
+        $user->user_email   = $email;
 
         return $user;
     }
@@ -34,6 +43,60 @@ class UserNameTest extends TestCase
         self::assertSame('Countess', UserName::format($this->user('', '', 'Countess')));
     }
 
+    /**
+     * WordPress defaults a new account's nickname to its `user_login`, and signup
+     * uses the email address as the login — so a self-registered account carried
+     * its own address as its nickname and every screen naming that person showed
+     * the address. The name they typed was in `display_name` all along.
+     */
+    public function testSkipsANicknameThatIsReallyTheLoginAndUsesTheDisplayName(): void
+    {
+        $user = $this->user(
+            '',
+            '',
+            '[email protected]',
+            'Grace Hopper',
+            login: '[email protected]',
+            email: '[email protected]',
+        );
+
+        self::assertSame('Grace Hopper', UserName::format($user, 42));
+    }
+
+    public function testSkipsANicknameThatIsReallyTheEmailAddress(): void
+    {
+        $user = $this->user(
+            '',
+            '',
+            '[email protected]',
+            'Grace Hopper',
+            login: 'gracehopper',
+            email: '[email protected]',
+        );
+
+        // Case-insensitively: the address is the address however it was typed.
+        self::assertSame('Grace Hopper', UserName::format($user, 42));
+    }
+
+    /**
+     * The whole point of the class: an identifier never reaches the screen, even
+     * when it is the only thing on file. Someone who registered without giving a
+     * name is shown as their id rather than as their email address.
+     */
+    public function testNeverFallsThroughToAnIdentifier(): void
+    {
+        $user = $this->user(
+            '',
+            '',
+            '[email protected]',
+            '[email protected]',
+            login: '[email protected]',
+            email: '[email protected]',
+        );
+
+        self::assertSame('42', UserName::format($user, 42));
+    }
+
     public function testFallsBackToIdWhenNothingSet(): void
     {
         self::assertSame('42', UserName::format($this->user('', '', ''), 42));

tests/Unit/Availability/AvailabilityControllerTest.php

@@ -8,6 +8,7 @@ use Mockery;
 use Unsupervised\Schedular\Availability\AvailabilityController;
 use Unsupervised\Schedular\Availability\AvailabilityRepository;
 use Unsupervised\Schedular\Availability\AvailabilitySlot;
+use Unsupervised\Schedular\Availability\WindowValidator;
 use Unsupervised\Schedular\Offering\OfferingRepository;
 use Unsupervised\Schedular\Tests\Unit\TestCase;
 
@@ -23,7 +24,7 @@ class AvailabilityControllerTest extends TestCase
 
         $this->repository = Mockery::mock(AvailabilityRepository::class);
         $this->offerings  = Mockery::mock(OfferingRepository::class);
-        $this->controller = new AvailabilityController($this->repository, $this->offerings);
+        $this->controller = new AvailabilityController($this->repository, $this->offerings, new WindowValidator($this->offerings));
 
         $_POST = [];
         $_GET  = [];
@@ -39,6 +40,7 @@ class AvailabilityControllerTest extends TestCase
         Functions\when('absint')->alias(static fn ($value) => abs((int) $value));
         Functions\when('get_option')->justReturn(1);
         Functions\when('current_time')->justReturn('2026-07-06');
+        Functions\when('selected')->justReturn('');
         Functions\when('admin_url')->justReturn('admin.php?page=us-availability');
         Functions\when('add_query_arg')->justReturn('admin.php?page=us-availability&usc_view=week');
         Functions\when('wp_nonce_field')->justReturn('');
@@ -131,6 +133,159 @@ class AvailabilityControllerTest extends TestCase
         self::assertStringNotContainsString('name="slot_ids[]" form="usc-bulk-delete-form" value="6"', $html);
     }
 
+    /**
+     * The reported bug: a 30-minute window submitted with the lesson length left
+     * on 60 saved nothing and said nothing. It must now say why.
+     */
+    public function testAddShowsAnErrorWhenTheWindowIsShorterThanTheLessonLength(): void
+    {
+        $_POST = [
+            'usc_action'       => 'add',
+            'start_dt'         => '2026-09-10T17:30',
+            'end_dt'           => '2026-09-10T18:00',
+            'duration_minutes' => '60',
+        ];
+
+        $this->repository->shouldNotReceive('createFromWindow');
+        $this->repository->shouldReceive('findByInstructor')->once()->with(3)->andReturn([]);
+
+        $html = $this->render();
+
+        self::assertStringContainsString('notice-error', $html);
+        self::assertStringContainsString('60-minute lesson length', $html);
+        self::assertStringNotContainsString('notice-success', $html);
+    }
+
+    /** @return array<string, array{array<string, string>, string}> */
+    public static function invalidWindows(): array
+    {
+        return [
+            'unparseable start' => [['start_dt' => 'whenever', 'end_dt' => '2026-09-10T18:00'], 'valid start and end'],
+            'end before start'  => [['start_dt' => '2026-09-10T18:00', 'end_dt' => '2026-09-10T17:00'], 'after the start time'],
+            'spans two days'    => [['start_dt' => '2026-09-10T23:00', 'end_dt' => '2026-09-11T01:00'], 'same day'],
+        ];
+    }
+
+    /**
+     * Each of these used to be a bare `return` — the page reloaded unchanged and
+     * the instructor had no way to tell the save had failed.
+     *
+     * @dataProvider invalidWindows
+     *
+     * @param array<string, string> $fields
+     */
+    public function testAddReportsEveryRejectedWindow(array $fields, string $expected): void
+    {
+        $_POST = array_merge([ 'usc_action' => 'add', 'duration_minutes' => '30' ], $fields);
+
+        $this->repository->shouldNotReceive('createFromWindow');
+        $this->repository->shouldReceive('findByInstructor')->once()->with(3)->andReturn([]);
+
+        $html = $this->render();
+
+        self::assertStringContainsString('notice-error', $html);
+        self::assertStringContainsString($expected, $html);
+    }
+
+    public function testAddRejectsAnOfferingTheInstructorDoesNotOwn(): void
+    {
+        // The REST endpoint always checked this; the admin form never did, so a
+        // crafted POST could tie a slot to another instructor's offering.
+        $_POST = [
+            'usc_action'       => 'add',
+            'start_dt'         => '2026-09-10T17:00',
+            'end_dt'           => '2026-09-10T18:00',
+            'duration_minutes' => '60',
+            'offering_id'      => '8',
+        ];
+
+        $this->offerings->shouldReceive('findById')->once()->with(8)->andReturn(null);
+        $this->repository->shouldNotReceive('createFromWindow');
+        $this->repository->shouldReceive('findByInstructor')->once()->with(3)->andReturn([]);
+
+        $html = $this->render();
+
+        self::assertStringContainsString('notice-error', $html);
+        self::assertStringContainsString('not available', $html);
+    }
+
+    public function testAddReportsHowManySlotsWereCreated(): void
+    {
+        $_POST = [
+            'usc_action'       => 'add',
+            'start_dt'         => '2026-09-10T17:00',
+            'end_dt'           => '2026-09-10T19:00',
+            'duration_minutes' => '60',
+            'recurrence'       => 'weekly',
+            'weeks'            => '41',
+        ];
+
+        $this->repository->shouldReceive('createFromWindow')->once()
+            ->with(Mockery::type(AvailabilitySlot::class), true, 41)
+            ->andReturn(range(1, 82));
+        $this->repository->shouldReceive('findByInstructor')->once()->with(3)->andReturn([]);
+
+        $html = $this->render();
+
+        self::assertStringContainsString('notice-success', $html);
+        self::assertStringContainsString('Added 82 bookable slots.', $html);
+    }
+
+    public function testAddReportsAFailedWrite(): void
+    {
+        // A valid window always splits into at least one slot, so an empty result
+        // means the inserts themselves failed.
+        $_POST = [
+            'usc_action'       => 'add',
+            'start_dt'         => '2026-09-10T17:00',
+            'end_dt'           => '2026-09-10T18:00',
+            'duration_minutes' => '60',
+        ];
+
+        $this->repository->shouldReceive('createFromWindow')->once()->andReturn([]);
+        $this->repository->shouldReceive('findByInstructor')->once()->with(3)->andReturn([]);
+
+        $html = $this->render();
+
+        self::assertStringContainsString('notice-error', $html);
+        self::assertStringContainsString('could not be saved', $html);
+    }
+
+    public function testSingleDeleteReportsAFailureToDelete(): void
+    {
+        $_POST = [ 'usc_action' => 'delete', 'slot_id' => '7' ];
+
+        $other = new AvailabilitySlot(instructorId: 4, startDt: '2026-07-08 09:00:00', endDt: '2026-07-08 10:00:00', id: 7);
+
+        $this->repository->shouldReceive('findById')->once()->with(7)->andReturn($other);
+        $this->repository->shouldReceive('findByInstructor')->once()->with(3)->andReturn([]);
+
+        $html = $this->render();
+
+        self::assertStringContainsString('notice-error', $html);
+        self::assertStringContainsString('could not be deleted', $html);
+    }
+
+    public function testBulkDeleteReportsBothHalvesOfAPartialResult(): void
+    {
+        $_POST = [ 'usc_action' => 'bulk_delete', 'slot_ids' => ['5', '7'] ];
+
+        $owned  = new AvailabilitySlot(instructorId: 3, startDt: '2026-07-08 09:00:00', endDt: '2026-07-08 10:00:00', id: 5);
+        $booked = new AvailabilitySlot(instructorId: 3, startDt: '2026-07-08 10:00:00', endDt: '2026-07-08 11:00:00', isBooked: true, id: 7);
+
+        $this->repository->shouldReceive('findById')->once()->with(5)->andReturn($owned);
+        $this->repository->shouldReceive('findById')->once()->with(7)->andReturn($booked);
+        $this->repository->shouldReceive('delete')->once()->with(5)->andReturn(true);
+        // The repository refuses a booked row, reporting it by returning false.
+        $this->repository->shouldReceive('delete')->once()->with(7)->andReturn(false);
+        $this->repository->shouldReceive('findByInstructor')->once()->with(3)->andReturn([]);
+
+        $html = $this->render();
+
+        self::assertStringContainsString('1 slot deleted.', $html);
+        self::assertStringContainsString('1 slot could not be deleted', $html);
+    }
+
     private function render(): string
     {
         ob_start();

tests/Unit/Availability/AvailabilityEndpointTest.php

@@ -8,6 +8,7 @@ use Mockery;
 use Unsupervised\Schedular\Availability\AvailabilityEndpoint;
 use Unsupervised\Schedular\Availability\AvailabilityRepository;
 use Unsupervised\Schedular\Availability\AvailabilitySlot;
+use Unsupervised\Schedular\Availability\WindowValidator;
 use Unsupervised\Schedular\Offering\OfferingRepository;
 use Unsupervised\Schedular\Tests\Unit\TestCase;
 
@@ -26,7 +27,7 @@ class AvailabilityEndpointTest extends TestCase
 
         $this->repository = Mockery::mock(AvailabilityRepository::class);
         $this->offerings  = Mockery::mock(OfferingRepository::class);
-        $this->endpoint   = new AvailabilityEndpoint($this->repository, $this->offerings);
+        $this->endpoint   = new AvailabilityEndpoint($this->repository, new WindowValidator($this->offerings));
     }
 
     public function testCreateRejectsWindowSpanningMultipleDays(): void

tests/Unit/Availability/AvailabilityRepositoryTest.php

@@ -49,6 +49,101 @@ class AvailabilityRepositoryTest extends TestCase
         self::assertSame(42, $result);
     }
 
+    public function testInsertReturnsZeroWhenTheWriteFails(): void
+    {
+        Functions\expect('current_time')->with('mysql')->andReturn('2026-04-01 12:00:00');
+
+        // wpdb::insert returns false on error, but insert_id still holds the
+        // previous statement's id — returning it made a failed write look like a
+        // successful one.
+        $this->db->shouldReceive('insert')->once()->andReturn(false);
+        $this->db->insert_id = 42;
+
+        $slot = new AvailabilitySlot(5, '2026-04-01 09:00:00', '2026-04-01 10:00:00', 30);
+
+        self::assertSame(0, $this->repo->insert($slot));
+    }
+
+    public function testCreateFromWindowOmitsChunksThatFailedToInsert(): void
+    {
+        Functions\when('current_time')->justReturn('2026-04-01 12:00:00');
+
+        // Three chunks; the middle write fails.
+        $results = [null, false, null];
+        $ids     = [11, 13];
+
+        $this->db->shouldReceive('insert')
+            ->times(3)
+            ->andReturnUsing(function () use (&$results, &$ids) {
+                $outcome = array_shift($results);
+
+                if (false !== $outcome) {
+                    $this->db->insert_id = array_shift($ids);
+                }
+
+                return $outcome;
+            });
+
+        $window = new AvailabilitySlot(5, '2026-04-01 09:00:00', '2026-04-01 10:30:00', 30);
+
+        self::assertSame([11, 13], $this->repo->createFromWindow($window));
+    }
+
+    public function testWeeklySeriesIsClampedToTheMaximum(): void
+    {
+        Functions\when('current_time')->justReturn('2026-04-01 12:00:00');
+
+        // The form's max is advisory; a hand-crafted POST could ask for any
+        // number, so the ceiling is enforced here.
+        $next = 1;
+        $this->db->shouldReceive('insert')
+            ->times(AvailabilitySlot::MAX_WEEKLY_OCCURRENCES)
+            ->andReturnUsing(function () use (&$next) {
+                $this->db->insert_id = $next++;
+
+                return null;
+            });
+        $this->db->shouldReceive('update')->once();
+
+        $first = new AvailabilitySlot(5, '2026-04-01 09:00:00', '2026-04-01 10:00:00', 60);
+
+        self::assertCount(
+            AvailabilitySlot::MAX_WEEKLY_OCCURRENCES,
+            $this->repo->createWeeklySeries($first, 10000)
+        );
+    }
+
+    public function testWeeklySeriesGroupsOnTheFirstRowThatActuallyWrote(): void
+    {
+        Functions\when('current_time')->justReturn('2026-04-01 12:00:00');
+
+        // The first insert fails. A failed row must not become the recurrence
+        // group (its id is 0), which would orphan every later occurrence.
+        $results = [false, null, null];
+        $ids     = [21, 22];
+
+        $this->db->shouldReceive('insert')
+            ->times(3)
+            ->andReturnUsing(function () use (&$results, &$ids) {
+                $outcome = array_shift($results);
+
+                if (false !== $outcome) {
+                    $this->db->insert_id = array_shift($ids);
+                }
+
+                return $outcome;
+            });
+
+        // The group is set from row 21 — the first that survived.
+        $this->db->shouldReceive('update')
+            ->once()
+            ->with('wp_us_availability', ['recurrence_group' => 21], ['id' => 21], ['%d'], ['%d']);
+
+        $first = new AvailabilitySlot(5, '2026-04-01 09:00:00', '2026-04-01 10:00:00', 60);
+
+        self::assertSame([21, 22], $this->repo->createWeeklySeries($first, 3));
+    }
+
     public function testCreateWeeklySeriesInsertsWeeklyAndSharesGroup(): void
     {
         Functions\when('current_time')->justReturn('2026-04-07 12:00:00');

tests/Unit/Availability/WindowValidatorTest.php

@@ -0,0 +1,143 @@
+<?php
+declare(strict_types=1);
+
+namespace Unsupervised\Schedular\Tests\Unit\Availability;
+
+use Mockery;
+use Unsupervised\Schedular\Availability\AvailabilitySlot;
+use Unsupervised\Schedular\Availability\WindowValidator;
+use Unsupervised\Schedular\Offering\Offering;
+use Unsupervised\Schedular\Offering\OfferingRepository;
+use Unsupervised\Schedular\Tests\Unit\TestCase;
+
+class WindowValidatorTest extends TestCase
+{
+    private OfferingRepository&Mockery\MockInterface $offerings;
+    private WindowValidator $validator;
+
+    protected function setUp(): void
+    {
+        parent::setUp();
+
+        $this->offerings = Mockery::mock(OfferingRepository::class);
+        $this->validator = new WindowValidator($this->offerings);
+    }
+
+    /**
+     * The reported bug: 5:30–6:00 PM submitted with the length select left on
+     * its 60-minute default. The window fits no lesson, so it used to persist
+     * nothing at all and say nothing.
+     */
+    public function testRejectsAWindowShorterThanTheLessonLength(): void
+    {
+        $result = $this->validator->validate(3, '2026-09-10 17:30', '2026-09-10 18:00', 60, 0);
+
+        self::assertInstanceOf(\WP_Error::class, $result);
+        self::assertSame('invalid_window', $result->get_error_code());
+        // The message names the length actually chosen, so the fix is obvious.
+        self::assertStringContainsString('60-minute', $result->get_error_message());
+    }
+
+    public function testAcceptsThatSameWindowAtAFittingLessonLength(): void
+    {
+        $result = $this->validator->validate(3, '2026-09-10 17:30', '2026-09-10 18:00', 30, 0);
+
+        self::assertInstanceOf(AvailabilitySlot::class, $result);
+        self::assertSame('2026-09-10 17:30:00', $result->startDt);
+        self::assertSame('2026-09-10 18:00:00', $result->endDt);
+        self::assertSame(30, $result->durationMinutes);
+        self::assertNull($result->offeringId);
+        self::assertCount(1, $result->splitByDuration());
+    }
+
+    /** @return array<string, array{string, string}> */
+    public static function badDateTimes(): array
+    {
+        return [
+            'empty start'        => ['', '2026-09-10 18:00'],
+            'empty end'          => ['2026-09-10 17:00', ''],
+            'unparseable start'  => ['tomorrow', '2026-09-10 18:00'],
+            'unparseable end'    => ['2026-09-10 17:00', 'not a date'],
+        ];
+    }
+
+    /** @dataProvider badDateTimes */
+    public function testRejectsUnusableDateTimes(string $start, string $end): void
+    {
+        $result = $this->validator->validate(3, $start, $end, 30, 0);
+
+        self::assertInstanceOf(\WP_Error::class, $result);
+        self::assertSame('invalid_datetime', $result->get_error_code());
+    }
+
+    public function testRejectsAnEndAtOrBeforeTheStart(): void
+    {
+        $backwards = $this->validator->validate(3, '2026-09-10 18:00', '2026-09-10 17:00', 30, 0);
+        $identical = $this->validator->validate(3, '2026-09-10 18:00', '2026-09-10 18:00', 30, 0);
+
+        self::assertInstanceOf(\WP_Error::class, $backwards);
+        self::assertInstanceOf(\WP_Error::class, $identical);
+        self::assertSame('invalid_datetime', $backwards->get_error_code());
+        self::assertSame('invalid_datetime', $identical->get_error_code());
+    }
+
+    public function testRejectsAWindowSpanningTwoDays(): void
+    {
+        $result = $this->validator->validate(3, '2026-09-10 23:00', '2026-09-11 01:00', 30, 0);
+
+        self::assertInstanceOf(\WP_Error::class, $result);
+        self::assertSame('invalid_window', $result->get_error_code());
+        self::assertStringContainsString('same day', $result->get_error_message());
+    }
+
+    public function testRejectsAnOfferingOwnedBySomeoneElse(): void
+    {
+        // Instructor 3 posting instructor 9's offering: accepting it would let a
+        // slot inherit another instructor's price and payment routing.
+        $this->offerings->shouldReceive('findById')->once()->with(8)
+            ->andReturn(new Offering(instructorId: 9, title: 'Theirs', kind: Offering::KIND_PRIVATE_LESSON, id: 8));
+
+        $result = $this->validator->validate(3, '2026-09-10 17:00', '2026-09-10 18:00', 60, 8);
+
+        self::assertInstanceOf(\WP_Error::class, $result);
+        self::assertSame('invalid_offering', $result->get_error_code());
+    }
+
+    public function testRejectsAnOfferingThatDoesNotExist(): void
+    {
+        $this->offerings->shouldReceive('findById')->once()->with(8)->andReturn(null);
+
+        $result = $this->validator->validate(3, '2026-09-10 17:00', '2026-09-10 18:00', 60, 8);
+
+        self::assertInstanceOf(\WP_Error::class, $result);
+        self::assertSame('invalid_offering', $result->get_error_code());
+    }
+
+    public function testKeepsAnOfferingTheInstructorOwns(): void
+    {
+        $this->offerings->shouldReceive('findById')->once()->with(8)
+            ->andReturn(new Offering(instructorId: 3, title: 'Mine', kind: Offering::KIND_PRIVATE_LESSON, id: 8));
+
+        $result = $this->validator->validate(3, '2026-09-10 17:00', '2026-09-10 18:00', 60, 8);
+
+        self::assertInstanceOf(AvailabilitySlot::class, $result);
+        self::assertSame(8, $result->offeringId);
+    }
+
+    public function testFallsBackToTheDefaultLessonLength(): void
+    {
+        $result = $this->validator->validate(3, '2026-09-10 09:00', '2026-09-10 10:00', 0, 0);
+
+        self::assertInstanceOf(AvailabilitySlot::class, $result);
+        self::assertSame(AvailabilitySlot::DEFAULT_DURATION_MINUTES, $result->durationMinutes);
+    }
+
+    public function testAcceptsTheDatetimeLocalFormTheFormActuallySubmits(): void
+    {
+        // The browser posts `Y-m-d\TH:i`, not the canonical space-separated form.
+        $result = $this->validator->validate(3, '2026-09-10T17:00', '2026-09-10T18:00', 60, 0);
+
+        self::assertInstanceOf(AvailabilitySlot::class, $result);
+        self::assertSame('2026-09-10 17:00:00', $result->startDt);
+    }
+}

tests/Unit/BlockPreviewTest.php

@@ -74,6 +74,23 @@ class BlockPreviewTest extends TestCase
         self::assertStringContainsString('us-editor-note', $html);
     }
 
+    /**
+     * The preview is what someone placing the block styles against, so it has to
+     * show both halves of the page — your own details as well as your students'.
+     */
+    public function testFamilyPreviewShowsTheAccountHoldersDetailsAndTheirStudents(): void
+    {
+        $html = BlockPreview::family();
+
+        self::assertStringContainsString('class="us-family-self"', $html);
+        self::assertStringContainsString('id="us-own-name"', $html);
+        self::assertStringContainsString('id="us-own-birth-year"', $html);
+        self::assertStringContainsString('I take lessons myself', $html);
+        self::assertStringContainsString('class="us-family-list"', $html);
+        self::assertStringContainsString('class="us-family-add"', $html);
+        self::assertStringContainsString('us-editor-note', $html);
+    }
+
     public function testRegistrationPreviewShowsADisabledSampleForm(): void
     {
         $html = BlockPreview::registration();

tests/Unit/BlockRegistrarTest.php

@@ -6,11 +6,13 @@ namespace Unsupervised\Schedular\Tests\Unit;
 use Brain\Monkey\Actions;
 use Brain\Monkey\Functions;
 use Mockery;
+use Unsupervised\Schedular\Auth\AccountPage;
 use Unsupervised\Schedular\Auth\LoginPage;
 use Unsupervised\Schedular\Auth\RegistrationPage;
 use Unsupervised\Schedular\BlockRegistrar;
 use Unsupervised\Schedular\Booking\BookingPage;
 use Unsupervised\Schedular\GroupClass\GroupClassPage;
+use Unsupervised\Schedular\Guardian\FamilyPage;
 
 /**
  * Test double exposing editor-preview mode as a switch (the real detection
@@ -41,6 +43,8 @@ class BlockRegistrarTest extends TestCase
     private LoginPage&Mockery\MockInterface $loginPage;
     private RegistrationPage&Mockery\MockInterface $registrationPage;
     private GroupClassPage&Mockery\MockInterface $groupClassPage;
+    private FamilyPage&Mockery\MockInterface $familyPage;
+    private AccountPage&Mockery\MockInterface $accountPage;
     private TestableBlockRegistrar $registrar;
 
     protected function setUp(): void
@@ -51,6 +55,8 @@ class BlockRegistrarTest extends TestCase
         $this->loginPage        = Mockery::mock(LoginPage::class);
         $this->registrationPage = Mockery::mock(RegistrationPage::class);
         $this->groupClassPage   = Mockery::mock(GroupClassPage::class);
+        $this->familyPage       = Mockery::mock(FamilyPage::class);
+        $this->accountPage      = Mockery::mock(AccountPage::class);
 
         // Most requests are not a just-finished registration; the tests that
         // exercise that path override this.
@@ -63,6 +69,8 @@ class BlockRegistrarTest extends TestCase
             $this->loginPage,
             $this->registrationPage,
             $this->groupClassPage,
+            $this->familyPage,
+            $this->accountPage,
         );
     }
 
@@ -74,7 +82,7 @@ class BlockRegistrarTest extends TestCase
         $this->registrar->register();
     }
 
-    public function testRegisterBlocksRegistersAllFourBlocksWithAssets(): void
+    public function testRegisterBlocksRegistersAllBlocksWithAssets(): void
     {
         Functions\expect('wp_register_script')
             ->once()
@@ -111,6 +119,8 @@ class BlockRegistrarTest extends TestCase
                 'us-scheduler/student-login',
                 'us-scheduler/student-register',
                 'us-scheduler/group-classes',
+                'us-scheduler/family',
+                'us-scheduler/account',
             ],
             array_keys($registered)
         );
@@ -207,6 +217,8 @@ class BlockRegistrarTest extends TestCase
             $this->loginPage,
             $this->registrationPage,
             $this->groupClassPage,
+            $this->familyPage,
+            $this->accountPage,
         );
 
         $this->bookingPage->shouldReceive('render')->once()->with([])->andReturn('live');

tests/Unit/Booking/BookingEndpointTest.php

@@ -11,22 +11,27 @@ use Unsupervised\Schedular\Booking\BookingEndpoint;
 use Unsupervised\Schedular\Booking\BookingRepository;
 use Unsupervised\Schedular\Booking\CancellationPolicy;
 use Unsupervised\Schedular\Booking\Lesson;
+use Unsupervised\Schedular\GroupClass\SessionSchedule;
+use Unsupervised\Schedular\Guardian\GuardianService;
 use Unsupervised\Schedular\Offering\Offering;
 use Unsupervised\Schedular\Offering\OfferingRepository;
 use Unsupervised\Schedular\Payment\Payment;
 use Unsupervised\Schedular\Payment\PaymentService;
 use Unsupervised\Schedular\Payment\StudioSettings;
+use Unsupervised\Schedular\Policy\PolicyAcceptance;
 use Unsupervised\Schedular\Registration\RegistrationGate;
 use Unsupervised\Schedular\Tests\Unit\TestCase;
 
 class BookingEndpointTest extends TestCase
 {
+    private GuardianService&Mockery\MockInterface $guardians;
     private AvailabilityRepository $availability;
     private BookingRepository $bookings;
     private OfferingRepository $offerings;
     private RegistrationGate $gate;
     private PaymentService $payments;
     private StudioSettings $settings;
+    private SessionSchedule&Mockery\MockInterface $sessions;
     private BookingEndpoint $endpoint;
 
     protected function setUp(): void
@@ -52,6 +57,19 @@ class BookingEndpointTest extends TestCase
         // cancellation paths simply allow the call.
         $this->payments->shouldReceive('creditForCancelledLesson')->andReturn(null)->byDefault();
 
+        $this->guardians = Mockery::mock(GuardianService::class);
+        // The default account books only for itself: no guardian link anywhere.
+        $this->guardians->shouldReceive('canActFor')
+            ->andReturnUsing(static fn (int $actor, int $student): bool => $actor === $student)->byDefault();
+        $this->guardians->shouldReceive('payerFor')->andReturnUsing(static fn (int $id): int => $id)->byDefault();
+        $this->guardians->shouldReceive('householdIds')->andReturnUsing(static fn (int $id): array => [$id])->byDefault();
+        $this->guardians->shouldReceive('studentName')->andReturn('Ada')->byDefault();
+
+        $this->sessions = Mockery::mock(SessionSchedule::class);
+        // Most tests are about one-to-one lessons; the group-class ones say so.
+        $this->sessions->shouldReceive('upcomingForStudent')->andReturn([])->byDefault();
+        $this->sessions->shouldReceive('upcomingForInstructor')->andReturn([])->byDefault();
+
         $this->endpoint = new BookingEndpoint(
             $this->availability,
             $this->bookings,
@@ -59,6 +77,8 @@ class BookingEndpointTest extends TestCase
             $this->gate,
             $this->payments,
             new CancellationPolicy($this->settings),
+            $this->guardians,
+            $this->sessions,
         );
     }
 
@@ -182,7 +202,7 @@ class BookingEndpointTest extends TestCase
         $this->gate->shouldReceive('record')->once();
         $this->payments->shouldReceive('createForRegistration')
             ->once()
-            ->with(Payment::REG_LESSON, 77, 5, 3, 50.0, 'CAD', null)
+            ->with(Payment::REG_LESSON, 77, 5, 3, 50.0, 'CAD', null, null, null, 5)
             ->andReturn(new Payment(
                 studentId:        5,
                 instructorId:     3,
@@ -260,7 +280,7 @@ class BookingEndpointTest extends TestCase
         $this->gate->shouldReceive('record')->once();
         $this->payments->shouldReceive('createForRegistration')
             ->once()
-            ->with(Payment::REG_LESSON, 77, 5, 3, 50.0, 'CAD', null)
+            ->with(Payment::REG_LESSON, 77, 5, 3, 50.0, 'CAD', null, null, null, 5)
             ->andReturn(new Payment(
                 studentId:        5,
                 instructorId:     3,
@@ -336,8 +356,8 @@ class BookingEndpointTest extends TestCase
         // Three claimed occurrences at a per-lesson (one_time) price of 50 → 150.
         $this->payments->shouldReceive('createForRegistration')
             ->once()
-            ->with(Payment::REG_LESSON, 77, 5, 3, 150.0, 'CAD', null)
-            ->andReturn(new Payment(5, 3, Payment::REG_LESSON, 77, 150.0, 'CAD', Payment::METHOD_ETRANSFER, Payment::STATUS_PENDING, id: 12));
+            ->with(Payment::REG_LESSON, 77, 5, 3, 150.0, 'CAD', null, null, null, 5)
+            ->andReturn(new Payment(5, 3, Payment::REG_LESSON, 77, 150.0, currency: 'CAD', method: Payment::METHOD_ETRANSFER, status: Payment::STATUS_PENDING, id: 12));
         $this->bookings->shouldNotReceive('updateStatus');
 
         $request = new \WP_REST_Request(['slot_id' => 10, 'offering_id' => 8, 'recurrence' => 'weekly']);
@@ -375,8 +395,8 @@ class BookingEndpointTest extends TestCase
         // A full_term price already covers the whole reservation.
         $this->payments->shouldReceive('createForRegistration')
             ->once()
-            ->with(Payment::REG_LESSON, 77, 5, 3, 400.0, 'CAD', null)
-            ->andReturn(new Payment(5, 3, Payment::REG_LESSON, 77, 400.0, 'CAD', Payment::METHOD_ETRANSFER, Payment::STATUS_PENDING, id: 12));
+            ->with(Payment::REG_LESSON, 77, 5, 3, 400.0, 'CAD', null, null, null, 5)
+            ->andReturn(new Payment(5, 3, Payment::REG_LESSON, 77, 400.0, currency: 'CAD', method: Payment::METHOD_ETRANSFER, status: Payment::STATUS_PENDING, id: 12));
         $this->bookings->shouldNotReceive('updateStatus');
 
         $request = new \WP_REST_Request(['slot_id' => 10, 'offering_id' => 8, 'recurrence' => 'weekly']);
@@ -427,8 +447,8 @@ class BookingEndpointTest extends TestCase
         // Charged now, for a single lesson's fee, as a normal (non-scheduled) payment.
         $this->payments->shouldReceive('createForRegistration')
             ->once()
-            ->with(Payment::REG_LESSON, 77, 5, 3, 45.0, 'CAD', null)
-            ->andReturn(new Payment(5, 3, Payment::REG_LESSON, 77, 45.0, 'CAD', Payment::METHOD_ETRANSFER, Payment::STATUS_PENDING, id: 12));
+            ->with(Payment::REG_LESSON, 77, 5, 3, 45.0, 'CAD', null, null, null, 5)
+            ->andReturn(new Payment(5, 3, Payment::REG_LESSON, 77, 45.0, currency: 'CAD', method: Payment::METHOD_ETRANSFER, status: Payment::STATUS_PENDING, id: 12));
         $this->bookings->shouldNotReceive('updateStatus');
 
         $result = $this->endpoint->book(new \WP_REST_Request(['slot_id' => 10, 'offering_id' => 8]));
@@ -657,4 +677,220 @@ class BookingEndpointTest extends TestCase
         self::assertSame('Piano Lesson', $data[0]['offering_title']);
         self::assertSame(60, $data[0]['duration_minutes']);
     }
+
+    /**
+     * The authorisation boundary of guardian booking: without it any signed-in
+     * student could book — and bill — against any user id they cared to send.
+     */
+    public function testBookForAStudentTheCallerDoesNotGuardIsForbidden(): void
+    {
+        $this->guardians->shouldReceive('canActFor')->with(5, 99)->andReturn(false);
+
+        // Rejected before anything is looked up, claimed, or charged.
+        $this->availability->shouldNotReceive('findById');
+        $this->availability->shouldNotReceive('claim');
+        $this->bookings->shouldNotReceive('insert');
+        $this->payments->shouldNotReceive('createForRegistration');
+
+        $request = new \WP_REST_Request(['slot_id' => 10, 'offering_id' => 8, 'student_id' => 99]);
+        $result  = $this->endpoint->book($request);
+
+        self::assertInstanceOf(\WP_Error::class, $result);
+        self::assertSame('forbidden', $result->get_error_code());
+    }
+
+    public function testGuardianBooksTheLessonInTheChildsNameAndBillsThemselves(): void
+    {
+        $this->guardians->shouldReceive('canActFor')->with(5, 42)->andReturn(true);
+        $this->guardians->shouldReceive('payerFor')->with(42)->andReturn(5);
+
+        $this->availability->shouldReceive('findById')->with(10)->andReturn($this->slot(10, 3, null));
+        $this->offerings->shouldReceive('findById')->with(8)->andReturn(
+            new Offering(instructorId: 3, kind: Offering::KIND_PRIVATE_LESSON, title: 'Lesson', price: 50.0, id: 8)
+        );
+        $this->gate->shouldReceive('validate')->andReturn(null);
+        $this->availability->shouldReceive('claim')->with(10)->once()->andReturn(true);
+
+        // The lesson belongs to the child…
+        $this->bookings->shouldReceive('insert')
+            ->once()
+            ->with(Mockery::on(static fn (Lesson $l): bool => $l->studentId === 42))
+            ->andReturn(77);
+
+        // …the acceptance names the child but is attributed to the guardian…
+        $this->gate->shouldReceive('record')
+            ->once()
+            ->with(PolicyAcceptance::REG_LESSON, 77, 42, 8, Mockery::any(), Mockery::any(), Mockery::any(), 5);
+
+        // …and the charge is raised against the child but owed by the guardian.
+        $this->payments->shouldReceive('createForRegistration')
+            ->once()
+            ->with(Payment::REG_LESSON, 77, 42, 3, 50.0, 'CAD', null, null, null, 5)
+            ->andReturn(new Payment(42, 3, Payment::REG_LESSON, 77, 50.0, payerId: 5, currency: 'CAD', method: Payment::METHOD_ETRANSFER, status: Payment::STATUS_PENDING, id: 12));
+
+        $request = new \WP_REST_Request(['slot_id' => 10, 'offering_id' => 8, 'student_id' => 42]);
+        $result  = $this->endpoint->book($request);
+
+        self::assertInstanceOf(\WP_REST_Response::class, $result);
+        self::assertSame(201, $result->get_status());
+    }
+
+    /**
+     * Sending your own id explicitly is the same as sending none — no guardian
+     * lookup is needed to book for yourself.
+     */
+    public function testBookForYourOwnIdNeedsNoGuardianLink(): void
+    {
+        $this->availability->shouldReceive('findById')->with(10)->andReturn($this->slot(10, 3, null));
+        $this->offerings->shouldReceive('findById')->with(8)->andReturn(
+            new Offering(instructorId: 3, kind: Offering::KIND_PRIVATE_LESSON, title: 'Lesson', price: 0.0, id: 8)
+        );
+        $this->gate->shouldReceive('validate')->andReturn(null);
+        $this->availability->shouldReceive('claim')->with(10)->once()->andReturn(true);
+        $this->bookings->shouldReceive('insert')
+            ->once()
+            ->with(Mockery::on(static fn (Lesson $l): bool => $l->studentId === 5))
+            ->andReturn(77);
+        $this->gate->shouldReceive('record')->once();
+        $this->bookings->shouldReceive('updateStatus')->once()->andReturn(true);
+
+        $request = new \WP_REST_Request(['slot_id' => 10, 'offering_id' => 8, 'student_id' => 5]);
+
+        self::assertInstanceOf(\WP_REST_Response::class, $this->endpoint->book($request));
+    }
+
+    public function testGuardianMayCancelTheirChildsLesson(): void
+    {
+        $this->guardians->shouldReceive('canActFor')->with(5, 42)->andReturn(true);
+
+        $lesson = new Lesson(slotId: 10, studentId: 42, instructorId: 3, status: Lesson::STATUS_CONFIRMED, id: 77);
+        $this->bookings->shouldReceive('findById')->with(77)->andReturn($lesson);
+        $this->availability->shouldReceive('findById')->with(10)->andReturn($this->slot(10, 3, null));
+        $this->bookings->shouldReceive('updateStatus')->once()->with(77, Lesson::STATUS_CANCELLED)->andReturn(true);
+        $this->availability->shouldReceive('release')->once()->with(10)->andReturn(true);
+        $this->payments->shouldReceive('voidPending')->once();
+
+        $result = $this->endpoint->cancel(new \WP_REST_Request(['id' => 77]));
+
+        self::assertInstanceOf(\WP_REST_Response::class, $result);
+    }
+
+    public function testMyLessonsCoversTheWholeHouseholdSortedByStart(): void
+    {
+        Functions\when('current_user_can')->justReturn(false);
+
+        $this->guardians->shouldReceive('householdIds')->with(5)->andReturn([5, 42]);
+        $this->guardians->shouldReceive('studentName')->with(5)->andReturn('Grace');
+        $this->guardians->shouldReceive('studentName')->with(42)->andReturn('Ada');
+
+        $mine  = new Lesson(slotId: 11, studentId: 5, instructorId: 3, status: Lesson::STATUS_CONFIRMED, id: 78);
+        $childs = new Lesson(slotId: 10, studentId: 42, instructorId: 3, status: Lesson::STATUS_CONFIRMED, id: 77);
+
+        $this->bookings->shouldReceive('findUpcomingForStudent')->with(5)->andReturn([$mine]);
+        $this->bookings->shouldReceive('findUpcomingForStudent')->with(42)->andReturn([$childs]);
+
+        // Slot 10 starts first, so the child's lesson leads the merged list.
+        $this->availability->shouldReceive('findById')->with(10)->andReturn($this->slot(10, 3, null));
+        $this->availability->shouldReceive('findById')->with(11)->andReturn(new AvailabilitySlot(
+            instructorId:    3,
+            startDt:         '2026-07-02 10:00:00',
+            endDt:           '2026-07-02 11:00:00',
+            durationMinutes: 60,
+            id:              11,
+        ));
+
+        $data = $this->endpoint->myLessons(new \WP_REST_Request([]))->get_data();
+
+        self::assertSame([77, 78], array_column($data, 'id'));
+        self::assertSame(['Ada', 'Grace'], array_column($data, 'student_name'));
+    }
+
+    /**
+     * A group class has no availability slot behind it, so it never appeared in
+     * this list at all — a student whose whole term was a group class saw an
+     * empty schedule. Its sessions now sort in among the booked lessons.
+     */
+    public function testMyLessonsInterleavesGroupClassSessionsWithLessons(): void
+    {
+        Functions\when('current_user_can')->justReturn(false);
+
+        $this->guardians->shouldReceive('householdIds')->with(5)->andReturn([5]);
+        $this->guardians->shouldReceive('studentName')->with(5)->andReturn('Grace');
+
+        // Slot 10 starts 2026-07-01 10:00 (the fixture), so the class on
+        // 2026-06-30 comes first and the one on 2026-07-07 last.
+        $lesson = new Lesson(slotId: 10, studentId: 5, instructorId: 3, status: Lesson::STATUS_CONFIRMED, id: 78);
+        $this->bookings->shouldReceive('findUpcomingForStudent')->with(5)->andReturn([$lesson]);
+        $this->availability->shouldReceive('findById')->with(10)->andReturn($this->slot(10, 3, null));
+
+        $this->sessions->shouldReceive('upcomingForStudent')->with(5, '2026-06-01 10:00:00')->andReturn([
+            [
+                'enrollment_id'    => 40,
+                'offering_id'      => 8,
+                'offering_title'   => 'Choir',
+                'instructor_id'    => 3,
+                'status'           => 'active',
+                'start_dt'         => '2026-06-30 16:00:00',
+                'end_dt'           => '2026-06-30 17:00:00',
+                'duration_minutes' => 60,
+            ],
+            [
+                'enrollment_id'    => 40,
+                'offering_id'      => 8,
+                'offering_title'   => 'Choir',
+                'instructor_id'    => 3,
+                'status'           => 'active',
+                'start_dt'         => '2026-07-07 16:00:00',
+                'end_dt'           => '2026-07-07 17:00:00',
+                'duration_minutes' => 60,
+            ],
+        ]);
+
+        $data = $this->endpoint->myLessons(new \WP_REST_Request([]))->get_data();
+
+        self::assertSame(
+            ['2026-06-30 16:00:00', '2026-07-01 10:00:00', '2026-07-07 16:00:00'],
+            array_column($data, 'start_dt')
+        );
+
+        // `kind` is what lets the panel withhold a Cancel button from a session
+        // that is a date in a term rather than a booked slot. A lesson carries no
+        // `kind` at all, which is the absence the panel reads as "cancellable".
+        self::assertSame('group_class', $data[0]['kind']);
+        self::assertSame('group_class', $data[2]['kind']);
+        self::assertSame('Choir', $data[0]['offering_title']);
+        self::assertSame('Grace', $data[0]['student_name']);
+        self::assertArrayNotHasKey('kind', $data[1]);
+    }
+
+    /**
+     * An instructor's own group classes join their schedule the same way, and
+     * one session is one row however many students are enrolled in it.
+     */
+    public function testMyLessonsAddsAnInstructorsOwnGroupClassSessions(): void
+    {
+        Functions\when('current_user_can')->justReturn(true);
+
+        $this->bookings->shouldReceive('findUpcomingForInstructor')->with(5)->andReturn([]);
+        $this->sessions->shouldReceive('upcomingForInstructor')->with(5, '2026-06-01 10:00:00')->andReturn([
+            [
+                'enrollment_id'    => 0,
+                'offering_id'      => 8,
+                'offering_title'   => 'Choir',
+                'instructor_id'    => 5,
+                'status'           => 'active',
+                'start_dt'         => '2026-06-30 16:00:00',
+                'end_dt'           => '2026-06-30 17:00:00',
+                'duration_minutes' => 60,
+            ],
+        ]);
+
+        $data = $this->endpoint->myLessons(new \WP_REST_Request([]))->get_data();
+
+        self::assertCount(1, $data);
+        self::assertSame('group_class', $data[0]['kind']);
+        self::assertSame('Choir', $data[0]['offering_title']);
+        // Nobody's name: the row is the class, not one student's place in it.
+        self::assertArrayNotHasKey('student_name', $data[0]);
+    }
 }

tests/Unit/Booking/BookingPageTest.php

@@ -4,17 +4,26 @@ declare(strict_types=1);
 namespace Unsupervised\Schedular\Tests\Unit\Booking;
 
 use Brain\Monkey\Functions;
+use Mockery;
 use Unsupervised\Schedular\Booking\BookingPage;
+use Unsupervised\Schedular\Guardian\GuardianService;
 use Unsupervised\Schedular\Tests\Unit\TestCase;
 
 class BookingPageTest extends TestCase
 {
     private BookingPage $page;
+    private GuardianService&Mockery\MockInterface $guardians;
 
     protected function setUp(): void
     {
         parent::setUp();
-        $this->page = new BookingPage();
+        $this->guardians = Mockery::mock(GuardianService::class);
+        // Most cases are a single-student account: one bookable person, no picker.
+        $this->guardians->shouldReceive('bookableStudents')->andReturn(
+            [['id' => 3, 'name' => 'Ada', 'is_self' => true]]
+        )->byDefault();
+
+        $this->page = new BookingPage($this->guardians);
     }
 
     /**
@@ -171,4 +180,35 @@ class BookingPageTest extends TestCase
 
         self::assertSame('https://example.com/wp-login.php', $this->page->loginUrl(5));
     }
+
+    /**
+     * A single-student account gets a one-entry list, which the script renders
+     * as no picker at all.
+     */
+    public function testStudentListIsEmbeddedForTheScript(): void
+    {
+        $html = $this->renderForStudent([]);
+
+        self::assertStringContainsString('data-students=', $html);
+        self::assertStringContainsString('"is_self":true', $html);
+    }
+
+    /**
+     * Children lead the embedded list, so the picker's default selection is a
+     * child rather than the parent.
+     */
+    public function testGuardianListLeadsWithChildren(): void
+    {
+        $this->guardians->shouldReceive('bookableStudents')->with(3)->andReturn([
+            ['id' => 42, 'name' => 'Ada', 'is_self' => false],
+            ['id' => 3, 'name' => 'Grace', 'is_self' => true],
+        ]);
+
+        $html = $this->renderForStudent([]);
+
+        $students = json_decode(html_entity_decode((string) preg_replace('/.*data-students="([^"]*)".*/s', '$1', $html)), true);
+
+        self::assertSame([42, 3], array_column((array) $students, 'id'));
+        self::assertFalse($students[0]['is_self']);
+    }
 }