feat(course): audit fixes and twelve extensions (Modules 7b, 12, 13)

Audit pass:
- Frame rule counts frames since the last move, so every step lasts
  exactly movesEvery(score) frames, also right after a speed-up
- clampTime + MAX_GAP_MS: a hidden tab no longer replays the whole gap
- Pong Restart keeps held keys
- Fact corrections (mulberry32 output coverage, Haskell IO, uniform)
- New fixture cases from a mutation analysis

Extensions (all three tracks, shared fixtures, course text):
- Turn queue (Exercise 10.6), persisted high score (10.7),
  replay viewer (10.8), play() end-to-end helper (9.5)
- Optional State (4.7) and optional Module 7b, stack-safe IO
- Module 12, property-based testing with generators, shrinking,
  invariants and a model-based oracle
- Module 13, Conway's Life with a Click event
- JS type checking via jsconfig, JSDoc and types.d.ts
- Maintainer tools: scripts/mutate.mjs, scripts/typecheck-js.sh,
  Playwright end-to-end suite (e2e/, scripts/e2e.sh)

Docs: docs/contract.md is the canonical contract; specs and build log
under docs/superpowers.

Verified: JS 728, Scala 689, F# 691 unit tests; stubs and progression
M01-M13 and M07b; 176 end-to-end tests on Chromium and WebKit.

Co-Authored-By: Claude Fable 5.2 <noreply@anthropic.com>

scala/web/BrowserPlatform.scala

@@ -4,9 +4,12 @@ package web
 import scala.scalajs.js
 import scala.scalajs.js.Dynamic.global
 import scala.scalajs.js.typedarray.Uint32Array
+import scala.util.control.NonFatal
 
 /**
  * Browser glue: turns a canvas into a Platform. Impure by nature; not part of the exercises' logic.
+ * Snake, Pong, the replay viewer and Life share it; only Snake performs `LoadBest` and `SaveBest`, so only Snake
+ * touches storage, and only Life does anything with clicks.
  * `js.Dynamic` lets us call browser APIs by name without type facades (and without extra libraries).
  */
 final class BrowserPlatform(canvas: js.Dynamic) extends Platform:
@@ -38,6 +41,26 @@ final class BrowserPlatform(canvas: js.Dynamic) extends Platform:
     global.crypto.getRandomValues(buf)
     buf(0).toLong
 
+  // m10: where the best score survives a reload.
+  private val bestKey = "pure-snake-best"
+
+  // Storage can be missing, blocked (privacy settings) or hold anything: all of that reads as 0, and nothing throws.
+  // `window.localStorage` is read inside the `try`, because some browsers throw as soon as it is touched.
+  def loadBest(): Int =
+    try
+      val raw = window.localStorage.getItem(bestKey)
+      if raw == null || js.isUndefined(raw) then 0
+      else
+        // Only what saveBest writes counts: decimal digits, at most Int.MaxValue (so all three tracks read alike).
+        val s = raw.asInstanceOf[String]
+        if s.matches("[0-9]{1,10}") && s.toDouble <= Int.MaxValue then s.toDouble.toInt else 0
+    catch case NonFatal(_) => 0
+
+  // A record that cannot be stored is lost; the game goes on.
+  def saveBest(score: Int): Unit =
+    try window.localStorage.setItem(bestKey, score.toString)
+    catch case NonFatal(_) => () // ignored on purpose
+
   // t is the number of milliseconds since the first animation frame.
   def startClock(onTime: Long => Unit): Unit =
     def frame(start: Option[Double]): js.Function1[Double, Unit] = now =>
@@ -48,3 +71,17 @@ final class BrowserPlatform(canvas: js.Dynamic) extends Platform:
 
   def onKeyDown(cb: String => Unit): Unit = listen("keydown", cb)
   def onKeyUp(cb: String => Unit): Unit = listen("keyup", cb)
+
+  // m13: clicks on the canvas (not the window), converted to canvas pixels. The listener is added only when a runtime
+  // asks for clicks. The page may show the canvas at another size than its width x height (CSS scaling, zoom) and draws
+  // a border around it, so the window coordinates are made relative to the drawing area (bounding rectangle minus the
+  // border, clientLeft/clientTop) and then scaled by the canvas size over its shown size (clientWidth/clientHeight).
+  def onClick(cb: (Int, Int) => Unit): Unit =
+    val handler: js.Function1[js.Dynamic, Unit] = e =>
+      val r = canvas.getBoundingClientRect()
+      def axis(client: String, start: String, border: String, size: String, shown: String): Int =
+        val offset = e.selectDynamic(client).asInstanceOf[Double] - r.selectDynamic(start).asInstanceOf[Double] -
+          canvas.selectDynamic(border).asInstanceOf[Double]
+        math.floor(offset * canvas.selectDynamic(size).asInstanceOf[Double] / canvas.selectDynamic(shown).asInstanceOf[Double]).toInt
+      cb(axis("clientX", "left", "clientLeft", "width", "clientWidth"), axis("clientY", "top", "clientTop", "height", "clientHeight"))
+    canvas.addEventListener("click", handler)

scala/web/Main.scala

@@ -1,9 +1,10 @@
 package snake
 package web
 
+import scala.scalajs.js
 import scala.scalajs.js.Dynamic.global
 
-// Two programs, one runtime: build-web.sh picks the entry point with --main-class.
+// Four programs, one runtime: build-web.sh picks the entry point with --main-class.
 
 private def canvas() = global.document.getElementById("game")
 
@@ -14,3 +15,29 @@ object SnakeMain:
 /** scala/pong.html: Pong (m11). */
 object PongMain:
   def main(args: Array[String]): Unit = Runtime.runApp(pong.PongApp.pongMain, BrowserPlatform(canvas()))
+
+/**
+ * scala/replay.html: the replay viewer (m10). The recording is plain JSON next to the test fixtures; the page is served
+ * from the repository root by scripts/serve.mjs, so it can be fetched (relative to the page, scala/replay.html).
+ * The JSON is decoded by hand with js.Dynamic: `{seed, actions}`, each action `{"tag":"Tick"}` or
+ * `{"tag":"Turn","dir":"Up"}`.
+ */
+object ReplayMain:
+  private def action(a: js.Dynamic): Action = a.tag.asInstanceOf[String] match
+    case "Tick" => Action.Tick
+    case "Turn" => Action.Turn(Direction.valueOf(a.dir.asInstanceOf[String]))
+    case other  => throw new IllegalArgumentException(s"a recording holds only Tick and Turn, not $other")
+
+  private def recording(json: js.Dynamic): Recording =
+    Recording(
+      json.seed.asInstanceOf[Double].toLong,
+      json.actions.asInstanceOf[js.Array[js.Dynamic]].toList.map(action)
+    )
+
+  def main(args: Array[String]): Unit =
+    val loaded = global.fetch("../fixtures/replay-sample.json").`then`((r: js.Dynamic) => r.json())
+    loaded.`then`((json: js.Dynamic) => Runtime.runApp(Replay.replayMain(recording(json)), BrowserPlatform(canvas())))
+
+/** scala/life.html: Conway's Life with the mouse (m13). */
+object LifeMain:
+  def main(args: Array[String]): Unit = Runtime.runApp(life.LifeApp.lifeMain, BrowserPlatform(canvas()))