@lxpack/validators 0.1.1 → 0.2.1

package/dist/index.js

@@ -1,81 +1,285 @@
 // src/schemas.ts
+import { z as z2 } from "zod";
+
+// src/conditions.ts
 import { z } from "zod";
-var choiceSchema = z.object({
-  id: z.string().min(1),
-  text: z.string().min(1),
-  correct: z.boolean().optional()
+var baseConditionSchema = z.union([
+  z.object({
+    variable: z.object({
+      eq: z.tuple([
+        z.string().min(1),
+        z.union([z.string(), z.number(), z.boolean()])
+      ])
+    })
+  }).strict(),
+  z.object({
+    assessment: z.object({
+      passed: z.string().min(1)
+    })
+  }).strict(),
+  z.object({
+    interaction: z.object({
+      done: z.string().min(1)
+    })
+  }).strict()
+]);
+var conditionSchema = z.lazy(
+  () => z.union([
+    ...baseConditionSchema.options,
+    z.object({ all: z.array(conditionSchema) }).strict(),
+    z.object({ any: z.array(conditionSchema) }).strict()
+  ])
+);
+var flowRuleSchema = z.object({
+  when: conditionSchema,
+  goto: z.string().min(1)
+}).strict();
+
+// src/schemas.ts
+var choiceSchema = z2.object({
+  id: z2.string().min(1),
+  text: z2.string().min(1),
+  correct: z2.boolean().optional()
 }).strict();
-var assessmentQuestionSchema = z.object({
-  id: z.string().min(1),
-  prompt: z.string().min(1),
-  choices: z.array(choiceSchema).min(1),
-  explanation: z.string().optional()
+var assessmentQuestionSchema = z2.object({
+  id: z2.string().min(1),
+  prompt: z2.string().min(1),
+  choices: z2.array(choiceSchema).min(1),
+  explanation: z2.string().optional()
 }).strict().superRefine((question, ctx) => {
   const correctCount = question.choices.filter((c) => c.correct === true).length;
   if (correctCount !== 1) {
     ctx.addIssue({
-      code: z.ZodIssueCode.custom,
+      code: z2.ZodIssueCode.custom,
       message: "Each question must have exactly one correct choice",
       path: ["choices"]
     });
   }
 });
-var markdownLessonSchema = z.object({
-  id: z.string().min(1),
-  type: z.literal("markdown"),
-  file: z.string().min(1),
-  title: z.string().optional()
+var markdownLessonSchema = z2.object({
+  id: z2.string().min(1),
+  type: z2.literal("markdown"),
+  file: z2.string().min(1),
+  title: z2.string().optional()
+}).strict();
+var htmlLessonSchema = z2.object({
+  id: z2.string().min(1),
+  type: z2.literal("html"),
+  path: z2.string().min(1),
+  title: z2.string().optional()
 }).strict();
-var htmlLessonSchema = z.object({
-  id: z.string().min(1),
-  type: z.literal("html"),
-  path: z.string().min(1),
-  title: z.string().optional()
+var componentLessonSchema = z2.object({
+  id: z2.string().min(1),
+  type: z2.literal("component"),
+  component: z2.string().min(1),
+  props: z2.record(z2.unknown()).optional(),
+  title: z2.string().optional()
 }).strict();
-var lessonSchema = z.discriminatedUnion("type", [
+var lessonSchema = z2.discriminatedUnion("type", [
   markdownLessonSchema,
-  htmlLessonSchema
+  htmlLessonSchema,
+  componentLessonSchema
 ]);
-var assessmentSchema = z.object({
-  id: z.string().min(1),
-  title: z.string().optional(),
-  passingScore: z.number().min(0).max(1).default(0.7),
-  questions: z.array(assessmentQuestionSchema).min(1)
+var showFeedbackSchema = z2.enum(["immediate", "end", "never"]).default("never");
+var assessmentSchema = z2.object({
+  id: z2.string().min(1),
+  title: z2.string().optional(),
+  passingScore: z2.number().min(0).max(1).default(0.7),
+  maxAttempts: z2.number().int().min(1).optional(),
+  shuffleChoices: z2.boolean().optional(),
+  showFeedback: showFeedbackSchema.optional(),
+  questions: z2.array(assessmentQuestionSchema).min(1)
 }).strict();
-var assessmentRefSchema = z.object({
-  id: z.string().min(1),
-  file: z.string().min(1)
+var assessmentRefSchema = z2.object({
+  id: z2.string().min(1),
+  file: z2.string().min(1)
 }).strict();
-var trackingSchema = z.object({
-  completion: z.object({
-    threshold: z.number().min(0).max(1).default(0.9)
+var variableDefSchema = z2.object({
+  default: z2.union([z2.string(), z2.number(), z2.boolean()]),
+  type: z2.enum(["string", "number", "boolean"]).optional()
+}).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)
   }).strict().optional()
 }).strict().optional();
-var runtimeConfigSchema = z.object({
-  theme: z.string().default("modern")
+var runtimeConfigSchema = z2.object({
+  theme: z2.string().default("modern")
 }).strict().optional();
-var courseManifestSchema = z.object({
-  title: z.string().min(1),
-  version: z.string().min(1),
-  description: z.string().optional(),
+var courseManifestSchema = z2.object({
+  title: z2.string().min(1),
+  version: z2.string().min(1),
+  description: z2.string().optional(),
   runtime: runtimeConfigSchema,
   tracking: trackingSchema,
-  lessons: z.array(lessonSchema).min(1),
-  assessments: z.array(assessmentRefSchema).optional()
+  variables: z2.record(variableDefSchema).optional(),
+  flow: z2.array(flowRuleSchema).optional(),
+  lessons: z2.array(lessonSchema).min(1),
+  assessments: z2.array(assessmentRefSchema).optional()
 }).strict();
 
-// src/validate.ts
-import { existsSync, realpathSync, statSync } from "fs";
-import { isAbsolute, join, relative, resolve } from "path";
-import { parse as parseYaml } from "yaml";
-import { readFile } from "fs/promises";
-function formatErrorMessage(err) {
-  return err instanceof Error ? err.message : String(err);
+// src/components.ts
+var BUILTIN_COMPONENT_IDS = [
+  "callout",
+  "image-card",
+  "checklist"
+];
+function isBuiltinComponentId(id) {
+  return BUILTIN_COMPONENT_IDS.includes(id);
 }
-function formatIssuePath(path) {
-  const joined = path.map(String).join(".");
-  return joined || "course.yaml";
+
+// src/flow-validate.ts
+function collectActivityIds(manifest) {
+  const ids = /* @__PURE__ */ new Set();
+  for (const lesson of manifest.lessons) {
+    ids.add(lesson.id);
+  }
+  for (const ref of manifest.assessments ?? []) {
+    ids.add(ref.id);
+  }
+  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]);
+  }
+  if ("assessment" in condition && condition.assessment?.passed) {
+    refs.assessments.add(condition.assessment.passed);
+  }
+  if ("interaction" in condition && condition.interaction?.done) {
+    refs.interactions.add(condition.interaction.done);
+  }
+  if ("all" in condition && condition.all) {
+    for (const c of condition.all) collectConditionRefs(c, refs);
+  }
+  if ("any" in condition && condition.any) {
+    for (const c of condition.any) collectConditionRefs(c, refs);
+  }
+}
+function validateFlow(manifest) {
+  const issues = [];
+  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}]`;
+    if (!activityIds.has(rule.goto)) {
+      issues.push({
+        path: `${path}.goto`,
+        message: `Unknown activity id: ${rule.goto}`,
+        severity: "error"
+      });
+    }
+    const refs = {
+      variables: /* @__PURE__ */ new Set(),
+      assessments: /* @__PURE__ */ new Set(),
+      interactions: /* @__PURE__ */ new Set()
+    };
+    collectConditionRefs(rule.when, refs);
+    for (const v of refs.variables) {
+      if (!manifestVars.has(v)) {
+        issues.push({
+          path: `${path}.when`,
+          message: `Unknown variable in condition: ${v}`,
+          severity: "error"
+        });
+      }
+    }
+    for (const a of refs.assessments) {
+      if (!assessmentIds.has(a)) {
+        issues.push({
+          path: `${path}.when`,
+          message: `Unknown assessment in condition: ${a}`,
+          severity: "error"
+        });
+      }
+    }
+    for (const i of refs.interactions) {
+      if (!activityIds.has(i)) {
+        issues.push({
+          path: `${path}.when`,
+          message: `Unknown interaction/lesson id in condition: ${i}`,
+          severity: "error"
+        });
+      }
+    }
+  });
+  return issues;
+}
+function detectFlowCycles(flow) {
+  const gotoOf = /* @__PURE__ */ new Map();
+  flow.forEach((rule, i) => gotoOf.set(i, rule.goto));
+  const errors = [];
+  const visited = /* @__PURE__ */ new Set();
+  for (let start = 0; start < flow.length; start++) {
+    if (visited.has(start)) continue;
+    const chain = /* @__PURE__ */ new Set();
+    let i = start;
+    while (i !== void 0 && i < flow.length) {
+      const ruleIndex = i;
+      if (chain.has(ruleIndex)) {
+        errors.push(`Flow rule cycle detected involving flow[${ruleIndex}]`);
+        break;
+      }
+      if (visited.has(ruleIndex)) break;
+      chain.add(ruleIndex);
+      visited.add(ruleIndex);
+      const target = gotoOf.get(ruleIndex);
+      const nextIdx = flow.findIndex(
+        (_, idx) => idx > ruleIndex && flow[idx].goto === target
+      );
+      i = nextIdx >= 0 ? nextIdx : void 0;
+    }
+  }
+  return errors;
 }
+
+// src/validate.ts
+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";
+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);
@@ -106,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",
@@ -120,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 [
       {
@@ -143,198 +696,24 @@ 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 === "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"
-          });
-        }
-      }
-    }
-  }
-  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);
+    issues.push(...lessonValidators[lesson.type](resolvedDir, lesson));
   }
-  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"
       });
     }
@@ -342,80 +721,64 @@ async function validateCourse(courseDir) {
   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 questions = assessment.questions.map((q) => {
-    const correct = q.choices.find((c) => c.correct === true);
-    if (correct) {
-      answerKey[q.id] = correct.id;
-    }
-    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
-  };
-}
-async function buildRuntimeAssessmentBundle(courseDir, manifest) {
-  const assessments = {};
-  const answerKeys = {};
+// 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 { learner, answerKey } = toLearnerAssessment(parsed.data);
-    assessments[ref.id] = learner;
-    answerKeys[ref.id] = answerKey;
+    activities.push({
+      id: ref.id,
+      title: ref.id.replace(/_/g, " "),
+      kind: "assessment"
+    });
   }
-  return { assessments, answerKeys };
+  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,
   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
+  validateCourse,
+  validateFlow,
+  variableDefSchema
 };