From f860bfa1b3e1f45a271fb4871f2c76d7e713ea17 Mon Sep 17 00:00:00 2001
From: tiennm99 <tiennm99@outlook.com>
Date: Tue, 18 Aug 2026 09:44:58 +0700
Subject: [PATCH] refactor(client/web): migrate TypeScript to plain JavaScript
 + JSDoc

Convert all .ts and <script lang="ts"> Svelte files under client/web to
.js/.svelte with JSDoc type annotations, replacing tsconfig project
references with a single jsconfig.json (strict + checkJs) and adding a
svelte-check `check` script. No runtime behavior changes; a handful of
pre-existing strictness gaps (missing vite/client ambient types, Phaser
scene fields without initializers, a WebSocket ArrayBuffer generic
mismatch) are annotated/cast rather than altered so the new check gate
is green without changing logic.
---
 client/web/README.md                          | 22 +++--
 .../web/{tsconfig.node.json => jsconfig.json} | 22 ++---
 client/web/package.json                       |  1 +
 client/web/src/PhaserGame.svelte              | 27 +++---
 client/web/src/app.d.ts                       |  2 +
 .../auth/{auth.svelte.ts => auth.svelte.js}   | 26 +++--
 .../web/src/auth/{firebase.ts => firebase.js} | 42 +++++---
 client/web/src/components/BetaBanner.svelte   |  5 +-
 client/web/src/components/Lobby.svelte        |  2 +-
 client/web/src/components/SignIn.svelte       |  4 +-
 .../web/src/game/{EventBus.ts => EventBus.js} |  2 +-
 client/web/src/game/{main.ts => main.js}      |  6 +-
 .../web/src/game/scenes/{Boot.ts => Boot.js}  |  0
 .../web/src/game/scenes/{Game.ts => Game.js}  |  9 +-
 .../game/scenes/{GameOver.ts => GameOver.js}  |  9 +-
 .../game/scenes/{MainMenu.ts => MainMenu.js}  | 17 ++--
 .../scenes/{Preloader.ts => Preloader.js}     |  2 +-
 .../src/games/{registry.ts => registry.js}    | 11 ++-
 client/web/src/games/runner/GameRunner.svelte | 79 +++++++++------
 .../web/src/games/runner/eventbus-helpers.js  | 54 +++++++++++
 .../web/src/games/runner/eventbus-helpers.ts  | 37 --------
 client/web/src/games/types.js                 | 22 +++++
 client/web/src/games/types.ts                 | 21 ----
 client/web/src/games/wordle/WordleHud.svelte  | 20 ++--
 .../wordle/{WordleScene.ts => WordleScene.js} | 95 ++++++++++++-------
 .../src/games/wordle/{index.ts => index.js}   |  6 +-
 .../games/wordle/{scoring.ts => scoring.js}   | 28 ++++--
 .../{scoring.test.ts => scoring.test.js}      |  0
 client/web/src/lib/{index.ts => index.js}     |  0
 client/web/src/net/{proto.ts => proto.js}     | 79 +++++++++++----
 client/web/src/net/{ws.ts => ws.js}           | 67 ++++++++-----
 client/web/src/routes/+page.svelte            |  2 +-
 client/web/tsconfig.app.json                  | 24 -----
 client/web/tsconfig.json                      | 11 ---
 docs/code-standards.md                        | 36 +++----
 docs/codebase-summary.md                      | 26 ++---
 docs/system-architecture.md                   |  6 +-
 37 files changed, 498 insertions(+), 324 deletions(-)
 rename client/web/{tsconfig.node.json => jsconfig.json} (60%)
 rename client/web/src/auth/{auth.svelte.ts => auth.svelte.js} (62%)
 rename client/web/src/auth/{firebase.ts => firebase.js} (62%)
 rename client/web/src/game/{EventBus.ts => EventBus.js} (66%)
 rename client/web/src/game/{main.ts => main.js} (84%)
 rename client/web/src/game/scenes/{Boot.ts => Boot.js} (100%)
 rename client/web/src/game/scenes/{Game.ts => Game.js} (74%)
 rename client/web/src/game/scenes/{GameOver.ts => GameOver.js} (73%)
 rename client/web/src/game/scenes/{MainMenu.ts => MainMenu.js} (76%)
 rename client/web/src/game/scenes/{Preloader.ts => Preloader.js} (95%)
 rename client/web/src/games/{registry.ts => registry.js} (60%)
 create mode 100644 client/web/src/games/runner/eventbus-helpers.js
 delete mode 100644 client/web/src/games/runner/eventbus-helpers.ts
 create mode 100644 client/web/src/games/types.js
 delete mode 100644 client/web/src/games/types.ts
 rename client/web/src/games/wordle/{WordleScene.ts => WordleScene.js} (82%)
 rename client/web/src/games/wordle/{index.ts => index.js} (72%)
 rename client/web/src/games/wordle/{scoring.ts => scoring.js} (74%)
 rename client/web/src/games/wordle/{scoring.test.ts => scoring.test.js} (100%)
 rename client/web/src/lib/{index.ts => index.js} (100%)
 rename client/web/src/net/{proto.ts => proto.js} (64%)
 rename client/web/src/net/{ws.ts => ws.js} (64%)
 delete mode 100644 client/web/tsconfig.app.json
 delete mode 100644 client/web/tsconfig.json

diff --git a/client/web/README.md b/client/web/README.md
index cca3e23..eb7abf1 100644
--- a/client/web/README.md
+++ b/client/web/README.md
@@ -1,6 +1,6 @@
 # Phaser Svelte Template
 
-This is a Phaser 3 project template that uses the Svelte framework, TypeScript and Vite for bundling. It includes a bridge for Svelte to Phaser game communication, hot-reloading for quick development workflow and scripts to generate production-ready builds.
+This is a Phaser 3 project template that uses the Svelte framework and Vite for bundling. It includes a bridge for Svelte to Phaser game communication, hot-reloading for quick development workflow and scripts to generate production-ready builds.
 
 ### Versions
 
@@ -9,7 +9,8 @@ This template has been updated for:
 - [Phaser 3.90.0](https://github.com/phaserjs/phaser)
 - [Svelte 5.23.1](https://github.com/sveltejs/kit)
 - [Vite 6.3.1](https://github.com/vitejs/vite)
-- [TypeScript 5.7.2](https://github.com/microsoft/TypeScript)
+
+Source is plain JavaScript with JSDoc type annotations, checked via `npm run check` (`svelte-check` against `jsconfig.json`).
 
 ![screenshot](screenshot.png)
 
@@ -26,6 +27,7 @@ This template has been updated for:
 | `npm run build` | Create a production build in the `build` folder |
 | `npm run dev-nolog` | Launch a development web server without sending anonymous data (see "About log.js" below) |
 | `npm run build-nolog` | Create a production build in the `dist` folder without sending anonymous data (see "About log.js" below) |
+| `npm run check` | Type-check the JSDoc-annotated JavaScript and Svelte source via `svelte-check` |
 
 ## Writing Code
 
@@ -48,8 +50,8 @@ We have provided a default project structure to get you started. This is as foll
 | `src/+page.svelte`            | Svelte page that integrates the functionality of the game created with Phaser.|
 | `src/PhaserGame.svelte`       | The Svelte component that initializes the Phaser game and acts as a bridge between Svelte and Phaser.|
 | `src/game`                    | Contains the game source code.                                             |
-| `src/game/EventBus.ts`        | A simple event bus to communicate between Svelte and Phaser.               |
-| `src/game/main.ts`            | The main **game** entry point containing the game configuration and starting the game.|
+| `src/game/EventBus.js`        | A simple event bus to communicate between Svelte and Phaser.               |
+| `src/game/main.js`            | The main **game** entry point containing the game configuration and starting the game.|
 | `src/game/scenes/`            | Folder containing the Phaser Scenes.                                       |
 | `static/assets`               | Contains the static assets used by the game.                              |
 
@@ -57,7 +59,7 @@ We have provided a default project structure to get you started. This is as foll
 
 The `PhaserGame.svelte` component is the bridge between Svelte and Phaser. It initializes the Phaser game and passes events between the two.
 
-To communicate between Svelte and Phaser, you can use the **EventBus.ts** file. This is a simple event bus that allows you to emit and listen for events from both Svelte and Phaser.
+To communicate between Svelte and Phaser, you can use the **EventBus.js** file. This is a simple event bus that allows you to emit and listen for events from both Svelte and Phaser.
 
 ```js
 // In Svelte
@@ -112,11 +114,13 @@ Here's an example of how to access Phaser data for use in a Svelte Component:
 
 ```js
 // In a parent component
-<script lang="ts">
-    import type { Scene } from "phaser";
-    import PhaserGame, { type TPhaserRef } from "game/PhaserGame.svelte"; // We provide the type TPhaserRef but this route is an example. You should use the correct path to the PhaserGame component.
+<script>
+    import PhaserGame from "game/PhaserGame.svelte"; // This route is an example. You should use the correct path to the PhaserGame component.
+
+    /** @typedef {import('game/PhaserGame.svelte').TPhaserRef} TPhaserRef */
 
-    let phaserRef: TPhaserRef = { game: null, scene: null};
+    /** @type {TPhaserRef} */
+    let phaserRef = { game: null, scene: null};
 
     const onCurrentActiveScene = (scene) => {
         
diff --git a/client/web/tsconfig.node.json b/client/web/jsconfig.json
similarity index 60%
rename from client/web/tsconfig.node.json
rename to client/web/jsconfig.json
index 0cbbb5b..eb0292b 100644
--- a/client/web/tsconfig.node.json
+++ b/client/web/jsconfig.json
@@ -1,19 +1,17 @@
 {
+    "extends": "@tsconfig/svelte/tsconfig.json",
     "compilerOptions": {
-        "tsBuildInfoFile": "./node_modules/.tmp/tsconfig.node.tsbuildinfo",
-        "target": "ES2022",
-        "lib": [
-            "ES2023"
-        ],
+        "target": "ESNext",
+        "useDefineForClassFields": true,
         "module": "ESNext",
-        "skipLibCheck": true,
-        /* Bundler mode */
+        "resolveJsonModule": true,
         "moduleResolution": "bundler",
-        "allowImportingTsExtensions": true,
         "isolatedModules": true,
         "moduleDetection": "force",
+        "allowJs": true,
+        "checkJs": true,
         "noEmit": true,
-        /* Linting */
+        "skipLibCheck": true,
         "strict": true,
         "noUnusedLocals": true,
         "noUnusedParameters": true,
@@ -21,6 +19,8 @@
         "noUncheckedSideEffectImports": true
     },
     "include": [
-        "vite.config.ts"
+        "src/**/*.js",
+        "src/**/*.d.ts",
+        "src/**/*.svelte"
     ]
-}
\ No newline at end of file
+}
diff --git a/client/web/package.json b/client/web/package.json
index 6f04ead..0a1a543 100644
--- a/client/web/package.json
+++ b/client/web/package.json
@@ -25,6 +25,7 @@
     "dev-nolog": "vite --config vite/config.dev.mjs",
     "build-nolog": "vite build --config vite/config.prod.mjs",
     "preview": "vite preview --outDir build",
+    "check": "svelte-check --tsconfig ./jsconfig.json",
     "test": "vitest run",
     "test:watch": "vitest"
   },
diff --git a/client/web/src/PhaserGame.svelte b/client/web/src/PhaserGame.svelte
index ece964c..c12f280 100644
--- a/client/web/src/PhaserGame.svelte
+++ b/client/web/src/PhaserGame.svelte
@@ -1,40 +1,41 @@
-<script context="module" lang="ts">
+<script context="module">
 
-    import type { Game, Scene } from "phaser";
-
-    export type TPhaserRef = {
-        game: Game | null,
-        scene: Scene | null
-    };
+    /**
+     * @typedef {Object} TPhaserRef
+     * @property {import('phaser').Game | null} game
+     * @property {import('phaser').Scene | null} scene
+     */
 
 </script>
 
-<script lang="ts">
+<script>
 
     import { onMount } from "svelte";
     import StartGame from "./game/main";
     import { EventBus } from './game/EventBus';
 
-    export let phaserRef: TPhaserRef = {
+    /** @type {TPhaserRef} */
+    export let phaserRef = {
         game: null,
         scene: null
     };
 
-    export let currentActiveScene: (scene: Scene) => void | undefined;
+    /** @type {(scene: import('phaser').Scene) => void | undefined} */
+    export let currentActiveScene;
 
     onMount(() => {
 
         phaserRef.game = StartGame("game-container");
 
-        EventBus.on('current-scene-ready', (scene_instance: Scene) => {
+        EventBus.on('current-scene-ready', (/** @type {import('phaser').Scene} */ scene_instance) => {
 
             phaserRef.scene = scene_instance;
 
             if(currentActiveScene)
             {
-                
+
                 currentActiveScene(scene_instance);
-                
+
             }
 
         });
diff --git a/client/web/src/app.d.ts b/client/web/src/app.d.ts
index 743f07b..f7e51c8 100644
--- a/client/web/src/app.d.ts
+++ b/client/web/src/app.d.ts
@@ -1,3 +1,5 @@
+/// <reference types="vite/client" />
+
 // See https://kit.svelte.dev/docs/types#app
 // for information about these interfaces
 declare global {
diff --git a/client/web/src/auth/auth.svelte.ts b/client/web/src/auth/auth.svelte.js
similarity index 62%
rename from client/web/src/auth/auth.svelte.ts
rename to client/web/src/auth/auth.svelte.js
index 017f955..acf5f81 100644
--- a/client/web/src/auth/auth.svelte.ts
+++ b/client/web/src/auth/auth.svelte.js
@@ -3,12 +3,14 @@
 // onAuthStateChanged listener, so reactive consumers get repaint when the
 // SDK rehydrates the user from persistence.
 
-import { initFirebase, onAuthStateChanged, signInWithGoogle, signInWithEmail, signInAnonymously, signOut, getIdToken, type User } from './firebase';
+import { initFirebase, onAuthStateChanged, signInWithGoogle, signInWithEmail, signInAnonymously, signOut, getIdToken } from './firebase';
+
+/** @typedef {import('./firebase').User} User */
 
 class AuthState {
-  user = $state<User | null>(null);
+  user = $state(/** @type {User | null} */ (null));
   loading = $state(true);
-  error = $state<string | null>(null);
+  error = $state(/** @type {string | null} */ (null));
 
   constructor() {
     const a = initFirebase();
@@ -23,16 +25,20 @@ class AuthState {
     try {
       this.user = await signInWithGoogle();
     } catch (e) {
-      this.error = (e as Error).message;
+      this.error = /** @type {Error} */ (e).message;
     }
   }
 
-  async signInWithEmail(email: string, password: string) {
+  /**
+   * @param {string} email
+   * @param {string} password
+   */
+  async signInWithEmail(email, password) {
     this.error = null;
     try {
       this.user = await signInWithEmail(email, password);
     } catch (e) {
-      this.error = (e as Error).message;
+      this.error = /** @type {Error} */ (e).message;
     }
   }
 
@@ -41,7 +47,7 @@ class AuthState {
     try {
       this.user = await signInAnonymously();
     } catch (e) {
-      this.error = (e as Error).message;
+      this.error = /** @type {Error} */ (e).message;
     }
   }
 
@@ -50,7 +56,11 @@ class AuthState {
     this.user = null;
   }
 
-  async getIdToken(forceRefresh = false): Promise<string | null> {
+  /**
+   * @param {boolean} [forceRefresh]
+   * @returns {Promise<string | null>}
+   */
+  async getIdToken(forceRefresh = false) {
     return getIdToken(forceRefresh);
   }
 }
diff --git a/client/web/src/auth/firebase.ts b/client/web/src/auth/firebase.js
similarity index 62%
rename from client/web/src/auth/firebase.ts
rename to client/web/src/auth/firebase.js
index 5d58f33..d806245 100644
--- a/client/web/src/auth/firebase.ts
+++ b/client/web/src/auth/firebase.js
@@ -5,7 +5,7 @@
 // Public-by-design config (apiKey etc.) lives in `import.meta.env.VITE_*`
 // — safe to ship in the bundle.
 
-import { initializeApp, type FirebaseApp } from 'firebase/app';
+import { initializeApp } from 'firebase/app';
 import {
   getAuth,
   signInWithPopup,
@@ -13,15 +13,20 @@ import {
   signInAnonymously as fbSignInAnon,
   GoogleAuthProvider,
   signOut as fbSignOut,
-  onAuthStateChanged,
-  type User,
-  type Auth
+  onAuthStateChanged
 } from 'firebase/auth';
 
-let app: FirebaseApp | null = null;
-let auth: Auth | null = null;
+/** @typedef {import('firebase/app').FirebaseApp} FirebaseApp */
+/** @typedef {import('firebase/auth').User} User */
+/** @typedef {import('firebase/auth').Auth} Auth */
 
-export function initFirebase(): Auth {
+/** @type {FirebaseApp | null} */
+let app = null;
+/** @type {Auth | null} */
+let auth = null;
+
+/** @returns {Auth} */
+export function initFirebase() {
   if (auth) return auth;
   app = initializeApp({
     apiKey: import.meta.env.VITE_FIREBASE_API_KEY,
@@ -33,32 +38,44 @@ export function initFirebase(): Auth {
   return auth;
 }
 
-export async function signInWithGoogle(): Promise<User> {
+/** @returns {Promise<User>} */
+export async function signInWithGoogle() {
   const a = initFirebase();
   const cred = await signInWithPopup(a, new GoogleAuthProvider());
   return cred.user;
 }
 
-export async function signInWithEmail(email: string, password: string): Promise<User> {
+/**
+ * @param {string} email
+ * @param {string} password
+ * @returns {Promise<User>}
+ */
+export async function signInWithEmail(email, password) {
   const a = initFirebase();
   const cred = await signInWithEmailAndPassword(a, email, password);
   return cred.user;
 }
 
-export async function signInAnonymously(): Promise<User> {
+/** @returns {Promise<User>} */
+export async function signInAnonymously() {
   const a = initFirebase();
   const cred = await fbSignInAnon(a);
   return cred.user;
 }
 
-export async function signOut(): Promise<void> {
+/** @returns {Promise<void>} */
+export async function signOut() {
   const a = initFirebase();
   await fbSignOut(a);
 }
 
 // getIdToken returns the current ID token. Pass forceRefresh=true to bypass
 // the SDK's 5-minute cache (the WS reconnect path uses this).
-export async function getIdToken(forceRefresh = false): Promise<string | null> {
+/**
+ * @param {boolean} [forceRefresh]
+ * @returns {Promise<string | null>}
+ */
+export async function getIdToken(forceRefresh = false) {
   const a = initFirebase();
   const u = a.currentUser;
   if (!u) return null;
@@ -66,4 +83,3 @@ export async function getIdToken(forceRefresh = false): Promise<string | null> {
 }
 
 export { onAuthStateChanged };
-export type { User };
diff --git a/client/web/src/components/BetaBanner.svelte b/client/web/src/components/BetaBanner.svelte
index 35888e3..d4c8eb1 100644
--- a/client/web/src/components/BetaBanner.svelte
+++ b/client/web/src/components/BetaBanner.svelte
@@ -1,7 +1,8 @@
-<script lang="ts">
+<script>
   // Sticky beta-stage notice. `mode` ∈ "full" (signin page, always visible)
   // or "topbar" (lobby, dismissable per session via sessionStorage).
-  let { mode = 'full' as 'full' | 'topbar' } = $props();
+  /** @type {{ mode?: 'full' | 'topbar' }} */
+  let { mode = 'full' } = $props();
 
   const sessionKey = 'dleague.beta.dismissed';
   let dismissed = $state(
diff --git a/client/web/src/components/Lobby.svelte b/client/web/src/components/Lobby.svelte
index 582bd18..76c2c36 100644
--- a/client/web/src/components/Lobby.svelte
+++ b/client/web/src/components/Lobby.svelte
@@ -1,4 +1,4 @@
-<script lang="ts">
+<script>
   import { onMount, onDestroy } from 'svelte';
   import { auth } from '../auth/auth.svelte';
   import { WsClient, defaultWsUrl } from '../net/ws';
diff --git a/client/web/src/components/SignIn.svelte b/client/web/src/components/SignIn.svelte
index c5ed3e2..15003d0 100644
--- a/client/web/src/components/SignIn.svelte
+++ b/client/web/src/components/SignIn.svelte
@@ -1,4 +1,4 @@
-<script lang="ts">
+<script>
   import { auth } from '../auth/auth.svelte';
   import BetaBanner from './BetaBanner.svelte';
 
@@ -36,7 +36,7 @@
 
   <form
     class="email"
-    onsubmit={(e: SubmitEvent) => {
+    onsubmit={(/** @type {SubmitEvent} */ e) => {
       e.preventDefault();
       withEmail();
     }}
diff --git a/client/web/src/game/EventBus.ts b/client/web/src/game/EventBus.js
similarity index 66%
rename from client/web/src/game/EventBus.ts
rename to client/web/src/game/EventBus.js
index 98a8ee5..be41dfc 100644
--- a/client/web/src/game/EventBus.ts
+++ b/client/web/src/game/EventBus.js
@@ -1,4 +1,4 @@
 import { Events } from 'phaser';
 
 // Used to emit events between components, HTML and Phaser scenes
-export const EventBus = new Events.EventEmitter();
\ No newline at end of file
+export const EventBus = new Events.EventEmitter();
diff --git a/client/web/src/game/main.ts b/client/web/src/game/main.js
similarity index 84%
rename from client/web/src/game/main.ts
rename to client/web/src/game/main.js
index d0530ca..7f4ac4a 100644
--- a/client/web/src/game/main.ts
+++ b/client/web/src/game/main.js
@@ -7,7 +7,8 @@ import { Preloader } from './scenes/Preloader';
 
 // Find out more information about the Game Config at:
 // https://docs.phaser.io/api-documentation/typedef/types-core#gameconfig
-const config: Phaser.Types.Core.GameConfig = {
+/** @type {Phaser.Types.Core.GameConfig} */
+const config = {
     type: AUTO,
     width: 1024,
     height: 768,
@@ -22,7 +23,8 @@ const config: Phaser.Types.Core.GameConfig = {
     ]
 };
 
-const StartGame = (parent: string) => {
+/** @param {string} parent */
+const StartGame = (parent) => {
 
     return new Game({ ...config, parent });
 
diff --git a/client/web/src/game/scenes/Boot.ts b/client/web/src/game/scenes/Boot.js
similarity index 100%
rename from client/web/src/game/scenes/Boot.ts
rename to client/web/src/game/scenes/Boot.js
diff --git a/client/web/src/game/scenes/Game.ts b/client/web/src/game/scenes/Game.js
similarity index 74%
rename from client/web/src/game/scenes/Game.ts
rename to client/web/src/game/scenes/Game.js
index 19db45c..95964b2 100644
--- a/client/web/src/game/scenes/Game.ts
+++ b/client/web/src/game/scenes/Game.js
@@ -3,9 +3,12 @@ import { Scene } from 'phaser';
 
 export class Game extends Scene
 {
-    camera: Phaser.Cameras.Scene2D.Camera;
-    background: Phaser.GameObjects.Image;
-    gameText: Phaser.GameObjects.Text;
+    /** @type {Phaser.Cameras.Scene2D.Camera} */
+    camera = /** @type {any} */ (undefined);
+    /** @type {Phaser.GameObjects.Image} */
+    background = /** @type {any} */ (undefined);
+    /** @type {Phaser.GameObjects.Text} */
+    gameText = /** @type {any} */ (undefined);
 
     constructor ()
     {
diff --git a/client/web/src/game/scenes/GameOver.ts b/client/web/src/game/scenes/GameOver.js
similarity index 73%
rename from client/web/src/game/scenes/GameOver.ts
rename to client/web/src/game/scenes/GameOver.js
index 34cd62b..2fb502a 100644
--- a/client/web/src/game/scenes/GameOver.ts
+++ b/client/web/src/game/scenes/GameOver.js
@@ -3,9 +3,12 @@ import { Scene } from 'phaser';
 
 export class GameOver extends Scene
 {
-    camera: Phaser.Cameras.Scene2D.Camera;
-    background: Phaser.GameObjects.Image;
-    gameOverText : Phaser.GameObjects.Text;
+    /** @type {Phaser.Cameras.Scene2D.Camera} */
+    camera = /** @type {any} */ (undefined);
+    /** @type {Phaser.GameObjects.Image} */
+    background = /** @type {any} */ (undefined);
+    /** @type {Phaser.GameObjects.Text} */
+    gameOverText = /** @type {any} */ (undefined);
 
     constructor ()
     {
diff --git a/client/web/src/game/scenes/MainMenu.ts b/client/web/src/game/scenes/MainMenu.js
similarity index 76%
rename from client/web/src/game/scenes/MainMenu.ts
rename to client/web/src/game/scenes/MainMenu.js
index af58f13..2c76b00 100644
--- a/client/web/src/game/scenes/MainMenu.ts
+++ b/client/web/src/game/scenes/MainMenu.js
@@ -1,13 +1,17 @@
-import { type GameObjects, Scene } from 'phaser';
+import { Scene } from 'phaser';
 
 import { EventBus } from '../EventBus';
 
 export class MainMenu extends Scene
 {
-    background: GameObjects.Image;
-    logo: GameObjects.Image;
-    title: GameObjects.Text;
-    logoTween: Phaser.Tweens.Tween | null;
+    /** @type {import('phaser').GameObjects.Image} */
+    background = /** @type {any} */ (undefined);
+    /** @type {import('phaser').GameObjects.Image} */
+    logo = /** @type {any} */ (undefined);
+    /** @type {import('phaser').GameObjects.Text} */
+    title = /** @type {any} */ (undefined);
+    /** @type {Phaser.Tweens.Tween | null} */
+    logoTween = /** @type {any} */ (undefined);
 
     constructor ()
     {
@@ -40,7 +44,8 @@ export class MainMenu extends Scene
         this.scene.start('Game');
     }
 
-    moveLogo (vueCallback: ({ x, y }: { x: number, y: number }) => void)
+    /** @param {(pos: { x: number, y: number }) => void} vueCallback */
+    moveLogo (vueCallback)
     {
         if (this.logoTween)
         {
diff --git a/client/web/src/game/scenes/Preloader.ts b/client/web/src/game/scenes/Preloader.js
similarity index 95%
rename from client/web/src/game/scenes/Preloader.ts
rename to client/web/src/game/scenes/Preloader.js
index ca77176..f696d32 100644
--- a/client/web/src/game/scenes/Preloader.ts
+++ b/client/web/src/game/scenes/Preloader.js
@@ -19,7 +19,7 @@ export class Preloader extends Scene
         const bar = this.add.rectangle(512-230, 384, 4, 28, 0xffffff);
 
         //  Use the 'progress' event emitted by the LoaderPlugin to update the loading bar
-        this.load.on('progress', (progress: number) => {
+        this.load.on('progress', (/** @type {number} */ progress) => {
 
             //  Update the progress bar (our bar is 464px wide, so 100% = 464px)
             bar.width = 4 + (460 * progress);
diff --git a/client/web/src/games/registry.ts b/client/web/src/games/registry.js
similarity index 60%
rename from client/web/src/games/registry.ts
rename to client/web/src/games/registry.js
index d60b04a..195a2fa 100644
--- a/client/web/src/games/registry.ts
+++ b/client/web/src/games/registry.js
@@ -2,13 +2,18 @@
 // so Vite splits the per-variant code into its own chunk — Phaser loads
 // once, the variant chunk only when its game is played.
 
-import type { GameVariant } from './types';
+/** @typedef {import('./types').GameVariant} GameVariant */
 
-export const variants = new Map<string, () => Promise<GameVariant>>([
+/** @type {Map<string, () => Promise<GameVariant>>} */
+export const variants = new Map([
   ['wordle', async () => (await import('./wordle')).default],
 ]);
 
-export async function loadVariant(key: string): Promise<GameVariant> {
+/**
+ * @param {string} key
+ * @returns {Promise<GameVariant>}
+ */
+export async function loadVariant(key) {
   const loader = variants.get(key);
   if (!loader) throw new Error(`unknown game variant: ${key}`);
   return loader();
diff --git a/client/web/src/games/runner/GameRunner.svelte b/client/web/src/games/runner/GameRunner.svelte
index 9982681..f90bb85 100644
--- a/client/web/src/games/runner/GameRunner.svelte
+++ b/client/web/src/games/runner/GameRunner.svelte
@@ -1,4 +1,4 @@
-<script lang="ts">
+<script>
   // Generic game shell. Loads the requested variant via dynamic import,
   // fetches today's puzzle (auth'd → includes word for client-side per-guess
   // feedback), fetches resume state, mounts the Phaser scene + Svelte HUD,
@@ -7,28 +7,39 @@
   import { onMount, onDestroy } from 'svelte';
   import { auth } from '../../auth/auth.svelte';
   import { loadVariant } from '../registry';
-  import type { GameVariant } from '../types';
-  import type { Game } from 'phaser';
-  import { onAttemptComplete, type AttemptCompletePayload } from './eventbus-helpers';
+  import { onAttemptComplete } from './eventbus-helpers';
 
-  let { variantKey, onExit = () => {} } = $props();
+  /** @typedef {import('../types').GameVariant} GameVariant */
+  /** @typedef {import('phaser').Game} Game */
+  /** @typedef {import('./eventbus-helpers').AttemptCompletePayload} AttemptCompletePayload */
 
-  type Stage = 'loading' | 'ready' | 'finished' | 'error';
-  let stage = $state<Stage>('loading');
-  let errorMsg = $state<string | null>(null);
-  let variant = $state<GameVariant | null>(null);
-  let puzzleDate = $state<string>('');
-  let game: Game | null = null;
-  let unsubAttempt: (() => void) | null = null;
-
-  interface PuzzleResponse {
-    date: string;
-    word: string;
-    hint?: string;
-    difficulty?: number;
-  }
+  /** @type {{ variantKey: string, onExit?: () => void }} */
+  let { variantKey, onExit = () => {} } = $props();
 
-  async function authedFetch(path: string, init?: RequestInit): Promise<Response> {
+  /** @typedef {'loading' | 'ready' | 'finished' | 'error'} Stage */
+  let stage = $state(/** @type {Stage} */ ('loading'));
+  let errorMsg = $state(/** @type {string | null} */ (null));
+  let variant = $state(/** @type {GameVariant | null} */ (null));
+  let puzzleDate = $state(/** @type {string} */ (''));
+  /** @type {Game | null} */
+  let game = null;
+  /** @type {(() => void) | null} */
+  let unsubAttempt = null;
+
+  /**
+   * @typedef {Object} PuzzleResponse
+   * @property {string} date
+   * @property {string} word
+   * @property {string} [hint]
+   * @property {number} [difficulty]
+   */
+
+  /**
+   * @param {string} path
+   * @param {RequestInit} [init]
+   * @returns {Promise<Response>}
+   */
+  async function authedFetch(path, init) {
     const token = await auth.getIdToken(false);
     if (!token) throw new Error('not signed in');
     return fetch(path, {
@@ -37,13 +48,18 @@
     });
   }
 
-  async function fetchPuzzle(): Promise<PuzzleResponse> {
+  /** @returns {Promise<PuzzleResponse>} */
+  async function fetchPuzzle() {
     const res = await authedFetch('/api/v1/puzzles/me/today');
     if (!res.ok) throw new Error(`puzzle fetch failed: ${res.status}`);
     return res.json();
   }
 
-  async function fetchResume(date: string): Promise<string[] | null> {
+  /**
+   * @param {string} date
+   * @returns {Promise<string[] | null>}
+   */
+  async function fetchResume(date) {
     const res = await authedFetch(`/api/v1/attempts/me/${date}`);
     if (res.status === 404) return null;
     if (!res.ok) throw new Error(`resume fetch failed: ${res.status}`);
@@ -51,7 +67,12 @@
     return Array.isArray(a.guesses) ? a.guesses : null;
   }
 
-  async function postAttempt(date: string, guesses: string[]): Promise<void> {
+  /**
+   * @param {string} date
+   * @param {string[]} guesses
+   * @returns {Promise<void>}
+   */
+  async function postAttempt(date, guesses) {
     const res = await authedFetch('/api/v1/attempts', {
       method: 'POST',
       headers: { 'Content-Type': 'application/json' },
@@ -60,7 +81,8 @@
     if (!res.ok) throw new Error(`attempt post failed: ${res.status}`);
   }
 
-  async function startGame(parentId: string) {
+  /** @param {string} parentId */
+  async function startGame(parentId) {
     const v = await loadVariant(variantKey);
     variant = v;
     const puzzle = await fetchPuzzle();
@@ -82,17 +104,18 @@
     };
     // Wait until Phaser is up before starting the scene.
     game.events.once('ready', () => {
-      game!.scene.start('Wordle', initData);
+      /** @type {Game} */ (game).scene.start('Wordle', initData);
     });
     if (game.isBooted) game.scene.start('Wordle', initData);
     stage = 'ready';
   }
 
-  async function handleAttemptComplete(p: AttemptCompletePayload) {
+  /** @param {AttemptCompletePayload} p */
+  async function handleAttemptComplete(p) {
     try {
       await postAttempt(puzzleDate, p.guesses);
     } catch (e) {
-      errorMsg = (e as Error).message;
+      errorMsg = /** @type {Error} */ (e).message;
     }
     stage = 'finished';
   }
@@ -102,7 +125,7 @@
     try {
       await startGame('game-container');
     } catch (e) {
-      errorMsg = (e as Error).message;
+      errorMsg = /** @type {Error} */ (e).message;
       stage = 'error';
     }
   });
diff --git a/client/web/src/games/runner/eventbus-helpers.js b/client/web/src/games/runner/eventbus-helpers.js
new file mode 100644
index 0000000..bff8a98
--- /dev/null
+++ b/client/web/src/games/runner/eventbus-helpers.js
@@ -0,0 +1,54 @@
+// Typed wrappers around the shared EventBus so variants and the runner
+// don't ping each other with stringly-typed events scattered across files.
+
+import { EventBus } from '../../game/EventBus';
+
+/**
+ * @typedef {Object} AttemptCompletePayload
+ * @property {string[]} guesses
+ * @property {('hit' | 'present' | 'miss')[][]} evaluations
+ * @property {'won' | 'lost'} status
+ */
+
+/**
+ * @typedef {{ kind: 'attempt-complete', payload: AttemptCompletePayload } | { kind: 'guess-submitted', payload: { guess: string } }} GameRunnerEvent
+ */
+
+export const Events = {
+  ATTEMPT_COMPLETE: /** @type {'attempt-complete'} */ ('attempt-complete'),
+  GUESS_SUBMITTED: /** @type {'guess-submitted'} */ ('guess-submitted'),
+};
+
+/**
+ * @param {AttemptCompletePayload} payload
+ * @returns {void}
+ */
+export function emitAttemptComplete(payload) {
+  EventBus.emit(Events.ATTEMPT_COMPLETE, payload);
+}
+
+/**
+ * @param {(p: AttemptCompletePayload) => void} fn
+ * @returns {() => void}
+ */
+export function onAttemptComplete(fn) {
+  EventBus.on(Events.ATTEMPT_COMPLETE, fn);
+  return () => EventBus.off(Events.ATTEMPT_COMPLETE, fn);
+}
+
+/**
+ * @param {string} guess
+ * @returns {void}
+ */
+export function emitGuessSubmitted(guess) {
+  EventBus.emit(Events.GUESS_SUBMITTED, { guess });
+}
+
+/**
+ * @param {(p: { guess: string }) => void} fn
+ * @returns {() => void}
+ */
+export function onGuessSubmitted(fn) {
+  EventBus.on(Events.GUESS_SUBMITTED, fn);
+  return () => EventBus.off(Events.GUESS_SUBMITTED, fn);
+}
diff --git a/client/web/src/games/runner/eventbus-helpers.ts b/client/web/src/games/runner/eventbus-helpers.ts
deleted file mode 100644
index 4580358..0000000
--- a/client/web/src/games/runner/eventbus-helpers.ts
+++ /dev/null
@@ -1,37 +0,0 @@
-// Typed wrappers around the shared EventBus so variants and the runner
-// don't ping each other with stringly-typed events scattered across files.
-
-import { EventBus } from '../../game/EventBus';
-
-export interface AttemptCompletePayload {
-  guesses: string[];
-  evaluations: ('hit' | 'present' | 'miss')[][];
-  status: 'won' | 'lost';
-}
-
-export type GameRunnerEvent =
-  | { kind: 'attempt-complete'; payload: AttemptCompletePayload }
-  | { kind: 'guess-submitted'; payload: { guess: string } };
-
-export const Events = {
-  ATTEMPT_COMPLETE: 'attempt-complete' as const,
-  GUESS_SUBMITTED: 'guess-submitted' as const,
-};
-
-export function emitAttemptComplete(payload: AttemptCompletePayload): void {
-  EventBus.emit(Events.ATTEMPT_COMPLETE, payload);
-}
-
-export function onAttemptComplete(fn: (p: AttemptCompletePayload) => void): () => void {
-  EventBus.on(Events.ATTEMPT_COMPLETE, fn);
-  return () => EventBus.off(Events.ATTEMPT_COMPLETE, fn);
-}
-
-export function emitGuessSubmitted(guess: string): void {
-  EventBus.emit(Events.GUESS_SUBMITTED, { guess });
-}
-
-export function onGuessSubmitted(fn: (p: { guess: string }) => void): () => void {
-  EventBus.on(Events.GUESS_SUBMITTED, fn);
-  return () => EventBus.off(Events.GUESS_SUBMITTED, fn);
-}
diff --git a/client/web/src/games/types.js b/client/web/src/games/types.js
new file mode 100644
index 0000000..cbf0bae
--- /dev/null
+++ b/client/web/src/games/types.js
@@ -0,0 +1,22 @@
+// GameVariant is the contract for a pluggable -dle game. Each variant
+// supplies a Phaser scene class (canvas-side rendering + game logic) plus a
+// Svelte component that renders the HUD overlay (attempt counter, win/lose
+// modal, etc.). Auth and networking are owned by the runner — variants stay
+// pure game.
+
+/**
+ * @typedef {Object} GameVariantMeta
+ * @property {string} title
+ * @property {'easy' | 'medium' | 'hard'} difficulty
+ * @property {string} tagline
+ */
+
+/**
+ * @typedef {Object} GameVariant
+ * @property {string} key
+ * @property {new (...args: any[]) => import('phaser').Scene} Scene
+ * @property {import('svelte').Component<any>} Hud
+ * @property {GameVariantMeta} meta
+ */
+
+export {};
diff --git a/client/web/src/games/types.ts b/client/web/src/games/types.ts
deleted file mode 100644
index 2456567..0000000
--- a/client/web/src/games/types.ts
+++ /dev/null
@@ -1,21 +0,0 @@
-// GameVariant is the contract for a pluggable -dle game. Each variant
-// supplies a Phaser scene class (canvas-side rendering + game logic) plus a
-// Svelte component that renders the HUD overlay (attempt counter, win/lose
-// modal, etc.). Auth and networking are owned by the runner — variants stay
-// pure game.
-
-import type { Scene } from 'phaser';
-import type { Component } from 'svelte';
-
-export interface GameVariantMeta {
-  title: string;
-  difficulty: 'easy' | 'medium' | 'hard';
-  tagline: string;
-}
-
-export interface GameVariant {
-  key: string;
-  Scene: new (...args: any[]) => Scene;
-  Hud: Component<any>;
-  meta: GameVariantMeta;
-}
diff --git a/client/web/src/games/wordle/WordleHud.svelte b/client/web/src/games/wordle/WordleHud.svelte
index ae0a900..b6b849d 100644
--- a/client/web/src/games/wordle/WordleHud.svelte
+++ b/client/web/src/games/wordle/WordleHud.svelte
@@ -1,15 +1,20 @@
-<script lang="ts">
+<script>
   import { onMount, onDestroy } from 'svelte';
-  import { onAttemptComplete, onGuessSubmitted, type AttemptCompletePayload } from '../runner/eventbus-helpers';
+  import { onAttemptComplete, onGuessSubmitted } from '../runner/eventbus-helpers';
   import { MAX_GUESSES } from './scoring';
 
-  let { date = '', onDone = (_p: AttemptCompletePayload) => {} } = $props();
+  /** @typedef {import('../runner/eventbus-helpers').AttemptCompletePayload} AttemptCompletePayload */
+
+  /** @type {{ date?: string, onDone?: (p: AttemptCompletePayload) => void }} */
+  let { date = '', onDone = (_p) => {} } = $props();
 
   let guessesUsed = $state(0);
-  let result = $state<AttemptCompletePayload | null>(null);
+  let result = $state(/** @type {AttemptCompletePayload | null} */ (null));
 
-  let unsubGuess: (() => void) | null = null;
-  let unsubComplete: (() => void) | null = null;
+  /** @type {(() => void) | null} */
+  let unsubGuess = null;
+  /** @type {(() => void) | null} */
+  let unsubComplete = null;
 
   onMount(() => {
     unsubGuess = onGuessSubmitted(() => {
@@ -26,7 +31,8 @@
     unsubComplete?.();
   });
 
-  function shareText(): string {
+  /** @returns {string} */
+  function shareText() {
     if (!result) return '';
     const grid = result.evaluations
       .map((row) => row.map((e) => (e === 'hit' ? '🟩' : e === 'present' ? '🟨' : '⬛')).join(''))
diff --git a/client/web/src/games/wordle/WordleScene.ts b/client/web/src/games/wordle/WordleScene.js
similarity index 82%
rename from client/web/src/games/wordle/WordleScene.ts
rename to client/web/src/games/wordle/WordleScene.js
index 28a343b..9cfa8b6 100644
--- a/client/web/src/games/wordle/WordleScene.ts
+++ b/client/web/src/games/wordle/WordleScene.js
@@ -8,10 +8,11 @@ import {
   evaluateGuess,
   isWin,
   MAX_GUESSES,
-  type LetterEval,
 } from './scoring';
 import { emitAttemptComplete, emitGuessSubmitted } from '../runner/eventbus-helpers';
 
+/** @typedef {import('./scoring').LetterEval} LetterEval */
+
 const COLORS = {
   hit: 0x6aaa64,
   present: 0xc9b458,
@@ -22,34 +23,47 @@ const COLORS = {
   textInverse: 0xffffff,
 };
 
-const HEX = (n: number) => '#' + n.toString(16).padStart(6, '0');
+/** @param {number} n */
+const HEX = (n) => '#' + n.toString(16).padStart(6, '0');
 
-interface WordleInitData {
-  solution: string;
-  length: number;
-  resumeGuesses?: string[];
-}
+/**
+ * @typedef {Object} WordleInitData
+ * @property {string} solution
+ * @property {number} length
+ * @property {string[]} [resumeGuesses]
+ */
 
 const KEYBOARD_ROWS = ['QWERTYUIOP', 'ASDFGHJKL', '↵ZXCVBNM⌫'];
 
 export class WordleScene extends Scene {
-  private solution = '';
-  private wordLength = 5;
-  private guesses: string[] = [];
-  private evaluations: LetterEval[][] = [];
-  private currentInput = '';
-  private finished = false;
+  /** @type {string} */
+  solution = '';
+  /** @type {number} */
+  wordLength = 5;
+  /** @type {string[]} */
+  guesses = [];
+  /** @type {LetterEval[][]} */
+  evaluations = [];
+  /** @type {string} */
+  currentInput = '';
+  /** @type {boolean} */
+  finished = false;
 
-  private tiles: Phaser.GameObjects.Rectangle[][] = [];
-  private tileLabels: Phaser.GameObjects.Text[][] = [];
-  private keyButtons = new Map<string, { rect: Phaser.GameObjects.Rectangle; label: Phaser.GameObjects.Text }>();
-  private statusText?: Phaser.GameObjects.Text;
+  /** @type {Phaser.GameObjects.Rectangle[][]} */
+  tiles = [];
+  /** @type {Phaser.GameObjects.Text[][]} */
+  tileLabels = [];
+  /** @type {Map<string, { rect: Phaser.GameObjects.Rectangle, label: Phaser.GameObjects.Text }>} */
+  keyButtons = new Map();
+  /** @type {Phaser.GameObjects.Text | undefined} */
+  statusText;
 
   constructor() {
     super('Wordle');
   }
 
-  init(data: WordleInitData) {
+  /** @param {WordleInitData} data */
+  init(data) {
     this.solution = (data.solution || '').toUpperCase();
     this.wordLength = data.length || this.solution.length || 5;
     this.guesses = [];
@@ -98,7 +112,7 @@ export class WordleScene extends Scene {
     EventBus.emit('current-scene-ready', this);
   }
 
-  private buildGrid() {
+  buildGrid() {
     const tileSize = 56;
     const gap = 6;
     const rows = MAX_GUESSES;
@@ -127,7 +141,7 @@ export class WordleScene extends Scene {
     }
   }
 
-  private buildKeyboard() {
+  buildKeyboard() {
     const keyW = 36;
     const keyH = 48;
     const gap = 4;
@@ -155,21 +169,24 @@ export class WordleScene extends Scene {
     }
   }
 
-  private handleKeyDown(ev: KeyboardEvent) {
+  /** @param {KeyboardEvent} ev */
+  handleKeyDown(ev) {
     if (this.finished) return;
     if (ev.key === 'Enter') this.submitGuess();
     else if (ev.key === 'Backspace') this.popLetter();
     else if (/^[a-zA-Z]$/.test(ev.key)) this.pushLetter(ev.key.toUpperCase());
   }
 
-  private handleVirtualKey(k: string) {
+  /** @param {string} k */
+  handleVirtualKey(k) {
     if (this.finished) return;
     if (k === '↵') this.submitGuess();
     else if (k === '⌫') this.popLetter();
     else this.pushLetter(k);
   }
 
-  private pushLetter(c: string) {
+  /** @param {string} c */
+  pushLetter(c) {
     if (this.currentInput.length >= this.wordLength) return;
     this.currentInput += c;
     const row = this.guesses.length;
@@ -185,7 +202,7 @@ export class WordleScene extends Scene {
     }
   }
 
-  private popLetter() {
+  popLetter() {
     if (this.currentInput.length === 0) return;
     const row = this.guesses.length;
     const col = this.currentInput.length - 1;
@@ -193,7 +210,7 @@ export class WordleScene extends Scene {
     if (this.tileLabels[row]?.[col]) this.tileLabels[row][col].setText('');
   }
 
-  private submitGuess() {
+  submitGuess() {
     if (this.currentInput.length !== this.wordLength) {
       this.showStatus(`Word must be ${this.wordLength} letters`);
       this.shakeRow(this.guesses.length);
@@ -223,7 +240,12 @@ export class WordleScene extends Scene {
     });
   }
 
-  private flipRow(row: number, evaluation: LetterEval[], done: () => void) {
+  /**
+   * @param {number} row
+   * @param {LetterEval[]} evaluation
+   * @param {() => void} done
+   */
+  flipRow(row, evaluation, done) {
     let pending = this.wordLength;
     for (let col = 0; col < this.wordLength; col++) {
       this.tweens.add({
@@ -248,16 +270,23 @@ export class WordleScene extends Scene {
     }
   }
 
-  private applyTileColor(row: number, col: number, ev: LetterEval) {
+  /**
+   * @param {number} row
+   * @param {number} col
+   * @param {LetterEval} ev
+   */
+  applyTileColor(row, col, ev) {
     this.tiles[row][col].setFillStyle(COLORS[ev]);
     this.tiles[row][col].setStrokeStyle(0);
     this.tileLabels[row][col].setColor(HEX(COLORS.textInverse));
   }
 
-  private refreshKeyboardColors() {
+  refreshKeyboardColors() {
     // Best-known eval per letter: hit > present > miss.
-    const rank: Record<LetterEval, number> = { hit: 3, present: 2, miss: 1 };
-    const best: Record<string, LetterEval> = {};
+    /** @type {Record<LetterEval, number>} */
+    const rank = { hit: 3, present: 2, miss: 1 };
+    /** @type {Record<string, LetterEval>} */
+    const best = {};
     for (let i = 0; i < this.guesses.length; i++) {
       for (let j = 0; j < this.wordLength; j++) {
         const c = this.guesses[i][j];
@@ -274,7 +303,8 @@ export class WordleScene extends Scene {
     }
   }
 
-  private shakeRow(row: number) {
+  /** @param {number} row */
+  shakeRow(row) {
     if (!this.tiles[row]) return;
     for (const t of this.tiles[row]) {
       this.tweens.add({
@@ -287,7 +317,8 @@ export class WordleScene extends Scene {
     }
   }
 
-  private showStatus(msg: string) {
+  /** @param {string} msg */
+  showStatus(msg) {
     this.statusText?.setText(msg);
   }
 }
diff --git a/client/web/src/games/wordle/index.ts b/client/web/src/games/wordle/index.js
similarity index 72%
rename from client/web/src/games/wordle/index.ts
rename to client/web/src/games/wordle/index.js
index ece230d..9166dad 100644
--- a/client/web/src/games/wordle/index.ts
+++ b/client/web/src/games/wordle/index.js
@@ -1,8 +1,10 @@
-import type { GameVariant } from '../types';
 import { WordleScene } from './WordleScene';
 import WordleHud from './WordleHud.svelte';
 
-const variant: GameVariant = {
+/** @typedef {import('../types').GameVariant} GameVariant */
+
+/** @type {GameVariant} */
+const variant = {
   key: 'wordle',
   Scene: WordleScene,
   Hud: WordleHud,
diff --git a/client/web/src/games/wordle/scoring.ts b/client/web/src/games/wordle/scoring.js
similarity index 74%
rename from client/web/src/games/wordle/scoring.ts
rename to client/web/src/games/wordle/scoring.js
index 9e87c4b..8baf4d6 100644
--- a/client/web/src/games/wordle/scoring.ts
+++ b/client/web/src/games/wordle/scoring.js
@@ -2,7 +2,7 @@
 // per-guess UX feedback. Final score reverification lives in
 // server/internal/api/scoring.go.
 
-export type LetterEval = 'hit' | 'present' | 'miss';
+/** @typedef {'hit' | 'present' | 'miss'} LetterEval */
 
 export const MAX_GUESSES = 6;
 
@@ -11,14 +11,21 @@ export const MAX_GUESSES = 6;
 // only against remaining (non-green) target letters. So `LLAMA` against
 // solution `ALLOY` yields [present, hit, present, miss, miss], not
 // [present, hit, present, present, miss].
-export function evaluateGuess(guess: string, solution: string): LetterEval[] {
+/**
+ * @param {string} guess
+ * @param {string} solution
+ * @returns {LetterEval[]}
+ */
+export function evaluateGuess(guess, solution) {
   const g = guess.toUpperCase();
   const s = solution.toUpperCase();
   if (g.length !== s.length) {
     throw new Error(`guess length ${g.length} != solution length ${s.length}`);
   }
-  const out: LetterEval[] = new Array(g.length).fill('miss');
-  const remaining: Record<string, number> = {};
+  /** @type {LetterEval[]} */
+  const out = new Array(g.length).fill('miss');
+  /** @type {Record<string, number>} */
+  const remaining = {};
 
   for (let i = 0; i < g.length; i++) {
     if (g[i] === s[i]) {
@@ -38,13 +45,22 @@ export function evaluateGuess(guess: string, solution: string): LetterEval[] {
   return out;
 }
 
-export function isWin(evaluation: LetterEval[]): boolean {
+/**
+ * @param {LetterEval[]} evaluation
+ * @returns {boolean}
+ */
+export function isWin(evaluation) {
   return evaluation.length > 0 && evaluation.every((e) => e === 'hit');
 }
 
 // Mirror the server's score formula (server/internal/api/scoring.go) so the
 // HUD can show a preview that matches the canonical leaderboard score.
-export function score(guesses: string[], solution: string): { score: number; won: boolean } {
+/**
+ * @param {string[]} guesses
+ * @param {string} solution
+ * @returns {{ score: number, won: boolean }}
+ */
+export function score(guesses, solution) {
   const SCORE_FIRST_SOLVE = 100;
   const SCORE_PER_GUESS = 15;
   const target = solution.trim().toUpperCase();
diff --git a/client/web/src/games/wordle/scoring.test.ts b/client/web/src/games/wordle/scoring.test.js
similarity index 100%
rename from client/web/src/games/wordle/scoring.test.ts
rename to client/web/src/games/wordle/scoring.test.js
diff --git a/client/web/src/lib/index.ts b/client/web/src/lib/index.js
similarity index 100%
rename from client/web/src/lib/index.ts
rename to client/web/src/lib/index.js
diff --git a/client/web/src/net/proto.ts b/client/web/src/net/proto.js
similarity index 64%
rename from client/web/src/net/proto.ts
rename to client/web/src/net/proto.js
index 3ab9522..d9a38d9 100644
--- a/client/web/src/net/proto.ts
+++ b/client/web/src/net/proto.js
@@ -78,9 +78,10 @@ message MatchEnd {
 }
 `;
 
-const root: Root = parse(SCHEMA, { keepCase: false }).root;
+/** @type {Root} */
+const root = parse(SCHEMA, { keepCase: false }).root;
 
-export const MessageType = {
+export const MessageType = /** @type {const} */ ({
   UNSPECIFIED: 0,
   PING: 1,
   PONG: 2,
@@ -90,9 +91,9 @@ export const MessageType = {
   JOIN_ROOM_ACK: 6,
   TURN: 7,
   MATCH_END: 8
-} as const;
+});
 
-export type MessageTypeValue = (typeof MessageType)[keyof typeof MessageType];
+/** @typedef {(typeof MessageType)[keyof typeof MessageType]} MessageTypeValue */
 
 const Envelope = root.lookupType('dleague.v1.Envelope');
 const AuthRequest = root.lookupType('dleague.v1.AuthRequest');
@@ -105,20 +106,35 @@ const Turn = root.lookupType('dleague.v1.Turn');
 const MatchEnd = root.lookupType('dleague.v1.MatchEnd');
 
 // Encoded envelope ready for `ws.send`.
-export function encodeEnvelope(typeNum: MessageTypeValue, requestId: string, innerType: Type, body: object): Uint8Array {
+/**
+ * @param {MessageTypeValue} typeNum
+ * @param {string} requestId
+ * @param {Type} innerType
+ * @param {object} body
+ * @returns {Uint8Array}
+ */
+export function encodeEnvelope(typeNum, requestId, innerType, body) {
   const payload = innerType.encode(innerType.create(body)).finish();
   return Envelope.encode(Envelope.create({ type: typeNum, requestId, payload })).finish();
 }
 
 // Decoded envelope + the inner body, looked up by the envelope's `type`.
-export function decodeEnvelope(buf: Uint8Array): { type: MessageTypeValue; requestId: string; body: any } {
-  const env = Envelope.decode(buf) as any;
+/**
+ * @param {Uint8Array} buf
+ * @returns {{ type: MessageTypeValue, requestId: string, body: any }}
+ */
+export function decodeEnvelope(buf) {
+  const env = /** @type {any} */ (Envelope.decode(buf));
   const inner = innerTypeFor(env.type);
   const body = inner ? inner.decode(env.payload) : null;
-  return { type: env.type as MessageTypeValue, requestId: env.requestId, body };
+  return { type: /** @type {MessageTypeValue} */ (env.type), requestId: env.requestId, body };
 }
 
-function innerTypeFor(t: number): Type | null {
+/**
+ * @param {number} t
+ * @returns {Type | null}
+ */
+function innerTypeFor(t) {
   switch (t) {
     case MessageType.PING: return Ping;
     case MessageType.PONG: return Pong;
@@ -134,24 +150,49 @@ function innerTypeFor(t: number): Type | null {
 
 // Convenience: typed builders that avoid stringly-typed call sites.
 export const Build = {
-  auth: (idToken: string, requestId = 'auth') =>
+  /**
+   * @param {string} idToken
+   * @param {string} [requestId]
+   */
+  auth: (idToken, requestId = 'auth') =>
     encodeEnvelope(MessageType.AUTH_REQUEST, requestId, AuthRequest, { idToken, version: 1 }),
-  ping: (clientUnixMs: number, requestId = 'ping') =>
+  /**
+   * @param {number} clientUnixMs
+   * @param {string} [requestId]
+   */
+  ping: (clientUnixMs, requestId = 'ping') =>
     encodeEnvelope(MessageType.PING, requestId, Ping, { clientUnixMs }),
-  joinRoom: (matchId: string, requestId = 'join') =>
+  /**
+   * @param {string} matchId
+   * @param {string} [requestId]
+   */
+  joinRoom: (matchId, requestId = 'join') =>
     encodeEnvelope(MessageType.JOIN_ROOM, requestId, JoinRoom, { matchId }),
-  turn: (matchId: string, turnIndex: number, payload: Uint8Array, requestId = 'turn') =>
+  /**
+   * @param {string} matchId
+   * @param {number} turnIndex
+   * @param {Uint8Array} payload
+   * @param {string} [requestId]
+   */
+  turn: (matchId, turnIndex, payload, requestId = 'turn') =>
     encodeEnvelope(MessageType.TURN, requestId, Turn, { matchId, turnIndex, payload }),
-  matchEnd: (matchId: string, winnerUid: string, scoreP1: number, scoreP2: number, requestId = 'end') =>
+  /**
+   * @param {string} matchId
+   * @param {string} winnerUid
+   * @param {number} scoreP1
+   * @param {number} scoreP2
+   * @param {string} [requestId]
+   */
+  matchEnd: (matchId, winnerUid, scoreP1, scoreP2, requestId = 'end') =>
     encodeEnvelope(MessageType.MATCH_END, requestId, MatchEnd, { matchId, winnerUid, scoreP1, scoreP2 })
 };
 
 // Re-export so consumers can hold typed bodies without re-importing protobufjs.
-export type AuthResponseBody = { ok: boolean; uid: string; error: string };
-export type JoinRoomAckBody = { ok: boolean; matchId: string; role: string; opponentUid: string; error: string };
-export type PongBody = { clientUnixMs: number; serverUnixMs: number };
-export type TurnBody = { matchId: string; turnIndex: number; payload: Uint8Array };
-export type MatchEndBody = { matchId: string; winnerUid: string; scoreP1: number; scoreP2: number };
+/** @typedef {{ ok: boolean, uid: string, error: string }} AuthResponseBody */
+/** @typedef {{ ok: boolean, matchId: string, role: string, opponentUid: string, error: string }} JoinRoomAckBody */
+/** @typedef {{ clientUnixMs: number, serverUnixMs: number }} PongBody */
+/** @typedef {{ matchId: string, turnIndex: number, payload: Uint8Array }} TurnBody */
+/** @typedef {{ matchId: string, winnerUid: string, scoreP1: number, scoreP2: number }} MatchEndBody */
 
 // Silence unused warnings for symbols re-exported as types only above.
 export { Reader, Writer };
diff --git a/client/web/src/net/ws.ts b/client/web/src/net/ws.js
similarity index 64%
rename from client/web/src/net/ws.ts
rename to client/web/src/net/ws.js
index 0916869..7c4afe9 100644
--- a/client/web/src/net/ws.ts
+++ b/client/web/src/net/ws.js
@@ -3,31 +3,45 @@
 // to subscribers. Auto-reconnect refreshes the Firebase ID token to dodge
 // the 1h expiry.
 
-import { Build, MessageType, decodeEnvelope, type AuthResponseBody, type MessageTypeValue } from './proto';
+import { Build, MessageType, decodeEnvelope } from './proto';
 import { auth } from '../auth/auth.svelte';
 
-type Listener = (body: any, requestId: string) => void;
+/** @typedef {import('./proto').AuthResponseBody} AuthResponseBody */
+/** @typedef {import('./proto').MessageTypeValue} MessageTypeValue */
 
-export type ConnState = 'idle' | 'connecting' | 'authenticating' | 'connected' | 'closed';
+/** @typedef {(body: any, requestId: string) => void} Listener */
+
+/** @typedef {'idle' | 'connecting' | 'authenticating' | 'connected' | 'closed'} ConnState */
 
 const reconnectBackoffMs = [500, 1000, 2000, 4000, 8000];
 
 export class WsClient {
-  private url: string;
-  private ws: WebSocket | null = null;
-  private listeners = new Map<MessageTypeValue, Set<Listener>>();
-  private reconnectAttempts = 0;
-  private intentionalClose = false;
-
-  state = $state<ConnState>('idle');
-  uid = $state<string | null>(null);
-  lastError = $state<string | null>(null);
-
-  constructor(url: string) {
+  /** @type {string} */
+  url;
+  /** @type {WebSocket | null} */
+  ws = null;
+  /** @type {Map<MessageTypeValue, Set<Listener>>} */
+  listeners = new Map();
+  /** @type {number} */
+  reconnectAttempts = 0;
+  /** @type {boolean} */
+  intentionalClose = false;
+
+  state = $state(/** @type {ConnState} */ ('idle'));
+  uid = $state(/** @type {string | null} */ (null));
+  lastError = $state(/** @type {string | null} */ (null));
+
+  /** @param {string} url */
+  constructor(url) {
     this.url = url;
   }
 
-  on(type: MessageTypeValue, listener: Listener): () => void {
+  /**
+   * @param {MessageTypeValue} type
+   * @param {Listener} listener
+   * @returns {() => void}
+   */
+  on(type, listener) {
     let set = this.listeners.get(type);
     if (!set) {
       set = new Set();
@@ -37,15 +51,17 @@ export class WsClient {
     return () => set?.delete(listener);
   }
 
-  send(buf: Uint8Array) {
+  /** @param {Uint8Array} buf */
+  send(buf) {
     if (this.ws?.readyState === WebSocket.OPEN) {
-      this.ws.send(buf);
+      this.ws.send(/** @type {ArrayBufferView<ArrayBuffer>} */ (buf));
     }
   }
 
   // Open + authenticate. Resolves on AUTH_RESPONSE{ok}, rejects on close
   // or AUTH_RESPONSE{ok:false}.
-  async connect(): Promise<void> {
+  /** @returns {Promise<void>} */
+  async connect() {
     this.intentionalClose = false;
     const token = await auth.getIdToken(false);
     if (!token) throw new Error('not signed in');
@@ -58,14 +74,14 @@ export class WsClient {
 
       ws.onopen = () => {
         this.state = 'authenticating';
-        ws.send(Build.auth(token));
+        ws.send(/** @type {ArrayBufferView<ArrayBuffer>} */ (Build.auth(token)));
       };
 
       ws.onmessage = (ev) => {
-        const buf = new Uint8Array(ev.data as ArrayBuffer);
+        const buf = new Uint8Array(/** @type {ArrayBuffer} */ (ev.data));
         const env = decodeEnvelope(buf);
         if (this.state === 'authenticating' && env.type === MessageType.AUTH_RESPONSE) {
-          const ack = env.body as AuthResponseBody;
+          const ack = /** @type {AuthResponseBody} */ (env.body);
           if (!ack.ok) {
             this.lastError = ack.error || 'auth rejected';
             this.state = 'closed';
@@ -94,7 +110,7 @@ export class WsClient {
         if (this.intentionalClose) return;
         if (wasConnected) {
           this.scheduleReconnect();
-        } else if (this.state === 'connecting') {
+        } else if (/** @type {any} */ (this.state) === 'connecting') {
           // Initial connect failed before resolving.
           reject(new Error('connect failed'));
         }
@@ -107,7 +123,7 @@ export class WsClient {
     this.ws?.close();
   }
 
-  private scheduleReconnect() {
+  scheduleReconnect() {
     const delay = reconnectBackoffMs[Math.min(this.reconnectAttempts, reconnectBackoffMs.length - 1)];
     this.reconnectAttempts += 1;
     setTimeout(() => {
@@ -118,8 +134,9 @@ export class WsClient {
 }
 
 // Default factory wires the URL from env or relative `/ws`.
-export function defaultWsUrl(): string {
-  const env = import.meta.env.VITE_WS_URL as string | undefined;
+/** @returns {string} */
+export function defaultWsUrl() {
+  const env = /** @type {string | undefined} */ (import.meta.env.VITE_WS_URL);
   if (env) return env;
   const proto = location.protocol === 'https:' ? 'wss:' : 'ws:';
   return `${proto}//${location.host}/ws`;
diff --git a/client/web/src/routes/+page.svelte b/client/web/src/routes/+page.svelte
index a5fa640..3c6e1b1 100644
--- a/client/web/src/routes/+page.svelte
+++ b/client/web/src/routes/+page.svelte
@@ -1,4 +1,4 @@
-<script lang="ts">
+<script>
   import { auth } from '../auth/auth.svelte';
   import SignIn from '../components/SignIn.svelte';
   import Lobby from '../components/Lobby.svelte';
diff --git a/client/web/tsconfig.app.json b/client/web/tsconfig.app.json
deleted file mode 100644
index 55a4b16..0000000
--- a/client/web/tsconfig.app.json
+++ /dev/null
@@ -1,24 +0,0 @@
-{
-    "extends": "@tsconfig/svelte/tsconfig.json",
-    "compilerOptions": {
-        "target": "ESNext",
-        "useDefineForClassFields": true,
-        "module": "ESNext",
-        "resolveJsonModule": true,
-        /**
-     * Typecheck JS in `.svelte` and `.js` files by default.
-     * Disable checkJs if you'd like to use dynamic types in JS.
-     * Note that setting allowJs false does not prevent the use
-     * of JS in `.svelte` files.
-     */
-        "allowJs": true,
-        "checkJs": true,
-        "isolatedModules": true,
-        "moduleDetection": "force"
-    },
-    "include": [
-        "src/**/*.ts",
-        "src/**/*.js",
-        "src/**/*.svelte"
-    ]
-}
\ No newline at end of file
diff --git a/client/web/tsconfig.json b/client/web/tsconfig.json
deleted file mode 100644
index 5666d7b..0000000
--- a/client/web/tsconfig.json
+++ /dev/null
@@ -1,11 +0,0 @@
-{
-    "files": [],
-    "references": [
-        {
-            "path": "./tsconfig.app.json"
-        },
-        {
-            "path": "./tsconfig.node.json"
-        }
-    ]
-}
\ No newline at end of file
diff --git a/docs/code-standards.md b/docs/code-standards.md
index 6318091..7ce3145 100644
--- a/docs/code-standards.md
+++ b/docs/code-standards.md
@@ -21,10 +21,11 @@ Patterns and constraints enforced in the dleague codebase. Updated for the Mongo
 ### Frontend (Svelte 5 + Phaser 4) Files
 
 - **Pluggable -dle variants** under `client/web/src/games/<name>/` — each variant exports a `GameVariant` (Scene class + Hud component).
-- **Phaser scenes** in PascalCase (`WordleScene.ts`) — matches Phaser ecosystem.
+- **Phaser scenes** in PascalCase (`WordleScene.js`) — matches Phaser ecosystem.
 - **Svelte components** in PascalCase (`WordleHud.svelte`, `Lobby.svelte`).
-- **Pure utilities** in lowercase (`scoring.ts`, `registry.ts`, `eventbus-helpers.ts`).
-- **Shared events** routed through `game/EventBus.ts` — typed wrappers in `games/runner/eventbus-helpers.ts`.
+- **Pure utilities** in lowercase (`scoring.js`, `registry.js`, `eventbus-helpers.js`).
+- **Shared events** routed through `game/EventBus.js` — JSDoc-typed wrappers in `games/runner/eventbus-helpers.js`.
+- Plain JavaScript + JSDoc throughout (no TypeScript) — checked via `npm run check` against `client/web/jsconfig.json`.
 
 ### Directory Structure
 
@@ -36,8 +37,8 @@ dleague/
 │       ├── components/           # Svelte UI: Lobby, SignIn, BetaBanner
 │       ├── game/                 # Phaser game shell + EventBus
 │       ├── games/                # Pluggable -dle variants (Phase 8)
-│       │   ├── types.ts          # GameVariant interface
-│       │   ├── registry.ts       # lazy variant loader
+│       │   ├── types.js          # GameVariant JSDoc typedef
+│       │   ├── registry.js       # lazy variant loader
 │       │   ├── runner/           # GameRunner + EventBus helpers
 │       │   └── wordle/           # First concrete variant
 │       └── net/                  # WS client + protobuf
@@ -92,24 +93,25 @@ dleague/
 
 ### Pluggable variants (Phase 8)
 
-```typescript
-interface GameVariant {
-  key: string;                    // 'wordle', 'sumdle', etc.
-  Scene: typeof Phaser.Scene;
-  Hud: typeof SvelteComponent;
-  meta: { title: string; difficulty: 'easy'|'medium'|'hard'; tagline: string };
-}
+```js
+/**
+ * @typedef {Object} GameVariant
+ * @property {string} key                    // 'wordle', 'sumdle', etc.
+ * @property {typeof Phaser.Scene} Scene
+ * @property {typeof SvelteComponent} Hud
+ * @property {{ title: string, difficulty: 'easy'|'medium'|'hard', tagline: string }} meta
+ */
 ```
 
-- Variants register in `client/web/src/games/registry.ts` as lazy imports.
+- Variants register in `client/web/src/games/registry.js` as lazy imports.
 - `GameRunner.svelte` fetches puzzle + resume state, mounts the scene, mounts the HUD, posts the final attempt.
-- Adding a new variant = copy `wordle/` folder + register in `registry.ts`.
+- Adding a new variant = copy `wordle/` folder + register in `registry.js`.
 
 ## Code Quality Rules
 
 ### Testing
 
-- **Unit tests** in `*_test.go` (Go) / `*.test.ts` (TypeScript via vitest).
+- **Unit tests** in `*_test.go` (Go) / `*.test.js` (JSDoc-typed JavaScript via vitest).
 - **Coverage target:** >70% on game logic, store impls, auth, API handlers.
 - **Memstore** validates the upper-layer test surface; live MongoDB tests are gated by env var `MONGODB_TEST_URI`.
 
@@ -155,8 +157,8 @@ era. Re-enable for Go 1.25.5 + Svelte/Phaser + Atlas, running:
 | Go constants | UPPER_SNAKE | `MAX_GUESSES`, `MaxGuesses` (mixed; PascalCase preferred for new) |
 | Protobuf messages | PascalCase | `AuthRequest`, `Envelope` |
 | Protobuf fields | snake_case | `message_type`, `request_id` |
-| TS modules (utility) | camelCase / kebab-case | `scoring.ts`, `eventbus-helpers.ts` |
-| TS classes & components | PascalCase | `WordleScene`, `WordleHud.svelte` |
+| JS modules (utility) | camelCase / kebab-case | `scoring.js`, `eventbus-helpers.js` |
+| JS classes & components | PascalCase | `WordleScene`, `WordleHud.svelte` |
 
 ## Dependencies
 
diff --git a/docs/codebase-summary.md b/docs/codebase-summary.md
index 2efb1cf..9bdd776 100644
--- a/docs/codebase-summary.md
+++ b/docs/codebase-summary.md
@@ -28,31 +28,31 @@ src/
 ├── app.html, app.d.ts        # SvelteKit shell
 ├── routes/                   # SvelteKit pages (single page: +page.svelte)
 ├── auth/
-│   ├── firebase.ts           # Firebase JS SDK config + helpers
-│   └── auth.svelte.ts        # Rune-backed singleton auth state ($state)
+│   ├── firebase.js           # Firebase JS SDK config + helpers
+│   └── auth.svelte.js        # Rune-backed singleton auth state ($state)
 ├── components/
 │   ├── BetaBanner.svelte     # "Beta — data may reset" banner
 │   ├── SignIn.svelte         # Email + Google + Anonymous sign-in
 │   └── Lobby.svelte          # Authenticated landing; mounts GameRunner
 ├── game/
-│   ├── EventBus.ts           # Shared Phaser.Events.EventEmitter
-│   ├── main.ts               # Legacy Phaser bootstrap (template scenes)
+│   ├── EventBus.js           # Shared Phaser.Events.EventEmitter
+│   ├── main.js               # Legacy Phaser bootstrap (template scenes)
 │   └── scenes/               # Boot, Preloader, MainMenu, Game, GameOver
 ├── games/                    # Pluggable -dle variants
-│   ├── types.ts              # GameVariant interface
-│   ├── registry.ts           # Lazy variant loader
+│   ├── types.js              # GameVariant JSDoc typedef
+│   ├── registry.js           # Lazy variant loader
 │   ├── runner/
 │   │   ├── GameRunner.svelte # Generic shell: fetch puzzle → mount scene + HUD → POST attempt
-│   │   └── eventbus-helpers.ts
+│   │   └── eventbus-helpers.js
 │   └── wordle/               # First concrete variant
-│       ├── WordleScene.ts    # Phaser scene: tile grid, keyboard, animations
+│       ├── WordleScene.js    # Phaser scene: tile grid, keyboard, animations
 │       ├── WordleHud.svelte  # Attempt counter, win/lose modal, share
-│       ├── scoring.ts        # Pure scoring + per-guess evaluation
-│       ├── scoring.test.ts   # vitest unit tests
-│       └── index.ts          # Default-exports the GameVariant
+│       ├── scoring.js        # Pure scoring + per-guess evaluation
+│       ├── scoring.test.js   # vitest unit tests
+│       └── index.js          # Default-exports the GameVariant
 ├── net/
-│   ├── proto.ts              # Envelope encode/decode helpers
-│   └── ws.ts                 # WsClient with AUTH handshake + auto-reconnect
+│   ├── proto.js              # Envelope encode/decode helpers
+│   └── ws.js                 # WsClient with AUTH handshake + auto-reconnect
 └── PhaserGame.svelte         # (Legacy) component for the template scenes
 ```
 
diff --git a/docs/system-architecture.md b/docs/system-architecture.md
index c9a15d3..1c21675 100644
--- a/docs/system-architecture.md
+++ b/docs/system-architecture.md
@@ -9,11 +9,11 @@
 │  ┌────────────────┐    ┌────────────────────────────────┐  │
 │  │ Svelte shell   │    │ Phaser 4 canvas (per-variant)  │  │
 │  │ Lobby / SignIn │◄──►│  WordleScene, …                │  │
-│  │ HUD overlays   │    │  via game/EventBus.ts          │  │
+│  │ HUD overlays   │    │  via game/EventBus.js          │  │
 │  └────────────────┘    └────────────────────────────────┘  │
 │         │                          │                        │
 │  ┌──────▼──────┐           ┌───────▼────────┐              │
-│  │ Firebase JS │           │ ws.ts client + │              │
+│  │ Firebase JS │           │ ws.js client + │              │
 │  │ SDK (Auth)  │           │ /api fetch     │              │
 │  └─────────────┘           └────────────────┘              │
 └─────────│───────────────────────────│───────────────────────┘
@@ -85,7 +85,7 @@ Lobby → "Play today's puzzle" → GameRunner.svelte
   → GET /api/v1/puzzles/me/today (Bearer; returns puzzle.word)
   → GET /api/v1/attempts/me/{date} (resume, 404 if none)
   → Phaser game starts WordleScene with solution + resume
-  → User makes guesses; scoring.ts evaluates client-side for UX
+  → User makes guesses; scoring.js evaluates client-side for UX
   → On win/lose: EventBus emits attempt-complete
   → POST /api/v1/attempts {date, guesses}
   → Server re-scores via api.Score; UpsertAttempt + SubmitScore