@learnpack/learnpack 5.0.358 → 5.0.360

package/src/creator/src/components/LanguageDetectionModal.tsx

@@ -4,12 +4,25 @@ interface LanguageDetectionModalProps {
   detectedLanguage: string
   onSwitch: () => void
   onStay: () => void
+  // Overrides for asking which language the course should be in, rather than
+  // suggesting an interface switch. Neither answer is the default there, so
+  // `equalChoices` gives both buttons the same weight.
+  title?: string
+  message?: string
+  switchLabel?: string
+  stayLabel?: string
+  equalChoices?: boolean
 }
 
 export default function LanguageDetectionModal({
   detectedLanguage,
   onSwitch,
   onStay,
+  title,
+  message,
+  switchLabel,
+  stayLabel,
+  equalChoices = false,
 }: LanguageDetectionModalProps) {
   const { t, i18n } = useTranslation()
 
@@ -17,27 +30,34 @@ export default function LanguageDetectionModal({
     <div className="fixed inset-0 bg-black/50 flex items-center justify-center z-1000">
       <div className="bg-white p-6 rounded-xl shadow-md max-w-md w-full mx-4">
         <h2 className="text-xl font-semibold text-center mb-4">
-          {t("languageDetection.title")}
+          {title ?? t("languageDetection.title")}
         </h2>
         <p className="text-gray-600 text-center mb-6">
-          {t("languageDetection.message", { 
-            language: t(`languageDetection.languages.${detectedLanguage.toLowerCase()}`)
-          })}
+          {message ??
+            t("languageDetection.message", {
+              language: t(`languageDetection.languages.${detectedLanguage.toLowerCase()}`)
+            })}
         </p>
         <div className="flex flex-col sm:flex-row gap-3">
           <button
             onClick={onSwitch}
-            className="flex-1 bg-blue-600 text-white py-2 px-4 rounded-md font-semibold hover:bg-blue-700 transition-colors"
+            className={
+              equalChoices
+                ? "flex-1 bg-gray-200 text-gray-800 py-2 px-4 rounded-md font-semibold hover:bg-gray-300 transition-colors"
+                : "flex-1 bg-blue-600 text-white py-2 px-4 rounded-md font-semibold hover:bg-blue-700 transition-colors"
+            }
           >
-            {t("languageDetection.switchTo", { 
-              language: t(`languageDetection.languages.${detectedLanguage.toLowerCase()}`)
-            })}
+            {switchLabel ??
+              t("languageDetection.switchTo", {
+                language: t(`languageDetection.languages.${detectedLanguage.toLowerCase()}`)
+              })}
           </button>
           <button
             onClick={onStay}
             className="flex-1 bg-gray-200 text-gray-800 py-2 px-4 rounded-md font-semibold hover:bg-gray-300 transition-colors"
           >
-            {t(`languageDetection.stayIn${i18n.language.toLowerCase().split("-")[0]}`)}
+            {stayLabel ??
+              t(`languageDetection.stayIn${i18n.language.toLowerCase().split("-")[0]}`)}
           </button>
         </div>
       </div>

package/src/creator/src/components/StepWizard.tsx

@@ -20,6 +20,8 @@ type Props = {
   setFormState: (formState: any) => void
   onFinish: () => void
   hideLastButton?: boolean
+  // Shown between Back and Next on every step.
+  footer?: React.ReactNode
 }
 
 const StepWizard: React.FC<Props> = ({
@@ -28,6 +30,7 @@ const StepWizard: React.FC<Props> = ({
   setFormState,
   onFinish,
   hideLastButton = false,
+  footer,
 }) => {
   const { t } = useTranslation()
   const currentStep = formState.currentStep
@@ -99,20 +102,25 @@ const StepWizard: React.FC<Props> = ({
           {steps.find((step) => step.slug === currentStep)?.content}
         </div>
 
-        <div className="flex justify-between">
+        {/* Three columns keep the footer centered even when Next is hidden. On
+            narrow screens it gets its own row under Back and Next. */}
+        <div className="grid grid-cols-2 sm:grid-cols-[1fr_auto_1fr] items-center gap-2">
           <button
             onClick={goBack}
             disabled={index === 0}
-            className={`text-sm text-gray-500 hover:text-gray-900 disabled:opacity-40  ${
+            className={`justify-self-start text-sm text-gray-500 hover:text-gray-900 disabled:opacity-40  ${
               index === 0 ? "cursor-not-allowed" : "cursor-pointer"
             }`}
           >
             ⬅ {t("stepWizard.back")}
           </button>
+          <div className="col-span-2 row-start-2 justify-self-center sm:col-span-1 sm:col-start-2 sm:row-start-1">
+            {footer}
+          </div>
           {!(hideLastButton && index === totalSteps - 1) && (
             <button
               onClick={index === totalSteps - 1 ? onFinish : goNext}
-              className={`text-sm text-blue-600 hover:text-blue-800 cursor-pointer disabled:opacity-40 disabled:cursor-not-allowed p-2 rounded-md ${
+              className={`justify-self-end text-sm text-blue-600 hover:text-blue-800 cursor-pointer disabled:opacity-40 disabled:cursor-not-allowed p-2 rounded-md ${
                 index === totalSteps - 1 ? "bg-blue-600 text-white" : ""
               }`}
             >

package/src/creator/src/components/Uploader.test.tsx

@@ -0,0 +1,65 @@
+import { describe, it, expect, vi, afterEach } from "vitest";
+import { cleanup, fireEvent, render, screen } from "@testing-library/react";
+import "../i18n";
+import { Uploader } from "./Uploader";
+
+const LINK = {
+  url: "https://www.youtube.com/watch?v=abc",
+  title: "Bases de datos",
+  transcript: "Hoy vamos a ver cómo se diseña una base de datos relacional",
+};
+
+// The real uploaders call Rigobot; these stand-ins finish straight away.
+vi.mock("./LinkUploader", () => ({
+  default: ({ onResult }: { onResult: (link: typeof LINK) => void }) => (
+    <button onClick={() => onResult(LINK)}>mock-link</button>
+  ),
+}));
+vi.mock("./FileUploader", () => ({
+  default: ({ onFinish }: { onFinish: () => void }) => (
+    <button onClick={onFinish}>mock-files</button>
+  ),
+}));
+
+afterEach(cleanup);
+
+describe("Uploader", () => {
+  it("hands pasted text over as both the content index and the seed", () => {
+    const onFinish = vi.fn();
+    render(<Uploader onFinish={onFinish} />);
+
+    fireEvent.click(screen.getByText("Write or paste a content table"));
+    fireEvent.change(screen.getByPlaceholderText("Add your text here..."), {
+      target: { value: "1. Tablas\n2. Claves" },
+    });
+    fireEvent.click(screen.getByText("Finish"));
+
+    expect(onFinish).toHaveBeenCalledWith(
+      "1. Tablas\n2. Claves",
+      "1. Tablas\n2. Claves"
+    );
+  });
+
+  it("hands a video's transcript over as the seed, outside the instructions", () => {
+    const onFinish = vi.fn();
+    render(<Uploader onFinish={onFinish} />);
+
+    fireEvent.click(screen.getByText("Share a Youtube link"));
+    fireEvent.click(screen.getByText("mock-link"));
+
+    expect(onFinish).toHaveBeenCalledWith(
+      `The following information comes from a Youtube video uploaded by the user. Use the transcript to create the course: ${JSON.stringify(LINK)}`,
+      LINK.transcript
+    );
+  });
+
+  it("gives no seed text for files, which are read from the store", () => {
+    const onFinish = vi.fn();
+    render(<Uploader onFinish={onFinish} />);
+
+    fireEvent.click(screen.getByText("Upload files"));
+    fireEvent.click(screen.getByText("mock-files"));
+
+    expect(onFinish).toHaveBeenCalledWith("");
+  });
+});

package/src/creator/src/components/Uploader.tsx

@@ -30,7 +30,10 @@ const TextUploader = ({ onFinish }: { onFinish: (text: string) => void }) => {
 export const Uploader = ({
   onFinish,
 }: {
-  onFinish: (text: string) => void
+  // seedText is the readable content behind `text`, used to detect the
+  // course language: the pasted text, or a video's transcript without the
+  // instructions wrapped around it. Uploaded files are read from the store.
+  onFinish: (text: string, seedText?: string) => void
 }) => {
   const [selectedOption, setSelectedOption] = useState<string | null>(null)
   const { t } = useTranslation()
@@ -62,7 +65,9 @@ export const Uploader = ({
         </>
       )}
 
-      {selectedOption === "text" && <TextUploader onFinish={onFinish} />}
+      {selectedOption === "text" && (
+        <TextUploader onFinish={(text) => onFinish(text, text)} />
+      )}
 
       {selectedOption === "files" && (
         <FileUploader
@@ -80,7 +85,8 @@ export const Uploader = ({
             onFinish(
               `The following information comes from a Youtube video uploaded by the user. Use the transcript to create the course: ${JSON.stringify(
                 link
-              )}`
+              )}`,
+              link.transcript
             )
           }}
         />

package/src/creator/src/locales/en.json

@@ -121,11 +121,18 @@
         "switchTo": "Yes, switch to {{language}}",
         "stayInen": "Stay in English",
         "stayInes": "Stay in Spanish",
+        "chooseTitle": "Course language",
+        "chooseMessage": "Which language should the course be in?",
         "languages": {
             "en": "English",
             "es": "Spanish"
         }
     },
+    "courseLanguage": {
+        "label": "Course language",
+        "auto": "Auto",
+        "autoHint": "Uses the language of your files and your description. If they don't match, we'll ask you."
+    },
     "login": {
         "creatingAccount": "Creating account…",
         "loggedInSuccessfully": "Logged in successfully",

package/src/creator/src/locales/es.json

@@ -121,11 +121,18 @@
         "switchTo": "Sí, cambiar a {{language}}",
         "stayInen": "Mantenerse en Inglés",
         "stayInes": "Mantenerse en Español",
+        "chooseTitle": "Idioma del curso",
+        "chooseMessage": "¿En qué idioma quieres el curso?",
         "languages": {
             "en": "Inglés",
             "es": "Español"
         }
     },
+    "courseLanguage": {
+        "label": "Idioma del curso",
+        "auto": "Automático",
+        "autoHint": "Usa el idioma de tus archivos y tu descripción. Si no coinciden, te preguntamos."
+    },
     "login": {
         "creatingAccount": "Creando cuenta…",
         "loggedInSuccessfully": "Inicio de sesión exitoso",

package/src/creator/src/utils/courseLanguage.test.ts

@@ -0,0 +1,215 @@
+import { describe, it, expect } from "vitest";
+import {
+  decideCourseLanguage,
+  detectDescriptionLanguage,
+  detectSeedLanguage,
+  detectTextLanguage,
+  toCourseLanguage,
+} from "./courseLanguage";
+
+const ENGLISH =
+  "Relational databases store information in tables made of rows and columns. " +
+  "Each table describes one kind of thing, such as customers or orders, and the " +
+  "relationships between tables are expressed through keys. In this chapter you " +
+  "will learn how to write queries that filter, sort and join data, and why " +
+  "indexes make those queries fast even when the tables hold millions of rows. ";
+
+const SPANISH =
+  "Las bases de datos relacionales guardan la información en tablas formadas " +
+  "por filas y columnas. Cada tabla describe un tipo de cosa, como clientes o " +
+  "pedidos, y las relaciones entre tablas se expresan mediante claves. En este " +
+  "capítulo aprenderás a escribir consultas que filtran, ordenan y combinan " +
+  "datos, y por qué los índices hacen que esas consultas sean rápidas. ";
+
+const PORTUGUESE =
+  "Os bancos de dados relacionais armazenam as informações em tabelas formadas " +
+  "por linhas e colunas. Cada tabela descreve um tipo de coisa, como clientes ou " +
+  "pedidos, e as relações entre as tabelas são expressas por meio de chaves. " +
+  "Neste capítulo você vai aprender a escrever consultas que filtram, ordenam e " +
+  "combinam dados, e por que os índices tornam essas consultas rápidas. ";
+
+const FRENCH =
+  "Les bases de données relationnelles stockent les informations dans des " +
+  "tables composées de lignes et de colonnes. Chaque table décrit un type de " +
+  "chose, comme les clients ou les commandes, et les relations entre les tables " +
+  "sont exprimées par des clés. Dans ce chapitre, vous apprendrez à écrire des " +
+  "requêtes qui filtrent, trient et combinent des données. ";
+
+const ENGLISH_COVER =
+  "University of Northfield. School of Engineering. Department of Computer " +
+  "Science. Lecture notes for the second year. Copyright 2024, all rights " +
+  "reserved. Prepared by the teaching staff for internal use only. ";
+
+const ENGLISH_REFERENCES =
+  "Codd, E. F. A relational model of data for large shared data banks. " +
+  "Communications of the ACM, volume 13, issue 6, pages 377 to 387. " +
+  "Date, C. J. An introduction to database systems. Addison Wesley. ";
+
+describe("toCourseLanguage", () => {
+  it.each([
+    ["es", "es"],
+    ["en", "en"],
+    ["EN", "en"],
+    [" es ", "es"],
+  ])("accepts %j as %s", (value, expected) => {
+    expect(toCourseLanguage(value)).toBe(expected);
+  });
+
+  it.each(["fr", "pt", "es-MX", "en-US", "", "spanish"])(
+    "rejects %j",
+    (value) => {
+      expect(toCourseLanguage(value)).toBeNull();
+    }
+  );
+
+  it("rejects a missing value", () => {
+    expect(toCourseLanguage(undefined)).toBeNull();
+    expect(toCourseLanguage(null)).toBeNull();
+  });
+});
+
+describe("detectTextLanguage", () => {
+  it("detects English and Spanish text", () => {
+    expect(detectTextLanguage(ENGLISH.repeat(2))).toBe("en");
+    expect(detectTextLanguage(SPANISH.repeat(2))).toBe("es");
+  });
+
+  it("reports other languages instead of passing them off as Spanish or English", () => {
+    expect(detectTextLanguage(PORTUGUESE.repeat(2))).toBe("other");
+    expect(detectTextLanguage(FRENCH.repeat(2))).toBe("other");
+  });
+
+  it("does not judge text with fewer than 200 letters", () => {
+    expect(detectTextLanguage("Python basics for data analysis")).toBeNull();
+  });
+
+  it("does not count digits and symbols as letters", () => {
+    // Over 200 characters, but under 200 letters: too little language to judge.
+    const text =
+      "Las ventas del trimestre por región y por producto son estas: " +
+      "| 2024 | 15.30 | 7 | 0.25 | 1999 | 48.10 | 3 | 0.75 |\n".repeat(6);
+    expect(text.length).toBeGreaterThan(200);
+    expect(detectTextLanguage(text)).toBeNull();
+  });
+
+  it("is not swayed by an English cover page on a Spanish document", () => {
+    const text = ENGLISH_COVER + SPANISH.repeat(20);
+    expect(detectTextLanguage(text)).toBe("es");
+  });
+
+  it("is not swayed by a long English bibliography after a Spanish body", () => {
+    // The body fills the first five windows, so the references never vote.
+    const text = SPANISH.repeat(40) + ENGLISH_REFERENCES.repeat(200);
+    expect(detectTextLanguage(text)).toBe("es");
+  });
+
+  it("does not guess when no language holds two thirds of the windows", () => {
+    // About half of the first five windows are Spanish, half English.
+    const text = SPANISH.repeat(14) + ENGLISH.repeat(40);
+    expect(detectTextLanguage(text)).toBeNull();
+  });
+});
+
+describe("detectSeedLanguage", () => {
+  const en = ENGLISH.repeat(2);
+  const es = SPANISH.repeat(2);
+  const pt = PORTUGUESE.repeat(2);
+
+  it("returns the language all sources share", () => {
+    expect(detectSeedLanguage([en])).toBe("en");
+    expect(detectSeedLanguage([es, es])).toBe("es");
+  });
+
+  it("reports sources that disagree instead of letting the longest win", () => {
+    expect(detectSeedLanguage([en.repeat(10), es])).toBe("mixed");
+  });
+
+  it("ignores sources too short to judge", () => {
+    expect(detectSeedLanguage([en, "Notas"])).toBe("en");
+  });
+
+  it("settles nothing when any source is in an unsupported language", () => {
+    expect(detectSeedLanguage([en, pt])).toBeNull();
+  });
+
+  it("settles nothing without judgeable sources", () => {
+    expect(detectSeedLanguage([])).toBeNull();
+    expect(detectSeedLanguage(["", "Notas"])).toBeNull();
+  });
+});
+
+describe("detectDescriptionLanguage", () => {
+  it.each([
+    "Learn TypeScript generics",
+    "Write better SQL queries",
+    "How to use pandas DataFrames",
+    "I want to learn how to build REST APIs with Flask",
+    "Teach the API documentation of our payment service",
+  ])("reads %j as English", (description) => {
+    expect(detectDescriptionLanguage(description)).toBe("en");
+  });
+
+  it.each([
+    "Curso de React hooks",
+    "Quiero aprender a construir APIs REST con Flask",
+    "Álgebra lineal para machine learning",
+    "Pipelines de CI/CD con GitHub Actions",
+    "¿Cómo funciona Docker?",
+  ])("reads %j as Spanish", (description) => {
+    expect(detectDescriptionLanguage(description)).toBe("es");
+  });
+
+  it.each([
+    "React hooks",
+    "Kubernetes",
+    "Data science con python course for beginners",
+    "",
+  ])("cannot tell %j", (description) => {
+    expect(detectDescriptionLanguage(description)).toBeNull();
+  });
+});
+
+describe("decideCourseLanguage", () => {
+  it.each([
+    // The user's choice wins over everything, with or without a seed.
+    [
+      { chosen: "es", seed: null, description: null },
+      { kind: "use", language: "es" },
+    ],
+    [
+      { chosen: "es", seed: "en", description: "en" },
+      { kind: "use", language: "es" },
+    ],
+    [
+      { chosen: "en", seed: "mixed", description: "es" },
+      { kind: "use", language: "en" },
+    ],
+    // Without a seed nothing is settled: the request goes out as before.
+    [{ chosen: null, seed: null, description: null }, { kind: "model" }],
+    [{ chosen: null, seed: null, description: "es" }, { kind: "model" }],
+    // The seed is used when the description agrees or cannot be judged.
+    [
+      { chosen: null, seed: "en", description: "en" },
+      { kind: "use", language: "en" },
+    ],
+    [
+      { chosen: null, seed: "en", description: null },
+      { kind: "use", language: "en" },
+    ],
+    [
+      { chosen: null, seed: "es", description: "es" },
+      { kind: "use", language: "es" },
+    ],
+    [
+      { chosen: null, seed: "es", description: null },
+      { kind: "use", language: "es" },
+    ],
+    // Any disagreement is the user's call.
+    [{ chosen: null, seed: "en", description: "es" }, { kind: "ask" }],
+    [{ chosen: null, seed: "es", description: "en" }, { kind: "ask" }],
+    [{ chosen: null, seed: "mixed", description: null }, { kind: "ask" }],
+    [{ chosen: null, seed: "mixed", description: "en" }, { kind: "ask" }],
+  ] as const)("%j decides %j", (input, expected) => {
+    expect(decideCourseLanguage(input)).toEqual(expected);
+  });
+});

package/src/creator/src/utils/courseLanguage.ts

@@ -0,0 +1,173 @@
+import { franc } from "franc";
+
+export type TCourseLanguage = "en" | "es";
+
+/**
+ * Narrows a language code to one the creator can build a course in.
+ * @param value - A code such as "es", "EN" or an i18next resolved language.
+ * @returns "en" or "es", or null for anything else (including "es-MX").
+ */
+export const toCourseLanguage = (
+  value: string | null | undefined
+): TCourseLanguage | null => {
+  const code = value?.trim().toLowerCase();
+  return code === "en" || code === "es" ? code : null;
+};
+
+// franc only reads the first 2048 characters of whatever it is given, so long
+// text is judged window by window.
+const WINDOW_LENGTH = 2048;
+// Enough windows that a cover page or front matter cannot decide alone, few
+// enough that an English bibliography at the end of a Spanish document cannot
+// outvote its body.
+const MAX_WINDOWS = 5;
+// Below this many letters, titles, code and tables misclassify. Digits and
+// symbols are not counted because they carry no language.
+const MIN_LETTERS = 200;
+// A window shorter than this at the end of the text is too small to vote.
+const MIN_WINDOW_LENGTH = 200;
+const MAJORITY = 2 / 3;
+
+const countLetters = (text: string) => (text.match(/\p{L}/gu) || []).length;
+
+/**
+ * Detects whether a piece of seed text is English or Spanish.
+ *
+ * Votes over the first few 2048-character windows and only answers on a
+ * two-thirds majority, so mixed or ambiguous text comes back as null rather
+ * than as a guess. Windows in any other language vote too, so a Portuguese
+ * or French document is not passed off as Spanish or English.
+ * @param text - Text extracted from an uploaded file, pasted text or a
+ * transcript.
+ * @returns "en" or "es", "other" when the text is mostly in a language the
+ * creator does not support, or null when there is too little text or no clear
+ * majority.
+ */
+export const detectTextLanguage = (
+  text: string
+): TCourseLanguage | "other" | null => {
+  if (countLetters(text) < MIN_LETTERS) return null;
+
+  let english = 0;
+  let spanish = 0;
+  let other = 0;
+  let windows = 0;
+  for (
+    let start = 0;
+    start < text.length && windows < MAX_WINDOWS;
+    start += WINDOW_LENGTH
+  ) {
+    const window = text.slice(start, start + WINDOW_LENGTH);
+    if (start > 0 && window.length < MIN_WINDOW_LENGTH) continue;
+    windows++;
+    const lang = franc(window);
+    if (lang === "eng") english++;
+    else if (lang === "spa") spanish++;
+    else if (lang !== "und") other++;
+  }
+
+  const votes = english + spanish + other;
+  if (votes === 0) return null;
+  if (english / votes >= MAJORITY) return "en";
+  if (spanish / votes >= MAJORITY) return "es";
+  if (other / votes >= MAJORITY) return "other";
+  return null;
+};
+
+export type TSeedLanguage = TCourseLanguage | "mixed" | null;
+
+/**
+ * Detects the language of everything the user gave as course content, judging
+ * each source separately so one long file cannot outvote a short one.
+ * @param seeds - The text of each uploaded file, pasted text or transcript.
+ * @returns The shared language, "mixed" when confidently detected sources
+ * disagree, or null when none could be judged or any source is in a language
+ * the creator does not support (the model then picks, as before).
+ */
+export const detectSeedLanguage = (seeds: string[]): TSeedLanguage => {
+  const detected = seeds.map(detectTextLanguage);
+  if (detected.includes("other")) return null;
+  const languages = new Set(
+    detected.filter((lang): lang is TCourseLanguage => lang !== null)
+  );
+  if (languages.size === 0) return null;
+  if (languages.size > 1) return "mixed";
+  return [...languages][0];
+};
+
+// Words that exist in only one of the two languages. Ambiguous ones such as
+// "a", "me", "no" or "son" are left out on purpose.
+const ENGLISH_ONLY_WORDS = new Set(
+  "the to and of for with how what why when your my our this that these those is are was be into from about on in an i we you want learn teach build create make use using write explain help course lesson beginners introduction basics guide".split(
+    " "
+  )
+);
+const SPANISH_ONLY_WORDS = new Set(
+  "el la los las del de para con por sobre cómo como qué que y en un una unos unas mi mis nuestro nuestra nuestros es son está quiero aprender aprende enseña enseñar crear crea construir usar usando escribir explica ayúdame curso lección principiantes introducción básico básica guía desde".split(
+    " "
+  )
+);
+const SPANISH_CHARACTERS = /[ñáéíóú¿¡]/i;
+
+/**
+ * Detects the language a course description was written in.
+ *
+ * Descriptions are a few words long and full of technical terms, which
+ * statistical detection misreads ("Learn TypeScript generics" comes out as
+ * Spanish). Counting words that only exist in one language is reliable at
+ * that length, and answering only when the other language shows no sign at
+ * all keeps mixed descriptions out.
+ * @param description - The course description from the wizard.
+ * @returns "en" or "es", or null when the description is mixed or has no
+ * telling words.
+ */
+export const detectDescriptionLanguage = (
+  description: string
+): TCourseLanguage | null => {
+  const words = description.toLowerCase().match(/\p{L}+/gu) || [];
+  let english = 0;
+  let spanish = 0;
+  for (const word of words) {
+    if (ENGLISH_ONLY_WORDS.has(word)) english++;
+    if (SPANISH_ONLY_WORDS.has(word)) spanish++;
+  }
+  if (SPANISH_CHARACTERS.test(description)) spanish++;
+
+  if (english > 0 && spanish === 0) return "en";
+  if (spanish > 0 && english === 0) return "es";
+  return null;
+};
+
+export type TCourseLanguageDecision =
+  // Nothing settles the language: the request goes out exactly as before and
+  // the model picks.
+  | { kind: "model" }
+  | { kind: "use"; language: TCourseLanguage }
+  // Only the user can say which language they meant.
+  | { kind: "ask" };
+
+/**
+ * Decides the course language before generation.
+ *
+ * A language the user chose always wins. Otherwise the seed's language is used
+ * when the description agrees or cannot be judged, and any disagreement is put
+ * to the user. A misread description can therefore only cause a question,
+ * never a course in the wrong language.
+ */
+export const decideCourseLanguage = ({
+  chosen,
+  seed,
+  description,
+}: {
+  chosen: TCourseLanguage | null;
+  seed: TSeedLanguage;
+  description: TCourseLanguage | null;
+}): TCourseLanguageDecision => {
+  if (chosen) return { kind: "use", language: chosen };
+  if (seed === null) return { kind: "model" };
+  if (seed === "mixed") return { kind: "ask" };
+  if (description === null || description === seed) {
+    return { kind: "use", language: seed };
+  }
+  return { kind: "ask" };
+};