@lessonkit/lxpack 1.0.0 → 1.0.2

package/dist/bridge.cjs

@@ -49,6 +49,15 @@ var import_tracking_schema3 = require("@lxpack/tracking-schema");
 // src/telemetry.ts
 var import_tracking_schema = require("@lxpack/tracking-schema");
 var SUPPORTED = new Set(import_tracking_schema.LESSONKIT_TELEMETRY_EVENTS);
+function isQuizAnsweredData(data) {
+  return typeof data === "object" && data !== null && typeof data.checkId === "string";
+}
+function isQuizCompletedData(data) {
+  return typeof data === "object" && data !== null && typeof data.checkId === "string";
+}
+function isInteractionData(data) {
+  return typeof data === "object" && data !== null;
+}
 function telemetryEventToLessonkit(event) {
   if (!SUPPORTED.has(event.name)) {
     return null;
@@ -60,16 +69,16 @@ function telemetryEventToLessonkit(event) {
   };
   if (name === "quiz_completed" || name === "quiz_answered") {
     const data = event.data;
-    mapped.assessmentId = data?.checkId;
-    if (data && "score" in data) {
-      mapped.score = data.score;
-      mapped.maxScore = data.maxScore;
-      mapped.passingScore = data.passingScore;
-    }
-    if (data) {
+    if (isQuizAnsweredData(data) || isQuizCompletedData(data)) {
+      mapped.assessmentId = data.checkId;
+      if ("score" in data) {
+        mapped.score = data.score;
+        mapped.maxScore = data.maxScore;
+        mapped.passingScore = data.passingScore;
+      }
       mapped.data = data;
     }
-  } else if (name === "interaction" && event.data) {
+  } else if (name === "interaction" && event.data && isInteractionData(event.data)) {
     mapped.data = event.data;
   }
   return mapped;
@@ -94,7 +103,7 @@ function getBridge(parentWindow) {
   if (typeof window === "undefined") return null;
   const parent = parentWindow ?? window.parent;
   if (!parent || parent === window) return null;
-  return parent.lxpack ?? null;
+  return parent.lxpackBridge?.v1 ?? parent.lxpack ?? null;
 }
 function isDevEnvironment() {
   const g = globalThis;

package/dist/bridge.js

@@ -1,6 +1,6 @@
 import {
   telemetryEventToLessonkit
-} from "./chunk-PSUSESH3.js";
+} from "./chunk-DYQI222N.js";
 
 // src/bridge.ts
 import {
@@ -41,7 +41,7 @@ function getBridge(parentWindow) {
   if (typeof window === "undefined") return null;
   const parent = parentWindow ?? window.parent;
   if (!parent || parent === window) return null;
-  return parent.lxpack ?? null;
+  return parent.lxpackBridge?.v1 ?? parent.lxpack ?? null;
 }
 function isDevEnvironment() {
   const g = globalThis;

package/dist/chunk-DYQI222N.js

@@ -0,0 +1,41 @@
+// src/telemetry.ts
+import { LESSONKIT_TELEMETRY_EVENTS } from "@lxpack/tracking-schema";
+var SUPPORTED = new Set(LESSONKIT_TELEMETRY_EVENTS);
+function isQuizAnsweredData(data) {
+  return typeof data === "object" && data !== null && typeof data.checkId === "string";
+}
+function isQuizCompletedData(data) {
+  return typeof data === "object" && data !== null && typeof data.checkId === "string";
+}
+function isInteractionData(data) {
+  return typeof data === "object" && data !== null;
+}
+function telemetryEventToLessonkit(event) {
+  if (!SUPPORTED.has(event.name)) {
+    return null;
+  }
+  const name = event.name;
+  const mapped = {
+    name,
+    lessonId: event.lessonId
+  };
+  if (name === "quiz_completed" || name === "quiz_answered") {
+    const data = event.data;
+    if (isQuizAnsweredData(data) || isQuizCompletedData(data)) {
+      mapped.assessmentId = data.checkId;
+      if ("score" in data) {
+        mapped.score = data.score;
+        mapped.maxScore = data.maxScore;
+        mapped.passingScore = data.passingScore;
+      }
+      mapped.data = data;
+    }
+  } else if (name === "interaction" && event.data && isInteractionData(event.data)) {
+    mapped.data = event.data;
+  }
+  return mapped;
+}
+
+export {
+  telemetryEventToLessonkit
+};

package/dist/index.cjs

@@ -53,6 +53,7 @@ __export(index_exports, {
   telemetryEventToLessonkit: () => telemetryEventToLessonkit,
   themeToLxpackRuntime: () => themeToLxpackRuntime,
   validateDescriptor: () => validateDescriptor,
+  validateDescriptorForTarget: () => validateDescriptorForTarget,
   validateLessonkitProject: () => validateLessonkitProject,
   validatePackageInputs: () => validatePackageInputs,
   validateProjectPaths: () => validateProjectPaths,
@@ -75,10 +76,11 @@ function resolveComparablePath(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;
-  const segments = spaPath.split(/[/\\]/).filter((s) => s.length > 0);
+  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 true;
+  return segments.length > 0;
 }
 function assertResolvedPathUnderRoot(root, target) {
   const rootResolved = resolveComparablePath(root);
@@ -110,13 +112,25 @@ function assertRealPathUnderRoot(root, target) {
   }
   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 = resolveComparablePath(root);
-  const targetResolved = resolveComparablePath(target);
+  const rootResolved = normalizePathForComparison(root);
+  const targetResolved = normalizePathForComparison(target);
   if (targetResolved === rootResolved) return true;
-  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;
-  return targetResolved.startsWith(prefix) || targetResolved.startsWith(win32Prefix);
+  const rel = relativePathUnderRoot(root, target);
+  if (!rel) return true;
+  return !rel.startsWith("..") && !(0, import_node_path.isAbsolute)(rel);
 }
 
 // src/theme.ts
@@ -137,6 +151,70 @@ function themeToLxpackRuntime(input) {
 // src/validateDescriptor.ts
 var VALID_LAYOUTS = ["single-spa", "per-lesson-spa"];
 var VALID_THEME_PRESETS = ["default", "light", "dark", "brand"];
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function parseLessonDescriptor(raw) {
+  if (!isRecord(raw)) {
+    return { id: "", title: "" };
+  }
+  return {
+    id: typeof raw.id === "string" ? raw.id : "",
+    title: typeof raw.title === "string" ? raw.title : "",
+    spaPath: typeof raw.spaPath === "string" ? raw.spaPath : void 0
+  };
+}
+function parseAssessmentDescriptor(raw) {
+  if (!isRecord(raw)) {
+    return { checkId: "", question: "", choices: [], answer: "" };
+  }
+  return {
+    checkId: typeof raw.checkId === "string" ? raw.checkId : "",
+    question: typeof raw.question === "string" ? raw.question : "",
+    choices: Array.isArray(raw.choices) ? raw.choices.filter((c) => typeof c === "string") : [],
+    answer: typeof raw.answer === "string" ? raw.answer : "",
+    passingScore: typeof raw.passingScore === "number" ? raw.passingScore : void 0
+  };
+}
+function parseCourseDescriptorInput(input) {
+  if (!isRecord(input)) return null;
+  const trackingRaw = input.tracking;
+  let tracking;
+  if (isRecord(trackingRaw)) {
+    const completionRaw = trackingRaw.completion;
+    const xapiRaw = trackingRaw.xapi;
+    tracking = {
+      completion: isRecord(completionRaw) ? {
+        threshold: typeof completionRaw.threshold === "number" ? completionRaw.threshold : void 0
+      } : void 0,
+      xapi: isRecord(xapiRaw) ? {
+        activityIri: typeof xapiRaw.activityIri === "string" ? xapiRaw.activityIri : void 0
+      } : void 0
+    };
+  }
+  const themeRaw = input.theme;
+  let theme;
+  if (isRecord(themeRaw)) {
+    theme = {
+      preset: typeof themeRaw.preset === "string" ? themeRaw.preset : void 0
+    };
+    if (isRecord(themeRaw.theme)) {
+      theme.theme = themeRaw.theme;
+    }
+  }
+  return {
+    courseId: typeof input.courseId === "string" ? input.courseId : "",
+    title: typeof input.title === "string" ? input.title : "",
+    version: typeof input.version === "string" ? input.version : void 0,
+    layout: typeof input.layout === "string" ? input.layout : void 0,
+    lessons: Array.isArray(input.lessons) ? input.lessons.map(parseLessonDescriptor) : [],
+    assessments: Array.isArray(input.assessments) ? input.assessments.map(parseAssessmentDescriptor) : void 0,
+    theme,
+    tracking,
+    spaDistDir: typeof input.spaDistDir === "string" ? input.spaDistDir : void 0,
+    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");
@@ -170,6 +248,31 @@ function 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;
+  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"
+        }
+      ]
+    };
+  }
+  return result;
+}
+function validateDescriptorParsed(input) {
   const issues = [];
   const course = (0, import_core.validateId)(input.courseId, "courseId");
   if (!course.ok) issues.push(...course.issues.map((i) => ({ path: i.path, message: i.message })));
@@ -315,7 +418,7 @@ function validatePathField(value, fieldPath, projectRoot, issues) {
     return;
   }
   try {
-    assertResolvedPathUnderRoot(projectRoot, (0, import_node_path2.resolve)(projectRoot, value));
+    assertRealPathUnderRoot(projectRoot, (0, import_node_path2.resolve)(projectRoot, value));
   } catch {
     issues.push({
       path: fieldPath,
@@ -345,14 +448,14 @@ function resolveSafePackageOutputOverride(projectRoot, override) {
   }
   if ((0, import_node_path2.isAbsolute)(trimmed)) {
     const resolved2 = (0, import_node_path2.resolve)(trimmed);
-    assertResolvedPathUnderRoot(root, resolved2);
+    assertRealPathUnderRoot(root, resolved2);
     return resolved2;
   }
   if (!isSafeRelativeSpaPath(trimmed)) {
     throw new Error(`unsafe output path: ${override}`);
   }
   const resolved = (0, import_node_path2.resolve)(root, trimmed);
-  assertResolvedPathUnderRoot(root, resolved);
+  assertRealPathUnderRoot(root, resolved);
   return resolved;
 }
 
@@ -399,6 +502,18 @@ function extractAssessments(descriptor) {
 }
 
 // src/interchange.ts
+function mapDescriptorTracking(tracking) {
+  if (!tracking) return void 0;
+  const mapped = {};
+  if (tracking.completion?.threshold !== void 0) {
+    mapped.completion = { threshold: tracking.completion.threshold };
+  }
+  const activityIri = tracking.xapi?.activityIri?.trim();
+  if (activityIri) {
+    mapped.xapi = { activityIri };
+  }
+  return Object.keys(mapped).length > 0 ? mapped : void 0;
+}
 function resolveSpaLessons(descriptor) {
   const mapped = mapLessonkitIds(descriptor);
   if (descriptor.layout === "single-spa") {
@@ -436,7 +551,7 @@ function descriptorToInterchange(descriptor) {
       type: "spa",
       path: l.path
     })),
-    tracking: descriptor.tracking,
+    tracking: mapDescriptorTracking(descriptor.tracking),
     runtime: runtime ? {
       theme: runtime.theme,
       cssVariables: runtime.cssVariables
@@ -513,7 +628,7 @@ async function writeLxpackProject(options) {
   const descriptor = validation.descriptor;
   const outDir = (0, import_node_path4.resolve)(options.outDir);
   if (options.projectRoot) {
-    assertResolvedPathUnderRoot((0, import_node_path4.resolve)(options.projectRoot), outDir);
+    assertRealPathUnderRoot((0, import_node_path4.resolve)(options.projectRoot), outDir);
   }
   const spaDirs = await resolveSpaDirs({ ...options, descriptor });
   const interchange = descriptorToInterchange(descriptor);
@@ -537,7 +652,7 @@ async function writeLxpackProject(options) {
 }
 
 // src/packageCourse.ts
-var import_node_path7 = require("path");
+var import_node_path8 = require("path");
 var fsp3 = __toESM(require("fs/promises"), 1);
 var import_api2 = require("@lxpack/api");
 
@@ -549,7 +664,7 @@ function validatePackageInputs(options) {
   const projectRoot = options.projectRoot ? (0, import_node_path5.resolve)(options.projectRoot) : void 0;
   if (projectRoot) {
     try {
-      assertResolvedPathUnderRoot(projectRoot, outDir);
+      assertRealPathUnderRoot(projectRoot, outDir);
     } catch (err) {
       return {
         ok: false,
@@ -596,7 +711,7 @@ function validatePackageInputs(options) {
   if (projectRoot && output) {
     const resolvedOutput = (0, import_node_path5.resolve)(projectRoot, output);
     try {
-      assertResolvedPathUnderRoot(projectRoot, resolvedOutput);
+      assertRealPathUnderRoot(projectRoot, resolvedOutput);
     } catch (err) {
       return {
         ok: false,
@@ -625,17 +740,21 @@ function remapArtifactPaths(stagingRoot, outDir, artifactPath) {
   if (!isResolvedPathUnderRoot(stagingRoot, resolved)) {
     return artifactPath;
   }
-  const stagingResolved = resolveComparablePath(stagingRoot);
-  const relative2 = resolved === stagingResolved ? "" : resolved.slice(stagingResolved.length).replace(/^[/\\]/, "");
-  if (!relative2) return outDir;
+  const rel = relativePathUnderRoot(stagingRoot, resolved);
+  if (rel.startsWith("..") || (0, import_node_path5.isAbsolute)(rel)) {
+    return artifactPath;
+  }
+  if (!rel) return outDir;
   if (/^[a-zA-Z]:[/\\]/.test(outDir)) {
-    return import_node_path5.win32.join(outDir, relative2.replace(/\//g, import_node_path5.win32.sep));
+    return import_node_path5.win32.join(outDir, rel.replace(/\//g, import_node_path5.win32.sep));
   }
-  return (0, import_node_path5.join)(outDir, relative2);
+  return (0, import_node_path5.join)(outDir, rel);
 }
 
 // src/packaging/promote.ts
 var fsp = __toESM(require("fs/promises"), 1);
+var import_node_crypto = require("crypto");
+var import_node_path6 = require("path");
 async function pathExists(path) {
   try {
     await fsp.access(path);
@@ -654,22 +773,36 @@ async function renameOrCopy(from, to) {
     await fsp.rm(from, { recursive: true, force: true });
   }
 }
+async function assertNoLegacyPromoteArtifacts(outDir) {
+  const legacyTmp = `${outDir}.tmp-promote`;
+  const legacyBak = `${outDir}.bak`;
+  const stale = [];
+  if (await pathExists(legacyTmp)) stale.push(legacyTmp);
+  if (await pathExists(legacyBak)) stale.push(legacyBak);
+  if (stale.length) {
+    throw new Error(
+      `[lessonkit/lxpack] cannot promote: remove stale packaging artifacts from a previous failed run: ${stale.join(", ")}`
+    );
+  }
+}
 async function promoteStagingToOutDir(stagingDir, outDir) {
-  const tmpPromote = `${outDir}.tmp-promote`;
-  const backup = `${outDir}.bak`;
+  await assertNoLegacyPromoteArtifacts(outDir);
+  const parent = (0, import_node_path6.dirname)(outDir);
+  const tmpPromote = await fsp.mkdtemp((0, import_node_path6.join)(parent, ".lk-promote-"));
   await renameOrCopy(stagingDir, tmpPromote);
   const hadOutDir = await pathExists(outDir);
-  if (hadOutDir) {
+  const backup = hadOutDir ? await fsp.mkdtemp((0, import_node_path6.join)(parent, ".lk-backup-")) : void 0;
+  if (hadOutDir && backup) {
     await renameOrCopy(outDir, backup);
   }
   try {
     await renameOrCopy(tmpPromote, outDir);
   } catch (promoteError) {
-    if (hadOutDir) {
+    if (hadOutDir && backup) {
       try {
         await renameOrCopy(backup, outDir);
       } catch (restoreError) {
-        const failedPromote2 = `${outDir}.failed-promote-${Date.now()}`;
+        const failedPromote2 = (0, import_node_path6.join)(parent, `.lk-failed-promote-${(0, import_node_crypto.randomUUID)()}`);
         try {
           await renameOrCopy(tmpPromote, failedPromote2);
         } catch {
@@ -693,7 +826,7 @@ async function promoteStagingToOutDir(stagingDir, outDir) {
       }
       throw promoteError;
     }
-    const failedPromote = `${outDir}.failed-promote-${Date.now()}`;
+    const failedPromote = (0, import_node_path6.join)(parent, `.lk-failed-promote-${(0, import_node_crypto.randomUUID)()}`);
     try {
       await renameOrCopy(tmpPromote, failedPromote);
     } catch {
@@ -701,19 +834,19 @@ async function promoteStagingToOutDir(stagingDir, outDir) {
     }
     throw promoteError;
   }
-  if (hadOutDir) {
+  if (backup) {
     await fsp.rm(backup, { recursive: true, force: true }).catch(() => void 0);
   }
 }
 
 // src/packaging/staging.ts
 var fsp2 = __toESM(require("fs/promises"), 1);
-var import_node_path6 = require("path");
+var import_node_path7 = require("path");
 var import_node_os = require("os");
 var import_api = require("@lxpack/api");
 async function buildStagingPackage(options) {
   const { target, output, dir, outputBaseDir, descriptor, ...writeOpts } = options;
-  const stagingDir = await fsp2.mkdtemp((0, import_node_path6.join)((0, import_node_os.tmpdir)(), "lessonkit-lxpack-"));
+  const stagingDir = await fsp2.mkdtemp((0, import_node_path7.join)((0, import_node_os.tmpdir)(), "lessonkit-lxpack-"));
   try {
     let spaDirs;
     try {
@@ -732,8 +865,8 @@ async function buildStagingPackage(options) {
     }
     const interchange = descriptorToInterchange(descriptor);
     const outputBase = outputBaseDir ?? ".lxpack/out";
-    await fsp2.mkdir((0, import_node_path6.join)(stagingDir, outputBase), { recursive: true });
-    const defaultOutput = output ?? (dir ? (0, import_node_path6.join)(outputBase, target) : (0, import_node_path6.join)(outputBase, `course-${target}.zip`));
+    await fsp2.mkdir((0, import_node_path7.join)(stagingDir, outputBase), { recursive: true });
+    const defaultOutput = output ?? (dir ? (0, import_node_path7.join)(outputBase, target) : (0, import_node_path7.join)(outputBase, `course-${target}.zip`));
     const build = await (0, import_api.packageLessonkit)({
       interchange,
       spaDirs,
@@ -770,25 +903,26 @@ async function buildStagingPackage(options) {
   }
 }
 async function ensureOutDirParent(outDir) {
-  await fsp2.mkdir((0, import_node_path6.dirname)(outDir), { recursive: true });
+  await fsp2.mkdir((0, import_node_path7.dirname)(outDir), { recursive: true });
 }
 
 // src/packageCourse.ts
 async function validateLessonkitProject(options) {
   return (0, import_api2.validateCourse)({
-    courseDir: (0, import_node_path7.resolve)(options.courseDir),
+    courseDir: (0, import_node_path8.resolve)(options.courseDir),
     target: options.target
   });
 }
 async function buildLessonkitProject(options) {
-  return (0, import_api2.buildCourse)({
-    courseDir: (0, import_node_path7.resolve)(options.courseDir),
+  const buildOptions = {
+    courseDir: (0, import_node_path8.resolve)(options.courseDir),
     target: options.target,
     output: options.output,
     dir: options.dir,
     outputBaseDir: options.outputBaseDir,
     assessments: options.assessments
-  });
+  };
+  return (0, import_api2.buildCourse)(buildOptions);
 }
 async function packageLessonkitCourse(options) {
   const { target, output, dir, outputBaseDir, ...writeOpts } = options;
@@ -808,11 +942,11 @@ async function packageLessonkitCourse(options) {
     };
   }
   const outDir = inputValidation.outDir;
-  const descriptorValidation = validateDescriptor(writeOpts.descriptor);
+  const descriptorValidation = validateDescriptorForTarget(writeOpts.descriptor, target);
   if (!descriptorValidation.ok) {
     return {
       ok: false,
-      courseDir: outDir,
+      courseDir: (0, import_node_path8.resolve)(writeOpts.outDir),
       target,
       issues: descriptorValidation.issues.map((i) => ({
         path: i.path,
@@ -821,22 +955,6 @@ async function packageLessonkitCourse(options) {
     };
   }
   const descriptor = descriptorValidation.descriptor;
-  if (target === "xapi" || target === "cmi5") {
-    const activityIri = descriptor.tracking?.xapi?.activityIri?.trim();
-    if (!activityIri) {
-      return {
-        ok: false,
-        courseDir: outDir,
-        target,
-        issues: [
-          {
-            path: "course.tracking.xapi.activityIri",
-            message: "tracking.xapi.activityIri is required for xapi and cmi5 export targets"
-          }
-        ]
-      };
-    }
-  }
   const staged = await buildStagingPackage({
     ...writeOpts,
     descriptor,
@@ -930,14 +1048,19 @@ function parseLessonkitManifest(raw, label = "lessonkit.json", projectRoot) {
   }
   const config = raw;
   const issues = [];
-  if (config.schemaVersion !== 1) {
+  let schemaVersion = config.schemaVersion;
+  if (schemaVersion === "1") {
+    schemaVersion = 1;
+  }
+  if (schemaVersion !== 1) {
     issues.push({
       path: "schemaVersion",
       message: `must be 1 (got ${String(config.schemaVersion)})`
     });
   }
-  const name = config.name;
-  if (typeof name !== "string" || !name.trim()) {
+  const nameRaw = config.name;
+  const name = typeof nameRaw === "string" ? nameRaw.trim() : "";
+  if (!name) {
     issues.push({ path: "name", message: "must be a non-empty string" });
   }
   const courseRaw = config.course;
@@ -1026,6 +1149,15 @@ var import_tracking_schema2 = require("@lxpack/tracking-schema");
 // src/telemetry.ts
 var import_tracking_schema = require("@lxpack/tracking-schema");
 var SUPPORTED = new Set(import_tracking_schema.LESSONKIT_TELEMETRY_EVENTS);
+function isQuizAnsweredData(data) {
+  return typeof data === "object" && data !== null && typeof data.checkId === "string";
+}
+function isQuizCompletedData(data) {
+  return typeof data === "object" && data !== null && typeof data.checkId === "string";
+}
+function isInteractionData(data) {
+  return typeof data === "object" && data !== null;
+}
 function telemetryEventToLessonkit(event) {
   if (!SUPPORTED.has(event.name)) {
     return null;
@@ -1037,16 +1169,16 @@ function telemetryEventToLessonkit(event) {
   };
   if (name === "quiz_completed" || name === "quiz_answered") {
     const data = event.data;
-    mapped.assessmentId = data?.checkId;
-    if (data && "score" in data) {
-      mapped.score = data.score;
-      mapped.maxScore = data.maxScore;
-      mapped.passingScore = data.passingScore;
-    }
-    if (data) {
+    if (isQuizAnsweredData(data) || isQuizCompletedData(data)) {
+      mapped.assessmentId = data.checkId;
+      if ("score" in data) {
+        mapped.score = data.score;
+        mapped.maxScore = data.maxScore;
+        mapped.passingScore = data.passingScore;
+      }
       mapped.data = data;
     }
-  } else if (name === "interaction" && event.data) {
+  } else if (name === "interaction" && event.data && isInteractionData(event.data)) {
     mapped.data = event.data;
   }
   return mapped;
@@ -1079,6 +1211,7 @@ var import_validators2 = require("@lxpack/validators");
   telemetryEventToLessonkit,
   themeToLxpackRuntime,
   validateDescriptor,
+  validateDescriptorForTarget,
   validateLessonkitProject,
   validatePackageInputs,
   validateProjectPaths,

package/dist/index.d.cts

@@ -1,9 +1,9 @@
 import { CheckId, CourseId, LessonId } from '@lessonkit/core';
 import { ThemePresetName, LessonkitThemeV1 } from '@lessonkit/themes';
-import { LessonkitInterchangeV1 } from '@lxpack/validators';
-export { LessonkitInterchangeV1, MaterializeLessonkitOptions, MaterializeLessonkitResult, lessonkitInterchangeSchema, materializeLessonkitProject, parseLessonkitInterchange } from '@lxpack/validators';
 import { ExportTarget, BuildCourseResult, ValidateCourseResult } from '@lxpack/api';
 export { ExportTarget } from '@lxpack/api';
+import { LessonkitInterchangeV1 } from '@lxpack/validators';
+export { LessonkitInterchangeV1, MaterializeLessonkitOptions, MaterializeLessonkitResult, lessonkitInterchangeSchema, materializeLessonkitProject, parseLessonkitInterchange } from '@lxpack/validators';
 export { LESSONKIT_TELEMETRY_EVENTS, LessonkitBridgeAction, LessonkitTelemetryEvent, LessonkitTelemetryEventName, TrackingSchemaEvent, mapLessonkitTelemetryToBridgeAction, mapLessonkitTelemetryToLxpack } from '@lxpack/tracking-schema';
 export { t as telemetryEventToLessonkit } from './telemetry-gCxlwc7I.cjs';
 
@@ -53,10 +53,14 @@ type MappedLessonkitIds = {
     checkIds: CheckId[];
 };
 
-type DescriptorValidationIssue = {
+/** Shared validation issue shape across lxpack parsers. */
+type ValidationIssue = {
     path: string;
     message: string;
+    severity?: string;
 };
+
+type DescriptorValidationIssue = ValidationIssue;
 type DescriptorValidationResult = {
     ok: true;
     descriptor: LessonkitCourseDescriptor;
@@ -64,7 +68,8 @@ type DescriptorValidationResult = {
     ok: false;
     issues: DescriptorValidationIssue[];
 };
-declare function validateDescriptor(input: LessonkitCourseDescriptor): DescriptorValidationResult;
+declare function validateDescriptor(input: unknown): DescriptorValidationResult;
+declare function validateDescriptorForTarget(input: unknown, target?: ExportTarget): DescriptorValidationResult;
 
 type ProjectPathsInput = {
     spaDistDir?: string;
@@ -94,7 +99,7 @@ declare function themeToLxpackRuntime(input: {
 }): LxpackRuntimeTheme;
 
 type SpaLessonEntry = {
-    id: string;
+    id: LessonId;
     title: string;
     path: string;
 };
@@ -188,7 +193,7 @@ type BuildLessonkitProjectOptions = {
     output?: string;
     dir?: boolean;
     outputBaseDir?: string;
-    assessments?: unknown[];
+    assessments?: LxpackInjectedAssessment[];
 };
 type PackageLessonkitCourseOptions = WriteLxpackProjectOptions & {
     target: ExportTarget;
@@ -268,4 +273,4 @@ type ParseManifestResult = {
 declare function parseLessonkitManifest(raw: unknown, label?: string, projectRoot?: string): ParseManifestResult;
 declare function loadLessonkitManifestFromFile(readJson: () => Promise<unknown>, label?: string, projectRoot?: string): Promise<ParseManifestResult>;
 
-export { type AssessmentDescriptor, type BuildLessonkitProjectOptions, type BuildStagingPackageOptions, type BuildStagingPackageResult, type DescriptorValidationIssue, type DescriptorValidationResult, type LessonDescriptor, type LessonkitCourseDescriptor, type LessonkitManifest, type LessonkitManifestPaths, type LxpackInjectedAssessment, type LxpackRuntimeTheme, type ManifestParseIssue, type MappedLessonkitIds, type PackageLessonkitCourseOptions, type PackageLessonkitCourseResult, type PackageValidationIssue, type ParseManifestResult, type ProjectPathsInput, type SpaLayout, type SpaLessonEntry, type ValidateLessonkitProjectOptions, type ValidatePackageInputsResult, type WriteLxpackProjectOptions, type WriteLxpackProjectResult, assessmentDescriptorToLxpack, buildLessonkitProject, buildStagingPackage, descriptorToInterchange, ensureOutDirParent, extractAssessments, loadLessonkitManifestFromFile, mapLessonkitIds, packageLessonkitCourse, parseLessonkitManifest, promoteStagingToOutDir, remapArtifactPaths, resolveSafePackageOutputOverride, resolveSpaLessons, themeToLxpackRuntime, validateDescriptor, validateLessonkitProject, validatePackageInputs, validateProjectPaths, writeLxpackProject };
+export { type AssessmentDescriptor, type BuildLessonkitProjectOptions, type BuildStagingPackageOptions, type BuildStagingPackageResult, type DescriptorValidationIssue, type DescriptorValidationResult, type LessonDescriptor, type LessonkitCourseDescriptor, type LessonkitManifest, type LessonkitManifestPaths, type LxpackInjectedAssessment, type LxpackRuntimeTheme, type ManifestParseIssue, type MappedLessonkitIds, type PackageLessonkitCourseOptions, type PackageLessonkitCourseResult, type PackageValidationIssue, type ParseManifestResult, type ProjectPathsInput, type SpaLayout, type SpaLessonEntry, type ValidateLessonkitProjectOptions, type ValidatePackageInputsResult, type ValidationIssue, type WriteLxpackProjectOptions, type WriteLxpackProjectResult, assessmentDescriptorToLxpack, buildLessonkitProject, buildStagingPackage, descriptorToInterchange, ensureOutDirParent, extractAssessments, loadLessonkitManifestFromFile, mapLessonkitIds, packageLessonkitCourse, parseLessonkitManifest, promoteStagingToOutDir, remapArtifactPaths, resolveSafePackageOutputOverride, resolveSpaLessons, themeToLxpackRuntime, validateDescriptor, validateDescriptorForTarget, validateLessonkitProject, validatePackageInputs, validateProjectPaths, writeLxpackProject };