@lessonkit/lxpack 1.5.0 → 1.7.0

package/dist/index.js

@@ -62,13 +62,40 @@ function normalizeDescriptor(input) {
           correctTargetIds: assessment.correctTargetIds.map((id) => id.trim()).filter((id) => id.length > 0)
         };
       }
+      if (assessment.kind === "sortParagraphs") {
+        return {
+          ...assessment,
+          checkId: check.id,
+          question,
+          paragraphs: assessment.paragraphs.map((p) => p.trim()).filter((p) => p.length > 0),
+          correctOrder: [...assessment.correctOrder]
+        };
+      }
+      if (assessment.kind === "guessTheAnswer") {
+        return {
+          ...assessment,
+          checkId: check.id,
+          question,
+          answer: assessment.answer.trim()
+        };
+      }
+      if (assessment.kind === "multimediaChoice") {
+        return {
+          ...assessment,
+          checkId: check.id,
+          question,
+          choices: assessment.choices.map((c) => c.trim()).filter((c) => c.length > 0),
+          answer: assessment.answer.trim()
+        };
+      }
       const mcq = assessment;
       return {
         ...mcq,
         checkId: check.id,
         question,
         choices: mcq.choices.map((c) => c.trim()).filter((c) => c.length > 0),
-        answer: mcq.answer.trim()
+        answer: mcq.answer.trim(),
+        answers: mcq.answers?.map((a) => a.trim()).filter((a) => a.length > 0)
       };
     })
   };
@@ -99,10 +126,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") {
@@ -134,7 +169,30 @@ function parseAssessmentDescriptor(raw) {
       correctTargetIds: Array.isArray(raw.correctTargetIds) ? raw.correctTargetIds.filter((id) => typeof id === "string") : []
     };
   }
-  if (typeof kind === "string" && kind !== "mcq" && kind !== "trueFalse" && kind !== "fillInBlanks" && kind !== "findHotspot" && kind !== "findMultipleHotspots") {
+  if (kind === "sortParagraphs") {
+    return {
+      kind: "sortParagraphs",
+      ...base,
+      paragraphs: Array.isArray(raw.paragraphs) ? raw.paragraphs.filter((p) => typeof p === "string") : [],
+      correctOrder: Array.isArray(raw.correctOrder) ? raw.correctOrder.filter((n) => typeof n === "number" && Number.isFinite(n)) : []
+    };
+  }
+  if (kind === "guessTheAnswer") {
+    return {
+      kind: "guessTheAnswer",
+      ...base,
+      answer: typeof raw.answer === "string" ? raw.answer : ""
+    };
+  }
+  if (kind === "multimediaChoice") {
+    return {
+      kind: "multimediaChoice",
+      ...base,
+      choices: Array.isArray(raw.choices) ? raw.choices.filter((c) => typeof c === "string") : [],
+      answer: typeof raw.answer === "string" ? raw.answer : ""
+    };
+  }
+  if (typeof kind === "string" && kind !== "mcq" && kind !== "trueFalse" && kind !== "fillInBlanks" && kind !== "findHotspot" && kind !== "findMultipleHotspots" && kind !== "sortParagraphs" && kind !== "guessTheAnswer" && kind !== "multimediaChoice") {
     return {
       kind,
       ...base,
@@ -146,7 +204,15 @@ function parseAssessmentDescriptor(raw) {
     kind: kind === "mcq" ? "mcq" : void 0,
     ...base,
     choices: Array.isArray(raw.choices) ? raw.choices.filter((c) => typeof c === "string") : [],
-    answer: typeof raw.answer === "string" ? raw.answer : ""
+    answer: typeof raw.answer === "string" ? raw.answer : "",
+    answers: Array.isArray(raw.answers) ? raw.answers.filter((a) => typeof a === "string") : void 0,
+    shuffleChoices: typeof raw.shuffleChoices === "boolean" ? raw.shuffleChoices : void 0,
+    shuffleSeed: typeof raw.shuffleSeed === "string" || typeof raw.shuffleSeed === "number" ? raw.shuffleSeed : void 0,
+    choiceFeedback: raw.choiceFeedback && typeof raw.choiceFeedback === "object" && !Array.isArray(raw.choiceFeedback) ? Object.fromEntries(
+      Object.entries(raw.choiceFeedback).filter(
+        (entry) => typeof entry[1] === "string"
+      )
+    ) : void 0
   };
 }
 function parseCourseDescriptorInput(input) {
@@ -194,8 +260,8 @@ import { validateId as validateId3 } from "@lessonkit/core";
 import { validateTheme } from "@lessonkit/themes";
 
 // src/spaPath.ts
-import { existsSync, realpathSync } from "fs";
-import { isAbsolute, join, relative, resolve, sep, win32 } from "path";
+import { realpathSync } from "fs";
+import { basename, dirname, isAbsolute, join, relative, resolve, sep, win32 } from "path";
 function resolveComparablePath(p) {
   if (/^[a-zA-Z]:[/\\]/.test(p)) {
     return win32.resolve(p);
@@ -221,43 +287,32 @@ function assertResolvedPathUnderRoot(root, target) {
     throw new Error(`unsafe path escapes project root: ${target}`);
   }
 }
-function resolveExistingPathUnderRoot(rootReal, rootResolved, targetResolved) {
-  const rel = relative(rootResolved, targetResolved);
-  if (rel.startsWith("..") || rel.includes(`..${sep}`)) {
-    throw new Error(`unsafe path escapes project root: ${targetResolved}`);
-  }
-  const segments = rel.split(/[/\\]/).filter((s) => s.length > 0 && s !== ".");
-  let current = rootReal;
-  for (const segment of segments) {
-    const next = join(current, segment);
-    if (existsSync(next)) {
+function resolvePhysicalPathForCheck(p) {
+  const resolved = resolveComparablePath(p);
+  try {
+    return realpathSync.native(resolved);
+  } catch {
+    let probe = resolved;
+    let suffix = "";
+    while (true) {
       try {
-        current = realpathSync(next);
+        const physical = realpathSync.native(probe);
+        return suffix ? join(physical, suffix) : physical;
       } catch {
-        current = next;
+        if (probe === dirname(probe)) {
+          return resolved;
+        }
+        const segment = basename(probe);
+        suffix = suffix ? join(segment, suffix) : segment;
+        probe = dirname(probe);
       }
-    } else {
-      current = next;
     }
-    assertResolvedPathUnderRoot(rootReal, current);
   }
-  return current;
 }
 function assertRealPathUnderRoot(root, target) {
-  const rootResolved = resolveComparablePath(root);
-  const targetResolved = resolveComparablePath(target);
-  let rootReal;
-  try {
-    rootReal = realpathSync(rootResolved);
-  } catch {
-    rootReal = rootResolved;
-  }
-  try {
-    const targetCheck = realpathSync(targetResolved);
-    assertResolvedPathUnderRoot(rootReal, targetCheck);
-  } catch {
-    resolveExistingPathUnderRoot(rootReal, rootResolved, targetResolved);
-  }
+  const rootPhysical = resolvePhysicalPathForCheck(root);
+  const targetPhysical = resolvePhysicalPathForCheck(target);
+  assertResolvedPathUnderRoot(rootPhysical, targetPhysical);
 }
 function normalizePathForComparison(p) {
   const resolved = resolveComparablePath(p);
@@ -280,6 +335,113 @@ function isResolvedPathUnderRoot(root, target) {
   return !rel.startsWith("..") && !isAbsolute(rel);
 }
 
+// src/validateProjectPaths.ts
+import { existsSync, realpathSync as realpathSync2 } from "fs";
+import { isAbsolute as isAbsolute2, resolve as resolve2 } from "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 validateManifestName(name) {
+  if (!name.length) {
+    return "must be a non-empty string";
+  }
+  if (name.includes("/") || name.includes("\\")) {
+    return "must not contain path separators";
+  }
+  if (!isSafeRelativeSpaPath(name)) {
+    return "must be a safe relative name without '..' segments or absolute prefixes";
+  }
+  if (isReservedOutputPath(name) || isReservedOutputPath(`${name}.lkcourse`)) {
+    return "must not target reserved directories (.git, node_modules, .github)";
+  }
+  return null;
+}
+function isReservedResolvedOutputPath(projectRoot, resolved) {
+  const rootResolved = resolveComparablePath(projectRoot);
+  const targetResolved = resolveComparablePath(resolved);
+  try {
+    const rootReal = existsSync(rootResolved) ? realpathSync2(rootResolved) : rootResolved;
+    const targetReal = existsSync(targetResolved) ? realpathSync2(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, resolve2(projectRoot, value));
+  } catch {
+    issues.push({
+      path: fieldPath,
+      message: "path must resolve inside the project root"
+    });
+  }
+}
+function validateProjectPaths(projectRoot, paths) {
+  const issues = [];
+  const root = resolve2(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 = resolve2(projectRoot);
+  const trimmed = override.trim();
+  if (!trimmed) {
+    throw new Error("output override must be a non-empty path");
+  }
+  if (isAbsolute2(trimmed)) {
+    const resolved2 = resolve2(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 = resolve2(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
 import { getPresetTheme, themeToCssVariables } from "@lessonkit/themes";
 function themeToLxpackRuntime(input) {
@@ -297,6 +459,7 @@ function themeToLxpackRuntime(input) {
 
 // src/descriptor/validateAssessments.ts
 import { validateId as validateId2 } from "@lessonkit/core";
+import { isMultiSelectMcq } from "@lessonkit/core";
 var validateMcqLike = (assessment, path, issues) => {
   if (!("choices" in assessment) || !Array.isArray(assessment.choices)) {
     issues.push({ path: `${path}.choices`, message: "choices is required for mcq" });
@@ -312,9 +475,44 @@ var validateMcqLike = (assessment, path, issues) => {
   }
   if (!assessment.answer.trim()) {
     issues.push({ path: `${path}.answer`, message: "answer is required" });
-  } else if (trimmedChoices.length && !trimmedChoices.includes(assessment.answer.trim())) {
+  } else if (!("answers" in assessment && isMultiSelectMcq({ answers: assessment.answers })) && trimmedChoices.length && !trimmedChoices.includes(assessment.answer.trim())) {
     issues.push({ path: `${path}.answer`, message: "answer must match a choice" });
   }
+  if ("answers" in assessment && assessment.answers !== void 0) {
+    if (!Array.isArray(assessment.answers)) {
+      issues.push({ path: `${path}.answers`, message: "answers must be an array when provided" });
+    } else {
+      const trimmedAnswers = assessment.answers.map((a) => a.trim()).filter((a) => a.length > 0);
+      if (assessment.answers.length > 0 && trimmedAnswers.length === 0) {
+        issues.push({ path: `${path}.answers`, message: "answers must include non-empty strings" });
+      }
+      const uniqueAnswers = new Set(trimmedAnswers);
+      if (trimmedAnswers.length !== uniqueAnswers.size) {
+        issues.push({ path: `${path}.answers`, message: "answers must be unique" });
+      }
+      for (const ans of trimmedAnswers) {
+        if (trimmedChoices.length && !trimmedChoices.includes(ans)) {
+          issues.push({ path: `${path}.answers`, message: "each answer must match a choice" });
+          break;
+        }
+      }
+    }
+  }
+  if ("choiceFeedback" in assessment && assessment.choiceFeedback !== void 0) {
+    if (typeof assessment.choiceFeedback !== "object" || assessment.choiceFeedback === null) {
+      issues.push({ path: `${path}.choiceFeedback`, message: "choiceFeedback must be an object" });
+    } else {
+      for (const key of Object.keys(assessment.choiceFeedback)) {
+        if (!trimmedChoices.includes(key.trim())) {
+          issues.push({
+            path: `${path}.choiceFeedback`,
+            message: "choiceFeedback keys must match choice labels"
+          });
+          break;
+        }
+      }
+    }
+  }
   const uniqueChoices = new Set(trimmedChoices);
   if (trimmedChoices.length !== uniqueChoices.size) {
     issues.push({ path: `${path}.choices`, message: "choices must be unique" });
@@ -334,6 +532,12 @@ function maxAchievableAssessmentScore(assessment) {
   if (kind === "findMultipleHotspots" && assessment.kind === "findMultipleHotspots") {
     return assessment.correctTargetIds?.map((id) => id.trim()).filter((id) => id.length > 0).length ?? 0;
   }
+  if (kind === "sortParagraphs" && assessment.kind === "sortParagraphs") {
+    return assessment.paragraphs?.length ?? assessment.correctOrder?.length ?? 0;
+  }
+  if ("answers" in assessment && Array.isArray(assessment.answers) && assessment.answers.length > 1) {
+    return assessment.answers.filter((a) => a.trim().length > 0).length;
+  }
   return 1;
 }
 var ASSESSMENT_VALIDATORS = {
@@ -356,8 +560,30 @@ var ASSESSMENT_VALIDATORS = {
         message: "template must include at least one blank wrapped in asterisks for fillInBlanks"
       });
     }
-    const explicitBlanks = assessment.blanks?.map((b) => ({ id: b.id?.trim() ?? "", answer: b.answer?.trim() ?? "" })).filter((b) => b.id.length > 0 && b.answer.length > 0) ?? [];
-    if (assessment.blanks !== void 0 && explicitBlanks.length === 0) {
+    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"
@@ -397,7 +623,31 @@ var ASSESSMENT_VALIDATORS = {
         message: "at least one non-empty correctTargetId is required for findMultipleHotspots"
       });
     }
-  }
+  },
+  sortParagraphs: (assessment, path, issues) => {
+    if (assessment.kind !== "sortParagraphs") return;
+    if (!Array.isArray(assessment.paragraphs) || assessment.paragraphs.length === 0) {
+      issues.push({ path: `${path}.paragraphs`, message: "paragraphs is required for sortParagraphs" });
+      return;
+    }
+    if (!Array.isArray(assessment.correctOrder) || assessment.correctOrder.length === 0) {
+      issues.push({ path: `${path}.correctOrder`, message: "correctOrder is required for sortParagraphs" });
+      return;
+    }
+    if (assessment.correctOrder.length !== assessment.paragraphs.length) {
+      issues.push({
+        path: `${path}.correctOrder`,
+        message: "correctOrder length must match paragraphs length for sortParagraphs"
+      });
+    }
+  },
+  guessTheAnswer: (assessment, path, issues) => {
+    if (assessment.kind !== "guessTheAnswer") return;
+    if (!assessment.answer?.trim()) {
+      issues.push({ path: `${path}.answer`, message: "answer is required for guessTheAnswer" });
+    }
+  },
+  multimediaChoice: validateMcqLike
 };
 function validateAssessmentEntry(assessment, index, issues, checkIds) {
   const path = `assessments[${index}]`;
@@ -505,6 +755,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",
@@ -565,6 +829,8 @@ function validateCourseDescriptor(input) {
 }
 
 // src/assessments.ts
+import { isMultiSelectMcq as isMultiSelectMcq2 } from "@lessonkit/core";
+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;");
 }
@@ -573,7 +839,7 @@ function decodeShellEntities(text) {
 }
 function containsUnsafeShellMarkup(text) {
   const decoded = decodeShellEntities(text);
-  return /<\/script/i.test(decoded) || /<!--/.test(decoded) || /</.test(decoded);
+  return /<\/script/i.test(decoded) || /<!--/.test(decoded) || /<[a-zA-Z!/]/.test(decoded);
 }
 function sanitizeShellField(text) {
   if (containsUnsafeShellMarkup(text)) return null;
@@ -588,6 +854,8 @@ function mcqToLxpack(assessment) {
   const checkId = sanitizeShellField(assessment.checkId);
   const prompt = sanitizeShellField(assessment.question);
   if (!checkId || !prompt) return null;
+  const normalizedAnswer = assessment.answer.trim();
+  const multiCorrect = assessment.answers && assessment.answers.length > 1 ? new Set(assessment.answers.map((a) => a.trim())) : /* @__PURE__ */ new Set([normalizedAnswer]);
   const choices = assessment.choices.map((text, index) => {
     const sanitizedText = sanitizeShellField(text);
     if (!sanitizedText) return null;
@@ -595,17 +863,21 @@ function mcqToLxpack(assessment) {
     return {
       id,
       text: sanitizedText,
-      correct: text === assessment.answer
+      correct: multiCorrect.has(text.trim())
     };
   });
   if (choices.some((choice) => choice === null)) return null;
+  const multiSelect = isMultiSelectMcq2(assessment);
   return {
     id: checkId,
-    passingScore: assessment.passingScore ?? 1,
+    passingScore: assessment.passingScore ?? DEFAULT_SHELL_PASSING_SCORE,
+    shuffleChoices: assessment.shuffleChoices === true ? true : void 0,
+    showFeedback: assessment.choiceFeedback && Object.keys(assessment.choiceFeedback).length > 0 ? "immediate" : void 0,
     questions: [
       {
         id: "q1",
         prompt,
+        ...multiSelect ? { selectionMode: "multiple" } : {},
         choices
       }
     ]
@@ -634,7 +906,20 @@ function assessmentDescriptorToLxpack(assessment) {
   if (kind === "findMultipleHotspots") {
     return null;
   }
-  if ("choices" in assessment && "answer" in assessment && typeof assessment.answer === "string") {
+  if (kind === "sortParagraphs" || kind === "guessTheAnswer") {
+    return null;
+  }
+  if (kind === "multimediaChoice" && assessment.kind === "multimediaChoice") {
+    return mcqToLxpack({
+      kind: "mcq",
+      checkId: assessment.checkId,
+      question: assessment.question,
+      choices: assessment.choices,
+      answer: assessment.answer,
+      passingScore: assessment.passingScore
+    });
+  }
+  if ((kind === "mcq" || assessment.kind === void 0) && "choices" in assessment && "answer" in assessment && typeof assessment.answer === "string") {
     return mcqToLxpack(assessment);
   }
   return null;
@@ -646,11 +931,20 @@ function extractAssessments(descriptor) {
 // src/descriptor/validateInjectableAssessments.ts
 function validateInjectableAssessments(descriptor) {
   const issues = [];
+  const spaOnlyKinds = /* @__PURE__ */ new Set([
+    "fillInBlanks",
+    "findHotspot",
+    "findMultipleHotspots",
+    "sortParagraphs",
+    "guessTheAnswer"
+  ]);
   (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}`
       });
     }
   });
@@ -666,7 +960,7 @@ var LMS_SHELL_TARGETS = /* @__PURE__ */ new Set([
   "cmi5"
 ]);
 function appendActivityIriIssues(issues, descriptor, target) {
-  const hasXapiTracking = Boolean(descriptor.tracking?.xapi);
+  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();
@@ -882,9 +1176,20 @@ function courseConfigCourseIdPresent(source, courseId) {
   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) {
@@ -953,117 +1258,42 @@ function validateReactManifestParity(opts) {
   return issues;
 }
 
-// src/validateProjectPaths.ts
-import { isAbsolute as isAbsolute2, resolve as resolve2 } from "path";
-var RESERVED_OUTPUT_SEGMENTS = /* @__PURE__ */ new Set([".git", "node_modules", ".github"]);
-function isReservedOutputPath(value) {
-  const normalized = value.replace(/\\/g, "/").replace(/^\/+|\/+$/g, "");
-  const segments = normalized.split("/").filter(Boolean);
-  return segments.some((segment) => RESERVED_OUTPUT_SEGMENTS.has(segment));
+// src/mapIds.ts
+import { assertValidId } from "@lessonkit/core";
+function mapLessonkitIds(descriptor) {
+  const courseId = assertValidId(descriptor.courseId, "courseId");
+  const lessonIds = descriptor.lessons.map((l) => assertValidId(l.id, "lessonId"));
+  const checkIds = (descriptor.assessments ?? []).map(
+    (a) => assertValidId(a.checkId, "checkId")
+  );
+  return { courseId, lessonIds, checkIds };
 }
-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;
+
+// src/interchange.ts
+function mapDescriptorTracking(tracking) {
+  if (!tracking) return void 0;
+  const mapped = {};
+  if (tracking.completion?.threshold !== void 0) {
+    mapped.completion = { threshold: tracking.completion.threshold };
   }
-  try {
-    assertRealPathUnderRoot(projectRoot, resolve2(projectRoot, value));
-  } catch {
-    issues.push({
-      path: fieldPath,
-      message: "path must resolve inside the project root"
-    });
+  const activityIri = tracking.xapi?.activityIri?.trim();
+  if (activityIri) {
+    mapped.xapi = { activityIri };
   }
+  return Object.keys(mapped).length > 0 ? mapped : void 0;
 }
-function validateProjectPaths(projectRoot, paths) {
-  const issues = [];
-  const root = resolve2(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, {
-      rejectReserved: true
-    });
-  }
-  if (paths.outputBaseDir?.trim()) {
-    validatePathField(paths.outputBaseDir.trim(), "paths.outputBaseDir", root, issues, {
-      rejectReserved: true
-    });
-  }
-  return issues;
-}
-function resolveSafePackageOutputOverride(projectRoot, override) {
-  const root = resolve2(projectRoot);
-  const trimmed = override.trim();
-  if (!trimmed) {
-    throw new Error("output override must be a non-empty path");
-  }
-  if (isAbsolute2(trimmed)) {
-    const resolved2 = resolve2(trimmed);
-    assertRealPathUnderRoot(root, resolved2);
-    if (isReservedOutputPath(trimmed)) {
-      throw new Error(`unsafe output path: ${override} targets a reserved directory`);
-    }
-    return resolved2;
-  }
-  if (!isSafeRelativeSpaPath(trimmed)) {
-    throw new Error(`unsafe output path: ${override}`);
-  }
-  if (isReservedOutputPath(trimmed)) {
-    throw new Error(`unsafe output path: ${override} targets a reserved directory`);
-  }
-  const resolved = resolve2(root, trimmed);
-  assertRealPathUnderRoot(root, resolved);
-  return resolved;
-}
-
-// src/mapIds.ts
-import { assertValidId } from "@lessonkit/core";
-function mapLessonkitIds(descriptor) {
-  const courseId = assertValidId(descriptor.courseId, "courseId");
-  const lessonIds = descriptor.lessons.map((l) => assertValidId(l.id, "lessonId"));
-  const checkIds = (descriptor.assessments ?? []).map(
-    (a) => assertValidId(a.checkId, "checkId")
-  );
-  return { courseId, lessonIds, checkIds };
-}
-
-// src/interchange.ts
-function mapDescriptorTracking(tracking) {
-  if (!tracking) return void 0;
-  const mapped = {};
-  if (tracking.completion?.threshold !== void 0) {
-    mapped.completion = { threshold: tracking.completion.threshold };
-  }
-  const activityIri = tracking.xapi?.activityIri?.trim();
-  if (activityIri) {
-    mapped.xapi = { activityIri };
-  }
-  return Object.keys(mapped).length > 0 ? mapped : void 0;
-}
-function resolveSpaLessons(descriptor) {
-  const mapped = mapLessonkitIds(descriptor);
-  if (descriptor.layout === "single-spa") {
-    const spaLessonId = descriptor.spaLessonId ?? mapped.lessonIds[0] ?? "main";
-    const firstLesson = descriptor.lessons.find((l) => l.id === spaLessonId);
-    return [
-      {
-        id: spaLessonId,
-        title: firstLesson?.title ?? descriptor.title,
-        path: "dist"
-      }
-    ];
+function resolveSpaLessons(descriptor) {
+  const mapped = mapLessonkitIds(descriptor);
+  if (descriptor.layout === "single-spa") {
+    const spaLessonId = descriptor.spaLessonId ?? mapped.lessonIds[0] ?? "main";
+    const firstLesson = descriptor.lessons.find((l) => l.id === spaLessonId);
+    return [
+      {
+        id: spaLessonId,
+        title: firstLesson?.title ?? descriptor.title,
+        path: "dist"
+      }
+    ];
   }
   return descriptor.lessons.map((lesson) => ({
     id: lesson.id,
@@ -1159,7 +1389,7 @@ async function resolveSpaDirs(options) {
 
 // src/spaDistValidation.ts
 import { lstat, readdir } from "fs/promises";
-import { realpathSync as realpathSync2 } from "fs";
+import { realpathSync as realpathSync3 } from "fs";
 import { join as join4 } from "path";
 async function assertSpaDistContentsSafe(spaDirs, projectRoot) {
   for (const [label, dir] of Object.entries(spaDirs)) {
@@ -1170,7 +1400,7 @@ async function assertSpaDistContentsSafe(spaDirs, projectRoot) {
     }
     let rootReal;
     try {
-      rootReal = realpathSync2(dirResolved);
+      rootReal = realpathSync3(dirResolved);
     } catch {
       throw new Error(`spa dist for "${label}" is not readable: ${dir}`);
     }
@@ -1199,7 +1429,7 @@ async function walkDistDir(rootReal, current, label) {
     }
     let entryReal;
     try {
-      entryReal = realpathSync2(entryPath);
+      entryReal = realpathSync3(entryPath);
     } catch (err) {
       throw new Error(
         `spa dist for "${label}" could not resolve path: ${entryPath}`,
@@ -1224,7 +1454,9 @@ 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 = resolve4(options.outDir);
   assertRealPathUnderRoot(resolve4(options.projectRoot), outDir);
@@ -1251,8 +1483,8 @@ async function writeLxpackProject(options) {
 }
 
 // src/packageCourse.ts
-import { resolve as resolve7 } from "path";
-import * as fsp3 from "fs/promises";
+import { resolve as resolve9 } from "path";
+import * as fsp4 from "fs/promises";
 import {
   buildCourse,
   validateCourse
@@ -1290,6 +1522,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,
@@ -1347,6 +1592,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 = isAbsolute3(output) ? resolve5(output) : resolve5(projectRoot, output);
@@ -1368,6 +1626,20 @@ function validatePackageInputs(options) {
         ]
       };
     }
+    const outputRel = isAbsolute3(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)"
+          }
+        ]
+      };
+    }
   }
   return { ok: true, outDir, projectRoot };
 }
@@ -1402,7 +1674,7 @@ function remapArtifactPaths(stagingRoot, outDir, artifactPath) {
 // src/packaging/promote.ts
 import * as fsp from "fs/promises";
 import { createHash, randomUUID } from "crypto";
-import { dirname, join as join7, resolve as resolve6 } from "path";
+import { dirname as dirname2, join as join7, resolve as resolve6 } from "path";
 async function pathExists(path) {
   try {
     await fsp.access(path);
@@ -1422,7 +1694,7 @@ async function renameOrCopy(from, to) {
   }
 }
 function promoteLockPath(outDir) {
-  const parent = dirname(outDir);
+  const parent = dirname2(outDir);
   const hash = createHash("sha256").update(resolve6(outDir)).digest("hex").slice(0, 16);
   return join7(parent, `.lk-promote-lock-${hash}`);
 }
@@ -1460,11 +1732,14 @@ async function isStalePromoteLock(lockPath) {
     return true;
   }
 }
+var PROMOTE_LOCK_TIMEOUT_MS = 15e3;
 async function withPromoteLock(outDir, fn) {
   const lockPath = promoteLockPath(outDir);
-  await fsp.mkdir(dirname(outDir), { recursive: true });
+  await fsp.mkdir(dirname2(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}
@@ -1482,7 +1757,9 @@ ${Date.now()}
         );
         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) {
@@ -1547,7 +1824,7 @@ async function mergePreservedOutArtifacts(priorArtifactsDir, destArtifactsDir, n
     if (newArtifactPaths.has(rel)) continue;
     const src = join7(priorArtifactsDir, rel);
     const dest = join7(destArtifactsDir, rel);
-    await fsp.mkdir(dirname(dest), { recursive: true });
+    await fsp.mkdir(dirname2(dest), { recursive: true });
     await fsp.cp(src, dest, { force: true });
   }
 }
@@ -1565,7 +1842,7 @@ async function promoteStagingToOutDir(stagingDir, outDir, options) {
         newArtifactPaths.add(rel);
       }
     }
-    const parent = dirname(outDir);
+    const parent = dirname2(outDir);
     let priorArtifactsBackup;
     const existingArtifactsDir = join7(outDir, outputBaseDir);
     if (await pathExists(outDir) && await pathExists(existingArtifactsDir)) {
@@ -1651,14 +1928,29 @@ async function promoteStagingToOutDir(stagingDir, outDir, options) {
   });
 }
 
-// src/packaging/staging.ts
+// src/packaging/relocateOutput.ts
 import * as fsp2 from "fs/promises";
-import { dirname as dirname2, join as join8 } from "path";
+import { dirname as dirname3, resolve as resolve7 } from "path";
+async function relocatePackageOutput(builtOutputPath, requestedOutputPath, projectRoot) {
+  if (!builtOutputPath || !requestedOutputPath) return builtOutputPath;
+  const resolvedBuilt = resolveComparablePath(builtOutputPath);
+  const resolvedRequested = resolveComparablePath(requestedOutputPath);
+  if (resolvedBuilt === resolvedRequested) return builtOutputPath;
+  const root = resolve7(projectRoot);
+  assertRealPathUnderRoot(root, resolvedRequested);
+  await fsp2.mkdir(dirname3(resolvedRequested), { recursive: true });
+  await renameOrCopy(resolvedBuilt, resolvedRequested);
+  return resolvedRequested;
+}
+
+// src/packaging/staging.ts
+import * as fsp3 from "fs/promises";
+import { dirname as dirname4, isAbsolute as isAbsolute4, join as join8, resolve as resolve8 } from "path";
 import { tmpdir } from "os";
 import { packageLessonkit } from "@lxpack/api";
 async function buildStagingPackage(options) {
   const { target, output, dir, outputBaseDir, descriptor, ...writeOpts } = options;
-  const stagingDir = await fsp2.mkdtemp(join8(tmpdir(), "lessonkit-lxpack-"));
+  const stagingDir = await fsp3.mkdtemp(join8(tmpdir(), "lessonkit-lxpack-"));
   let succeeded = false;
   try {
     let spaDirs;
@@ -1690,14 +1982,28 @@ async function buildStagingPackage(options) {
     }
     const interchange = descriptorToInterchange(descriptor);
     const outputBase = outputBaseDir ?? ".lxpack/out";
-    await fsp2.mkdir(join8(stagingDir, outputBase), { recursive: true });
-    const defaultOutput = output ?? (dir ? join8(outputBase, target) : join8(outputBase, `course-${target}.zip`));
+    await fsp3.mkdir(join8(stagingDir, outputBase), { recursive: true });
+    const defaultOutput = dir ? join8(outputBase, target) : join8(outputBase, `course-${target}.zip`);
+    let packageOutput = output ?? defaultOutput;
+    let requestedOutputPath;
+    let requestedOutputDir;
+    if (output) {
+      const projectRoot = resolve8(writeOpts.projectRoot);
+      const requested = isAbsolute4(output) ? resolve8(output) : resolve8(projectRoot, output);
+      if (dir) {
+        requestedOutputDir = requested;
+        packageOutput = defaultOutput;
+      } else {
+        requestedOutputPath = requested;
+        packageOutput = defaultOutput;
+      }
+    }
     const build = await packageLessonkit({
       interchange,
       spaDirs,
       target,
       courseDir: stagingDir,
-      output: defaultOutput,
+      output: packageOutput,
       dir,
       outputBaseDir,
       outputAnchorDir: stagingDir,
@@ -1721,17 +2027,19 @@ async function buildStagingPackage(options) {
       stagingDir,
       build,
       outputPath: "outputPath" in build ? build.outputPath : void 0,
-      outputDir: "outputDir" in build ? build.outputDir : void 0
+      outputDir: "outputDir" in build ? build.outputDir : void 0,
+      requestedOutputPath,
+      requestedOutputDir
     };
   } catch (err) {
-    await fsp2.rm(stagingDir, { recursive: true, force: true }).catch(
+    await fsp3.rm(stagingDir, { recursive: true, force: true }).catch(
       /* v8 ignore next */
       () => void 0
     );
     throw err;
   } finally {
     if (!succeeded) {
-      await fsp2.rm(stagingDir, { recursive: true, force: true }).catch(
+      await fsp3.rm(stagingDir, { recursive: true, force: true }).catch(
         /* v8 ignore next */
         () => void 0
       );
@@ -1739,7 +2047,7 @@ async function buildStagingPackage(options) {
   }
 }
 async function ensureOutDirParent(outDir) {
-  await fsp2.mkdir(dirname2(outDir), { recursive: true });
+  await fsp3.mkdir(dirname4(outDir), { recursive: true });
 }
 
 // src/packaging/issueSeverity.ts
@@ -1750,17 +2058,23 @@ 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) {
   return validateCourse({
-    courseDir: resolve7(options.courseDir),
+    courseDir: resolve9(options.courseDir),
     target: options.target
   });
 }
 async function buildLessonkitProject(options) {
   const buildOptions = {
-    courseDir: resolve7(options.courseDir),
+    courseDir: resolve9(options.courseDir),
     target: options.target,
     output: options.output,
     dir: options.dir,
@@ -1791,7 +2105,7 @@ async function packageLessonkitCourse(options) {
   if (!descriptorValidation.ok) {
     return {
       ok: false,
-      courseDir: resolve7(writeOpts.outDir),
+      courseDir: resolve9(writeOpts.outDir),
       target,
       issues: descriptorValidation.issues.map((i) => ({
         path: i.path,
@@ -1817,16 +2131,31 @@ async function packageLessonkitCourse(options) {
       }))
     };
   }
-  const staged = await buildStagingPackage({
-    ...writeOpts,
-    descriptor,
-    target,
-    output,
-    dir,
-    outputBaseDir
-  });
+  let staged;
+  try {
+    staged = await buildStagingPackage({
+      ...writeOpts,
+      descriptor,
+      target,
+      output,
+      dir,
+      outputBaseDir
+    });
+  } catch (err) {
+    return {
+      ok: false,
+      courseDir: outDir,
+      target,
+      issues: [
+        {
+          path: "staging",
+          message: err instanceof Error ? err.message : String(err)
+        }
+      ]
+    };
+  }
   if (!staged.ok) {
-    await fsp3.rm(staged.stagingDir, { recursive: true, force: true }).catch(
+    await fsp4.rm(staged.stagingDir, { recursive: true, force: true }).catch(
       /* v8 ignore next */
       () => void 0
     );
@@ -1843,7 +2172,7 @@ async function packageLessonkitCourse(options) {
   const { stagingDir, build } = staged;
   const buildErrorIssues = findPackagingErrorIssues(build.issues);
   if (buildErrorIssues.length > 0) {
-    await fsp3.rm(stagingDir, { recursive: true, force: true }).catch(
+    await fsp4.rm(stagingDir, { recursive: true, force: true }).catch(
       /* v8 ignore next */
       () => void 0
     );
@@ -1860,13 +2189,13 @@ async function packageLessonkitCourse(options) {
       }))
     };
   }
-  const stagingRoot = await fsp3.realpath(stagingDir);
+  const stagingRoot = await fsp4.realpath(stagingDir);
   const artifactIssues = [
     validateArtifactInStaging(stagingRoot, staged.outputPath, "outputPath"),
     validateArtifactInStaging(stagingRoot, staged.outputDir, "outputDir")
   ].filter((issue) => issue != null);
   if (artifactIssues.length > 0) {
-    await fsp3.rm(stagingDir, { recursive: true, force: true }).catch(
+    await fsp4.rm(stagingDir, { recursive: true, force: true }).catch(
       /* v8 ignore next */
       () => void 0
     );
@@ -1879,8 +2208,27 @@ async function packageLessonkitCourse(options) {
       issues: artifactIssues
     };
   }
-  const remappedOutputPath = remapArtifactPaths(stagingRoot, outDir, staged.outputPath);
-  const remappedOutputDir = remapArtifactPaths(stagingRoot, outDir, staged.outputDir);
+  const buildWarningIssues = findPackagingWarningIssues(build.issues);
+  if (options.strictBuild && buildWarningIssues.length > 0) {
+    await fsp4.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
+      }))
+    };
+  }
+  let remappedOutputPath = remapArtifactPaths(stagingRoot, outDir, staged.outputPath);
+  let remappedOutputDir = remapArtifactPaths(stagingRoot, outDir, staged.outputDir);
   const validation = {
     ok: true,
     manifest: build.manifest,
@@ -1893,7 +2241,7 @@ async function packageLessonkitCourse(options) {
       projectRoot: writeOpts.projectRoot
     });
   } catch (err) {
-    await fsp3.rm(stagingDir, { recursive: true, force: true }).catch(
+    await fsp4.rm(stagingDir, { recursive: true, force: true }).catch(
       /* v8 ignore next */
       () => void 0
     );
@@ -1911,6 +2259,32 @@ async function packageLessonkitCourse(options) {
       ]
     };
   }
+  try {
+    remappedOutputPath = await relocatePackageOutput(
+      remappedOutputPath,
+      staged.requestedOutputPath,
+      writeOpts.projectRoot
+    );
+    remappedOutputDir = await relocatePackageOutput(
+      remappedOutputDir,
+      staged.requestedOutputDir,
+      writeOpts.projectRoot
+    );
+  } catch (err) {
+    return {
+      ok: false,
+      courseDir: outDir,
+      target,
+      validation,
+      build,
+      issues: [
+        {
+          path: "output",
+          message: err instanceof Error ? err.message : String(err)
+        }
+      ]
+    };
+  }
   const remappedBuild = { ...build };
   if ("outputPath" in remappedBuild && remappedOutputPath !== void 0) {
     remappedBuild.outputPath = remappedOutputPath;
@@ -1954,8 +2328,9 @@ function parseLessonkitManifest(raw, label = "lessonkit.json", projectRoot) {
   }
   const nameRaw = config.name;
   const name = typeof nameRaw === "string" ? nameRaw.trim() : "";
-  if (!name) {
-    issues.push({ path: "name", message: "must be a non-empty string" });
+  const nameIssue = validateManifestName(name);
+  if (nameIssue) {
+    issues.push({ path: "name", message: nameIssue });
   }
   const courseRaw = config.course;
   if (Array.isArray(courseRaw)) {
@@ -2021,7 +2396,7 @@ function parseLessonkitManifest(raw, label = "lessonkit.json", projectRoot) {
         path: `paths.${key}`,
         message: "path must be relative without '..' segments or absolute prefixes"
       });
-    } else if ((key === "lxpackOutDir" || key === "outputBaseDir") && isReservedOutputPath(value)) {
+    } else if (isReservedOutputPath(value)) {
       issues.push({
         path: `paths.${key}`,
         message: "path must not target reserved directories (.git, node_modules, .github)"
@@ -2063,17 +2438,920 @@ import {
 import {
   lessonkitInterchangeSchema,
   materializeLessonkitProject as materializeLessonkitProject2,
-  parseLessonkitInterchange
+  parseLessonkitInterchange as parseLessonkitInterchange3
 } from "@lxpack/validators";
+
+// src/lkcourse/zip.ts
+import { readFileSync as readFileSync2, statSync } from "fs";
+import { dirname as dirname5, join as join9, normalize } from "path";
+import { strFromU8, strToU8, unzipSync, zipSync } from "fflate";
+var MAX_LKCOURSE_UNCOMPRESSED_BYTES = 256 * 1024 * 1024;
+function canonicalZipEntryPath(entryPath) {
+  const slashNormalized = entryPath.replace(/\\/g, "/");
+  const canonical = 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 zipSync(zipped, { level: 6 });
+}
+function readZip(archivePath) {
+  const issues = [];
+  let raw;
+  try {
+    raw = readFileSync2(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 = 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 = join9(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 strFromU8(data);
+}
+function utf8ToEntry(text) {
+  return 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
+import { existsSync as existsSync3, lstatSync as lstatSync2, readdirSync as readdirSync2, readFileSync as readFileSync3 } from "fs";
+import { createRequire } from "module";
+import { join as join10, relative as relative3 } from "path";
+import { validateId as validateId4 } from "@lessonkit/core";
+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 = join10(projectRoot, "src");
+  if (!existsSync3(srcDir)) return [];
+  const results = [];
+  const walk = (dir) => {
+    for (const entry of readdirSync2(dir)) {
+      const abs = join10(dir, entry);
+      try {
+        assertRealPathUnderRoot(projectRoot, abs);
+      } catch {
+        continue;
+      }
+      const stat2 = lstatSync2(abs);
+      if (stat2.isSymbolicLink()) continue;
+      if (stat2.isDirectory()) {
+        walk(abs);
+      } else if (SCANNABLE_EXTENSIONS2.some((ext) => entry.endsWith(ext))) {
+        results.push(relative3(projectRoot, abs));
+      }
+    }
+  };
+  walk(srcDir);
+  return results;
+}
+function loadCatalogBlockTypes(blockTypes) {
+  if (blockTypes?.length) return blockTypes;
+  try {
+    const require2 = createRequire(import.meta.url);
+    const catalogPath = require2.resolve("@lessonkit/react/block-catalog.v3.json");
+    const catalog = JSON.parse(readFileSync3(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 = validateId4(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 = join10(options.projectRoot, rel);
+    if (!existsSync3(abs)) continue;
+    const source = readFileSync3(abs, "utf8");
+    const parsed = parseJsxBlocks(source, blockTypes);
+    blocks.push(...parsed);
+  }
+  return {
+    schemaVersion: 1,
+    sources,
+    blocks
+  };
+}
+
+// src/lkcourse/export.ts
+import { mkdir as mkdir4, writeFile } from "fs/promises";
+import { createRequire as createRequire2 } from "module";
+import { dirname as dirname6, join as join11, resolve as resolve10 } from "path";
+import { parseLessonkitInterchange } from "@lxpack/validators";
+function resolveLessonkitVersion(explicit) {
+  if (explicit?.trim()) return explicit.trim();
+  try {
+    const require2 = createRequire2(import.meta.url);
+    const pkg = require2("../../package.json");
+    return pkg.version ?? "0.0.0";
+  } catch {
+    return "0.0.0";
+  }
+}
+async function exportLkcourse(options) {
+  const projectRoot = resolve10(options.projectRoot);
+  const manifest = options.manifest;
+  const spaDistDir = join11(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 injectableIssues = validateInjectableAssessments(manifest.course);
+  if (injectableIssues.length > 0) {
+    return {
+      ok: false,
+      issues: injectableIssues.map((issue) => ({
+        path: issue.path,
+        message: issue.message
+      }))
+    };
+  }
+  const interchange = descriptorToInterchange(manifest.course);
+  const interchangeParsed = 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 = resolve10(
+    projectRoot,
+    options.outPath ?? `${manifest.name}.lkcourse`
+  );
+  const archiveRel = options.outPath ?? `${manifest.name}.lkcourse`;
+  try {
+    assertRealPathUnderRoot(projectRoot, archivePath);
+  } catch (err) {
+    return {
+      ok: false,
+      issues: [
+        {
+          path: archiveRel,
+          message: err instanceof Error ? err.message : String(err)
+        }
+      ]
+    };
+  }
+  if (isReservedResolvedOutputPath(projectRoot, archivePath)) {
+    return {
+      ok: false,
+      issues: [
+        {
+          path: archiveRel,
+          message: "output path must not target reserved directories (.git, node_modules, .github)"
+        }
+      ]
+    };
+  }
+  if (!isSafeZipEntryPath(archiveRel)) {
+    return {
+      ok: false,
+      issues: [{ path: "outPath", message: "output path must be a safe relative path" }]
+    };
+  }
+  try {
+    await mkdir4(dirname6(archivePath), { recursive: true });
+    const zipped = createZip(zipEntries);
+    await 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
+import { parseLessonkitInterchange as parseLessonkitInterchange2 } from "@lxpack/validators";
+
+// src/lkcourse/assessmentParity.ts
+function validateLkcourseAssessmentConsistency(descriptor, interchange) {
+  const issues = [];
+  for (const issue of validateInjectableAssessments(descriptor)) {
+    issues.push({
+      path: `sourceManifest.course.${issue.path}`,
+      message: issue.message
+    });
+  }
+  const expectedIds = extractAssessments(descriptor).map((a) => a.id).sort();
+  const interchangeIds = (interchange.assessments ?? []).map((a) => a.id).sort();
+  const matches = expectedIds.length === interchangeIds.length && expectedIds.every((id, index) => id === interchangeIds[index]);
+  if (!matches) {
+    issues.push({
+      path: "interchange.assessments",
+      message: `injectable assessment ids [${expectedIds.join(", ")}] do not match interchange [${interchangeIds.join(", ")}]`
+    });
+  }
+  return issues;
+}
+
+// src/lkcourse/validate.ts
+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" });
+  }
+  const allowlisted = new Set(envelope.entries.map((entryPath) => entryPath.replace(/\\/g, "/")));
+  const spaDistPrefix = `${spaDistDir}/`;
+  for (const entryPath of envelope.entries) {
+    if (!entries.has(entryPath)) {
+      issues.push({
+        path: entryPath,
+        message: "listed in manifest.entries but missing from archive"
+      });
+    }
+  }
+  for (const zipPath of entries.keys()) {
+    const normalized = zipPath.replace(/\\/g, "/");
+    if (!normalized.startsWith(spaDistPrefix)) continue;
+    if (!allowlisted.has(normalized)) {
+      issues.push({
+        path: zipPath,
+        message: "unlisted file under spaDistDir; not in manifest.entries"
+      });
+    }
+  }
+  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 = parseLessonkitInterchange2(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})`
+    });
+  }
+  issues.push(
+    ...validateLkcourseAssessmentConsistency(
+      envelope.sourceManifest.course,
+      interchange
+    )
+  );
+  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
+import { access as access3, cp as cp2, mkdir as mkdir5, mkdtemp as mkdtemp3, readdir as readdir3, rename as rename2, rm as rm4, writeFile as writeFile2 } from "fs/promises";
+import { dirname as dirname7, join as join12, resolve as resolve11 } from "path";
+var IMPORT_ARTIFACTS = ["lessonkit.json", "dist"];
+async function pathExists2(path) {
+  try {
+    await access3(path);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function renameOrCopy2(from, to, opts) {
+  const renameFn = opts?.renameFn ?? rename2;
+  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 cp2(from, to, { recursive: true });
+    await rm4(from, { recursive: true, force: true });
+  }
+}
+async function writeImportTree(stagingDir, manifest, entries, spaDistDir, allowlistedSpaPaths) {
+  let fileCount = 0;
+  await writeFile2(
+    join12(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;
+    if (!allowlistedSpaPaths.has(normalized)) {
+      throw new Error(`unlisted spaDist entry rejected: ${entryPath}`);
+    }
+    const relativeUnderSpa = normalized.slice(spaDistDir.length + 1);
+    const outPath = join12(stagingDir, spaDistDir, relativeUnderSpa);
+    const resolvedOut = resolve11(outPath);
+    assertRealPathUnderRoot(stagingDir, resolvedOut);
+    if (!isSafeZipEntryPath(join12(spaDistDir, relativeUnderSpa))) {
+      throw new Error(`unsafe extraction path: ${entryPath}`);
+    }
+    await mkdir5(dirname7(resolvedOut), { recursive: true });
+    await writeFile2(resolvedOut, data);
+    fileCount += 1;
+  }
+  return fileCount;
+}
+async function backupImportArtifacts(targetDir) {
+  const existing = [];
+  for (const name of IMPORT_ARTIFACTS) {
+    if (await pathExists2(join12(targetDir, name))) {
+      existing.push(name);
+    }
+  }
+  if (!existing.length) return void 0;
+  const backupDir = await mkdtemp3(join12(targetDir, ".lkcourse-backup-"));
+  for (const name of existing) {
+    await renameOrCopy2(join12(targetDir, name), join12(backupDir, name));
+  }
+  return backupDir;
+}
+async function restoreImportBackup(targetDir, backupDir) {
+  for (const name of IMPORT_ARTIFACTS) {
+    const backupPath = join12(backupDir, name);
+    if (!await pathExists2(backupPath)) continue;
+    const destPath = join12(targetDir, name);
+    if (await pathExists2(destPath)) {
+      await rm4(destPath, { recursive: true, force: true });
+    }
+    await renameOrCopy2(backupPath, destPath);
+  }
+}
+async function snapshotPreExistingImportArtifacts(targetDir) {
+  const existing = /* @__PURE__ */ new Set();
+  for (const name of IMPORT_ARTIFACTS) {
+    if (await pathExists2(join12(targetDir, name))) {
+      existing.add(name);
+    }
+  }
+  return existing;
+}
+async function rollbackFailedImport(targetDir, backupDir, preExisting) {
+  if (backupDir) {
+    await restoreImportBackup(targetDir, backupDir);
+  }
+  for (const name of IMPORT_ARTIFACTS) {
+    if (preExisting.has(name)) continue;
+    const destPath = join12(targetDir, name);
+    if (await pathExists2(destPath)) {
+      await rm4(destPath, { recursive: true, force: true });
+    }
+  }
+}
+async function promoteImportStaging(stagingDir, targetDir) {
+  await mkdir5(targetDir, { recursive: true });
+  const entries = await readdir3(stagingDir, { withFileTypes: true });
+  for (const entry of entries) {
+    const srcPath = join12(stagingDir, entry.name);
+    const destPath = join12(targetDir, entry.name);
+    if (entry.isDirectory() || entry.isFile()) {
+      await renameOrCopy2(srcPath, destPath);
+    }
+  }
+}
+var promoteImportStagingImpl = promoteImportStaging;
+async function importLkcourse(options) {
+  const archivePath = resolve11(options.archivePath);
+  const targetDir = resolve11(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 mkdir5(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;
+  let preExisting;
+  try {
+    stagingDir = await mkdtemp3(join12(targetDir, ".lkcourse-import-"));
+    const allowlistedSpaPaths = new Set(
+      envelope.entries.map((entryPath) => entryPath.replace(/\\/g, "/")).filter((entryPath) => entryPath.startsWith(`${spaDistDir}/`))
+    );
+    const fileCount = await writeImportTree(
+      stagingDir,
+      manifest,
+      read.entries,
+      spaDistDir,
+      allowlistedSpaPaths
+    );
+    preExisting = await snapshotPreExistingImportArtifacts(targetDir);
+    backupDir = await backupImportArtifacts(targetDir);
+    try {
+      await promoteImportStagingImpl(stagingDir, targetDir);
+    } catch (promoteError) {
+      await rollbackFailedImport(targetDir, backupDir, preExisting);
+      backupDir = void 0;
+      throw promoteError;
+    }
+    if (backupDir) {
+      await rm4(backupDir, { recursive: true, force: true }).catch(() => void 0);
+      backupDir = void 0;
+    }
+    await rm4(stagingDir, { recursive: true, force: true });
+    stagingDir = void 0;
+    return {
+      ok: true,
+      targetDir,
+      manifest,
+      interchange,
+      fileCount
+    };
+  } catch (err) {
+    if (preExisting) {
+      await rollbackFailedImport(targetDir, backupDir, preExisting).catch(() => void 0);
+    } else if (backupDir) {
+      await restoreImportBackup(targetDir, backupDir).catch(() => void 0);
+    }
+    if (backupDir) {
+      await rm4(backupDir, { recursive: true, force: true }).catch(() => void 0);
+    }
+    if (stagingDir) {
+      await rm4(stagingDir, { recursive: true, force: true }).catch(() => void 0);
+    }
+    return {
+      ok: false,
+      issues: [
+        {
+          path: targetDir,
+          message: err instanceof Error ? err.message : String(err)
+        }
+      ]
+    };
+  }
+}
 export {
   LESSONKIT_TELEMETRY_EVENTS,
+  assertSpaDistContentsSafe,
   assessmentDescriptorToLxpack,
   buildLessonkitProject,
   buildStagingPackage,
   descriptorToInterchange,
   ensureOutDirParent,
   escapeShellText,
+  exportLkcourse,
   extractAssessments,
+  extractBlockTree,
+  importLkcourse,
   lessonkitInterchangeSchema,
   loadLessonkitManifestFromFile,
   mapLessonkitIds,
@@ -2081,8 +3359,9 @@ export {
   mapLessonkitTelemetryToLxpack,
   materializeLessonkitProject2 as materializeLessonkitProject,
   packageLessonkitCourse,
-  parseLessonkitInterchange,
+  parseLessonkitInterchange3 as parseLessonkitInterchange,
   parseLessonkitManifest,
+  parseLkcourseEnvelope,
   promoteStagingToOutDir,
   remapArtifactPaths,
   resolveSafePackageOutputOverride,
@@ -2092,6 +3371,9 @@ export {
   validateDescriptor,
   validateDescriptorForTarget,
   validateLessonkitProject,
+  validateLkcourse,
+  validateLkcourseArchiveEntries,
+  validateManifestName,
   validatePackageInputs,
   validateProjectPaths,
   validateReactManifestParity,