@lessonkit/lxpack 1.4.0 → 1.6.0

package/dist/index.cjs

@@ -31,21 +31,27 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 var index_exports = {};
 __export(index_exports, {
   LESSONKIT_TELEMETRY_EVENTS: () => import_tracking_schema2.LESSONKIT_TELEMETRY_EVENTS,
+  assertSpaDistContentsSafe: () => assertSpaDistContentsSafe,
   assessmentDescriptorToLxpack: () => assessmentDescriptorToLxpack,
   buildLessonkitProject: () => buildLessonkitProject,
   buildStagingPackage: () => buildStagingPackage,
   descriptorToInterchange: () => descriptorToInterchange,
   ensureOutDirParent: () => ensureOutDirParent,
+  escapeShellText: () => escapeShellText,
+  exportLkcourse: () => exportLkcourse,
   extractAssessments: () => extractAssessments,
-  lessonkitInterchangeSchema: () => import_validators2.lessonkitInterchangeSchema,
+  extractBlockTree: () => extractBlockTree,
+  importLkcourse: () => importLkcourse,
+  lessonkitInterchangeSchema: () => import_validators4.lessonkitInterchangeSchema,
   loadLessonkitManifestFromFile: () => loadLessonkitManifestFromFile,
   mapLessonkitIds: () => mapLessonkitIds,
   mapLessonkitTelemetryToBridgeAction: () => import_tracking_schema2.mapLessonkitTelemetryToBridgeAction,
   mapLessonkitTelemetryToLxpack: () => import_tracking_schema2.mapLessonkitTelemetryToLxpack,
-  materializeLessonkitProject: () => import_validators2.materializeLessonkitProject,
+  materializeLessonkitProject: () => import_validators4.materializeLessonkitProject,
   packageLessonkitCourse: () => packageLessonkitCourse,
-  parseLessonkitInterchange: () => import_validators2.parseLessonkitInterchange,
+  parseLessonkitInterchange: () => import_validators4.parseLessonkitInterchange,
   parseLessonkitManifest: () => parseLessonkitManifest,
+  parseLkcourseEnvelope: () => parseLkcourseEnvelope,
   promoteStagingToOutDir: () => promoteStagingToOutDir,
   remapArtifactPaths: () => remapArtifactPaths,
   resolveSafePackageOutputOverride: () => resolveSafePackageOutputOverride,
@@ -55,6 +61,8 @@ __export(index_exports, {
   validateDescriptor: () => validateDescriptor,
   validateDescriptorForTarget: () => validateDescriptorForTarget,
   validateLessonkitProject: () => validateLessonkitProject,
+  validateLkcourse: () => validateLkcourse,
+  validateLkcourseArchiveEntries: () => validateLkcourseArchiveEntries,
   validatePackageInputs: () => validatePackageInputs,
   validateProjectPaths: () => validateProjectPaths,
   validateReactManifestParity: () => validateReactManifestParity,
@@ -159,10 +167,18 @@ function parseAssessmentDescriptor(raw) {
   };
   const kind = raw.kind;
   if (kind === "trueFalse") {
+    let answer;
+    if (typeof raw.answer === "boolean") {
+      answer = raw.answer;
+    } else if (raw.answer === "true") {
+      answer = true;
+    } else if (raw.answer === "false") {
+      answer = false;
+    }
     return {
       kind: "trueFalse",
       ...base,
-      answer: typeof raw.answer === "boolean" ? raw.answer : raw.answer === "true"
+      answer
     };
   }
   if (kind === "fillInBlanks") {
@@ -340,6 +356,98 @@ function isResolvedPathUnderRoot(root, target) {
   return !rel.startsWith("..") && !(0, import_node_path.isAbsolute)(rel);
 }
 
+// src/validateProjectPaths.ts
+var import_node_fs2 = require("fs");
+var import_node_path2 = require("path");
+var RESERVED_OUTPUT_SEGMENTS = /* @__PURE__ */ new Set([".git", "node_modules", ".github"]);
+function isReservedOutputPath(value) {
+  let normalized = value.replace(/\\/g, "/");
+  while (normalized.startsWith("/")) normalized = normalized.slice(1);
+  while (normalized.endsWith("/")) normalized = normalized.slice(0, -1);
+  const segments = normalized.split("/").filter(Boolean);
+  return segments.some((segment) => RESERVED_OUTPUT_SEGMENTS.has(segment));
+}
+function isReservedResolvedOutputPath(projectRoot, resolved) {
+  const rootResolved = resolveComparablePath(projectRoot);
+  const targetResolved = resolveComparablePath(resolved);
+  try {
+    const rootReal = (0, import_node_fs2.existsSync)(rootResolved) ? (0, import_node_fs2.realpathSync)(rootResolved) : rootResolved;
+    const targetReal = (0, import_node_fs2.existsSync)(targetResolved) ? (0, import_node_fs2.realpathSync)(targetResolved) : targetResolved;
+    const rel = relativePathUnderRoot(rootReal, targetReal);
+    return isReservedOutputPath(rel);
+  } catch {
+    return isReservedOutputPath(resolved);
+  }
+}
+function validatePathField(value, fieldPath, projectRoot, issues, options) {
+  if (!isSafeRelativeSpaPath(value)) {
+    issues.push({
+      path: fieldPath,
+      message: "path must be relative without '..' segments or absolute prefixes"
+    });
+    return;
+  }
+  if (options?.rejectReserved && isReservedOutputPath(value)) {
+    issues.push({
+      path: fieldPath,
+      message: "path must not target reserved directories (.git, node_modules, .github)"
+    });
+    return;
+  }
+  try {
+    assertRealPathUnderRoot(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, {
+      rejectReserved: true
+    });
+  }
+  if (paths.lxpackOutDir?.trim()) {
+    validatePathField(paths.lxpackOutDir.trim(), "paths.lxpackOutDir", root, issues, {
+      rejectReserved: true
+    });
+  }
+  if (paths.outputBaseDir?.trim()) {
+    validatePathField(paths.outputBaseDir.trim(), "paths.outputBaseDir", root, issues, {
+      rejectReserved: true
+    });
+  }
+  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);
+    assertRealPathUnderRoot(root, resolved2);
+    if (isReservedOutputPath(trimmed) || isReservedResolvedOutputPath(root, resolved2)) {
+      throw new Error(`unsafe output path: ${override} targets a reserved directory`);
+    }
+    return resolved2;
+  }
+  if (!isSafeRelativeSpaPath(trimmed)) {
+    throw new Error(`unsafe output path: ${override}`);
+  }
+  const resolved = (0, import_node_path2.resolve)(root, trimmed);
+  assertRealPathUnderRoot(root, resolved);
+  if (isReservedOutputPath(trimmed) || isReservedResolvedOutputPath(root, resolved)) {
+    throw new Error(`unsafe output path: ${override} targets a reserved directory`);
+  }
+  return resolved;
+}
+
 // src/theme.ts
 var import_themes = require("@lessonkit/themes");
 function themeToLxpackRuntime(input) {
@@ -404,8 +512,52 @@ var ASSESSMENT_VALIDATORS = {
     }
   },
   fillInBlanks: (assessment, path, issues) => {
-    if (assessment.kind === "fillInBlanks" && !assessment.template?.trim()) {
+    if (assessment.kind !== "fillInBlanks") return;
+    if (!assessment.template?.trim()) {
       issues.push({ path: `${path}.template`, message: "template is required for fillInBlanks" });
+      return;
+    }
+    const templateBlankCount = countStarDelimitedBlanks(assessment.template);
+    if (templateBlankCount === 0) {
+      issues.push({
+        path: `${path}.template`,
+        message: "template must include at least one blank wrapped in asterisks for fillInBlanks"
+      });
+    }
+    const explicitBlanks = [];
+    if (assessment.blanks !== void 0) {
+      for (let i = 0; i < assessment.blanks.length; i++) {
+        const blank = assessment.blanks[i];
+        if (!blank || typeof blank !== "object") {
+          issues.push({
+            path: `${path}.blanks[${i}]`,
+            message: "blank entry must be an object with non-empty id and answer"
+          });
+          continue;
+        }
+        const id = blank.id?.trim() ?? "";
+        const answer = blank.answer?.trim() ?? "";
+        if (!id || !answer) {
+          issues.push({
+            path: `${path}.blanks[${i}]`,
+            message: "blank entry must include non-empty id and answer"
+          });
+          continue;
+        }
+        explicitBlanks.push({ id, answer });
+      }
+    }
+    if (assessment.blanks !== void 0 && explicitBlanks.length === 0 && !issues.some((issue) => issue.path?.startsWith(`${path}.blanks`))) {
+      issues.push({
+        path: `${path}.blanks`,
+        message: "blanks must include at least one entry with non-empty id and answer"
+      });
+    }
+    if (explicitBlanks.length > 0 && explicitBlanks.length !== templateBlankCount) {
+      issues.push({
+        path: `${path}.blanks`,
+        message: `blanks length (${explicitBlanks.length}) must match template blank count (${templateBlankCount})`
+      });
     }
   },
   findHotspot: (assessment, path, issues) => {
@@ -543,6 +695,20 @@ function validateCourseDescriptor(input) {
       });
     }
   }
+  const descriptorSpaDistDir = input.spaDistDir?.trim();
+  if (descriptorSpaDistDir) {
+    if (!isSafeRelativeSpaPath(descriptorSpaDistDir)) {
+      issues.push({
+        path: "spaDistDir",
+        message: "spaDistDir must be a relative path without '..' segments or absolute prefixes"
+      });
+    } else if (isReservedOutputPath(descriptorSpaDistDir)) {
+      issues.push({
+        path: "spaDistDir",
+        message: "spaDistDir must not target reserved directories (.git, node_modules, .github)"
+      });
+    }
+  }
   if (layout === "single-spa" && (input.lessons?.length ?? 0) > 1) {
     issues.push({
       path: "lessons",
@@ -603,27 +769,49 @@ function validateCourseDescriptor(input) {
 }
 
 // src/assessments.ts
+var DEFAULT_SHELL_PASSING_SCORE = 1;
+function escapeShellText(text) {
+  return text.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&#39;");
+}
+function decodeShellEntities(text) {
+  return text.replace(/&amp;/gi, "&").replace(/&lt;/gi, "<").replace(/&gt;/gi, ">").replace(/&quot;/gi, '"').replace(/&#39;/gi, "'").replace(/&#x([0-9a-f]+);/gi, (_, hex) => String.fromCharCode(parseInt(hex, 16))).replace(/&#(\d+);/g, (_, num) => String.fromCharCode(Number(num)));
+}
+function containsUnsafeShellMarkup(text) {
+  const decoded = decodeShellEntities(text);
+  return /<\/script/i.test(decoded) || /<!--/.test(decoded) || /<[a-zA-Z!/]/.test(decoded);
+}
+function sanitizeShellField(text) {
+  if (containsUnsafeShellMarkup(text)) return null;
+  return escapeShellText(text);
+}
 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 mcqToLxpack(assessment) {
+  const checkId = sanitizeShellField(assessment.checkId);
+  const prompt = sanitizeShellField(assessment.question);
+  if (!checkId || !prompt) return null;
+  const normalizedAnswer = assessment.answer.trim();
   const choices = assessment.choices.map((text, index) => {
+    const sanitizedText = sanitizeShellField(text);
+    if (!sanitizedText) return null;
     const id = slugChoiceId(text, index);
     return {
       id,
-      text,
-      correct: text === assessment.answer
+      text: sanitizedText,
+      correct: text.trim() === normalizedAnswer
     };
   });
+  if (choices.some((choice) => choice === null)) return null;
   return {
-    id: assessment.checkId,
-    passingScore: assessment.passingScore ?? 1,
+    id: checkId,
+    passingScore: assessment.passingScore ?? DEFAULT_SHELL_PASSING_SCORE,
     questions: [
       {
         id: "q1",
-        prompt: assessment.question,
+        prompt,
         choices
       }
     ]
@@ -664,11 +852,14 @@ function extractAssessments(descriptor) {
 // src/descriptor/validateInjectableAssessments.ts
 function validateInjectableAssessments(descriptor) {
   const issues = [];
+  const spaOnlyKinds = /* @__PURE__ */ new Set(["fillInBlanks", "findHotspot", "findMultipleHotspots"]);
   (descriptor.assessments ?? []).forEach((assessment, index) => {
     if (assessmentDescriptorToLxpack(assessment) === null) {
+      const kind = assessment.kind ?? "mcq";
+      const hint = spaOnlyKinds.has(kind) ? " \u2014 score in the SPA only; remove from lessonkit.json for LMS targets or use an injectable kind (mcq, trueFalse)" : "";
       issues.push({
         path: `assessments[${index}]`,
-        message: `assessment kind "${assessment.kind ?? "mcq"}" (checkId "${assessment.checkId}") is not injected into LMS shell quizzes`
+        message: `assessment kind "${kind}" (checkId "${assessment.checkId}") is not injected into LMS shell quizzes${hint}`
       });
     }
   });
@@ -683,22 +874,29 @@ var LMS_SHELL_TARGETS = /* @__PURE__ */ new Set([
   "xapi",
   "cmi5"
 ]);
+function appendActivityIriIssues(issues, descriptor, target) {
+  const hasXapiTracking = Boolean(descriptor.tracking?.xapi?.activityIri?.trim());
+  const requiresForTarget = target === "xapi" || target === "cmi5";
+  if (!hasXapiTracking && !requiresForTarget) return;
+  const activityIri = descriptor.tracking?.xapi?.activityIri?.trim();
+  const targetSuffix = target === "xapi" || target === "cmi5" ? ` for ${target} export targets` : " when tracking.xapi is configured";
+  if (!activityIri) {
+    issues.push({
+      path: "tracking.xapi.activityIri",
+      message: `tracking.xapi.activityIri is required${targetSuffix}`
+    });
+    return;
+  }
+  if (!/^https:\/\/.+/i.test(activityIri)) {
+    issues.push({
+      path: "tracking.xapi.activityIri",
+      message: `tracking.xapi.activityIri must be an HTTPS URL${targetSuffix}`
+    });
+  }
+}
 function validateDescriptorForExportTarget(descriptor, target) {
   const issues = [];
-  if (target === "xapi" || target === "cmi5") {
-    const activityIri = descriptor.tracking?.xapi?.activityIri?.trim();
-    if (!activityIri) {
-      issues.push({
-        path: "tracking.xapi.activityIri",
-        message: "tracking.xapi.activityIri is required for xapi and cmi5 export targets"
-      });
-    } else if (!/^https:\/\/.+/i.test(activityIri)) {
-      issues.push({
-        path: "tracking.xapi.activityIri",
-        message: "tracking.xapi.activityIri must be an HTTPS URL for xapi and cmi5 export targets"
-      });
-    }
-  }
+  appendActivityIriIssues(issues, descriptor, target);
   if (LMS_SHELL_TARGETS.has(target)) {
     issues.push(...validateInjectableAssessments(descriptor).map((issue) => ({
       ...issue,
@@ -732,40 +930,123 @@ function validateDescriptorForTarget(input, target) {
 }
 
 // src/validateReactParity.ts
-var import_node_fs2 = require("fs");
-var import_node_path2 = require("path");
+var import_node_fs3 = require("fs");
+var import_node_path3 = require("path");
 var SCANNABLE_EXTENSIONS = [".tsx", ".ts", ".jsx", ".js"];
-function collectSourceUnderSrc(projectRoot) {
-  const srcDir = (0, import_node_path2.join)(projectRoot, "src");
-  if (!(0, import_node_fs2.existsSync)(srcDir)) return [];
+function collectSourceUnderSrc(projectRoot, issues) {
+  const srcDir = (0, import_node_path3.join)(projectRoot, "src");
+  if (!(0, import_node_fs3.existsSync)(srcDir)) return [];
   const results = [];
   const walk = (dir) => {
-    for (const entry of (0, import_node_fs2.readdirSync)(dir)) {
-      const abs = (0, import_node_path2.join)(dir, entry);
-      if ((0, import_node_fs2.statSync)(abs).isDirectory()) {
+    for (const entry of (0, import_node_fs3.readdirSync)(dir)) {
+      const abs = (0, import_node_path3.join)(dir, entry);
+      let stat2;
+      try {
+        stat2 = (0, import_node_fs3.lstatSync)(abs);
+      } catch {
+        continue;
+      }
+      if (stat2.isSymbolicLink()) {
+        issues.push({
+          path: (0, import_node_path3.relative)(projectRoot, abs),
+          message: `Source tree contains symlink (rejected for parity scan): ${(0, import_node_path3.relative)(projectRoot, abs)}`,
+          severity: "error"
+        });
+        continue;
+      }
+      if (stat2.isDirectory()) {
+        try {
+          assertRealPathUnderRoot(projectRoot, abs);
+        } catch {
+          issues.push({
+            path: (0, import_node_path3.relative)(projectRoot, abs),
+            message: `Source directory escapes project root: ${(0, import_node_path3.relative)(projectRoot, abs)}`,
+            severity: "error"
+          });
+          continue;
+        }
         walk(abs);
       } else if (SCANNABLE_EXTENSIONS.some((ext) => entry.endsWith(ext))) {
-        results.push((0, import_node_path2.relative)(projectRoot, abs));
+        try {
+          assertRealPathUnderRoot(projectRoot, abs);
+        } catch {
+          issues.push({
+            path: (0, import_node_path3.relative)(projectRoot, abs),
+            message: `Source file escapes project root: ${(0, import_node_path3.relative)(projectRoot, abs)}`,
+            severity: "error"
+          });
+          continue;
+        }
+        results.push((0, import_node_path3.relative)(projectRoot, abs));
       }
     }
   };
   walk(srcDir);
   return results;
 }
-function readAppSources(projectRoot, appSources) {
-  return appSources.map((rel) => (0, import_node_path2.join)(projectRoot, rel)).filter((abs) => (0, import_node_fs2.existsSync)(abs)).map((abs) => (0, import_node_fs2.readFileSync)(abs, "utf8")).join("\n");
+function readAppSources(projectRoot, appSources, issues, customSourcesProvided) {
+  return appSources.map((rel) => {
+    if (!isSafeRelativeSpaPath(rel)) {
+      if (customSourcesProvided) {
+        issues.push({
+          path: rel,
+          message: `Unsafe appSources path skipped: ${rel}`,
+          severity: "warning"
+        });
+      }
+      return null;
+    }
+    const abs = (0, import_node_path3.join)(projectRoot, rel);
+    try {
+      assertRealPathUnderRoot(projectRoot, abs);
+      if ((0, import_node_fs3.existsSync)(abs) && (0, import_node_fs3.lstatSync)(abs).isSymbolicLink()) {
+        issues.push({
+          path: rel,
+          message: `appSources path is a symlink: ${rel}`,
+          severity: "error"
+        });
+        return null;
+      }
+    } catch {
+      issues.push({
+        path: rel,
+        message: `appSources path escapes project root: ${rel}`,
+        severity: "error"
+      });
+      return null;
+    }
+    if (!(0, import_node_fs3.existsSync)(abs)) return null;
+    return (0, import_node_fs3.readFileSync)(abs, "utf8");
+  }).filter((content) => content != null).join("\n");
 }
 function stripComments(source) {
   return source.replace(/\/\*[\s\S]*?\*\//g, " ").replace(/\/\/[^\n]*/g, " ");
 }
-function idPropPatterns(prop, id) {
-  return [
-    `${prop}="${id}"`,
-    `${prop}='${id}'`,
-    `${prop}={'${id}'}`,
-    `${prop}={"${id}"}`,
-    `${prop}={\`${id}\`}`
-  ];
+function maskUnrelatedStringLiterals(source) {
+  return source.replace(/(["'`])(?:\\.|(?!\1).)*\1/g, (match, _quote, offset, full) => {
+    const before = full.slice(Math.max(0, offset - 24), offset);
+    if (/\b(?:courseId|checkId|lessonId)\s*=\s*$/.test(before)) {
+      return match;
+    }
+    return '""';
+  });
+}
+function idPropPresent(source, prop, id) {
+  const stripped = stripComments(source);
+  const masked = maskUnrelatedStringLiterals(stripped);
+  return jsxPropRegex(prop, id).test(masked);
+}
+function escapeRegExp(value) {
+  return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+function jsxPropRegex(prop, id) {
+  const escapedId = escapeRegExp(id);
+  return new RegExp(
+    `(?<![A-Za-z0-9_$])${prop}\\s*=\\s*(?:"${escapedId}"|'${escapedId}'|\\{\\s*["'\`]${escapedId}["'\`]\\s*\\}|\\{\\s*\`${escapedId}\`\\s*\\})`
+  );
+}
+function maskStringLiterals(source) {
+  return source.replace(/(["'`])(?:\\.|(?!\1).)*\1/g, '""');
 }
 function extractStringConstants(source) {
   const stripped = stripComments(source);
@@ -776,7 +1057,9 @@ function extractStringConstants(source) {
   }
   return map;
 }
-function idUsedViaConstant(stripped, prop, id, constants) {
+function idUsedViaConstant(source, prop, id, constants) {
+  const stripped = stripComments(source);
+  const masked = maskStringLiterals(stripped);
   for (const [name, value] of constants) {
     if (value !== id) continue;
     const jsxPatterns = [
@@ -785,40 +1068,72 @@ function idUsedViaConstant(stripped, prop, id, constants) {
       `${prop}={${name} }`,
       `${prop}={ ${name}}`
     ];
-    if (jsxPatterns.some((p) => stripped.includes(p))) return true;
-    const objPatterns = [`${prop}: ${name}`, `${prop}:${name}`];
-    if (objPatterns.some((p) => stripped.includes(p))) return true;
+    if (jsxPatterns.some((p) => masked.includes(p))) return true;
   }
   return false;
 }
-function courseIdPresent(source, courseId) {
+function lessonIdInDataLiteral(source, lessonId) {
   const stripped = stripComments(source);
-  if (idPropPatterns("courseId", courseId).some((p) => stripped.includes(p))) return true;
-  return idUsedViaConstant(stripped, "courseId", courseId, extractStringConstants(source));
+  const escaped = escapeRegExp(lessonId);
+  return new RegExp(`\\bid\\s*:\\s*["'\`]${escaped}["'\`]`).test(stripped);
 }
-function checkIdPresent(source, checkId) {
+function lessonIdPresent(source, lessonId) {
+  if (idPropPresent(source, "lessonId", lessonId)) return true;
+  if (idUsedViaConstant(source, "lessonId", lessonId, extractStringConstants(source))) return true;
+  return lessonIdInDataLiteral(source, lessonId);
+}
+function courseConfigCourseIdPresent(source, courseId) {
   const stripped = stripComments(source);
-  if (idPropPatterns("checkId", checkId).some((p) => stripped.includes(p))) return true;
-  return idUsedViaConstant(stripped, "checkId", checkId, extractStringConstants(source));
+  const escaped = escapeRegExp(courseId);
+  const literalPattern = new RegExp(
+    `(?<![A-Za-z0-9_$])courseId\\s*:\\s*(?:"${escaped}"|'${escaped}')`
+  );
+  if (literalPattern.test(stripped)) return true;
+  return idUsedViaConstant(source, "courseId", courseId, extractStringConstants(source));
+}
+function courseMetaCourseIdPresent(source, courseId) {
+  const constants = extractStringConstants(source);
+  const stripped = stripComments(source);
+  for (const [name, value] of constants) {
+    if (value !== courseId) continue;
+    if (!new RegExp(`\\bcourseId\\s*:\\s*${name}\\b`).test(stripped)) continue;
+    if (/\blessons\s*:\s*\S/.test(stripped)) return true;
+  }
+  return false;
+}
+function courseIdPresent(source, courseId) {
+  if (idPropPresent(source, "courseId", courseId)) return true;
+  if (idUsedViaConstant(source, "courseId", courseId, extractStringConstants(source))) return true;
+  if (courseMetaCourseIdPresent(source, courseId)) return true;
+  return courseConfigCourseIdPresent(source, courseId);
+}
+function checkIdPresent(source, checkId) {
+  if (idPropPresent(source, "checkId", checkId)) return true;
+  return idUsedViaConstant(source, "checkId", checkId, extractStringConstants(source));
 }
 var ID_SYNC_DOC = "https://lessonkit.readthedocs.io/en/latest/guides/react-developers/quickstart.html#keep-react-ids-in-sync-with-lessonkitjson";
 function parityHint(message) {
   return `${message} See ${ID_SYNC_DOC}`;
 }
 function validateReactManifestParity(opts) {
-  const appSources = opts.appSources ?? collectSourceUnderSrc(opts.projectRoot);
-  const source = readAppSources(opts.projectRoot, appSources);
+  const issues = [];
+  const customSourcesProvided = opts.appSources !== void 0;
+  const appSources = opts.appSources ?? collectSourceUnderSrc(opts.projectRoot, issues);
+  const source = readAppSources(
+    opts.projectRoot,
+    appSources,
+    issues,
+    customSourcesProvided
+  );
   const hasDescriptorIds = Boolean(opts.descriptor.courseId) || (opts.descriptor.assessments?.length ?? 0) > 0;
   if (!source.trim()) {
-    return [
-      {
-        path: appSources.length > 0 ? appSources.join(", ") : "src/",
-        message: hasDescriptorIds ? "React app source not found for ID parity check" : "React app source not found for ID parity check",
-        severity: hasDescriptorIds ? "error" : "warning"
-      }
-    ];
+    issues.push({
+      path: appSources.length > 0 ? appSources.join(", ") : "src/",
+      message: hasDescriptorIds ? "React app source required for ID parity check when descriptor defines courseId or assessments" : "React app source not found for ID parity check",
+      severity: hasDescriptorIds ? "error" : "warning"
+    });
+    return issues;
   }
-  const issues = [];
   const courseId = opts.descriptor.courseId;
   if (!courseIdPresent(source, courseId)) {
     issues.push({
@@ -829,6 +1144,19 @@ function validateReactManifestParity(opts) {
       severity: "error"
     });
   }
+  for (const lesson of opts.descriptor.lessons ?? []) {
+    const lessonId = lesson.id;
+    if (!lessonId) continue;
+    if (!lessonIdPresent(source, lessonId)) {
+      issues.push({
+        path: `lessons.id:${lessonId}`,
+        message: parityHint(
+          `React app source missing lessonId="${lessonId}" declared in lessonkit.json.`
+        ),
+        severity: "error"
+      });
+    }
+  }
   for (const assessment of opts.descriptor.assessments ?? []) {
     const checkId = assessment.checkId;
     if (!checkId) continue;
@@ -845,58 +1173,6 @@ function validateReactManifestParity(opts) {
   return issues;
 }
 
-// src/validateProjectPaths.ts
-var import_node_path3 = 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 {
-    assertRealPathUnderRoot(projectRoot, (0, import_node_path3.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_path3.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_path3.resolve)(projectRoot);
-  const trimmed = override.trim();
-  if (!trimmed) {
-    throw new Error("output override must be a non-empty path");
-  }
-  if ((0, import_node_path3.isAbsolute)(trimmed)) {
-    const resolved2 = (0, import_node_path3.resolve)(trimmed);
-    assertRealPathUnderRoot(root, resolved2);
-    return resolved2;
-  }
-  if (!isSafeRelativeSpaPath(trimmed)) {
-    throw new Error(`unsafe output path: ${override}`);
-  }
-  const resolved = (0, import_node_path3.resolve)(root, trimmed);
-  assertRealPathUnderRoot(root, resolved);
-  return resolved;
-}
-
 // src/mapIds.ts
 var import_core4 = require("@lessonkit/core");
 function mapLessonkitIds(descriptor) {
@@ -1028,7 +1304,7 @@ async function resolveSpaDirs(options) {
 
 // src/spaDistValidation.ts
 var import_promises2 = require("fs/promises");
-var import_node_fs3 = require("fs");
+var import_node_fs4 = require("fs");
 var import_node_path5 = require("path");
 async function assertSpaDistContentsSafe(spaDirs, projectRoot) {
   for (const [label, dir] of Object.entries(spaDirs)) {
@@ -1039,7 +1315,7 @@ async function assertSpaDistContentsSafe(spaDirs, projectRoot) {
     }
     let rootReal;
     try {
-      rootReal = (0, import_node_fs3.realpathSync)(dirResolved);
+      rootReal = (0, import_node_fs4.realpathSync)(dirResolved);
     } catch {
       throw new Error(`spa dist for "${label}" is not readable: ${dir}`);
     }
@@ -1068,9 +1344,12 @@ async function walkDistDir(rootReal, current, label) {
     }
     let entryReal;
     try {
-      entryReal = (0, import_node_fs3.realpathSync)(entryPath);
-    } catch {
-      entryReal = entryPath;
+      entryReal = (0, import_node_fs4.realpathSync)(entryPath);
+    } catch (err) {
+      throw new Error(
+        `spa dist for "${label}" could not resolve path: ${entryPath}`,
+        { cause: err }
+      );
     }
     assertResolvedPathUnderRoot(rootReal, entryReal);
     if (stat2.isDirectory()) {
@@ -1090,12 +1369,12 @@ async function writeLxpackProject(options) {
   const descriptor = validation.descriptor;
   const injectableIssues = validateInjectableAssessments(descriptor);
   if (injectableIssues.length > 0) {
-    throw new Error(injectableIssues.map((i) => `${i.path}: ${i.message}`).join("; "));
+    throw new Error(
+      injectableIssues.map((i) => `${i.path ?? "assessments"}: ${i.message}`).join("; ")
+    );
   }
   const outDir = (0, import_node_path6.resolve)(options.outDir);
-  if (options.projectRoot) {
-    assertRealPathUnderRoot((0, import_node_path6.resolve)(options.projectRoot), outDir);
-  }
+  assertRealPathUnderRoot((0, import_node_path6.resolve)(options.projectRoot), outDir);
   const spaDirs = await resolveSpaDirs({ ...options, descriptor });
   await assertSpaDistContentsSafe(spaDirs, options.projectRoot);
   const interchange = descriptorToInterchange(descriptor);
@@ -1155,6 +1434,19 @@ function validatePackageInputs(options) {
       ]
     };
   }
+  if (isReservedOutputPath(outDir) || isReservedResolvedOutputPath(projectRoot, outDir)) {
+    return {
+      ok: false,
+      courseDir: outDir,
+      target,
+      issues: [
+        {
+          path: "outDir",
+          message: "outDir must not target reserved directories (.git, node_modules, .github)"
+        }
+      ]
+    };
+  }
   if (outputBaseDir && !isSafeRelativeSpaPath(outputBaseDir)) {
     return {
       ok: false,
@@ -1212,6 +1504,19 @@ function validatePackageInputs(options) {
         ]
       };
     }
+    if (isReservedOutputPath(outputBaseDir) || isReservedResolvedOutputPath(projectRoot, resolvedOutputBase)) {
+      return {
+        ok: false,
+        courseDir: outDir,
+        target,
+        issues: [
+          {
+            path: "outputBaseDir",
+            message: "outputBaseDir must not target reserved directories (.git, node_modules, .github)"
+          }
+        ]
+      };
+    }
   }
   if (output) {
     const resolvedOutput = (0, import_node_path7.isAbsolute)(output) ? (0, import_node_path7.resolve)(output) : (0, import_node_path7.resolve)(projectRoot, output);
@@ -1233,28 +1538,57 @@ function validatePackageInputs(options) {
         ]
       };
     }
-  }
-  return { ok: true, outDir, projectRoot };
-}
-function validateArtifactInStaging(stagingRoot, artifactPath, field) {
-  if (!artifactPath) return null;
-  const resolved = resolveComparablePath(artifactPath);
-  if (!isResolvedPathUnderRoot(stagingRoot, resolved)) {
-    return {
-      path: field,
-      message: `${field} is outside the staging directory: ${artifactPath}`
-    };
-  }
-  return null;
-}
-function remapArtifactPaths(stagingRoot, outDir, artifactPath) {
-  if (!artifactPath) return void 0;
-  const resolved = resolveComparablePath(artifactPath);
-  if (!isResolvedPathUnderRoot(stagingRoot, resolved)) {
-    throw new Error(`${artifactPath} is outside the staging directory`);
-  }
-  const rel = relativePathUnderRoot(stagingRoot, resolved);
-  if (rel.startsWith("..") || (0, import_node_path7.isAbsolute)(rel)) {
+    const outputRel = (0, import_node_path7.isAbsolute)(output) ? output : output;
+    if (isReservedOutputPath(outputRel) || isReservedResolvedOutputPath(projectRoot, resolvedOutput)) {
+      return {
+        ok: false,
+        courseDir: outDir,
+        target,
+        issues: [
+          {
+            path: "output",
+            message: "output must not target reserved directories (.git, node_modules, .github)"
+          }
+        ]
+      };
+    }
+    try {
+      relativePathUnderRoot(outDir, resolvedOutput);
+    } catch {
+      return {
+        ok: false,
+        courseDir: outDir,
+        target,
+        issues: [
+          {
+            path: "output",
+            message: "output must resolve inside outDir"
+          }
+        ]
+      };
+    }
+  }
+  return { ok: true, outDir, projectRoot };
+}
+function validateArtifactInStaging(stagingRoot, artifactPath, field) {
+  if (!artifactPath) return null;
+  const resolved = resolveComparablePath(artifactPath);
+  if (!isResolvedPathUnderRoot(stagingRoot, resolved)) {
+    return {
+      path: field,
+      message: `${field} is outside the staging directory: ${artifactPath}`
+    };
+  }
+  return null;
+}
+function remapArtifactPaths(stagingRoot, outDir, artifactPath) {
+  if (!artifactPath) return void 0;
+  const resolved = resolveComparablePath(artifactPath);
+  if (!isResolvedPathUnderRoot(stagingRoot, resolved)) {
+    throw new Error(`${artifactPath} is outside the staging directory`);
+  }
+  const rel = relativePathUnderRoot(stagingRoot, resolved);
+  if (rel.startsWith("..") || (0, import_node_path7.isAbsolute)(rel)) {
     throw new Error(`${artifactPath} is outside the staging directory`);
   }
   if (!rel) return outDir;
@@ -1291,33 +1625,53 @@ function promoteLockPath(outDir) {
   const hash = (0, import_node_crypto.createHash)("sha256").update((0, import_node_path8.resolve)(outDir)).digest("hex").slice(0, 16);
   return (0, import_node_path8.join)(parent, `.lk-promote-lock-${hash}`);
 }
-var STALE_LOCK_TTL_MS = 5 * 60 * 1e3;
+var STALE_ARTIFACT_TTL_MS = 5 * 60 * 1e3;
+var MAX_LOCK_AGE_MS = 30 * 60 * 1e3;
+var LOCK_TOKEN_RE = /^(\d+)\n([0-9a-f-]{36})(?:\n(\d+))?\n?$/i;
 async function isStalePromoteLock(lockPath) {
   try {
+    const stat2 = await fsp.stat(lockPath);
     const content = await fsp.readFile(lockPath, "utf8");
-    const pid = Number.parseInt(content.trim(), 10);
-    if (Number.isFinite(pid) && pid > 0) {
-      try {
-        process.kill(pid, 0);
-        return false;
-      } catch {
-        return true;
+    const match = content.match(LOCK_TOKEN_RE);
+    let lockAgeMs = Date.now() - stat2.mtimeMs;
+    if (match?.[3]) {
+      const startedAt = Number.parseInt(match[3], 10);
+      if (Number.isFinite(startedAt) && startedAt > 0) {
+        lockAgeMs = Date.now() - startedAt;
       }
     }
-    const stat2 = await fsp.stat(lockPath);
-    return Date.now() - stat2.mtimeMs > STALE_LOCK_TTL_MS;
+    if (lockAgeMs > MAX_LOCK_AGE_MS) {
+      return true;
+    }
+    if (match) {
+      const pid = Number.parseInt(match[1], 10);
+      if (Number.isFinite(pid) && pid > 0) {
+        try {
+          process.kill(pid, 0);
+          return false;
+        } catch {
+          return true;
+        }
+      }
+    }
+    return lockAgeMs > STALE_ARTIFACT_TTL_MS;
   } catch {
     return true;
   }
 }
+var PROMOTE_LOCK_TIMEOUT_MS = 15e3;
 async function withPromoteLock(outDir, fn) {
   const lockPath = promoteLockPath(outDir);
   await fsp.mkdir((0, import_node_path8.dirname)(outDir), { recursive: true });
   let lockHandle;
-  for (let attempt = 0; attempt < 200; attempt++) {
+  const maxAttempts = 400;
+  const started = Date.now();
+  for (let attempt = 0; attempt < maxAttempts; attempt++) {
     try {
       lockHandle = await fsp.open(lockPath, "wx");
       await lockHandle.writeFile(`${process.pid}
+${(0, import_node_crypto.randomUUID)()}
+${Date.now()}
 `, "utf8");
       break;
     } catch (err) {
@@ -1330,7 +1684,9 @@ async function withPromoteLock(outDir, fn) {
         );
         continue;
       }
-      await new Promise((resolveWait) => setTimeout(resolveWait, 25));
+      if (Date.now() - started >= PROMOTE_LOCK_TIMEOUT_MS) break;
+      const delayMs = Math.min(25 * 2 ** Math.floor(attempt / 20), 250);
+      await new Promise((resolveWait) => setTimeout(resolveWait, delayMs));
     }
   }
   if (!lockHandle) {
@@ -1349,22 +1705,77 @@ async function withPromoteLock(outDir, fn) {
     );
   }
 }
-async function assertNoLegacyPromoteArtifacts(outDir) {
+async function removeStaleLegacyPromoteArtifacts(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) {
+  const blocked = [];
+  for (const legacyPath of [legacyTmp, legacyBak]) {
+    if (!await pathExists(legacyPath)) continue;
+    try {
+      const stat2 = await fsp.stat(legacyPath);
+      if (Date.now() - stat2.mtimeMs > STALE_ARTIFACT_TTL_MS) {
+        await fsp.rm(legacyPath, { recursive: true, force: true }).catch(
+          /* v8 ignore next */
+          () => void 0
+        );
+        continue;
+      }
+    } catch {
+    }
+    blocked.push(legacyPath);
+  }
+  if (blocked.length) {
+    const rmHint = blocked.map((p) => `rm -rf ${JSON.stringify(p)}`).join("; ");
     throw new Error(
-      `[lessonkit/lxpack] cannot promote: remove stale packaging artifacts from a previous failed run: ${stale.join(", ")}`
+      `[lessonkit/lxpack] cannot promote: remove stale packaging artifacts from a previous failed run: ${blocked.join(", ")}. Try: ${rmHint}`
     );
   }
 }
-async function promoteStagingToOutDir(stagingDir, outDir) {
+async function listRelativePaths(root, dir = root) {
+  const entries = await fsp.readdir(dir, { withFileTypes: true });
+  const paths = [];
+  for (const entry of entries) {
+    const full = (0, import_node_path8.join)(dir, entry.name);
+    if (entry.isDirectory()) {
+      paths.push(...await listRelativePaths(root, full));
+    } else if (entry.isFile()) {
+      paths.push(full.slice(root.length + 1));
+    } else {
+    }
+  }
+  return paths;
+}
+async function mergePreservedOutArtifacts(priorArtifactsDir, destArtifactsDir, newArtifactPaths) {
+  if (!await pathExists(priorArtifactsDir)) return;
+  for (const rel of await listRelativePaths(priorArtifactsDir)) {
+    if (newArtifactPaths.has(rel)) continue;
+    const src = (0, import_node_path8.join)(priorArtifactsDir, rel);
+    const dest = (0, import_node_path8.join)(destArtifactsDir, rel);
+    await fsp.mkdir((0, import_node_path8.dirname)(dest), { recursive: true });
+    await fsp.cp(src, dest, { force: true });
+  }
+}
+async function promoteStagingToOutDir(stagingDir, outDir, options) {
+  const outputBaseDir = options?.outputBaseDir ?? ".lxpack/out";
+  if (options?.projectRoot) {
+    assertRealPathUnderRoot((0, import_node_path8.resolve)(options.projectRoot), (0, import_node_path8.resolve)(outDir));
+  }
   return withPromoteLock(outDir, async () => {
-    await assertNoLegacyPromoteArtifacts(outDir);
+    await removeStaleLegacyPromoteArtifacts(outDir);
+    const stagingArtifactsDir = (0, import_node_path8.join)(stagingDir, outputBaseDir);
+    const newArtifactPaths = /* @__PURE__ */ new Set();
+    if (await pathExists(stagingArtifactsDir)) {
+      for (const rel of await listRelativePaths(stagingArtifactsDir)) {
+        newArtifactPaths.add(rel);
+      }
+    }
     const parent = (0, import_node_path8.dirname)(outDir);
+    let priorArtifactsBackup;
+    const existingArtifactsDir = (0, import_node_path8.join)(outDir, outputBaseDir);
+    if (await pathExists(outDir) && await pathExists(existingArtifactsDir)) {
+      priorArtifactsBackup = await fsp.mkdtemp((0, import_node_path8.join)(parent, ".lk-prior-out-"));
+      await fsp.cp(existingArtifactsDir, (0, import_node_path8.join)(priorArtifactsBackup, outputBaseDir), { recursive: true });
+    }
     const tmpPromote = await fsp.mkdtemp((0, import_node_path8.join)(parent, ".lk-promote-"));
     await renameOrCopy(stagingDir, tmpPromote);
     const hadOutDir = await pathExists(outDir);
@@ -1421,6 +1832,20 @@ async function promoteStagingToOutDir(stagingDir, outDir) {
       }
       throw promoteError;
     }
+    if (priorArtifactsBackup) {
+      try {
+        await mergePreservedOutArtifacts(
+          (0, import_node_path8.join)(priorArtifactsBackup, outputBaseDir),
+          (0, import_node_path8.join)(outDir, outputBaseDir),
+          newArtifactPaths
+        );
+      } finally {
+        await fsp.rm(priorArtifactsBackup, { recursive: true, force: true }).catch(
+          /* v8 ignore next */
+          () => void 0
+        );
+      }
+    }
     if (backup) {
       await fsp.rm(backup, { recursive: true, force: true }).catch(
         /* v8 ignore next */
@@ -1438,6 +1863,7 @@ 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_path9.join)((0, import_node_os.tmpdir)(), "lessonkit-lxpack-"));
+  let succeeded = false;
   try {
     let spaDirs;
     try {
@@ -1493,6 +1919,7 @@ async function buildStagingPackage(options) {
         }))
       };
     }
+    succeeded = true;
     return {
       ok: true,
       stagingDir,
@@ -1506,6 +1933,13 @@ async function buildStagingPackage(options) {
       () => void 0
     );
     throw err;
+  } finally {
+    if (!succeeded) {
+      await fsp2.rm(stagingDir, { recursive: true, force: true }).catch(
+        /* v8 ignore next */
+        () => void 0
+      );
+    }
   }
 }
 async function ensureOutDirParent(outDir) {
@@ -1520,6 +1954,12 @@ function isPackagingErrorIssue(issue) {
 function findPackagingErrorIssues(issues) {
   return (issues ?? []).filter(isPackagingErrorIssue);
 }
+function isPackagingWarningIssue(issue) {
+  return issue.severity?.toLowerCase() === "warning";
+}
+function findPackagingWarningIssues(issues) {
+  return (issues ?? []).filter(isPackagingWarningIssue);
+}
 
 // src/packageCourse.ts
 async function validateLessonkitProject(options) {
@@ -1570,33 +2010,46 @@ async function packageLessonkitCourse(options) {
     };
   }
   const descriptor = descriptorValidation.descriptor;
-  if (writeOpts.projectRoot) {
-    const parityIssues = validateReactManifestParity({
-      projectRoot: writeOpts.projectRoot,
-      descriptor
+  const parityIssues = validateReactManifestParity({
+    projectRoot: writeOpts.projectRoot,
+    descriptor
+  });
+  const parityFailures = writeOpts.strictParity ? parityIssues : parityIssues.filter((i) => i.severity === "error");
+  if (parityFailures.length > 0) {
+    return {
+      ok: false,
+      courseDir: outDir,
+      target,
+      issues: parityFailures.map((i) => ({
+        path: i.path,
+        message: i.message,
+        severity: i.severity
+      }))
+    };
+  }
+  let staged;
+  try {
+    staged = await buildStagingPackage({
+      ...writeOpts,
+      descriptor,
+      target,
+      output,
+      dir,
+      outputBaseDir
     });
-    const parityErrors = parityIssues.filter((i) => i.severity === "error");
-    if (parityErrors.length > 0) {
-      return {
-        ok: false,
-        courseDir: outDir,
-        target,
-        issues: parityErrors.map((i) => ({
-          path: i.path,
-          message: i.message,
-          severity: i.severity
-        }))
-      };
-    }
+  } catch (err) {
+    return {
+      ok: false,
+      courseDir: outDir,
+      target,
+      issues: [
+        {
+          path: "staging",
+          message: err instanceof Error ? err.message : String(err)
+        }
+      ]
+    };
   }
-  const staged = await buildStagingPackage({
-    ...writeOpts,
-    descriptor,
-    target,
-    output,
-    dir,
-    outputBaseDir
-  });
   if (!staged.ok) {
     await fsp3.rm(staged.stagingDir, { recursive: true, force: true }).catch(
       /* v8 ignore next */
@@ -1646,11 +2099,30 @@ async function packageLessonkitCourse(options) {
       ok: false,
       courseDir: outDir,
       target,
-      validation: { ok: true, manifest: build.manifest, issues: build.issues },
+      validation: { ok: false, manifest: build.manifest, issues: build.issues },
       build,
       issues: artifactIssues
     };
   }
+  const buildWarningIssues = findPackagingWarningIssues(build.issues);
+  if (options.strictBuild && buildWarningIssues.length > 0) {
+    await fsp3.rm(stagingDir, { recursive: true, force: true }).catch(
+      /* v8 ignore next */
+      () => void 0
+    );
+    return {
+      ok: false,
+      courseDir: outDir,
+      target,
+      validation: { ok: false, manifest: build.manifest, issues: build.issues },
+      build,
+      issues: buildWarningIssues.map((i) => ({
+        path: i.path ?? "build",
+        message: i.message ?? "build warning",
+        severity: i.severity
+      }))
+    };
+  }
   const remappedOutputPath = remapArtifactPaths(stagingRoot, outDir, staged.outputPath);
   const remappedOutputDir = remapArtifactPaths(stagingRoot, outDir, staged.outputDir);
   const validation = {
@@ -1660,7 +2132,10 @@ async function packageLessonkitCourse(options) {
   };
   try {
     await ensureOutDirParent(outDir);
-    await promoteStagingToOutDir(stagingDir, outDir);
+    await promoteStagingToOutDir(stagingDir, outDir, {
+      outputBaseDir: outputBaseDir ?? ".lxpack/out",
+      projectRoot: writeOpts.projectRoot
+    });
   } catch (err) {
     await fsp3.rm(stagingDir, { recursive: true, force: true }).catch(
       /* v8 ignore next */
@@ -1783,6 +2258,20 @@ function parseLessonkitManifest(raw, label = "lessonkit.json", projectRoot) {
       message: `"course.spaDistDir" (${courseSpaDistDir}) differs from "paths.spaDistDir" (${paths.spaDistDir}). Use paths.spaDistDir for CLI build and package.`
     });
   }
+  for (const key of ["spaDistDir", "lxpackOutDir", "outputBaseDir"]) {
+    const value = paths[key];
+    if (!isSafeRelativeSpaPath(value)) {
+      issues.push({
+        path: `paths.${key}`,
+        message: "path must be relative without '..' segments or absolute prefixes"
+      });
+    } else if (isReservedOutputPath(value)) {
+      issues.push({
+        path: `paths.${key}`,
+        message: "path must not target reserved directories (.git, node_modules, .github)"
+      });
+    }
+  }
   if (projectRoot) {
     const pathIssues = validateProjectPaths(projectRoot, paths);
     for (const pi of pathIssues) {
@@ -1814,53 +2303,879 @@ 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);
+var BRANCH_TELEMETRY_EVENTS = ["branch_node_viewed", "branch_selected"];
+var ASSESSMENT_TELEMETRY_EVENTS = ["assessment_answered"];
+var SUPPORTED = /* @__PURE__ */ new Set([
+  ...import_tracking_schema.LESSONKIT_TELEMETRY_EVENTS,
+  ...BRANCH_TELEMETRY_EVENTS,
+  ...ASSESSMENT_TELEMETRY_EVENTS
+]);
 function isQuizAnsweredData(data) {
-  return typeof data === "object" && data !== null && typeof data.checkId === "string";
+  return typeof data === "object" && data !== null && typeof data.checkId === "string" && data.checkId.length > 0;
 }
 function isQuizCompletedData(data) {
-  return typeof data === "object" && data !== null && typeof data.checkId === "string";
+  return typeof data === "object" && data !== null && typeof data.checkId === "string" && data.checkId.length > 0;
+}
+function isAssessmentAnsweredData(data) {
+  return typeof data === "object" && data !== null && typeof data.checkId === "string" && data.checkId.length > 0;
 }
 function isInteractionData(data) {
   return typeof data === "object" && data !== null;
 }
+function isBranchNodeViewedData(data) {
+  return typeof data === "object" && data !== null && typeof data.blockId === "string" && typeof data.nodeId === "string";
+}
+function isBranchSelectedData(data) {
+  return typeof data === "object" && data !== null && typeof data.blockId === "string" && typeof data.fromNodeId === "string" && typeof data.toNodeId === "string";
+}
 function telemetryEventToLessonkit(event) {
   if (!SUPPORTED.has(event.name)) {
     return null;
   }
-  const name = event.name;
   const mapped = {
-    name,
+    name: event.name,
     lessonId: event.lessonId
   };
-  if (name === "quiz_completed" || name === "quiz_answered") {
+  if (event.name === "quiz_completed" || event.name === "quiz_answered" || event.name === "assessment_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;
+    if (!isQuizAnsweredData(data) && !isQuizCompletedData(data) && !isAssessmentAnsweredData(data)) {
+      return null;
     }
-  } else if (name === "interaction" && event.data && isInteractionData(event.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 (mapped.name === "interaction" && event.data && isInteractionData(event.data)) {
+    mapped.data = event.data;
+  } else if (event.name === "branch_node_viewed" && isBranchNodeViewedData(event.data)) {
+    mapped.data = event.data;
+  } else if (event.name === "branch_selected" && isBranchSelectedData(event.data)) {
     mapped.data = event.data;
   }
   return mapped;
 }
 
 // src/index.ts
+var import_validators4 = require("@lxpack/validators");
+
+// src/lkcourse/zip.ts
+var import_node_fs5 = require("fs");
+var import_node_path11 = require("path");
+var import_fflate = require("fflate");
+var MAX_LKCOURSE_UNCOMPRESSED_BYTES = 256 * 1024 * 1024;
+function canonicalZipEntryPath(entryPath) {
+  const slashNormalized = entryPath.replace(/\\/g, "/");
+  const canonical = (0, import_node_path11.normalize)(slashNormalized).replace(/\\/g, "/");
+  if (canonical !== slashNormalized) return null;
+  return canonical;
+}
+function isSafeZipEntryPath(entryPath) {
+  const canonical = canonicalZipEntryPath(entryPath);
+  if (!canonical?.length || canonical.startsWith("/") || canonical.includes("\0")) {
+    return false;
+  }
+  const segments = canonical.split("/").filter((s) => s.length > 0);
+  if (segments.some((s) => s === "..")) return false;
+  return segments.length > 0;
+}
+function createZip(entries) {
+  const zipped = {};
+  for (const [path, data] of entries) {
+    if (!isSafeZipEntryPath(path)) {
+      throw new Error(`unsafe zip entry path: ${path}`);
+    }
+    zipped[path.replace(/\\/g, "/")] = data instanceof Uint8Array ? data : new Uint8Array(data);
+  }
+  return (0, import_fflate.zipSync)(zipped, { level: 6 });
+}
+function readZip(archivePath) {
+  const issues = [];
+  let raw;
+  try {
+    raw = (0, import_node_fs5.readFileSync)(archivePath);
+  } catch {
+    return { ok: false, issues: [{ path: archivePath, message: "failed to read archive" }] };
+  }
+  if (!raw.length) {
+    return { ok: false, issues: [{ path: archivePath, message: "archive is empty" }] };
+  }
+  let unzipped;
+  try {
+    unzipped = (0, import_fflate.unzipSync)(raw);
+  } catch {
+    return { ok: false, issues: [{ path: archivePath, message: "invalid zip archive" }] };
+  }
+  const entries = /* @__PURE__ */ new Map();
+  let totalUncompressed = 0;
+  for (const [path, data] of Object.entries(unzipped)) {
+    const canonical = canonicalZipEntryPath(path);
+    if (!canonical || !isSafeZipEntryPath(canonical)) {
+      issues.push({ path, message: "unsafe zip entry path" });
+      continue;
+    }
+    if (entries.has(canonical)) {
+      issues.push({ path: canonical, message: "duplicate zip entry path" });
+      continue;
+    }
+    totalUncompressed += data.byteLength;
+    if (totalUncompressed > MAX_LKCOURSE_UNCOMPRESSED_BYTES) {
+      return {
+        ok: false,
+        issues: [
+          {
+            path: archivePath,
+            message: `archive exceeds max uncompressed size (${MAX_LKCOURSE_UNCOMPRESSED_BYTES} bytes)`
+          }
+        ]
+      };
+    }
+    entries.set(canonical, data);
+  }
+  if (issues.length) return { ok: false, issues };
+  return { ok: true, entries };
+}
+async function collectDistEntries(distDir, spaDistRelative) {
+  const { lstat: lstat2, readdir: readdir4, readFile: readFile2 } = await import("fs/promises");
+  const entries = /* @__PURE__ */ new Map();
+  const walk = async (absDir, relPrefix) => {
+    const dirEntries = await readdir4(absDir, { withFileTypes: true });
+    for (const entry of dirEntries) {
+      const abs = (0, import_node_path11.join)(absDir, entry.name);
+      const rel = relPrefix ? `${relPrefix}/${entry.name}` : entry.name;
+      const zipPath = `${spaDistRelative}/${rel}`.replace(/\\/g, "/");
+      if (!isSafeRelativeSpaPath(zipPath)) {
+        throw new Error(`unsafe dist path: ${zipPath}`);
+      }
+      const stat2 = await lstat2(abs);
+      if (stat2.isSymbolicLink()) {
+        throw new Error(`dist contains symlink: ${abs}`);
+      }
+      if (stat2.isDirectory()) {
+        await walk(abs, rel);
+      } else if (stat2.isFile()) {
+        entries.set(zipPath.replace(/\\/g, "/"), await readFile2(abs));
+      }
+    }
+  };
+  await walk(distDir, "");
+  return entries;
+}
+function entryToUtf8(data) {
+  return (0, import_fflate.strFromU8)(data);
+}
+function utf8ToEntry(text) {
+  return (0, import_fflate.strToU8)(text);
+}
+
+// src/lkcourse/parseEnvelope.ts
+function parseLkcourseEnvelope(raw, label = "manifest.json") {
+  const issues = [];
+  if (!raw || typeof raw !== "object") {
+    return { ok: false, issues: [{ path: label, message: "must be a JSON object" }] };
+  }
+  const obj = raw;
+  if (obj.format !== "lkcourse") {
+    issues.push({
+      path: "format",
+      message: `must be "lkcourse" (got ${String(obj.format)})`
+    });
+  }
+  let schemaVersion = obj.schemaVersion;
+  if (schemaVersion === "1") schemaVersion = 1;
+  if (schemaVersion !== 1) {
+    issues.push({
+      path: "schemaVersion",
+      message: `must be 1 (got ${String(obj.schemaVersion)})`
+    });
+  }
+  const lessonkitVersion = typeof obj.lessonkitVersion === "string" ? obj.lessonkitVersion.trim() : "";
+  if (!lessonkitVersion) {
+    issues.push({ path: "lessonkitVersion", message: "must be a non-empty string" });
+  }
+  const exportedAt = typeof obj.exportedAt === "string" ? obj.exportedAt.trim() : "";
+  if (!exportedAt) {
+    issues.push({ path: "exportedAt", message: "must be a non-empty string" });
+  }
+  const entriesRaw = obj.entries;
+  const entries = [];
+  if (!Array.isArray(entriesRaw) || entriesRaw.length === 0) {
+    issues.push({ path: "entries", message: "must be a non-empty array of relative paths" });
+  } else {
+    for (let i = 0; i < entriesRaw.length; i++) {
+      const entry = entriesRaw[i];
+      if (typeof entry !== "string" || !entry.trim()) {
+        issues.push({ path: `entries[${i}]`, message: "must be a non-empty string" });
+      } else {
+        const trimmed = entry.trim();
+        if (!isSafeZipEntryPath(trimmed)) {
+          issues.push({ path: `entries[${i}]`, message: "must be a safe relative path" });
+        } else {
+          entries.push(trimmed);
+        }
+      }
+    }
+  }
+  if (issues.length) return { ok: false, issues };
+  const manifestParsed = parseLessonkitManifest(obj.sourceManifest, `${label}.sourceManifest`);
+  if (!manifestParsed.ok) {
+    return {
+      ok: false,
+      issues: manifestParsed.issues.map((issue) => ({
+        path: `sourceManifest.${issue.path}`,
+        message: issue.message
+      }))
+    };
+  }
+  return {
+    ok: true,
+    envelope: {
+      format: "lkcourse",
+      schemaVersion: 1,
+      lessonkitVersion,
+      exportedAt,
+      sourceManifest: manifestParsed.manifest,
+      entries
+    }
+  };
+}
+
+// src/lkcourse/blockTree.ts
+var import_node_fs6 = require("fs");
+var import_node_module = require("module");
+var import_node_path12 = require("path");
+var import_core5 = require("@lessonkit/core");
+var import_meta = {};
+var SCANNABLE_EXTENSIONS2 = [".tsx", ".ts", ".jsx", ".js"];
+var ID_PROPS = ["courseId", "lessonId", "checkId", "blockId", "nodeId"];
+function stripComments2(source) {
+  return source.replace(/\/\*[\s\S]*?\*\//g, " ").replace(/\/\/[^\n]*/g, " ");
+}
+function collectSourceUnderSrc2(projectRoot) {
+  const srcDir = (0, import_node_path12.join)(projectRoot, "src");
+  if (!(0, import_node_fs6.existsSync)(srcDir)) return [];
+  const results = [];
+  const walk = (dir) => {
+    for (const entry of (0, import_node_fs6.readdirSync)(dir)) {
+      const abs = (0, import_node_path12.join)(dir, entry);
+      try {
+        assertRealPathUnderRoot(projectRoot, abs);
+      } catch {
+        continue;
+      }
+      const stat2 = (0, import_node_fs6.lstatSync)(abs);
+      if (stat2.isSymbolicLink()) continue;
+      if (stat2.isDirectory()) {
+        walk(abs);
+      } else if (SCANNABLE_EXTENSIONS2.some((ext) => entry.endsWith(ext))) {
+        results.push((0, import_node_path12.relative)(projectRoot, abs));
+      }
+    }
+  };
+  walk(srcDir);
+  return results;
+}
+function loadCatalogBlockTypes(blockTypes) {
+  if (blockTypes?.length) return blockTypes;
+  try {
+    const require2 = (0, import_node_module.createRequire)(import_meta.url);
+    const catalogPath = require2.resolve("@lessonkit/react/block-catalog.v3.json");
+    const catalog = JSON.parse((0, import_node_fs6.readFileSync)(catalogPath, "utf8"));
+    return (catalog.entries ?? []).map((e) => e.type).filter((t) => typeof t === "string" && t.length > 0);
+  } catch {
+    return [
+      "Course",
+      "Lesson",
+      "Scenario",
+      "Quiz",
+      "KnowledgeCheck",
+      "ProgressTracker",
+      "Reflection",
+      "TrueFalse",
+      "MarkTheWords",
+      "FillInTheBlanks",
+      "DragTheWords",
+      "DragAndDrop",
+      "AssessmentSequence",
+      "Text",
+      "Heading",
+      "Image",
+      "Video",
+      "Page",
+      "InteractiveBook",
+      "Slide",
+      "SlideDeck",
+      "TimedCue",
+      "InteractiveVideo",
+      "Summary",
+      "BranchingScenario",
+      "BranchNode",
+      "BranchChoice",
+      "Embed",
+      "Chart"
+    ];
+  }
+}
+function extractIdProp(tagSource, prop) {
+  const re = new RegExp(
+    `\\b${prop}\\s*=\\s*(?:"([^"]*)"|'([^']*)'|\\{\\s*["'\`]([^"'\`]+)["'\`]\\s*\\})`
+  );
+  const match = tagSource.match(re);
+  if (!match) return void 0;
+  return match[1] ?? match[2] ?? match[3];
+}
+function parseJsxBlocks(source, blockTypes) {
+  const stripped = stripComments2(source);
+  const tagRe = /<([A-Z][A-Za-z0-9]*)\b([^>]*?)(\/?)>/g;
+  const stack = [];
+  const roots = [];
+  for (const match of stripped.matchAll(tagRe)) {
+    const rawTag = match[1];
+    const attrs = match[2] ?? "";
+    const selfClosing = match[3] === "/";
+    if (rawTag === "Fragment" || rawTag.endsWith("Provider")) continue;
+    const known = blockTypes.has(rawTag);
+    const node = known ? { type: rawTag } : { type: "Unknown", rawTag };
+    for (const prop of ID_PROPS) {
+      const value = extractIdProp(attrs, prop);
+      if (value) node[prop] = value;
+    }
+    if (selfClosing) {
+      if (stack.length) {
+        const parent = stack[stack.length - 1];
+        parent.children = parent.children ?? [];
+        parent.children.push(node);
+      } else {
+        roots.push(node);
+      }
+      continue;
+    }
+    const closeRe = new RegExp(`</${rawTag}>`);
+    const closeMatch = closeRe.exec(stripped.slice((match.index ?? 0) + match[0].length));
+    if (!closeMatch) {
+      if (stack.length) {
+        const parent = stack[stack.length - 1];
+        parent.children = parent.children ?? [];
+        parent.children.push(node);
+      } else {
+        roots.push(node);
+      }
+      continue;
+    }
+    stack.push(node);
+    const nextClose = stripped.indexOf(`</${rawTag}>`, (match.index ?? 0) + match[0].length);
+    const inner = stripped.slice((match.index ?? 0) + match[0].length, nextClose);
+    if (!inner.includes("<")) {
+      stack.pop();
+      if (stack.length) {
+        const parent = stack[stack.length - 1];
+        parent.children = parent.children ?? [];
+        parent.children.push(node);
+      } else {
+        roots.push(node);
+      }
+    }
+  }
+  return roots.length ? roots : stack;
+}
+function validateNodeIds(node, pathPrefix, issues) {
+  for (const prop of ID_PROPS) {
+    const value = node[prop];
+    if (value === void 0) continue;
+    const validated = (0, import_core5.validateId)(value, prop);
+    if (!validated.ok) {
+      issues.push({
+        path: `${pathPrefix}.${prop}`,
+        message: validated.issues[0]?.message ?? `invalid ${prop}`
+      });
+    }
+  }
+  node.children?.forEach((child, index) => {
+    validateNodeIds(child, `${pathPrefix}.children[${index}]`, issues);
+  });
+}
+function validateBlockTreeIds(tree) {
+  const issues = [];
+  tree.blocks.forEach((block, index) => {
+    validateNodeIds(block, `blocks[${index}]`, issues);
+  });
+  return issues;
+}
+function extractBlockTree(options) {
+  const blockTypes = new Set(loadCatalogBlockTypes(options.blockTypes));
+  const sources = options.appSources ?? collectSourceUnderSrc2(options.projectRoot);
+  const blocks = [];
+  for (const rel of sources) {
+    const abs = (0, import_node_path12.join)(options.projectRoot, rel);
+    if (!(0, import_node_fs6.existsSync)(abs)) continue;
+    const source = (0, import_node_fs6.readFileSync)(abs, "utf8");
+    const parsed = parseJsxBlocks(source, blockTypes);
+    blocks.push(...parsed);
+  }
+  return {
+    schemaVersion: 1,
+    sources,
+    blocks
+  };
+}
+
+// src/lkcourse/export.ts
+var import_promises3 = require("fs/promises");
+var import_node_module2 = require("module");
+var import_node_path13 = require("path");
 var import_validators2 = require("@lxpack/validators");
+var import_meta2 = {};
+function resolveLessonkitVersion(explicit) {
+  if (explicit?.trim()) return explicit.trim();
+  try {
+    const require2 = (0, import_node_module2.createRequire)(import_meta2.url);
+    const pkg = require2("../../package.json");
+    return pkg.version ?? "0.0.0";
+  } catch {
+    return "0.0.0";
+  }
+}
+async function exportLkcourse(options) {
+  const projectRoot = (0, import_node_path13.resolve)(options.projectRoot);
+  const manifest = options.manifest;
+  const spaDistDir = (0, import_node_path13.join)(projectRoot, manifest.paths.spaDistDir);
+  try {
+    assertRealPathUnderRoot(projectRoot, spaDistDir);
+    await assertSpaDistContentsSafe({ main: spaDistDir }, projectRoot);
+  } catch (err) {
+    return {
+      ok: false,
+      issues: [
+        {
+          path: manifest.paths.spaDistDir,
+          message: err instanceof Error ? err.message : String(err)
+        }
+      ]
+    };
+  }
+  const interchange = descriptorToInterchange(manifest.course);
+  const interchangeParsed = (0, import_validators2.parseLessonkitInterchange)(interchange);
+  if (!interchangeParsed.ok) {
+    return {
+      ok: false,
+      issues: interchangeParsed.issues.map((i) => ({
+        path: `interchange.${i.path ?? ""}`.replace(/\.$/, ""),
+        message: i.message
+      }))
+    };
+  }
+  const validatedInterchange = interchangeParsed.data;
+  const interchangeCourseId = validatedInterchange.course?.id;
+  if (!interchangeCourseId) {
+    return {
+      ok: false,
+      issues: [{ path: "interchange.course.id", message: "missing course id in interchange" }]
+    };
+  }
+  if (manifest.course.courseId !== interchangeCourseId) {
+    return {
+      ok: false,
+      issues: [
+        {
+          path: "course.courseId",
+          message: `descriptor courseId "${manifest.course.courseId}" does not match interchange course.id "${interchangeCourseId}"`
+        }
+      ]
+    };
+  }
+  const zipEntries = /* @__PURE__ */ new Map();
+  const interchangeJson = JSON.stringify(interchange, null, 2);
+  zipEntries.set("interchange.json", utf8ToEntry(interchangeJson));
+  let blockTreeJson;
+  if (options.includeBlockTree) {
+    const blockTree = extractBlockTree({ projectRoot });
+    const blockTreeIssues = validateBlockTreeIds(blockTree);
+    if (blockTreeIssues.length) {
+      return {
+        ok: false,
+        issues: blockTreeIssues.map((issue) => ({
+          path: `block-tree.${issue.path}`,
+          message: issue.message
+        }))
+      };
+    }
+    blockTreeJson = JSON.stringify(blockTree, null, 2);
+    zipEntries.set("block-tree.json", utf8ToEntry(blockTreeJson));
+  }
+  let distEntries;
+  try {
+    distEntries = await collectDistEntries(spaDistDir, manifest.paths.spaDistDir);
+  } catch (err) {
+    return {
+      ok: false,
+      issues: [
+        {
+          path: manifest.paths.spaDistDir,
+          message: err instanceof Error ? err.message : String(err)
+        }
+      ]
+    };
+  }
+  if (!distEntries.has(`${manifest.paths.spaDistDir}/index.html`.replace(/\\/g, "/"))) {
+    return {
+      ok: false,
+      issues: [
+        {
+          path: `${manifest.paths.spaDistDir}/index.html`,
+          message: "dist must contain index.html before export"
+        }
+      ]
+    };
+  }
+  for (const [path, data] of distEntries) {
+    zipEntries.set(path, data);
+  }
+  const entryPaths = [...zipEntries.keys()].sort();
+  const envelope = {
+    format: "lkcourse",
+    schemaVersion: 1,
+    lessonkitVersion: resolveLessonkitVersion(options.lessonkitVersion),
+    exportedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    sourceManifest: manifest,
+    entries: entryPaths
+  };
+  const envelopeCheck = parseLkcourseEnvelope(envelope);
+  if (!envelopeCheck.ok) {
+    return { ok: false, issues: envelopeCheck.issues };
+  }
+  zipEntries.set("manifest.json", utf8ToEntry(JSON.stringify(envelope, null, 2)));
+  const archivePath = (0, import_node_path13.resolve)(
+    projectRoot,
+    options.outPath ?? `${manifest.name}.lkcourse`
+  );
+  try {
+    assertRealPathUnderRoot(projectRoot, archivePath);
+  } catch (err) {
+    return {
+      ok: false,
+      issues: [
+        {
+          path: options.outPath ?? `${manifest.name}.lkcourse`,
+          message: err instanceof Error ? err.message : String(err)
+        }
+      ]
+    };
+  }
+  if (!isSafeZipEntryPath(options.outPath ?? `${manifest.name}.lkcourse`)) {
+    return {
+      ok: false,
+      issues: [{ path: "outPath", message: "output path must be a safe relative path" }]
+    };
+  }
+  try {
+    await (0, import_promises3.mkdir)((0, import_node_path13.dirname)(archivePath), { recursive: true });
+    const zipped = createZip(zipEntries);
+    await (0, import_promises3.writeFile)(archivePath, zipped);
+  } catch (err) {
+    return {
+      ok: false,
+      issues: [
+        {
+          path: archivePath,
+          message: err instanceof Error ? err.message : String(err)
+        }
+      ]
+    };
+  }
+  return {
+    ok: true,
+    archivePath,
+    fileCount: zipEntries.size,
+    includeBlockTree: Boolean(options.includeBlockTree)
+  };
+}
+
+// src/lkcourse/validate.ts
+var import_validators3 = require("@lxpack/validators");
+function validateLkcourseArchiveEntries(entries, _archiveLabel) {
+  const issues = [];
+  const manifestData = entries.get("manifest.json");
+  if (!manifestData) {
+    return {
+      ok: false,
+      issues: [{ path: "manifest.json", message: "required file missing from archive" }]
+    };
+  }
+  let envelopeRaw;
+  try {
+    envelopeRaw = JSON.parse(entryToUtf8(manifestData));
+  } catch {
+    return {
+      ok: false,
+      issues: [{ path: "manifest.json", message: "invalid JSON" }]
+    };
+  }
+  const envelopeParsed = parseLkcourseEnvelope(envelopeRaw, "manifest.json");
+  if (!envelopeParsed.ok) {
+    return { ok: false, issues: envelopeParsed.issues };
+  }
+  const envelope = envelopeParsed.envelope;
+  const interchangeData = entries.get("interchange.json");
+  if (!interchangeData) {
+    issues.push({ path: "interchange.json", message: "required file missing from archive" });
+  }
+  const spaDistDir = envelope.sourceManifest.paths.spaDistDir.replace(/\\/g, "/");
+  const spaIndexPath = `${spaDistDir}/index.html`;
+  if (!entries.has(spaIndexPath)) {
+    issues.push({ path: spaIndexPath, message: "required file missing from archive" });
+  }
+  for (const entryPath of envelope.entries) {
+    if (!entries.has(entryPath)) {
+      issues.push({
+        path: entryPath,
+        message: "listed in manifest.entries but missing from archive"
+      });
+    }
+  }
+  if (issues.length) return { ok: false, issues };
+  let interchangeRaw;
+  try {
+    interchangeRaw = JSON.parse(entryToUtf8(interchangeData));
+  } catch {
+    return {
+      ok: false,
+      issues: [{ path: "interchange.json", message: "invalid JSON" }]
+    };
+  }
+  const interchangeParsed = (0, import_validators3.parseLessonkitInterchange)(interchangeRaw);
+  if (!interchangeParsed.ok) {
+    return {
+      ok: false,
+      issues: interchangeParsed.issues.map((i) => ({
+        path: `interchange.${i.path ?? ""}`.replace(/\.$/, ""),
+        message: i.message
+      }))
+    };
+  }
+  const interchange = interchangeParsed.data;
+  const interchangeCourseId = interchange.course?.id;
+  if (!interchangeCourseId) {
+    issues.push({
+      path: "interchange.course.id",
+      message: "missing course id in interchange"
+    });
+  } else if (envelope.sourceManifest.course.courseId !== interchangeCourseId) {
+    issues.push({
+      path: "sourceManifest.course.courseId",
+      message: `does not match interchange.course.id (${interchangeCourseId})`
+    });
+  }
+  if (issues.length) return { ok: false, issues };
+  const blockTreeData = entries.get("block-tree.json");
+  if (blockTreeData) {
+    let blockTreeRaw;
+    try {
+      blockTreeRaw = JSON.parse(entryToUtf8(blockTreeData));
+    } catch {
+      return {
+        ok: false,
+        issues: [{ path: "block-tree.json", message: "invalid JSON" }]
+      };
+    }
+    const blockTree = blockTreeRaw;
+    if (Array.isArray(blockTree?.blocks)) {
+      const blockTreeIssues = validateBlockTreeIds(blockTree);
+      if (blockTreeIssues.length) {
+        return {
+          ok: false,
+          issues: blockTreeIssues.map((issue) => ({
+            path: `block-tree.${issue.path}`,
+            message: issue.message
+          }))
+        };
+      }
+    }
+  }
+  return {
+    ok: true,
+    envelope,
+    interchange
+  };
+}
+function validateLkcourse(archivePath) {
+  const read = readZip(archivePath);
+  if (!read.ok) return read;
+  return validateLkcourseArchiveEntries(read.entries, archivePath);
+}
+
+// src/lkcourse/import.ts
+var import_promises4 = require("fs/promises");
+var import_node_path14 = require("path");
+var IMPORT_ARTIFACTS = ["lessonkit.json", "dist"];
+async function pathExists2(path) {
+  try {
+    await (0, import_promises4.access)(path);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function renameOrCopy2(from, to, opts) {
+  const renameFn = opts?.renameFn ?? import_promises4.rename;
+  try {
+    await renameFn(from, to);
+  } catch (err) {
+    const code = err && typeof err === "object" && "code" in err ? String(err.code) : "";
+    if (code !== "EXDEV") throw err;
+    await (0, import_promises4.cp)(from, to, { recursive: true });
+    await (0, import_promises4.rm)(from, { recursive: true, force: true });
+  }
+}
+async function writeImportTree(stagingDir, manifest, entries, spaDistDir) {
+  let fileCount = 0;
+  await (0, import_promises4.writeFile)(
+    (0, import_node_path14.join)(stagingDir, "lessonkit.json"),
+    `${JSON.stringify(manifest, null, 2)}
+`,
+    "utf8"
+  );
+  fileCount += 1;
+  for (const [entryPath, data] of entries) {
+    const normalized = entryPath.replace(/\\/g, "/");
+    if (!normalized.startsWith(`${spaDistDir}/`)) continue;
+    const relativeUnderSpa = normalized.slice(spaDistDir.length + 1);
+    const outPath = (0, import_node_path14.join)(stagingDir, spaDistDir, relativeUnderSpa);
+    const resolvedOut = (0, import_node_path14.resolve)(outPath);
+    assertRealPathUnderRoot(stagingDir, resolvedOut);
+    if (!isSafeZipEntryPath((0, import_node_path14.join)(spaDistDir, relativeUnderSpa))) {
+      throw new Error(`unsafe extraction path: ${entryPath}`);
+    }
+    await (0, import_promises4.mkdir)((0, import_node_path14.dirname)(resolvedOut), { recursive: true });
+    await (0, import_promises4.writeFile)(resolvedOut, data);
+    fileCount += 1;
+  }
+  return fileCount;
+}
+async function backupImportArtifacts(targetDir) {
+  const existing = [];
+  for (const name of IMPORT_ARTIFACTS) {
+    if (await pathExists2((0, import_node_path14.join)(targetDir, name))) {
+      existing.push(name);
+    }
+  }
+  if (!existing.length) return void 0;
+  const backupDir = await (0, import_promises4.mkdtemp)((0, import_node_path14.join)(targetDir, ".lkcourse-backup-"));
+  for (const name of existing) {
+    await renameOrCopy2((0, import_node_path14.join)(targetDir, name), (0, import_node_path14.join)(backupDir, name));
+  }
+  return backupDir;
+}
+async function restoreImportBackup(targetDir, backupDir) {
+  for (const name of IMPORT_ARTIFACTS) {
+    const backupPath = (0, import_node_path14.join)(backupDir, name);
+    if (!await pathExists2(backupPath)) continue;
+    const destPath = (0, import_node_path14.join)(targetDir, name);
+    if (await pathExists2(destPath)) {
+      await (0, import_promises4.rm)(destPath, { recursive: true, force: true });
+    }
+    await renameOrCopy2(backupPath, destPath);
+  }
+}
+async function promoteImportStaging(stagingDir, targetDir) {
+  const entries = await (0, import_promises4.readdir)(stagingDir, { withFileTypes: true });
+  for (const entry of entries) {
+    const srcPath = (0, import_node_path14.join)(stagingDir, entry.name);
+    const destPath = (0, import_node_path14.join)(targetDir, entry.name);
+    if (entry.isDirectory()) {
+      await (0, import_promises4.cp)(srcPath, destPath, { recursive: true, force: true });
+    } else if (entry.isFile()) {
+      await (0, import_promises4.mkdir)((0, import_node_path14.dirname)(destPath), { recursive: true });
+      await (0, import_promises4.cp)(srcPath, destPath);
+    }
+  }
+}
+var promoteImportStagingImpl = promoteImportStaging;
+async function importLkcourse(options) {
+  const archivePath = (0, import_node_path14.resolve)(options.archivePath);
+  const targetDir = (0, import_node_path14.resolve)(options.targetDir);
+  const validated = validateLkcourse(archivePath);
+  if (!validated.ok) return validated;
+  const { envelope, interchange } = validated;
+  const manifest = envelope.sourceManifest;
+  const spaDistDir = manifest.paths.spaDistDir.replace(/\\/g, "/");
+  try {
+    await (0, import_promises4.mkdir)(targetDir, { recursive: true });
+    assertRealPathUnderRoot(targetDir, targetDir);
+  } catch (err) {
+    return {
+      ok: false,
+      issues: [
+        {
+          path: targetDir,
+          message: err instanceof Error ? err.message : String(err)
+        }
+      ]
+    };
+  }
+  const read = readZip(archivePath);
+  if (!read.ok) return read;
+  let stagingDir;
+  let backupDir;
+  try {
+    stagingDir = await (0, import_promises4.mkdtemp)((0, import_node_path14.join)(targetDir, ".lkcourse-import-"));
+    const fileCount = await writeImportTree(stagingDir, manifest, read.entries, spaDistDir);
+    backupDir = await backupImportArtifacts(targetDir);
+    try {
+      await promoteImportStagingImpl(stagingDir, targetDir);
+    } catch (promoteError) {
+      if (backupDir) {
+        await restoreImportBackup(targetDir, backupDir);
+      }
+      throw promoteError;
+    }
+    if (backupDir) {
+      await (0, import_promises4.rm)(backupDir, { recursive: true, force: true }).catch(() => void 0);
+      backupDir = void 0;
+    }
+    await (0, import_promises4.rm)(stagingDir, { recursive: true, force: true });
+    stagingDir = void 0;
+    return {
+      ok: true,
+      targetDir,
+      manifest,
+      interchange,
+      fileCount
+    };
+  } catch (err) {
+    if (backupDir) {
+      await restoreImportBackup(targetDir, backupDir).catch(() => void 0);
+      await (0, import_promises4.rm)(backupDir, { recursive: true, force: true }).catch(() => void 0);
+    }
+    if (stagingDir) {
+      await (0, import_promises4.rm)(stagingDir, { recursive: true, force: true }).catch(() => void 0);
+    }
+    return {
+      ok: false,
+      issues: [
+        {
+          path: targetDir,
+          message: err instanceof Error ? err.message : String(err)
+        }
+      ]
+    };
+  }
+}
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   LESSONKIT_TELEMETRY_EVENTS,
+  assertSpaDistContentsSafe,
   assessmentDescriptorToLxpack,
   buildLessonkitProject,
   buildStagingPackage,
   descriptorToInterchange,
   ensureOutDirParent,
+  escapeShellText,
+  exportLkcourse,
   extractAssessments,
+  extractBlockTree,
+  importLkcourse,
   lessonkitInterchangeSchema,
   loadLessonkitManifestFromFile,
   mapLessonkitIds,
@@ -1870,6 +3185,7 @@ var import_validators2 = require("@lxpack/validators");
   packageLessonkitCourse,
   parseLessonkitInterchange,
   parseLessonkitManifest,
+  parseLkcourseEnvelope,
   promoteStagingToOutDir,
   remapArtifactPaths,
   resolveSafePackageOutputOverride,
@@ -1879,6 +3195,8 @@ var import_validators2 = require("@lxpack/validators");
   validateDescriptor,
   validateDescriptorForTarget,
   validateLessonkitProject,
+  validateLkcourse,
+  validateLkcourseArchiveEntries,
   validatePackageInputs,
   validateProjectPaths,
   validateReactManifestParity,