@thanh01.pmt/curriculum-kit 1.0.0

package/dist/schemas/index.cjs

@@ -0,0 +1,1640 @@
+'use strict';
+
+var zod = require('zod');
+
+// src/schemas/index.ts
+var LearningObjectiveRowSchema = zod.z.object({
+  code: zod.z.string().describe('LO code, e.g. "LO1"'),
+  objective: zod.z.string().describe("Bloom-tagged learning objective"),
+  evidence: zod.z.string().describe("Observable student evidence / output"),
+  successCriteria: zod.z.string().describe("Measurable pass/fail condition"),
+  /**
+   * Standards anchors (Phase 1: optional). Format: "statementId" or
+   * "packId:statementId", e.g. "csta-k12-2017:1B-AP-10". IDs MUST exist in an
+   * adopted Framework Pack — the Standards Coverage Gate resolves and audits them.
+   */
+  standardRefs: zod.z.array(zod.z.string()).optional().default([]).describe("Anchoring standard statement IDs from adopted Framework Packs"),
+  /** Ontora knowledge-tree anchors, e.g. "ontora:WHILE_LOOP" (optional, Phase 1). */
+  conceptRefs: zod.z.array(zod.z.string()).optional().default([]).describe('Anchoring ontora concept codes, e.g. "ontora:FOR_LOOP"')
+});
+var ActivitySeqRowSchema = zod.z.object({
+  seq: zod.z.coerce.number().int(),
+  phase: zod.z.string().describe("EDP or 5E phase label"),
+  activityType: zod.z.string().describe('e.g. "Mini-lecture", "Brainstorming", "Hands-on Coding"'),
+  actor: zod.z.string().describe('"Teacher" | "Students" | "Teacher + Students"'),
+  purpose: zod.z.string().describe("Why this activity is done"),
+  studentAction: zod.z.string(),
+  teacherMove: zod.z.string(),
+  outputEvidence: zod.z.string(),
+  lo: zod.z.array(zod.z.string()).describe('e.g. ["LO1","LO2"]'),
+  durationMinutes: zod.z.coerce.number().default(10),
+  artifactContract: zod.z.string().describe('Satellite artifact(s) linked, e.g. "SLIDE_U03_M01_L13"')
+});
+var ResourceMapRowSchema = zod.z.object({
+  resourceType: zod.z.string().describe('"Slide Deck" | "Handout" | "Starter Code" | "Lab Tools" | etc.'),
+  identifier: zod.z.string(),
+  description: zod.z.string(),
+  location: zod.z.string().default("")
+});
+var AssessmentMapRowSchema = zod.z.object({
+  form: zod.z.string().describe('"Formative Checkpoint" | "Summative Assessment" | "Peer Feedback"'),
+  when: zod.z.string().describe("When in the sequence this is assessed"),
+  tool: zod.z.string().describe("Assessment tool or artifact used"),
+  criteria: zod.z.string(),
+  performanceLevels: zod.z.string().default(""),
+  remediationPath: zod.z.string().default("")
+});
+var ArtifactContractRowSchema = zod.z.object({
+  artifactId: zod.z.string(),
+  artifactType: zod.z.string(),
+  description: zod.z.string(),
+  requiredSections: zod.z.string().default(""),
+  format: zod.z.string().default(""),
+  owner: zod.z.string().default("")
+});
+var LessonFlowPhaseSchema = zod.z.object({
+  phase: zod.z.string().describe('Phase title, e.g. "ASK", "ENGAGE", "PLAN"'),
+  durationMinutes: zod.z.coerce.number(),
+  content: zod.z.string().describe("Full narrative content of this phase (teacher actions, student actions, code, outputs)")
+});
+var TroubleshootingRowSchema = zod.z.object({
+  issue: zod.z.string(),
+  potentialCause: zod.z.string(),
+  solution: zod.z.string()
+});
+var LessonBaseSchema = zod.z.object({
+  lessonId: zod.z.string(),
+  title: zod.z.string(),
+  language: zod.z.string().default("en"),
+  estimatedDuration: zod.z.string().describe('e.g. "90 minutes"'),
+  projectObjective: zod.z.string(),
+  materials: zod.z.string().default(""),
+  learningObjectives: zod.z.array(LearningObjectiveRowSchema).min(1),
+  activitySequence: zod.z.array(ActivitySeqRowSchema).min(1),
+  resourceMap: zod.z.array(ResourceMapRowSchema).default([]),
+  assessmentMap: zod.z.array(AssessmentMapRowSchema).default([]),
+  artifactContract: zod.z.array(ArtifactContractRowSchema).default([]),
+  lessonFlow: zod.z.array(LessonFlowPhaseSchema).min(1),
+  teacherNotes: zod.z.string().optional().default(""),
+  troubleshooting: zod.z.array(TroubleshootingRowSchema).default([])
+});
+var EDPPhaseEnum = zod.z.enum([
+  "Ask",
+  "Imagine",
+  "Plan",
+  "Create",
+  "Test & Improve",
+  "Share & Evaluate"
+]);
+var LessonPlanEDPSchema = LessonBaseSchema.extend({
+  artifactType: zod.z.literal("LESSON_EDP").default("LESSON_EDP")
+});
+var FiveEPhaseEnum = zod.z.enum([
+  "Engage",
+  "Explore",
+  "Explain",
+  "Elaborate",
+  "Evaluate"
+]);
+var FiveEFlowPhaseSchema = LessonFlowPhaseSchema.extend({
+  hookScenario: zod.z.string().optional().describe("Hook story/roleplay for Engage phase (5E-specific)"),
+  openQuestion: zod.z.string().optional().describe("Explicit guiding question posed to class"),
+  visualIllustration: zod.z.string().optional().describe("Mermaid diagram, code, or JSON snippet for Explain phase"),
+  tieredScaffolding: zod.z.object({
+    bronze: zod.z.string().default(""),
+    silver: zod.z.string().default(""),
+    gold: zod.z.string().default("")
+  }).optional(),
+  exitTicketQuestions: zod.z.array(zod.z.string()).optional()
+});
+var LessonPlan5ESchema = LessonBaseSchema.extend({
+  artifactType: zod.z.literal("LESSON_5E").default("LESSON_5E"),
+  lessonFlow: zod.z.array(FiveEFlowPhaseSchema).min(1),
+  keywords: zod.z.array(zod.z.string()).default([])
+}).omit({ lessonFlow: true }).extend({
+  lessonFlow: zod.z.array(FiveEFlowPhaseSchema).min(1)
+});
+var CoreConceptSchema = zod.z.object({
+  name: zod.z.string(),
+  analogy: zod.z.string().default(""),
+  technicalDepth: zod.z.string().default(""),
+  comparisonTable: zod.z.object({
+    headers: zod.z.array(zod.z.string()),
+    rows: zod.z.array(zod.z.array(zod.z.string()))
+  }).optional(),
+  formulaOrRule: zod.z.string().optional().default("")
+});
+var LessonSectionSchema = zod.z.object({
+  title: zod.z.string(),
+  durationMinutes: zod.z.coerce.number().default(15),
+  teacherActions: zod.z.string().default(""),
+  studentActions: zod.z.string().default(""),
+  analogies: zod.z.array(zod.z.string()).optional().default([]),
+  formativeCheck: zod.z.string().optional().default("")
+});
+var LessonPlanSchema = zod.z.object({
+  artifactType: zod.z.literal("LESSON").default("LESSON"),
+  lessonId: zod.z.string(),
+  title: zod.z.string(),
+  language: zod.z.string().default("vi"),
+  topic: zod.z.string().default("General Topic"),
+  targetGradeOrAudience: zod.z.string().default("Learners"),
+  overview: zod.z.string(),
+  learningObjectives: zod.z.array(zod.z.object({
+    code: zod.z.string().default("LO"),
+    name: zod.z.string().optional().default(""),
+    description: zod.z.string(),
+    bloomLevel: zod.z.string().default("understand"),
+    successCriteria: zod.z.string().optional().default("")
+  })).default([]),
+  prerequisites: zod.z.string().optional().default(""),
+  materialsSummary: zod.z.string().optional().default(""),
+  keywords: zod.z.array(zod.z.string()).optional().default([]),
+  hookTitle: zod.z.string().optional().default(""),
+  hookScenario: zod.z.string().default(""),
+  hookQuestions: zod.z.array(zod.z.string()).optional().default([]),
+  coreConcepts: zod.z.array(CoreConceptSchema).optional().default([]),
+  guidedPractice: zod.z.object({
+    title: zod.z.string().default(""),
+    explanation: zod.z.string().default(""),
+    codeSnippet: zod.z.string().default(""),
+    codeLanguage: zod.z.string().default("typescript"),
+    mermaidDiagram: zod.z.string().optional().default("")
+  }).optional(),
+  independentPractice: zod.z.object({
+    title: zod.z.string().default(""),
+    description: zod.z.string().default("")
+  }).optional(),
+  differentiation: zod.z.object({
+    bronzeTier: zod.z.string().default(""),
+    silverTier: zod.z.string().default(""),
+    goldTier: zod.z.string().default("")
+  }).default({ bronzeTier: "", silverTier: "", goldTier: "" }),
+  sections: zod.z.array(LessonSectionSchema).min(1),
+  exitTicket: zod.z.object({
+    questionStem: zod.z.string(),
+    expectedAnswerOrRubric: zod.z.string().default(""),
+    metacognitivePrompt: zod.z.string().default("")
+  }),
+  teacherNotes: zod.z.object({
+    commonPitfalls: zod.z.array(zod.z.string()).default([]),
+    troubleshootingMatrix: zod.z.array(TroubleshootingRowSchema).default([]),
+    extensionNotes: zod.z.string().optional().default("")
+  }).optional().default({ commonPitfalls: [], troubleshootingMatrix: [], extensionNotes: "" })
+});
+var ActivityStepSchema = zod.z.object({
+  stepNumber: zod.z.coerce.number().default(1),
+  title: zod.z.string().describe("Short descriptive title of this step"),
+  durationMinutes: zod.z.coerce.number().default(10).describe("Estimated duration for this step"),
+  teacherInstructions: zod.z.string().default("").describe("Guidance and checkpoint tips for the teacher"),
+  studentInstructions: zod.z.string().describe("Direct, clear, actionable step-by-step instructions for students"),
+  checkpoint: zod.z.string().optional().default("").describe("Clear observable checkpoint or success indicator for this step")
+});
+var ComputationalThinkingSchema = zod.z.object({
+  problemStatement: zod.z.string().describe("T\xECnh hu\u1ED1ng th\u1EF1c t\u1EBF \u0111\u1EA7y th\xE1ch th\u1EE9c c\u1EA7n gi\u1EA3i quy\u1EBFt"),
+  decomposition: zod.z.array(zod.z.string()).describe("C\xE1c b\u01B0\u1EDBc ph\xE2n r\xE3 b\xE0i to\xE1n l\u1EDBn th\xE0nh c\xE1c ph\u1EA7n nh\u1ECF"),
+  algorithmDesign: zod.z.string().describe("Thi\u1EBFt k\u1EBF lu\u1ED3ng thu\u1EADt to\xE1n v\xE0 x\u1EED l\xFD d\u1EEF li\u1EC7u tr\u01B0\u1EDBc khi code")
+});
+var ActiveLearningWorkflowSchema = zod.z.object({
+  phase1Planning: zod.z.object({
+    durationMinutes: zod.z.coerce.number().default(15),
+    studentTask: zod.z.string().describe("V\u1EBD s\u01A1 \u0111\u1ED3, thi\u1EBFt k\u1EBF lu\u1ED3ng tr\xEAn gi\u1EA5y/b\u1EA3ng tr\u01B0\u1EDBc khi g\xF5 ph\xEDm"),
+    teacherAction: zod.z.string().describe("Quan s\xE1t v\xE0 \u0111\u1EB7t c\xE2u h\u1ECFi g\u1EE3i m\u1EDF (Inquiry questions)"),
+    inquiryQuestions: zod.z.array(zod.z.string()).default([])
+  }),
+  phase2Implementation: zod.z.object({
+    durationMinutes: zod.z.coerce.number().default(40),
+    studentTask: zod.z.string().describe("Hi\u1EC7n th\u1EF1c h\xF3a gi\u1EA3i ph\xE1p qua code ho\u1EB7c l\u1EAFp r\xE1p ph\u1EA7n c\u1EE9ng"),
+    teacherAction: zod.z.string().describe("H\u1ED7 tr\u1EE3 khi h\u1ECDc sinh b\u1ECB t\u1EAFc > 5 ph\xFAt, tr\xE1nh l\xE0m h\u1ED9"),
+    codeOrCommands: zod.z.array(zod.z.string()).default([])
+  }),
+  phase3Debugging: zod.z.object({
+    durationMinutes: zod.z.coerce.number().default(15),
+    testingSteps: zod.z.string().describe("Quy tr\xECnh ch\u1EA1y th\u1EED nghi\u1EC7m v\xE0 ki\u1EC3m tra \u0111\u1EA7u ra"),
+    errorAnalysis: zod.z.string().describe("Ph\xE2n t\xEDch m\xE3 l\u1ED7i v\xE0 t\u1EF1 g\u1EE1 l\u1ED7i d\u1EF1a tr\xEAn b\u1EA3ng Troubleshooting")
+  })
+});
+var ActivityLabSchema = zod.z.object({
+  artifactType: zod.z.literal("ACT").default("ACT"),
+  lessonId: zod.z.string().describe("Matching lesson identifier"),
+  title: zod.z.string().describe("Activity title"),
+  language: zod.z.string().default("vi").describe('Language code of the content, e.g. "vi" or "en"'),
+  objective: zod.z.string().describe("Core hands-on objective of the activity"),
+  totalDurationMinutes: zod.z.coerce.number().default(60).describe("Total estimated duration of the activity"),
+  // 1. Computational Thinking Focus
+  computationalThinking: ComputationalThinkingSchema.optional(),
+  // 2. Bill of Materials (BOM)
+  materialsBOM: zod.z.object({
+    hardware: zod.z.array(zod.z.string()).default([]).describe("Hardware boards, components, sensors, or devices required (b\u1ECDc trong <!-- [HARDWARE_BOM] -->)"),
+    software: zod.z.array(zod.z.string()).default([]).describe("IDE, compilers, browser tools, libraries, or simulators required"),
+    consumables: zod.z.array(zod.z.string()).default([]).describe("Paper, pens, wires, or disposable items"),
+    otherResources: zod.z.array(zod.z.string()).default([]).describe("Worksheets, handouts, or reference links")
+  }),
+  // 3. Constraints & Safety
+  safetyWarnings: zod.z.array(zod.z.string()).default([]).describe("Essential safety cautions, electrical warnings, or common hazards"),
+  designConstraints: zod.z.array(zod.z.string()).default([]).describe("Design constraints to stimulate creative problem solving"),
+  teacherTips: zod.z.array(zod.z.string()).default([]).describe("Pedagogical facilitation tips, troubleshooting tricks"),
+  // 4. Workflow (Phases or Steps)
+  activeLearningWorkflow: ActiveLearningWorkflowSchema.optional(),
+  steps: zod.z.array(ActivityStepSchema).default([]).describe("Step-by-step procedure of the activity"),
+  // 5. Differentiation (3-Tier)
+  differentiation3Tier: zod.z.object({
+    bronzeTier: zod.z.string().default("").describe("Nhi\u1EC7m v\u1EE5 n\u1EC1n t\u1EA3ng c\u01A1 b\u1EA3n"),
+    silverTier: zod.z.string().default("").describe("Nhi\u1EC7m v\u1EE5 \u1EE9ng d\u1EE5ng logic n\xE2ng cao"),
+    goldTier: zod.z.string().default("").describe("Th\u1EED th\xE1ch s\xE1ng t\u1EA1o m\u1EDF r\u1ED9ng")
+  }).optional(),
+  scaffoldingSupport: zod.z.string().default("").describe("How to simplify for struggling students"),
+  levelUpExtension: zod.z.string().default("").describe("Extension task for students who finish early"),
+  // 6. Reflection
+  reflectionQuestion: zod.z.string().optional().default("").describe("C\xE2u h\u1ECFi ph\u1EA3n t\u01B0 k\xEDch th\xEDch t\u01B0 duy ph\u1EA3n bi\u1EC7n")
+});
+var CodeSnippetSchema = zod.z.object({
+  filename: zod.z.string().describe("Filename with extension, e.g. main.py, App.swift, solution.ts"),
+  language: zod.z.string().describe("Programming language identifier, e.g. python, swift, typescript, cpp"),
+  purpose: zod.z.enum(["starter", "solution", "test_runner", "scaffold"]).describe("Role of this code file"),
+  content: zod.z.string().describe("Complete, clean, runnable source code with standardized comments and docstrings"),
+  explanation: zod.z.string().default("").describe("Explanation of key algorithmic blocks and syntax nuances")
+});
+var LabTierTaskSchema = zod.z.object({
+  mins: zod.z.coerce.number().default(15),
+  objective: zod.z.string().describe("M\u1EE5c ti\xEAu c\u1EE7a t\u1EA7ng nhi\u1EC7m v\u1EE5"),
+  task: zod.z.string().describe("M\xF4 t\u1EA3 nhi\u1EC7m v\u1EE5 c\u1EE5 th\u1EC3"),
+  requirement: zod.z.string().describe("Ti\xEAu ch\xED ho\xE0n th\xE0nh b\u1EAFt bu\u1ED9c")
+});
+var CodeLabSchema = zod.z.object({
+  artifactType: zod.z.literal("CODE").default("CODE"),
+  lessonId: zod.z.string().describe("Matching lesson identifier"),
+  title: zod.z.string().describe("Code Lab title"),
+  language: zod.z.string().default("vi").describe('Language code for human explanations, e.g. "vi" or "en"'),
+  techStack: zod.z.array(zod.z.string()).default([]).describe('Technologies used, e.g. ["Python", "PyTorch"] or ["Swift", "SwiftUI"]'),
+  // 1. Environment & Setup
+  environmentSetup: zod.z.object({
+    languageFramework: zod.z.string().default(""),
+    ideEditor: zod.z.string().default(""),
+    requiredLibraries: zod.z.array(zod.z.string()).default([]),
+    hardwareOrEnvConnection: zod.z.string().optional().default("")
+  }).optional(),
+  // 2. 3-Tier Differentiation Tasks
+  threeTierTasks: zod.z.object({
+    bronze: LabTierTaskSchema,
+    silver: LabTierTaskSchema,
+    gold: LabTierTaskSchema
+  }).optional(),
+  // 3. Verified Runnable Code Snippets (bọc trong <!-- [SME_MANDATE] -->)
+  starterCode: CodeSnippetSchema.describe("Starter code provided to the learner with fill-in markers or skeletons"),
+  solutionCode: CodeSnippetSchema.describe("Complete verified reference solution code"),
+  testCases: zod.z.array(
+    zod.z.object({
+      description: zod.z.string().describe("What this test case verifies"),
+      input: zod.z.string().optional().default("").describe("Input or mock parameters"),
+      expectedOutput: zod.z.string().describe("Expected return value, output, or UI state")
+    })
+  ).default([]).describe("Automated verification tests or validation checks"),
+  // 4. Troubleshooting & Debugging Matrix
+  troubleshootingMatrix: zod.z.array(
+    zod.z.object({
+      issue: zod.z.string().describe("Hi\u1EC7n t\u01B0\u1EE3ng l\u1ED7i runtime/compile"),
+      potentialCause: zod.z.string().describe("Nguy\xEAn nh\xE2n ti\u1EC1m \u1EA9n"),
+      solution: zod.z.string().describe("Gi\u1EA3i ph\xE1p kh\u1EAFc ph\u1EE5c d\u1EE9t \u0111i\u1EC3m")
+    })
+  ).default([]),
+  commonBugsAndFixes: zod.z.array(
+    zod.z.object({
+      bugDescription: zod.z.string().describe("Common error message or logical pitfall"),
+      solutionHint: zod.z.string().describe("How to diagnose and fix it")
+    })
+  ).default([]),
+  // 5. Submission Checklist
+  submissionChecklist: zod.z.array(zod.z.string()).default([]).describe("Danh m\u1EE5c ki\u1EC3m tra ho\xE0n th\xE0nh n\u1ED9p b\xE0i")
+});
+var WorksheetItemTypeEnum = zod.z.enum([
+  "fill_blank",
+  // Fill in the blanks sentence/table
+  "multiple_choice",
+  // Select the correct option
+  "matching",
+  // Match left column to right column
+  "short_answer",
+  // Open-ended text response
+  "code_trace",
+  // Trace through code and write output
+  "diagram_fill",
+  // Complete a circuit/flow diagram
+  "true_false",
+  // True or False statement
+  "ordering"
+  // Arrange steps/phases in correct order
+]);
+var WorksheetItemSchema = zod.z.object({
+  itemNumber: zod.z.coerce.number().int().default(1),
+  itemType: WorksheetItemTypeEnum,
+  prompt: zod.z.string().describe("The question, fill-in stem, or task instruction"),
+  starterContent: zod.z.string().optional().describe(
+    "Pre-filled content: code with blanks, table skeleton, diagram description, or matching columns"
+  ),
+  options: zod.z.array(zod.z.string()).optional().describe("Options for multiple_choice / true_false items"),
+  answerKey: zod.z.string().optional().describe("Expected answer for teacher use"),
+  checkpointRequired: zod.z.boolean().default(false).describe(
+    "If true, student must get teacher sign-off before proceeding"
+  )
+});
+var WorksheetPartSchema = zod.z.object({
+  partNumber: zod.z.coerce.number().int(),
+  partTitle: zod.z.string().describe('e.g. "Knowledge Check", "Guided Practice", "Concept Tracing", "Reflection"'),
+  objective: zod.z.string().optional().default(""),
+  items: zod.z.array(WorksheetItemSchema).min(1),
+  checkpointInstruction: zod.z.string().optional().describe(
+    'Instruction shown at the end of this part, e.g. "\u2610 Ho\xE0n th\xE0nh Part 1 \u2014 Xin gi\xE1o vi\xEAn ki\u1EC3m tra"'
+  )
+});
+var WorksheetSchema = zod.z.object({
+  artifactType: zod.z.literal("WKS").default("WKS"),
+  lessonId: zod.z.string(),
+  title: zod.z.string(),
+  language: zod.z.string().default("en"),
+  // Student header fields
+  studentName: zod.z.string().optional().default(""),
+  classLabel: zod.z.string().optional().default(""),
+  // Main content: array of Parts (Part 1: Knowledge Check, Part 2: Guided Practice, etc.)
+  parts: zod.z.array(WorksheetPartSchema).min(1),
+  // Reflection / Computational Thinking prompts (Part 3 in template, standalone)
+  reflectionPrompts: zod.z.array(zod.z.string()).default([])
+});
+var HandoutSectionSchema = zod.z.object({
+  heading: zod.z.string().describe("Short descriptive section heading (Max 3 levels)"),
+  summaryPoints: zod.z.array(zod.z.string()).describe("Scannable bullet points in second-person voice (You will...)"),
+  codeSnippet: zod.z.string().optional().describe("Essential copy-paste ready syntax or command"),
+  tableData: zod.z.object({
+    headers: zod.z.array(zod.z.string()),
+    rows: zod.z.array(zod.z.array(zod.z.string()))
+  }).optional().describe("Structured table for comparisons or hardware pinouts"),
+  calloutBox: zod.z.object({
+    type: zod.z.string().default("key_formula"),
+    title: zod.z.string(),
+    content: zod.z.string()
+  }).optional()
+});
+var HandoutSchema = zod.z.object({
+  artifactType: zod.z.literal("HANDOUT").default("HANDOUT"),
+  lessonId: zod.z.string().describe("Matching lesson identifier"),
+  title: zod.z.string().describe("Handout title"),
+  language: zod.z.string().default("vi").describe('Language code of the content, e.g. "vi" or "en"'),
+  tagline: zod.z.string().default("").describe("1-sentence core takeaway"),
+  // 1. Core Concepts Summary
+  coreConceptsSummary: zod.z.array(
+    zod.z.object({
+      concept: zod.z.string().describe("T\xEAn kh\xE1i ni\u1EC7m"),
+      definition: zod.z.string().describe("\u0110\u1ECBnh ngh\u0129a ng\u1EAFn g\u1ECDn, chu\u1EA9n 5-second")
+    })
+  ).default([]),
+  // 2. Syntax & Configs Table
+  syntaxTable: zod.z.array(
+    zod.z.object({
+      syntax: zod.z.string().describe("C\xFA ph\xE1p l\u1EC7nh ho\u1EB7c t\xEAn Node/Config"),
+      meaning: zod.z.string().describe("\xDD ngh\u0129a & ch\u1EE9c n\u0103ng"),
+      example: zod.z.string().describe("V\xED d\u1EE5 code ho\u1EB7c c\u1EA5u h\xECnh m\u1EABu")
+    })
+  ).default([]),
+  // 3. General 3-Step Problem Solving Procedure
+  problemSolvingProcedure: zod.z.object({
+    step1Trigger: zod.z.string().default("X\xE1c \u0111\u1ECBnh input/trigger k\xEDch ho\u1EA1t"),
+    step2Logic: zod.z.string().default("X\u1EED l\xFD logic, t\xEDnh to\xE1n ho\u1EB7c l\u1ECDc d\u1EEF li\u1EC7u"),
+    step3Output: zod.z.string().default("Xu\u1EA5t k\u1EBFt qu\u1EA3, c\u1EADp nh\u1EADt tr\u1EA1ng th\xE1i ho\u1EB7c g\u1EEDi c\u1EA3nh b\xE1o")
+  }).optional().default({
+    step1Trigger: "X\xE1c \u0111\u1ECBnh input/trigger k\xEDch ho\u1EA1t",
+    step2Logic: "X\u1EED l\xFD logic, t\xEDnh to\xE1n ho\u1EB7c l\u1ECDc d\u1EEF li\u1EC7u",
+    step3Output: "Xu\u1EA5t k\u1EBFt qu\u1EA3, c\u1EADp nh\u1EADt tr\u1EA1ng th\xE1i ho\u1EB7c g\u1EEDi c\u1EA3nh b\xE1o"
+  }),
+  // 4. Pro Tips
+  proTips: zod.z.array(zod.z.string()).default([]).describe("M\u1EB9o th\u1EF1c chi\u1EBFn h\u1EEFu \xEDch"),
+  // 5. Sections & Glossary (Backward Compatibility)
+  sections: zod.z.array(HandoutSectionSchema).default([]).describe("Scannable reference sections"),
+  glossary: zod.z.array(
+    zod.z.object({
+      term: zod.z.string().describe("Technical term or acronym"),
+      definition: zod.z.string().describe("Plain, jargon-free explanation")
+    })
+  ).default([]).describe("Zero-jargon glossary of terms introduced in this lesson")
+});
+var MarpSlideSchema = zod.z.object({
+  slideNumber: zod.z.number().int().min(1).max(60),
+  slideType: zod.z.enum([
+    "title",
+    "agenda",
+    "review",
+    "hook",
+    "concept_def",
+    "concept_visual",
+    "concept_compare",
+    "concept_check",
+    "concept_recap",
+    "code_demo",
+    "guided_practice",
+    "activity_intro",
+    "activity_steps",
+    "checkpoint",
+    "exit_ticket",
+    "summary_next",
+    "custom"
+  ]),
+  title: zod.z.string().describe("Slide title or headline"),
+  bloomTag: zod.z.enum(["Remember", "Understand", "Apply", "Analyze", "Evaluate", "Create", "None"]).default("None"),
+  bulletPoints: zod.z.array(zod.z.string()).max(6).describe("Concise bullet points, max 15 words each"),
+  codeSnippet: zod.z.string().optional().describe("Formatted fenced code block for demo"),
+  diagramMermaid: zod.z.string().optional().describe("Mermaid diagram definition for visual concepts"),
+  presenterNotes: zod.z.string().optional().describe("Teacher speaker notes hidden in presentation mode")
+});
+var SlideDeckSchema = zod.z.object({
+  artifactType: zod.z.literal("SLIDE").default("SLIDE"),
+  lessonId: zod.z.string().describe("Matching lesson identifier"),
+  title: zod.z.string().describe("Presentation title"),
+  language: zod.z.string().describe('Language code of the content, e.g. "vi" or "en"'),
+  marpTheme: zod.z.string().default("gaia"),
+  slides: zod.z.array(MarpSlideSchema).min(6).max(60).describe("Sequential Marp slides scaled dynamically by knowledge volume")
+});
+var TeachingScriptPhaseSchema = zod.z.object({
+  phase: zod.z.string().describe(
+    'Phase label from GUIDE template: "Hook / Engage" | "Explore / Core Concepts" | "Elaborate / Hands-on Activity" | "Evaluate / Wrap-up"'
+  ),
+  durationRange: zod.z.string().describe('e.g. "5-10 minutes"'),
+  delivery: zod.z.string().describe("Real-world story, demo, analogy, or inquiry activity"),
+  keyPoints: zod.z.string().describe("What to emphasize; what to skip if running late"),
+  quickCheckQuestions: zod.z.array(zod.z.string()).default([]).describe("2-3 rapid comprehension check questions"),
+  classroomManagement: zod.z.string().optional().describe("Grouping, device management, seating"),
+  facilitation: zod.z.string().optional().describe("When to intervene vs. let students struggle productively"),
+  proTips: zod.z.string().optional().describe("Experience-based tips for this specific activity")
+});
+var MisconceptionSchema = zod.z.object({
+  misconception: zod.z.string().describe("What students often wrongly assume or confuse"),
+  counterStrategy: zod.z.string().describe("How the teacher should explain or demonstrate the truth")
+});
+var TroubleshootingEntrySchema = zod.z.object({
+  symptom: zod.z.string().describe("Error message or hardware failure symptom"),
+  rootCause: zod.z.string().describe("Why this occurs"),
+  solution: zod.z.string().describe("Exact step to fix it")
+});
+var ScoringRubricRowSchema = zod.z.object({
+  criteriaName: zod.z.string(),
+  meetsStandard: zod.z.string().describe("Description of acceptable student performance"),
+  exceedsStandard: zod.z.string().describe("Description of advanced mastery")
+});
+var TeacherGuideSchema = zod.z.object({
+  artifactType: zod.z.literal("GUIDE").default("GUIDE"),
+  lessonId: zod.z.string(),
+  title: zod.z.string(),
+  language: zod.z.string().default("en"),
+  // 1. Objectives & Preparation
+  pedagogicalRationale: zod.z.string().describe("The main instructional goal \u2014 mindset shift, not just knowledge"),
+  commonMisconceptions: zod.z.array(MisconceptionSchema).min(1),
+  technicalChecklist: zod.z.array(zod.z.string()).default([]).describe(
+    "Software/hardware to install; links to have open before class"
+  ),
+  // 2. Teaching Script & Progression
+  teachingScript: zod.z.array(TeachingScriptPhaseSchema).min(1).describe(
+    "Ordered phases: Hook/Engage \u2192 Explore/Core Concepts \u2192 Elaborate/Hands-on \u2192 Evaluate/Wrap-up"
+  ),
+  // 3. Troubleshooting & FAQs
+  troubleshootingGuide: zod.z.array(TroubleshootingEntrySchema).min(1),
+  // 4. Assessment & Differentiation
+  scoringRubric: zod.z.array(ScoringRubricRowSchema).default([]),
+  differentiationTips: zod.z.object({
+    proficient: zod.z.string().describe("Minimum threshold description for proficiency"),
+    advanced: zod.z.string().describe("Extension tasks / Peer mentoring opportunities"),
+    enrichmentQuestion: zod.z.string().optional().describe("1-2 deep-thinking questions for gifted students")
+  }).optional()
+});
+var ExtensionChallengeSchema = zod.z.object({
+  challengeNumber: zod.z.number().int().min(1),
+  title: zod.z.string().describe("Catchy title for the extension project"),
+  contextDescription: zod.z.string().describe("Novel real-world context for applying the skill"),
+  taskDescription: zod.z.string().describe("Specific goal and requirements of the challenge"),
+  expectedDeliverable: zod.z.string().describe("What the student produces (code, prototype, report)"),
+  hintOrGuidance: zod.z.string().optional().describe("Open-ended exploration prompt")
+});
+var ExtensionSchema = zod.z.object({
+  artifactType: zod.z.literal("EXT").default("EXT"),
+  lessonId: zod.z.string().describe("Matching lesson identifier"),
+  title: zod.z.string().describe("Extension title"),
+  language: zod.z.string().describe('Language code of the content, e.g. "vi" or "en"'),
+  coreLearningObjectivePreserved: zod.z.string().describe("The core LO that this challenge extends"),
+  challenges: zod.z.array(ExtensionChallengeSchema).min(2).describe("At least 2 diverse extension challenges")
+});
+var QualityAuditVerdictSchema = zod.z.enum(["PASS", "NEEDS_REVISION", "FAIL"]);
+var JudgeCriterionSchema = zod.z.object({
+  name: zod.z.string().describe("Criterion name, e.g. Bloom Alignment, Code Validity, Word Count Gate, Language Adherence"),
+  passed: zod.z.boolean(),
+  score: zod.z.number().min(0).max(100).describe("Score out of 100"),
+  feedback: zod.z.string().describe("Constructive feedback or citation of issues")
+});
+var CurriculumQualityReportSchema = zod.z.object({
+  targetArtifactType: zod.z.string().describe("Type of artifact audited, e.g. LESSON, ACT, CODE, WKS, SLIDE"),
+  lessonId: zod.z.string(),
+  overallVerdict: QualityAuditVerdictSchema,
+  totalScore: zod.z.number().min(0).max(100),
+  languageAdherencePassed: zod.z.boolean().describe("True if content strictly matches the requested target language"),
+  criteria: zod.z.array(JudgeCriterionSchema).min(3),
+  actionableRepairPrompts: zod.z.array(zod.z.string()).default([]).describe("Concrete instruction prompts to fix detected issues in the next repair turn")
+});
+var ProjectProfileSchema = zod.z.object({
+  id: zod.z.string().optional(),
+  name: zod.z.string(),
+  version: zod.z.string().optional(),
+  purpose: zod.z.string().optional(),
+  project_type: zod.z.string().optional(),
+  platform: zod.z.array(zod.z.string()).optional().default([]),
+  tech_stack: zod.z.union([zod.z.record(zod.z.array(zod.z.string())), zod.z.array(zod.z.string()), zod.z.record(zod.z.string())]).optional().default([]),
+  architecture: zod.z.array(zod.z.string()).optional().default([]),
+  source: zod.z.object({
+    repository: zod.z.string().optional(),
+    commit: zod.z.string().optional(),
+    scan_dir: zod.z.string().optional()
+  }).optional()
+});
+var ProductGoalSchema = zod.z.object({
+  id: zod.z.string(),
+  description: zod.z.string()
+});
+var UserJourneySchema = zod.z.object({
+  id: zod.z.string(),
+  name: zod.z.string(),
+  steps: zod.z.array(zod.z.string()).optional().default([]),
+  requirement_ids: zod.z.array(zod.z.string()).optional().default([])
+});
+var ProjectGraphSchema = zod.z.object({
+  schema_version: zod.z.number().optional().default(3),
+  project: ProjectProfileSchema,
+  product: zod.z.object({
+    goals: zod.z.array(ProductGoalSchema).optional().default([]),
+    users: zod.z.array(zod.z.any()).optional().default([]),
+    journeys: zod.z.array(UserJourneySchema).optional().default([]),
+    requirements: zod.z.array(zod.z.any()).optional().default([])
+  }).optional().default({}),
+  features: zod.z.array(zod.z.object({
+    id: zod.z.string().optional(),
+    name: zod.z.string().optional(),
+    description: zod.z.string().optional(),
+    components: zod.z.array(zod.z.string()).optional().default([]),
+    requirements: zod.z.array(zod.z.any()).optional().default([])
+  })).optional().default([]),
+  capabilities: zod.z.array(zod.z.any()).optional().default([]),
+  architecture: zod.z.any().optional(),
+  experience: zod.z.any().optional(),
+  data_integration: zod.z.any().optional(),
+  implementation: zod.z.object({
+    files: zod.z.array(zod.z.any()).optional().default([]),
+    symbols: zod.z.array(zod.z.any()).optional().default([]),
+    modules: zod.z.array(zod.z.any()).optional().default([])
+  }).optional().default({}),
+  validation: zod.z.any().optional(),
+  evidence: zod.z.any().optional()
+});
+var InstructionStepSchema = zod.z.object({
+  stepNumber: zod.z.string().default("1.1").describe('e.g. "1.1", "1.2"'),
+  actionTitle: zod.z.string().describe('Action verb title, e.g. "Create Bonjour Discovery Browser"'),
+  explanation: zod.z.string().describe("Explanation of why this action is performed and how it works"),
+  targetFile: zod.z.string().optional().default("").describe('Relative path of the target file being created or edited, e.g. "Sources/WledLib/Discovery/BonjourBrowser.swift"'),
+  codeSnippet: zod.z.string().optional().default("").describe("Complete or focused code snippet following grow-by-step or snippet-per-step style"),
+  codeLanguage: zod.z.string().optional().default("swift").describe('Language for syntax highlighting, e.g. "swift", "typescript", "cpp", "bash"'),
+  tip: zod.z.string().optional().default("").describe("Helpful operational tip or best practice"),
+  warning: zod.z.string().optional().default("").describe("Operational gotcha or critical warning"),
+  expectedResult: zod.z.string().default("").describe("Explicit observable output or success condition after completing this step"),
+  imagePlaceholder: zod.z.string().optional().default("").describe("Description of visual screenshot or diagram placeholder [IMAGE: ...]")
+});
+var InstructionSectionSchema = zod.z.object({
+  sectionNumber: zod.z.coerce.number().default(1),
+  title: zod.z.string().describe("Section title"),
+  goal: zod.z.string().describe("What the reader achieves in this section"),
+  estimatedMinutes: zod.z.coerce.number().default(15),
+  preflightChecks: zod.z.array(zod.z.string()).default([]).describe("Commands or conditions to check before starting this section"),
+  steps: zod.z.array(InstructionStepSchema).min(1),
+  rollbackOrCleanup: zod.z.string().optional().default("").describe("How to undo or reset state if something fails")
+});
+var ProjectInstructionSchema = zod.z.object({
+  artifactType: zod.z.literal("INSTRUCTION").default("INSTRUCTION"),
+  instructionId: zod.z.string().describe('Milestone or instruction ID, e.g. "F0-S1"'),
+  title: zod.z.string().describe("Tutorial title"),
+  language: zod.z.string().describe('Target language code, e.g. "vi" or "en"'),
+  difficulty: zod.z.string().default("intermediate"),
+  estimatedTotalMinutes: zod.z.coerce.number().default(45).describe("Total estimated duration in minutes"),
+  scopeMode: zod.z.string().default("milestone"),
+  milestoneRef: zod.z.string().optional().default("").describe("Milestone code or ID"),
+  featureRef: zod.z.string().optional().default("").describe("Feature ID or name"),
+  techStack: zod.z.array(zod.z.string()).default([]).describe("List of tools, SDKs, libraries"),
+  prerequisites: zod.z.array(zod.z.string()).default([]).describe("Prerequisites assumed before starting"),
+  materialsAndTools: zod.z.array(zod.z.string()).default([]).describe("Required software, SDKs, accounts, or simulators"),
+  sections: zod.z.array(InstructionSectionSchema).min(1),
+  verificationChecklist: zod.z.array(zod.z.string()).default([]).describe("Final end-to-end verification checklist to confirm working implementation")
+});
+var ProgressiveHintsSchema = zod.z.object({
+  hint1Concept: zod.z.string().describe("Level 1: G\u1EE3i \xFD \u0111\u1ECBnh h\u01B0\u1EDBng t\u01B0 duy / kh\xE1i ni\u1EC7m c\u1ED1t l\xF5i"),
+  hint2Skeleton: zod.z.string().describe("Level 2: Khung s\u01B0\u1EDDn code / method signature m\u1EABu"),
+  hint3Solution: zod.z.object({
+    code: zod.z.string().describe("Level 3: L\u1EDDi gi\u1EA3i code ho\xE0n ch\u1EC9nh 100% runnable"),
+    explanation: zod.z.string().describe("Ph\xE2n t\xEDch t\u1EA1i sao gi\u1EA3i ph\xE1p n\xE0y t\u1ED1i \u01B0u v\xE0 x\u1EED l\xFD \u0111\u01B0\u1EE3c v\u1EA5n \u0111\u1EC1")
+  })
+});
+var SelfPacedChallengeSchema = zod.z.object({
+  tier: zod.z.enum(["bronze", "silver", "gold"]),
+  title: zod.z.string().describe("T\xEAn th\u1EED th\xE1ch"),
+  estimatedMinutes: zod.z.coerce.number().default(15),
+  objective: zod.z.string().describe("M\u1EE5c ti\xEAu c\u1EE5 th\u1EC3 c\u1EE7a th\u1EED th\xE1ch"),
+  tasks: zod.z.array(zod.z.string()).describe("Danh s\xE1ch nhi\u1EC7m v\u1EE5 t\u1EEBng b\u01B0\u1EDBc c\u1EA7n l\xE0m"),
+  verifyCommand: zod.z.string().describe("L\u1EC7nh terminal ho\u1EB7c test runner \u0111\u1EC3 t\u1EF1 ki\u1EC3m ch\u1EE9ng (VD: curl... ho\u1EB7c swift test)"),
+  expectedOutput: zod.z.string().describe("K\u1EBFt qu\u1EA3 mong \u0111\u1EE3i hi\u1EC3n th\u1ECB tr\xEAn terminal khi ch\u1EA1y \u0111\xFAng"),
+  hints: ProgressiveHintsSchema
+});
+var SelfLabSchema = zod.z.object({
+  artifactType: zod.z.literal("SELF_LAB").default("SELF_LAB"),
+  labId: zod.z.string().describe("Identifier matching milestone (e.g. F0-S1)"),
+  title: zod.z.string().describe("Lab title"),
+  language: zod.z.string().default("vi").describe('Language code of content, e.g. "vi" or "en"'),
+  difficulty: zod.z.enum(["beginner", "intermediate", "advanced"]).default("intermediate"),
+  estimatedTotalMinutes: zod.z.coerce.number().default(60),
+  techStack: zod.z.array(zod.z.string()).default([]),
+  // Mission Briefing & Preflight
+  missionBriefing: zod.z.string().describe("B\u1ED1i c\u1EA3nh k\u1ECBch b\u1EA3n v\xE0 nhi\u1EC7m v\u1EE5 c\u1EE7a b\xE0i lab"),
+  preflightChecklist: zod.z.array(zod.z.string()).default([]).describe("Danh m\u1EE5c ki\u1EC3m tra m\xF4i tr\u01B0\u1EDDng tr\u01B0\u1EDBc khi b\u1EAFt \u0111\u1EA7u"),
+  // 3 Progressive Challenges (Bronze -> Silver -> Gold)
+  challenges: zod.z.object({
+    bronze: SelfPacedChallengeSchema,
+    silver: SelfPacedChallengeSchema,
+    gold: SelfPacedChallengeSchema
+  }),
+  // Troubleshooting Matrix
+  troubleshootingMatrix: zod.z.array(
+    zod.z.object({
+      symptom: zod.z.string().describe("Tri\u1EC7u ch\u1EE9ng ho\u1EB7c th\xF4ng b\xE1o l\u1ED7i"),
+      rootCause: zod.z.string().describe("Nguy\xEAn nh\xE2n g\u1ED1c r\u1EC5"),
+      exactFix: zod.z.string().describe("H\u01B0\u1EDBng d\u1EABn s\u1EEDa l\u1ED7i ch\xEDnh x\xE1c t\u1EEBng b\u01B0\u1EDBc")
+    })
+  ).default([]),
+  // Final Checklist
+  finalSubmissionChecklist: zod.z.array(zod.z.string()).default([]).describe("Danh m\u1EE5c ki\u1EC3m tra ho\xE0n th\xE0nh to\xE0n b\u1ED9 b\xE0i lab")
+});
+var AssessmentObjectiveSchema = zod.z.object({
+  aoCode: zod.z.string().describe('Assessment Objective code, e.g. "AO1"'),
+  alignedLO: zod.z.string().describe('Matched learning objective code, e.g. "LO1"'),
+  bloomLevel: zod.z.enum(["Remember", "Understand", "Apply", "Analyze", "Evaluate", "Create"]),
+  objective: zod.z.string().describe("Measurable assessment objective statement"),
+  /** Standards anchors: "statementId" or "packId:statementId" from adopted Framework Packs (Phase 1: optional). */
+  standardRefs: zod.z.array(zod.z.string()).optional().default([]).describe("Anchoring standard statement IDs from adopted Framework Packs")
+});
+var QuizOptionSchema = zod.z.object({
+  id: zod.z.string().describe('Option label: "A" | "B" | "C" | "D"'),
+  text: zod.z.string().describe("Full text of the option (may be a table row, code snippet, or sentence)"),
+  isCorrect: zod.z.boolean().describe("True if this option is the correct answer"),
+  explanation: zod.z.string().describe("Detailed distractor rationale or confirmation why this is correct/incorrect")
+});
+var DiagnosticQuestionSchema = zod.z.object({
+  id: zod.z.string().describe('Question ID, e.g. "Q1"'),
+  alignedAO: zod.z.string().optional().describe('Matched AO code(s), e.g. "AO1, AO2"'),
+  // Accept both PascalCase (new) and lowercase (legacy) for backward compat
+  bloomLevel: zod.z.enum([
+    "Remember",
+    "Understand",
+    "Apply",
+    "Analyze",
+    "Evaluate",
+    "Create",
+    "remember",
+    "understand",
+    "apply",
+    "analyze",
+    "evaluate",
+    "create"
+  ]).default("Apply"),
+  questionType: zod.z.enum(["multiple_choice", "code_analysis", "matching", "open_ended"]).default("multiple_choice"),
+  // scenarioOrStem: PRIMARY field — kept for backward compat with evaluators & serializers
+  scenarioOrStem: zod.z.string().optional().describe("Legacy combined field. Evaluators read this for stem analysis."),
+  // scenario + stem: richer decomposition for new content (both optional)
+  scenario: zod.z.string().optional().describe("Real-world context framing the question"),
+  stem: zod.z.string().optional().describe("The core question prompt (new authoring standard)"),
+  codeSnippet: zod.z.string().optional().describe("Code block for code analysis questions"),
+  codeLanguage: zod.z.string().optional().default("cpp"),
+  options: zod.z.array(QuizOptionSchema).min(2).max(6),
+  // correctAnswer: optional for backward compat with old fixtures (legacy used isCorrect on options)
+  correctAnswer: zod.z.string().optional().describe('Correct option id, e.g. "A"'),
+  teacherNote: zod.z.string().optional().describe("Pedagogical note for assessor/teacher only"),
+  // takeawayMessage: backward-compat alias for teacherNote
+  takeawayMessage: zod.z.string().optional().describe("@deprecated \u2014 use teacherNote. Kept for serializer backward compat.")
+});
+var CompetencyRubricRowSchema = zod.z.object({
+  competencyDimension: zod.z.string().describe('Competency label with linked LO, e.g. "C1: Hardware Integration (LO1)"'),
+  developing: zod.z.string().describe("Level 1 \u2014 does not meet standard"),
+  proficient: zod.z.string().describe("Level 2 \u2014 meets standard"),
+  advanced: zod.z.string().describe("Level 3 \u2014 exceeds standard"),
+  exemplary: zod.z.string().describe("Level 4 \u2014 outstanding mastery")
+});
+var DiagnosticQuizSchema = zod.z.object({
+  artifactType: zod.z.literal("QUIZ"),
+  quizId: zod.z.string().describe('Matching artifact identifier, e.g. "QUIZ_U03_M01_L13"'),
+  title: zod.z.string(),
+  language: zod.z.string().default("en").describe('"en" or "vi"'),
+  totalQuestions: zod.z.coerce.number().optional().default(5),
+  timeAllocationMinutes: zod.z.coerce.number().optional().default(15),
+  passingScorePct: zod.z.coerce.number().default(80),
+  // Assessment Objectives table (## [REQUIRED] Assessment Objectives)
+  assessmentObjectives: zod.z.array(AssessmentObjectiveSchema).optional().default([]),
+  // Question bank (## [REQUIRED] Multiple-Choice + ## [REQUIRED] Code Analysis)
+  questions: zod.z.array(DiagnosticQuestionSchema).min(1),
+  // Competency Rubric (## [REQUIRED] Competency Rubric)
+  rubric: zod.z.array(CompetencyRubricRowSchema).optional().default([])
+});
+var SelfPacedBundleSchema = zod.z.object({
+  bundleId: zod.z.string().describe("Milestone identifier (e.g. F0-S1)"),
+  title: zod.z.string().describe("Bundle title"),
+  language: zod.z.string().default("vi"),
+  techStack: zod.z.array(zod.z.string()).default([]),
+  instruction: ProjectInstructionSchema.describe("Instructable Step-by-Step Blueprint"),
+  selfLab: SelfLabSchema.describe("Self-Paced Lab with Progressive Hints & Verification Commands"),
+  quiz: DiagnosticQuizSchema.describe("Diagnostic Quiz Kit with Comprehensive Feedback"),
+  cheatSheet: HandoutSchema.describe("5-Second Rule Reference & Syntax Cheat Sheet"),
+  codeLab: CodeLabSchema.optional().describe("Code Lab with Starter & Solution Code")
+});
+var RubricCriteriaSchema = zod.z.object({
+  criteriaName: zod.z.string().describe('Criteria label, e.g. "Circuitry" or "Code Correctness"'),
+  weightPercent: zod.z.coerce.number().int().min(1).max(100).describe("Relative weight as integer %"),
+  excellent: zod.z.string().describe("Level 4 \u2014 Excellent performance descriptor"),
+  proficient: zod.z.string().describe("Level 3 \u2014 Proficient performance descriptor"),
+  developing: zod.z.string().describe("Level 2 \u2014 Developing performance descriptor"),
+  beginning: zod.z.string().describe("Level 1 \u2014 Beginning performance descriptor")
+});
+var ExitTicketQuickItemSchema = zod.z.object({
+  question: zod.z.string(),
+  questionType: zod.z.enum(["multiple_choice", "true_false", "short_answer", "open_ended"]),
+  answerOrScoringGuide: zod.z.string().default("")
+});
+var RubricSchema = zod.z.object({
+  artifactType: zod.z.literal("RUBRIC").default("RUBRIC"),
+  lessonId: zod.z.string(),
+  title: zod.z.string(),
+  language: zod.z.string().default("en"),
+  // Assessment Overview
+  assessmentType: zod.z.enum(["Formative", "Summative", "Self-assessment", "Peer-review"]),
+  assessmentFormat: zod.z.enum([
+    "Short Exercise",
+    "Exit Ticket",
+    "Practical Product",
+    "Project Presentation"
+  ]),
+  targetLOs: zod.z.array(zod.z.string()).describe('LO codes being assessed, e.g. ["LO1", "LO2"]'),
+  targetAudience: zod.z.enum(["Teachers", "Students"]).default("Teachers").describe(
+    '"Teachers" = technical/pedagogical language; "Students" = simple "I can..." language'
+  ),
+  // Rubric Table (weights should sum to ~100)
+  criteria: zod.z.array(RubricCriteriaSchema).min(1),
+  // Optional quick exit ticket at end of session (≤3 items)
+  exitTicket: zod.z.array(ExitTicketQuickItemSchema).max(3).optional(),
+  // Student self-assessment checklist
+  selfAssessmentChecklist: zod.z.array(zod.z.string()).optional(),
+  selfAssessmentReflection: zod.z.string().optional().describe(
+    'Open-ended reflection prompt, e.g. "One thing I am most proud of is:"'
+  )
+});
+var ExitTicketRecallPromptSchema = zod.z.object({
+  question: zod.z.string().describe("Conceptual scenario or analogy comparison testing core mental model"),
+  answerAreaLabel: zod.z.string().default("Write 1-2 concise sentences")
+});
+var ExitTicketBugHuntSchema = zod.z.object({
+  codeSnippet: zod.z.string().describe("4-8 line realistic code snippet containing exactly 1 bug/missing annotation"),
+  codeLanguage: zod.z.string().default("swift"),
+  tasks: zod.z.array(zod.z.string()).describe(
+    'Ordered task list, e.g. ["Identify the Compiler/Runtime Error", "Write the corrected line"]'
+  ),
+  expectedBugDescription: zod.z.string().describe("The exact error type/message students should identify"),
+  correctedLine: zod.z.string().describe("The single corrected line of code")
+});
+var ExitTicketMetacognitionSchema = zod.z.object({
+  options: zod.z.array(zod.z.object({
+    label: zod.z.string().describe('"\u{1F7E2} Green" | "\u{1F7E1} Yellow" | "\u{1F534} Red"'),
+    description: zod.z.string().describe('e.g. "I can build and explain to a peer without hints"')
+  })).default([
+    { label: "\u{1F7E2} Green (Mastered)", description: "I can build and explain this concept to a peer without any hints." },
+    { label: "\u{1F7E1} Yellow (Needs Practice)", description: "I understand the concept but got stuck on syntax or error messages." },
+    { label: "\u{1F534} Red (Blocked)", description: "I need help understanding why this architecture is used." }
+  ]),
+  lingeringQuestion: zod.z.string().default("What is one question you still have before leaving today's lab?")
+});
+var ExitTicketSchema = zod.z.object({
+  artifactType: zod.z.literal("EXIT_TICKET").default("EXIT_TICKET"),
+  lessonId: zod.z.string(),
+  title: zod.z.string(),
+  language: zod.z.string().default("en"),
+  estimatedMinutes: zod.z.coerce.number().default(7),
+  // Target Learning Objectives
+  targetLOs: zod.z.array(zod.z.object({
+    code: zod.z.string().describe('LO code, e.g. "ULO" or "LO1"'),
+    loType: zod.z.enum(["ULO", "CIO", "SIO"]).optional(),
+    description: zod.z.string()
+  })),
+  // Part 1: Recall & Conceptual Anchor
+  recallPrompt: ExitTicketRecallPromptSchema,
+  // Part 2: Application & Bug Hunt
+  applicationPrompt: ExitTicketBugHuntSchema,
+  // Part 3: Metacognitive Reflection
+  metacognition: ExitTicketMetacognitionSchema,
+  // Scoring & Intervention Trigger
+  scoringGuide: zod.z.object({
+    proficiencyThreshold: zod.z.string().describe('e.g. "Green/Yellow check + Correct Bug Hunt answer"'),
+    interventionProtocol: zod.z.string().describe('e.g. "If \u226525% Red, start next session with 5-min Live Debug Warm-up"')
+  })
+});
+var TierLevelEnum = zod.z.enum(["Bronze", "Silver", "Gold"]);
+var TierObjectiveSchema = zod.z.object({
+  tier: TierLevelEnum,
+  bloomTarget: zod.z.string().describe('e.g. "Remember / Understand" | "Apply / Analyze" | "Evaluate / Create"'),
+  scaffoldingRatio: zod.z.string().describe('e.g. "70% Starter Code / 30% Fill-in"'),
+  successCriteria: zod.z.string().describe("Condition that determines tier completion")
+});
+var BronzeTierSchema = zod.z.object({
+  targetAudience: zod.z.string().default("All learners (mandatory milestone)"),
+  guidingPrompt: zod.z.string().describe("Clear instruction with references to Handout"),
+  starterCode: zod.z.string().default("").describe("Pre-filled boilerplate code with TODO placeholders"),
+  codeLanguage: zod.z.string().default("swift"),
+  fillInSlots: zod.z.array(zod.z.object({
+    todoLabel: zod.z.string().describe('e.g. "TODO 1 [Bronze]"'),
+    instruction: zod.z.string()
+  })).default([]),
+  verificationTest: zod.z.string().default("testBronzeBaseline()")
+});
+var SilverTierSchema = zod.z.object({
+  targetAudience: zod.z.string().default("Learners who completed Bronze without mentor intervention"),
+  guidingPrompt: zod.z.string(),
+  requirements: zod.z.array(zod.z.string()).min(1).describe("Numbered requirements: validation, state logic, user feedback"),
+  implementationTarget: zod.z.string().default("").describe("Skeleton or description of what to implement"),
+  codeLanguage: zod.z.string().default("swift"),
+  verificationTest: zod.z.string().default("testSilverLogicAndValidation()")
+});
+var GoldTierSchema = zod.z.object({
+  targetAudience: zod.z.string().default("Advanced learners finished ahead of schedule"),
+  architecturalChallenge: zod.z.string().describe("Open-ended architectural task"),
+  constraints: zod.z.array(zod.z.string()).min(1).describe('Hard invariants, e.g. "zero data-race under concurrent mutations"'),
+  verificationTest: zod.z.string().optional().default("testGoldConcurrencySafety()")
+});
+var MentorCheatsheetSchema = zod.z.object({
+  bronzeStumble: zod.z.string().default("").describe("Most common Bronze mistake"),
+  silverStumble: zod.z.string().default("").describe("Most common Silver mistake"),
+  goldDiscussionPrompt: zod.z.string().optional().describe("Scaling / architecture discussion question")
+});
+var TieredPracticeSchema = zod.z.object({
+  artifactType: zod.z.literal("TIERED_PRACTICE").default("TIERED_PRACTICE"),
+  lessonId: zod.z.string(),
+  title: zod.z.string(),
+  language: zod.z.string().default("en"),
+  // Tier matrix overview
+  tierMatrix: zod.z.array(TierObjectiveSchema).length(3).describe("One entry per tier: Bronze, Silver, Gold"),
+  // Tier content
+  bronze: BronzeTierSchema,
+  silver: SilverTierSchema,
+  gold: GoldTierSchema,
+  // Test suite reference
+  testSuiteClass: zod.z.string().optional().describe('XCTest class name, e.g. "AlarmSystemTestSuite"'),
+  // Mentor hints
+  mentorCheatsheet: MentorCheatsheetSchema.optional()
+});
+var BellRingerDaySchema = zod.z.object({
+  dayLabel: zod.z.string().describe('e.g. "Day 1 (Monday)" or "Day 1"'),
+  bloomLevel: zod.z.enum([
+    "Remember",
+    "Understand",
+    "Apply",
+    "Analyze",
+    "Evaluate",
+    "Create"
+  ]).optional(),
+  promptType: zod.z.enum([
+    "mental_model_recall",
+    "code_tracing",
+    "bug_hunt",
+    "diagram_tracing",
+    "creative_synthesis",
+    "open_reflection"
+  ]).default("open_reflection"),
+  prompt: zod.z.string().describe("The warm-up question or task shown on projector"),
+  codeSnippet: zod.z.string().optional().describe("Code to trace or debug"),
+  codeLanguage: zod.z.string().optional().default("cpp"),
+  answerKey: zod.z.string().optional().describe("Teacher-facing expected answer or rubric note")
+});
+var BellRingerSchema = zod.z.object({
+  artifactType: zod.z.literal("BELL_RINGER"),
+  lessonId: zod.z.string(),
+  title: zod.z.string(),
+  language: zod.z.string().optional().default("en"),
+  weeklyTheme: zod.z.string().describe("Core concept theme for the week"),
+  routineProtocol: zod.z.string().optional().default(
+    "Display prompt on projector as students enter. Students write in Daily Journal before class discussion."
+  ),
+  days: zod.z.array(BellRingerDaySchema).min(1).max(7)
+});
+var GlossaryTermSchema = zod.z.object({
+  termName: zod.z.string().describe("Term in the target language"),
+  termNameEN: zod.z.string().optional().describe("English term (for code/docs reference)"),
+  bloomLevel: zod.z.enum(["Remember", "Understand", "Apply"]).optional(),
+  simpleDefinition: zod.z.string().describe("Max 2 sentences, age-appropriate, no jargon"),
+  memoryAnalogy: zod.z.string().describe('Analogy: "This term is like [familiar thing]..."'),
+  realWorldExample: zod.z.string().describe("1-3 line code snippet or 1-sentence real-world use case"),
+  codeLanguage: zod.z.string().optional().default(""),
+  commonMistake: zod.z.string().optional().describe("What students often confuse this with, and why"),
+  seeMore: zod.z.array(zod.z.string()).optional().default([]).describe("Related term names")
+});
+var GlossaryQuickRefRowSchema = zod.z.object({
+  termEN: zod.z.string(),
+  translation: zod.z.string().optional().default(""),
+  bloomLevel: zod.z.enum(["Remember", "Understand", "Apply"]).optional(),
+  mnemonicKeywords: zod.z.string().optional().default("")
+});
+var StandardizedTermRowSchema = zod.z.object({
+  technicalTerm: zod.z.string(),
+  note: zod.z.string(),
+  doNotUse: zod.z.string().optional().default("")
+});
+var GlossarySchema = zod.z.object({
+  artifactType: zod.z.literal("GLOSSARY"),
+  lessonId: zod.z.string(),
+  title: zod.z.string(),
+  language: zod.z.string().optional().default("en"),
+  terms: zod.z.array(GlossaryTermSchema).min(1).describe("Ordered from basic to advanced"),
+  quickReferenceTable: zod.z.array(GlossaryQuickRefRowSchema).optional().default([]),
+  standardizedTerms: zod.z.array(StandardizedTermRowSchema).optional().default([])
+});
+var ChoiceSquareSchema = zod.z.object({
+  squareNumber: zod.z.coerce.number().int().min(1).max(9),
+  squareLabel: zod.z.string().describe('e.g. "Square 1: The Bug Hunter"'),
+  category: zod.z.enum(["analytical", "visual_architecture", "creative_applied"]).optional(),
+  points: zod.z.coerce.number().int().default(30),
+  isCenterMaster: zod.z.boolean().default(false).describe("True for the mandatory center \u2B50 challenge"),
+  description: zod.z.string().describe("What the student must do"),
+  deliverable: zod.z.string().optional().describe('What to submit, e.g. "Pull Request diff + clean build"'),
+  acceptanceCriteria: zod.z.array(zod.z.string()).optional().default([]),
+  format: zod.z.string().optional().describe('Submission format, e.g. "Mermaid sequenceDiagram"')
+});
+var ChoiceRuleSchema = zod.z.object({
+  model: zod.z.enum(["tic_tac_toe", "point_balance", "custom"]).default("tic_tac_toe"),
+  description: zod.z.string().describe("How the student wins / completes the board"),
+  minimumPoints: zod.z.coerce.number().optional().describe("Minimum points for point_balance model"),
+  mandatoryCategories: zod.z.array(zod.z.string()).optional().default([])
+});
+var ChoiceBoardRubricRowSchema = zod.z.object({
+  criteriaName: zod.z.string(),
+  exemplary: zod.z.string(),
+  proficient: zod.z.string(),
+  developing: zod.z.string(),
+  beginning: zod.z.string()
+});
+var ChoiceBoardSchema = zod.z.object({
+  artifactType: zod.z.literal("CHOICE_BOARD"),
+  lessonId: zod.z.string(),
+  title: zod.z.string(),
+  language: zod.z.string().optional().default("en"),
+  coreConceptAnchor: zod.z.string().describe("All options must demonstrate mastery of this invariant"),
+  choiceRule: ChoiceRuleSchema,
+  squares: zod.z.array(ChoiceSquareSchema).min(1).max(9),
+  rubric: zod.z.array(ChoiceBoardRubricRowSchema).optional().default([])
+});
+var OrganizerTypeEnum = zod.z.enum([
+  "mermaid_flowchart",
+  // Architectural data flow (graph TD/LR)
+  "mermaid_sequence",
+  // Sequence / message flow diagram
+  "mermaid_state",
+  // State machine / lifecycle diagram
+  "mermaid_er",
+  // Entity-relationship diagram
+  "mermaid_class",
+  // Class / OOP diagram
+  "venn_comparison",
+  // Comparative analysis (2+ sets)
+  "fill_in_text",
+  // ASCII/text fill-in exercise
+  "concept_map"
+  // Node-link concept map (freeform)
+]);
+var GraphicOrganizerItemSchema = zod.z.object({
+  organizerNumber: zod.z.coerce.number().int(),
+  organizerTitle: zod.z.string().describe('e.g. "Architectural Data Flow" or "State Machine & Lifecycle"'),
+  organizerType: OrganizerTypeEnum,
+  mermaidCode: zod.z.string().optional().describe("Raw Mermaid.js diagram definition"),
+  fillInTemplate: zod.z.string().optional().describe("ASCII text fill-in box template"),
+  wordBank: zod.z.array(zod.z.string()).optional().default([]).describe("Word bank for fill-in exercises"),
+  cognitiveGoal: zod.z.string().optional().describe("Why this diagram helps (Paivio dual-coding, etc.)"),
+  requiredLabels: zod.z.array(zod.z.string()).optional().default([]).describe("Items students must correctly label")
+});
+var GraphicOrganizerSchema = zod.z.object({
+  artifactType: zod.z.literal("GRAPHIC_ORGANIZER"),
+  lessonId: zod.z.string(),
+  title: zod.z.string(),
+  language: zod.z.string().optional().default("en"),
+  cognitivePurpose: zod.z.string().optional().describe(
+    'Cognitive design rationale, e.g. "Dual-coding theory: spatial + verbal processing"'
+  ),
+  organizers: zod.z.array(GraphicOrganizerItemSchema).min(1)
+});
+var CERConclusionSchema = zod.z.object({
+  claim: zod.z.string().describe("Direct 1-sentence answer to the driving question"),
+  evidence: zod.z.string().describe("Specific quantitative data from the collection table"),
+  reasoning: zod.z.string().describe("Connection between evidence and the technical principle")
+});
+var ExperimentalDesignSchema = zod.z.object({
+  hypothesisTemplate: zod.z.string().describe(
+    '"If [action], then [predicted outcome] because [rationale]."'
+  ),
+  independentVariable: zod.z.string().describe("The variable being manipulated"),
+  dependentVariable: zod.z.string().describe("The variable being measured"),
+  controlVariables: zod.z.array(zod.z.string()).optional().default([]).describe("Constants held fixed")
+});
+var ScienceLabSchema = zod.z.object({
+  artifactType: zod.z.literal("SCIENCE_LAB"),
+  lessonId: zod.z.string(),
+  title: zod.z.string(),
+  language: zod.z.string().optional().default("en"),
+  domain: zod.z.string().optional().describe('e.g. "Software Engineering / Concurrency"'),
+  // Guiding Inquiry
+  drivingQuestion: zod.z.string().describe("Real-world engineering driving question"),
+  engineeringPhenomenon: zod.z.string().optional().describe("Observed phenomenon requiring explanation"),
+  // Hypothesis & Experimental Design
+  experimentalDesign: ExperimentalDesignSchema,
+  // Data Collection
+  labSetupCode: zod.z.string().optional().describe("Instrumentation / benchmark harness code"),
+  labSetupCodeLanguage: zod.z.string().optional().default("cpp"),
+  dataCollectionColumns: zod.z.array(zod.z.string()).optional().default([]).describe("Table column headers"),
+  trialCount: zod.z.coerce.number().optional().default(4),
+  // CER Conclusion
+  cerTemplates: CERConclusionSchema.optional().describe("Pre-filled example or rubric for CER"),
+  // Peer Review
+  peerReviewProtocol: zod.z.string().optional().describe(
+    "How groups exchange and verify each other's results"
+  ),
+  reproducibilityTolerancePct: zod.z.coerce.number().optional().default(10)
+});
+var StationTypeEnum = zod.z.enum([
+  "teacher_led",
+  // Station 1: Small-group guided inquiry with teacher
+  "pair_lab",
+  // Station 2: Collaborative hands-on pair programming
+  "digital_self_paced",
+  // Station 3: Independent async code lab / LMS
+  "offline_modeling",
+  // Station 4: No-screen diagram / whiteboard activity
+  "custom"
+]);
+var RotationStationSchema = zod.z.object({
+  stationNumber: zod.z.coerce.number().int(),
+  stationLabel: zod.z.string().describe('e.g. "Station 1: Teacher-Led (Guided Inquiry)"'),
+  stationType: StationTypeEnum,
+  goal: zod.z.string().describe("What students achieve at this station"),
+  durationMinutes: zod.z.coerce.number().optional().default(15),
+  teacherScriptOrInquiry: zod.z.string().optional().describe(
+    "Teacher talking points or inquiry prompts (for teacher_led station)"
+  ),
+  studentInstructions: zod.z.string().optional().describe("Step-by-step student task"),
+  materials: zod.z.array(zod.z.string()).optional().default([]),
+  successMilestone: zod.z.string().optional().describe("Observable completion criterion"),
+  differentiationTrigger: zod.z.string().optional().describe("What to do if students struggle")
+});
+var StationRecordRowSchema = zod.z.object({
+  stationNumber: zod.z.coerce.number().int(),
+  taskCompleted: zod.z.string(),
+  verificationMethod: zod.z.string().describe("Teacher stamp, peer signature, auto-token, etc."),
+  keyInsightPrompt: zod.z.string().optional().default("What did you learn at this station?")
+});
+var StationRotationSchema = zod.z.object({
+  artifactType: zod.z.literal("STATION_ROTATION"),
+  lessonId: zod.z.string(),
+  title: zod.z.string(),
+  language: zod.z.string().optional().default("en"),
+  totalDurationMinutes: zod.z.coerce.number().optional().default(60),
+  rotationDurationMinutes: zod.z.coerce.number().optional().default(15),
+  transitionBufferMinutes: zod.z.coerce.number().optional().default(2),
+  groupSize: zod.z.string().optional().default("4-6 students"),
+  groupingStrategy: zod.z.string().optional().default("Heterogeneous"),
+  stations: zod.z.array(RotationStationSchema).min(2),
+  recordingSheet: zod.z.array(StationRecordRowSchema).optional().default([])
+});
+var CardTierEnum = zod.z.enum(["bronze", "silver", "gold"]);
+var TaskCardSchema = zod.z.object({
+  cardId: zod.z.string().describe('e.g. "CARD_01"'),
+  cardNumber: zod.z.coerce.number().int(),
+  setLabel: zod.z.string().optional().describe(
+    'e.g. "Set A: Foundational Concepts" or "Set B: Code Diagnosis"'
+  ),
+  tier: CardTierEnum.optional().default("bronze"),
+  points: zod.z.coerce.number().int().optional().default(1),
+  category: zod.z.string().optional().describe(
+    'e.g. "Vocabulary", "Code Tracing", "Bug Hunt", "Architecture"'
+  ),
+  prompt: zod.z.string().describe("The task / question printed on the card"),
+  codeSnippet: zod.z.string().optional().describe("Code to trace or debug"),
+  codeLanguage: zod.z.string().optional().default("cpp"),
+  options: zod.z.array(zod.z.object({
+    id: zod.z.string(),
+    text: zod.z.string(),
+    isCorrect: zod.z.boolean().optional()
+  })).optional().default([]).describe("MCQ options (if applicable)"),
+  hint: zod.z.string().optional().describe("Student-facing hint"),
+  answerKey: zod.z.string().describe("Teacher-facing correct answer or solution blueprint"),
+  answerPoints: zod.z.coerce.number().int().optional().default(1)
+});
+var TaskCardsSchema = zod.z.object({
+  artifactType: zod.z.literal("TASK_CARDS"),
+  lessonId: zod.z.string(),
+  title: zod.z.string(),
+  language: zod.z.string().optional().default("en"),
+  targetSkills: zod.z.array(zod.z.string()).optional().default([]).describe(
+    'e.g. ["Conceptual Understanding", "Code Tracing", "Bug Hunting"]'
+  ),
+  cardFormat: zod.z.string().optional().default("4 cards per A4 page"),
+  scoringSystem: zod.z.string().optional().default(
+    "Bronze (1 pt), Silver (2 pts), Gold (3 pts)"
+  ),
+  cards: zod.z.array(TaskCardSchema).min(1)
+});
+var ReviewGameQuestionSchema = zod.z.object({
+  questionId: zod.z.string().optional(),
+  round: zod.z.coerce.number().int().min(1).max(3).describe("1=Speed, 2=Code Duel, 3=Final Boss"),
+  points: zod.z.coerce.number().int(),
+  category: zod.z.string().optional().describe('e.g. "Vocabulary & Syntax", "Mental Model"'),
+  prompt: zod.z.string().describe("The question or challenge shown to teams"),
+  codeSnippet: zod.z.string().optional(),
+  codeLanguage: zod.z.string().optional().default(""),
+  options: zod.z.array(zod.z.object({
+    id: zod.z.string(),
+    text: zod.z.string(),
+    isCorrect: zod.z.boolean().optional()
+  })).optional().default([]).describe("MCQ options for Round 1"),
+  answerOrExplanation: zod.z.string().describe("Correct answer or winning explanation"),
+  timeLimit: zod.z.coerce.number().optional().default(20).describe("Seconds"),
+  bonusMechanic: zod.z.string().optional().describe('e.g. "Teams can wager points"')
+});
+var ReviewGameExportRowSchema = zod.z.object({
+  question: zod.z.string(),
+  option1: zod.z.string(),
+  option2: zod.z.string(),
+  option3: zod.z.string().optional().default(""),
+  option4: zod.z.string().optional().default(""),
+  correctAnswer: zod.z.coerce.number().int().min(1).max(4).describe("1-indexed correct option"),
+  timeLimitSec: zod.z.coerce.number().optional().default(20)
+});
+var ReviewGameSchema = zod.z.object({
+  artifactType: zod.z.literal("REVIEW_GAME"),
+  lessonId: zod.z.string(),
+  title: zod.z.string(),
+  language: zod.z.string().optional().default("en"),
+  // Setup
+  format: zod.z.string().optional().default("3 rounds, progressive difficulty, team buzzers"),
+  teamSize: zod.z.string().optional().default("3-5 students"),
+  hasBonusWager: zod.z.boolean().optional().default(true).describe("Teams can wager points on Round 3"),
+  // Questions per round
+  questions: zod.z.array(ReviewGameQuestionSchema).min(1),
+  // Export-ready format for Kahoot / Quizizz
+  exportRows: zod.z.array(ReviewGameExportRowSchema).optional().default([])
+});
+var PrerequisiteDecisionSchema = zod.z.enum([
+  "mastered_before_course",
+  // entry-level knowledge — referenced, not taught
+  "taught_in_prior_lesson",
+  // formally taught in an earlier session
+  "recap_in_lesson",
+  // re-activated at the start of this session
+  "jit_introduce_in_lesson",
+  // introduced just-in-time inside this session
+  "scaffolded_provide"
+  // not taught — supplied ready-made (scaffold)
+]);
+var ScaffoldDecisionSchema = zod.z.enum([
+  "student_builds",
+  "provide_partial",
+  "provide_full",
+  "provide_reference"
+]);
+var DepthLevelSchema = zod.z.enum(["ulo", "cio", "sio"]);
+var BloomLevelSchema = zod.z.enum([
+  "Remember",
+  "Understand",
+  "Apply",
+  "Analyze",
+  "Evaluate",
+  "Create"
+]);
+var EntryLevelSchema = zod.z.enum(["beginner", "intermediate", "advanced"]);
+var NodeKindSchema = zod.z.enum(["skill", "concept", "product_step"]);
+var LessonCodeSchema = zod.z.string().regex(/^U\d{2}_M\d{2}_L\d{2}$/, "lesson code must match UXX_MYY_LZZ");
+var SourceCiteSchema = zod.z.object({
+  node_ids: zod.z.array(zod.z.string()).default([]),
+  concept_codes: zod.z.array(zod.z.string()).default([])
+});
+var CourseObjectiveSchema = zod.z.object({
+  id: zod.z.string(),
+  statement: zod.z.string().min(8),
+  bloom: BloomLevelSchema,
+  sources: SourceCiteSchema
+});
+var UnitPlanSchema = zod.z.object({
+  id: zod.z.string().regex(/^U\d{2}$/),
+  name: zod.z.string().min(3),
+  objectives: zod.z.array(CourseObjectiveSchema).min(1),
+  node_ids: zod.z.array(zod.z.string()).min(1),
+  total_minutes: zod.z.number().int().positive(),
+  rationale: zod.z.string().min(3),
+  // Phases fully contained in this unit (empty for non-phase plans)
+  phase_ids: zod.z.array(zod.z.string()).default([]),
+  // Product completion description carried from the domain analysis (optional)
+  product_completion: zod.z.string().default("")
+});
+var DepthAssignmentSchema = zod.z.object({
+  node_id: zod.z.string(),
+  depth: DepthLevelSchema,
+  source: zod.z.enum(["feed_hint", "planner", "escalated"])
+});
+var PrerequisiteDecisionEntrySchema = zod.z.object({
+  node_id: zod.z.string(),
+  decision: PrerequisiteDecisionSchema,
+  reason: zod.z.string().min(3)
+});
+var ScaffoldDecisionEntrySchema = zod.z.object({
+  item: zod.z.string().min(1),
+  decision: ScaffoldDecisionSchema,
+  minutes_saved: zod.z.number().int().nonnegative().default(0),
+  reason: zod.z.string().min(3)
+});
+var SessionPlanSchema = zod.z.object({
+  id: LessonCodeSchema,
+  unit_id: zod.z.string().regex(/^U\d{2}$/),
+  order: zod.z.number().int().positive(),
+  title: zod.z.string().min(3),
+  // [4] Free-text session objective — no ULO/CIO/SIO mapping at this stage.
+  prose_objective: zod.z.string().min(10),
+  node_ids: zod.z.array(zod.z.string()).min(1),
+  // Development phases this session contributes to (empty when the feed has no phases)
+  phase_ids: zod.z.array(zod.z.string()).default([]),
+  new_keywords: zod.z.array(zod.z.string()).default([]),
+  prerequisite_keywords: zod.z.array(zod.z.string()).default([]),
+  knowledge_minutes: zod.z.number().int().nonnegative(),
+  practice_minutes: zod.z.number().int().nonnegative(),
+  overhead_minutes: zod.z.number().int().nonnegative(),
+  depth_assignments: zod.z.array(DepthAssignmentSchema).min(1),
+  prerequisite_decisions: zod.z.array(PrerequisiteDecisionEntrySchema).default([]),
+  scaffold_decisions: zod.z.array(ScaffoldDecisionEntrySchema).default([]),
+  // What the student can demonstrate after this session — feeds exit tickets.
+  exit_evidence: zod.z.array(zod.z.string()).min(1),
+  differentiation: zod.z.object({ bronze: zod.z.string(), silver: zod.z.string(), gold: zod.z.string() })
+});
+var TranslationPolicySchema = zod.z.object({
+  policy: zod.z.enum(["after_artifact", "end_of_unit", "at_publish"]).default("at_publish"),
+  target_language: zod.z.string().nullable().default(null)
+});
+var CoverageReportSchema = zod.z.object({
+  assigned_node_ids: zod.z.array(zod.z.string()),
+  unassigned_node_ids: zod.z.array(zod.z.string()),
+  warnings: zod.z.array(zod.z.string())
+});
+var PlanConstraintsSchema = zod.z.object({
+  age_band: zod.z.tuple([zod.z.number().int(), zod.z.number().int()]),
+  entry_level: EntryLevelSchema,
+  session_duration_minutes: zod.z.number().int().positive(),
+  // Overhead (setup/recap/wrap-up) share of a session, 0..0.5.
+  overhead_ratio: zod.z.number().min(0).max(0.5).default(0.15),
+  total_sessions: zod.z.number().int().positive().nullable().default(null),
+  // Keywords the entry level already masters (drives mastered_before_course).
+  entry_keywords: zod.z.array(zod.z.string()).default([]),
+  course_goals: zod.z.array(zod.z.string()).default([]),
+  capstone: zod.z.string().nullable().default(null)
+});
+var CurriculumPlanSchema = zod.z.object({
+  schema_version: zod.z.literal(1),
+  plan_id: zod.z.string(),
+  plan_hash: zod.z.string(),
+  created_at: zod.z.string(),
+  source: zod.z.object({
+    graph_type: zod.z.enum(["curriculum_feed", "project_graph", "knowledge_graph", "hybrid_graph"]),
+    feed_schema_version: zod.z.number().nullable().default(null),
+    warnings: zod.z.array(zod.z.string()).default([]),
+    hallucination_count: zod.z.number().int().nonnegative().default(0)
+  }),
+  constraints: PlanConstraintsSchema,
+  course: zod.z.object({
+    // [1] Course-level objectives, each citing source nodes (anti-fabrication)
+    objectives: zod.z.array(CourseObjectiveSchema).min(1),
+    capstone_ref: zod.z.string().nullable().default(null)
+  }),
+  units: zod.z.array(UnitPlanSchema).min(1),
+  // [2]
+  sessions: zod.z.array(SessionPlanSchema).min(1),
+  // [3][4][5][6]
+  glossary_scope: zod.z.array(zod.z.object({
+    session_id: LessonCodeSchema,
+    terms: zod.z.array(zod.z.string())
+  })),
+  translation: TranslationPolicySchema,
+  coverage_report: CoverageReportSchema,
+  approval: zod.z.object({
+    status: zod.z.enum(["draft", "approved"]),
+    approved_at: zod.z.string().nullable().default(null),
+    // Hash of the plan payload the approval covers — invalidation key for EXPOSITION.
+    plan_hash: zod.z.string().nullable().default(null)
+  })
+});
+var PlanningNodeSchema = zod.z.object({
+  id: zod.z.string(),
+  kind: NodeKindSchema,
+  name: zod.z.string().min(1),
+  concept_codes: zod.z.array(zod.z.string()).default([]),
+  keywords: zod.z.array(zod.z.string()).default([]),
+  new_keywords: zod.z.array(zod.z.string()).default([]),
+  prerequisite_keywords: zod.z.array(zod.z.string()).default([]),
+  estimated_minutes: zod.z.number().int().nonnegative(),
+  bloom_hint: BloomLevelSchema.nullable().default(null),
+  depth_hint: DepthLevelSchema.nullable().default(null),
+  completion_level: zod.z.enum(["mvp", "standard", "stretch"]).default("standard"),
+  scaffold_candidates: zod.z.array(zod.z.object({
+    item: zod.z.string(),
+    reason: zod.z.string().default(""),
+    minutes_saved: zod.z.number().int().nonnegative().default(0),
+    suggest: ScaffoldDecisionSchema.default("provide_full")
+  })).default([]),
+  references: zod.z.array(zod.z.object({
+    file: zod.z.string(),
+    evidence: zod.z.string().default("")
+  })).default([]),
+  phase_id: zod.z.string().default("")
+});
+var DependencyEdgeSchema = zod.z.object({
+  from: zod.z.string(),
+  to: zod.z.string(),
+  kind: zod.z.enum(["knowledge", "task"]),
+  reason: zod.z.string().default("")
+});
+var PlanningGraphSchema = zod.z.object({
+  graph_type: zod.z.enum(["curriculum_feed", "project_graph", "knowledge_graph", "hybrid_graph"]),
+  warnings: zod.z.array(zod.z.string()).default([]),
+  hallucination_count: zod.z.number().int().nonnegative().default(0),
+  nodes: zod.z.array(PlanningNodeSchema).min(1, "planning graph must contain at least one node"),
+  edges: zod.z.array(DependencyEdgeSchema).default([]),
+  groupings: zod.z.array(zod.z.object({
+    id: zod.z.string(),
+    name: zod.z.string(),
+    node_ids: zod.z.array(zod.z.string()).min(1),
+    rationale: zod.z.string().default("")
+  })).default([]),
+  // Progressive completion phases (from CurriculumFeed.phases). When non-empty
+  // they define units and the teaching sequence; groupings stay informational.
+  phases: zod.z.array(zod.z.object({
+    id: zod.z.string(),
+    order: zod.z.number().int().positive(),
+    name: zod.z.string(),
+    product_completion: zod.z.string().default(""),
+    node_ids: zod.z.array(zod.z.string()).min(1)
+  })).default([])
+});
+var PlannerInputSchema = zod.z.object({
+  graph: zod.z.unknown(),
+  constraints: PlanConstraintsSchema,
+  translation: TranslationPolicySchema.default({ policy: "at_publish", target_language: null })
+});
+function validateCurriculumPlan(plan) {
+  const parsed = CurriculumPlanSchema.parse(plan);
+  for (const s of parsed.sessions) {
+    const total = s.knowledge_minutes + s.practice_minutes + s.overhead_minutes;
+    if (total > parsed.constraints.session_duration_minutes) {
+      throw new Error(
+        "Session " + s.id + " budget violated: " + total + " > " + parsed.constraints.session_duration_minutes + " minutes"
+      );
+    }
+  }
+  return parsed;
+}
+
+// src/schemas/index.ts
+var CurriculumArtifactSchema = zod.z.discriminatedUnion("artifactType", [
+  // ─── Lesson variants ───────────────────────────────────────────
+  LessonPlanSchema,
+  // 'LESSON'      — legacy (deprecated)
+  LessonPlanEDPSchema,
+  // 'LESSON_EDP'  — Engineering Design Process
+  LessonPlan5ESchema,
+  // 'LESSON_5E'   — 5E Instructional Model
+  // ─── Activity & Practice ───────────────────────────────────────
+  ActivityLabSchema,
+  // 'ACT'
+  TieredPracticeSchema,
+  // 'TIERED_PRACTICE'
+  BellRingerSchema,
+  // 'BELL_RINGER'
+  ChoiceBoardSchema,
+  // 'CHOICE_BOARD'
+  // ─── Code ─────────────────────────────────────────────────────
+  CodeLabSchema,
+  // 'CODE'
+  // ─── Assessment ───────────────────────────────────────────────
+  DiagnosticQuizSchema,
+  // 'QUIZ'
+  RubricSchema,
+  // 'RUBRIC'
+  ExitTicketSchema,
+  // 'EXIT_TICKET'
+  // ─── Student-facing resources ──────────────────────────────────
+  WorksheetSchema,
+  // 'WKS'
+  HandoutSchema,
+  // 'HANDOUT'
+  SlideDeckSchema,
+  // 'SLIDE'
+  TeacherGuideSchema,
+  // 'GUIDE'
+  ExtensionSchema,
+  // 'EXT'
+  GlossarySchema,
+  // 'GLOSSARY'
+  GraphicOrganizerSchema,
+  // 'GRAPHIC_ORGANIZER'
+  ScienceLabSchema,
+  // 'SCIENCE_LAB'
+  StationRotationSchema,
+  // 'STATION_ROTATION'
+  TaskCardsSchema,
+  // 'TASK_CARDS'
+  ReviewGameSchema
+  // 'REVIEW_GAME'
+]);
+var LearningObjectiveInputSchema = zod.z.object({
+  code: zod.z.string(),
+  name: zod.z.string(),
+  description: zod.z.string().optional().default(""),
+  lo_type: zod.z.enum(["UNIVERSAL", "CONCEPTUAL_IMPL", "SPECIFIC_IMPL", "ULO", "CIO", "SIO"]).or(zod.z.string()),
+  bloom_level: zod.z.string().optional().default("understand"),
+  knowledge_dimension: zod.z.string().optional().default("CONCEPTUAL"),
+  assessment: zod.z.string().optional().default("concept-check"),
+  keyword: zod.z.string().optional().default(""),
+  concept: zod.z.string().optional().default(""),
+  concept_code: zod.z.string().optional().default(""),
+  concept_name: zod.z.string().optional().default("")
+});
+var MilestoneInputSchema = zod.z.object({
+  id: zod.z.string().optional(),
+  name: zod.z.string(),
+  description: zod.z.string().optional().default(""),
+  feature_id: zod.z.string().optional().default("F0"),
+  feature_name: zod.z.string().optional().default(""),
+  concept_code: zod.z.string().optional().default(""),
+  concept_name: zod.z.string().optional().default(""),
+  completion_level: zod.z.string().optional().default("base"),
+  difficulty: zod.z.string().optional().default("Beginner"),
+  bloom_level: zod.z.string().optional().default("Understand"),
+  tech_keywords: zod.z.array(zod.z.string()).optional().default([]),
+  prerequisite_concept_codes: zod.z.array(zod.z.string()).optional().default([]),
+  all_keywords: zod.z.array(zod.z.string()).optional().default([]).describe("All keywords associated with this milestone (aggregated from concepts)"),
+  new_keywords: zod.z.array(zod.z.string()).optional().default([]).describe("Keywords introduced for the first time at this milestone"),
+  prerequisite_keywords: zod.z.array(zod.z.string()).optional().default([]).describe("Keywords already introduced in earlier milestones"),
+  learning_objectives: zod.z.array(LearningObjectiveInputSchema).optional().default([]),
+  rationale: zod.z.string().or(zod.z.array(zod.z.string())).optional().default(""),
+  instruction_ref: zod.z.string().optional(),
+  /** Canonical numeric grade band [min, max] for standards retrieval (Phase 2). */
+  grade_band: zod.z.tuple([zod.z.number().int(), zod.z.number().int()]).optional()
+});
+var PhaseInputSchema = zod.z.object({
+  phase_id: zod.z.number().or(zod.z.string()),
+  title: zod.z.string().optional(),
+  phase_name: zod.z.string().optional(),
+  description: zod.z.string().optional().default(""),
+  target_outcome: zod.z.string().optional(),
+  milestones: zod.z.array(MilestoneInputSchema).default([])
+});
+var RoadmapInputSchema = zod.z.object({
+  project_brief: zod.z.object({
+    name: zod.z.string().optional(),
+    title: zod.z.string().optional(),
+    goal: zod.z.string().optional(),
+    description: zod.z.string().optional().default(""),
+    tech_stack: zod.z.array(zod.z.string()).optional().default([]),
+    estimated_hours: zod.z.number().optional().default(0),
+    estimated_weeks: zod.z.number().optional().default(0),
+    target_learner: zod.z.string().optional(),
+    audience: zod.z.string().optional(),
+    icon: zod.z.string().optional()
+  }),
+  phases: zod.z.array(PhaseInputSchema).default([])
+});
+
+exports.ActiveLearningWorkflowSchema = ActiveLearningWorkflowSchema;
+exports.ActivityLabSchema = ActivityLabSchema;
+exports.ActivitySeqRowSchema = ActivitySeqRowSchema;
+exports.ActivityStepSchema = ActivityStepSchema;
+exports.ArtifactContractRowSchema = ArtifactContractRowSchema;
+exports.AssessmentMapRowSchema = AssessmentMapRowSchema;
+exports.AssessmentObjectiveSchema = AssessmentObjectiveSchema;
+exports.BellRingerDaySchema = BellRingerDaySchema;
+exports.BellRingerSchema = BellRingerSchema;
+exports.BloomLevelSchema = BloomLevelSchema;
+exports.BronzeTierSchema = BronzeTierSchema;
+exports.CERConclusionSchema = CERConclusionSchema;
+exports.CardTierEnum = CardTierEnum;
+exports.ChoiceBoardRubricRowSchema = ChoiceBoardRubricRowSchema;
+exports.ChoiceBoardSchema = ChoiceBoardSchema;
+exports.ChoiceRuleSchema = ChoiceRuleSchema;
+exports.ChoiceSquareSchema = ChoiceSquareSchema;
+exports.CodeLabSchema = CodeLabSchema;
+exports.CodeSnippetSchema = CodeSnippetSchema;
+exports.CompetencyRubricRowSchema = CompetencyRubricRowSchema;
+exports.ComputationalThinkingSchema = ComputationalThinkingSchema;
+exports.CoreConceptSchema = CoreConceptSchema;
+exports.CourseObjectiveSchema = CourseObjectiveSchema;
+exports.CoverageReportSchema = CoverageReportSchema;
+exports.CurriculumArtifactSchema = CurriculumArtifactSchema;
+exports.CurriculumPlanSchema = CurriculumPlanSchema;
+exports.CurriculumQualityReportSchema = CurriculumQualityReportSchema;
+exports.DependencyEdgeSchema = DependencyEdgeSchema;
+exports.DepthAssignmentSchema = DepthAssignmentSchema;
+exports.DepthLevelSchema = DepthLevelSchema;
+exports.DiagnosticQuestionSchema = DiagnosticQuestionSchema;
+exports.DiagnosticQuizSchema = DiagnosticQuizSchema;
+exports.EDPPhaseEnum = EDPPhaseEnum;
+exports.EntryLevelSchema = EntryLevelSchema;
+exports.ExitTicketBugHuntSchema = ExitTicketBugHuntSchema;
+exports.ExitTicketMetacognitionSchema = ExitTicketMetacognitionSchema;
+exports.ExitTicketQuickItemSchema = ExitTicketQuickItemSchema;
+exports.ExitTicketRecallPromptSchema = ExitTicketRecallPromptSchema;
+exports.ExitTicketSchema = ExitTicketSchema;
+exports.ExperimentalDesignSchema = ExperimentalDesignSchema;
+exports.ExtensionChallengeSchema = ExtensionChallengeSchema;
+exports.ExtensionSchema = ExtensionSchema;
+exports.FiveEFlowPhaseSchema = FiveEFlowPhaseSchema;
+exports.FiveEPhaseEnum = FiveEPhaseEnum;
+exports.GlossaryQuickRefRowSchema = GlossaryQuickRefRowSchema;
+exports.GlossarySchema = GlossarySchema;
+exports.GlossaryTermSchema = GlossaryTermSchema;
+exports.GoldTierSchema = GoldTierSchema;
+exports.GraphicOrganizerItemSchema = GraphicOrganizerItemSchema;
+exports.GraphicOrganizerSchema = GraphicOrganizerSchema;
+exports.HandoutSchema = HandoutSchema;
+exports.HandoutSectionSchema = HandoutSectionSchema;
+exports.InstructionSectionSchema = InstructionSectionSchema;
+exports.InstructionStepSchema = InstructionStepSchema;
+exports.JudgeCriterionSchema = JudgeCriterionSchema;
+exports.LabTierTaskSchema = LabTierTaskSchema;
+exports.LearningObjectiveInputSchema = LearningObjectiveInputSchema;
+exports.LearningObjectiveRowSchema = LearningObjectiveRowSchema;
+exports.LessonFlowPhaseSchema = LessonFlowPhaseSchema;
+exports.LessonPlan5ESchema = LessonPlan5ESchema;
+exports.LessonPlanEDPSchema = LessonPlanEDPSchema;
+exports.LessonPlanSchema = LessonPlanSchema;
+exports.LessonSectionSchema = LessonSectionSchema;
+exports.MarpSlideSchema = MarpSlideSchema;
+exports.MentorCheatsheetSchema = MentorCheatsheetSchema;
+exports.MilestoneInputSchema = MilestoneInputSchema;
+exports.MisconceptionSchema = MisconceptionSchema;
+exports.NodeKindSchema = NodeKindSchema;
+exports.OrganizerTypeEnum = OrganizerTypeEnum;
+exports.PhaseInputSchema = PhaseInputSchema;
+exports.PlanConstraintsSchema = PlanConstraintsSchema;
+exports.PlannerInputSchema = PlannerInputSchema;
+exports.PlanningGraphSchema = PlanningGraphSchema;
+exports.PlanningNodeSchema = PlanningNodeSchema;
+exports.PrerequisiteDecisionEntrySchema = PrerequisiteDecisionEntrySchema;
+exports.PrerequisiteDecisionSchema = PrerequisiteDecisionSchema;
+exports.ProductGoalSchema = ProductGoalSchema;
+exports.ProgressiveHintsSchema = ProgressiveHintsSchema;
+exports.ProjectGraphSchema = ProjectGraphSchema;
+exports.ProjectInstructionSchema = ProjectInstructionSchema;
+exports.ProjectProfileSchema = ProjectProfileSchema;
+exports.QualityAuditVerdictSchema = QualityAuditVerdictSchema;
+exports.QuizOptionSchema = QuizOptionSchema;
+exports.ResourceMapRowSchema = ResourceMapRowSchema;
+exports.ReviewGameExportRowSchema = ReviewGameExportRowSchema;
+exports.ReviewGameQuestionSchema = ReviewGameQuestionSchema;
+exports.ReviewGameSchema = ReviewGameSchema;
+exports.RoadmapInputSchema = RoadmapInputSchema;
+exports.RotationStationSchema = RotationStationSchema;
+exports.RubricCriteriaSchema = RubricCriteriaSchema;
+exports.RubricSchema = RubricSchema;
+exports.ScaffoldDecisionEntrySchema = ScaffoldDecisionEntrySchema;
+exports.ScaffoldDecisionSchema = ScaffoldDecisionSchema;
+exports.ScienceLabSchema = ScienceLabSchema;
+exports.ScoringRubricRowSchema = ScoringRubricRowSchema;
+exports.SelfLabSchema = SelfLabSchema;
+exports.SelfPacedBundleSchema = SelfPacedBundleSchema;
+exports.SelfPacedChallengeSchema = SelfPacedChallengeSchema;
+exports.SessionPlanSchema = SessionPlanSchema;
+exports.SilverTierSchema = SilverTierSchema;
+exports.SlideDeckSchema = SlideDeckSchema;
+exports.StandardizedTermRowSchema = StandardizedTermRowSchema;
+exports.StationRecordRowSchema = StationRecordRowSchema;
+exports.StationRotationSchema = StationRotationSchema;
+exports.StationTypeEnum = StationTypeEnum;
+exports.TaskCardSchema = TaskCardSchema;
+exports.TaskCardsSchema = TaskCardsSchema;
+exports.TeacherGuideSchema = TeacherGuideSchema;
+exports.TeachingScriptPhaseSchema = TeachingScriptPhaseSchema;
+exports.TierLevelEnum = TierLevelEnum;
+exports.TierObjectiveSchema = TierObjectiveSchema;
+exports.TieredPracticeSchema = TieredPracticeSchema;
+exports.TranslationPolicySchema = TranslationPolicySchema;
+exports.TroubleshootingEntrySchema = TroubleshootingEntrySchema;
+exports.TroubleshootingRowSchema = TroubleshootingRowSchema;
+exports.UnitPlanSchema = UnitPlanSchema;
+exports.UserJourneySchema = UserJourneySchema;
+exports.WorksheetItemSchema = WorksheetItemSchema;
+exports.WorksheetItemTypeEnum = WorksheetItemTypeEnum;
+exports.WorksheetPartSchema = WorksheetPartSchema;
+exports.WorksheetSchema = WorksheetSchema;
+exports.validateCurriculumPlan = validateCurriculumPlan;
+//# sourceMappingURL=index.cjs.map
+//# sourceMappingURL=index.cjs.map