@thanh01.pmt/interactive-quiz-kit 1.0.22 → 1.0.23

package/dist/ai.cjs

@@ -0,0 +1,3595 @@
+'use strict';
+
+var genai = require('@google/genai');
+var zod = require('zod');
+var genkit = require('genkit');
+var googleai = require('@genkit-ai/googleai');
+
+var __defProp = Object.defineProperty;
+var __defProps = Object.defineProperties;
+var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
+var __getOwnPropSymbols = Object.getOwnPropertySymbols;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __propIsEnum = Object.prototype.propertyIsEnumerable;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp.call(b, prop))
+      __defNormalProp(a, prop, b[prop]);
+  if (__getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(b)) {
+      if (__propIsEnum.call(b, prop))
+        __defNormalProp(a, prop, b[prop]);
+    }
+  return a;
+};
+var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
+var __objRest = (source, exclude) => {
+  var target = {};
+  for (var prop in source)
+    if (__hasOwnProp.call(source, prop) && exclude.indexOf(prop) < 0)
+      target[prop] = source[prop];
+  if (source != null && __getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(source)) {
+      if (exclude.indexOf(prop) < 0 && __propIsEnum.call(source, prop))
+        target[prop] = source[prop];
+    }
+  return target;
+};
+
+// src/utils/idGenerators.ts
+function generateUniqueId(prefix = "id_") {
+  return prefix + Date.now().toString(36) + Math.random().toString(36).substring(2, 7);
+}
+var DebugLogger = class {
+  static formatTimestamp() {
+    return (/* @__PURE__ */ new Date()).toISOString();
+  }
+  static logPrompt(attempt, prompt, inputContext) {
+    console.log("\n" + "=".repeat(80));
+    console.log(`[${this.formatTimestamp()}] \u{1F50D} PROMPT DEBUG - Attempt ${attempt}`);
+    console.log("=".repeat(80));
+    console.log("Input Context:", JSON.stringify(inputContext, null, 2));
+    console.log("\n" + "-".repeat(40) + " FULL PROMPT " + "-".repeat(40));
+    console.log(prompt);
+    console.log("-".repeat(90));
+    console.log("Prompt Length:", prompt.length, "characters");
+    console.log("=".repeat(80) + "\n");
+  }
+  static logResponse(attempt, rawResponse) {
+    console.log("\n" + "=".repeat(80));
+    console.log(`[${this.formatTimestamp()}] \u{1F4DD} AI RESPONSE - Attempt ${attempt}`);
+    console.log("=".repeat(80));
+    console.log("Raw Response Length:", rawResponse.length, "characters");
+    console.log("\n" + "-".repeat(40) + " FULL RESPONSE " + "-".repeat(39));
+    console.log(rawResponse);
+    console.log("-".repeat(90));
+    console.log("=".repeat(80) + "\n");
+  }
+  static logValidation(attempt, step, data) {
+    console.log(`[${this.formatTimestamp()}] \u2705 VALIDATION - Attempt ${attempt} - ${step}`);
+    console.log(JSON.stringify(data, null, 2));
+    console.log("-".repeat(50));
+  }
+  static logRetryInfo(attempt, error, willRetry) {
+    console.log("\n" + "=".repeat(80));
+    console.log(`[${this.formatTimestamp()}] \u26A0\uFE0F  RETRY INFO - Attempt ${attempt}`);
+    console.log("=".repeat(80));
+    console.log("Error Type:", error.constructor.name);
+    console.log("Error Message:", error.message);
+    console.log("Will Retry:", willRetry);
+    if (error.stack) {
+      console.log("Stack Trace:", error.stack);
+    }
+    console.log("=".repeat(80) + "\n");
+  }
+  static logAttemptSummary(attemptResults) {
+    console.log("\n" + "=".repeat(80));
+    console.log(`[${this.formatTimestamp()}] \u{1F4CA} ATTEMPT SUMMARY`);
+    console.log("=".repeat(80));
+    attemptResults.forEach((result, index) => {
+      console.log(`Attempt ${index + 1}:`);
+      console.log(`  Status: ${result.success ? "\u2705 SUCCESS" : "\u274C FAILED"}`);
+      console.log(`  Duration: ${result.duration}ms`);
+      console.log(`  Error: ${result.error || "None"}`);
+      console.log(`  Prompt Length: ${result.promptLength} chars`);
+      console.log(`  Response Length: ${result.responseLength || 0} chars`);
+      console.log("");
+    });
+    console.log("=".repeat(80) + "\n");
+  }
+};
+
+// src/utils/aiUtils.ts
+async function urlToGenerativePart(url, mimeType) {
+  const response = await fetch(url);
+  if (!response.ok) {
+    throw new Error(`Failed to fetch image from URL: ${url}. Status: ${response.status} ${response.statusText}`);
+  }
+  const buffer = await response.arrayBuffer();
+  return {
+    inlineData: {
+      data: Buffer.from(buffer).toString("base64"),
+      mimeType
+    }
+  };
+}
+var QuizContextSchema = zod.z.object({
+  plannedTopic: zod.z.string().optional(),
+  plannedQuestionType: zod.z.string().optional(),
+  plannedBloomLevel: zod.z.string().optional(),
+  plannedContextId: zod.z.string().optional(),
+  targetMisconception: zod.z.string().optional(),
+  difficultyReason: zod.z.string().optional(),
+  topicSpecificity: zod.z.enum(["broad", "focused", "specific"]).optional(),
+  originalLoId: zod.z.string().optional(),
+  originalSubject: zod.z.string().optional(),
+  originalCategory: zod.z.string().optional(),
+  originalTopic: zod.z.string().optional(),
+  loDescription: zod.z.string().optional().describe("The full description of the learning objective for deep context.")
+});
+var BaseQuestionGenerationClientInputSchema = zod.z.object({
+  language: zod.z.string().optional().default("English"),
+  difficulty: zod.z.enum(["easy", "medium", "hard"]),
+  quizContext: QuizContextSchema.optional(),
+  imageUrl: zod.z.string().url().optional().describe("Optional URL of an image to be used as context.")
+});
+var BaseQuestionZodSchema = zod.z.object({
+  id: zod.z.string(),
+  prompt: zod.z.string().min(1),
+  points: zod.z.number().min(0).optional(),
+  explanation: zod.z.string().optional(),
+  difficulty: zod.z.enum(["easy", "medium", "hard"]).optional(),
+  topic: zod.z.string().optional(),
+  category: zod.z.string().optional(),
+  subject: zod.z.string().optional(),
+  learningObjective: zod.z.string().optional(),
+  bloomLevel: zod.z.string().optional(),
+  contextCode: zod.z.string().optional(),
+  gradeBand: zod.z.string().optional(),
+  course: zod.z.string().optional(),
+  glossary: zod.z.array(zod.z.string()).optional()
+});
+var TrueFalseQuestionZodSchema = BaseQuestionZodSchema.extend({
+  questionType: zod.z.literal("true_false"),
+  correctAnswer: zod.z.boolean()
+});
+var MultipleChoiceQuestionZodSchema = BaseQuestionZodSchema.extend({
+  questionType: zod.z.literal("multiple_choice"),
+  options: zod.z.array(zod.z.object({ id: zod.z.string(), text: zod.z.string().min(1) })).min(2),
+  correctAnswerId: zod.z.string()
+}).refine((data) => data.options.some((option) => option.id === data.correctAnswerId), {
+  message: "correctAnswerId must match one of the option IDs",
+  path: ["correctAnswerId"]
+});
+var MultipleResponseQuestionZodSchema = BaseQuestionZodSchema.extend({
+  questionType: zod.z.literal("multiple_response"),
+  options: zod.z.array(zod.z.object({ id: zod.z.string(), text: zod.z.string().min(1) })).min(2),
+  correctAnswerIds: zod.z.array(zod.z.string()).min(1)
+}).refine((data) => data.correctAnswerIds.every((id) => data.options.some((opt) => opt.id === id)), {
+  message: "All correctAnswerIds must exist in the options array",
+  path: ["correctAnswerIds"]
+});
+var ShortAnswerQuestionZodSchema = BaseQuestionZodSchema.extend({
+  questionType: zod.z.literal("short_answer"),
+  acceptedAnswers: zod.z.array(zod.z.string().min(1)).min(1),
+  isCaseSensitive: zod.z.boolean().optional()
+});
+var NumericQuestionZodSchema = BaseQuestionZodSchema.extend({
+  questionType: zod.z.literal("numeric"),
+  answer: zod.z.number(),
+  tolerance: zod.z.number().min(0).optional()
+});
+var FillInTheBlanksQuestionZodSchema = BaseQuestionZodSchema.extend({
+  questionType: zod.z.literal("fill_in_the_blanks"),
+  segments: zod.z.array(zod.z.object({
+    type: zod.z.enum(["text", "blank"]),
+    content: zod.z.string().optional(),
+    id: zod.z.string().optional()
+  })).min(1),
+  answers: zod.z.array(zod.z.object({
+    blankId: zod.z.string(),
+    acceptedValues: zod.z.array(zod.z.string().min(1)).min(1)
+  })).min(1),
+  isCaseSensitive: zod.z.boolean().optional()
+}).refine((data) => {
+  const segmentBlankIds = new Set(data.segments.filter((s) => s.type === "blank" && s.id).map((s) => s.id));
+  const answerBlankIds = new Set(data.answers.map((a) => a.blankId));
+  return segmentBlankIds.size === answerBlankIds.size && [...segmentBlankIds].every((id) => answerBlankIds.has(id));
+}, { message: "Mismatch between defined blanks in segments and their answers.", path: ["answers"] });
+var SequenceQuestionZodSchema = BaseQuestionZodSchema.extend({
+  questionType: zod.z.literal("sequence"),
+  items: zod.z.array(zod.z.object({ id: zod.z.string(), content: zod.z.string().min(1) })).min(2),
+  correctOrder: zod.z.array(zod.z.string()).min(2)
+}).refine((data) => new Set(data.correctOrder).size === data.items.length, {
+  message: "correctOrder must contain all unique item IDs exactly once.",
+  path: ["correctOrder"]
+});
+var MatchingQuestionZodSchema = BaseQuestionZodSchema.extend({
+  questionType: zod.z.literal("matching"),
+  prompts: zod.z.array(zod.z.object({ id: zod.z.string(), content: zod.z.string().min(1) })).min(2),
+  options: zod.z.array(zod.z.object({ id: zod.z.string(), content: zod.z.string().min(1) })).min(2),
+  correctAnswerMap: zod.z.array(zod.z.object({ promptId: zod.z.string(), optionId: zod.z.string() })).min(2),
+  shuffleOptions: zod.z.boolean().optional()
+}).refine((data) => data.prompts.length === data.correctAnswerMap.length, {
+  message: "Each prompt must have exactly one corresponding answer in the map.",
+  path: ["correctAnswerMap"]
+});
+var CodingQuestionZodSchema = BaseQuestionZodSchema.extend({
+  questionType: zod.z.literal("coding"),
+  codingLanguage: zod.z.enum(["cpp", "javascript", "python", "swift", "csharp"]),
+  functionSignature: zod.z.string().optional(),
+  solutionCode: zod.z.string(),
+  testCases: zod.z.array(zod.z.object({
+    id: zod.z.string(),
+    input: zod.z.array(zod.z.any()),
+    expectedOutput: zod.z.any(),
+    isPublic: zod.z.boolean()
+  })).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(),
+  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
+});
+
+// src/ai/flows/question-gen/generate-fitb-question.ts
+var MAX_RETRY_ATTEMPTS = 3;
+var RETRY_DELAY_MS = 3e3;
+function buildEnhancedPrompt(clientInput, attemptNumber) {
+  const { quizContext, language, difficulty, numberOfBlanks, imageUrl } = clientInput;
+  const category = (quizContext == null ? void 0 : 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'.
+
+` : "";
+  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 == null ? void 0 : quizContext.loDescription) && `**Learning Objective:** ${quizContext.loDescription}`,
+    imageContextInstruction,
+    (quizContext == null ? void 0 : quizContext.plannedBloomLevel) && `**Cognitive Level (Bloom's):** ${quizContext.plannedBloomLevel}`,
+    (quizContext == null ? void 0 : quizContext.targetMisconception) && `**Target Misconception:** Design the blank to test this specific point: "${quizContext.targetMisconception}"`
+  ].filter(Boolean).map((s) => `- ${s}`).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.",
+    points: 10,
+    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 Fill-in-the-Blanks 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.
+
+## 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.
+
+### Input Parameters
+- **Topic for Question:** ${(quizContext == null ? void 0 : quizContext.plannedTopic) || "General"}
+- **Language for Text:** ${language}
+- **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:
+
+${exampleJson}
+
+Now, generate the JSON for the requested question.`;
+}
+async function generateFillInTheBlanksQuestion(clientInput, apiKey) {
+  var _a, _b, _c, _d, _e, _f, _g, _h, _i, _j, _k, _l, _m;
+  const ai = new genai.GoogleGenAI({ apiKey });
+  const model = "gemini-2.5-flash";
+  const config = {
+    temperature: 0.8,
+    responseMimeType: "application/json",
+    thinkingConfig: {
+      thinkingBudget: 4e3
+    }
+  };
+  const attemptResults = [];
+  let lastError = null;
+  for (let attempt = 1; attempt <= MAX_RETRY_ATTEMPTS; attempt++) {
+    const startTime = Date.now();
+    const promptText = buildEnhancedPrompt(clientInput, attempt);
+    const promptHash = Buffer.from(promptText).toString("base64").slice(0, 10);
+    try {
+      DebugLogger.logPrompt(attempt, promptText, __spreadProps(__spreadValues({}, 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, contents });
+      const response = aiResult;
+      const rawText = ((_e = (_d = (_c = (_b = (_a = response.candidates) == null ? void 0 : _a[0]) == null ? void 0 : _b.content) == null ? void 0 : _c.parts) == null ? void 0 : _d[0]) == null ? void 0 : _e.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 = AIFillInTheBlanksOutputFieldsSchema.parse(parsedJson);
+      DebugLogger.logValidation(attempt, "Zod Schema Validated", aiGeneratedContent);
+      const blankCount = aiGeneratedContent.segments.filter((s) => s.type === "blank").length;
+      if (blankCount !== clientInput.numberOfBlanks) {
+        throw new Error(`AI generated ${blankCount} blanks, but ${clientInput.numberOfBlanks} were required.`);
+      }
+      aiGeneratedContent.segments.forEach((segment, index) => {
+        if (segment.type === "blank" && (!segment.acceptedAnswers || segment.acceptedAnswers.length === 0)) {
+          throw new Error(`Segment ${index} is a 'blank' but is missing 'acceptedAnswers'.`);
+        }
+        if (segment.type === "text" && typeof segment.content !== "string") {
+          throw new Error(`Segment ${index} is 'text' but is missing 'content'.`);
+        }
+      });
+      if ((_f = clientInput.quizContext) == null ? void 0 : _f.originalCategory) {
+        const verifiedCategory = (_g = aiGeneratedContent.verifiedCategory) == null ? void 0 : _g.toLowerCase();
+        const requiredCategory = clientInput.quizContext.originalCategory.toLowerCase();
+        if (verifiedCategory && verifiedCategory !== requiredCategory) {
+          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",
+        prompt: aiGeneratedContent.prompt,
+        segments: finalSegments,
+        answers: finalAnswers,
+        isCaseSensitive: clientInput.isCaseSensitive,
+        explanation: aiGeneratedContent.explanation,
+        points: aiGeneratedContent.points,
+        topic: aiGeneratedContent.topic || ((_h = clientInput.quizContext) == null ? void 0 : _h.originalTopic),
+        difficulty: clientInput.difficulty,
+        contextCode: (_i = clientInput.quizContext) == null ? void 0 : _i.plannedContextId,
+        bloomLevel: (_j = clientInput.quizContext) == null ? void 0 : _j.plannedBloomLevel,
+        learningObjective: (_k = clientInput.quizContext) == null ? void 0 : _k.originalLoId,
+        subject: (_l = clientInput.quizContext) == null ? void 0 : _l.originalSubject,
+        category: (_m = clientInput.quizContext) == null ? void 0 : _m.originalCategory,
+        imageUrl: clientInput.imageUrl
+      };
+      const validatedQuestion = FillInTheBlanksQuestionZodSchema.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)`);
+      if (attempt > 1) DebugLogger.logAttemptSummary(attemptResults);
+      return { question: validatedQuestion };
+    } 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_ATTEMPTS;
+      DebugLogger.logRetryInfo(attempt, error, willRetry);
+      if (willRetry) {
+        console.log(`\u23F3 Retrying in ${RETRY_DELAY_MS}ms...`);
+        await new Promise((resolve) => setTimeout(resolve, RETRY_DELAY_MS));
+      }
+    }
+  }
+  DebugLogger.logAttemptSummary(attemptResults);
+  const errorMessage = `Failed to generate FITB question after ${MAX_RETRY_ATTEMPTS} attempts. Last error: ${lastError == null ? void 0 : 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)
+});
+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(),
+  verifiedCategory: zod.z.string().optional()
+  // Thêm để xác thực
+});
+
+// src/ai/flows/question-gen/generate-matching-question.ts
+var MAX_RETRY_ATTEMPTS2 = 3;
+var RETRY_DELAY_MS2 = 3e3;
+function buildEnhancedPrompt2(clientInput, attemptNumber) {
+  const { quizContext, language, difficulty, numberOfPairs, imageUrl } = clientInput;
+  const category = (quizContext == null ? void 0 : 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.
+
+` : "";
+  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 == null ? void 0 : quizContext.loDescription) && `**Learning Objective:** ${quizContext.loDescription}`,
+    imageContextInstruction,
+    (quizContext == null ? void 0 : quizContext.plannedBloomLevel) && `**Cognitive Level (Bloom's):** ${quizContext.plannedBloomLevel}`,
+    (quizContext == null ? void 0 : quizContext.targetMisconception) && `**Target Misconception:** Design a pair that specifically tests this confusion: "${quizContext.targetMisconception}"`
+  ].filter(Boolean).map((s) => `- ${s}`).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." }
+    ],
+    explanation: "These are the fundamental characteristics of Swift's main collection types.",
+    points: 10,
+    difficulty: "easy",
+    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 Matching Question.
+
+## 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.
+
+## CRITICAL CONTEXT FOR THIS QUESTION
+${contextStrings}
+
+## Task: Generate the Question
+Based on all the rules and context above, generate a single Matching Question.
+
+### Input Parameters
+- **Topic for Question:** ${(quizContext == null ? void 0 : quizContext.plannedTopic) || "General"}
+- **Language for Text:** ${language}
+- **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:
+
+${exampleJson}
+
+Now, generate the JSON for the requested question.`;
+}
+async function generateMatchingQuestion(clientInput, apiKey) {
+  var _a, _b, _c, _d, _e, _f, _g, _h, _i, _j, _k, _l, _m;
+  const ai = new genai.GoogleGenAI({ apiKey });
+  const model = "gemini-2.5-flash";
+  const config = {
+    temperature: 0.8,
+    responseMimeType: "application/json",
+    thinkingConfig: {
+      thinkingBudget: 4e3
+    }
+  };
+  const attemptResults = [];
+  let lastError = null;
+  for (let attempt = 1; attempt <= MAX_RETRY_ATTEMPTS2; attempt++) {
+    const startTime = Date.now();
+    const promptText = buildEnhancedPrompt2(clientInput, attempt);
+    const promptHash = Buffer.from(promptText).toString("base64").slice(0, 10);
+    try {
+      DebugLogger.logPrompt(attempt, promptText, __spreadProps(__spreadValues({}, 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, contents });
+      const response = aiResult;
+      const rawText = ((_e = (_d = (_c = (_b = (_a = response.candidates) == null ? void 0 : _a[0]) == null ? void 0 : _b.content) == null ? void 0 : _c.parts) == null ? void 0 : _d[0]) == null ? void 0 : _e.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 = AIMatchingOutputFieldsSchema.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 ((_f = clientInput.quizContext) == null ? void 0 : _f.originalCategory) {
+        const verifiedCategory = (_g = aiGeneratedContent.verifiedCategory) == null ? void 0 : _g.toLowerCase();
+        const requiredCategory = clientInput.quizContext.originalCategory.toLowerCase();
+        if (verifiedCategory && verifiedCategory !== requiredCategory) {
+          throw new Error(`Category mismatch: Required ${requiredCategory}, got ${verifiedCategory}`);
+        }
+      }
+      const finalPrompts = [];
+      const finalOptions = [];
+      const finalCorrectAnswerMap = [];
+      aiGeneratedContent.correctPairs.forEach((pair) => {
+        const promptId = generateUniqueId("m_p_");
+        const optionId = generateUniqueId("m_o_");
+        finalPrompts.push({ id: promptId, content: pair.promptText });
+        finalOptions.push({ id: optionId, content: pair.optionText });
+        finalCorrectAnswerMap.push({ promptId, optionId });
+      });
+      const completeQuestion = {
+        id: generateUniqueId("match_ai_"),
+        questionType: "matching",
+        prompt: aiGeneratedContent.prompt,
+        prompts: finalPrompts,
+        options: finalOptions,
+        correctAnswerMap: finalCorrectAnswerMap,
+        shuffleOptions: clientInput.shuffleOptions,
+        explanation: aiGeneratedContent.explanation,
+        points: aiGeneratedContent.points,
+        topic: aiGeneratedContent.topic || ((_h = clientInput.quizContext) == null ? void 0 : _h.originalTopic),
+        difficulty: clientInput.difficulty,
+        contextCode: (_i = clientInput.quizContext) == null ? void 0 : _i.plannedContextId,
+        bloomLevel: (_j = clientInput.quizContext) == null ? void 0 : _j.plannedBloomLevel,
+        learningObjective: (_k = clientInput.quizContext) == null ? void 0 : _k.originalLoId,
+        subject: (_l = clientInput.quizContext) == null ? void 0 : _l.originalSubject,
+        category: (_m = clientInput.quizContext) == null ? void 0 : _m.originalCategory,
+        imageUrl: clientInput.imageUrl
+      };
+      const validatedQuestion = MatchingQuestionZodSchema.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)`);
+      if (attempt > 1) DebugLogger.logAttemptSummary(attemptResults);
+      return { question: validatedQuestion };
+    } 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_ATTEMPTS2;
+      DebugLogger.logRetryInfo(attempt, error, willRetry);
+      if (willRetry) {
+        console.log(`\u23F3 Retrying in ${RETRY_DELAY_MS2}ms...`);
+        await new Promise((resolve) => setTimeout(resolve, RETRY_DELAY_MS2));
+      }
+    }
+  }
+  DebugLogger.logAttemptSummary(attemptResults);
+  const errorMessage = `Failed to generate Matching question after ${MAX_RETRY_ATTEMPTS2} attempts. Last error: ${lastError == null ? void 0 : 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)
+});
+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().describe("The category this question actually addresses.")
+});
+
+// src/ai/flows/question-gen/generate-mcq-question.ts
+var MAX_RETRY_ATTEMPTS3 = 3;
+var RETRY_DELAY_MS3 = 3e3;
+function buildEnhancedPrompt3(clientInput, attemptNumber) {
+  const { quizContext, language, difficulty, numberOfOptions, imageUrl } = clientInput;
+  const category = (quizContext == null ? void 0 : quizContext.originalCategory) || "the specified technical category";
+  const attemptInfo = attemptNumber > 1 ? `
+## DEBUG INFO - This is attempt #${attemptNumber}
+Previous attempts failed...
+
+` : "";
+  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 == null ? void 0 : quizContext.loDescription) && `**Learning Objective:** ${quizContext.loDescription}`,
+    imageContextInstruction,
+    (quizContext == null ? void 0 : quizContext.plannedBloomLevel) && `**Cognitive Level (Bloom's):** ${quizContext.plannedBloomLevel}`,
+    (quizContext == null ? void 0 : quizContext.targetMisconception) && `**Target Misconception:** Use this to create plausible incorrect answers: "${quizContext.targetMisconception}"`,
+    (quizContext == null ? void 0 : quizContext.difficultyReason) && `**Pedagogical Reason:** ${quizContext.difficultyReason}`
+  ].filter(Boolean).map((s) => `- ${s}`).join("\n");
+  const exampleJson = JSON.stringify({
+    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." }
+    ],
+    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: `Control Flow in ${category}`,
+    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.
+
+## 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.
+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 Multiple Choice Question.
+
+### Input Parameters
+- **Topic for Question:** ${(quizContext == null ? void 0 : quizContext.plannedTopic) || "General"}
+- **Language for Text:** ${language}
+- **Difficulty Level:** ${difficulty}
+- **Number of Options:** ${numberOfOptions}
+
+### Required JSON Output Format
+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 generateMCQQuestion(clientInput, apiKey) {
+  var _a, _b, _c, _d, _e, _f, _g, _h, _i, _j, _k, _l, _m;
+  const ai = new genai.GoogleGenAI({ apiKey });
+  const model = "gemini-2.5-flash";
+  const config = {
+    temperature: 0.8,
+    responseMimeType: "application/json",
+    thinkingConfig: {
+      thinkingBudget: 4e3
+    }
+  };
+  const attemptResults = [];
+  let lastError = null;
+  for (let attempt = 1; attempt <= MAX_RETRY_ATTEMPTS3; attempt++) {
+    const startTime = Date.now();
+    const promptText = buildEnhancedPrompt3(clientInput, attempt);
+    const promptHash = Buffer.from(promptText).toString("base64").slice(0, 10);
+    try {
+      DebugLogger.logPrompt(attempt, promptText, __spreadProps(__spreadValues({}, 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,
+        contents
+      });
+      const response = aiResult;
+      const rawText = ((_e = (_d = (_c = (_b = (_a = response.candidates) == null ? void 0 : _a[0]) == null ? void 0 : _b.content) == null ? void 0 : _c.parts) == null ? void 0 : _d[0]) == null ? void 0 : _e.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 = AIMCQOutputFieldsSchema.parse(parsedJson);
+      DebugLogger.logValidation(attempt, "Zod Schema Validated", aiGeneratedContent);
+      if ((_f = clientInput.quizContext) == null ? void 0 : _f.originalCategory) {
+        const verifiedCategory = (_g = aiGeneratedContent.verifiedCategory) == null ? void 0 : _g.toLowerCase();
+        const requiredCategory = clientInput.quizContext.originalCategory.toLowerCase();
+        if (verifiedCategory && verifiedCategory !== requiredCategory) {
+          throw new Error(`Category mismatch: Required ${requiredCategory}, got ${verifiedCategory}`);
+        }
+      }
+      const finalOptions = [];
+      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("mcq_ai_"),
+        questionType: "multiple_choice",
+        prompt: aiGeneratedContent.prompt,
+        options: finalOptions,
+        correctAnswerId: finalCorrectAnswerId,
+        explanation: aiGeneratedContent.explanation,
+        points: aiGeneratedContent.points,
+        topic: aiGeneratedContent.topic || ((_h = clientInput.quizContext) == null ? void 0 : _h.originalTopic),
+        difficulty: clientInput.difficulty,
+        contextCode: (_i = clientInput.quizContext) == null ? void 0 : _i.plannedContextId,
+        bloomLevel: (_j = clientInput.quizContext) == null ? void 0 : _j.plannedBloomLevel,
+        learningObjective: (_k = clientInput.quizContext) == null ? void 0 : _k.originalLoId,
+        subject: (_l = clientInput.quizContext) == null ? void 0 : _l.originalSubject,
+        category: (_m = clientInput.quizContext) == null ? void 0 : _m.originalCategory,
+        imageUrl: clientInput.imageUrl
+      };
+      const validatedQuestion = MultipleChoiceQuestionZodSchema.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)`);
+      if (attempt > 1) DebugLogger.logAttemptSummary(attemptResults);
+      return { question: validatedQuestion };
+    } 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_ATTEMPTS3;
+      DebugLogger.logRetryInfo(attempt, error, willRetry);
+      if (willRetry) {
+        console.log(`\u23F3 Retrying in ${RETRY_DELAY_MS3}ms...`);
+        await new Promise((resolve) => setTimeout(resolve, RETRY_DELAY_MS3));
+      }
+    }
+  }
+  DebugLogger.logAttemptSummary(attemptResults);
+  const errorMessage = `Failed to generate MCQ question after ${MAX_RETRY_ATTEMPTS3} attempts. Last error: ${lastError == null ? void 0 : 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)
+});
+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-mrq-question.ts
+var MAX_RETRY_ATTEMPTS4 = 3;
+var RETRY_DELAY_MS4 = 3e3;
+function buildEnhancedPrompt4(clientInput, attemptNumber) {
+  const { quizContext, language, difficulty, numberOfOptions, minCorrectAnswers, maxCorrectAnswers, imageUrl } = clientInput;
+  const category = (quizContext == null ? void 0 : 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.
+
+` : "";
+  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} (This is the ONLY language to be used)`,
+    (quizContext == null ? void 0 : quizContext.loDescription) && `**Learning Objective:** ${quizContext.loDescription}`,
+    imageContextInstruction,
+    (quizContext == null ? void 0 : quizContext.plannedBloomLevel) && `**Cognitive Level (Bloom's):** ${quizContext.plannedBloomLevel}`,
+    (quizContext == null ? void 0 : quizContext.targetMisconception) && `**Target Misconception:** Use this to create plausible incorrect answers (distractors). The misconception is: "${quizContext.targetMisconception}"`,
+    (quizContext == null ? void 0 : quizContext.difficultyReason) && `**Pedagogical Reason:** ${quizContext.difficultyReason}`
+  ].filter(Boolean).map((s) => `- ${s}`).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.",
+    points: 10,
+    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 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}**.
+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.
+
+## CRITICAL CONTEXT FOR THIS QUESTION
+${contextStrings}
+
+## Task: Generate the Question
+Based on all the rules and context above, generate a single Multiple Response Question.
+
+### Input Parameters
+- **Topic for Question:** ${(quizContext == null ? void 0 : quizContext.plannedTopic) || "General"}
+- **Language for Text:** ${language}
+- **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.
+
+${exampleJson}
+
+Now, generate the JSON for the requested question.`;
+}
+async function generateMRQQuestion(clientInput, apiKey) {
+  var _a, _b, _c, _d, _e, _f, _g, _h, _i, _j, _k, _l, _m;
+  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 config = {
+    temperature: 0.8,
+    responseMimeType: "application/json",
+    thinkingConfig: {
+      thinkingBudget: 4e3
+    }
+  };
+  const attemptResults = [];
+  let lastError = null;
+  for (let attempt = 1; attempt <= MAX_RETRY_ATTEMPTS4; attempt++) {
+    const startTime = Date.now();
+    const promptText = buildEnhancedPrompt4(clientInput, attempt);
+    const promptHash = Buffer.from(promptText).toString("base64").slice(0, 10);
+    try {
+      DebugLogger.logPrompt(attempt, promptText, __spreadProps(__spreadValues({}, 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,
+        contents
+      });
+      const response = aiResult;
+      const rawText = ((_e = (_d = (_c = (_b = (_a = response.candidates) == null ? void 0 : _a[0]) == null ? void 0 : _b.content) == null ? void 0 : _c.parts) == null ? void 0 : _d[0]) == null ? void 0 : _e.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 = 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 ((_f = clientInput.quizContext) == null ? void 0 : _f.originalCategory) {
+        const verifiedCategory = (_g = aiGeneratedContent.verifiedCategory) == null ? void 0 : _g.toLowerCase();
+        const requiredCategory = clientInput.quizContext.originalCategory.toLowerCase();
+        if (verifiedCategory && verifiedCategory !== requiredCategory) {
+          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",
+        prompt: aiGeneratedContent.prompt,
+        options: finalOptions,
+        correctAnswerIds: finalCorrectAnswerIds,
+        explanation: aiGeneratedContent.explanation,
+        points: aiGeneratedContent.points,
+        topic: aiGeneratedContent.topic || ((_h = clientInput.quizContext) == null ? void 0 : _h.originalTopic),
+        difficulty: aiGeneratedContent.difficulty || clientInput.difficulty,
+        contextCode: (_i = clientInput.quizContext) == null ? void 0 : _i.plannedContextId,
+        bloomLevel: (_j = clientInput.quizContext) == null ? void 0 : _j.plannedBloomLevel,
+        learningObjective: (_k = clientInput.quizContext) == null ? void 0 : _k.originalLoId,
+        subject: (_l = clientInput.quizContext) == null ? void 0 : _l.originalSubject,
+        category: (_m = clientInput.quizContext) == null ? void 0 : _m.originalCategory,
+        imageUrl: clientInput.imageUrl
+      };
+      const validatedQuestion = MultipleResponseQuestionZodSchema.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)`);
+      if (attempt > 1) DebugLogger.logAttemptSummary(attemptResults);
+      return { question: validatedQuestion };
+    } 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_ATTEMPTS4;
+      DebugLogger.logRetryInfo(attempt, error, willRetry);
+      if (willRetry) {
+        console.log(`\u23F3 Retrying in ${RETRY_DELAY_MS4}ms...`);
+        await new Promise((resolve) => setTimeout(resolve, RETRY_DELAY_MS4));
+      }
+    }
+  }
+  DebugLogger.logAttemptSummary(attemptResults);
+  const errorMessage = `Failed to generate MRQ question after ${MAX_RETRY_ATTEMPTS4} attempts. Last error: ${lastError == null ? void 0 : lastError.message}`;
+  console.error("\n\u274C Final Result: FAILED");
+  console.error(errorMessage);
+  return { error: errorMessage };
+}
+BaseQuestionGenerationClientInputSchema.extend({
+  allowDecimals: zod.z.boolean().optional().default(true),
+  minRange: zod.z.number().optional(),
+  maxRange: zod.z.number().optional(),
+  // Thêm trường tolerance để client có thể tùy chỉnh
+  tolerance: zod.z.number().min(0).optional().default(0)
+});
+var AINumericOutputFieldsSchema = zod.z.object({
+  prompt: zod.z.string(),
+  answer: zod.z.number(),
+  // AI có thể đề xuất một tolerance, nhưng chúng ta sẽ ưu tiên của client
+  tolerance: zod.z.number().min(0).optional(),
+  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()
+  // Thêm để xác thực
+});
+
+// src/ai/flows/question-gen/generate-numeric-question.ts
+var MAX_RETRY_ATTEMPTS5 = 3;
+var RETRY_DELAY_MS5 = 3e3;
+function buildEnhancedPrompt5(clientInput, attemptNumber) {
+  const { quizContext, language, difficulty, minRange, maxRange, allowDecimals, imageUrl } = clientInput;
+  const category = (quizContext == null ? void 0 : quizContext.originalCategory) || "the specified technical category";
+  const attemptInfo = attemptNumber > 1 ? `
+## DEBUG INFO - This is attempt #${attemptNumber}
+Previous attempts failed. Ensure the 'answer' is a valid number and fits within the specified constraints.
+
+` : "";
+  const imageContextInstruction = imageUrl ? `**Image Context:** You MUST analyze the provided image. The question and its numerical answer must be directly related to the content of this image.` : "";
+  const contextStrings = [
+    `**Required Category:** ${category}`,
+    (quizContext == null ? void 0 : quizContext.loDescription) && `**Learning Objective:** ${quizContext.loDescription}`,
+    imageContextInstruction,
+    (quizContext == null ? void 0 : quizContext.plannedBloomLevel) && `**Cognitive Level (Bloom's):** ${quizContext.plannedBloomLevel}`,
+    (quizContext == null ? void 0 : quizContext.targetMisconception) && `**Target Misconception:** The question should clarify this numerical error: "${quizContext.targetMisconception}"`
+  ].filter(Boolean).map((s) => `- ${s}`).join("\n");
+  const constraintStrings = [
+    minRange !== void 0 && `The final 'answer' MUST be greater than or equal to ${minRange}.`,
+    maxRange !== void 0 && `The final 'answer' MUST be less than or equal to ${maxRange}.`,
+    !allowDecimals && `The final 'answer' MUST be an integer (whole number).`
+  ].filter(Boolean).join("\n");
+  const exampleJson = JSON.stringify({
+    prompt: "A Swift `Int` on a 64-bit platform can store a maximum value of 2^63 - 1. What is the maximum value for an `Int8`?",
+    answer: 127,
+    tolerance: 0,
+    explanation: "An Int8 uses 8 bits. One bit is for the sign, leaving 7 bits for the value. The range is from -128 to 127 (2^7 - 1).",
+    points: 10,
+    difficulty: "medium",
+    topic: "Swift Data 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 Numeric Question.
+
+## Core Rules (Non-negotiable)
+1.  **Category Purity:** The question MUST be exclusively about **${category}**.
+2.  **Quantitative Answer:** The question MUST ask for a specific, objective numerical answer.
+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 Numeric Question.
+
+### Input Parameters & Constraints
+- **Topic for Question:** ${(quizContext == null ? void 0 : quizContext.plannedTopic) || "General"}
+- **Language for Text:** ${language}
+- **Difficulty Level:** ${difficulty}
+${constraintStrings ? `
+### CRITICAL CONSTRAINTS ON THE ANSWER
+${constraintStrings}` : ""}
+
+### 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 generateNumericQuestion(clientInput, apiKey) {
+  var _a, _b, _c, _d, _e, _f, _g, _h, _i, _j, _k, _l, _m, _n, _o;
+  if (clientInput.minRange !== void 0 && clientInput.maxRange !== void 0 && clientInput.minRange > clientInput.maxRange) {
+    return { error: `Invalid input: minRange (${clientInput.minRange}) cannot be greater than maxRange (${clientInput.maxRange}).` };
+  }
+  const ai = new genai.GoogleGenAI({ apiKey });
+  const model = "gemini-2.5-flash";
+  const config = {
+    temperature: 0.4,
+    // Giữ nhiệt độ thấp cho các câu trả lời chính xác
+    responseMimeType: "application/json",
+    thinkingConfig: {
+      thinkingBudget: 4e3
+    }
+  };
+  const attemptResults = [];
+  let lastError = null;
+  for (let attempt = 1; attempt <= MAX_RETRY_ATTEMPTS5; attempt++) {
+    const startTime = Date.now();
+    const promptText = buildEnhancedPrompt5(clientInput, attempt);
+    const promptHash = Buffer.from(promptText).toString("base64").slice(0, 10);
+    try {
+      DebugLogger.logPrompt(attempt, promptText, __spreadProps(__spreadValues({}, 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, contents });
+      const response = aiResult;
+      const rawText = ((_e = (_d = (_c = (_b = (_a = response.candidates) == null ? void 0 : _a[0]) == null ? void 0 : _b.content) == null ? void 0 : _c.parts) == null ? void 0 : _d[0]) == null ? void 0 : _e.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 = AINumericOutputFieldsSchema.parse(parsedJson);
+      DebugLogger.logValidation(attempt, "Zod Schema Validated", aiGeneratedContent);
+      const answer = aiGeneratedContent.answer;
+      if (clientInput.minRange !== void 0 && answer < clientInput.minRange) {
+        throw new Error(`AI answer ${answer} is less than the required minRange of ${clientInput.minRange}.`);
+      }
+      if (clientInput.maxRange !== void 0 && answer > clientInput.maxRange) {
+        throw new Error(`AI answer ${answer} is greater than the required maxRange of ${clientInput.maxRange}.`);
+      }
+      if (!clientInput.allowDecimals && !Number.isInteger(answer)) {
+        throw new Error(`AI answer ${answer} is not an integer, but decimals are not allowed.`);
+      }
+      if ((_f = clientInput.quizContext) == null ? void 0 : _f.originalCategory) {
+        const verifiedCategory = (_g = aiGeneratedContent.verifiedCategory) == null ? void 0 : _g.toLowerCase();
+        const requiredCategory = clientInput.quizContext.originalCategory.toLowerCase();
+        if (verifiedCategory && verifiedCategory !== requiredCategory) {
+          throw new Error(`Category mismatch: Required ${requiredCategory}, got ${verifiedCategory}`);
+        }
+      }
+      const completeQuestion = {
+        id: generateUniqueId("num_ai_"),
+        questionType: "numeric",
+        prompt: aiGeneratedContent.prompt,
+        answer: aiGeneratedContent.answer,
+        tolerance: (_i = (_h = clientInput.tolerance) != null ? _h : aiGeneratedContent.tolerance) != null ? _i : 0,
+        explanation: aiGeneratedContent.explanation,
+        points: aiGeneratedContent.points,
+        topic: aiGeneratedContent.topic || ((_j = clientInput.quizContext) == null ? void 0 : _j.originalTopic),
+        difficulty: clientInput.difficulty,
+        contextCode: (_k = clientInput.quizContext) == null ? void 0 : _k.plannedContextId,
+        bloomLevel: (_l = clientInput.quizContext) == null ? void 0 : _l.plannedBloomLevel,
+        learningObjective: (_m = clientInput.quizContext) == null ? void 0 : _m.originalLoId,
+        subject: (_n = clientInput.quizContext) == null ? void 0 : _n.originalSubject,
+        category: (_o = clientInput.quizContext) == null ? void 0 : _o.originalCategory,
+        imageUrl: clientInput.imageUrl
+      };
+      const validatedQuestion = NumericQuestionZodSchema.parse(completeQuestion);
+      attemptResults.push({ success: true, duration, promptLength: promptText.length, responseLength: rawText.length, promptHash });
+      console.log(`
+\u2705 Numeric generation successful on attempt ${attempt} (${duration}ms)`);
+      if (attempt > 1) DebugLogger.logAttemptSummary(attemptResults);
+      return { question: validatedQuestion };
+    } 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_ATTEMPTS5;
+      DebugLogger.logRetryInfo(attempt, error, willRetry);
+      if (willRetry) {
+        console.log(`\u23F3 Retrying in ${RETRY_DELAY_MS5}ms...`);
+        await new Promise((resolve) => setTimeout(resolve, RETRY_DELAY_MS5));
+      }
+    }
+  }
+  DebugLogger.logAttemptSummary(attemptResults);
+  const errorMessage = `Failed to generate Numeric question after ${MAX_RETRY_ATTEMPTS5} attempts. Last error: ${lastError == null ? void 0 : lastError.message}`;
+  console.error("\n\u274C Final Result: FAILED");
+  console.error(errorMessage);
+  return { error: errorMessage };
+}
+BaseQuestionGenerationClientInputSchema.extend({
+  numberOfItems: zod.z.number().int().min(2).max(10).optional().default(4)
+});
+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(),
+  topic: zod.z.string().optional(),
+  verifiedCategory: zod.z.string().optional()
+  // Thêm để xác thực
+});
+
+// src/ai/flows/question-gen/generate-sequence-question.ts
+var MAX_RETRY_ATTEMPTS6 = 3;
+var RETRY_DELAY_MS6 = 3e3;
+function buildEnhancedPrompt6(clientInput, attemptNumber) {
+  const { quizContext, language, difficulty, numberOfItems, imageUrl } = clientInput;
+  const category = (quizContext == null ? void 0 : 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.
+
+` : "";
+  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 == null ? void 0 : quizContext.loDescription) && `**Learning Objective:** ${quizContext.loDescription}`,
+    imageContextInstruction,
+    (quizContext == null ? void 0 : quizContext.plannedBloomLevel) && `**Cognitive Level (Bloom's):** ${quizContext.plannedBloomLevel}`,
+    (quizContext == null ? void 0 : quizContext.targetMisconception) && `**Target Misconception:** The sequence should clarify this specific process error: "${quizContext.targetMisconception}"`
+  ].filter(Boolean).map((s) => `- ${s}`).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."
+    ],
+    explanation: "This is the fundamental sequence for a basic data task in URLSession.",
+    points: 10,
+    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 Sequence 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.
+
+## CRITICAL CONTEXT FOR THIS QUESTION
+${contextStrings}
+
+## Task: Generate the Question
+Based on all the rules and context above, generate a single Sequence Question.
+
+### Input Parameters
+- **Topic for Question:** ${(quizContext == null ? void 0 : quizContext.plannedTopic) || "General"}
+- **Language for Text:** ${language}
+- **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:
+
+${exampleJson}
+
+Now, generate the JSON for the requested question.`;
+}
+async function generateSequenceQuestion(clientInput, apiKey) {
+  var _a, _b, _c, _d, _e, _f, _g, _h, _i, _j, _k, _l, _m;
+  const ai = new genai.GoogleGenAI({ apiKey });
+  const model = "gemini-2.5-flash";
+  const config = {
+    temperature: 0.7,
+    responseMimeType: "application/json",
+    thinkingConfig: {
+      thinkingBudget: 4e3
+    }
+  };
+  const attemptResults = [];
+  let lastError = null;
+  for (let attempt = 1; attempt <= MAX_RETRY_ATTEMPTS6; attempt++) {
+    const startTime = Date.now();
+    const promptText = buildEnhancedPrompt6(clientInput, attempt);
+    const promptHash = Buffer.from(promptText).toString("base64").slice(0, 10);
+    try {
+      DebugLogger.logPrompt(attempt, promptText, __spreadProps(__spreadValues({}, 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, contents });
+      const response = aiResult;
+      const rawText = ((_e = (_d = (_c = (_b = (_a = response.candidates) == null ? void 0 : _a[0]) == null ? void 0 : _b.content) == null ? void 0 : _c.parts) == null ? void 0 : _d[0]) == null ? void 0 : _e.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 = 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 ((_f = clientInput.quizContext) == null ? void 0 : _f.originalCategory) {
+        const verifiedCategory = (_g = aiGeneratedContent.verifiedCategory) == null ? void 0 : _g.toLowerCase();
+        const requiredCategory = clientInput.quizContext.originalCategory.toLowerCase();
+        if (verifiedCategory && verifiedCategory !== requiredCategory) {
+          throw new Error(`Category mismatch: Required ${requiredCategory}, got ${verifiedCategory}`);
+        }
+      }
+      const finalItems = [];
+      const finalCorrectOrder = [];
+      aiGeneratedContent.itemsInCorrectOrder.forEach((content) => {
+        const id = generateUniqueId("seqi_");
+        finalItems.push({ id, content });
+        finalCorrectOrder.push(id);
+      });
+      const completeQuestion = {
+        id: generateUniqueId("seq_ai_"),
+        questionType: "sequence",
+        prompt: aiGeneratedContent.prompt,
+        items: finalItems,
+        correctOrder: finalCorrectOrder,
+        explanation: aiGeneratedContent.explanation,
+        points: aiGeneratedContent.points,
+        topic: aiGeneratedContent.topic || ((_h = clientInput.quizContext) == null ? void 0 : _h.originalTopic),
+        difficulty: clientInput.difficulty,
+        contextCode: (_i = clientInput.quizContext) == null ? void 0 : _i.plannedContextId,
+        bloomLevel: (_j = clientInput.quizContext) == null ? void 0 : _j.plannedBloomLevel,
+        learningObjective: (_k = clientInput.quizContext) == null ? void 0 : _k.originalLoId,
+        subject: (_l = clientInput.quizContext) == null ? void 0 : _l.originalSubject,
+        category: (_m = clientInput.quizContext) == null ? void 0 : _m.originalCategory,
+        imageUrl: clientInput.imageUrl
+      };
+      const validatedQuestion = SequenceQuestionZodSchema.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)`);
+      if (attempt > 1) DebugLogger.logAttemptSummary(attemptResults);
+      return { question: validatedQuestion };
+    } 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_ATTEMPTS6;
+      DebugLogger.logRetryInfo(attempt, error, willRetry);
+      if (willRetry) {
+        console.log(`\u23F3 Retrying in ${RETRY_DELAY_MS6}ms...`);
+        await new Promise((resolve) => setTimeout(resolve, RETRY_DELAY_MS6));
+      }
+    }
+  }
+  DebugLogger.logAttemptSummary(attemptResults);
+  const errorMessage = `Failed to generate Sequence question after ${MAX_RETRY_ATTEMPTS6} attempts. Last error: ${lastError == null ? void 0 : lastError.message}`;
+  console.error("\n\u274C Final Result: FAILED");
+  console.error(errorMessage);
+  return { error: errorMessage };
+}
+BaseQuestionGenerationClientInputSchema.extend({
+  isCaseSensitive: zod.z.boolean().optional().default(false)
+});
+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()
+  // Thêm để xác thực
+});
+
+// src/ai/flows/question-gen/generate-short-answer-question.ts
+var MAX_RETRY_ATTEMPTS7 = 3;
+var RETRY_DELAY_MS7 = 3e3;
+function buildEnhancedPrompt7(clientInput, attemptNumber) {
+  const { quizContext, language, difficulty, imageUrl } = clientInput;
+  const category = (quizContext == null ? void 0 : 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.
+
+` : "";
+  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}`,
+    (quizContext == null ? void 0 : quizContext.loDescription) && `**Learning Objective:** ${quizContext.loDescription}`,
+    imageContextInstruction,
+    (quizContext == null ? void 0 : quizContext.plannedBloomLevel) && `**Cognitive Level (Bloom's):** ${quizContext.plannedBloomLevel}`,
+    (quizContext == null ? void 0 : quizContext.targetMisconception) && `**Target Misconception:** The question should require an answer that corrects this specific misconception: "${quizContext.targetMisconception}"`
+  ].filter(Boolean).map((s) => `- ${s}`).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.",
+    points: 10,
+    difficulty: "easy",
+    topic: "Swift Constants",
+    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.
+
+## 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.
+
+## CRITICAL CONTEXT FOR THIS QUESTION
+${contextStrings}
+
+## Task: Generate the Question
+Based on all the rules and context above, generate a single Short Answer Question.
+
+### Input Parameters
+- **Topic for Question:** ${(quizContext == null ? void 0 : quizContext.plannedTopic) || "General"}
+- **Language for Text:** ${language}
+- **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 generateShortAnswerQuestion(clientInput, apiKey) {
+  var _a, _b, _c, _d, _e, _f, _g, _h, _i, _j, _k, _l, _m;
+  const ai = new genai.GoogleGenAI({ apiKey });
+  const model = "gemini-2.5-flash";
+  const config = {
+    temperature: 0.5,
+    responseMimeType: "application/json",
+    thinkingConfig: {
+      thinkingBudget: 4e3
+    }
+  };
+  const attemptResults = [];
+  let lastError = null;
+  for (let attempt = 1; attempt <= MAX_RETRY_ATTEMPTS7; attempt++) {
+    const startTime = Date.now();
+    const promptText = buildEnhancedPrompt7(clientInput, attempt);
+    const promptHash = Buffer.from(promptText).toString("base64").slice(0, 10);
+    try {
+      DebugLogger.logPrompt(attempt, promptText, __spreadProps(__spreadValues({}, 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, contents });
+      const response = aiResult;
+      const rawText = ((_e = (_d = (_c = (_b = (_a = response.candidates) == null ? void 0 : _a[0]) == null ? void 0 : _b.content) == null ? void 0 : _c.parts) == null ? void 0 : _d[0]) == null ? void 0 : _e.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 = AIShortAnswerOutputFieldsSchema.parse(parsedJson);
+      DebugLogger.logValidation(attempt, "Zod Schema Validated", aiGeneratedContent);
+      if ((_f = clientInput.quizContext) == null ? void 0 : _f.originalCategory) {
+        const verifiedCategory = (_g = aiGeneratedContent.verifiedCategory) == null ? void 0 : _g.toLowerCase();
+        const requiredCategory = clientInput.quizContext.originalCategory.toLowerCase();
+        if (verifiedCategory && verifiedCategory !== requiredCategory) {
+          throw new Error(`Category mismatch: Required ${requiredCategory}, got ${verifiedCategory}`);
+        }
+      }
+      const completeQuestion = {
+        id: generateUniqueId("saq_ai_"),
+        questionType: "short_answer",
+        prompt: aiGeneratedContent.prompt,
+        acceptedAnswers: aiGeneratedContent.acceptedAnswers,
+        isCaseSensitive: clientInput.isCaseSensitive,
+        explanation: aiGeneratedContent.explanation,
+        points: aiGeneratedContent.points,
+        topic: aiGeneratedContent.topic || ((_h = clientInput.quizContext) == null ? void 0 : _h.originalTopic),
+        difficulty: clientInput.difficulty,
+        contextCode: (_i = clientInput.quizContext) == null ? void 0 : _i.plannedContextId,
+        bloomLevel: (_j = clientInput.quizContext) == null ? void 0 : _j.plannedBloomLevel,
+        learningObjective: (_k = clientInput.quizContext) == null ? void 0 : _k.originalLoId,
+        subject: (_l = clientInput.quizContext) == null ? void 0 : _l.originalSubject,
+        category: (_m = clientInput.quizContext) == null ? void 0 : _m.originalCategory,
+        imageUrl: clientInput.imageUrl
+      };
+      const validatedQuestion = ShortAnswerQuestionZodSchema.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)`);
+      if (attempt > 1) DebugLogger.logAttemptSummary(attemptResults);
+      return { question: validatedQuestion };
+    } 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_ATTEMPTS7;
+      DebugLogger.logRetryInfo(attempt, error, willRetry);
+      if (willRetry) {
+        console.log(`\u23F3 Retrying in ${RETRY_DELAY_MS7}ms...`);
+        await new Promise((resolve) => setTimeout(resolve, RETRY_DELAY_MS7));
+      }
+    }
+  }
+  DebugLogger.logAttemptSummary(attemptResults);
+  const errorMessage = `Failed to generate Short Answer question after ${MAX_RETRY_ATTEMPTS7} attempts. Last error: ${lastError == null ? void 0 : 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."),
+  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
+});
+
+// src/ai/flows/question-gen/generate-true-false-question.ts
+var MAX_RETRY_ATTEMPTS8 = 3;
+var RETRY_DELAY_MS8 = 3e3;
+function buildEnhancedPrompt8(clientInput, attemptNumber) {
+  const { quizContext, language, difficulty, imageUrl } = clientInput;
+  const category = (quizContext == null ? void 0 : 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.
+
+` : "";
+  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 == null ? void 0 : 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 == null ? void 0 : quizContext.loDescription) && `**Learning Objective:** ${quizContext.loDescription}`,
+    imageContextInstruction,
+    (quizContext == null ? void 0 : quizContext.plannedBloomLevel) && `**Cognitive Level (Bloom's):** ${quizContext.plannedBloomLevel}`,
+    misconceptionGuidance,
+    (quizContext == null ? void 0 : quizContext.difficultyReason) && `**Pedagogical Reason:** ${quizContext.difficultyReason}`
+  ].filter(Boolean).map((s) => `- ${s}`).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 '!'.",
+    points: 10,
+    difficulty: "easy",
+    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 True/False 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.
+
+## CRITICAL CONTEXT FOR THIS QUESTION
+${contextStrings}
+
+## Task: Generate the Question
+Based on all the rules and context above, generate a single True/False Question.
+
+### Input Parameters
+- **Topic for Question:** ${(quizContext == null ? void 0 : quizContext.plannedTopic) || "General"}
+- **Language for Text:** ${language}
+- **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 generateTrueFalseQuestion(clientInput, apiKey) {
+  var _a, _b, _c, _d, _e, _f, _g, _h, _i, _j, _k, _l, _m, _n;
+  const ai = new genai.GoogleGenAI({ apiKey });
+  const model = "gemini-2.5-flash";
+  const config = {
+    temperature: 0.6,
+    responseMimeType: "application/json",
+    thinkingConfig: {
+      thinkingBudget: 4e3
+    }
+  };
+  const attemptResults = [];
+  let lastError = null;
+  for (let attempt = 1; attempt <= MAX_RETRY_ATTEMPTS8; attempt++) {
+    const startTime = Date.now();
+    const promptText = buildEnhancedPrompt8(clientInput, attempt);
+    const promptHash = Buffer.from(promptText).toString("base64").slice(0, 10);
+    try {
+      DebugLogger.logPrompt(attempt, promptText, __spreadProps(__spreadValues({}, 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, contents });
+      const response = aiResult;
+      const rawText = ((_e = (_d = (_c = (_b = (_a = response.candidates) == null ? void 0 : _a[0]) == null ? void 0 : _b.content) == null ? void 0 : _c.parts) == null ? void 0 : _d[0]) == null ? void 0 : _e.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 = AITrueFalseOutputFieldsSchema.parse(parsedJson);
+      DebugLogger.logValidation(attempt, "Zod Schema Validated", aiGeneratedContent);
+      if (((_f = clientInput.quizContext) == null ? void 0 : _f.targetMisconception) && aiGeneratedContent.correctAnswer === true) {
+        throw new Error("AI failed to follow the Misconception Priority rule. The answer should have been false.");
+      }
+      if ((_g = clientInput.quizContext) == null ? void 0 : _g.originalCategory) {
+        const verifiedCategory = (_h = aiGeneratedContent.verifiedCategory) == null ? void 0 : _h.toLowerCase();
+        const requiredCategory = clientInput.quizContext.originalCategory.toLowerCase();
+        if (verifiedCategory && verifiedCategory !== requiredCategory) {
+          throw new Error(`Category mismatch: Required ${requiredCategory}, got ${verifiedCategory}`);
+        }
+      }
+      const completeQuestion = {
+        id: generateUniqueId("tf_ai_"),
+        questionType: "true_false",
+        prompt: aiGeneratedContent.prompt,
+        correctAnswer: aiGeneratedContent.correctAnswer,
+        explanation: aiGeneratedContent.explanation,
+        points: aiGeneratedContent.points,
+        topic: aiGeneratedContent.topic || ((_i = clientInput.quizContext) == null ? void 0 : _i.originalTopic),
+        difficulty: clientInput.difficulty,
+        contextCode: (_j = clientInput.quizContext) == null ? void 0 : _j.plannedContextId,
+        bloomLevel: (_k = clientInput.quizContext) == null ? void 0 : _k.plannedBloomLevel,
+        learningObjective: (_l = clientInput.quizContext) == null ? void 0 : _l.originalLoId,
+        subject: (_m = clientInput.quizContext) == null ? void 0 : _m.originalSubject,
+        category: (_n = clientInput.quizContext) == null ? void 0 : _n.originalCategory,
+        imageUrl: clientInput.imageUrl
+      };
+      const validatedQuestion = TrueFalseQuestionZodSchema.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)`);
+      if (attempt > 1) DebugLogger.logAttemptSummary(attemptResults);
+      return { question: validatedQuestion };
+    } 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_ATTEMPTS8;
+      DebugLogger.logRetryInfo(attempt, error, willRetry);
+      if (willRetry) {
+        console.log(`\u23F3 Retrying in ${RETRY_DELAY_MS8}ms...`);
+        await new Promise((resolve) => setTimeout(resolve, RETRY_DELAY_MS8));
+      }
+    }
+  }
+  DebugLogger.logAttemptSummary(attemptResults);
+  const errorMessage = `Failed to generate True/False question after ${MAX_RETRY_ATTEMPTS8} attempts. Last error: ${lastError == null ? void 0 : lastError.message}`;
+  console.error("\n\u274C Final Result: FAILED");
+  console.error(errorMessage);
+  return { error: errorMessage };
+}
+
+// src/utils/jsonUtils.ts
+var JsonRepairEngine = class {
+  /**
+   * Attempts to repair unterminated strings in JSON.
+   * NOTE: This is a heuristic approach and may not be perfect for all cases.
+   */
+  static repairUnterminatedStrings(jsonStr) {
+    let repaired = jsonStr;
+    let inString = false;
+    let escaped = false;
+    let lastQuoteIndex = -1;
+    for (let i = 0; i < repaired.length; i++) {
+      const char = repaired[i];
+      if (escaped) {
+        escaped = false;
+        continue;
+      }
+      if (char === "\\") {
+        escaped = true;
+        continue;
+      }
+      if (char === '"') {
+        inString = !inString;
+        if (inString) {
+          lastQuoteIndex = i;
+        }
+      }
+    }
+    if (inString && lastQuoteIndex !== -1) {
+      const beforeUnterminated = repaired.substring(0, lastQuoteIndex + 1);
+      const afterUnterminated = repaired.substring(lastQuoteIndex + 1);
+      const breakPoints = [",", "}", "]", "\n"];
+      let breakIndex = -1;
+      for (let i = 0; i < afterUnterminated.length; i++) {
+        if (breakPoints.includes(afterUnterminated[i])) {
+          breakIndex = i;
+          break;
+        }
+      }
+      if (breakIndex !== -1) {
+        const stringContent = afterUnterminated.substring(0, breakIndex);
+        const remainder = afterUnterminated.substring(breakIndex);
+        const escapedContent = stringContent.replace(new RegExp('(?<!\\\\)"', "g"), '\\"');
+        repaired = beforeUnterminated + escapedContent + '"' + remainder;
+      } else {
+        const escapedContent = afterUnterminated.replace(new RegExp('(?<!\\\\)"', "g"), '\\"');
+        repaired = beforeUnterminated + escapedContent + '"';
+      }
+    }
+    return repaired;
+  }
+  // FIX: Replaced unsafe single quote replacement with a stateful parser.
+  /**
+   * Safely replaces single quotes with double quotes only for keys and string values,
+   * ignoring apostrophes inside already double-quoted strings.
+   */
+  static safelyFixQuotes(jsonStr) {
+    let result = "";
+    let inDoubleQuoteString = false;
+    let escaped = false;
+    for (let i = 0; i < jsonStr.length; i++) {
+      const char = jsonStr[i];
+      if (escaped) {
+        result += char;
+        escaped = false;
+        continue;
+      }
+      if (char === "\\") {
+        escaped = true;
+        result += char;
+        continue;
+      }
+      if (char === '"') {
+        inDoubleQuoteString = !inDoubleQuoteString;
+      }
+      if (char === "'" && !inDoubleQuoteString) {
+        result += '"';
+      } else {
+        result += char;
+      }
+    }
+    return result;
+  }
+  /**
+   * Fixes common JSON formatting issues using more robust methods.
+   */
+  static applyCommonFixes(jsonStr) {
+    let fixed = jsonStr;
+    fixed = this.safelyFixQuotes(fixed);
+    fixed = fixed.replace(/,\s*([}\]])/g, "$1");
+    fixed = fixed.replace(/("|}|\d|]|true|false|null)\s*\n\s*(")/g, "$1,\n$2");
+    fixed = fixed.replace(/"[\s\S]*?"/g, (match) => {
+      const content = match.substring(1, match.length - 1);
+      const fixedContent = content.replace(/\n/g, "\\n").replace(/\r/g, "\\r");
+      return `"${fixedContent}"`;
+    });
+    fixed = fixed.replace(/"(true|false|null)"/g, "$1");
+    return fixed;
+  }
+  /**
+   * Validates JSON by attempting to parse and providing detailed error info.
+   */
+  static validateAndGetError(jsonStr) {
+    try {
+      JSON.parse(jsonStr);
+      return { isValid: true };
+    } catch (error) {
+      const errorMessage = error.message || "";
+      const positionMatch = errorMessage.match(/position (\d+)/);
+      const position = positionMatch ? parseInt(positionMatch[1], 10) : void 0;
+      return {
+        isValid: false,
+        error: errorMessage,
+        position
+      };
+    }
+  }
+  /**
+   * Main repair function that attempts multiple strategies.
+   */
+  static repairJson(jsonStr) {
+    var _a;
+    let current = jsonStr.trim();
+    const maxAttempts = 5;
+    let lastError = "";
+    let lastPosition = -1;
+    for (let attempt = 0; attempt < maxAttempts; attempt++) {
+      const validation = this.validateAndGetError(current);
+      if (validation.isValid) {
+        return current;
+      }
+      console.warn(`JSON repair attempt ${attempt + 1}: ${validation.error}`);
+      if (validation.error === lastError && validation.position === lastPosition) {
+        console.error("Repair attempt stuck on the same error, aborting this strategy.");
+        if (validation.position) {
+          const truncated = current.substring(0, validation.position);
+          const openBraces = (truncated.match(/{/g) || []).length;
+          const closeBraces = (truncated.match(/}/g) || []).length;
+          const openBrackets = (truncated.match(/\[/g) || []).length;
+          const closeBrackets = (truncated.match(/\]/g) || []).length;
+          let repaired = truncated.replace(/,\s*$/, "");
+          for (let i = 0; i < openBrackets - closeBrackets; i++) repaired += "]";
+          for (let i = 0; i < openBraces - closeBraces; i++) repaired += "}";
+          current = repaired;
+          const finalValidation = this.validateAndGetError(current);
+          if (finalValidation.isValid) return current;
+        }
+        break;
+      }
+      lastError = validation.error || "";
+      lastPosition = validation.position;
+      if ((_a = validation.error) == null ? void 0 : _a.includes("Unterminated string")) {
+        current = this.repairUnterminatedStrings(current);
+      } else {
+        current = this.applyCommonFixes(current);
+      }
+    }
+    try {
+      let finalAttempt = this.applyCommonFixes(jsonStr.trim());
+      finalAttempt = this.repairUnterminatedStrings(finalAttempt);
+      JSON.parse(finalAttempt);
+      return finalAttempt;
+    } catch (e) {
+      throw new Error(`Unable to repair JSON after ${maxAttempts} attempts. Last known error: ${lastError}`);
+    }
+  }
+};
+function extractJsonFromMarkdown(text) {
+  if (!text) {
+    throw new Error("Input text is empty or null.");
+  }
+  const trimmedText = text.trim();
+  try {
+    JSON.parse(trimmedText);
+    return trimmedText;
+  } catch (e) {
+  }
+  const markdownPatterns = [
+    /```(?:json|JSON)\s*([\s\S]*?)\s*```/,
+    // ```json ... ```
+    /```\s*({[\s\S]*?}|\[[\s\S]*?\])\s*```/
+    // ``` { ... } ``` or ``` [ ... ] ```
+  ];
+  for (const pattern of markdownPatterns) {
+    const match = trimmedText.match(pattern);
+    if (match && match[1]) {
+      const content = match[1].trim();
+      try {
+        JSON.parse(content);
+        return content;
+      } catch (e) {
+        console.warn("JSON inside markdown block is invalid, attempting repair...");
+        try {
+          return JsonRepairEngine.repairJson(content);
+        } catch (repairError) {
+          console.warn(`Markdown block repair failed: ${repairError.message}. Trying other strategies...`);
+        }
+      }
+    }
+  }
+  const firstBrace = trimmedText.indexOf("{");
+  const firstBracket = trimmedText.indexOf("[");
+  let startIndex = -1;
+  if (firstBrace === -1 && firstBracket === -1) ; else if (firstBrace === -1) {
+    startIndex = firstBracket;
+  } else if (firstBracket === -1) {
+    startIndex = firstBrace;
+  } else {
+    startIndex = Math.min(firstBrace, firstBracket);
+  }
+  if (startIndex !== -1) {
+    const textToProcess = trimmedText.substring(startIndex);
+    let balance = 0;
+    let inString = false;
+    let escaped = false;
+    const startChar = textToProcess[0];
+    const endChar = startChar === "{" ? "}" : "]";
+    for (let i = 0; i < textToProcess.length; i++) {
+      const char = textToProcess[i];
+      if (escaped) {
+        escaped = false;
+        continue;
+      }
+      if (char === "\\") {
+        escaped = true;
+        continue;
+      }
+      if (char === '"') {
+        inString = !inString;
+      }
+      if (!inString) {
+        if (char === startChar) balance++;
+        if (char === endChar) balance--;
+      }
+      if (balance === 0 && i > 0) {
+        const potentialJson = textToProcess.substring(0, i + 1);
+        try {
+          JSON.parse(potentialJson);
+          return potentialJson;
+        } catch (e) {
+          console.warn(`Balanced JSON segment is invalid, attempting repair...`);
+          try {
+            return JsonRepairEngine.repairJson(potentialJson);
+          } catch (repairError) {
+            console.warn(`Repair failed for balanced segment: ${repairError.message}`);
+          }
+        }
+        break;
+      }
+    }
+  }
+  console.warn("All extraction strategies failed, attempting to repair the entire input text as a last resort.");
+  try {
+    return JsonRepairEngine.repairJson(trimmedText);
+  } catch (finalError) {
+    throw new Error(`Unable to extract or repair valid JSON from AI response. Preview: "${trimmedText.substring(0, 100)}...". Final error: ${finalError.message}`);
+  }
+}
+var TopicWithMetadataSchema = zod.z.object({
+  topic: zod.z.string().min(1),
+  ratio: zod.z.number().min(0).max(100),
+  originalLoId: zod.z.string().optional(),
+  originalSubject: zod.z.string().optional(),
+  originalCategory: zod.z.string().optional(),
+  originalTopic: zod.z.string().optional(),
+  commonMisconceptions: zod.z.array(zod.z.string()).optional()
+});
+var BloomLevelStringsEnum = zod.z.enum(["remembering", "understanding", "applying", "analyzing", "evaluating", "creating"]);
+var fullQuizSupportedQuestionTypesArray = [
+  "true_false",
+  "multiple_choice",
+  "multiple_response",
+  "short_answer",
+  "numeric",
+  "fill_in_the_blanks",
+  "sequence",
+  "matching",
+  "drag_and_drop",
+  "coding"
+];
+zod.z.object({
+  language: zod.z.string().optional().default("English"),
+  totalQuestions: zod.z.number().int().min(1).max(50),
+  numCodingQuestions: zod.z.number().optional().default(0),
+  topics: zod.z.array(TopicWithMetadataSchema).min(1),
+  bloomLevels: zod.z.array(zod.z.object({
+    level: BloomLevelStringsEnum,
+    ratio: zod.z.number().min(0).max(100)
+  })).min(1),
+  selectedContextIds: zod.z.array(zod.z.string()).optional(),
+  selectedQuestionTypes: zod.z.array(zod.z.enum(fullQuizSupportedQuestionTypesArray)).min(1),
+  imageContexts: zod.z.array(zod.z.custom()).optional().describe("Library of available image contexts for the AI to use.")
+});
+var PlannedQuestionSchema = zod.z.object({
+  plannedTopic: zod.z.string().min(1).describe("The specific, assessable topic for this question."),
+  plannedQuestionType: zod.z.enum(fullQuizSupportedQuestionTypesArray).describe("The specific question type chosen."),
+  plannedBloomLevel: BloomLevelStringsEnum.describe("The Bloom's level assigned."),
+  plannedContextId: zod.z.string().optional().describe("The specific context ID chosen for this question."),
+  imageId: zod.z.string().nullable().optional().describe("The ID of the image from the context library to be used for this question."),
+  targetMisconception: zod.z.string().optional().describe("A specific common misconception this question should target."),
+  difficultyReason: zod.z.string().optional().describe("Strategic explanation of difficulty choice and placement."),
+  topicSpecificity: zod.z.enum(["broad", "focused", "specific"]).optional().describe("How specific the topic coverage should be."),
+  originalLoId: zod.z.string().optional(),
+  originalSubject: zod.z.string().optional(),
+  originalCategory: zod.z.string().optional(),
+  originalTopic: zod.z.string().optional()
+});
+var GenerateQuizPlanOutputSchema = zod.z.object({
+  quizPlan: zod.z.array(PlannedQuestionSchema).describe("A detailed plan for each question in the quiz."),
+  diversityMetrics: zod.z.object({
+    questionTypeDistribution: zod.z.record(zod.z.number()).optional(),
+    bloomLevelDistribution: zod.z.record(zod.z.number()).optional(),
+    maxConsecutiveSameType: zod.z.number().optional()
+  }).optional().describe("Metrics showing the diversity achieved in the plan."),
+  planningStrategy: zod.z.object({
+    overallApproach: zod.z.string().optional(),
+    keyDecisions: zod.z.array(zod.z.string()).optional()
+  }).optional()
+});
+
+// src/ai/flows/generate-quiz-plan.ts
+var QuizPlanLogger = class {
+  constructor() {
+    this.logs = [];
+    this.startTime = Date.now();
+  }
+  log(phase, data, duration) {
+    this.logs.push({
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      phase,
+      data,
+      duration
+    });
+    if (duration !== void 0) {
+      console.log(`[${phase}] Completed in ${duration}ms:`, data);
+    } else {
+      console.log(`[${phase}]:`, data);
+    }
+  }
+  getLogs() {
+    return this.logs;
+  }
+  getTotalDuration() {
+    return Date.now() - this.startTime;
+  }
+};
+function generateQuestionTypeSelectionGuidance() {
+  return `
+QUESTION TYPE SELECTION BEST PRACTICES:
+
+**TRUE_FALSE (true_false)**
+- Best for: Binary concepts, fact verification, common misconceptions
+- Bloom levels: Primarily Remembering, Understanding
+- Use when: Testing definitive statements, clarifying misconceptions
+- Example: "Photosynthesis only occurs during daytime" (targets timing misconception)
+
+**MULTIPLE CHOICE (multiple_choice)**
+- Best for: Concept selection, process understanding, comparison
+- Bloom levels: All levels, especially Understanding and Applying
+- Use when: Testing conceptual understanding with clear alternatives
+- Example: "Which factor most affects enzyme activity?" (applying knowledge)
+
+**MULTIPLE RESPONSE (multiple_response)**
+- Best for: Identifying multiple correct factors, comprehensive understanding
+- Bloom levels: Understanding, Analyzing, Evaluating
+- Use when: Multiple correct answers exist, testing thorough knowledge
+- Example: "Select all factors that influence plant growth" (analyzing components)
+
+**FILL IN THE BLANKS (fill_in_the_blanks)**
+- Best for: Key terminology, formulas, specific facts
+- Bloom levels: Remembering, Understanding
+- Use when: Testing precise recall of important terms/concepts
+- Example: "The process of _____ converts light energy to chemical energy"
+
+**NUMERIC (numeric)**
+- Best for: Calculations, quantitative problems, formula application
+- Bloom levels: Applying, Analyzing
+- Use when: Mathematical computations are required
+- Example: "Calculate the molarity of a 2L solution containing 0.5 moles of NaCl"
+
+**MATCHING (matching)**
+- Best for: Connecting related concepts, terminology pairs
+- Bloom levels: Remembering, Understanding
+- Use when: Testing relationships between terms and definitions
+- Example: Match organelles with their functions
+
+**SEQUENCE (sequence)**
+- Best for: Process steps, chronological order, procedural knowledge
+- Bloom levels: Understanding, Applying, Analyzing
+- Use when: Order or sequence is critical to understanding
+- Example: "Arrange the steps of mitosis in correct order"
+
+**DRAG AND DROP (drag_and_drop)**
+- Best for: Categorization, classification, spatial relationships
+- Bloom levels: Understanding, Applying, Analyzing
+- Use when: Grouping or organizing information is key
+- Example: "Classify these compounds as acids, bases, or neutral"
+
+**SHORT ANSWER (short_answer)**
+- Best for: Explanations, definitions, problem-solving steps
+- Bloom levels: Understanding, Applying, Analyzing, Evaluating, Creating
+- Use when: Requiring explanatory responses, open-ended thinking
+- Example: "Explain why enzymes are specific to certain substrates"
+
+**CODING (coding)**
+- Best for: Programming problems, algorithm implementation
+- Bloom levels: Applying, Analyzing, Evaluating, Creating
+- Use when: Technical implementation or code analysis is required
+- Example: "Write a function to calculate factorial recursively"
+`;
+}
+function generateAdvancedBloomGuidance() {
+  return `
+ADVANCED BLOOM'S TAXONOMY & QUESTION TYPE OPTIMIZATION:
+
+**REMEMBERING (Knowledge Recall)**
+- Primary types: true_false, fill_in_the_blanks, matching
+- Secondary types: multiple_choice (simple recall)
+- Focus: Facts, terms, basic concepts, definitions
+- Misconception addressing: Use true_false to clarify common confusions
+
+**UNDERSTANDING (Comprehension)**
+- Primary types: multiple_choice, short_answer, matching
+- Secondary types: multiple_response, sequence
+- Focus: Explanations, interpretations, examples, classifications
+- Best for: "Explain why...", "What does this mean...", "Give an example..."
+
+**APPLYING (Using Knowledge)**
+- Primary types: numeric, short_answer, sequence, coding
+- Secondary types: multiple_choice, drag_and_drop
+- Focus: Problem-solving, implementing procedures, using methods
+- Best for: Calculations, step-by-step processes, practical applications
+
+**ANALYZING (Breaking Down Information)**
+- Primary types: multiple_response, short_answer, sequence, coding
+- Secondary types: drag_and_drop, multiple_choice
+- Focus: Identifying components, relationships, cause-effect
+- Best for: "What are the factors...", "How do these relate...", "Break down..."
+
+**EVALUATING (Making Judgments)**
+- Primary types: short_answer, multiple_response, coding
+- Secondary types: multiple_choice (with justification)
+- Focus: Critiquing, judging, comparing alternatives, decision-making
+- Best for: "Which is better and why...", "Evaluate the approach...", "Critique..."
+
+**CREATING (Producing New Work)**
+- Primary types: short_answer, coding, sequence
+- Secondary types: drag_and_drop (design tasks)
+- Focus: Designing, planning, producing, constructing
+- Best for: "Design a solution...", "Create a plan...", "Develop a strategy..."
+`;
+}
+function generateDiversityRules() {
+  return `
+ENHANCED DIVERSITY & QUALITY ASSURANCE RULES:
+
+**Question Type Distribution Strategy:**
+1. Never place more than 3 consecutive questions of the same type
+2. Distribute question types based on their cognitive complexity
+3. For quizzes with 10+ questions, use at least 4 different question types
+4. For quizzes with 20+ questions, use at least 6 different question types
+5. Balance quick-answer types (true_false, multiple_choice) with deeper types (short_answer, coding)
+
+**Intelligent Difficulty Progression:**
+1. Opening (20%): Start with confidence-building questions (Remembering/Understanding)
+2. Building (40%): Gradually increase complexity (Understanding/Applying)
+3. Peak (30%): Most challenging questions (Analyzing/Evaluating/Creating)
+4. Closing (10%): Moderate challenge to end positively
+
+**Misconception-Driven Planning:**
+- When common misconceptions are provided, prioritize question types that can effectively address them
+- Use true_false for binary misconceptions
+- Use multiple_choice for concept selection misconceptions
+- Use short_answer for complex misconceptions requiring explanation
+
+**Contextual Intelligence:**
+- Programming/Technical topics: Favor coding, numeric, short_answer
+- Process-oriented topics: Favor sequence, short_answer, drag_and_drop
+- Conceptual topics: Favor multiple_choice, multiple_response, true_false
+- Factual topics: Favor fill_in_the_blanks, matching, true_false
+`;
+}
+async function generateQuizPlan(clientInput, apiKey, imageContexts = []) {
+  var _a, _b, _c, _d, _e, _f, _g, _h, _i, _j, _k, _l, _m, _n;
+  const logger = new QuizPlanLogger();
+  try {
+    logger.log("VALIDATION_START", {
+      totalQuestions: clientInput.totalQuestions,
+      availableTypes: clientInput.selectedQuestionTypes,
+      topicCount: clientInput.topics.length,
+      bloomLevelCount: clientInput.bloomLevels.length
+    });
+    const totalTopicRatio = clientInput.topics.reduce((sum, t) => sum + t.ratio, 0);
+    if (Math.abs(totalTopicRatio - 100) > 1) {
+      throw new Error(`Total topic ratio must be 100%. Current sum: ${totalTopicRatio.toFixed(1)}%`);
+    }
+    const totalBloomRatio = clientInput.bloomLevels.reduce((sum, b) => sum + b.ratio, 0);
+    if (Math.abs(totalBloomRatio - 100) > 1) {
+      throw new Error(`Total Bloom level ratio must be 100%. Current sum: ${totalBloomRatio.toFixed(1)}%`);
+    }
+    logger.log("VALIDATION_SUCCESS", {
+      topicRatioSum: totalTopicRatio,
+      bloomRatioSum: totalBloomRatio
+    });
+    const aiStartTime = Date.now();
+    const ai = new genai.GoogleGenAI({
+      apiKey
+    });
+    const model = "gemini-2.5-pro";
+    const config = {
+      temperature: 0.8,
+      thinkingConfig: {
+        thinkingBudget: 4096
+      },
+      responseMimeType: "application/json"
+    };
+    logger.log("AI_INITIALIZATION", { model }, Date.now() - aiStartTime);
+    const { language, totalQuestions, numCodingQuestions = 0 } = clientInput;
+    const promptStartTime = Date.now();
+    const topicsDistribution = clientInput.topics.map((t) => {
+      let topicString = `- Topic Context: "${t.topic}", LoId: "${t.originalLoId || "nil"}", Subject: "${t.originalSubject || "nil"}", Category: "${t.originalCategory || "nil"}", Topic: "${t.originalTopic || "nil"}", Ratio: ${t.ratio}%`;
+      if (t.commonMisconceptions && t.commonMisconceptions.length > 0) {
+        topicString += `
+    - Common Misconceptions: [${t.commonMisconceptions.join(", ")}]`;
+      }
+      return topicString;
+    }).join("\n    ");
+    const bloomDistribution = clientInput.bloomLevels.map(
+      (b) => `- Level: "${b.level}", Ratio: ${b.ratio}%`
+    ).join("\n    ");
+    let questionTypesForPrompt = [...clientInput.selectedQuestionTypes];
+    if (numCodingQuestions === 0) {
+      questionTypesForPrompt = questionTypesForPrompt.filter(
+        (type) => type !== "short_answer" && type !== "coding"
+      );
+    }
+    const allowedQuestionTypes = questionTypesForPrompt.map((t) => `'${t}'`).join(", ");
+    const codingRequirement = numCodingQuestions > 0 ? `
+**CRITICAL CODING REQUIREMENT**: Exactly ${numCodingQuestions} questions in the plan MUST be of type 'coding'. These should typically be at 'applying' or higher Bloom levels and focus on implementation, debugging, or algorithm design.` : "";
+    const imageContextSection = imageContexts && imageContexts.length > 0 ? `
+## AVAILABLE IMAGE CONTEXT LIBRARY
+You have access to a library of pre-described images. When planning a question, if its subject, category, and topic match an image in this library AND the image's description is relevant to the planned question's topic, you MUST include the corresponding \`imageId\` in your output. Otherwise, leave the \`imageId\` field null or omit it.
+
+\`\`\`json
+${JSON.stringify(imageContexts.map((img) => ({ imageId: img.id, subject: img.subject, category: img.category, topic: img.topic, description: img.detailedDescription })), null, 2)}
+\`\`\`
+` : "";
+    const enhancedPromptText = `You are an elite educational assessment architect with expertise in cognitive science and adaptive learning. Your mission is to create a strategically optimized quiz plan that maximizes learning effectiveness.
+
+${generateQuestionTypeSelectionGuidance()}
+
+${generateAdvancedBloomGuidance()}
+
+${generateDiversityRules()}
+
+## COMPREHENSIVE QUIZ REQUIREMENTS:
+
+**Target Language**: ${language}
+**Total Questions**: ${totalQuestions}${codingRequirement}
+
+**Topic Distribution & Learning Context** (follow precisely):
+    ${topicsDistribution}
+
+**Cognitive Complexity Distribution** (follow precisely):
+    ${bloomDistribution}
+
+**Available Question Arsenal**: ${allowedQuestionTypes}
+
+**Image Resources**: ${imageContextSection} 
+
+## STRATEGIC PLANNING METHODOLOGY:
+
+1. **Misconception Analysis**: If common misconceptions are provided, design questions specifically to address and correct them
+2. **Question Type Intelligence**: Select question types based on the cognitive demands and content nature
+3. **Difficulty Orchestration**: Create a learning journey that builds confidence while challenging appropriately
+4. **Diversity Optimization**: Ensure variety prevents monotony and maintains engagement
+5. **Context Sensitivity**: Match question types to topic characteristics (technical, conceptual, procedural)
+6. **Image Context Integration**: Intelligently associate questions with relevant images from the provided library to enhance contextual understanding.
+
+## ENHANCED OUTPUT FORMAT:
+
+Return ONLY a JSON object with this EXACT structure:
+
+\`\`\`json
+{
+  "quizPlan": [
+   {
+      "plannedTopic": "Specific, assessable topic derived from provided context",
+      "plannedQuestionType": "question_type_from_allowed_list",
+      "plannedBloomLevel": "bloom_level_from_requirements",
+      "plannedContextId": "THEO_ABS",
+      "imageId": "imgctx_12345abcde", // or null
+      "targetMisconception": "Specific misconception this question addresses (or 'none' if not applicable)",
+      "difficultyReason": "Strategic explanation of difficulty choice and placement",
+      "topicSpecificity": "broad|focused|specific",
+      "originalLoId": "corresponding_LoId_from_input",
+      "originalSubject": "corresponding_Subject_from_input",
+      "originalCategory": "corresponding_Category_from_input",
+      "originalTopic": "corresponding_Topic_from_input"
+    }
+  ],
+  "diversityMetrics": {
+    "questionTypeDistribution": {"type1": count1, "type2": count2},
+    "bloomLevelDistribution": {"level1": count1, "level2": count2},
+    "maxConsecutiveSameType": number,
+    "difficultyProgression": "description of how difficulty progresses",
+    "misconceptionCoverage": number_of_misconceptions_addressed
+  },
+  "planningStrategy": {
+    "overallApproach": "Brief description of the strategic approach taken",
+    "keyDecisions": ["Major decision 1", "Major decision 2", "Major decision 3"]
+  }
+}
+\`\`\`
+
+Execute this plan with pedagogical precision. The quiz should feel like a carefully crafted learning journey that challenges and educates simultaneously.`;
+    logger.log("PROMPT_PREPARATION", {
+      promptLength: enhancedPromptText.length,
+      topicCount: clientInput.topics.length,
+      misconceptionCount: clientInput.topics.reduce((sum, t) => {
+        var _a2;
+        return sum + (((_a2 = t.commonMisconceptions) == null ? void 0 : _a2.length) || 0);
+      }, 0)
+    }, Date.now() - promptStartTime);
+    const generationStartTime = Date.now();
+    const contents = [
+      {
+        role: "user",
+        parts: [
+          {
+            text: enhancedPromptText
+          }
+        ]
+      }
+    ];
+    const aiResult = await ai.models.generateContent({
+      model,
+      config,
+      contents
+    });
+    const response = aiResult;
+    const generationDuration = Date.now() - generationStartTime;
+    logger.log("AI_GENERATION", {
+      responseLength: ((_f = (_e = (_d = (_c = (_b = (_a = response.candidates) == null ? void 0 : _a[0]) == null ? void 0 : _b.content) == null ? void 0 : _c.parts) == null ? void 0 : _d[0]) == null ? void 0 : _e.text) == null ? void 0 : _f.length) || 0,
+      duration: generationDuration
+    }, generationDuration);
+    const processingStartTime = Date.now();
+    const rawText = ((_k = (_j = (_i = (_h = (_g = response.candidates) == null ? void 0 : _g[0]) == null ? void 0 : _h.content) == null ? void 0 : _i.parts) == null ? void 0 : _j[0]) == null ? void 0 : _k.text) || "";
+    let jsonText = rawText;
+    if (!rawText.trim().startsWith("{") && !rawText.trim().startsWith("[")) {
+      jsonText = extractJsonFromMarkdown(rawText);
+    }
+    logger.log("JSON_EXTRACTION", {
+      rawTextLength: rawText.length,
+      extractedJsonLength: jsonText.length
+    });
+    const aiGeneratedContent = GenerateQuizPlanOutputSchema.parse(JSON.parse(jsonText));
+    logger.log("SCHEMA_VALIDATION", { success: true }, Date.now() - processingStartTime);
+    const validationStartTime = Date.now();
+    if (aiGeneratedContent.quizPlan.length !== clientInput.totalQuestions) {
+      throw new Error(`AI planned for ${aiGeneratedContent.quizPlan.length} questions, but ${clientInput.totalQuestions} were requested.`);
+    }
+    const invalidTypes = [];
+    aiGeneratedContent.quizPlan.forEach((item, index) => {
+      if (!clientInput.selectedQuestionTypes.includes(item.plannedQuestionType)) {
+        invalidTypes.push(`Question ${index + 1}: '${item.plannedQuestionType}'`);
+      }
+    });
+    if (invalidTypes.length > 0) {
+      throw new Error(`Invalid question types found: ${invalidTypes.join(", ")}`);
+    }
+    const codingQuestions = aiGeneratedContent.quizPlan.filter((q) => q.plannedQuestionType === "coding");
+    if (numCodingQuestions > 0 && codingQuestions.length !== numCodingQuestions) {
+      throw new Error(`Expected ${numCodingQuestions} coding questions, but got ${codingQuestions.length}`);
+    }
+    const diversityAnalysis = validateConsecutiveTypes(aiGeneratedContent.quizPlan);
+    logger.log("VALIDATION_COMPLETE", {
+      questionCount: aiGeneratedContent.quizPlan.length,
+      codingQuestionCount: codingQuestions.length,
+      maxConsecutiveType: diversityAnalysis.maxConsecutive,
+      questionTypeDistribution: ((_l = aiGeneratedContent.diversityMetrics) == null ? void 0 : _l.questionTypeDistribution) || {}
+    }, Date.now() - validationStartTime);
+    const finalResult = __spreadProps(__spreadValues({}, aiGeneratedContent), {
+      logs: logger.getLogs()
+    });
+    logger.log("GENERATION_COMPLETE", {
+      totalDuration: logger.getTotalDuration(),
+      success: true,
+      finalQuestionCount: finalResult.quizPlan.length
+    }, logger.getTotalDuration());
+    console.log("\n=== QUIZ PLAN GENERATION SUMMARY ===");
+    console.log(`\u2705 Successfully generated ${finalResult.quizPlan.length} questions`);
+    console.log(`\u23F1\uFE0F Total generation time: ${logger.getTotalDuration()}ms`);
+    console.log(`\u{1F3AF} Question types: ${Object.keys(((_m = finalResult.diversityMetrics) == null ? void 0 : _m.questionTypeDistribution) || {}).join(", ")}`);
+    console.log(`\u{1F9E0} Bloom levels: ${Object.keys(((_n = finalResult.diversityMetrics) == null ? void 0 : _n.bloomLevelDistribution) || {}).join(", ")}`);
+    if (numCodingQuestions > 0) {
+      console.log(`\u{1F4BB} Coding questions: ${codingQuestions.length}/${numCodingQuestions} required`);
+    }
+    console.log(JSON.stringify(finalResult));
+    console.log("=====================================\n");
+    return finalResult;
+  } catch (error) {
+    logger.log("ERROR", {
+      message: error.message,
+      stack: error.stack,
+      totalDuration: logger.getTotalDuration()
+    });
+    console.error("\u274C Quiz Plan Generation Failed:", error.message);
+    console.error("\u{1F4CB} Full logs available in returned object");
+    throw new Error(`Failed to generate Quiz Plan: ${error.message}`);
+  }
+}
+function validateConsecutiveTypes(quizPlan) {
+  var _a, _b;
+  let maxConsecutive = 1;
+  let maxType = ((_a = quizPlan[0]) == null ? void 0 : _a.plannedQuestionType) || "";
+  let maxStartIndex = 0;
+  let currentConsecutive = 1;
+  let currentType = ((_b = quizPlan[0]) == null ? void 0 : _b.plannedQuestionType) || "";
+  let currentStartIndex = 0;
+  for (let i = 1; i < quizPlan.length; i++) {
+    if (quizPlan[i].plannedQuestionType === currentType) {
+      currentConsecutive++;
+    } else {
+      if (currentConsecutive > maxConsecutive) {
+        maxConsecutive = currentConsecutive;
+        maxType = currentType;
+        maxStartIndex = currentStartIndex;
+      }
+      currentConsecutive = 1;
+      currentType = quizPlan[i].plannedQuestionType;
+      currentStartIndex = i;
+    }
+  }
+  if (currentConsecutive > maxConsecutive) {
+    maxConsecutive = currentConsecutive;
+    maxType = currentType;
+    maxStartIndex = currentStartIndex;
+  }
+  return {
+    maxConsecutive,
+    type: maxType,
+    startIndex: maxStartIndex
+  };
+}
+
+// src/services/TopicDataService.ts
+var TopicDataService = class {
+  /**
+   * Saves an array of LearningObjective objects to Local Storage, overwriting existing data.
+   * @param data The array of learning objectives to save.
+   */
+  static saveData(data) {
+    try {
+      if (typeof window === "undefined") return;
+      const serializedData = JSON.stringify(data);
+      localStorage.setItem(this.STORAGE_KEY, serializedData);
+    } catch (error) {
+      console.error("Error saving learning objectives to Local Storage:", error);
+    }
+  }
+  /**
+   * Merges a new set of learning objectives with the existing data in Local Storage.
+   * If an LO ID from newData already exists, it will be updated. Otherwise, it will be added.
+   * @param newData The array of new or updated learning objectives.
+   */
+  static mergeData(newData) {
+    const existingData = this.getData();
+    const loMap = new Map(existingData.map((lo) => [lo.loId, lo]));
+    newData.forEach((newLo) => {
+      loMap.set(newLo.loId, newLo);
+    });
+    const mergedData = Array.from(loMap.values());
+    this.saveData(mergedData);
+  }
+  /**
+   * Retrieves the array of LearningObjective objects from Local Storage.
+   * @returns An array of learning objectives, or an empty array if none are found or an error occurs.
+   */
+  static getData() {
+    try {
+      if (typeof window === "undefined") return [];
+      const storedData = localStorage.getItem(this.STORAGE_KEY);
+      return storedData ? JSON.parse(storedData) : [];
+    } catch (error) {
+      console.error("Error retrieving learning objectives from Local Storage:", error);
+      this.clearData();
+      return [];
+    }
+  }
+  /**
+   * Removes all learning objective data from Local Storage.
+   */
+  static clearData() {
+    try {
+      if (typeof window === "undefined") return;
+      localStorage.removeItem(this.STORAGE_KEY);
+    } catch (error) {
+      console.error("Error clearing learning objectives from Local Storage:", error);
+    }
+  }
+  /**
+   * Parses TSV content into an array of LearningObjective objects.
+   * @param tsvContent The raw string content from a .tsv file.
+   * @returns An object containing the successfully parsed data and any errors encountered.
+   */
+  static parseTSV(tsvContent) {
+    const lines = tsvContent.split("\n").filter((line) => line.trim() !== "");
+    if (lines.length < 2) {
+      return { data: [], errors: ["File is empty or contains only a header."] };
+    }
+    const headerLine = lines.shift();
+    const headers = headerLine.split("	").map((h) => h.trim());
+    if (headers.length !== this.EXPECTED_HEADERS.length || !this.EXPECTED_HEADERS.every((h, i) => h === headers[i])) {
+      const errorMsg = `Invalid TSV header. Expected: "${this.EXPECTED_HEADERS.join("	")}". Received: "${headers.join("	")}"`;
+      return { data: [], errors: [errorMsg] };
+    }
+    const data = [];
+    const errors = [];
+    lines.forEach((line, index) => {
+      const values = line.split("	").map((v) => v.trim());
+      if (values.length !== this.EXPECTED_HEADERS.length) {
+        errors.push(`Line ${index + 2}: Incorrect number of columns. Expected ${this.EXPECTED_HEADERS.length}, but got ${values.length}.`);
+        return;
+      }
+      const [
+        loId,
+        loDescription,
+        subject,
+        category,
+        topic,
+        keywordsStr,
+        grade,
+        stemElementsStr,
+        bloomLevelsStr
+      ] = values;
+      if (!loId || !subject || !category || !topic) {
+        errors.push(`Line ${index + 2}: Missing required fields (LO ID, Subject, Category, or Topic).`);
+        return;
+      }
+      const learningObjective = {
+        loId,
+        loDescription,
+        subject,
+        category,
+        topic,
+        keywords: keywordsStr.split(",").map((k) => k.trim()).filter(Boolean),
+        grade,
+        stemElements: stemElementsStr.split(",").map((s) => s.trim()).filter(Boolean),
+        bloomLevelsGuideline: bloomLevelsStr.split(",").map((b) => b.trim()).filter(Boolean)
+      };
+      data.push(learningObjective);
+    });
+    return { data, errors };
+  }
+  /**
+   * Gets a unique list of all subjects from the stored data.
+   * @returns An array of subject strings.
+   */
+  static getSubjects() {
+    const data = this.getData();
+    const subjects = data.map((item) => item.subject);
+    return [...new Set(subjects)].sort();
+  }
+  /**
+   * Gets a unique list of categories for a given subject.
+   * @param subject The subject to filter by.
+   * @returns An array of category strings.
+   */
+  static getCategoriesBySubject(subject) {
+    const data = this.getData();
+    const categories = data.filter((item) => item.subject === subject).map((item) => item.category);
+    return [...new Set(categories)].sort();
+  }
+  /**
+   * Gets a unique list of topics for a given category.
+   * @param category The category to filter by.
+   * @returns An array of topic strings.
+   */
+  static getTopicsByCategory(category) {
+    const data = this.getData();
+    const topics = data.filter((item) => item.category === category).map((item) => item.topic);
+    return [...new Set(topics)].sort();
+  }
+  /**
+   * Retrieves all LearningObjective details for a given list of topics.
+   * @param topics An array of topic strings to search for.
+   * @returns An array of matching LearningObjective objects.
+   */
+  static getLearningObjectivesByTopics(topics) {
+    const data = this.getData();
+    const topicSet = new Set(topics);
+    return data.filter((item) => topicSet.has(item.topic));
+  }
+};
+TopicDataService.STORAGE_KEY = "interactive_quiz_kit_learning_objectives";
+TopicDataService.EXPECTED_HEADERS = [
+  "LO ID",
+  "LO Description",
+  "Subject",
+  "Category",
+  "Topic",
+  "Keywords",
+  "Grade",
+  "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()),
+    expectedOutput: zod.z.any().describe("The expected output for this test case - REQUIRED"),
+    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, imageUrl } = clientInput;
+  const subject = (quizContext == null ? void 0 : 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.
+
+` : "";
+  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 == null ? void 0 : quizContext.loDescription) && `**Learning Objective:** ${quizContext.loDescription}`,
+    imageContextInstruction,
+    (quizContext == null ? void 0 : quizContext.plannedBloomLevel) && `**Cognitive Level (Bloom's):** ${quizContext.plannedBloomLevel}`,
+    (quizContext == null ? void 0 : quizContext.targetMisconception) && `**Target Misconception:** The problem should test against this common error: "${quizContext.targetMisconception}"`
+  ].filter(Boolean).map((s) => `- ${s}`).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.
+
+## CRITICAL CONTEXT FOR THIS QUESTION
+${contextStrings}
+
+## Task: Generate the Question
+### Input Parameters
+- **Topic for Question:** ${(quizContext == null ? void 0 : quizContext.plannedTopic) || "General"}
+- **Natural Language for Text:** ${language}
+- **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) {
+  var _a, _b, _c, _d, _e, _f, _g, _h, _i, _j, _k;
+  const ai = new genai.GoogleGenAI({ apiKey });
+  const model = "gemini-2.5-flash";
+  const config = {
+    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, __spreadProps(__spreadValues({}, 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, contents });
+      const response = aiResult;
+      const rawText = ((_e = (_d = (_c = (_b = (_a = response.candidates) == null ? void 0 : _a[0]) == null ? void 0 : _b.content) == null ? void 0 : _c.parts) == null ? void 0 : _d[0]) == null ? void 0 : _e.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) => {
+        if (tc.expectedOutput === void 0) {
+          throw new Error("A test case from AI is missing the required 'expectedOutput' field.");
+        }
+        return {
+          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,
+        // FIXED: Correct field name
+        functionSignature: aiGeneratedContent.functionSignature,
+        solutionCode: aiGeneratedContent.solutionCode,
+        testCases,
+        points: 25,
+        topic: (_f = clientInput.quizContext) == null ? void 0 : _f.originalTopic,
+        difficulty: clientInput.difficulty,
+        contextCode: (_g = clientInput.quizContext) == null ? void 0 : _g.plannedContextId,
+        bloomLevel: (_h = clientInput.quizContext) == null ? void 0 : _h.plannedBloomLevel,
+        learningObjective: (_i = clientInput.quizContext) == null ? void 0 : _i.originalLoId,
+        subject: (_j = clientInput.quizContext) == null ? void 0 : _j.originalSubject,
+        category: (_k = clientInput.quizContext) == null ? void 0 : _k.originalCategory,
+        imageUrl: clientInput.imageUrl
+      };
+      const validatedQuestion = 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: validatedQuestion };
+    } 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 == null ? void 0 : 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;
+var RETRY_DELAY_MS10 = 2e3;
+var delay = (ms) => new Promise((res) => setTimeout(res, ms));
+var calculateCombinedDifficulty = (plannedQ) => {
+  const { plannedBloomLevel, plannedQuestionType, plannedContextId } = plannedQ;
+  let contextScore = 1;
+  if (["SPEC_CASE", "NAT_OBS", "DATA_MOD", "INTERDISC", "HYPO_COMP"].includes(plannedContextId || "")) contextScore = 2;
+  else if (["TECH_ENG", "EXP_INV", "REAL_PROB"].includes(plannedContextId || "")) contextScore = 3;
+  let bloomScore = 1;
+  if (plannedBloomLevel === "understanding") bloomScore = 2;
+  else if (plannedBloomLevel === "applying") bloomScore = 3;
+  else if (["analyzing", "evaluating", "creating"].includes(plannedBloomLevel)) bloomScore = 4;
+  let questionTypeScore = 1;
+  switch (plannedQuestionType) {
+    case "matching":
+    case "fill_in_the_blanks":
+    case "numeric":
+      questionTypeScore = 2;
+      break;
+    case "sequence":
+    case "multiple_response":
+    case "drag_and_drop":
+    case "coding":
+      questionTypeScore = 3;
+      break;
+  }
+  const totalScore = bloomScore + contextScore + questionTypeScore;
+  if (totalScore <= 4) return "easy";
+  if (totalScore <= 7) return "medium";
+  return "hard";
+};
+async function generateQuestionsFromQuizPlan(clientInput, apiKey) {
+  var _a, _b;
+  const { quizPlan, language, imageContexts } = clientInput;
+  const generatedQuestions = [];
+  const errors = [];
+  const allLearningObjectives = TopicDataService.getData();
+  for (let i = 0; i < quizPlan.length; i++) {
+    const plannedQ = quizPlan[i];
+    let questionGenerated = false;
+    let lastError = null;
+    for (let attempt = 1; attempt <= MAX_ATTEMPTS; attempt++) {
+      try {
+        const fullLO = plannedQ.originalLoId ? allLearningObjectives.find((lo) => lo.loId === plannedQ.originalLoId) : null;
+        const quizContext = {
+          plannedTopic: plannedQ.plannedTopic,
+          plannedQuestionType: plannedQ.plannedQuestionType,
+          plannedBloomLevel: plannedQ.plannedBloomLevel,
+          plannedContextId: plannedQ.plannedContextId,
+          targetMisconception: plannedQ.targetMisconception,
+          difficultyReason: plannedQ.difficultyReason,
+          topicSpecificity: plannedQ.topicSpecificity,
+          originalLoId: plannedQ.originalLoId,
+          originalSubject: plannedQ.originalSubject,
+          originalCategory: plannedQ.originalCategory,
+          originalTopic: plannedQ.originalTopic,
+          loDescription: (fullLO == null ? void 0 : fullLO.loDescription) || plannedQ.plannedTopic
+        };
+        const imageUrl = plannedQ.imageId && imageContexts ? (_a = imageContexts.find((ctx) => ctx.id === plannedQ.imageId)) == null ? void 0 : _a.imageUrl : void 0;
+        const baseClientInput = {
+          language,
+          difficulty: calculateCombinedDifficulty(plannedQ),
+          quizContext,
+          imageUrl
+        };
+        let result = {};
+        switch (plannedQ.plannedQuestionType) {
+          case "true_false":
+            result = await generateTrueFalseQuestion(baseClientInput, apiKey);
+            break;
+          case "multiple_choice":
+            result = await generateMCQQuestion(__spreadProps(__spreadValues({}, baseClientInput), { numberOfOptions: 4 }), apiKey);
+            break;
+          case "multiple_response":
+            result = await generateMRQQuestion(__spreadProps(__spreadValues({}, baseClientInput), { numberOfOptions: 5, minCorrectAnswers: 2, maxCorrectAnswers: 3 }), apiKey);
+            break;
+          case "short_answer":
+            result = await generateShortAnswerQuestion(__spreadProps(__spreadValues({}, baseClientInput), { isCaseSensitive: false }), apiKey);
+            break;
+          case "numeric":
+            result = await generateNumericQuestion(__spreadProps(__spreadValues({}, baseClientInput), { allowDecimals: true, tolerance: 0 }), apiKey);
+            break;
+          case "fill_in_the_blanks":
+            result = await generateFillInTheBlanksQuestion(__spreadProps(__spreadValues({}, baseClientInput), { numberOfBlanks: 2, isCaseSensitive: false }), apiKey);
+            break;
+          case "sequence":
+            result = await generateSequenceQuestion(__spreadProps(__spreadValues({}, baseClientInput), { numberOfItems: 4 }), apiKey);
+            break;
+          case "matching":
+            result = await generateMatchingQuestion(__spreadProps(__spreadValues({}, baseClientInput), { numberOfPairs: 4, shuffleOptions: true }), apiKey);
+            break;
+          case "coding": {
+            const subject = ((_b = plannedQ.originalSubject) == null ? void 0 : _b.toLowerCase()) || "";
+            let codingLanguage = "javascript";
+            if (subject.includes("swift")) codingLanguage = "swift";
+            else if (subject.includes("python")) codingLanguage = "python";
+            result = await generateCodingQuestion(__spreadProps(__spreadValues({}, baseClientInput), {
+              codingLanguage,
+              displayLanguage: language || "English"
+            }), apiKey);
+            break;
+          }
+          default:
+            throw new Error(`Question type "${plannedQ.plannedQuestionType}" is not supported for automated generation.`);
+        }
+        if (result.error) {
+          throw new Error(result.error);
+        }
+        if (result.question) {
+          const question = result.question;
+          question.learningObjective = plannedQ.originalLoId;
+          question.subject = plannedQ.originalSubject;
+          question.category = plannedQ.originalCategory;
+          question.topic = plannedQ.originalTopic;
+          question.bloomLevel = plannedQ.plannedBloomLevel;
+          if (question.points === void 0) question.points = 10;
+          generatedQuestions.push(question);
+          questionGenerated = true;
+          break;
+        } else {
+          throw new Error(`AI did not return a question object for type '${plannedQ.plannedQuestionType}'.`);
+        }
+      } catch (e) {
+        lastError = e;
+        console.warn(`Attempt ${attempt} failed for question ${i + 1} (Topic: ${plannedQ.plannedTopic}): ${e.message}`);
+        if (attempt < MAX_ATTEMPTS) {
+          await delay(RETRY_DELAY_MS10);
+        }
+      }
+    }
+    if (!questionGenerated && lastError) {
+      errors.push({
+        plannedQuestionIndex: i,
+        plannedTopic: plannedQ.plannedTopic,
+        plannedQuestionType: plannedQ.plannedQuestionType,
+        error: lastError.message || "Unknown error after all retries."
+      });
+    }
+  }
+  return { generatedQuestions, errors: errors.length > 0 ? errors : void 0 };
+}
+var QuestionResultForAISchema = zod.z.object({
+  questionId: zod.z.string(),
+  prompt: zod.z.string(),
+  isCorrect: zod.z.boolean(),
+  userAnswer: zod.z.any().optional(),
+  correctAnswer: zod.z.any().optional(),
+  evaluationDetails: zod.z.array(zod.z.custom()).optional().describe("Detailed results for each test case, for coding questions.")
+});
+zod.z.object({
+  language: zod.z.string().describe('The language for the generated review (e.g., "Vietnamese", "English").'),
+  questionResults: zod.z.array(QuestionResultForAISchema).min(1)
+});
+var AIQuizReviewOutputSchema = zod.z.object({
+  questionReviews: zod.z.array(
+    zod.z.object({
+      questionId: zod.z.string().describe("The ID of the question being reviewed."),
+      explanation: zod.z.string().describe("A detailed, personalized explanation for this question in Markdown format.")
+    })
+  ).describe("An array of reviews, one for each question."),
+  overallSummary: zod.z.string().describe("A comprehensive summary of key concepts in Markdown format."),
+  relatedTopics: zod.z.array(zod.z.string()).describe("A list of suggested topics or keywords for further study.")
+});
+
+// src/ai/flows/generate-quiz-review.ts
+async function generateQuizReview(clientInput, apiKey) {
+  try {
+    const ai = genkit.genkit({
+      plugins: [googleai.googleAI({ apiKey })],
+      model: googleai.gemini20Flash
+    });
+    const resultsString = JSON.stringify(clientInput.questionResults, null, 2);
+    const promptText = `
+You are an expert educational tutor. Your task is to analyze a student's quiz results and provide a detailed, helpful review in ${clientInput.language}.
+
+**Here are the student's quiz results:**
+${resultsString}
+
+**Instructions:**
+1.  **Analyze Each Question:** For every question in the results, create a corresponding object in the "questionReviews" array. Match the "questionId".
+2.  **Write Personalized Explanations:** In the "explanation" for each question, provide a clear and encouraging explanation.
+    - **For standard questions:** Explain why the correct answer is right and, if the user was wrong, gently explain their misconception.
+    - **CRITICAL - For CODING questions (those with 'evaluationDetails'):**
+        - If the user was correct ('isCorrect': true), congratulate them and briefly praise their solution.
+        - If the user was incorrect, analyze the 'evaluationDetails'. Find the FIRST failed test case. Explain WHY their code failed that specific test case. For example: "Your code works for positive numbers, but it failed on the test case with an empty array. It seems you haven't handled that edge case."
+        - DO NOT just repeat the test case data. Provide a pedagogical explanation.
+3.  **Create an Overall Summary:** In "overallSummary", synthesize the main ideas from all questions into a cohesive review. Focus on reinforcing the main learning points, especially those related to questions the user answered incorrectly.
+4.  **Suggest Further Study:** In "relatedTopics", provide 2-3 specific keywords or topics for further study.
+5.  **Language and Formatting:** Ensure all generated text is in ${clientInput.language} and uses Markdown.
+
+**JSON OUTPUT FORMAT:**
+Return a single, valid JSON object with this EXACT format.
+
+\`\`\`json
+{
+  "questionReviews": [
+    {
+      "questionId": "some-question-id-1",
+      "explanation": "Your detailed explanation for the first question goes here."
+    }
+  ],
+  "overallSummary": "A comprehensive summary of the key concepts from the quiz.",
+  "relatedTopics": ["Keyword for further study 1", "Related Concept 2"]
+}
+\`\`\`
+
+Return only the valid JSON response.`;
+    const response = await ai.generate(promptText);
+    const rawText = response.text;
+    const jsonText = extractJsonFromMarkdown(rawText);
+    const aiGeneratedContent = JSON.parse(jsonText);
+    const validatedOutput = AIQuizReviewOutputSchema.parse(aiGeneratedContent);
+    return validatedOutput;
+  } catch (error) {
+    console.error("Error generating Quiz Review:", error);
+    if (error instanceof zod.z.ZodError) {
+      throw new Error(`AI returned data in an unexpected format. Validation failed: ${error.message}`);
+    }
+    throw new Error(`Failed to generate Quiz Review: ${error.message}`);
+  }
+}
+zod.z.object({
+  language: zod.z.string(),
+  userName: zod.z.string().optional(),
+  performanceByTopic: zod.z.array(zod.z.object({
+    name: zod.z.string(),
+    averageScore: zod.z.number()
+  })).optional(),
+  recentHistory: zod.z.array(zod.z.object({
+    quizTitle: zod.z.string(),
+    percentage: zod.z.number(),
+    topics: zod.z.array(zod.z.object({
+      subject: zod.z.string(),
+      category: zod.z.string(),
+      topic: zod.z.string()
+    }))
+  })).optional(),
+  allAvailableTopics: zod.z.array(zod.z.object({
+    loId: zod.z.string(),
+    subject: zod.z.string(),
+    category: zod.z.string(),
+    topic: zod.z.string()
+  }))
+});
+var PracticeSuggestionOutputSchema = zod.z.object({
+  suggestionText: zod.z.string().describe("The personalized message from the AI tutor in Markdown format."),
+  suggestedTopics: zod.z.array(zod.z.object({
+    loId: zod.z.string(),
+    topicName: zod.z.string(),
+    reason: zod.z.enum(["review", "explore"]),
+    suggestedDifficulty: zod.z.enum(["Very Easy", "Easy", "Medium", "Hard", "Expert"])
+  }))
+});
+async function generatePracticeSuggestion(clientInput, apiKey) {
+  try {
+    const ai = genkit.genkit({
+      plugins: [googleai.googleAI({ apiKey })],
+      model: googleai.gemini20Flash
+    });
+    const { language, userName, performanceByTopic, recentHistory, allAvailableTopics } = clientInput;
+    const promptText = `
+You are a friendly and insightful AI Learning Coach. Your goal is to provide a personalized practice suggestion for a student named ${userName || "there"}.
+
+**Analyze the following student data:**
+
+1.  **Performance by Topic (Weaknesses):**
+    ${JSON.stringify(performanceByTopic, null, 2)}
+
+2.  **Recent Practice Sessions (Strengths & Recent Activity):**
+    ${JSON.stringify(recentHistory, null, 2)}
+
+3.  **All Available Topics in the Curriculum:**
+    ${JSON.stringify(allAvailableTopics.slice(0, 50), null, 2)}... (and more)
+
+**Your Task:**
+Based on the data, create a helpful and encouraging practice plan. Follow these steps in your reasoning:
+1.  **Identify Weaknesses:** Look at "Performance by Topic". Identify 1-2 topics with the lowest 'averageScore'. These are candidates for 'review'.
+2.  **Identify Strengths/Interests:** Look at "Recent Practice Sessions". Identify 1-2 topics the student has recently practiced and performed well on (e.g., score > 80%).
+3.  **Suggest Related Topics:** From the "All Available Topics" list, find 1-2 new topics that are in the same 'category' or 'subject' as the student's strengths. These are candidates for 'explore'.
+4.  **Suggest Difficulty:** For each suggested topic, determine an appropriate difficulty level ('Easy', 'Medium', or 'Hard').
+    - If the reason is 'review', suggest 'Easy' or 'Medium' to help them rebuild their foundation.
+    - If the reason is 'explore', suggest 'Medium' as a starting point for a new challenge.
+5.  **Synthesize a Plan:** Combine the topics for 'review' and 'explore' into a balanced suggestion.
+6.  **Write a Personalized Message:** In 'suggestionText', write a friendly message in ${language}. Explain WHY you are suggesting these topics and difficulties.
+
+**JSON OUTPUT FORMAT:**
+Return a single, valid JSON object in this exact format. All text must be in ${language}.
+
+{
+  "suggestionText": "Ch\xE0o ${userName || "b\u1EA1n"}, t\xF4i \u0111\xE3 xem qua k\u1EBFt qu\u1EA3 c\u1EE7a b\u1EA1n! \u0110\u1EC3 c\u1EE7ng c\u1ED1 ki\u1EBFn th\u1EE9c, ch\xFAng ta h\xE3y \xF4n l\u1EA1i ch\u1EE7 \u0111\u1EC1 [T\xEAn ch\u1EE7 \u0111\u1EC1 y\u1EBFu] \u1EDF m\u1EE9c \u0111\u1ED9 'Easy' nh\xE9. V\xEC b\u1EA1n \u0111\xE3 l\xE0m r\u1EA5t t\u1ED1t ph\u1EA7n [T\xEAn ch\u1EE7 \u0111\u1EC1 m\u1EA1nh], h\xE3y th\u1EED s\u1EE9c v\u1EDBi ch\u1EE7 \u0111\u1EC1 li\xEAn quan l\xE0 [T\xEAn ch\u1EE7 \u0111\u1EC1 kh\xE1m ph\xE1] \u1EDF m\u1EE9c \u0111\u1ED9 'Medium' xem sao!",
+  "suggestedTopics": [
+    { "loId": "some-lo-id-1", "topicName": "[T\xEAn ch\u1EE7 \u0111\u1EC1 y\u1EBFu]", "reason": "review", "suggestedDifficulty": "Easy" },
+    { "loId": "some-lo-id-2", "topicName": "[T\xEAn ch\u1EE7 \u0111\u1EC1 kh\xE1m ph\xE1]", "reason": "explore", "suggestedDifficulty": "Medium" }
+  ]
+}
+
+Return only the JSON response.`;
+    const response = await ai.generate(promptText);
+    const rawText = response.text;
+    const jsonText = extractJsonFromMarkdown(rawText);
+    const aiGeneratedContent = JSON.parse(jsonText);
+    const validatedOutput = PracticeSuggestionOutputSchema.parse(aiGeneratedContent);
+    return validatedOutput;
+  } catch (error) {
+    console.error("Error generating practice suggestion:", error);
+    if (error instanceof zod.z.ZodError) {
+      throw new Error(`AI returned data in an unexpected format. Validation failed: ${error.message}`);
+    }
+    throw new Error(`Failed to generate practice suggestion: ${error.message}`);
+  }
+}
+zod.z.object({
+  language: zod.z.string().default("English"),
+  userName: zod.z.string().optional(),
+  weeklyGoal: zod.z.number().optional(),
+  unlockedAchievements: zod.z.array(zod.z.object({
+    id: zod.z.string(),
+    name: zod.z.string(),
+    description: zod.z.string(),
+    icon: zod.z.string()
+  })),
+  stats: zod.z.any(),
+  // Using z.any() for simplicity, as PracticeStats is complex and defined elsewhere.
+  history: zod.z.array(zod.z.any()),
+  // Using z.any() for simplicity.
+  startDate: zod.z.string().describe("The start date for the analysis period in ISO format (YYYY-MM-DD)."),
+  endDate: zod.z.string().describe("The end date for the analysis period in ISO format (YYYY-MM-DD)."),
+  allAvailableTopics: zod.z.array(zod.z.object({
+    loId: zod.z.string(),
+    subject: zod.z.string(),
+    category: zod.z.string(),
+    topic: zod.z.string()
+  })).describe("A complete list of all available topics for the AI to choose from.")
+});
+var RoadmapItemSchema = zod.z.object({
+  day: zod.z.string(),
+  topicName: zod.z.string(),
+  reason: zod.z.string(),
+  suggestedDifficulty: zod.z.enum(["Very Easy", "Easy", "Medium", "Hard", "Expert"]),
+  loId: zod.z.string(),
+  isCompleted: zod.z.boolean()
+});
+var WeeklyRoadmapSchema = zod.z.object({
+  generatedAt: zod.z.number(),
+  items: zod.z.array(RoadmapItemSchema)
+});
+var AnalysisReportSchema = zod.z.object({
+  generatedAt: zod.z.number(),
+  startDate: zod.z.string(),
+  endDate: zod.z.string(),
+  effortAndConsistencyRemarks: zod.z.string(),
+  strengths: zod.z.array(zod.z.string()),
+  areasForImprovement: zod.z.array(zod.z.string()),
+  gamificationRemarks: zod.z.string()
+});
+var LearningAnalysisOutputSchema = zod.z.object({
+  analysisReport: AnalysisReportSchema.optional(),
+  weeklyRoadmap: WeeklyRoadmapSchema.optional()
+});
+
+// src/ai/flows/generate-learning-analysis.ts
+async function generateLearningAnalysis(clientInput, apiKey) {
+  try {
+    const ai = genkit.genkit({
+      plugins: [googleai.googleAI({ apiKey })],
+      model: googleai.gemini20Flash
+    });
+    const {
+      language,
+      userName = "learner",
+      weeklyGoal = 5,
+      unlockedAchievements,
+      stats,
+      history,
+      startDate,
+      endDate,
+      allAvailableTopics
+    } = clientInput;
+    const filteredHistory = history.filter(
+      (session) => session.timestamp >= new Date(startDate).getTime() && session.timestamp <= new Date(endDate).setHours(23, 59, 59, 999)
+    );
+    const promptText = `
+You are an expert AI Learning Coach. Your task is to analyze a student's learning data and generate a comprehensive JSON object containing an analysis report and a suggested weekly roadmap.
+
+**Student Data:**
+- Name: ${userName}
+- Weekly Goal: ${weeklyGoal} sessions
+- Unlocked Achievements: ${JSON.stringify(unlockedAchievements.map((a) => a.name))}
+- Overall Performance Stats (for context): ${JSON.stringify(stats, null, 2)}
+- Detailed Practice History (for analysis): ${JSON.stringify(filteredHistory, null, 2)}
+- **Source of Truth - All Available Topics**: ${JSON.stringify(allAvailableTopics, null, 2)}
+
+**CRITICAL INSTRUCTIONS:**
+You MUST generate a single JSON object with two main keys: "analysisReport" and "weeklyRoadmap".
+All topic names and loIds in your "weeklyRoadmap" output MUST be chosen directly from the "All Available Topics" list provided above. DO NOT invent topics or loIds.
+
+--- LOGIC FLOW ---
+
+**IF Practice History is NOT EMPTY:**
+1.  **For "analysisReport":**
+    - Analyze the data strictly within the period from ${startDate} to ${endDate}.
+    - **effortAndConsistencyRemarks**: Write a personalized comment on the student's effort.
+    - **strengths**: Identify 2-3 topics where the student performed best.
+    - **areasForImprovement**: Identify 2-3 topics where the student struggled the most.
+    - **gamificationRemarks**: Write an encouraging message mentioning their achievements.
+2.  **For "weeklyRoadmap":**
+    - Create a 5-item roadmap for the upcoming week.
+    - Prioritize the "areasForImprovement" you identified. For each, find the corresponding entry in "All Available Topics" and use its "topicName" and "loId".
+    - If more items are needed, select related topics from "All Available Topics".
+
+**IF Practice History IS EMPTY:**
+1.  **For "analysisReport":**
+    - **effortAndConsistencyRemarks**: Write a welcoming message for a new learner, encouraging them to start their journey.
+    - **strengths**: Return an empty array [].
+    - **areasForImprovement**: Return an empty array [].
+    - **gamificationRemarks**: Write a general motivational message about starting to learn.
+2.  **For "weeklyRoadmap":**
+    - Create a 5-item "starter" roadmap.
+    - Select 5 diverse and foundational topics directly from the "All Available Topics" list. Use their exact "topicName" and "loId".
+    - For the "reason", explain that this is a good starting point to explore the subject.
+
+--- END LOGIC FLOW ---
+
+**CRITICAL JSON OUTPUT FORMAT:**
+Return ONLY the JSON object. All descriptive string content (like remarks, strengths, reasons) MUST be in ${language}.
+The 'suggestedDifficulty' field MUST ALWAYS be one of these exact English strings: 'Very Easy', 'Easy', 'Medium', 'Hard', 'Expert'.
+
+\`\`\`json
+{
+  "analysisReport": {
+    "generatedAt": ${Date.now()},
+    "startDate": "${startDate}",
+    "endDate": "${endDate}",
+    "effortAndConsistencyRemarks": "Your detailed remarks...",
+    "strengths": ["Topic A", "Subject B"],
+    "areasForImprovement": ["Topic C", "Topic D"],
+    "gamificationRemarks": "Your encouraging remarks..."
+  },
+  "weeklyRoadmap": {
+    "generatedAt": ${Date.now()},
+    "items": [
+      {
+        "day": "Monday",
+        "topicName": "Topic C",
+        "reason": "To strengthen your understanding of this key area.",
+        "suggestedDifficulty": "Easy",
+        "loId": "lo-id-for-topic-c-from-the-list",
+        "isCompleted": false
+      }
+    ]
+  }
+}
+\`\`\`
+`;
+    const response = await ai.generate(promptText);
+    const rawText = response.text;
+    const jsonText = extractJsonFromMarkdown(rawText);
+    const aiGeneratedContent = JSON.parse(jsonText);
+    const validatedOutput = LearningAnalysisOutputSchema.parse(aiGeneratedContent);
+    return validatedOutput;
+  } catch (error) {
+    console.error("Error generating learning analysis:", error);
+    if (error instanceof zod.z.ZodError) {
+      throw new Error(`AI returned data in an unexpected format. Validation failed: ${error.message}`);
+    }
+    const errorMessage = String(error.message || "");
+    if (errorMessage.includes("503") || errorMessage.toLowerCase().includes("service unavailable") || errorMessage.toLowerCase().includes("overloaded")) {
+      throw new Error("D\u1ECBch v\u1EE5 AI hi\u1EC7n \u0111ang qu\xE1 t\u1EA3i. Vui l\xF2ng th\u1EED l\u1EA1i sau \xEDt ph\xFAt.");
+    }
+    throw new Error(`Failed to generate learning analysis: ${errorMessage}`);
+  }
+}
+zod.z.object({
+  language: zod.z.string(),
+  userName: zod.z.string().optional(),
+  currentStreak: zod.z.number().optional(),
+  weakestTopic: zod.z.string().optional()
+});
+var GenerateMotivationalQuoteOutputSchema = zod.z.object({
+  text: zod.z.string(),
+  author: zod.z.string()
+});
+
+// src/ai/flows/generate-motivational-quote.ts
+async function generateMotivationalQuote(clientInput, apiKey) {
+  try {
+    const ai = genkit.genkit({
+      plugins: [googleai.googleAI({ apiKey })],
+      model: googleai.gemini20Flash
+    });
+    const { language, userName, currentStreak, weakestTopic } = clientInput;
+    let contextPrompt = "";
+    if (userName) {
+      contextPrompt += `The student's name is ${userName}. Address them directly.`;
+    }
+    if (currentStreak && currentStreak > 1) {
+      contextPrompt += ` They are on a ${currentStreak}-day practice streak. Acknowledge this achievement.`;
+    }
+    if (weakestTopic) {
+      contextPrompt += ` They seem to be struggling with the topic "${weakestTopic}". Encourage them to persevere on this topic.`;
+    }
+    const promptText = `
+You are an AI Learning Coach. Your task is to generate a single, short, and powerful motivational quote for a student.
+
+**Context about the student:**
+${contextPrompt || "No specific context provided, generate a general motivational quote about learning."}
+
+**Instructions:**
+1.  Create a quote that is concise (under 20 words).
+2.  The quote must be encouraging and relevant to learning or perseverance.
+3.  If context is provided, subtly weave it into the quote.
+4.  The quote must be in the following language: ${language}.
+
+**JSON OUTPUT FORMAT:**
+Return the response as a single, valid JSON object with this EXACT format:
+{
+  "text": "Your generated motivational quote here.",
+  "author": "AI Tutor"
+}
+
+Return only the JSON response.`;
+    try {
+      const response = await ai.generate(promptText);
+      const rawText = response.text;
+      const jsonText = extractJsonFromMarkdown(rawText);
+      const aiGeneratedContent = JSON.parse(jsonText);
+      const validatedOutput = GenerateMotivationalQuoteOutputSchema.parse(aiGeneratedContent);
+      return validatedOutput;
+    } catch (apiError) {
+      console.warn(`Could not generate AI motivational quote due to an API error: ${apiError.message}. Falling back to static quotes.`);
+      return null;
+    }
+  } catch (error) {
+    console.error("An unexpected error occurred in the generateMotivationalQuote flow:", error);
+    return null;
+  }
+}
+zod.z.object({
+  language: zod.z.string(),
+  learningObjectivesContent: zod.z.string().min(50, { message: "Learning objectives content must be substantial." }),
+  overallSubject: zod.z.string().min(1, { message: "Overall subject is required for context." })
+});
+var PlanKnowledgeCardsOutputSchema = zod.z.object({
+  concepts: zod.z.array(zod.z.string()).min(1, { message: "AI should identify at least one concept." })
+});
+
+// src/ai/flows/plan-knowledge-cards.ts
+async function planKnowledgeCards(clientInput, apiKey) {
+  try {
+    const ai = genkit.genkit({
+      plugins: [googleai.googleAI({ apiKey })],
+      model: googleai.gemini20Flash
+    });
+    const { language, learningObjectivesContent, overallSubject } = clientInput;
+    const promptText = `
+You are an expert curriculum designer specializing in the subject of "${overallSubject}".
+Your task is to analyze the provided learning objectives and identify the most critical concepts, keywords, and technical terms that a student must know.
+
+**Provided Learning Objectives Document:**
+---
+${learningObjectivesContent}
+---
+
+**Instructions:**
+1.  Read the entire document carefully to understand the scope of the subject matter.
+2.  Identify between 15 and 20 of the most fundamental and important concepts.
+3.  Focus on nouns, technical terms, and core principles (e.g., "Variable", "Optional Chaining", "Protocol", "Delegate Pattern").
+4.  Do not select broad, generic phrases. The concepts should be specific enough to be explained on a single flashcard.
+5.  List these concepts in ${language}.
+
+**JSON OUTPUT FORMAT:**
+Return a single, valid JSON object with this EXACT format:
+{
+  "concepts": [
+    "First Concept",
+    "Second Concept",
+    "Third Concept",
+    ...
+  ]
+}
+
+Return only the JSON response.`;
+    const response = await ai.generate(promptText);
+    const rawText = response.text;
+    const jsonText = extractJsonFromMarkdown(rawText);
+    const aiGeneratedContent = JSON.parse(jsonText);
+    const validatedOutput = PlanKnowledgeCardsOutputSchema.parse(aiGeneratedContent);
+    return validatedOutput;
+  } catch (error) {
+    console.error("Error planning knowledge cards:", error);
+    if (error instanceof zod.z.ZodError) {
+      throw new Error(`AI returned data in an unexpected format for planning. Validation failed: ${error.message}`);
+    }
+    throw new Error(`Failed to plan knowledge cards: ${error.message}`);
+  }
+}
+zod.z.object({
+  language: zod.z.string(),
+  concept: zod.z.string().min(1, { message: "Concept cannot be empty." }),
+  overallSubject: zod.z.string().min(1, { message: "Overall subject is required for context." }),
+  fullContext: zod.z.string().optional().describe("The full learning objectives document for context reference.")
+});
+var GenerateSingleKnowledgeCardOutputSchema = zod.z.object({
+  concept: zod.z.string(),
+  definition: zod.z.string(),
+  example: zod.z.string()
+});
+
+// src/ai/flows/generate-single-knowledge-card.ts
+async function generateSingleKnowledgeCard(clientInput, apiKey) {
+  const ai = genkit.genkit({
+    plugins: [googleai.googleAI({ apiKey })],
+    model: googleai.gemini20Flash
+  });
+  try {
+    const { language, concept, overallSubject, fullContext } = clientInput;
+    const promptText = `
+You are an expert educator for "${overallSubject}". Create content for a single knowledge card.
+Target Concept: ${concept}
+Instructions:
+1.  Write a concise "definition" (under 40 words).
+2.  Provide a practical "example" (code or real-world scenario) relevant to "${overallSubject}".
+3.  All content must be in ${language}.
+4.  The 'concept' field in your output must exactly match the Target Concept.`;
+    const response = await ai.generate({
+      prompt: promptText,
+      output: {
+        schema: GenerateSingleKnowledgeCardOutputSchema
+      }
+    });
+    const validatedOutput = response.output;
+    if (!validatedOutput) {
+      throw new Error("AI did not return a valid structured output.");
+    }
+    return validatedOutput;
+  } catch (error) {
+    console.error(`Error generating knowledge card for concept "${clientInput.concept}":`, error);
+    if (error instanceof zod.z.ZodError) {
+      throw new Error(`AI output validation failed for card "${clientInput.concept}". Error: ${error.message}`);
+    }
+    throw new Error(`Failed to generate knowledge card for "${clientInput.concept}": ${error.message}`);
+  }
+}
+var LearningObjectiveContextSchema = zod.z.object({
+  loId: zod.z.string(),
+  subject: zod.z.string(),
+  category: zod.z.string(),
+  topic: zod.z.string(),
+  loDescription: zod.z.string()
+});
+zod.z.object({
+  language: zod.z.string().default("English"),
+  documentContent: zod.z.string().min(100, { message: "Document content must be substantial enough for analysis." }),
+  learningObjectives: zod.z.array(LearningObjectiveContextSchema).min(1, { message: "At least one learning objective is required for mapping." })
+});
+var MappedLOSchema = zod.z.object({
+  loId: zod.z.string().describe("The exact loId from the provided learning objectives list that matches the document content."),
+  confidence: zod.z.number().min(0).max(100).describe("A confidence score (0-100) of how well the document maps to this LO."),
+  reasoning: zod.z.string().describe("A brief explanation for why this mapping is relevant.")
+});
+var AssessAndMapDocumentOutputSchema = zod.z.object({
+  relevanceScore: zod.z.number().min(0).max(100).describe("An overall score (0-100) indicating how relevant the document is to the provided learning objectives as a whole."),
+  isFreestyleRecommended: zod.z.boolean().describe("A simple recommendation. True if the document is not relevant enough to be part of the structured curriculum."),
+  mappedLOs: zod.z.array(MappedLOSchema).describe("A list of specific learning objectives the document is mapped to. Empty if not relevant.")
+});
+
+// src/ai/flows/assess-and-map-document.ts
+async function assessAndMapDocument(clientInput, apiKey) {
+  try {
+    const ai = genkit.genkit({
+      plugins: [googleai.googleAI({ apiKey })],
+      model: googleai.gemini20Flash
+    });
+    const { language, documentContent, learningObjectives } = clientInput;
+    const relevanceThreshold = 40;
+    const promptText = `
+You are an expert curriculum analyst. Your task is to analyze a given document and determine how relevant it is to a provided list of learning objectives (LOs).
+
+**INPUT DATA:**
+
+1.  **DOCUMENT CONTENT (first 1000 characters):**
+    ---
+    ${documentContent.substring(0, 1e3)}...
+    ---
+
+2.  **LIST OF AVAILABLE LEARNING OBJECTIVES:**
+    ---
+    ${JSON.stringify(learningObjectives, null, 2)}
+    ---
+
+**YOUR ANALYSIS TASKS:**
+
+1.  **Overall Relevance Assessment:** Read the document content and compare it against the entire list of LOs. Assign an overall "relevanceScore" from 0 (completely unrelated) to 100 (perfectly aligned with one or more LOs).
+
+2.  **Specific Mapping:** Identify which specific LOs from the list are directly addressed by the document. For each match you find, provide:
+    - The exact "loId" of the matched LO.
+    - A "confidence" score (0-100) for that specific match.
+    - A brief "reasoning" in ${language} explaining why the document content maps to that LO.
+
+3.  **Recommendation:** Based on your overall relevanceScore, provide a boolean recommendation "isFreestyleRecommended". This should be \`true\` if the relevanceScore is below ${relevanceThreshold}, and \`false\` otherwise.
+
+**CRITICAL JSON OUTPUT FORMAT:**
+Return a single, valid JSON object in this EXACT format. Do not include any other text or markdown.
+
+\`\`\`json
+{
+  "relevanceScore": 85,
+  "isFreestyleRecommended": false,
+  "mappedLOs": [
+    {
+      "loId": "SWIFT_FUNC_01",
+      "confidence": 95,
+      "reasoning": "The document provides a detailed explanation of function syntax and default parameters, which directly aligns with this learning objective."
+    }
+  ]
+}
+\`\`\`
+
+If the document is not relevant at all, the "mappedLOs" array should be empty, and the "relevanceScore" should be low.
+`;
+    const response = await ai.generate(promptText);
+    const rawText = response.text;
+    const jsonText = extractJsonFromMarkdown(rawText);
+    const aiGeneratedContent = JSON.parse(jsonText);
+    const validatedOutput = AssessAndMapDocumentOutputSchema.parse(aiGeneratedContent);
+    return validatedOutput;
+  } catch (error) {
+    console.error("Error in assessAndMapDocument flow:", error);
+    if (error instanceof zod.z.ZodError) {
+      throw new Error(`AI output validation failed: ${error.message}`);
+    }
+    throw new Error(`Failed to assess document: ${error.message}`);
+  }
+}
+zod.z.object({
+  language: zod.z.string().optional().default("English"),
+  documentContent: zod.z.string().min(100, { message: "Document content must be substantial enough to generate a quiz." }),
+  numQuestions: zod.z.number().int().min(1).max(20).optional().default(10),
+  questionTypes: zod.z.array(zod.z.enum(["multiple_choice", "true_false", "short_answer"])).optional()
+});
+var AnyGeneratedQuestionSchema = zod.z.union([
+  MultipleChoiceQuestionZodSchema,
+  TrueFalseQuestionZodSchema,
+  ShortAnswerQuestionZodSchema
+]);
+var GenerateQuizFromTextOutputSchema = zod.z.object({
+  generatedQuestions: zod.z.array(AnyGeneratedQuestionSchema)
+});
+
+// src/ai/flows/generate-quiz-from-text.ts
+var AnyGeneratedQuestionSchema2 = GenerateQuizFromTextOutputSchema.shape.generatedQuestions.element;
+async function generateQuizFromText(clientInput, apiKey) {
+  try {
+    const ai = genkit.genkit({
+      plugins: [googleai.googleAI({ apiKey })],
+      model: googleai.gemini20Flash
+    });
+    const { language, documentContent, numQuestions, questionTypes } = clientInput;
+    const allowedTypes = questionTypes || ["multiple_choice", "true_false"];
+    const promptText = `
+You are an expert educator. Your task is to create a quiz with exactly ${numQuestions} questions based SOLELY on the provided document content.
+
+**DOCUMENT CONTENT:**
+---
+${documentContent}
+---
+
+**QUIZ REQUIREMENTS:**
+1.  **Total Questions:** Generate exactly ${numQuestions} questions.
+2.  **Language:** All content (prompts, options, explanations) must be in ${language}.
+3.  **Content Source:** All questions MUST be derived directly from the provided DOCUMENT CONTENT. Do not use any external knowledge.
+4.  **Question Types:** Use a mix of the following question types: ${allowedTypes.join(", ")}. Prioritize 'multiple_choice'.
+5.  **Key Concepts:** Focus on the most important facts, definitions, and concepts within the text.
+6.  **Explanations:** Provide a brief, clear explanation for each question, referencing the source text.
+
+**OUTPUT FORMAT:**
+Return the response as a single JSON object with a key "generatedQuestions" containing an array of exactly ${numQuestions} question objects. Do NOT include any other text or markdown formatting outside of the JSON object.
+
+**Example of the JSON structure:**
+\`\`\`json
+{
+  "generatedQuestions": [
+    {
+      "questionType": "multiple_choice",
+      "prompt": "Based on the text, what is the primary function of a mitochondria?",
+      "options": [
+        { "tempId": "A", "text": "Cellular respiration" },
+        { "tempId": "B", "text": "Photosynthesis" },
+        { "tempId": "C", "text": "Protein synthesis" }
+      ],
+      "correctTempOptionId": "A",
+      "explanation": "The document states that mitochondria are the powerhouses of the cell, responsible for cellular respiration.",
+      "points": 10,
+      "difficulty": "medium",
+      "topic": "Cell Biology"
+    },
+    {
+      "questionType": "true_false",
+      "prompt": "The document indicates that the cell wall is found in both plant and animal cells.",
+      "correctAnswer": false,
+      "explanation": "The text specifies that the cell wall is a feature of plant cells, not animal cells.",
+      "points": 10,
+      "difficulty": "easy",
+      "topic": "Cell Biology"
+    }
+  ]
+}
+\`\`\`
+
+Now, generate the JSON response.`;
+    const response = await ai.generate(promptText);
+    const rawText = response.text;
+    const jsonText = extractJsonFromMarkdown(rawText);
+    const aiGeneratedContent = JSON.parse(jsonText);
+    if (!aiGeneratedContent.generatedQuestions || !Array.isArray(aiGeneratedContent.generatedQuestions)) {
+      throw new Error("AI did not return a valid 'generatedQuestions' array.");
+    }
+    const finalQuestions = [];
+    for (const rawQuestion of aiGeneratedContent.generatedQuestions) {
+      try {
+        const questionId = generateUniqueId(`${rawQuestion.questionType}_`);
+        let finalQuestion = null;
+        switch (rawQuestion.questionType) {
+          case "multiple_choice": {
+            const tempOptions = rawQuestion.options || [];
+            const finalOptions = tempOptions.map((opt) => ({
+              id: generateUniqueId("opt_"),
+              text: opt.text,
+              tempId: opt.tempId
+            }));
+            const correctTempId = rawQuestion.correctTempOptionId;
+            const correctFinalOption = finalOptions.find((opt) => opt.tempId === correctTempId);
+            if (!correctFinalOption) {
+              console.warn(`Skipping MCQ due to invalid correctTempOptionId: ${correctTempId}`);
+              continue;
+            }
+            finalQuestion = __spreadProps(__spreadValues({}, rawQuestion), {
+              id: questionId,
+              options: finalOptions.map((_a) => {
+                var _b = _a, { tempId } = _b, rest = __objRest(_b, ["tempId"]);
+                return rest;
+              }),
+              correctAnswerId: correctFinalOption.id
+            });
+            break;
+          }
+          case "true_false":
+          case "short_answer": {
+            finalQuestion = __spreadProps(__spreadValues({}, rawQuestion), { id: questionId });
+            break;
+          }
+          default:
+            console.warn(`Unsupported question type generated by AI: ${rawQuestion.questionType}. Skipping.`);
+            continue;
+        }
+        const validatedQuestion = AnyGeneratedQuestionSchema2.parse(finalQuestion);
+        finalQuestions.push(validatedQuestion);
+      } catch (error) {
+        console.error("Error processing a single generated question:", error, "Question data:", rawQuestion);
+      }
+    }
+    return { generatedQuestions: finalQuestions };
+  } catch (error) {
+    console.error("Error generating quiz from text:", error);
+    if (error instanceof zod.z.ZodError) {
+      throw new Error(`AI output validation failed: ${error.message}`);
+    }
+    throw new Error(`Failed to generate quiz from text: ${error.message}`);
+  }
+}
+
+exports.assessAndMapDocument = assessAndMapDocument;
+exports.generateFillInTheBlanksQuestion = generateFillInTheBlanksQuestion;
+exports.generateLearningAnalysis = generateLearningAnalysis;
+exports.generateMCQQuestion = generateMCQQuestion;
+exports.generateMRQQuestion = generateMRQQuestion;
+exports.generateMatchingQuestion = generateMatchingQuestion;
+exports.generateMotivationalQuote = generateMotivationalQuote;
+exports.generateNumericQuestion = generateNumericQuestion;
+exports.generatePracticeSuggestion = generatePracticeSuggestion;
+exports.generateQuestionsFromQuizPlan = generateQuestionsFromQuizPlan;
+exports.generateQuizFromText = generateQuizFromText;
+exports.generateQuizPlan = generateQuizPlan;
+exports.generateQuizReview = generateQuizReview;
+exports.generateSequenceQuestion = generateSequenceQuestion;
+exports.generateShortAnswerQuestion = generateShortAnswerQuestion;
+exports.generateSingleKnowledgeCard = generateSingleKnowledgeCard;
+exports.generateTrueFalseQuestion = generateTrueFalseQuestion;
+exports.planKnowledgeCards = planKnowledgeCards;