@thanh01.pmt/interactive-quiz-kit 1.0.27 → 1.0.28

package/dist/authoring.cjs

@@ -8067,20 +8067,12 @@ var CodingQuestionZodSchema = BaseQuestionZodSchema.extend({
   })).min(1)
 });
 
-// src/ai/flows/question-gen/generate-fitb-question-types.ts
-BaseQuestionGenerationClientInputSchema.extend({
-  numberOfBlanks: zod.z.number().int().min(1).max(5).optional().default(1),
-  isCaseSensitive: zod.z.boolean().optional().default(false)
-});
-var AIFillInTheBlanksOutputFieldsSchema = zod.z.object({
-  prompt: zod.z.string().describe("The instructional text for the user, e.g., 'Fill in the blanks to complete the sentence.'"),
-  // Yêu cầu AI trả về cấu trúc segments trực tiếp
-  segments: zod.z.array(zod.z.object({
-    type: zod.z.enum(["text", "blank"]),
-    content: zod.z.string().optional().describe("The text content for a 'text' segment."),
-    acceptedAnswers: zod.z.array(zod.z.string().min(1)).min(1).optional().describe("An array of correct answers for a 'blank' segment.")
-  })).min(1).describe("An array of text and blank segments representing the question."),
-  explanation: zod.z.string().optional(),
+// src/ai/flows/question-gen/generate-true-false-question-types.ts
+BaseQuestionGenerationClientInputSchema.extend({});
+var AITrueFalseOutputFieldsSchema = zod.z.object({
+  prompt: zod.z.string().describe("The statement that the user will evaluate as true or false."),
+  correctAnswer: zod.z.boolean(),
+  explanation: zod.z.string().optional().describe("An explanation of why the statement is true or false, especially important if false."),
   points: zod.z.number().optional().default(10),
   difficulty: zod.z.enum(["easy", "medium", "hard"]).optional(),
   topic: zod.z.string().optional(),
@@ -8088,57 +8080,55 @@ var AIFillInTheBlanksOutputFieldsSchema = zod.z.object({
   // Thêm để xác thực
 });
 
-// src/ai/flows/question-gen/generate-fitb-question.ts
+// src/ai/flows/question-gen/generate-true-false-question.ts
 var MAX_RETRY_ATTEMPTS = 3;
 var RETRY_DELAY_MS = 3e3;
 function buildEnhancedPrompt(clientInput, attemptNumber) {
-  const { quizContext, language: language3, difficulty, numberOfBlanks, imageUrl } = clientInput;
+  const { quizContext, language: language3, difficulty, imageUrl } = clientInput;
   const category = quizContext?.originalCategory || "the specified technical category";
   const attemptInfo = attemptNumber > 1 ? `
 ## DEBUG INFO - This is attempt #${attemptNumber}
-Previous attempts failed. Pay strict attention to the JSON schema, especially the 'segments' array structure. Ensure 'blank' segments have 'acceptedAnswers' and 'text' segments have 'content'.
+Previous attempts failed. Ensure the JSON is valid and 'correctAnswer' is a boolean.
 
 ` : "";
-  const imageContextInstruction = imageUrl ? `**Image Context:** You MUST analyze the provided image. The question and blanks must be directly related to the content of this image.` : "";
+  const imageContextInstruction = imageUrl ? `**Image Context:** You MUST analyze the provided image. The True/False statement must be directly related to the content of this image.` : "";
+  const misconceptionGuidance = quizContext?.targetMisconception ? `**Target Misconception:** The statement you create MUST be FALSE and based on this common mistake: "${quizContext.targetMisconception}"` : "";
   const contextStrings = [
     `**Required Category:** ${category}`,
     quizContext?.loDescription && `**Learning Objective:** ${quizContext.loDescription}`,
     imageContextInstruction,
     quizContext?.plannedBloomLevel && `**Cognitive Level (Bloom's):** ${quizContext.plannedBloomLevel}`,
-    quizContext?.targetMisconception && `**Target Misconception:** Design the blank to test this specific point: "${quizContext.targetMisconception}"`
+    misconceptionGuidance,
+    quizContext?.difficultyReason && `**Pedagogical Reason:** ${quizContext.difficultyReason}`
   ].filter(Boolean).map((s2) => `- ${s2}`).join("\n");
   const exampleJson = JSON.stringify({
-    prompt: "Complete the following Swift code snippet.",
-    segments: [
-      { "type": "text", "content": "To declare a new function in Swift, you use the `" },
-      { "type": "blank", "acceptedAnswers": ["func"] },
-      { "type": "text", "content": "` keyword." }
-    ],
-    explanation: "The 'func' keyword is used to declare a function in the Swift programming language.",
+    prompt: "In Swift, you must explicitly unwrap an Optional value before you can use its stored value.",
+    correctAnswer: true,
+    explanation: "Optional values in Swift represent the presence or absence of a value. To access the value when it exists, you must unwrap it using methods like 'if let', 'guard let', or the force unwrap operator '!'.",
     points: 10,
     difficulty: "easy",
-    topic: "Swift Function Declaration",
+    topic: "Swift Optionals",
     verifiedCategory: category
   }, null, 2);
   return `${attemptInfo}You are an expert Question Author for advanced technical education, specializing in: ${category}.
-Your mission is to create a high-quality, technically accurate Fill-in-the-Blanks Question.
+Your mission is to create a high-quality, technically accurate True/False Question.
 
 ## Core Rules (Non-negotiable)
-1.  **Category Purity:** The question MUST be exclusively about **${category}**.
-2.  **Schema Integrity:** The response MUST be ONLY a single, valid JSON object that strictly follows the provided schema.
-3.  **Logical Segments:** For 'blank' segments, you MUST provide 'acceptedAnswers'. For 'text' segments, you MUST provide 'content'. Do not mix them.
+1.  **Category Purity:** The statement ('prompt') MUST be exclusively about **${category}**.
+2.  **Clarity:** The statement must be definitively true or false, with no ambiguity.
+3.  **Misconception Priority:** If a Target Misconception is provided, the statement MUST be FALSE and reflect that misconception. This is a critical rule.
+4.  **Schema Integrity:** The response MUST be ONLY a single, valid JSON object.
 
 ## CRITICAL CONTEXT FOR THIS QUESTION
 ${contextStrings}
 
 ## Task: Generate the Question
-Based on all the rules and context above, generate a single Fill-in-the-Blanks Question.
+Based on all the rules and context above, generate a single True/False Question.
 
 ### Input Parameters
 - **Topic for Question:** ${quizContext?.plannedTopic || "General"}
 - **Language for Text:** ${language3}
 - **Difficulty Level:** ${difficulty}
-- **Number of Blanks:** Generate exactly ${numberOfBlanks} segment(s) with type 'blank'.
 
 ### Required JSON Output Format
 Your response must be ONLY the JSON object, matching this exact structure:
@@ -8147,11 +8137,11 @@ ${exampleJson}
 
 Now, generate the JSON for the requested question.`;
 }
-async function generateFillInTheBlanksQuestion(clientInput, apiKey) {
+async function generateTrueFalseQuestion(clientInput, apiKey) {
   const ai = new genai.GoogleGenAI({ apiKey });
   const model = "gemini-2.5-flash";
   const config2 = {
-    temperature: 0.8,
+    temperature: 0.6,
     responseMimeType: "application/json",
     thinkingConfig: {
       thinkingBudget: 4e3
@@ -8180,20 +8170,11 @@ async function generateFillInTheBlanksQuestion(clientInput, apiKey) {
       if (!rawText) throw new Error("AI returned an empty response.");
       const parsedJson = JSON.parse(rawText);
       DebugLogger.logValidation(attempt, "JSON Parsed Successfully", parsedJson);
-      const aiGeneratedContent = AIFillInTheBlanksOutputFieldsSchema.parse(parsedJson);
+      const aiGeneratedContent = AITrueFalseOutputFieldsSchema.parse(parsedJson);
       DebugLogger.logValidation(attempt, "Zod Schema Validated", aiGeneratedContent);
-      const blankCount = aiGeneratedContent.segments.filter((s2) => s2.type === "blank").length;
-      if (blankCount !== clientInput.numberOfBlanks) {
-        throw new Error(`AI generated ${blankCount} blanks, but ${clientInput.numberOfBlanks} were required.`);
+      if (clientInput.quizContext?.targetMisconception && aiGeneratedContent.correctAnswer === true) {
+        throw new Error("AI failed to follow the Misconception Priority rule. The answer should have been false.");
       }
-      aiGeneratedContent.segments.forEach((segment, index3) => {
-        if (segment.type === "blank" && (!segment.acceptedAnswers || segment.acceptedAnswers.length === 0)) {
-          throw new Error(`Segment ${index3} is a 'blank' but is missing 'acceptedAnswers'.`);
-        }
-        if (segment.type === "text" && typeof segment.content !== "string") {
-          throw new Error(`Segment ${index3} is 'text' but is missing 'content'.`);
-        }
-      });
       if (clientInput.quizContext?.originalCategory) {
         const verifiedCategory = aiGeneratedContent.verifiedCategory?.toLowerCase();
         const requiredCategory = clientInput.quizContext.originalCategory.toLowerCase();
@@ -8201,24 +8182,11 @@ async function generateFillInTheBlanksQuestion(clientInput, apiKey) {
           throw new Error(`Category mismatch: Required ${requiredCategory}, got ${verifiedCategory}`);
         }
       }
-      const finalSegments = [];
-      const finalAnswers = [];
-      aiGeneratedContent.segments.forEach((segment) => {
-        if (segment.type === "text") {
-          finalSegments.push({ type: "text", content: segment.content });
-        } else if (segment.type === "blank" && segment.acceptedAnswers) {
-          const blankId = generateUniqueId("blank_");
-          finalSegments.push({ type: "blank", id: blankId });
-          finalAnswers.push({ blankId, acceptedValues: segment.acceptedAnswers });
-        }
-      });
       const completeQuestion = {
-        id: generateUniqueId("fitb_ai_"),
-        questionType: "fill_in_the_blanks",
+        id: generateUniqueId("tf_ai_"),
+        questionType: "true_false",
         prompt: aiGeneratedContent.prompt,
-        segments: finalSegments,
-        answers: finalAnswers,
-        isCaseSensitive: clientInput.isCaseSensitive,
+        correctAnswer: aiGeneratedContent.correctAnswer,
         explanation: aiGeneratedContent.explanation,
         points: aiGeneratedContent.points,
         topic: aiGeneratedContent.topic || clientInput.quizContext?.originalTopic,
@@ -8230,10 +8198,10 @@ async function generateFillInTheBlanksQuestion(clientInput, apiKey) {
         category: clientInput.quizContext?.originalCategory,
         imageUrl: clientInput.imageUrl
       };
-      const validatedQuestion = FillInTheBlanksQuestionZodSchema.parse(completeQuestion);
+      const validatedQuestion = TrueFalseQuestionZodSchema.parse(completeQuestion);
       attemptResults.push({ success: true, duration, promptLength: promptText.length, responseLength: rawText.length, promptHash });
       console.log(`
-\u2705 FITB generation successful on attempt ${attempt} (${duration}ms)`);
+\u2705 True/False generation successful on attempt ${attempt} (${duration}ms)`);
       if (attempt > 1) DebugLogger.logAttemptSummary(attemptResults);
       return { question: validatedQuestion };
     } catch (error) {
@@ -8249,89 +8217,93 @@ async function generateFillInTheBlanksQuestion(clientInput, apiKey) {
     }
   }
   DebugLogger.logAttemptSummary(attemptResults);
-  const errorMessage = `Failed to generate FITB question after ${MAX_RETRY_ATTEMPTS} attempts. Last error: ${lastError?.message}`;
+  const errorMessage = `Failed to generate True/False question after ${MAX_RETRY_ATTEMPTS} attempts. Last error: ${lastError?.message}`;
   console.error("\n\u274C Final Result: FAILED");
   console.error(errorMessage);
   return { error: errorMessage };
 }
 BaseQuestionGenerationClientInputSchema.extend({
-  numberOfPairs: zod.z.number().int().min(2).max(8).optional().default(4),
-  shuffleOptions: zod.z.boolean().optional().default(true)
+  numberOfOptions: zod.z.number().int().min(2).max(6).optional().default(4)
 });
-var AIMatchingOutputFieldsSchema = zod.z.object({
-  prompt: zod.z.string().describe("The instructional text for the user, e.g., 'Match the concept to its definition.'"),
-  correctPairs: zod.z.array(zod.z.object({
-    promptText: zod.z.string().min(1).describe("The text for the left-hand side item (the prompt)."),
-    optionText: zod.z.string().min(1).describe("The text for the right-hand side item (the matching option).")
-  })).min(2),
-  explanation: zod.z.string().optional(),
+var AIMCQOutputFieldsSchema = zod.z.object({
+  prompt: zod.z.string().describe("The question statement itself."),
+  options: zod.z.array(
+    zod.z.object({
+      tempId: zod.z.string().describe("A temporary, unique identifier for this option (e.g., 'A', 'B', '1', '2')."),
+      text: zod.z.string().describe("The text content of this answer option.")
+    })
+  ).min(2).max(6),
+  correctTempOptionId: zod.z.string().describe("The temporary ID of the correct option from the generated options array."),
+  explanation: zod.z.string().optional().describe("A brief explanation of why the answer is correct."),
   points: zod.z.number().optional().default(10),
   difficulty: zod.z.enum(["easy", "medium", "hard"]).optional(),
   topic: zod.z.string().optional(),
-  verifiedCategory: zod.z.string().optional()
-  // Thêm để xác thực
+  verifiedCategory: zod.z.string().optional().describe("The category this question actually addresses.")
 });
 
-// src/ai/flows/question-gen/generate-matching-question.ts
+// src/ai/flows/question-gen/generate-mcq-question.ts
 var MAX_RETRY_ATTEMPTS2 = 3;
 var RETRY_DELAY_MS2 = 3e3;
 function buildEnhancedPrompt2(clientInput, attemptNumber) {
-  const { quizContext, language: language3, difficulty, numberOfPairs, imageUrl } = clientInput;
+  const { quizContext, language: language3, difficulty, numberOfOptions, imageUrl } = clientInput;
   const category = quizContext?.originalCategory || "the specified technical category";
   const attemptInfo = attemptNumber > 1 ? `
 ## DEBUG INFO - This is attempt #${attemptNumber}
-Previous attempts failed. Please ensure the 'correctPairs' array has exactly the required number of items and the JSON is valid.
+Previous attempts failed...
 
 ` : "";
-  const imageContextInstruction = imageUrl ? `**Image Context:** You MUST analyze the provided image. The matching pairs must be directly related to the content of this image.` : "";
+  const imageContextInstruction = imageUrl ? `**Image Context:** You MUST analyze the provided image. The question and options must be directly related to the content of this image.` : "";
   const contextStrings = [
     `**Required Category:** ${category}`,
     quizContext?.loDescription && `**Learning Objective:** ${quizContext.loDescription}`,
     imageContextInstruction,
     quizContext?.plannedBloomLevel && `**Cognitive Level (Bloom's):** ${quizContext.plannedBloomLevel}`,
-    quizContext?.targetMisconception && `**Target Misconception:** Design a pair that specifically tests this confusion: "${quizContext.targetMisconception}"`
+    quizContext?.targetMisconception && `**Target Misconception:** Use this to create plausible incorrect answers: "${quizContext.targetMisconception}"`,
+    quizContext?.difficultyReason && `**Pedagogical Reason:** ${quizContext.difficultyReason}`
   ].filter(Boolean).map((s2) => `- ${s2}`).join("\n");
   const exampleJson = JSON.stringify({
-    prompt: "Match each Swift collection type to its primary characteristic.",
-    correctPairs: [
-      { "promptText": "Array", "optionText": "An ordered, random-access collection." },
-      { "promptText": "Set", "optionText": "An unordered collection of unique elements." },
-      { "promptText": "Dictionary", "optionText": "An unordered collection of key-value associations." }
+    prompt: `In ${category}, what is the primary purpose of the 'guard' statement?`,
+    options: [
+      { tempId: "A", text: "To execute a block of code repeatedly." },
+      { tempId: "B", text: "To define a new custom data type." },
+      { tempId: "C", text: "To exit a scope early if a condition is not met." },
+      { tempId: "D", text: "To handle errors thrown by a function." }
     ],
-    explanation: "These are the fundamental characteristics of Swift's main collection types.",
+    correctTempOptionId: "C",
+    explanation: `The 'guard' statement in ${category} provides an early exit from a scope (like a function) if a condition is false, enhancing code readability by handling required conditions upfront.`,
     points: 10,
     difficulty: "easy",
-    topic: "Swift Collection Types",
+    topic: `Control Flow in ${category}`,
     verifiedCategory: category
   }, null, 2);
-  return `${attemptInfo}You are an expert Question Author for advanced technical education, specializing in: ${category}.
-Your mission is to create a high-quality, technically accurate Matching Question.
+  return `${attemptInfo}You are an expert Question Author for advanced technical education, specializing in the programming language: ${category}.
+Your sole mission is to create a high-quality, technically accurate Multiple Choice Question. You must adhere to the following rules at all times.
 
 ## Core Rules (Non-negotiable)
-1.  **Category Purity:** The question MUST be exclusively about **${category}**.
-2.  **Logical Pairs:** The items to be matched must have a clear, one-to-one relationship.
-3.  **Schema Integrity:** The response MUST be ONLY a single, valid JSON object that strictly follows the provided schema.
+1.  **Category Purity:** The question, options, and explanation MUST be exclusively about **${category}**. Do NOT mention or use syntax from other languages.
+2.  **Context Adherence:** The question's content must directly align with all provided context.
+3.  **Format Integrity:** You MUST return ONLY a single, valid JSON object that strictly follows the provided schema. Do not include any extra text, comments, or markdown formatting.
 
 ## CRITICAL CONTEXT FOR THIS QUESTION
 ${contextStrings}
 
 ## Task: Generate the Question
-Based on all the rules and context above, generate a single Matching Question.
+Based on all the rules and context above, generate a single Multiple Choice Question.
 
 ### Input Parameters
 - **Topic for Question:** ${quizContext?.plannedTopic || "General"}
 - **Language for Text:** ${language3}
 - **Difficulty Level:** ${difficulty}
-- **Number of Pairs:** Generate exactly ${numberOfPairs} correct pairs in the 'correctPairs' array.
+- **Number of Options:** ${numberOfOptions}
 
 ### Required JSON Output Format
-Your response must be ONLY the JSON object, matching this exact structure:
+Your response must be ONLY the JSON object, matching this exact structure and field names.
 
 ${exampleJson}
 
 Now, generate the JSON for the requested question.`;
 }
-async function generateMatchingQuestion(clientInput, apiKey) {
+async function generateMCQQuestion(clientInput, apiKey) {
   const ai = new genai.GoogleGenAI({ apiKey });
   const model = "gemini-2.5-flash";
   const config2 = {
@@ -8356,19 +8328,22 @@ async function generateMatchingQuestion(clientInput, apiKey) {
         parts.unshift(imagePart);
       }
       const contents = [{ role: "user", parts }];
-      const aiResult = await ai.models.generateContent({ model, config: config2, contents });
+      const aiResult = await ai.models.generateContent({
+        model,
+        config: config2,
+        contents
+      });
       const response = aiResult;
       const rawText = response.candidates?.[0]?.content?.parts?.[0]?.text || "";
       const duration = Date.now() - startTime;
       DebugLogger.logResponse(attempt, rawText);
-      if (!rawText) throw new Error("AI returned an empty response.");
+      if (!rawText) {
+        throw new Error("AI returned an empty response.");
+      }
       const parsedJson = JSON.parse(rawText);
       DebugLogger.logValidation(attempt, "JSON Parsed Successfully", parsedJson);
-      const aiGeneratedContent = AIMatchingOutputFieldsSchema.parse(parsedJson);
+      const aiGeneratedContent = AIMCQOutputFieldsSchema.parse(parsedJson);
       DebugLogger.logValidation(attempt, "Zod Schema Validated", aiGeneratedContent);
-      if (aiGeneratedContent.correctPairs.length !== clientInput.numberOfPairs) {
-        throw new Error(`AI generated ${aiGeneratedContent.correctPairs.length} pairs, but ${clientInput.numberOfPairs} were required.`);
-      }
       if (clientInput.quizContext?.originalCategory) {
         const verifiedCategory = aiGeneratedContent.verifiedCategory?.toLowerCase();
         const requiredCategory = clientInput.quizContext.originalCategory.toLowerCase();
@@ -8376,24 +8351,23 @@ async function generateMatchingQuestion(clientInput, apiKey) {
           throw new Error(`Category mismatch: Required ${requiredCategory}, got ${verifiedCategory}`);
         }
       }
-      const finalPrompts = [];
       const finalOptions = [];
-      const finalCorrectAnswerMap = [];
-      aiGeneratedContent.correctPairs.forEach((pair2) => {
-        const promptId = generateUniqueId("m_p_");
-        const optionId = generateUniqueId("m_o_");
-        finalPrompts.push({ id: promptId, content: pair2.promptText });
-        finalOptions.push({ id: optionId, content: pair2.optionText });
-        finalCorrectAnswerMap.push({ promptId, optionId });
+      const tempIdToFinalIdMap = {};
+      aiGeneratedContent.options.forEach((aiOption) => {
+        const finalId = generateUniqueId("opt_");
+        finalOptions.push({ id: finalId, text: aiOption.text });
+        tempIdToFinalIdMap[aiOption.tempId] = finalId;
       });
+      const finalCorrectAnswerId = tempIdToFinalIdMap[aiGeneratedContent.correctTempOptionId];
+      if (!finalCorrectAnswerId) {
+        throw new Error(`Correct option ID '${aiGeneratedContent.correctTempOptionId}' is invalid`);
+      }
       const completeQuestion = {
-        id: generateUniqueId("match_ai_"),
-        questionType: "matching",
+        id: generateUniqueId("mcq_ai_"),
+        questionType: "multiple_choice",
         prompt: aiGeneratedContent.prompt,
-        prompts: finalPrompts,
         options: finalOptions,
-        correctAnswerMap: finalCorrectAnswerMap,
-        shuffleOptions: clientInput.shuffleOptions,
+        correctAnswerId: finalCorrectAnswerId,
         explanation: aiGeneratedContent.explanation,
         points: aiGeneratedContent.points,
         topic: aiGeneratedContent.topic || clientInput.quizContext?.originalTopic,
@@ -8405,10 +8379,10 @@ async function generateMatchingQuestion(clientInput, apiKey) {
         category: clientInput.quizContext?.originalCategory,
         imageUrl: clientInput.imageUrl
       };
-      const validatedQuestion = MatchingQuestionZodSchema.parse(completeQuestion);
+      const validatedQuestion = MultipleChoiceQuestionZodSchema.parse(completeQuestion);
       attemptResults.push({ success: true, duration, promptLength: promptText.length, responseLength: rawText.length, promptHash });
       console.log(`
-\u2705 Matching generation successful on attempt ${attempt} (${duration}ms)`);
+\u2705 MCQ generation successful on attempt ${attempt} (${duration}ms)`);
       if (attempt > 1) DebugLogger.logAttemptSummary(attemptResults);
       return { question: validatedQuestion };
     } catch (error) {
@@ -8424,84 +8398,83 @@ async function generateMatchingQuestion(clientInput, apiKey) {
     }
   }
   DebugLogger.logAttemptSummary(attemptResults);
-  const errorMessage = `Failed to generate Matching question after ${MAX_RETRY_ATTEMPTS2} attempts. Last error: ${lastError?.message}`;
+  const errorMessage = `Failed to generate MCQ question after ${MAX_RETRY_ATTEMPTS2} attempts. Last error: ${lastError?.message}`;
   console.error("\n\u274C Final Result: FAILED");
   console.error(errorMessage);
   return { error: errorMessage };
 }
 BaseQuestionGenerationClientInputSchema.extend({
-  numberOfOptions: zod.z.number().int().min(2).max(6).optional().default(4)
+  numberOfOptions: zod.z.number().int().min(2).max(8).optional().default(5),
+  minCorrectAnswers: zod.z.number().int().min(1).optional().default(2),
+  maxCorrectAnswers: zod.z.number().int().min(1).optional().default(3)
 });
-var AIMCQOutputFieldsSchema = zod.z.object({
-  prompt: zod.z.string().describe("The question statement itself."),
-  options: zod.z.array(
-    zod.z.object({
-      tempId: zod.z.string().describe("A temporary, unique identifier for this option (e.g., 'A', 'B', '1', '2')."),
-      text: zod.z.string().describe("The text content of this answer option.")
-    })
-  ).min(2).max(6),
-  correctTempOptionId: zod.z.string().describe("The temporary ID of the correct option from the generated options array."),
-  explanation: zod.z.string().optional().describe("A brief explanation of why the answer is correct."),
+var AIMRQOutputFieldsSchema = zod.z.object({
+  prompt: zod.z.string(),
+  options: zod.z.array(zod.z.object({ tempId: zod.z.string(), text: zod.z.string() })).min(2).max(8),
+  correctTempOptionIds: zod.z.array(zod.z.string()).min(1),
+  explanation: zod.z.string().optional(),
   points: zod.z.number().optional().default(10),
   difficulty: zod.z.enum(["easy", "medium", "hard"]).optional(),
   topic: zod.z.string().optional(),
   verifiedCategory: zod.z.string().optional().describe("The category this question actually addresses.")
 });
 
-// src/ai/flows/question-gen/generate-mcq-question.ts
+// src/ai/flows/question-gen/generate-mrq-question.ts
 var MAX_RETRY_ATTEMPTS3 = 3;
 var RETRY_DELAY_MS3 = 3e3;
 function buildEnhancedPrompt3(clientInput, attemptNumber) {
-  const { quizContext, language: language3, difficulty, numberOfOptions, imageUrl } = clientInput;
+  const { quizContext, language: language3, difficulty, numberOfOptions, minCorrectAnswers, maxCorrectAnswers, imageUrl } = clientInput;
   const category = quizContext?.originalCategory || "the specified technical category";
   const attemptInfo = attemptNumber > 1 ? `
 ## DEBUG INFO - This is attempt #${attemptNumber}
-Previous attempts failed...
+Previous attempts failed due to validation errors. Pay close attention to the number of correct answers and the JSON schema.
 
 ` : "";
   const imageContextInstruction = imageUrl ? `**Image Context:** You MUST analyze the provided image. The question and options must be directly related to the content of this image.` : "";
   const contextStrings = [
-    `**Required Category:** ${category}`,
+    `**Required Category:** ${category} (This is the ONLY language to be used)`,
     quizContext?.loDescription && `**Learning Objective:** ${quizContext.loDescription}`,
     imageContextInstruction,
     quizContext?.plannedBloomLevel && `**Cognitive Level (Bloom's):** ${quizContext.plannedBloomLevel}`,
-    quizContext?.targetMisconception && `**Target Misconception:** Use this to create plausible incorrect answers: "${quizContext.targetMisconception}"`,
+    quizContext?.targetMisconception && `**Target Misconception:** Use this to create plausible incorrect answers (distractors). The misconception is: "${quizContext.targetMisconception}"`,
     quizContext?.difficultyReason && `**Pedagogical Reason:** ${quizContext.difficultyReason}`
   ].filter(Boolean).map((s2) => `- ${s2}`).join("\n");
   const exampleJson = JSON.stringify({
-    prompt: `In ${category}, what is the primary purpose of the 'guard' statement?`,
+    prompt: "Which of the following are considered programming paradigms?",
     options: [
-      { tempId: "A", text: "To execute a block of code repeatedly." },
-      { tempId: "B", text: "To define a new custom data type." },
-      { tempId: "C", text: "To exit a scope early if a condition is not met." },
-      { tempId: "D", text: "To handle errors thrown by a function." }
+      { "tempId": "A", "text": "Object-Oriented" },
+      { "tempId": "B", "text": "Assembly" },
+      { "tempId": "C", "text": "Functional" },
+      { "tempId": "D", "text": "Procedural" },
+      { "tempId": "E", "text": "Middleware" }
     ],
-    correctTempOptionId: "C",
-    explanation: `The 'guard' statement in ${category} provides an early exit from a scope (like a function) if a condition is false, enhancing code readability by handling required conditions upfront.`,
+    correctTempOptionIds: ["A", "C", "D"],
+    explanation: "Object-Oriented, Functional, and Procedural are all major programming paradigms. Assembly is a low-level language, and Middleware is a type of software, not a paradigm.",
     points: 10,
-    difficulty: "easy",
-    topic: `Control Flow in ${category}`,
+    difficulty: "medium",
+    topic: "Programming Paradigms",
     verifiedCategory: category
   }, null, 2);
   return `${attemptInfo}You are an expert Question Author for advanced technical education, specializing in the programming language: ${category}.
-Your sole mission is to create a high-quality, technically accurate Multiple Choice Question. You must adhere to the following rules at all times.
+Your sole mission is to create a high-quality, technically accurate Multiple Response Question. You must adhere to the following rules at all times.
 
 ## Core Rules (Non-negotiable)
-1.  **Category Purity:** The question, options, and explanation MUST be exclusively about **${category}**. Do NOT mention or use syntax from other languages.
+1.  **Category Purity:** The question, options, and explanation MUST be exclusively about **${category}**.
 2.  **Context Adherence:** The question's content must directly align with all provided context.
-3.  **Format Integrity:** You MUST return ONLY a single, valid JSON object that strictly follows the provided schema. Do not include any extra text, comments, or markdown formatting.
+3.  **Format Integrity:** You MUST return ONLY a single, valid JSON object that strictly follows the provided schema. Do not include any extra text or comments.
 
 ## CRITICAL CONTEXT FOR THIS QUESTION
 ${contextStrings}
 
 ## Task: Generate the Question
-Based on all the rules and context above, generate a single Multiple Choice Question.
+Based on all the rules and context above, generate a single Multiple Response Question.
 
 ### Input Parameters
 - **Topic for Question:** ${quizContext?.plannedTopic || "General"}
 - **Language for Text:** ${language3}
 - **Difficulty Level:** ${difficulty}
-- **Number of Options:** ${numberOfOptions}
+- **Number of Options:** Generate exactly ${numberOfOptions} options.
+- **Number of Correct Answers:** The 'correctTempOptionIds' array MUST contain between ${minCorrectAnswers} and ${maxCorrectAnswers} valid IDs from the options you generate.
 
 ### Required JSON Output Format
 Your response must be ONLY the JSON object, matching this exact structure and field names.
@@ -8510,7 +8483,13 @@ ${exampleJson}
 
 Now, generate the JSON for the requested question.`;
 }
-async function generateMCQQuestion(clientInput, apiKey) {
+async function generateMRQQuestion(clientInput, apiKey) {
+  if (clientInput.minCorrectAnswers > clientInput.maxCorrectAnswers) {
+    return { error: `Invalid input: minCorrectAnswers (${clientInput.minCorrectAnswers}) cannot be greater than maxCorrectAnswers (${clientInput.maxCorrectAnswers}).` };
+  }
+  if (clientInput.maxCorrectAnswers >= clientInput.numberOfOptions) {
+    return { error: `Invalid input: maxCorrectAnswers (${clientInput.maxCorrectAnswers}) must be less than the total numberOfOptions (${clientInput.numberOfOptions}).` };
+  }
   const ai = new genai.GoogleGenAI({ apiKey });
   const model = "gemini-2.5-flash";
   const config2 = {
@@ -8549,8 +8528,15 @@ async function generateMCQQuestion(clientInput, apiKey) {
       }
       const parsedJson = JSON.parse(rawText);
       DebugLogger.logValidation(attempt, "JSON Parsed Successfully", parsedJson);
-      const aiGeneratedContent = AIMCQOutputFieldsSchema.parse(parsedJson);
+      const aiGeneratedContent = AIMRQOutputFieldsSchema.parse(parsedJson);
       DebugLogger.logValidation(attempt, "Zod Schema Validated", aiGeneratedContent);
+      if (aiGeneratedContent.options.length !== clientInput.numberOfOptions) {
+        throw new Error(`AI generated ${aiGeneratedContent.options.length} options, but ${clientInput.numberOfOptions} were required.`);
+      }
+      const correctCount = aiGeneratedContent.correctTempOptionIds.length;
+      if (correctCount < clientInput.minCorrectAnswers || correctCount > clientInput.maxCorrectAnswers) {
+        throw new Error(`AI provided ${correctCount} correct answers, which is outside the required range of ${clientInput.minCorrectAnswers}-${clientInput.maxCorrectAnswers}.`);
+      }
       if (clientInput.quizContext?.originalCategory) {
         const verifiedCategory = aiGeneratedContent.verifiedCategory?.toLowerCase();
         const requiredCategory = clientInput.quizContext.originalCategory.toLowerCase();
@@ -8560,25 +8546,29 @@ async function generateMCQQuestion(clientInput, apiKey) {
       }
       const finalOptions = [];
       const tempIdToFinalIdMap = {};
+      const allTempIds = /* @__PURE__ */ new Set();
       aiGeneratedContent.options.forEach((aiOption) => {
-        const finalId = generateUniqueId("opt_");
+        const finalId = generateUniqueId("opt_mr_");
         finalOptions.push({ id: finalId, text: aiOption.text });
         tempIdToFinalIdMap[aiOption.tempId] = finalId;
+        allTempIds.add(aiOption.tempId);
+      });
+      const finalCorrectAnswerIds = aiGeneratedContent.correctTempOptionIds.map((tempId) => {
+        if (!allTempIds.has(tempId)) {
+          throw new Error(`AI provided an invalid correctTempOptionId ('${tempId}') which does not exist in the generated options.`);
+        }
+        return tempIdToFinalIdMap[tempId];
       });
-      const finalCorrectAnswerId = tempIdToFinalIdMap[aiGeneratedContent.correctTempOptionId];
-      if (!finalCorrectAnswerId) {
-        throw new Error(`Correct option ID '${aiGeneratedContent.correctTempOptionId}' is invalid`);
-      }
       const completeQuestion = {
-        id: generateUniqueId("mcq_ai_"),
-        questionType: "multiple_choice",
+        id: generateUniqueId("mrq_ai_"),
+        questionType: "multiple_response",
         prompt: aiGeneratedContent.prompt,
         options: finalOptions,
-        correctAnswerId: finalCorrectAnswerId,
+        correctAnswerIds: finalCorrectAnswerIds,
         explanation: aiGeneratedContent.explanation,
         points: aiGeneratedContent.points,
         topic: aiGeneratedContent.topic || clientInput.quizContext?.originalTopic,
-        difficulty: clientInput.difficulty,
+        difficulty: aiGeneratedContent.difficulty || clientInput.difficulty,
         contextCode: clientInput.quizContext?.plannedContextId,
         bloomLevel: clientInput.quizContext?.plannedBloomLevel,
         learningObjective: clientInput.quizContext?.originalLoId,
@@ -8586,10 +8576,10 @@ async function generateMCQQuestion(clientInput, apiKey) {
         category: clientInput.quizContext?.originalCategory,
         imageUrl: clientInput.imageUrl
       };
-      const validatedQuestion = MultipleChoiceQuestionZodSchema.parse(completeQuestion);
+      const validatedQuestion = MultipleResponseQuestionZodSchema.parse(completeQuestion);
       attemptResults.push({ success: true, duration, promptLength: promptText.length, responseLength: rawText.length, promptHash });
       console.log(`
-\u2705 MCQ generation successful on attempt ${attempt} (${duration}ms)`);
+\u2705 MRQ generation successful on attempt ${attempt} (${duration}ms)`);
       if (attempt > 1) DebugLogger.logAttemptSummary(attemptResults);
       return { question: validatedQuestion };
     } catch (error) {
@@ -8605,102 +8595,85 @@ async function generateMCQQuestion(clientInput, apiKey) {
     }
   }
   DebugLogger.logAttemptSummary(attemptResults);
-  const errorMessage = `Failed to generate MCQ question after ${MAX_RETRY_ATTEMPTS3} attempts. Last error: ${lastError?.message}`;
+  const errorMessage = `Failed to generate MRQ question after ${MAX_RETRY_ATTEMPTS3} attempts. Last error: ${lastError?.message}`;
   console.error("\n\u274C Final Result: FAILED");
   console.error(errorMessage);
   return { error: errorMessage };
 }
 BaseQuestionGenerationClientInputSchema.extend({
-  numberOfOptions: zod.z.number().int().min(2).max(8).optional().default(5),
-  minCorrectAnswers: zod.z.number().int().min(1).optional().default(2),
-  maxCorrectAnswers: zod.z.number().int().min(1).optional().default(3)
+  isCaseSensitive: zod.z.boolean().optional().default(false)
 });
-var AIMRQOutputFieldsSchema = zod.z.object({
-  prompt: zod.z.string(),
-  options: zod.z.array(zod.z.object({ tempId: zod.z.string(), text: zod.z.string() })).min(2).max(8),
-  correctTempOptionIds: zod.z.array(zod.z.string()).min(1),
+var AIShortAnswerOutputFieldsSchema = zod.z.object({
+  prompt: zod.z.string().describe("The question text that prompts the user for a short answer."),
+  acceptedAnswers: zod.z.array(zod.z.string().min(1)).min(1).describe("An array of one or more acceptable short answers. Include common variations if applicable."),
+  // isCaseSensitive không cần thiết ở đây, chúng ta sẽ quản lý nó ở phía client
   explanation: zod.z.string().optional(),
   points: zod.z.number().optional().default(10),
   difficulty: zod.z.enum(["easy", "medium", "hard"]).optional(),
   topic: zod.z.string().optional(),
-  verifiedCategory: zod.z.string().optional().describe("The category this question actually addresses.")
+  verifiedCategory: zod.z.string().optional()
+  // Thêm để xác thực
 });
 
-// src/ai/flows/question-gen/generate-mrq-question.ts
+// src/ai/flows/question-gen/generate-short-answer-question.ts
 var MAX_RETRY_ATTEMPTS4 = 3;
 var RETRY_DELAY_MS4 = 3e3;
 function buildEnhancedPrompt4(clientInput, attemptNumber) {
-  const { quizContext, language: language3, difficulty, numberOfOptions, minCorrectAnswers, maxCorrectAnswers, imageUrl } = clientInput;
+  const { quizContext, language: language3, difficulty, imageUrl } = clientInput;
   const category = quizContext?.originalCategory || "the specified technical category";
   const attemptInfo = attemptNumber > 1 ? `
 ## DEBUG INFO - This is attempt #${attemptNumber}
-Previous attempts failed due to validation errors. Pay close attention to the number of correct answers and the JSON schema.
+Previous attempts failed. Ensure 'acceptedAnswers' is a non-empty array of strings and the JSON is valid.
 
 ` : "";
-  const imageContextInstruction = imageUrl ? `**Image Context:** You MUST analyze the provided image. The question and options must be directly related to the content of this image.` : "";
+  const imageContextInstruction = imageUrl ? `**Image Context:** You MUST analyze the provided image. The question and its short answer must be directly related to the content of this image.` : "";
   const contextStrings = [
-    `**Required Category:** ${category} (This is the ONLY language to be used)`,
+    `**Required Category:** ${category}`,
     quizContext?.loDescription && `**Learning Objective:** ${quizContext.loDescription}`,
     imageContextInstruction,
     quizContext?.plannedBloomLevel && `**Cognitive Level (Bloom's):** ${quizContext.plannedBloomLevel}`,
-    quizContext?.targetMisconception && `**Target Misconception:** Use this to create plausible incorrect answers (distractors). The misconception is: "${quizContext.targetMisconception}"`,
-    quizContext?.difficultyReason && `**Pedagogical Reason:** ${quizContext.difficultyReason}`
+    quizContext?.targetMisconception && `**Target Misconception:** The question should require an answer that corrects this specific misconception: "${quizContext.targetMisconception}"`
   ].filter(Boolean).map((s2) => `- ${s2}`).join("\n");
   const exampleJson = JSON.stringify({
-    prompt: "Which of the following are considered programming paradigms?",
-    options: [
-      { "tempId": "A", "text": "Object-Oriented" },
-      { "tempId": "B", "text": "Assembly" },
-      { "tempId": "C", "text": "Functional" },
-      { "tempId": "D", "text": "Procedural" },
-      { "tempId": "E", "text": "Middleware" }
-    ],
-    correctTempOptionIds: ["A", "C", "D"],
-    explanation: "Object-Oriented, Functional, and Procedural are all major programming paradigms. Assembly is a low-level language, and Middleware is a type of software, not a paradigm.",
+    prompt: "In Swift, what keyword is used to declare a constant?",
+    acceptedAnswers: ["let"],
+    explanation: "The 'let' keyword is used to declare constants, which are values that cannot be changed after they are set. 'var' is used for variables.",
     points: 10,
-    difficulty: "medium",
-    topic: "Programming Paradigms",
+    difficulty: "easy",
+    topic: "Swift Constants",
     verifiedCategory: category
   }, null, 2);
-  return `${attemptInfo}You are an expert Question Author for advanced technical education, specializing in the programming language: ${category}.
-Your sole mission is to create a high-quality, technically accurate Multiple Response Question. You must adhere to the following rules at all times.
+  return `${attemptInfo}You are an expert Question Author for advanced technical education, specializing in: ${category}.
+Your mission is to create a high-quality, technically accurate Short Answer Question.
 
 ## Core Rules (Non-negotiable)
-1.  **Category Purity:** The question, options, and explanation MUST be exclusively about **${category}**.
-2.  **Context Adherence:** The question's content must directly align with all provided context.
-3.  **Format Integrity:** You MUST return ONLY a single, valid JSON object that strictly follows the provided schema. Do not include any extra text or comments.
+1.  **Category Purity:** The question MUST be exclusively about **${category}**.
+2.  **Objective Answer:** The question must have a short, factual, and objective answer. Avoid questions that are subjective or require long explanations.
+3.  **Schema Integrity:** The response MUST be ONLY a single, valid JSON object.
 
 ## CRITICAL CONTEXT FOR THIS QUESTION
 ${contextStrings}
 
 ## Task: Generate the Question
-Based on all the rules and context above, generate a single Multiple Response Question.
+Based on all the rules and context above, generate a single Short Answer Question.
 
 ### Input Parameters
 - **Topic for Question:** ${quizContext?.plannedTopic || "General"}
 - **Language for Text:** ${language3}
 - **Difficulty Level:** ${difficulty}
-- **Number of Options:** Generate exactly ${numberOfOptions} options.
-- **Number of Correct Answers:** The 'correctTempOptionIds' array MUST contain between ${minCorrectAnswers} and ${maxCorrectAnswers} valid IDs from the options you generate.
 
 ### Required JSON Output Format
-Your response must be ONLY the JSON object, matching this exact structure and field names.
+Your response must be ONLY the JSON object, matching this exact structure:
 
 ${exampleJson}
 
 Now, generate the JSON for the requested question.`;
 }
-async function generateMRQQuestion(clientInput, apiKey) {
-  if (clientInput.minCorrectAnswers > clientInput.maxCorrectAnswers) {
-    return { error: `Invalid input: minCorrectAnswers (${clientInput.minCorrectAnswers}) cannot be greater than maxCorrectAnswers (${clientInput.maxCorrectAnswers}).` };
-  }
-  if (clientInput.maxCorrectAnswers >= clientInput.numberOfOptions) {
-    return { error: `Invalid input: maxCorrectAnswers (${clientInput.maxCorrectAnswers}) must be less than the total numberOfOptions (${clientInput.numberOfOptions}).` };
-  }
+async function generateShortAnswerQuestion(clientInput, apiKey) {
   const ai = new genai.GoogleGenAI({ apiKey });
   const model = "gemini-2.5-flash";
   const config2 = {
-    temperature: 0.8,
+    temperature: 0.5,
     responseMimeType: "application/json",
     thinkingConfig: {
       thinkingBudget: 4e3
@@ -8721,29 +8694,16 @@ async function generateMRQQuestion(clientInput, apiKey) {
         parts.unshift(imagePart);
       }
       const contents = [{ role: "user", parts }];
-      const aiResult = await ai.models.generateContent({
-        model,
-        config: config2,
-        contents
-      });
+      const aiResult = await ai.models.generateContent({ model, config: config2, contents });
       const response = aiResult;
       const rawText = response.candidates?.[0]?.content?.parts?.[0]?.text || "";
       const duration = Date.now() - startTime;
       DebugLogger.logResponse(attempt, rawText);
-      if (!rawText) {
-        throw new Error("AI returned an empty response.");
-      }
+      if (!rawText) throw new Error("AI returned an empty response.");
       const parsedJson = JSON.parse(rawText);
       DebugLogger.logValidation(attempt, "JSON Parsed Successfully", parsedJson);
-      const aiGeneratedContent = AIMRQOutputFieldsSchema.parse(parsedJson);
+      const aiGeneratedContent = AIShortAnswerOutputFieldsSchema.parse(parsedJson);
       DebugLogger.logValidation(attempt, "Zod Schema Validated", aiGeneratedContent);
-      if (aiGeneratedContent.options.length !== clientInput.numberOfOptions) {
-        throw new Error(`AI generated ${aiGeneratedContent.options.length} options, but ${clientInput.numberOfOptions} were required.`);
-      }
-      const correctCount = aiGeneratedContent.correctTempOptionIds.length;
-      if (correctCount < clientInput.minCorrectAnswers || correctCount > clientInput.maxCorrectAnswers) {
-        throw new Error(`AI provided ${correctCount} correct answers, which is outside the required range of ${clientInput.minCorrectAnswers}-${clientInput.maxCorrectAnswers}.`);
-      }
       if (clientInput.quizContext?.originalCategory) {
         const verifiedCategory = aiGeneratedContent.verifiedCategory?.toLowerCase();
         const requiredCategory = clientInput.quizContext.originalCategory.toLowerCase();
@@ -8751,31 +8711,16 @@ async function generateMRQQuestion(clientInput, apiKey) {
           throw new Error(`Category mismatch: Required ${requiredCategory}, got ${verifiedCategory}`);
         }
       }
-      const finalOptions = [];
-      const tempIdToFinalIdMap = {};
-      const allTempIds = /* @__PURE__ */ new Set();
-      aiGeneratedContent.options.forEach((aiOption) => {
-        const finalId = generateUniqueId("opt_mr_");
-        finalOptions.push({ id: finalId, text: aiOption.text });
-        tempIdToFinalIdMap[aiOption.tempId] = finalId;
-        allTempIds.add(aiOption.tempId);
-      });
-      const finalCorrectAnswerIds = aiGeneratedContent.correctTempOptionIds.map((tempId) => {
-        if (!allTempIds.has(tempId)) {
-          throw new Error(`AI provided an invalid correctTempOptionId ('${tempId}') which does not exist in the generated options.`);
-        }
-        return tempIdToFinalIdMap[tempId];
-      });
       const completeQuestion = {
-        id: generateUniqueId("mrq_ai_"),
-        questionType: "multiple_response",
+        id: generateUniqueId("saq_ai_"),
+        questionType: "short_answer",
         prompt: aiGeneratedContent.prompt,
-        options: finalOptions,
-        correctAnswerIds: finalCorrectAnswerIds,
+        acceptedAnswers: aiGeneratedContent.acceptedAnswers,
+        isCaseSensitive: clientInput.isCaseSensitive,
         explanation: aiGeneratedContent.explanation,
         points: aiGeneratedContent.points,
         topic: aiGeneratedContent.topic || clientInput.quizContext?.originalTopic,
-        difficulty: aiGeneratedContent.difficulty || clientInput.difficulty,
+        difficulty: clientInput.difficulty,
         contextCode: clientInput.quizContext?.plannedContextId,
         bloomLevel: clientInput.quizContext?.plannedBloomLevel,
         learningObjective: clientInput.quizContext?.originalLoId,
@@ -8783,10 +8728,10 @@ async function generateMRQQuestion(clientInput, apiKey) {
         category: clientInput.quizContext?.originalCategory,
         imageUrl: clientInput.imageUrl
       };
-      const validatedQuestion = MultipleResponseQuestionZodSchema.parse(completeQuestion);
+      const validatedQuestion = ShortAnswerQuestionZodSchema.parse(completeQuestion);
       attemptResults.push({ success: true, duration, promptLength: promptText.length, responseLength: rawText.length, promptHash });
       console.log(`
-\u2705 MRQ generation successful on attempt ${attempt} (${duration}ms)`);
+\u2705 Short Answer generation successful on attempt ${attempt} (${duration}ms)`);
       if (attempt > 1) DebugLogger.logAttemptSummary(attemptResults);
       return { question: validatedQuestion };
     } catch (error) {
@@ -8802,7 +8747,7 @@ async function generateMRQQuestion(clientInput, apiKey) {
     }
   }
   DebugLogger.logAttemptSummary(attemptResults);
-  const errorMessage = `Failed to generate MRQ question after ${MAX_RETRY_ATTEMPTS4} attempts. Last error: ${lastError?.message}`;
+  const errorMessage = `Failed to generate Short Answer question after ${MAX_RETRY_ATTEMPTS4} attempts. Last error: ${lastError?.message}`;
   console.error("\n\u274C Final Result: FAILED");
   console.error(errorMessage);
   return { error: errorMessage };
@@ -8988,13 +8933,17 @@ async function generateNumericQuestion(clientInput, apiKey) {
   return { error: errorMessage };
 }
 BaseQuestionGenerationClientInputSchema.extend({
-  numberOfItems: zod.z.number().int().min(2).max(10).optional().default(4)
+  numberOfBlanks: zod.z.number().int().min(1).max(5).optional().default(1),
+  isCaseSensitive: zod.z.boolean().optional().default(false)
 });
-var AISequenceOutputFieldsSchema = zod.z.object({
-  prompt: zod.z.string().describe("The instructional text for the user, e.g., 'Arrange the steps in the correct order.'"),
-  // Yêu cầu AI cung cấp các item dưới dạng một mảng duy nhất đã được sắp xếp đúng thứ tự
-  // Điều này đơn giản hóa logic và giảm rủi ro
-  itemsInCorrectOrder: zod.z.array(zod.z.string().min(1)).min(2).describe("An array of strings, with each string representing an item to be sequenced. The array itself MUST be in the correct final order."),
+var AIFillInTheBlanksOutputFieldsSchema = zod.z.object({
+  prompt: zod.z.string().describe("The instructional text for the user, e.g., 'Fill in the blanks to complete the sentence.'"),
+  // Yêu cầu AI trả về cấu trúc segments trực tiếp
+  segments: zod.z.array(zod.z.object({
+    type: zod.z.enum(["text", "blank"]),
+    content: zod.z.string().optional().describe("The text content for a 'text' segment."),
+    acceptedAnswers: zod.z.array(zod.z.string().min(1)).min(1).optional().describe("An array of correct answers for a 'blank' segment.")
+  })).min(1).describe("An array of text and blank segments representing the question."),
   explanation: zod.z.string().optional(),
   points: zod.z.number().optional().default(10),
   difficulty: zod.z.enum(["easy", "medium", "hard"]).optional(),
@@ -9003,58 +8952,57 @@ var AISequenceOutputFieldsSchema = zod.z.object({
   // Thêm để xác thực
 });
 
-// src/ai/flows/question-gen/generate-sequence-question.ts
+// src/ai/flows/question-gen/generate-fitb-question.ts
 var MAX_RETRY_ATTEMPTS6 = 3;
 var RETRY_DELAY_MS6 = 3e3;
 function buildEnhancedPrompt6(clientInput, attemptNumber) {
-  const { quizContext, language: language3, difficulty, numberOfItems, imageUrl } = clientInput;
+  const { quizContext, language: language3, difficulty, numberOfBlanks, imageUrl } = clientInput;
   const category = quizContext?.originalCategory || "the specified technical category";
   const attemptInfo = attemptNumber > 1 ? `
 ## DEBUG INFO - This is attempt #${attemptNumber}
-Previous attempts failed. Ensure the 'itemsInCorrectOrder' array has exactly the required number of items and the JSON is valid.
+Previous attempts failed. Pay strict attention to the JSON schema, especially the 'segments' array structure. Ensure 'blank' segments have 'acceptedAnswers' and 'text' segments have 'content'.
 
 ` : "";
-  const imageContextInstruction = imageUrl ? `**Image Context:** You MUST analyze the provided image. The sequence of items must be directly related to the process or content shown in this image.` : "";
+  const imageContextInstruction = imageUrl ? `**Image Context:** You MUST analyze the provided image. The question and blanks must be directly related to the content of this image.` : "";
   const contextStrings = [
     `**Required Category:** ${category}`,
     quizContext?.loDescription && `**Learning Objective:** ${quizContext.loDescription}`,
     imageContextInstruction,
     quizContext?.plannedBloomLevel && `**Cognitive Level (Bloom's):** ${quizContext.plannedBloomLevel}`,
-    quizContext?.targetMisconception && `**Target Misconception:** The sequence should clarify this specific process error: "${quizContext.targetMisconception}"`
+    quizContext?.targetMisconception && `**Target Misconception:** Design the blank to test this specific point: "${quizContext.targetMisconception}"`
   ].filter(Boolean).map((s2) => `- ${s2}`).join("\n");
   const exampleJson = JSON.stringify({
-    prompt: "Arrange the steps to make a network request in Swift using URLSession.",
-    itemsInCorrectOrder: [
-      "Create a URL object.",
-      "Create a URLSessionDataTask with the URL.",
-      "Start the task by calling its resume() method.",
-      "Handle the completion handler with data, response, and error."
+    prompt: "Complete the following Swift code snippet.",
+    segments: [
+      { "type": "text", "content": "To declare a new function in Swift, you use the `" },
+      { "type": "blank", "acceptedAnswers": ["func"] },
+      { "type": "text", "content": "` keyword." }
     ],
-    explanation: "This is the fundamental sequence for a basic data task in URLSession.",
+    explanation: "The 'func' keyword is used to declare a function in the Swift programming language.",
     points: 10,
-    difficulty: "medium",
-    topic: "Swift Networking",
+    difficulty: "easy",
+    topic: "Swift Function Declaration",
     verifiedCategory: category
   }, null, 2);
   return `${attemptInfo}You are an expert Question Author for advanced technical education, specializing in: ${category}.
-Your mission is to create a high-quality, technically accurate Sequence Question.
+Your mission is to create a high-quality, technically accurate Fill-in-the-Blanks Question.
 
 ## Core Rules (Non-negotiable)
 1.  **Category Purity:** The question MUST be exclusively about **${category}**.
-2.  **Unambiguous Order:** The items MUST represent a clear, objective process, timeline, or order with only one correct sequence.
-3.  **Schema Integrity:** The response MUST be ONLY a single, valid JSON object that strictly follows the provided schema.
+2.  **Schema Integrity:** The response MUST be ONLY a single, valid JSON object that strictly follows the provided schema.
+3.  **Logical Segments:** For 'blank' segments, you MUST provide 'acceptedAnswers'. For 'text' segments, you MUST provide 'content'. Do not mix them.
 
 ## CRITICAL CONTEXT FOR THIS QUESTION
 ${contextStrings}
 
 ## Task: Generate the Question
-Based on all the rules and context above, generate a single Sequence Question.
+Based on all the rules and context above, generate a single Fill-in-the-Blanks Question.
 
 ### Input Parameters
 - **Topic for Question:** ${quizContext?.plannedTopic || "General"}
 - **Language for Text:** ${language3}
 - **Difficulty Level:** ${difficulty}
-- **Number of Items:** Generate an array 'itemsInCorrectOrder' containing exactly ${numberOfItems} items. The array itself MUST be in the correct final sequence.
+- **Number of Blanks:** Generate exactly ${numberOfBlanks} segment(s) with type 'blank'.
 
 ### Required JSON Output Format
 Your response must be ONLY the JSON object, matching this exact structure:
@@ -9063,11 +9011,11 @@ ${exampleJson}
 
 Now, generate the JSON for the requested question.`;
 }
-async function generateSequenceQuestion(clientInput, apiKey) {
+async function generateFillInTheBlanksQuestion(clientInput, apiKey) {
   const ai = new genai.GoogleGenAI({ apiKey });
   const model = "gemini-2.5-flash";
   const config2 = {
-    temperature: 0.7,
+    temperature: 0.8,
     responseMimeType: "application/json",
     thinkingConfig: {
       thinkingBudget: 4e3
@@ -9096,11 +9044,20 @@ async function generateSequenceQuestion(clientInput, apiKey) {
       if (!rawText) throw new Error("AI returned an empty response.");
       const parsedJson = JSON.parse(rawText);
       DebugLogger.logValidation(attempt, "JSON Parsed Successfully", parsedJson);
-      const aiGeneratedContent = AISequenceOutputFieldsSchema.parse(parsedJson);
+      const aiGeneratedContent = AIFillInTheBlanksOutputFieldsSchema.parse(parsedJson);
       DebugLogger.logValidation(attempt, "Zod Schema Validated", aiGeneratedContent);
-      if (aiGeneratedContent.itemsInCorrectOrder.length !== clientInput.numberOfItems) {
-        throw new Error(`AI generated ${aiGeneratedContent.itemsInCorrectOrder.length} items, but ${clientInput.numberOfItems} were required.`);
+      const blankCount = aiGeneratedContent.segments.filter((s2) => s2.type === "blank").length;
+      if (blankCount !== clientInput.numberOfBlanks) {
+        throw new Error(`AI generated ${blankCount} blanks, but ${clientInput.numberOfBlanks} were required.`);
       }
+      aiGeneratedContent.segments.forEach((segment, index3) => {
+        if (segment.type === "blank" && (!segment.acceptedAnswers || segment.acceptedAnswers.length === 0)) {
+          throw new Error(`Segment ${index3} is a 'blank' but is missing 'acceptedAnswers'.`);
+        }
+        if (segment.type === "text" && typeof segment.content !== "string") {
+          throw new Error(`Segment ${index3} is 'text' but is missing 'content'.`);
+        }
+      });
       if (clientInput.quizContext?.originalCategory) {
         const verifiedCategory = aiGeneratedContent.verifiedCategory?.toLowerCase();
         const requiredCategory = clientInput.quizContext.originalCategory.toLowerCase();
@@ -9108,19 +9065,24 @@ async function generateSequenceQuestion(clientInput, apiKey) {
           throw new Error(`Category mismatch: Required ${requiredCategory}, got ${verifiedCategory}`);
         }
       }
-      const finalItems = [];
-      const finalCorrectOrder = [];
-      aiGeneratedContent.itemsInCorrectOrder.forEach((content4) => {
-        const id2 = generateUniqueId("seqi_");
-        finalItems.push({ id: id2, content: content4 });
-        finalCorrectOrder.push(id2);
+      const finalSegments = [];
+      const finalAnswers = [];
+      aiGeneratedContent.segments.forEach((segment) => {
+        if (segment.type === "text") {
+          finalSegments.push({ type: "text", content: segment.content });
+        } else if (segment.type === "blank" && segment.acceptedAnswers) {
+          const blankId = generateUniqueId("blank_");
+          finalSegments.push({ type: "blank", id: blankId });
+          finalAnswers.push({ blankId, acceptedValues: segment.acceptedAnswers });
+        }
       });
       const completeQuestion = {
-        id: generateUniqueId("seq_ai_"),
-        questionType: "sequence",
+        id: generateUniqueId("fitb_ai_"),
+        questionType: "fill_in_the_blanks",
         prompt: aiGeneratedContent.prompt,
-        items: finalItems,
-        correctOrder: finalCorrectOrder,
+        segments: finalSegments,
+        answers: finalAnswers,
+        isCaseSensitive: clientInput.isCaseSensitive,
         explanation: aiGeneratedContent.explanation,
         points: aiGeneratedContent.points,
         topic: aiGeneratedContent.topic || clientInput.quizContext?.originalTopic,
@@ -9132,10 +9094,10 @@ async function generateSequenceQuestion(clientInput, apiKey) {
         category: clientInput.quizContext?.originalCategory,
         imageUrl: clientInput.imageUrl
       };
-      const validatedQuestion = SequenceQuestionZodSchema.parse(completeQuestion);
+      const validatedQuestion = FillInTheBlanksQuestionZodSchema.parse(completeQuestion);
       attemptResults.push({ success: true, duration, promptLength: promptText.length, responseLength: rawText.length, promptHash });
       console.log(`
-\u2705 Sequence generation successful on attempt ${attempt} (${duration}ms)`);
+\u2705 FITB generation successful on attempt ${attempt} (${duration}ms)`);
       if (attempt > 1) DebugLogger.logAttemptSummary(attemptResults);
       return { question: validatedQuestion };
     } catch (error) {
@@ -9151,18 +9113,19 @@ async function generateSequenceQuestion(clientInput, apiKey) {
     }
   }
   DebugLogger.logAttemptSummary(attemptResults);
-  const errorMessage = `Failed to generate Sequence question after ${MAX_RETRY_ATTEMPTS6} attempts. Last error: ${lastError?.message}`;
+  const errorMessage = `Failed to generate FITB question after ${MAX_RETRY_ATTEMPTS6} attempts. Last error: ${lastError?.message}`;
   console.error("\n\u274C Final Result: FAILED");
   console.error(errorMessage);
   return { error: errorMessage };
 }
 BaseQuestionGenerationClientInputSchema.extend({
-  isCaseSensitive: zod.z.boolean().optional().default(false)
+  numberOfItems: zod.z.number().int().min(2).max(10).optional().default(4)
 });
-var AIShortAnswerOutputFieldsSchema = zod.z.object({
-  prompt: zod.z.string().describe("The question text that prompts the user for a short answer."),
-  acceptedAnswers: zod.z.array(zod.z.string().min(1)).min(1).describe("An array of one or more acceptable short answers. Include common variations if applicable."),
-  // isCaseSensitive không cần thiết ở đây, chúng ta sẽ quản lý nó ở phía client
+var AISequenceOutputFieldsSchema = zod.z.object({
+  prompt: zod.z.string().describe("The instructional text for the user, e.g., 'Arrange the steps in the correct order.'"),
+  // Yêu cầu AI cung cấp các item dưới dạng một mảng duy nhất đã được sắp xếp đúng thứ tự
+  // Điều này đơn giản hóa logic và giảm rủi ro
+  itemsInCorrectOrder: zod.z.array(zod.z.string().min(1)).min(2).describe("An array of strings, with each string representing an item to be sequenced. The array itself MUST be in the correct final order."),
   explanation: zod.z.string().optional(),
   points: zod.z.number().optional().default(10),
   difficulty: zod.z.enum(["easy", "medium", "hard"]).optional(),
@@ -9171,52 +9134,58 @@ var AIShortAnswerOutputFieldsSchema = zod.z.object({
   // Thêm để xác thực
 });
 
-// src/ai/flows/question-gen/generate-short-answer-question.ts
+// src/ai/flows/question-gen/generate-sequence-question.ts
 var MAX_RETRY_ATTEMPTS7 = 3;
 var RETRY_DELAY_MS7 = 3e3;
 function buildEnhancedPrompt7(clientInput, attemptNumber) {
-  const { quizContext, language: language3, difficulty, imageUrl } = clientInput;
+  const { quizContext, language: language3, difficulty, numberOfItems, imageUrl } = clientInput;
   const category = quizContext?.originalCategory || "the specified technical category";
   const attemptInfo = attemptNumber > 1 ? `
 ## DEBUG INFO - This is attempt #${attemptNumber}
-Previous attempts failed. Ensure 'acceptedAnswers' is a non-empty array of strings and the JSON is valid.
+Previous attempts failed. Ensure the 'itemsInCorrectOrder' array has exactly the required number of items and the JSON is valid.
 
 ` : "";
-  const imageContextInstruction = imageUrl ? `**Image Context:** You MUST analyze the provided image. The question and its short answer must be directly related to the content of this image.` : "";
+  const imageContextInstruction = imageUrl ? `**Image Context:** You MUST analyze the provided image. The sequence of items must be directly related to the process or content shown in this image.` : "";
   const contextStrings = [
     `**Required Category:** ${category}`,
     quizContext?.loDescription && `**Learning Objective:** ${quizContext.loDescription}`,
     imageContextInstruction,
     quizContext?.plannedBloomLevel && `**Cognitive Level (Bloom's):** ${quizContext.plannedBloomLevel}`,
-    quizContext?.targetMisconception && `**Target Misconception:** The question should require an answer that corrects this specific misconception: "${quizContext.targetMisconception}"`
+    quizContext?.targetMisconception && `**Target Misconception:** The sequence should clarify this specific process error: "${quizContext.targetMisconception}"`
   ].filter(Boolean).map((s2) => `- ${s2}`).join("\n");
   const exampleJson = JSON.stringify({
-    prompt: "In Swift, what keyword is used to declare a constant?",
-    acceptedAnswers: ["let"],
-    explanation: "The 'let' keyword is used to declare constants, which are values that cannot be changed after they are set. 'var' is used for variables.",
+    prompt: "Arrange the steps to make a network request in Swift using URLSession.",
+    itemsInCorrectOrder: [
+      "Create a URL object.",
+      "Create a URLSessionDataTask with the URL.",
+      "Start the task by calling its resume() method.",
+      "Handle the completion handler with data, response, and error."
+    ],
+    explanation: "This is the fundamental sequence for a basic data task in URLSession.",
     points: 10,
-    difficulty: "easy",
-    topic: "Swift Constants",
+    difficulty: "medium",
+    topic: "Swift Networking",
     verifiedCategory: category
   }, null, 2);
   return `${attemptInfo}You are an expert Question Author for advanced technical education, specializing in: ${category}.
-Your mission is to create a high-quality, technically accurate Short Answer Question.
+Your mission is to create a high-quality, technically accurate Sequence Question.
 
 ## Core Rules (Non-negotiable)
 1.  **Category Purity:** The question MUST be exclusively about **${category}**.
-2.  **Objective Answer:** The question must have a short, factual, and objective answer. Avoid questions that are subjective or require long explanations.
-3.  **Schema Integrity:** The response MUST be ONLY a single, valid JSON object.
+2.  **Unambiguous Order:** The items MUST represent a clear, objective process, timeline, or order with only one correct sequence.
+3.  **Schema Integrity:** The response MUST be ONLY a single, valid JSON object that strictly follows the provided schema.
 
 ## CRITICAL CONTEXT FOR THIS QUESTION
 ${contextStrings}
 
 ## Task: Generate the Question
-Based on all the rules and context above, generate a single Short Answer Question.
+Based on all the rules and context above, generate a single Sequence Question.
 
 ### Input Parameters
 - **Topic for Question:** ${quizContext?.plannedTopic || "General"}
 - **Language for Text:** ${language3}
 - **Difficulty Level:** ${difficulty}
+- **Number of Items:** Generate an array 'itemsInCorrectOrder' containing exactly ${numberOfItems} items. The array itself MUST be in the correct final sequence.
 
 ### Required JSON Output Format
 Your response must be ONLY the JSON object, matching this exact structure:
@@ -9225,11 +9194,11 @@ ${exampleJson}
 
 Now, generate the JSON for the requested question.`;
 }
-async function generateShortAnswerQuestion(clientInput, apiKey) {
+async function generateSequenceQuestion(clientInput, apiKey) {
   const ai = new genai.GoogleGenAI({ apiKey });
   const model = "gemini-2.5-flash";
   const config2 = {
-    temperature: 0.5,
+    temperature: 0.7,
     responseMimeType: "application/json",
     thinkingConfig: {
       thinkingBudget: 4e3
@@ -9258,8 +9227,11 @@ async function generateShortAnswerQuestion(clientInput, apiKey) {
       if (!rawText) throw new Error("AI returned an empty response.");
       const parsedJson = JSON.parse(rawText);
       DebugLogger.logValidation(attempt, "JSON Parsed Successfully", parsedJson);
-      const aiGeneratedContent = AIShortAnswerOutputFieldsSchema.parse(parsedJson);
+      const aiGeneratedContent = AISequenceOutputFieldsSchema.parse(parsedJson);
       DebugLogger.logValidation(attempt, "Zod Schema Validated", aiGeneratedContent);
+      if (aiGeneratedContent.itemsInCorrectOrder.length !== clientInput.numberOfItems) {
+        throw new Error(`AI generated ${aiGeneratedContent.itemsInCorrectOrder.length} items, but ${clientInput.numberOfItems} were required.`);
+      }
       if (clientInput.quizContext?.originalCategory) {
         const verifiedCategory = aiGeneratedContent.verifiedCategory?.toLowerCase();
         const requiredCategory = clientInput.quizContext.originalCategory.toLowerCase();
@@ -9267,12 +9239,19 @@ async function generateShortAnswerQuestion(clientInput, apiKey) {
           throw new Error(`Category mismatch: Required ${requiredCategory}, got ${verifiedCategory}`);
         }
       }
+      const finalItems = [];
+      const finalCorrectOrder = [];
+      aiGeneratedContent.itemsInCorrectOrder.forEach((content4) => {
+        const id2 = generateUniqueId("seqi_");
+        finalItems.push({ id: id2, content: content4 });
+        finalCorrectOrder.push(id2);
+      });
       const completeQuestion = {
-        id: generateUniqueId("saq_ai_"),
-        questionType: "short_answer",
+        id: generateUniqueId("seq_ai_"),
+        questionType: "sequence",
         prompt: aiGeneratedContent.prompt,
-        acceptedAnswers: aiGeneratedContent.acceptedAnswers,
-        isCaseSensitive: clientInput.isCaseSensitive,
+        items: finalItems,
+        correctOrder: finalCorrectOrder,
         explanation: aiGeneratedContent.explanation,
         points: aiGeneratedContent.points,
         topic: aiGeneratedContent.topic || clientInput.quizContext?.originalTopic,
@@ -9284,10 +9263,10 @@ async function generateShortAnswerQuestion(clientInput, apiKey) {
         category: clientInput.quizContext?.originalCategory,
         imageUrl: clientInput.imageUrl
       };
-      const validatedQuestion = ShortAnswerQuestionZodSchema.parse(completeQuestion);
+      const validatedQuestion = SequenceQuestionZodSchema.parse(completeQuestion);
       attemptResults.push({ success: true, duration, promptLength: promptText.length, responseLength: rawText.length, promptHash });
       console.log(`
-\u2705 Short Answer generation successful on attempt ${attempt} (${duration}ms)`);
+\u2705 Sequence generation successful on attempt ${attempt} (${duration}ms)`);
       if (attempt > 1) DebugLogger.logAttemptSummary(attemptResults);
       return { question: validatedQuestion };
     } catch (error) {
@@ -9303,16 +9282,22 @@ async function generateShortAnswerQuestion(clientInput, apiKey) {
     }
   }
   DebugLogger.logAttemptSummary(attemptResults);
-  const errorMessage = `Failed to generate Short Answer question after ${MAX_RETRY_ATTEMPTS7} attempts. Last error: ${lastError?.message}`;
+  const errorMessage = `Failed to generate Sequence question after ${MAX_RETRY_ATTEMPTS7} attempts. Last error: ${lastError?.message}`;
   console.error("\n\u274C Final Result: FAILED");
   console.error(errorMessage);
   return { error: errorMessage };
 }
-BaseQuestionGenerationClientInputSchema.extend({});
-var AITrueFalseOutputFieldsSchema = zod.z.object({
-  prompt: zod.z.string().describe("The statement that the user will evaluate as true or false."),
-  correctAnswer: zod.z.boolean(),
-  explanation: zod.z.string().optional().describe("An explanation of why the statement is true or false, especially important if false."),
+BaseQuestionGenerationClientInputSchema.extend({
+  numberOfPairs: zod.z.number().int().min(2).max(8).optional().default(4),
+  shuffleOptions: zod.z.boolean().optional().default(true)
+});
+var AIMatchingOutputFieldsSchema = zod.z.object({
+  prompt: zod.z.string().describe("The instructional text for the user, e.g., 'Match the concept to its definition.'"),
+  correctPairs: zod.z.array(zod.z.object({
+    promptText: zod.z.string().min(1).describe("The text for the left-hand side item (the prompt)."),
+    optionText: zod.z.string().min(1).describe("The text for the right-hand side item (the matching option).")
+  })).min(2),
+  explanation: zod.z.string().optional(),
   points: zod.z.number().optional().default(10),
   difficulty: zod.z.enum(["easy", "medium", "hard"]).optional(),
   topic: zod.z.string().optional(),
@@ -9320,55 +9305,57 @@ var AITrueFalseOutputFieldsSchema = zod.z.object({
   // Thêm để xác thực
 });
 
-// src/ai/flows/question-gen/generate-true-false-question.ts
+// src/ai/flows/question-gen/generate-matching-question.ts
 var MAX_RETRY_ATTEMPTS8 = 3;
 var RETRY_DELAY_MS8 = 3e3;
 function buildEnhancedPrompt8(clientInput, attemptNumber) {
-  const { quizContext, language: language3, difficulty, imageUrl } = clientInput;
+  const { quizContext, language: language3, difficulty, numberOfPairs, imageUrl } = clientInput;
   const category = quizContext?.originalCategory || "the specified technical category";
   const attemptInfo = attemptNumber > 1 ? `
 ## DEBUG INFO - This is attempt #${attemptNumber}
-Previous attempts failed. Ensure the JSON is valid and 'correctAnswer' is a boolean.
+Previous attempts failed. Please ensure the 'correctPairs' array has exactly the required number of items and the JSON is valid.
 
 ` : "";
-  const imageContextInstruction = imageUrl ? `**Image Context:** You MUST analyze the provided image. The True/False statement must be directly related to the content of this image.` : "";
-  const misconceptionGuidance = quizContext?.targetMisconception ? `**Target Misconception:** The statement you create MUST be FALSE and based on this common mistake: "${quizContext.targetMisconception}"` : "";
+  const imageContextInstruction = imageUrl ? `**Image Context:** You MUST analyze the provided image. The matching pairs must be directly related to the content of this image.` : "";
   const contextStrings = [
     `**Required Category:** ${category}`,
     quizContext?.loDescription && `**Learning Objective:** ${quizContext.loDescription}`,
     imageContextInstruction,
     quizContext?.plannedBloomLevel && `**Cognitive Level (Bloom's):** ${quizContext.plannedBloomLevel}`,
-    misconceptionGuidance,
-    quizContext?.difficultyReason && `**Pedagogical Reason:** ${quizContext.difficultyReason}`
+    quizContext?.targetMisconception && `**Target Misconception:** Design a pair that specifically tests this confusion: "${quizContext.targetMisconception}"`
   ].filter(Boolean).map((s2) => `- ${s2}`).join("\n");
   const exampleJson = JSON.stringify({
-    prompt: "In Swift, you must explicitly unwrap an Optional value before you can use its stored value.",
-    correctAnswer: true,
-    explanation: "Optional values in Swift represent the presence or absence of a value. To access the value when it exists, you must unwrap it using methods like 'if let', 'guard let', or the force unwrap operator '!'.",
+    prompt: "Match each Swift collection type to its primary characteristic.",
+    correctPairs: [
+      { "promptText": "Array", "optionText": "An ordered, random-access collection." },
+      { "promptText": "Set", "optionText": "An unordered collection of unique elements." },
+      { "promptText": "Dictionary", "optionText": "An unordered collection of key-value associations." }
+    ],
+    explanation: "These are the fundamental characteristics of Swift's main collection types.",
     points: 10,
     difficulty: "easy",
-    topic: "Swift Optionals",
+    topic: "Swift Collection Types",
     verifiedCategory: category
   }, null, 2);
   return `${attemptInfo}You are an expert Question Author for advanced technical education, specializing in: ${category}.
-Your mission is to create a high-quality, technically accurate True/False Question.
+Your mission is to create a high-quality, technically accurate Matching Question.
 
 ## Core Rules (Non-negotiable)
-1.  **Category Purity:** The statement ('prompt') MUST be exclusively about **${category}**.
-2.  **Clarity:** The statement must be definitively true or false, with no ambiguity.
-3.  **Misconception Priority:** If a Target Misconception is provided, the statement MUST be FALSE and reflect that misconception. This is a critical rule.
-4.  **Schema Integrity:** The response MUST be ONLY a single, valid JSON object.
+1.  **Category Purity:** The question MUST be exclusively about **${category}**.
+2.  **Logical Pairs:** The items to be matched must have a clear, one-to-one relationship.
+3.  **Schema Integrity:** The response MUST be ONLY a single, valid JSON object that strictly follows the provided schema.
 
 ## CRITICAL CONTEXT FOR THIS QUESTION
 ${contextStrings}
 
 ## Task: Generate the Question
-Based on all the rules and context above, generate a single True/False Question.
+Based on all the rules and context above, generate a single Matching Question.
 
 ### Input Parameters
 - **Topic for Question:** ${quizContext?.plannedTopic || "General"}
 - **Language for Text:** ${language3}
 - **Difficulty Level:** ${difficulty}
+- **Number of Pairs:** Generate exactly ${numberOfPairs} correct pairs in the 'correctPairs' array.
 
 ### Required JSON Output Format
 Your response must be ONLY the JSON object, matching this exact structure:
@@ -9377,11 +9364,11 @@ ${exampleJson}
 
 Now, generate the JSON for the requested question.`;
 }
-async function generateTrueFalseQuestion(clientInput, apiKey) {
+async function generateMatchingQuestion(clientInput, apiKey) {
   const ai = new genai.GoogleGenAI({ apiKey });
   const model = "gemini-2.5-flash";
   const config2 = {
-    temperature: 0.6,
+    temperature: 0.8,
     responseMimeType: "application/json",
     thinkingConfig: {
       thinkingBudget: 4e3
@@ -9410,10 +9397,10 @@ async function generateTrueFalseQuestion(clientInput, apiKey) {
       if (!rawText) throw new Error("AI returned an empty response.");
       const parsedJson = JSON.parse(rawText);
       DebugLogger.logValidation(attempt, "JSON Parsed Successfully", parsedJson);
-      const aiGeneratedContent = AITrueFalseOutputFieldsSchema.parse(parsedJson);
+      const aiGeneratedContent = AIMatchingOutputFieldsSchema.parse(parsedJson);
       DebugLogger.logValidation(attempt, "Zod Schema Validated", aiGeneratedContent);
-      if (clientInput.quizContext?.targetMisconception && aiGeneratedContent.correctAnswer === true) {
-        throw new Error("AI failed to follow the Misconception Priority rule. The answer should have been false.");
+      if (aiGeneratedContent.correctPairs.length !== clientInput.numberOfPairs) {
+        throw new Error(`AI generated ${aiGeneratedContent.correctPairs.length} pairs, but ${clientInput.numberOfPairs} were required.`);
       }
       if (clientInput.quizContext?.originalCategory) {
         const verifiedCategory = aiGeneratedContent.verifiedCategory?.toLowerCase();
@@ -9422,11 +9409,24 @@ async function generateTrueFalseQuestion(clientInput, apiKey) {
           throw new Error(`Category mismatch: Required ${requiredCategory}, got ${verifiedCategory}`);
         }
       }
+      const finalPrompts = [];
+      const finalOptions = [];
+      const finalCorrectAnswerMap = [];
+      aiGeneratedContent.correctPairs.forEach((pair2) => {
+        const promptId = generateUniqueId("m_p_");
+        const optionId = generateUniqueId("m_o_");
+        finalPrompts.push({ id: promptId, content: pair2.promptText });
+        finalOptions.push({ id: optionId, content: pair2.optionText });
+        finalCorrectAnswerMap.push({ promptId, optionId });
+      });
       const completeQuestion = {
-        id: generateUniqueId("tf_ai_"),
-        questionType: "true_false",
+        id: generateUniqueId("match_ai_"),
+        questionType: "matching",
         prompt: aiGeneratedContent.prompt,
-        correctAnswer: aiGeneratedContent.correctAnswer,
+        prompts: finalPrompts,
+        options: finalOptions,
+        correctAnswerMap: finalCorrectAnswerMap,
+        shuffleOptions: clientInput.shuffleOptions,
         explanation: aiGeneratedContent.explanation,
         points: aiGeneratedContent.points,
         topic: aiGeneratedContent.topic || clientInput.quizContext?.originalTopic,
@@ -9438,10 +9438,10 @@ async function generateTrueFalseQuestion(clientInput, apiKey) {
         category: clientInput.quizContext?.originalCategory,
         imageUrl: clientInput.imageUrl
       };
-      const validatedQuestion = TrueFalseQuestionZodSchema.parse(completeQuestion);
+      const validatedQuestion = MatchingQuestionZodSchema.parse(completeQuestion);
       attemptResults.push({ success: true, duration, promptLength: promptText.length, responseLength: rawText.length, promptHash });
       console.log(`
-\u2705 True/False generation successful on attempt ${attempt} (${duration}ms)`);
+\u2705 Matching generation successful on attempt ${attempt} (${duration}ms)`);
       if (attempt > 1) DebugLogger.logAttemptSummary(attemptResults);
       return { question: validatedQuestion };
     } catch (error) {
@@ -9457,7 +9457,167 @@ async function generateTrueFalseQuestion(clientInput, apiKey) {
     }
   }
   DebugLogger.logAttemptSummary(attemptResults);
-  const errorMessage = `Failed to generate True/False question after ${MAX_RETRY_ATTEMPTS8} attempts. Last error: ${lastError?.message}`;
+  const errorMessage = `Failed to generate Matching question after ${MAX_RETRY_ATTEMPTS8} attempts. Last error: ${lastError?.message}`;
+  console.error("\n\u274C Final Result: FAILED");
+  console.error(errorMessage);
+  return { error: errorMessage };
+}
+BaseQuestionGenerationClientInputSchema.extend({
+  codingLanguage: zod.z.enum(["cpp", "javascript", "python", "swift", "csharp"])
+});
+var AICodingQuestionOutputSchema = zod.z.object({
+  prompt: zod.z.string().describe("The problem description for the user."),
+  functionSignature: zod.z.string().optional().describe("A suggested function signature for the user to implement."),
+  solutionCode: zod.z.string().describe("A complete, correct model solution in the specified language."),
+  testCases: zod.z.array(zod.z.object({
+    input: zod.z.array(zod.z.any()),
+    // FIX: Use .refine to make it explicitly non-optional for TypeScript's inference
+    expectedOutput: zod.z.any().refine((val) => val !== void 0, {
+      message: "expectedOutput is required and cannot be undefined."
+    }),
+    isPublic: zod.z.boolean()
+  })).min(3, { message: "Must provide at least 3 test cases." }),
+  verifiedCodingLanguage: zod.z.enum(["cpp", "javascript", "python", "swift", "csharp"]).optional().describe("The programming language this question actually addresses.")
+});
+
+// src/ai/flows/question-gen/generate-coding-question.ts
+var MAX_RETRY_ATTEMPTS9 = 3;
+var RETRY_DELAY_MS9 = 3e3;
+function buildEnhancedPrompt9(clientInput, attemptNumber) {
+  const { quizContext, difficulty, codingLanguage, language: language3, imageUrl } = clientInput;
+  const subject = quizContext?.originalSubject || codingLanguage;
+  const attemptInfo = attemptNumber > 1 ? `
+## DEBUG INFO - This is attempt #${attemptNumber}
+Previous attempts failed. Pay strict attention to the JSON schema and all rules. Ensure every object in the 'testCases' array has a non-null 'expectedOutput' field.
+
+` : "";
+  const imageContextInstruction = imageUrl ? `**Image Context:** You MUST analyze the provided image. The coding problem must be directly related to processing or interpreting the content of this image.` : "";
+  const contextStrings = [
+    `**Subject:** ${subject}`,
+    quizContext?.loDescription && `**Learning Objective:** ${quizContext.loDescription}`,
+    imageContextInstruction,
+    quizContext?.plannedBloomLevel && `**Cognitive Level (Bloom's):** ${quizContext.plannedBloomLevel}`,
+    quizContext?.targetMisconception && `**Target Misconception:** The problem should test against this common error: "${quizContext.targetMisconception}"`
+  ].filter(Boolean).map((s2) => `- ${s2}`).join("\n");
+  const exampleJson = JSON.stringify({
+    prompt: "Write a function named 'add' that takes two integers and returns their sum.",
+    functionSignature: "function add(a, b) { ... }",
+    solutionCode: "function add(a, b) {\n  return a + b;\n}",
+    testCases: [
+      { "input": [1, 2], "expectedOutput": 3, "isPublic": true },
+      { "input": [-1, 1], "expectedOutput": 0, "isPublic": true },
+      { "input": [0, 0], "expectedOutput": 0, "isPublic": false }
+    ],
+    verifiedCodingLanguage: "javascript"
+  }, null, 2);
+  return `${attemptInfo}You are an expert programming problem designer for ${subject}.
+Generate a single, high-quality Coding question.
+
+## Core Rules
+1.  **Language Purity:** All code ('functionSignature', 'solutionCode') MUST be in **${codingLanguage}**.
+2.  **Context Adherence:** The problem MUST be directly related to the provided context.
+3.  **Format Integrity:** You MUST return ONLY a single, valid JSON object.
+4.  **Test Case Integrity:** Every test case object in the 'testCases' array MUST have a non-null and defined 'expectedOutput' field. This is a critical rule.
+
+## CRITICAL CONTEXT FOR THIS QUESTION
+${contextStrings}
+
+## Task: Generate the Question
+### Input Parameters
+- **Topic for Question:** ${quizContext?.plannedTopic || "General"}
+- **Natural Language for Text:** ${language3}
+- **Coding Language:** ${codingLanguage}
+- **Difficulty Level:** ${difficulty}
+
+### Required JSON Output Format
+Your response must be ONLY the JSON object, matching this exact structure:
+
+${exampleJson}
+
+Now, generate the JSON for the requested question.`;
+}
+async function generateCodingQuestion(clientInput, apiKey) {
+  const ai = new genai.GoogleGenAI({ apiKey });
+  const model = "gemini-2.5-flash";
+  const config2 = {
+    temperature: 0.5,
+    responseMimeType: "application/json",
+    thinkingConfig: {
+      thinkingBudget: 5e3
+    }
+  };
+  const attemptResults = [];
+  let lastError = null;
+  for (let attempt = 1; attempt <= MAX_RETRY_ATTEMPTS9; attempt++) {
+    const startTime = Date.now();
+    const promptText = buildEnhancedPrompt9(clientInput, attempt);
+    const promptHash = Buffer.from(promptText).toString("base64").slice(0, 10);
+    try {
+      DebugLogger.logPrompt(attempt, promptText, { ...clientInput, attemptNumber: attempt, promptHash });
+      const parts = [{ text: promptText }];
+      if (clientInput.imageUrl) {
+        const mimeType = clientInput.imageUrl.endsWith(".png") ? "image/png" : "image/jpeg";
+        const imagePart = await urlToGenerativePart(clientInput.imageUrl, mimeType);
+        parts.unshift(imagePart);
+      }
+      const contents = [{ role: "user", parts }];
+      const aiResult = await ai.models.generateContent({ model, config: config2, contents });
+      const response = aiResult;
+      const rawText = response.candidates?.[0]?.content?.parts?.[0]?.text || "";
+      const duration = Date.now() - startTime;
+      DebugLogger.logResponse(attempt, rawText);
+      if (!rawText) throw new Error("AI returned an empty response.");
+      const parsedJson = JSON.parse(rawText);
+      DebugLogger.logValidation(attempt, "JSON Parsed Successfully", parsedJson);
+      const aiGeneratedContent = AICodingQuestionOutputSchema.parse(parsedJson);
+      DebugLogger.logValidation(attempt, "Zod Schema Validated", aiGeneratedContent);
+      if (aiGeneratedContent.verifiedCodingLanguage && aiGeneratedContent.verifiedCodingLanguage !== clientInput.codingLanguage) {
+        throw new Error(`Language mismatch: Required ${clientInput.codingLanguage}, but AI generated for ${aiGeneratedContent.verifiedCodingLanguage}.`);
+      }
+      const testCases = aiGeneratedContent.testCases.map((tc) => ({
+        id: generateUniqueId("tc_"),
+        input: tc.input,
+        expectedOutput: tc.expectedOutput,
+        isPublic: tc.isPublic
+      }));
+      const completeQuestion = {
+        id: generateUniqueId("coding_"),
+        questionType: "coding",
+        prompt: aiGeneratedContent.prompt,
+        codingLanguage: clientInput.codingLanguage,
+        functionSignature: aiGeneratedContent.functionSignature,
+        solutionCode: aiGeneratedContent.solutionCode,
+        testCases,
+        points: 25,
+        topic: clientInput.quizContext?.originalTopic,
+        difficulty: clientInput.difficulty,
+        contextCode: clientInput.quizContext?.plannedContextId,
+        bloomLevel: clientInput.quizContext?.plannedBloomLevel,
+        learningObjective: clientInput.quizContext?.originalLoId,
+        subject: clientInput.quizContext?.originalSubject,
+        category: clientInput.quizContext?.originalCategory,
+        imageUrl: clientInput.imageUrl
+      };
+      CodingQuestionZodSchema.parse(completeQuestion);
+      attemptResults.push({ success: true, duration, promptLength: promptText.length, responseLength: rawText.length, promptHash });
+      console.log(`
+\u2705 Coding question generation successful on attempt ${attempt} (${duration}ms)`);
+      if (attempt > 1) DebugLogger.logAttemptSummary(attemptResults);
+      return { question: completeQuestion };
+    } catch (error) {
+      lastError = error;
+      const duration = Date.now() - startTime;
+      attemptResults.push({ success: false, duration, error: error.message, promptLength: promptText.length, promptHash });
+      const willRetry = attempt < MAX_RETRY_ATTEMPTS9;
+      DebugLogger.logRetryInfo(attempt, error, willRetry);
+      if (willRetry) {
+        console.log(`\u23F3 Retrying in ${RETRY_DELAY_MS9}ms...`);
+        await new Promise((resolve) => setTimeout(resolve, RETRY_DELAY_MS9));
+      }
+    }
+  }
+  DebugLogger.logAttemptSummary(attemptResults);
+  const errorMessage = `Failed to generate Coding question after ${MAX_RETRY_ATTEMPTS9} attempts. Last error: ${lastError?.message}`;
   console.error("\n\u274C Final Result: FAILED");
   console.error(errorMessage);
   return { error: errorMessage };
@@ -10107,166 +10267,6 @@ TopicDataService.EXPECTED_HEADERS = [
   "STEM Element(s)",
   "Bloom\u2019s Level(s) Guideline"
 ];
-BaseQuestionGenerationClientInputSchema.extend({
-  codingLanguage: zod.z.enum(["cpp", "javascript", "python", "swift", "csharp"])
-});
-var AICodingQuestionOutputSchema = zod.z.object({
-  prompt: zod.z.string().describe("The problem description for the user."),
-  functionSignature: zod.z.string().optional().describe("A suggested function signature for the user to implement."),
-  solutionCode: zod.z.string().describe("A complete, correct model solution in the specified language."),
-  testCases: zod.z.array(zod.z.object({
-    input: zod.z.array(zod.z.any()),
-    // FIX: Use .refine to make it explicitly non-optional for TypeScript's inference
-    expectedOutput: zod.z.any().refine((val) => val !== void 0, {
-      message: "expectedOutput is required and cannot be undefined."
-    }),
-    isPublic: zod.z.boolean()
-  })).min(3, { message: "Must provide at least 3 test cases." }),
-  verifiedCodingLanguage: zod.z.enum(["cpp", "javascript", "python", "swift", "csharp"]).optional().describe("The programming language this question actually addresses.")
-});
-
-// src/ai/flows/question-gen/generate-coding-question.ts
-var MAX_RETRY_ATTEMPTS9 = 3;
-var RETRY_DELAY_MS9 = 3e3;
-function buildEnhancedPrompt9(clientInput, attemptNumber) {
-  const { quizContext, difficulty, codingLanguage, language: language3, imageUrl } = clientInput;
-  const subject = quizContext?.originalSubject || codingLanguage;
-  const attemptInfo = attemptNumber > 1 ? `
-## DEBUG INFO - This is attempt #${attemptNumber}
-Previous attempts failed. Pay strict attention to the JSON schema and all rules. Ensure every object in the 'testCases' array has a non-null 'expectedOutput' field.
-
-` : "";
-  const imageContextInstruction = imageUrl ? `**Image Context:** You MUST analyze the provided image. The coding problem must be directly related to processing or interpreting the content of this image.` : "";
-  const contextStrings = [
-    `**Subject:** ${subject}`,
-    quizContext?.loDescription && `**Learning Objective:** ${quizContext.loDescription}`,
-    imageContextInstruction,
-    quizContext?.plannedBloomLevel && `**Cognitive Level (Bloom's):** ${quizContext.plannedBloomLevel}`,
-    quizContext?.targetMisconception && `**Target Misconception:** The problem should test against this common error: "${quizContext.targetMisconception}"`
-  ].filter(Boolean).map((s2) => `- ${s2}`).join("\n");
-  const exampleJson = JSON.stringify({
-    prompt: "Write a function named 'add' that takes two integers and returns their sum.",
-    functionSignature: "function add(a, b) { ... }",
-    solutionCode: "function add(a, b) {\n  return a + b;\n}",
-    testCases: [
-      { "input": [1, 2], "expectedOutput": 3, "isPublic": true },
-      { "input": [-1, 1], "expectedOutput": 0, "isPublic": true },
-      { "input": [0, 0], "expectedOutput": 0, "isPublic": false }
-    ],
-    verifiedCodingLanguage: "javascript"
-  }, null, 2);
-  return `${attemptInfo}You are an expert programming problem designer for ${subject}.
-Generate a single, high-quality Coding question.
-
-## Core Rules
-1.  **Language Purity:** All code ('functionSignature', 'solutionCode') MUST be in **${codingLanguage}**.
-2.  **Context Adherence:** The problem MUST be directly related to the provided context.
-3.  **Format Integrity:** You MUST return ONLY a single, valid JSON object.
-4.  **Test Case Integrity:** Every test case object in the 'testCases' array MUST have a non-null and defined 'expectedOutput' field. This is a critical rule.
-
-## CRITICAL CONTEXT FOR THIS QUESTION
-${contextStrings}
-
-## Task: Generate the Question
-### Input Parameters
-- **Topic for Question:** ${quizContext?.plannedTopic || "General"}
-- **Natural Language for Text:** ${language3}
-- **Coding Language:** ${codingLanguage}
-- **Difficulty Level:** ${difficulty}
-
-### Required JSON Output Format
-Your response must be ONLY the JSON object, matching this exact structure:
-
-${exampleJson}
-
-Now, generate the JSON for the requested question.`;
-}
-async function generateCodingQuestion(clientInput, apiKey) {
-  const ai = new genai.GoogleGenAI({ apiKey });
-  const model = "gemini-2.5-flash";
-  const config2 = {
-    temperature: 0.5,
-    responseMimeType: "application/json",
-    thinkingConfig: {
-      thinkingBudget: 5e3
-    }
-  };
-  const attemptResults = [];
-  let lastError = null;
-  for (let attempt = 1; attempt <= MAX_RETRY_ATTEMPTS9; attempt++) {
-    const startTime = Date.now();
-    const promptText = buildEnhancedPrompt9(clientInput, attempt);
-    const promptHash = Buffer.from(promptText).toString("base64").slice(0, 10);
-    try {
-      DebugLogger.logPrompt(attempt, promptText, { ...clientInput, attemptNumber: attempt, promptHash });
-      const parts = [{ text: promptText }];
-      if (clientInput.imageUrl) {
-        const mimeType = clientInput.imageUrl.endsWith(".png") ? "image/png" : "image/jpeg";
-        const imagePart = await urlToGenerativePart(clientInput.imageUrl, mimeType);
-        parts.unshift(imagePart);
-      }
-      const contents = [{ role: "user", parts }];
-      const aiResult = await ai.models.generateContent({ model, config: config2, contents });
-      const response = aiResult;
-      const rawText = response.candidates?.[0]?.content?.parts?.[0]?.text || "";
-      const duration = Date.now() - startTime;
-      DebugLogger.logResponse(attempt, rawText);
-      if (!rawText) throw new Error("AI returned an empty response.");
-      const parsedJson = JSON.parse(rawText);
-      DebugLogger.logValidation(attempt, "JSON Parsed Successfully", parsedJson);
-      const aiGeneratedContent = AICodingQuestionOutputSchema.parse(parsedJson);
-      DebugLogger.logValidation(attempt, "Zod Schema Validated", aiGeneratedContent);
-      if (aiGeneratedContent.verifiedCodingLanguage && aiGeneratedContent.verifiedCodingLanguage !== clientInput.codingLanguage) {
-        throw new Error(`Language mismatch: Required ${clientInput.codingLanguage}, but AI generated for ${aiGeneratedContent.verifiedCodingLanguage}.`);
-      }
-      const testCases = aiGeneratedContent.testCases.map((tc) => ({
-        id: generateUniqueId("tc_"),
-        input: tc.input,
-        expectedOutput: tc.expectedOutput,
-        isPublic: tc.isPublic
-      }));
-      const completeQuestion = {
-        id: generateUniqueId("coding_"),
-        questionType: "coding",
-        prompt: aiGeneratedContent.prompt,
-        codingLanguage: clientInput.codingLanguage,
-        functionSignature: aiGeneratedContent.functionSignature,
-        solutionCode: aiGeneratedContent.solutionCode,
-        testCases,
-        points: 25,
-        topic: clientInput.quizContext?.originalTopic,
-        difficulty: clientInput.difficulty,
-        contextCode: clientInput.quizContext?.plannedContextId,
-        bloomLevel: clientInput.quizContext?.plannedBloomLevel,
-        learningObjective: clientInput.quizContext?.originalLoId,
-        subject: clientInput.quizContext?.originalSubject,
-        category: clientInput.quizContext?.originalCategory,
-        imageUrl: clientInput.imageUrl
-      };
-      CodingQuestionZodSchema.parse(completeQuestion);
-      attemptResults.push({ success: true, duration, promptLength: promptText.length, responseLength: rawText.length, promptHash });
-      console.log(`
-\u2705 Coding question generation successful on attempt ${attempt} (${duration}ms)`);
-      if (attempt > 1) DebugLogger.logAttemptSummary(attemptResults);
-      return { question: completeQuestion };
-    } catch (error) {
-      lastError = error;
-      const duration = Date.now() - startTime;
-      attemptResults.push({ success: false, duration, error: error.message, promptLength: promptText.length, promptHash });
-      const willRetry = attempt < MAX_RETRY_ATTEMPTS9;
-      DebugLogger.logRetryInfo(attempt, error, willRetry);
-      if (willRetry) {
-        console.log(`\u23F3 Retrying in ${RETRY_DELAY_MS9}ms...`);
-        await new Promise((resolve) => setTimeout(resolve, RETRY_DELAY_MS9));
-      }
-    }
-  }
-  DebugLogger.logAttemptSummary(attemptResults);
-  const errorMessage = `Failed to generate Coding question after ${MAX_RETRY_ATTEMPTS9} attempts. Last error: ${lastError?.message}`;
-  console.error("\n\u274C Final Result: FAILED");
-  console.error(errorMessage);
-  return { error: errorMessage };
-}
 
 // src/ai/flows/generate-questions-from-quiz-plan.ts
 var MAX_ATTEMPTS = 3;
@@ -105746,6 +105746,7 @@ exports.assessAndMapDocument = assessAndMapDocument;
 exports.cn = cn;
 exports.emptyQuiz = emptyQuiz;
 exports.exportQuizAsSCORMZip = exportQuizAsSCORMZip;
+exports.generateCodingQuestion = generateCodingQuestion;
 exports.generateFillInTheBlanksQuestion = generateFillInTheBlanksQuestion;
 exports.generateLauncherHTML = generateLauncherHTML;
 exports.generateLearningAnalysis = generateLearningAnalysis;