Restore the saved language on retry

Retrying a coding attempt currently resets its language to Python, which
can hide the mismatch until starter code or tests appear. Preserve the
saved language only when the problem offers it, retaining Python as the
fallback.

Author: Corn0722

tests/browser/candidate-cases.test.js

@@ -656,9 +656,10 @@ test("C stays unavailable until a function-style judge has loaded", async (t) =>
       let releaseJudge = () => {};
       try {
         releaseJudge = await holdJudge(page);
-        await page.goto(`${enabled.base}/interview.html?problem=${problem}`, {
-          waitUntil: "domcontentloaded",
-        });
+        await page.goto(
+          `${enabled.base}/interview.html?problem=${problem}&language=c`,
+          { waitUntil: "domcontentloaded" },
+        );
         const c = page.locator('[data-language="c"]');
         await page.waitForFunction(
           () => document.querySelector('[data-language="c"]').disabled,
@@ -671,12 +672,20 @@ test("C stays unavailable until a function-style judge has loaded", async (t) =>
         releaseJudge();
         await candidateCasesReady(page);
         assert.equal(await c.isDisabled(), classStyle);
-        if (classStyle)
+        if (classStyle) {
           assert.match(
             await c.getAttribute("title"),
             /only builds function judges/,
           );
-        else assert.equal(await clickSelects(c), true);
+          assert.match(
+            await page
+              .locator('[data-language="python"]')
+              .getAttribute("class"),
+            /\bselected\b/,
+          );
+        } else {
+          assert.match(await c.getAttribute("class"), /\bselected\b/);
+        }
         for (const language of ["python", "javascript", "cpp", "java"]) {
           assert.equal(
             await page.locator(`[data-language="${language}"]`).isDisabled(),

tests/browser/editor-pipeline.test.js

@@ -95,6 +95,36 @@ const setCode = (page, value, start = value.length, end = start) =>
     { value, start, end },
   );
 
+test("the interview restores an offered language from the URL", async (t) => {
+  const ctx = await editorPage(t, { params: { language: "javascript" } });
+  if (!ctx) return;
+  const { page, errors } = ctx;
+  try {
+    assert.match(
+      await page.locator('[data-language="javascript"]').getAttribute("class"),
+      /\bselected\b/,
+    );
+    assert.deepEqual(errors, []);
+  } finally {
+    await page.close();
+  }
+});
+
+test("the interview keeps Python for an unknown saved language", async (t) => {
+  const ctx = await editorPage(t, { params: { language: "unknown" } });
+  if (!ctx) return;
+  const { page, errors } = ctx;
+  try {
+    assert.match(
+      await page.locator('[data-language="python"]').getAttribute("class"),
+      /\bselected\b/,
+    );
+    assert.deepEqual(errors, []);
+  } finally {
+    await page.close();
+  }
+});
+
 test("typing an opening bracket auto-closes it, in a real browser", async (t) => {
   const ctx = await editorPage(t);
   if (!ctx) return;

tests/browser/lobby.test.js

@@ -2044,6 +2044,22 @@ lobbyTest("try again selects the problem", async (page) => {
   );
 });
 
+lobbyTest("try again restores the saved language", async (page) => {
+  reports = [
+    {
+      payload: {
+        ...savedAttempt(EASY[0]).payload,
+        language: "javascript",
+      },
+    },
+  ];
+  await lobby(page);
+  await page.getByRole("button", { name: "Try again" }).click();
+  await page.click("#start");
+  await page.waitForURL("**/interview?**");
+  assert.equal(new URL(page.url()).searchParams.get("language"), "javascript");
+});
+
 lobbyTest(
   "an unmappable history entry fetches the page map at most once",
   async (page) => {

web/app.js

@@ -53,6 +53,8 @@ let duration;
 let interviewLoop = "coding_behavioral";
 /// Which surface the interview runs on; see the format row in index.html.
 let mode = "coding";
+/// The saved language attached to a problem selected through Try again.
+let retryLanguage = null;
 let reports = [];
 /// The practice focus the share box currently refers to.
 let sharedFocus = null;
@@ -393,6 +395,8 @@ start.addEventListener("click", async () => {
   destination.searchParams.set("duration", String(duration));
   destination.searchParams.set("loop", interviewLoop);
   destination.searchParams.set("mode", mode);
+  if (mode === "coding" && retryLanguage)
+    destination.searchParams.set("language", retryLanguage);
   setEditorOptions(destination.searchParams, selectedEditorOptions());
   const profile = {
     role: nodes.profileRole.value.trim(),
@@ -1113,12 +1117,13 @@ function applySuggestedLevel() {
 /// Clearing a filtered-out card must not leave Start pointing at it, and
 /// picking another card must not bypass an account request already in flight.
 /// Callers own the explanation beside the picker; this only knows which card.
-function setProblem(card) {
+function setProblem(card, language = null) {
   // Two buttons, not a sweep of all 150. `problem` still holds the outgoing
   // card here, which is what makes that possible.
   mark(problem?.button, false);
   mark(card?.button, true);
   problem = card;
+  retryLanguage = language;
   syncLobbyControls();
 }
 
@@ -1391,7 +1396,7 @@ function renderAttemptHistory(attempts) {
       if (!card) return;
       manualProblem = true;
       card.button.hidden = false;
-      setProblem(card);
+      setProblem(card, attempt.language);
       const savedDuration = attempt.durationMin;
       const offered = durations.map((button) =>
         Number(button.dataset.duration),

web/interview.js

@@ -278,6 +278,9 @@ const judgePromise = loadJudge(problem.page).catch(() => null);
 const candidateCaseStorageKey = `codetrial.candidateCases.${problem.page}`;
 /// Filled by `applyLanguages`, which `init` calls before anything reads it.
 let languages = [];
+// A delayed judge may make the requested C tab available after the first
+// paint. Do not switch to it after the candidate has chosen a tab or edited.
+let languageChoiceCommitted = false;
 /// What the lobby asked for, until `/api/token` says what it got. The range
 /// here mirrors the server's own and is the fallback for a URL that arrives
 /// without passing through the lobby; the answer below is what the interview
@@ -295,6 +298,7 @@ const interviewLoop = codingLoop(params.get("loop"));
 /// the answer would leave the editor bound and the starter code published in
 /// an interview that has neither.
 const whiteboard = modeIsWhiteboard(params.get("mode"));
+const requestedLanguage = whiteboard ? null : params.get("language");
 /// The same answer as the wire spelling, which the token request and the
 /// checklist both need. Derived from the boolean rather than from the URL a
 /// second time, so an unrecognized value cannot reach the server as itself.
@@ -616,7 +620,11 @@ async function init() {
   applyEditorTheme(readStored(EDITOR_THEME_KEY));
   renderProblem();
   applyLanguages(null);
-  setLanguage("python");
+  setLanguage(
+    requestedLanguage && languages.includes(requestedLanguage)
+      ? requestedLanguage
+      : "python",
+  );
   bindEvents();
   if (whiteboard) initWhiteboard();
   placeJimStageBelowToolbar(
@@ -651,6 +659,13 @@ async function init() {
   // microtask.
   void judgePromise.then((spec) => {
     applyLanguages(spec);
+    if (
+      !languageChoiceCommitted &&
+      requestedLanguage &&
+      state.language !== requestedLanguage &&
+      languages.includes(requestedLanguage)
+    )
+      setLanguage(requestedLanguage);
   });
   // No enumeration here. Before the preflight grant the browser reports only a
   // blank placeholder, so the list is discarded and repainted a few lines down;
@@ -850,9 +865,10 @@ function bindEvents() {
     nodes.resultsChevron.textContent = nodes.resultsBody.hidden ? "^" : "v";
   });
   for (const button of document.querySelectorAll("[data-language]")) {
-    button.addEventListener("click", () =>
-      setLanguage(button.dataset.language),
-    );
+    button.addEventListener("click", () => {
+      languageChoiceCommitted = true;
+      setLanguage(button.dataset.language);
+    });
   }
   for (const [button, step] of [
     [nodes.editorFontSmaller, -1],
@@ -988,6 +1004,7 @@ function bindEvents() {
     }
   });
   nodes.editor.addEventListener("input", () => {
+    languageChoiceCommitted = true;
     // Before the buffer below is taken, because this sends the tab as it
     // arrived. Typing inside the switch's own debounce window cancels it
     // otherwise, and the single packet that survives carries the switch and the