@contractspec/module.learning-journey 1.57.0 → 1.58.0

package/dist/node/index.js

@@ -0,0 +1,3833 @@
+// src/contracts/shared.ts
+var LEARNING_JOURNEY_OWNERS = ["modules.learning-journey"];
+
+// src/contracts/models.ts
+import { ScalarTypeEnum, defineSchemaModel } from "@contractspec/lib.schema";
+var CourseModel = defineSchemaModel({
+  name: "Course",
+  description: "A learning course",
+  fields: {
+    id: { type: ScalarTypeEnum.String_unsecure(), isOptional: false },
+    title: { type: ScalarTypeEnum.String_unsecure(), isOptional: false },
+    slug: { type: ScalarTypeEnum.String_unsecure(), isOptional: false },
+    description: { type: ScalarTypeEnum.String_unsecure(), isOptional: true },
+    difficulty: { type: ScalarTypeEnum.String_unsecure(), isOptional: false },
+    status: { type: ScalarTypeEnum.String_unsecure(), isOptional: false },
+    estimatedDuration: {
+      type: ScalarTypeEnum.Int_unsecure(),
+      isOptional: true
+    },
+    thumbnailUrl: { type: ScalarTypeEnum.String_unsecure(), isOptional: true },
+    createdAt: { type: ScalarTypeEnum.DateTime(), isOptional: false }
+  }
+});
+var LearnerModel = defineSchemaModel({
+  name: "Learner",
+  description: "A learner profile",
+  fields: {
+    id: { type: ScalarTypeEnum.String_unsecure(), isOptional: false },
+    userId: { type: ScalarTypeEnum.String_unsecure(), isOptional: false },
+    displayName: { type: ScalarTypeEnum.String_unsecure(), isOptional: true },
+    level: { type: ScalarTypeEnum.Int_unsecure(), isOptional: false },
+    totalXp: { type: ScalarTypeEnum.Int_unsecure(), isOptional: false },
+    currentStreak: { type: ScalarTypeEnum.Int_unsecure(), isOptional: false },
+    longestStreak: { type: ScalarTypeEnum.Int_unsecure(), isOptional: false },
+    createdAt: { type: ScalarTypeEnum.DateTime(), isOptional: false }
+  }
+});
+var EnrollmentModel = defineSchemaModel({
+  name: "Enrollment",
+  description: "A course enrollment",
+  fields: {
+    id: { type: ScalarTypeEnum.String_unsecure(), isOptional: false },
+    learnerId: { type: ScalarTypeEnum.String_unsecure(), isOptional: false },
+    courseId: { type: ScalarTypeEnum.String_unsecure(), isOptional: false },
+    status: { type: ScalarTypeEnum.String_unsecure(), isOptional: false },
+    progress: { type: ScalarTypeEnum.Int_unsecure(), isOptional: false },
+    startedAt: { type: ScalarTypeEnum.DateTime(), isOptional: true },
+    completedAt: { type: ScalarTypeEnum.DateTime(), isOptional: true }
+  }
+});
+var ProgressModel = defineSchemaModel({
+  name: "LessonProgress",
+  description: "Lesson progress",
+  fields: {
+    id: { type: ScalarTypeEnum.String_unsecure(), isOptional: false },
+    learnerId: { type: ScalarTypeEnum.String_unsecure(), isOptional: false },
+    lessonId: { type: ScalarTypeEnum.String_unsecure(), isOptional: false },
+    status: { type: ScalarTypeEnum.String_unsecure(), isOptional: false },
+    progress: { type: ScalarTypeEnum.Int_unsecure(), isOptional: false },
+    score: { type: ScalarTypeEnum.Int_unsecure(), isOptional: true },
+    timeSpent: { type: ScalarTypeEnum.Int_unsecure(), isOptional: false },
+    completedAt: { type: ScalarTypeEnum.DateTime(), isOptional: true }
+  }
+});
+var DeckModel = defineSchemaModel({
+  name: "Deck",
+  description: "A flashcard deck",
+  fields: {
+    id: { type: ScalarTypeEnum.String_unsecure(), isOptional: false },
+    title: { type: ScalarTypeEnum.String_unsecure(), isOptional: false },
+    description: { type: ScalarTypeEnum.String_unsecure(), isOptional: true },
+    cardCount: { type: ScalarTypeEnum.Int_unsecure(), isOptional: false },
+    isPublic: { type: ScalarTypeEnum.Boolean(), isOptional: false },
+    createdAt: { type: ScalarTypeEnum.DateTime(), isOptional: false }
+  }
+});
+var CardModel = defineSchemaModel({
+  name: "Card",
+  description: "A flashcard",
+  fields: {
+    id: { type: ScalarTypeEnum.String_unsecure(), isOptional: false },
+    deckId: { type: ScalarTypeEnum.String_unsecure(), isOptional: false },
+    front: { type: ScalarTypeEnum.String_unsecure(), isOptional: false },
+    back: { type: ScalarTypeEnum.String_unsecure(), isOptional: false },
+    hints: { type: ScalarTypeEnum.JSON(), isOptional: true },
+    isDue: { type: ScalarTypeEnum.Boolean(), isOptional: false },
+    nextReviewAt: { type: ScalarTypeEnum.DateTime(), isOptional: true }
+  }
+});
+var AchievementModel = defineSchemaModel({
+  name: "Achievement",
+  description: "An achievement",
+  fields: {
+    id: { type: ScalarTypeEnum.String_unsecure(), isOptional: false },
+    key: { type: ScalarTypeEnum.String_unsecure(), isOptional: false },
+    name: { type: ScalarTypeEnum.String_unsecure(), isOptional: false },
+    description: { type: ScalarTypeEnum.String_unsecure(), isOptional: false },
+    icon: { type: ScalarTypeEnum.String_unsecure(), isOptional: true },
+    xpReward: { type: ScalarTypeEnum.Int_unsecure(), isOptional: false },
+    unlockedAt: { type: ScalarTypeEnum.DateTime(), isOptional: true }
+  }
+});
+var EnrollInCourseInput = defineSchemaModel({
+  name: "EnrollInCourseInput",
+  description: "Input for enrolling in a course",
+  fields: {
+    courseId: { type: ScalarTypeEnum.String_unsecure(), isOptional: false }
+  }
+});
+var CompleteLessonInput = defineSchemaModel({
+  name: "CompleteLessonInput",
+  description: "Input for completing a lesson",
+  fields: {
+    lessonId: { type: ScalarTypeEnum.String_unsecure(), isOptional: false },
+    score: { type: ScalarTypeEnum.Int_unsecure(), isOptional: true },
+    timeSpent: { type: ScalarTypeEnum.Int_unsecure(), isOptional: false }
+  }
+});
+var SubmitCardReviewInput = defineSchemaModel({
+  name: "SubmitCardReviewInput",
+  description: "Input for submitting a card review",
+  fields: {
+    cardId: { type: ScalarTypeEnum.String_unsecure(), isOptional: false },
+    rating: { type: ScalarTypeEnum.String_unsecure(), isOptional: false },
+    responseTimeMs: { type: ScalarTypeEnum.Int_unsecure(), isOptional: true }
+  }
+});
+var GetDueCardsInput = defineSchemaModel({
+  name: "GetDueCardsInput",
+  description: "Input for getting due cards",
+  fields: {
+    deckId: { type: ScalarTypeEnum.String_unsecure(), isOptional: true },
+    limit: { type: ScalarTypeEnum.Int_unsecure(), isOptional: true }
+  }
+});
+var GetDueCardsOutput = defineSchemaModel({
+  name: "GetDueCardsOutput",
+  description: "Output for getting due cards",
+  fields: {
+    cards: { type: CardModel, isArray: true, isOptional: false },
+    total: { type: ScalarTypeEnum.Int_unsecure(), isOptional: false }
+  }
+});
+var GetLearnerDashboardInput = defineSchemaModel({
+  name: "GetLearnerDashboardInput",
+  description: "Input for getting learner dashboard",
+  fields: {
+    learnerId: { type: ScalarTypeEnum.String_unsecure(), isOptional: true }
+  }
+});
+var LearnerDashboardModel = defineSchemaModel({
+  name: "LearnerDashboard",
+  description: "Learner dashboard data",
+  fields: {
+    learner: { type: LearnerModel, isOptional: false },
+    currentStreak: { type: ScalarTypeEnum.Int_unsecure(), isOptional: false },
+    dailyXpGoal: { type: ScalarTypeEnum.Int_unsecure(), isOptional: false },
+    dailyXpProgress: { type: ScalarTypeEnum.Int_unsecure(), isOptional: false },
+    activeEnrollments: {
+      type: EnrollmentModel,
+      isArray: true,
+      isOptional: false
+    },
+    recentAchievements: {
+      type: AchievementModel,
+      isArray: true,
+      isOptional: false
+    },
+    dueCardCount: { type: ScalarTypeEnum.Int_unsecure(), isOptional: false }
+  }
+});
+var SuccessOutput = defineSchemaModel({
+  name: "SuccessOutput",
+  description: "Generic success output",
+  fields: {
+    success: { type: ScalarTypeEnum.Boolean(), isOptional: false },
+    xpEarned: { type: ScalarTypeEnum.Int_unsecure(), isOptional: true }
+  }
+});
+
+// src/contracts/operations.ts
+import { defineCommand, defineQuery } from "@contractspec/lib.contracts";
+var EnrollInCourseContract = defineCommand({
+  meta: {
+    key: "learning.enroll",
+    version: "1.0.0",
+    stability: "stable",
+    owners: [...LEARNING_JOURNEY_OWNERS],
+    tags: ["learning", "enrollment"],
+    description: "Enroll in a course.",
+    goal: "Start learning a new course.",
+    context: "Called when a learner wants to start a course."
+  },
+  io: {
+    input: EnrollInCourseInput,
+    output: EnrollmentModel,
+    errors: {
+      COURSE_NOT_FOUND: {
+        description: "Course does not exist",
+        http: 404,
+        gqlCode: "COURSE_NOT_FOUND",
+        when: "Course ID is invalid"
+      },
+      ALREADY_ENROLLED: {
+        description: "Already enrolled in course",
+        http: 409,
+        gqlCode: "ALREADY_ENROLLED",
+        when: "Learner is already enrolled"
+      }
+    }
+  },
+  policy: {
+    auth: "user"
+  }
+});
+var CompleteLessonContract = defineCommand({
+  meta: {
+    key: "learning.completeLesson",
+    version: "1.0.0",
+    stability: "stable",
+    owners: [...LEARNING_JOURNEY_OWNERS],
+    tags: ["learning", "progress"],
+    description: "Mark a lesson as completed.",
+    goal: "Record lesson completion and earn XP.",
+    context: "Called when a learner finishes a lesson."
+  },
+  io: {
+    input: CompleteLessonInput,
+    output: SuccessOutput,
+    errors: {
+      LESSON_NOT_FOUND: {
+        description: "Lesson does not exist",
+        http: 404,
+        gqlCode: "LESSON_NOT_FOUND",
+        when: "Lesson ID is invalid"
+      },
+      NOT_ENROLLED: {
+        description: "Not enrolled in course",
+        http: 403,
+        gqlCode: "NOT_ENROLLED",
+        when: "Learner is not enrolled in the course"
+      }
+    }
+  },
+  policy: {
+    auth: "user"
+  }
+});
+var SubmitCardReviewContract = defineCommand({
+  meta: {
+    key: "learning.submitCardReview",
+    version: "1.0.0",
+    stability: "stable",
+    owners: [...LEARNING_JOURNEY_OWNERS],
+    tags: ["learning", "flashcards"],
+    description: "Submit a flashcard review.",
+    goal: "Record review and update SRS schedule.",
+    context: "Called when reviewing flashcards."
+  },
+  io: {
+    input: SubmitCardReviewInput,
+    output: SuccessOutput,
+    errors: {
+      CARD_NOT_FOUND: {
+        description: "Card does not exist",
+        http: 404,
+        gqlCode: "CARD_NOT_FOUND",
+        when: "Card ID is invalid"
+      },
+      INVALID_RATING: {
+        description: "Invalid rating",
+        http: 400,
+        gqlCode: "INVALID_RATING",
+        when: "Rating must be AGAIN, HARD, GOOD, or EASY"
+      }
+    }
+  },
+  policy: {
+    auth: "user"
+  }
+});
+var GetDueCardsContract = defineQuery({
+  meta: {
+    key: "learning.getDueCards",
+    version: "1.0.0",
+    stability: "stable",
+    owners: [...LEARNING_JOURNEY_OWNERS],
+    tags: ["learning", "flashcards"],
+    description: "Get flashcards due for review.",
+    goal: "Get the next batch of cards to review.",
+    context: "Called when starting a review session."
+  },
+  io: {
+    input: GetDueCardsInput,
+    output: GetDueCardsOutput
+  },
+  policy: {
+    auth: "user"
+  }
+});
+var GetLearnerDashboardContract = defineQuery({
+  meta: {
+    key: "learning.getDashboard",
+    version: "1.0.0",
+    stability: "stable",
+    owners: [...LEARNING_JOURNEY_OWNERS],
+    tags: ["learning", "dashboard"],
+    description: "Get learner dashboard data.",
+    goal: "Display learner progress and stats.",
+    context: "Called when viewing the learning dashboard."
+  },
+  io: {
+    input: GetLearnerDashboardInput,
+    output: LearnerDashboardModel
+  },
+  policy: {
+    auth: "user"
+  }
+});
+
+// src/contracts/onboarding.ts
+import { ScalarTypeEnum as ScalarTypeEnum2, defineSchemaModel as defineSchemaModel2 } from "@contractspec/lib.schema";
+import { defineCommand as defineCommand2, defineQuery as defineQuery2 } from "@contractspec/lib.contracts";
+var OnboardingStepConditionModel = defineSchemaModel2({
+  name: "OnboardingStepCondition",
+  description: "Structured completion condition for onboarding steps.",
+  fields: {
+    eventName: { type: ScalarTypeEnum2.String_unsecure(), isOptional: false },
+    eventVersion: { type: ScalarTypeEnum2.String_unsecure(), isOptional: true },
+    sourceModule: { type: ScalarTypeEnum2.String_unsecure(), isOptional: true },
+    payloadFilter: { type: ScalarTypeEnum2.JSON(), isOptional: true }
+  }
+});
+var OnboardingStepModel = defineSchemaModel2({
+  name: "OnboardingStep",
+  description: "Declarative onboarding step definition.",
+  fields: {
+    id: { type: ScalarTypeEnum2.String_unsecure(), isOptional: false },
+    trackId: { type: ScalarTypeEnum2.String_unsecure(), isOptional: false },
+    title: { type: ScalarTypeEnum2.String_unsecure(), isOptional: false },
+    description: { type: ScalarTypeEnum2.String_unsecure(), isOptional: true },
+    instructions: { type: ScalarTypeEnum2.String_unsecure(), isOptional: true },
+    helpUrl: { type: ScalarTypeEnum2.String_unsecure(), isOptional: true },
+    order: { type: ScalarTypeEnum2.Int_unsecure(), isOptional: false },
+    completionEvent: {
+      type: ScalarTypeEnum2.String_unsecure(),
+      isOptional: false
+    },
+    completionCondition: {
+      type: OnboardingStepConditionModel,
+      isOptional: true
+    },
+    xpReward: { type: ScalarTypeEnum2.Int_unsecure(), isOptional: true },
+    isRequired: { type: ScalarTypeEnum2.Boolean(), isOptional: true },
+    canSkip: { type: ScalarTypeEnum2.Boolean(), isOptional: true },
+    actionUrl: { type: ScalarTypeEnum2.String_unsecure(), isOptional: true },
+    actionLabel: { type: ScalarTypeEnum2.String_unsecure(), isOptional: true },
+    metadata: { type: ScalarTypeEnum2.JSON(), isOptional: true }
+  }
+});
+var OnboardingTrackModel = defineSchemaModel2({
+  name: "OnboardingTrack",
+  description: "Onboarding track metadata and steps.",
+  fields: {
+    id: { type: ScalarTypeEnum2.String_unsecure(), isOptional: false },
+    productId: { type: ScalarTypeEnum2.String_unsecure(), isOptional: true },
+    name: { type: ScalarTypeEnum2.String_unsecure(), isOptional: false },
+    description: { type: ScalarTypeEnum2.String_unsecure(), isOptional: true },
+    targetUserSegment: {
+      type: ScalarTypeEnum2.String_unsecure(),
+      isOptional: true
+    },
+    targetRole: { type: ScalarTypeEnum2.String_unsecure(), isOptional: true },
+    isActive: { type: ScalarTypeEnum2.Boolean(), isOptional: true },
+    isRequired: { type: ScalarTypeEnum2.Boolean(), isOptional: true },
+    canSkip: { type: ScalarTypeEnum2.Boolean(), isOptional: true },
+    totalXp: { type: ScalarTypeEnum2.Int_unsecure(), isOptional: true },
+    completionXpBonus: {
+      type: ScalarTypeEnum2.Int_unsecure(),
+      isOptional: true
+    },
+    completionBadgeKey: {
+      type: ScalarTypeEnum2.String_unsecure(),
+      isOptional: true
+    },
+    streakHoursWindow: {
+      type: ScalarTypeEnum2.Int_unsecure(),
+      isOptional: true
+    },
+    streakBonusXp: { type: ScalarTypeEnum2.Int_unsecure(), isOptional: true },
+    metadata: { type: ScalarTypeEnum2.JSON(), isOptional: true },
+    steps: { type: OnboardingStepModel, isArray: true, isOptional: false }
+  }
+});
+var OnboardingStepProgressModel = defineSchemaModel2({
+  name: "OnboardingStepProgress",
+  description: "Progress for a specific onboarding step.",
+  fields: {
+    stepId: { type: ScalarTypeEnum2.String_unsecure(), isOptional: false },
+    status: { type: ScalarTypeEnum2.String_unsecure(), isOptional: false },
+    xpEarned: { type: ScalarTypeEnum2.Int_unsecure(), isOptional: true },
+    triggeringEvent: {
+      type: ScalarTypeEnum2.String_unsecure(),
+      isOptional: true
+    },
+    eventPayload: { type: ScalarTypeEnum2.JSON(), isOptional: true },
+    completedAt: { type: ScalarTypeEnum2.DateTime(), isOptional: true }
+  }
+});
+var OnboardingProgressModel = defineSchemaModel2({
+  name: "OnboardingProgress",
+  description: "Aggregated progress for an onboarding track.",
+  fields: {
+    learnerId: { type: ScalarTypeEnum2.String_unsecure(), isOptional: true },
+    trackId: { type: ScalarTypeEnum2.String_unsecure(), isOptional: false },
+    progress: { type: ScalarTypeEnum2.Int_unsecure(), isOptional: false },
+    isCompleted: { type: ScalarTypeEnum2.Boolean(), isOptional: false },
+    xpEarned: { type: ScalarTypeEnum2.Int_unsecure(), isOptional: true },
+    startedAt: { type: ScalarTypeEnum2.DateTime(), isOptional: true },
+    completedAt: { type: ScalarTypeEnum2.DateTime(), isOptional: true },
+    lastActivityAt: { type: ScalarTypeEnum2.DateTime(), isOptional: true },
+    steps: {
+      type: OnboardingStepProgressModel,
+      isArray: true,
+      isOptional: true
+    }
+  }
+});
+var ListOnboardingTracksInput = defineSchemaModel2({
+  name: "ListOnboardingTracksInput",
+  description: "Filters for listing onboarding tracks.",
+  fields: {
+    learnerId: { type: ScalarTypeEnum2.String_unsecure(), isOptional: true },
+    productId: { type: ScalarTypeEnum2.String_unsecure(), isOptional: true },
+    trackIds: {
+      type: ScalarTypeEnum2.String_unsecure(),
+      isArray: true,
+      isOptional: true
+    },
+    includeProgress: {
+      type: ScalarTypeEnum2.Boolean(),
+      isOptional: true
+    }
+  }
+});
+var ListOnboardingTracksOutput = defineSchemaModel2({
+  name: "ListOnboardingTracksOutput",
+  description: "Available onboarding tracks with optional progress.",
+  fields: {
+    tracks: { type: OnboardingTrackModel, isArray: true, isOptional: false },
+    progress: {
+      type: OnboardingProgressModel,
+      isArray: true,
+      isOptional: true
+    }
+  }
+});
+var GetOnboardingProgressInput = defineSchemaModel2({
+  name: "GetOnboardingProgressInput",
+  description: "Input for fetching onboarding progress for a track.",
+  fields: {
+    trackId: { type: ScalarTypeEnum2.String_unsecure(), isOptional: false },
+    learnerId: { type: ScalarTypeEnum2.String_unsecure(), isOptional: true }
+  }
+});
+var RecordOnboardingEventInput = defineSchemaModel2({
+  name: "RecordOnboardingEventInput",
+  description: "Record a domain event to advance onboarding progress via completion conditions.",
+  fields: {
+    learnerId: { type: ScalarTypeEnum2.String_unsecure(), isOptional: false },
+    trackId: { type: ScalarTypeEnum2.String_unsecure(), isOptional: true },
+    eventName: { type: ScalarTypeEnum2.String_unsecure(), isOptional: false },
+    eventVersion: { type: ScalarTypeEnum2.String_unsecure(), isOptional: true },
+    eventPayload: { type: ScalarTypeEnum2.JSON(), isOptional: true },
+    occurredAt: { type: ScalarTypeEnum2.DateTime(), isOptional: true }
+  }
+});
+var ListOnboardingTracksContract = defineQuery2({
+  meta: {
+    key: "learning.onboarding.listTracks",
+    version: "1.0.0",
+    stability: "stable",
+    owners: [...LEARNING_JOURNEY_OWNERS],
+    tags: ["learning", "onboarding", "journey"],
+    description: "List onboarding tracks available to a learner or product.",
+    goal: "Expose track catalog for UI/API surfaces.",
+    context: "Called when showing onboarding/learning journey catalog."
+  },
+  io: {
+    input: ListOnboardingTracksInput,
+    output: ListOnboardingTracksOutput
+  },
+  policy: {
+    auth: "user"
+  }
+});
+var GetOnboardingProgressContract = defineQuery2({
+  meta: {
+    key: "learning.onboarding.getProgress",
+    version: "1.0.0",
+    stability: "stable",
+    owners: [...LEARNING_JOURNEY_OWNERS],
+    tags: ["learning", "onboarding", "journey"],
+    description: "Fetch onboarding progress for a specific track.",
+    goal: "Display learner progress and remaining steps.",
+    context: "Called when rendering a track detail or widget."
+  },
+  io: {
+    input: GetOnboardingProgressInput,
+    output: OnboardingProgressModel
+  },
+  policy: {
+    auth: "user"
+  }
+});
+var RecordOnboardingEventContract = defineCommand2({
+  meta: {
+    key: "learning.onboarding.recordEvent",
+    version: "1.0.0",
+    stability: "stable",
+    owners: [...LEARNING_JOURNEY_OWNERS],
+    tags: ["learning", "onboarding", "events"],
+    description: "Record a domain event to evaluate onboarding step completion conditions.",
+    goal: "Advance onboarding automatically from product events.",
+    context: "Called by event bus handlers when relevant product events fire (e.g., deal.created)."
+  },
+  io: {
+    input: RecordOnboardingEventInput,
+    output: SuccessOutput,
+    errors: {
+      TRACK_NOT_FOUND: {
+        description: "Track not found for event routing",
+        http: 404,
+        gqlCode: "TRACK_NOT_FOUND",
+        when: "Track ID or routing context is invalid"
+      },
+      STEP_NOT_FOUND: {
+        description: "Step not found for completion condition",
+        http: 404,
+        gqlCode: "STEP_NOT_FOUND",
+        when: "No step matches the incoming event"
+      }
+    }
+  },
+  policy: {
+    auth: "user"
+  }
+});
+// src/docs/learning-journey.docblock.ts
+import { registerDocBlocks } from "@contractspec/lib.contracts/docs";
+var learningJourneyDocBlocks = [
+  {
+    id: "docs.learning-journey.engine",
+    title: "Learning Journey Engine",
+    summary: "Tracks learners, tracks/modules/steps, progress, quizzes, streaks, XP, and AI coaching hooks for product-integrated onboarding.",
+    kind: "reference",
+    visibility: "public",
+    route: "/docs/learning-journey/engine",
+    tags: ["learning", "onboarding", "journey", "education"],
+    body: `## Capabilities
+
+- **Entities**: Learner, Track, Module, Step, Progress, Quiz, Flashcard, AI Coach, Gamification (XP, streaks, badges).
+- **Contracts**: enroll/resume/advance steps, complete quizzes, record streaks, assign XP, fetch progress dashboards, onboarding list/progress/recordEvent.
+- **Engines**: spaced-repetition (SRS), streak calculator, XP progression.
+- **Events**: learner.enrolled, step.completed, quiz.scored, streak.reset, xp.awarded, onboarding.started/completed/step_completed.
+
+## Completion conditions
+- Event-based: name/version/source + payload filter
+- Count-based: require N events (optional time window)
+- Time-bounded: must complete within a window; steps can unlock by day/hour
+- SRS mastery: complete when cards/skills hit mastery thresholds (with required counts)
+
+## Usage
+
+1) Compose schema
+- Include \`learningJourneySchemaContribution\` (entities export) in composition.
+
+2) Register contracts/events
+- Import from \`@contractspec/module.learning-journey\` into your spec registry.
+
+3) Bind to product actions
+- Tie \`Step\` completion conditions to domain events (e.g., deal.created, agent.run.completed, drill.session.completed).
+- Trigger notifications via Notification Center and audits on completion.
+
+4) Gamification
+- Use \`XP\` and \`Streak\` engines to update learner stats; emit analytics for UI.
+
+## Example
+
+${"```"}ts
+import { learningJourneyEntities } from '@contractspec/module.learning-journey';
+import { StreakEngine } from '@contractspec/module.learning-journey/engines';
+
+const streak = new StreakEngine({ graceDays: 1 });
+const updated = streak.compute({ lastActiveAt: new Date(), today: new Date() });
+${"```"},
+
+## Guardrails
+
+- Keep steps bound to real product events, not just button clicks.
+- Avoid storing PII in content; keep org/user scoping for multi-tenant isolation.
+- Emit analytics and audit logs for completions; respect \`prefers-reduced-motion\` in UIs consuming these specs.
+- Track completion bonuses: \`completionXpBonus\`, \`completionBadgeKey\`, optional \`streakHoursWindow\` + \`streakBonusXp\`.
+`
+  },
+  {
+    id: "docs.learning-journey.goal",
+    title: "Learning Journey — Goal",
+    summary: "Why the learning journey engine exists and the outcomes it targets.",
+    kind: "goal",
+    visibility: "public",
+    route: "/docs/learning-journey/goal",
+    tags: ["learning", "goal"],
+    body: `## Why it matters
+- Provides a regenerable onboarding/education engine tied to product signals.
+- Keeps tracks, steps, quizzes, and gamification consistent across surfaces.
+
+## Business/Product goal
+- Drive activation and retention with measurable progress, SRS, and streaks.
+- Allow product teams to adjust journeys safely via specs.
+
+## Success criteria
+- Journey changes regenerate UI/API/events without drift.
+- Analytics/audit hooks exist for completions and streaks.`
+  },
+  {
+    id: "docs.learning-journey.usage",
+    title: "Learning Journey — Usage",
+    summary: "How to compose, bind, and regenerate journeys safely.",
+    kind: "usage",
+    visibility: "public",
+    route: "/docs/learning-journey/usage",
+    tags: ["learning", "usage"],
+    body: `## Setup
+1) Include \`learningJourneyEntities\` in schema composition.
+2) Register contracts/events from \`@contractspec/module.learning-journey\`.
+3) Bind steps to real product events (e.g., deal.created, run.completed).
+
+## Extend & regenerate
+1) Update track/module/step definitions or quiz schemas in spec.
+2) Regenerate to sync UI/API/events; mark PII paths where needed.
+3) Use Feature Flags to trial new tracks or streak rules.
+
+## Guardrails
+- Avoid hardcoded progression; keep engines declarative.
+- Emit analytics/audit for completions; respect user locale/accessibility in presentations.
+- Keep content free of PII; scope learners by org/tenant.`
+  },
+  {
+    id: "docs.learning-journey.constraints",
+    title: "Learning Journey — Constraints & Safety",
+    summary: "Internal guardrails for progression, telemetry, and regeneration semantics.",
+    kind: "reference",
+    visibility: "internal",
+    route: "/docs/learning-journey/constraints",
+    tags: ["learning", "constraints", "internal"],
+    body: `## Constraints
+- Progression (tracks/modules/steps) and engines (SRS, streaks, XP) must stay declarative in spec.
+- Events to emit: learner.enrolled, step.completed, quiz.scored, streak.reset, xp.awarded.
+- Regeneration should not change scoring/streak rules without explicit spec change.
+
+## PII & Telemetry
+- Mark PII (learner identifiers) and redact in presentations; keep telemetry aggregated when possible.
+- Respect accessibility (prefers-reduced-motion) in UIs consuming these specs.
+
+## Verification
+- Add fixtures for streak/XP rule changes and quiz scoring.
+- Ensure Notifications/Audit wiring persists for completions; analytics emitted for progress.
+- Use Feature Flags to trial new tracks or reward rules; default safe/off.`
+  }
+];
+registerDocBlocks(learningJourneyDocBlocks);
+// src/engines/srs.ts
+var DEFAULT_SRS_CONFIG = {
+  learningSteps: [1, 10],
+  graduatingInterval: 1,
+  easyInterval: 4,
+  relearningSteps: [10],
+  minEaseFactor: 1.3,
+  maxInterval: 365,
+  intervalModifier: 1,
+  newIntervalModifier: 0.5,
+  hardIntervalModifier: 1.2,
+  easyBonus: 1.3
+};
+
+class SRSEngine {
+  config;
+  constructor(config = {}) {
+    this.config = { ...DEFAULT_SRS_CONFIG, ...config };
+  }
+  calculateNextReview(state, rating, now = new Date) {
+    if (!state.isGraduated && !state.isRelearning) {
+      return this.handleLearningCard(state, rating, now);
+    }
+    if (state.isRelearning) {
+      return this.handleRelearningCard(state, rating, now);
+    }
+    return this.handleReviewCard(state, rating, now);
+  }
+  getInitialState() {
+    return {
+      interval: 0,
+      easeFactor: 2.5,
+      repetitions: 0,
+      learningStep: 0,
+      isGraduated: false,
+      isRelearning: false,
+      lapses: 0
+    };
+  }
+  isDue(nextReviewAt, now = new Date) {
+    return nextReviewAt <= now;
+  }
+  getOverdueDays(nextReviewAt, now = new Date) {
+    const diff = now.getTime() - nextReviewAt.getTime();
+    return Math.floor(diff / (1000 * 60 * 60 * 24));
+  }
+  handleLearningCard(state, rating, now) {
+    const steps = this.config.learningSteps;
+    let newStep = state.learningStep;
+    let isGraduated = false;
+    let interval = 0;
+    let nextReviewAt;
+    switch (rating) {
+      case "AGAIN":
+        newStep = 0;
+        interval = steps[0] ?? 1;
+        nextReviewAt = this.addMinutes(now, interval);
+        break;
+      case "HARD":
+        interval = steps[newStep] ?? steps[0] ?? 1;
+        nextReviewAt = this.addMinutes(now, interval);
+        break;
+      case "GOOD":
+        newStep++;
+        if (newStep >= steps.length) {
+          isGraduated = true;
+          interval = this.config.graduatingInterval;
+          nextReviewAt = this.addDays(now, interval);
+        } else {
+          interval = steps[newStep] ?? 10;
+          nextReviewAt = this.addMinutes(now, interval);
+        }
+        break;
+      case "EASY":
+        isGraduated = true;
+        interval = this.config.easyInterval;
+        nextReviewAt = this.addDays(now, interval);
+        break;
+    }
+    return {
+      interval: isGraduated ? interval : 0,
+      easeFactor: state.easeFactor,
+      repetitions: isGraduated ? 1 : 0,
+      nextReviewAt,
+      learningStep: newStep,
+      isGraduated,
+      isRelearning: false,
+      lapses: state.lapses
+    };
+  }
+  handleRelearningCard(state, rating, now) {
+    const steps = this.config.relearningSteps;
+    let newStep = state.learningStep;
+    let isRelearning = true;
+    let interval = 0;
+    let nextReviewAt;
+    switch (rating) {
+      case "AGAIN":
+        newStep = 0;
+        interval = steps[0] ?? 10;
+        nextReviewAt = this.addMinutes(now, interval);
+        break;
+      case "HARD":
+        interval = steps[newStep] ?? steps[0] ?? 10;
+        nextReviewAt = this.addMinutes(now, interval);
+        break;
+      case "GOOD":
+        newStep++;
+        if (newStep >= steps.length) {
+          isRelearning = false;
+          interval = Math.max(1, Math.floor(state.interval * this.config.newIntervalModifier));
+          nextReviewAt = this.addDays(now, interval);
+        } else {
+          interval = steps[newStep] ?? 10;
+          nextReviewAt = this.addMinutes(now, interval);
+        }
+        break;
+      case "EASY":
+        isRelearning = false;
+        interval = Math.max(1, Math.floor(state.interval * this.config.newIntervalModifier * 1.5));
+        nextReviewAt = this.addDays(now, interval);
+        break;
+    }
+    return {
+      interval: isRelearning ? state.interval : interval,
+      easeFactor: state.easeFactor,
+      repetitions: isRelearning ? state.repetitions : state.repetitions + 1,
+      nextReviewAt,
+      learningStep: newStep,
+      isGraduated: true,
+      isRelearning,
+      lapses: state.lapses
+    };
+  }
+  handleReviewCard(state, rating, now) {
+    let newInterval;
+    let newEaseFactor = state.easeFactor;
+    let repetitions = state.repetitions;
+    let isRelearning = false;
+    let learningStep = 0;
+    let lapses = state.lapses;
+    switch (rating) {
+      case "AGAIN":
+        lapses++;
+        isRelearning = true;
+        learningStep = 0;
+        newEaseFactor = Math.max(this.config.minEaseFactor, newEaseFactor - 0.2);
+        newInterval = state.interval;
+        return {
+          interval: newInterval,
+          easeFactor: newEaseFactor,
+          repetitions,
+          nextReviewAt: this.addMinutes(now, this.config.relearningSteps[0] ?? 10),
+          learningStep,
+          isGraduated: true,
+          isRelearning: true,
+          lapses
+        };
+      case "HARD":
+        newEaseFactor = Math.max(this.config.minEaseFactor, newEaseFactor - 0.15);
+        newInterval = Math.max(state.interval + 1, state.interval * this.config.hardIntervalModifier);
+        break;
+      case "GOOD":
+        newInterval = state.interval * newEaseFactor * this.config.intervalModifier;
+        repetitions++;
+        break;
+      case "EASY":
+        newEaseFactor = newEaseFactor + 0.15;
+        newInterval = state.interval * newEaseFactor * this.config.easyBonus * this.config.intervalModifier;
+        repetitions++;
+        break;
+    }
+    newInterval = Math.min(Math.round(newInterval), this.config.maxInterval);
+    newInterval = Math.max(1, newInterval);
+    return {
+      interval: newInterval,
+      easeFactor: newEaseFactor,
+      repetitions,
+      nextReviewAt: this.addDays(now, newInterval),
+      learningStep,
+      isGraduated: true,
+      isRelearning,
+      lapses
+    };
+  }
+  addMinutes(date, minutes) {
+    return new Date(date.getTime() + minutes * 60 * 1000);
+  }
+  addDays(date, days) {
+    return new Date(date.getTime() + days * 24 * 60 * 60 * 1000);
+  }
+}
+var srsEngine = new SRSEngine;
+
+// src/engines/xp.ts
+var DEFAULT_XP_CONFIG = {
+  baseValues: {
+    lesson_complete: 10,
+    quiz_pass: 20,
+    quiz_perfect: 50,
+    flashcard_review: 1,
+    course_complete: 200,
+    module_complete: 50,
+    streak_bonus: 5,
+    achievement_unlock: 0,
+    daily_goal_complete: 15,
+    first_lesson: 25,
+    onboarding_step: 5,
+    onboarding_complete: 50
+  },
+  scoreThresholds: [
+    { min: 90, multiplier: 1.5 },
+    { min: 80, multiplier: 1.25 },
+    { min: 70, multiplier: 1 },
+    { min: 60, multiplier: 0.75 },
+    { min: 0, multiplier: 0.5 }
+  ],
+  streakTiers: [
+    { days: 365, bonus: 50 },
+    { days: 180, bonus: 30 },
+    { days: 90, bonus: 20 },
+    { days: 30, bonus: 15 },
+    { days: 14, bonus: 10 },
+    { days: 7, bonus: 5 },
+    { days: 3, bonus: 2 },
+    { days: 1, bonus: 0 }
+  ],
+  perfectScoreMultiplier: 1.5,
+  firstAttemptBonus: 10,
+  retryPenalty: 0.5,
+  speedBonusMultiplier: 1.2,
+  speedBonusThreshold: 0.8
+};
+
+class XPEngine {
+  config;
+  constructor(config = {}) {
+    this.config = {
+      ...DEFAULT_XP_CONFIG,
+      ...config,
+      baseValues: { ...DEFAULT_XP_CONFIG.baseValues, ...config.baseValues },
+      scoreThresholds: config.scoreThresholds || DEFAULT_XP_CONFIG.scoreThresholds,
+      streakTiers: config.streakTiers || DEFAULT_XP_CONFIG.streakTiers
+    };
+  }
+  calculate(input) {
+    const breakdown = [];
+    const baseXp = input.baseXp ?? this.config.baseValues[input.activity];
+    let totalXp = baseXp;
+    breakdown.push({
+      source: "base",
+      amount: baseXp
+    });
+    if (input.score !== undefined) {
+      const scoreMultiplier = this.getScoreMultiplier(input.score);
+      if (scoreMultiplier !== 1) {
+        const scoreBonus = Math.round(baseXp * (scoreMultiplier - 1));
+        totalXp += scoreBonus;
+        breakdown.push({
+          source: "score_bonus",
+          amount: scoreBonus,
+          multiplier: scoreMultiplier
+        });
+      }
+      if (input.score === 100) {
+        const perfectBonus = Math.round(baseXp * (this.config.perfectScoreMultiplier - 1));
+        totalXp += perfectBonus;
+        breakdown.push({
+          source: "perfect_score",
+          amount: perfectBonus,
+          multiplier: this.config.perfectScoreMultiplier
+        });
+      }
+    }
+    if (input.attemptNumber === 1 && !input.isRetry) {
+      totalXp += this.config.firstAttemptBonus;
+      breakdown.push({
+        source: "first_attempt",
+        amount: this.config.firstAttemptBonus
+      });
+    }
+    if (input.isRetry) {
+      const penalty = Math.round(totalXp * (1 - this.config.retryPenalty));
+      totalXp -= penalty;
+      breakdown.push({
+        source: "retry_penalty",
+        amount: -penalty,
+        multiplier: this.config.retryPenalty
+      });
+    }
+    if (input.currentStreak && input.currentStreak > 0) {
+      const streakBonus = this.getStreakBonus(input.currentStreak);
+      if (streakBonus > 0) {
+        totalXp += streakBonus;
+        breakdown.push({
+          source: "streak_bonus",
+          amount: streakBonus
+        });
+      }
+    }
+    if (baseXp > 0) {
+      totalXp = Math.max(1, totalXp);
+    }
+    return {
+      totalXp: Math.round(totalXp),
+      baseXp,
+      breakdown
+    };
+  }
+  calculateStreakBonus(currentStreak) {
+    const bonus = this.getStreakBonus(currentStreak);
+    return {
+      totalXp: bonus,
+      baseXp: bonus,
+      breakdown: [
+        {
+          source: "streak_bonus",
+          amount: bonus
+        }
+      ]
+    };
+  }
+  getXpForLevel(level) {
+    if (level <= 1)
+      return 0;
+    return Math.round(100 * Math.pow(level - 1, 1.5));
+  }
+  getLevelFromXp(totalXp) {
+    let level = 1;
+    let xpRequired = this.getXpForLevel(level + 1);
+    while (totalXp >= xpRequired && level < 1000) {
+      level++;
+      xpRequired = this.getXpForLevel(level + 1);
+    }
+    const xpForCurrentLevel = this.getXpForLevel(level);
+    const xpForNextLevel = this.getXpForLevel(level + 1);
+    return {
+      level,
+      xpInLevel: totalXp - xpForCurrentLevel,
+      xpForNextLevel: xpForNextLevel - xpForCurrentLevel
+    };
+  }
+  getScoreMultiplier(score) {
+    for (const threshold of this.config.scoreThresholds) {
+      if (score >= threshold.min) {
+        return threshold.multiplier;
+      }
+    }
+    return 1;
+  }
+  getStreakBonus(streak) {
+    for (const tier of this.config.streakTiers) {
+      if (streak >= tier.days) {
+        return tier.bonus;
+      }
+    }
+    return 0;
+  }
+}
+var xpEngine = new XPEngine;
+
+// src/engines/streak.ts
+var DEFAULT_STREAK_CONFIG = {
+  timezone: "UTC",
+  freezesPerMonth: 2,
+  maxFreezes: 5,
+  gracePeriodHours: 4
+};
+
+class StreakEngine {
+  config;
+  constructor(config = {}) {
+    this.config = { ...DEFAULT_STREAK_CONFIG, ...config };
+  }
+  update(state, now = new Date) {
+    const todayDate = this.getDateString(now);
+    const result = {
+      state: { ...state },
+      streakMaintained: false,
+      streakLost: false,
+      freezeUsed: false,
+      newStreak: false,
+      daysMissed: 0
+    };
+    if (!state.lastActivityDate) {
+      result.state.currentStreak = 1;
+      result.state.longestStreak = Math.max(1, state.longestStreak);
+      result.state.lastActivityAt = now;
+      result.state.lastActivityDate = todayDate;
+      result.newStreak = true;
+      result.streakMaintained = true;
+      return result;
+    }
+    if (state.lastActivityDate === todayDate) {
+      result.state.lastActivityAt = now;
+      result.streakMaintained = true;
+      return result;
+    }
+    const daysSinceActivity = this.getDaysBetween(state.lastActivityDate, todayDate);
+    if (daysSinceActivity === 1) {
+      result.state.currentStreak = state.currentStreak + 1;
+      result.state.longestStreak = Math.max(result.state.currentStreak, state.longestStreak);
+      result.state.lastActivityAt = now;
+      result.state.lastActivityDate = todayDate;
+      result.streakMaintained = true;
+      return result;
+    }
+    result.daysMissed = daysSinceActivity - 1;
+    const freezesNeeded = result.daysMissed;
+    if (freezesNeeded <= state.freezesRemaining) {
+      result.state.freezesRemaining = state.freezesRemaining - freezesNeeded;
+      result.state.freezeUsedAt = now;
+      result.state.currentStreak = state.currentStreak + 1;
+      result.state.longestStreak = Math.max(result.state.currentStreak, state.longestStreak);
+      result.state.lastActivityAt = now;
+      result.state.lastActivityDate = todayDate;
+      result.freezeUsed = true;
+      result.streakMaintained = true;
+      return result;
+    }
+    result.streakLost = true;
+    result.state.currentStreak = 1;
+    result.state.lastActivityAt = now;
+    result.state.lastActivityDate = todayDate;
+    result.newStreak = true;
+    return result;
+  }
+  checkStatus(state, now = new Date) {
+    if (!state.lastActivityDate) {
+      return {
+        isActive: false,
+        willExpireAt: null,
+        canUseFreeze: false,
+        daysUntilExpiry: 0
+      };
+    }
+    const todayDate = this.getDateString(now);
+    const daysSinceActivity = this.getDaysBetween(state.lastActivityDate, todayDate);
+    if (daysSinceActivity === 0) {
+      const tomorrow = this.addDays(now, 1);
+      tomorrow.setHours(23, 59, 59, 999);
+      return {
+        isActive: true,
+        willExpireAt: tomorrow,
+        canUseFreeze: state.freezesRemaining > 0,
+        daysUntilExpiry: 1
+      };
+    }
+    if (daysSinceActivity === 1) {
+      const endOfDay = new Date(now);
+      endOfDay.setHours(23 + this.config.gracePeriodHours, 59, 59, 999);
+      return {
+        isActive: true,
+        willExpireAt: endOfDay,
+        canUseFreeze: state.freezesRemaining > 0,
+        daysUntilExpiry: 0
+      };
+    }
+    const missedDays = daysSinceActivity - 1;
+    return {
+      isActive: missedDays <= state.freezesRemaining,
+      willExpireAt: null,
+      canUseFreeze: missedDays <= state.freezesRemaining,
+      daysUntilExpiry: -missedDays
+    };
+  }
+  useFreeze(state, now = new Date) {
+    if (state.freezesRemaining <= 0) {
+      return null;
+    }
+    return {
+      ...state,
+      freezesRemaining: state.freezesRemaining - 1,
+      freezeUsedAt: now
+    };
+  }
+  awardMonthlyFreezes(state) {
+    return {
+      ...state,
+      freezesRemaining: Math.min(state.freezesRemaining + this.config.freezesPerMonth, this.config.maxFreezes)
+    };
+  }
+  getInitialState() {
+    return {
+      currentStreak: 0,
+      longestStreak: 0,
+      lastActivityAt: null,
+      lastActivityDate: null,
+      freezesRemaining: this.config.freezesPerMonth,
+      freezeUsedAt: null
+    };
+  }
+  getMilestones(currentStreak) {
+    const milestones = [3, 7, 14, 30, 60, 90, 180, 365, 500, 1000];
+    const achieved = milestones.filter((m) => currentStreak >= m);
+    const next = milestones.find((m) => currentStreak < m) ?? null;
+    return { achieved, next };
+  }
+  getDateString(date) {
+    const year = date.getFullYear();
+    const month = String(date.getMonth() + 1).padStart(2, "0");
+    const day = String(date.getDate()).padStart(2, "0");
+    return `${year}-${month}-${day}`;
+  }
+  getDaysBetween(dateStr1, dateStr2) {
+    const date1 = new Date(dateStr1);
+    const date2 = new Date(dateStr2);
+    const diffTime = date2.getTime() - date1.getTime();
+    return Math.floor(diffTime / (1000 * 60 * 60 * 24));
+  }
+  addDays(date, days) {
+    return new Date(date.getTime() + days * 24 * 60 * 60 * 1000);
+  }
+}
+var streakEngine = new StreakEngine;
+// 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
+};
+
+// src/events.ts
+import { ScalarTypeEnum as ScalarTypeEnum3, defineSchemaModel as defineSchemaModel3 } from "@contractspec/lib.schema";
+import { defineEvent } from "@contractspec/lib.contracts";
+var CoursePublishedPayload = defineSchemaModel3({
+  name: "CoursePublishedEventPayload",
+  description: "Payload when a course is published",
+  fields: {
+    courseId: { type: ScalarTypeEnum3.String_unsecure(), isOptional: false },
+    title: { type: ScalarTypeEnum3.String_unsecure(), isOptional: false },
+    authorId: { type: ScalarTypeEnum3.String_unsecure(), isOptional: false },
+    publishedAt: { type: ScalarTypeEnum3.DateTime(), isOptional: false }
+  }
+});
+var CoursePublishedEvent = defineEvent({
+  meta: {
+    key: "course.published",
+    version: "1.0.0",
+    description: "A course has been published.",
+    stability: "stable",
+    owners: [...LEARNING_JOURNEY_OWNERS],
+    tags: ["learning", "course"]
+  },
+  payload: CoursePublishedPayload
+});
+var EnrollmentCreatedPayload = defineSchemaModel3({
+  name: "EnrollmentCreatedEventPayload",
+  description: "Payload when a learner enrolls in a course",
+  fields: {
+    enrollmentId: { type: ScalarTypeEnum3.String_unsecure(), isOptional: false },
+    learnerId: { type: ScalarTypeEnum3.String_unsecure(), isOptional: false },
+    courseId: { type: ScalarTypeEnum3.String_unsecure(), isOptional: false },
+    enrolledAt: { type: ScalarTypeEnum3.DateTime(), isOptional: false }
+  }
+});
+var EnrollmentCreatedEvent = defineEvent({
+  meta: {
+    key: "enrollment.created",
+    version: "1.0.0",
+    description: "A learner has enrolled in a course.",
+    stability: "stable",
+    owners: [...LEARNING_JOURNEY_OWNERS],
+    tags: ["learning", "enrollment"]
+  },
+  payload: EnrollmentCreatedPayload
+});
+var LessonCompletedPayload = defineSchemaModel3({
+  name: "LessonCompletedEventPayload",
+  description: "Payload when a lesson is completed",
+  fields: {
+    learnerId: { type: ScalarTypeEnum3.String_unsecure(), isOptional: false },
+    lessonId: { type: ScalarTypeEnum3.String_unsecure(), isOptional: false },
+    courseId: { type: ScalarTypeEnum3.String_unsecure(), isOptional: false },
+    score: { type: ScalarTypeEnum3.Int_unsecure(), isOptional: true },
+    xpEarned: { type: ScalarTypeEnum3.Int_unsecure(), isOptional: false },
+    timeSpent: { type: ScalarTypeEnum3.Int_unsecure(), isOptional: false },
+    completedAt: { type: ScalarTypeEnum3.DateTime(), isOptional: false }
+  }
+});
+var LessonCompletedEvent = defineEvent({
+  meta: {
+    key: "lesson.completed",
+    version: "1.0.0",
+    description: "A learner has completed a lesson.",
+    stability: "stable",
+    owners: [...LEARNING_JOURNEY_OWNERS],
+    tags: ["learning", "progress", "lesson"]
+  },
+  payload: LessonCompletedPayload
+});
+var CourseCompletedPayload = defineSchemaModel3({
+  name: "CourseCompletedEventPayload",
+  description: "Payload when a course is completed",
+  fields: {
+    learnerId: { type: ScalarTypeEnum3.String_unsecure(), isOptional: false },
+    courseId: { type: ScalarTypeEnum3.String_unsecure(), isOptional: false },
+    enrollmentId: { type: ScalarTypeEnum3.String_unsecure(), isOptional: false },
+    score: { type: ScalarTypeEnum3.Int_unsecure(), isOptional: true },
+    xpEarned: { type: ScalarTypeEnum3.Int_unsecure(), isOptional: false },
+    certificateId: { type: ScalarTypeEnum3.String_unsecure(), isOptional: true },
+    completedAt: { type: ScalarTypeEnum3.DateTime(), isOptional: false }
+  }
+});
+var CourseCompletedEvent = defineEvent({
+  meta: {
+    key: "course.completed",
+    version: "1.0.0",
+    description: "A learner has completed a course.",
+    stability: "stable",
+    owners: [...LEARNING_JOURNEY_OWNERS],
+    tags: ["learning", "progress", "course"]
+  },
+  payload: CourseCompletedPayload
+});
+var OnboardingStartedPayload = defineSchemaModel3({
+  name: "OnboardingStartedEventPayload",
+  description: "Payload when onboarding starts",
+  fields: {
+    learnerId: { type: ScalarTypeEnum3.String_unsecure(), isOptional: false },
+    trackId: { type: ScalarTypeEnum3.String_unsecure(), isOptional: false },
+    productId: { type: ScalarTypeEnum3.String_unsecure(), isOptional: false },
+    startedAt: { type: ScalarTypeEnum3.DateTime(), isOptional: false }
+  }
+});
+var OnboardingStartedEvent = defineEvent({
+  meta: {
+    key: "onboarding.started",
+    version: "1.0.0",
+    description: "A learner has started onboarding.",
+    stability: "stable",
+    owners: [...LEARNING_JOURNEY_OWNERS],
+    tags: ["learning", "onboarding"]
+  },
+  payload: OnboardingStartedPayload
+});
+var OnboardingStepCompletedPayload = defineSchemaModel3({
+  name: "OnboardingStepCompletedEventPayload",
+  description: "Payload when an onboarding step is completed",
+  fields: {
+    learnerId: { type: ScalarTypeEnum3.String_unsecure(), isOptional: false },
+    trackId: { type: ScalarTypeEnum3.String_unsecure(), isOptional: false },
+    stepId: { type: ScalarTypeEnum3.String_unsecure(), isOptional: false },
+    triggeringEvent: {
+      type: ScalarTypeEnum3.String_unsecure(),
+      isOptional: true
+    },
+    xpEarned: { type: ScalarTypeEnum3.Int_unsecure(), isOptional: false },
+    completedAt: { type: ScalarTypeEnum3.DateTime(), isOptional: false }
+  }
+});
+var OnboardingStepCompletedEvent = defineEvent({
+  meta: {
+    key: "onboarding.step_completed",
+    version: "1.0.0",
+    description: "An onboarding step has been completed.",
+    stability: "stable",
+    owners: [...LEARNING_JOURNEY_OWNERS],
+    tags: ["learning", "onboarding"]
+  },
+  payload: OnboardingStepCompletedPayload
+});
+var OnboardingCompletedPayload = defineSchemaModel3({
+  name: "OnboardingCompletedEventPayload",
+  description: "Payload when onboarding is completed",
+  fields: {
+    learnerId: { type: ScalarTypeEnum3.String_unsecure(), isOptional: false },
+    trackId: { type: ScalarTypeEnum3.String_unsecure(), isOptional: false },
+    productId: { type: ScalarTypeEnum3.String_unsecure(), isOptional: false },
+    xpEarned: { type: ScalarTypeEnum3.Int_unsecure(), isOptional: false },
+    completedAt: { type: ScalarTypeEnum3.DateTime(), isOptional: false }
+  }
+});
+var OnboardingCompletedEvent = defineEvent({
+  meta: {
+    key: "onboarding.completed",
+    version: "1.0.0",
+    description: "A learner has completed onboarding.",
+    stability: "stable",
+    owners: [...LEARNING_JOURNEY_OWNERS],
+    tags: ["learning", "onboarding"]
+  },
+  payload: OnboardingCompletedPayload
+});
+var CardReviewedPayload = defineSchemaModel3({
+  name: "CardReviewedEventPayload",
+  description: "Payload when a flashcard is reviewed",
+  fields: {
+    learnerId: { type: ScalarTypeEnum3.String_unsecure(), isOptional: false },
+    cardId: { type: ScalarTypeEnum3.String_unsecure(), isOptional: false },
+    deckId: { type: ScalarTypeEnum3.String_unsecure(), isOptional: false },
+    rating: { type: ScalarTypeEnum3.String_unsecure(), isOptional: false },
+    responseTimeMs: { type: ScalarTypeEnum3.Int_unsecure(), isOptional: true },
+    reviewedAt: { type: ScalarTypeEnum3.DateTime(), isOptional: false }
+  }
+});
+var CardReviewedEvent = defineEvent({
+  meta: {
+    key: "flashcard.reviewed",
+    version: "1.0.0",
+    description: "A flashcard has been reviewed.",
+    stability: "stable",
+    owners: [...LEARNING_JOURNEY_OWNERS],
+    tags: ["learning", "flashcards"]
+  },
+  payload: CardReviewedPayload
+});
+var QuizStartedPayload = defineSchemaModel3({
+  name: "QuizStartedEventPayload",
+  description: "Payload when a quiz is started",
+  fields: {
+    learnerId: { type: ScalarTypeEnum3.String_unsecure(), isOptional: false },
+    quizId: { type: ScalarTypeEnum3.String_unsecure(), isOptional: false },
+    attemptId: { type: ScalarTypeEnum3.String_unsecure(), isOptional: false },
+    attemptNumber: { type: ScalarTypeEnum3.Int_unsecure(), isOptional: false },
+    startedAt: { type: ScalarTypeEnum3.DateTime(), isOptional: false }
+  }
+});
+var QuizStartedEvent = defineEvent({
+  meta: {
+    key: "quiz.started",
+    version: "1.0.0",
+    description: "A quiz attempt has started.",
+    stability: "stable",
+    owners: [...LEARNING_JOURNEY_OWNERS],
+    tags: ["learning", "quiz"]
+  },
+  payload: QuizStartedPayload
+});
+var QuizCompletedPayload = defineSchemaModel3({
+  name: "QuizCompletedEventPayload",
+  description: "Payload when a quiz is completed",
+  fields: {
+    learnerId: { type: ScalarTypeEnum3.String_unsecure(), isOptional: false },
+    quizId: { type: ScalarTypeEnum3.String_unsecure(), isOptional: false },
+    attemptId: { type: ScalarTypeEnum3.String_unsecure(), isOptional: false },
+    score: { type: ScalarTypeEnum3.Int_unsecure(), isOptional: false },
+    percentageScore: { type: ScalarTypeEnum3.Int_unsecure(), isOptional: false },
+    passed: { type: ScalarTypeEnum3.Boolean(), isOptional: false },
+    xpEarned: { type: ScalarTypeEnum3.Int_unsecure(), isOptional: false },
+    timeSpent: { type: ScalarTypeEnum3.Int_unsecure(), isOptional: false },
+    completedAt: { type: ScalarTypeEnum3.DateTime(), isOptional: false }
+  }
+});
+var QuizCompletedEvent = defineEvent({
+  meta: {
+    key: "quiz.completed",
+    version: "1.0.0",
+    description: "A quiz attempt has been completed.",
+    stability: "stable",
+    owners: [...LEARNING_JOURNEY_OWNERS],
+    tags: ["learning", "quiz"]
+  },
+  payload: QuizCompletedPayload
+});
+var XpEarnedPayload = defineSchemaModel3({
+  name: "XpEarnedEventPayload",
+  description: "Payload when XP is earned",
+  fields: {
+    learnerId: { type: ScalarTypeEnum3.String_unsecure(), isOptional: false },
+    amount: { type: ScalarTypeEnum3.Int_unsecure(), isOptional: false },
+    source: { type: ScalarTypeEnum3.String_unsecure(), isOptional: false },
+    sourceId: { type: ScalarTypeEnum3.String_unsecure(), isOptional: true },
+    totalXp: { type: ScalarTypeEnum3.Int_unsecure(), isOptional: false },
+    earnedAt: { type: ScalarTypeEnum3.DateTime(), isOptional: false }
+  }
+});
+var XpEarnedEvent = defineEvent({
+  meta: {
+    key: "xp.earned",
+    version: "1.0.0",
+    description: "XP has been earned.",
+    stability: "stable",
+    owners: [...LEARNING_JOURNEY_OWNERS],
+    tags: ["learning", "gamification", "xp"]
+  },
+  payload: XpEarnedPayload
+});
+var LevelUpPayload = defineSchemaModel3({
+  name: "LevelUpEventPayload",
+  description: "Payload when a learner levels up",
+  fields: {
+    learnerId: { type: ScalarTypeEnum3.String_unsecure(), isOptional: false },
+    previousLevel: { type: ScalarTypeEnum3.Int_unsecure(), isOptional: false },
+    newLevel: { type: ScalarTypeEnum3.Int_unsecure(), isOptional: false },
+    totalXp: { type: ScalarTypeEnum3.Int_unsecure(), isOptional: false },
+    leveledUpAt: { type: ScalarTypeEnum3.DateTime(), isOptional: false }
+  }
+});
+var LevelUpEvent = defineEvent({
+  meta: {
+    key: "level.up",
+    version: "1.0.0",
+    description: "A learner has leveled up.",
+    stability: "stable",
+    owners: [...LEARNING_JOURNEY_OWNERS],
+    tags: ["learning", "gamification", "level"]
+  },
+  payload: LevelUpPayload
+});
+var StreakUpdatedPayload = defineSchemaModel3({
+  name: "StreakUpdatedEventPayload",
+  description: "Payload when a streak is updated",
+  fields: {
+    learnerId: { type: ScalarTypeEnum3.String_unsecure(), isOptional: false },
+    previousStreak: { type: ScalarTypeEnum3.Int_unsecure(), isOptional: false },
+    currentStreak: { type: ScalarTypeEnum3.Int_unsecure(), isOptional: false },
+    longestStreak: { type: ScalarTypeEnum3.Int_unsecure(), isOptional: false },
+    freezeUsed: { type: ScalarTypeEnum3.Boolean(), isOptional: false },
+    updatedAt: { type: ScalarTypeEnum3.DateTime(), isOptional: false }
+  }
+});
+var StreakUpdatedEvent = defineEvent({
+  meta: {
+    key: "streak.updated",
+    version: "1.0.0",
+    description: "A streak has been updated.",
+    stability: "stable",
+    owners: [...LEARNING_JOURNEY_OWNERS],
+    tags: ["learning", "gamification", "streak"]
+  },
+  payload: StreakUpdatedPayload
+});
+var AchievementUnlockedPayload = defineSchemaModel3({
+  name: "AchievementUnlockedEventPayload",
+  description: "Payload when an achievement is unlocked",
+  fields: {
+    learnerId: { type: ScalarTypeEnum3.String_unsecure(), isOptional: false },
+    achievementId: {
+      type: ScalarTypeEnum3.String_unsecure(),
+      isOptional: false
+    },
+    achievementKey: {
+      type: ScalarTypeEnum3.String_unsecure(),
+      isOptional: false
+    },
+    achievementName: {
+      type: ScalarTypeEnum3.String_unsecure(),
+      isOptional: false
+    },
+    xpEarned: { type: ScalarTypeEnum3.Int_unsecure(), isOptional: false },
+    unlockedAt: { type: ScalarTypeEnum3.DateTime(), isOptional: false }
+  }
+});
+var AchievementUnlockedEvent = defineEvent({
+  meta: {
+    key: "achievement.unlocked",
+    version: "1.0.0",
+    description: "An achievement has been unlocked.",
+    stability: "stable",
+    owners: [...LEARNING_JOURNEY_OWNERS],
+    tags: ["learning", "gamification", "achievement"]
+  },
+  payload: AchievementUnlockedPayload
+});
+var DailyGoalCompletedPayload = defineSchemaModel3({
+  name: "DailyGoalCompletedEventPayload",
+  description: "Payload when a daily goal is completed",
+  fields: {
+    learnerId: { type: ScalarTypeEnum3.String_unsecure(), isOptional: false },
+    date: { type: ScalarTypeEnum3.String_unsecure(), isOptional: false },
+    targetXp: { type: ScalarTypeEnum3.Int_unsecure(), isOptional: false },
+    actualXp: { type: ScalarTypeEnum3.Int_unsecure(), isOptional: false },
+    completedAt: { type: ScalarTypeEnum3.DateTime(), isOptional: false }
+  }
+});
+var DailyGoalCompletedEvent = defineEvent({
+  meta: {
+    key: "daily_goal.completed",
+    version: "1.0.0",
+    description: "A daily goal has been completed.",
+    stability: "stable",
+    owners: [...LEARNING_JOURNEY_OWNERS],
+    tags: ["learning", "gamification", "goal"]
+  },
+  payload: DailyGoalCompletedPayload
+});
+var CertificateIssuedPayload = defineSchemaModel3({
+  name: "CertificateIssuedEventPayload",
+  description: "Payload when a certificate is issued",
+  fields: {
+    certificateId: {
+      type: ScalarTypeEnum3.String_unsecure(),
+      isOptional: false
+    },
+    learnerId: { type: ScalarTypeEnum3.String_unsecure(), isOptional: false },
+    courseId: { type: ScalarTypeEnum3.String_unsecure(), isOptional: false },
+    certificateNumber: {
+      type: ScalarTypeEnum3.String_unsecure(),
+      isOptional: false
+    },
+    issuedAt: { type: ScalarTypeEnum3.DateTime(), isOptional: false }
+  }
+});
+var CertificateIssuedEvent = defineEvent({
+  meta: {
+    key: "certificate.issued",
+    version: "1.0.0",
+    description: "A certificate has been issued.",
+    stability: "stable",
+    owners: [...LEARNING_JOURNEY_OWNERS],
+    tags: ["learning", "certificate"]
+  },
+  payload: CertificateIssuedPayload
+});
+var LearningJourneyEvents = {
+  CoursePublishedEvent,
+  EnrollmentCreatedEvent,
+  LessonCompletedEvent,
+  CourseCompletedEvent,
+  OnboardingStartedEvent,
+  OnboardingStepCompletedEvent,
+  OnboardingCompletedEvent,
+  CardReviewedEvent,
+  QuizStartedEvent,
+  QuizCompletedEvent,
+  XpEarnedEvent,
+  LevelUpEvent,
+  StreakUpdatedEvent,
+  AchievementUnlockedEvent,
+  DailyGoalCompletedEvent,
+  CertificateIssuedEvent
+};
+// src/learning-journey.feature.ts
+import { defineFeature } from "@contractspec/lib.contracts";
+var LearningJourneyFeature = defineFeature({
+  meta: {
+    key: "learning-journey",
+    version: "1.0.0",
+    title: "Learning Journey",
+    description: "Learning platform with courses, onboarding, flashcards, and gamification",
+    domain: "learning",
+    owners: ["@platform.learning-journey"],
+    tags: ["learning", "onboarding", "courses", "flashcards", "gamification"],
+    stability: "stable"
+  },
+  operations: [
+    { key: "learning.onboarding.recordEvent", version: "1.0.0" },
+    { key: "learning.onboarding.listTracks", version: "1.0.0" },
+    { key: "learning.onboarding.getProgress", version: "1.0.0" },
+    { key: "learning.enroll", version: "1.0.0" },
+    { key: "learning.completeLesson", version: "1.0.0" },
+    { key: "learning.submitCardReview", version: "1.0.0" },
+    { key: "learning.getDueCards", version: "1.0.0" },
+    { key: "learning.getDashboard", version: "1.0.0" }
+  ],
+  events: [
+    { key: "course.published", version: "1.0.0" },
+    { key: "course.completed", version: "1.0.0" },
+    { key: "enrollment.created", version: "1.0.0" },
+    { key: "lesson.completed", version: "1.0.0" },
+    { key: "onboarding.started", version: "1.0.0" },
+    { key: "onboarding.step_completed", version: "1.0.0" },
+    { key: "onboarding.completed", version: "1.0.0" },
+    { key: "flashcard.reviewed", version: "1.0.0" },
+    { key: "quiz.started", version: "1.0.0" },
+    { key: "quiz.completed", version: "1.0.0" },
+    { key: "xp.earned", version: "1.0.0" },
+    { key: "level.up", version: "1.0.0" },
+    { key: "streak.updated", version: "1.0.0" },
+    { key: "achievement.unlocked", version: "1.0.0" },
+    { key: "daily_goal.completed", version: "1.0.0" },
+    { key: "certificate.issued", version: "1.0.0" }
+  ],
+  presentations: [],
+  opToPresentation: [],
+  presentationsTargets: [],
+  capabilities: {
+    provides: [
+      { key: "learning-journey", version: "1.0.0" },
+      { key: "onboarding", version: "1.0.0" },
+      { key: "gamification", version: "1.0.0" }
+    ],
+    requires: [{ key: "identity", version: "1.0.0" }]
+  }
+});
+export {
+  xpEngine,
+  streakEngine,
+  srsEngine,
+  quizEnums,
+  quizEntities,
+  onboardingEnums,
+  onboardingEntities,
+  learningJourneySchemaContribution,
+  learningJourneyEnums,
+  learningJourneyEntities,
+  learnerEnums,
+  learnerEntities,
+  gamificationEnums,
+  gamificationEntities,
+  flashcardEnums,
+  flashcardEntities,
+  courseEnums,
+  courseEntities,
+  aiEnums,
+  aiEntities,
+  XpEarnedEvent,
+  XPTransactionEntity,
+  XPEngine,
+  SuccessOutput,
+  SubmitCardReviewInput,
+  SubmitCardReviewContract,
+  StreakUpdatedEvent,
+  StreakEntity,
+  StreakEngine,
+  SkillMapEntity,
+  SkillAssessmentEntity,
+  SRSEngine,
+  RecordOnboardingEventContract,
+  RecommendationTypeEnum,
+  RecommendationEntity,
+  QuizStatusEnum,
+  QuizStartedEvent,
+  QuizEntity,
+  QuizCompletedEvent,
+  QuizAttemptEntity,
+  QuestionTypeEnum,
+  QuestionOptionEntity,
+  QuestionEntity,
+  ProgressStatusEnum,
+  ProgressModel,
+  OnboardingTrackModel,
+  OnboardingTrackEntity,
+  OnboardingStepStatusEnum,
+  OnboardingStepProgressModel,
+  OnboardingStepModel,
+  OnboardingStepEntity,
+  OnboardingStepCompletionEntity,
+  OnboardingStepCompletedEvent,
+  OnboardingStartedEvent,
+  OnboardingProgressModel,
+  OnboardingProgressEntity,
+  OnboardingCompletedEvent,
+  ModuleCompletionEntity,
+  ListOnboardingTracksContract,
+  LevelUpEvent,
+  LessonTypeEnum,
+  LessonProgressEntity,
+  LessonEntity,
+  LessonContentEntity,
+  LessonCompletedEvent,
+  LearningStyleEnum,
+  LearningPathEntity,
+  LearningJourneyFeature,
+  LearningJourneyEvents,
+  LearningGapEntity,
+  LearnerProfileEntity,
+  LearnerModel,
+  LearnerEntity,
+  LearnerDashboardModel,
+  LearnerAchievementEntity,
+  LeaderboardPeriodEnum,
+  LeaderboardEntryEntity,
+  LEARNING_JOURNEY_OWNERS,
+  HeartEntity,
+  GetOnboardingProgressContract,
+  GetLearnerDashboardInput,
+  GetLearnerDashboardContract,
+  GetDueCardsOutput,
+  GetDueCardsInput,
+  GetDueCardsContract,
+  EnrollmentStatusEnum,
+  EnrollmentModel,
+  EnrollmentEntity,
+  EnrollmentCreatedEvent,
+  EnrollInCourseInput,
+  EnrollInCourseContract,
+  DeckModel,
+  DeckEntity,
+  DailyGoalEntity,
+  DailyGoalCompletedEvent,
+  DEFAULT_XP_CONFIG,
+  DEFAULT_STREAK_CONFIG,
+  DEFAULT_SRS_CONFIG,
+  CourseStatusEnum,
+  CoursePublishedEvent,
+  CourseModuleEntity,
+  CourseModel,
+  CourseEntity,
+  CourseDifficultyEnum,
+  CourseCompletedEvent,
+  ContentTypeEnum,
+  CompleteLessonInput,
+  CompleteLessonContract,
+  CertificateIssuedEvent,
+  CertificateEntity,
+  CardScheduleEntity,
+  CardReviewedEvent,
+  CardReviewEntity,
+  CardRatingEnum,
+  CardModel,
+  CardEntity,
+  AttemptStatusEnum,
+  AchievementUnlockedEvent,
+  AchievementTypeEnum,
+  AchievementModel,
+  AchievementEntity
+};