@lessonkit/lxpack 1.6.0 → 1.7.1

package/dist/index.cjs

@@ -63,6 +63,7 @@ __export(index_exports, {
   validateLessonkitProject: () => validateLessonkitProject,
   validateLkcourse: () => validateLkcourse,
   validateLkcourseArchiveEntries: () => validateLkcourseArchiveEntries,
+  validateManifestName: () => validateManifestName,
   validatePackageInputs: () => validatePackageInputs,
   validateProjectPaths: () => validateProjectPaths,
   validateReactManifestParity: () => validateReactManifestParity,
@@ -130,13 +131,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)
       };
     })
   };
@@ -210,7 +238,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,
@@ -222,7 +273,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) {
@@ -266,7 +325,7 @@ function parseCourseDescriptorInput(input) {
 }
 
 // src/descriptor/validateCourse.ts
-var import_core3 = require("@lessonkit/core");
+var import_core4 = require("@lessonkit/core");
 var import_themes2 = require("@lessonkit/themes");
 
 // src/spaPath.ts
@@ -297,43 +356,32 @@ function assertResolvedPathUnderRoot(root, target) {
     throw new Error(`unsafe path escapes project root: ${target}`);
   }
 }
-function resolveExistingPathUnderRoot(rootReal, rootResolved, targetResolved) {
-  const rel = (0, import_node_path.relative)(rootResolved, targetResolved);
-  if (rel.startsWith("..") || rel.includes(`..${import_node_path.sep}`)) {
-    throw new Error(`unsafe path escapes project root: ${targetResolved}`);
-  }
-  const segments = rel.split(/[/\\]/).filter((s) => s.length > 0 && s !== ".");
-  let current = rootReal;
-  for (const segment of segments) {
-    const next = (0, import_node_path.join)(current, segment);
-    if ((0, import_node_fs.existsSync)(next)) {
+function resolvePhysicalPathForCheck(p) {
+  const resolved = resolveComparablePath(p);
+  try {
+    return import_node_fs.realpathSync.native(resolved);
+  } catch {
+    let probe = resolved;
+    let suffix = "";
+    while (true) {
       try {
-        current = (0, import_node_fs.realpathSync)(next);
+        const physical = import_node_fs.realpathSync.native(probe);
+        return suffix ? (0, import_node_path.join)(physical, suffix) : physical;
       } catch {
-        current = next;
+        if (probe === (0, import_node_path.dirname)(probe)) {
+          return resolved;
+        }
+        const segment = (0, import_node_path.basename)(probe);
+        suffix = suffix ? (0, import_node_path.join)(segment, suffix) : segment;
+        probe = (0, import_node_path.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 = (0, import_node_fs.realpathSync)(rootResolved);
-  } catch {
-    rootReal = rootResolved;
-  }
-  try {
-    const targetCheck = (0, import_node_fs.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);
@@ -367,6 +415,21 @@ function isReservedOutputPath(value) {
   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);
@@ -465,6 +528,7 @@ function themeToLxpackRuntime(input) {
 
 // src/descriptor/validateAssessments.ts
 var import_core2 = require("@lessonkit/core");
+var import_core3 = require("@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" });
@@ -480,9 +544,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 && (0, import_core3.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" });
@@ -502,6 +601,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 = {
@@ -587,7 +692,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}]`;
@@ -642,7 +771,7 @@ var VALID_LAYOUTS = ["single-spa", "per-lesson-spa"];
 var VALID_THEME_PRESETS = ["default", "light", "dark", "brand"];
 function validateCourseDescriptor(input) {
   const issues = [];
-  const course = (0, import_core3.validateId)(input.courseId, "courseId");
+  const course = (0, import_core4.validateId)(input.courseId, "courseId");
   if (!course.ok) issues.push(...course.issues.map((i) => ({ path: i.path, message: i.message })));
   if (!input.title?.trim()) {
     issues.push({ path: "title", message: "title is required" });
@@ -719,7 +848,7 @@ function validateCourseDescriptor(input) {
   const spaPaths = /* @__PURE__ */ new Set();
   for (const [index, lesson] of (input.lessons ?? []).entries()) {
     const path = `lessons[${index}]`;
-    const lessonResult = (0, import_core3.validateId)(lesson.id, `${path}.id`);
+    const lessonResult = (0, import_core4.validateId)(lesson.id, `${path}.id`);
     if (!lessonResult.ok) {
       issues.push(...lessonResult.issues.map((i) => ({ path: i.path, message: i.message })));
     } else if (lessonIds.has(lessonResult.id)) {
@@ -751,7 +880,7 @@ function validateCourseDescriptor(input) {
   }
   if (layout === "single-spa" && input.spaLessonId?.trim()) {
     const spaId = input.spaLessonId.trim();
-    const spaResult = (0, import_core3.validateId)(spaId, "spaLessonId");
+    const spaResult = (0, import_core4.validateId)(spaId, "spaLessonId");
     if (!spaResult.ok) {
       issues.push(...spaResult.issues.map((i) => ({ path: i.path, message: i.message })));
     } else if (!lessonIds.has(spaResult.id)) {
@@ -769,6 +898,7 @@ function validateCourseDescriptor(input) {
 }
 
 // src/assessments.ts
+var import_core5 = require("@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;");
@@ -794,6 +924,7 @@ function mcqToLxpack(assessment) {
   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;
@@ -801,17 +932,21 @@ function mcqToLxpack(assessment) {
     return {
       id,
       text: sanitizedText,
-      correct: text.trim() === normalizedAnswer
+      correct: multiCorrect.has(text.trim())
     };
   });
   if (choices.some((choice) => choice === null)) return null;
+  const multiSelect = (0, import_core5.isMultiSelectMcq)(assessment);
   return {
     id: checkId,
     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
       }
     ]
@@ -840,7 +975,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;
@@ -852,7 +1000,13 @@ function extractAssessments(descriptor) {
 // src/descriptor/validateInjectableAssessments.ts
 function validateInjectableAssessments(descriptor) {
   const issues = [];
-  const spaOnlyKinds = /* @__PURE__ */ new Set(["fillInBlanks", "findHotspot", "findMultipleHotspots"]);
+  const spaOnlyKinds = /* @__PURE__ */ new Set([
+    "fillInBlanks",
+    "findHotspot",
+    "findMultipleHotspots",
+    "sortParagraphs",
+    "guessTheAnswer"
+  ]);
   (descriptor.assessments ?? []).forEach((assessment, index) => {
     if (assessmentDescriptorToLxpack(assessment) === null) {
       const kind = assessment.kind ?? "mcq";
@@ -1174,12 +1328,12 @@ function validateReactManifestParity(opts) {
 }
 
 // src/mapIds.ts
-var import_core4 = require("@lessonkit/core");
+var import_core6 = require("@lessonkit/core");
 function mapLessonkitIds(descriptor) {
-  const courseId = (0, import_core4.assertValidId)(descriptor.courseId, "courseId");
-  const lessonIds = descriptor.lessons.map((l) => (0, import_core4.assertValidId)(l.id, "lessonId"));
+  const courseId = (0, import_core6.assertValidId)(descriptor.courseId, "courseId");
+  const lessonIds = descriptor.lessons.map((l) => (0, import_core6.assertValidId)(l.id, "lessonId"));
   const checkIds = (descriptor.assessments ?? []).map(
-    (a) => (0, import_core4.assertValidId)(a.checkId, "checkId")
+    (a) => (0, import_core6.assertValidId)(a.checkId, "checkId")
   );
   return { courseId, lessonIds, checkIds };
 }
@@ -1398,8 +1552,8 @@ async function writeLxpackProject(options) {
 }
 
 // src/packageCourse.ts
-var import_node_path10 = require("path");
-var fsp3 = __toESM(require("fs/promises"), 1);
+var import_node_path11 = require("path");
+var fsp4 = __toESM(require("fs/promises"), 1);
 var import_api2 = require("@lxpack/api");
 
 // src/packaging/validateInputs.ts
@@ -1552,21 +1706,6 @@ function validatePackageInputs(options) {
         ]
       };
     }
-    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 };
 }
@@ -1855,14 +1994,29 @@ async function promoteStagingToOutDir(stagingDir, outDir, options) {
   });
 }
 
-// src/packaging/staging.ts
+// src/packaging/relocateOutput.ts
 var fsp2 = __toESM(require("fs/promises"), 1);
 var import_node_path9 = require("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 = (0, import_node_path9.resolve)(projectRoot);
+  assertRealPathUnderRoot(root, resolvedRequested);
+  await fsp2.mkdir((0, import_node_path9.dirname)(resolvedRequested), { recursive: true });
+  await renameOrCopy(resolvedBuilt, resolvedRequested);
+  return resolvedRequested;
+}
+
+// src/packaging/staging.ts
+var fsp3 = __toESM(require("fs/promises"), 1);
+var import_node_path10 = require("path");
 var import_node_os = require("os");
 var import_api = require("@lxpack/api");
 async function buildStagingPackage(options) {
   const { target, output, dir, outputBaseDir, descriptor, ...writeOpts } = options;
-  const stagingDir = await fsp2.mkdtemp((0, import_node_path9.join)((0, import_node_os.tmpdir)(), "lessonkit-lxpack-"));
+  const stagingDir = await fsp3.mkdtemp((0, import_node_path10.join)((0, import_node_os.tmpdir)(), "lessonkit-lxpack-"));
   let succeeded = false;
   try {
     let spaDirs;
@@ -1894,14 +2048,28 @@ async function buildStagingPackage(options) {
     }
     const interchange = descriptorToInterchange(descriptor);
     const outputBase = outputBaseDir ?? ".lxpack/out";
-    await fsp2.mkdir((0, import_node_path9.join)(stagingDir, outputBase), { recursive: true });
-    const defaultOutput = output ?? (dir ? (0, import_node_path9.join)(outputBase, target) : (0, import_node_path9.join)(outputBase, `course-${target}.zip`));
+    await fsp3.mkdir((0, import_node_path10.join)(stagingDir, outputBase), { recursive: true });
+    const defaultOutput = dir ? (0, import_node_path10.join)(outputBase, target) : (0, import_node_path10.join)(outputBase, `course-${target}.zip`);
+    let packageOutput = output ?? defaultOutput;
+    let requestedOutputPath;
+    let requestedOutputDir;
+    if (output) {
+      const projectRoot = (0, import_node_path10.resolve)(writeOpts.projectRoot);
+      const requested = (0, import_node_path10.isAbsolute)(output) ? (0, import_node_path10.resolve)(output) : (0, import_node_path10.resolve)(projectRoot, output);
+      if (dir) {
+        requestedOutputDir = requested;
+        packageOutput = defaultOutput;
+      } else {
+        requestedOutputPath = requested;
+        packageOutput = defaultOutput;
+      }
+    }
     const build = await (0, import_api.packageLessonkit)({
       interchange,
       spaDirs,
       target,
       courseDir: stagingDir,
-      output: defaultOutput,
+      output: packageOutput,
       dir,
       outputBaseDir,
       outputAnchorDir: stagingDir,
@@ -1925,17 +2093,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
       );
@@ -1943,7 +2113,7 @@ async function buildStagingPackage(options) {
   }
 }
 async function ensureOutDirParent(outDir) {
-  await fsp2.mkdir((0, import_node_path9.dirname)(outDir), { recursive: true });
+  await fsp3.mkdir((0, import_node_path10.dirname)(outDir), { recursive: true });
 }
 
 // src/packaging/issueSeverity.ts
@@ -1964,13 +2134,13 @@ function findPackagingWarningIssues(issues) {
 // src/packageCourse.ts
 async function validateLessonkitProject(options) {
   return (0, import_api2.validateCourse)({
-    courseDir: (0, import_node_path10.resolve)(options.courseDir),
+    courseDir: (0, import_node_path11.resolve)(options.courseDir),
     target: options.target
   });
 }
 async function buildLessonkitProject(options) {
   const buildOptions = {
-    courseDir: (0, import_node_path10.resolve)(options.courseDir),
+    courseDir: (0, import_node_path11.resolve)(options.courseDir),
     target: options.target,
     output: options.output,
     dir: options.dir,
@@ -2001,7 +2171,7 @@ async function packageLessonkitCourse(options) {
   if (!descriptorValidation.ok) {
     return {
       ok: false,
-      courseDir: (0, import_node_path10.resolve)(writeOpts.outDir),
+      courseDir: (0, import_node_path11.resolve)(writeOpts.outDir),
       target,
       issues: descriptorValidation.issues.map((i) => ({
         path: i.path,
@@ -2051,7 +2221,7 @@ async function packageLessonkitCourse(options) {
     };
   }
   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
     );
@@ -2068,7 +2238,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
     );
@@ -2085,13 +2255,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
     );
@@ -2106,7 +2276,7 @@ async function packageLessonkitCourse(options) {
   }
   const buildWarningIssues = findPackagingWarningIssues(build.issues);
   if (options.strictBuild && buildWarningIssues.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
     );
@@ -2123,8 +2293,8 @@ async function packageLessonkitCourse(options) {
       }))
     };
   }
-  const remappedOutputPath = remapArtifactPaths(stagingRoot, outDir, staged.outputPath);
-  const remappedOutputDir = remapArtifactPaths(stagingRoot, outDir, staged.outputDir);
+  let remappedOutputPath = remapArtifactPaths(stagingRoot, outDir, staged.outputPath);
+  let remappedOutputDir = remapArtifactPaths(stagingRoot, outDir, staged.outputDir);
   const validation = {
     ok: true,
     manifest: build.manifest,
@@ -2137,7 +2307,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
     );
@@ -2155,6 +2325,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;
@@ -2198,8 +2394,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)) {
@@ -2363,12 +2560,12 @@ var import_validators4 = require("@lxpack/validators");
 
 // src/lkcourse/zip.ts
 var import_node_fs5 = require("fs");
-var import_node_path11 = require("path");
+var import_node_path12 = 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, "/");
+  const canonical = (0, import_node_path12.normalize)(slashNormalized).replace(/\\/g, "/");
   if (canonical !== slashNormalized) return null;
   return canonical;
 }
@@ -2443,7 +2640,7 @@ async function collectDistEntries(distDir, spaDistRelative) {
   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 abs = (0, import_node_path12.join)(absDir, entry.name);
       const rel = relPrefix ? `${relPrefix}/${entry.name}` : entry.name;
       const zipPath = `${spaDistRelative}/${rel}`.replace(/\\/g, "/");
       if (!isSafeRelativeSpaPath(zipPath)) {
@@ -2545,8 +2742,8 @@ function parseLkcourseEnvelope(raw, label = "manifest.json") {
 // 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_node_path13 = require("path");
+var import_core7 = require("@lessonkit/core");
 var import_meta = {};
 var SCANNABLE_EXTENSIONS2 = [".tsx", ".ts", ".jsx", ".js"];
 var ID_PROPS = ["courseId", "lessonId", "checkId", "blockId", "nodeId"];
@@ -2554,12 +2751,12 @@ function stripComments2(source) {
   return source.replace(/\/\*[\s\S]*?\*\//g, " ").replace(/\/\/[^\n]*/g, " ");
 }
 function collectSourceUnderSrc2(projectRoot) {
-  const srcDir = (0, import_node_path12.join)(projectRoot, "src");
+  const srcDir = (0, import_node_path13.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);
+      const abs = (0, import_node_path13.join)(dir, entry);
       try {
         assertRealPathUnderRoot(projectRoot, abs);
       } catch {
@@ -2570,7 +2767,7 @@ function collectSourceUnderSrc2(projectRoot) {
       if (stat2.isDirectory()) {
         walk(abs);
       } else if (SCANNABLE_EXTENSIONS2.some((ext) => entry.endsWith(ext))) {
-        results.push((0, import_node_path12.relative)(projectRoot, abs));
+        results.push((0, import_node_path13.relative)(projectRoot, abs));
       }
     }
   };
@@ -2684,7 +2881,7 @@ 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);
+    const validated = (0, import_core7.validateId)(value, prop);
     if (!validated.ok) {
       issues.push({
         path: `${pathPrefix}.${prop}`,
@@ -2708,7 +2905,7 @@ function extractBlockTree(options) {
   const sources = options.appSources ?? collectSourceUnderSrc2(options.projectRoot);
   const blocks = [];
   for (const rel of sources) {
-    const abs = (0, import_node_path12.join)(options.projectRoot, rel);
+    const abs = (0, import_node_path13.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);
@@ -2724,7 +2921,7 @@ function extractBlockTree(options) {
 // src/lkcourse/export.ts
 var import_promises3 = require("fs/promises");
 var import_node_module2 = require("module");
-var import_node_path13 = require("path");
+var import_node_path14 = require("path");
 var import_validators2 = require("@lxpack/validators");
 var import_meta2 = {};
 function resolveLessonkitVersion(explicit) {
@@ -2738,9 +2935,9 @@ function resolveLessonkitVersion(explicit) {
   }
 }
 async function exportLkcourse(options) {
-  const projectRoot = (0, import_node_path13.resolve)(options.projectRoot);
+  const projectRoot = (0, import_node_path14.resolve)(options.projectRoot);
   const manifest = options.manifest;
-  const spaDistDir = (0, import_node_path13.join)(projectRoot, manifest.paths.spaDistDir);
+  const spaDistDir = (0, import_node_path14.join)(projectRoot, manifest.paths.spaDistDir);
   try {
     assertRealPathUnderRoot(projectRoot, spaDistDir);
     await assertSpaDistContentsSafe({ main: spaDistDir }, projectRoot);
@@ -2755,6 +2952,16 @@ async function exportLkcourse(options) {
       ]
     };
   }
+  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 = (0, import_validators2.parseLessonkitInterchange)(interchange);
   if (!interchangeParsed.ok) {
@@ -2846,10 +3053,11 @@ async function exportLkcourse(options) {
     return { ok: false, issues: envelopeCheck.issues };
   }
   zipEntries.set("manifest.json", utf8ToEntry(JSON.stringify(envelope, null, 2)));
-  const archivePath = (0, import_node_path13.resolve)(
+  const archivePath = (0, import_node_path14.resolve)(
     projectRoot,
     options.outPath ?? `${manifest.name}.lkcourse`
   );
+  const archiveRel = options.outPath ?? `${manifest.name}.lkcourse`;
   try {
     assertRealPathUnderRoot(projectRoot, archivePath);
   } catch (err) {
@@ -2857,20 +3065,31 @@ async function exportLkcourse(options) {
       ok: false,
       issues: [
         {
-          path: options.outPath ?? `${manifest.name}.lkcourse`,
+          path: archiveRel,
           message: err instanceof Error ? err.message : String(err)
         }
       ]
     };
   }
-  if (!isSafeZipEntryPath(options.outPath ?? `${manifest.name}.lkcourse`)) {
+  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 (0, import_promises3.mkdir)((0, import_node_path13.dirname)(archivePath), { recursive: true });
+    await (0, import_promises3.mkdir)((0, import_node_path14.dirname)(archivePath), { recursive: true });
     const zipped = createZip(zipEntries);
     await (0, import_promises3.writeFile)(archivePath, zipped);
   } catch (err) {
@@ -2894,6 +3113,29 @@ async function exportLkcourse(options) {
 
 // src/lkcourse/validate.ts
 var import_validators3 = require("@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");
@@ -2926,6 +3168,8 @@ function validateLkcourseArchiveEntries(entries, _archiveLabel) {
   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({
@@ -2934,6 +3178,16 @@ function validateLkcourseArchiveEntries(entries, _archiveLabel) {
       });
     }
   }
+  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 {
@@ -2967,6 +3221,12 @@ function validateLkcourseArchiveEntries(entries, _archiveLabel) {
       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) {
@@ -3007,7 +3267,7 @@ function validateLkcourse(archivePath) {
 
 // src/lkcourse/import.ts
 var import_promises4 = require("fs/promises");
-var import_node_path14 = require("path");
+var import_node_path15 = require("path");
 var IMPORT_ARTIFACTS = ["lessonkit.json", "dist"];
 async function pathExists2(path) {
   try {
@@ -3028,10 +3288,10 @@ async function renameOrCopy2(from, to, opts) {
     await (0, import_promises4.rm)(from, { recursive: true, force: true });
   }
 }
-async function writeImportTree(stagingDir, manifest, entries, spaDistDir) {
+async function writeImportTree(stagingDir, manifest, entries, spaDistDir, allowlistedSpaPaths) {
   let fileCount = 0;
   await (0, import_promises4.writeFile)(
-    (0, import_node_path14.join)(stagingDir, "lessonkit.json"),
+    (0, import_node_path15.join)(stagingDir, "lessonkit.json"),
     `${JSON.stringify(manifest, null, 2)}
 `,
     "utf8"
@@ -3040,14 +3300,17 @@ async function writeImportTree(stagingDir, manifest, entries, spaDistDir) {
   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 = (0, import_node_path14.join)(stagingDir, spaDistDir, relativeUnderSpa);
-    const resolvedOut = (0, import_node_path14.resolve)(outPath);
+    const outPath = (0, import_node_path15.join)(stagingDir, spaDistDir, relativeUnderSpa);
+    const resolvedOut = (0, import_node_path15.resolve)(outPath);
     assertRealPathUnderRoot(stagingDir, resolvedOut);
-    if (!isSafeZipEntryPath((0, import_node_path14.join)(spaDistDir, relativeUnderSpa))) {
+    if (!isSafeZipEntryPath((0, import_node_path15.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.mkdir)((0, import_node_path15.dirname)(resolvedOut), { recursive: true });
     await (0, import_promises4.writeFile)(resolvedOut, data);
     fileCount += 1;
   }
@@ -3056,45 +3319,64 @@ async function writeImportTree(stagingDir, manifest, entries, spaDistDir) {
 async function backupImportArtifacts(targetDir) {
   const existing = [];
   for (const name of IMPORT_ARTIFACTS) {
-    if (await pathExists2((0, import_node_path14.join)(targetDir, name))) {
+    if (await pathExists2((0, import_node_path15.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-"));
+  const backupDir = await (0, import_promises4.mkdtemp)((0, import_node_path15.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));
+    await renameOrCopy2((0, import_node_path15.join)(targetDir, name), (0, import_node_path15.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);
+    const backupPath = (0, import_node_path15.join)(backupDir, name);
     if (!await pathExists2(backupPath)) continue;
-    const destPath = (0, import_node_path14.join)(targetDir, name);
+    const destPath = (0, import_node_path15.join)(targetDir, name);
     if (await pathExists2(destPath)) {
       await (0, import_promises4.rm)(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((0, import_node_path15.join)(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 = (0, import_node_path15.join)(targetDir, name);
+    if (await pathExists2(destPath)) {
+      await (0, import_promises4.rm)(destPath, { recursive: true, force: true });
+    }
+  }
+}
 async function promoteImportStaging(stagingDir, targetDir) {
+  await (0, import_promises4.mkdir)(targetDir, { recursive: true });
   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);
+    const srcPath = (0, import_node_path15.join)(stagingDir, entry.name);
+    const destPath = (0, import_node_path15.join)(targetDir, entry.name);
+    if (entry.isDirectory() || entry.isFile()) {
+      await renameOrCopy2(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 archivePath = (0, import_node_path15.resolve)(options.archivePath);
+  const targetDir = (0, import_node_path15.resolve)(options.targetDir);
   const validated = validateLkcourse(archivePath);
   if (!validated.ok) return validated;
   const { envelope, interchange } = validated;
@@ -3118,16 +3400,26 @@ async function importLkcourse(options) {
   if (!read.ok) return read;
   let stagingDir;
   let backupDir;
+  let preExisting;
   try {
-    stagingDir = await (0, import_promises4.mkdtemp)((0, import_node_path14.join)(targetDir, ".lkcourse-import-"));
-    const fileCount = await writeImportTree(stagingDir, manifest, read.entries, spaDistDir);
+    stagingDir = await (0, import_promises4.mkdtemp)((0, import_node_path15.join)(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) {
-      if (backupDir) {
-        await restoreImportBackup(targetDir, backupDir);
-      }
+      await rollbackFailedImport(targetDir, backupDir, preExisting);
+      backupDir = void 0;
       throw promoteError;
     }
     if (backupDir) {
@@ -3144,8 +3436,12 @@ async function importLkcourse(options) {
       fileCount
     };
   } catch (err) {
-    if (backupDir) {
+    if (preExisting) {
+      await rollbackFailedImport(targetDir, backupDir, preExisting).catch(() => void 0);
+    } else if (backupDir) {
       await restoreImportBackup(targetDir, backupDir).catch(() => void 0);
+    }
+    if (backupDir) {
       await (0, import_promises4.rm)(backupDir, { recursive: true, force: true }).catch(() => void 0);
     }
     if (stagingDir) {
@@ -3197,6 +3493,7 @@ async function importLkcourse(options) {
   validateLessonkitProject,
   validateLkcourse,
   validateLkcourseArchiveEntries,
+  validateManifestName,
   validatePackageInputs,
   validateProjectPaths,
   validateReactManifestParity,