@thanh01.pmt/interactive-quiz-kit 1.0.0

package/dist/index.js

@@ -0,0 +1,2779 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __defProps = Object.defineProperties;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getOwnPropSymbols = Object.getOwnPropertySymbols;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __propIsEnum = Object.prototype.propertyIsEnumerable;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp.call(b, prop))
+      __defNormalProp(a, prop, b[prop]);
+  if (__getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(b)) {
+      if (__propIsEnum.call(b, prop))
+        __defNormalProp(a, prop, b[prop]);
+    }
+  return a;
+};
+var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  QuizEngine: () => QuizEngine,
+  SCORMService: () => SCORMService,
+  cn: () => cn,
+  emptyQuiz: () => emptyQuiz,
+  exportQuizAsSCORMZip: () => exportQuizAsSCORMZip,
+  generateFillInTheBlanksQuestion: () => generateFillInTheBlanksQuestion,
+  generateLauncherHTML: () => generateLauncherHTML,
+  generateMCQQuestion: () => generateMCQQuestion,
+  generateMRQQuestion: () => generateMRQQuestion,
+  generateMatchingQuestion: () => generateMatchingQuestion,
+  generateNumericQuestion: () => generateNumericQuestion,
+  generateQuestionsFromQuizPlan: () => generateQuestionsFromQuizPlan,
+  generateQuizPlan: () => generateQuizPlan,
+  generateSCORMManifest: () => generateSCORMManifest,
+  generateSequenceQuestion: () => generateSequenceQuestion,
+  generateShortAnswerQuestion: () => generateShortAnswerQuestion,
+  generateTrueFalseQuestion: () => generateTrueFalseQuestion,
+  generateUniqueId: () => generateUniqueId,
+  sampleQuiz: () => sampleQuiz
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/services/SCORMService.ts
+var SCORM_TRUE = "true";
+var SCORM_NO_ERROR = "0";
+var CMI_CORE_LESSON_STATUS_PASSED = "passed";
+var CMI_CORE_LESSON_STATUS_FAILED = "failed";
+var CMI_CORE_LESSON_STATUS_COMPLETED = "completed";
+var CMI_CORE_LESSON_STATUS_INCOMPLETE = "incomplete";
+var CMI_CORE_LESSON_STATUS_NOT_ATTEMPTED = "not attempted";
+var CMI_COMPLETION_STATUS_COMPLETED = "completed";
+var CMI_COMPLETION_STATUS_INCOMPLETE = "incomplete";
+var CMI_SUCCESS_STATUS_PASSED = "passed";
+var CMI_SUCCESS_STATUS_FAILED = "failed";
+var SCORMService = class {
+  constructor(settings) {
+    this.scormAPI = null;
+    this.scormVersionFound = null;
+    this.isInitialized = false;
+    this.isTerminated = false;
+    this.studentName = null;
+    this.settings = __spreadValues({
+      setCompletionOnFinish: true,
+      setSuccessOnPass: true,
+      autoCommit: true
+    }, settings);
+    if (typeof window !== "undefined") {
+      this._findAPI();
+    }
+  }
+  _findAPIRecursive(win) {
+    if (win === null) return null;
+    if (win.API_1484_11) {
+      this.scormVersionFound = "2004";
+      return win.API_1484_11;
+    }
+    if (win.API) {
+      this.scormVersionFound = "1.2";
+      return win.API;
+    }
+    if (win.parent && win.parent !== win) {
+      return this._findAPIRecursive(win.parent);
+    }
+    if (win.opener && typeof win.opener !== "undefined" && win.opener !== win && win.opener !== win.parent) {
+      try {
+        if (win.opener.document) {
+          return this._findAPIRecursive(win.opener);
+        }
+      } catch (e) {
+        console.warn("SCORMService: Could not access win.opener for API search due to cross-origin restrictions.");
+      }
+    }
+    return null;
+  }
+  _findAPI() {
+    try {
+      this.scormAPI = this._findAPIRecursive(window);
+      if (this.scormAPI) {
+        if (!this.scormVersionFound) this.scormVersionFound = this.settings.version;
+        console.log(`SCORMService: API Found. Version determined: ${this.scormVersionFound}`);
+      } else {
+        console.warn("SCORMService: SCORM API not found in window hierarchy.");
+      }
+    } catch (e) {
+      console.error("SCORMService: Error finding SCORM API", e);
+      this.scormAPI = null;
+    }
+  }
+  hasAPI() {
+    return this.scormAPI !== null;
+  }
+  getSCORMVersion() {
+    return this.scormVersionFound;
+  }
+  initialize() {
+    if (!this.hasAPI()) return { success: false, error: "SCORM API not found." };
+    if (this.isInitialized) return { success: true, studentName: this.studentName || void 0 };
+    const result = this.scormVersionFound === "2004" ? this.scormAPI.Initialize("") : this.scormAPI.LMSInitialize("");
+    if (result.toString() === SCORM_TRUE || result === true) {
+      this.isInitialized = true;
+      this.isTerminated = false;
+      const studentNameVar = this.settings.studentNameVar || (this.scormVersionFound === "2004" ? "cmi.learner_name" : "cmi.core.student_name");
+      this.studentName = this.getValue(studentNameVar);
+      if (this.scormVersionFound === "2004") {
+        const completionStatusVar = this.settings.completionStatusVar_2004 || this.settings.lessonStatusVar || "cmi.completion_status";
+        if (this.getValue(completionStatusVar) === "not attempted") {
+          this.setValue(completionStatusVar, CMI_COMPLETION_STATUS_INCOMPLETE);
+        }
+      } else {
+        const lessonStatusVar = this.settings.lessonStatusVar_1_2 || this.settings.lessonStatusVar || "cmi.core.lesson_status";
+        if (this.getValue(lessonStatusVar) === CMI_CORE_LESSON_STATUS_NOT_ATTEMPTED) {
+          this.setValue(lessonStatusVar, CMI_CORE_LESSON_STATUS_INCOMPLETE);
+        }
+      }
+      if (this.settings.autoCommit) this.commit();
+      return { success: true, studentName: this.studentName || void 0 };
+    } else {
+      const error = this.getLastError();
+      return { success: false, error: `Initialization failed: ${error.message}` };
+    }
+  }
+  terminate() {
+    if (!this.hasAPI() || !this.isInitialized || this.isTerminated) {
+      const reason = !this.hasAPI() ? "API not found" : !this.isInitialized ? "Not initialized" : "Already terminated";
+      return { success: !this.hasAPI() || this.isTerminated, error: this.isTerminated ? void 0 : reason };
+    }
+    const result = this.scormVersionFound === "2004" ? this.scormAPI.Terminate("") : this.scormAPI.LMSFinish("");
+    if (result.toString() === SCORM_TRUE || result === true) {
+      this.isTerminated = true;
+      this.isInitialized = false;
+      return { success: true };
+    } else {
+      const error = this.getLastError();
+      return { success: false, error: `Termination failed: ${error.message}` };
+    }
+  }
+  setValue(element, value) {
+    if (!this.hasAPI() || !this.isInitialized) {
+      return { success: false, error: !this.hasAPI() ? "SCORM API not found." : "SCORM not initialized." };
+    }
+    const valStr = value.toString();
+    const result = this.scormVersionFound === "2004" ? this.scormAPI.SetValue(element, valStr) : this.scormAPI.LMSSetValue(element, valStr);
+    if (result.toString() === SCORM_TRUE || result === true) {
+      if (this.settings.autoCommit) this.commit();
+      return { success: true };
+    } else {
+      const error = this.getLastError();
+      return { success: false, error: `SetValue failed for ${element}: ${error.message}` };
+    }
+  }
+  getValue(element) {
+    var _a;
+    if (!this.hasAPI() || !this.isInitialized) return null;
+    const value = this.scormVersionFound === "2004" ? this.scormAPI.GetValue(element) : this.scormAPI.LMSGetValue(element);
+    const error = this.getLastError();
+    if (error.code !== SCORM_NO_ERROR && error.code !== "403" && error.code !== "0") {
+      console.warn(`SCORMService: GetValue for ${element} produced an error ${error.code}: ${error.message}. Returning raw value:`, value);
+    }
+    return (_a = value == null ? void 0 : value.toString()) != null ? _a : null;
+  }
+  commit() {
+    if (!this.hasAPI() || !this.isInitialized) {
+      return { success: false, error: !this.hasAPI() ? "SCORM API not found." : "SCORM not initialized." };
+    }
+    const result = this.scormVersionFound === "2004" ? this.scormAPI.Commit("") : this.scormAPI.LMSCommit("");
+    if (result.toString() === SCORM_TRUE || result === true) {
+      return { success: true };
+    } else {
+      const error = this.getLastError();
+      return { success: false, error: `Commit failed: ${error.message}` };
+    }
+  }
+  setScore(rawScore, maxScore, minScore = 0) {
+    if (!this.hasAPI() || !this.isInitialized) return;
+    if (this.scormVersionFound === "2004") {
+      const scoreRawVar = this.settings.scoreRawVar_2004 || this.settings.scoreRawVar || "cmi.score.raw";
+      const scoreMaxVar = this.settings.scoreMaxVar_2004 || this.settings.scoreMaxVar || "cmi.score.max";
+      const scoreMinVar = this.settings.scoreMinVar_2004 || this.settings.scoreMinVar || "cmi.score.min";
+      const scoreScaledVar = this.settings.scoreScaledVar_2004 || "cmi.score.scaled";
+      this.setValue(scoreMinVar, minScore);
+      this.setValue(scoreMaxVar, maxScore);
+      this.setValue(scoreRawVar, rawScore);
+      if (maxScore > minScore) {
+        const scaledScore = (rawScore - minScore) / (maxScore - minScore);
+        this.setValue(scoreScaledVar, parseFloat(scaledScore.toFixed(4)));
+      } else if (maxScore === minScore && maxScore !== 0) {
+        this.setValue(scoreScaledVar, rawScore >= maxScore ? 1 : 0);
+      } else {
+        this.setValue(scoreScaledVar, 0);
+      }
+    } else {
+      const scoreRawVar = this.settings.scoreRawVar_1_2 || this.settings.scoreRawVar || "cmi.core.score.raw";
+      const scoreMaxVar = this.settings.scoreMaxVar_1_2 || this.settings.scoreMaxVar || "cmi.core.score.max";
+      const scoreMinVar = this.settings.scoreMinVar_1_2 || this.settings.scoreMinVar || "cmi.core.score.min";
+      this.setValue(scoreMinVar, minScore);
+      this.setValue(scoreMaxVar, maxScore);
+      this.setValue(scoreRawVar, rawScore);
+    }
+  }
+  setLessonStatus(status, passed) {
+    if (!this.hasAPI() || !this.isInitialized) return;
+    if (this.scormVersionFound === "2004") {
+      const completionStatusVar = this.settings.completionStatusVar_2004 || this.settings.lessonStatusVar || "cmi.completion_status";
+      const successStatusVar = this.settings.successStatusVar_2004 || "cmi.success_status";
+      if (this.settings.setCompletionOnFinish && (status === "completed" || status === "passed" || status === "failed")) {
+        this.setValue(completionStatusVar, CMI_COMPLETION_STATUS_COMPLETED);
+      } else if (status === "incomplete" || status === "browsed") {
+        this.setValue(completionStatusVar, CMI_COMPLETION_STATUS_INCOMPLETE);
+      }
+      if (this.settings.setSuccessOnPass && passed !== void 0) {
+        this.setValue(successStatusVar, passed ? CMI_SUCCESS_STATUS_PASSED : CMI_SUCCESS_STATUS_FAILED);
+      }
+    } else {
+      const lessonStatusVar = this.settings.lessonStatusVar_1_2 || this.settings.lessonStatusVar || "cmi.core.lesson_status";
+      let finalStatus = status;
+      if (this.settings.setCompletionOnFinish) {
+        if (this.settings.setSuccessOnPass && passed !== void 0) {
+          finalStatus = passed ? CMI_CORE_LESSON_STATUS_PASSED : CMI_CORE_LESSON_STATUS_FAILED;
+        } else {
+          finalStatus = CMI_CORE_LESSON_STATUS_COMPLETED;
+        }
+      } else {
+        if (status === CMI_CORE_LESSON_STATUS_PASSED || status === CMI_CORE_LESSON_STATUS_FAILED) {
+        } else {
+          finalStatus = CMI_CORE_LESSON_STATUS_INCOMPLETE;
+        }
+      }
+      this.setValue(lessonStatusVar, finalStatus);
+    }
+  }
+  getLastError() {
+    var _a, _b;
+    if (!this.hasAPI()) return { code: "-1", message: "SCORM API not found." };
+    const errorCode = this.scormVersionFound === "2004" ? this.scormAPI.GetLastError() : this.scormAPI.LMSGetLastError();
+    if (errorCode === SCORM_NO_ERROR || errorCode === 0 || errorCode === "0") {
+      return { code: SCORM_NO_ERROR, message: "No error." };
+    }
+    const errorMessage = this.scormVersionFound === "2004" ? this.scormAPI.GetErrorString(errorCode.toString()) : this.scormAPI.LMSGetErrorString(errorCode.toString());
+    const diagnostic = this.scormVersionFound === "2004" ? this.scormAPI.GetDiagnostic(errorCode.toString()) : this.scormAPI.LMSGetDiagnostic(errorCode.toString());
+    return {
+      code: errorCode.toString(),
+      message: (_a = errorMessage == null ? void 0 : errorMessage.toString()) != null ? _a : "Unknown error.",
+      diagnostic: (_b = diagnostic == null ? void 0 : diagnostic.toString()) != null ? _b : void 0
+    };
+  }
+  formatCMITime(totalSeconds) {
+    const pad = (num, size = 2) => num.toString().padStart(size, "0");
+    if (this.scormVersionFound === "2004") {
+      const hours = Math.floor(totalSeconds / 3600);
+      const minutes = Math.floor(totalSeconds % 3600 / 60);
+      const seconds = parseFloat((totalSeconds % 60).toFixed(2));
+      let timeString = "PT";
+      if (hours > 0) timeString += `${hours}H`;
+      if (minutes > 0 || hours > 0 && seconds > 0) {
+        timeString += `${minutes}M`;
+      }
+      if (seconds > 0 || timeString === "PT") {
+        timeString += `${seconds}S`;
+      }
+      return timeString === "PT" ? "PT0S" : timeString;
+    } else {
+      const hours = Math.floor(totalSeconds / 3600);
+      const minutes = Math.floor(totalSeconds % 3600 / 60);
+      const secondsOnly = Math.floor(totalSeconds % 60);
+      const centiseconds = Math.floor((totalSeconds - Math.floor(totalSeconds)) * 100);
+      return `${pad(hours, 4)}:${pad(minutes)}:${pad(secondsOnly)}.${pad(centiseconds)}`;
+    }
+  }
+};
+
+// src/services/QuizEngine.ts
+var QuizEngine = class {
+  // Stores time in seconds
+  constructor(options) {
+    this.userAnswers = /* @__PURE__ */ new Map();
+    this.currentQuestionIndex = 0;
+    this.timerId = null;
+    this.timeLeftInSeconds = null;
+    this.scormService = null;
+    this.quizResultState = { scormStatus: "idle" };
+    this.questionStartTime = null;
+    this.questionTimings = /* @__PURE__ */ new Map();
+    var _a, _b, _c, _d, _e;
+    this.config = options.config;
+    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();
+    if (((_b = this.config.settings) == null ? void 0 : _b.timeLimitMinutes) && this.config.settings.timeLimitMinutes > 0) {
+      this.timeLeftInSeconds = this.config.settings.timeLimitMinutes * 60;
+    }
+    if ((_c = this.config.settings) == null ? void 0 : _c.scorm) {
+      this.quizResultState.scormStatus = "initializing";
+      this.scormService = new SCORMService(this.config.settings.scorm);
+      if (this.scormService.hasAPI()) {
+        const initResult = this.scormService.initialize();
+        if (initResult.success) {
+          this.quizResultState.scormStatus = "initialized";
+          this.quizResultState.studentName = initResult.studentName;
+        } else {
+          this.quizResultState.scormStatus = "error";
+          this.quizResultState.scormError = initResult.error || "SCORM initialization failed.";
+        }
+      } else {
+        this.quizResultState.scormStatus = "no_api";
+      }
+    }
+    const initialQ = this.getCurrentQuestion();
+    if (initialQ) {
+      this.questionStartTime = Date.now();
+    }
+    if (this.callbacks.onQuizStart) {
+      this.callbacks.onQuizStart({
+        initialQuestion: initialQ,
+        currentQuestionNumber: this.getCurrentQuestionNumber(),
+        totalQuestions: this.getTotalQuestions(),
+        timeLimitInSeconds: this.timeLeftInSeconds,
+        scormStatus: this.quizResultState.scormStatus,
+        studentName: this.quizResultState.studentName
+      });
+    }
+    if (this.timeLeftInSeconds !== null) {
+      this.startTimer();
+    }
+    (_e = (_d = this.callbacks).onQuestionChange) == null ? void 0 : _e.call(_d, initialQ, this.getCurrentQuestionNumber(), this.getTotalQuestions());
+  }
+  _recordCurrentQuestionTime() {
+    if (this.questionStartTime && this.currentQuestionIndex >= 0 && this.currentQuestionIndex < this.questions.length) {
+      const currentQId = this.questions[this.currentQuestionIndex].id;
+      const elapsedMs = Date.now() - this.questionStartTime;
+      const currentTotalTime = this.questionTimings.get(currentQId) || 0;
+      this.questionTimings.set(currentQId, currentTotalTime + elapsedMs / 1e3);
+    }
+    this.questionStartTime = null;
+  }
+  startTimer() {
+    if (this.timerId !== null) {
+      clearInterval(this.timerId);
+    }
+    this.timerId = setInterval(() => this.handleTick(), 1e3);
+  }
+  stopTimer() {
+    if (this.timerId !== null) {
+      clearInterval(this.timerId);
+      this.timerId = null;
+    }
+  }
+  handleTick() {
+    var _a, _b, _c, _d;
+    if (this.timeLeftInSeconds === null) return;
+    if (this.timeLeftInSeconds > 0) {
+      this.timeLeftInSeconds--;
+      (_b = (_a = this.callbacks).onTimeTick) == null ? void 0 : _b.call(_a, this.timeLeftInSeconds);
+    }
+    if (this.timeLeftInSeconds <= 0) {
+      this.stopTimer();
+      (_d = (_c = this.callbacks).onQuizTimeUp) == null ? void 0 : _d.call(_c);
+      this.calculateResults().then((results) => {
+      });
+    }
+  }
+  getTimeLeftInSeconds() {
+    return this.timeLeftInSeconds;
+  }
+  getCurrentQuestion() {
+    return this.questions[this.currentQuestionIndex] || null;
+  }
+  getCurrentQuestionNumber() {
+    return this.currentQuestionIndex + 1;
+  }
+  getTotalQuestions() {
+    return this.questions.length;
+  }
+  submitAnswer(questionId, answer) {
+    var _a, _b;
+    this.userAnswers.set(questionId, answer);
+    const question = this.questions.find((q) => q.id === questionId);
+    if (question) {
+      (_b = (_a = this.callbacks).onAnswerSubmit) == null ? void 0 : _b.call(_a, question, answer);
+    } else {
+      console.warn(`QuizEngine: Question with id ${questionId} not found for onAnswerSubmit.`);
+    }
+  }
+  getUserAnswer(questionId) {
+    return this.userAnswers.get(questionId);
+  }
+  nextQuestion() {
+    var _a, _b;
+    this._recordCurrentQuestionTime();
+    if (this.currentQuestionIndex < this.questions.length - 1) {
+      this.currentQuestionIndex++;
+      const currentQ = this.getCurrentQuestion();
+      this.questionStartTime = Date.now();
+      (_b = (_a = this.callbacks).onQuestionChange) == null ? void 0 : _b.call(_a, currentQ, this.getCurrentQuestionNumber(), this.getTotalQuestions());
+      return currentQ;
+    }
+    return null;
+  }
+  previousQuestion() {
+    var _a, _b;
+    this._recordCurrentQuestionTime();
+    if (this.currentQuestionIndex > 0) {
+      this.currentQuestionIndex--;
+      const currentQ = this.getCurrentQuestion();
+      this.questionStartTime = Date.now();
+      (_b = (_a = this.callbacks).onQuestionChange) == null ? void 0 : _b.call(_a, currentQ, this.getCurrentQuestionNumber(), this.getTotalQuestions());
+      return currentQ;
+    }
+    return null;
+  }
+  goToQuestion(index) {
+    var _a, _b;
+    if (index >= 0 && index < this.questions.length && index !== this.currentQuestionIndex) {
+      this._recordCurrentQuestionTime();
+      this.currentQuestionIndex = index;
+      const currentQ = this.getCurrentQuestion();
+      this.questionStartTime = Date.now();
+      (_b = (_a = this.callbacks).onQuestionChange) == null ? void 0 : _b.call(_a, currentQ, this.getCurrentQuestionNumber(), this.getTotalQuestions());
+      return currentQ;
+    }
+    return this.getCurrentQuestion();
+  }
+  isQuizFinished() {
+    return this.quizResultState.score !== void 0;
+  }
+  async _sendResultsToWebhook(results) {
+    var _a;
+    if (!((_a = this.config.settings) == null ? void 0 : _a.webhookUrl)) {
+      results.webhookStatus = "idle";
+      return;
+    }
+    results.webhookStatus = "sending";
+    try {
+      const response = await fetch(this.config.settings.webhookUrl, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify(results)
+      });
+      if (response.ok) {
+        results.webhookStatus = "success";
+      } else {
+        results.webhookStatus = "error";
+        results.webhookError = `Webhook returned status: ${response.status} ${response.statusText}`;
+        try {
+          const errorBody = await response.text();
+          results.webhookError += ` - Body: ${errorBody.substring(0, 200)}`;
+        } catch (e) {
+        }
+      }
+    } catch (error) {
+      results.webhookStatus = "error";
+      results.webhookError = error instanceof Error ? `Fetch error: ${error.message}` : "Unknown webhook error.";
+    }
+  }
+  _sendResultsToSCORM(results) {
+    var _a, _b, _c, _d, _e, _f, _g;
+    if (!this.scormService || !this.scormService.hasAPI() || this.quizResultState.scormStatus === "no_api") {
+      results.scormStatus = this.quizResultState.scormStatus || "idle";
+      return;
+    }
+    if (this.quizResultState.scormStatus === "error" && ((_a = this.quizResultState.scormError) == null ? void 0 : _a.includes("initialization failed"))) {
+      results.scormStatus = "error";
+      results.scormError = this.quizResultState.scormError;
+      return;
+    }
+    results.scormStatus = "sending_data";
+    try {
+      this.scormService.setScore(results.score, results.maxScore, 0);
+      let lessonStatusSetting = "completed";
+      if (((_b = this.config.settings) == null ? void 0 : _b.passingScorePercent) !== void 0 && ((_c = this.config.settings) == null ? void 0 : _c.passingScorePercent) !== null) {
+        lessonStatusSetting = results.passed ? "passed" : "failed";
+      } else if ((_e = (_d = this.config.settings) == null ? void 0 : _d.scorm) == null ? void 0 : _e.setCompletionOnFinish) {
+        lessonStatusSetting = "completed";
+      }
+      this.scormService.setLessonStatus(lessonStatusSetting, results.passed);
+      if (results.totalTimeSpentSeconds !== void 0 && this.scormService.formatCMITime) {
+        const cmiTime = this.scormService.formatCMITime(results.totalTimeSpentSeconds);
+        const sessionTimeVar = ((_g = (_f = this.config.settings) == null ? void 0 : _f.scorm) == null ? void 0 : _g.sessionTimeVar) || (this.scormService.getSCORMVersion() === "2004" ? "cmi.session_time" : "cmi.core.session_time");
+        if (sessionTimeVar) this.scormService.setValue(sessionTimeVar, cmiTime);
+      }
+      const commitResult = this.scormService.commit();
+      if (commitResult.success) {
+        results.scormStatus = "committed";
+      } else {
+        results.scormStatus = "error";
+        results.scormError = commitResult.error || "SCORM commit failed.";
+      }
+    } catch (e) {
+      results.scormStatus = "error";
+      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 === void 0 || key === null || key.trim() === "") 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) => {
+      const qResult = this.userAnswers.get(q.id);
+      const { isCorrect } = this.evaluateQuestion(q, qResult || null);
+      const pointsForThisQuestion = q.points !== void 0 ? q.points : 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 calculateResults() {
+    var _a, _b, _c, _d;
+    this.stopTimer();
+    this._recordCurrentQuestionTime();
+    let totalScore = 0;
+    let maxScore = 0;
+    const questionResultsArray = [];
+    let accumulatedTotalTimeSpent = 0;
+    for (const question of this.questions) {
+      const userAnswer = this.userAnswers.get(question.id) || null;
+      const questionPoints = question.points !== void 0 ? question.points : 0;
+      maxScore += questionPoints;
+      const { isCorrect, correctAnswer, pointsEarned } = this.evaluateQuestion(question, userAnswer);
+      totalScore += pointsEarned;
+      const timeSpentOnThisQuestion = parseFloat((this.questionTimings.get(question.id) || 0).toFixed(2));
+      accumulatedTotalTimeSpent += timeSpentOnThisQuestion;
+      questionResultsArray.push({
+        questionId: question.id,
+        isCorrect,
+        pointsEarned,
+        userAnswer,
+        correctAnswer,
+        timeSpentSeconds: timeSpentOnThisQuestion
+      });
+    }
+    const percentage = maxScore > 0 ? parseFloat((totalScore / maxScore * 100).toFixed(2)) : 0;
+    let passed = void 0;
+    if (((_a = this.config.settings) == null ? void 0 : _a.passingScorePercent) !== void 0 && this.config.settings.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 finalResults = __spreadValues({
+      score: totalScore,
+      maxScore,
+      percentage,
+      answers: this.userAnswers,
+      questionResults: questionResultsArray,
+      passed,
+      webhookStatus: "idle",
+      scormStatus: this.quizResultState.scormStatus || "idle",
+      scormError: this.quizResultState.scormError,
+      studentName: this.quizResultState.studentName,
+      totalTimeSpentSeconds: totalQuizTimeSpentSeconds,
+      averageTimePerQuestionSeconds
+    }, metadataPerformance);
+    this.quizResultState = __spreadValues(__spreadValues({}, this.quizResultState), finalResults);
+    if ((_b = this.config.settings) == null ? void 0 : _b.scorm) {
+      this._sendResultsToSCORM(finalResults);
+    }
+    await this._sendResultsToWebhook(finalResults);
+    (_d = (_c = this.callbacks).onQuizFinish) == null ? void 0 : _d.call(_c, finalResults);
+    return finalResults;
+  }
+  evaluateQuestion(question, answer) {
+    let isCorrect = false;
+    let correctAnswerValue = null;
+    const points = question.points !== void 0 ? question.points : 0;
+    switch (question.questionType) {
+      case "multiple_choice":
+        correctAnswerValue = question.correctAnswerId;
+        isCorrect = answer === correctAnswerValue;
+        break;
+      case "multiple_response":
+        const mrq = question;
+        correctAnswerValue = mrq.correctAnswerIds;
+        if (Array.isArray(answer) && Array.isArray(correctAnswerValue)) {
+          const userAnswerSet = new Set(answer);
+          const correctAnswerSet = new Set(correctAnswerValue);
+          isCorrect = userAnswerSet.size === correctAnswerSet.size && [...userAnswerSet].every((id) => correctAnswerSet.has(id));
+        }
+        break;
+      case "fill_in_the_blanks":
+        const fitbq = question;
+        correctAnswerValue = {};
+        fitbq.answers.forEach((ans) => {
+          correctAnswerValue[ans.blankId] = ans.acceptedValues;
+        });
+        if (typeof answer === "object" && answer !== null && !Array.isArray(answer)) {
+          const userAnswerMap = answer;
+          isCorrect = fitbq.answers.every((correctAnsDef) => {
+            var _a;
+            const userValForBlank = (_a = userAnswerMap[correctAnsDef.blankId]) == null ? void 0 : _a.trim();
+            const acceptedValsForBlank = correctAnsDef.acceptedValues.map((v) => v.trim());
+            const caseSensitive = fitbq.isCaseSensitive === void 0 ? false : fitbq.isCaseSensitive;
+            if (userValForBlank === void 0) return false;
+            return caseSensitive ? acceptedValsForBlank.some((accVal) => accVal === userValForBlank) : acceptedValsForBlank.some((accVal) => accVal.toLowerCase() === userValForBlank.toLowerCase());
+          });
+        }
+        break;
+      case "drag_and_drop":
+        const dndq = question;
+        correctAnswerValue = {};
+        dndq.answerMap.forEach((map) => {
+          correctAnswerValue[map.draggableId] = map.dropZoneId;
+        });
+        if (typeof answer === "object" && answer !== null && !Array.isArray(answer)) {
+          const userAnswerMap = answer;
+          const correctPairsCount = dndq.answerMap.length;
+          isCorrect = dndq.answerMap.every((map) => userAnswerMap[map.draggableId] === map.dropZoneId) && Object.keys(userAnswerMap).length === correctPairsCount;
+        }
+        break;
+      case "true_false":
+        const tfq = question;
+        correctAnswerValue = tfq.correctAnswer;
+        let tfAnswer = answer;
+        if (typeof answer === "string") tfAnswer = answer.toLowerCase() === "true";
+        if (typeof tfAnswer === "boolean") isCorrect = tfAnswer === tfq.correctAnswer;
+        break;
+      case "short_answer":
+        const saq = question;
+        correctAnswerValue = saq.acceptedAnswers;
+        if (typeof answer === "string") {
+          const userAnswerTrimmed = answer.trim();
+          const caseSensitive = saq.isCaseSensitive === void 0 ? false : saq.isCaseSensitive;
+          isCorrect = saq.acceptedAnswers.some((accAns) => caseSensitive ? accAns.trim() === userAnswerTrimmed : accAns.trim().toLowerCase() === userAnswerTrimmed.toLowerCase());
+        }
+        break;
+      case "numeric":
+        const nq = question;
+        correctAnswerValue = { answer: nq.answer, tolerance: nq.tolerance };
+        if (typeof answer === "string" || typeof answer === "number") {
+          const userAnswerNum = parseFloat(String(answer));
+          if (!isNaN(userAnswerNum)) {
+            isCorrect = nq.tolerance !== void 0 && nq.tolerance !== null ? Math.abs(userAnswerNum - nq.answer) <= nq.tolerance : userAnswerNum === nq.answer;
+          }
+        }
+        break;
+      case "sequence":
+        const seqQ = question;
+        correctAnswerValue = seqQ.correctOrder;
+        if (Array.isArray(answer) && Array.isArray(seqQ.correctOrder) && answer.length === seqQ.correctOrder.length) {
+          isCorrect = answer.every((itemId, index) => itemId === seqQ.correctOrder[index]);
+        }
+        break;
+      case "matching":
+        const matQ = question;
+        correctAnswerValue = matQ.correctAnswerMap.reduce((acc, curr) => {
+          acc[curr.promptId] = curr.optionId;
+          return acc;
+        }, {});
+        if (typeof answer === "object" && answer !== null && !Array.isArray(answer)) {
+          const userAnswerMap = answer;
+          const correctMapPairsCount = matQ.correctAnswerMap.length;
+          isCorrect = matQ.correctAnswerMap.every((map) => userAnswerMap[map.promptId] === map.optionId) && Object.keys(userAnswerMap).length === correctMapPairsCount;
+        }
+        break;
+      case "hotspot":
+        const hsQ = question;
+        correctAnswerValue = hsQ.correctHotspotIds;
+        if (typeof answer === "string") {
+          isCorrect = hsQ.correctHotspotIds.includes(answer);
+        } else if (Array.isArray(answer)) {
+          const userAnswerSet = new Set(answer);
+          const correctAnswerSet = new Set(hsQ.correctHotspotIds);
+          isCorrect = userAnswerSet.size === correctAnswerSet.size && [...userAnswerSet].every((id) => correctAnswerSet.has(id));
+        }
+        break;
+      case "blockly_programming":
+      case "scratch_programming":
+        const progQ = question;
+        correctAnswerValue = progQ.solutionGeneratedCode;
+        if (typeof answer === "string" && typeof correctAnswerValue === "string") {
+          if (typeof window !== "undefined" && window.Blockly) {
+            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) || "";
+              generatedUserCode = generatedUserCode.split("\\n").map((line) => line.trim()).filter((line) => line.length > 0).join("\\n");
+              tempWorkspace.dispose();
+            } catch (e) {
+              console.error(`Error generating code from user's ${progQ.questionType} XML for evaluation:`, e);
+              generatedUserCode = `Error generating code: ${e}`;
+            }
+            isCorrect = generatedUserCode === correctAnswerValue;
+          } else {
+            console.warn(`Blockly library not available in QuizEngine for ${progQ.questionType} code generation during evaluation. XML will be stored, but code comparison skipped.`);
+            isCorrect = false;
+          }
+        } else {
+          isCorrect = false;
+        }
+        break;
+      default:
+        const _exhaustiveCheck = question;
+        console.warn("Unsupported question type in QuizEngine evaluation:", _exhaustiveCheck);
+        isCorrect = false;
+    }
+    return { isCorrect, correctAnswer: correctAnswerValue, pointsEarned: isCorrect ? points : 0 };
+  }
+  getElapsedTime() {
+    return Date.now() - this.overallStartTime;
+  }
+  destroy() {
+    this.stopTimer();
+    this._recordCurrentQuestionTime();
+    if (this.scormService && this.scormService.hasAPI()) {
+      if (this.quizResultState.scormStatus === "initialized" || this.quizResultState.scormStatus === "committed" || this.quizResultState.scormStatus === "sending_data") {
+        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/services/HTMLLauncherGenerator.ts
+var escapeAttribute = (unsafe) => {
+  if (typeof unsafe !== "string") return "";
+  return unsafe.replace(/"/g, "&quot;");
+};
+var generateLauncherHTML = (quizConfig, libraryJSPath = "lib/interactive-quiz-kit.esm.js", quizDataPath = "quiz_data.json", blocklyCSSPath = "blockly-styles.css", title) => {
+  const pageTitle = escapeAttribute(title || quizConfig.title || "Interactive Quiz");
+  const relLibraryJSPath = libraryJSPath.startsWith("./") ? libraryJSPath : `./${libraryJSPath}`;
+  const relQuizDataPath = quizDataPath.startsWith("./") ? quizDataPath : `./${quizDataPath}`;
+  const relBlocklyCSSPath = blocklyCSSPath.startsWith("./") ? blocklyCSSPath : `./${blocklyCSSPath}`;
+  return `<!DOCTYPE html>
+<html lang="en">
+<head>
+  <meta charset="UTF-8">
+  <meta name="viewport" content="width=device-width, initial-scale=1.0">
+  <title>${pageTitle}</title>
+  <style>
+    body { margin: 0; font-family: -apple-system, BlinkMacSystemFont, "Segoe UI", Roboto, Helvetica, Arial, sans-serif, "Apple Color Emoji", "Segoe UI Emoji", "Segoe UI Symbol"; background-color: #f0f2f5; color: #1f2937; display: flex; justify-content: center; align-items: flex-start; min-height: 100vh; padding-top: 20px; box-sizing: border-box; }
+    #root { width: 100%; max-width: 900px; background-color: #ffffff; border-radius: 8px; box-shadow: 0 4px 6px rgba(0,0,0,0.1); padding: 20px; }
+    .loading-spinner {
+      border: 4px solid #e5e7eb; border-top: 4px solid #3b82f6; 
+      border-radius: 50%; width: 40px; height: 40px;
+      animation: spin 1s linear infinite;
+      margin: 60px auto 20px auto;
+    }
+    @keyframes spin { 0% { transform: rotate(0deg); } 100% { transform: rotate(360deg); } }
+    .status-message { text-align: center; padding: 20px; margin-top: 10px; color: #4b5563; }
+    /* Basic button styling for exit (if QuizPlayer doesn't provide one post-completion) */
+    .exit-button { display: block; margin: 20px auto; padding: 10px 20px; background-color: #3b82f6; color: white; border: none; border-radius: 4px; cursor: pointer; font-size: 16px; }
+    .exit-button:hover { background-color: #2563eb; }
+  </style>
+  <link rel="stylesheet" href="${escapeAttribute(relBlocklyCSSPath)}">
+  <script type="importmap">
+  {
+    "imports": {
+      "react": "https://esm.sh/react@18.3.1",
+      "react-dom/client": "https://esm.sh/react-dom@18.3.1/client"
+    }
+  }
+  </script>
+</head>
+<body>
+  <div id="root">
+    <div class="loading-spinner" aria-label="Loading quiz content"></div>
+    <p class="status-message" role="status">Loading Quiz...</p>
+  </div>
+
+  <script type="module">
+    import React from 'react';
+    import ReactDOM from 'react-dom/client';
+    // The library path must be relative to this HTML file within the SCORM package
+    import { QuizPlayer } from '${escapeAttribute(relLibraryJSPath)}';
+
+    async function loadQuizData() {
+      try {
+        // quizDataPath is relative to this HTML file
+        const response = await fetch('${escapeAttribute(relQuizDataPath)}');
+        if (!response.ok) {
+          throw new Error('Failed to load quiz data: Status ' + response.status + ' - ' + response.statusText + '. Ensure quiz_data.json is in the same directory as the launcher HTML or the path is correct.');
+        }
+        return await response.json();
+      } catch (error) {
+        console.error("Error loading quiz data:", error);
+        showStatusMessage('Error: Could not load quiz configuration. ' + error.message, true);
+        return null;
+      }
+    }
+    
+    function showStatusMessage(message, isError = false) {
+        const rootEl = document.getElementById('root');
+        if (rootEl) {
+            rootEl.innerHTML = ''; // Clear previous content (like spinner)
+            const messageEl = document.createElement('p');
+            messageEl.textContent = message;
+            messageEl.className = 'status-message';
+            if(isError) {
+              messageEl.style.color = '#ef4444'; // Red for errors
+              messageEl.setAttribute('role', 'alert');
+            } else {
+              messageEl.setAttribute('role', 'status');
+            }
+            rootEl.appendChild(messageEl);
+        }
+    }
+
+    function showCompletionScreen(message) {
+      const rootEl = document.getElementById('root');
+      if (rootEl) {
+        rootEl.innerHTML = ''; // Clear quiz player
+        const messageEl = document.createElement('p');
+        messageEl.textContent = message;
+        messageEl.className = 'status-message';
+        rootEl.appendChild(messageEl);
+
+        // Optional: Add a manual close button if LMS doesn't handle it or for testing
+        // const closeButton = document.createElement('button');
+        // closeButton.textContent = 'Close Quiz';
+        // closeButton.className = 'exit-button';
+        // closeButton.onclick = () => {
+        //   try { window.close(); } catch(e) { console.warn("Could not close window programmatically."); }
+        //   // SCORM termination should have happened in QuizPlayer/QuizEngine
+        // };
+        // rootEl.appendChild(closeButton);
+      }
+    }
+
+    async function main() {
+      const quizConfigData = await loadQuizData();
+      if (!quizConfigData) {
+        return; // Error message already shown by loadQuizData
+      }
+
+      // Check if QuizPlayer is available
+      if (typeof QuizPlayer !== 'function') {
+        showStatusMessage('Error: QuizPlayer component not found. Check library bundle.', true);
+        return;
+      }
+
+      const App = () => {
+        const handleQuizComplete = (result) => {
+          console.log("Quiz Complete (SCORM Launcher):", result);
+          let completionMessage = 'Quiz completed. ';
+          if (result.passed !== undefined) {
+            completionMessage += result.passed ? 'You passed!' : 'You did not pass.';
+          }
+          completionMessage += ' You may now close this window, or your Learning Management System will manage navigation.';
+          showCompletionScreen(completionMessage);
+          // SCORM termination logic should be handled by QuizEngine/QuizPlayer via SCORMService.destroy()
+        };
+
+        const handleExitQuiz = () => {
+          console.log("Quiz Exited (SCORM Launcher)");
+          showCompletionScreen('Quiz exited. You may close this window or your Learning Management System will manage navigation.');
+          // SCORM termination logic should be handled by QuizEngine/QuizPlayer via SCORMService.destroy()
+        };
+        
+        // Fallback if quizConfigData is malformed but loaded
+        if (!quizConfigData.questions || !Array.isArray(quizConfigData.questions)) {
+            showStatusMessage('Error: Quiz data is malformed. "questions" array is missing.', true);
+            return React.createElement('div', null, 'Error rendering quiz.');
+        }
+
+
+        return React.createElement(QuizPlayer, {
+          quizConfig: quizConfigData,
+          onQuizComplete: handleQuizComplete,
+          onExitQuiz: handleExitQuiz,
+          // You might pass isScormContext=true if QuizPlayer needs it
+        });
+      };
+
+      const rootElement = document.getElementById('root');
+      if (rootElement) {
+        rootElement.innerHTML = ''; // Clear loading message before rendering React app
+        const reactRoot = ReactDOM.createRoot(rootElement);
+        reactRoot.render(React.createElement(React.StrictMode, null, React.createElement(App)));
+      } else {
+        console.error('Root element (#root) not found for SCORM launcher.');
+        document.body.innerHTML = '<p style="color: red; text-align: center; padding: 20px;">Critical Error: Root HTML element not found.</p>';
+      }
+    }
+
+    // Ensure DOM is ready before trying to find #root
+    if (document.readyState === 'loading') {
+      document.addEventListener('DOMContentLoaded', main);
+    } else {
+      main();
+    }
+  </script>
+</body>
+</html>
+`;
+};
+
+// src/services/SCORMManifestGenerator.ts
+var escapeXML = (unsafe) => {
+  if (typeof unsafe !== "string") return "";
+  return unsafe.replace(/[<>&'"]/g, (c) => {
+    switch (c) {
+      case "<":
+        return "&lt;";
+      case ">":
+        return "&gt;";
+      case "&":
+        return "&amp;";
+      case "'":
+        return "&apos;";
+      case '"':
+        return "&quot;";
+      default:
+        return c;
+    }
+  });
+};
+var generateSCORMManifest = (quizConfig, scormVersion, launcherFile = "index.html", libraryJSPath = "lib/interactive-quiz-kit.esm.js", quizDataPath = "quiz_data.json", blocklyCSSPath = "blockly-styles.css") => {
+  var _a;
+  const uniqueId = `iqk_${quizConfig.id.replace(/[^a-zA-Z0-9_]/g, "_")}`;
+  const organizationId = `ORG-${uniqueId}`;
+  const itemId = `ITEM-${uniqueId}`;
+  const resourceId = `RES-${uniqueId}`;
+  const quizTitle = escapeXML(quizConfig.title);
+  const passingScore = (_a = quizConfig.settings) == null ? void 0 : _a.passingScorePercent;
+  const effectiveScormVersion = scormVersion;
+  const schemaVersion = effectiveScormVersion === "2004" ? "2004 4th Edition" : "1.2";
+  const adlcpNamespace = effectiveScormVersion === "2004" ? "http://www.adlnet.org/xsd/adlcp_v1p3" : "http://www.adlnet.org/xsd/adlcp_rootv1p2";
+  const imsmdNamespace = effectiveScormVersion === "2004" ? "http://www.imsglobal.org/xsd/imsmd_v1p2" : "http://www.imsglobal.org/xsd/imsmd_rootv1p2p1";
+  const xsiSchemaLocation = effectiveScormVersion === "2004" ? "http://www.imsglobal.org/xsd/imscp_v1p1 imscp_v1p1.xsd http://www.adlnet.org/xsd/adlcp_v1p3 adlcp_v1p3.xsd http://www.imsglobal.org/xsd/imsmd_v1p2 imsmd_v1p2p2.xsd" : "http://www.imsglobal.org/xsd/imscp_v1p1 imscp_v1p1.xsd http://www.adlnet.org/xsd/adlcp_rootv1p2 adlcp_rootv1p2.xsd http://www.imsglobal.org/xsd/imsmd_rootv1p2p1 imsmd_rootv1p2p1.xsd";
+  const files = [
+    launcherFile,
+    libraryJSPath,
+    quizDataPath,
+    blocklyCSSPath
+  ].map((file) => `<file href="${escapeXML(file)}"/>`).join("\n      ");
+  const manifestHeader = effectiveScormVersion === "2004" ? `<?xml version="1.0" encoding="UTF-8"?>
+<manifest identifier="${uniqueId}-MANIFEST" version="1.0" 
+          xmlns="http://www.imsglobal.org/xsd/imscp_v1p1"
+          xmlns:adlcp="${adlcpNamespace}"
+          xmlns:imsmd="${imsmdNamespace}"
+          xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+          xsi:schemaLocation="${xsiSchemaLocation}">` : (
+    // SCORM 1.2
+    `<?xml version="1.0" encoding="UTF-8"?>
+<manifest identifier="${uniqueId}-MANIFEST" version="1.2" 
+          xmlns="http://www.imsproject.org/xsd/imscp_rootv1p1p2"
+          xmlns:adlcp="${adlcpNamespace}"
+          xmlns:imsmd="${imsmdNamespace}"
+          xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+          xsi:schemaLocation="${xsiSchemaLocation}">`
+  );
+  const organizationStructure = effectiveScormVersion === "2004" ? `<organizations default="${organizationId}">
+    <organization identifier="${organizationId}" structure="hierarchical">
+      <title>${quizTitle}</title>
+      <item identifier="${itemId}" identifierref="${resourceId}">
+        <title>${quizTitle}</title>
+        ${passingScore !== void 0 ? `<adlcp:masteryscore>${passingScore}</adlcp:masteryscore>` : ""}
+      </item>
+    </organization>
+  </organizations>` : (
+    // SCORM 1.2
+    `<organizations default="${organizationId}">
+    <organization identifier="${organizationId}">
+      <title>${quizTitle}</title>
+      <item identifier="${itemId}" identifierref="${resourceId}" isvisible="true">
+        <title>${quizTitle}</title>
+        ${passingScore !== void 0 ? `<adlcp:masteryscore>${passingScore}</adlcp:masteryscore>` : ""}
+      </item>
+    </organization>
+  </organizations>`
+  );
+  const resourceScormType = effectiveScormVersion === "2004" ? "sco" : "sco";
+  return `${manifestHeader}
+  <metadata>
+    <schema>ADL SCORM</schema>
+    <schemaversion>${schemaVersion}</schemaversion>
+    <imsmd:lom>
+      <imsmd:general>
+        <imsmd:title>
+          <imsmd:langstring xml:lang="en">${quizTitle}</imsmd:langstring>
+        </imsmd:title>
+        ${quizConfig.description ? `<imsmd:description><imsmd:langstring xml:lang="en">${escapeXML(quizConfig.description)}</imsmd:langstring></imsmd:description>` : ""}
+      </imsmd:general>
+    </imsmd:lom>
+  </metadata>
+  ${organizationStructure}
+  <resources>
+    <resource identifier="${resourceId}" type="webcontent" adlcp:scormtype="${resourceScormType}" href="${escapeXML(launcherFile)}">
+      ${files}
+    </resource>
+  </resources>
+</manifest>`;
+};
+
+// src/utils/idGenerators.ts
+function generateUniqueId(prefix = "id_") {
+  return prefix + Date.now().toString(36) + Math.random().toString(36).substring(2, 7);
+}
+
+// src/services/sampleQuiz.ts
+var trueFalseQ1 = {
+  id: generateUniqueId("tfq_"),
+  questionType: "true_false",
+  prompt: "B\u1EA7u tr\u1EDDi c\xF3 m\xE0u xanh do hi\u1EC7n t\u01B0\u1EE3ng t\xE1n x\u1EA1 Rayleigh.",
+  correctAnswer: true,
+  points: 10,
+  explanation: "T\xE1n x\u1EA1 Rayleigh khi\u1EBFn \xE1nh s\xE1ng xanh t\xE1n x\u1EA1 nhi\u1EC1u h\u01A1n c\xE1c m\xE0u kh\xE1c v\xEC n\xF3 truy\u1EC1n \u0111i d\u01B0\u1EDBi d\u1EA1ng s\xF3ng ng\u1EAFn h\u01A1n, nh\u1ECF h\u01A1n.",
+  difficulty: "easy",
+  topic: "V\u1EADt l\xFD",
+  category: "Khoa h\u1ECDc",
+  learningObjective: "Hi\u1EC3u v\u1EC1 quang h\u1ECDc kh\xED quy\u1EC3n c\u01A1 b\u1EA3n."
+};
+var mcq1 = {
+  id: generateUniqueId("mcq_"),
+  questionType: "multiple_choice",
+  prompt: "Th\u1EE7 \u0111\xF4 c\u1EE7a Ph\xE1p l\xE0 g\xEC?",
+  options: [
+    { id: generateUniqueId("opt_"), text: "Berlin" },
+    { id: generateUniqueId("opt_"), text: "Madrid" },
+    { id: generateUniqueId("opt_"), text: "Paris" },
+    { id: generateUniqueId("opt_"), text: "Rome" }
+  ],
+  correctAnswerId: "",
+  points: 15,
+  difficulty: "easy",
+  topic: "\u0110\u1ECBa l\xFD",
+  category: "Khoa h\u1ECDc X\xE3 h\u1ED9i"
+};
+var parisOption = mcq1.options.find((opt) => opt.text === "Paris");
+if (parisOption) {
+  mcq1.correctAnswerId = parisOption.id;
+}
+var mrq1_opt1_id = generateUniqueId("opt_");
+var mrq1_opt2_id = generateUniqueId("opt_");
+var mrq1_opt3_id = generateUniqueId("opt_");
+var mrq1_opt4_id = generateUniqueId("opt_");
+var mrq1_opt5_id = generateUniqueId("opt_");
+var mrq1 = {
+  id: generateUniqueId("mrq_"),
+  questionType: "multiple_response",
+  prompt: "Nh\u1EEFng h\xE0nh tinh n\xE0o sau \u0111\xE2y thu\u1ED9c H\u1EC7 M\u1EB7t Tr\u1EDDi c\xF3 v\xE0nh \u0111ai (rings)?",
+  options: [
+    { id: mrq1_opt1_id, text: "Sao Th\u1ED5 (Saturn)" },
+    { id: mrq1_opt2_id, text: "Sao M\u1ED9c (Jupiter)" },
+    { id: mrq1_opt3_id, text: "Sao Thi\xEAn V\u01B0\u01A1ng (Uranus)" },
+    { id: mrq1_opt4_id, text: "Sao H\u1EA3i V\u01B0\u01A1ng (Neptune)" },
+    { id: mrq1_opt5_id, text: "Tr\xE1i \u0110\u1EA5t (Earth)" }
+  ],
+  correctAnswerIds: [mrq1_opt1_id, mrq1_opt2_id, mrq1_opt3_id, mrq1_opt4_id],
+  points: 20,
+  explanation: "Sao Th\u1ED5 n\u1ED5i ti\u1EBFng v\u1EDBi h\u1EC7 th\u1ED1ng v\xE0nh \u0111ai ph\u1EE9c t\u1EA1p. Sao M\u1ED9c, Sao Thi\xEAn V\u01B0\u01A1ng v\xE0 Sao H\u1EA3i V\u01B0\u01A1ng c\u0169ng c\xF3 v\xE0nh \u0111ai, m\u1EB7c d\xF9 ch\xFAng m\u1EDD h\u01A1n v\xE0 kh\xF3 quan s\xE1t h\u01A1n nhi\u1EC1u so v\u1EDBi v\xE0nh \u0111ai c\u1EE7a Sao Th\u1ED5.",
+  difficulty: "medium",
+  topic: "Thi\xEAn v\u0103n h\u1ECDc",
+  category: "Khoa h\u1ECDc"
+};
+var shortAnswerQ1 = {
+  id: generateUniqueId("saq_"),
+  questionType: "short_answer",
+  prompt: "Ng\xF4n ng\u1EEF l\u1EADp tr\xECnh n\xE0o th\u01B0\u1EDDng \u0111\u01B0\u1EE3c s\u1EED d\u1EE5ng ch\u1EE7 y\u1EBFu cho ph\xE1t tri\u1EC3n web ph\xEDa client-side \u0111\u1EC3 l\xE0m cho c\xE1c trang web tr\u1EDF n\xEAn t\u01B0\u01A1ng t\xE1c?",
+  acceptedAnswers: ["JavaScript", "Javascript", "javascript", "JS", "js"],
+  points: 10,
+  explanation: "JavaScript l\xE0 ng\xF4n ng\u1EEF k\u1ECBch b\u1EA3n ch\xEDnh ch\u1EA1y tr\xEAn tr\xECnh duy\u1EC7t c\u1EE7a ng\u01B0\u1EDDi d\xF9ng \u0111\u1EC3 t\u1EA1o ra c\xE1c trang web t\u01B0\u01A1ng t\xE1c.",
+  difficulty: "easy",
+  topic: "Ph\xE1t tri\u1EC3n Web",
+  category: "C\xF4ng ngh\u1EC7",
+  isCaseSensitive: false
+};
+var numericQ1 = {
+  id: generateUniqueId("nq_"),
+  questionType: "numeric",
+  prompt: "Nhi\u1EC7t \u0111\u1ED9 s\xF4i c\u1EE7a n\u01B0\u1EDBc \u1EDF \xE1p su\u1EA5t kh\xED quy\u1EC3n ti\xEAu chu\u1EA9n l\xE0 bao nhi\xEAu \u0111\u1ED9 C?",
+  answer: 100,
+  tolerance: 1,
+  points: 10,
+  explanation: "N\u01B0\u1EDBc s\xF4i \u1EDF 100 \u0111\u1ED9 C (212 \u0111\u1ED9 F) \u1EDF \xE1p su\u1EA5t kh\xED quy\u1EC3n ti\xEAu chu\u1EA9n.",
+  difficulty: "easy",
+  topic: "H\xF3a h\u1ECDc",
+  category: "Khoa h\u1ECDc"
+};
+var fillInTheBlanksQ1 = {
+  id: generateUniqueId("fitb_"),
+  questionType: "fill_in_the_blanks",
+  prompt: "\u0110i\u1EC1n v\xE0o ch\u1ED7 tr\u1ED1ng \u0111\u1EC3 ho\xE0n th\xE0nh c\xE2u sau:",
+  segments: [
+    { type: "text", content: "N\u01B0\u1EDBc \u0111\u01B0\u1EE3c c\u1EA5u t\u1EA1o t\u1EEB hai nguy\xEAn t\u1ED1 l\xE0 " },
+    { type: "blank", id: "fitb_h" },
+    { type: "text", content: " v\xE0 " },
+    { type: "blank", id: "fitb_o" },
+    { type: "text", content: "." }
+  ],
+  answers: [
+    { blankId: "fitb_h", acceptedValues: ["Hydro", "Hydrogen", "H"] },
+    { blankId: "fitb_o", acceptedValues: ["Oxy", "Oxygen", "O"] }
+  ],
+  isCaseSensitive: false,
+  points: 15,
+  explanation: "N\u01B0\u1EDBc (H\u2082O) \u0111\u01B0\u1EE3c t\u1EA1o th\xE0nh t\u1EEB hai nguy\xEAn t\u1EED Hydro v\xE0 m\u1ED9t nguy\xEAn t\u1EED Oxy.",
+  difficulty: "easy",
+  topic: "H\xF3a h\u1ECDc C\u01A1 b\u1EA3n",
+  category: "Khoa h\u1ECDc"
+};
+var sequenceQ1_item1_id = generateUniqueId("seqi_");
+var sequenceQ1_item2_id = generateUniqueId("seqi_");
+var sequenceQ1_item3_id = generateUniqueId("seqi_");
+var sequenceQ1_item4_id = generateUniqueId("seqi_");
+var sequenceQ1 = {
+  id: generateUniqueId("seqq_"),
+  questionType: "sequence",
+  prompt: "S\u1EAFp x\u1EBFp c\xE1c h\xE0nh tinh sau theo th\u1EE9 t\u1EF1 t\u1EEB g\u1EA7n M\u1EB7t Tr\u1EDDi nh\u1EA5t \u0111\u1EBFn xa nh\u1EA5t:",
+  items: [
+    { id: sequenceQ1_item1_id, content: "Sao H\u1ECFa (Mars)" },
+    { id: sequenceQ1_item2_id, content: "Tr\xE1i \u0110\u1EA5t (Earth)" },
+    { id: sequenceQ1_item3_id, content: "Sao Th\u1EE7y (Mercury)" },
+    { id: sequenceQ1_item4_id, content: "Sao Kim (Venus)" }
+  ],
+  correctOrder: [sequenceQ1_item3_id, sequenceQ1_item4_id, sequenceQ1_item2_id, sequenceQ1_item1_id],
+  points: 20,
+  explanation: "Th\u1EE9 t\u1EF1 \u0111\xFAng c\u1EE7a c\xE1c h\xE0nh tinh t\u1EEB g\u1EA7n M\u1EB7t Tr\u1EDDi nh\u1EA5t l\xE0: Sao Th\u1EE7y, Sao Kim, Tr\xE1i \u0110\u1EA5t, Sao H\u1ECFa.",
+  difficulty: "medium",
+  topic: "Thi\xEAn v\u0103n h\u1ECDc",
+  category: "Khoa h\u1ECDc"
+};
+var matchingQ1_prompt_vn = generateUniqueId("matp_");
+var matchingQ1_prompt_jp = generateUniqueId("matp_");
+var matchingQ1_prompt_us = generateUniqueId("matp_");
+var matchingQ1_opt_hanoi = generateUniqueId("mato_");
+var matchingQ1_opt_tokyo = generateUniqueId("mato_");
+var matchingQ1_opt_dc = generateUniqueId("mato_");
+var matchingQ1 = {
+  id: generateUniqueId("matq_"),
+  questionType: "matching",
+  prompt: "H\xE3y gh\xE9p m\u1ED7i qu\u1ED1c gia v\u1EDBi th\u1EE7 \u0111\xF4 t\u01B0\u01A1ng \u1EE9ng.",
+  prompts: [
+    { id: matchingQ1_prompt_vn, content: "Vi\u1EC7t Nam" },
+    { id: matchingQ1_prompt_jp, content: "Nh\u1EADt B\u1EA3n" },
+    { id: matchingQ1_prompt_us, content: "Hoa K\u1EF3" }
+  ],
+  options: [
+    { id: matchingQ1_opt_tokyo, content: "Tokyo" },
+    { id: matchingQ1_opt_hanoi, content: "H\xE0 N\u1ED9i" },
+    { id: matchingQ1_opt_dc, content: "Washington D.C." }
+  ],
+  correctAnswerMap: [
+    { promptId: matchingQ1_prompt_vn, optionId: matchingQ1_opt_hanoi },
+    { promptId: matchingQ1_prompt_jp, optionId: matchingQ1_opt_tokyo },
+    { promptId: matchingQ1_prompt_us, optionId: matchingQ1_opt_dc }
+  ],
+  points: 15,
+  explanation: "H\xE0 N\u1ED9i l\xE0 th\u1EE7 \u0111\xF4 c\u1EE7a Vi\u1EC7t Nam, Tokyo l\xE0 c\u1EE7a Nh\u1EADt B\u1EA3n, v\xE0 Washington D.C. l\xE0 c\u1EE7a Hoa K\u1EF3.",
+  difficulty: "easy",
+  topic: "\u0110\u1ECBa l\xFD Th\u1EBF gi\u1EDBi",
+  shuffleOptions: true
+};
+var dndQ1_drag_apple = generateUniqueId("dndi_");
+var dndQ1_drag_banana = generateUniqueId("dndi_");
+var dndQ1_drag_orange = generateUniqueId("dndi_");
+var dndQ1_drop_red = generateUniqueId("dndz_");
+var dndQ1_drop_yellow = generateUniqueId("dndz_");
+var dndQ1_drop_orange_color = generateUniqueId("dndz_");
+var dragAndDropQ1 = {
+  id: generateUniqueId("dndq_"),
+  questionType: "drag_and_drop",
+  prompt: "K\xE9o c\xE1c lo\u1EA1i tr\xE1i c\xE2y v\xE0o \u0111\xFAng gi\u1ECF m\xE0u c\u1EE7a ch\xFAng (theo logic gh\xE9p n\u1ED1i \u0111\u01A1n gi\u1EA3n).",
+  draggableItems: [
+    { id: dndQ1_drag_apple, content: "T\xE1o" },
+    { id: dndQ1_drag_banana, content: "Chu\u1ED1i" },
+    { id: dndQ1_drag_orange, content: "Cam" }
+  ],
+  dropZones: [
+    { id: dndQ1_drop_red, label: "Gi\u1ECF \u0110\u1ECF" },
+    { id: dndQ1_drop_yellow, label: "Gi\u1ECF V\xE0ng" },
+    { id: dndQ1_drop_orange_color, label: "Gi\u1ECF Cam" }
+  ],
+  answerMap: [
+    { draggableId: dndQ1_drag_apple, dropZoneId: dndQ1_drop_red },
+    { draggableId: dndQ1_drag_banana, dropZoneId: dndQ1_drop_yellow },
+    { draggableId: dndQ1_drag_orange, dropZoneId: dndQ1_drop_orange_color }
+  ],
+  points: 15,
+  explanation: "T\xE1o th\u01B0\u1EDDng c\xF3 m\xE0u \u0111\u1ECF (gi\u1ECF \u0111\u1ECF), chu\u1ED1i m\xE0u v\xE0ng (gi\u1ECF v\xE0ng), v\xE0 cam c\xF3 m\xE0u cam (gi\u1ECF cam).",
+  difficulty: "easy",
+  topic: "M\xE0u s\u1EAFc v\xE0 V\u1EADt th\u1EC3",
+  backgroundImageUrl: "https://placehold.co/600x200.png",
+  imageAltText: "colored baskets"
+};
+var hotspotQ1_engine_left = generateUniqueId("hs_");
+var hotspotQ1_engine_right = generateUniqueId("hs_");
+var hotspotQ1_cockpit = generateUniqueId("hs_");
+var hotspotQ1 = {
+  id: generateUniqueId("hsq_"),
+  questionType: "hotspot",
+  prompt: "Nh\u1EA5p v\xE0o (c\xE1c) \u0111\u1ED9ng c\u01A1 c\u1EE7a m\xE1y bay trong h\xECnh.",
+  imageUrl: "https://placehold.co/600x400.png",
+  imageAltText: "airplane diagram",
+  hotspots: [
+    { id: hotspotQ1_engine_left, shape: "rect", coords: [150, 200, 80, 60], description: "\u0110\u1ED9ng c\u01A1 b\xEAn tr\xE1i" },
+    { id: hotspotQ1_engine_right, shape: "rect", coords: [370, 200, 80, 60], description: "\u0110\u1ED9ng c\u01A1 b\xEAn ph\u1EA3i" },
+    { id: hotspotQ1_cockpit, shape: "rect", coords: [250, 120, 100, 70], description: "Bu\u1ED3ng l\xE1i" }
+  ],
+  correctHotspotIds: [hotspotQ1_engine_left, hotspotQ1_engine_right],
+  points: 15,
+  explanation: "M\xE1y bay n\xE0y c\xF3 hai \u0111\u1ED9ng c\u01A1 ch\xEDnh, n\u1EB1m d\u01B0\u1EDBi c\xE1nh.",
+  difficulty: "medium",
+  topic: "H\xE0ng kh\xF4ng",
+  category: "K\u1EF9 thu\u1EADt"
+};
+var blocklyQ1 = {
+  id: generateUniqueId("blkq_"),
+  questionType: "blockly_programming",
+  prompt: "S\u1EED d\u1EE5ng c\xE1c kh\u1ED1i l\u1EC7nh \u0111\u1EC3 t\u1EA1o m\u1ED9t ch\u01B0\u01A1ng tr\xECnh in ra d\xF2ng ch\u1EEF 'Hello, World!' v\xE0o console.",
+  points: 25,
+  difficulty: "easy",
+  topic: "L\u1EADp tr\xECnh C\u01A1 b\u1EA3n",
+  category: "C\xF4ng ngh\u1EC7 Th\xF4ng tin",
+  toolboxDefinition: `
+    <xml xmlns="https://developers.google.com/blockly/xml">
+      <category name="Text" colour="%{BKY_TEXTS_HUE}">
+        <block type="text"></block>
+        <block type="text_print"></block>
+      </category>
+    </xml>
+  `,
+  initialWorkspace: `
+    <xml xmlns="https://developers.google.com/blockly/xml">
+      <block type="text_print" id="${generateUniqueId("blki_")}" x="70" y="70">
+        <value name="TEXT">
+          <shadow type="text" id="${generateUniqueId("blki_")}">
+            <field name="TEXT">abc</field>
+          </shadow>
+        </value>
+      </block>
+    </xml>
+  `,
+  solutionWorkspaceXML: `
+    <xml xmlns="https://developers.google.com/blockly/xml">
+      <block type="text_print" id="${generateUniqueId("blki_solution_")}" x="70" y="70">
+        <value name="TEXT">
+          <block type="text" id="${generateUniqueId("blki_text_solution_")}">
+            <field name="TEXT">Hello, World!</field>
+          </block>
+        </value>
+      </block>
+    </xml>
+  `,
+  solutionGeneratedCode: "window.alert('Hello, World!');",
+  // Normalized JS code
+  explanation: "Ch\u01B0\u01A1ng tr\xECnh c\u1EA7n s\u1EED d\u1EE5ng kh\u1ED1i 'print' v\u1EDBi \u0111\u1EA7u v\xE0o l\xE0 kh\u1ED1i v\u0103n b\u1EA3n ch\u1EE9a 'Hello, World!'."
+};
+var scratchQ1 = {
+  id: generateUniqueId("scrq_"),
+  questionType: "scratch_programming",
+  prompt: "D\xF9ng kh\u1ED1i l\u1EC7nh Scratch \u0111\u1EC3 di chuy\u1EC3n nh\xE2n v\u1EADt v\u1EC1 ph\xEDa tr\u01B0\u1EDBc 10 b\u01B0\u1EDBc khi c\u1EDD xanh \u0111\u01B0\u1EE3c click.",
+  points: 20,
+  difficulty: "easy",
+  topic: "L\u1EADp tr\xECnh Scratch",
+  category: "C\xF4ng ngh\u1EC7 Th\xF4ng tin",
+  toolboxDefinition: `
+    <xml xmlns="https://developers.google.com/blockly/xml">
+      <category name="Motion" colour="#4C97FF">
+        <block type="motion_movesteps"></block>
+      </category>
+      <category name="Events" colour="#FFBF00">
+        <block type="event_whenflagclicked"></block>
+      </category>
+    </xml>
+  `,
+  initialWorkspace: `
+    <xml xmlns="https://developers.google.com/blockly/xml"></xml>
+  `,
+  solutionWorkspaceXML: `
+    <xml xmlns="https://developers.google.com/blockly/xml">
+      <block type="event_whenflagclicked" id="${generateUniqueId("scr_event_")}" x="50" y="50">
+        <next>
+          <block type="motion_movesteps" id="${generateUniqueId("scr_motion_")}">
+            <value name="STEPS">
+              <shadow type="math_number">
+                <field name="NUM">10</field>
+              </shadow>
+            </value>
+          </block>
+        </next>
+      </block>
+    </xml>
+  `,
+  solutionGeneratedCode: "whenGreenFlagClicked(() => { move(10); });",
+  // Example pseudo-code or JS representation
+  explanation: "S\u1EED d\u1EE5ng kh\u1ED1i 'when green flag clicked' t\u1EEB Events v\xE0 kh\u1ED1i 'move 10 steps' t\u1EEB Motion."
+};
+var sampleQuiz = {
+  id: "sample-quiz-001",
+  title: "Sample Quiz for Testers",
+  description: "A short quiz with a few different question types to test the QuizKit functionality.",
+  questions: [
+    trueFalseQ1,
+    mcq1,
+    mrq1,
+    shortAnswerQ1,
+    numericQ1,
+    fillInTheBlanksQ1,
+    sequenceQ1,
+    matchingQ1,
+    dragAndDropQ1,
+    hotspotQ1,
+    blocklyQ1,
+    scratchQ1
+    // Added Scratch question
+  ],
+  settings: {
+    shuffleQuestions: true,
+    shuffleOptions: true,
+    showCorrectAnswers: "end_of_quiz",
+    passingScorePercent: 70,
+    timeLimitMinutes: 25
+  }
+};
+var emptyQuiz = {
+  id: generateUniqueId("quiz_"),
+  title: "New Quiz",
+  description: "",
+  questions: [],
+  settings: {
+    shuffleQuestions: false,
+    shuffleOptions: false,
+    showCorrectAnswers: "end_of_quiz",
+    passingScorePercent: 0,
+    timeLimitMinutes: 0
+  }
+};
+
+// src/services/scormPackaging.ts
+var import_jszip = __toESM(require("jszip"));
+var sanitizeFilename = (name) => {
+  return name.replace(/[^a-z0-9_.-]/gi, "_").toLowerCase();
+};
+var exportQuizAsSCORMZip = async (quiz, options) => {
+  try {
+    const zip = new import_jszip.default();
+    const quizDataString = JSON.stringify(quiz, null, 2);
+    zip.file("quiz_data.json", quizDataString);
+    const libraryJSPath = "lib/interactive-quiz-kit.esm.js";
+    const blocklyCSSPath = "blockly-styles.css";
+    const manifestContent = generateSCORMManifest(
+      quiz,
+      options.scormVersion,
+      "index.html",
+      // Launcher file name in ZIP
+      libraryJSPath,
+      // Expected path for lib JS in ZIP
+      "quiz_data.json",
+      // Path to quiz data in ZIP
+      blocklyCSSPath
+      // Expected path for Blockly CSS in ZIP
+    );
+    zip.file("imsmanifest.xml", manifestContent);
+    const launcherContent = generateLauncherHTML(
+      quiz,
+      // Pass full quizConfig for title and other potential uses
+      libraryJSPath,
+      // Path to library JS, relative within ZIP
+      "quiz_data.json",
+      // Path to quiz data, relative within ZIP
+      blocklyCSSPath,
+      // Path to Blockly CSS, relative within ZIP
+      quiz.title
+      // Explicitly pass title for the HTML page
+    );
+    zip.file("index.html", launcherContent);
+    const blob = await zip.generateAsync({ type: "blob" });
+    const fileName = `${sanitizeFilename(quiz.title || "quiz")}_scorm_${options.scormVersion.replace(".", "_")}.zip`;
+    const link = document.createElement("a");
+    link.href = URL.createObjectURL(blob);
+    link.download = fileName;
+    document.body.appendChild(link);
+    link.click();
+    document.body.removeChild(link);
+    URL.revokeObjectURL(link.href);
+    return { success: true, fileName };
+  } catch (err) {
+    console.error("Error creating SCORM ZIP:", err);
+    return { success: false, error: err instanceof Error ? err.message : "Unknown error during ZIP creation." };
+  }
+};
+
+// src/ai/genkit.ts
+var import_genkit = require("genkit");
+var import_googleai = require("@genkit-ai/googleai");
+var ai = (0, import_genkit.genkit)({
+  plugins: [(0, import_googleai.googleAI)()],
+  model: "googleai/gemini-2.0-flash"
+});
+
+// src/ai/flows/generate-fitb-question.ts
+var import_genkit3 = require("genkit");
+var GenerateFillInTheBlanksQuestionInputSchema = import_genkit3.z.object({
+  topic: import_genkit3.z.string().describe("The topic for the question."),
+  difficulty: import_genkit3.z.enum(["easy", "medium", "hard"]).optional().default("medium"),
+  numberOfBlanks: import_genkit3.z.number().int().min(1).max(5).optional().default(1).describe("Number of blanks to include (1-5)."),
+  isCaseSensitive: import_genkit3.z.boolean().optional().default(false).describe("Whether answers should be case-sensitive."),
+  contextDescription: import_genkit3.z.string().optional().describe("A specific context or scenario for the question, complementing the main topic."),
+  selectedContextId: import_genkit3.z.string().optional().describe("The ID of the selected context, if any.")
+});
+var AIFillInTheBlanksOutputFieldsSchema = import_genkit3.z.object({
+  prompt: import_genkit3.z.string().describe("The overall instruction for the question (e.g., 'Fill in the blanks in the sentence below.')."),
+  sentenceWithPlaceholders: import_genkit3.z.string().describe("The sentence containing placeholders for blanks, e.g., 'The capital of {{country}} is {{city}}.' or 'Water is made of {{element1}} and {{element2}}.' Placeholders should be distinct and clearly marked, e.g., using {{placeholder_name}} format."),
+  blanks: import_genkit3.z.array(
+    import_genkit3.z.object({
+      placeholder: import_genkit3.z.string().describe("The exact placeholder string used in 'sentenceWithPlaceholders' (e.g., 'country', 'element1'). Do not include the curly braces."),
+      acceptedAnswers: import_genkit3.z.array(import_genkit3.z.string()).min(1).describe("An array of acceptable answers for this blank.")
+    })
+  ).min(1).describe("An array defining each placeholder and its accepted answers."),
+  isCaseSensitive: import_genkit3.z.boolean().optional().describe("Should answer evaluation be case sensitive? Defaults to input or false."),
+  explanation: import_genkit3.z.string().optional().describe("Explanation for the correct answer(s)."),
+  points: import_genkit3.z.number().optional().default(10),
+  difficulty: import_genkit3.z.enum(["easy", "medium", "hard"]).optional(),
+  topic: import_genkit3.z.string().optional()
+});
+var FillInTheBlanksQuestionZodSchema = import_genkit3.z.object({
+  id: import_genkit3.z.string(),
+  questionType: import_genkit3.z.literal("fill_in_the_blanks"),
+  prompt: import_genkit3.z.string(),
+  segments: import_genkit3.z.array(import_genkit3.z.object({ type: import_genkit3.z.enum(["text", "blank"]), content: import_genkit3.z.string().optional(), id: import_genkit3.z.string().optional() })),
+  answers: import_genkit3.z.array(import_genkit3.z.object({ blankId: import_genkit3.z.string(), acceptedValues: import_genkit3.z.array(import_genkit3.z.string()) })),
+  isCaseSensitive: import_genkit3.z.boolean().optional(),
+  points: import_genkit3.z.number().optional(),
+  explanation: import_genkit3.z.string().optional(),
+  learningObjective: import_genkit3.z.string().optional(),
+  glossary: import_genkit3.z.array(import_genkit3.z.string()).optional(),
+  bloomLevel: import_genkit3.z.string().optional(),
+  difficulty: import_genkit3.z.enum(["easy", "medium", "hard"]).optional(),
+  contextCode: import_genkit3.z.string().optional(),
+  gradeBand: import_genkit3.z.string().optional(),
+  course: import_genkit3.z.string().optional(),
+  category: import_genkit3.z.string().optional(),
+  topic: import_genkit3.z.string().optional()
+});
+var GenerateFillInTheBlanksQuestionOutputSchema = import_genkit3.z.object({
+  question: FillInTheBlanksQuestionZodSchema.optional().describe("The generated Fill-In-The-Blanks question.")
+});
+async function generateFillInTheBlanksQuestion(input) {
+  return generateFillInTheBlanksQuestionFlow(input);
+}
+var fitbAIPrompt = ai.definePrompt({
+  name: "fitbQuestionGeneratorPrompt",
+  input: { schema: GenerateFillInTheBlanksQuestionInputSchema },
+  output: { schema: AIFillInTheBlanksOutputFieldsSchema },
+  prompt: `You are an expert quiz question writer.
+Generate a single Fill-In-The-Blanks question with approximately {{{numberOfBlanks}}} blanks.
+Provide:
+1.  An overall 'prompt' or instruction.
+2.  A 'sentenceWithPlaceholders' where blanks are clearly marked with double curly braces, e.g., "{{blank_name}}". Each placeholder name inside the braces must be unique.
+3.  A 'blanks' array, where each object defines a 'placeholder' (matching a name from the sentence, without braces) and its 'acceptedAnswers'.
+4.  Specify 'isCaseSensitive' (defaulting to {{{isCaseSensitive}}}).
+5.  Optional 'explanation', 'points' (default 10), refined 'topic', and 'difficulty'.
+
+Topic: {{{topic}}}
+{{#if contextDescription}}
+Context: {{{contextDescription}}}
+{{/if}}
+Difficulty: {{{difficulty}}}
+Target Number of Blanks: {{{numberOfBlanks}}}
+Case Sensitive: {{{isCaseSensitive}}}
+
+Example for 'sentenceWithPlaceholders': "The {{color_of_sky}} sky is beautiful, and the {{type_of_grass}} grass is green."
+Example for 'blanks' array entry for the above: { "placeholder": "color_of_sky", "acceptedAnswers": ["blue"] }
+
+Ensure your output strictly matches the requested JSON schema. The number of entries in the 'blanks' array should correspond to the number of unique placeholders in 'sentenceWithPlaceholders'.
+`
+});
+var generateFillInTheBlanksQuestionFlow = ai.defineFlow(
+  {
+    name: "generateFillInTheBlanksQuestionFlow",
+    inputSchema: GenerateFillInTheBlanksQuestionInputSchema,
+    outputSchema: GenerateFillInTheBlanksQuestionOutputSchema
+  },
+  async (input) => {
+    try {
+      const { output: aiGeneratedContent } = await fitbAIPrompt(input);
+      if (aiGeneratedContent) {
+        const segments = [];
+        const answers = [];
+        const placeholderToBlankIdMap = {};
+        aiGeneratedContent.blanks.forEach((blankInfo) => {
+          const blankId = generateUniqueId("blank_");
+          placeholderToBlankIdMap[blankInfo.placeholder] = blankId;
+          answers.push({
+            blankId,
+            acceptedValues: blankInfo.acceptedAnswers
+          });
+        });
+        let remainingSentence = aiGeneratedContent.sentenceWithPlaceholders;
+        const placeholderRegex = /\{\{([^}]+)\}\}/g;
+        let lastIndex = 0;
+        let match;
+        while ((match = placeholderRegex.exec(remainingSentence)) !== null) {
+          const placeholderName = match[1];
+          const blankId = placeholderToBlankIdMap[placeholderName];
+          if (match.index > lastIndex) {
+            segments.push({ type: "text", content: remainingSentence.substring(lastIndex, match.index) });
+          }
+          if (blankId) {
+            segments.push({ type: "blank", id: blankId });
+          } else {
+            console.warn(`Placeholder {{${placeholderName}}} found in sentence but not in blanks definition. Treating as text.`);
+            segments.push({ type: "text", content: match[0] });
+          }
+          lastIndex = placeholderRegex.lastIndex;
+        }
+        if (lastIndex < remainingSentence.length) {
+          segments.push({ type: "text", content: remainingSentence.substring(lastIndex) });
+        }
+        if (answers.length === 0 && segments.some((s) => s.type === "blank")) {
+          throw new Error("AI generated blank segments but no corresponding answer definitions.");
+        }
+        if (segments.filter((s) => s.type === "blank").length !== answers.length) {
+          console.warn(`Mismatch between number of blank segments (${segments.filter((s) => s.type === "blank").length}) and answer definitions (${answers.length}). Review AI output.`);
+          if (answers.length === 0 && segments.filter((s) => s.type === "blank").length > 0) {
+            throw new Error("AI generated blank segments but no answer definitions for them.");
+          }
+        }
+        const completeQuestion = {
+          id: generateUniqueId("fitb_ai_"),
+          questionType: "fill_in_the_blanks",
+          prompt: aiGeneratedContent.prompt,
+          segments,
+          answers,
+          isCaseSensitive: aiGeneratedContent.isCaseSensitive === void 0 ? input.isCaseSensitive : aiGeneratedContent.isCaseSensitive,
+          explanation: aiGeneratedContent.explanation,
+          points: aiGeneratedContent.points,
+          topic: aiGeneratedContent.topic || input.topic,
+          difficulty: aiGeneratedContent.difficulty || input.difficulty,
+          contextCode: input.contextDescription ? input.selectedContextId : void 0
+        };
+        return { question: completeQuestion };
+      } else {
+        throw new Error("AI did not return content for the Fill-In-The-Blanks question.");
+      }
+    } catch (error) {
+      console.error("Error generating Fill-In-The-Blanks question in flow:", error);
+      throw new Error(`Failed to generate Fill-In-The-Blanks question: ${error.message}`);
+    }
+  }
+);
+
+// src/ai/flows/generate-matching-question.ts
+var import_genkit5 = require("genkit");
+var GenerateMatchingQuestionInputSchema = import_genkit5.z.object({
+  topic: import_genkit5.z.string().describe("The topic for the question."),
+  difficulty: import_genkit5.z.enum(["easy", "medium", "hard"]).optional().default("medium"),
+  numberOfPairs: import_genkit5.z.number().int().min(2).max(8).optional().default(4).describe("Number of pairs to match (2-8)."),
+  shuffleOptions: import_genkit5.z.boolean().optional().default(true).describe("Whether the options should be shuffled for the user."),
+  contextDescription: import_genkit5.z.string().optional().describe("A specific context or scenario for the question, complementing the main topic."),
+  selectedContextId: import_genkit5.z.string().optional().describe("The ID of the selected context, if any.")
+});
+var AIMatchingOutputFieldsSchema = import_genkit5.z.object({
+  prompt: import_genkit5.z.string().describe("The overall instruction (e.g., 'Match the terms to their definitions.')."),
+  correctPairs: import_genkit5.z.array(
+    import_genkit5.z.object({
+      promptText: import_genkit5.z.string().describe("The text for a prompt item (e.g., a term)."),
+      optionText: import_genkit5.z.string().describe("The text for the corresponding option item (e.g., its definition).")
+    })
+  ).min(2).describe("An array of objects, each representing a correct prompt-option pair."),
+  explanation: import_genkit5.z.string().optional().describe("General explanation if needed."),
+  points: import_genkit5.z.number().optional().default(10),
+  difficulty: import_genkit5.z.enum(["easy", "medium", "hard"]).optional(),
+  topic: import_genkit5.z.string().optional()
+});
+var MatchingQuestionZodSchema = import_genkit5.z.object({
+  id: import_genkit5.z.string(),
+  questionType: import_genkit5.z.literal("matching"),
+  prompt: import_genkit5.z.string(),
+  prompts: import_genkit5.z.array(import_genkit5.z.object({ id: import_genkit5.z.string(), content: import_genkit5.z.string() })),
+  options: import_genkit5.z.array(import_genkit5.z.object({ id: import_genkit5.z.string(), content: import_genkit5.z.string() })),
+  correctAnswerMap: import_genkit5.z.array(import_genkit5.z.object({ promptId: import_genkit5.z.string(), optionId: import_genkit5.z.string() })),
+  shuffleOptions: import_genkit5.z.boolean().optional(),
+  points: import_genkit5.z.number().optional(),
+  explanation: import_genkit5.z.string().optional(),
+  learningObjective: import_genkit5.z.string().optional(),
+  glossary: import_genkit5.z.array(import_genkit5.z.string()).optional(),
+  bloomLevel: import_genkit5.z.string().optional(),
+  difficulty: import_genkit5.z.enum(["easy", "medium", "hard"]).optional(),
+  contextCode: import_genkit5.z.string().optional(),
+  gradeBand: import_genkit5.z.string().optional(),
+  course: import_genkit5.z.string().optional(),
+  category: import_genkit5.z.string().optional(),
+  topic: import_genkit5.z.string().optional()
+});
+var GenerateMatchingQuestionOutputSchema = import_genkit5.z.object({
+  question: MatchingQuestionZodSchema.optional().describe("The generated Matching question.")
+});
+async function generateMatchingQuestion(input) {
+  return generateMatchingQuestionFlow(input);
+}
+var matchingAIPrompt = ai.definePrompt({
+  name: "matchingQuestionGeneratorPrompt",
+  input: { schema: GenerateMatchingQuestionInputSchema },
+  output: { schema: AIMatchingOutputFieldsSchema },
+  prompt: `You are an expert quiz question writer.
+Generate a single Matching question with exactly {{{numberOfPairs}}} correct pairs.
+Provide:
+1.  An overall 'prompt' or instruction.
+2.  A 'correctPairs' array: each object in this array should contain a 'promptText' and its corresponding 'optionText'. These represent items that correctly match.
+3.  Optional 'explanation', 'points' (default 10), refined 'topic', and 'difficulty'.
+
+Topic: {{{topic}}}
+{{#if contextDescription}}
+Context: {{{contextDescription}}}
+{{/if}}
+Difficulty: {{{difficulty}}}
+Number of Pairs: {{{numberOfPairs}}}
+
+Ensure your output strictly matches the requested JSON schema. 'correctPairs' must have {{{numberOfPairs}}} elements.
+The promptText and optionText within each pair should be distinct and meaningful for a matching question.
+`
+});
+var generateMatchingQuestionFlow = ai.defineFlow(
+  {
+    name: "generateMatchingQuestionFlow",
+    inputSchema: GenerateMatchingQuestionInputSchema,
+    outputSchema: GenerateMatchingQuestionOutputSchema
+  },
+  async (input) => {
+    try {
+      const { output: aiGeneratedContent } = await matchingAIPrompt(input);
+      if (aiGeneratedContent) {
+        if (aiGeneratedContent.correctPairs.length !== input.numberOfPairs) {
+          throw new Error(`AI generated ${aiGeneratedContent.correctPairs.length} pairs, but ${input.numberOfPairs} were requested.`);
+        }
+        const finalPrompts = [];
+        const finalOptions = [];
+        const finalCorrectAnswerMap = [];
+        const promptTextToId = {};
+        const optionTextToId = {};
+        aiGeneratedContent.correctPairs.forEach((pair) => {
+          let promptId = promptTextToId[pair.promptText];
+          if (!promptId) {
+            promptId = generateUniqueId("m_p_");
+            promptTextToId[pair.promptText] = promptId;
+            finalPrompts.push({ id: promptId, content: pair.promptText });
+          }
+          let optionId = optionTextToId[pair.optionText];
+          if (!optionId) {
+            optionId = generateUniqueId("m_o_");
+            optionTextToId[pair.optionText] = optionId;
+            finalOptions.push({ id: optionId, content: pair.optionText });
+          }
+          if (!finalCorrectAnswerMap.find((m) => m.promptId === promptId && m.optionId === optionId)) {
+            finalCorrectAnswerMap.push({ promptId, optionId });
+          }
+        });
+        if (finalPrompts.length < input.numberOfPairs || finalOptions.length < input.numberOfPairs) {
+          console.warn(`AI generated ${finalPrompts.length} unique prompts and ${finalOptions.length} unique options for ${input.numberOfPairs} requested pairs. This might lead to an unbalanced matching question or indicate duplicate content from AI.`);
+        }
+        if (finalCorrectAnswerMap.length !== input.numberOfPairs) {
+          throw new Error(`Could not form the required ${input.numberOfPairs} unique mappings from AI output. AI provided ${finalCorrectAnswerMap.length} valid mappings.`);
+        }
+        const completeQuestion = {
+          id: generateUniqueId("match_ai_"),
+          questionType: "matching",
+          prompt: aiGeneratedContent.prompt,
+          prompts: finalPrompts,
+          options: finalOptions,
+          correctAnswerMap: finalCorrectAnswerMap,
+          shuffleOptions: input.shuffleOptions,
+          explanation: aiGeneratedContent.explanation,
+          points: aiGeneratedContent.points,
+          topic: aiGeneratedContent.topic || input.topic,
+          difficulty: aiGeneratedContent.difficulty || input.difficulty,
+          contextCode: input.contextDescription ? input.selectedContextId : void 0
+        };
+        return { question: completeQuestion };
+      } else {
+        throw new Error("AI did not return content for the Matching question.");
+      }
+    } catch (error) {
+      console.error("Error generating Matching question in flow:", error);
+      throw new Error(`Failed to generate Matching question: ${error.message}`);
+    }
+  }
+);
+
+// src/ai/flows/generate-mcq-question.ts
+var import_genkit7 = require("genkit");
+var GenerateMCQQuestionInputSchema = import_genkit7.z.object({
+  topic: import_genkit7.z.string().describe("The topic for the question."),
+  difficulty: import_genkit7.z.enum(["easy", "medium", "hard"]).optional().default("medium"),
+  numberOfOptions: import_genkit7.z.number().int().min(2).max(6).optional().default(4).describe("Number of answer options to generate (2-6)."),
+  contextDescription: import_genkit7.z.string().optional().describe("A specific context or scenario for the question, complementing the main topic."),
+  selectedContextId: import_genkit7.z.string().optional().describe("The ID of the selected context, if any.")
+});
+var AIMCQOutputFieldsSchema = import_genkit7.z.object({
+  prompt: import_genkit7.z.string().describe("The question statement itself."),
+  options: import_genkit7.z.array(
+    import_genkit7.z.object({
+      tempId: import_genkit7.z.string().describe("A temporary, unique identifier for this option (e.g., 'A', 'B', '1', '2')."),
+      text: import_genkit7.z.string().describe("The text content of this answer option.")
+    })
+  ).min(2).max(6).describe("An array of answer choices that matches the numberOfOptions specified in the input."),
+  correctTempOptionId: import_genkit7.z.string().describe("The temporary ID of the correct option from the generated options array."),
+  explanation: import_genkit7.z.string().optional().describe("A brief explanation of why the answer is correct."),
+  points: import_genkit7.z.number().optional().default(10).describe("Points for a correct answer."),
+  difficulty: import_genkit7.z.enum(["easy", "medium", "hard"]).optional().describe("Assessed difficulty."),
+  topic: import_genkit7.z.string().optional().describe("Refined topic.")
+});
+var MultipleChoiceQuestionZodSchema = import_genkit7.z.object({
+  id: import_genkit7.z.string(),
+  questionType: import_genkit7.z.literal("multiple_choice"),
+  prompt: import_genkit7.z.string(),
+  options: import_genkit7.z.array(import_genkit7.z.object({ id: import_genkit7.z.string(), text: import_genkit7.z.string() })),
+  correctAnswerId: import_genkit7.z.string(),
+  points: import_genkit7.z.number().optional(),
+  explanation: import_genkit7.z.string().optional(),
+  learningObjective: import_genkit7.z.string().optional(),
+  glossary: import_genkit7.z.array(import_genkit7.z.string()).optional(),
+  bloomLevel: import_genkit7.z.string().optional(),
+  difficulty: import_genkit7.z.enum(["easy", "medium", "hard"]).optional(),
+  contextCode: import_genkit7.z.string().optional(),
+  gradeBand: import_genkit7.z.string().optional(),
+  course: import_genkit7.z.string().optional(),
+  category: import_genkit7.z.string().optional(),
+  topic: import_genkit7.z.string().optional()
+});
+var GenerateMCQQuestionOutputSchema = import_genkit7.z.object({
+  question: MultipleChoiceQuestionZodSchema.optional().describe("The generated Multiple Choice question.")
+});
+async function generateMCQQuestion(input) {
+  return generateMCQQuestionFlow(input);
+}
+var mcqAIPrompt = ai.definePrompt({
+  name: "mcqQuestionGeneratorPrompt",
+  input: { schema: GenerateMCQQuestionInputSchema },
+  output: { schema: AIMCQOutputFieldsSchema },
+  prompt: `You are an expert quiz question writer.
+Generate a single Multiple Choice question based on the following inputs.
+Provide the question statement (prompt), an array of options (each with a unique temporary ID like 'A', 'B', 'C' or 'option_1', 'option_2' and its text), the temporary ID of the correct option, an optional explanation, optional points (default 10), and optionally refine the topic and difficulty.
+Ensure there are exactly {{{numberOfOptions}}} options. The temporary IDs for options must be unique within the 'options' array and one of them must match 'correctTempOptionId'.
+
+Topic: {{{topic}}}
+{{#if contextDescription}}
+Context: {{{contextDescription}}}
+{{/if}}
+Difficulty: {{{difficulty}}}
+Number of Options: {{{numberOfOptions}}}
+
+Ensure your output strictly matches the requested JSON schema.
+`
+});
+var generateMCQQuestionFlow = ai.defineFlow(
+  {
+    name: "generateMCQQuestionFlow",
+    inputSchema: GenerateMCQQuestionInputSchema,
+    outputSchema: GenerateMCQQuestionOutputSchema
+  },
+  async (input) => {
+    try {
+      const { output: aiGeneratedContent } = await mcqAIPrompt(input);
+      if (aiGeneratedContent) {
+        const finalOptions = [];
+        const tempIdToFinalIdMap = {};
+        aiGeneratedContent.options.forEach((aiOption) => {
+          const finalId = generateUniqueId("opt_");
+          finalOptions.push({ id: finalId, text: aiOption.text });
+          tempIdToFinalIdMap[aiOption.tempId] = finalId;
+        });
+        const finalCorrectAnswerId = tempIdToFinalIdMap[aiGeneratedContent.correctTempOptionId];
+        if (!finalCorrectAnswerId) {
+          const correctAiOption = aiGeneratedContent.options.find((o) => o.tempId === aiGeneratedContent.correctTempOptionId);
+          if (correctAiOption) {
+          } else {
+            const index = parseInt(aiGeneratedContent.correctTempOptionId);
+            if (!isNaN(index) && index >= 0 && index < finalOptions.length && finalOptions[index].id) {
+            } else {
+              throw new Error(`Correct option ID '${aiGeneratedContent.correctTempOptionId}' is invalid or does not match any generated option tempId.`);
+            }
+          }
+          if (!finalCorrectAnswerId) {
+            throw new Error(`Correct option ID '${aiGeneratedContent.correctTempOptionId}' is invalid or does not match any generated option tempId.`);
+          }
+        }
+        const completeQuestion = {
+          id: generateUniqueId("mcq_ai_"),
+          questionType: "multiple_choice",
+          prompt: aiGeneratedContent.prompt,
+          options: finalOptions,
+          correctAnswerId: finalCorrectAnswerId,
+          explanation: aiGeneratedContent.explanation,
+          points: aiGeneratedContent.points,
+          topic: aiGeneratedContent.topic || input.topic,
+          difficulty: aiGeneratedContent.difficulty || input.difficulty,
+          learningObjective: void 0,
+          glossary: void 0,
+          bloomLevel: void 0,
+          contextCode: input.contextDescription ? input.selectedContextId : void 0,
+          gradeBand: void 0,
+          course: void 0,
+          category: void 0
+        };
+        return { question: completeQuestion };
+      } else {
+        throw new Error("AI did not return content for the MCQ question.");
+      }
+    } catch (error) {
+      console.error("Error generating MCQ question in flow:", error);
+      throw new Error(`Failed to generate MCQ question: ${error.message}`);
+    }
+  }
+);
+
+// src/ai/flows/generate-mrq-question.ts
+var import_genkit9 = require("genkit");
+var GenerateMRQQuestionInputSchema = import_genkit9.z.object({
+  topic: import_genkit9.z.string().describe("The topic for the question."),
+  difficulty: import_genkit9.z.enum(["easy", "medium", "hard"]).optional().default("medium"),
+  numberOfOptions: import_genkit9.z.number().int().min(2).max(8).optional().default(5).describe("Number of answer options to generate (2-8)."),
+  minCorrectAnswers: import_genkit9.z.number().int().min(1).optional().default(2).describe("Minimum number of correct answers among the options."),
+  maxCorrectAnswers: import_genkit9.z.number().int().min(1).optional().default(3).describe("Maximum number of correct answers (must be <= numberOfOptions)."),
+  contextDescription: import_genkit9.z.string().optional().describe("A specific context or scenario for the question, complementing the main topic."),
+  selectedContextId: import_genkit9.z.string().optional().describe("The ID of the selected context, if any.")
+});
+var AIMRQOutputFieldsSchema = import_genkit9.z.object({
+  prompt: import_genkit9.z.string().describe("The question statement itself."),
+  options: import_genkit9.z.array(
+    import_genkit9.z.object({
+      tempId: import_genkit9.z.string().describe("A temporary, unique identifier for this option (e.g., 'A', 'B')."),
+      text: import_genkit9.z.string().describe("The text content of this answer option.")
+    })
+  ).min(2).max(8).describe("An array of answer choices."),
+  correctTempOptionIds: import_genkit9.z.array(import_genkit9.z.string()).min(1).describe("An array of temporary IDs of the correct options from the generated options array."),
+  explanation: import_genkit9.z.string().optional().describe("A brief explanation of why the answers are correct."),
+  points: import_genkit9.z.number().optional().default(10).describe("Points for a correct answer."),
+  difficulty: import_genkit9.z.enum(["easy", "medium", "hard"]).optional().describe("Assessed difficulty."),
+  topic: import_genkit9.z.string().optional().describe("Refined topic.")
+});
+var MultipleResponseQuestionZodSchema = import_genkit9.z.object({
+  id: import_genkit9.z.string(),
+  questionType: import_genkit9.z.literal("multiple_response"),
+  prompt: import_genkit9.z.string(),
+  options: import_genkit9.z.array(import_genkit9.z.object({ id: import_genkit9.z.string(), text: import_genkit9.z.string() })),
+  correctAnswerIds: import_genkit9.z.array(import_genkit9.z.string()),
+  points: import_genkit9.z.number().optional(),
+  explanation: import_genkit9.z.string().optional(),
+  learningObjective: import_genkit9.z.string().optional(),
+  glossary: import_genkit9.z.array(import_genkit9.z.string()).optional(),
+  bloomLevel: import_genkit9.z.string().optional(),
+  difficulty: import_genkit9.z.enum(["easy", "medium", "hard"]).optional(),
+  contextCode: import_genkit9.z.string().optional(),
+  gradeBand: import_genkit9.z.string().optional(),
+  course: import_genkit9.z.string().optional(),
+  category: import_genkit9.z.string().optional(),
+  topic: import_genkit9.z.string().optional()
+});
+var GenerateMRQQuestionOutputSchema = import_genkit9.z.object({
+  question: MultipleResponseQuestionZodSchema.optional().describe("The generated Multiple Response question.")
+});
+async function generateMRQQuestion(input) {
+  if (input.minCorrectAnswers > input.maxCorrectAnswers) {
+    throw new Error("Minimum correct answers cannot exceed maximum correct answers.");
+  }
+  if (input.maxCorrectAnswers > input.numberOfOptions) {
+    throw new Error("Maximum correct answers cannot exceed the total number of options.");
+  }
+  return generateMRQQuestionFlow(input);
+}
+var mrqAIPrompt = ai.definePrompt({
+  name: "mrqQuestionGeneratorPrompt",
+  input: { schema: GenerateMRQQuestionInputSchema },
+  output: { schema: AIMRQOutputFieldsSchema },
+  prompt: `You are an expert quiz question writer.
+Generate a single Multiple Response question based on the following inputs.
+Provide the question statement (prompt), an array of options (each with a unique temporary ID and its text), an array of the temporary IDs of the correct options, an optional explanation, optional points (default 10), and optionally refine the topic and difficulty.
+Ensure there are exactly {{{numberOfOptions}}} options.
+Ensure there are between {{{minCorrectAnswers}}} and {{{maxCorrectAnswers}}} correct options.
+The temporary IDs for options must be unique within the 'options' array and all IDs in 'correctTempOptionIds' must match one of them.
+
+Topic: {{{topic}}}
+{{#if contextDescription}}
+Context: {{{contextDescription}}}
+{{/if}}
+Difficulty: {{{difficulty}}}
+Number of Options: {{{numberOfOptions}}}
+Min Correct Answers: {{{minCorrectAnswers}}}
+Max Correct Answers: {{{maxCorrectAnswers}}}
+
+Ensure your output strictly matches the requested JSON schema.
+`
+});
+var generateMRQQuestionFlow = ai.defineFlow(
+  {
+    name: "generateMRQQuestionFlow",
+    inputSchema: GenerateMRQQuestionInputSchema,
+    outputSchema: GenerateMRQQuestionOutputSchema
+  },
+  async (input) => {
+    try {
+      const { output: aiGeneratedContent } = await mrqAIPrompt(input);
+      if (aiGeneratedContent) {
+        const finalOptions = [];
+        const tempIdToFinalIdMap = {};
+        aiGeneratedContent.options.forEach((aiOption) => {
+          const finalId = generateUniqueId("opt_mr_");
+          finalOptions.push({ id: finalId, text: aiOption.text });
+          tempIdToFinalIdMap[aiOption.tempId] = finalId;
+        });
+        const finalCorrectAnswerIds = aiGeneratedContent.correctTempOptionIds.map((tempId) => {
+          const finalId = tempIdToFinalIdMap[tempId];
+          if (!finalId) {
+            throw new Error(`AI provided an invalid correctTempOptionId ('${tempId}') that does not map to any generated option.`);
+          }
+          return finalId;
+        });
+        if (finalCorrectAnswerIds.length < input.minCorrectAnswers || finalCorrectAnswerIds.length > input.maxCorrectAnswers) {
+          throw new Error(`AI generated ${finalCorrectAnswerIds.length} correct answers, which is outside the requested range of ${input.minCorrectAnswers}-${input.maxCorrectAnswers}.`);
+        }
+        if (finalOptions.length !== input.numberOfOptions) {
+          throw new Error(`AI generated ${finalOptions.length} options, but ${input.numberOfOptions} were requested.`);
+        }
+        const completeQuestion = {
+          id: generateUniqueId("mrq_ai_"),
+          questionType: "multiple_response",
+          prompt: aiGeneratedContent.prompt,
+          options: finalOptions,
+          correctAnswerIds: finalCorrectAnswerIds,
+          explanation: aiGeneratedContent.explanation,
+          points: aiGeneratedContent.points,
+          topic: aiGeneratedContent.topic || input.topic,
+          difficulty: aiGeneratedContent.difficulty || input.difficulty,
+          learningObjective: void 0,
+          glossary: void 0,
+          bloomLevel: void 0,
+          contextCode: input.contextDescription ? input.selectedContextId : void 0,
+          gradeBand: void 0,
+          course: void 0,
+          category: void 0
+        };
+        return { question: completeQuestion };
+      } else {
+        throw new Error("AI did not return content for the MRQ question.");
+      }
+    } catch (error) {
+      console.error("Error generating MRQ question in flow:", error);
+      throw new Error(`Failed to generate MRQ question: ${error.message}`);
+    }
+  }
+);
+
+// src/ai/flows/generate-numeric-question.ts
+var import_genkit11 = require("genkit");
+var GenerateNumericQuestionInputSchema = import_genkit11.z.object({
+  topic: import_genkit11.z.string().describe("The topic for the question."),
+  difficulty: import_genkit11.z.enum(["easy", "medium", "hard"]).optional().default("medium"),
+  allowDecimals: import_genkit11.z.boolean().optional().default(true).describe("Whether the answer can be a decimal."),
+  minRange: import_genkit11.z.number().optional().describe("Optional minimum value for the answer."),
+  maxRange: import_genkit11.z.number().optional().describe("Optional maximum value for the answer."),
+  contextDescription: import_genkit11.z.string().optional().describe("A specific context or scenario for the question, complementing the main topic."),
+  selectedContextId: import_genkit11.z.string().optional().describe("The ID of the selected context, if any.")
+});
+var AINumericOutputFieldsSchema = import_genkit11.z.object({
+  prompt: import_genkit11.z.string().describe("The question statement that expects a numerical answer."),
+  answer: import_genkit11.z.number().describe("The precise numerical correct answer."),
+  tolerance: import_genkit11.z.number().optional().default(0).describe("The acceptable range of error (plus or minus). E.g., if answer is 10 and tolerance is 0.5, answers between 9.5 and 10.5 are correct. Default is 0 for exact match."),
+  explanation: import_genkit11.z.string().optional().describe("Explanation for the correct answer."),
+  points: import_genkit11.z.number().optional().default(10),
+  difficulty: import_genkit11.z.enum(["easy", "medium", "hard"]).optional(),
+  topic: import_genkit11.z.string().optional()
+});
+var NumericQuestionZodSchema = import_genkit11.z.object({
+  id: import_genkit11.z.string(),
+  questionType: import_genkit11.z.literal("numeric"),
+  prompt: import_genkit11.z.string(),
+  answer: import_genkit11.z.number(),
+  tolerance: import_genkit11.z.number().optional(),
+  points: import_genkit11.z.number().optional(),
+  explanation: import_genkit11.z.string().optional(),
+  learningObjective: import_genkit11.z.string().optional(),
+  glossary: import_genkit11.z.array(import_genkit11.z.string()).optional(),
+  bloomLevel: import_genkit11.z.string().optional(),
+  difficulty: import_genkit11.z.enum(["easy", "medium", "hard"]).optional(),
+  contextCode: import_genkit11.z.string().optional(),
+  gradeBand: import_genkit11.z.string().optional(),
+  course: import_genkit11.z.string().optional(),
+  category: import_genkit11.z.string().optional(),
+  topic: import_genkit11.z.string().optional()
+});
+var GenerateNumericQuestionOutputSchema = import_genkit11.z.object({
+  question: NumericQuestionZodSchema.optional().describe("The generated Numeric question.")
+});
+async function generateNumericQuestion(input) {
+  return generateNumericQuestionFlow(input);
+}
+var numericAIPrompt = ai.definePrompt({
+  name: "numericQuestionGeneratorPrompt",
+  input: { schema: GenerateNumericQuestionInputSchema },
+  output: { schema: AINumericOutputFieldsSchema },
+  prompt: `You are an expert quiz question writer.
+Generate a single Numeric question based on the topic and difficulty.
+The question should require a numerical answer.
+Provide the question prompt, the correct numerical answer, an optional tolerance (default 0 for exact match), an optional explanation, points (default 10), and optionally refine the topic/difficulty.
+{{#if minRange}}The answer should ideally be greater than or equal to {{{minRange}}}.{{/if}}
+{{#if maxRange}}The answer should ideally be less than or equal to {{{maxRange}}}.{{/if}}
+The answer should be an integer if 'allowDecimals' is false, otherwise it can be a decimal. Current 'allowDecimals': {{{allowDecimals}}}.
+
+Topic: {{{topic}}}
+{{#if contextDescription}}
+Context: {{{contextDescription}}}
+{{/if}}
+Difficulty: {{{difficulty}}}
+
+Ensure your output strictly matches the requested JSON schema.
+`
+});
+var generateNumericQuestionFlow = ai.defineFlow(
+  {
+    name: "generateNumericQuestionFlow",
+    inputSchema: GenerateNumericQuestionInputSchema,
+    outputSchema: GenerateNumericQuestionOutputSchema
+  },
+  async (input) => {
+    try {
+      const { output: aiGeneratedContent } = await numericAIPrompt(input);
+      if (aiGeneratedContent) {
+        let finalAnswer = aiGeneratedContent.answer;
+        if (!input.allowDecimals) {
+          finalAnswer = Math.round(finalAnswer);
+        }
+        if (input.minRange !== void 0 && finalAnswer < input.minRange) {
+          console.warn(`AI generated answer ${finalAnswer} below minRange ${input.minRange}. Adjusting or re-prompt might be needed for stricter adherence.`);
+        }
+        if (input.maxRange !== void 0 && finalAnswer > input.maxRange) {
+          console.warn(`AI generated answer ${finalAnswer} above maxRange ${input.maxRange}. Adjusting or re-prompt might be needed.`);
+        }
+        const completeQuestion = {
+          id: generateUniqueId("numq_ai_"),
+          questionType: "numeric",
+          prompt: aiGeneratedContent.prompt,
+          answer: finalAnswer,
+          tolerance: aiGeneratedContent.tolerance,
+          explanation: aiGeneratedContent.explanation,
+          points: aiGeneratedContent.points,
+          topic: aiGeneratedContent.topic || input.topic,
+          difficulty: aiGeneratedContent.difficulty || input.difficulty,
+          contextCode: input.contextDescription ? input.selectedContextId : void 0
+        };
+        return { question: completeQuestion };
+      } else {
+        throw new Error("AI did not return content for the Numeric question.");
+      }
+    } catch (error) {
+      console.error("Error generating Numeric question in flow:", error);
+      throw new Error(`Failed to generate Numeric question: ${error.message}`);
+    }
+  }
+);
+
+// src/ai/flows/generate-quiz-plan-flow.ts
+var import_genkit13 = require("genkit");
+var fullQuizSupportedQuestionTypesArray = [
+  "true_false",
+  "multiple_choice",
+  "multiple_response",
+  "short_answer",
+  "numeric",
+  "fill_in_the_blanks",
+  "sequence",
+  "matching",
+  "drag_and_drop"
+];
+var BloomLevelStringsEnum = import_genkit13.z.enum(["remembering", "understanding", "applying"]);
+var GenerateQuizPlanInputSchema = import_genkit13.z.object({
+  totalQuestions: import_genkit13.z.number().int().min(1).max(100).describe("Total number of questions for the quiz (1-100)."),
+  topics: import_genkit13.z.array(
+    import_genkit13.z.object({
+      topic: import_genkit13.z.string().min(1, { message: "Topic name cannot be empty." }).describe("Name of the topic."),
+      ratio: import_genkit13.z.number().min(0).max(100).describe("Percentage of questions for this topic (0-100).")
+    })
+  ).min(1, { message: "At least one topic is required." }).describe("List of topics and their desired percentage distribution."),
+  bloomLevels: import_genkit13.z.array(
+    import_genkit13.z.object({
+      level: BloomLevelStringsEnum.describe("Bloom's taxonomy level."),
+      ratio: import_genkit13.z.number().min(0).max(100).describe("Percentage of questions for this Bloom level (0-100).")
+    })
+  ).min(1, { message: "At least one Bloom level distribution is required." }).describe("Desired distribution of Bloom's levels across the quiz."),
+  selectedContextIds: import_genkit13.z.array(import_genkit13.z.string()).optional().describe('Array of IDs for contexts relevant to the quiz (e.g., "THEO_ABS", "REAL_PROB"). These are hints for the AI.'),
+  selectedQuestionTypes: import_genkit13.z.array(import_genkit13.z.enum(fullQuizSupportedQuestionTypesArray)).min(1, { message: "At least one question type must be selected." }).describe("Array of question types to be used in the quiz. Must not include Hotspot or Blockly types.")
+});
+var PlannedQuestionSchema = import_genkit13.z.object({
+  plannedTopic: import_genkit13.z.string().describe("The specific topic for this question, derived from the input topics and ratios."),
+  plannedQuestionType: import_genkit13.z.enum(fullQuizSupportedQuestionTypesArray).describe("The specific question type chosen for this question from the allowed types."),
+  plannedBloomLevel: BloomLevelStringsEnum.describe("The Bloom's level assigned to this question based on overall distribution.")
+});
+var GenerateQuizPlanOutputSchema = import_genkit13.z.object({
+  quizPlan: import_genkit13.z.array(PlannedQuestionSchema).describe("A detailed plan for each question in the quiz, specifying topic, type, and Bloom level.")
+});
+async function generateQuizPlan(input) {
+  const totalTopicRatio = input.topics.reduce((sum, t) => sum + t.ratio, 0);
+  if (Math.abs(totalTopicRatio - 100) > 0.1 && input.topics.length > 0) {
+    throw new Error(`Total topic ratio must be 100%. Current sum: ${totalTopicRatio.toFixed(1)}%`);
+  }
+  const totalBloomRatio = input.bloomLevels.reduce((sum, b) => sum + b.ratio, 0);
+  if (Math.abs(totalBloomRatio - 100) > 0.1) {
+    throw new Error(`Total Bloom level ratio must be 100%. Current sum: ${totalBloomRatio.toFixed(1)}%`);
+  }
+  if (input.totalQuestions <= 0 || input.totalQuestions > 100) {
+    throw new Error("Total questions must be between 1 and 100.");
+  }
+  if (input.selectedQuestionTypes.length === 0) {
+    throw new Error("At least one question type must be selected.");
+  }
+  if (input.selectedQuestionTypes.some((qt) => qt === "hotspot" || qt === "blockly_programming" || qt === "scratch_programming")) {
+    throw new Error("Selected question types must not include Hotspot, Blockly Programming, or Scratch Programming for this flow.");
+  }
+  return generateQuizPlanFlow(input);
+}
+var quizPlannerAIPrompt = ai.definePrompt({
+  name: "quizPlannerAIPrompt",
+  input: { schema: GenerateQuizPlanInputSchema },
+  output: { schema: GenerateQuizPlanOutputSchema },
+  prompt: `You are an expert educational content planner specializing in creating balanced and effective quiz blueprints.
+Your task is to generate a detailed plan for a quiz consisting of exactly {{{totalQuestions}}} questions.
+The plan should be an array of objects, where each object represents one question and specifies its 'plannedTopic', 'plannedQuestionType', and 'plannedBloomLevel'.
+
+Constraints and Guidelines:
+1.  **Total Questions**: The output 'quizPlan' array must contain exactly {{{totalQuestions}}} elements.
+2.  **Topic Distribution**: Distribute the questions across the following topics according to their specified ratios. Aim to match these ratios as closely as possible.
+    {{#each topics}}
+    - Topic: "{{this.topic}}", Ratio: {{this.ratio}}%
+    {{/each}}
+3.  **Bloom Level Distribution**: Distribute the questions across the following Bloom's Taxonomy levels according to their specified ratios. This distribution applies to the entire quiz.
+    {{#each bloomLevels}}
+    - Level: "{{this.level}}", Ratio: {{this.ratio}}%
+    {{/each}}
+4.  **Question Types**: For each planned question, select a 'plannedQuestionType' from the following allowed types: {{#each selectedQuestionTypes}}{{{this}}}{{#unless @last}}, {{/unless}}{{/each}}. Try to use a variety of these selected types throughout the quiz, if appropriate for the topics and Bloom levels. The available types are: ${fullQuizSupportedQuestionTypesArray.map((q) => `'${q}'`).join(", ")}.
+5.  **Contexts (Informational)**: The user has indicated the following general contexts are relevant to the quiz: {{#if selectedContextIds}}{{#each selectedContextIds}}{{{this}}}{{#unless @last}}, {{/unless}}{{/each}}{{else}}None specified{{/if}}. You don't need to explicitly assign a context ID to each planned question in your output, but keep these in mind when deciding on topic nuances or type suitability, if applicable. The actual detailed question generation later will handle context.
+6.  **Output Format**: Ensure your output is a JSON object containing a single key "quizPlan", which is an array of question plan objects. Each question plan object must have "plannedTopic" (string), "plannedQuestionType" (one of the allowed enum values specified in guideline 4), and "plannedBloomLevel" (one of the allowed enum values: 'remembering', 'understanding', 'applying').
+
+Example of a single element in the 'quizPlan' array:
+{
+  "plannedTopic": "Cellular Respiration Stages",
+  "plannedQuestionType": "multiple_choice",
+  "plannedBloomLevel": "understanding"
+}
+
+Carefully calculate the number of questions for each topic and Bloom level based on the total number of questions and the provided ratios. Strive for a balanced and logical distribution.
+If ratios lead to fractional questions, round to the nearest whole number in a way that maintains the total number of questions.
+The 'plannedTopic' for each question should be specific and directly related to one of the user-provided topics.
+The final 'quizPlan' array must have exactly {{{totalQuestions}}} elements.
+`
+});
+var generateQuizPlanFlow = ai.defineFlow(
+  {
+    name: "generateQuizPlanFlow",
+    inputSchema: GenerateQuizPlanInputSchema,
+    outputSchema: GenerateQuizPlanOutputSchema
+  },
+  async (input) => {
+    try {
+      const { output } = await quizPlannerAIPrompt(input);
+      if (!output || !output.quizPlan) {
+        throw new Error("AI did not return a quiz plan.");
+      }
+      if (output.quizPlan.length !== input.totalQuestions) {
+        console.warn(`AI generated a plan for ${output.quizPlan.length} questions, but ${input.totalQuestions} were requested. This is an error in AI adherence.`);
+        throw new Error(`AI planned for ${output.quizPlan.length} questions, but ${input.totalQuestions} were requested. The plan must match the total number of questions.`);
+      }
+      output.quizPlan.forEach((item, index) => {
+        if (!input.selectedQuestionTypes.includes(item.plannedQuestionType)) {
+          throw new Error(`AI planned question ${index + 1} with an invalid or disallowed question type: ${item.plannedQuestionType}`);
+        }
+        const validBloomLevels = ["remembering", "understanding", "applying"];
+        if (!validBloomLevels.includes(item.plannedBloomLevel)) {
+          throw new Error(`AI planned question ${index + 1} with an invalid Bloom level: ${item.plannedBloomLevel}`);
+        }
+        if (!input.topics.some((t) => t.topic === item.plannedTopic)) {
+          console.warn(`AI planned question ${index + 1} with topic "${item.plannedTopic}" which was not in the input topics. This might be an AI interpretation or error.`);
+        }
+      });
+      return output;
+    } catch (error) {
+      console.error("Error generating Quiz Plan in flow:", error);
+      throw new Error(`Failed to generate Quiz Plan: ${error.message}`);
+    }
+  }
+);
+
+// src/ai/flows/generate-sequence-question.ts
+var import_genkit15 = require("genkit");
+var GenerateSequenceQuestionInputSchema = import_genkit15.z.object({
+  topic: import_genkit15.z.string().describe("The topic for the question."),
+  difficulty: import_genkit15.z.enum(["easy", "medium", "hard"]).optional().default("medium"),
+  numberOfItems: import_genkit15.z.number().int().min(2).max(10).optional().default(4).describe("Number of items to sequence (2-10)."),
+  contextDescription: import_genkit15.z.string().optional().describe("A specific context or scenario for the question, complementing the main topic."),
+  selectedContextId: import_genkit15.z.string().optional().describe("The ID of the selected context, if any.")
+});
+var AISequenceOutputFieldsSchema = import_genkit15.z.object({
+  prompt: import_genkit15.z.string().describe("The instruction for sequencing (e.g., 'Arrange the following steps in chronological order.')."),
+  itemsContent: import_genkit15.z.array(import_genkit15.z.string()).min(2).describe("An array of strings, where each string is the content of an item to be sequenced. The order here can be random or pre-sorted by AI, it doesn't matter for this field."),
+  correctOrderContent: import_genkit15.z.array(import_genkit15.z.string()).min(2).describe("An array of strings representing the content of the items in the correct sequence. Each string here MUST match one of the strings in 'itemsContent'."),
+  explanation: import_genkit15.z.string().optional().describe("Explanation for the correct sequence."),
+  points: import_genkit15.z.number().optional().default(10),
+  difficulty: import_genkit15.z.enum(["easy", "medium", "hard"]).optional(),
+  topic: import_genkit15.z.string().optional()
+});
+var SequenceQuestionZodSchema = import_genkit15.z.object({
+  id: import_genkit15.z.string(),
+  questionType: import_genkit15.z.literal("sequence"),
+  prompt: import_genkit15.z.string(),
+  items: import_genkit15.z.array(import_genkit15.z.object({ id: import_genkit15.z.string(), content: import_genkit15.z.string() })),
+  correctOrder: import_genkit15.z.array(import_genkit15.z.string()),
+  // Array of item IDs
+  points: import_genkit15.z.number().optional(),
+  explanation: import_genkit15.z.string().optional(),
+  learningObjective: import_genkit15.z.string().optional(),
+  glossary: import_genkit15.z.array(import_genkit15.z.string()).optional(),
+  bloomLevel: import_genkit15.z.string().optional(),
+  difficulty: import_genkit15.z.enum(["easy", "medium", "hard"]).optional(),
+  contextCode: import_genkit15.z.string().optional(),
+  gradeBand: import_genkit15.z.string().optional(),
+  course: import_genkit15.z.string().optional(),
+  category: import_genkit15.z.string().optional(),
+  topic: import_genkit15.z.string().optional()
+});
+var GenerateSequenceQuestionOutputSchema = import_genkit15.z.object({
+  question: SequenceQuestionZodSchema.optional().describe("The generated Sequence question.")
+});
+async function generateSequenceQuestion(input) {
+  return generateSequenceQuestionFlow(input);
+}
+var sequenceAIPrompt = ai.definePrompt({
+  name: "sequenceQuestionGeneratorPrompt",
+  input: { schema: GenerateSequenceQuestionInputSchema },
+  output: { schema: AISequenceOutputFieldsSchema },
+  prompt: `You are an expert quiz question writer.
+Generate a single Sequence question with exactly {{{numberOfItems}}} items to be ordered.
+Provide:
+1.  A 'prompt' or instruction.
+2.  An 'itemsContent' array: strings for each item (e.g., ["Event A", "Event B", "Event C"]). The order here doesn't matter yet.
+3.  A 'correctOrderContent' array: strings from 'itemsContent' but in the correct sequence.
+4.  Optional 'explanation', 'points' (default 10), refined 'topic', and 'difficulty'.
+
+Topic: {{{topic}}}
+{{#if contextDescription}}
+Context: {{{contextDescription}}}
+{{/if}}
+Difficulty: {{{difficulty}}}
+Number of Items: {{{numberOfItems}}}
+
+Ensure 'itemsContent' and 'correctOrderContent' contain the same set of strings, and 'correctOrderContent' has exactly {{{numberOfItems}}} elements.
+Ensure your output strictly matches the requested JSON schema.
+`
+});
+var generateSequenceQuestionFlow = ai.defineFlow(
+  {
+    name: "generateSequenceQuestionFlow",
+    inputSchema: GenerateSequenceQuestionInputSchema,
+    outputSchema: GenerateSequenceQuestionOutputSchema
+  },
+  async (input) => {
+    try {
+      const { output: aiGeneratedContent } = await sequenceAIPrompt(input);
+      if (aiGeneratedContent) {
+        if (aiGeneratedContent.itemsContent.length !== input.numberOfItems || aiGeneratedContent.correctOrderContent.length !== input.numberOfItems) {
+          throw new Error(`AI generated ${aiGeneratedContent.itemsContent.length} itemsContent and ${aiGeneratedContent.correctOrderContent.length} correctOrderContent, but ${input.numberOfItems} were requested.`);
+        }
+        const contentToIdMap = {};
+        const finalItems = aiGeneratedContent.itemsContent.map((content) => {
+          const id = generateUniqueId("seqi_");
+          contentToIdMap[content] = id;
+          return { id, content };
+        });
+        const finalCorrectOrder = aiGeneratedContent.correctOrderContent.map((content) => {
+          const id = contentToIdMap[content];
+          if (!id) {
+            throw new Error(`Content "${content}" in 'correctOrderContent' does not match any content in 'itemsContent'.`);
+          }
+          return id;
+        });
+        if (new Set(finalCorrectOrder).size !== finalItems.length) {
+          throw new Error("Correct order does not contain all items from itemsContent uniquely or items are missing/duplicated.");
+        }
+        const completeQuestion = {
+          id: generateUniqueId("seq_ai_"),
+          questionType: "sequence",
+          prompt: aiGeneratedContent.prompt,
+          items: finalItems,
+          correctOrder: finalCorrectOrder,
+          explanation: aiGeneratedContent.explanation,
+          points: aiGeneratedContent.points,
+          topic: aiGeneratedContent.topic || input.topic,
+          difficulty: aiGeneratedContent.difficulty || input.difficulty,
+          contextCode: input.contextDescription ? input.selectedContextId : void 0
+        };
+        return { question: completeQuestion };
+      } else {
+        throw new Error("AI did not return content for the Sequence question.");
+      }
+    } catch (error) {
+      console.error("Error generating Sequence question in flow:", error);
+      throw new Error(`Failed to generate Sequence question: ${error.message}`);
+    }
+  }
+);
+
+// src/ai/flows/generate-short-answer-question.ts
+var import_genkit17 = require("genkit");
+var GenerateShortAnswerQuestionInputSchema = import_genkit17.z.object({
+  topic: import_genkit17.z.string().describe("The topic for the question."),
+  difficulty: import_genkit17.z.enum(["easy", "medium", "hard"]).optional().default("medium"),
+  isCaseSensitive: import_genkit17.z.boolean().optional().default(false).describe("Whether the answer should be case-sensitive."),
+  contextDescription: import_genkit17.z.string().optional().describe("A specific context or scenario for the question, complementing the main topic."),
+  selectedContextId: import_genkit17.z.string().optional().describe("The ID of the selected context, if any.")
+});
+var AIShortAnswerOutputFieldsSchema = import_genkit17.z.object({
+  prompt: import_genkit17.z.string().describe("The question statement."),
+  acceptedAnswers: import_genkit17.z.array(import_genkit17.z.string()).min(1).describe("An array of acceptable short answers. Provide variations if appropriate."),
+  isCaseSensitive: import_genkit17.z.boolean().optional().describe("Should the answer evaluation be case sensitive? Defaults to input or false."),
+  explanation: import_genkit17.z.string().optional().describe("Explanation for the correct answer(s)."),
+  points: import_genkit17.z.number().optional().default(10),
+  difficulty: import_genkit17.z.enum(["easy", "medium", "hard"]).optional(),
+  topic: import_genkit17.z.string().optional()
+});
+var ShortAnswerQuestionZodSchema = import_genkit17.z.object({
+  id: import_genkit17.z.string(),
+  questionType: import_genkit17.z.literal("short_answer"),
+  prompt: import_genkit17.z.string(),
+  acceptedAnswers: import_genkit17.z.array(import_genkit17.z.string()),
+  isCaseSensitive: import_genkit17.z.boolean().optional(),
+  points: import_genkit17.z.number().optional(),
+  explanation: import_genkit17.z.string().optional(),
+  learningObjective: import_genkit17.z.string().optional(),
+  glossary: import_genkit17.z.array(import_genkit17.z.string()).optional(),
+  bloomLevel: import_genkit17.z.string().optional(),
+  difficulty: import_genkit17.z.enum(["easy", "medium", "hard"]).optional(),
+  contextCode: import_genkit17.z.string().optional(),
+  gradeBand: import_genkit17.z.string().optional(),
+  course: import_genkit17.z.string().optional(),
+  category: import_genkit17.z.string().optional(),
+  topic: import_genkit17.z.string().optional()
+});
+var GenerateShortAnswerQuestionOutputSchema = import_genkit17.z.object({
+  question: ShortAnswerQuestionZodSchema.optional().describe("The generated Short Answer question.")
+});
+async function generateShortAnswerQuestion(input) {
+  return generateShortAnswerQuestionFlow(input);
+}
+var shortAnswerAIPrompt = ai.definePrompt({
+  name: "shortAnswerQuestionGeneratorPrompt",
+  input: { schema: GenerateShortAnswerQuestionInputSchema },
+  output: { schema: AIShortAnswerOutputFieldsSchema },
+  prompt: `You are an expert quiz question writer.
+Generate a single Short Answer question based on the following inputs.
+Provide the question prompt, an array of accepted answer strings, and specify if case sensitivity is important (default to {{{isCaseSensitive}}}).
+Also include an optional explanation, points (default 10), and optionally refine the topic/difficulty.
+
+Topic: {{{topic}}}
+{{#if contextDescription}}
+Context: {{{contextDescription}}}
+{{/if}}
+Difficulty: {{{difficulty}}}
+Case Sensitive: {{{isCaseSensitive}}}
+
+Ensure your output strictly matches the requested JSON schema.
+`
+});
+var generateShortAnswerQuestionFlow = ai.defineFlow(
+  {
+    name: "generateShortAnswerQuestionFlow",
+    inputSchema: GenerateShortAnswerQuestionInputSchema,
+    outputSchema: GenerateShortAnswerQuestionOutputSchema
+  },
+  async (input) => {
+    try {
+      const { output: aiGeneratedContent } = await shortAnswerAIPrompt(input);
+      if (aiGeneratedContent) {
+        const completeQuestion = {
+          id: generateUniqueId("saq_ai_"),
+          questionType: "short_answer",
+          prompt: aiGeneratedContent.prompt,
+          acceptedAnswers: aiGeneratedContent.acceptedAnswers,
+          isCaseSensitive: aiGeneratedContent.isCaseSensitive === void 0 ? input.isCaseSensitive : aiGeneratedContent.isCaseSensitive,
+          explanation: aiGeneratedContent.explanation,
+          points: aiGeneratedContent.points,
+          topic: aiGeneratedContent.topic || input.topic,
+          difficulty: aiGeneratedContent.difficulty || input.difficulty,
+          contextCode: input.contextDescription ? input.selectedContextId : void 0
+        };
+        return { question: completeQuestion };
+      } else {
+        throw new Error("AI did not return content for the Short Answer question.");
+      }
+    } catch (error) {
+      console.error("Error generating Short Answer question in flow:", error);
+      throw new Error(`Failed to generate Short Answer question: ${error.message}`);
+    }
+  }
+);
+
+// src/ai/flows/generate-true-false-question.ts
+var import_genkit19 = require("genkit");
+var GenerateTrueFalseQuestionInputSchema = import_genkit19.z.object({
+  topic: import_genkit19.z.string().describe("The topic for which to generate a True/False question."),
+  difficulty: import_genkit19.z.enum(["easy", "medium", "hard"]).optional().default("medium").describe("The difficulty level of the question (optional)."),
+  contextDescription: import_genkit19.z.string().optional().describe("A specific context or scenario for the question, complementing the main topic."),
+  selectedContextId: import_genkit19.z.string().optional().describe("The ID of the selected context, if any.")
+});
+var AIQuestionOutputFieldsSchema = import_genkit19.z.object({
+  prompt: import_genkit19.z.string().describe("The question text itself. This is the statement to be evaluated as true or false."),
+  correctAnswer: import_genkit19.z.boolean().describe("The correct answer for the statement (true if the statement is true, false if it is false)."),
+  explanation: import_genkit19.z.string().optional().describe("A brief explanation of why the answer is correct."),
+  points: import_genkit19.z.number().optional().default(10).describe("Points awarded for a correct answer. Defaults to 10."),
+  difficulty: import_genkit19.z.enum(["easy", "medium", "hard"]).optional().describe("The assessed difficulty of the generated question."),
+  topic: import_genkit19.z.string().optional().describe("The specific topic of the generated question, potentially refined from the input topic.")
+});
+var TrueFalseQuestionZodSchema = import_genkit19.z.object({
+  id: import_genkit19.z.string(),
+  questionType: import_genkit19.z.literal("true_false"),
+  prompt: import_genkit19.z.string(),
+  correctAnswer: import_genkit19.z.boolean(),
+  points: import_genkit19.z.number().optional(),
+  explanation: import_genkit19.z.string().optional(),
+  learningObjective: import_genkit19.z.string().optional(),
+  glossary: import_genkit19.z.array(import_genkit19.z.string()).optional(),
+  bloomLevel: import_genkit19.z.string().optional(),
+  difficulty: import_genkit19.z.enum(["easy", "medium", "hard"]).optional(),
+  contextCode: import_genkit19.z.string().optional(),
+  gradeBand: import_genkit19.z.string().optional(),
+  course: import_genkit19.z.string().optional(),
+  category: import_genkit19.z.string().optional(),
+  topic: import_genkit19.z.string().optional()
+});
+var GenerateTrueFalseQuestionOutputSchema = import_genkit19.z.object({
+  question: TrueFalseQuestionZodSchema.optional().describe("The generated True/False question.")
+});
+async function generateTrueFalseQuestion(input) {
+  return generateTrueFalseQuestionFlow(input);
+}
+var trueFalseAIPrompt = ai.definePrompt({
+  name: "trueFalseQuestionGeneratorPrompt",
+  input: { schema: GenerateTrueFalseQuestionInputSchema },
+  output: { schema: AIQuestionOutputFieldsSchema },
+  prompt: `You are an expert quiz question writer.
+Generate a single True/False question based on the following inputs.
+The question should be a statement that can be clearly evaluated as true or false.
+Provide the question statement (prompt), the correct answer (true or false), an optional explanation, optional points (default to 10), and optionally refine the topic and difficulty.
+
+Topic: {{{topic}}}
+{{#if contextDescription}}
+Context: {{{contextDescription}}}
+{{/if}}
+Difficulty: {{{difficulty}}}
+
+Ensure your output strictly matches the requested JSON schema.
+`
+});
+var generateTrueFalseQuestionFlow = ai.defineFlow(
+  {
+    name: "generateTrueFalseQuestionFlow",
+    inputSchema: GenerateTrueFalseQuestionInputSchema,
+    outputSchema: GenerateTrueFalseQuestionOutputSchema
+  },
+  async (input) => {
+    try {
+      const { output: aiGeneratedContent } = await trueFalseAIPrompt(input);
+      if (aiGeneratedContent) {
+        const completeQuestion = {
+          prompt: aiGeneratedContent.prompt,
+          correctAnswer: aiGeneratedContent.correctAnswer,
+          explanation: aiGeneratedContent.explanation,
+          points: aiGeneratedContent.points,
+          topic: aiGeneratedContent.topic || input.topic,
+          difficulty: aiGeneratedContent.difficulty || input.difficulty,
+          id: generateUniqueId("tf_ai_"),
+          questionType: "true_false",
+          learningObjective: void 0,
+          glossary: void 0,
+          bloomLevel: void 0,
+          contextCode: input.contextDescription ? input.selectedContextId : void 0,
+          gradeBand: void 0,
+          course: void 0,
+          category: void 0
+        };
+        return { question: completeQuestion };
+      } else {
+        throw new Error("AI did not return content for the question.");
+      }
+    } catch (error) {
+      console.error("Error generating True/False question in flow:", error);
+      throw new Error(`Failed to generate True/False question: ${error.message}`);
+    }
+  }
+);
+
+// src/ai/flows/generateQuestionsFromQuizPlanFlow.ts
+var import_genkit21 = require("genkit");
+var internalContextOptions = [
+  { contextId: "THEO_ABS", contextDescription: "L\xFD thuy\u1EBFt/Tr\u1EEBu t\u01B0\u1EE3ng" },
+  { contextId: "SPEC_CASE", contextDescription: "V\xED d\u1EE5 C\u1EE5 th\u1EC3/Tr\u01B0\u1EDDng h\u1EE3p Ri\xEAng" },
+  { contextId: "NAT_OBS", contextDescription: "Hi\u1EC7n t\u01B0\u1EE3ng T\u1EF1 nhi\xEAn/Quan s\xE1t" },
+  { contextId: "TECH_ENG", contextDescription: "\u1EE8ng d\u1EE5ng C\xF4ng ngh\u1EC7/K\u1EF9 thu\u1EADt" },
+  { contextId: "EXP_INV", contextDescription: "Th\xED nghi\u1EC7m/\u0110i\u1EC1u tra Khoa h\u1ECDc" },
+  { contextId: "REAL_PROB", contextDescription: "V\u1EA5n \u0111\u1EC1 Th\u1EF1c t\u1EBF/X\xE3 h\u1ED9i/M\xF4i tr\u01B0\u1EDDng" },
+  { contextId: "DATA_MOD", contextDescription: "Di\u1EC5n gi\u1EA3i D\u1EEF li\u1EC7u/M\xF4 h\xECnh h\xF3a" },
+  { contextId: "HIST_SCI", contextDescription: "L\u1ECBch s\u1EED/Ph\xE1t tri\u1EC3n Khoa h\u1ECDc" },
+  { contextId: "INTERDISC", contextDescription: "Li\xEAn ng\xE0nh (Interdisciplinary)" },
+  { contextId: "HYPO_COMP", contextDescription: "Gi\u1EA3 \u0111\u1ECBnh/So s\xE1nh T\xECnh hu\u1ED1ng" }
+];
+var LocalBloomLevelStringsEnum = import_genkit21.z.enum(["remembering", "understanding", "applying"]);
+var fullQuizSupportedQuestionTypesArrayForSchema = [
+  "true_false",
+  "multiple_choice",
+  "multiple_response",
+  "short_answer",
+  "numeric",
+  "fill_in_the_blanks",
+  "sequence",
+  "matching",
+  "drag_and_drop"
+];
+var LocalPlannedQuestionSchema = import_genkit21.z.object({
+  plannedTopic: import_genkit21.z.string().describe("The specific topic for this question, derived from the input topics and ratios."),
+  plannedQuestionType: import_genkit21.z.enum(fullQuizSupportedQuestionTypesArrayForSchema).describe("The specific question type chosen for this question from the allowed types."),
+  plannedBloomLevel: LocalBloomLevelStringsEnum.describe("The Bloom's level assigned to this question based on overall distribution.")
+});
+var GenerateQuestionsFromQuizPlanInputSchema = import_genkit21.z.object({
+  quizPlan: import_genkit21.z.array(LocalPlannedQuestionSchema).describe("The plan for each question, from Stage 1."),
+  selectedContextIds: import_genkit21.z.array(import_genkit21.z.string()).optional().describe("Array of IDs for contexts relevant to the overall quiz."),
+  customContextInput: import_genkit21.z.string().optional().describe("Custom context description if provided by the user.")
+});
+var GenerationErrorSchema = import_genkit21.z.object({
+  plannedQuestionIndex: import_genkit21.z.number().describe("Index of the question in the plan that failed."),
+  plannedTopic: import_genkit21.z.string(),
+  plannedQuestionType: import_genkit21.z.string(),
+  error: import_genkit21.z.string().describe("Error message for this specific question generation.")
+});
+var GenerateQuestionsFromQuizPlanOutputSchema = import_genkit21.z.object({
+  generatedQuestions: import_genkit21.z.array(import_genkit21.z.custom((val) => typeof val === "object" && val !== null && "id" in val && "questionType" in val)).describe("Array of successfully generated QuizQuestion objects."),
+  errors: import_genkit21.z.array(GenerationErrorSchema).optional().describe("Array of errors encountered during generation for specific planned questions.")
+});
+var calculateCombinedDifficulty = (contextId, bloomLevel, qType, generalCustomContextInput) => {
+  let contextScore = 1;
+  const selectedContext = contextId ? internalContextOptions.find((c) => c.contextId === contextId) : void 0;
+  if (selectedContext) {
+    if (["THEO_ABS", "HIST_SCI"].includes(selectedContext.contextId)) contextScore = 1;
+    else if (["SPEC_CASE", "NAT_OBS", "DATA_MOD", "INTERDISC", "HYPO_COMP"].includes(selectedContext.contextId)) contextScore = 2;
+    else if (["TECH_ENG", "EXP_INV", "REAL_PROB"].includes(selectedContext.contextId)) contextScore = 3;
+  } else if (generalCustomContextInput && generalCustomContextInput.trim()) {
+    contextScore = 2;
+  }
+  let bloomScore = 1;
+  if (bloomLevel === "understanding") bloomScore = 2;
+  else if (bloomLevel === "applying") bloomScore = 3;
+  let questionTypeScore = 1;
+  switch (qType) {
+    case "true_false":
+    case "multiple_choice":
+    case "short_answer":
+      questionTypeScore = 1;
+      break;
+    case "matching":
+    case "fill_in_the_blanks":
+    case "numeric":
+      questionTypeScore = 2;
+      break;
+    case "sequence":
+    case "multiple_response":
+    case "drag_and_drop":
+      questionTypeScore = 3;
+      break;
+    default:
+      questionTypeScore = 1;
+  }
+  const totalScore = bloomScore + contextScore + questionTypeScore;
+  if (totalScore <= 4) return "easy";
+  if (totalScore <= 6) return "medium";
+  return "hard";
+};
+async function generateQuestionsFromQuizPlan(input) {
+  return generateQuestionsFromQuizPlanFlow(input);
+}
+var generateQuestionsFromQuizPlanFlow = ai.defineFlow(
+  {
+    name: "generateQuestionsFromQuizPlanFlow",
+    inputSchema: GenerateQuestionsFromQuizPlanInputSchema,
+    outputSchema: GenerateQuestionsFromQuizPlanOutputSchema
+  },
+  async ({ quizPlan, selectedContextIds, customContextInput }) => {
+    var _a, _b;
+    const generatedQuestions = [];
+    const errors = [];
+    for (let i = 0; i < quizPlan.length; i++) {
+      const plannedQ = quizPlan[i];
+      let question = void 0;
+      let generationError = null;
+      let contextDescriptionForAI = void 0;
+      let contextIdForDifficultyCalc = plannedQ.plannedContextId;
+      if (plannedQ.plannedContextId && plannedQ.plannedContextId !== "__custom__") {
+        contextDescriptionForAI = (_a = internalContextOptions.find((c) => c.contextId === plannedQ.plannedContextId)) == null ? void 0 : _a.contextDescription;
+      } else if (selectedContextIds && selectedContextIds.length > 0 && selectedContextIds[0] !== "__custom__") {
+        contextDescriptionForAI = (_b = internalContextOptions.find((c) => c.contextId === selectedContextIds[0])) == null ? void 0 : _b.contextDescription;
+        if (!contextIdForDifficultyCalc) contextIdForDifficultyCalc = selectedContextIds[0];
+      } else if (customContextInput && customContextInput.trim()) {
+        contextDescriptionForAI = customContextInput.trim();
+        if (!contextIdForDifficultyCalc) contextIdForDifficultyCalc = "__custom__";
+      }
+      const difficultyForAI = calculateCombinedDifficulty(
+        contextIdForDifficultyCalc,
+        plannedQ.plannedBloomLevel,
+        plannedQ.plannedQuestionType,
+        contextDescriptionForAI
+      );
+      const baseQuestionInput = {
+        topic: plannedQ.plannedTopic,
+        difficulty: difficultyForAI,
+        contextDescription: contextDescriptionForAI,
+        selectedContextId: plannedQ.plannedContextId
+      };
+      try {
+        switch (plannedQ.plannedQuestionType) {
+          case "true_false":
+            ({ question } = await generateTrueFalseQuestion(baseQuestionInput));
+            break;
+          case "multiple_choice":
+            ({ question } = await generateMCQQuestion(__spreadProps(__spreadValues({}, baseQuestionInput), { numberOfOptions: 4 })));
+            break;
+          case "multiple_response":
+            ({ question } = await generateMRQQuestion(__spreadProps(__spreadValues({}, baseQuestionInput), { numberOfOptions: 5, minCorrectAnswers: 2, maxCorrectAnswers: 3 })));
+            break;
+          case "short_answer":
+            ({ question } = await generateShortAnswerQuestion(__spreadProps(__spreadValues({}, baseQuestionInput), { isCaseSensitive: false })));
+            break;
+          case "numeric":
+            ({ question } = await generateNumericQuestion(__spreadProps(__spreadValues({}, baseQuestionInput), { allowDecimals: true })));
+            break;
+          case "fill_in_the_blanks":
+            ({ question } = await generateFillInTheBlanksQuestion(__spreadProps(__spreadValues({}, baseQuestionInput), { numberOfBlanks: 2, isCaseSensitive: false })));
+            break;
+          case "sequence":
+            ({ question } = await generateSequenceQuestion(__spreadProps(__spreadValues({}, baseQuestionInput), { numberOfItems: 4 })));
+            break;
+          case "matching":
+            ({ question } = await generateMatchingQuestion(__spreadProps(__spreadValues({}, baseQuestionInput), { numberOfPairs: 4 })));
+            break;
+          case "drag_and_drop":
+            generationError = `Question type "drag_and_drop" is planned but generation is not yet supported.`;
+            console.warn(`Skipping Drag and Drop question generation for topic: ${plannedQ.plannedTopic}. Not implemented.`);
+            break;
+          default:
+            generationError = `Question type "${plannedQ.plannedQuestionType}" is not supported for automated generation in this flow.`;
+        }
+        if (question) {
+          question.topic = plannedQ.plannedTopic;
+          question.bloomLevel = plannedQ.plannedBloomLevel;
+          question.difficulty = difficultyForAI;
+          question.contextCode = plannedQ.plannedContextId || (contextDescriptionForAI ? (selectedContextIds == null ? void 0 : selectedContextIds[0]) || "__custom__" : void 0);
+          if (question.points === void 0) question.points = 10;
+          generatedQuestions.push(question);
+        } else if (!generationError) {
+          generationError = `AI did not return a question object for ${plannedQ.plannedQuestionType}.`;
+        }
+      } catch (e) {
+        generationError = e.message || `Unknown error generating ${plannedQ.plannedQuestionType} question for topic ${plannedQ.plannedTopic}.`;
+      }
+      if (generationError) {
+        console.error(`Error during Stage 2 generation for planned question index ${i}: ${generationError}`);
+        errors.push({
+          plannedQuestionIndex: i,
+          plannedTopic: plannedQ.plannedTopic,
+          plannedQuestionType: plannedQ.plannedQuestionType,
+          error: generationError
+        });
+      }
+    }
+    return { generatedQuestions, errors: errors.length > 0 ? errors : void 0 };
+  }
+);
+
+// src/utils/utils.ts
+var import_clsx = require("clsx");
+var import_tailwind_merge = require("tailwind-merge");
+function cn(...inputs) {
+  return (0, import_tailwind_merge.twMerge)((0, import_clsx.clsx)(inputs));
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  QuizEngine,
+  SCORMService,
+  cn,
+  emptyQuiz,
+  exportQuizAsSCORMZip,
+  generateFillInTheBlanksQuestion,
+  generateLauncherHTML,
+  generateMCQQuestion,
+  generateMRQQuestion,
+  generateMatchingQuestion,
+  generateNumericQuestion,
+  generateQuestionsFromQuizPlan,
+  generateQuizPlan,
+  generateSCORMManifest,
+  generateSequenceQuestion,
+  generateShortAnswerQuestion,
+  generateTrueFalseQuestion,
+  generateUniqueId,
+  sampleQuiz
+});