From db42007be41868b4415b1122f5732c935a5ce6de Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?S=C4=ABlav=C4=81pi=20Cheesley?= <silavapi@silavapi.co.uk>
Date: Tue, 22 Sep 2026 19:08:24 +0100
Subject: [PATCH] Add sprint mode, with a timer bound to the drill it was
 started for

A sprint is a timed run across every key unlocked so far, folded into one
synthetic lesson by the new src/drill/sprint.ts, so the text generator is
handed a sprint the same way it is handed a rung. It carries no lesson id, so
it earns experience and no stars, and the result card names what it was
outright rather than leaving it to be inferred from "none, this was not a
lesson".

The reason this change exists is regression 3, the nastiest failure the
prototype shipped. An abandoned sprint left its interval running; the interval
then acted on whichever drill was current, and because an untimed drill carried
a limit of zero, "elapsed is at least the limit" was true on the very first
keystroke. Every drill after that died instantly: a learner would abandon a
sprint, go back to a lesson, and watch it end before they had typed anything.

Half of that was already fixed in limits.ts, where NO_LIMIT is a real state.
The other half is fixed structurally here. startSprintTimer captures the one
Drill it is for and never looks a drill up again, and it demands a currentDrill
reader which it compares with that captured object by identity on every tick,
stopping itself the instant they differ. The binding is a required argument
rather than a convention, so there is no way to build a timer that is not bound
to a drill, and a teardown that is missed costs one tick of nothing rather than
every drill that follows. The three regression todos are filled in, including
one that fires a deliberately uncancelled tick at a later drill and proves it
does nothing.

The repeating callback is injected, so nothing under src/drill reaches for
setInterval and every test drives the tick by hand. The default schedule lives
in the drill view, which is where the brief says a wall clock belongs.

WCAG 2.2.1 applies and the exemption is not claimed. The duration control is
built from SPRINT_DURATIONS_MS so the options cannot drift from the durations,
the current setting is stated in visible text rather than only shown as a
selected option, and the untimed option genuinely never expires -- proved at a
century of elapsed time in unit and functional tests and at an hour of faked
wall clock in a browser. The countdown is a role="timer", whose implicit live
setting is off, so the number is never announced per second; time running out
is announced instead at three polite milestones, and the count of those
announcements over a whole sprint is asserted.

parseSprintLimit refuses an empty control rather than letting Number('') become
zero and read as a deliberate choice of untimed. Absent, zero and malformed are
three different things.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
---
 docs/accessibility.md                       |  71 ++-
 index.html                                  |  45 ++
 src/drill/sprint.ts                         | 381 +++++++++++++++
 src/ui/drill-view.ts                        | 176 ++++++-
 src/ui/load-form.ts                         | 110 ++++-
 src/ui/sprint-controls.ts                   | 106 +++++
 src/ui/theme.css                            |  29 +-
 tests/e2e/pending.spec.ts                   |  66 ++-
 tests/e2e/sprint.spec.ts                    | 185 ++++++++
 tests/functional/sprint-view.test.ts        | 495 ++++++++++++++++++++
 tests/regression/prototype-failures.test.ts | 136 +++++-
 tests/unit/sprint.test.ts                   | 443 ++++++++++++++++++
 12 files changed, 2192 insertions(+), 51 deletions(-)
 create mode 100644 src/drill/sprint.ts
 create mode 100644 src/ui/sprint-controls.ts
 create mode 100644 tests/e2e/sprint.spec.ts
 create mode 100644 tests/functional/sprint-view.test.ts
 create mode 100644 tests/unit/sprint.test.ts

diff --git a/docs/accessibility.md b/docs/accessibility.md
index 51d5d43..338626b 100644
--- a/docs/accessibility.md
+++ b/docs/accessibility.md
@@ -11,22 +11,24 @@ see most of what matters here, so the manual checklist below is the real test.
 
 ## Automated coverage
 
-| What                                                    | Where                                 |
-| ------------------------------------------------------- | ------------------------------------- |
-| Axe, WCAG 2.0/2.1/2.2 A and AA rules                    | `tests/e2e/load-layout.spec.ts`       |
-| Contrast, both themes, computed styles                  | `tests/e2e/contrast.spec.ts`          |
-| Contrast maths                                          | `tests/unit/contrast.test.ts`         |
-| Reflow at 320, 600 and 1280 px                          | `tests/e2e/reflow.spec.ts`            |
-| Visible focus ring                                      | `tests/e2e/load-layout.spec.ts`       |
-| Keyboard-only reachability                              | `tests/e2e/load-layout.spec.ts`       |
-| Adjustable and disableable time limits                  | `tests/unit/limits.test.ts`           |
-| Escape releases capture, and Tab still moves focus      | `tests/e2e/pending.spec.ts`           |
-| Marks told apart by decoration, not colour alone        | `tests/e2e/drill.spec.ts`             |
-| The drill surface's name and its description            | `tests/e2e/drill.spec.ts`             |
-| Words never broken across lines, at three widths        | `tests/e2e/drill.spec.ts`             |
-| Both button variants, both themes                       | `tests/e2e/drill.spec.ts`             |
-| Nothing moves on the drill surface under reduced motion | `tests/e2e/drill.spec.ts`             |
-| Drill text, marks, capture and result behaviour         | `tests/functional/drill-view.test.ts` |
+| What                                                    | Where                                         |
+| ------------------------------------------------------- | --------------------------------------------- |
+| Axe, WCAG 2.0/2.1/2.2 A and AA rules                    | `tests/e2e/load-layout.spec.ts`               |
+| Contrast, both themes, computed styles                  | `tests/e2e/contrast.spec.ts`                  |
+| Contrast maths                                          | `tests/unit/contrast.test.ts`                 |
+| Reflow at 320, 600 and 1280 px                          | `tests/e2e/reflow.spec.ts`                    |
+| Visible focus ring                                      | `tests/e2e/load-layout.spec.ts`               |
+| Keyboard-only reachability                              | `tests/e2e/load-layout.spec.ts`               |
+| Adjustable and disableable time limits                  | `tests/unit/limits.test.ts`                   |
+| Sprint duration control, countdown and warnings         | `tests/e2e/sprint.spec.ts`                    |
+| A sprint timer never acting on another drill            | `tests/regression/prototype-failures.test.ts` |
+| Escape releases capture, and Tab still moves focus      | `tests/e2e/pending.spec.ts`                   |
+| Marks told apart by decoration, not colour alone        | `tests/e2e/drill.spec.ts`                     |
+| The drill surface's name and its description            | `tests/e2e/drill.spec.ts`                     |
+| Words never broken across lines, at three widths        | `tests/e2e/drill.spec.ts`                     |
+| Both button variants, both themes                       | `tests/e2e/drill.spec.ts`                     |
+| Nothing moves on the drill surface under reduced motion | `tests/e2e/drill.spec.ts`                     |
+| Drill text, marks, capture and result behaviour         | `tests/functional/drill-view.test.ts`         |
 
 ## Manual checklist
 
@@ -136,11 +138,34 @@ cannot be, so every item here still needs a manual pass.
 
 ### Timing
 
-Sprint mode imposes a limit, so WCAG 2.2.1 applies.
-
-- [ ] A duration control is offered.
-- [ ] An untimed option is offered, and it genuinely never expires.
-- [ ] The exemption for essential timing is not claimed.
+Sprint mode imposes a limit, so WCAG 2.2.1 applies. The exemption for essential
+timing is deliberately not claimed: a sprint is a measurement, and a measurement
+someone cannot take is not essential to anything.
+
+- [x] A duration control is offered, built from `SPRINT_DURATIONS_MS` so the
+      options and the durations cannot drift apart. **Automated** in
+      `tests/functional/sprint-view.test.ts` and `tests/e2e/sprint.spec.ts`.
+- [x] An untimed option is offered, and it genuinely never expires. **Automated**
+      three times over, at three scales: `hasReachedLimit` at
+      `Number.MAX_SAFE_INTEGER` in `tests/regression/prototype-failures.test.ts`,
+      a century of elapsed time through a running sprint timer in
+      `tests/unit/sprint.test.ts` and `tests/functional/sprint-view.test.ts`, and
+      an hour of faked wall clock in a real browser in
+      `tests/e2e/pending.spec.ts`.
+- [x] The limit is adjustable before the sprint starts, and the current setting
+      is stated in visible text rather than only shown as a selected option.
+      **Automated** in `tests/e2e/sprint.spec.ts`.
+- [x] The exemption for essential timing is not claimed.
+- [x] The countdown is visible while a timed sprint runs, and is a `role="timer"`
+      whose implicit live setting is off, so it is never announced per second.
+      **Automated** in `tests/functional/sprint-view.test.ts` and
+      `tests/e2e/sprint.spec.ts`.
+- [x] Time running out is announced politely at a handful of milestones — a
+      minute, thirty seconds, ten — so the countdown is never the only channel.
+      **Automated**: the count of announcements over a whole sprint is asserted,
+      in `tests/functional/sprint-view.test.ts`. Hearing it is still manual.
+- [ ] A sprint feels escapable to someone using a screen reader: the milestones
+      land without talking over the word announcements. Needs a person.
 
 ### Reflow and zoom
 
@@ -166,8 +191,8 @@ exists.
 - Screen reader testing is manual. There is no automated substitute. The regions,
   their roles and the text written into them are asserted, and that is as far as a
   test reaches: no test can hear VoiceOver or NVDA.
-- The sprint and ladder views do not exist yet, so the timing section is checked
-  only at the unit level, through `src/drill/limits.ts`.
+- The repair drill does not exist yet, so nothing checks what it says about the
+  keys it was built from.
 - Nothing yet checks the drill surface at 400 per cent zoom by hand. Reflow at 320
   CSS pixels is automated, which is the same measurement from the other side, but
   it is not the same experience.
diff --git a/index.html b/index.html
index ee3d788..f25cf3e 100644
--- a/index.html
+++ b/index.html
@@ -83,6 +83,18 @@ <h2 id="drill-heading">Practise</h2>
           <button id="drill-reset" type="button" class="button button-outline">Start over</button>
         </p>
         <p id="drill-next" class="drill-next"></p>
+        <!--
+          The sprint countdown.
+
+          It sits here, directly above the text, because that is where the eyes
+          already are; the control that sets it lives in its own section below.
+
+          role="timer" carries an implicit aria-live of "off", which is the
+          point: the number changes every second and a region that announced it
+          would be unusable. The other channel is #sprint-warning below, a polite
+          region written only at a handful of milestones.
+        -->
+        <p id="sprint-countdown" class="sprint-countdown" role="timer" hidden></p>
         <div
           id="drill-surface"
           class="drill-surface"
@@ -97,6 +109,7 @@ <h2 id="drill-heading">Practise</h2>
           Escape releases the keyboard from anywhere in the drill.
         </p>
         <p id="drill-capture" class="drill-hint" role="status" aria-live="polite"></p>
+        <p id="sprint-warning" class="drill-hint" role="status" aria-live="polite"></p>
         <p id="drill-progress" class="drill-progress" role="status" aria-live="polite"></p>
         <p id="drill-error" class="drill-error" role="alert" hidden></p>
 
@@ -112,6 +125,38 @@ <h3>How that went</h3>
         </div>
       </section>
 
+      <!--
+        Sprint mode.
+
+        It comes after the drill section for the same reason the ladder does: the
+        first few tab stops on the page have to reach the drill controls, and a
+        duration control between the file input and "Start drill" would take one
+        of them.
+
+        WCAG 2.2.1 applies here and the exemption is not claimed. The duration is
+        adjustable before a sprint starts, the current setting is stated in words
+        under the control rather than only shown as a selected option, and one of
+        the options is untimed and genuinely never expires.
+      -->
+      <section id="sprint-section" aria-labelledby="sprint-heading" hidden>
+        <h2 id="sprint-heading">Sprint</h2>
+        <p id="sprint-intro">
+          A timed run across every key you have unlocked so far, rather than one lesson. It measures
+          where you are, so it earns no stars. Escape gives the keyboard back mid-sprint, as it does
+          everywhere else.
+        </p>
+        <p>
+          <label class="field">
+            <span>How long the sprint runs</span>
+            <select id="sprint-duration"></select>
+          </label>
+        </p>
+        <p id="sprint-setting" class="drill-hint"></p>
+        <p class="drill-controls">
+          <button id="sprint-start" type="button" class="button button-solid">Start sprint</button>
+        </p>
+      </section>
+
       <!--
         The ladder.
 
diff --git a/src/drill/sprint.ts b/src/drill/sprint.ts
new file mode 100644
index 0000000..265f819
--- /dev/null
+++ b/src/drill/sprint.ts
@@ -0,0 +1,381 @@
+/**
+ * Sprint mode: a timed run across everything unlocked, for measuring rather
+ * than learning.
+ *
+ * Two jobs live here, and both are DOM-free like the rest of this layer.
+ *
+ * **What a sprint is made of.** `sprintLesson` folds every lesson the learner
+ * has reached into one synthetic lesson, so the text generator can be handed a
+ * sprint the same way it is handed a rung. A sprint is not lesson zero and it is
+ * not the current lesson: it is all of them at once, which is the only reason it
+ * measures anything.
+ *
+ * **The timer, and why it is here rather than in the UI.** Regression 3 is the
+ * nastiest failure this project shipped: an abandoned sprint left its interval
+ * running, the interval then acted on whichever drill was current, and because
+ * an untimed drill carried a limit of zero, "elapsed is at least the limit" was
+ * true on the very first keystroke. Every drill after that died instantly.
+ *
+ * Half of that is fixed in `limits.ts`, where `NO_LIMIT` is a real state. The
+ * other half is fixed here, structurally: `startSprintTimer` captures the one
+ * `Drill` it is for and never looks a drill up again. It also demands a
+ * `currentDrill` reader and compares it with that captured object **by
+ * identity** on every single tick, stopping itself the moment they differ. So a
+ * teardown that is missed — which is exactly how this happened the first time —
+ * costs one tick of nothing, not every drill that follows. The binding is a
+ * required argument rather than a convention, so it cannot be forgotten: there
+ * is no way to construct a timer that is not bound to a drill.
+ *
+ * The repeating callback itself is injected. Nothing in `src/drill/**` reaches
+ * for `setInterval`, so every test drives this by calling the tick directly and
+ * the engine's "the UI drives elapsed time" rule survives intact.
+ */
+
+import type { Lesson } from '../ladder/generate.js';
+import { describeLimit, isTimed } from './limits.js';
+import type { Drill, DrillResult } from './types.js';
+
+export class SprintError extends Error {
+  override readonly name = 'SprintError';
+  constructor(problem: string, options?: ErrorOptions) {
+    super(`Cannot build a sprint: ${problem}`, options);
+  }
+}
+
+/**
+ * A tick that failed. Thrown rather than swallowed, with the original attached,
+ * and the timer is stopped first so a broken observer cannot leave an interval
+ * running — which is the shape of the bug this module exists to prevent.
+ */
+export class SprintTimerError extends Error {
+  override readonly name = 'SprintTimerError';
+  constructor(options: ErrorOptions) {
+    super('The sprint timer failed on a tick, so it has stopped itself.', options);
+  }
+}
+
+/**
+ * The id the synthetic sprint lesson carries. It is deliberately not an id any
+ * generated ladder uses, because a sprint must never be able to write stars to a
+ * rung: scoring refuses stars outside lesson mode, and this is the second lock
+ * on the same door.
+ */
+export const SPRINT_LESSON_ID = 'sprint';
+
+export const SPRINT_LESSON_NAME = 'Sprint';
+
+/**
+ * One lesson standing for everything unlocked.
+ *
+ * Lessons are cumulative, so the last unlocked rung's key set is already the
+ * whole of it; the union is taken anyway because "every key unlocked" is the
+ * thing being asked for, and a ladder that ever stops being cumulative should
+ * change the sprint rather than quietly narrow it.
+ *
+ * The stage is the reached lesson's own stage, so a sprint drills prose once the
+ * ladder has reached prose and capitals once it has reached capitals, and never
+ * asks for a character the learner has not been shown.
+ */
+export function sprintLesson(lessons: readonly Lesson[], unlockedIndex: number): Lesson {
+  if (lessons.length === 0) {
+    throw new SprintError('this layout produced no ladder, so nothing is unlocked');
+  }
+  if (!Number.isInteger(unlockedIndex) || unlockedIndex < 0) {
+    throw new SprintError(
+      `the unlocked lesson index must be a non-negative whole number, got ${String(unlockedIndex)}`,
+    );
+  }
+  // Clamped rather than refused: an imported progress file may have come from a
+  // longer ladder than this layout produces, and sprinting everything this
+  // ladder has is the right answer to that.
+  const reachedIndex = Math.min(unlockedIndex, lessons.length - 1);
+  const reached = lessons[reachedIndex];
+  if (reached === undefined) {
+    // Unreachable given the clamp above; prefer throwing to inventing a lesson.
+    throw new SprintError(`no lesson at index ${reachedIndex} of ${lessons.length}`);
+  }
+
+  const keys: string[] = [];
+  for (const lesson of lessons.slice(0, reachedIndex + 1)) {
+    for (const key of lesson.keys) {
+      if (!keys.includes(key)) keys.push(key);
+    }
+  }
+  if (keys.length === 0) {
+    throw new SprintError('the lessons unlocked so far contain no keys');
+  }
+
+  const rungs = reachedIndex + 1;
+  return {
+    id: SPRINT_LESSON_ID,
+    name: SPRINT_LESSON_NAME,
+    blurb:
+      `Everything you have unlocked at once: ${keys.length} keys from ` +
+      `${rungs === 1 ? '1 lesson' : `${rungs} lessons`}. A sprint measures where you are; ` +
+      'it earns no stars.',
+    addedKeys: [],
+    keys,
+    stage: reached.stage,
+  };
+}
+
+/**
+ * A brisk pace, used only to decide how much text a sprint needs. Higher than
+ * anyone is expected to type, because a sprint that runs out of words before it
+ * runs out of time stops measuring and starts being a lesson.
+ */
+export const SPRINT_PACE_WPM = 70;
+/** Enough to score honestly even on the shortest sprint. */
+export const SPRINT_MIN_WORDS = 24;
+/** Past this the page is long enough that nobody reaches the end anyway. */
+export const SPRINT_MAX_WORDS = 200;
+/** An untimed sprint has to be finishable, so it gets a fixed length. */
+export const SPRINT_UNTIMED_WORDS = 48;
+
+export function sprintWordCount(limitMs: number): number {
+  if (!isTimed(limitMs)) return SPRINT_UNTIMED_WORDS;
+  const words = Math.ceil((limitMs / 60_000) * SPRINT_PACE_WPM);
+  return Math.min(SPRINT_MAX_WORDS, Math.max(SPRINT_MIN_WORDS, words));
+}
+
+/**
+ * A duration as a learner would choose it, for a control's option text. Not
+ * `describeLimit` itself, because "untimed" on its own reads like a missing
+ * value in a list of durations, and untimed is the opposite of missing.
+ */
+export function describeDurationChoice(limitMs: number): string {
+  if (!isTimed(limitMs)) return 'Untimed — no limit, it never runs out';
+  return describeLimit(limitMs);
+}
+
+/**
+ * A duration chosen in the UI, checked against the durations actually offered.
+ *
+ * Prefer throwing to a wrong default: a limit that arrived from a control this
+ * module did not populate is a sign the markup and the module have drifted, and
+ * silently sprinting for a minute instead would be a wrong answer nobody sees.
+ */
+export function parseSprintLimit(value: string, durations: readonly number[]): number {
+  // Checked before `Number`, because `Number('')` is zero and zero is `NO_LIMIT`:
+  // an empty control would otherwise read as a deliberate choice of untimed.
+  // Absent, zero and malformed are three different things.
+  if (value.trim() === '') {
+    throw new SprintError('no duration was chosen; an empty control is not the untimed option');
+  }
+  const limitMs = Number(value);
+  if (!Number.isFinite(limitMs) || !durations.includes(limitMs)) {
+    throw new SprintError(
+      `${JSON.stringify(value)} is not one of the durations on offer (${durations.join(', ')})`,
+    );
+  }
+  return limitMs;
+}
+
+/** Seconds left, rounded up, so the readout only reads zero when it is. */
+export function secondsLeft(remainingMs: number): number {
+  if (!Number.isFinite(remainingMs) || remainingMs < 0) {
+    throw new RangeError(
+      `Remaining time must be a non-negative number, got ${String(remainingMs)}`,
+    );
+  }
+  return Math.ceil(remainingMs / 1000);
+}
+
+/**
+ * The visible countdown.
+ *
+ * `null` means untimed, as it does everywhere else in this layer, and it says so
+ * in words rather than showing a dash or a frozen zero.
+ */
+export function describeCountdown(remainingMs: number | null): string {
+  if (remainingMs === null) return 'Untimed sprint. There is no time limit, so it never runs out.';
+  const seconds = secondsLeft(remainingMs);
+  const minutes = Math.floor(seconds / 60);
+  const rest = seconds % 60;
+  return `Time left: ${minutes}:${String(rest).padStart(2, '0')}`;
+}
+
+/**
+ * When to say something out loud, longest first.
+ *
+ * The countdown is a visible readout and nothing announces it, because a region
+ * that spoke every second would make the drill unusable with a screen reader.
+ * These milestones are the other channel: a handful of polite announcements, so
+ * the time running out is never something only a sighted learner can know.
+ */
+export const SPRINT_WARNINGS_MS: readonly number[] = [60_000, 30_000, 10_000];
+
+export interface SprintWarnings {
+  /** What to announce now, or null when nothing is due. Never repeats itself. */
+  due(remainingMs: number | null): string | null;
+  /** The thresholds this sprint is long enough to use. */
+  readonly armed: readonly number[];
+}
+
+/**
+ * Milestone announcements for one sprint.
+ *
+ * A threshold at or above the whole limit is dropped: announcing "1 minute left"
+ * as a one-minute sprint starts is noise, not information. Each armed threshold
+ * fires once, and a tick that skips past several fires only the tightest of
+ * them, so a slow tick cannot produce a burst.
+ */
+export function createSprintWarnings(
+  limitMs: number,
+  thresholds: readonly number[] = SPRINT_WARNINGS_MS,
+): SprintWarnings {
+  const armed = isTimed(limitMs)
+    ? [...thresholds]
+        .filter((threshold) => threshold > 0 && threshold < limitMs)
+        .sort((a, b) => b - a)
+    : [];
+  const fired = new Set<number>();
+
+  return {
+    armed,
+    due(remainingMs: number | null): string | null {
+      // An untimed sprint has nothing to warn about, by definition.
+      if (remainingMs === null) return null;
+      const crossed = armed.filter(
+        (threshold) => !fired.has(threshold) && remainingMs <= threshold,
+      );
+      if (crossed.length === 0) return null;
+      for (const threshold of crossed) fired.add(threshold);
+      const tightest = Math.min(...crossed);
+      return `${describeLimit(tightest)} left in this sprint.`;
+    },
+  };
+}
+
+/** Why a timer stopped. Every path out of a running timer names itself. */
+export type SprintStopReason =
+  /** Its drill's limit ran out; the result has been handed on. */
+  | 'expired'
+  /** Its drill finished by being typed through. */
+  | 'finished'
+  /** Its drill is no longer the current one. This is regression 3's guard. */
+  | 'abandoned'
+  /** Someone called `stop`. */
+  | 'stopped'
+  /** A tick threw. The error is rethrown, never swallowed. */
+  | 'error';
+
+export interface SprintTimerOptions {
+  /**
+   * The drill this timer is for. Captured once, here, and never looked up
+   * again: every tick acts on this object or on nothing at all.
+   */
+  readonly drill: Drill;
+  /**
+   * What the app has on screen now. Compared with `drill` by identity on every
+   * tick, and the timer stops itself the instant they differ.
+   *
+   * Required rather than optional on purpose. The whole of regression 3 was a
+   * timer that acted on whichever drill was current, so a timer that cannot be
+   * built without being told how to recognise its own drill is the fix.
+   */
+  readonly currentDrill: () => Drill | null;
+  /** Starts the repeating tick, and returns the function that cancels it. */
+  readonly schedule: (tick: () => void) => () => void;
+  /** Called on each tick the bound drill is still live. `null` when untimed. */
+  readonly onTick?: (remainingMs: number | null, drill: Drill) => void;
+  /** Called once, with the result, when the bound drill's own limit runs out. */
+  readonly onExpire?: (result: DrillResult, drill: Drill) => void;
+  readonly onStop?: (reason: SprintStopReason, drill: Drill) => void;
+}
+
+export interface SprintTimer {
+  /** The one drill this timer may ever act on. */
+  readonly drill: Drill;
+  readonly stopped: boolean;
+  /** Why it stopped, or null while it is still running. */
+  readonly stopReason: SprintStopReason | null;
+  /** Idempotent. Safe from inside a tick and safe twice. */
+  stop(): void;
+}
+
+export function startSprintTimer(options: SprintTimerOptions): SprintTimer {
+  // Captured once. Nothing below ever reads `options.drill` again, so there is
+  // no later moment at which this timer could be pointed at another drill.
+  const bound = options.drill;
+
+  let cancel: (() => void) | null = null;
+  let stopped = false;
+  let stopReason: SprintStopReason | null = null;
+
+  function isStopped(): boolean {
+    return stopped;
+  }
+
+  function stop(reason: SprintStopReason): void {
+    if (stopped) return;
+    stopped = true;
+    stopReason = reason;
+    const cancelNow = cancel;
+    cancel = null;
+    if (cancelNow !== null) cancelNow();
+    options.onStop?.(reason, bound);
+  }
+
+  function runTick(): void {
+    if (stopped) return;
+
+    // The binding, checked before anything else happens. A timer that has
+    // outlived its drill does nothing and takes itself out of the world.
+    if (options.currentDrill() !== bound) {
+      stop('abandoned');
+      return;
+    }
+
+    if (bound.isFinished) {
+      stop('finished');
+      return;
+    }
+
+    // Asked of the bound drill, so an untimed drill is asked about its own
+    // absent limit and answers null, whatever any other drill's limit is.
+    const expired = bound.checkTimeLimit();
+    if (expired !== null) {
+      // Stopped before the result is handed on, so an observer that throws
+      // cannot leave this interval running behind it.
+      stop('expired');
+      options.onExpire?.(expired, bound);
+      return;
+    }
+
+    options.onTick?.(bound.remainingMs(), bound);
+  }
+
+  function tick(): void {
+    try {
+      runTick();
+    } catch (cause) {
+      stop('error');
+      throw new SprintTimerError({ cause });
+    }
+  }
+
+  // Scheduled last, so that everything a tick reads is already in place. A
+  // schedule that runs its tick synchronously can therefore stop this timer
+  // before it has even handed back a cancel, so that cancel is honoured here
+  // rather than quietly dropped and left running.
+  const started = options.schedule(tick);
+  if (isStopped()) {
+    started();
+  } else {
+    cancel = started;
+  }
+
+  return {
+    drill: bound,
+    get stopped() {
+      return stopped;
+    },
+    get stopReason() {
+      return stopReason;
+    },
+    stop(): void {
+      stop('stopped');
+    },
+  };
+}
diff --git a/src/ui/drill-view.ts b/src/ui/drill-view.ts
index 0721399..c29973e 100644
--- a/src/ui/drill-view.ts
+++ b/src/ui/drill-view.ts
@@ -24,10 +24,14 @@
  * nothing in this module moves focus except in response to Escape or a click, and
  * nothing listens for focus leaving in order to pull it back.
  *
- * No timer lives here either. The engine owns no interval and neither does this:
- * elapsed time is driven by calling `checkTimeLimit()` on each keystroke, which
- * is all an untimed drill needs. Sprint mode's wall-clock tick arrives with the
- * sprint work, and when it does it belongs in this module, not in the engine.
+ * **The engine owns no timer, and neither does this.** Elapsed time is driven by
+ * calling `checkTimeLimit()` on each keystroke, which is all a lesson needs. A
+ * sprint also needs a wall clock, because its limit can run out while nobody is
+ * typing, so this module — never the engine — schedules one. It does it through
+ * `startSprintTimer`, which captures the drill it is for and compares it by
+ * identity on every tick, so a timer this module forgets to stop can still only
+ * ever act on its own drill. That is regression 3, and the binding is structural
+ * rather than a teardown anyone has to remember.
  */
 
 import { describeKey, indexKeys, type BoardDefinition, type KeyPosition } from '../board/types.js';
@@ -41,7 +45,15 @@ import {
   type DrillSession,
   type Mark,
 } from '../drill/index.js';
+import { describeLimit } from '../drill/limits.js';
 import { scoreDrill, type DrillMode, type DrillScore } from '../drill/scoring.js';
+import {
+  createSprintWarnings,
+  describeCountdown,
+  startSprintTimer,
+  type SprintTimer,
+  type SprintWarnings,
+} from '../drill/sprint.js';
 import type { Keymap } from '../keymap/types.js';
 import { keyStatId } from '../stats/storage.js';
 import { required } from './dom.js';
@@ -64,6 +76,20 @@ export const SAMPLE_DRILL_TEXT = 'ask a task; a lad had a flask.';
 export const DRILL_WORD_CLASS = 'drill-word';
 export const DRILL_CHAR_CLASS = 'drill-char';
 
+/**
+ * How often a running sprint looks at the clock. A second, because the countdown
+ * is shown to the second and a faster tick would only burn battery.
+ */
+export const SPRINT_TICK_MS = 1000;
+
+/** The default schedule: a plain interval, and the cancel that clears it. */
+function intervalSchedule(tick: () => void): () => void {
+  const id = setInterval(tick, SPRINT_TICK_MS);
+  return (): void => {
+    clearInterval(id);
+  };
+}
+
 /**
  * A drill text that this layout cannot type. Thrown rather than dropping the
  * characters, because a drill that asks for a key the keyboard does not have
@@ -133,6 +159,15 @@ export interface DrillViewOptions {
    * called for an unfinished drill.
    */
   readonly onScored?: (scored: ScoredDrill) => void;
+  /**
+   * Starts the sprint countdown's repeating tick and returns the function that
+   * cancels it. Defaults to `setInterval` at `SPRINT_TICK_MS`.
+   *
+   * Injected so that a test can step the clock itself and assert what the timer
+   * did, rather than waiting a real second for it. A schedule is only ever asked
+   * for in sprint mode; a lesson never creates one.
+   */
+  readonly schedule?: (tick: () => void) => () => void;
   readonly root?: ParentNode;
 }
 
@@ -291,6 +326,8 @@ export function createDrillView(options: DrillViewOptions): DrillView {
     capture: required('#drill-capture', HTMLElement, root),
     progress: required('#drill-progress', HTMLElement, root),
     error: required('#drill-error', HTMLElement, root),
+    countdown: required('#sprint-countdown', HTMLElement, root),
+    timeWarning: required('#sprint-warning', HTMLElement, root),
     result: required('#drill-result', HTMLElement, root),
     resultSummary: required('#drill-result-summary', HTMLElement, root),
     resultDetail: required('#drill-result-detail', HTMLElement, root),
@@ -312,10 +349,22 @@ export function createDrillView(options: DrillViewOptions): DrillView {
   const session =
     options.session ?? createDrillSession(options.now === undefined ? {} : { now: options.now });
 
+  const schedule = options.schedule ?? intervalSchedule;
+
   let drill: Drill | null = null;
   let rendered = renderDrillText(options.text);
   let captured = false;
   let announcedWord = -1;
+  /**
+   * The sprint's wall clock, and the milestones it announces.
+   *
+   * There is at most one, it belongs to exactly one drill, and it is replaced
+   * rather than added to. Even so, nothing below relies on this variable being
+   * tidied up: the timer stops itself as soon as the drill it was started for is
+   * no longer the current one, which is the guarantee regression 3 needs.
+   */
+  let timer: SprintTimer | null = null;
+  let warnings: SprintWarnings | null = null;
 
   /**
    * Every character has to be typeable on this keyboard before the drill starts.
@@ -392,6 +441,76 @@ export function createDrillView(options: DrillViewOptions): DrillView {
     el.surface.dataset['captured'] = captured ? 'true' : 'false';
   }
 
+  /** The drill mode named in words, so the result card says what it was. */
+  function describeMode(): string {
+    if (mode === 'sprint') {
+      return `sprint across every unlocked key, ${describeLimit(limitMs)}`;
+    }
+    if (mode === 'repair') return 'repair drill';
+    return lessonName === null ? 'lesson' : `lesson: ${lessonName}`;
+  }
+
+  /**
+   * The countdown, and the milestone announcements beside it.
+   *
+   * Two channels on purpose. The readout is a `role="timer"`, whose implicit
+   * live setting is off, so the second-by-second number is never announced; the
+   * polite region is written only when `warnings` says a milestone has been
+   * crossed, which is a handful of times per sprint at most. WCAG 2.2.1 asks for
+   * the limit to be knowable without watching a number tick down.
+   */
+  function paintCountdown(remaining: number | null): void {
+    if (mode !== 'sprint') return;
+    el.countdown.textContent = describeCountdown(remaining);
+    el.countdown.hidden = false;
+    const warning = warnings?.due(remaining) ?? null;
+    if (warning !== null) el.timeWarning.textContent = warning;
+  }
+
+  function hideCountdown(): void {
+    el.countdown.hidden = true;
+    el.countdown.textContent = '';
+    el.timeWarning.textContent = '';
+  }
+
+  /**
+   * Stop whatever timer is running, if one is.
+   *
+   * Deliberately not the thing that makes this safe. A teardown that is missed
+   * is exactly how regression 3 happened, so the timer also stops itself the
+   * moment its own drill stops being the current one. This is the tidy path; the
+   * identity check in `startSprintTimer` is the guarantee.
+   */
+  function stopTimer(): void {
+    timer?.stop();
+    timer = null;
+  }
+
+  /**
+   * Give this drill, and only this drill, a wall clock.
+   *
+   * `currentDrill` reads the view's own `drill` variable, so the moment
+   * `startDrill` replaces it — or anything else abandons it — the tick sees a
+   * different object and the timer takes itself out of the world without
+   * touching the new drill.
+   */
+  function startTimer(current: Drill): void {
+    stopTimer();
+    warnings = createSprintWarnings(limitMs);
+    timer = startSprintTimer({
+      drill: current,
+      currentDrill: () => drill,
+      schedule,
+      onTick: (remaining) => {
+        paintCountdown(remaining);
+      },
+      onExpire: (result, expiredDrill) => {
+        finish(expiredDrill, result);
+      },
+    });
+    paintCountdown(current.remainingMs());
+  }
+
   function paintMarks(current: Drill | null): void {
     const marks: readonly Mark[] = current?.marks ?? [];
     const cursor = current === null || current.isFinished ? -1 : current.cursor;
@@ -444,7 +563,11 @@ export function createDrillView(options: DrillViewOptions): DrillView {
   function render(): void {
     paintMarks(drill);
     describeNext(drill);
-    if (drill !== null && !drill.isFinished) announceWord(drill);
+    if (drill === null || drill.isFinished) return;
+    announceWord(drill);
+    // Between ticks as well as on them, so the readout answers to the keystroke
+    // that was just typed rather than lagging up to a second behind it.
+    paintCountdown(drill.remainingMs());
   }
 
   /**
@@ -492,6 +615,12 @@ export function createDrillView(options: DrillViewOptions): DrillView {
     return [['Best on this lesson', starWords(scored.bestStars)]];
   }
 
+  /** How the assertive summary opens. A sprint says so; a lesson reads as before. */
+  function completionLead(completed: boolean): string {
+    if (mode === 'sprint') return completed ? 'Sprint complete' : 'Sprint over, time up';
+    return completed ? 'Drill complete' : 'Time up';
+  }
+
   function showResult(current: Drill, result: DrillResult): void {
     const score: DrillScore = scoreDrill({
       mode,
@@ -517,6 +646,10 @@ export function createDrillView(options: DrillViewOptions): DrillView {
       ],
       ['Stars', mode === 'lesson' ? starWords(score.stars) : 'none, this was not a lesson'],
       ['Experience', `${score.experienceGained} XP`],
+      // Named rather than left to be inferred from the star row: "the result
+      // distinguishes a sprint from a lesson" is an acceptance criterion, and
+      // "none, this was not a lesson" says what it was not, never what it was.
+      ['Drill', describeMode()],
       ['Ended', result.completed ? 'you typed it through' : 'the time limit ran out'],
       ...bestStarsRow(recorded),
     ];
@@ -541,16 +674,22 @@ export function createDrillView(options: DrillViewOptions): DrillView {
     // Unhidden first, then written, so the assertive region announces the result
     // once rather than announcing an empty region and then its contents.
     el.resultSummary.textContent =
-      `${result.completed ? 'Drill complete' : 'Time up'}. ` +
+      `${completionLead(result.completed)}. ` +
       `${score.wordsPerMinute} words per minute, ${percentage(score.accuracy)} accuracy` +
       `${mode === 'lesson' ? `, ${starWords(score.stars)}` : ''}. ` +
       `Next: ${score.nextStep.label}. ${score.nextStep.why}`;
 
-    el.start.textContent = 'Start another drill';
+    el.start.textContent = mode === 'sprint' ? 'Start another sprint' : 'Start another drill';
   }
 
   function finish(current: Drill, result: DrillResult): void {
+    // Before anything is rendered: a finished drill has no time left to count,
+    // and a tick landing mid-render would only repaint a dead countdown.
+    stopTimer();
     render();
+    if (mode === 'sprint') {
+      el.countdown.textContent = describeCountdown(result.completed ? current.remainingMs() : 0);
+    }
     showResult(current, result);
   }
 
@@ -579,7 +718,7 @@ export function createDrillView(options: DrillViewOptions): DrillView {
     }
 
     if (drill !== null && !drill.isFinished) {
-      el.start.textContent = 'Resume drill';
+      el.start.textContent = mode === 'sprint' ? 'Resume sprint' : 'Resume drill';
     }
   }
 
@@ -587,13 +726,23 @@ export function createDrillView(options: DrillViewOptions): DrillView {
     checkTypeable(options.text);
     clearError();
     hideResult();
+    // The outgoing drill is abandoned here, so its timer goes with it. Even if
+    // this line were lost, the old timer could not touch the new drill: it
+    // compares the drill it captured with the current one and stops instead.
+    stopTimer();
+    hideCountdown();
     announcedWord = -1;
     const drillOptions: DrillOptions = { text: options.text, limitMs };
     drill = session.start(drillOptions);
     mountText(options.text);
-    el.start.textContent = 'Resume drill';
+    el.start.textContent = mode === 'sprint' ? 'Resume sprint' : 'Resume drill';
+    if (mode === 'sprint') startTimer(drill);
     render();
-    announce(`Drill ready: ${rendered.wordTexts.length} words. Type what you see.`);
+    announce(
+      mode === 'sprint'
+        ? `Sprint ready: ${rendered.wordTexts.length} words, ${describeLimit(limitMs)}. Type what you see.`
+        : `Drill ready: ${rendered.wordTexts.length} words. Type what you see.`,
+    );
     focusSurface();
   }
 
@@ -720,6 +869,12 @@ export function createDrillView(options: DrillViewOptions): DrillView {
   mountText(options.text);
   hideResult();
   clearError();
+  // A fresh view owns the countdown whether or not it is a sprint: a lesson
+  // built over an abandoned sprint must not leave that sprint's clock on screen.
+  hideCountdown();
+  // And it owns the start button's wording for the same reason. A lesson built
+  // after a sprint was abandoned must not still be offering to resume it.
+  el.start.textContent = mode === 'sprint' ? 'Restart this sprint' : 'Start drill';
   setCaptureState('');
   render();
 
@@ -733,6 +888,7 @@ export function createDrillView(options: DrillViewOptions): DrillView {
     start: startDrill,
     release,
     destroy(): void {
+      stopTimer();
       release('teardown');
       el.start.removeEventListener('click', onStartClick);
       el.reset.removeEventListener('click', startDrill);
diff --git a/src/ui/load-form.ts b/src/ui/load-form.ts
index 46b225a..9676421 100644
--- a/src/ui/load-form.ts
+++ b/src/ui/load-form.ts
@@ -30,8 +30,11 @@ import {
 import { describeFailure, required } from './dom.js';
 import { createDrillView, SAMPLE_DRILL_TEXT, type DrillView } from './drill-view.js';
 import { DrillTextError, generateDrillText } from '../drill/text.js';
+import { highestUnlockedLesson } from '../drill/scoring.js';
+import { SprintError, sprintLesson, sprintWordCount } from '../drill/sprint.js';
 import { summariseKeymap } from './layout-summary.js';
 import { createProgressView, type ProgressView } from './progress-view.js';
+import { createSprintControls, type SprintControls } from './sprint-controls.js';
 
 /**
  * Where saved progress lives, and what to tell the learner about it.
@@ -105,6 +108,7 @@ export function wireUp(root: ParentNode = document, options: WireUpOptions = {})
   const legend = required('#board-legend', HTMLElement, root);
   const keyList = required('#board-key-list', HTMLElement, root);
   const drillSection = required('#drill-section', HTMLElement, root);
+  const sprintSection = required('#sprint-section', HTMLElement, root);
   const ladderSection = required('#ladder-section', HTMLElement, root);
   const statsSection = required('#stats-section', HTMLElement, root);
   const progressSection = required('#progress-section', HTMLElement, root);
@@ -115,6 +119,7 @@ export function wireUp(root: ParentNode = document, options: WireUpOptions = {})
   let restingHighlight = GLOVE80.spacePosition;
   let drillView: DrillView | null = null;
   let progressView: ProgressView | null = null;
+  let sprintControls: SprintControls | null = null;
 
   /**
    * Storage, the session and the saved progress are set up once, here, before a
@@ -139,6 +144,7 @@ export function wireUp(root: ParentNode = document, options: WireUpOptions = {})
     summary.hidden = true;
     board.hidden = true;
     drillSection.hidden = true;
+    sprintSection.hidden = true;
     ladderSection.hidden = true;
     statsSection.hidden = true;
     progressSection.hidden = true;
@@ -236,23 +242,92 @@ export function wireUp(root: ParentNode = document, options: WireUpOptions = {})
             },
           }),
       root,
-      onNextKey: (next): void => {
-        if (next === null) {
-          highlight(restingHighlight, 'Highlighted on the diagram');
-          return;
-        }
-        highlight(next.position, 'Highlighted on the diagram, the next key');
-      },
-      onScored: (): void => {
-        // The stars and the experience are already in live progress by now. This
-        // is where they are written down and where the ladder learns about them.
-        progressView?.save();
-        progressView?.refresh();
-      },
+      onNextKey: followNextKey,
+      onScored: saveAndRefresh,
     });
     drillSection.hidden = false;
   }
 
+  /** The board highlight follows the drill rather than leading it. */
+  function followNextKey(next: { readonly position: number } | null): void {
+    if (next === null) {
+      highlight(restingHighlight, 'Highlighted on the diagram');
+      return;
+    }
+    highlight(next.position, 'Highlighted on the diagram, the next key');
+  }
+
+  function saveAndRefresh(): void {
+    // The stars and the experience are already in live progress by now. This is
+    // where they are written down and where the ladder learns about them.
+    progressView?.save();
+    progressView?.refresh();
+  }
+
+  /**
+   * Replaces the drill surface with a sprint and starts it.
+   *
+   * A sprint is not a rung: it runs against every key unlocked so far, folded
+   * into one synthetic lesson by `sprintLesson`, and it carries no lesson id, so
+   * it earns experience and no stars. Scoring refuses stars outside lesson mode
+   * anyway; passing null here means there is nowhere for them to go either.
+   *
+   * Building the drill destroys the previous view, which stops that drill's
+   * timer. Nothing depends on that happening: a sprint timer is bound to its own
+   * drill and stops itself when another drill becomes current. Regression 3.
+   */
+  function showSprint(keymap: Keymap, lessons: readonly Lesson[], limitMs: number): void {
+    const stars = lessons.map((lesson) => session.progress.stars[lesson.id] ?? 0);
+    const unlocked = highestUnlockedLesson(stars);
+
+    let text: string;
+    try {
+      const lesson = sprintLesson(lessons, unlocked);
+      text = generateDrillText(lesson, { seed: seed(), words: sprintWordCount(limitMs) });
+    } catch (cause) {
+      // Surfaced, never swallowed, and the drill already on screen is left
+      // exactly as it was: a sprint that cannot be built must not take the
+      // learner's lesson away with it.
+      if (cause instanceof SprintError || cause instanceof DrillTextError) {
+        showSprintError(`Could not build a sprint: ${cause.message}`);
+        return;
+      }
+      throw cause;
+    }
+
+    clearError();
+    drillView?.destroy();
+    drillView = createDrillView({
+      board: GLOVE80,
+      keymap,
+      text,
+      limitMs,
+      session,
+      mode: 'sprint',
+      lessonId: null,
+      lessonName: null,
+      nextLessonName: null,
+      root,
+      onNextKey: followNextKey,
+      onScored: saveAndRefresh,
+    });
+    drillSection.hidden = false;
+    // Start it here rather than making the learner press a second button: they
+    // have already said "Start sprint", and the duration was set before that.
+    drillView.start();
+  }
+
+  /**
+   * A sprint that could not be built, reported without tearing the page down.
+   *
+   * `showError` hides every section, which is right for a layout that would not
+   * parse and wrong here: the lesson on screen is still perfectly good.
+   */
+  function showSprintError(message: string): void {
+    error.textContent = message;
+    error.hidden = false;
+  }
+
   /**
    * Builds the ladder, the statistics and the export and import controls.
    *
@@ -286,6 +361,15 @@ export function wireUp(root: ParentNode = document, options: WireUpOptions = {})
     // actually produce: an imported file may have come from a longer one.
     const current = lessons[Math.min(Math.max(0, session.progress.lesson), lessons.length - 1)];
     showDrill(keymap, current ?? null, nextAfter(lessons, current ?? null), lessons);
+
+    sprintControls?.destroy();
+    sprintControls = createSprintControls({
+      root,
+      onStart: (limitMs): void => {
+        showSprint(keymap, lessons, limitMs);
+      },
+    });
+    sprintSection.hidden = false;
   }
 
   function clearError(): void {
diff --git a/src/ui/sprint-controls.ts b/src/ui/sprint-controls.ts
new file mode 100644
index 0000000..ee41f81
--- /dev/null
+++ b/src/ui/sprint-controls.ts
@@ -0,0 +1,106 @@
+/**
+ * The sprint's duration control.
+ *
+ * WCAG 2.2.1 applies to sprint mode, because a sprint imposes a time limit, and
+ * the brief declines to argue the "essential timing" exemption. So the limit is
+ * adjustable before a sprint starts, the current setting is stated in visible
+ * text beside the control rather than only implied by the selected option, and
+ * one of the options genuinely never expires — `NO_LIMIT` is a real state in
+ * `limits.ts`, not a zero that reads as "already out of time".
+ *
+ * The options are built from `SPRINT_DURATIONS_MS` rather than written into the
+ * markup, so a duration added there appears here without anyone remembering to
+ * add it twice, and a value that did not come from that list is refused rather
+ * than quietly rounded to something else.
+ */
+
+import { describeLimit, isTimed, SPRINT_DURATIONS_MS } from '../drill/limits.js';
+import { describeDurationChoice, parseSprintLimit } from '../drill/sprint.js';
+import { required } from './dom.js';
+
+/** The duration a learner is offered first. A minute is a sprint; untimed is a choice. */
+export const DEFAULT_SPRINT_LIMIT_MS = 60_000;
+
+export interface SprintControlsOptions {
+  /** Called when the learner starts a sprint, with the limit they chose. */
+  readonly onStart: (limitMs: number) => void;
+  /** Called whenever the chosen limit changes, before any sprint is started. */
+  readonly onLimitChange?: (limitMs: number) => void;
+  readonly initialLimitMs?: number;
+  readonly durations?: readonly number[];
+  readonly root?: ParentNode;
+}
+
+export interface SprintControls {
+  /** The limit a sprint started now would run under. */
+  readonly limitMs: number;
+  /** Remove every listener. Nothing survives this. */
+  destroy(): void;
+}
+
+/** The sentence under the control. The setting is a fact, not a tooltip. */
+export function describeSetting(limitMs: number): string {
+  if (!isTimed(limitMs)) {
+    return 'Current setting: untimed. This sprint will never run out of time; finish it or press Escape whenever you like.';
+  }
+  return `Current setting: ${describeLimit(limitMs)}. You can change this before you start; it stays put once a sprint is running.`;
+}
+
+export function createSprintControls(options: SprintControlsOptions): SprintControls {
+  const root = options.root ?? document;
+  const durations = options.durations ?? SPRINT_DURATIONS_MS;
+  if (durations.length === 0) {
+    // Prefer throwing to offering a control with nothing in it.
+    throw new RangeError('A sprint duration control needs at least one duration to offer');
+  }
+
+  const select = required('#sprint-duration', HTMLSelectElement, root);
+  const setting = required('#sprint-setting', HTMLElement, root);
+  const start = required('#sprint-start', HTMLButtonElement, root);
+
+  select.replaceChildren(
+    ...durations.map((limitMs) => {
+      const option = document.createElement('option');
+      option.value = String(limitMs);
+      option.textContent = describeDurationChoice(limitMs);
+      return option;
+    }),
+  );
+
+  const wanted = options.initialLimitMs ?? DEFAULT_SPRINT_LIMIT_MS;
+  const first = durations[0];
+  if (first === undefined) throw new RangeError('A sprint duration control needs a first duration');
+  select.value = String(durations.includes(wanted) ? wanted : first);
+
+  /** Read back through the parser, so the control and the sprint agree or throw. */
+  function chosen(): number {
+    return parseSprintLimit(select.value, durations);
+  }
+
+  function showSetting(): void {
+    setting.textContent = describeSetting(chosen());
+  }
+
+  function onChange(): void {
+    showSetting();
+    options.onLimitChange?.(chosen());
+  }
+
+  function onStart(): void {
+    options.onStart(chosen());
+  }
+
+  select.addEventListener('change', onChange);
+  start.addEventListener('click', onStart);
+  showSetting();
+
+  return {
+    get limitMs() {
+      return chosen();
+    },
+    destroy(): void {
+      select.removeEventListener('change', onChange);
+      start.removeEventListener('click', onStart);
+    },
+  };
+}
diff --git a/src/ui/theme.css b/src/ui/theme.css
index a422cd1..b1c0c89 100644
--- a/src/ui/theme.css
+++ b/src/ui/theme.css
@@ -129,7 +129,8 @@ a {
   min-height: 1.5rem;
 }
 
-input[type='file'] {
+input[type='file'],
+select {
   padding: 0.5rem;
   border: 1px solid var(--border);
   border-radius: var(--radius);
@@ -137,6 +138,16 @@ input[type='file'] {
   color: var(--ink);
 }
 
+/*
+ * Comfortably past the 24 by 24 CSS pixel floor of WCAG 2.5.8, and past the
+ * 1.5rem the bare element rule sets, because a duration control is something
+ * people change mid-session with whatever pointer they have.
+ */
+select {
+  min-height: 2.25rem;
+  font: inherit;
+}
+
 :focus-visible {
   outline: 3px solid var(--focus);
   outline-offset: 2px;
@@ -367,6 +378,22 @@ dd {
   font-weight: 600;
 }
 
+/*
+ * The sprint countdown.
+ *
+ * Tabular figures so the number does not jog sideways as the digits change: it
+ * sits directly above the text being typed, and movement there is a distraction
+ * at best. It carries no transition in either motion mode for the same reason
+ * the drill text carries none — the second has to land when it lands.
+ */
+.sprint-countdown {
+  margin-block: 0.5rem;
+  color: var(--ink);
+  font-weight: 600;
+  font-variant-numeric: tabular-nums;
+  transition: none;
+}
+
 .drill-surface {
   padding: 0.75rem;
   border: 2px solid var(--border);
diff --git a/tests/e2e/pending.spec.ts b/tests/e2e/pending.spec.ts
index 0516594..b140ea9 100644
--- a/tests/e2e/pending.spec.ts
+++ b/tests/e2e/pending.spec.ts
@@ -3,6 +3,7 @@ import { tmpdir } from 'node:os';
 import { join } from 'node:path';
 import { expect, test } from '@playwright/test';
 import {
+  DRILL_SEED,
   REFERENCE_LAYOUT_PATH,
   drillPrefix,
   expectedDrillText,
@@ -11,8 +12,27 @@ import {
   loadReferenceLayout,
   referenceLadder,
 } from './helpers.js';
+import { sprintLesson, sprintWordCount } from '../../src/drill/sprint.js';
+import { generateDrillText } from '../../src/drill/text.js';
 import type { Page } from '@playwright/test';
 
+/**
+ * The text a sprint will drill, worked out the way the app works it out: the
+ * pinned seed, and the whole key set unlocked so far. With no saved progress
+ * that is the first rung, so this is the ladder's first lesson's keys rather
+ * than its text.
+ */
+function expectedSprintText(limitMs: number): string {
+  return generateDrillText(sprintLesson(referenceLadder(), 0), {
+    seed: DRILL_SEED,
+    words: sprintWordCount(limitMs),
+  });
+}
+
+function sprintPrefix(count: number, limitMs: number): string {
+  return [...expectedSprintText(limitMs)].slice(0, count).join('');
+}
+
 /**
  * Tab forward until the element with this id has focus, returning every stop on
  * the way so a failure says where focus actually went. Out here rather than in a
@@ -113,7 +133,51 @@ test.describe('the trainer journeys', () => {
 
   test.fixme('builds a repair drill from exactly the keys that were missed', () => {});
 
-  test.fixme('runs a sprint to its limit, and offers an untimed option', () => {});
+  test('runs a sprint to its limit, and offers an untimed option', async ({ page }) => {
+    // The page's own clock is faked, so a thirty second sprint costs no wall
+    // time and an untimed one can be pushed an hour ahead between assertions.
+    await page.clock.install();
+    await gotoApp(page);
+    await loadReferenceLayout(page);
+
+    // The limit is adjustable before the sprint starts, and the setting is
+    // stated in visible text rather than only shown as a selected option.
+    await page.locator('#sprint-duration').selectOption('30000');
+    await expect(page.locator('#sprint-setting')).toContainText('Current setting: 30 seconds');
+    await page.getByRole('button', { name: 'Start sprint' }).click();
+
+    // A sprint runs across every unlocked key, so it is not the lesson's text.
+    await expect(page.locator('#drill-text')).toHaveText(expectedSprintText(30_000));
+    await expect(page.locator('#sprint-countdown')).toHaveText('Time left: 0:30');
+
+    await page.keyboard.type(sprintPrefix(12, 30_000), { delay: 20 });
+    await page.clock.fastForward(31_000);
+
+    // It ran to its limit, and the result says it was a sprint rather than a
+    // lesson: different wording, and the kind of drill named outright.
+    await expect(page.locator('#drill-result')).toBeVisible();
+    await expect(page.locator('#drill-result-summary')).toContainText('Sprint over, time up');
+    await expect(page.locator('#drill-result-detail')).toContainText(
+      'sprint across every unlocked key',
+    );
+    await expect(page.locator('#drill-result-detail')).toContainText('the time limit ran out');
+
+    // And the untimed option is genuinely untimed.
+    await page.locator('#sprint-duration').selectOption('0');
+    await expect(page.locator('#sprint-setting')).toContainText('untimed');
+    await page.getByRole('button', { name: 'Start sprint' }).click();
+    await expect(page.locator('#sprint-countdown')).toContainText('no time limit');
+
+    await page.keyboard.type(sprintPrefix(4, 0), { delay: 20 });
+    // An hour later, with no keystroke in between, it has still not expired.
+    await page.clock.fastForward('01:00:00');
+    await expect(page.locator('#drill-result')).toBeHidden();
+    await expect(page.locator('#sprint-countdown')).toContainText('no time limit');
+
+    // And it is still typeable after all that time, rather than quietly dead.
+    await page.keyboard.type(sprintPrefix(8, 0).slice(4), { delay: 20 });
+    await expect(page.locator('#drill-text .drill-char[data-mark="correct"]')).toHaveCount(8);
+  });
 
   test('keeps progress across a reload', async ({ page }) => {
     await gotoApp(page);
diff --git a/tests/e2e/sprint.spec.ts b/tests/e2e/sprint.spec.ts
new file mode 100644
index 0000000..faa311f
--- /dev/null
+++ b/tests/e2e/sprint.spec.ts
@@ -0,0 +1,185 @@
+import { expect, test, type Page } from '@playwright/test';
+import { NO_LIMIT, SPRINT_DURATIONS_MS } from '../../src/drill/limits.js';
+import { sprintLesson, sprintWordCount } from '../../src/drill/sprint.js';
+import { generateDrillText } from '../../src/drill/text.js';
+import {
+  DRILL_SEED,
+  expectedDrillText,
+  expectNoAxeViolations,
+  gotoApp,
+  loadReferenceLayout,
+  referenceLadder,
+} from './helpers.js';
+
+/**
+ * Sprint mode in a real browser.
+ *
+ * Time is faked rather than waited for: `page.clock` freezes the page's own
+ * clock, so a thirty second sprint takes no wall time and an untimed one can be
+ * pushed an hour into the future between two assertions. Nothing here sleeps.
+ *
+ * The drill text is worked out the same way the app works it out, from the
+ * pinned `?seed=` and the ladder the reference layout generates, so a change to
+ * the generator fails these rather than being silently agreed with.
+ */
+
+/** With no saved progress only the first rung is unlocked, so that is the sprint. */
+function expectedSprintText(limitMs: number): string {
+  return generateDrillText(sprintLesson(referenceLadder(), 0), {
+    seed: DRILL_SEED,
+    words: sprintWordCount(limitMs),
+  });
+}
+
+function sprintPrefix(count: number, limitMs: number): string {
+  return [...expectedSprintText(limitMs)].slice(0, count).join('');
+}
+
+/** Choose a duration and start a sprint with it. */
+async function startSprint(page: Page, limitMs: number): Promise<void> {
+  await page.locator('#sprint-duration').selectOption(String(limitMs));
+  await page.getByRole('button', { name: 'Start sprint' }).click();
+}
+
+test('offers every duration the drill layer defines, untimed among them', async ({ page }) => {
+  await gotoApp(page);
+  await loadReferenceLayout(page);
+
+  const options = page.locator('#sprint-duration option');
+  await expect(options).toHaveCount(SPRINT_DURATIONS_MS.length);
+  await expect(options.first()).toContainText('Untimed');
+  // The setting is stated in visible text, not only implied by which option the
+  // control happens to be showing. WCAG 2.2.1.
+  await expect(page.locator('#sprint-setting')).toContainText('Current setting: 1 minute');
+});
+
+test('the limit is adjustable before the sprint starts, and says what it is', async ({ page }) => {
+  await gotoApp(page);
+  await loadReferenceLayout(page);
+
+  await page.locator('#sprint-duration').selectOption('30000');
+  await expect(page.locator('#sprint-setting')).toContainText('Current setting: 30 seconds');
+
+  await page.locator('#sprint-duration').selectOption(String(NO_LIMIT));
+  await expect(page.locator('#sprint-setting')).toContainText('untimed');
+  await expect(page.locator('#sprint-setting')).toContainText('never run out');
+});
+
+test('the duration control is at least 24 by 24 CSS pixels', async ({ page }) => {
+  await gotoApp(page);
+  await loadReferenceLayout(page);
+
+  for (const selector of ['#sprint-duration', '#sprint-start']) {
+    const box = await page.locator(selector).boundingBox();
+    expect(box?.width ?? 0, `${selector} width`).toBeGreaterThanOrEqual(24);
+    expect(box?.height ?? 0, `${selector} height`).toBeGreaterThanOrEqual(24);
+  }
+});
+
+test('runs a sprint across every unlocked key, not one lesson', async ({ page }) => {
+  await gotoApp(page);
+  await loadReferenceLayout(page);
+
+  // The lesson drill is on screen first, and the sprint replaces it with a
+  // different text built from the whole unlocked key set.
+  await expect(page.locator('#drill-text')).toHaveText(expectedDrillText());
+  await startSprint(page, 30_000);
+  await expect(page.locator('#drill-text')).toHaveText(expectedSprintText(30_000));
+  await expect(page.locator('#drill-text')).not.toHaveText(expectedDrillText());
+});
+
+test('shows a countdown while a timed sprint runs', async ({ page }) => {
+  await page.clock.install();
+  await gotoApp(page);
+  await loadReferenceLayout(page);
+
+  await startSprint(page, 60_000);
+  const countdown = page.locator('#sprint-countdown');
+  await expect(countdown).toBeVisible();
+  await expect(countdown).toHaveText('Time left: 1:00');
+  // It is a timer, whose implicit live setting is off: the number changes every
+  // second and must never be announced.
+  await expect(countdown).toHaveAttribute('role', 'timer');
+  await expect(countdown).not.toHaveAttribute('aria-live', /.*/u);
+
+  await page.keyboard.type(sprintPrefix(4, 60_000), { delay: 20 });
+  await page.clock.fastForward(20_000);
+  await expect(countdown).toHaveText('Time left: 0:40');
+});
+
+test('announces time running out politely, and not every second', async ({ page }) => {
+  await page.clock.install();
+  await gotoApp(page);
+  await loadReferenceLayout(page);
+
+  await startSprint(page, 60_000);
+  const warning = page.locator('#sprint-warning');
+  await expect(warning).toHaveAttribute('aria-live', 'polite');
+  await expect(warning).toBeEmpty();
+
+  await page.keyboard.type(sprintPrefix(4, 60_000), { delay: 20 });
+
+  await page.clock.fastForward(30_000);
+  await expect(warning).toContainText('30 seconds left');
+
+  // Twenty more seconds pass and the region has moved on once, to the next
+  // milestone, rather than having been rewritten twenty times.
+  await page.clock.fastForward(20_000);
+  await expect(warning).toContainText('10 seconds left');
+});
+
+test('a sprint earns no stars and says so, whatever the pace', async ({ page }) => {
+  await page.clock.install();
+  await gotoApp(page);
+  await loadReferenceLayout(page);
+
+  await startSprint(page, 30_000);
+  await page.keyboard.type(sprintPrefix(20, 30_000), { delay: 15 });
+  await page.clock.fastForward(31_000);
+
+  await expect(page.locator('#drill-result-detail')).toContainText('none, this was not a lesson');
+  await expect(page.locator('#ladder-list .ladder-rung').first()).toContainText('no stars yet');
+});
+
+test('abandoning a sprint for a lesson leaves no timer running', async ({ page }) => {
+  await page.clock.install();
+  await gotoApp(page);
+  await loadReferenceLayout(page);
+
+  const ladder = referenceLadder();
+  const first = ladder[0];
+  expect(first, 'the reference ladder should have a first lesson').toBeDefined();
+
+  await startSprint(page, 30_000);
+  await page.keyboard.type(sprintPrefix(3, 30_000), { delay: 20 });
+
+  // Abandoned: back to the lesson, which is untimed.
+  await page.getByRole('button', { name: `Practise ${first!.name}` }).click();
+  await expect(page.locator('#drill-text')).toHaveText(expectedDrillText());
+  await expect(page.locator('#sprint-countdown')).toBeHidden();
+
+  await page.getByRole('button', { name: 'Start drill' }).click();
+  // Long past the abandoned sprint's limit. The old timer must not be able to
+  // reach this drill. Regression 3.
+  await page.clock.fastForward(300_000);
+  await expect(page.locator('#drill-result')).toBeHidden();
+
+  // And the lesson runs all the way through, which is what used to be
+  // impossible: every drill after an abandoned sprint died on its first key.
+  await page.keyboard.type(expectedDrillText(), { delay: 20 });
+  await expect(page.locator('#drill-result-summary')).toContainText('Drill complete');
+});
+
+test('is axe clean with a sprint on screen, and with its result', async ({ page }) => {
+  await page.clock.install();
+  await gotoApp(page);
+  await loadReferenceLayout(page);
+
+  await startSprint(page, 30_000);
+  await expectNoAxeViolations(page, 'a running sprint');
+
+  await page.keyboard.type(sprintPrefix(8, 30_000), { delay: 20 });
+  await page.clock.fastForward(31_000);
+  await expect(page.locator('#drill-result')).toBeVisible();
+  await expectNoAxeViolations(page, 'a finished sprint');
+});
diff --git a/tests/functional/sprint-view.test.ts b/tests/functional/sprint-view.test.ts
new file mode 100644
index 0000000..33aacce
--- /dev/null
+++ b/tests/functional/sprint-view.test.ts
@@ -0,0 +1,495 @@
+/**
+ * Sprint mode on the real markup, and the duration control beside it.
+ *
+ * The body of `index.html` is what these mount, so a rename fails here rather
+ * than in a browser. Nothing waits for a real second: the drill surface takes
+ * its schedule as an option, so a test holds the ticks and fires them by hand
+ * against a clock it drives itself.
+ *
+ * What lives here rather than in `tests/unit/sprint.test.ts`: everything that
+ * needs a DOM. The countdown text, the polite region beside it, the result card
+ * naming what kind of drill it was, and the guarantee that a sprint abandoned
+ * for a lesson leaves nothing behind that can touch that lesson.
+ */
+
+import { readFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { afterEach, beforeEach, describe, expect, it } from 'vitest';
+import { GLOVE80 } from '../../src/board/index.js';
+import { createDrillSession, type DrillSession } from '../../src/drill/index.js';
+import { NO_LIMIT, SPRINT_DURATIONS_MS } from '../../src/drill/limits.js';
+import { parseMoErgoLayoutText } from '../../src/keymap/moergo.js';
+import { emptyProgress } from '../../src/stats/storage.js';
+import { createDrillView, type DrillView } from '../../src/ui/drill-view.js';
+import {
+  createSprintControls,
+  DEFAULT_SPRINT_LIMIT_MS,
+  type SprintControls,
+} from '../../src/ui/sprint-controls.js';
+import { readReferenceLayout } from '../fixtures/index.js';
+
+const keymap = parseMoErgoLayoutText(readReferenceLayout(), { board: GLOVE80 });
+
+const PAGE_BODY = (() => {
+  const html = readFileSync(join(process.cwd(), 'index.html'), 'utf8');
+  const body = /<body>([\s\S]*)<\/body>/.exec(html);
+  if (body?.[1] === undefined) {
+    throw new Error('index.html has no <body> for the functional tests to mount');
+  }
+  return body[1].replace(/<script[\s\S]*?<\/script>/g, '');
+})();
+
+/** Every character of it is on the reference layout's very first lesson. */
+const SPRINT_TEXT = 'a task and a flask';
+
+function testClock(start = 10_000) {
+  let value = start;
+  return {
+    now: (): number => value,
+    advance(ms: number): void {
+      value += ms;
+    },
+  };
+}
+
+/** The ticks the view has scheduled, fired by hand. */
+function manualSchedule() {
+  const ticks = new Set<() => void>();
+  const schedule = (tick: () => void): (() => void) => {
+    ticks.add(tick);
+    return (): void => {
+      ticks.delete(tick);
+    };
+  };
+  return {
+    schedule,
+    fire(): void {
+      for (const tick of [...ticks]) tick();
+    },
+    /**
+     * The ticks as they stand now, kept past their cancel.
+     *
+     * This is how a missed `clearInterval` is reproduced: the app stops the
+     * timer properly, and the test fires the callback anyway, to prove that the
+     * binding rather than the teardown is what keeps the next drill safe.
+     */
+    snapshot(): readonly (() => void)[] {
+      return [...ticks];
+    },
+    get live(): number {
+      return ticks.size;
+    },
+  };
+}
+
+function find(selector: string): HTMLElement {
+  const element = document.querySelector<HTMLElement>(selector);
+  if (element === null) throw new Error(`index.html is missing ${selector}`);
+  return element;
+}
+
+function text(selector: string): string {
+  return find(selector).textContent;
+}
+
+function type(key: string, clock: { advance(ms: number): void }, gapMs = 90): void {
+  clock.advance(gapMs);
+  document.dispatchEvent(new KeyboardEvent('keydown', { key, bubbles: true, cancelable: true }));
+}
+
+interface Mounted {
+  readonly clock: ReturnType<typeof testClock>;
+  readonly schedule: ReturnType<typeof manualSchedule>;
+  readonly session: DrillSession;
+  sprint(limitMs?: number): DrillView;
+  lesson(): DrillView;
+  readonly views: DrillView[];
+}
+
+function mount(): Mounted {
+  document.body.innerHTML = PAGE_BODY;
+  find('#drill-section').hidden = false;
+  find('#sprint-section').hidden = false;
+
+  const clock = testClock();
+  const schedule = manualSchedule();
+  const session = createDrillSession({ now: clock.now, progress: emptyProgress() });
+  const views: DrillView[] = [];
+
+  return {
+    clock,
+    schedule,
+    session,
+    views,
+    sprint(limitMs = 30_000): DrillView {
+      const view = createDrillView({
+        board: GLOVE80,
+        keymap,
+        text: SPRINT_TEXT,
+        limitMs,
+        mode: 'sprint',
+        lessonId: null,
+        lessonName: null,
+        session,
+        schedule: schedule.schedule,
+      });
+      views.push(view);
+      return view;
+    },
+    lesson(): DrillView {
+      const view = createDrillView({
+        board: GLOVE80,
+        keymap,
+        text: SPRINT_TEXT,
+        limitMs: NO_LIMIT,
+        mode: 'lesson',
+        lessonId: 'home',
+        lessonName: 'Home row',
+        session,
+        schedule: schedule.schedule,
+      });
+      views.push(view);
+      return view;
+    },
+  };
+}
+
+describe('a sprint on the drill surface', () => {
+  let mounted: Mounted;
+
+  beforeEach(() => {
+    mounted = mount();
+  });
+
+  afterEach(() => {
+    for (const view of mounted.views) view.destroy();
+    document.body.replaceChildren();
+  });
+
+  it('shows a countdown as soon as a timed sprint starts', () => {
+    const view = mounted.sprint(30_000);
+    view.start();
+
+    expect(find('#sprint-countdown').hidden).toBe(false);
+    expect(text('#sprint-countdown')).toBe('Time left: 0:30');
+  });
+
+  it('counts down on its own, without a keystroke', () => {
+    const view = mounted.sprint(30_000);
+    view.start();
+    type('a', mounted.clock);
+
+    mounted.clock.advance(9_000);
+    mounted.schedule.fire();
+    expect(text('#sprint-countdown')).toBe('Time left: 0:21');
+
+    mounted.clock.advance(10_000);
+    mounted.schedule.fire();
+    expect(text('#sprint-countdown')).toBe('Time left: 0:11');
+  });
+
+  it('never announces the countdown itself, which would speak every second', () => {
+    const view = mounted.sprint(30_000);
+    view.start();
+
+    // role="timer" has an implicit aria-live of "off". The number changes every
+    // second and must never be read out.
+    expect(find('#sprint-countdown').getAttribute('role')).toBe('timer');
+    expect(find('#sprint-countdown').getAttribute('aria-live')).toBeNull();
+  });
+
+  it('announces time running out politely, at milestones rather than every second', () => {
+    const view = mounted.sprint(120_000);
+    view.start();
+    type('a', mounted.clock);
+
+    const warning = find('#sprint-warning');
+    expect(warning.getAttribute('aria-live')).toBe('polite');
+    expect(warning.textContent).toBe('');
+
+    const spoken: string[] = [];
+    for (let elapsed = 0; elapsed < 120; elapsed += 1) {
+      mounted.clock.advance(1_000);
+      mounted.schedule.fire();
+      const said = warning.textContent;
+      if (said !== '' && spoken.at(-1) !== said) spoken.push(said);
+    }
+
+    // Three milestones over two minutes, not a hundred and twenty.
+    expect(spoken).toHaveLength(3);
+    expect(spoken[0]).toContain('1 minute left');
+    expect(spoken[1]).toContain('30 seconds left');
+    expect(spoken[2]).toContain('10 seconds left');
+  });
+
+  it('ends the sprint when its limit runs out, with nobody typing', () => {
+    const view = mounted.sprint(30_000);
+    view.start();
+    type('a', mounted.clock);
+
+    mounted.clock.advance(30_000);
+    mounted.schedule.fire();
+
+    expect(find('#drill-result').hidden).toBe(false);
+    expect(text('#drill-result-summary')).toContain('Sprint over, time up');
+    expect(text('#drill-result-detail')).toContain('the time limit ran out');
+    expect(text('#sprint-countdown')).toBe('Time left: 0:00');
+    // And nothing is left ticking once the result is on screen.
+    expect(mounted.schedule.live).toBe(0);
+  });
+
+  it('tells a sprint apart from a lesson on the result card', () => {
+    const view = mounted.sprint(30_000);
+    view.start();
+    for (const character of SPRINT_TEXT) type(character, mounted.clock);
+
+    expect(find('#drill-result').hidden).toBe(false);
+    expect(text('#drill-result-detail')).toContain('sprint across every unlocked key');
+    expect(text('#drill-result-detail')).toContain('30 seconds');
+    expect(text('#drill-result-detail')).toContain('none, this was not a lesson');
+    expect(text('#drill-result-summary')).toContain('Sprint complete');
+    expect(text('#drill-result-summary')).not.toContain('Drill complete');
+  });
+
+  it('says lesson on a lesson, so the two never read the same', () => {
+    const view = mounted.lesson();
+    view.start();
+    for (const character of SPRINT_TEXT) type(character, mounted.clock);
+
+    expect(text('#drill-result-detail')).toContain('lesson: Home row');
+    expect(text('#drill-result-detail')).not.toContain('sprint');
+    expect(text('#drill-result-summary')).toContain('Drill complete');
+  });
+
+  it('earns no stars, whatever the pace', () => {
+    const view = mounted.sprint(60_000);
+    view.start();
+    for (const character of SPRINT_TEXT) type(character, mounted.clock, 40);
+
+    expect(mounted.session.progress.stars).toEqual({});
+    expect(mounted.session.progress.xp).toBeGreaterThan(0);
+  });
+});
+
+describe('an untimed sprint', () => {
+  let mounted: Mounted;
+
+  beforeEach(() => {
+    mounted = mount();
+  });
+
+  afterEach(() => {
+    for (const view of mounted.views) view.destroy();
+    document.body.replaceChildren();
+  });
+
+  it('says so in words rather than showing a clock that never moves', () => {
+    const view = mounted.sprint(NO_LIMIT);
+    view.start();
+
+    expect(find('#sprint-countdown').hidden).toBe(false);
+    expect(text('#sprint-countdown')).toContain('no time limit');
+    expect(text('#sprint-countdown')).not.toMatch(/\d:\d\d/u);
+  });
+
+  it('genuinely never expires, at any elapsed time at all', () => {
+    const view = mounted.sprint(NO_LIMIT);
+    view.start();
+    type('a', mounted.clock);
+
+    // A minute, a day, a year, then a century. None of it ends the sprint.
+    for (const jump of [60_000, 86_400_000, 31_557_600_000, 3_155_760_000_000]) {
+      mounted.clock.advance(jump);
+      mounted.schedule.fire();
+      expect(find('#drill-result').hidden).toBe(true);
+      expect(text('#sprint-countdown')).toContain('no time limit');
+    }
+
+    // And it is still typeable after all that: the next keystroke lands.
+    type(' ', mounted.clock);
+    expect(document.querySelectorAll('#drill-text .drill-char[data-mark="correct"]')).toHaveLength(
+      2,
+    );
+    expect(find('#drill-result').hidden).toBe(true);
+  });
+
+  it('never announces a milestone, because there is no milestone to reach', () => {
+    const view = mounted.sprint(NO_LIMIT);
+    view.start();
+    type('a', mounted.clock);
+
+    for (let tick = 0; tick < 200; tick += 1) {
+      mounted.clock.advance(1_000);
+      mounted.schedule.fire();
+    }
+
+    expect(text('#sprint-warning')).toBe('');
+  });
+});
+
+describe('abandoning a sprint', () => {
+  let mounted: Mounted;
+
+  beforeEach(() => {
+    mounted = mount();
+  });
+
+  afterEach(() => {
+    for (const view of mounted.views) view.destroy();
+    document.body.replaceChildren();
+  });
+
+  it('leaves no timer running when the sprint view is destroyed', () => {
+    const view = mounted.sprint(30_000);
+    view.start();
+    expect(mounted.schedule.live).toBe(1);
+
+    view.destroy();
+    expect(mounted.schedule.live).toBe(0);
+  });
+
+  it('leaves no timer running when another drill is started on the same view', () => {
+    const view = mounted.sprint(30_000);
+    view.start();
+    type('a', mounted.clock);
+    view.start();
+
+    // One timer, for the drill now on screen. Not two.
+    expect(mounted.schedule.live).toBe(1);
+  });
+
+  it('lets a lesson run normally after a sprint was started and abandoned', () => {
+    const sprint = mounted.sprint(30_000);
+    sprint.start();
+    type('a', mounted.clock);
+
+    // The tick is kept hold of before the sprint goes away, so that it can be
+    // fired afterwards: this is a `clearInterval` that never happened, which is
+    // the exact shape of the original failure.
+    const stray = mounted.schedule.snapshot();
+    expect(stray).toHaveLength(1);
+
+    // Abandoned mid-sprint, the way a learner does: they go back to a lesson.
+    sprint.destroy();
+    const lesson = mounted.lesson();
+    lesson.start();
+
+    // Far past the abandoned sprint's limit, and the stray tick fires anyway.
+    // It is bound to the sprint, so it can do nothing to the lesson.
+    mounted.clock.advance(120_000);
+    for (const tick of stray) tick();
+
+    for (const character of SPRINT_TEXT) type(character, mounted.clock);
+
+    expect(text('#drill-result-summary')).toContain('Drill complete');
+    expect(document.querySelectorAll('#drill-text .drill-char[data-mark="correct"]')).toHaveLength(
+      [...SPRINT_TEXT].length,
+    );
+    expect(text('#drill-result-detail')).toContain('you typed it through');
+  });
+
+  it('hides the countdown on a lesson, which has no time to count', () => {
+    const sprint = mounted.sprint(30_000);
+    sprint.start();
+    expect(find('#sprint-countdown').hidden).toBe(false);
+
+    sprint.destroy();
+    const lesson = mounted.lesson();
+    lesson.start();
+
+    expect(find('#sprint-countdown').hidden).toBe(true);
+    expect(text('#sprint-warning')).toBe('');
+  });
+});
+
+describe('the duration control', () => {
+  let controls: SprintControls | null = null;
+
+  beforeEach(() => {
+    document.body.innerHTML = PAGE_BODY;
+    find('#sprint-section').hidden = false;
+  });
+
+  afterEach(() => {
+    controls?.destroy();
+    controls = null;
+    document.body.replaceChildren();
+  });
+
+  function select(): HTMLSelectElement {
+    const element = document.querySelector<HTMLSelectElement>('#sprint-duration');
+    if (element === null) throw new Error('index.html is missing #sprint-duration');
+    return element;
+  }
+
+  it('offers every duration the drill layer defines, untimed included', () => {
+    controls = createSprintControls({ onStart: () => undefined });
+
+    const values = [...select().options].map((option) => Number(option.value));
+    expect(values).toEqual([...SPRINT_DURATIONS_MS]);
+    expect(values).toContain(NO_LIMIT);
+  });
+
+  it('names the untimed option as a choice rather than as a blank', () => {
+    controls = createSprintControls({ onStart: () => undefined });
+
+    const untimed = [...select().options].find((option) => Number(option.value) === NO_LIMIT);
+    expect(untimed?.textContent.toLowerCase()).toContain('untimed');
+    expect(untimed?.textContent).not.toBe('');
+  });
+
+  it('states the current setting in visible text, not only as a selected option', () => {
+    controls = createSprintControls({ onStart: () => undefined });
+
+    expect(text('#sprint-setting')).toContain('Current setting: 1 minute');
+    expect(controls.limitMs).toBe(DEFAULT_SPRINT_LIMIT_MS);
+  });
+
+  it('is adjustable before a sprint starts, and says so as it changes', () => {
+    const started: number[] = [];
+    const changed: number[] = [];
+    controls = createSprintControls({
+      onStart: (limitMs) => started.push(limitMs),
+      onLimitChange: (limitMs) => changed.push(limitMs),
+    });
+
+    select().value = String(NO_LIMIT);
+    select().dispatchEvent(new Event('change', { bubbles: true }));
+
+    expect(changed).toEqual([NO_LIMIT]);
+    expect(text('#sprint-setting')).toContain('untimed');
+    expect(text('#sprint-setting')).toContain('never run out');
+
+    find('#sprint-start').click();
+    expect(started).toEqual([NO_LIMIT]);
+  });
+
+  it('starts a sprint with exactly the duration on screen', () => {
+    const started: number[] = [];
+    controls = createSprintControls({ onStart: (limitMs) => started.push(limitMs) });
+
+    select().value = '300000';
+    select().dispatchEvent(new Event('change', { bubbles: true }));
+    find('#sprint-start').click();
+
+    expect(started).toEqual([300_000]);
+    expect(text('#sprint-setting')).toContain('5 minutes');
+  });
+
+  it('refuses a value the control never offered rather than guessing one', () => {
+    controls = createSprintControls({ onStart: () => undefined });
+
+    // A tampered or drifted control. Prefer throwing to sprinting for a
+    // duration nobody chose.
+    select().innerHTML = '<option value="45000" selected>45 seconds</option>';
+    expect(() => controls?.limitMs).toThrow();
+  });
+
+  it('is a real control at least 24 by 24 CSS pixels, per WCAG 2.5.8', () => {
+    controls = createSprintControls({ onStart: () => undefined });
+    // jsdom has no layout, so the stylesheet's own rule is what is asserted
+    // here; the measured size lives in tests/e2e/sprint.spec.ts.
+    const css = readFileSync(join(process.cwd(), 'src', 'ui', 'theme.css'), 'utf8');
+    expect(css).toMatch(/select\s*\{[^}]*min-height:\s*2\.25rem/u);
+  });
+});
diff --git a/tests/regression/prototype-failures.test.ts b/tests/regression/prototype-failures.test.ts
index f367aa4..1849f33 100644
--- a/tests/regression/prototype-failures.test.ts
+++ b/tests/regression/prototype-failures.test.ts
@@ -20,6 +20,8 @@ import {
   KeystrokeHandlerError,
 } from '../../src/drill/engine.js';
 import { hasReachedLimit, NO_LIMIT } from '../../src/drill/limits.js';
+import { startSprintTimer } from '../../src/drill/sprint.js';
+import type { Drill } from '../../src/drill/types.js';
 import {
   emptyProgress,
   keyStatId,
@@ -333,9 +335,137 @@ describe('regression 3: timers must not outlive their drill', () => {
     expect(hasReachedLimit(Number.MAX_SAFE_INTEGER, NO_LIMIT)).toBe(false);
   });
 
-  it.todo('clears a sprint timer when the sprint is abandoned');
-  it.todo('lets a lesson run normally after a sprint was started and abandoned');
-  it.todo('never lets a timer act on a drill other than the one it was started for');
+  /**
+   * A schedule a test fires by hand, standing in for `setInterval`.
+   *
+   * `live` is the whole point: a timer that has stopped must leave nothing
+   * behind that anything can fire again, and a cancel that never arrived is
+   * exactly what the prototype shipped.
+   */
+  function manualSchedule() {
+    const ticks = new Set<() => void>();
+    // An arrow rather than a method, so it can be handed straight to the timer.
+    const schedule = (tick: () => void): (() => void) => {
+      ticks.add(tick);
+      return (): void => {
+        ticks.delete(tick);
+      };
+    };
+    return {
+      schedule,
+      fire(): void {
+        for (const tick of [...ticks]) tick();
+      },
+      get live(): number {
+        return ticks.size;
+      },
+    };
+  }
+
+  it('clears a sprint timer when the sprint is abandoned', () => {
+    const clock = testClock();
+    const schedule = manualSchedule();
+    const sprint = createDrill({ text: 'ask a task', limitMs: 30_000, now: clock.now });
+    sprint.press('a');
+
+    let current: Drill | null = sprint;
+    const timer = startSprintTimer({
+      drill: sprint,
+      currentDrill: () => current,
+      schedule: schedule.schedule,
+    });
+
+    expect(schedule.live).toBe(1);
+
+    // Abandoned: the learner walked away and something else became current.
+    current = null;
+    clock.advance(60_000);
+    schedule.fire();
+
+    expect(timer.stopped).toBe(true);
+    expect(timer.stopReason).toBe('abandoned');
+    // Nothing is left that could be fired again, so there is no second chance
+    // for it to act on anything.
+    expect(schedule.live).toBe(0);
+  });
+
+  it('lets a lesson run normally after a sprint was started and abandoned', () => {
+    const clock = testClock();
+    const schedule = manualSchedule();
+
+    const sprint = createDrill({ text: 'ask a task', limitMs: 30_000, now: clock.now });
+    sprint.press('a');
+    let current: Drill = sprint;
+    startSprintTimer({
+      drill: sprint,
+      currentDrill: () => current,
+      schedule: schedule.schedule,
+    });
+
+    // The sprint is abandoned for an untimed lesson, which is the drill that
+    // used to die on its very first keystroke.
+    const lesson = createDrill({ text: 'ask a task', limitMs: NO_LIMIT, now: clock.now });
+    current = lesson;
+
+    // Time enough to have expired the sprint several times over.
+    clock.advance(120_000);
+    schedule.fire();
+
+    const first = lesson.press('a');
+    expect(first.kind).toBe('correct');
+    expect(lesson.isFinished).toBe(false);
+
+    // And it keeps going, all the way through, with the clock far past any
+    // limit the abandoned sprint ever had.
+    for (const character of [...'sk a task'.slice(0)]) {
+      clock.advance(10_000);
+      schedule.fire();
+      lesson.press(character);
+    }
+
+    expect(lesson.isFinished).toBe(true);
+    expect(lesson.result?.completed).toBe(true);
+    expect(lesson.result?.totalKeystrokes).toBe(10);
+  });
+
+  it('never lets a timer act on a drill other than the one it was started for', () => {
+    const clock = testClock();
+    const schedule = manualSchedule();
+
+    const sprint = createDrill({ text: 'ask a task', limitMs: 30_000, now: clock.now });
+    sprint.press('a');
+    const other = createDrill({ text: 'ask a task', limitMs: 30_000, now: clock.now });
+    other.press('a');
+
+    let current: Drill = sprint;
+    const acted: string[] = [];
+    const timer = startSprintTimer({
+      drill: sprint,
+      currentDrill: () => current,
+      schedule: schedule.schedule,
+      onTick: (_remaining, drill) => acted.push(drill === sprint ? 'sprint' : 'other'),
+      onExpire: (_result, drill) => acted.push(drill === sprint ? 'sprint-end' : 'other-end'),
+    });
+
+    clock.advance(1_000);
+    schedule.fire();
+    expect(acted).toEqual(['sprint']);
+
+    // The current drill is swapped for another one that is itself timed, and
+    // has been running long enough to be over its own limit. If the timer read
+    // "whichever drill is current" it would end this one; it must not.
+    current = other;
+    clock.advance(60_000);
+    schedule.fire();
+    schedule.fire();
+
+    expect(timer.stopReason).toBe('abandoned');
+    expect(acted).toEqual(['sprint']);
+    expect(other.isFinished).toBe(false);
+    expect(other.result).toBeNull();
+    // The timer still names the one drill it was ever allowed to touch.
+    expect(timer.drill).toBe(sprint);
+  });
 });
 
 describe('regression 4: a finished drill must never swallow input', () => {
diff --git a/tests/unit/sprint.test.ts b/tests/unit/sprint.test.ts
new file mode 100644
index 0000000..8281b0b
--- /dev/null
+++ b/tests/unit/sprint.test.ts
@@ -0,0 +1,443 @@
+/**
+ * Sprint mode's pure half: what a sprint is made of, how long it asks for, how
+ * it words itself, and the timer that must never outlive its drill.
+ *
+ * The timer is unit-testable at all because it takes its schedule as an
+ * argument. Nothing here waits for a real second: the schedule is a list of
+ * callbacks a test fires by hand, which is the same discipline the engine
+ * follows with its clock.
+ */
+
+import { describe, expect, it } from 'vitest';
+import { createDrill } from '../../src/drill/engine.js';
+import { NO_LIMIT, SPRINT_DURATIONS_MS } from '../../src/drill/limits.js';
+import {
+  createSprintWarnings,
+  describeCountdown,
+  describeDurationChoice,
+  parseSprintLimit,
+  secondsLeft,
+  SPRINT_LESSON_ID,
+  SPRINT_MAX_WORDS,
+  SPRINT_MIN_WORDS,
+  SPRINT_UNTIMED_WORDS,
+  SprintError,
+  SprintTimerError,
+  sprintLesson,
+  sprintWordCount,
+  startSprintTimer,
+} from '../../src/drill/sprint.js';
+import type { Lesson } from '../../src/ladder/generate.js';
+
+function lesson(id: string, keys: readonly string[], stage: Lesson['stage'] = 'keys'): Lesson {
+  return { id, name: id, blurb: id, addedKeys: [], keys, stage };
+}
+
+/** Three cumulative rungs, the way a generated ladder produces them. */
+const LADDER: readonly Lesson[] = [
+  lesson('one', ['a', 'n', ' ']),
+  lesson('two', ['a', 'n', ' ', 'i', 's']),
+  lesson('three', ['a', 'n', ' ', 'i', 's', 't', 'h'], 'prose'),
+];
+
+function testClock(start = 1_000) {
+  let value = start;
+  return {
+    now: (): number => value,
+    advance(ms: number): void {
+      value += ms;
+    },
+  };
+}
+
+/**
+ * A schedule a test fires by hand, and a count of how many cancels it has been
+ * handed. `live` is the thing regression 3 is really about: a timer that has
+ * stopped must leave nothing behind that can be fired again.
+ */
+function manualSchedule() {
+  const ticks = new Set<() => void>();
+  let cancelled = 0;
+  // An arrow rather than a method, so it can be handed straight to the timer.
+  const schedule = (tick: () => void): (() => void) => {
+    ticks.add(tick);
+    return (): void => {
+      cancelled += 1;
+      ticks.delete(tick);
+    };
+  };
+  return {
+    schedule,
+    fire(): void {
+      for (const tick of [...ticks]) tick();
+    },
+    get live(): number {
+      return ticks.size;
+    },
+    get cancelled(): number {
+      return cancelled;
+    },
+  };
+}
+
+describe('sprintLesson', () => {
+  it('runs against every key unlocked so far, not one lesson', () => {
+    const sprint = sprintLesson(LADDER, 2);
+    expect(sprint.keys).toEqual(['a', 'n', ' ', 'i', 's', 't', 'h']);
+    expect(sprint.id).toBe(SPRINT_LESSON_ID);
+  });
+
+  it('stops at the lesson actually unlocked, so it never asks for a key not yet taught', () => {
+    expect(sprintLesson(LADDER, 0).keys).toEqual(['a', 'n', ' ']);
+    expect(sprintLesson(LADDER, 1).keys).toEqual(['a', 'n', ' ', 'i', 's']);
+  });
+
+  it('takes the reached lesson stage, so prose only appears once the ladder has it', () => {
+    expect(sprintLesson(LADDER, 1).stage).toBe('keys');
+    expect(sprintLesson(LADDER, 2).stage).toBe('prose');
+  });
+
+  it('clamps an index from a longer ladder rather than refusing to sprint', () => {
+    expect(sprintLesson(LADDER, 99).keys).toEqual(sprintLesson(LADDER, 2).keys);
+  });
+
+  it('carries no ladder id, so a sprint can never write stars to a rung', () => {
+    expect(LADDER.map((rung) => rung.id)).not.toContain(SPRINT_LESSON_ID);
+  });
+
+  it('refuses a ladder with no lessons rather than inventing one', () => {
+    expect(() => sprintLesson([], 0)).toThrow(SprintError);
+  });
+
+  it('refuses an index that is not a whole number', () => {
+    expect(() => sprintLesson(LADDER, -1)).toThrow(SprintError);
+    expect(() => sprintLesson(LADDER, 1.5)).toThrow(SprintError);
+  });
+
+  it('refuses lessons that contain no keys at all', () => {
+    expect(() => sprintLesson([lesson('empty', [])], 0)).toThrow(SprintError);
+  });
+});
+
+describe('sprintWordCount', () => {
+  it('gives an untimed sprint a finishable length', () => {
+    expect(sprintWordCount(NO_LIMIT)).toBe(SPRINT_UNTIMED_WORDS);
+  });
+
+  it('scales with the limit, so the words outlast the clock', () => {
+    expect(sprintWordCount(60_000)).toBeGreaterThan(sprintWordCount(30_000));
+    expect(sprintWordCount(300_000)).toBeGreaterThanOrEqual(sprintWordCount(120_000));
+  });
+
+  it('stays between its floor and its ceiling for every duration on offer', () => {
+    for (const limitMs of SPRINT_DURATIONS_MS) {
+      const words = sprintWordCount(limitMs);
+      expect(words, `${limitMs} ms`).toBeGreaterThanOrEqual(
+        Math.min(SPRINT_MIN_WORDS, SPRINT_UNTIMED_WORDS),
+      );
+      expect(words, `${limitMs} ms`).toBeLessThanOrEqual(SPRINT_MAX_WORDS);
+    }
+  });
+});
+
+describe('the duration control vocabulary', () => {
+  it('names untimed as a choice rather than as a missing value', () => {
+    expect(describeDurationChoice(NO_LIMIT).toLowerCase()).toContain('untimed');
+    expect(describeDurationChoice(NO_LIMIT).toLowerCase()).toContain('never');
+  });
+
+  it('names every other duration in plain words', () => {
+    expect(describeDurationChoice(30_000)).toBe('30 seconds');
+    expect(describeDurationChoice(60_000)).toBe('1 minute');
+    expect(describeDurationChoice(300_000)).toBe('5 minutes');
+  });
+
+  it('accepts only a duration that was actually offered', () => {
+    for (const limitMs of SPRINT_DURATIONS_MS) {
+      expect(parseSprintLimit(String(limitMs), SPRINT_DURATIONS_MS)).toBe(limitMs);
+    }
+  });
+
+  it('throws rather than defaulting when a value did not come from the list', () => {
+    expect(() => parseSprintLimit('45000', SPRINT_DURATIONS_MS)).toThrow(SprintError);
+    expect(() => parseSprintLimit('', SPRINT_DURATIONS_MS)).toThrow(SprintError);
+    expect(() => parseSprintLimit('a minute', SPRINT_DURATIONS_MS)).toThrow(SprintError);
+  });
+});
+
+describe('the countdown readout', () => {
+  it('says untimed in words rather than showing a frozen zero', () => {
+    expect(describeCountdown(null)).toContain('no time limit');
+    expect(describeCountdown(null)).not.toMatch(/\d:\d\d/u);
+  });
+
+  it('rounds up, so it only reads zero when the time really is gone', () => {
+    expect(secondsLeft(1)).toBe(1);
+    expect(secondsLeft(999)).toBe(1);
+    expect(secondsLeft(0)).toBe(0);
+    expect(describeCountdown(1)).toBe('Time left: 0:01');
+    expect(describeCountdown(0)).toBe('Time left: 0:00');
+  });
+
+  it('reads as minutes and seconds', () => {
+    expect(describeCountdown(30_000)).toBe('Time left: 0:30');
+    expect(describeCountdown(60_000)).toBe('Time left: 1:00');
+    expect(describeCountdown(125_000)).toBe('Time left: 2:05');
+  });
+
+  it('refuses a negative remaining time rather than showing a negative clock', () => {
+    expect(() => secondsLeft(-1)).toThrow(RangeError);
+  });
+});
+
+describe('the polite warnings beside the countdown', () => {
+  it('never announces an untimed sprint, however long it runs', () => {
+    const warnings = createSprintWarnings(NO_LIMIT);
+    expect(warnings.armed).toEqual([]);
+    expect(warnings.due(null)).toBeNull();
+  });
+
+  it('announces each milestone once and only once', () => {
+    const warnings = createSprintWarnings(120_000);
+    expect(warnings.due(90_000)).toBeNull();
+    expect(warnings.due(60_000)).toContain('1 minute');
+    expect(warnings.due(59_000)).toBeNull();
+    expect(warnings.due(45_000)).toBeNull();
+    expect(warnings.due(30_000)).toContain('30 seconds');
+    expect(warnings.due(30_000)).toBeNull();
+    expect(warnings.due(9_000)).toContain('10 seconds');
+    expect(warnings.due(1_000)).toBeNull();
+  });
+
+  it('never announces every second: one sprint produces a handful at most', () => {
+    const warnings = createSprintWarnings(120_000);
+    const spoken: string[] = [];
+    for (let remaining = 120_000; remaining >= 0; remaining -= 1000) {
+      const said = warnings.due(remaining);
+      if (said !== null) spoken.push(said);
+    }
+    expect(spoken).toHaveLength(warnings.armed.length);
+    expect(spoken.length).toBeLessThanOrEqual(3);
+  });
+
+  it('drops a threshold at or above the whole limit, which would be noise', () => {
+    expect(createSprintWarnings(30_000).armed).toEqual([10_000]);
+    expect(createSprintWarnings(60_000).armed).toEqual([30_000, 10_000]);
+  });
+
+  it('fires only the tightest milestone when a tick skips past several', () => {
+    const warnings = createSprintWarnings(300_000);
+    expect(warnings.due(5_000)).toContain('10 seconds');
+    expect(warnings.due(4_000)).toBeNull();
+  });
+});
+
+describe('startSprintTimer', () => {
+  it('counts down the drill it was given, tick by tick', () => {
+    const clock = testClock();
+    const drill = createDrill({ text: 'ask a task', limitMs: 30_000, now: clock.now });
+    drill.press('a');
+    const schedule = manualSchedule();
+    const seen: (number | null)[] = [];
+
+    startSprintTimer({
+      drill,
+      currentDrill: () => drill,
+      schedule: schedule.schedule,
+      onTick: (remaining) => seen.push(remaining),
+    });
+
+    clock.advance(10_000);
+    schedule.fire();
+    clock.advance(5_000);
+    schedule.fire();
+
+    expect(seen).toEqual([20_000, 15_000]);
+  });
+
+  it('ends the drill when its own limit runs out, once', () => {
+    const clock = testClock();
+    const drill = createDrill({ text: 'ask a task', limitMs: 30_000, now: clock.now });
+    drill.press('a');
+    const schedule = manualSchedule();
+    const expired: number[] = [];
+
+    const timer = startSprintTimer({
+      drill,
+      currentDrill: () => drill,
+      schedule: schedule.schedule,
+      onExpire: (result) => expired.push(result.elapsedMs),
+    });
+
+    clock.advance(30_000);
+    schedule.fire();
+    schedule.fire();
+
+    expect(expired).toEqual([30_000]);
+    expect(timer.stopped).toBe(true);
+    expect(timer.stopReason).toBe('expired');
+    expect(schedule.live).toBe(0);
+  });
+
+  it('stops itself when its drill finishes by being typed through', () => {
+    const clock = testClock();
+    const drill = createDrill({ text: 'ab', limitMs: 30_000, now: clock.now });
+    const schedule = manualSchedule();
+    const timer = startSprintTimer({
+      drill,
+      currentDrill: () => drill,
+      schedule: schedule.schedule,
+    });
+
+    drill.press('a');
+    clock.advance(500);
+    drill.press('b');
+    schedule.fire();
+
+    expect(timer.stopReason).toBe('finished');
+    expect(schedule.live).toBe(0);
+  });
+
+  it('is bound to its drill, so it will not act on whichever drill is current', () => {
+    const clock = testClock();
+    const sprint = createDrill({ text: 'ask a task', limitMs: 30_000, now: clock.now });
+    sprint.press('a');
+    const lessonDrill = createDrill({ text: 'ask a task', limitMs: NO_LIMIT, now: clock.now });
+
+    const schedule = manualSchedule();
+    let current = sprint;
+    const ticks: unknown[] = [];
+    const timer = startSprintTimer({
+      drill: sprint,
+      currentDrill: () => current,
+      schedule: schedule.schedule,
+      onTick: (remaining) => ticks.push(remaining),
+      onExpire: () => ticks.push('expired'),
+    });
+
+    // The sprint is abandoned: another drill becomes the current one.
+    current = lessonDrill;
+    lessonDrill.press('a');
+    clock.advance(60_000);
+    schedule.fire();
+
+    expect(timer.stopped).toBe(true);
+    expect(timer.stopReason).toBe('abandoned');
+    expect(ticks).toEqual([]);
+    // The drill it was not started for is untouched, and still live.
+    expect(lessonDrill.isFinished).toBe(false);
+    expect(lessonDrill.result).toBeNull();
+  });
+
+  it('never expires an untimed drill, at any elapsed time at all', () => {
+    const clock = testClock();
+    const drill = createDrill({ text: 'ask a task', limitMs: NO_LIMIT, now: clock.now });
+    drill.press('a');
+    const schedule = manualSchedule();
+    const seen: (number | null)[] = [];
+    let expired = 0;
+
+    const timer = startSprintTimer({
+      drill,
+      currentDrill: () => drill,
+      schedule: schedule.schedule,
+      onTick: (remaining) => seen.push(remaining),
+      onExpire: () => {
+        expired += 1;
+      },
+    });
+
+    // A hundred thousand years, and then some.
+    for (const jump of [1_000, 60_000, 86_400_000, 3_155_760_000_000]) {
+      clock.advance(jump);
+      schedule.fire();
+    }
+
+    expect(expired).toBe(0);
+    expect(timer.stopped).toBe(false);
+    expect(drill.isFinished).toBe(false);
+    // Remaining time is null for every one of them: never zero, never negative.
+    expect(seen).toEqual([null, null, null, null]);
+  });
+
+  it('is idempotent to stop, and stopping cancels exactly once', () => {
+    const drill = createDrill({ text: 'ask', limitMs: 30_000 });
+    const schedule = manualSchedule();
+    const timer = startSprintTimer({
+      drill,
+      currentDrill: () => drill,
+      schedule: schedule.schedule,
+    });
+
+    timer.stop();
+    timer.stop();
+
+    expect(schedule.cancelled).toBe(1);
+    expect(schedule.live).toBe(0);
+    expect(timer.stopReason).toBe('stopped');
+  });
+
+  it('stops itself before rethrowing a tick that failed, and keeps the cause', () => {
+    const clock = testClock();
+    const drill = createDrill({ text: 'ask a task', limitMs: 30_000, now: clock.now });
+    drill.press('a');
+    const schedule = manualSchedule();
+    const boom = new Error('the countdown readout blew up');
+
+    const timer = startSprintTimer({
+      drill,
+      currentDrill: () => drill,
+      schedule: schedule.schedule,
+      onTick: () => {
+        throw boom;
+      },
+    });
+
+    expect(() => {
+      schedule.fire();
+    }).toThrow(SprintTimerError);
+    expect(timer.stopped).toBe(true);
+    expect(timer.stopReason).toBe('error');
+    expect(schedule.live).toBe(0);
+
+    // Surfaced, never swallowed: the original is attached.
+    let caught: unknown;
+    const second = startSprintTimer({
+      drill,
+      currentDrill: () => drill,
+      schedule: schedule.schedule,
+      onTick: () => {
+        throw boom;
+      },
+    });
+    try {
+      schedule.fire();
+    } catch (error) {
+      caught = error;
+    }
+    expect(second.stopped).toBe(true);
+    expect(caught).toBeInstanceOf(SprintTimerError);
+    expect((caught as SprintTimerError).cause).toBe(boom);
+  });
+
+  it('honours a cancel even when the schedule ran its tick synchronously', () => {
+    const drill = createDrill({ text: 'ask', limitMs: 30_000 });
+    let cancelled = 0;
+    const other = createDrill({ text: 'ask', limitMs: 30_000 });
+
+    const timer = startSprintTimer({
+      drill,
+      // Already abandoned before the schedule even returns.
+      currentDrill: () => other,
+      schedule: (tick) => {
+        tick();
+        return (): void => {
+          cancelled += 1;
+        };
+      },
+    });
+
+    expect(timer.stopReason).toBe('abandoned');
+    expect(cancelled).toBe(1);
+  });
+});