@lessonkit/lxpack 1.1.0 → 1.2.0

package/dist/index.cjs

@@ -61,97 +61,79 @@ __export(index_exports, {
 });
 module.exports = __toCommonJS(index_exports);
 
-// src/validateDescriptor.ts
+// src/descriptor/normalize.ts
 var import_core = require("@lessonkit/core");
-
-// src/spaPath.ts
-var import_node_fs = require("fs");
-var import_node_path = require("path");
-function resolveComparablePath(p) {
-  if (/^[a-zA-Z]:[/\\]/.test(p)) {
-    return import_node_path.win32.resolve(p);
-  }
-  return (0, import_node_path.resolve)(p);
-}
-function isSafeRelativeSpaPath(spaPath) {
-  if (!spaPath.length || spaPath.includes("\0")) return false;
-  if (spaPath.startsWith("/") || spaPath.startsWith("\\")) return false;
-  if (/^[a-zA-Z]:/.test(spaPath)) return false;
-  if (spaPath === "." || spaPath === "./") return false;
-  const segments = spaPath.split(/[/\\]/).filter((s) => s.length > 0 && s !== ".");
-  if (segments.some((s) => s === "..")) return false;
-  return segments.length > 0;
-}
-function assertResolvedPathUnderRoot(root, target) {
-  const rootResolved = resolveComparablePath(root);
-  const targetResolved = resolveComparablePath(target);
-  const prefix = rootResolved.endsWith(import_node_path.sep) ? rootResolved : rootResolved + import_node_path.sep;
-  const win32Prefix = rootResolved.endsWith(import_node_path.win32.sep) ? rootResolved : rootResolved + import_node_path.win32.sep;
-  if (targetResolved !== rootResolved && !targetResolved.startsWith(prefix) && /* v8 ignore next */
-  !targetResolved.startsWith(win32Prefix)) {
-    throw new Error(`unsafe path escapes project root: ${target}`);
-  }
-}
-function assertRealPathUnderRoot(root, target) {
-  const rootResolved = resolveComparablePath(root);
-  const targetResolved = resolveComparablePath(target);
-  let rootReal;
-  try {
-    rootReal = (0, import_node_fs.realpathSync)(rootResolved);
-  } catch {
-    rootReal = rootResolved;
-  }
-  let targetCheck;
-  try {
-    targetCheck = (0, import_node_fs.realpathSync)(targetResolved);
-  } catch {
-    const rel = (0, import_node_path.relative)(rootResolved, targetResolved);
-    if (rel.startsWith("..") || rel.includes(`..${import_node_path.sep}`)) {
-      throw new Error(`unsafe path escapes project root: ${target}`);
-    }
-    targetCheck = (0, import_node_path.resolve)(rootReal, rel);
-  }
-  assertResolvedPathUnderRoot(rootReal, targetCheck);
-}
-function normalizePathForComparison(p) {
-  const resolved = resolveComparablePath(p);
-  return /^[a-zA-Z]:[/\\]/.test(resolved) ? resolved.toLowerCase() : resolved;
-}
-function relativePathUnderRoot(root, target) {
-  const rootResolved = normalizePathForComparison(root);
-  const targetResolved = normalizePathForComparison(target);
-  if (/^[a-zA-Z]:[/\\]/.test(rootResolved)) {
-    return import_node_path.win32.relative(rootResolved, targetResolved);
-  }
-  return (0, import_node_path.relative)(rootResolved, targetResolved);
-}
-function isResolvedPathUnderRoot(root, target) {
-  const rootResolved = normalizePathForComparison(root);
-  const targetResolved = normalizePathForComparison(target);
-  if (targetResolved === rootResolved) return true;
-  const rel = relativePathUnderRoot(root, target);
-  if (!rel) return true;
-  return !rel.startsWith("..") && !(0, import_node_path.isAbsolute)(rel);
-}
-
-// src/theme.ts
-var import_themes = require("@lessonkit/themes");
-function themeToLxpackRuntime(input) {
-  const theme = input.theme ?? (0, import_themes.getPresetTheme)(input.preset ?? "default");
-  const raw = (0, import_themes.themeToCssVariables)(theme);
-  const cssVariables = {};
-  for (const [key, value] of Object.entries(raw)) {
-    cssVariables[key] = String(value);
-  }
+function normalizeDescriptor(input) {
+  const course = (0, import_core.validateId)(input.courseId, "courseId");
+  if (!course.ok) throw new Error("normalizeDescriptor called with invalid courseId");
   return {
-    theme: theme.name,
-    cssVariables
+    ...input,
+    courseId: course.id,
+    title: input.title.trim(),
+    version: input.version?.trim() || void 0,
+    spaLessonId: input.spaLessonId?.trim() || void 0,
+    lessons: input.lessons.map((lesson) => {
+      const idResult = (0, import_core.validateId)(lesson.id, "lessonId");
+      if (!idResult.ok) throw new Error("normalizeDescriptor called with invalid lesson id");
+      return {
+        ...lesson,
+        id: idResult.id,
+        title: lesson.title.trim(),
+        spaPath: lesson.spaPath?.trim() || void 0
+      };
+    }),
+    assessments: input.assessments?.map((assessment) => {
+      const check = (0, import_core.validateId)(assessment.checkId, "checkId");
+      if (!check.ok) throw new Error("normalizeDescriptor called with invalid checkId");
+      const question = assessment.question.trim();
+      if (assessment.kind === "trueFalse") {
+        return { ...assessment, checkId: check.id, question };
+      }
+      if (assessment.kind === "fillInBlanks") {
+        return {
+          ...assessment,
+          checkId: check.id,
+          question,
+          template: assessment.template.trim(),
+          blanks: assessment.blanks?.map((b) => ({
+            id: b.id.trim(),
+            answer: b.answer.trim()
+          }))
+        };
+      }
+      if (assessment.kind === "findHotspot") {
+        return {
+          ...assessment,
+          checkId: check.id,
+          question,
+          src: assessment.src.trim(),
+          alt: assessment.alt.trim(),
+          correctTargetId: assessment.correctTargetId.trim()
+        };
+      }
+      if (assessment.kind === "findMultipleHotspots") {
+        return {
+          ...assessment,
+          checkId: check.id,
+          question,
+          src: assessment.src.trim(),
+          alt: assessment.alt.trim(),
+          correctTargetIds: assessment.correctTargetIds.map((id) => id.trim()).filter((id) => id.length > 0)
+        };
+      }
+      const mcq = assessment;
+      return {
+        ...mcq,
+        checkId: check.id,
+        question,
+        choices: mcq.choices.map((c) => c.trim()).filter((c) => c.length > 0),
+        answer: mcq.answer.trim()
+      };
+    })
   };
 }
 
-// src/validateDescriptor.ts
-var VALID_LAYOUTS = ["single-spa", "per-lesson-spa"];
-var VALID_THEME_PRESETS = ["default", "light", "dark", "brand"];
+// src/descriptor/parseInput.ts
 function isRecord(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
@@ -193,6 +175,24 @@ function parseAssessmentDescriptor(raw) {
       })) : void 0
     };
   }
+  if (kind === "findHotspot") {
+    return {
+      kind: "findHotspot",
+      ...base,
+      src: typeof raw.src === "string" ? raw.src : "",
+      alt: typeof raw.alt === "string" ? raw.alt : "",
+      correctTargetId: typeof raw.correctTargetId === "string" ? raw.correctTargetId : ""
+    };
+  }
+  if (kind === "findMultipleHotspots") {
+    return {
+      kind: "findMultipleHotspots",
+      ...base,
+      src: typeof raw.src === "string" ? raw.src : "",
+      alt: typeof raw.alt === "string" ? raw.alt : "",
+      correctTargetIds: Array.isArray(raw.correctTargetIds) ? raw.correctTargetIds.filter((id) => typeof id === "string") : []
+    };
+  }
   return {
     kind: kind === "mcq" ? "mcq" : void 0,
     ...base,
@@ -239,82 +239,158 @@ function parseCourseDescriptorInput(input) {
     spaLessonId: typeof input.spaLessonId === "string" ? input.spaLessonId : void 0
   };
 }
-function normalizeDescriptor(input) {
-  const course = (0, import_core.validateId)(input.courseId, "courseId");
-  if (!course.ok) throw new Error("normalizeDescriptor called with invalid courseId");
+
+// src/descriptor/validateCourse.ts
+var import_core3 = require("@lessonkit/core");
+
+// src/spaPath.ts
+var import_node_fs = require("fs");
+var import_node_path = require("path");
+function resolveComparablePath(p) {
+  if (/^[a-zA-Z]:[/\\]/.test(p)) {
+    return import_node_path.win32.resolve(p);
+  }
+  return (0, import_node_path.resolve)(p);
+}
+function isSafeRelativeSpaPath(spaPath) {
+  if (!spaPath.length || spaPath.includes("\0")) return false;
+  if (spaPath.startsWith("/") || spaPath.startsWith("\\")) return false;
+  if (/^[a-zA-Z]:/.test(spaPath)) return false;
+  if (spaPath === "." || spaPath === "./") return false;
+  const segments = spaPath.split(/[/\\]/).filter((s) => s.length > 0 && s !== ".");
+  if (segments.some((s) => s === "..")) return false;
+  return segments.length > 0;
+}
+function assertResolvedPathUnderRoot(root, target) {
+  const rootResolved = resolveComparablePath(root);
+  const targetResolved = resolveComparablePath(target);
+  const prefix = rootResolved.endsWith(import_node_path.sep) ? rootResolved : rootResolved + import_node_path.sep;
+  const win32Prefix = rootResolved.endsWith(import_node_path.win32.sep) ? rootResolved : rootResolved + import_node_path.win32.sep;
+  if (targetResolved !== rootResolved && !targetResolved.startsWith(prefix) && /* v8 ignore next */
+  !targetResolved.startsWith(win32Prefix)) {
+    throw new Error(`unsafe path escapes project root: ${target}`);
+  }
+}
+function assertRealPathUnderRoot(root, target) {
+  const rootResolved = resolveComparablePath(root);
+  const targetResolved = resolveComparablePath(target);
+  let rootReal;
+  try {
+    rootReal = (0, import_node_fs.realpathSync)(rootResolved);
+  } catch {
+    rootReal = rootResolved;
+  }
+  let targetCheck;
+  try {
+    targetCheck = (0, import_node_fs.realpathSync)(targetResolved);
+  } catch {
+    const rel = (0, import_node_path.relative)(rootResolved, targetResolved);
+    if (rel.startsWith("..") || rel.includes(`..${import_node_path.sep}`)) {
+      throw new Error(`unsafe path escapes project root: ${target}`);
+    }
+    targetCheck = (0, import_node_path.resolve)(rootReal, rel);
+  }
+  assertResolvedPathUnderRoot(rootReal, targetCheck);
+}
+function normalizePathForComparison(p) {
+  const resolved = resolveComparablePath(p);
+  return /^[a-zA-Z]:[/\\]/.test(resolved) ? resolved.toLowerCase() : resolved;
+}
+function relativePathUnderRoot(root, target) {
+  const rootResolved = normalizePathForComparison(root);
+  const targetResolved = normalizePathForComparison(target);
+  if (/^[a-zA-Z]:[/\\]/.test(rootResolved)) {
+    return import_node_path.win32.relative(rootResolved, targetResolved);
+  }
+  return (0, import_node_path.relative)(rootResolved, targetResolved);
+}
+function isResolvedPathUnderRoot(root, target) {
+  const rootResolved = normalizePathForComparison(root);
+  const targetResolved = normalizePathForComparison(target);
+  if (targetResolved === rootResolved) return true;
+  const rel = relativePathUnderRoot(root, target);
+  if (!rel) return true;
+  return !rel.startsWith("..") && !(0, import_node_path.isAbsolute)(rel);
+}
+
+// src/theme.ts
+var import_themes = require("@lessonkit/themes");
+function themeToLxpackRuntime(input) {
+  const theme = input.theme ?? (0, import_themes.getPresetTheme)(input.preset ?? "default");
+  const raw = (0, import_themes.themeToCssVariables)(theme);
+  const cssVariables = {};
+  for (const [key, value] of Object.entries(raw)) {
+    cssVariables[key] = String(value);
+  }
   return {
-    ...input,
-    courseId: course.id,
-    title: input.title.trim(),
-    version: input.version?.trim() || void 0,
-    spaLessonId: input.spaLessonId?.trim() || void 0,
-    lessons: input.lessons.map((lesson) => {
-      const idResult = (0, import_core.validateId)(lesson.id, "lessonId");
-      if (!idResult.ok) throw new Error("normalizeDescriptor called with invalid lesson id");
-      return {
-        ...lesson,
-        id: idResult.id,
-        title: lesson.title.trim(),
-        spaPath: lesson.spaPath?.trim() || void 0
-      };
-    }),
-    assessments: input.assessments?.map((assessment) => {
-      const check = (0, import_core.validateId)(assessment.checkId, "checkId");
-      if (!check.ok) throw new Error("normalizeDescriptor called with invalid checkId");
-      const question = assessment.question.trim();
-      if (assessment.kind === "trueFalse") {
-        return { ...assessment, checkId: check.id, question };
-      }
-      if (assessment.kind === "fillInBlanks") {
-        return {
-          ...assessment,
-          checkId: check.id,
-          question,
-          template: assessment.template.trim(),
-          blanks: assessment.blanks?.map((b) => ({
-            id: b.id.trim(),
-            answer: b.answer.trim()
-          }))
-        };
-      }
-      return {
-        ...assessment,
-        checkId: check.id,
-        question,
-        choices: assessment.choices.map((c) => c.trim()).filter((c) => c.length > 0),
-        answer: assessment.answer.trim()
-      };
-    })
+    theme: theme.name,
+    cssVariables
   };
 }
-function validateDescriptor(input) {
-  const parsed = parseCourseDescriptorInput(input);
-  if (parsed === null) {
-    return { ok: false, issues: [{ path: "course", message: "must be an object" }] };
+
+// src/descriptor/validateAssessments.ts
+var import_core2 = require("@lessonkit/core");
+var validateMcqLike = (assessment, path, issues) => {
+  if (!("choices" in assessment) || !("answer" in assessment) || typeof assessment.answer !== "string") {
+    return;
   }
-  return validateDescriptorParsed(parsed);
-}
-function validateDescriptorForTarget(input, target) {
-  const result = validateDescriptor(input);
-  if (!result.ok || !target) return result;
-  if (target !== "xapi" && target !== "cmi5") return result;
-  const activityIri = result.descriptor.tracking?.xapi?.activityIri?.trim();
-  if (!activityIri) {
-    return {
-      ok: false,
-      issues: [
-        {
-          path: "course.tracking.xapi.activityIri",
-          message: "tracking.xapi.activityIri is required for xapi and cmi5 export targets"
-        }
-      ]
-    };
+  const trimmedChoices = assessment.choices.map((c) => c.trim()).filter((c) => c.length > 0);
+  if (!trimmedChoices.length) {
+    issues.push({ path: `${path}.choices`, message: "at least one non-empty choice is required" });
+  }
+  if (!assessment.answer.trim()) {
+    issues.push({ path: `${path}.answer`, message: "answer is required" });
+  } else if (trimmedChoices.length && !trimmedChoices.includes(assessment.answer.trim())) {
+    issues.push({ path: `${path}.answer`, message: "answer must match a choice" });
+  }
+};
+var ASSESSMENT_VALIDATORS = {
+  mcq: validateMcqLike,
+  trueFalse: (assessment, path, issues) => {
+    if (assessment.kind === "trueFalse" && typeof assessment.answer !== "boolean") {
+      issues.push({ path: `${path}.answer`, message: "answer must be a boolean for trueFalse" });
+    }
+  },
+  fillInBlanks: (assessment, path, issues) => {
+    if (assessment.kind === "fillInBlanks" && !assessment.template?.trim()) {
+      issues.push({ path: `${path}.template`, message: "template is required for fillInBlanks" });
+    }
+  },
+  findHotspot: () => {
+  },
+  findMultipleHotspots: () => {
+  }
+};
+function validateAssessmentEntry(assessment, index, issues, checkIds) {
+  const path = `assessments[${index}]`;
+  const check = (0, import_core2.validateId)(assessment.checkId, `${path}.checkId`);
+  if (!check.ok) {
+    issues.push(...check.issues.map((i) => ({ path: i.path, message: i.message })));
+  } else if (checkIds.has(check.id)) {
+    issues.push({ path: `${path}.checkId`, message: "duplicate checkId" });
+  } else {
+    checkIds.add(check.id);
+  }
+  if (!assessment.question?.trim()) {
+    issues.push({ path: `${path}.question`, message: "question is required" });
+  }
+  const kind = assessment.kind ?? "mcq";
+  ASSESSMENT_VALIDATORS[kind](assessment, path, issues);
+  const passingScore = assessment.passingScore;
+  if (passingScore !== void 0 && !(Number.isFinite(passingScore) && passingScore > 0)) {
+    issues.push({
+      path: `${path}.passingScore`,
+      message: "passingScore must be greater than 0 (absolute point threshold)"
+    });
   }
-  return result;
 }
-function validateDescriptorParsed(input) {
+
+// src/descriptor/validateCourse.ts
+var VALID_LAYOUTS = ["single-spa", "per-lesson-spa"];
+var VALID_THEME_PRESETS = ["default", "light", "dark", "brand"];
+function validateCourseDescriptor(input) {
   const issues = [];
-  const course = (0, import_core.validateId)(input.courseId, "courseId");
+  const course = (0, import_core3.validateId)(input.courseId, "courseId");
   if (!course.ok) issues.push(...course.issues.map((i) => ({ path: i.path, message: i.message })));
   if (!input.title?.trim()) {
     issues.push({ path: "title", message: "title is required" });
@@ -367,7 +443,7 @@ function validateDescriptorParsed(input) {
   const spaPaths = /* @__PURE__ */ new Set();
   for (const [index, lesson] of (input.lessons ?? []).entries()) {
     const path = `lessons[${index}]`;
-    const lessonResult = (0, import_core.validateId)(lesson.id, `${path}.id`);
+    const lessonResult = (0, import_core3.validateId)(lesson.id, `${path}.id`);
     if (!lessonResult.ok) {
       issues.push(...lessonResult.issues.map((i) => ({ path: i.path, message: i.message })));
     } else if (lessonIds.has(lessonResult.id)) {
@@ -399,7 +475,7 @@ function validateDescriptorParsed(input) {
   }
   if (layout === "single-spa" && input.spaLessonId?.trim()) {
     const spaId = input.spaLessonId.trim();
-    const spaResult = (0, import_core.validateId)(spaId, "spaLessonId");
+    const spaResult = (0, import_core3.validateId)(spaId, "spaLessonId");
     if (!spaResult.ok) {
       issues.push(...spaResult.issues.map((i) => ({ path: i.path, message: i.message })));
     } else if (!lessonIds.has(spaResult.id)) {
@@ -411,52 +487,48 @@ function validateDescriptorParsed(input) {
   }
   const checkIds = /* @__PURE__ */ new Set();
   for (const [index, assessment] of (input.assessments ?? []).entries()) {
-    const path = `assessments[${index}]`;
-    const check = (0, import_core.validateId)(assessment.checkId, `${path}.checkId`);
-    if (!check.ok) {
-      issues.push(...check.issues.map((i) => ({ path: i.path, message: i.message })));
-    } else if (checkIds.has(check.id)) {
-      issues.push({ path: `${path}.checkId`, message: "duplicate checkId" });
-    } else {
-      checkIds.add(check.id);
-    }
-    if (!assessment.question?.trim()) {
-      issues.push({ path: `${path}.question`, message: "question is required" });
-    }
-    const kind = assessment.kind ?? "mcq";
-    if (kind === "trueFalse" && assessment.kind === "trueFalse") {
-      if (typeof assessment.answer !== "boolean") {
-        issues.push({ path: `${path}.answer`, message: "answer must be a boolean for trueFalse" });
-      }
-    } else if (kind === "fillInBlanks" && assessment.kind === "fillInBlanks") {
-      if (!assessment.template?.trim()) {
-        issues.push({ path: `${path}.template`, message: "template is required for fillInBlanks" });
-      }
-    } else if ("choices" in assessment && "answer" in assessment && typeof assessment.answer === "string") {
-      const trimmedChoices = assessment.choices.map((c) => c.trim()).filter((c) => c.length > 0);
-      if (!trimmedChoices.length) {
-        issues.push({
-          path: `${path}.choices`,
-          message: "at least one non-empty choice is required"
-        });
-      }
-      if (!assessment.answer.trim()) {
-        issues.push({ path: `${path}.answer`, message: "answer is required" });
-      } else if (trimmedChoices.length && !trimmedChoices.includes(assessment.answer.trim())) {
-        issues.push({ path: `${path}.answer`, message: "answer must match a choice" });
+    validateAssessmentEntry(assessment, index, issues, checkIds);
+  }
+  return issues;
+}
+
+// src/descriptor/validateForTarget.ts
+function validateDescriptorForExportTarget(descriptor, target) {
+  if (target !== "xapi" && target !== "cmi5") return [];
+  const activityIri = descriptor.tracking?.xapi?.activityIri?.trim();
+  if (!activityIri) {
+    return [
+      {
+        path: "course.tracking.xapi.activityIri",
+        message: "tracking.xapi.activityIri is required for xapi and cmi5 export targets"
       }
-    }
-    const passingScore = assessment.passingScore;
-    if (passingScore !== void 0 && !(Number.isFinite(passingScore) && passingScore > 0)) {
-      issues.push({
-        path: `${path}.passingScore`,
-        message: "passingScore must be greater than 0 (absolute point threshold)"
-      });
-    }
+    ];
   }
+  return [];
+}
+
+// src/validateDescriptor.ts
+function validateDescriptorParsed(input) {
+  const issues = validateCourseDescriptor(input);
   if (issues.length) return { ok: false, issues };
   return { ok: true, descriptor: normalizeDescriptor(input) };
 }
+function validateDescriptor(input) {
+  const parsed = parseCourseDescriptorInput(input);
+  if (parsed === null) {
+    return { ok: false, issues: [{ path: "course", message: "must be an object" }] };
+  }
+  return validateDescriptorParsed(parsed);
+}
+function validateDescriptorForTarget(input, target) {
+  const result = validateDescriptor(input);
+  if (!result.ok || !target) return result;
+  const targetIssues = validateDescriptorForExportTarget(result.descriptor, target);
+  if (targetIssues.length) {
+    return { ok: false, issues: targetIssues };
+  }
+  return result;
+}
 
 // src/validateProjectPaths.ts
 var import_node_path2 = require("path");
@@ -511,12 +583,12 @@ function resolveSafePackageOutputOverride(projectRoot, override) {
 }
 
 // src/mapIds.ts
-var import_core2 = require("@lessonkit/core");
+var import_core4 = require("@lessonkit/core");
 function mapLessonkitIds(descriptor) {
-  const courseId = (0, import_core2.assertValidId)(descriptor.courseId, "courseId");
-  const lessonIds = descriptor.lessons.map((l) => (0, import_core2.assertValidId)(l.id, "lessonId"));
+  const courseId = (0, import_core4.assertValidId)(descriptor.courseId, "courseId");
+  const lessonIds = descriptor.lessons.map((l) => (0, import_core4.assertValidId)(l.id, "lessonId"));
   const checkIds = (descriptor.assessments ?? []).map(
-    (a) => (0, import_core2.assertValidId)(a.checkId, "checkId")
+    (a) => (0, import_core4.assertValidId)(a.checkId, "checkId")
   );
   return { courseId, lessonIds, checkIds };
 }
@@ -565,6 +637,19 @@ function assessmentDescriptorToLxpack(assessment) {
   if (kind === "fillInBlanks") {
     return null;
   }
+  if (kind === "findHotspot" && assessment.kind === "findHotspot") {
+    return mcqToLxpack({
+      kind: "mcq",
+      checkId: assessment.checkId,
+      question: assessment.question,
+      choices: [assessment.correctTargetId, "other"],
+      answer: assessment.correctTargetId,
+      passingScore: assessment.passingScore
+    });
+  }
+  if (kind === "findMultipleHotspots") {
+    return null;
+  }
   if ("choices" in assessment && "answer" in assessment && typeof assessment.answer === "string") {
     return mcqToLxpack(assessment);
   }

package/dist/index.d.cts

@@ -40,8 +40,26 @@ type FillInBlanksAssessmentDescriptor = {
     }>;
     passingScore?: number;
 };
+type FindHotspotAssessmentDescriptor = {
+    kind: "findHotspot";
+    checkId: CheckId;
+    question: string;
+    src: string;
+    alt: string;
+    correctTargetId: string;
+    passingScore?: number;
+};
+type FindMultipleHotspotsAssessmentDescriptor = {
+    kind: "findMultipleHotspots";
+    checkId: CheckId;
+    question: string;
+    src: string;
+    alt: string;
+    correctTargetIds: string[];
+    passingScore?: number;
+};
 /** Discriminated assessment entries in lessonkit.json (defaults to MCQ when kind omitted). */
-type AssessmentDescriptor = McqAssessmentDescriptor | TrueFalseAssessmentDescriptor | FillInBlanksAssessmentDescriptor;
+type AssessmentDescriptor = McqAssessmentDescriptor | TrueFalseAssessmentDescriptor | FillInBlanksAssessmentDescriptor | FindHotspotAssessmentDescriptor | FindMultipleHotspotsAssessmentDescriptor;
 type LessonkitCourseDescriptor = {
     courseId: CourseId;
     title: string;

package/dist/index.d.ts

@@ -40,8 +40,26 @@ type FillInBlanksAssessmentDescriptor = {
     }>;
     passingScore?: number;
 };
+type FindHotspotAssessmentDescriptor = {
+    kind: "findHotspot";
+    checkId: CheckId;
+    question: string;
+    src: string;
+    alt: string;
+    correctTargetId: string;
+    passingScore?: number;
+};
+type FindMultipleHotspotsAssessmentDescriptor = {
+    kind: "findMultipleHotspots";
+    checkId: CheckId;
+    question: string;
+    src: string;
+    alt: string;
+    correctTargetIds: string[];
+    passingScore?: number;
+};
 /** Discriminated assessment entries in lessonkit.json (defaults to MCQ when kind omitted). */
-type AssessmentDescriptor = McqAssessmentDescriptor | TrueFalseAssessmentDescriptor | FillInBlanksAssessmentDescriptor;
+type AssessmentDescriptor = McqAssessmentDescriptor | TrueFalseAssessmentDescriptor | FillInBlanksAssessmentDescriptor | FindHotspotAssessmentDescriptor | FindMultipleHotspotsAssessmentDescriptor;
 type LessonkitCourseDescriptor = {
     courseId: CourseId;
     title: string;

package/dist/index.js

@@ -2,97 +2,79 @@ import {
   telemetryEventToLessonkit
 } from "./chunk-DYQI222N.js";
 
-// src/validateDescriptor.ts
+// src/descriptor/normalize.ts
 import { validateId } from "@lessonkit/core";
-
-// src/spaPath.ts
-import { realpathSync } from "fs";
-import { isAbsolute, relative, resolve, sep, win32 } from "path";
-function resolveComparablePath(p) {
-  if (/^[a-zA-Z]:[/\\]/.test(p)) {
-    return win32.resolve(p);
-  }
-  return resolve(p);
-}
-function isSafeRelativeSpaPath(spaPath) {
-  if (!spaPath.length || spaPath.includes("\0")) return false;
-  if (spaPath.startsWith("/") || spaPath.startsWith("\\")) return false;
-  if (/^[a-zA-Z]:/.test(spaPath)) return false;
-  if (spaPath === "." || spaPath === "./") return false;
-  const segments = spaPath.split(/[/\\]/).filter((s) => s.length > 0 && s !== ".");
-  if (segments.some((s) => s === "..")) return false;
-  return segments.length > 0;
-}
-function assertResolvedPathUnderRoot(root, target) {
-  const rootResolved = resolveComparablePath(root);
-  const targetResolved = resolveComparablePath(target);
-  const prefix = rootResolved.endsWith(sep) ? rootResolved : rootResolved + sep;
-  const win32Prefix = rootResolved.endsWith(win32.sep) ? rootResolved : rootResolved + win32.sep;
-  if (targetResolved !== rootResolved && !targetResolved.startsWith(prefix) && /* v8 ignore next */
-  !targetResolved.startsWith(win32Prefix)) {
-    throw new Error(`unsafe path escapes project root: ${target}`);
-  }
-}
-function assertRealPathUnderRoot(root, target) {
-  const rootResolved = resolveComparablePath(root);
-  const targetResolved = resolveComparablePath(target);
-  let rootReal;
-  try {
-    rootReal = realpathSync(rootResolved);
-  } catch {
-    rootReal = rootResolved;
-  }
-  let targetCheck;
-  try {
-    targetCheck = realpathSync(targetResolved);
-  } catch {
-    const rel = relative(rootResolved, targetResolved);
-    if (rel.startsWith("..") || rel.includes(`..${sep}`)) {
-      throw new Error(`unsafe path escapes project root: ${target}`);
-    }
-    targetCheck = resolve(rootReal, rel);
-  }
-  assertResolvedPathUnderRoot(rootReal, targetCheck);
-}
-function normalizePathForComparison(p) {
-  const resolved = resolveComparablePath(p);
-  return /^[a-zA-Z]:[/\\]/.test(resolved) ? resolved.toLowerCase() : resolved;
-}
-function relativePathUnderRoot(root, target) {
-  const rootResolved = normalizePathForComparison(root);
-  const targetResolved = normalizePathForComparison(target);
-  if (/^[a-zA-Z]:[/\\]/.test(rootResolved)) {
-    return win32.relative(rootResolved, targetResolved);
-  }
-  return relative(rootResolved, targetResolved);
-}
-function isResolvedPathUnderRoot(root, target) {
-  const rootResolved = normalizePathForComparison(root);
-  const targetResolved = normalizePathForComparison(target);
-  if (targetResolved === rootResolved) return true;
-  const rel = relativePathUnderRoot(root, target);
-  if (!rel) return true;
-  return !rel.startsWith("..") && !isAbsolute(rel);
-}
-
-// src/theme.ts
-import { getPresetTheme, themeToCssVariables } from "@lessonkit/themes";
-function themeToLxpackRuntime(input) {
-  const theme = input.theme ?? getPresetTheme(input.preset ?? "default");
-  const raw = themeToCssVariables(theme);
-  const cssVariables = {};
-  for (const [key, value] of Object.entries(raw)) {
-    cssVariables[key] = String(value);
-  }
+function normalizeDescriptor(input) {
+  const course = validateId(input.courseId, "courseId");
+  if (!course.ok) throw new Error("normalizeDescriptor called with invalid courseId");
   return {
-    theme: theme.name,
-    cssVariables
+    ...input,
+    courseId: course.id,
+    title: input.title.trim(),
+    version: input.version?.trim() || void 0,
+    spaLessonId: input.spaLessonId?.trim() || void 0,
+    lessons: input.lessons.map((lesson) => {
+      const idResult = validateId(lesson.id, "lessonId");
+      if (!idResult.ok) throw new Error("normalizeDescriptor called with invalid lesson id");
+      return {
+        ...lesson,
+        id: idResult.id,
+        title: lesson.title.trim(),
+        spaPath: lesson.spaPath?.trim() || void 0
+      };
+    }),
+    assessments: input.assessments?.map((assessment) => {
+      const check = validateId(assessment.checkId, "checkId");
+      if (!check.ok) throw new Error("normalizeDescriptor called with invalid checkId");
+      const question = assessment.question.trim();
+      if (assessment.kind === "trueFalse") {
+        return { ...assessment, checkId: check.id, question };
+      }
+      if (assessment.kind === "fillInBlanks") {
+        return {
+          ...assessment,
+          checkId: check.id,
+          question,
+          template: assessment.template.trim(),
+          blanks: assessment.blanks?.map((b) => ({
+            id: b.id.trim(),
+            answer: b.answer.trim()
+          }))
+        };
+      }
+      if (assessment.kind === "findHotspot") {
+        return {
+          ...assessment,
+          checkId: check.id,
+          question,
+          src: assessment.src.trim(),
+          alt: assessment.alt.trim(),
+          correctTargetId: assessment.correctTargetId.trim()
+        };
+      }
+      if (assessment.kind === "findMultipleHotspots") {
+        return {
+          ...assessment,
+          checkId: check.id,
+          question,
+          src: assessment.src.trim(),
+          alt: assessment.alt.trim(),
+          correctTargetIds: assessment.correctTargetIds.map((id) => id.trim()).filter((id) => id.length > 0)
+        };
+      }
+      const mcq = assessment;
+      return {
+        ...mcq,
+        checkId: check.id,
+        question,
+        choices: mcq.choices.map((c) => c.trim()).filter((c) => c.length > 0),
+        answer: mcq.answer.trim()
+      };
+    })
   };
 }
 
-// src/validateDescriptor.ts
-var VALID_LAYOUTS = ["single-spa", "per-lesson-spa"];
-var VALID_THEME_PRESETS = ["default", "light", "dark", "brand"];
+// src/descriptor/parseInput.ts
 function isRecord(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
@@ -134,6 +116,24 @@ function parseAssessmentDescriptor(raw) {
       })) : void 0
     };
   }
+  if (kind === "findHotspot") {
+    return {
+      kind: "findHotspot",
+      ...base,
+      src: typeof raw.src === "string" ? raw.src : "",
+      alt: typeof raw.alt === "string" ? raw.alt : "",
+      correctTargetId: typeof raw.correctTargetId === "string" ? raw.correctTargetId : ""
+    };
+  }
+  if (kind === "findMultipleHotspots") {
+    return {
+      kind: "findMultipleHotspots",
+      ...base,
+      src: typeof raw.src === "string" ? raw.src : "",
+      alt: typeof raw.alt === "string" ? raw.alt : "",
+      correctTargetIds: Array.isArray(raw.correctTargetIds) ? raw.correctTargetIds.filter((id) => typeof id === "string") : []
+    };
+  }
   return {
     kind: kind === "mcq" ? "mcq" : void 0,
     ...base,
@@ -180,82 +180,158 @@ function parseCourseDescriptorInput(input) {
     spaLessonId: typeof input.spaLessonId === "string" ? input.spaLessonId : void 0
   };
 }
-function normalizeDescriptor(input) {
-  const course = validateId(input.courseId, "courseId");
-  if (!course.ok) throw new Error("normalizeDescriptor called with invalid courseId");
+
+// src/descriptor/validateCourse.ts
+import { validateId as validateId3 } from "@lessonkit/core";
+
+// src/spaPath.ts
+import { realpathSync } from "fs";
+import { isAbsolute, relative, resolve, sep, win32 } from "path";
+function resolveComparablePath(p) {
+  if (/^[a-zA-Z]:[/\\]/.test(p)) {
+    return win32.resolve(p);
+  }
+  return resolve(p);
+}
+function isSafeRelativeSpaPath(spaPath) {
+  if (!spaPath.length || spaPath.includes("\0")) return false;
+  if (spaPath.startsWith("/") || spaPath.startsWith("\\")) return false;
+  if (/^[a-zA-Z]:/.test(spaPath)) return false;
+  if (spaPath === "." || spaPath === "./") return false;
+  const segments = spaPath.split(/[/\\]/).filter((s) => s.length > 0 && s !== ".");
+  if (segments.some((s) => s === "..")) return false;
+  return segments.length > 0;
+}
+function assertResolvedPathUnderRoot(root, target) {
+  const rootResolved = resolveComparablePath(root);
+  const targetResolved = resolveComparablePath(target);
+  const prefix = rootResolved.endsWith(sep) ? rootResolved : rootResolved + sep;
+  const win32Prefix = rootResolved.endsWith(win32.sep) ? rootResolved : rootResolved + win32.sep;
+  if (targetResolved !== rootResolved && !targetResolved.startsWith(prefix) && /* v8 ignore next */
+  !targetResolved.startsWith(win32Prefix)) {
+    throw new Error(`unsafe path escapes project root: ${target}`);
+  }
+}
+function assertRealPathUnderRoot(root, target) {
+  const rootResolved = resolveComparablePath(root);
+  const targetResolved = resolveComparablePath(target);
+  let rootReal;
+  try {
+    rootReal = realpathSync(rootResolved);
+  } catch {
+    rootReal = rootResolved;
+  }
+  let targetCheck;
+  try {
+    targetCheck = realpathSync(targetResolved);
+  } catch {
+    const rel = relative(rootResolved, targetResolved);
+    if (rel.startsWith("..") || rel.includes(`..${sep}`)) {
+      throw new Error(`unsafe path escapes project root: ${target}`);
+    }
+    targetCheck = resolve(rootReal, rel);
+  }
+  assertResolvedPathUnderRoot(rootReal, targetCheck);
+}
+function normalizePathForComparison(p) {
+  const resolved = resolveComparablePath(p);
+  return /^[a-zA-Z]:[/\\]/.test(resolved) ? resolved.toLowerCase() : resolved;
+}
+function relativePathUnderRoot(root, target) {
+  const rootResolved = normalizePathForComparison(root);
+  const targetResolved = normalizePathForComparison(target);
+  if (/^[a-zA-Z]:[/\\]/.test(rootResolved)) {
+    return win32.relative(rootResolved, targetResolved);
+  }
+  return relative(rootResolved, targetResolved);
+}
+function isResolvedPathUnderRoot(root, target) {
+  const rootResolved = normalizePathForComparison(root);
+  const targetResolved = normalizePathForComparison(target);
+  if (targetResolved === rootResolved) return true;
+  const rel = relativePathUnderRoot(root, target);
+  if (!rel) return true;
+  return !rel.startsWith("..") && !isAbsolute(rel);
+}
+
+// src/theme.ts
+import { getPresetTheme, themeToCssVariables } from "@lessonkit/themes";
+function themeToLxpackRuntime(input) {
+  const theme = input.theme ?? getPresetTheme(input.preset ?? "default");
+  const raw = themeToCssVariables(theme);
+  const cssVariables = {};
+  for (const [key, value] of Object.entries(raw)) {
+    cssVariables[key] = String(value);
+  }
   return {
-    ...input,
-    courseId: course.id,
-    title: input.title.trim(),
-    version: input.version?.trim() || void 0,
-    spaLessonId: input.spaLessonId?.trim() || void 0,
-    lessons: input.lessons.map((lesson) => {
-      const idResult = validateId(lesson.id, "lessonId");
-      if (!idResult.ok) throw new Error("normalizeDescriptor called with invalid lesson id");
-      return {
-        ...lesson,
-        id: idResult.id,
-        title: lesson.title.trim(),
-        spaPath: lesson.spaPath?.trim() || void 0
-      };
-    }),
-    assessments: input.assessments?.map((assessment) => {
-      const check = validateId(assessment.checkId, "checkId");
-      if (!check.ok) throw new Error("normalizeDescriptor called with invalid checkId");
-      const question = assessment.question.trim();
-      if (assessment.kind === "trueFalse") {
-        return { ...assessment, checkId: check.id, question };
-      }
-      if (assessment.kind === "fillInBlanks") {
-        return {
-          ...assessment,
-          checkId: check.id,
-          question,
-          template: assessment.template.trim(),
-          blanks: assessment.blanks?.map((b) => ({
-            id: b.id.trim(),
-            answer: b.answer.trim()
-          }))
-        };
-      }
-      return {
-        ...assessment,
-        checkId: check.id,
-        question,
-        choices: assessment.choices.map((c) => c.trim()).filter((c) => c.length > 0),
-        answer: assessment.answer.trim()
-      };
-    })
+    theme: theme.name,
+    cssVariables
   };
 }
-function validateDescriptor(input) {
-  const parsed = parseCourseDescriptorInput(input);
-  if (parsed === null) {
-    return { ok: false, issues: [{ path: "course", message: "must be an object" }] };
+
+// src/descriptor/validateAssessments.ts
+import { validateId as validateId2 } from "@lessonkit/core";
+var validateMcqLike = (assessment, path, issues) => {
+  if (!("choices" in assessment) || !("answer" in assessment) || typeof assessment.answer !== "string") {
+    return;
   }
-  return validateDescriptorParsed(parsed);
-}
-function validateDescriptorForTarget(input, target) {
-  const result = validateDescriptor(input);
-  if (!result.ok || !target) return result;
-  if (target !== "xapi" && target !== "cmi5") return result;
-  const activityIri = result.descriptor.tracking?.xapi?.activityIri?.trim();
-  if (!activityIri) {
-    return {
-      ok: false,
-      issues: [
-        {
-          path: "course.tracking.xapi.activityIri",
-          message: "tracking.xapi.activityIri is required for xapi and cmi5 export targets"
-        }
-      ]
-    };
+  const trimmedChoices = assessment.choices.map((c) => c.trim()).filter((c) => c.length > 0);
+  if (!trimmedChoices.length) {
+    issues.push({ path: `${path}.choices`, message: "at least one non-empty choice is required" });
+  }
+  if (!assessment.answer.trim()) {
+    issues.push({ path: `${path}.answer`, message: "answer is required" });
+  } else if (trimmedChoices.length && !trimmedChoices.includes(assessment.answer.trim())) {
+    issues.push({ path: `${path}.answer`, message: "answer must match a choice" });
+  }
+};
+var ASSESSMENT_VALIDATORS = {
+  mcq: validateMcqLike,
+  trueFalse: (assessment, path, issues) => {
+    if (assessment.kind === "trueFalse" && typeof assessment.answer !== "boolean") {
+      issues.push({ path: `${path}.answer`, message: "answer must be a boolean for trueFalse" });
+    }
+  },
+  fillInBlanks: (assessment, path, issues) => {
+    if (assessment.kind === "fillInBlanks" && !assessment.template?.trim()) {
+      issues.push({ path: `${path}.template`, message: "template is required for fillInBlanks" });
+    }
+  },
+  findHotspot: () => {
+  },
+  findMultipleHotspots: () => {
+  }
+};
+function validateAssessmentEntry(assessment, index, issues, checkIds) {
+  const path = `assessments[${index}]`;
+  const check = validateId2(assessment.checkId, `${path}.checkId`);
+  if (!check.ok) {
+    issues.push(...check.issues.map((i) => ({ path: i.path, message: i.message })));
+  } else if (checkIds.has(check.id)) {
+    issues.push({ path: `${path}.checkId`, message: "duplicate checkId" });
+  } else {
+    checkIds.add(check.id);
+  }
+  if (!assessment.question?.trim()) {
+    issues.push({ path: `${path}.question`, message: "question is required" });
+  }
+  const kind = assessment.kind ?? "mcq";
+  ASSESSMENT_VALIDATORS[kind](assessment, path, issues);
+  const passingScore = assessment.passingScore;
+  if (passingScore !== void 0 && !(Number.isFinite(passingScore) && passingScore > 0)) {
+    issues.push({
+      path: `${path}.passingScore`,
+      message: "passingScore must be greater than 0 (absolute point threshold)"
+    });
   }
-  return result;
 }
-function validateDescriptorParsed(input) {
+
+// src/descriptor/validateCourse.ts
+var VALID_LAYOUTS = ["single-spa", "per-lesson-spa"];
+var VALID_THEME_PRESETS = ["default", "light", "dark", "brand"];
+function validateCourseDescriptor(input) {
   const issues = [];
-  const course = validateId(input.courseId, "courseId");
+  const course = validateId3(input.courseId, "courseId");
   if (!course.ok) issues.push(...course.issues.map((i) => ({ path: i.path, message: i.message })));
   if (!input.title?.trim()) {
     issues.push({ path: "title", message: "title is required" });
@@ -308,7 +384,7 @@ function validateDescriptorParsed(input) {
   const spaPaths = /* @__PURE__ */ new Set();
   for (const [index, lesson] of (input.lessons ?? []).entries()) {
     const path = `lessons[${index}]`;
-    const lessonResult = validateId(lesson.id, `${path}.id`);
+    const lessonResult = validateId3(lesson.id, `${path}.id`);
     if (!lessonResult.ok) {
       issues.push(...lessonResult.issues.map((i) => ({ path: i.path, message: i.message })));
     } else if (lessonIds.has(lessonResult.id)) {
@@ -340,7 +416,7 @@ function validateDescriptorParsed(input) {
   }
   if (layout === "single-spa" && input.spaLessonId?.trim()) {
     const spaId = input.spaLessonId.trim();
-    const spaResult = validateId(spaId, "spaLessonId");
+    const spaResult = validateId3(spaId, "spaLessonId");
     if (!spaResult.ok) {
       issues.push(...spaResult.issues.map((i) => ({ path: i.path, message: i.message })));
     } else if (!lessonIds.has(spaResult.id)) {
@@ -352,52 +428,48 @@ function validateDescriptorParsed(input) {
   }
   const checkIds = /* @__PURE__ */ new Set();
   for (const [index, assessment] of (input.assessments ?? []).entries()) {
-    const path = `assessments[${index}]`;
-    const check = validateId(assessment.checkId, `${path}.checkId`);
-    if (!check.ok) {
-      issues.push(...check.issues.map((i) => ({ path: i.path, message: i.message })));
-    } else if (checkIds.has(check.id)) {
-      issues.push({ path: `${path}.checkId`, message: "duplicate checkId" });
-    } else {
-      checkIds.add(check.id);
-    }
-    if (!assessment.question?.trim()) {
-      issues.push({ path: `${path}.question`, message: "question is required" });
-    }
-    const kind = assessment.kind ?? "mcq";
-    if (kind === "trueFalse" && assessment.kind === "trueFalse") {
-      if (typeof assessment.answer !== "boolean") {
-        issues.push({ path: `${path}.answer`, message: "answer must be a boolean for trueFalse" });
-      }
-    } else if (kind === "fillInBlanks" && assessment.kind === "fillInBlanks") {
-      if (!assessment.template?.trim()) {
-        issues.push({ path: `${path}.template`, message: "template is required for fillInBlanks" });
-      }
-    } else if ("choices" in assessment && "answer" in assessment && typeof assessment.answer === "string") {
-      const trimmedChoices = assessment.choices.map((c) => c.trim()).filter((c) => c.length > 0);
-      if (!trimmedChoices.length) {
-        issues.push({
-          path: `${path}.choices`,
-          message: "at least one non-empty choice is required"
-        });
-      }
-      if (!assessment.answer.trim()) {
-        issues.push({ path: `${path}.answer`, message: "answer is required" });
-      } else if (trimmedChoices.length && !trimmedChoices.includes(assessment.answer.trim())) {
-        issues.push({ path: `${path}.answer`, message: "answer must match a choice" });
+    validateAssessmentEntry(assessment, index, issues, checkIds);
+  }
+  return issues;
+}
+
+// src/descriptor/validateForTarget.ts
+function validateDescriptorForExportTarget(descriptor, target) {
+  if (target !== "xapi" && target !== "cmi5") return [];
+  const activityIri = descriptor.tracking?.xapi?.activityIri?.trim();
+  if (!activityIri) {
+    return [
+      {
+        path: "course.tracking.xapi.activityIri",
+        message: "tracking.xapi.activityIri is required for xapi and cmi5 export targets"
       }
-    }
-    const passingScore = assessment.passingScore;
-    if (passingScore !== void 0 && !(Number.isFinite(passingScore) && passingScore > 0)) {
-      issues.push({
-        path: `${path}.passingScore`,
-        message: "passingScore must be greater than 0 (absolute point threshold)"
-      });
-    }
+    ];
   }
+  return [];
+}
+
+// src/validateDescriptor.ts
+function validateDescriptorParsed(input) {
+  const issues = validateCourseDescriptor(input);
   if (issues.length) return { ok: false, issues };
   return { ok: true, descriptor: normalizeDescriptor(input) };
 }
+function validateDescriptor(input) {
+  const parsed = parseCourseDescriptorInput(input);
+  if (parsed === null) {
+    return { ok: false, issues: [{ path: "course", message: "must be an object" }] };
+  }
+  return validateDescriptorParsed(parsed);
+}
+function validateDescriptorForTarget(input, target) {
+  const result = validateDescriptor(input);
+  if (!result.ok || !target) return result;
+  const targetIssues = validateDescriptorForExportTarget(result.descriptor, target);
+  if (targetIssues.length) {
+    return { ok: false, issues: targetIssues };
+  }
+  return result;
+}
 
 // src/validateProjectPaths.ts
 import { isAbsolute as isAbsolute2, resolve as resolve2 } from "path";
@@ -506,6 +578,19 @@ function assessmentDescriptorToLxpack(assessment) {
   if (kind === "fillInBlanks") {
     return null;
   }
+  if (kind === "findHotspot" && assessment.kind === "findHotspot") {
+    return mcqToLxpack({
+      kind: "mcq",
+      checkId: assessment.checkId,
+      question: assessment.question,
+      choices: [assessment.correctTargetId, "other"],
+      answer: assessment.correctTargetId,
+      passingScore: assessment.passingScore
+    });
+  }
+  if (kind === "findMultipleHotspots") {
+    return null;
+  }
   if ("choices" in assessment && "answer" in assessment && typeof assessment.answer === "string") {
     return mcqToLxpack(assessment);
   }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lessonkit/lxpack",
-  "version": "1.1.0",
+  "version": "1.2.0",
   "private": false,
   "description": "LXPack export adapter for LessonKit courses (SCORM, standalone, xAPI, cmi5).",
   "license": "Apache-2.0",
@@ -9,7 +9,7 @@
     "url": "git+https://github.com/eddiethedean/lessonkit.git",
     "directory": "packages/lxpack"
   },
-  "homepage": "https://github.com/eddiethedean/lessonkit",
+  "homepage": "https://lessonkit.readthedocs.io/en/latest/reference/packaging.html",
   "bugs": {
     "url": "https://github.com/eddiethedean/lessonkit/issues"
   },
@@ -55,8 +55,8 @@
     "lint": "echo \"(no lint configured yet)\""
   },
   "dependencies": {
-    "@lessonkit/core": "1.1.0",
-    "@lessonkit/themes": "1.1.0",
+    "@lessonkit/core": "1.2.0",
+    "@lessonkit/themes": "1.2.0",
     "@lxpack/api": "^0.6.2",
     "@lxpack/spa-bridge": "^0.6.2",
     "@lxpack/tracking-schema": "^0.6.2",