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

package/dist/index.cjs

@@ -1,6 +1,8 @@
 'use strict';
 
 var zod = require('zod');
+var genkit = require('genkit');
+var googleai = require('@genkit-ai/googleai');
 var JSZip = require('jszip');
 var clsx = require('clsx');
 var tailwindMerge = require('tailwind-merge');
@@ -276,6 +278,847 @@ var SCORMService = class {
   }
 };
 
+// src/services/evaluators/multiple-choice-evaluator.ts
+var MultipleChoiceEvaluator = class {
+  async evaluate(question, answer) {
+    var _a;
+    const points = (_a = question.points) != null ? _a : 0;
+    const correctAnswerId = question.correctAnswerId;
+    const isCorrect = answer === correctAnswerId;
+    const correctOption = question.options.find((opt) => opt.id === correctAnswerId);
+    const correctAnswerDetail = {
+      id: correctAnswerId,
+      value: (correctOption == null ? void 0 : correctOption.text) || ""
+    };
+    return Promise.resolve({
+      isCorrect,
+      correctAnswer: correctAnswerDetail,
+      pointsEarned: isCorrect ? points : 0
+    });
+  }
+};
+
+// src/services/evaluators/multiple-response-evaluator.ts
+var MultipleResponseEvaluator = class {
+  async evaluate(question, answer) {
+    var _a;
+    const points = (_a = question.points) != null ? _a : 0;
+    const correctAnswerIds = question.correctAnswerIds;
+    let isCorrect = false;
+    if (Array.isArray(answer)) {
+      const userAnswerSet = new Set(answer);
+      const correctAnswerSet = new Set(correctAnswerIds);
+      isCorrect = userAnswerSet.size === correctAnswerSet.size && [...userAnswerSet].every((id) => correctAnswerSet.has(id));
+    }
+    const correctValues = correctAnswerIds.map(
+      (id) => {
+        var _a2;
+        return ((_a2 = question.options.find((opt) => opt.id === id)) == null ? void 0 : _a2.text) || "";
+      }
+    );
+    const correctAnswerDetail = {
+      id: correctAnswerIds,
+      value: correctValues
+    };
+    return Promise.resolve({
+      isCorrect,
+      correctAnswer: correctAnswerDetail,
+      pointsEarned: isCorrect ? points : 0
+    });
+  }
+};
+
+// src/services/evaluators/true-false-evaluator.ts
+var TrueFalseEvaluator = class {
+  async evaluate(question, answer) {
+    var _a;
+    const points = (_a = question.points) != null ? _a : 0;
+    const correctAnswer = question.correctAnswer;
+    let userAnswer = answer;
+    if (typeof answer === "string") {
+      userAnswer = answer.toLowerCase() === "true";
+    }
+    const isCorrect = typeof userAnswer === "boolean" && userAnswer === correctAnswer;
+    const correctAnswerDetail = {
+      id: null,
+      value: correctAnswer
+    };
+    return Promise.resolve({
+      isCorrect,
+      correctAnswer: correctAnswerDetail,
+      pointsEarned: isCorrect ? points : 0
+    });
+  }
+};
+
+// src/services/evaluators/short-answer-evaluator.ts
+var ShortAnswerEvaluator = class {
+  async evaluate(question, answer) {
+    var _a, _b;
+    const points = (_a = question.points) != null ? _a : 0;
+    let isCorrect = false;
+    if (typeof answer === "string") {
+      const userAnswerTrimmed = answer.trim();
+      const caseSensitive = (_b = question.isCaseSensitive) != null ? _b : false;
+      isCorrect = question.acceptedAnswers.some(
+        (accAns) => caseSensitive ? accAns.trim() === userAnswerTrimmed : accAns.trim().toLowerCase() === userAnswerTrimmed.toLowerCase()
+      );
+    }
+    const correctAnswerDetail = {
+      id: null,
+      value: question.acceptedAnswers
+    };
+    return Promise.resolve({
+      isCorrect,
+      correctAnswer: correctAnswerDetail,
+      pointsEarned: isCorrect ? points : 0
+    });
+  }
+};
+
+// src/services/evaluators/numeric-evaluator.ts
+var NumericEvaluator = class {
+  async evaluate(question, answer) {
+    var _a;
+    const points = (_a = question.points) != null ? _a : 0;
+    let isCorrect = false;
+    if (typeof answer === "string" || typeof answer === "number") {
+      const userAnswerNum = parseFloat(String(answer));
+      if (!isNaN(userAnswerNum)) {
+        isCorrect = question.tolerance != null ? Math.abs(userAnswerNum - question.answer) <= question.tolerance : userAnswerNum === question.answer;
+      }
+    }
+    const correctAnswerDetail = {
+      id: null,
+      value: question.answer
+    };
+    return Promise.resolve({
+      isCorrect,
+      correctAnswer: correctAnswerDetail,
+      pointsEarned: isCorrect ? points : 0
+    });
+  }
+};
+
+// src/services/evaluators/sequence-evaluator.ts
+var SequenceEvaluator = class {
+  async evaluate(question, answer) {
+    var _a;
+    const points = (_a = question.points) != null ? _a : 0;
+    let isCorrect = false;
+    if (Array.isArray(answer) && answer.length === question.correctOrder.length) {
+      isCorrect = answer.every((itemId, index) => itemId === question.correctOrder[index]);
+    }
+    const correctValues = question.correctOrder.map(
+      (id) => {
+        var _a2;
+        return ((_a2 = question.items.find((item) => item.id === id)) == null ? void 0 : _a2.content) || "";
+      }
+    );
+    const correctAnswerDetail = {
+      id: question.correctOrder,
+      value: correctValues
+    };
+    return Promise.resolve({
+      isCorrect,
+      correctAnswer: correctAnswerDetail,
+      pointsEarned: isCorrect ? points : 0
+    });
+  }
+};
+
+// src/services/evaluators/matching-evaluator.ts
+var MatchingEvaluator = class {
+  async evaluate(question, answer) {
+    var _a;
+    const points = (_a = question.points) != null ? _a : 0;
+    let isCorrect = false;
+    if (typeof answer === "object" && answer !== null && !Array.isArray(answer)) {
+      const userAnswerMap = answer;
+      isCorrect = question.correctAnswerMap.length === Object.keys(userAnswerMap).length && question.correctAnswerMap.every((map) => userAnswerMap[map.promptId] === map.optionId);
+    }
+    const correctMap = question.correctAnswerMap.reduce((acc, curr) => {
+      var _a2, _b;
+      const promptText = ((_a2 = question.prompts.find((p) => p.id === curr.promptId)) == null ? void 0 : _a2.content) || "";
+      const optionText = ((_b = question.options.find((o) => o.id === curr.optionId)) == null ? void 0 : _b.content) || "";
+      acc[promptText] = optionText;
+      return acc;
+    }, {});
+    const correctAnswerDetail = {
+      id: null,
+      value: correctMap
+    };
+    return Promise.resolve({
+      isCorrect,
+      correctAnswer: correctAnswerDetail,
+      pointsEarned: isCorrect ? points : 0
+    });
+  }
+};
+
+// src/services/evaluators/fill-in-the-blanks-evaluator.ts
+var FillInTheBlanksEvaluator = class {
+  async evaluate(question, answer) {
+    var _a;
+    const points = (_a = question.points) != null ? _a : 0;
+    let isCorrect = false;
+    if (typeof answer === "object" && answer !== null && !Array.isArray(answer)) {
+      const userAnswerMap = answer;
+      isCorrect = question.answers.length > 0 && question.answers.every((correctAnsDef) => {
+        var _a2, _b;
+        const userValForBlank = (_a2 = userAnswerMap[correctAnsDef.blankId]) == null ? void 0 : _a2.trim();
+        if (userValForBlank === void 0) return false;
+        const caseSensitive = (_b = question.isCaseSensitive) != null ? _b : false;
+        return correctAnsDef.acceptedValues.some(
+          (accVal) => caseSensitive ? accVal.trim() === userValForBlank : accVal.trim().toLowerCase() === userValForBlank.toLowerCase()
+        );
+      });
+    }
+    const correctMap = question.answers.reduce((acc, curr) => {
+      acc[curr.blankId] = curr.acceptedValues.join(" | ");
+      return acc;
+    }, {});
+    const correctAnswerDetail = {
+      id: null,
+      value: correctMap
+    };
+    return Promise.resolve({
+      isCorrect,
+      correctAnswer: correctAnswerDetail,
+      pointsEarned: isCorrect ? points : 0
+    });
+  }
+};
+
+// src/services/evaluators/drag-and-drop-evaluator.ts
+var DragAndDropEvaluator = class {
+  async evaluate(question, answer) {
+    var _a;
+    const points = (_a = question.points) != null ? _a : 0;
+    let isCorrect = false;
+    if (typeof answer === "object" && answer !== null && !Array.isArray(answer)) {
+      const userAnswerMap = answer;
+      isCorrect = question.answerMap.length === Object.keys(userAnswerMap).length && question.answerMap.every((map) => userAnswerMap[map.draggableId] === map.dropZoneId);
+    }
+    const correctMap = question.answerMap.reduce((acc, curr) => {
+      var _a2, _b;
+      const draggableText = ((_a2 = question.draggableItems.find((d) => d.id === curr.draggableId)) == null ? void 0 : _a2.content) || "";
+      const dropZoneText = ((_b = question.dropZones.find((z4) => z4.id === curr.dropZoneId)) == null ? void 0 : _b.label) || "";
+      acc[draggableText] = dropZoneText;
+      return acc;
+    }, {});
+    const correctAnswerDetail = {
+      id: null,
+      value: correctMap
+    };
+    return Promise.resolve({
+      isCorrect,
+      correctAnswer: correctAnswerDetail,
+      pointsEarned: isCorrect ? points : 0
+    });
+  }
+};
+
+// src/services/evaluators/hotspot-evaluator.ts
+var HotspotEvaluator = class {
+  async evaluate(question, answer) {
+    var _a;
+    const points = (_a = question.points) != null ? _a : 0;
+    let isCorrect = false;
+    if (Array.isArray(answer)) {
+      const userAnswerSet = new Set(answer);
+      const correctAnswerSet = new Set(question.correctHotspotIds);
+      isCorrect = userAnswerSet.size === correctAnswerSet.size && [...userAnswerSet].every((id) => correctAnswerSet.has(id));
+    }
+    const correctValues = question.correctHotspotIds.map(
+      (id) => {
+        var _a2;
+        return ((_a2 = question.hotspots.find((h) => h.id === id)) == null ? void 0 : _a2.description) || id;
+      }
+    );
+    const correctAnswerDetail = {
+      id: question.correctHotspotIds,
+      value: correctValues
+    };
+    return Promise.resolve({
+      isCorrect,
+      correctAnswer: correctAnswerDetail,
+      pointsEarned: isCorrect ? points : 0
+    });
+  }
+};
+
+// src/services/evaluators/programming-evaluator.ts
+var ProgrammingEvaluator = class {
+  async evaluate(question, answer) {
+    var _a, _b;
+    const points = (_a = question.points) != null ? _a : 0;
+    let isCorrect = false;
+    if (typeof answer === "string" && typeof question.solutionGeneratedCode === "string") {
+      if (typeof window !== "undefined" && ((_b = window.Blockly) == null ? void 0 : _b.JavaScript)) {
+        const LocalBlockly = window.Blockly;
+        let generatedUserCode = "";
+        try {
+          const tempWorkspace = new LocalBlockly.Workspace();
+          const dom = LocalBlockly.Xml.textToDom(answer);
+          LocalBlockly.Xml.domToWorkspace(dom, tempWorkspace);
+          generatedUserCode = LocalBlockly.JavaScript.workspaceToCode(tempWorkspace) || "";
+          const normalize = (code) => code.replace(/\s+/g, " ").trim();
+          isCorrect = normalize(generatedUserCode) === normalize(question.solutionGeneratedCode);
+          tempWorkspace.dispose();
+        } catch (e) {
+          console.error(`Error generating code from user's ${question.questionType} XML for evaluation:`, e);
+          isCorrect = false;
+        }
+      } else {
+        console.warn(`Blockly library not available for ${question.questionType} evaluation. Skipping code comparison.`);
+        isCorrect = false;
+      }
+    }
+    const correctAnswerDetail = {
+      id: null,
+      value: question.solutionGeneratedCode || ""
+    };
+    return Promise.resolve({
+      isCorrect,
+      correctAnswer: correctAnswerDetail,
+      pointsEarned: isCorrect ? points : 0
+    });
+  }
+};
+
+// 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}`);
+  }
+}
+zod.z.object({
+  language: zod.z.custom(),
+  problemPrompt: zod.z.string(),
+  userCode: zod.z.string(),
+  testCase: zod.z.custom()
+});
+var AIEvaluationOutputSchema = zod.z.object({
+  passed: zod.z.boolean().describe("Did the user's code produce the expected output for the given input?"),
+  actualOutput: zod.z.any().describe("The actual output produced by the user's code."),
+  reasoning: zod.z.string().describe("A brief explanation of why the code passed or failed, or if there was a syntax error.")
+});
+var EvaluateUserCodeOutputSchema = AIEvaluationOutputSchema;
+
+// src/ai/flows/evaluate-user-code.ts
+async function evaluateUserCode(clientInput, apiKey) {
+  try {
+    const ai = genkit.genkit({
+      plugins: [googleai.googleAI({ apiKey })],
+      model: googleai.gemini20Flash
+    });
+    const { language, problemPrompt, userCode, testCase } = clientInput;
+    const promptText = `
+You are an expert Code Judge and Teaching Assistant for a ${language} programming course.
+Your task is to evaluate a student's code submission for a specific problem against a single test case.
+
+## Problem Description
+${problemPrompt}
+
+## Student's Code Submission
+\`\`\`${language}
+${userCode}
+\`\`\`
+
+## Test Case to Evaluate
+- Input(s): ${JSON.stringify(testCase.input)}
+- Expected Output: ${JSON.stringify(testCase.expectedOutput)}
+
+## Your Task
+1.  **Analyze Execution:** Mentally execute the student's code with the provided input(s).
+2.  **Determine Output:** Figure out what the actual output of the code would be.
+3.  **Compare:** Compare the actual output with the expected output.
+4.  **Handle Errors:** If the code has a syntax error or would crash, treat it as a failure.
+5.  **Provide Reasoning:** Briefly explain your conclusion. If it failed, explain why (e.g., "incorrect result", "infinite loop", "syntax error on line 5").
+
+**CRITICAL JSON OUTPUT FORMAT:**
+Return ONLY the JSON object with this EXACT structure.
+
+\`\`\`json
+{
+  "passed": false,
+  "actualOutput": 5,
+  "reasoning": "The function correctly summed the numbers but did not filter for only even numbers."
+}
+\`\`\`
+
+Return only the JSON response.`;
+    const response = await ai.generate(promptText);
+    const rawText = response.text;
+    const jsonText = extractJsonFromMarkdown(rawText);
+    const aiGeneratedContent = JSON.parse(jsonText);
+    return EvaluateUserCodeOutputSchema.parse(aiGeneratedContent);
+  } catch (error) {
+    console.error("Error evaluating user code:", error);
+    if (error instanceof zod.z.ZodError) {
+      throw new Error(`AI evaluation output validation failed: ${error.message}`);
+    }
+    return {
+      passed: false,
+      actualOutput: "Evaluation Error",
+      reasoning: `The AI judge failed to process the code. Error: ${error.message}`
+    };
+  }
+}
+
+// src/services/APIKeyService.ts
+var GEMINI_API_KEY_SERVICE_NAME = "gemini";
+var LOCAL_STORAGE_PREFIX = "iqk_api_keys_";
+function _encode(data) {
+  if (typeof window !== "undefined" && typeof window.btoa === "function") {
+    try {
+      return window.btoa(data);
+    } catch (e) {
+      console.error("Base64 encoding (btoa) failed:", e);
+      return data;
+    }
+  }
+  return data;
+}
+function _decode(data) {
+  if (typeof window !== "undefined" && typeof window.atob === "function") {
+    try {
+      return window.atob(data);
+    } catch (e) {
+      console.error("Base64 decoding (atob) failed:", e);
+      return data;
+    }
+  }
+  return data;
+}
+var APIKeyService = class {
+  static getStorageKey(serviceName) {
+    return `${LOCAL_STORAGE_PREFIX}${serviceName}`;
+  }
+  /**
+   * Saves an API key to localStorage. The key is mildly obfuscated using Base64.
+   * @param serviceName - The name of the service (e.g., 'gemini').
+   * @param apiKey - The API key to save.
+   */
+  static saveAPIKey(serviceName, apiKey) {
+    if (typeof window !== "undefined" && window.localStorage) {
+      try {
+        const encodedKey = _encode(apiKey);
+        localStorage.setItem(this.getStorageKey(serviceName), encodedKey);
+      } catch (e) {
+        console.error(`Error saving API key for ${serviceName} to localStorage:`, e);
+      }
+    } else {
+      console.warn("localStorage is not available. APIKeyService cannot save keys.");
+    }
+  }
+  /**
+   * Retrieves an API key from localStorage.
+   * @param serviceName - The name of the service.
+   * @returns The decoded API key, or null if not found or if localStorage is unavailable.
+   */
+  static getAPIKey(serviceName) {
+    if (typeof window !== "undefined" && window.localStorage) {
+      try {
+        const storedKey = localStorage.getItem(this.getStorageKey(serviceName));
+        if (storedKey) {
+          return _decode(storedKey);
+        }
+      } catch (e) {
+        console.error(`Error retrieving API key for ${serviceName} from localStorage:`, e);
+      }
+    }
+    return null;
+  }
+  /**
+   * Removes an API key from localStorage.
+   * @param serviceName - The name of the service.
+   */
+  static removeAPIKey(serviceName) {
+    if (typeof window !== "undefined" && window.localStorage) {
+      try {
+        localStorage.removeItem(this.getStorageKey(serviceName));
+      } catch (e) {
+        console.error(`Error removing API key for ${serviceName} from localStorage:`, e);
+      }
+    }
+  }
+  /**
+   * Checks if an API key exists in localStorage for the given service.
+   * @param serviceName - The name of the service.
+   * @returns True if a key exists, false otherwise.
+   */
+  static hasAPIKey(serviceName) {
+    return this.getAPIKey(serviceName) !== null;
+  }
+};
+
+// src/services/CodeEvaluationService.ts
+var CodeEvaluationService = class {
+  constructor() {
+    this.apiKey = APIKeyService.getAPIKey(GEMINI_API_KEY_SERVICE_NAME);
+  }
+  /**
+   * Evaluates a user's code against a single test case using an AI judge.
+   * @param question The full CodingQuestion object.
+   * @param userCode The user's submitted code string.
+   * @param testCase The specific TestCase to evaluate against.
+   * @returns A promise that resolves to an EvaluationResult object.
+   */
+  async evaluateSingleTestCase(question, userCode, testCase) {
+    if (!this.apiKey) {
+      return {
+        testCaseId: testCase.id,
+        passed: false,
+        actualOutput: "Configuration Error",
+        reasoning: "API Key is not configured."
+      };
+    }
+    const aiResult = await evaluateUserCode({
+      language: question.language,
+      problemPrompt: question.prompt,
+      userCode,
+      testCase
+    }, this.apiKey);
+    return __spreadValues({
+      testCaseId: testCase.id
+    }, aiResult);
+  }
+  /**
+   * Evaluates user's code against all test cases for a given question.
+   * @param question The full CodingQuestion object.
+   * @param userCode The user's submitted code string.
+   * @returns A promise that resolves to an array of EvaluationResult objects.
+   */
+  async evaluateAllTestCases(question, userCode) {
+    const results = [];
+    for (const testCase of question.testCases) {
+      const result = await this.evaluateSingleTestCase(question, userCode, testCase);
+      results.push(result);
+    }
+    return results;
+  }
+  /**
+   * Evaluates user's code against only the public test cases for a given question.
+   * Useful for a "Run Tests" button before final submission.
+   * @param question The full CodingQuestion object.
+   * @param userCode The user's submitted code string.
+   * @returns A promise that resolves to an array of EvaluationResult objects.
+   */
+  async evaluatePublicTestCases(question, userCode) {
+    const publicTestCases = question.testCases.filter((tc) => tc.isPublic);
+    const results = [];
+    for (const testCase of publicTestCases) {
+      const result = await this.evaluateSingleTestCase(question, userCode, testCase);
+      results.push(result);
+    }
+    return results;
+  }
+};
+
+// src/services/evaluators/coding-evaluator.ts
+var CodingEvaluator = class {
+  async evaluate(question, answer) {
+    var _a;
+    const points = (_a = question.points) != null ? _a : 0;
+    if (typeof answer !== "string" || !answer.trim()) {
+      return {
+        isCorrect: false,
+        correctAnswer: { id: null, value: question.solutionCode },
+        pointsEarned: 0,
+        evaluationDetails: question.testCases.map((tc) => ({
+          testCaseId: tc.id,
+          passed: false,
+          actualOutput: "No submission",
+          reasoning: "User did not submit any code."
+        }))
+      };
+    }
+    try {
+      const evaluationService = new CodeEvaluationService();
+      const testCaseResults = await evaluationService.evaluateAllTestCases(question, answer);
+      const isCorrect = testCaseResults.every((result) => result.passed);
+      const correctAnswerDetail = {
+        id: null,
+        value: question.solutionCode
+      };
+      return {
+        isCorrect,
+        correctAnswer: correctAnswerDetail,
+        pointsEarned: isCorrect ? points : 0,
+        evaluationDetails: testCaseResults
+        // Pass through the detailed results
+      };
+    } catch (error) {
+      console.error("A critical error occurred during code evaluation:", error);
+      return {
+        isCorrect: false,
+        correctAnswer: { id: null, value: question.solutionCode },
+        pointsEarned: 0,
+        evaluationDetails: question.testCases.map((tc) => ({
+          testCaseId: tc.id,
+          passed: false,
+          actualOutput: "Evaluation Error",
+          reasoning: error instanceof Error ? error.message : "An unknown error occurred."
+        }))
+      };
+    }
+  }
+};
+
 // src/services/QuizEngine.ts
 var QuizEngine = class {
   constructor(options) {
@@ -292,6 +1135,8 @@ var QuizEngine = class {
     this.callbacks = options.callbacks || {};
     this.questions = ((_a = this.config.settings) == null ? void 0 : _a.shuffleQuestions) ? [...this.config.questions].sort(() => Math.random() - 0.5) : this.config.questions;
     this.overallStartTime = Date.now();
+    this.evaluators = /* @__PURE__ */ new Map();
+    this.registerEvaluators();
     if (((_b = this.config.settings) == null ? void 0 : _b.timeLimitMinutes) && this.config.settings.timeLimitMinutes > 0) {
       this.timeLeftInSeconds = this.config.settings.timeLimitMinutes * 60;
     }
@@ -330,6 +1175,22 @@ var QuizEngine = class {
     }
     (_e = (_d = this.callbacks).onQuestionChange) == null ? void 0 : _e.call(_d, initialQ, this.getCurrentQuestionNumber(), this.getTotalQuestions());
   }
+  registerEvaluators() {
+    this.evaluators.set("multiple_choice", new MultipleChoiceEvaluator());
+    this.evaluators.set("multiple_response", new MultipleResponseEvaluator());
+    this.evaluators.set("true_false", new TrueFalseEvaluator());
+    this.evaluators.set("short_answer", new ShortAnswerEvaluator());
+    this.evaluators.set("numeric", new NumericEvaluator());
+    this.evaluators.set("sequence", new SequenceEvaluator());
+    this.evaluators.set("matching", new MatchingEvaluator());
+    this.evaluators.set("fill_in_the_blanks", new FillInTheBlanksEvaluator());
+    this.evaluators.set("drag_and_drop", new DragAndDropEvaluator());
+    this.evaluators.set("hotspot", new HotspotEvaluator());
+    const programmingEvaluator = new ProgrammingEvaluator();
+    this.evaluators.set("blockly_programming", programmingEvaluator);
+    this.evaluators.set("scratch_programming", programmingEvaluator);
+    this.evaluators.set("coding", new CodingEvaluator());
+  }
   _recordCurrentQuestionTime() {
     if (this.questionStartTime && this.currentQuestionIndex >= 0 && this.currentQuestionIndex < this.questions.length) {
       const currentQId = this.questions[this.currentQuestionIndex].id;
@@ -422,180 +1283,28 @@ var QuizEngine = class {
     }
     return this.getCurrentQuestion();
   }
-  evaluateQuestion(question, answer) {
-    var _a, _b, _c;
-    let isCorrect = false;
-    let correctAnswerDetail = null;
-    const points = (_a = question.points) != null ? _a : 0;
-    const findOptionText = (q, id) => {
-      var _a2;
-      return ((_a2 = q.options.find((opt) => opt.id === id)) == null ? void 0 : _a2.text) || "";
-    };
-    switch (question.questionType) {
-      case "multiple_choice": {
-        const q = question;
-        const correctAnswerId = q.correctAnswerId;
-        const correctValue = findOptionText(q, correctAnswerId);
-        correctAnswerDetail = { id: correctAnswerId, value: correctValue };
-        isCorrect = answer === correctAnswerId;
-        break;
-      }
-      case "multiple_response": {
-        const q = question;
-        const correctAnswerIds = q.correctAnswerIds;
-        const correctValues = correctAnswerIds.map((id) => findOptionText(q, id));
-        correctAnswerDetail = { id: correctAnswerIds, value: correctValues };
-        if (Array.isArray(answer)) {
-          const userAnswerSet = new Set(answer);
-          const correctAnswerSet = new Set(correctAnswerIds);
-          isCorrect = userAnswerSet.size === correctAnswerSet.size && [...userAnswerSet].every((id) => correctAnswerSet.has(id));
-        }
-        break;
-      }
-      case "true_false": {
-        const q = question;
-        correctAnswerDetail = { id: null, value: q.correctAnswer };
-        let tfAnswer = answer;
-        if (typeof answer === "string") tfAnswer = answer.toLowerCase() === "true";
-        isCorrect = typeof tfAnswer === "boolean" && tfAnswer === q.correctAnswer;
-        break;
-      }
-      case "short_answer": {
-        const q = question;
-        correctAnswerDetail = { id: null, value: q.acceptedAnswers };
-        if (typeof answer === "string") {
-          const userAnswerTrimmed = answer.trim();
-          const caseSensitive = (_b = q.isCaseSensitive) != null ? _b : false;
-          isCorrect = q.acceptedAnswers.some((accAns) => caseSensitive ? accAns.trim() === userAnswerTrimmed : accAns.trim().toLowerCase() === userAnswerTrimmed.toLowerCase());
-        }
-        break;
-      }
-      case "numeric": {
-        const q = question;
-        correctAnswerDetail = { id: null, value: q.answer };
-        if (typeof answer === "string" || typeof answer === "number") {
-          const userAnswerNum = parseFloat(String(answer));
-          if (!isNaN(userAnswerNum)) {
-            isCorrect = q.tolerance != null ? Math.abs(userAnswerNum - q.answer) <= q.tolerance : userAnswerNum === q.answer;
-          }
-        }
-        break;
-      }
-      case "sequence": {
-        const q = question;
-        const correctValues = q.correctOrder.map((id) => {
-          var _a2;
-          return ((_a2 = q.items.find((item) => item.id === id)) == null ? void 0 : _a2.content) || "";
-        });
-        correctAnswerDetail = { id: q.correctOrder, value: correctValues };
-        if (Array.isArray(answer) && answer.length === q.correctOrder.length) {
-          isCorrect = answer.every((itemId, index) => itemId === q.correctOrder[index]);
-        }
-        break;
-      }
-      case "matching": {
-        const q = question;
-        const correctMap = q.correctAnswerMap.reduce((acc, curr) => {
-          var _a2, _b2;
-          const promptText = ((_a2 = q.prompts.find((p) => p.id === curr.promptId)) == null ? void 0 : _a2.content) || "";
-          const optionText = ((_b2 = q.options.find((o) => o.id === curr.optionId)) == null ? void 0 : _b2.content) || "";
-          acc[promptText] = optionText;
-          return acc;
-        }, {});
-        correctAnswerDetail = { id: null, value: correctMap };
-        if (typeof answer === "object" && answer !== null && !Array.isArray(answer)) {
-          const userAnswerMap = answer;
-          isCorrect = q.correctAnswerMap.length === Object.keys(userAnswerMap).length && q.correctAnswerMap.every((map) => userAnswerMap[map.promptId] === map.optionId);
-        }
-        break;
-      }
-      case "fill_in_the_blanks": {
-        const q = question;
-        const correctMap = q.answers.reduce((acc, curr) => {
-          acc[curr.blankId] = curr.acceptedValues.join(" | ");
-          return acc;
-        }, {});
-        correctAnswerDetail = { id: null, value: correctMap };
-        if (typeof answer === "object" && answer !== null && !Array.isArray(answer)) {
-          const userAnswerMap = answer;
-          isCorrect = q.answers.every((correctAnsDef) => {
-            var _a2, _b2;
-            const userValForBlank = (_a2 = userAnswerMap[correctAnsDef.blankId]) == null ? void 0 : _a2.trim();
-            if (userValForBlank === void 0) return false;
-            const caseSensitive = (_b2 = q.isCaseSensitive) != null ? _b2 : false;
-            return correctAnsDef.acceptedValues.some((accVal) => caseSensitive ? accVal.trim() === userValForBlank : accVal.trim().toLowerCase() === userValForBlank.toLowerCase());
-          });
-        }
-        break;
-      }
-      case "drag_and_drop": {
-        const q = question;
-        const correctMap = q.answerMap.reduce((acc, curr) => {
-          var _a2, _b2;
-          const draggableText = ((_a2 = q.draggableItems.find((d) => d.id === curr.draggableId)) == null ? void 0 : _a2.content) || "";
-          const dropZoneText = ((_b2 = q.dropZones.find((z13) => z13.id === curr.dropZoneId)) == null ? void 0 : _b2.label) || "";
-          acc[draggableText] = dropZoneText;
-          return acc;
-        }, {});
-        correctAnswerDetail = { id: null, value: correctMap };
-        if (typeof answer === "object" && answer !== null && !Array.isArray(answer)) {
-          const userAnswerMap = answer;
-          isCorrect = q.answerMap.length === Object.keys(userAnswerMap).length && q.answerMap.every((map) => userAnswerMap[map.draggableId] === map.dropZoneId);
-        }
-        break;
-      }
-      case "hotspot": {
-        const q = question;
-        const correctValues = q.correctHotspotIds.map((id) => {
-          var _a2;
-          return ((_a2 = q.hotspots.find((h) => h.id === id)) == null ? void 0 : _a2.description) || id;
-        });
-        correctAnswerDetail = { id: q.correctHotspotIds, value: correctValues };
-        if (Array.isArray(answer)) {
-          const userAnswerSet = new Set(answer);
-          const correctAnswerSet = new Set(q.correctHotspotIds);
-          isCorrect = userAnswerSet.size === correctAnswerSet.size && [...userAnswerSet].every((id) => correctAnswerSet.has(id));
-        }
-        break;
-      }
-      case "blockly_programming":
-      case "scratch_programming": {
-        const q = question;
-        correctAnswerDetail = { id: null, value: q.solutionGeneratedCode || "" };
-        if (typeof answer === "string" && typeof q.solutionGeneratedCode === "string") {
-          if (typeof window !== "undefined" && ((_c = window.Blockly) == null ? void 0 : _c.JavaScript)) {
-            const LocalBlockly = window.Blockly;
-            let generatedUserCode = "";
-            try {
-              const tempWorkspace = new LocalBlockly.Workspace();
-              const dom = LocalBlockly.Xml.textToDom(answer);
-              LocalBlockly.Xml.domToWorkspace(dom, tempWorkspace);
-              generatedUserCode = LocalBlockly.JavaScript.workspaceToCode(tempWorkspace) || "";
-              const normalize = (code) => code.replace(/\s+/g, " ").trim();
-              isCorrect = normalize(generatedUserCode) === normalize(q.solutionGeneratedCode);
-              tempWorkspace.dispose();
-            } catch (e) {
-              console.error(`Error generating code from user's ${q.questionType} XML for evaluation:`, e);
-              isCorrect = false;
-            }
-          } else {
-            console.warn(`Blockly library not available in QuizEngine for ${q.questionType} code generation during evaluation. Skipping code comparison.`);
-            isCorrect = false;
-          }
-        }
-        break;
-      }
-      default: {
-        const _exhaustiveCheck = question;
-        console.warn("Unsupported question type in QuizEngine evaluation:", _exhaustiveCheck);
-        isCorrect = false;
-        correctAnswerDetail = { id: null, value: "Evaluation not implemented." };
+  getElapsedTime() {
+    return Date.now() - this.overallStartTime;
+  }
+  destroy() {
+    this.stopTimer();
+    this._recordCurrentQuestionTime();
+    if (this.scormService && this.scormService.hasAPI()) {
+      if (["initialized", "committed", "sending_data"].includes(this.quizResultState.scormStatus || "")) {
+        const termResult = this.scormService.terminate();
+        if (termResult.success) {
+          this.quizResultState.scormStatus = "terminated";
+        } else {
+          this.quizResultState.scormStatus = "error";
+          this.quizResultState.scormError = termResult.error || "SCORM termination failed on destroy.";
+        }
       }
     }
-    return { isCorrect, correctAnswer: correctAnswerDetail, pointsEarned: isCorrect ? points : 0 };
+    this.scormService = null;
   }
+  // (Tiếp theo từ Phần 1)
   async calculateResults() {
-    var _a, _b, _c, _d, _e, _f, _g, _h, _i, _j;
+    var _a, _b, _c, _d, _e;
     this.stopTimer();
     this._recordCurrentQuestionTime();
     let totalScore = 0;
@@ -605,92 +1314,31 @@ var QuizEngine = class {
     for (const question of this.questions) {
       const userAnswerRaw = this.userAnswers.get(question.id) || null;
       maxScore += (_a = question.points) != null ? _a : 0;
-      const { isCorrect, correctAnswer: correctAnswerDetail, pointsEarned } = this.evaluateQuestion(question, userAnswerRaw);
+      const evaluator = this.evaluators.get(question.questionType);
+      if (!evaluator) {
+        console.warn(`No evaluator found for question type: ${question.questionType}`);
+        questionResultsArray.push({
+          questionId: question.id,
+          questionType: question.questionType,
+          prompt: question.prompt,
+          isCorrect: false,
+          pointsEarned: 0,
+          userAnswer: { id: null, value: userAnswerRaw },
+          correctAnswer: { id: null, value: "Evaluation not implemented." },
+          timeSpentSeconds: parseFloat((this.questionTimings.get(question.id) || 0).toFixed(2))
+        });
+        continue;
+      }
+      const {
+        isCorrect,
+        correctAnswer: correctAnswerDetail,
+        pointsEarned,
+        evaluationDetails
+      } = await evaluator.evaluate(question, userAnswerRaw);
       totalScore += pointsEarned;
       const timeSpentOnThisQuestion = parseFloat((this.questionTimings.get(question.id) || 0).toFixed(2));
       accumulatedTotalTimeSpent += timeSpentOnThisQuestion;
-      let userAnswerDetail = null;
-      let allOptions = void 0;
-      if (userAnswerRaw !== null) {
-        switch (question.questionType) {
-          case "multiple_choice": {
-            const q = question;
-            allOptions = q.options.map((opt) => ({ id: opt.id, value: opt.text }));
-            const id = userAnswerRaw;
-            userAnswerDetail = { id, value: ((_b = allOptions.find((opt) => opt.id === id)) == null ? void 0 : _b.value) || "" };
-            break;
-          }
-          case "multiple_response": {
-            const q = question;
-            allOptions = q.options.map((opt) => ({ id: opt.id, value: opt.text }));
-            const ids = userAnswerRaw;
-            const values = ids.map((id) => {
-              var _a2;
-              return ((_a2 = allOptions == null ? void 0 : allOptions.find((opt) => opt.id === id)) == null ? void 0 : _a2.value) || "";
-            });
-            userAnswerDetail = { id: ids, value: values };
-            break;
-          }
-          case "true_false":
-          case "short_answer":
-          case "numeric":
-            userAnswerDetail = { id: null, value: userAnswerRaw };
-            break;
-          case "sequence": {
-            const q = question;
-            allOptions = q.items.map((item) => ({ id: item.id, value: item.content }));
-            const ids = userAnswerRaw;
-            const values = ids.map((id) => {
-              var _a2;
-              return ((_a2 = allOptions == null ? void 0 : allOptions.find((opt) => opt.id === id)) == null ? void 0 : _a2.value) || "";
-            });
-            userAnswerDetail = { id: ids, value: values };
-            break;
-          }
-          case "matching": {
-            const q = question;
-            const userAnswerMap = userAnswerRaw;
-            const valueMap = {};
-            for (const promptId in userAnswerMap) {
-              const optionId = userAnswerMap[promptId];
-              const promptText = ((_c = q.prompts.find((p) => p.id === promptId)) == null ? void 0 : _c.content) || "";
-              const optionText = ((_d = q.options.find((o) => o.id === optionId)) == null ? void 0 : _d.content) || "";
-              valueMap[promptText] = optionText;
-            }
-            userAnswerDetail = { id: null, value: valueMap };
-            break;
-          }
-          // --- LOGIC MỚI ĐƯỢC THÊM VÀO ---
-          case "fill_in_the_blanks": {
-            if (typeof userAnswerRaw === "object" && userAnswerRaw !== null && !Array.isArray(userAnswerRaw)) {
-              userAnswerDetail = { id: null, value: userAnswerRaw };
-            }
-            break;
-          }
-          case "drag_and_drop": {
-            const q = question;
-            if (typeof userAnswerRaw === "object" && userAnswerRaw !== null && !Array.isArray(userAnswerRaw)) {
-              const userAnswerMapByIds = userAnswerRaw;
-              const enrichedUserAnswerMap = {};
-              for (const draggableId in userAnswerMapByIds) {
-                const dropZoneId = userAnswerMapByIds[draggableId];
-                const draggableText = ((_e = q.draggableItems.find((d) => d.id === draggableId)) == null ? void 0 : _e.content) || `(ID: ${draggableId})`;
-                const dropZoneText = ((_f = q.dropZones.find((z13) => z13.id === dropZoneId)) == null ? void 0 : _f.label) || `(ID: ${dropZoneId})`;
-                enrichedUserAnswerMap[draggableText] = dropZoneText;
-              }
-              userAnswerDetail = { id: null, value: enrichedUserAnswerMap };
-            }
-            break;
-          }
-          // ------------------------------------
-          // Các loại câu hỏi còn lại vẫn giữ fallback
-          case "hotspot":
-          case "blockly_programming":
-          case "scratch_programming":
-            userAnswerDetail = { id: null, value: userAnswerRaw };
-            break;
-        }
-      }
+      const userAnswerDetail = this.formatUserAnswerDetail(question, userAnswerRaw);
       questionResultsArray.push({
         questionId: question.id,
         questionType: question.questionType,
@@ -699,18 +1347,18 @@ var QuizEngine = class {
         pointsEarned,
         userAnswer: userAnswerDetail,
         correctAnswer: correctAnswerDetail,
-        allOptions,
-        timeSpentSeconds: timeSpentOnThisQuestion
+        timeSpentSeconds: timeSpentOnThisQuestion,
+        evaluationDetails
       });
     }
     const percentage = maxScore > 0 ? parseFloat((totalScore / maxScore * 100).toFixed(2)) : 0;
     let passed = void 0;
-    if (((_g = this.config.settings) == null ? void 0 : _g.passingScorePercent) != null) {
+    if (((_b = this.config.settings) == null ? void 0 : _b.passingScorePercent) != null) {
       passed = percentage >= this.config.settings.passingScorePercent;
     }
     const totalQuizTimeSpentSeconds = parseFloat(accumulatedTotalTimeSpent.toFixed(2));
     const averageTimePerQuestionSeconds = this.questions.length > 0 ? parseFloat((totalQuizTimeSpentSeconds / this.questions.length).toFixed(2)) : 0;
-    const metadataPerformance = this._calculateMetadataPerformance();
+    const metadataPerformance = await this._calculateMetadataPerformance();
     const finalResults = __spreadValues({
       score: totalScore,
       maxScore,
@@ -726,11 +1374,118 @@ var QuizEngine = class {
       averageTimePerQuestionSeconds
     }, metadataPerformance);
     this.quizResultState = __spreadValues(__spreadValues({}, this.quizResultState), finalResults);
-    if ((_h = this.config.settings) == null ? void 0 : _h.scorm) this._sendResultsToSCORM(finalResults);
+    if ((_c = this.config.settings) == null ? void 0 : _c.scorm) this._sendResultsToSCORM(finalResults);
     await this._sendResultsToWebhook(finalResults);
-    (_j = (_i = this.callbacks).onQuizFinish) == null ? void 0 : _j.call(_i, finalResults);
+    (_e = (_d = this.callbacks).onQuizFinish) == null ? void 0 : _e.call(_d, finalResults);
     return finalResults;
   }
+  formatUserAnswerDetail(question, userAnswerRaw) {
+    var _a, _b, _c, _d, _e;
+    if (userAnswerRaw === null) return null;
+    switch (question.questionType) {
+      case "multiple_choice": {
+        const q = question;
+        const id = userAnswerRaw;
+        return { id, value: ((_a = q.options.find((opt) => opt.id === id)) == null ? void 0 : _a.text) || "" };
+      }
+      case "multiple_response": {
+        const q = question;
+        const ids = userAnswerRaw;
+        const values = ids.map((id) => {
+          var _a2;
+          return ((_a2 = q.options.find((opt) => opt.id === id)) == null ? void 0 : _a2.text) || "";
+        });
+        return { id: ids, value: values };
+      }
+      case "sequence": {
+        const q = question;
+        const ids = userAnswerRaw;
+        const values = ids.map((id) => {
+          var _a2;
+          return ((_a2 = q.items.find((item) => item.id === id)) == null ? void 0 : _a2.content) || "";
+        });
+        return { id: ids, value: values };
+      }
+      case "matching": {
+        const q = question;
+        const userAnswerMap = userAnswerRaw;
+        const valueMap = {};
+        for (const promptId in userAnswerMap) {
+          const optionId = userAnswerMap[promptId];
+          const promptText = ((_b = q.prompts.find((p) => p.id === promptId)) == null ? void 0 : _b.content) || "";
+          const optionText = ((_c = q.options.find((o) => o.id === optionId)) == null ? void 0 : _c.content) || "";
+          valueMap[promptText] = optionText;
+        }
+        return { id: null, value: valueMap };
+      }
+      case "drag_and_drop": {
+        const q = question;
+        if (typeof userAnswerRaw === "object" && userAnswerRaw !== null && !Array.isArray(userAnswerRaw)) {
+          const userAnswerMapByIds = userAnswerRaw;
+          const enrichedUserAnswerMap = {};
+          for (const draggableId in userAnswerMapByIds) {
+            const dropZoneId = userAnswerMapByIds[draggableId];
+            const draggableText = ((_d = q.draggableItems.find((d) => d.id === draggableId)) == null ? void 0 : _d.content) || `(ID: ${draggableId})`;
+            const dropZoneText = ((_e = q.dropZones.find((z4) => z4.id === dropZoneId)) == null ? void 0 : _e.label) || `(ID: ${dropZoneId})`;
+            enrichedUserAnswerMap[draggableText] = dropZoneText;
+          }
+          return { id: null, value: enrichedUserAnswerMap };
+        }
+        return { id: null, value: userAnswerRaw };
+      }
+      default:
+        return { id: null, value: userAnswerRaw };
+    }
+  }
+  async _calculateMetadataPerformance() {
+    var _a;
+    const loPerformanceMap = /* @__PURE__ */ new Map();
+    const categoryPerformanceMap = /* @__PURE__ */ new Map();
+    const topicPerformanceMap = /* @__PURE__ */ new Map();
+    const difficultyPerformanceMap = /* @__PURE__ */ new Map();
+    const bloomLevelPerformanceMap = /* @__PURE__ */ new Map();
+    const updateMap = (map, key, points, isCorrect) => {
+      if (!key) return;
+      const current = map.get(key) || { totalQuestions: 0, correctQuestions: 0, pointsEarned: 0, maxPoints: 0 };
+      current.totalQuestions++;
+      current.maxPoints += points;
+      if (isCorrect) {
+        current.correctQuestions++;
+        current.pointsEarned += points;
+      }
+      map.set(key, current);
+    };
+    for (const q of this.questions) {
+      const userAnswer = this.userAnswers.get(q.id) || null;
+      const evaluator = this.evaluators.get(q.questionType);
+      if (evaluator) {
+        const { isCorrect } = await evaluator.evaluate(q, userAnswer);
+        const pointsForThisQuestion = (_a = q.points) != null ? _a : 0;
+        updateMap(loPerformanceMap, q.learningObjective, pointsForThisQuestion, isCorrect);
+        updateMap(categoryPerformanceMap, q.category, pointsForThisQuestion, isCorrect);
+        updateMap(topicPerformanceMap, q.topic, pointsForThisQuestion, isCorrect);
+        updateMap(difficultyPerformanceMap, q.difficulty, pointsForThisQuestion, isCorrect);
+        updateMap(bloomLevelPerformanceMap, q.bloomLevel, pointsForThisQuestion, isCorrect);
+      }
+    }
+    const formatPerformanceArray = (map, keyName) => {
+      return Array.from(map.entries()).map(([key, data]) => ({
+        [keyName]: key,
+        totalQuestions: data.totalQuestions,
+        correctQuestions: data.correctQuestions,
+        pointsEarned: data.pointsEarned,
+        maxPoints: data.maxPoints,
+        percentage: data.maxPoints > 0 ? parseFloat((data.pointsEarned / data.maxPoints * 100).toFixed(2)) : 0
+      }));
+    };
+    return {
+      performanceByLearningObjective: formatPerformanceArray(loPerformanceMap, "learningObjective"),
+      performanceByCategory: formatPerformanceArray(categoryPerformanceMap, "category"),
+      performanceByTopic: formatPerformanceArray(topicPerformanceMap, "topic"),
+      performanceByDifficulty: formatPerformanceArray(difficultyPerformanceMap, "difficulty"),
+      performanceByBloomLevel: formatPerformanceArray(bloomLevelPerformanceMap, "bloomLevel")
+    };
+  }
   async _sendResultsToWebhook(results) {
     var _a;
     if (!((_a = this.config.settings) == null ? void 0 : _a.webhookUrl)) {
@@ -798,71 +1553,6 @@ var QuizEngine = class {
       results.scormError = e instanceof Error ? e.message : "Unknown SCORM data sending error.";
     }
   }
-  _calculateMetadataPerformance() {
-    const loPerformanceMap = /* @__PURE__ */ new Map();
-    const categoryPerformanceMap = /* @__PURE__ */ new Map();
-    const topicPerformanceMap = /* @__PURE__ */ new Map();
-    const difficultyPerformanceMap = /* @__PURE__ */ new Map();
-    const bloomLevelPerformanceMap = /* @__PURE__ */ new Map();
-    const updateMap = (map, key, points, isCorrect) => {
-      if (!key) return;
-      const current = map.get(key) || { totalQuestions: 0, correctQuestions: 0, pointsEarned: 0, maxPoints: 0 };
-      current.totalQuestions++;
-      current.maxPoints += points;
-      if (isCorrect) {
-        current.correctQuestions++;
-        current.pointsEarned += points;
-      }
-      map.set(key, current);
-    };
-    this.questions.forEach((q) => {
-      var _a;
-      const qResult = this.userAnswers.get(q.id);
-      const { isCorrect } = this.evaluateQuestion(q, qResult || null);
-      const pointsForThisQuestion = (_a = q.points) != null ? _a : 0;
-      updateMap(loPerformanceMap, q.learningObjective, pointsForThisQuestion, isCorrect);
-      updateMap(categoryPerformanceMap, q.category, pointsForThisQuestion, isCorrect);
-      updateMap(topicPerformanceMap, q.topic, pointsForThisQuestion, isCorrect);
-      updateMap(difficultyPerformanceMap, q.difficulty, pointsForThisQuestion, isCorrect);
-      updateMap(bloomLevelPerformanceMap, q.bloomLevel, pointsForThisQuestion, isCorrect);
-    });
-    const formatPerformanceArray = (map, keyName) => {
-      return Array.from(map.entries()).map(([key, data]) => ({
-        [keyName]: key,
-        totalQuestions: data.totalQuestions,
-        correctQuestions: data.correctQuestions,
-        pointsEarned: data.pointsEarned,
-        maxPoints: data.maxPoints,
-        percentage: data.maxPoints > 0 ? parseFloat((data.pointsEarned / data.maxPoints * 100).toFixed(2)) : 0
-      }));
-    };
-    return {
-      performanceByLearningObjective: formatPerformanceArray(loPerformanceMap, "learningObjective"),
-      performanceByCategory: formatPerformanceArray(categoryPerformanceMap, "category"),
-      performanceByTopic: formatPerformanceArray(topicPerformanceMap, "topic"),
-      performanceByDifficulty: formatPerformanceArray(difficultyPerformanceMap, "difficulty"),
-      performanceByBloomLevel: formatPerformanceArray(bloomLevelPerformanceMap, "bloomLevel")
-    };
-  }
-  getElapsedTime() {
-    return Date.now() - this.overallStartTime;
-  }
-  destroy() {
-    this.stopTimer();
-    this._recordCurrentQuestionTime();
-    if (this.scormService && this.scormService.hasAPI()) {
-      if (["initialized", "committed", "sending_data"].includes(this.quizResultState.scormStatus || "")) {
-        const termResult = this.scormService.terminate();
-        if (termResult.success) {
-          this.quizResultState.scormStatus = "terminated";
-        } else {
-          this.quizResultState.scormStatus = "error";
-          this.quizResultState.scormError = termResult.error || "SCORM termination failed on destroy.";
-        }
-      }
-    }
-    this.scormService = null;
-  }
 };
 
 // src/utils/idGenerators.ts
@@ -875,22 +1565,12 @@ var QuizEditorService = class {
   constructor(initialQuiz) {
     this.quiz = JSON.parse(JSON.stringify(initialQuiz));
   }
-  /**
-   * Returns the current state of the quiz configuration.
-   * @returns The current QuizConfig object.
-   */
   getQuiz() {
     return this.quiz;
   }
-  /**
-   * Creates a new, "empty" question object based on the specified question type.
-   * @param type The type of question to create.
-   * @returns A new QuizQuestion object with default values.
-   */
   static createNewQuestionTemplate(type) {
     const baseNewQuestion = {
       id: generateUniqueId(`new_${type}_`),
-      // 'new_' prefix indicates it's a new, unsaved question
       questionType: type,
       prompt: "",
       points: 10,
@@ -944,16 +1624,21 @@ var QuizEditorService = class {
           solutionWorkspaceXML: "",
           solutionGeneratedCode: ""
         });
+      case "coding":
+        return __spreadProps(__spreadValues({}, baseNewQuestion), {
+          questionType: "coding",
+          language: "javascript",
+          solutionCode: "",
+          testCases: [],
+          functionSignature: "",
+          points: 25
+          // Coding questions are worth more by default
+        });
       default:
         const _exhaustiveCheck = type;
         throw new Error(`Question type "${_exhaustiveCheck}" is not supported for creation.`);
     }
   }
-  /**
-   * Adds a new question to the quiz. If the question ID is temporary, a new permanent ID is generated.
-   * @param question The question object to add.
-   * @returns The updated QuizConfig.
-   */
   addQuestion(question) {
     const newQuestion = __spreadValues({}, question);
     if (newQuestion.id.startsWith("new_")) {
@@ -962,11 +1647,6 @@ var QuizEditorService = class {
     this.quiz.questions.push(newQuestion);
     return this.quiz;
   }
-  /**
-   * Updates an existing question in the quiz.
-   * @param updatedQuestion The full question object with changes.
-   * @returns The updated QuizConfig.
-   */
   updateQuestion(updatedQuestion) {
     const questionIndex = this.quiz.questions.findIndex((q) => q.id === updatedQuestion.id);
     if (questionIndex === -1) {
@@ -975,11 +1655,6 @@ var QuizEditorService = class {
     this.quiz.questions[questionIndex] = updatedQuestion;
     return this.quiz;
   }
-  /**
-   * Deletes a question from the quiz by its index.
-   * @param index The index of the question to delete.
-   * @returns The updated QuizConfig.
-   */
   deleteQuestionByIndex(index) {
     if (index < 0 || index >= this.quiz.questions.length) {
       throw new Error(`Invalid index ${index} for question deletion.`);
@@ -987,12 +1662,6 @@ var QuizEditorService = class {
     this.quiz.questions.splice(index, 1);
     return this.quiz;
   }
-  /**
-   * Moves a question from one position to another.
-   * @param fromIndex The current index of the question.
-   * @param toIndex The target index for the question.
-   * @returns The updated QuizConfig.
-   */
   moveQuestion(fromIndex, toIndex) {
     if (fromIndex < 0 || fromIndex >= this.quiz.questions.length || toIndex < 0 || toIndex >= this.quiz.questions.length) {
       throw new Error("Invalid index for moving question.");
@@ -1002,823 +1671,960 @@ var QuizEditorService = class {
     return this.quiz;
   }
 };
-var QuestionOptionSchema = zod.z.object({
-  id: zod.z.string().describe("Unique ID for the option."),
-  text: zod.z.string().describe("Text content of the option.")
-});
-var MultipleChoiceQuestionSchema = zod.z.object({
-  // Các trường bắt buộc (required)
-  id: zod.z.string().describe("Unique identifier."),
-  questionType: zod.z.literal("multiple_choice"),
-  // Tương đương với "const" trong JSON Schema
-  prompt: zod.z.string().describe("Question statement."),
-  options: zod.z.array(QuestionOptionSchema).min(1).describe("Array of answer choices."),
-  correctAnswerId: zod.z.string().describe("ID of the correct option."),
-  // Các trường tùy chọn (optional)
-  points: zod.z.number().optional().describe("Points for correct answer."),
-  explanation: zod.z.string().optional().describe("Explanation for the answer."),
-  learningObjective: zod.z.string().optional(),
-  glossary: zod.z.array(zod.z.string()).optional(),
-  bloomLevel: zod.z.string().optional(),
-  difficulty: zod.z.enum(["easy", "medium", "hard"]).optional(),
-  // Có thể làm chặt chẽ hơn với z.enum
-  contextCode: zod.z.string().optional(),
-  gradeBand: zod.z.string().optional(),
-  course: zod.z.string().optional(),
-  category: zod.z.string().optional(),
-  topic: zod.z.string().optional()
-});
-var exampleData = {
-  id: "mcq-123",
-  questionType: "multiple_choice",
-  prompt: "What is 2 + 2?",
-  options: [
-    { id: "opt-1", text: "3" },
-    { id: "opt-2", text: "4" }
-  ],
-  correctAnswerId: "opt-2",
-  points: 10
-};
-try {
-  const validatedQuestion = MultipleChoiceQuestionSchema.parse(exampleData);
-  console.log("Validation successful:", validatedQuestion);
-} catch (error) {
-  console.error("Validation failed:", error);
-}
-var QuestionOptionSchema2 = zod.z.object({
-  id: zod.z.string(),
-  text: zod.z.string()
-});
-var MultipleResponseQuestionSchema = zod.z.object({
-  // Các trường bắt buộc
-  id: zod.z.string(),
-  questionType: zod.z.literal("multiple_response"),
-  prompt: zod.z.string(),
-  options: zod.z.array(QuestionOptionSchema2).min(1),
-  correctAnswerIds: zod.z.array(zod.z.string()).min(1).describe("Array of IDs of the correct options."),
-  // Các trường tùy chọn
-  points: zod.z.number().optional(),
-  explanation: zod.z.string().optional(),
-  learningObjective: zod.z.string().optional(),
-  glossary: zod.z.array(zod.z.string()).optional(),
-  bloomLevel: zod.z.string().optional(),
-  difficulty: zod.z.enum(["easy", "medium", "hard"]).optional(),
-  contextCode: zod.z.string().optional(),
-  gradeBand: zod.z.string().optional(),
-  course: zod.z.string().optional(),
-  category: zod.z.string().optional(),
-  topic: zod.z.string().optional()
-});
-var TextSegmentSchema = zod.z.object({
-  type: zod.z.literal("text"),
-  content: zod.z.string().describe("Text content for 'text' type segments.")
-});
-var BlankSegmentSchema = zod.z.object({
-  type: zod.z.literal("blank"),
-  id: zod.z.string().describe("Unique ID for 'blank' type segments, used to map to answers.")
-});
-var SegmentSchema = zod.z.discriminatedUnion("type", [
-  TextSegmentSchema,
-  BlankSegmentSchema
-]);
-var AnswerSchema = zod.z.object({
-  blankId: zod.z.string().describe("ID of the blank this answer corresponds to."),
-  acceptedValues: zod.z.array(zod.z.string()).min(1).describe("Array of acceptable string values for this blank.")
-});
-var FillInTheBlanksQuestionSchema = zod.z.object({
-  // Các trường bắt buộc
-  id: zod.z.string(),
-  questionType: zod.z.literal("fill_in_the_blanks"),
-  prompt: zod.z.string().describe("Overall instruction or context for the fill-in-the-blanks sentence(s)."),
-  segments: zod.z.array(SegmentSchema).min(1).describe("Array of text and blank segments constructing the question."),
-  answers: zod.z.array(AnswerSchema).min(1).describe("Definitions of correct answers for each blank."),
-  // Các trường tùy chọn
-  isCaseSensitive: zod.z.boolean().optional().describe("Whether answer evaluation should be case sensitive."),
+var BaseRawQuestionSchema = zod.z.object({
+  questionType: zod.z.string(),
+  prompt: zod.z.string().min(1, { message: "Prompt cannot be empty." }),
   points: zod.z.number().optional(),
   explanation: zod.z.string().optional(),
-  learningObjective: zod.z.string().optional(),
-  glossary: zod.z.array(zod.z.string()).optional(),
-  bloomLevel: zod.z.string().optional(),
+  topic: zod.z.string().optional(),
   difficulty: zod.z.enum(["easy", "medium", "hard"]).optional(),
-  contextCode: zod.z.string().optional(),
-  gradeBand: zod.z.string().optional(),
-  course: zod.z.string().optional(),
-  category: zod.z.string().optional(),
-  topic: zod.z.string().optional()
-});
-var DraggableItemSchema = zod.z.object({
-  id: zod.z.string(),
-  content: zod.z.string()
+  bloomLevel: zod.z.string().optional()
 });
-var DropZoneSchema = zod.z.object({
-  id: zod.z.string(),
-  label: zod.z.string()
-});
-var AnswerMapSchema = zod.z.object({
-  draggableId: zod.z.string(),
-  dropZoneId: zod.z.string()
+var RawMCQSchema = BaseRawQuestionSchema.extend({
+  questionType: zod.z.literal("multiple_choice"),
+  options: zod.z.array(zod.z.string()).min(2, { message: "Multiple Choice questions need at least 2 options." }),
+  correctAnswer: zod.z.string({ required_error: "A correct answer is required." })
 });
-var DragAndDropQuestionSchema = zod.z.object({
-  // Các trường bắt buộc
-  id: zod.z.string(),
-  questionType: zod.z.literal("drag_and_drop"),
-  prompt: zod.z.string(),
-  draggableItems: zod.z.array(DraggableItemSchema).min(1),
-  dropZones: zod.z.array(DropZoneSchema).min(1),
-  answerMap: zod.z.array(AnswerMapSchema).min(1),
-  // Các trường tùy chọn
-  backgroundImageUrl: zod.z.string().url().optional().describe("Must be a valid URL format."),
-  // .url() tương đương "format": "uri-reference"
-  imageAltText: zod.z.string().optional(),
-  points: zod.z.number().optional(),
-  explanation: zod.z.string().optional(),
-  learningObjective: zod.z.string().optional(),
-  glossary: zod.z.array(zod.z.string()).optional(),
-  bloomLevel: zod.z.string().optional(),
-  difficulty: zod.z.enum(["easy", "medium", "hard"]).optional(),
-  contextCode: zod.z.string().optional(),
-  gradeBand: zod.z.string().optional(),
-  course: zod.z.string().optional(),
-  category: zod.z.string().optional(),
-  topic: zod.z.string().optional()
+var RawMRQSchema = BaseRawQuestionSchema.extend({
+  questionType: zod.z.literal("multiple_response"),
+  options: zod.z.array(zod.z.string()).min(2, { message: "Multiple Response questions need at least 2 options." }),
+  correctAnswers: zod.z.array(zod.z.string()).min(1, { message: "At least one correct answer is required." })
 });
-var TrueFalseQuestionSchema = zod.z.object({
-  // Các trường bắt buộc
-  id: zod.z.string().describe("Unique identifier for the question."),
-  questionType: zod.z.literal("true_false").describe("The type of the question."),
-  prompt: zod.z.string().describe("The main text or statement for the question."),
-  correctAnswer: zod.z.boolean().describe("The correct answer for the statement (true if the statement is true, false if it is false)."),
-  // Các trường tùy chọn
-  points: zod.z.number().optional().describe("Points awarded for a correct answer."),
-  explanation: zod.z.string().optional().describe("Explanation for why the answer is correct or incorrect."),
-  learningObjective: zod.z.string().optional().describe("The learning objective this question addresses."),
-  glossary: zod.z.array(zod.z.string()).optional().describe("List of related glossary terms."),
-  bloomLevel: zod.z.string().optional().describe("Cognitive level based on Bloom's Taxonomy (e.g., 'Remembering', 'Applying')."),
-  difficulty: zod.z.enum(["easy", "medium", "hard"]).optional().describe("Difficulty level of the question."),
-  contextCode: zod.z.string().optional().describe("Identifier for the context of the question."),
-  gradeBand: zod.z.string().optional().describe("Target grade band for the question (e.g., 'K-2', 'Middle School')."),
-  course: zod.z.string().optional().describe("Associated course name."),
-  category: zod.z.string().optional().describe("General category of the question content (e.g., 'Mathematics', 'History')."),
-  topic: zod.z.string().optional().describe("Specific topic within the category.")
+var RawTFSchema = BaseRawQuestionSchema.extend({
+  questionType: zod.z.literal("true_false"),
+  correctAnswer: zod.z.boolean({ required_error: "A correct answer (true/false) is required." })
 });
-var ShortAnswerQuestionSchema = zod.z.object({
-  // Các trường bắt buộc
-  id: zod.z.string(),
+var RawSASchema = BaseRawQuestionSchema.extend({
   questionType: zod.z.literal("short_answer"),
-  prompt: zod.z.string(),
-  acceptedAnswers: zod.z.array(zod.z.string()).min(1).describe("An array of acceptable short answers."),
-  // Các trường tùy chọn
-  isCaseSensitive: zod.z.boolean().optional().describe("Whether the answer evaluation should be case sensitive."),
-  points: zod.z.number().optional(),
-  explanation: zod.z.string().optional(),
-  learningObjective: zod.z.string().optional(),
-  glossary: zod.z.array(zod.z.string()).optional(),
-  bloomLevel: zod.z.string().optional(),
-  difficulty: zod.z.enum(["easy", "medium", "hard"]).optional(),
-  contextCode: zod.z.string().optional(),
-  gradeBand: zod.z.string().optional(),
-  course: zod.z.string().optional(),
-  category: zod.z.string().optional(),
-  topic: zod.z.string().optional()
+  acceptedAnswers: zod.z.array(zod.z.string()).min(1, { message: "At least one accepted answer is required." })
 });
-var NumericQuestionSchema = zod.z.object({
-  // Các trường bắt buộc
-  id: zod.z.string(),
+var RawNumericSchema = BaseRawQuestionSchema.extend({
   questionType: zod.z.literal("numeric"),
-  prompt: zod.z.string(),
-  answer: zod.z.number().describe("The precise numerical correct answer."),
-  // Các trường tùy chọn
-  tolerance: zod.z.number().optional().describe("The acceptable range of error (plus or minus)."),
-  points: zod.z.number().optional(),
-  explanation: zod.z.string().optional(),
-  learningObjective: zod.z.string().optional(),
-  glossary: zod.z.array(zod.z.string()).optional(),
-  bloomLevel: zod.z.string().optional(),
-  difficulty: zod.z.enum(["easy", "medium", "hard"]).optional(),
-  contextCode: zod.z.string().optional(),
-  gradeBand: zod.z.string().optional(),
-  course: zod.z.string().optional(),
-  category: zod.z.string().optional(),
-  topic: zod.z.string().optional()
+  answer: zod.z.number({ required_error: "A numeric answer is required." }),
+  tolerance: zod.z.number().optional()
 });
-var SequenceItemSchema = zod.z.object({
-  id: zod.z.string().describe("Unique ID for the item."),
-  content: zod.z.string().describe("Text content of the item.")
-});
-var SequenceQuestionSchema = zod.z.object({
-  // Các trường bắt buộc
-  id: zod.z.string(),
+var RawSequenceSchema = BaseRawQuestionSchema.extend({
   questionType: zod.z.literal("sequence"),
-  prompt: zod.z.string(),
-  items: zod.z.array(SequenceItemSchema).min(2).describe("Array of items to be sequenced."),
-  correctOrder: zod.z.array(zod.z.string()).min(2).describe("Array of item IDs in the correct sequence."),
-  // Các trường tùy chọn
-  points: zod.z.number().optional(),
-  explanation: zod.z.string().optional(),
-  learningObjective: zod.z.string().optional(),
-  glossary: zod.z.array(zod.z.string()).optional(),
-  bloomLevel: zod.z.string().optional(),
-  difficulty: zod.z.enum(["easy", "medium", "hard"]).optional(),
-  contextCode: zod.z.string().optional(),
-  gradeBand: zod.z.string().optional(),
-  course: zod.z.string().optional(),
-  category: zod.z.string().optional(),
-  topic: zod.z.string().optional()
-});
-var MatchPromptItemSchema = zod.z.object({
-  id: zod.z.string(),
-  content: zod.z.string()
-});
-var MatchOptionItemSchema = zod.z.object({
-  id: zod.z.string(),
-  content: zod.z.string()
+  items: zod.z.array(zod.z.string()).min(2, { message: "Sequence questions need at least 2 items." }),
+  correctOrder: zod.z.array(zod.z.string()).min(2)
 });
-var CorrectAnswerMapSchema = zod.z.object({
-  promptId: zod.z.string(),
-  optionId: zod.z.string()
-});
-var MatchingQuestionSchema = zod.z.object({
-  // Các trường bắt buộc
-  id: zod.z.string(),
+var RawMatchingSchema = BaseRawQuestionSchema.extend({
   questionType: zod.z.literal("matching"),
-  prompt: zod.z.string(),
-  prompts: zod.z.array(MatchPromptItemSchema).min(1).describe("Array of items to be matched (e.g., terms, questions)."),
-  options: zod.z.array(MatchOptionItemSchema).min(1).describe("Array of choices to match with the prompts (e.g., definitions, answers)."),
-  correctAnswerMap: zod.z.array(CorrectAnswerMapSchema).min(1).describe("Array defining the correct pairings between prompt IDs and option IDs."),
-  // Các trường tùy chọn
-  shuffleOptions: zod.z.boolean().optional().describe("Whether the display order of options should be shuffled for the user."),
-  points: zod.z.number().optional(),
-  explanation: zod.z.string().optional(),
-  learningObjective: zod.z.string().optional(),
-  glossary: zod.z.array(zod.z.string()).optional(),
-  bloomLevel: zod.z.string().optional(),
-  difficulty: zod.z.enum(["easy", "medium", "hard"]).optional(),
-  contextCode: zod.z.string().optional(),
-  gradeBand: zod.z.string().optional(),
-  course: zod.z.string().optional(),
-  category: zod.z.string().optional(),
-  topic: zod.z.string().optional()
+  prompts: zod.z.array(zod.z.string()).min(1),
+  options: zod.z.array(zod.z.string()).min(1),
+  correctAnswerMap: zod.z.record(zod.z.string(), { required_error: "A map of correct answers is required." })
 });
-var HotspotRectSchema = zod.z.object({
-  id: zod.z.string().describe("Unique ID for the hotspot."),
-  shape: zod.z.literal("rect"),
-  coords: zod.z.number().array().length(4).describe("Coordinates for the rect: [x, y, width, height]."),
-  description: zod.z.string().optional().describe("Optional description for the hotspot (e.g., for tooltips).")
-});
-var HotspotCircleSchema = zod.z.object({
-  id: zod.z.string().describe("Unique ID for the hotspot."),
-  shape: zod.z.literal("circle"),
-  coords: zod.z.number().array().length(3).describe("Coordinates for the circle: [centerX, centerY, radius]."),
-  description: zod.z.string().optional().describe("Optional description for the hotspot (e.g., for tooltips).")
+var RawFITBSchema = BaseRawQuestionSchema.extend({
+  questionType: zod.z.literal("fill_in_the_blanks"),
+  sentenceWithPlaceholders: zod.z.string().includes("{{", { message: "Sentence must contain at least one placeholder like {{placeholder}}." }),
+  blanks: zod.z.record(zod.z.array(zod.z.string()).min(1), { required_error: "Blanks definitions are required." })
 });
-var HotspotAreaSchema = zod.z.discriminatedUnion("shape", [
-  HotspotRectSchema,
-  HotspotCircleSchema
+var AnyRawQuestionSchema = zod.z.discriminatedUnion("questionType", [
+  RawMCQSchema,
+  RawMRQSchema,
+  RawTFSchema,
+  RawSASchema,
+  RawNumericSchema,
+  RawSequenceSchema,
+  RawMatchingSchema,
+  RawFITBSchema
 ]);
-var HotspotQuestionSchema = zod.z.object({
-  // Các trường bắt buộc
-  id: zod.z.string(),
-  questionType: zod.z.literal("hotspot"),
-  prompt: zod.z.string(),
-  imageUrl: zod.z.string().url().describe("URL of the image to be used."),
-  hotspots: zod.z.array(HotspotAreaSchema).min(1).describe("Array of clickable hotspot areas on the image."),
-  correctHotspotIds: zod.z.array(zod.z.string()).min(1).describe("Array of IDs of the correct hotspots."),
-  // Các trường tùy chọn
-  imageAltText: zod.z.string().optional().describe("Alternative text for the image, for accessibility."),
-  points: zod.z.number().optional(),
-  explanation: zod.z.string().optional(),
-  learningObjective: zod.z.string().optional(),
-  glossary: zod.z.array(zod.z.string()).optional(),
-  bloomLevel: zod.z.string().optional(),
-  difficulty: zod.z.enum(["easy", "medium", "hard"]).optional(),
-  contextCode: zod.z.string().optional(),
-  gradeBand: zod.z.string().optional(),
-  course: zod.z.string().optional(),
-  category: zod.z.string().optional(),
-  topic: zod.z.string().optional()
-});
-var BlocklyProgrammingQuestionSchema = zod.z.object({
-  // Các trường bắt buộc (required)
-  id: zod.z.string(),
-  questionType: zod.z.literal("blockly_programming"),
-  prompt: zod.z.string(),
-  toolboxDefinition: zod.z.string().describe("XML string defining the Blockly toolbox."),
-  // Các trường tùy chọn (optional)
-  initialWorkspace: zod.z.string().optional().describe("Optional XML string for the initial state of the Blockly workspace."),
-  solutionWorkspaceXML: zod.z.string().optional().describe("Optional XML string representing the solution, for visual display."),
-  solutionGeneratedCode: zod.z.string().optional().describe("The JavaScript code that a correct Blockly program should generate, used for grading."),
-  points: zod.z.number().optional(),
-  explanation: zod.z.string().optional(),
-  learningObjective: zod.z.string().optional(),
-  glossary: zod.z.array(zod.z.string()).optional(),
-  bloomLevel: zod.z.string().optional(),
-  difficulty: zod.z.enum(["easy", "medium", "hard"]).optional(),
-  contextCode: zod.z.string().optional(),
-  gradeBand: zod.z.string().optional(),
-  course: zod.z.string().optional(),
-  category: zod.z.string().optional(),
-  topic: zod.z.string().optional()
-});
-var exampleData2 = {
-  id: "blkq-001",
-  questionType: "blockly_programming",
-  prompt: "Create a program to say 'Hello!'",
-  toolboxDefinition: "<xml>...</xml>",
-  solutionGeneratedCode: "window.alert('Hello!');"
-};
-try {
-  const validatedQuestion = BlocklyProgrammingQuestionSchema.parse(exampleData2);
-  console.log("Validation successful:", validatedQuestion);
-} catch (error) {
-  console.error("Validation failed:", error);
-}
-var ScratchProgrammingQuestionSchema = zod.z.object({
-  // Các trường bắt buộc (required)
-  id: zod.z.string(),
-  questionType: zod.z.literal("scratch_programming"),
-  prompt: zod.z.string(),
-  toolboxDefinition: zod.z.string().describe("XML string defining the Blockly/Scratch toolbox."),
-  // Các trường tùy chọn (optional)
-  initialWorkspace: zod.z.string().optional().describe("Optional XML string for the initial state of the workspace."),
-  solutionWorkspaceXML: zod.z.string().optional().describe("Optional XML string representing the solution blocks."),
-  solutionGeneratedCode: zod.z.string().optional().describe("The code or logic representation that a correct program should achieve, used for grading."),
-  points: zod.z.number().optional(),
-  explanation: zod.z.string().optional(),
-  learningObjective: zod.z.string().optional(),
-  glossary: zod.z.array(zod.z.string()).optional(),
-  bloomLevel: zod.z.string().optional(),
-  difficulty: zod.z.enum(["easy", "medium", "hard"]).optional(),
-  contextCode: zod.z.string().optional(),
-  gradeBand: zod.z.string().optional(),
-  course: zod.z.string().optional(),
-  category: zod.z.string().optional(),
-  topic: zod.z.string().optional()
-});
-var exampleData3 = {
-  id: "scrq-001",
-  questionType: "scratch_programming",
-  prompt: "Make the cat move 10 steps.",
-  toolboxDefinition: "<xml>...</xml>",
-  solutionGeneratedCode: "move(10)"
-};
-try {
-  const validatedQuestion = ScratchProgrammingQuestionSchema.parse(exampleData3);
-  console.log("Validation successful:", validatedQuestion);
-} catch (error) {
-  console.error("Validation failed:", error);
-}
-
-// src/services/QuestionImportService.ts
-var tsvQuestionTypeMap = {
-  TF: "true_false",
-  MC: "multiple_choice",
-  MR: "multiple_response",
-  TI: "short_answer",
-  MG: "matching",
-  SEQ: "sequence",
-  NUMG: "numeric"
-  // Add other mappings if needed
-};
-var tsvDifficultyMap = {
-  "d\u1EC5": "easy",
-  "easy": "easy",
-  "trung b\xECnh": "medium",
-  "medium": "medium",
-  "kh\xF3": "hard",
-  "hard": "hard"
-};
-var tsvBloomLevelMap = {
-  "nh\u1EDB": "remembering",
-  "remembering": "remembering",
-  "hi\u1EC3u": "understanding",
-  "understanding": "understanding",
-  "\xE1p d\u1EE5ng": "applying",
-  "applying": "applying",
-  "v\u1EADn d\u1EE5ng": "applying"
-  // Add other bloom levels if needed
-};
-var schemaMap = {
-  multiple_choice: MultipleChoiceQuestionSchema,
-  multiple_response: MultipleResponseQuestionSchema,
-  fill_in_the_blanks: FillInTheBlanksQuestionSchema,
-  drag_and_drop: DragAndDropQuestionSchema,
-  true_false: TrueFalseQuestionSchema,
-  short_answer: ShortAnswerQuestionSchema,
-  numeric: NumericQuestionSchema,
-  sequence: SequenceQuestionSchema,
-  matching: MatchingQuestionSchema,
-  hotspot: HotspotQuestionSchema,
-  blockly_programming: BlocklyProgrammingQuestionSchema,
-  scratch_programming: ScratchProgrammingQuestionSchema
-};
 var QuestionImportService = class {
   static processJSON(jsonString) {
-    const validQuestions = [];
-    const errors = [];
-    let parsedData;
     try {
-      parsedData = JSON.parse(jsonString);
+      const rawData = JSON.parse(jsonString);
+      if (!Array.isArray(rawData)) {
+        return { validQuestions: [], errors: [{ index: 0, message: "JSON content must be an array of question objects.", data: rawData }] };
+      }
+      return this.processRawObjects(rawData);
     } catch (e) {
-      errors.push({
-        index: 0,
-        message: `Invalid JSON format: ${e.message || "Could not parse the file/text."}`,
-        data: jsonString.substring(0, 500)
-      });
-      return { validQuestions, errors };
+      const message = e instanceof Error ? e.message : "Invalid JSON format.";
+      return { validQuestions: [], errors: [{ index: 0, message, data: jsonString.substring(0, 500) }] };
     }
-    if (!Array.isArray(parsedData)) {
-      errors.push({
-        index: 0,
-        message: "Invalid format. The root of the JSON must be an array of question objects.",
-        data: parsedData
-      });
-      return { validQuestions, errors };
-    }
-    parsedData.forEach((rawQuestion, index) => {
-      if (typeof rawQuestion !== "object" || rawQuestion === null || !rawQuestion.questionType) {
-        errors.push({
-          index: index + 1,
-          message: 'Invalid question object. Each item must be an object with a "questionType" property.',
-          data: rawQuestion
-        });
-        return;
-      }
-      const schema = schemaMap[rawQuestion.questionType];
-      if (!schema) {
-        errors.push({
-          index: index + 1,
-          message: `Unsupported question type: "${rawQuestion.questionType}".`,
-          data: rawQuestion
-        });
-        return;
-      }
-      const validationResult = schema.safeParse(rawQuestion);
-      if (validationResult.success) {
-        const sanitizedQuestion = this._sanitizeAndRegenerateIds(validationResult.data);
-        validQuestions.push(sanitizedQuestion);
-      } else {
-        const errorMessages = validationResult.error.errors.map((e) => `${e.path.join(".")} - ${e.message}`).join("; ");
-        errors.push({
-          index: index + 1,
-          message: `Validation failed: ${errorMessages}`,
-          data: rawQuestion
-        });
-      }
-    });
-    return { validQuestions, errors };
   }
-  /**
-   * Processes a TSV string to import questions.
-   * @param tsvString The raw TSV string to process.
-   * @returns An object containing arrays of valid questions and any errors encountered.
-   */
   static processTSV(tsvString) {
-    const validQuestions = [];
-    const errors = [];
     const lines = tsvString.split(/\r?\n/).filter((line) => line.trim() !== "");
     if (lines.length < 2) {
-      errors.push({ index: 0, message: "TSV file must have a header row and at least one data row.", data: tsvString });
-      return { validQuestions, errors };
-    }
-    const headerFields = lines[0].split("	").map((h) => h.trim().toLowerCase());
-    const headerMap = new Map(headerFields.map((header, index) => [header, index]));
-    const requiredHeaders = ["question type", "question text"];
-    for (const required of requiredHeaders) {
-      if (!headerMap.has(required)) {
-        errors.push({ index: 0, message: `Missing required header column: "${required}".`, data: lines[0] });
-        return { validQuestions, errors };
-      }
-    }
-    const dataRows = lines.slice(1);
-    dataRows.forEach((row, index) => {
-      const rowNumber = index + 2;
-      const columns = row.split("	");
+      return { validQuestions: [], errors: [{ index: 0, message: "TSV file must have a header and at least one data row.", data: tsvString }] };
+    }
+    const header = lines.shift().split("	").map((h) => h.trim());
+    const rawObjects = [];
+    const errors = [];
+    lines.forEach((line, index) => {
+      const values = line.split("	");
+      const rowObject = {};
+      header.forEach((h, i) => {
+        var _a;
+        rowObject[h] = ((_a = values[i]) == null ? void 0 : _a.trim()) || "";
+      });
       try {
-        const questionTypeAbbr = (columns[headerMap.get("question type")] || "").trim().toUpperCase();
-        const questionType = tsvQuestionTypeMap[questionTypeAbbr];
-        if (!questionType) {
-          throw new Error(`Unknown or unsupported Question Type: "${questionTypeAbbr}".`);
-        }
-        let transformedQuestion = this._transformRowToQuestion(columns, headerMap, questionType);
-        const schema = schemaMap[questionType];
-        const validationResult = schema.safeParse(transformedQuestion);
-        if (validationResult.success) {
-          const sanitizedQuestion = this._sanitizeAndRegenerateIds(validationResult.data);
-          validQuestions.push(sanitizedQuestion);
-        } else {
-          const errorMessages = validationResult.error.errors.map((e) => `${e.path.join(".")} - ${e.message}`).join("; ");
-          throw new Error(`Validation failed: ${errorMessages}`);
-        }
+        const transformedObject = this.transformTsvRowToRawObject(rowObject);
+        rawObjects.push(transformedObject);
+      } catch (e) {
+        const message = e instanceof Error ? e.message : "Error transforming TSV row.";
+        errors.push({ index: index + 2, message, data: line });
+      }
+    });
+    const processedResult = this.processRawObjects(rawObjects);
+    return { validQuestions: processedResult.validQuestions, errors: [...errors, ...processedResult.errors] };
+  }
+  static processRawObjects(rawObjects) {
+    const validQuestions = [];
+    const errors = [];
+    rawObjects.forEach((rawQ, index) => {
+      try {
+        const validatedRawQ = AnyRawQuestionSchema.parse(rawQ);
+        const question = this.createQuestionFromRawObject(validatedRawQ);
+        validQuestions.push(question);
       } catch (e) {
-        errors.push({
-          index: rowNumber,
-          message: e.message,
-          data: row
-        });
+        const message = e instanceof zod.z.ZodError ? e.errors.map((err) => `${err.path.join(".")} - ${err.message}`).join("; ") : e instanceof Error ? e.message : "Unknown validation error.";
+        errors.push({ index: index + 1, message, data: rawQ });
       }
     });
     return { validQuestions, errors };
   }
-  /**
-   * Central dispatcher to transform a TSV row into a QuizQuestion object.
-   * @private
-   */
-  static _transformRowToQuestion(columns, headerMap, type) {
-    const getColumn = (name) => {
-      var _a;
-      return ((_a = columns[headerMap.get(name.toLowerCase())]) == null ? void 0 : _a.trim()) || "";
-    };
-    const baseQuestion = {
-      prompt: getColumn("Question Text"),
-      explanation: getColumn("Explanation"),
-      points: parseInt(getColumn("Points"), 10) || 10,
-      difficulty: tsvDifficultyMap[getColumn("Difficulty").toLowerCase()] || "medium",
-      bloomLevel: tsvBloomLevelMap[getColumn("Bloom Taxonomy").toLowerCase()],
-      topic: getColumn("Concepts")
-      // Add other base fields here if needed
+  static transformTsvRowToRawObject(row) {
+    const { questionType, prompt, options, correctAnswer, points, explanation, topic, difficulty, bloomLevel, tolerance } = row;
+    if (!questionType) throw new Error("`questionType` column is missing or empty.");
+    const base = {
+      questionType,
+      prompt,
+      points: points ? parseInt(points, 10) : void 0,
+      explanation,
+      topic,
+      difficulty,
+      bloomLevel
     };
-    const answerCols = Array.from({ length: 10 }, (_, i) => getColumn(`Answer ${i + 1}`)).filter(Boolean);
-    switch (type) {
+    switch (questionType) {
       case "multiple_choice":
-        return this._transformMC(baseQuestion, answerCols);
+        return __spreadProps(__spreadValues({}, base), { options: options.split("|"), correctAnswer });
       case "multiple_response":
-        return this._transformMR(baseQuestion, answerCols);
+        return __spreadProps(__spreadValues({}, base), { options: options.split("|"), correctAnswers: correctAnswer.split("|") });
       case "true_false":
-        return this._transformTF(baseQuestion, answerCols);
+        return __spreadProps(__spreadValues({}, base), { correctAnswer: correctAnswer.toLowerCase() === "true" });
       case "short_answer":
-        return __spreadProps(__spreadValues({}, baseQuestion), { questionType: "short_answer", acceptedAnswers: answerCols, isCaseSensitive: false });
+        return __spreadProps(__spreadValues({}, base), { acceptedAnswers: correctAnswer.split("|") });
       case "numeric":
-        const answer = parseFloat(answerCols[0]);
-        if (isNaN(answer)) throw new Error("Numeric answer is not a valid number.");
-        return __spreadProps(__spreadValues({}, baseQuestion), { questionType: "numeric", answer, tolerance: void 0 });
-      case "matching":
-        return this._transformMG(baseQuestion, answerCols);
+        return __spreadProps(__spreadValues({}, base), { answer: parseFloat(correctAnswer), tolerance: tolerance ? parseFloat(tolerance) : void 0 });
       case "sequence":
-        return this._transformSEQ(baseQuestion, answerCols);
-      default:
-        throw new Error(`Transformation logic for type "${type}" is not implemented.`);
-    }
-  }
-  // --- Specific Transformation Helpers ---
-  static _transformMC(base, answers) {
-    let correctAnswerId = "";
-    const options = answers.map((ans) => {
-      const isCorrect = ans.startsWith("*");
-      const text = isCorrect ? ans.substring(1).trim() : ans.trim();
-      const id = generateUniqueId("opt_");
-      if (isCorrect) {
-        correctAnswerId = id;
+        return __spreadProps(__spreadValues({}, base), { items: options.split("|"), correctOrder: correctAnswer.split("|") });
+      case "matching": {
+        const [promptsStr, optionsStr] = options.split("#");
+        const prompts = promptsStr.replace("prompts:", "").split("|");
+        const opts = optionsStr.replace("options:", "").split("|");
+        const correctAnswerMap = correctAnswer.split("|").reduce((acc, pair) => {
+          const [key, ...valParts] = pair.split(":");
+          acc[key] = valParts.join(":");
+          return acc;
+        }, {});
+        return __spreadProps(__spreadValues({}, base), { prompts, options: opts, correctAnswerMap });
       }
-      return { id, text };
-    });
-    if (!correctAnswerId) throw new Error("Multiple Choice question must have one correct answer marked with *.");
-    return __spreadProps(__spreadValues({}, base), { questionType: "multiple_choice", options, correctAnswerId });
-  }
-  static _transformMR(base, answers) {
-    const correctAnswerIds = [];
-    const options = answers.map((ans) => {
-      const isCorrect = ans.startsWith("*");
-      const text = isCorrect ? ans.substring(1).trim() : ans.trim();
-      const id = generateUniqueId("opt_mr_");
-      if (isCorrect) {
-        correctAnswerIds.push(id);
+      case "fill_in_the_blanks": {
+        const blanks = correctAnswer.split("#").reduce((acc, part) => {
+          const [key, valuesStr] = part.split(":");
+          acc[key] = valuesStr.split("|");
+          return acc;
+        }, {});
+        return __spreadProps(__spreadValues({}, base), { sentenceWithPlaceholders: options, blanks });
       }
-      return { id, text };
-    });
-    if (correctAnswerIds.length === 0) throw new Error("Multiple Response question must have at least one correct answer marked with *.");
-    return __spreadProps(__spreadValues({}, base), { questionType: "multiple_response", options, correctAnswerIds });
-  }
-  static _transformTF(base, answers) {
-    if (answers.length < 2) throw new Error("True/False question requires at least two answer columns.");
-    const isTrueCorrect = answers[0].startsWith("*");
-    const isFalseCorrect = answers[1].startsWith("*");
-    if (isTrueCorrect === isFalseCorrect) throw new Error("True/False question must have exactly one correct answer marked with *.");
-    return __spreadProps(__spreadValues({}, base), { questionType: "true_false", correctAnswer: isTrueCorrect });
-  }
-  static _transformMG(base, answers) {
-    const prompts = [];
-    const options = [];
-    const correctAnswerMap = [];
-    answers.forEach((pair) => {
-      const parts = pair.split("|");
-      if (parts.length !== 2) throw new Error(`Invalid matching pair format: "${pair}". Must be "prompt|option".`);
-      const promptItem = { id: generateUniqueId("m_p_"), content: parts[0].trim() };
-      const optionItem = { id: generateUniqueId("m_o_"), content: parts[1].trim() };
-      prompts.push(promptItem);
-      options.push(optionItem);
-      correctAnswerMap.push({ promptId: promptItem.id, optionId: optionItem.id });
-    });
-    return __spreadProps(__spreadValues({}, base), { questionType: "matching", prompts, options, correctAnswerMap, shuffleOptions: true });
-  }
-  static _transformSEQ(base, answers) {
-    const items = [];
-    const correctOrder = [];
-    answers.forEach((content) => {
-      const item = { id: generateUniqueId("seqi_"), content: content.trim() };
-      items.push(item);
-      correctOrder.push(item.id);
-    });
-    return __spreadProps(__spreadValues({}, base), { questionType: "sequence", items, correctOrder });
+      default:
+        throw new Error(`Unsupported questionType "${questionType}" in TSV.`);
+    }
   }
-  /**
-   * @private
-   */
-  static _sanitizeAndRegenerateIds(question) {
-    const newQuestion = __spreadProps(__spreadValues({}, question), { id: generateUniqueId(`${question.questionType}_`) });
-    switch (newQuestion.questionType) {
+  static createQuestionFromRawObject(validatedRawQ) {
+    const baseQuestionData = {
+      id: generateUniqueId(validatedRawQ.questionType),
+      prompt: validatedRawQ.prompt,
+      points: validatedRawQ.points,
+      explanation: validatedRawQ.explanation,
+      topic: validatedRawQ.topic,
+      difficulty: validatedRawQ.difficulty,
+      bloomLevel: validatedRawQ.bloomLevel
+    };
+    switch (validatedRawQ.questionType) {
       case "multiple_choice": {
-        const oldIdToNewIdMap = /* @__PURE__ */ new Map();
-        newQuestion.options = newQuestion.options.map((opt) => {
-          const newId = generateUniqueId("opt_");
-          oldIdToNewIdMap.set(opt.id, newId);
-          return __spreadProps(__spreadValues({}, opt), { id: newId });
-        });
-        newQuestion.correctAnswerId = oldIdToNewIdMap.get(newQuestion.correctAnswerId) || "";
-        break;
+        const options = validatedRawQ.options.map((text) => ({ id: generateUniqueId("opt_"), text }));
+        const correctOption = options.find((opt) => opt.text === validatedRawQ.correctAnswer);
+        if (!correctOption) throw new Error(`Correct answer "${validatedRawQ.correctAnswer}" not found in options.`);
+        return __spreadProps(__spreadValues({}, baseQuestionData), { questionType: "multiple_choice", options, correctAnswerId: correctOption.id });
       }
       case "multiple_response": {
-        const oldIdToNewIdMap = /* @__PURE__ */ new Map();
-        newQuestion.options = newQuestion.options.map((opt) => {
-          const newId = generateUniqueId("opt_mr_");
-          oldIdToNewIdMap.set(opt.id, newId);
-          return __spreadProps(__spreadValues({}, opt), { id: newId });
-        });
-        newQuestion.correctAnswerIds = newQuestion.correctAnswerIds.map((oldId) => oldIdToNewIdMap.get(oldId)).filter((newId) => !!newId);
-        break;
-      }
-      case "fill_in_the_blanks": {
-        const oldBlankIdToNewIdMap = /* @__PURE__ */ new Map();
-        newQuestion.segments = newQuestion.segments.map((seg) => {
-          if (seg.type === "blank" && seg.id) {
-            const newId = generateUniqueId("blank_");
-            oldBlankIdToNewIdMap.set(seg.id, newId);
-            return __spreadProps(__spreadValues({}, seg), { id: newId });
-          }
-          return seg;
-        });
-        newQuestion.answers = newQuestion.answers.map((ans) => {
-          const newBlankId = oldBlankIdToNewIdMap.get(ans.blankId);
-          return newBlankId ? __spreadProps(__spreadValues({}, ans), { blankId: newBlankId }) : ans;
-        });
-        break;
+        const options = validatedRawQ.options.map((text) => ({ id: generateUniqueId("opt_mr_"), text }));
+        const correctIds = options.filter((opt) => validatedRawQ.correctAnswers.includes(opt.text)).map((opt) => opt.id);
+        if (correctIds.length !== validatedRawQ.correctAnswers.length) throw new Error("Some correct answers were not found in options.");
+        return __spreadProps(__spreadValues({}, baseQuestionData), { questionType: "multiple_response", options, correctAnswerIds: correctIds });
       }
+      case "true_false":
+        return __spreadProps(__spreadValues({}, baseQuestionData), { questionType: "true_false", correctAnswer: validatedRawQ.correctAnswer });
+      case "short_answer":
+        return __spreadProps(__spreadValues({}, baseQuestionData), { questionType: "short_answer", acceptedAnswers: validatedRawQ.acceptedAnswers, isCaseSensitive: false });
+      case "numeric":
+        return __spreadProps(__spreadValues({}, baseQuestionData), { questionType: "numeric", answer: validatedRawQ.answer, tolerance: validatedRawQ.tolerance });
       case "sequence": {
-        const oldIdToNewIdMap = /* @__PURE__ */ new Map();
-        newQuestion.items = newQuestion.items.map((item) => {
-          const newId = generateUniqueId("seqi_");
-          oldIdToNewIdMap.set(item.id, newId);
-          return __spreadProps(__spreadValues({}, item), { id: newId });
+        if (validatedRawQ.items.length !== validatedRawQ.correctOrder.length) {
+          throw new Error("The number of items must match the number of items in the correct order for a sequence question.");
+        }
+        const items = validatedRawQ.items.map((content) => ({ id: generateUniqueId("seqi_"), content }));
+        const correctOrder = validatedRawQ.correctOrder.map((orderText) => {
+          const foundItem = items.find((item) => item.content === orderText);
+          if (!foundItem) throw new Error(`Sequence item "${orderText}" in correctOrder not found in items list.`);
+          return foundItem.id;
         });
-        newQuestion.correctOrder = newQuestion.correctOrder.map((oldId) => oldIdToNewIdMap.get(oldId)).filter((newId) => !!newId);
-        break;
+        return __spreadProps(__spreadValues({}, baseQuestionData), { questionType: "sequence", items, correctOrder });
       }
       case "matching": {
-        const oldPromptIdMap = /* @__PURE__ */ new Map();
-        const oldOptionIdMap = /* @__PURE__ */ new Map();
-        newQuestion.prompts = newQuestion.prompts.map((p) => {
-          const newId = generateUniqueId("m_p_");
-          oldPromptIdMap.set(p.id, newId);
-          return __spreadProps(__spreadValues({}, p), { id: newId });
-        });
-        newQuestion.options = newQuestion.options.map((o) => {
-          const newId = generateUniqueId("m_o_");
-          oldOptionIdMap.set(o.id, newId);
-          return __spreadProps(__spreadValues({}, o), { id: newId });
-        });
-        newQuestion.correctAnswerMap = newQuestion.correctAnswerMap.map((map) => ({
-          promptId: oldPromptIdMap.get(map.promptId) || "",
-          optionId: oldOptionIdMap.get(map.optionId) || ""
-        })).filter((map) => map.promptId && map.optionId);
-        break;
-      }
-      case "drag_and_drop": {
-        const oldDraggableIdMap = /* @__PURE__ */ new Map();
-        const oldDropZoneIdMap = /* @__PURE__ */ new Map();
-        newQuestion.draggableItems = newQuestion.draggableItems.map((item) => {
-          const newId = generateUniqueId("drag_");
-          oldDraggableIdMap.set(item.id, newId);
-          return __spreadProps(__spreadValues({}, item), { id: newId });
-        });
-        newQuestion.dropZones = newQuestion.dropZones.map((zone) => {
-          const newId = generateUniqueId("zone_");
-          oldDropZoneIdMap.set(zone.id, newId);
-          return __spreadProps(__spreadValues({}, zone), { id: newId });
+        if (validatedRawQ.prompts.length !== Object.keys(validatedRawQ.correctAnswerMap).length) {
+          throw new Error("Each prompt must have a corresponding correct answer in the map for a matching question.");
+        }
+        const prompts = validatedRawQ.prompts.map((p) => ({ id: generateUniqueId("matp_"), content: p }));
+        const options = validatedRawQ.options.map((o) => ({ id: generateUniqueId("mato_"), content: o }));
+        const correctAnswerMap = Object.entries(validatedRawQ.correctAnswerMap).map(([promptText, optionText]) => {
+          const prompt = prompts.find((p) => p.content === promptText);
+          const option = options.find((o) => o.content === optionText);
+          if (!prompt || !option) throw new Error(`Matching pair "${promptText}":"${optionText}" not found in prompts/options.`);
+          return { promptId: prompt.id, optionId: option.id };
         });
-        newQuestion.answerMap = newQuestion.answerMap.map((map) => ({
-          draggableId: oldDraggableIdMap.get(map.draggableId) || "",
-          dropZoneId: oldDropZoneIdMap.get(map.dropZoneId) || ""
-        })).filter((map) => map.draggableId && map.dropZoneId);
-        break;
+        return __spreadProps(__spreadValues({}, baseQuestionData), { questionType: "matching", prompts, options, correctAnswerMap, shuffleOptions: true });
       }
-      case "hotspot": {
-        const oldIdToNewIdMap = /* @__PURE__ */ new Map();
-        newQuestion.hotspots = newQuestion.hotspots.map((spot) => {
-          const newId = generateUniqueId("hs_");
-          oldIdToNewIdMap.set(spot.id, newId);
-          return __spreadProps(__spreadValues({}, spot), { id: newId });
+      case "fill_in_the_blanks": {
+        const { sentenceWithPlaceholders, blanks } = validatedRawQ;
+        const segments = [];
+        const answers = [];
+        const placeholderMap = {};
+        Object.keys(blanks).forEach((placeholder) => {
+          const blankId = generateUniqueId("blank_");
+          placeholderMap[placeholder] = blankId;
+          answers.push({ blankId, acceptedValues: blanks[placeholder] });
         });
-        newQuestion.correctHotspotIds = newQuestion.correctHotspotIds.map((oldId) => oldIdToNewIdMap.get(oldId)).filter((newId) => !!newId);
-        break;
+        const regex = /\{\{([^}]+)\}\}/g;
+        let lastIndex = 0;
+        let match;
+        while ((match = regex.exec(sentenceWithPlaceholders)) !== null) {
+          if (match.index > lastIndex) {
+            segments.push({ type: "text", content: sentenceWithPlaceholders.substring(lastIndex, match.index) });
+          }
+          const placeholder = match[1];
+          const blankId = placeholderMap[placeholder];
+          if (!blankId) throw new Error(`Placeholder "{{${placeholder}}}" found in sentence but not defined in blanks object.`);
+          segments.push({ type: "blank", id: blankId });
+          lastIndex = regex.lastIndex;
+        }
+        if (lastIndex < sentenceWithPlaceholders.length) {
+          segments.push({ type: "text", content: sentenceWithPlaceholders.substring(lastIndex) });
+        }
+        return __spreadProps(__spreadValues({}, baseQuestionData), { questionType: "fill_in_the_blanks", segments, answers, isCaseSensitive: false });
       }
-      case "true_false":
-      case "short_answer":
-      case "numeric":
-      case "blockly_programming":
-      case "scratch_programming":
-        break;
-      default:
-        const _exhaustiveCheck = newQuestion;
-        console.warn("Unhandled question type in _sanitizeAndRegenerateIds:", _exhaustiveCheck);
-        break;
     }
-    return newQuestion;
+    throw new Error(`Unhandled question type in createQuestionFromRawObject: ${validatedRawQ.questionType}`);
   }
 };
 
-// src/services/APIKeyService.ts
-var GEMINI_API_KEY_SERVICE_NAME = "gemini";
-var LOCAL_STORAGE_PREFIX = "iqk_api_keys_";
-function _encode(data) {
-  if (typeof window !== "undefined" && typeof window.btoa === "function") {
-    try {
-      return window.btoa(data);
-    } catch (e) {
-      console.error("Base64 encoding (btoa) failed:", e);
-      return data;
-    }
+// src/services/UserConfigService.ts
+var LOCAL_STORAGE_PREFIX2 = "iqk_user_config_";
+var UserConfigService = class {
+  static getStorageKey(key) {
+    return `${LOCAL_STORAGE_PREFIX2}${key}`;
   }
-  return data;
-}
-function _decode(data) {
-  if (typeof window !== "undefined" && typeof window.atob === "function") {
-    try {
-      return window.atob(data);
-    } catch (e) {
-      console.error("Base64 decoding (atob) failed:", e);
-      return data;
+  static setConfig(key, value) {
+    if (typeof window !== "undefined" && window.localStorage) {
+      try {
+        const serializedValue = JSON.stringify(value);
+        localStorage.setItem(this.getStorageKey(key), serializedValue);
+      } catch (e) {
+        console.error(`Error saving config key "${key}" to localStorage:`, e);
+      }
     }
   }
-  return data;
-}
-var APIKeyService = class {
-  static getStorageKey(serviceName) {
-    return `${LOCAL_STORAGE_PREFIX}${serviceName}`;
+  static getConfig(key, defaultValue = null) {
+    if (typeof window !== "undefined" && window.localStorage) {
+      try {
+        const storedValue = localStorage.getItem(this.getStorageKey(key));
+        if (storedValue !== null) {
+          return JSON.parse(storedValue);
+        }
+      } catch (e) {
+        console.error(`Error retrieving or parsing config key "${key}" from localStorage:`, e);
+        return defaultValue;
+      }
+    }
+    return defaultValue;
   }
-  /**
-   * Saves an API key to localStorage. The key is mildly obfuscated using Base64.
-   * @param serviceName - The name of the service (e.g., 'gemini').
-   * @param apiKey - The API key to save.
-   */
-  static saveAPIKey(serviceName, apiKey) {
+  static removeConfig(key) {
     if (typeof window !== "undefined" && window.localStorage) {
       try {
-        const encodedKey = _encode(apiKey);
-        localStorage.setItem(this.getStorageKey(serviceName), encodedKey);
+        localStorage.removeItem(this.getStorageKey(key));
       } catch (e) {
-        console.error(`Error saving API key for ${serviceName} to localStorage:`, e);
+        console.error(`Error removing config key "${key}" from localStorage:`, e);
       }
-    } else {
-      console.warn("localStorage is not available. APIKeyService cannot save keys.");
     }
   }
+  // --- Convenience Methods for Simple Configs ---
+  static getFullName() {
+    return this.getConfig("fullName", null);
+  }
+  static setFullName(name) {
+    this.setConfig("fullName", name);
+  }
+  static getWeeklyGoal() {
+    const goal = this.getConfig("weeklyGoal", 5);
+    return typeof goal === "number" ? goal : 5;
+  }
+  static setWeeklyGoal(goal) {
+    this.setConfig("weeklyGoal", goal);
+  }
+  static getLanguage() {
+    var _a;
+    return (_a = this.getConfig("language", "en")) != null ? _a : "en";
+  }
+  static setLanguage(language) {
+    this.setConfig("language", language);
+  }
+  // --- Methods for Advanced Goal Management ---
+  static getGoals() {
+    return this.getConfig("advanced_goals", []) || [];
+  }
+  static saveGoals(goals) {
+    this.setConfig("advanced_goals", goals);
+  }
   /**
-   * Retrieves an API key from localStorage.
-   * @param serviceName - The name of the service.
-   * @returns The decoded API key, or null if not found or if localStorage is unavailable.
+   * Adds a new goal to the user's list. The goal object should not contain a description.
+   * @param newGoal A partial Goal object without id, description, isAchieved, or achievedAt.
    */
-  static getAPIKey(serviceName) {
-    if (typeof window !== "undefined" && window.localStorage) {
+  static addGoal(newGoal) {
+    const goals = this.getGoals();
+    const goalToAdd = __spreadProps(__spreadValues({}, newGoal), {
+      id: generateUniqueId("goal_"),
+      isAchieved: false
+    });
+    this.saveGoals([...goals, goalToAdd]);
+  }
+  static updateGoal(updatedGoal) {
+    const goals = this.getGoals();
+    const index = goals.findIndex((g) => g.id === updatedGoal.id);
+    if (index > -1) {
+      goals[index] = updatedGoal;
+      this.saveGoals(goals);
+    }
+  }
+  static deleteGoal(goalId) {
+    const goals = this.getGoals();
+    const filteredGoals = goals.filter((g) => g.id !== goalId);
+    this.saveGoals(filteredGoals);
+  }
+};
+
+// src/services/PracticeHistoryService.ts
+var LOCAL_STORAGE_KEY = "iqk_practice_history_v2";
+var PracticeHistoryService = class {
+  static getPracticeHistory() {
+    if (typeof window === "undefined") return [];
+    try {
+      const storedData = localStorage.getItem(LOCAL_STORAGE_KEY);
+      return storedData ? JSON.parse(storedData) : [];
+    } catch (e) {
+      console.error("Error retrieving practice history:", e);
+      return [];
+    }
+  }
+  static saveHistory(history) {
+    if (typeof window !== "undefined") {
       try {
-        const storedKey = localStorage.getItem(this.getStorageKey(serviceName));
-        if (storedKey) {
-          return _decode(storedKey);
+        localStorage.setItem(LOCAL_STORAGE_KEY, JSON.stringify(history));
+      } catch (e) {
+        console.error("Error saving practice history to localStorage:", e);
+      }
+    }
+  }
+  static saveCompletedPracticeSession(quizConfig, result, review = null) {
+    const history = this.getPracticeHistory();
+    const topicsCovered = Array.from(
+      new Set(quizConfig.questions.map((q) => JSON.stringify({
+        subject: q.subject || "Uncategorized",
+        category: q.category || "General",
+        topic: q.topic || "General Topic"
+      })))
+    ).map((s) => JSON.parse(s));
+    const newSession = {
+      id: `session_${Date.now()}_${Math.random().toString(36).substring(2, 7)}`,
+      timestamp: Date.now(),
+      quizConfig,
+      quizResult: result,
+      quizReview: review,
+      summary: {
+        topics: topicsCovered,
+        score: result.score,
+        maxScore: result.maxScore,
+        percentage: result.percentage
+      }
+    };
+    history.unshift(newSession);
+    this.saveHistory(history);
+    return newSession.id;
+  }
+  static updatePracticeReview(sessionId, review) {
+    const history = this.getPracticeHistory();
+    const sessionIndex = history.findIndex((s) => s.id === sessionId);
+    if (sessionIndex > -1) {
+      history[sessionIndex].quizReview = review;
+      this.saveHistory(history);
+    } else {
+      console.warn(`Could not find session with ID "${sessionId}" to update review.`);
+    }
+  }
+  static getPracticeSessionById(sessionId) {
+    return this.getPracticeHistory().find((s) => s.id === sessionId) || null;
+  }
+  static getPracticeHistorySummary() {
+    const history = this.getPracticeHistory();
+    return history.map((session) => ({
+      id: session.id,
+      timestamp: session.timestamp,
+      quizTitle: session.quizConfig.title,
+      topics: session.summary.topics,
+      score: session.summary.score,
+      maxScore: session.summary.maxScore,
+      percentage: session.summary.percentage
+    }));
+  }
+  static getPracticeStats() {
+    const history = this.getPracticeHistory();
+    if (history.length === 0) {
+      return {
+        totalSessions: 0,
+        currentStreak: 0,
+        longestStreak: 0,
+        activityCalendar: {},
+        performanceBySubject: [],
+        performanceByTopic: []
+      };
+    }
+    const toLocalDateString = (timestamp) => {
+      const date = new Date(timestamp);
+      const offset = date.getTimezoneOffset();
+      const adjustedDate = new Date(date.getTime() - offset * 60 * 1e3);
+      return adjustedDate.toISOString().split("T")[0];
+    };
+    const activityCalendar = {};
+    const uniquePracticeDays = /* @__PURE__ */ new Set();
+    history.forEach((session) => {
+      const dateStr = toLocalDateString(session.timestamp);
+      activityCalendar[dateStr] = (activityCalendar[dateStr] || 0) + 1;
+      uniquePracticeDays.add(dateStr);
+    });
+    const sortedDays = Array.from(uniquePracticeDays).sort().reverse();
+    let currentStreak = 0;
+    let longestStreak = 0;
+    if (sortedDays.length > 0) {
+      const today = /* @__PURE__ */ new Date();
+      const todayStr = toLocalDateString(today.getTime());
+      const yesterday = /* @__PURE__ */ new Date();
+      yesterday.setDate(today.getDate() - 1);
+      const yesterdayStr = toLocalDateString(yesterday.getTime());
+      if (sortedDays[0] === todayStr || sortedDays[0] === yesterdayStr) {
+        currentStreak = 1;
+        for (let i = 0; i < sortedDays.length - 1; i++) {
+          const currentDay = new Date(sortedDays[i]);
+          const nextDay = new Date(sortedDays[i + 1]);
+          const diffTime = currentDay.getTime() - nextDay.getTime();
+          const diffDays = Math.round(diffTime / (1e3 * 60 * 60 * 24));
+          if (diffDays === 1) {
+            currentStreak++;
+          } else {
+            break;
+          }
+        }
+      }
+    }
+    if (sortedDays.length > 0) {
+      let tempStreak = 1;
+      longestStreak = 1;
+      for (let i = 0; i < sortedDays.length - 1; i++) {
+        const currentDay = new Date(sortedDays[i]);
+        const nextDay = new Date(sortedDays[i + 1]);
+        const diffTime = currentDay.getTime() - nextDay.getTime();
+        const diffDays = Math.round(diffTime / (1e3 * 60 * 60 * 24));
+        if (diffDays === 1) {
+          tempStreak++;
+        } else {
+          tempStreak = 1;
         }
+        if (tempStreak > longestStreak) {
+          longestStreak = tempStreak;
+        }
+      }
+    } else {
+      longestStreak = 0;
+    }
+    const subjectPerf = {};
+    const topicPerf = {};
+    history.forEach((session) => {
+      session.summary.topics.forEach((topicInfo) => {
+        if (session.summary.percentage !== null) {
+          if (!subjectPerf[topicInfo.subject]) subjectPerf[topicInfo.subject] = { total: 0, count: 0 };
+          subjectPerf[topicInfo.subject].total += session.summary.percentage;
+          subjectPerf[topicInfo.subject].count++;
+          if (!topicPerf[topicInfo.topic]) topicPerf[topicInfo.topic] = { total: 0, count: 0 };
+          topicPerf[topicInfo.topic].total += session.summary.percentage;
+          topicPerf[topicInfo.topic].count++;
+        }
+      });
+    });
+    const formatPerf = (perfData) => {
+      return Object.entries(perfData).map(([name, data]) => ({
+        name,
+        totalSessions: data.count,
+        averageScore: parseFloat((data.total / data.count).toFixed(2))
+      })).sort((a, b) => b.totalSessions - a.totalSessions);
+    };
+    return {
+      totalSessions: history.length,
+      currentStreak,
+      longestStreak,
+      activityCalendar,
+      performanceBySubject: formatPerf(subjectPerf),
+      performanceByTopic: formatPerf(topicPerf)
+    };
+  }
+  static clearHistory() {
+    if (typeof window !== "undefined") {
+      localStorage.removeItem(LOCAL_STORAGE_KEY);
+    }
+  }
+};
+
+// src/data/achievements.json
+var achievements_default = [
+  {
+    id: "first_session",
+    icon: "Rocket",
+    nameKey: "achievements.first_session.name",
+    descriptionKey: "achievements.first_session.description",
+    condition: {
+      type: "SESSION_COUNT",
+      params: { count: 1 }
+    }
+  },
+  {
+    id: "five_sessions",
+    icon: "BookOpen",
+    nameKey: "achievements.five_sessions.name",
+    descriptionKey: "achievements.five_sessions.description",
+    condition: {
+      type: "SESSION_COUNT",
+      params: { count: 5 }
+    }
+  },
+  {
+    id: "perfect_score",
+    icon: "Star",
+    nameKey: "achievements.perfect_score.name",
+    descriptionKey: "achievements.perfect_score.description",
+    condition: {
+      type: "PERFECT_SCORE",
+      params: {}
+    }
+  },
+  {
+    id: "streak_3_days",
+    icon: "Flame",
+    nameKey: "achievements.streak_3_days.name",
+    descriptionKey: "achievements.streak_3_days.description",
+    condition: {
+      type: "STREAK",
+      params: { days: 3 }
+    }
+  },
+  {
+    id: "ten_sessions",
+    icon: "Award",
+    nameKey: "achievements.ten_sessions.name",
+    descriptionKey: "achievements.ten_sessions.description",
+    condition: {
+      type: "SESSION_COUNT",
+      params: { count: 10 }
+    }
+  },
+  {
+    id: "streak_7_days",
+    icon: "Sparkles",
+    nameKey: "achievements.streak_7_days.name",
+    descriptionKey: "achievements.streak_7_days.description",
+    condition: {
+      type: "STREAK",
+      params: { days: 7 }
+    }
+  },
+  {
+    id: "weekend_warrior",
+    icon: "CalendarDays",
+    nameKey: "achievements.weekend_warrior.name",
+    descriptionKey: "achievements.weekend_warrior.description",
+    condition: {
+      type: "SESSION_ON_WEEKEND",
+      params: {}
+    }
+  },
+  {
+    id: "night_owl",
+    icon: "Moon",
+    nameKey: "achievements.night_owl.name",
+    descriptionKey: "achievements.night_owl.description",
+    condition: {
+      type: "SESSION_AFTER_HOUR",
+      params: { hour: 22 }
+    }
+  },
+  {
+    id: "polymath_prospect",
+    icon: "Library",
+    nameKey: "achievements.polymath_prospect.name",
+    descriptionKey: "achievements.polymath_prospect.description",
+    condition: {
+      type: "DISTINCT_SUBJECTS",
+      params: { count: 3 }
+    }
+  },
+  {
+    id: "subject_specialist",
+    icon: "Target",
+    nameKey: "achievements.subject_specialist.name",
+    descriptionKey: "achievements.subject_specialist.description",
+    condition: {
+      type: "SESSIONS_IN_SUBJECT",
+      params: { count: 5 }
+    }
+  },
+  {
+    id: "high_achiever",
+    icon: "TrendingUp",
+    nameKey: "achievements.high_achiever.name",
+    descriptionKey: "achievements.high_achiever.description",
+    condition: {
+      type: "CONSECUTIVE_HIGH_SCORE",
+      params: { count: 3, score: 90 }
+    }
+  },
+  {
+    id: "comeback_kid",
+    icon: "ChevronsUp",
+    nameKey: "achievements.comeback_kid.name",
+    descriptionKey: "achievements.comeback_kid.description",
+    condition: {
+      type: "SCORE_IMPROVEMENT",
+      params: { improvement: 20 }
+    }
+  },
+  {
+    id: "twenty_five_sessions",
+    icon: "Medal",
+    nameKey: "achievements.twenty_five_sessions.name",
+    descriptionKey: "achievements.twenty_five_sessions.description",
+    condition: {
+      type: "SESSION_COUNT",
+      params: { count: 25 }
+    }
+  },
+  {
+    id: "streak_14_days",
+    icon: "Gem",
+    nameKey: "achievements.streak_14_days.name",
+    descriptionKey: "achievements.streak_14_days.description",
+    condition: {
+      type: "STREAK",
+      params: { days: 14 }
+    }
+  },
+  {
+    id: "subject_master",
+    icon: "Crown",
+    nameKey: "achievements.subject_master.name",
+    descriptionKey: "achievements.subject_master.description",
+    condition: {
+      type: "SUBJECT_MASTERY",
+      params: { score: 90, sessions: 5 }
+    }
+  },
+  {
+    id: "centurion",
+    icon: "ShieldCheck",
+    nameKey: "achievements.centurion.name",
+    descriptionKey: "achievements.centurion.description",
+    condition: {
+      type: "SESSION_COUNT",
+      params: { count: 100 }
+    }
+  }
+];
+
+// src/services/AchievementService.ts
+var LOCAL_STORAGE_KEY2 = "iqk_unlocked_achievements_v2";
+var ALL_ACHIEVEMENT_DEFS = achievements_default;
+var conditionEvaluators = {
+  SESSION_COUNT: (params, history) => history.length >= params.count,
+  PERFECT_SCORE: (params, history) => history.some((s) => s.summary.percentage === 100),
+  STREAK: (params, history, stats) => stats.longestStreak >= params.days,
+  SESSION_ON_WEEKEND: (params, history) => history.some((s) => [0, 6].includes(new Date(s.timestamp).getDay())),
+  SESSION_AFTER_HOUR: (params, history) => history.some((s) => new Date(s.timestamp).getHours() >= params.hour),
+  DISTINCT_SUBJECTS: (params, history) => {
+    const subjects = new Set(history.flatMap((s) => s.summary.topics.map((t) => t.subject)));
+    return subjects.size >= params.count;
+  },
+  SESSIONS_IN_SUBJECT: (params, history) => {
+    const subjectCounts = history.flatMap((s) => s.summary.topics.map((t) => t.subject)).reduce((acc, subject) => {
+      acc[subject] = (acc[subject] || 0) + 1;
+      return acc;
+    }, {});
+    return Object.values(subjectCounts).some((count) => count >= params.count);
+  },
+  CONSECUTIVE_HIGH_SCORE: (params, history) => {
+    if (history.length < params.count) return false;
+    for (let i = 0; i <= history.length - params.count; i++) {
+      const recentSessions = history.slice(i, i + params.count);
+      if (recentSessions.every((s) => s.summary.percentage !== null && s.summary.percentage >= params.score)) {
+        return true;
+      }
+    }
+    return false;
+  },
+  SCORE_IMPROVEMENT: (params, history) => {
+    if (history.length < 2) return false;
+    for (let i = 0; i < history.length - 1; i++) {
+      const currentPercent = history[i].summary.percentage;
+      const previousPercent = history[i + 1].summary.percentage;
+      if (currentPercent !== null && previousPercent !== null && currentPercent - previousPercent >= params.improvement) {
+        return true;
+      }
+    }
+    return false;
+  },
+  SUBJECT_MASTERY: (params, history, stats) => {
+    return stats.performanceBySubject.some((s) => s.averageScore >= params.score && s.totalSessions >= params.sessions);
+  }
+};
+var AchievementService = class {
+  static getUnlockedAchievementsMap() {
+    if (typeof window === "undefined") return {};
+    try {
+      const storedData = localStorage.getItem(LOCAL_STORAGE_KEY2);
+      return storedData ? JSON.parse(storedData) : {};
+    } catch (e) {
+      console.error("Error retrieving unlocked achievements map:", e);
+      return {};
+    }
+  }
+  static saveUnlockedAchievementsMap(unlockedMap) {
+    if (typeof window !== "undefined") {
+      try {
+        localStorage.setItem(LOCAL_STORAGE_KEY2, JSON.stringify(unlockedMap));
       } catch (e) {
-        console.error(`Error retrieving API key for ${serviceName} from localStorage:`, e);
+        console.error("Error saving unlocked achievements map:", e);
       }
     }
-    return null;
   }
+  static checkAndUnlockAchievements(history, stats) {
+    const unlockedMap = this.getUnlockedAchievementsMap();
+    const newlyUnlocked = [];
+    let hasChanges = false;
+    ALL_ACHIEVEMENT_DEFS.forEach((achievementDef) => {
+      if (unlockedMap[achievementDef.id]) {
+        return;
+      }
+      const evaluator = conditionEvaluators[achievementDef.condition.type];
+      if (evaluator) {
+        const isUnlocked = evaluator(achievementDef.condition.params, history, stats);
+        if (isUnlocked) {
+          const unlockTime = Date.now();
+          unlockedMap[achievementDef.id] = unlockTime;
+          newlyUnlocked.push(achievementDef);
+          hasChanges = true;
+        }
+      } else {
+        console.warn(`No evaluator found for achievement condition type: "${achievementDef.condition.type}"`);
+      }
+    });
+    if (hasChanges) {
+      this.saveUnlockedAchievementsMap(unlockedMap);
+    }
+    return newlyUnlocked;
+  }
+  static getAllAchievementDefinitions() {
+    return ALL_ACHIEVEMENT_DEFS;
+  }
+  static getAllAchievementsWithStatus() {
+    const unlockedMap = this.getUnlockedAchievementsMap();
+    return ALL_ACHIEVEMENT_DEFS.map((def) => {
+      const unlockedAt = unlockedMap[def.id];
+      return {
+        id: def.id,
+        icon: def.icon,
+        name: def.nameKey,
+        description: def.descriptionKey,
+        unlockedAt: unlockedAt || void 0
+      };
+    });
+  }
+};
+
+// src/services/MotivationalQuotes.ts
+var QUOTE_BANK = [
+  { text: "H\u1ECDc, h\u1ECDc n\u1EEFa, h\u1ECDc m\xE3i.", author: "V.I. Lenin" },
+  { text: "H\xE0nh tr\xECnh v\u1EA1n d\u1EB7m b\u1EAFt \u0111\u1EA7u b\u1EB1ng m\u1ED9t b\u01B0\u1EDBc ch\xE2n.", author: "L\xE3o T\u1EED" },
+  { text: "C\xE1ch t\u1ED1t nh\u1EA5t \u0111\u1EC3 d\u1EF1 \u0111o\xE1n t\u01B0\u01A1ng lai l\xE0 t\u1EA1o ra n\xF3.", author: "Peter Drucker" },
+  { text: "\u0110\u1EEBng lo l\u1EAFng v\u1EC1 th\u1EA5t b\u1EA1i; h\xE3y lo l\u1EAFng v\u1EC1 nh\u1EEFng c\u01A1 h\u1ED9i b\u1EA1n b\u1ECF l\u1EE1 khi kh\xF4ng d\xE1m th\u1EED.", author: "Jack Canfield" },
+  { text: "Th\xE0nh c\xF4ng kh\xF4ng ph\u1EA3i l\xE0 cu\u1ED1i c\xF9ng, th\u1EA5t b\u1EA1i kh\xF4ng ph\u1EA3i l\xE0 ch\u1EBFt ng\u01B0\u1EDDi: l\xF2ng can \u0111\u1EA3m \u0111i ti\u1EBFp m\u1EDBi quan tr\u1ECDng.", author: "Winston Churchill" },
+  { text: "Ch\u1EC9 nh\u1EEFng ng\u01B0\u1EDDi d\xE1m th\u1EA5t b\u1EA1i l\u1EDBn m\u1EDBi c\xF3 th\u1EC3 \u0111\u1EA1t \u0111\u01B0\u1EE3c th\xE0nh c\xF4ng l\u1EDBn.", author: "Robert F. Kennedy" },
+  { text: "Ki\u1EBFn th\u1EE9c l\xE0 s\u1EE9c m\u1EA1nh.", author: "Francis Bacon" },
+  { text: "S\u1EF1 kh\xE1c bi\u1EC7t gi\u1EEFa b\xECnh th\u01B0\u1EDDng v\xE0 phi th\u01B0\u1EDDng ch\u1EC9 l\xE0 m\u1ED9t ch\xFAt n\u1ED7 l\u1EF1c.", author: "Jimmy Johnson" },
+  { text: "H\xE3y l\xE0 s\u1EF1 thay \u0111\u1ED5i m\xE0 b\u1EA1n mu\u1ED1n th\u1EA5y tr\xEAn th\u1EBF gi\u1EDBi.", author: "Mahatma Gandhi" },
+  { text: "H\xF4m nay b\u1EA1n \u0111\u1ECDc, ng\xE0y mai b\u1EA1n s\u1EBD l\xE3nh \u0111\u1EA1o.", author: "Margaret Fuller" },
+  { text: "R\u1EC5 c\u1EE7a gi\xE1o d\u1EE5c th\xEC \u0111\u1EAFng, nh\u01B0ng qu\u1EA3 c\u1EE7a n\xF3 th\xEC ng\u1ECDt.", author: "Aristotle" },
+  { text: "C\xE1ch \u0111\u1EC3 b\u1EAFt \u0111\u1EA7u l\xE0 ng\u1EEBng n\xF3i v\xE0 b\u1EAFt \u0111\u1EA7u l\xE0m.", author: "Walt Disney" },
+  { text: "K\u1EF7 lu\u1EADt l\xE0 c\u1EA7u n\u1ED1i gi\u1EEFa m\u1EE5c ti\xEAu v\xE0 th\xE0nh t\u1EF1u.", author: "Jim Rohn" },
+  { text: "B\u1EA1n kh\xF4ng c\u1EA7n ph\u1EA3i v\u0129 \u0111\u1EA1i \u0111\u1EC3 b\u1EAFt \u0111\u1EA7u, nh\u01B0ng b\u1EA1n ph\u1EA3i b\u1EAFt \u0111\u1EA7u \u0111\u1EC3 tr\u1EDF n\xEAn v\u0129 \u0111\u1EA1i.", author: "Zig Ziglar" },
+  { text: "Tin r\u1EB1ng b\u1EA1n c\xF3 th\u1EC3 v\xE0 b\u1EA1n \u0111\xE3 \u0111i \u0111\u01B0\u1EE3c n\u1EEDa \u0111\u01B0\u1EDDng.", author: "Theodore Roosevelt" },
+  { text: "M\u1ED9t ng\u01B0\u1EDDi kh\xF4ng bao gi\u1EDD m\u1EAFc sai l\u1EA7m l\xE0 ng\u01B0\u1EDDi kh\xF4ng bao gi\u1EDD th\u1EED b\u1EA5t c\u1EE9 \u0111i\u1EC1u g\xEC m\u1EDBi.", author: "Albert Einstein" },
+  { text: "Th\u1EED th\xE1ch l\xE0 th\u1EE9 l\xE0m cho cu\u1ED9c s\u1ED1ng th\xFA v\u1ECB v\xE0 v\u01B0\u1EE3t qua ch\xFAng l\xE0 \u0111i\u1EC1u l\xE0m cho cu\u1ED9c s\u1ED1ng c\xF3 \xFD ngh\u0129a.", author: "Joshua J. Marine" },
+  { text: "Thi\xEAn t\xE0i l\xE0 m\u1ED9t ph\u1EA7n tr\u0103m c\u1EA3m h\u1EE9ng v\xE0 ch\xEDn m\u01B0\u01A1i ch\xEDn ph\u1EA7n tr\u0103m m\u1ED3 h\xF4i.", author: "Thomas Edison" },
+  { text: "\u0110\u1EEBng \u0111\u1EC3 ng\xE0y h\xF4m qua chi\u1EBFm qu\xE1 nhi\u1EC1u th\u1EDDi gian c\u1EE7a ng\xE0y h\xF4m nay.", author: "Will Rogers" },
+  { text: "N\u1EBFu c\u01A1 h\u1ED9i kh\xF4ng g\xF5 c\u1EEDa, h\xE3y x\xE2y m\u1ED9t c\xE1nh c\u1EEDa.", author: "Milton Berle" }
+];
+var QuoteService = class {
   /**
-   * Removes an API key from localStorage.
-   * @param serviceName - The name of the service.
+   * Retrieves a random quote from the internal quote bank.
+   * @returns A quote object containing text and author.
    */
-  static removeAPIKey(serviceName) {
-    if (typeof window !== "undefined" && window.localStorage) {
+  static getRandomQuote() {
+    if (QUOTE_BANK.length === 0) {
+      return { text: "H\xE3y b\u1EAFt \u0111\u1EA7u h\xE0nh tr\xECnh h\u1ECDc t\u1EADp c\u1EE7a b\u1EA1n.", author: "QuizKit" };
+    }
+    const randomIndex = Math.floor(Math.random() * QUOTE_BANK.length);
+    return QUOTE_BANK[randomIndex];
+  }
+};
+
+// src/services/KnowledgeCardService.ts
+var LOCAL_STORAGE_KEY3 = "iqk_knowledge_cards_store";
+var GENERATION_FLAG_KEY = "iqk_card_generation_in_progress";
+var KnowledgeCardService = class {
+  static generateHash(str) {
+    let hash = 0;
+    if (str.length === 0) return hash.toString();
+    for (let i = 0; i < str.length; i++) {
+      const char = str.charCodeAt(i);
+      hash = (hash << 5) - hash + char;
+      hash |= 0;
+    }
+    return hash.toString();
+  }
+  static getStore() {
+    if (typeof window === "undefined") {
+      return { sourceHash: null, conceptsPlan: [], generatedConcepts: {}, cards: [] };
+    }
+    try {
+      const storedData = localStorage.getItem(LOCAL_STORAGE_KEY3);
+      if (storedData) {
+        return JSON.parse(storedData);
+      }
+    } catch (e) {
+      console.error("Error reading Knowledge Card store from localStorage:", e);
+    }
+    return { sourceHash: null, conceptsPlan: [], generatedConcepts: {}, cards: [] };
+  }
+  static saveStore(store) {
+    if (typeof window !== "undefined") {
       try {
-        localStorage.removeItem(this.getStorageKey(serviceName));
+        localStorage.setItem(LOCAL_STORAGE_KEY3, JSON.stringify(store));
       } catch (e) {
-        console.error(`Error removing API key for ${serviceName} from localStorage:`, e);
+        console.error("Error saving Knowledge Card store to localStorage:", e);
       }
     }
   }
+  static getSourceHash() {
+    return this.getStore().sourceHash;
+  }
+  /**
+   * Saves a new card generation plan. This clears old cards and resets the generation progress.
+   * @param sourceHash The hash of the new source content.
+   * @param concepts An array of concept strings to be generated.
+   */
+  static saveCardPlan(sourceHash, concepts) {
+    const newStore = {
+      sourceHash,
+      conceptsPlan: concepts,
+      generatedConcepts: {},
+      cards: []
+    };
+    this.saveStore(newStore);
+  }
+  /**
+   * Saves a newly generated card to the store and marks its concept as completed.
+   * @param card The KnowledgeCard object to save.
+   */
+  static saveGeneratedCard(card) {
+    const store = this.getStore();
+    if (!store.cards.some((c) => c.id === card.id)) {
+      store.cards.push(card);
+      store.generatedConcepts[card.concept] = true;
+      this.saveStore(store);
+    }
+  }
   /**
-   * Checks if an API key exists in localStorage for the given service.
-   * @param serviceName - The name of the service.
-   * @returns True if a key exists, false otherwise.
+   * Gets the list of concepts that are in the plan but have not been generated yet.
+   * @returns An array of concept strings that are pending generation.
    */
-  static hasAPIKey(serviceName) {
-    return this.getAPIKey(serviceName) !== null;
+  static getPendingConcepts() {
+    const store = this.getStore();
+    return store.conceptsPlan.filter((concept) => !store.generatedConcepts[concept]);
+  }
+  /**
+   * Gets the current status of the card generation process.
+   * @returns An object with the total number of cards planned and the number completed.
+   */
+  static getGenerationStatus() {
+    const store = this.getStore();
+    return {
+      total: store.conceptsPlan.length,
+      completed: Object.keys(store.generatedConcepts).length
+    };
+  }
+  /**
+   * Checks if a generation process is currently marked as running in this browser tab/session.
+   * Uses sessionStorage to prevent multiple tabs from running the same process.
+   * @returns True if a process is marked as running, false otherwise.
+   */
+  static isGenerationInProgress() {
+    if (typeof window === "undefined") return false;
+    return sessionStorage.getItem(GENERATION_FLAG_KEY) === "true";
+  }
+  /**
+   * Sets or clears the flag indicating that a generation process is active.
+   * @param status The status to set (true for running, false for stopped).
+   */
+  static setGenerationStatus(status) {
+    if (typeof window !== "undefined") {
+      if (status) {
+        sessionStorage.setItem(GENERATION_FLAG_KEY, "true");
+      } else {
+        sessionStorage.removeItem(GENERATION_FLAG_KEY);
+      }
+    }
+  }
+  static getCards() {
+    return this.getStore().cards;
+  }
+  static getRandomCard() {
+    const cards = this.getCards();
+    if (cards.length === 0) return null;
+    const randomIndex = Math.floor(Math.random() * cards.length);
+    return cards[randomIndex];
+  }
+  static searchCards(query) {
+    const cards = this.getCards();
+    if (!query.trim()) return [];
+    const lowerCaseQuery = query.toLowerCase();
+    return cards.filter(
+      (card) => card.concept.toLowerCase().includes(lowerCaseQuery) || card.definition.toLowerCase().includes(lowerCaseQuery)
+    );
   }
 };
 
@@ -2444,11 +3250,16 @@ function cn(...inputs) {
 }
 
 exports.APIKeyService = APIKeyService;
+exports.AchievementService = AchievementService;
 exports.GEMINI_API_KEY_SERVICE_NAME = GEMINI_API_KEY_SERVICE_NAME;
+exports.KnowledgeCardService = KnowledgeCardService;
+exports.PracticeHistoryService = PracticeHistoryService;
 exports.QuestionImportService = QuestionImportService;
 exports.QuizEditorService = QuizEditorService;
 exports.QuizEngine = QuizEngine;
+exports.QuoteService = QuoteService;
 exports.SCORMService = SCORMService;
+exports.UserConfigService = UserConfigService;
 exports.cn = cn;
 exports.emptyQuiz = emptyQuiz;
 exports.exportQuizAsSCORMZip = exportQuizAsSCORMZip;