@contractspec/module.learning-journey 1.57.0 → 1.59.0

package/dist/browser/entities/index.js

@@ -0,0 +1,2136 @@
+// src/entities/ai.ts
+import {
+  defineEntity,
+  defineEntityEnum,
+  field,
+  index
+} from "@contractspec/lib.schema";
+var LearningStyleEnum = defineEntityEnum({
+  name: "LearningStyle",
+  values: ["VISUAL", "AUDITORY", "READING", "KINESTHETIC", "MIXED"],
+  schema: "lssm_learning",
+  description: "Preferred learning style."
+});
+var RecommendationTypeEnum = defineEntityEnum({
+  name: "RecommendationType",
+  values: [
+    "COURSE",
+    "LESSON",
+    "REVIEW",
+    "PRACTICE",
+    "ASSESSMENT",
+    "DECK"
+  ],
+  schema: "lssm_learning",
+  description: "Type of learning recommendation."
+});
+var LearnerProfileEntity = defineEntity({
+  name: "LearnerProfile",
+  description: "AI personalization profile for a learner.",
+  schema: "lssm_learning",
+  map: "learner_profile",
+  fields: {
+    id: field.id({ description: "Unique profile identifier" }),
+    learnerId: field.foreignKey({ description: "Learner" }),
+    learningStyle: field.enum("LearningStyle", {
+      default: "MIXED",
+      description: "Preferred learning style"
+    }),
+    preferredDifficulty: field.string({
+      default: '"adaptive"',
+      description: "Difficulty preference"
+    }),
+    preferredSessionLength: field.int({
+      default: 30,
+      description: "Preferred session length in minutes"
+    }),
+    interests: field.json({ isOptional: true, description: "Topic interests" }),
+    goals: field.json({ isOptional: true, description: "Learning goals" }),
+    pacePreference: field.string({
+      default: '"normal"',
+      description: "Learning pace: slow, normal, fast"
+    }),
+    bestTimeOfDay: field.string({
+      isOptional: true,
+      description: "Best time for learning"
+    }),
+    averageSessionLength: field.int({
+      isOptional: true,
+      description: "Average session length"
+    }),
+    daysActivePerWeek: field.int({
+      isOptional: true,
+      description: "Days active per week"
+    }),
+    avgQuizScore: field.int({
+      isOptional: true,
+      description: "Average quiz score"
+    }),
+    avgLessonCompletionTime: field.int({
+      isOptional: true,
+      description: "Avg lesson completion time"
+    }),
+    strengths: field.json({
+      isOptional: true,
+      description: "Identified strengths"
+    }),
+    weaknesses: field.json({
+      isOptional: true,
+      description: "Areas for improvement"
+    }),
+    lastAnalyzedAt: field.dateTime({
+      isOptional: true,
+      description: "Last AI analysis"
+    }),
+    metadata: field.json({
+      isOptional: true,
+      description: "Additional metadata"
+    }),
+    createdAt: field.createdAt(),
+    updatedAt: field.updatedAt(),
+    learner: field.belongsTo("Learner", ["learnerId"], ["id"], {
+      onDelete: "Cascade"
+    })
+  },
+  indexes: [
+    index.unique(["learnerId"], { name: "learner_profile_unique" }),
+    index.on(["learningStyle"])
+  ],
+  enums: [LearningStyleEnum]
+});
+var SkillMapEntity = defineEntity({
+  name: "SkillMap",
+  description: "Maps learner proficiency across skills.",
+  schema: "lssm_learning",
+  map: "skill_map",
+  fields: {
+    id: field.id({ description: "Unique skill map identifier" }),
+    learnerId: field.foreignKey({ description: "Learner" }),
+    skillId: field.string({ description: "Skill identifier" }),
+    skillName: field.string({ description: "Skill name" }),
+    skillCategory: field.string({
+      isOptional: true,
+      description: "Skill category"
+    }),
+    level: field.int({ default: 0, description: "Proficiency level (0-100)" }),
+    confidence: field.decimal({
+      default: 0.5,
+      description: "Confidence in assessment"
+    }),
+    lessonsCompleted: field.int({
+      default: 0,
+      description: "Related lessons completed"
+    }),
+    quizzesCompleted: field.int({
+      default: 0,
+      description: "Related quizzes completed"
+    }),
+    practiceTime: field.int({
+      default: 0,
+      description: "Practice time in minutes"
+    }),
+    lastPracticedAt: field.dateTime({
+      isOptional: true,
+      description: "Last practice time"
+    }),
+    learningVelocity: field.decimal({
+      isOptional: true,
+      description: "Learning speed for this skill"
+    }),
+    predictedTimeToMastery: field.int({
+      isOptional: true,
+      description: "Predicted time to mastery (minutes)"
+    }),
+    createdAt: field.createdAt(),
+    updatedAt: field.updatedAt(),
+    learner: field.belongsTo("Learner", ["learnerId"], ["id"], {
+      onDelete: "Cascade"
+    })
+  },
+  indexes: [
+    index.unique(["learnerId", "skillId"], { name: "skill_map_unique" }),
+    index.on(["skillId", "level"]),
+    index.on(["learnerId", "level"])
+  ]
+});
+var LearningPathEntity = defineEntity({
+  name: "LearningPath",
+  description: "AI-generated personalized learning path.",
+  schema: "lssm_learning",
+  map: "learning_path",
+  fields: {
+    id: field.id({ description: "Unique path identifier" }),
+    learnerId: field.foreignKey({ description: "Learner" }),
+    name: field.string({ description: "Path name" }),
+    description: field.string({
+      isOptional: true,
+      description: "Path description"
+    }),
+    goal: field.string({ isOptional: true, description: "Path goal" }),
+    steps: field.json({ description: "Ordered list of learning steps" }),
+    currentStepIndex: field.int({
+      default: 0,
+      description: "Current step index"
+    }),
+    progress: field.int({ default: 0, description: "Completion percentage" }),
+    completedSteps: field.int({ default: 0, description: "Steps completed" }),
+    totalSteps: field.int({ default: 0, description: "Total steps" }),
+    generatedAt: field.dateTime({ description: "When path was generated" }),
+    adaptedFrom: field.string({
+      isOptional: true,
+      description: "Original path ID if adapted"
+    }),
+    generationParams: field.json({
+      isOptional: true,
+      description: "AI generation parameters"
+    }),
+    adaptationHistory: field.json({
+      isOptional: true,
+      description: "Path adaptation history"
+    }),
+    isActive: field.boolean({
+      default: true,
+      description: "Whether path is active"
+    }),
+    isCompleted: field.boolean({
+      default: false,
+      description: "Whether path is completed"
+    }),
+    startedAt: field.dateTime({
+      isOptional: true,
+      description: "When started"
+    }),
+    completedAt: field.dateTime({
+      isOptional: true,
+      description: "When completed"
+    }),
+    estimatedCompletionDate: field.dateTime({
+      isOptional: true,
+      description: "Estimated completion"
+    }),
+    createdAt: field.createdAt(),
+    updatedAt: field.updatedAt(),
+    learner: field.belongsTo("Learner", ["learnerId"], ["id"], {
+      onDelete: "Cascade"
+    })
+  },
+  indexes: [index.on(["learnerId", "isActive"]), index.on(["generatedAt"])]
+});
+var RecommendationEntity = defineEntity({
+  name: "Recommendation",
+  description: "AI-powered learning recommendation.",
+  schema: "lssm_learning",
+  map: "recommendation",
+  fields: {
+    id: field.id({ description: "Unique recommendation identifier" }),
+    learnerId: field.foreignKey({ description: "Learner" }),
+    type: field.enum("RecommendationType", {
+      description: "Recommendation type"
+    }),
+    itemId: field.string({ description: "Recommended item ID" }),
+    itemType: field.string({
+      description: "Item type (course, lesson, deck, etc.)"
+    }),
+    score: field.decimal({ description: "Recommendation score (0-1)" }),
+    confidence: field.decimal({ description: "Confidence in recommendation" }),
+    reason: field.string({ description: "Human-readable reason" }),
+    factors: field.json({
+      isOptional: true,
+      description: "Factors that contributed to recommendation"
+    }),
+    status: field.string({
+      default: '"pending"',
+      description: "Status: pending, viewed, accepted, dismissed"
+    }),
+    viewedAt: field.dateTime({ isOptional: true, description: "When viewed" }),
+    acceptedAt: field.dateTime({
+      isOptional: true,
+      description: "When accepted"
+    }),
+    dismissedAt: field.dateTime({
+      isOptional: true,
+      description: "When dismissed"
+    }),
+    feedback: field.string({ isOptional: true, description: "User feedback" }),
+    feedbackRating: field.int({
+      isOptional: true,
+      description: "Feedback rating (1-5)"
+    }),
+    expiresAt: field.dateTime({
+      isOptional: true,
+      description: "When recommendation expires"
+    }),
+    createdAt: field.createdAt(),
+    updatedAt: field.updatedAt(),
+    learner: field.belongsTo("Learner", ["learnerId"], ["id"], {
+      onDelete: "Cascade"
+    })
+  },
+  indexes: [
+    index.on(["learnerId", "status", "score"]),
+    index.on(["type", "status"]),
+    index.on(["expiresAt"])
+  ],
+  enums: [RecommendationTypeEnum]
+});
+var LearningGapEntity = defineEntity({
+  name: "LearningGap",
+  description: "Identified learning gap.",
+  schema: "lssm_learning",
+  map: "learning_gap",
+  fields: {
+    id: field.id({ description: "Unique gap identifier" }),
+    learnerId: field.foreignKey({ description: "Learner" }),
+    skillId: field.string({ description: "Skill with gap" }),
+    skillName: field.string({ description: "Skill name" }),
+    severity: field.string({
+      default: '"moderate"',
+      description: "Gap severity: minor, moderate, major"
+    }),
+    confidence: field.decimal({ description: "Confidence in gap detection" }),
+    evidence: field.json({ isOptional: true, description: "Evidence for gap" }),
+    relatedQuestions: field.json({
+      isOptional: true,
+      description: "Questions that revealed gap"
+    }),
+    suggestedRemediation: field.json({
+      isOptional: true,
+      description: "Suggested remediation"
+    }),
+    remediationProgress: field.int({
+      default: 0,
+      description: "Remediation progress"
+    }),
+    status: field.string({
+      default: '"open"',
+      description: "Status: open, in_progress, resolved"
+    }),
+    resolvedAt: field.dateTime({
+      isOptional: true,
+      description: "When resolved"
+    }),
+    detectedAt: field.dateTime({ description: "When gap was detected" }),
+    createdAt: field.createdAt(),
+    updatedAt: field.updatedAt(),
+    learner: field.belongsTo("Learner", ["learnerId"], ["id"], {
+      onDelete: "Cascade"
+    })
+  },
+  indexes: [
+    index.on(["learnerId", "status"]),
+    index.on(["skillId", "status"]),
+    index.on(["severity", "status"])
+  ]
+});
+var aiEntities = [
+  LearnerProfileEntity,
+  SkillMapEntity,
+  LearningPathEntity,
+  RecommendationEntity,
+  LearningGapEntity
+];
+var aiEnums = [LearningStyleEnum, RecommendationTypeEnum];
+
+// src/entities/course.ts
+import {
+  defineEntity as defineEntity2,
+  defineEntityEnum as defineEntityEnum2,
+  field as field2,
+  index as index2
+} from "@contractspec/lib.schema";
+var CourseDifficultyEnum = defineEntityEnum2({
+  name: "CourseDifficulty",
+  values: ["BEGINNER", "INTERMEDIATE", "ADVANCED", "EXPERT"],
+  schema: "lssm_learning",
+  description: "Difficulty level of a course."
+});
+var CourseStatusEnum = defineEntityEnum2({
+  name: "CourseStatus",
+  values: ["DRAFT", "PUBLISHED", "ARCHIVED"],
+  schema: "lssm_learning",
+  description: "Publication status of a course."
+});
+var LessonTypeEnum = defineEntityEnum2({
+  name: "LessonType",
+  values: [
+    "CONTENT",
+    "VIDEO",
+    "INTERACTIVE",
+    "QUIZ",
+    "PRACTICE",
+    "PROJECT"
+  ],
+  schema: "lssm_learning",
+  description: "Type of lesson content."
+});
+var ContentTypeEnum = defineEntityEnum2({
+  name: "ContentType",
+  values: ["MARKDOWN", "VIDEO", "AUDIO", "EMBED", "SCORM", "CUSTOM"],
+  schema: "lssm_learning",
+  description: "Type of lesson content format."
+});
+var CourseEntity = defineEntity2({
+  name: "Course",
+  description: "A structured learning course.",
+  schema: "lssm_learning",
+  map: "course",
+  fields: {
+    id: field2.id({ description: "Unique course identifier" }),
+    title: field2.string({ description: "Course title" }),
+    slug: field2.string({ isUnique: true, description: "URL-friendly slug" }),
+    description: field2.string({
+      isOptional: true,
+      description: "Course description"
+    }),
+    summary: field2.string({ isOptional: true, description: "Short summary" }),
+    difficulty: field2.enum("CourseDifficulty", {
+      default: "BEGINNER",
+      description: "Difficulty level"
+    }),
+    category: field2.string({
+      isOptional: true,
+      description: "Course category"
+    }),
+    tags: field2.json({ isOptional: true, description: "Tags for discovery" }),
+    prerequisites: field2.json({
+      isOptional: true,
+      description: "Required course IDs"
+    }),
+    requiredSkills: field2.json({
+      isOptional: true,
+      description: "Required skill levels"
+    }),
+    estimatedDuration: field2.int({
+      isOptional: true,
+      description: "Estimated duration in minutes"
+    }),
+    thumbnailUrl: field2.string({
+      isOptional: true,
+      description: "Thumbnail image URL"
+    }),
+    coverImageUrl: field2.string({
+      isOptional: true,
+      description: "Cover image URL"
+    }),
+    promoVideoUrl: field2.string({
+      isOptional: true,
+      description: "Promo video URL"
+    }),
+    status: field2.enum("CourseStatus", {
+      default: "DRAFT",
+      description: "Publication status"
+    }),
+    publishedAt: field2.dateTime({
+      isOptional: true,
+      description: "When published"
+    }),
+    authorId: field2.string({ description: "Author user ID" }),
+    orgId: field2.string({
+      isOptional: true,
+      description: "Organization scope"
+    }),
+    isPublic: field2.boolean({
+      default: false,
+      description: "Whether course is publicly accessible"
+    }),
+    isFeatured: field2.boolean({
+      default: false,
+      description: "Whether course is featured"
+    }),
+    certificateEnabled: field2.boolean({
+      default: false,
+      description: "Award certificate on completion"
+    }),
+    metadata: field2.json({
+      isOptional: true,
+      description: "Additional metadata"
+    }),
+    createdAt: field2.createdAt(),
+    updatedAt: field2.updatedAt(),
+    modules: field2.hasMany("CourseModule"),
+    enrollments: field2.hasMany("Enrollment")
+  },
+  indexes: [
+    index2.on(["orgId", "status"]),
+    index2.on(["category"]),
+    index2.on(["difficulty"]),
+    index2.on(["authorId"])
+  ],
+  enums: [CourseDifficultyEnum, CourseStatusEnum]
+});
+var CourseModuleEntity = defineEntity2({
+  name: "CourseModule",
+  description: "A module (section) within a course.",
+  schema: "lssm_learning",
+  map: "course_module",
+  fields: {
+    id: field2.id({ description: "Unique module identifier" }),
+    courseId: field2.foreignKey({ description: "Parent course" }),
+    title: field2.string({ description: "Module title" }),
+    description: field2.string({
+      isOptional: true,
+      description: "Module description"
+    }),
+    order: field2.int({ default: 0, description: "Display order" }),
+    unlockCondition: field2.json({
+      isOptional: true,
+      description: "Conditions to unlock module"
+    }),
+    prerequisiteModuleIds: field2.json({
+      isOptional: true,
+      description: "Required modules to complete first"
+    }),
+    estimatedDuration: field2.int({
+      isOptional: true,
+      description: "Estimated duration in minutes"
+    }),
+    createdAt: field2.createdAt(),
+    updatedAt: field2.updatedAt(),
+    course: field2.belongsTo("Course", ["courseId"], ["id"], {
+      onDelete: "Cascade"
+    }),
+    lessons: field2.hasMany("Lesson"),
+    completions: field2.hasMany("ModuleCompletion")
+  },
+  indexes: [index2.on(["courseId", "order"])]
+});
+var LessonEntity = defineEntity2({
+  name: "Lesson",
+  description: "An individual lesson within a module.",
+  schema: "lssm_learning",
+  map: "lesson",
+  fields: {
+    id: field2.id({ description: "Unique lesson identifier" }),
+    moduleId: field2.foreignKey({ description: "Parent module" }),
+    title: field2.string({ description: "Lesson title" }),
+    description: field2.string({
+      isOptional: true,
+      description: "Lesson description"
+    }),
+    type: field2.enum("LessonType", {
+      default: "CONTENT",
+      description: "Lesson type"
+    }),
+    order: field2.int({ default: 0, description: "Display order" }),
+    estimatedDuration: field2.int({
+      isOptional: true,
+      description: "Estimated duration in minutes"
+    }),
+    xpReward: field2.int({
+      default: 10,
+      description: "XP awarded on completion"
+    }),
+    isFree: field2.boolean({
+      default: false,
+      description: "Whether lesson is free preview"
+    }),
+    isRequired: field2.boolean({
+      default: true,
+      description: "Whether lesson is required for completion"
+    }),
+    metadata: field2.json({
+      isOptional: true,
+      description: "Additional metadata"
+    }),
+    createdAt: field2.createdAt(),
+    updatedAt: field2.updatedAt(),
+    module: field2.belongsTo("CourseModule", ["moduleId"], ["id"], {
+      onDelete: "Cascade"
+    }),
+    contents: field2.hasMany("LessonContent"),
+    progress: field2.hasMany("LessonProgress"),
+    quizzes: field2.hasMany("Quiz")
+  },
+  indexes: [index2.on(["moduleId", "order"]), index2.on(["type"])],
+  enums: [LessonTypeEnum]
+});
+var LessonContentEntity = defineEntity2({
+  name: "LessonContent",
+  description: "Content block within a lesson.",
+  schema: "lssm_learning",
+  map: "lesson_content",
+  fields: {
+    id: field2.id({ description: "Unique content identifier" }),
+    lessonId: field2.foreignKey({ description: "Parent lesson" }),
+    contentType: field2.enum("ContentType", { description: "Content format" }),
+    content: field2.string({
+      isOptional: true,
+      description: "Text content (markdown, etc.)"
+    }),
+    mediaUrl: field2.string({
+      isOptional: true,
+      description: "Media URL for video/audio"
+    }),
+    embedData: field2.json({
+      isOptional: true,
+      description: "Embed data for external content"
+    }),
+    order: field2.int({ default: 0, description: "Display order" }),
+    duration: field2.int({
+      isOptional: true,
+      description: "Content duration in seconds"
+    }),
+    metadata: field2.json({
+      isOptional: true,
+      description: "Additional metadata"
+    }),
+    createdAt: field2.createdAt(),
+    updatedAt: field2.updatedAt(),
+    lesson: field2.belongsTo("Lesson", ["lessonId"], ["id"], {
+      onDelete: "Cascade"
+    })
+  },
+  indexes: [index2.on(["lessonId", "order"])],
+  enums: [ContentTypeEnum]
+});
+var courseEntities = [
+  CourseEntity,
+  CourseModuleEntity,
+  LessonEntity,
+  LessonContentEntity
+];
+var courseEnums = [
+  CourseDifficultyEnum,
+  CourseStatusEnum,
+  LessonTypeEnum,
+  ContentTypeEnum
+];
+
+// src/entities/flashcard.ts
+import {
+  defineEntity as defineEntity3,
+  defineEntityEnum as defineEntityEnum3,
+  field as field3,
+  index as index3
+} from "@contractspec/lib.schema";
+var CardRatingEnum = defineEntityEnum3({
+  name: "CardRating",
+  values: ["AGAIN", "HARD", "GOOD", "EASY"],
+  schema: "lssm_learning",
+  description: "Rating for a flashcard review."
+});
+var DeckEntity = defineEntity3({
+  name: "Deck",
+  description: "A collection of flashcards.",
+  schema: "lssm_learning",
+  map: "deck",
+  fields: {
+    id: field3.id({ description: "Unique deck identifier" }),
+    ownerId: field3.foreignKey({ description: "Deck owner (learner)" }),
+    title: field3.string({ description: "Deck title" }),
+    description: field3.string({
+      isOptional: true,
+      description: "Deck description"
+    }),
+    category: field3.string({ isOptional: true, description: "Deck category" }),
+    tags: field3.json({ isOptional: true, description: "Tags for discovery" }),
+    isPublic: field3.boolean({
+      default: false,
+      description: "Whether deck is publicly visible"
+    }),
+    cardCount: field3.int({ default: 0, description: "Number of cards" }),
+    coverImageUrl: field3.string({
+      isOptional: true,
+      description: "Cover image URL"
+    }),
+    orgId: field3.string({
+      isOptional: true,
+      description: "Organization scope"
+    }),
+    newCardsPerDay: field3.int({
+      default: 20,
+      description: "New cards to introduce per day"
+    }),
+    reviewsPerDay: field3.int({
+      default: 100,
+      description: "Maximum reviews per day"
+    }),
+    metadata: field3.json({
+      isOptional: true,
+      description: "Additional metadata"
+    }),
+    createdAt: field3.createdAt(),
+    updatedAt: field3.updatedAt(),
+    owner: field3.belongsTo("Learner", ["ownerId"], ["id"], {
+      onDelete: "Cascade"
+    }),
+    cards: field3.hasMany("Card")
+  },
+  indexes: [
+    index3.on(["ownerId"]),
+    index3.on(["isPublic", "category"]),
+    index3.on(["orgId"])
+  ]
+});
+var CardEntity = defineEntity3({
+  name: "Card",
+  description: "An individual flashcard.",
+  schema: "lssm_learning",
+  map: "card",
+  fields: {
+    id: field3.id({ description: "Unique card identifier" }),
+    deckId: field3.foreignKey({ description: "Parent deck" }),
+    front: field3.string({ description: "Front of card (question)" }),
+    back: field3.string({ description: "Back of card (answer)" }),
+    hints: field3.json({ isOptional: true, description: "Hints for the card" }),
+    explanation: field3.string({
+      isOptional: true,
+      description: "Detailed explanation"
+    }),
+    frontMediaUrl: field3.string({
+      isOptional: true,
+      description: "Media for front"
+    }),
+    backMediaUrl: field3.string({
+      isOptional: true,
+      description: "Media for back"
+    }),
+    audioUrl: field3.string({
+      isOptional: true,
+      description: "Audio pronunciation"
+    }),
+    tags: field3.json({ isOptional: true, description: "Card tags" }),
+    difficulty: field3.int({ default: 0, description: "Card difficulty (0-5)" }),
+    order: field3.int({ default: 0, description: "Card order in deck" }),
+    isSuspended: field3.boolean({
+      default: false,
+      description: "Whether card is suspended"
+    }),
+    metadata: field3.json({
+      isOptional: true,
+      description: "Additional metadata"
+    }),
+    createdAt: field3.createdAt(),
+    updatedAt: field3.updatedAt(),
+    deck: field3.belongsTo("Deck", ["deckId"], ["id"], { onDelete: "Cascade" }),
+    reviews: field3.hasMany("CardReview"),
+    schedules: field3.hasMany("CardSchedule")
+  },
+  indexes: [index3.on(["deckId", "order"]), index3.on(["isSuspended"])]
+});
+var CardReviewEntity = defineEntity3({
+  name: "CardReview",
+  description: "A single review of a flashcard.",
+  schema: "lssm_learning",
+  map: "card_review",
+  fields: {
+    id: field3.id({ description: "Unique review identifier" }),
+    learnerId: field3.foreignKey({ description: "Reviewer" }),
+    cardId: field3.foreignKey({ description: "Reviewed card" }),
+    rating: field3.enum("CardRating", { description: "Review rating" }),
+    responseTimeMs: field3.int({
+      isOptional: true,
+      description: "Time to respond in ms"
+    }),
+    intervalBefore: field3.int({ description: "Interval before review (days)" }),
+    easeFactorBefore: field3.decimal({
+      description: "Ease factor before review"
+    }),
+    intervalAfter: field3.int({ description: "Interval after review (days)" }),
+    easeFactorAfter: field3.decimal({ description: "Ease factor after review" }),
+    reviewType: field3.string({
+      default: '"review"',
+      description: "Type: new, learning, review, relearning"
+    }),
+    reviewedAt: field3.dateTime({ description: "When reviewed" }),
+    createdAt: field3.createdAt(),
+    learner: field3.belongsTo("Learner", ["learnerId"], ["id"], {
+      onDelete: "Cascade"
+    }),
+    card: field3.belongsTo("Card", ["cardId"], ["id"], { onDelete: "Cascade" })
+  },
+  indexes: [
+    index3.on(["learnerId", "reviewedAt"]),
+    index3.on(["cardId", "reviewedAt"]),
+    index3.on(["rating"])
+  ],
+  enums: [CardRatingEnum]
+});
+var CardScheduleEntity = defineEntity3({
+  name: "CardSchedule",
+  description: "SRS schedule for a learner/card pair.",
+  schema: "lssm_learning",
+  map: "card_schedule",
+  fields: {
+    id: field3.id({ description: "Unique schedule identifier" }),
+    learnerId: field3.foreignKey({ description: "Learner" }),
+    cardId: field3.foreignKey({ description: "Card" }),
+    interval: field3.int({
+      default: 0,
+      description: "Current interval in days"
+    }),
+    easeFactor: field3.decimal({
+      default: 2.5,
+      description: "Ease factor (SM-2)"
+    }),
+    repetitions: field3.int({
+      default: 0,
+      description: "Number of successful repetitions"
+    }),
+    nextReviewAt: field3.dateTime({ description: "When next review is due" }),
+    lastReviewAt: field3.dateTime({
+      isOptional: true,
+      description: "When last reviewed"
+    }),
+    learningStep: field3.int({
+      default: 0,
+      description: "Current learning step"
+    }),
+    isGraduated: field3.boolean({
+      default: false,
+      description: "Whether card has graduated"
+    }),
+    isRelearning: field3.boolean({
+      default: false,
+      description: "Whether card is being relearned"
+    }),
+    lapses: field3.int({
+      default: 0,
+      description: "Number of times card was forgotten"
+    }),
+    reviewCount: field3.int({ default: 0, description: "Total review count" }),
+    createdAt: field3.createdAt(),
+    updatedAt: field3.updatedAt(),
+    learner: field3.belongsTo("Learner", ["learnerId"], ["id"], {
+      onDelete: "Cascade"
+    }),
+    card: field3.belongsTo("Card", ["cardId"], ["id"], { onDelete: "Cascade" })
+  },
+  indexes: [
+    index3.unique(["learnerId", "cardId"], { name: "card_schedule_unique" }),
+    index3.on(["learnerId", "nextReviewAt"]),
+    index3.on(["nextReviewAt"])
+  ]
+});
+var flashcardEntities = [
+  DeckEntity,
+  CardEntity,
+  CardReviewEntity,
+  CardScheduleEntity
+];
+var flashcardEnums = [CardRatingEnum];
+
+// src/entities/gamification.ts
+import {
+  defineEntity as defineEntity4,
+  defineEntityEnum as defineEntityEnum4,
+  field as field4,
+  index as index4
+} from "@contractspec/lib.schema";
+var AchievementTypeEnum = defineEntityEnum4({
+  name: "AchievementType",
+  values: [
+    "MILESTONE",
+    "STREAK",
+    "SKILL",
+    "SOCIAL",
+    "SPECIAL",
+    "SEASONAL"
+  ],
+  schema: "lssm_learning",
+  description: "Type of achievement."
+});
+var LeaderboardPeriodEnum = defineEntityEnum4({
+  name: "LeaderboardPeriod",
+  values: ["DAILY", "WEEKLY", "MONTHLY", "ALL_TIME"],
+  schema: "lssm_learning",
+  description: "Leaderboard time period."
+});
+var AchievementEntity = defineEntity4({
+  name: "Achievement",
+  description: "An achievement that can be unlocked.",
+  schema: "lssm_learning",
+  map: "achievement",
+  fields: {
+    id: field4.id({ description: "Unique achievement identifier" }),
+    key: field4.string({ isUnique: true, description: "Achievement key" }),
+    name: field4.string({ description: "Achievement name" }),
+    description: field4.string({ description: "Achievement description" }),
+    icon: field4.string({ isOptional: true, description: "Icon name or URL" }),
+    color: field4.string({ isOptional: true, description: "Display color" }),
+    badgeUrl: field4.string({
+      isOptional: true,
+      description: "Badge image URL"
+    }),
+    type: field4.enum("AchievementType", {
+      default: "MILESTONE",
+      description: "Achievement type"
+    }),
+    category: field4.string({
+      isOptional: true,
+      description: "Achievement category"
+    }),
+    rarity: field4.string({
+      default: '"common"',
+      description: "Rarity: common, rare, epic, legendary"
+    }),
+    xpReward: field4.int({ default: 50, description: "XP awarded" }),
+    condition: field4.json({ description: "Unlock condition" }),
+    order: field4.int({ default: 0, description: "Display order" }),
+    isHidden: field4.boolean({
+      default: false,
+      description: "Hide until unlocked"
+    }),
+    isActive: field4.boolean({
+      default: true,
+      description: "Whether achievement is active"
+    }),
+    orgId: field4.string({
+      isOptional: true,
+      description: "Organization scope"
+    }),
+    metadata: field4.json({
+      isOptional: true,
+      description: "Additional metadata"
+    }),
+    createdAt: field4.createdAt(),
+    updatedAt: field4.updatedAt(),
+    learnerAchievements: field4.hasMany("LearnerAchievement")
+  },
+  indexes: [
+    index4.on(["type"]),
+    index4.on(["category"]),
+    index4.on(["isActive"]),
+    index4.on(["orgId"])
+  ],
+  enums: [AchievementTypeEnum]
+});
+var LearnerAchievementEntity = defineEntity4({
+  name: "LearnerAchievement",
+  description: "An achievement unlocked by a learner.",
+  schema: "lssm_learning",
+  map: "learner_achievement",
+  fields: {
+    id: field4.id({ description: "Unique record identifier" }),
+    learnerId: field4.foreignKey({ description: "Learner" }),
+    achievementId: field4.foreignKey({ description: "Achievement" }),
+    xpEarned: field4.int({ default: 0, description: "XP earned" }),
+    progress: field4.int({ default: 100, description: "Progress percentage" }),
+    currentValue: field4.int({
+      isOptional: true,
+      description: "Current value towards goal"
+    }),
+    targetValue: field4.int({
+      isOptional: true,
+      description: "Target value for completion"
+    }),
+    unlockedAt: field4.dateTime({ description: "When unlocked" }),
+    createdAt: field4.createdAt(),
+    learner: field4.belongsTo("Learner", ["learnerId"], ["id"], {
+      onDelete: "Cascade"
+    }),
+    achievement: field4.belongsTo("Achievement", ["achievementId"], ["id"], {
+      onDelete: "Cascade"
+    })
+  },
+  indexes: [
+    index4.unique(["learnerId", "achievementId"], {
+      name: "learner_achievement_unique"
+    }),
+    index4.on(["learnerId", "unlockedAt"]),
+    index4.on(["achievementId"])
+  ]
+});
+var StreakEntity = defineEntity4({
+  name: "Streak",
+  description: "Tracks daily learning streaks.",
+  schema: "lssm_learning",
+  map: "streak",
+  fields: {
+    id: field4.id({ description: "Unique streak identifier" }),
+    learnerId: field4.foreignKey({ description: "Learner" }),
+    currentStreak: field4.int({
+      default: 0,
+      description: "Current streak days"
+    }),
+    longestStreak: field4.int({
+      default: 0,
+      description: "Longest streak ever"
+    }),
+    lastActivityAt: field4.dateTime({
+      isOptional: true,
+      description: "Last learning activity"
+    }),
+    lastActivityDate: field4.string({
+      isOptional: true,
+      description: "Last activity date (YYYY-MM-DD)"
+    }),
+    freezesRemaining: field4.int({
+      default: 0,
+      description: "Streak freezes available"
+    }),
+    freezeUsedAt: field4.dateTime({
+      isOptional: true,
+      description: "When last freeze was used"
+    }),
+    streakHistory: field4.json({
+      isOptional: true,
+      description: "Historical streak data"
+    }),
+    createdAt: field4.createdAt(),
+    updatedAt: field4.updatedAt(),
+    learner: field4.belongsTo("Learner", ["learnerId"], ["id"], {
+      onDelete: "Cascade"
+    })
+  },
+  indexes: [
+    index4.unique(["learnerId"], { name: "streak_learner_unique" }),
+    index4.on(["currentStreak"]),
+    index4.on(["longestStreak"])
+  ]
+});
+var DailyGoalEntity = defineEntity4({
+  name: "DailyGoal",
+  description: "Daily XP goal tracking.",
+  schema: "lssm_learning",
+  map: "daily_goal",
+  fields: {
+    id: field4.id({ description: "Unique goal identifier" }),
+    learnerId: field4.foreignKey({ description: "Learner" }),
+    date: field4.string({ description: "Date (YYYY-MM-DD)" }),
+    targetXp: field4.int({ description: "Target XP for the day" }),
+    currentXp: field4.int({ default: 0, description: "XP earned today" }),
+    isCompleted: field4.boolean({
+      default: false,
+      description: "Whether goal was met"
+    }),
+    completedAt: field4.dateTime({
+      isOptional: true,
+      description: "When goal was completed"
+    }),
+    xpBreakdown: field4.json({
+      isOptional: true,
+      description: "XP sources breakdown"
+    }),
+    createdAt: field4.createdAt(),
+    updatedAt: field4.updatedAt(),
+    learner: field4.belongsTo("Learner", ["learnerId"], ["id"], {
+      onDelete: "Cascade"
+    })
+  },
+  indexes: [
+    index4.unique(["learnerId", "date"], { name: "daily_goal_unique" }),
+    index4.on(["date", "isCompleted"])
+  ]
+});
+var LeaderboardEntryEntity = defineEntity4({
+  name: "LeaderboardEntry",
+  description: "Leaderboard entry for a learner.",
+  schema: "lssm_learning",
+  map: "leaderboard_entry",
+  fields: {
+    id: field4.id({ description: "Unique entry identifier" }),
+    learnerId: field4.foreignKey({ description: "Learner" }),
+    periodType: field4.enum("LeaderboardPeriod", { description: "Period type" }),
+    periodKey: field4.string({ description: "Period key (e.g., 2024-W01)" }),
+    xp: field4.int({ default: 0, description: "XP earned in period" }),
+    rank: field4.int({ isOptional: true, description: "Rank in leaderboard" }),
+    lessonsCompleted: field4.int({
+      default: 0,
+      description: "Lessons completed"
+    }),
+    quizzesPassed: field4.int({ default: 0, description: "Quizzes passed" }),
+    cardsReviewed: field4.int({ default: 0, description: "Cards reviewed" }),
+    streakDays: field4.int({ default: 0, description: "Streak days in period" }),
+    league: field4.string({ isOptional: true, description: "League tier" }),
+    orgId: field4.string({
+      isOptional: true,
+      description: "Organization scope"
+    }),
+    createdAt: field4.createdAt(),
+    updatedAt: field4.updatedAt(),
+    learner: field4.belongsTo("Learner", ["learnerId"], ["id"], {
+      onDelete: "Cascade"
+    })
+  },
+  indexes: [
+    index4.unique(["learnerId", "periodType", "periodKey"], {
+      name: "leaderboard_entry_unique"
+    }),
+    index4.on(["periodType", "periodKey", "xp"]),
+    index4.on(["orgId", "periodType", "periodKey", "xp"])
+  ],
+  enums: [LeaderboardPeriodEnum]
+});
+var HeartEntity = defineEntity4({
+  name: "Heart",
+  description: "Lives/hearts system for quiz attempts.",
+  schema: "lssm_learning",
+  map: "heart",
+  fields: {
+    id: field4.id({ description: "Unique heart record identifier" }),
+    learnerId: field4.foreignKey({ description: "Learner" }),
+    current: field4.int({ default: 5, description: "Current hearts" }),
+    max: field4.int({ default: 5, description: "Maximum hearts" }),
+    lastRefillAt: field4.dateTime({
+      isOptional: true,
+      description: "Last refill time"
+    }),
+    nextRefillAt: field4.dateTime({
+      isOptional: true,
+      description: "Next refill time"
+    }),
+    refillIntervalMinutes: field4.int({
+      default: 240,
+      description: "Minutes between refills"
+    }),
+    infiniteUntil: field4.dateTime({
+      isOptional: true,
+      description: "Infinite hearts until"
+    }),
+    createdAt: field4.createdAt(),
+    updatedAt: field4.updatedAt(),
+    learner: field4.belongsTo("Learner", ["learnerId"], ["id"], {
+      onDelete: "Cascade"
+    })
+  },
+  indexes: [
+    index4.unique(["learnerId"], { name: "heart_learner_unique" }),
+    index4.on(["nextRefillAt"])
+  ]
+});
+var XPTransactionEntity = defineEntity4({
+  name: "XPTransaction",
+  description: "Record of XP earned or spent.",
+  schema: "lssm_learning",
+  map: "xp_transaction",
+  fields: {
+    id: field4.id({ description: "Unique transaction identifier" }),
+    learnerId: field4.foreignKey({ description: "Learner" }),
+    amount: field4.int({
+      description: "XP amount (positive = earned, negative = spent)"
+    }),
+    type: field4.string({
+      description: "Transaction type (lesson, quiz, streak, achievement, etc.)"
+    }),
+    sourceType: field4.string({
+      isOptional: true,
+      description: "Source entity type"
+    }),
+    sourceId: field4.string({
+      isOptional: true,
+      description: "Source entity ID"
+    }),
+    description: field4.string({
+      isOptional: true,
+      description: "Human-readable description"
+    }),
+    balanceAfter: field4.int({ description: "Total XP after transaction" }),
+    createdAt: field4.createdAt(),
+    learner: field4.belongsTo("Learner", ["learnerId"], ["id"], {
+      onDelete: "Cascade"
+    })
+  },
+  indexes: [
+    index4.on(["learnerId", "createdAt"]),
+    index4.on(["type"]),
+    index4.on(["sourceType", "sourceId"])
+  ]
+});
+var gamificationEntities = [
+  AchievementEntity,
+  LearnerAchievementEntity,
+  StreakEntity,
+  DailyGoalEntity,
+  LeaderboardEntryEntity,
+  HeartEntity,
+  XPTransactionEntity
+];
+var gamificationEnums = [AchievementTypeEnum, LeaderboardPeriodEnum];
+
+// src/entities/learner.ts
+import {
+  defineEntity as defineEntity5,
+  defineEntityEnum as defineEntityEnum5,
+  field as field5,
+  index as index5
+} from "@contractspec/lib.schema";
+var EnrollmentStatusEnum = defineEntityEnum5({
+  name: "EnrollmentStatus",
+  values: [
+    "ENROLLED",
+    "IN_PROGRESS",
+    "COMPLETED",
+    "DROPPED",
+    "EXPIRED"
+  ],
+  schema: "lssm_learning",
+  description: "Status of a course enrollment."
+});
+var ProgressStatusEnum = defineEntityEnum5({
+  name: "ProgressStatus",
+  values: ["NOT_STARTED", "IN_PROGRESS", "COMPLETED", "SKIPPED"],
+  schema: "lssm_learning",
+  description: "Status of lesson progress."
+});
+var LearnerEntity = defineEntity5({
+  name: "Learner",
+  description: "A learner profile.",
+  schema: "lssm_learning",
+  map: "learner",
+  fields: {
+    id: field5.id({ description: "Unique learner identifier" }),
+    userId: field5.string({ isUnique: true, description: "Associated user ID" }),
+    displayName: field5.string({
+      isOptional: true,
+      description: "Display name"
+    }),
+    avatarUrl: field5.string({ isOptional: true, description: "Avatar URL" }),
+    bio: field5.string({ isOptional: true, description: "Short bio" }),
+    level: field5.int({ default: 1, description: "Current level" }),
+    totalXp: field5.int({ default: 0, description: "Total XP earned" }),
+    currentStreak: field5.int({
+      default: 0,
+      description: "Current streak days"
+    }),
+    longestStreak: field5.int({
+      default: 0,
+      description: "Longest streak ever"
+    }),
+    lastActivityAt: field5.dateTime({
+      isOptional: true,
+      description: "Last learning activity"
+    }),
+    timezone: field5.string({
+      default: '"UTC"',
+      description: "Learner timezone"
+    }),
+    dailyGoalXp: field5.int({ default: 50, description: "Daily XP goal" }),
+    reminderEnabled: field5.boolean({
+      default: true,
+      description: "Enable reminders"
+    }),
+    reminderTime: field5.string({
+      isOptional: true,
+      description: "Preferred reminder time"
+    }),
+    orgId: field5.string({
+      isOptional: true,
+      description: "Organization scope"
+    }),
+    metadata: field5.json({
+      isOptional: true,
+      description: "Additional metadata"
+    }),
+    createdAt: field5.createdAt(),
+    updatedAt: field5.updatedAt(),
+    enrollments: field5.hasMany("Enrollment"),
+    lessonProgress: field5.hasMany("LessonProgress"),
+    achievements: field5.hasMany("LearnerAchievement"),
+    decks: field5.hasMany("Deck"),
+    profile: field5.hasOne("LearnerProfile")
+  },
+  indexes: [
+    index5.on(["orgId"]),
+    index5.on(["totalXp"]),
+    index5.on(["level"]),
+    index5.on(["currentStreak"])
+  ]
+});
+var EnrollmentEntity = defineEntity5({
+  name: "Enrollment",
+  description: "A learner enrollment in a course.",
+  schema: "lssm_learning",
+  map: "enrollment",
+  fields: {
+    id: field5.id({ description: "Unique enrollment identifier" }),
+    learnerId: field5.foreignKey({ description: "Enrolled learner" }),
+    courseId: field5.foreignKey({ description: "Enrolled course" }),
+    status: field5.enum("EnrollmentStatus", {
+      default: "ENROLLED",
+      description: "Enrollment status"
+    }),
+    progress: field5.int({
+      default: 0,
+      description: "Completion percentage (0-100)"
+    }),
+    completedLessons: field5.int({
+      default: 0,
+      description: "Number of completed lessons"
+    }),
+    totalLessons: field5.int({
+      default: 0,
+      description: "Total lessons in course"
+    }),
+    xpEarned: field5.int({
+      default: 0,
+      description: "XP earned in this course"
+    }),
+    startedAt: field5.dateTime({
+      isOptional: true,
+      description: "When learner started"
+    }),
+    completedAt: field5.dateTime({
+      isOptional: true,
+      description: "When learner completed"
+    }),
+    lastAccessedAt: field5.dateTime({
+      isOptional: true,
+      description: "Last access time"
+    }),
+    certificateId: field5.string({
+      isOptional: true,
+      description: "Issued certificate ID"
+    }),
+    metadata: field5.json({
+      isOptional: true,
+      description: "Additional metadata"
+    }),
+    createdAt: field5.createdAt(),
+    updatedAt: field5.updatedAt(),
+    learner: field5.belongsTo("Learner", ["learnerId"], ["id"], {
+      onDelete: "Cascade"
+    }),
+    course: field5.belongsTo("Course", ["courseId"], ["id"], {
+      onDelete: "Cascade"
+    })
+  },
+  indexes: [
+    index5.unique(["learnerId", "courseId"], { name: "enrollment_unique" }),
+    index5.on(["learnerId", "status"]),
+    index5.on(["courseId", "status"])
+  ],
+  enums: [EnrollmentStatusEnum]
+});
+var LessonProgressEntity = defineEntity5({
+  name: "LessonProgress",
+  description: "Progress tracking for a lesson.",
+  schema: "lssm_learning",
+  map: "lesson_progress",
+  fields: {
+    id: field5.id({ description: "Unique progress identifier" }),
+    learnerId: field5.foreignKey({ description: "Learner" }),
+    lessonId: field5.foreignKey({ description: "Lesson" }),
+    status: field5.enum("ProgressStatus", {
+      default: "NOT_STARTED",
+      description: "Progress status"
+    }),
+    progress: field5.int({
+      default: 0,
+      description: "Completion percentage (0-100)"
+    }),
+    score: field5.int({
+      isOptional: true,
+      description: "Score achieved (for quizzes)"
+    }),
+    attempts: field5.int({ default: 0, description: "Number of attempts" }),
+    bestScore: field5.int({
+      isOptional: true,
+      description: "Best score across attempts"
+    }),
+    timeSpent: field5.int({ default: 0, description: "Time spent in seconds" }),
+    xpEarned: field5.int({
+      default: 0,
+      description: "XP earned from this lesson"
+    }),
+    startedAt: field5.dateTime({
+      isOptional: true,
+      description: "When started"
+    }),
+    completedAt: field5.dateTime({
+      isOptional: true,
+      description: "When completed"
+    }),
+    lastAccessedAt: field5.dateTime({
+      isOptional: true,
+      description: "Last access time"
+    }),
+    bookmarks: field5.json({
+      isOptional: true,
+      description: "Content bookmarks"
+    }),
+    notes: field5.string({ isOptional: true, description: "Learner notes" }),
+    createdAt: field5.createdAt(),
+    updatedAt: field5.updatedAt(),
+    learner: field5.belongsTo("Learner", ["learnerId"], ["id"], {
+      onDelete: "Cascade"
+    }),
+    lesson: field5.belongsTo("Lesson", ["lessonId"], ["id"], {
+      onDelete: "Cascade"
+    })
+  },
+  indexes: [
+    index5.unique(["learnerId", "lessonId"], { name: "lesson_progress_unique" }),
+    index5.on(["learnerId", "status"]),
+    index5.on(["lessonId"])
+  ],
+  enums: [ProgressStatusEnum]
+});
+var ModuleCompletionEntity = defineEntity5({
+  name: "ModuleCompletion",
+  description: "Module completion record.",
+  schema: "lssm_learning",
+  map: "module_completion",
+  fields: {
+    id: field5.id({ description: "Unique completion identifier" }),
+    learnerId: field5.foreignKey({ description: "Learner" }),
+    moduleId: field5.foreignKey({ description: "Module" }),
+    score: field5.int({ isOptional: true, description: "Average score" }),
+    xpEarned: field5.int({ default: 0, description: "XP earned" }),
+    timeSpent: field5.int({ default: 0, description: "Time spent in seconds" }),
+    completedAt: field5.dateTime({ description: "When completed" }),
+    createdAt: field5.createdAt(),
+    learner: field5.belongsTo("Learner", ["learnerId"], ["id"], {
+      onDelete: "Cascade"
+    }),
+    module: field5.belongsTo("CourseModule", ["moduleId"], ["id"], {
+      onDelete: "Cascade"
+    })
+  },
+  indexes: [
+    index5.unique(["learnerId", "moduleId"], {
+      name: "module_completion_unique"
+    }),
+    index5.on(["learnerId", "completedAt"])
+  ]
+});
+var CertificateEntity = defineEntity5({
+  name: "Certificate",
+  description: "Course completion certificate.",
+  schema: "lssm_learning",
+  map: "certificate",
+  fields: {
+    id: field5.id({ description: "Unique certificate identifier" }),
+    learnerId: field5.foreignKey({ description: "Certificate holder" }),
+    courseId: field5.foreignKey({ description: "Completed course" }),
+    enrollmentId: field5.foreignKey({ description: "Associated enrollment" }),
+    certificateNumber: field5.string({
+      isUnique: true,
+      description: "Unique certificate number"
+    }),
+    title: field5.string({ description: "Certificate title" }),
+    description: field5.string({
+      isOptional: true,
+      description: "Certificate description"
+    }),
+    score: field5.int({ isOptional: true, description: "Final score" }),
+    grade: field5.string({ isOptional: true, description: "Grade awarded" }),
+    issuedAt: field5.dateTime({ description: "When issued" }),
+    validUntil: field5.dateTime({
+      isOptional: true,
+      description: "Expiration date"
+    }),
+    verificationUrl: field5.string({
+      isOptional: true,
+      description: "Verification URL"
+    }),
+    credentialHash: field5.string({
+      isOptional: true,
+      description: "Credential hash for verification"
+    }),
+    isRevoked: field5.boolean({
+      default: false,
+      description: "Whether certificate is revoked"
+    }),
+    revokedAt: field5.dateTime({
+      isOptional: true,
+      description: "When revoked"
+    }),
+    revokedReason: field5.string({
+      isOptional: true,
+      description: "Revocation reason"
+    }),
+    metadata: field5.json({
+      isOptional: true,
+      description: "Additional metadata"
+    }),
+    createdAt: field5.createdAt(),
+    learner: field5.belongsTo("Learner", ["learnerId"], ["id"], {
+      onDelete: "Cascade"
+    }),
+    course: field5.belongsTo("Course", ["courseId"], ["id"], {
+      onDelete: "Cascade"
+    })
+  },
+  indexes: [
+    index5.on(["learnerId"]),
+    index5.on(["courseId"]),
+    index5.on(["issuedAt"])
+  ]
+});
+var learnerEntities = [
+  LearnerEntity,
+  EnrollmentEntity,
+  LessonProgressEntity,
+  ModuleCompletionEntity,
+  CertificateEntity
+];
+var learnerEnums = [EnrollmentStatusEnum, ProgressStatusEnum];
+
+// src/entities/onboarding.ts
+import {
+  defineEntity as defineEntity6,
+  defineEntityEnum as defineEntityEnum6,
+  field as field6,
+  index as index6
+} from "@contractspec/lib.schema";
+var OnboardingStepStatusEnum = defineEntityEnum6({
+  name: "OnboardingStepStatus",
+  values: ["PENDING", "IN_PROGRESS", "COMPLETED", "SKIPPED"],
+  schema: "lssm_learning",
+  description: "Status of an onboarding step."
+});
+var OnboardingTrackEntity = defineEntity6({
+  name: "OnboardingTrack",
+  description: "An onboarding track for a product.",
+  schema: "lssm_learning",
+  map: "onboarding_track",
+  fields: {
+    id: field6.id({ description: "Unique track identifier" }),
+    productId: field6.string({ description: "Product this track is for" }),
+    name: field6.string({ description: "Track name" }),
+    description: field6.string({
+      isOptional: true,
+      description: "Track description"
+    }),
+    targetUserSegment: field6.string({
+      isOptional: true,
+      description: "Target user segment"
+    }),
+    targetRole: field6.string({
+      isOptional: true,
+      description: "Target user role"
+    }),
+    welcomeTitle: field6.string({
+      isOptional: true,
+      description: "Welcome message title"
+    }),
+    welcomeMessage: field6.string({
+      isOptional: true,
+      description: "Welcome message"
+    }),
+    completionTitle: field6.string({
+      isOptional: true,
+      description: "Completion message title"
+    }),
+    completionMessage: field6.string({
+      isOptional: true,
+      description: "Completion message"
+    }),
+    isActive: field6.boolean({
+      default: true,
+      description: "Whether track is active"
+    }),
+    isRequired: field6.boolean({
+      default: false,
+      description: "Whether track is required"
+    }),
+    canSkip: field6.boolean({
+      default: true,
+      description: "Whether steps can be skipped"
+    }),
+    totalXp: field6.int({
+      default: 100,
+      description: "Total XP for completing track"
+    }),
+    completionXpBonus: field6.int({
+      isOptional: true,
+      description: "Bonus XP for completing track"
+    }),
+    completionBadgeKey: field6.string({
+      isOptional: true,
+      description: "Badge awarded on completion"
+    }),
+    streakHoursWindow: field6.int({
+      isOptional: true,
+      description: "Hours window to finish for streak bonus"
+    }),
+    streakBonusXp: field6.int({
+      isOptional: true,
+      description: "Bonus XP if completed within streak window"
+    }),
+    orgId: field6.string({
+      isOptional: true,
+      description: "Organization scope"
+    }),
+    metadata: field6.json({
+      isOptional: true,
+      description: "Additional metadata"
+    }),
+    createdAt: field6.createdAt(),
+    updatedAt: field6.updatedAt(),
+    steps: field6.hasMany("OnboardingStep"),
+    progress: field6.hasMany("OnboardingProgress")
+  },
+  indexes: [
+    index6.on(["productId", "isActive"]),
+    index6.on(["orgId"]),
+    index6.unique(["productId", "targetUserSegment", "targetRole"], {
+      name: "onboarding_track_target"
+    })
+  ]
+});
+var OnboardingStepEntity = defineEntity6({
+  name: "OnboardingStep",
+  description: "A step in an onboarding track.",
+  schema: "lssm_learning",
+  map: "onboarding_step",
+  fields: {
+    id: field6.id({ description: "Unique step identifier" }),
+    trackId: field6.foreignKey({ description: "Parent track" }),
+    title: field6.string({ description: "Step title" }),
+    description: field6.string({
+      isOptional: true,
+      description: "Step description"
+    }),
+    instructions: field6.string({
+      isOptional: true,
+      description: "How to complete the step"
+    }),
+    helpUrl: field6.string({
+      isOptional: true,
+      description: "Link to help documentation"
+    }),
+    order: field6.int({ default: 0, description: "Display order" }),
+    triggerEvent: field6.string({
+      isOptional: true,
+      description: "Event that triggers step start"
+    }),
+    completionEvent: field6.string({
+      description: "Event that completes the step"
+    }),
+    completionEventVersion: field6.int({
+      isOptional: true,
+      description: "Version of the completion event"
+    }),
+    completionSourceModule: field6.string({
+      isOptional: true,
+      description: "Module emitting the completion event"
+    }),
+    completionEventFilter: field6.json({
+      isOptional: true,
+      description: "Filter for completion event"
+    }),
+    actionUrl: field6.string({
+      isOptional: true,
+      description: "URL to navigate to complete"
+    }),
+    actionLabel: field6.string({
+      isOptional: true,
+      description: "Action button label"
+    }),
+    highlightSelector: field6.string({
+      isOptional: true,
+      description: "CSS selector to highlight"
+    }),
+    tooltipPosition: field6.string({
+      isOptional: true,
+      description: "Tooltip position"
+    }),
+    xpReward: field6.int({ default: 10, description: "XP for completing step" }),
+    isRequired: field6.boolean({
+      default: true,
+      description: "Whether step is required"
+    }),
+    canSkip: field6.boolean({
+      default: true,
+      description: "Whether step can be skipped"
+    }),
+    metadata: field6.json({
+      isOptional: true,
+      description: "Additional metadata"
+    }),
+    createdAt: field6.createdAt(),
+    updatedAt: field6.updatedAt(),
+    track: field6.belongsTo("OnboardingTrack", ["trackId"], ["id"], {
+      onDelete: "Cascade"
+    })
+  },
+  indexes: [index6.on(["trackId", "order"]), index6.on(["completionEvent"])]
+});
+var OnboardingProgressEntity = defineEntity6({
+  name: "OnboardingProgress",
+  description: "Tracks user progress through an onboarding track.",
+  schema: "lssm_learning",
+  map: "onboarding_progress",
+  fields: {
+    id: field6.id({ description: "Unique progress identifier" }),
+    learnerId: field6.foreignKey({ description: "Learner" }),
+    trackId: field6.foreignKey({ description: "Onboarding track" }),
+    currentStepId: field6.string({
+      isOptional: true,
+      description: "Current step ID"
+    }),
+    completedSteps: field6.json({
+      default: "[]",
+      description: "Array of completed step IDs"
+    }),
+    skippedSteps: field6.json({
+      default: "[]",
+      description: "Array of skipped step IDs"
+    }),
+    progress: field6.int({
+      default: 0,
+      description: "Completion percentage (0-100)"
+    }),
+    isCompleted: field6.boolean({
+      default: false,
+      description: "Whether track is completed"
+    }),
+    xpEarned: field6.int({ default: 0, description: "XP earned from track" }),
+    startedAt: field6.dateTime({ description: "When user started" }),
+    completedAt: field6.dateTime({
+      isOptional: true,
+      description: "When user completed"
+    }),
+    lastActivityAt: field6.dateTime({
+      isOptional: true,
+      description: "Last activity"
+    }),
+    isDismissed: field6.boolean({
+      default: false,
+      description: "Whether user dismissed onboarding"
+    }),
+    dismissedAt: field6.dateTime({
+      isOptional: true,
+      description: "When dismissed"
+    }),
+    metadata: field6.json({
+      isOptional: true,
+      description: "Additional metadata"
+    }),
+    createdAt: field6.createdAt(),
+    updatedAt: field6.updatedAt(),
+    learner: field6.belongsTo("Learner", ["learnerId"], ["id"], {
+      onDelete: "Cascade"
+    }),
+    track: field6.belongsTo("OnboardingTrack", ["trackId"], ["id"], {
+      onDelete: "Cascade"
+    })
+  },
+  indexes: [
+    index6.unique(["learnerId", "trackId"], {
+      name: "onboarding_progress_unique"
+    }),
+    index6.on(["learnerId", "isCompleted"]),
+    index6.on(["trackId"])
+  ],
+  enums: [OnboardingStepStatusEnum]
+});
+var OnboardingStepCompletionEntity = defineEntity6({
+  name: "OnboardingStepCompletion",
+  description: "Individual step completion record.",
+  schema: "lssm_learning",
+  map: "onboarding_step_completion",
+  fields: {
+    id: field6.id({ description: "Unique completion identifier" }),
+    progressId: field6.foreignKey({ description: "Parent progress record" }),
+    stepId: field6.foreignKey({ description: "Completed step" }),
+    status: field6.enum("OnboardingStepStatus", {
+      description: "Completion status"
+    }),
+    xpEarned: field6.int({ default: 0, description: "XP earned" }),
+    triggeringEvent: field6.string({
+      isOptional: true,
+      description: "Event that triggered completion"
+    }),
+    eventPayload: field6.json({
+      isOptional: true,
+      description: "Event payload"
+    }),
+    completedAt: field6.dateTime({ description: "When completed" }),
+    createdAt: field6.createdAt(),
+    progress: field6.belongsTo("OnboardingProgress", ["progressId"], ["id"], {
+      onDelete: "Cascade"
+    }),
+    step: field6.belongsTo("OnboardingStep", ["stepId"], ["id"], {
+      onDelete: "Cascade"
+    })
+  },
+  indexes: [
+    index6.unique(["progressId", "stepId"], { name: "step_completion_unique" }),
+    index6.on(["completedAt"])
+  ]
+});
+var onboardingEntities = [
+  OnboardingTrackEntity,
+  OnboardingStepEntity,
+  OnboardingProgressEntity,
+  OnboardingStepCompletionEntity
+];
+var onboardingEnums = [OnboardingStepStatusEnum];
+
+// src/entities/quiz.ts
+import {
+  defineEntity as defineEntity7,
+  defineEntityEnum as defineEntityEnum7,
+  field as field7,
+  index as index7
+} from "@contractspec/lib.schema";
+var QuestionTypeEnum = defineEntityEnum7({
+  name: "QuestionType",
+  values: [
+    "MULTIPLE_CHOICE",
+    "TRUE_FALSE",
+    "FILL_BLANK",
+    "MATCHING",
+    "SHORT_ANSWER",
+    "CODE"
+  ],
+  schema: "lssm_learning",
+  description: "Type of quiz question."
+});
+var QuizStatusEnum = defineEntityEnum7({
+  name: "QuizStatus",
+  values: ["DRAFT", "PUBLISHED", "ARCHIVED"],
+  schema: "lssm_learning",
+  description: "Publication status of a quiz."
+});
+var AttemptStatusEnum = defineEntityEnum7({
+  name: "AttemptStatus",
+  values: ["IN_PROGRESS", "COMPLETED", "TIMED_OUT", "ABANDONED"],
+  schema: "lssm_learning",
+  description: "Status of a quiz attempt."
+});
+var QuizEntity = defineEntity7({
+  name: "Quiz",
+  description: "A quiz assessment.",
+  schema: "lssm_learning",
+  map: "quiz",
+  fields: {
+    id: field7.id({ description: "Unique quiz identifier" }),
+    lessonId: field7.foreignKey({
+      isOptional: true,
+      description: "Associated lesson"
+    }),
+    title: field7.string({ description: "Quiz title" }),
+    description: field7.string({
+      isOptional: true,
+      description: "Quiz description"
+    }),
+    instructions: field7.string({
+      isOptional: true,
+      description: "Quiz instructions"
+    }),
+    passingScore: field7.int({
+      default: 70,
+      description: "Passing score percentage"
+    }),
+    timeLimit: field7.int({
+      isOptional: true,
+      description: "Time limit in seconds"
+    }),
+    maxAttempts: field7.int({
+      isOptional: true,
+      description: "Maximum attempts allowed"
+    }),
+    shuffleQuestions: field7.boolean({
+      default: false,
+      description: "Shuffle question order"
+    }),
+    shuffleOptions: field7.boolean({
+      default: false,
+      description: "Shuffle answer options"
+    }),
+    showCorrectAnswers: field7.boolean({
+      default: true,
+      description: "Show correct answers after"
+    }),
+    showExplanations: field7.boolean({
+      default: true,
+      description: "Show explanations after"
+    }),
+    status: field7.enum("QuizStatus", {
+      default: "DRAFT",
+      description: "Publication status"
+    }),
+    totalPoints: field7.int({
+      default: 0,
+      description: "Total points available"
+    }),
+    xpReward: field7.int({ default: 20, description: "XP for passing" }),
+    orgId: field7.string({
+      isOptional: true,
+      description: "Organization scope"
+    }),
+    metadata: field7.json({
+      isOptional: true,
+      description: "Additional metadata"
+    }),
+    createdAt: field7.createdAt(),
+    updatedAt: field7.updatedAt(),
+    lesson: field7.belongsTo("Lesson", ["lessonId"], ["id"], {
+      onDelete: "Cascade"
+    }),
+    questions: field7.hasMany("Question"),
+    attempts: field7.hasMany("QuizAttempt")
+  },
+  indexes: [index7.on(["lessonId"]), index7.on(["status"]), index7.on(["orgId"])],
+  enums: [QuizStatusEnum]
+});
+var QuestionEntity = defineEntity7({
+  name: "Question",
+  description: "A quiz question.",
+  schema: "lssm_learning",
+  map: "question",
+  fields: {
+    id: field7.id({ description: "Unique question identifier" }),
+    quizId: field7.foreignKey({ description: "Parent quiz" }),
+    type: field7.enum("QuestionType", { description: "Question type" }),
+    content: field7.string({ description: "Question text" }),
+    mediaUrl: field7.string({ isOptional: true, description: "Question media" }),
+    points: field7.int({ default: 1, description: "Points for correct answer" }),
+    codeLanguage: field7.string({
+      isOptional: true,
+      description: "Programming language"
+    }),
+    codeTemplate: field7.string({
+      isOptional: true,
+      description: "Starter code template"
+    }),
+    testCases: field7.json({
+      isOptional: true,
+      description: "Test cases for code validation"
+    }),
+    explanation: field7.string({
+      isOptional: true,
+      description: "Explanation of correct answer"
+    }),
+    hint: field7.string({
+      isOptional: true,
+      description: "Hint for the question"
+    }),
+    order: field7.int({ default: 0, description: "Display order" }),
+    skillId: field7.string({
+      isOptional: true,
+      description: "Associated skill"
+    }),
+    metadata: field7.json({
+      isOptional: true,
+      description: "Additional metadata"
+    }),
+    createdAt: field7.createdAt(),
+    updatedAt: field7.updatedAt(),
+    quiz: field7.belongsTo("Quiz", ["quizId"], ["id"], { onDelete: "Cascade" }),
+    options: field7.hasMany("QuestionOption")
+  },
+  indexes: [
+    index7.on(["quizId", "order"]),
+    index7.on(["type"]),
+    index7.on(["skillId"])
+  ],
+  enums: [QuestionTypeEnum]
+});
+var QuestionOptionEntity = defineEntity7({
+  name: "QuestionOption",
+  description: "An answer option for a question.",
+  schema: "lssm_learning",
+  map: "question_option",
+  fields: {
+    id: field7.id({ description: "Unique option identifier" }),
+    questionId: field7.foreignKey({ description: "Parent question" }),
+    content: field7.string({ description: "Option text" }),
+    matchContent: field7.string({
+      isOptional: true,
+      description: "Match pair content"
+    }),
+    isCorrect: field7.boolean({
+      default: false,
+      description: "Whether option is correct"
+    }),
+    feedback: field7.string({
+      isOptional: true,
+      description: "Feedback when selected"
+    }),
+    order: field7.int({ default: 0, description: "Display order" }),
+    metadata: field7.json({
+      isOptional: true,
+      description: "Additional metadata"
+    }),
+    createdAt: field7.createdAt(),
+    updatedAt: field7.updatedAt(),
+    question: field7.belongsTo("Question", ["questionId"], ["id"], {
+      onDelete: "Cascade"
+    })
+  },
+  indexes: [index7.on(["questionId", "order"])]
+});
+var QuizAttemptEntity = defineEntity7({
+  name: "QuizAttempt",
+  description: "A learner quiz attempt.",
+  schema: "lssm_learning",
+  map: "quiz_attempt",
+  fields: {
+    id: field7.id({ description: "Unique attempt identifier" }),
+    learnerId: field7.foreignKey({ description: "Learner" }),
+    quizId: field7.foreignKey({ description: "Quiz" }),
+    status: field7.enum("AttemptStatus", {
+      default: "IN_PROGRESS",
+      description: "Attempt status"
+    }),
+    score: field7.int({ isOptional: true, description: "Score achieved" }),
+    percentageScore: field7.int({
+      isOptional: true,
+      description: "Percentage score"
+    }),
+    passed: field7.boolean({ isOptional: true, description: "Whether passed" }),
+    totalQuestions: field7.int({ default: 0, description: "Total questions" }),
+    answeredQuestions: field7.int({
+      default: 0,
+      description: "Questions answered"
+    }),
+    correctAnswers: field7.int({ default: 0, description: "Correct answers" }),
+    answers: field7.json({ isOptional: true, description: "Submitted answers" }),
+    xpEarned: field7.int({ default: 0, description: "XP earned" }),
+    timeSpent: field7.int({ default: 0, description: "Time spent in seconds" }),
+    startedAt: field7.dateTime({ description: "When started" }),
+    completedAt: field7.dateTime({
+      isOptional: true,
+      description: "When completed"
+    }),
+    attemptNumber: field7.int({
+      default: 1,
+      description: "Which attempt this is"
+    }),
+    metadata: field7.json({
+      isOptional: true,
+      description: "Additional metadata"
+    }),
+    createdAt: field7.createdAt(),
+    updatedAt: field7.updatedAt(),
+    learner: field7.belongsTo("Learner", ["learnerId"], ["id"], {
+      onDelete: "Cascade"
+    }),
+    quiz: field7.belongsTo("Quiz", ["quizId"], ["id"], { onDelete: "Cascade" })
+  },
+  indexes: [
+    index7.on(["learnerId", "quizId"]),
+    index7.on(["learnerId", "status"]),
+    index7.on(["quizId", "status"])
+  ],
+  enums: [AttemptStatusEnum]
+});
+var SkillAssessmentEntity = defineEntity7({
+  name: "SkillAssessment",
+  description: "Assessment of a skill based on quiz performance.",
+  schema: "lssm_learning",
+  map: "skill_assessment",
+  fields: {
+    id: field7.id({ description: "Unique assessment identifier" }),
+    learnerId: field7.foreignKey({ description: "Learner" }),
+    skillId: field7.string({ description: "Skill identifier" }),
+    skillName: field7.string({ description: "Skill name" }),
+    level: field7.int({ default: 1, description: "Proficiency level (1-5)" }),
+    score: field7.int({ default: 0, description: "Assessment score (0-100)" }),
+    confidence: field7.decimal({
+      default: 0.5,
+      description: "Confidence in assessment"
+    }),
+    questionsAnswered: field7.int({
+      default: 0,
+      description: "Total questions answered"
+    }),
+    questionsCorrect: field7.int({ default: 0, description: "Total correct" }),
+    assessedAt: field7.dateTime({ description: "Last assessment time" }),
+    createdAt: field7.createdAt(),
+    updatedAt: field7.updatedAt(),
+    learner: field7.belongsTo("Learner", ["learnerId"], ["id"], {
+      onDelete: "Cascade"
+    })
+  },
+  indexes: [
+    index7.unique(["learnerId", "skillId"], { name: "skill_assessment_unique" }),
+    index7.on(["learnerId", "level"]),
+    index7.on(["skillId"])
+  ]
+});
+var quizEntities = [
+  QuizEntity,
+  QuestionEntity,
+  QuestionOptionEntity,
+  QuizAttemptEntity,
+  SkillAssessmentEntity
+];
+var quizEnums = [QuestionTypeEnum, QuizStatusEnum, AttemptStatusEnum];
+// src/entities/index.ts
+var learningJourneyEntities = [
+  ...courseEntities,
+  ...learnerEntities,
+  ...onboardingEntities,
+  ...flashcardEntities,
+  ...quizEntities,
+  ...gamificationEntities,
+  ...aiEntities
+];
+var learningJourneyEnums = [
+  ...courseEnums,
+  ...learnerEnums,
+  ...onboardingEnums,
+  ...flashcardEnums,
+  ...quizEnums,
+  ...gamificationEnums,
+  ...aiEnums
+];
+var learningJourneySchemaContribution = {
+  moduleId: "@contractspec/module.learning-journey",
+  entities: learningJourneyEntities,
+  enums: learningJourneyEnums
+};
+export {
+  quizEnums,
+  quizEntities,
+  onboardingEnums,
+  onboardingEntities,
+  learningJourneySchemaContribution,
+  learningJourneyEnums,
+  learningJourneyEntities,
+  learnerEnums,
+  learnerEntities,
+  gamificationEnums,
+  gamificationEntities,
+  flashcardEnums,
+  flashcardEntities,
+  courseEnums,
+  courseEntities,
+  aiEnums,
+  aiEntities,
+  XPTransactionEntity,
+  StreakEntity,
+  SkillMapEntity,
+  SkillAssessmentEntity,
+  RecommendationTypeEnum,
+  RecommendationEntity,
+  QuizStatusEnum,
+  QuizEntity,
+  QuizAttemptEntity,
+  QuestionTypeEnum,
+  QuestionOptionEntity,
+  QuestionEntity,
+  ProgressStatusEnum,
+  OnboardingTrackEntity,
+  OnboardingStepStatusEnum,
+  OnboardingStepEntity,
+  OnboardingStepCompletionEntity,
+  OnboardingProgressEntity,
+  ModuleCompletionEntity,
+  LessonTypeEnum,
+  LessonProgressEntity,
+  LessonEntity,
+  LessonContentEntity,
+  LearningStyleEnum,
+  LearningPathEntity,
+  LearningGapEntity,
+  LearnerProfileEntity,
+  LearnerEntity,
+  LearnerAchievementEntity,
+  LeaderboardPeriodEnum,
+  LeaderboardEntryEntity,
+  HeartEntity,
+  EnrollmentStatusEnum,
+  EnrollmentEntity,
+  DeckEntity,
+  DailyGoalEntity,
+  CourseStatusEnum,
+  CourseModuleEntity,
+  CourseEntity,
+  CourseDifficultyEnum,
+  ContentTypeEnum,
+  CertificateEntity,
+  CardScheduleEntity,
+  CardReviewEntity,
+  CardRatingEnum,
+  CardEntity,
+  AttemptStatusEnum,
+  AchievementTypeEnum,
+  AchievementEntity
+};