@lessonkit/lxpack 0.8.0 → 0.9.0

package/dist/index.cjs

@@ -1,7 +1,9 @@
 "use strict";
+var __create = Object.create;
 var __defProp = Object.defineProperty;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
 var __export = (target, all) => {
   for (var name in all)
@@ -15,21 +17,38 @@ var __copyProps = (to, from, except, desc) => {
   }
   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, {
+  LESSONKIT_TELEMETRY_EVENTS: () => import_tracking_schema2.LESSONKIT_TELEMETRY_EVENTS,
   assessmentDescriptorToLxpack: () => assessmentDescriptorToLxpack,
   buildLessonkitProject: () => buildLessonkitProject,
   descriptorToInterchange: () => descriptorToInterchange,
   extractAssessments: () => extractAssessments,
+  lessonkitInterchangeSchema: () => import_validators2.lessonkitInterchangeSchema,
   mapLessonkitIds: () => mapLessonkitIds,
+  mapLessonkitTelemetryToBridgeAction: () => import_tracking_schema2.mapLessonkitTelemetryToBridgeAction,
+  mapLessonkitTelemetryToLxpack: () => import_tracking_schema2.mapLessonkitTelemetryToLxpack,
+  materializeLessonkitProject: () => import_validators2.materializeLessonkitProject,
   packageLessonkitCourse: () => packageLessonkitCourse,
+  parseLessonkitInterchange: () => import_validators2.parseLessonkitInterchange,
+  resolveSafePackageOutputOverride: () => resolveSafePackageOutputOverride,
   resolveSpaLessons: () => resolveSpaLessons,
+  telemetryEventToLessonkit: () => telemetryEventToLessonkit,
   themeToLxpackRuntime: () => themeToLxpackRuntime,
   validateDescriptor: () => validateDescriptor,
   validateLessonkitProject: () => validateLessonkitProject,
+  validateProjectPaths: () => validateProjectPaths,
   writeLxpackProject: () => writeLxpackProject
 });
 module.exports = __toCommonJS(index_exports);
@@ -43,8 +62,8 @@ 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(/[/\\]/);
-  if (segments.some((s) => s === "..")) return false;
+  const segments = spaPath.split(/[/\\]/).filter((s) => s.length > 0);
+  if (segments.some((s) => s === ".." || s === ".")) return false;
   return true;
 }
 function assertResolvedPathUnderRoot(root, target) {
@@ -56,6 +75,21 @@ function assertResolvedPathUnderRoot(root, target) {
   }
 }
 
+// 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 {
+    theme: theme.name,
+    cssVariables
+  };
+}
+
 // src/validateDescriptor.ts
 var VALID_LAYOUTS = ["single-spa", "per-lesson-spa"];
 var VALID_THEME_PRESETS = ["default", "light", "dark", "brand"];
@@ -117,6 +151,25 @@ function validateDescriptor(input) {
       message: `unknown preset; use one of: ${VALID_THEME_PRESETS.join(", ")}`
     });
   }
+  if (input.theme?.theme) {
+    try {
+      themeToLxpackRuntime({ preset: themePreset, theme: input.theme.theme });
+    } catch (err) {
+      issues.push({
+        path: "theme.theme",
+        message: err instanceof Error ? err.message : "invalid custom theme"
+      });
+    }
+  }
+  const completionThreshold = input.tracking?.completion?.threshold;
+  if (completionThreshold !== void 0) {
+    if (!Number.isFinite(completionThreshold) || completionThreshold < 0 || completionThreshold > 1) {
+      issues.push({
+        path: "tracking.completion.threshold",
+        message: "threshold must be a finite number between 0 and 1"
+      });
+    }
+  }
   if (layout === "single-spa" && (input.lessons?.length ?? 0) > 1) {
     issues.push({
       path: "lessons",
@@ -196,24 +249,69 @@ function validateDescriptor(input) {
       issues.push({ path: `${path}.answer`, message: "answer must match a choice" });
     }
     const passingScore = assessment.passingScore;
-    if (passingScore !== void 0) {
-      if (!(passingScore > 0)) {
-        issues.push({
-          path: `${path}.passingScore`,
-          message: "passingScore must be greater than 0"
-        });
-      } else if (trimmedChoices.length && passingScore > trimmedChoices.length) {
-        issues.push({
-          path: `${path}.passingScore`,
-          message: "passingScore must not exceed the number of choices"
-        });
-      }
+    if (passingScore !== void 0 && !(passingScore > 0)) {
+      issues.push({
+        path: `${path}.passingScore`,
+        message: "passingScore must be greater than 0 (absolute point threshold)"
+      });
     }
   }
   if (issues.length) return { ok: false, issues };
   return { ok: true, descriptor: normalizeDescriptor(input) };
 }
 
+// src/validateProjectPaths.ts
+var import_node_path2 = require("path");
+function validatePathField(value, fieldPath, projectRoot, issues) {
+  if (!isSafeRelativeSpaPath(value)) {
+    issues.push({
+      path: fieldPath,
+      message: "path must be relative without '..' segments or absolute prefixes"
+    });
+    return;
+  }
+  try {
+    assertResolvedPathUnderRoot(projectRoot, (0, import_node_path2.resolve)(projectRoot, value));
+  } catch {
+    issues.push({
+      path: fieldPath,
+      message: "path must resolve inside the project root"
+    });
+  }
+}
+function validateProjectPaths(projectRoot, paths) {
+  const issues = [];
+  const root = (0, import_node_path2.resolve)(projectRoot);
+  if (paths.spaDistDir?.trim()) {
+    validatePathField(paths.spaDistDir.trim(), "paths.spaDistDir", root, issues);
+  }
+  if (paths.lxpackOutDir?.trim()) {
+    validatePathField(paths.lxpackOutDir.trim(), "paths.lxpackOutDir", root, issues);
+  }
+  if (paths.outputBaseDir?.trim()) {
+    validatePathField(paths.outputBaseDir.trim(), "paths.outputBaseDir", root, issues);
+  }
+  return issues;
+}
+function resolveSafePackageOutputOverride(projectRoot, override) {
+  const root = (0, import_node_path2.resolve)(projectRoot);
+  const trimmed = override.trim();
+  if (!trimmed) {
+    throw new Error("output override must be a non-empty path");
+  }
+  if ((0, import_node_path2.isAbsolute)(trimmed)) {
+    const resolved2 = (0, import_node_path2.resolve)(trimmed);
+    assertResolvedPathUnderRoot(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);
+  return resolved;
+}
+
 // src/mapIds.ts
 var import_core2 = require("@lessonkit/core");
 function mapLessonkitIds(descriptor) {
@@ -225,20 +323,36 @@ function mapLessonkitIds(descriptor) {
   return { courseId, lessonIds, checkIds };
 }
 
-// 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);
-  }
+// src/assessments.ts
+function slugChoiceId(text, index) {
+  const base = text.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-|-$/g, "").slice(0, 32);
+  const stem = base.length ? base : "choice";
+  return `${stem}-${index + 1}`;
+}
+function assessmentDescriptorToLxpack(assessment) {
+  const choices = assessment.choices.map((text, index) => {
+    const id = slugChoiceId(text, index);
+    return {
+      id,
+      text,
+      correct: text === assessment.answer
+    };
+  });
   return {
-    theme: theme.name,
-    cssVariables
+    id: assessment.checkId,
+    passingScore: assessment.passingScore ?? 1,
+    questions: [
+      {
+        id: "q1",
+        prompt: assessment.question,
+        choices
+      }
+    ]
   };
 }
+function extractAssessments(descriptor) {
+  return (descriptor.assessments ?? []).map(assessmentDescriptorToLxpack);
+}
 
 // src/interchange.ts
 function resolveSpaLessons(descriptor) {
@@ -263,6 +377,8 @@ function resolveSpaLessons(descriptor) {
 function descriptorToInterchange(descriptor) {
   const mapped = mapLessonkitIds(descriptor);
   const spaLessons = resolveSpaLessons(descriptor);
+  const runtime = descriptor.theme ? themeToLxpackRuntime(descriptor.theme) : void 0;
+  const assessments = extractAssessments(descriptor);
   return {
     format: "lessonkit",
     version: "1",
@@ -276,121 +392,52 @@ function descriptorToInterchange(descriptor) {
       type: "spa",
       path: l.path
     })),
-    tracking: descriptor.tracking
-  };
-}
-
-// src/assessments.ts
-function slugChoiceId(text, index) {
-  const base = text.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-|-$/g, "").slice(0, 32);
-  const stem = base.length ? base : "choice";
-  return `${stem}-${index + 1}`;
-}
-function assessmentDescriptorToLxpack(assessment) {
-  const choices = assessment.choices.map((text, index) => {
-    const id = slugChoiceId(text, index);
-    return {
-      id,
-      text,
-      correct: text === assessment.answer
-    };
-  });
-  return {
-    id: assessment.checkId,
-    passingScore: assessment.passingScore ?? 1,
-    questions: [
-      {
-        id: "q1",
-        prompt: assessment.question,
-        choices
-      }
-    ]
+    tracking: descriptor.tracking,
+    runtime: runtime ? {
+      theme: runtime.theme,
+      cssVariables: runtime.cssVariables
+    } : void 0,
+    assessments: assessments.length ? assessments : void 0
   };
 }
-function extractAssessments(descriptor) {
-  return (descriptor.assessments ?? []).map(assessmentDescriptorToLxpack);
-}
 
 // src/writeProject.ts
-var import_promises = require("fs/promises");
-var import_node_path2 = require("path");
+var import_node_path4 = require("path");
+var import_validators = require("@lxpack/validators");
 
-// src/assessmentYaml.ts
-function yamlQuote(value) {
-  return JSON.stringify(value);
-}
-function emitAssessmentYaml(assessment) {
-  const lx = assessmentDescriptorToLxpack(assessment);
-  const lines = [];
-  lines.push(`id: ${lx.id}`);
-  lines.push(`passingScore: ${lx.passingScore}`);
-  lines.push("questions:");
-  for (const question of lx.questions) {
-    lines.push(`  - id: ${question.id}`);
-    lines.push(`    prompt: ${yamlQuote(question.prompt)}`);
-    lines.push("    choices:");
-    for (const choice of question.choices) {
-      lines.push(`      - id: ${choice.id}`);
-      lines.push(`        text: ${yamlQuote(choice.text)}`);
-      if (choice.correct) lines.push("        correct: true");
+// src/spaDirs.ts
+var import_promises = require("fs/promises");
+var import_node_path3 = require("path");
+async function resolveSpaDirs(options) {
+  const { descriptor, spaDistDir, lessonSpaDirs, projectRoot } = options;
+  const spaLessons = resolveSpaLessons(descriptor);
+  if (descriptor.layout === "single-spa") {
+    const spaDistRelative = spaDistDir ?? descriptor.spaDistDir ?? "dist";
+    const srcDist = projectRoot ? (0, import_node_path3.resolve)(projectRoot, spaDistRelative) : (0, import_node_path3.resolve)(spaDistRelative);
+    if (projectRoot) {
+      assertResolvedPathUnderRoot((0, import_node_path3.resolve)(projectRoot), srcDist);
     }
-  }
-  return `${lines.join("\n")}
-`;
-}
-
-// src/yaml.ts
-function yamlQuote2(value) {
-  if (/[:#\n\r]/.test(value) || value.startsWith(" ") || value.endsWith(" ")) {
-    return JSON.stringify(value);
-  }
-  return value;
-}
-function emitCourseYaml(opts) {
-  const lines = [];
-  lines.push(`title: ${yamlQuote2(opts.title)}`);
-  lines.push(`version: ${yamlQuote2(opts.version)}`);
-  if (opts.description) lines.push(`description: ${yamlQuote2(opts.description)}`);
-  if (opts.runtime) {
-    lines.push("runtime:");
-    lines.push(`  theme: ${yamlQuote2(opts.runtime.theme)}`);
-    if (opts.runtime.cssVariables && Object.keys(opts.runtime.cssVariables).length) {
-      lines.push("  cssVariables:");
-      for (const [key, value] of Object.entries(opts.runtime.cssVariables).sort(
-        ([a], [b]) => a.localeCompare(b)
-      )) {
-        lines.push(`    ${key}: ${JSON.stringify(String(value))}`);
-      }
+    try {
+      await (0, import_promises.access)(srcDist);
+    } catch {
+      throw new Error(`spaDistDir not found: ${srcDist}`);
     }
+    const lessonId = spaLessons[0]?.id ?? "main";
+    return { [lessonId]: srcDist };
   }
-  if (opts.tracking?.completion?.threshold !== void 0) {
-    lines.push("tracking:");
-    lines.push("  completion:");
-    lines.push(`    threshold: ${opts.tracking.completion.threshold}`);
-  }
-  lines.push("lessons:");
-  for (const lesson of opts.lessons) {
-    lines.push(`  - id: ${lesson.id}`);
-    lines.push(`    title: ${yamlQuote2(lesson.title)}`);
-    lines.push(`    type: spa`);
-    lines.push(`    path: ${lesson.path}`);
-  }
-  if (opts.assessments.length) {
-    lines.push("assessments:");
-    for (const assessment of opts.assessments) {
-      lines.push(`  - id: ${assessment.id}`);
-      lines.push(`    file: ${assessment.file}`);
+  const dirs = {};
+  const lessonDirs = lessonSpaDirs ?? {};
+  for (const lesson of descriptor.lessons) {
+    const src = lessonDirs[lesson.id];
+    if (!src) {
+      throw new Error(`lessonSpaDirs missing build output for lesson "${lesson.id}"`);
     }
+    dirs[lesson.id] = (0, import_node_path3.resolve)(src);
   }
-  return `${lines.join("\n")}
-`;
+  return dirs;
 }
 
 // src/writeProject.ts
-async function copyDir(src, dest) {
-  await (0, import_promises.mkdir)((0, import_node_path2.dirname)(dest), { recursive: true });
-  await (0, import_promises.cp)(src, dest, { recursive: true });
-}
 async function writeLxpackProject(options) {
   const validation = validateDescriptor(options.descriptor);
   if (!validation.ok) {
@@ -399,90 +446,42 @@ async function writeLxpackProject(options) {
     );
   }
   const descriptor = validation.descriptor;
-  const outDir = (0, import_node_path2.resolve)(options.outDir);
-  await (0, import_promises.mkdir)(outDir, { recursive: true });
-  const spaLessons = resolveSpaLessons(descriptor);
-  const runtime = descriptor.theme ? themeToLxpackRuntime(descriptor.theme) : void 0;
-  const assessments = (descriptor.assessments ?? []).map((a) => ({
-    id: a.checkId,
-    file: `assessments/${a.checkId}.yaml`
-  }));
-  if (descriptor.layout === "single-spa") {
-    const srcDist = (0, import_node_path2.resolve)(options.spaDistDir ?? descriptor.spaDistDir ?? "dist");
-    try {
-      await (0, import_promises.access)(srcDist);
-    } catch {
-      throw new Error(`spaDistDir not found: ${srcDist}`);
-    }
-    const destDist = (0, import_node_path2.join)(outDir, "dist");
-    await (0, import_promises.rm)(destDist, { recursive: true, force: true });
-    await copyDir(srcDist, destDist);
-  } else {
-    const lessonDirs = options.lessonSpaDirs ?? {};
-    for (const lesson of descriptor.lessons) {
-      const src = lessonDirs[lesson.id];
-      if (!src) {
-        throw new Error(`lessonSpaDirs missing build output for lesson "${lesson.id}"`);
-      }
-      const dest = (0, import_node_path2.join)(outDir, lesson.spaPath);
-      assertResolvedPathUnderRoot(outDir, dest);
-      await (0, import_promises.rm)(dest, { recursive: true, force: true });
-      await copyDir((0, import_node_path2.resolve)(src), dest);
-    }
-  }
-  if (assessments.length) {
-    const assessmentsDir = (0, import_node_path2.join)(outDir, "assessments");
-    await (0, import_promises.mkdir)(assessmentsDir, { recursive: true });
-    for (const assessment of descriptor.assessments ?? []) {
-      await (0, import_promises.writeFile)(
-        (0, import_node_path2.join)(outDir, `assessments/${assessment.checkId}.yaml`),
-        emitAssessmentYaml(assessment),
-        "utf-8"
-      );
-    }
+  const outDir = (0, import_node_path4.resolve)(options.outDir);
+  const spaDirs = await resolveSpaDirs({ ...options, descriptor });
+  const interchange = descriptorToInterchange(descriptor);
+  const materialized = await (0, import_validators.materializeLessonkitProject)({
+    interchange,
+    spaDirs,
+    courseDir: outDir,
+    writeAuthoringFiles: true
+  });
+  if (!materialized.ok) {
+    throw new Error(
+      materialized.issues.map((i) => `${i.path ?? ""}: ${i.message}`.trim()).join("; ")
+    );
   }
-  const courseYamlPath = (0, import_node_path2.join)(outDir, "course.yaml");
-  await (0, import_promises.writeFile)(
-    courseYamlPath,
-    emitCourseYaml({
-      title: descriptor.title,
-      version: descriptor.version ?? "1.0.0",
-      runtime,
-      tracking: descriptor.tracking,
-      lessons: spaLessons.map((l) => ({
-        id: l.id,
-        title: l.title,
-        type: "spa",
-        path: l.path
-      })),
-      assessments
-    }),
-    "utf-8"
-  );
-  const lessonkitJsonPath = (0, import_node_path2.join)(outDir, "lessonkit.json");
-  await (0, import_promises.writeFile)(
-    lessonkitJsonPath,
-    `${JSON.stringify(descriptorToInterchange(descriptor), null, 2)}
-`,
-    "utf-8"
-  );
-  return { outDir, courseYamlPath, lessonkitJsonPath };
+  const courseDir = materialized.courseDir;
+  return {
+    outDir: courseDir,
+    courseYamlPath: (0, import_node_path4.join)(courseDir, "course.yaml"),
+    lessonkitJsonPath: (0, import_node_path4.join)(courseDir, "lessonkit.json")
+  };
 }
 
 // src/packageCourse.ts
-var import_promises2 = require("fs/promises");
-var import_node_path3 = require("path");
+var fsp = __toESM(require("fs/promises"), 1);
+var import_node_path5 = require("path");
 var import_node_os = require("os");
 var import_api = require("@lxpack/api");
 async function validateLessonkitProject(options) {
   return (0, import_api.validateCourse)({
-    courseDir: (0, import_node_path3.resolve)(options.courseDir),
+    courseDir: (0, import_node_path5.resolve)(options.courseDir),
     target: options.target
   });
 }
 async function buildLessonkitProject(options) {
   return (0, import_api.buildCourse)({
-    courseDir: (0, import_node_path3.resolve)(options.courseDir),
+    courseDir: (0, import_node_path5.resolve)(options.courseDir),
     target: options.target,
     output: options.output,
     dir: options.dir,
@@ -490,9 +489,38 @@ async function buildLessonkitProject(options) {
     assessments: options.assessments
   });
 }
+async function pathExists(path) {
+  try {
+    await fsp.access(path);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function promoteStagingToOutDir(stagingDir, outDir) {
+  const tmpPromote = `${outDir}.tmp-promote`;
+  const backup = `${outDir}.bak`;
+  await fsp.rename(stagingDir, tmpPromote);
+  const hadOutDir = await pathExists(outDir);
+  if (hadOutDir) {
+    await fsp.rename(outDir, backup);
+  }
+  try {
+    await fsp.rename(tmpPromote, outDir);
+  } catch (promoteError) {
+    if (hadOutDir) {
+      await fsp.rename(backup, outDir).catch(() => void 0);
+    }
+    await fsp.rm(tmpPromote, { recursive: true, force: true }).catch(() => void 0);
+    throw promoteError;
+  }
+  if (hadOutDir) {
+    await fsp.rm(backup, { recursive: true, force: true }).catch(() => void 0);
+  }
+}
 async function packageLessonkitCourse(options) {
   const { target, output, dir, outputBaseDir, ...writeOpts } = options;
-  const outDir = (0, import_node_path3.resolve)(writeOpts.outDir);
+  const outDir = (0, import_node_path5.resolve)(writeOpts.outDir);
   const descriptorValidation = validateDescriptor(writeOpts.descriptor);
   if (!descriptorValidation.ok) {
     return {
@@ -506,42 +534,50 @@ async function packageLessonkitCourse(options) {
     };
   }
   const descriptor = descriptorValidation.descriptor;
-  const stagingDir = await (0, import_promises2.mkdtemp)((0, import_node_path3.join)((0, import_node_os.tmpdir)(), "lessonkit-lxpack-"));
+  const stagingDir = await fsp.mkdtemp((0, import_node_path5.join)((0, import_node_os.tmpdir)(), "lessonkit-lxpack-"));
   let promoted = false;
   try {
-    const written = await writeLxpackProject({ ...writeOpts, descriptor, outDir: stagingDir });
-    const courseDir = written.outDir;
-    const assessments = extractAssessments(descriptor);
-    const validation = await validateLessonkitProject({ courseDir, target });
-    if (!validation.ok) {
+    let spaDirs;
+    try {
+      spaDirs = await resolveSpaDirs({ ...writeOpts, descriptor });
+    } catch (err) {
       return {
         ok: false,
         courseDir: outDir,
         target,
-        validation,
-        issues: validation.issues.map((i) => ({
-          path: i.path,
-          message: i.message,
-          severity: i.severity
-        }))
+        issues: [
+          {
+            path: "spaDirs",
+            message: err instanceof Error ? err.message : String(err)
+          }
+        ]
       };
     }
+    const interchange = descriptorToInterchange(descriptor);
     const outputBase = outputBaseDir ?? ".lxpack/out";
-    await (0, import_promises2.mkdir)((0, import_node_path3.join)(courseDir, outputBase), { recursive: true });
-    const defaultOutput = output ?? (dir ? (0, import_node_path3.join)(outputBase, target) : (0, import_node_path3.join)(outputBase, `course-${target}.zip`));
-    const build = await buildLessonkitProject({
-      courseDir,
+    await fsp.mkdir((0, import_node_path5.join)(stagingDir, outputBase), { recursive: true });
+    const defaultOutput = output ?? (dir ? (0, import_node_path5.join)(outputBase, target) : (0, import_node_path5.join)(outputBase, `course-${target}.zip`));
+    const build = await (0, import_api.packageLessonkit)({
+      interchange,
+      spaDirs,
       target,
-      output: defaultOutput.startsWith("/") ? defaultOutput : (0, import_node_path3.join)(courseDir, defaultOutput),
+      courseDir: stagingDir,
+      output: defaultOutput,
       dir,
-      assessments: assessments.length ? assessments : void 0
+      outputBaseDir,
+      outputAnchorDir: stagingDir,
+      writeAuthoringFiles: true
     });
     if (!build.ok) {
+      const validation2 = {
+        ok: false,
+        issues: build.issues
+      };
       return {
         ok: false,
         courseDir: outDir,
         target,
-        validation,
+        validation: validation2,
         build,
         issues: build.issues.map((i) => ({
           path: i.path,
@@ -550,46 +586,105 @@ async function packageLessonkitCourse(options) {
         }))
       };
     }
-    await (0, import_promises2.rm)(outDir, { recursive: true, force: true });
-    await (0, import_promises2.mkdir)((0, import_node_path3.dirname)(outDir), { recursive: true });
-    await (0, import_promises2.rename)(stagingDir, outDir);
-    promoted = true;
+    const validation = {
+      ok: true,
+      manifest: build.manifest,
+      issues: build.issues
+    };
+    const stagingRoot = await fsp.realpath(stagingDir);
     const remapArtifactPath = (artifactPath) => {
       if (!artifactPath) return void 0;
-      const resolved = (0, import_node_path3.resolve)(artifactPath);
-      const stagingResolved = (0, import_node_path3.resolve)(stagingDir);
-      if (resolved === stagingResolved || resolved.startsWith(stagingResolved + "/")) {
-        return (0, import_node_path3.join)(outDir, resolved.slice(stagingResolved.length + 1));
+      const resolved = (0, import_node_path5.resolve)(artifactPath);
+      if (resolved === stagingRoot || resolved.startsWith(`${stagingRoot}/`)) {
+        return (0, import_node_path5.join)(outDir, resolved.slice(stagingRoot.length + 1));
       }
       return artifactPath;
     };
+    const remappedOutputPath = remapArtifactPath(
+      "outputPath" in build ? build.outputPath : void 0
+    );
+    const remappedOutputDir = remapArtifactPath("outputDir" in build ? build.outputDir : void 0);
+    await fsp.mkdir((0, import_node_path5.dirname)(outDir), { recursive: true });
+    await promoteStagingToOutDir(stagingDir, outDir);
+    promoted = true;
+    const remappedBuild = { ...build };
+    if ("outputPath" in remappedBuild && remappedOutputPath !== void 0) {
+      remappedBuild.outputPath = remappedOutputPath;
+    }
+    if ("outputDir" in remappedBuild && remappedOutputDir !== void 0) {
+      remappedBuild.outputDir = remappedOutputDir;
+    }
     return {
       ok: true,
       courseDir: outDir,
       target,
-      outputPath: remapArtifactPath("outputPath" in build ? build.outputPath : void 0),
-      outputDir: remapArtifactPath("outputDir" in build ? build.outputDir : void 0),
+      outputPath: remappedOutputPath,
+      outputDir: remappedOutputDir,
       fileCount: build.fileCount,
       validation,
-      build
+      build: remappedBuild
     };
   } finally {
     if (!promoted) {
-      await (0, import_promises2.rm)(stagingDir, { recursive: true, force: true }).catch(() => void 0);
+      await fsp.rm(stagingDir, { recursive: true, force: true }).catch(() => void 0);
+    }
+  }
+}
+
+// src/index.ts
+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 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;
+    mapped.assessmentId = data?.checkId;
+    if (data && "score" in data) {
+      mapped.score = data.score;
+      mapped.maxScore = data.maxScore;
+      mapped.passingScore = data.passingScore;
     }
+    if (data) {
+      mapped.data = data;
+    }
+  } else if (name === "interaction" && event.data) {
+    mapped.data = event.data;
   }
+  return mapped;
 }
+
+// src/index.ts
+var import_validators2 = require("@lxpack/validators");
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
+  LESSONKIT_TELEMETRY_EVENTS,
   assessmentDescriptorToLxpack,
   buildLessonkitProject,
   descriptorToInterchange,
   extractAssessments,
+  lessonkitInterchangeSchema,
   mapLessonkitIds,
+  mapLessonkitTelemetryToBridgeAction,
+  mapLessonkitTelemetryToLxpack,
+  materializeLessonkitProject,
   packageLessonkitCourse,
+  parseLessonkitInterchange,
+  resolveSafePackageOutputOverride,
   resolveSpaLessons,
+  telemetryEventToLessonkit,
   themeToLxpackRuntime,
   validateDescriptor,
   validateLessonkitProject,
+  validateProjectPaths,
   writeLxpackProject
 });