Never drop an enrolled class from upcoming lessons; delete a guardian's children with them; pin the panel's line spacing

Three fixes from testing the branch.

A group class was only listed when its schedule resolved to exact
datetimes, which needs a class time *and* a duration — both optional on
the offering form, and the schedule note exists precisely so a studio can
write "Tuesdays 4:00pm" instead. A class configured that way vanished
from the list, which is the one thing this feature must never do. So
Offering::sessionStarts() splits "when does it meet" from "how long does
it run" (sessionWindows() is that plus the duration, unchanged), and
SessionSchedule degrades instead of disappearing: dated rows with an open
end when there is no duration, and a single row carrying
Offering::scheduleLabel() when there is no time to derive dates from.
Only a class whose last day has passed drops out.

Deleting a guardian now deletes the children linked to them, releasing
each one's lessons and enrolments first. 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 it was
left stranded on the roster still holding slots. A `handled` set makes
the re-entrant delete_user each child deletion fires a no-op, and stops a
circular link recursing.

The upcoming panel never stated its own line-height, so a theme setting
line-height: 0 above it — the usual icon-font reset — was inherited
straight through. Below 1 that produces both reported symptoms at once:
stacked lines overlap, and the status pill's background is shorter than
the text in it. Pinned at the same id-level specificity as the rest.

Tests: composer test (863), composer lint, composer cs all pass.

Co-Authored-By: Claude Opus 5 <[email protected]>

src/Auth/DeletedUserCleanup.php

@@ -8,10 +8,13 @@ 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.
+ * 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
@@ -24,6 +27,13 @@ use Unsupervised\Schedular\Payment\PaymentService;
  * 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
@@ -32,38 +42,62 @@ use Unsupervised\Schedular\Payment\PaymentService;
  */
 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. `wpmu_delete_user` is the
-		// multisite equivalent for a user removed from the network entirely.
+		// 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' ] );
 	}
 
 	/**
-	 * Cancel and release everything the account had booked ahead of it.
+	 * 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 ) {
+		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( $userId ) as $lesson ) {
+		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( $userId ) as $enrollment ) {
+		foreach ( $this->enrollments->findByStudent( $studentId ) as $enrollment ) {
 			if ( Enrollment::STATUS_ACTIVE !== $enrollment->status ) {
 				continue;
 			}
@@ -72,4 +106,25 @@ class DeletedUserCleanup {
 			$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 );
+		}
+	}
 }