@lxpack/validators 0.2.0 → 0.2.1

package/dist/index.d.ts

@@ -291,7 +291,7 @@ declare const assessmentRefSchema: z.ZodObject<{
     id: string;
     file: string;
 }>;
-declare const variableDefSchema: z.ZodObject<{
+declare const variableDefSchema: z.ZodEffects<z.ZodObject<{
     default: z.ZodUnion<[z.ZodString, z.ZodNumber, z.ZodBoolean]>;
     type: z.ZodOptional<z.ZodEnum<["string", "number", "boolean"]>>;
 }, "strict", z.ZodTypeAny, {
@@ -300,6 +300,12 @@ declare const variableDefSchema: z.ZodObject<{
 }, {
     default: string | number | boolean;
     type?: "string" | "number" | "boolean" | undefined;
+}>, {
+    default: string | number | boolean;
+    type?: "string" | "number" | "boolean" | undefined;
+}, {
+    default: string | number | boolean;
+    type?: "string" | "number" | "boolean" | undefined;
 }>;
 declare const trackingSchema: z.ZodOptional<z.ZodObject<{
     completion: z.ZodOptional<z.ZodObject<{
@@ -354,7 +360,7 @@ declare const courseManifestSchema: z.ZodObject<{
             threshold?: number | undefined;
         } | undefined;
     }>>;
-    variables: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
+    variables: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodEffects<z.ZodObject<{
         default: z.ZodUnion<[z.ZodString, z.ZodNumber, z.ZodBoolean]>;
         type: z.ZodOptional<z.ZodEnum<["string", "number", "boolean"]>>;
     }, "strict", z.ZodTypeAny, {
@@ -363,6 +369,12 @@ declare const courseManifestSchema: z.ZodObject<{
     }, {
         default: string | number | boolean;
         type?: "string" | "number" | "boolean" | undefined;
+    }>, {
+        default: string | number | boolean;
+        type?: "string" | "number" | "boolean" | undefined;
+    }, {
+        default: string | number | boolean;
+        type?: "string" | "number" | "boolean" | undefined;
     }>>>;
     flow: z.ZodOptional<z.ZodArray<z.ZodObject<{
         when: z.ZodType<Condition, z.ZodTypeDef, Condition>;
@@ -529,18 +541,6 @@ declare const BUILTIN_COMPONENT_IDS: readonly ["callout", "image-card", "checkli
 type BuiltinComponentId = (typeof BUILTIN_COMPONENT_IDS)[number];
 declare function isBuiltinComponentId(id: string): id is BuiltinComponentId;
 
-declare function formatErrorMessage(err: unknown): string;
-declare function formatIssuePath(path: PropertyKey[]): string;
-interface ValidationIssue {
-    path: string;
-    message: string;
-    severity: "error" | "warning";
-}
-interface ValidationResult {
-    valid: boolean;
-    manifest?: CourseManifest;
-    issues: ValidationIssue[];
-}
 declare function isPathContained(rootDir: string, candidatePath: string): boolean;
 declare function resolveCoursePath(courseDir: string, relativePath: string): {
     ok: true;
@@ -555,6 +555,21 @@ declare function assertResolvedPathContained(courseDir: string, resolvedPath: st
     ok: false;
     message: string;
 };
+
+declare function formatErrorMessage(err: unknown): string;
+declare function formatIssuePath(path: PropertyKey[]): string;
+interface ValidationIssue {
+    path: string;
+    message: string;
+    severity: "error" | "warning";
+}
+interface ValidationResult {
+    valid: boolean;
+    manifest?: CourseManifest;
+    issues: ValidationIssue[];
+    /** Populated when assessment files parse successfully. */
+    parsedAssessments?: Map<string, Assessment>;
+}
 declare function loadManifest(courseDir: string): Promise<{
     manifest: CourseManifest;
     raw: unknown;
@@ -562,6 +577,7 @@ declare function loadManifest(courseDir: string): Promise<{
 declare function validateCourse(courseDir: string): Promise<ValidationResult>;
 
 declare function collectActivityIds(manifest: CourseManifest): Set<string>;
+declare function collectAssessmentIds(manifest: CourseManifest): Set<string>;
 declare function validateFlow(manifest: CourseManifest): ValidationIssue[];
 /** Detect simple goto cycles (same-target chains). */
 declare function detectFlowCycles(flow: FlowRule[]): string[];
@@ -601,6 +617,22 @@ declare function toLearnerAssessment(assessment: Assessment): {
     config: AssessmentRuntimeConfig;
     feedback: QuestionFeedback;
 };
+
+interface ParsedAssessmentsResult {
+    parsed: Map<string, Assessment>;
+    issues: ValidationIssue[];
+}
+declare function loadParsedAssessments(courseDir: string, manifest: CourseManifest): Promise<ParsedAssessmentsResult>;
+declare function buildRuntimeAssessmentBundleFromParsed(parsed: Map<string, Assessment>): RuntimeAssessmentBundle;
 declare function buildRuntimeAssessmentBundle(courseDir: string, manifest: CourseManifest): Promise<RuntimeAssessmentBundle>;
 
-export { type Assessment, type AssessmentRef, type AssessmentRuntimeConfig, BUILTIN_COMPONENT_IDS, type BuiltinComponentId, type ComponentLesson, type Condition, type CourseManifest, type FlowRule, type LearnerAssessment, type LearnerChoice, type LearnerQuestion, type Lesson, type QuestionFeedback, type RuntimeAssessmentBundle, type ShowFeedback, type ValidationIssue, type ValidationResult, type VariableDef, assertResolvedPathContained, assessmentQuestionSchema, assessmentRefSchema, assessmentSchema, buildRuntimeAssessmentBundle, collectActivityIds, componentLessonSchema, conditionSchema, courseManifestSchema, detectFlowCycles, flowRuleSchema, formatErrorMessage, formatIssuePath, htmlLessonSchema, isBuiltinComponentId, isPathContained, lessonSchema, loadManifest, markdownLessonSchema, resolveCoursePath, runtimeConfigSchema, showFeedbackSchema, toLearnerAssessment, trackingSchema, validateCourse, validateFlow, variableDefSchema };
+interface CourseActivity {
+    id: string;
+    title: string;
+    kind: "lesson" | "assessment";
+}
+declare function enumerateActivities(manifest: CourseManifest): CourseActivity[];
+
+declare function escapeHtml(text: string): string;
+
+export { type Assessment, type AssessmentRef, type AssessmentRuntimeConfig, BUILTIN_COMPONENT_IDS, type BuiltinComponentId, type ComponentLesson, type Condition, type CourseActivity, type CourseManifest, type FlowRule, type LearnerAssessment, type LearnerChoice, type LearnerQuestion, type Lesson, type QuestionFeedback, type RuntimeAssessmentBundle, type ShowFeedback, type ValidationIssue, type ValidationResult, type VariableDef, assertResolvedPathContained, assessmentQuestionSchema, assessmentRefSchema, assessmentSchema, buildRuntimeAssessmentBundle, buildRuntimeAssessmentBundleFromParsed, collectActivityIds, collectAssessmentIds, componentLessonSchema, conditionSchema, courseManifestSchema, detectFlowCycles, enumerateActivities, escapeHtml, flowRuleSchema, formatErrorMessage, formatIssuePath, htmlLessonSchema, isBuiltinComponentId, isPathContained, lessonSchema, loadManifest, loadParsedAssessments, markdownLessonSchema, resolveCoursePath, runtimeConfigSchema, showFeedbackSchema, toLearnerAssessment, trackingSchema, validateCourse, validateFlow, variableDefSchema };

package/dist/index.js

@@ -97,7 +97,30 @@ var assessmentRefSchema = z2.object({
 var variableDefSchema = z2.object({
   default: z2.union([z2.string(), z2.number(), z2.boolean()]),
   type: z2.enum(["string", "number", "boolean"]).optional()
-}).strict();
+}).strict().superRefine((def, ctx) => {
+  const t = def.type;
+  if (t === "string" && typeof def.default !== "string") {
+    ctx.addIssue({
+      code: z2.ZodIssueCode.custom,
+      message: "Default must be a string when type is string",
+      path: ["default"]
+    });
+  }
+  if (t === "number" && typeof def.default !== "number") {
+    ctx.addIssue({
+      code: z2.ZodIssueCode.custom,
+      message: "Default must be a number when type is number",
+      path: ["default"]
+    });
+  }
+  if (t === "boolean" && typeof def.default !== "boolean") {
+    ctx.addIssue({
+      code: z2.ZodIssueCode.custom,
+      message: "Default must be a boolean when type is boolean",
+      path: ["default"]
+    });
+  }
+});
 var trackingSchema = z2.object({
   completion: z2.object({
     threshold: z2.number().min(0).max(1).default(0.9)
@@ -139,6 +162,13 @@ function collectActivityIds(manifest) {
   }
   return ids;
 }
+function collectAssessmentIds(manifest) {
+  const ids = /* @__PURE__ */ new Set();
+  for (const ref of manifest.assessments ?? []) {
+    ids.add(ref.id);
+  }
+  return ids;
+}
 function collectConditionRefs(condition, refs) {
   if ("variable" in condition && condition.variable?.eq) {
     refs.variables.add(condition.variable.eq[0]);
@@ -161,6 +191,7 @@ function validateFlow(manifest) {
   const flow = manifest.flow;
   if (!flow?.length) return issues;
   const activityIds = collectActivityIds(manifest);
+  const assessmentIds = collectAssessmentIds(manifest);
   const manifestVars = new Set(Object.keys(manifest.variables ?? {}));
   flow.forEach((rule, index) => {
     const path = `flow[${index}]`;
@@ -187,7 +218,7 @@ function validateFlow(manifest) {
       }
     }
     for (const a of refs.assessments) {
-      if (!activityIds.has(a)) {
+      if (!assessmentIds.has(a)) {
         issues.push({
           path: `${path}.when`,
           message: `Unknown assessment in condition: ${a}`,
@@ -200,7 +231,7 @@ function validateFlow(manifest) {
         issues.push({
           path: `${path}.when`,
           message: `Unknown interaction/lesson id in condition: ${i}`,
-          severity: "warning"
+          severity: "error"
         });
       }
     }
@@ -236,17 +267,19 @@ function detectFlowCycles(flow) {
 }
 
 // src/validate.ts
-import { existsSync, realpathSync, statSync } from "fs";
-import { isAbsolute, join, relative, resolve } from "path";
-import { parse as parseYaml } from "yaml";
+import { existsSync as existsSync5 } from "fs";
+import { readFile as readFile2 } from "fs/promises";
+import { join as join3, resolve as resolve2 } from "path";
+import { parse as parseYaml2 } from "yaml";
+
+// src/course-assessments.ts
+import { existsSync, statSync } from "fs";
 import { readFile } from "fs/promises";
-function formatErrorMessage(err) {
-  return err instanceof Error ? err.message : String(err);
-}
-function formatIssuePath(path) {
-  const joined = path.map(String).join(".");
-  return joined || "course.yaml";
-}
+import { parse as parseYaml } from "yaml";
+
+// src/course-paths.ts
+import { realpathSync } from "fs";
+import { isAbsolute, relative, resolve } from "path";
 function isPathContained(rootDir, candidatePath) {
   const root = resolve(rootDir);
   const candidate = resolve(candidatePath);
@@ -277,10 +310,359 @@ function assertResolvedPathContained(courseDir, resolvedPath) {
     return { ok: false, message: "Path could not be resolved" };
   }
 }
+
+// src/assessments.ts
+function toLearnerAssessment(assessment) {
+  const answerKey = {};
+  const feedback = {};
+  const questions = assessment.questions.map((q) => {
+    const correct = q.choices.find((c) => c.correct === true);
+    if (correct) {
+      answerKey[q.id] = correct.id;
+    }
+    if (q.explanation) {
+      feedback[q.id] = q.explanation;
+    }
+    return {
+      id: q.id,
+      prompt: q.prompt,
+      choices: q.choices.map((c) => ({ id: c.id, text: c.text }))
+    };
+  });
+  return {
+    learner: {
+      id: assessment.id,
+      title: assessment.title,
+      passingScore: assessment.passingScore,
+      questions
+    },
+    answerKey,
+    config: {
+      maxAttempts: assessment.maxAttempts ?? 1,
+      shuffleChoices: assessment.shuffleChoices ?? false,
+      showFeedback: assessment.showFeedback ?? "never"
+    },
+    feedback
+  };
+}
+
+// src/course-assessments.ts
+async function loadParsedAssessments(courseDir, manifest) {
+  const resolvedDir = courseDir;
+  const issues = [];
+  const parsed = /* @__PURE__ */ new Map();
+  const assessmentIds = /* @__PURE__ */ new Set();
+  for (const ref of manifest.assessments ?? []) {
+    if (assessmentIds.has(ref.id)) {
+      issues.push({
+        path: "assessments",
+        message: `Duplicate assessment ID: ${ref.id}`,
+        severity: "error"
+      });
+    }
+    assessmentIds.add(ref.id);
+    const resolved = resolveCoursePath(resolvedDir, ref.file);
+    if (!resolved.ok) {
+      issues.push({
+        path: `assessments.${ref.id}.file`,
+        message: resolved.message,
+        severity: "error"
+      });
+      continue;
+    }
+    if (!existsSync(resolved.path)) {
+      issues.push({
+        path: `assessments.${ref.id}.file`,
+        message: `Assessment file not found: ${ref.file}`,
+        severity: "error"
+      });
+      continue;
+    }
+    const contained = assertResolvedPathContained(resolvedDir, resolved.path);
+    if (!contained.ok) {
+      issues.push({
+        path: `assessments.${ref.id}.file`,
+        message: contained.message,
+        severity: "error"
+      });
+      continue;
+    }
+    const assessmentStat = statSync(resolved.path);
+    if (!assessmentStat.isFile()) {
+      issues.push({
+        path: `assessments.${ref.id}.file`,
+        message: `Assessment path is not a file: ${ref.file}`,
+        severity: "error"
+      });
+      continue;
+    }
+    try {
+      const content = await readFile(resolved.path, "utf-8");
+      const raw = parseYaml(content);
+      const result = assessmentSchema.safeParse(raw);
+      if (!result.success) {
+        for (const issue of result.error.issues) {
+          const subPath = issue.path.length ? issue.path.join(".") : "root";
+          issues.push({
+            path: `${ref.file}:${subPath}`,
+            message: issue.message,
+            severity: "error"
+          });
+        }
+        continue;
+      }
+      if (result.data.id !== ref.id) {
+        issues.push({
+          path: `assessments.${ref.id}`,
+          message: `Assessment file id "${result.data.id}" does not match manifest ref id "${ref.id}"`,
+          severity: "error"
+        });
+        continue;
+      }
+      parsed.set(ref.id, result.data);
+    } catch (err) {
+      issues.push({
+        path: ref.file,
+        message: `Failed to parse assessment: ${formatErrorMessage(err)}`,
+        severity: "error"
+      });
+    }
+  }
+  return { parsed, issues };
+}
+function buildRuntimeAssessmentBundleFromParsed(parsed) {
+  const assessments = {};
+  const answerKeys = {};
+  const configs = {};
+  const feedback = {};
+  for (const [id, assessment] of parsed) {
+    const built = toLearnerAssessment(assessment);
+    assessments[id] = built.learner;
+    answerKeys[id] = built.answerKey;
+    configs[id] = built.config;
+    feedback[id] = built.feedback;
+  }
+  return { assessments, answerKeys, configs, feedback };
+}
+async function buildRuntimeAssessmentBundle(courseDir, manifest) {
+  const { parsed, issues } = await loadParsedAssessments(courseDir, manifest);
+  const errors = issues.filter((i) => i.severity === "error");
+  if (errors.length > 0) {
+    throw new Error(
+      errors.map((i) => `${i.path}: ${i.message}`).join("; ")
+    );
+  }
+  return buildRuntimeAssessmentBundleFromParsed(parsed);
+}
+
+// src/validate/lesson-markdown.ts
+import { existsSync as existsSync2, statSync as statSync2 } from "fs";
+function validateMarkdownLesson(courseDir, lesson) {
+  const issues = [];
+  const resolved = resolveCoursePath(courseDir, lesson.file);
+  if (!resolved.ok) {
+    issues.push({
+      path: `lessons.${lesson.id}.file`,
+      message: resolved.message,
+      severity: "error"
+    });
+    return issues;
+  }
+  if (!existsSync2(resolved.path)) {
+    issues.push({
+      path: `lessons.${lesson.id}.file`,
+      message: `Lesson file not found: ${lesson.file}`,
+      severity: "error"
+    });
+    return issues;
+  }
+  const contained = assertResolvedPathContained(courseDir, resolved.path);
+  if (!contained.ok) {
+    issues.push({
+      path: `lessons.${lesson.id}.file`,
+      message: contained.message,
+      severity: "error"
+    });
+    return issues;
+  }
+  const stat = statSync2(resolved.path);
+  if (!stat.isFile()) {
+    issues.push({
+      path: `lessons.${lesson.id}.file`,
+      message: `Lesson path is not a file: ${lesson.file}`,
+      severity: "error"
+    });
+  }
+  return issues;
+}
+
+// src/validate/lesson-html.ts
+import { existsSync as existsSync3, statSync as statSync3 } from "fs";
+import { join } from "path";
+function validateHtmlLesson(courseDir, lesson) {
+  const issues = [];
+  const resolved = resolveCoursePath(courseDir, lesson.path);
+  if (!resolved.ok) {
+    issues.push({
+      path: `lessons.${lesson.id}.path`,
+      message: resolved.message,
+      severity: "error"
+    });
+    return issues;
+  }
+  if (!existsSync3(resolved.path)) {
+    issues.push({
+      path: `lessons.${lesson.id}.path`,
+      message: `HTML interaction directory not found: ${lesson.path}`,
+      severity: "error"
+    });
+    return issues;
+  }
+  const contained = assertResolvedPathContained(courseDir, resolved.path);
+  if (!contained.ok) {
+    issues.push({
+      path: `lessons.${lesson.id}.path`,
+      message: contained.message,
+      severity: "error"
+    });
+    return issues;
+  }
+  const stat = statSync3(resolved.path);
+  if (!stat.isDirectory()) {
+    issues.push({
+      path: `lessons.${lesson.id}.path`,
+      message: `HTML interaction path is not a directory: ${lesson.path}`,
+      severity: "error"
+    });
+    return issues;
+  }
+  const indexPath = join(resolved.path, "index.html");
+  if (!existsSync3(indexPath)) {
+    issues.push({
+      path: `lessons.${lesson.id}.path`,
+      message: `HTML interaction missing index.html: ${lesson.path}`,
+      severity: "error"
+    });
+    return issues;
+  }
+  const indexContained = assertResolvedPathContained(courseDir, indexPath);
+  if (!indexContained.ok) {
+    issues.push({
+      path: `lessons.${lesson.id}.path`,
+      message: indexContained.message,
+      severity: "error"
+    });
+    return issues;
+  }
+  if (!statSync3(indexPath).isFile()) {
+    issues.push({
+      path: `lessons.${lesson.id}.path`,
+      message: `index.html is not a file: ${lesson.path}/index.html`,
+      severity: "error"
+    });
+  }
+  return issues;
+}
+
+// src/validate/lesson-component.ts
+import { existsSync as existsSync4, statSync as statSync4 } from "fs";
+import { join as join2 } from "path";
+function validateComponentLesson(courseDir, lesson) {
+  const issues = [];
+  if (isBuiltinComponentId(lesson.component)) {
+    return issues;
+  }
+  const resolved = resolveCoursePath(
+    courseDir,
+    join2("components", lesson.component)
+  );
+  if (!resolved.ok) {
+    issues.push({
+      path: `lessons.${lesson.id}.component`,
+      message: resolved.message,
+      severity: "error"
+    });
+    return issues;
+  }
+  if (!existsSync4(resolved.path)) {
+    issues.push({
+      path: `lessons.${lesson.id}.component`,
+      message: `Unknown component "${lesson.component}" and no override at components/${lesson.component}`,
+      severity: "error"
+    });
+    return issues;
+  }
+  const contained = assertResolvedPathContained(courseDir, resolved.path);
+  if (!contained.ok) {
+    issues.push({
+      path: `lessons.${lesson.id}.component`,
+      message: contained.message,
+      severity: "error"
+    });
+    return issues;
+  }
+  const componentStat = statSync4(resolved.path);
+  if (!componentStat.isFile()) {
+    issues.push({
+      path: `lessons.${lesson.id}.component`,
+      message: `Component override path is not a file: components/${lesson.component}`,
+      severity: "error"
+    });
+  }
+  return issues;
+}
+
+// src/validate/registry.ts
+var lessonValidators = {
+  markdown: (courseDir, lesson) => validateMarkdownLesson(courseDir, lesson),
+  html: (courseDir, lesson) => validateHtmlLesson(courseDir, lesson),
+  component: (courseDir, lesson) => validateComponentLesson(courseDir, lesson)
+};
+
+// src/validate/ids.ts
+function validateActivityIds(manifest) {
+  const issues = [];
+  const lessonIdCounts = /* @__PURE__ */ new Map();
+  for (const lesson of manifest.lessons) {
+    lessonIdCounts.set(lesson.id, (lessonIdCounts.get(lesson.id) ?? 0) + 1);
+  }
+  for (const [id, count] of lessonIdCounts) {
+    if (count > 1) {
+      issues.push({
+        path: "lessons",
+        message: `Duplicate lesson ID: ${id}`,
+        severity: "error"
+      });
+    }
+  }
+  const assessmentIdSet = /* @__PURE__ */ new Set();
+  for (const ref of manifest.assessments ?? []) {
+    assessmentIdSet.add(ref.id);
+  }
+  for (const lesson of manifest.lessons) {
+    if (assessmentIdSet.has(lesson.id)) {
+      issues.push({
+        path: "lessons",
+        message: `Lesson ID "${lesson.id}" conflicts with an assessment ID`,
+        severity: "error"
+      });
+    }
+  }
+  return issues;
+}
+
+// src/validate.ts
+function formatErrorMessage(err) {
+  return err instanceof Error ? err.message : String(err);
+}
+function formatIssuePath(path) {
+  const joined = path.map(String).join(".");
+  return joined || "course.yaml";
+}
 async function loadManifest(courseDir) {
-  const resolvedDir = resolve(courseDir);
-  const manifestPath = join(resolvedDir, "course.yaml");
-  if (!existsSync(manifestPath)) {
+  const resolvedDir = resolve2(courseDir);
+  const manifestPath = join3(resolvedDir, "course.yaml");
+  if (!existsSync5(manifestPath)) {
     return [
       {
         path: "course.yaml",
@@ -291,8 +673,8 @@ async function loadManifest(courseDir) {
   }
   let raw;
   try {
-    const content = await readFile(manifestPath, "utf-8");
-    raw = parseYaml(content);
+    const content = await readFile2(manifestPath, "utf-8");
+    raw = parseYaml2(content);
   } catch (err) {
     return [
       {
@@ -314,333 +696,56 @@ async function loadManifest(courseDir) {
 }
 async function validateCourse(courseDir) {
   const issues = [];
-  const resolvedDir = resolve(courseDir);
+  const resolvedDir = resolve2(courseDir);
   const loaded = await loadManifest(resolvedDir);
   if (Array.isArray(loaded)) {
     return { valid: false, issues: loaded };
   }
   const { manifest } = loaded;
   for (const lesson of manifest.lessons) {
-    if (lesson.type === "markdown") {
-      const resolved = resolveCoursePath(resolvedDir, lesson.file);
-      if (!resolved.ok) {
-        issues.push({
-          path: `lessons.${lesson.id}.file`,
-          message: resolved.message,
-          severity: "error"
-        });
-        continue;
-      }
-      if (!existsSync(resolved.path)) {
-        issues.push({
-          path: `lessons.${lesson.id}.file`,
-          message: `Lesson file not found: ${lesson.file}`,
-          severity: "error"
-        });
-        continue;
-      }
-      const contained = assertResolvedPathContained(resolvedDir, resolved.path);
-      if (!contained.ok) {
-        issues.push({
-          path: `lessons.${lesson.id}.file`,
-          message: contained.message,
-          severity: "error"
-        });
-        continue;
-      }
-      const stat = statSync(resolved.path);
-      if (!stat.isFile()) {
-        issues.push({
-          path: `lessons.${lesson.id}.file`,
-          message: `Lesson path is not a file: ${lesson.file}`,
-          severity: "error"
-        });
-      }
-    } else if (lesson.type === "component") {
-      if (!isBuiltinComponentId(lesson.component)) {
-        const resolved = resolveCoursePath(
-          resolvedDir,
-          join("components", lesson.component)
-        );
-        if (!resolved.ok) {
-          issues.push({
-            path: `lessons.${lesson.id}.component`,
-            message: resolved.message,
-            severity: "error"
-          });
-          continue;
-        }
-        if (!existsSync(resolved.path)) {
-          issues.push({
-            path: `lessons.${lesson.id}.component`,
-            message: `Unknown component "${lesson.component}" and no override at components/${lesson.component}`,
-            severity: "error"
-          });
-          continue;
-        }
-        const contained = assertResolvedPathContained(resolvedDir, resolved.path);
-        if (!contained.ok) {
-          issues.push({
-            path: `lessons.${lesson.id}.component`,
-            message: contained.message,
-            severity: "error"
-          });
-        }
-      }
-    } else if (lesson.type === "html") {
-      const resolved = resolveCoursePath(resolvedDir, lesson.path);
-      if (!resolved.ok) {
-        issues.push({
-          path: `lessons.${lesson.id}.path`,
-          message: resolved.message,
-          severity: "error"
-        });
-        continue;
-      }
-      if (!existsSync(resolved.path)) {
-        issues.push({
-          path: `lessons.${lesson.id}.path`,
-          message: `HTML interaction directory not found: ${lesson.path}`,
-          severity: "error"
-        });
-        continue;
-      }
-      const contained = assertResolvedPathContained(resolvedDir, resolved.path);
-      if (!contained.ok) {
-        issues.push({
-          path: `lessons.${lesson.id}.path`,
-          message: contained.message,
-          severity: "error"
-        });
-        continue;
-      }
-      const stat = statSync(resolved.path);
-      if (!stat.isDirectory()) {
-        issues.push({
-          path: `lessons.${lesson.id}.path`,
-          message: `HTML interaction path is not a directory: ${lesson.path}`,
-          severity: "error"
-        });
-        continue;
-      }
-      const indexPath = join(resolved.path, "index.html");
-      if (!existsSync(indexPath)) {
-        issues.push({
-          path: `lessons.${lesson.id}.path`,
-          message: `HTML interaction missing index.html: ${lesson.path}`,
-          severity: "error"
-        });
-      } else {
-        const indexContained = assertResolvedPathContained(
-          resolvedDir,
-          indexPath
-        );
-        if (!indexContained.ok) {
-          issues.push({
-            path: `lessons.${lesson.id}.path`,
-            message: indexContained.message,
-            severity: "error"
-          });
-        } else if (!statSync(indexPath).isFile()) {
-          issues.push({
-            path: `lessons.${lesson.id}.path`,
-            message: `index.html is not a file: ${lesson.path}/index.html`,
-            severity: "error"
-          });
-        }
-      }
-    }
+    issues.push(...lessonValidators[lesson.type](resolvedDir, lesson));
   }
-  if (manifest.assessments) {
-    const assessmentIds = /* @__PURE__ */ new Set();
-    for (const ref of manifest.assessments) {
-      if (assessmentIds.has(ref.id)) {
-        issues.push({
-          path: "assessments",
-          message: `Duplicate assessment ID: ${ref.id}`,
-          severity: "error"
-        });
-      }
-      assessmentIds.add(ref.id);
-      const resolved = resolveCoursePath(resolvedDir, ref.file);
-      if (!resolved.ok) {
-        issues.push({
-          path: `assessments.${ref.id}.file`,
-          message: resolved.message,
-          severity: "error"
-        });
-        continue;
-      }
-      if (!existsSync(resolved.path)) {
-        issues.push({
-          path: `assessments.${ref.id}.file`,
-          message: `Assessment file not found: ${ref.file}`,
-          severity: "error"
-        });
-        continue;
-      }
-      const contained = assertResolvedPathContained(resolvedDir, resolved.path);
-      if (!contained.ok) {
-        issues.push({
-          path: `assessments.${ref.id}.file`,
-          message: contained.message,
-          severity: "error"
-        });
-        continue;
-      }
-      const assessmentStat = statSync(resolved.path);
-      if (!assessmentStat.isFile()) {
-        issues.push({
-          path: `assessments.${ref.id}.file`,
-          message: `Assessment path is not a file: ${ref.file}`,
-          severity: "error"
-        });
-        continue;
-      }
-      try {
-        const content = await readFile(resolved.path, "utf-8");
-        const raw = parseYaml(content);
-        const parsed = assessmentSchema.safeParse(raw);
-        if (!parsed.success) {
-          for (const issue of parsed.error.issues) {
-            const subPath = issue.path.length ? issue.path.join(".") : "root";
-            issues.push({
-              path: `${ref.file}:${subPath}`,
-              message: issue.message,
-              severity: "error"
-            });
-          }
-          continue;
-        }
-        if (parsed.data.id !== ref.id) {
-          issues.push({
-            path: `assessments.${ref.id}`,
-            message: `Assessment file id "${parsed.data.id}" does not match manifest ref id "${ref.id}"`,
-            severity: "error"
-          });
-        }
-      } catch (err) {
-        issues.push({
-          path: ref.file,
-          message: `Failed to parse assessment: ${formatErrorMessage(err)}`,
-          severity: "error"
-        });
-      }
-    }
-  }
-  const lessonIdCounts = /* @__PURE__ */ new Map();
-  for (const lesson of manifest.lessons) {
-    lessonIdCounts.set(lesson.id, (lessonIdCounts.get(lesson.id) ?? 0) + 1);
-  }
-  for (const [id, count] of lessonIdCounts) {
-    if (count > 1) {
+  const assessmentLoad = await loadParsedAssessments(resolvedDir, manifest);
+  issues.push(...assessmentLoad.issues);
+  issues.push(...validateActivityIds(manifest));
+  issues.push(...validateFlow(manifest));
+  if (manifest.flow?.length) {
+    for (const message of detectFlowCycles(manifest.flow)) {
       issues.push({
-        path: "lessons",
-        message: `Duplicate lesson ID: ${id}`,
+        path: "flow",
+        message,
         severity: "error"
       });
     }
   }
-  issues.push(...validateFlow(manifest));
-  if (manifest.variables) {
-    for (const [name, def] of Object.entries(manifest.variables)) {
-      const t = def.type;
-      if (t === "string" && typeof def.default !== "string") {
-        issues.push({
-          path: `variables.${name}.default`,
-          message: "Default must be a string when type is string",
-          severity: "error"
-        });
-      }
-      if (t === "number" && typeof def.default !== "number") {
-        issues.push({
-          path: `variables.${name}.default`,
-          message: "Default must be a number when type is number",
-          severity: "error"
-        });
-      }
-      if (t === "boolean" && typeof def.default !== "boolean") {
-        issues.push({
-          path: `variables.${name}.default`,
-          message: "Default must be a boolean when type is boolean",
-          severity: "error"
-        });
-      }
-    }
-  }
   return {
     valid: issues.filter((i) => i.severity === "error").length === 0,
     manifest,
-    issues
+    issues,
+    parsedAssessments: assessmentLoad.parsed
   };
 }
 
-// src/assessments.ts
-import { readFile as readFile2 } from "fs/promises";
-import { parse as parseYaml2 } from "yaml";
-function toLearnerAssessment(assessment) {
-  const answerKey = {};
-  const feedback = {};
-  const questions = assessment.questions.map((q) => {
-    const correct = q.choices.find((c) => c.correct === true);
-    if (correct) {
-      answerKey[q.id] = correct.id;
-    }
-    if (q.explanation) {
-      feedback[q.id] = q.explanation;
-    }
-    return {
-      id: q.id,
-      prompt: q.prompt,
-      choices: q.choices.map((c) => ({ id: c.id, text: c.text }))
-    };
-  });
-  return {
-    learner: {
-      id: assessment.id,
-      title: assessment.title,
-      passingScore: assessment.passingScore,
-      questions
-    },
-    answerKey,
-    config: {
-      maxAttempts: assessment.maxAttempts ?? 1,
-      shuffleChoices: assessment.shuffleChoices ?? false,
-      showFeedback: assessment.showFeedback ?? "never"
-    },
-    feedback
-  };
-}
-async function buildRuntimeAssessmentBundle(courseDir, manifest) {
-  const assessments = {};
-  const answerKeys = {};
-  const configs = {};
-  const feedback = {};
+// src/activities.ts
+function enumerateActivities(manifest) {
+  const activities = manifest.lessons.map((lesson) => ({
+    id: lesson.id,
+    title: lesson.title ?? lesson.id,
+    kind: "lesson"
+  }));
   for (const ref of manifest.assessments ?? []) {
-    const resolved = resolveCoursePath(courseDir, ref.file);
-    if (!resolved.ok) {
-      throw new Error(resolved.message);
-    }
-    const content = await readFile2(resolved.path, "utf-8");
-    const raw = parseYaml2(content);
-    const parsed = assessmentSchema.safeParse(raw);
-    if (!parsed.success) {
-      throw new Error(
-        `Invalid assessment ${ref.file}: ${parsed.error.issues.map((i) => i.message).join("; ")}`
-      );
-    }
-    if (parsed.data.id !== ref.id) {
-      throw new Error(
-        `Assessment file id "${parsed.data.id}" does not match manifest ref "${ref.id}"`
-      );
-    }
-    const built = toLearnerAssessment(parsed.data);
-    assessments[ref.id] = built.learner;
-    answerKeys[ref.id] = built.answerKey;
-    configs[ref.id] = built.config;
-    feedback[ref.id] = built.feedback;
+    activities.push({
+      id: ref.id,
+      title: ref.id.replace(/_/g, " "),
+      kind: "assessment"
+    });
   }
-  return { assessments, answerKeys, configs, feedback };
+  return activities;
+}
+
+// src/html.ts
+function escapeHtml(text) {
+  return text.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;");
 }
 export {
   BUILTIN_COMPONENT_IDS,
@@ -649,11 +754,15 @@ export {
   assessmentRefSchema,
   assessmentSchema,
   buildRuntimeAssessmentBundle,
+  buildRuntimeAssessmentBundleFromParsed,
   collectActivityIds,
+  collectAssessmentIds,
   componentLessonSchema,
   conditionSchema,
   courseManifestSchema,
   detectFlowCycles,
+  enumerateActivities,
+  escapeHtml,
   flowRuleSchema,
   formatErrorMessage,
   formatIssuePath,
@@ -662,6 +771,7 @@ export {
   isPathContained,
   lessonSchema,
   loadManifest,
+  loadParsedAssessments,
   markdownLessonSchema,
   resolveCoursePath,
   runtimeConfigSchema,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lxpack/validators",
-  "version": "0.2.0",
+  "version": "0.2.1",
   "description": "Course manifest validation for LXPack",
   "license": "Apache-2.0",
   "repository": {