From 5a8f50f67b0cb04900678b8e836f6128f19db593 Mon Sep 17 00:00:00 2001
From: Rotimi Best <best@classroomio.com>
Date: Mon, 30 Mar 2026 08:24:55 +0100
Subject: [PATCH] feat: certification rules, content sanitization, handle draft
 course updates and reset content, better redis logging

---
 AGENTS.md                                     |  50 +
 PRD-TRACKER.md                                |   2 +-
 apps/api/package.json                         |   5 +-
 apps/api/src/middlewares/rate-limiter.ts      |   5 +-
 apps/api/src/routes/course/course.ts          |  32 +
 .../src/routes/organization/organization.ts   |  42 +-
 .../services/course-import/course-import.ts   |  94 +-
 apps/api/src/services/course/clone.ts         |   3 +-
 apps/api/src/services/course/completion.ts    | 275 +++++
 apps/api/src/services/course/course.ts        |  67 +-
 apps/api/src/services/course/invite.ts        |  13 +-
 apps/api/src/services/course/people.ts        |   4 +-
 apps/api/src/services/exercise/exercise.ts    |  70 +-
 apps/api/src/services/exercise/utils.ts       |   1 +
 apps/api/src/services/lesson-language.ts      |   7 +-
 apps/api/src/services/lesson/lesson.ts        |   5 +-
 apps/api/src/services/newsfeed/newsfeed.ts    |  18 +-
 apps/api/src/services/organization.ts         |  76 +-
 .../api/src/services/organization/audience.ts | 357 ++++---
 .../api/src/services/submission/submission.ts | 152 +--
 apps/api/src/types/org.ts                     |  16 +
 apps/api/src/utils/course-completion.ts       |  89 ++
 apps/api/src/utils/errors.ts                  |   1 +
 apps/api/src/utils/redis/redis.ts             |  27 +-
 apps/api/src/utils/s3.ts                      |   6 +-
 apps/api/src/utils/sanitize-html.ts           |  39 +
 apps/dashboard/src/app.css                    |  25 +
 .../audience-delete-confirmation.svelte       |  42 +
 .../components/audience-member-row.svelte     |  36 +-
 .../components/audience-table-toolbar.svelte  |  39 +-
 .../audience/components/audience-table.svelte |  11 +-
 .../lib/features/audience/components/index.ts |   1 +
 .../features/audience/pages/audience.svelte   | 214 +++-
 .../lib/features/course/api/course.svelte.ts  |  36 +-
 .../features/course/api/exercise.svelte.ts    |  10 +-
 .../lib/features/course/api/lesson.svelte.ts  |  13 +-
 .../ceritficate/certificate-design.svelte     | 134 +++
 .../ceritficate/certificate-edit.svelte       |  38 +
 .../ceritficate/certificate-settings.svelte   | 186 ++++
 .../course-completion-modal.svelte            |  57 +
 .../components/ceritficate/design.svelte      | 196 ----
 .../student-certificate/index.svelte          |   2 +-
 .../unlocked-certificate.svelte               |  99 +-
 .../content/content-create-modal.svelte       |   2 +-
 .../content/exercise-create-stepper.svelte    |   2 +-
 .../components/exercise/edit-mode.svelte      |  46 +-
 .../exercise/exercise-settings-tab.svelte     |  56 +
 .../course/components/exercise/store.ts       |  13 +-
 .../components/exercise/view-mode.svelte      |  21 +-
 .../lesson/content-navigation-actions.svelte  |  15 +-
 .../features/course/components/list.svelte    |  82 +-
 .../people/existing-students-section.svelte   | 184 ++--
 .../components/people/invitation-modal.svelte |   6 +-
 .../components/question-container.svelte      |   5 +
 .../course-content-sidebar-navigation.svelte  |  24 +-
 .../sidebar/course-content-tree.svelte        |   3 +-
 .../sidebar/course-sidebar-navigation.svelte  |   4 +-
 .../features/course/pages/certificates.svelte |  10 +-
 .../lib/features/course/pages/courses.svelte  |  31 +-
 .../lib/features/course/pages/exercise.svelte |  84 +-
 .../lib/features/course/pages/settings.svelte |   7 +-
 .../src/lib/features/course/store.ts          |  26 +-
 .../course/store/course-completion-modal.ts   |  16 +
 .../course/utils/certificate-utils.ts         |  10 +
 .../lib/features/course/utils/constants.ts    |  13 +
 .../lib/features/course/utils/functions.ts    |  11 +-
 .../src/lib/features/course/utils/types.ts    |  12 +
 .../lib/features/lms/pages/mylearning.svelte  |   2 +-
 .../src/lib/features/org/api/org.svelte.ts    |  82 +-
 .../org/utils/audience-query-utils.ts         |  58 +
 .../src/lib/features/org/utils/types.ts       |  16 +-
 .../features/settings/pages/domains.svelte    |   2 +-
 .../src/lib/features/ui/confetti/store.ts     |   7 +
 .../components/editor/editor.svelte           |  22 +-
 .../src/lib/features/ui/question/constants.ts |   3 +-
 .../src/lib/utils/functions/validator.ts      |  11 -
 .../src/lib/utils/services/api/base.svelte.ts |   4 +
 .../src/lib/utils/services/api/index.ts       |  43 +-
 .../src/lib/utils/translations/da.json        |  35 +-
 .../src/lib/utils/translations/de.json        |  35 +-
 .../src/lib/utils/translations/en.json        |   7 +-
 .../src/lib/utils/translations/es.json        |  37 +-
 .../src/lib/utils/translations/fr.json        |  35 +-
 .../src/lib/utils/translations/hi.json        |  35 +-
 .../src/lib/utils/translations/pl.json        |  35 +-
 .../src/lib/utils/translations/pt.json        |  35 +-
 .../src/lib/utils/translations/ru.json        |  35 +-
 .../src/lib/utils/translations/vi.json        |  37 +-
 apps/dashboard/src/routes/+error.svelte       |   3 +-
 .../src/routes/courses/[id]/+layout.svelte    |   2 +
 .../courses/[id]/certificates/+page.svelte    | 150 ++-
 .../exercises/[exerciseId]/+page.server.ts    |   6 +-
 .../[id]/exercises/[exerciseId]/+page.svelte  |   5 +-
 .../routes/courses/[id]/settings/+page.svelte |   5 +-
 .../org/[slug]/audience/+page.server.ts       |  15 +-
 .../routes/org/[slug]/audience/+page.svelte   |   4 +-
 .../routes/org/[slug]/courses/+page.server.ts |   5 -
 .../queries/course/certification-exercise.ts  |  80 ++
 packages/db/src/queries/course/course.ts      | 147 ++-
 packages/db/src/queries/course/people.ts      |  36 +
 .../src/queries/organization/organization.ts  | 168 ++-
 .../db/src/queries/submission/submission.ts   |  50 +-
 packages/db/src/schema.ts                     |  16 +-
 packages/db/src/scripts/seed.ts               |  22 +-
 packages/db/src/utils/seed/course.ts          |  15 +-
 packages/db/src/utils/seed/organization.ts    |  15 +-
 .../db/src/utils/seed/organizationPlan.ts     |  28 +
 .../db/src/utils/seed/organizationmember.ts   |  27 +-
 packages/db/users.json                        | 102 ++
 packages/email/src/emails/index.ts            |   3 +
 .../src/emails/student-course-completion.ts   |  33 +
 .../src/emails/student-course-welcome.ts      |  11 +-
 packages/email/src/utils/constants.ts         |   1 +
 .../question-types/src/question-scoring.ts    | 349 ++++++
 packages/ui/package.json                      |   1 +
 .../editor/ui/components/CodeBlock.svelte     |   2 +-
 .../shared/option-correctness-badges.svelte   |  14 +-
 .../multi-select-list.svelte                  |  71 +-
 .../ui/src/custom/multi-select-list/types.ts  |   2 +-
 packages/ui/src/custom/search/search.svelte   |  21 +-
 packages/ui/src/output.css                    |   2 +-
 packages/ui/src/tools/sanitize.ts             |  87 +-
 packages/ui/tsconfig.json                     |   4 +-
 packages/utils/src/functions/index.ts         |   1 +
 packages/utils/src/functions/sanitize.ts      |  50 +
 .../utils/src/validation/course/course.ts     |  15 +-
 .../utils/src/validation/exercise/exercise.ts |   1 +
 .../src/validation/organization/audience.ts   |  15 +
 pnpm-lock.yaml                                | 353 ++++++-
 prd/classes/README.md                         | 993 ------------------
 prd/programs/README.md                        | 993 ++++++++++++++++++
 131 files changed, 5643 insertions(+), 2134 deletions(-)
 create mode 100644 apps/api/src/services/course/completion.ts
 create mode 100644 apps/api/src/utils/course-completion.ts
 create mode 100644 apps/api/src/utils/sanitize-html.ts
 create mode 100644 apps/dashboard/src/lib/features/audience/components/audience-delete-confirmation.svelte
 create mode 100644 apps/dashboard/src/lib/features/course/components/ceritficate/certificate-design.svelte
 create mode 100644 apps/dashboard/src/lib/features/course/components/ceritficate/certificate-edit.svelte
 create mode 100644 apps/dashboard/src/lib/features/course/components/ceritficate/certificate-settings.svelte
 create mode 100644 apps/dashboard/src/lib/features/course/components/ceritficate/course-completion-modal.svelte
 delete mode 100644 apps/dashboard/src/lib/features/course/components/ceritficate/design.svelte
 create mode 100644 apps/dashboard/src/lib/features/course/components/exercise/exercise-settings-tab.svelte
 create mode 100644 apps/dashboard/src/lib/features/course/store/course-completion-modal.ts
 create mode 100644 apps/dashboard/src/lib/features/course/utils/certificate-utils.ts
 create mode 100644 apps/dashboard/src/lib/features/org/utils/audience-query-utils.ts
 create mode 100644 packages/db/src/queries/course/certification-exercise.ts
 create mode 100644 packages/db/src/utils/seed/organizationPlan.ts
 create mode 100644 packages/email/src/emails/student-course-completion.ts
 create mode 100644 packages/question-types/src/question-scoring.ts
 create mode 100644 packages/utils/src/functions/sanitize.ts
 delete mode 100644 prd/classes/README.md
 create mode 100644 prd/programs/README.md

diff --git a/AGENTS.md b/AGENTS.md
index a2bd02d5..7207416e 100644
--- a/AGENTS.md
+++ b/AGENTS.md
@@ -5,6 +5,8 @@ This document collects implementation rules and workflow conventions for code ch
 ## Naming Convention
 
 - Use kebab-case for files (e.g. `user-profile.svelte`, `org.svelte.ts`).
+- **Variables must read clearly at the call site.** Avoid opaque single-letter or ultra-short names (`d`, `x`, `tmp`) unless they match a universal convention (e.g. `i` in a trivial index loop). Prefer names that state intent (`deadlineDate`, `parsedUrl`, `nextSection`).
+- **After an early `return` (or other guard exit), leave a blank line** before the next statement so the “happy path” block is visually separated from guards.
 
 ## Creating a New Route
 
@@ -177,6 +179,54 @@ You can bind form controls directly to a writable store’s properties. Svelte c
 <Select.Root type="single" bind:value={$inviteSettingsStore.preset}>
 ```
 
+### Form Structure
+
+For large dashboard forms, group fields by section instead of rendering one long flat list of controls.
+
+- Use a top-level `Field.Group` as the form container.
+- Split each logical section into its own `Field.Set`.
+- Use `Field.Legend` for the section title.
+- Separate sibling sections with `Field.Separator`.
+- Inside each section, wrap related controls in an inner `Field.Group`.
+- Put every control inside `Field.Field`, and use `orientation="horizontal"` for toggle or checkbox rows.
+- Use `Field.Description` for helper copy that applies to a whole section.
+
+Pattern:
+
+```svelte
+<Field.Group>
+  <Field.Set>
+    <Field.Legend>{$t('settings.section.heading')}</Field.Legend>
+
+    <Field.Field orientation="horizontal">
+      <Switch bind:checked={$store.section.enabled} />
+      <Field.Label>{$t('settings.section.toggle')}</Field.Label>
+    </Field.Field>
+
+    <Field.Group>
+      <Field.Field>
+        <Field.Label>{$t('settings.section.title')}</Field.Label>
+        <Input bind:value={$store.section.title} />
+      </Field.Field>
+
+      <Field.Field>
+        <Field.Label>{$t('settings.section.description')}</Field.Label>
+        <Textarea bind:value={$store.section.description} />
+      </Field.Field>
+    </Field.Group>
+  </Field.Set>
+
+  <Field.Separator />
+
+  <Field.Set>
+    <Field.Legend>{$t('settings.other.heading')}</Field.Legend>
+    <!-- more grouped fields -->
+  </Field.Set>
+</Field.Group>
+```
+
+Use `@cio/ui/custom/*-field` wrappers for standard app forms. When building larger settings/editor screens that need legends, descriptions, separators, grouped rows, or mixed controls such as `Switch`, `Checkbox`, `RadioGroup`, image pickers, and action buttons, compose the form with `@cio/ui/base/field` primitives and the matching base inputs instead.
+
 ### Reactive built-in collections
 
 In Svelte 5, the built-in `Set` and `Map` classes are **not** reactive. Use `SvelteSet` and `SvelteMap` from `svelte/reactivity` instead. They are already reactive on their own — do **not** wrap them in `$state()`.
diff --git a/PRD-TRACKER.md b/PRD-TRACKER.md
index 388a1102..e90a80fb 100644
--- a/PRD-TRACKER.md
+++ b/PRD-TRACKER.md
@@ -11,7 +11,7 @@ Use this file to keep a single prioritized view of all PRDs.
 | 3 | 5 | `prd/course-import` | todo |
 | 4 | 8 | `prd/exercise-question-types` | in-progress (A3, A6, A7, C3, C7, C13, C14 done) |
 | 5 | 3 | `prd/course-cohorts` | todo |
-| 6 | - | `prd/classes` | todo |
+| 6 | - | `prd/programs` | todo |
 | 7 | 13 | `prd/self-host-single-org.md` | done |
 | 8 | 7 | `prd/email-template-customization` | todo |
 | 9 | - | `prd/selective-exercise-assignment` | todo |
diff --git a/apps/api/package.json b/apps/api/package.json
index 25698577..d5c9eba3 100644
--- a/apps/api/package.json
+++ b/apps/api/package.json
@@ -41,7 +41,6 @@
     "@aws-sdk/client-s3": "^3.388.0",
     "@aws-sdk/s3-request-presigner": "^3.675.0",
     "@cio/db": "workspace:*",
-    "drizzle-orm": "^0.44.7",
     "@cio/email": "workspace:*",
     "@cio/question-types": "workspace:*",
     "@cio/utils": "workspace:*",
@@ -52,13 +51,15 @@
     "@sentry/profiling-node": "^7.110.1",
     "axios": "^1.4.0",
     "dotenv": "^16.3.1",
+    "drizzle-orm": "^0.44.7",
     "hono": "^4.11.3",
     "hono-openapi": "^1.0.8",
     "hono-rate-limiter": "^0.4.2",
-    "redis": "^4.7.0",
+    "isomorphic-dompurify": "^3.7.1",
     "katex": "^0.16.10",
     "marked": "^7.0.3",
     "nanoid": "^5.1.5",
+    "redis": "^4.7.0",
     "zod": "^4.1.8",
     "zod-openapi": "^5.4.1"
   },
diff --git a/apps/api/src/middlewares/rate-limiter.ts b/apps/api/src/middlewares/rate-limiter.ts
index bfc50866..c921ac87 100644
--- a/apps/api/src/middlewares/rate-limiter.ts
+++ b/apps/api/src/middlewares/rate-limiter.ts
@@ -9,7 +9,7 @@ import type { MiddlewareHandler } from 'hono';
 import { RedisRateLimiter } from '@api/utils/redis/limiter';
 import { userKeyGenerator } from '../utils/redis/key-generators';
 import { env } from '@api/config/env';
-import { redis } from '@api/utils/redis/redis';
+import { logRedisUnavailableOnce, redis } from '@api/utils/redis/redis';
 
 export interface RateLimiterOptions {
   windowMs?: number;
@@ -80,8 +80,7 @@ export const createRateLimiter = (options: RateLimiterOptions = {}): MiddlewareH
 
       await next();
     } catch (error) {
-      console.error('Rate limiter error:', error);
-      // If Redis is down, allow the request but log the error
+      logRedisUnavailableOnce('Redis rate limiter unavailable, allowing requests without rate limiting', error);
       await next();
     }
   };
diff --git a/apps/api/src/routes/course/course.ts b/apps/api/src/routes/course/course.ts
index f2aeff60..73edbb33 100644
--- a/apps/api/src/routes/course/course.ts
+++ b/apps/api/src/routes/course/course.ts
@@ -26,6 +26,7 @@ import {
   getCourseProgress,
   updateCourse
 } from '@api/services/course/course';
+import { assertCertificateDownloadAllowed, evaluateCourseCertification } from '@api/services/course/completion';
 import { getCourseTags, replaceCourseTags } from '@api/services/tag';
 
 import { Hono } from '@api/utils/hono';
@@ -393,6 +394,33 @@ export const courseRouter = new Hono()
       }
     }
   )
+  /**
+   * GET /course/:courseId/certification-evaluation
+   * Full certification eligibility for the current user (blockers for UI).
+   */
+  .get(
+    '/:courseId/certification-evaluation',
+    authMiddleware,
+    courseMemberMiddleware,
+    zValidator('param', ZCourseProgressParam),
+    async (c) => {
+      try {
+        const { courseId } = c.req.valid('param');
+        const user = c.get('user')!;
+        const data = await evaluateCourseCertification(courseId, user.id);
+
+        return c.json(
+          {
+            success: true,
+            data
+          },
+          200
+        );
+      } catch (error) {
+        return handleError(c, error, 'Failed to evaluate certification');
+      }
+    }
+  )
   /**
    * GET /course/:courseId/analytics
    * Gets course analytics including student progress, completion rates, and grades
@@ -427,6 +455,10 @@ export const courseRouter = new Hono()
     zValidator('param', ZCourseDownloadParam),
     zValidator('json', ZCertificateDownload),
     async (c) => {
+      const { courseId } = c.req.valid('param');
+      const user = c.get('user')!;
+      await assertCertificateDownloadAllowed(courseId, user.id);
+
       const validatedData = c.req.valid('json');
 
       const result = await generateCertificate(validatedData);
diff --git a/apps/api/src/routes/organization/organization.ts b/apps/api/src/routes/organization/organization.ts
index b87bf295..558050af 100644
--- a/apps/api/src/routes/organization/organization.ts
+++ b/apps/api/src/routes/organization/organization.ts
@@ -4,6 +4,7 @@ import {
   ZCancelOrgPlan,
   ZCreateOrgPlan,
   ZCreateOrganization,
+  ZGetAudienceQuery,
   ZGetCoursesBySiteName,
   ZGetOrgSetup,
   ZGetOrganizationCoursesQuery,
@@ -37,6 +38,7 @@ import {
   getRecommendedCourses,
   getUserAnalytics,
   getUserEnrolledCourses,
+  removeAudienceMember,
   removeTeamMember,
   updateOrg,
   updateOrgPlan
@@ -178,15 +180,18 @@ export const organizationRouter = new Hono()
    * Gets organization audience (students)
    * Requires authentication
    */
-  .get('/audience', authMiddleware, orgTeamMemberMiddleware, async (c) => {
+  .get('/audience', authMiddleware, orgTeamMemberMiddleware, zValidator('query', ZGetAudienceQuery), async (c) => {
     try {
       const orgId = c.req.header('cio-org-id')!;
-      const audience = await getOrgAudience(orgId);
+      const query = c.req.valid('query');
+      const audience = await getOrgAudience(orgId, query);
 
       return c.json(
         {
           success: true,
-          data: audience
+          data: audience.items,
+          pagination: audience.pagination,
+          query: audience.query
         },
         200
       );
@@ -194,6 +199,35 @@ export const organizationRouter = new Hono()
       return handleError(c, error, 'Failed to fetch organization audience');
     }
   })
+  /**
+   * DELETE /organization/audience/:memberId
+   * Removes a student from the organization
+   */
+  .delete(
+    '/audience/:memberId',
+    authMiddleware,
+    orgAdminMiddleware,
+    zValidator('param', ZRemoveTeamMember),
+    async (c) => {
+      try {
+        const orgId = c.req.header('cio-org-id')!;
+        const user = c.get('user')!;
+        const { memberId } = c.req.valid('param');
+
+        const deleted = await removeAudienceMember(orgId, memberId, user.id);
+
+        return c.json(
+          {
+            success: true,
+            data: deleted
+          },
+          200
+        );
+      } catch (error) {
+        return handleError(c, error, 'Failed to remove audience member');
+      }
+    }
+  )
   /**
    * POST /organization/audience/resend-invite
    * Resends a student org invite email (new token; optional course metadata from last invite)
@@ -604,7 +638,7 @@ export const organizationRouter = new Hono()
   .post(
     '/audience/assign-courses',
     authMiddleware,
-    orgAdminMiddleware,
+    orgTeamMemberMiddleware,
     zValidator('json', ZAssignAudienceCourses),
     async (c) => {
       try {
diff --git a/apps/api/src/services/course-import/course-import.ts b/apps/api/src/services/course-import/course-import.ts
index 3247981c..6481180b 100644
--- a/apps/api/src/services/course-import/course-import.ts
+++ b/apps/api/src/services/course-import/course-import.ts
@@ -2,9 +2,20 @@ import { AppError, ErrorCodes } from '@api/utils/errors';
 import { env } from '@api/config/env';
 import { getDashboardBaseUrl } from '@api/config/dashboard-url';
 import { createCourse, updateCourse } from '@api/services/course/course';
-import { createExercise, getExercise, listExercises, replaceExerciseService } from '@api/services/exercise';
-import { createCourseSection, listCourseSections, updateCourseSectionService } from '@api/services/course/section';
-import { createLesson, listLessons, updateLessonService } from '@api/services/lesson';
+import {
+  createExercise,
+  deleteExerciseService,
+  getExercise,
+  listExercises,
+  replaceExerciseService
+} from '@api/services/exercise';
+import {
+  createCourseSection,
+  deleteCourseSectionService,
+  listCourseSections,
+  updateCourseSectionService
+} from '@api/services/course/section';
+import { createLesson, listLessons, updateLessonService, deleteLessonService } from '@api/services/lesson';
 import { upsertLessonLanguageService, updateLessonLanguageService } from '@api/services/lesson-language';
 import {
   createCourseImportDraft,
@@ -203,6 +214,43 @@ function parseStoredDraft(record: TCourseImportDraft): TCourseImportDraftPayload
   return ZCourseImportDraftPayload.parse(record.draft);
 }
 
+async function reserveDraftPublishedCourseId(
+  orgId: string,
+  draftId: string,
+  draft: TCourseImportDraftPayload,
+  existingSummary: TCourseImportDraft['summary'],
+  courseId: string
+) {
+  await updateCourseImportDraft(orgId, draftId, {
+    publishedCourseId: courseId,
+    summary: {
+      ...(existingSummary ?? {}),
+      ...buildDraftSummary(draft),
+      publishedCourseId: courseId
+    }
+  });
+}
+
+async function resetCourseContentForDraftRetry(courseId: string) {
+  const [exercises, lessons, sections] = await Promise.all([
+    listExercises(courseId),
+    listLessons(courseId),
+    listCourseSections(courseId)
+  ]);
+
+  for (const exercise of exercises) {
+    await deleteExerciseService(exercise.id);
+  }
+
+  for (const lesson of lessons) {
+    await deleteLessonService(lesson.id);
+  }
+
+  for (const section of sections) {
+    await deleteCourseSectionService(section.id);
+  }
+}
+
 async function assertCourseBelongsToOrganization(orgId: string, courseId: string) {
   const courseOrgId = await getCourseOrganizationId(courseId);
 
@@ -665,6 +713,14 @@ export async function publishCourseImportDraftService(
     const courseDescription = overrides.description ?? draft.course.description;
     const courseType = overrides.type ?? draft.course.type;
     const courseMetadata = overrides.metadata ?? draft.course.metadata;
+    const courseUpdateFields: Partial<TCourse> = {
+      title: courseTitle,
+      description: courseDescription,
+      type: courseType
+    };
+    if (courseMetadata) {
+      courseUpdateFields.metadata = courseMetadata;
+    }
 
     const sectionExternalIds = new Set(draft.sections.map((section) => section.externalId));
     draft.lessons.forEach((lesson) => {
@@ -673,17 +729,31 @@ export async function publishCourseImportDraftService(
       }
     });
 
-    const courseResult = await createCourse(profileId, {
-      title: courseTitle,
-      description: courseDescription,
-      type: courseType,
-      organizationId: orgId
-    });
+    let courseId = existing.publishedCourseId;
 
-    const courseId = courseResult.course.id;
+    if (courseId) {
+      const [existingCourse] = await getCourseById(courseId);
+      if (!existingCourse || existingCourse.status === 'DELETED') {
+        courseId = null;
+      } else {
+        await updateCourse(courseId, courseUpdateFields);
+        await resetCourseContentForDraftRetry(courseId);
+      }
+    }
 
-    if (courseMetadata) {
-      await updateCourse(courseId, { metadata: courseMetadata });
+    if (!courseId) {
+      const courseResult = await createCourse(profileId, {
+        title: courseTitle,
+        description: courseDescription,
+        type: courseType,
+        organizationId: orgId
+      });
+
+      courseId = courseResult.course.id;
+      await reserveDraftPublishedCourseId(orgId, draftId, draft, existing.summary, courseId);
+      if (courseMetadata) {
+        await updateCourse(courseId, { metadata: courseMetadata });
+      }
     }
 
     const bannerImageUrl = await resolvePublishBannerImage(courseTitle, overrides);
diff --git a/apps/api/src/services/course/clone.ts b/apps/api/src/services/course/clone.ts
index 4ca85ab5..68bf5751 100644
--- a/apps/api/src/services/course/clone.ts
+++ b/apps/api/src/services/course/clone.ts
@@ -182,8 +182,7 @@ export async function cloneCourse(
     currency: course.currency,
     bannerImage: course.bannerImage,
     isPublished: course.isPublished,
-    isCertificateDownloadable: course.isCertificateDownloadable,
-    certificateTheme: course.certificateTheme,
+    certificate: course.certificate,
     status: course.status,
     type: course.type
   });
diff --git a/apps/api/src/services/course/completion.ts b/apps/api/src/services/course/completion.ts
new file mode 100644
index 00000000..d48eb16a
--- /dev/null
+++ b/apps/api/src/services/course/completion.ts
@@ -0,0 +1,275 @@
+import * as schema from '@cio/db/schema';
+
+import { AppError, ErrorCodes } from '@api/utils/errors';
+import {
+  calcCourseProgressPercent,
+  isBeforeOrEqualDeadline,
+  scheduleCertificationCompletionWork
+} from '@api/utils/course-completion';
+import {
+  exerciseBelongsToCourse,
+  getExerciseTitleAndMaxPoints,
+  getStudentSubmissionsForExercise
+} from '@cio/db/queries/course/certification-exercise';
+import {
+  getCourseCertificationRow,
+  getCourseProgress as getCourseProgressQuery,
+  type TCourseCertificationRow
+} from '@cio/db/queries/course/course';
+
+import { ROLE } from '@cio/utils/constants';
+import { db } from '@cio/db/drizzle';
+import { eq } from 'drizzle-orm';
+
+export type CertificationBlocker = {
+  code:
+    | 'CERT_PROGRESS'
+    | 'CERT_DEADLINE_PASSED'
+    | 'CERT_NO_CONTENT'
+    | 'CERT_FINAL_EXERCISE_NOT_SUBMITTED'
+    | 'CERT_FINAL_EXERCISE_PENDING_GRADE'
+    | 'CERT_FINAL_EXERCISE_SCORE'
+    | 'CERT_FINAL_EXERCISE_MISCONFIGURED';
+  params?: Record<string, string | number>;
+};
+
+export type CourseCompletionEvaluation = {
+  progressPercent: number;
+  certificationThreshold: number;
+  meetsThreshold: boolean;
+  eligibleForCertificate: boolean;
+  certificateEarnedAt: string | null;
+  blockers: CertificationBlocker[];
+  meetsFinalExerciseRule: boolean;
+};
+
+function percentFromTotal(total: number, maxPoints: number): number {
+  if (maxPoints <= 0) return 0;
+  return Math.round((total / maxPoints) * 100);
+}
+
+async function evaluateFinalExerciseRule(params: {
+  courseId: string;
+  requiredExerciseId: string | null | undefined;
+  minScorePercent: number | null | undefined;
+  groupMemberId: string | null;
+}): Promise<{
+  meetsFinalExerciseRule: boolean;
+  blockers: CertificationBlocker[];
+}> {
+  const { courseId, requiredExerciseId, minScorePercent, groupMemberId } = params;
+
+  if (!requiredExerciseId) {
+    return { meetsFinalExerciseRule: true, blockers: [] };
+  }
+
+  const belongs = await exerciseBelongsToCourse(requiredExerciseId, courseId);
+  if (!belongs) {
+    return { meetsFinalExerciseRule: true, blockers: [] };
+  }
+
+  const requiredPercent = minScorePercent ?? 100;
+
+  if (!groupMemberId) {
+    return {
+      meetsFinalExerciseRule: false,
+      blockers: [{ code: 'CERT_FINAL_EXERCISE_NOT_SUBMITTED' }]
+    };
+  }
+
+  const { title: exerciseTitle, maxPoints } = await getExerciseTitleAndMaxPoints(requiredExerciseId);
+
+  if (maxPoints <= 0) {
+    return {
+      meetsFinalExerciseRule: false,
+      blockers: [
+        {
+          code: 'CERT_FINAL_EXERCISE_MISCONFIGURED',
+          params: { exerciseTitle }
+        }
+      ]
+    };
+  }
+
+  const submissions = await getStudentSubmissionsForExercise(groupMemberId, requiredExerciseId);
+
+  if (submissions.length === 0) {
+    return {
+      meetsFinalExerciseRule: false,
+      blockers: [
+        {
+          code: 'CERT_FINAL_EXERCISE_NOT_SUBMITTED',
+          params: { exerciseTitle }
+        }
+      ]
+    };
+  }
+
+  const completed = submissions.filter((s) => s.gradingState === 'completed');
+  if (completed.length === 0) {
+    return {
+      meetsFinalExerciseRule: false,
+      blockers: [
+        {
+          code: 'CERT_FINAL_EXERCISE_PENDING_GRADE',
+          params: { exerciseTitle }
+        }
+      ]
+    };
+  }
+
+  let bestPercent = 0;
+  for (const s of completed) {
+    const total = Number(s.total ?? 0);
+    const p = percentFromTotal(total, maxPoints);
+    if (p > bestPercent) bestPercent = p;
+  }
+
+  if (bestPercent < requiredPercent) {
+    return {
+      meetsFinalExerciseRule: false,
+      blockers: [
+        {
+          code: 'CERT_FINAL_EXERCISE_SCORE',
+          params: {
+            exerciseTitle,
+            bestPercent,
+            requiredPercent
+          }
+        }
+      ]
+    };
+  }
+
+  return { meetsFinalExerciseRule: true, blockers: [] };
+}
+
+async function buildCertificationEvaluation(
+  courseId: string,
+  profileId: string,
+  courseRow: TCourseCertificationRow,
+  progressArg?: Awaited<ReturnType<typeof getCourseProgressQuery>>
+): Promise<CourseCompletionEvaluation> {
+  const progress = progressArg ?? (await getCourseProgressQuery(courseId, profileId));
+  const certificate = courseRow.certificate ?? {};
+
+  const threshold = certificate.threshold ?? 100;
+  const progressPercent = calcCourseProgressPercent({
+    lessonsCompleted: progress.lessonsCompleted,
+    totalLessons: progress.lessonsCount,
+    exercisesCompleted: progress.exercisesCompleted,
+    exercisesCount: progress.exercisesCount
+  });
+
+  const now = new Date();
+  const meetsThreshold = progressPercent >= threshold;
+  const withinDeadline = isBeforeOrEqualDeadline(certificate.deadline, now);
+  const hasContent = progress.lessonsCount + progress.exercisesCount > 0;
+
+  const blockers: CertificationBlocker[] = [];
+
+  if (!withinDeadline) {
+    blockers.push({ code: 'CERT_DEADLINE_PASSED' });
+  }
+  if (!meetsThreshold) {
+    blockers.push({
+      code: 'CERT_PROGRESS',
+      params: { current: progressPercent, required: threshold }
+    });
+  }
+  if (!hasContent) {
+    blockers.push({ code: 'CERT_NO_CONTENT' });
+  }
+
+  const finalEval = await evaluateFinalExerciseRule({
+    courseId,
+    requiredExerciseId: certificate.requiredExerciseId,
+    minScorePercent: certificate.exerciseMinScorePercent,
+    groupMemberId: progress.groupMemberId
+  });
+
+  blockers.push(...finalEval.blockers);
+
+  const eligibleForCertificate =
+    progress.roleId === ROLE.STUDENT &&
+    !!progress.groupMemberId &&
+    meetsThreshold &&
+    hasContent &&
+    withinDeadline &&
+    finalEval.meetsFinalExerciseRule;
+
+  return {
+    progressPercent,
+    certificationThreshold: threshold,
+    meetsThreshold,
+    eligibleForCertificate,
+    certificateEarnedAt: progress.certificateEarnedAt,
+    blockers,
+    meetsFinalExerciseRule: finalEval.meetsFinalExerciseRule
+  };
+}
+
+/**
+ * Evaluates certification eligibility. On first eligibility, persists
+ * `certificateEarnedAt` and fires the completion email (non-blocking).
+ */
+export async function evaluateCourseCertification(
+  courseId: string,
+  profileId: string
+): Promise<CourseCompletionEvaluation & { isNewCompletion: boolean }> {
+  const [progress, courseRow] = await Promise.all([
+    getCourseProgressQuery(courseId, profileId),
+    getCourseCertificationRow(courseId)
+  ]);
+
+  if (!courseRow) {
+    throw new AppError('Course not found', ErrorCodes.COURSE_NOT_FOUND, 404);
+  }
+
+  const evaluation = await buildCertificationEvaluation(courseId, profileId, courseRow, progress);
+
+  let certificateEarnedAt = evaluation.certificateEarnedAt;
+  let isNewCompletion = false;
+
+  if (evaluation.eligibleForCertificate && !certificateEarnedAt && progress.groupMemberId) {
+    const earnedAt = new Date().toISOString();
+    certificateEarnedAt = earnedAt;
+    isNewCompletion = true;
+
+    scheduleCertificationCompletionWork({
+      courseId,
+      profileId,
+      groupMemberId: progress.groupMemberId,
+      courseRow,
+      earnedAt
+    });
+  }
+
+  return { ...evaluation, certificateEarnedAt, isNewCompletion };
+}
+
+/**
+ * Server-side guard for PDF certificate download (must match dashboard eligibility).
+ */
+export async function assertCertificateDownloadAllowed(courseId: string, profileId: string): Promise<void> {
+  const evaluation = await evaluateCourseCertification(courseId, profileId);
+
+  const [courseMeta] = await db
+    .select({
+      certificate: schema.course.certificate
+    })
+    .from(schema.course)
+    .where(eq(schema.course.id, courseId))
+    .limit(1);
+
+  if (!courseMeta?.certificate?.isDownloadable) {
+    throw new AppError('Certificate download is not enabled for this course', ErrorCodes.VALIDATION_ERROR, 403);
+  }
+
+  const hasEarnedPreviously = evaluation.certificateEarnedAt != null;
+  const canDownload = hasEarnedPreviously || evaluation.eligibleForCertificate;
+
+  if (!canDownload) {
+    throw new AppError('Course completion requirements not met', ErrorCodes.VALIDATION_ERROR, 403);
+  }
+}
diff --git a/apps/api/src/services/course/course.ts b/apps/api/src/services/course/course.ts
index c972a021..fd10ff2d 100644
--- a/apps/api/src/services/course/course.ts
+++ b/apps/api/src/services/course/course.ts
@@ -1,4 +1,5 @@
 import { AppError, ErrorCodes } from '@api/utils/errors';
+import { sanitizeHtml, sanitizeOptionalHtml, sanitizeUnknownStrings } from '@api/utils/sanitize-html';
 import { addGroupMember, createGroup } from '@cio/db/queries/group';
 import {
   createCourseNewsfeed,
@@ -20,6 +21,7 @@ import {
 import { ContentType, ROLE } from '@cio/utils/constants';
 import type { TCourse } from '@cio/db/types';
 import { db } from '@cio/db/drizzle';
+import { exerciseBelongsToCourse } from '@cio/db/queries/course/certification-exercise';
 import { updateExercisesSectionId } from '@cio/db/queries/exercise/exercise';
 import { getProfileById } from '@cio/db/queries/auth';
 import { buildCourseContent, calcPercentageWithRounding, formatLastSeen, type CourseContent } from './utils';
@@ -27,6 +29,42 @@ import { buildCourseContent, calcPercentageWithRounding, formatLastSeen, type Co
 const DEFAULT_CONTENT_GROUPING = true;
 const DEFAULT_SECTION_TITLE = 'First Section [edit me]';
 
+function sanitizeCourseMetadata(metadata: TCourse['metadata'] | undefined) {
+  if (!metadata) return metadata;
+
+  return {
+    ...metadata,
+    description: sanitizeOptionalHtml(metadata.description),
+    goals: sanitizeOptionalHtml(metadata.goals),
+    requirements: sanitizeOptionalHtml(metadata.requirements),
+    reward: metadata.reward
+      ? {
+          ...metadata.reward,
+          description: sanitizeHtml(metadata.reward.description)
+        }
+      : metadata.reward,
+    instructor: metadata.instructor
+      ? {
+          ...metadata.instructor,
+          description: sanitizeHtml(metadata.instructor.description)
+        }
+      : metadata.instructor,
+    reviews: metadata.reviews?.map((review) => ({
+      ...review,
+      description: sanitizeHtml(review.description)
+    }))
+  };
+}
+
+function sanitizeCourseCertificate(certificate: TCourse['certificate'] | undefined) {
+  if (!certificate) return certificate;
+
+  return {
+    ...certificate,
+    emailMessage: sanitizeOptionalHtml(certificate.emailMessage)
+  };
+}
+
 /**
  * Gets a course by ID or slug with all related data
  * @param courseId Course ID (optional if slug provided)
@@ -93,11 +131,13 @@ export async function createCourse(
   data: { title: string; description: string; type: 'LIVE_CLASS' | 'SELF_PACED'; organizationId: string }
 ): Promise<{ course: TCourse; groupId: string; memberId: string }> {
   try {
+    const description = sanitizeHtml(data.description);
+
     const result = await db.transaction(async () => {
       // 1. Create group
       const [newGroup] = await createGroup({
         name: data.title,
-        description: data.description,
+        description,
         organizationId: data.organizationId
       });
 
@@ -108,7 +148,7 @@ export async function createCourse(
       // 2. Create course with group_id
       const [newCourse] = await createCourseQuery({
         title: data.title,
-        description: data.description,
+        description,
         type: data.type,
         groupId: newGroup.id
       });
@@ -130,8 +170,8 @@ export async function createCourse(
 
       // 4. Add default news feed
       await createCourseNewsfeed({
-        content: `<h2>Welcome to this course 🎉&nbsp;</h2>
-<p>Thank you for joining this course and I hope you get the best out of it.</p>`,
+        content: sanitizeHtml(`<h2>Welcome to this course 🎉&nbsp;</h2>
+<p>Thank you for joining this course and I hope you get the best out of it.</p>`),
         courseId: newCourse.id,
         isPinned: true,
         authorId: newMember.id
@@ -166,7 +206,24 @@ export async function createCourse(
  */
 export async function updateCourse(courseId: string, data: Partial<TCourse>) {
   try {
-    const updated = await updateCourseQuery(courseId, data);
+    const sanitizedData: Partial<TCourse> = {
+      ...data,
+      description: sanitizeOptionalHtml(data.description),
+      overview: sanitizeOptionalHtml(data.overview),
+      metadata: sanitizeCourseMetadata(data.metadata),
+      certificate: sanitizeCourseCertificate(data.certificate),
+      logo: data.logo,
+      slug: data.slug
+    };
+
+    if (data.certificate?.requiredExerciseId) {
+      const ok = await exerciseBelongsToCourse(data.certificate.requiredExerciseId, courseId);
+      if (!ok) {
+        throw new AppError('Certification exercise must belong to this course', ErrorCodes.VALIDATION_ERROR, 400);
+      }
+    }
+
+    const updated = await updateCourseQuery(courseId, sanitizeUnknownStrings(sanitizedData));
     if (!updated) {
       throw new AppError('Course not found', ErrorCodes.COURSE_NOT_FOUND, 404);
     }
diff --git a/apps/api/src/services/course/invite.ts b/apps/api/src/services/course/invite.ts
index 2566bab2..62ab8911 100644
--- a/apps/api/src/services/course/invite.ts
+++ b/apps/api/src/services/course/invite.ts
@@ -343,15 +343,18 @@ async function sendStudentJoinEmails(input: {
   courseId: string;
   courseName: string;
   orgName: string;
+  orgSiteName: string | null;
   studentId: string;
   studentEmail: string;
 }) {
   try {
+    const loginUrl = getDashboardBaseUrl(input.orgSiteName ?? undefined);
     await sendEmail('studentCourseWelcome', {
       to: input.studentEmail,
       fields: {
         orgName: input.orgName,
-        courseName: input.courseName
+        courseName: input.courseName,
+        loginUrl
       },
       from: buildEmailFromName(`${input.orgName} (via ClassroomIO.com)`)
     });
@@ -678,6 +681,7 @@ export async function enrollInCourse(
     courseId,
     courseName: title,
     orgName: org.name,
+    orgSiteName: org.siteName,
     studentId: user.id,
     studentEmail: normalizedEmail
   });
@@ -962,7 +966,8 @@ export async function acceptStudentInvite(token: string, user: TAuthUser, contex
         alreadyJoined: true,
         courseId: course.id,
         courseName: course.title,
-        orgName: organization.name
+        orgName: organization.name,
+        orgSiteName: organization.siteName
       };
     }
 
@@ -1061,7 +1066,8 @@ export async function acceptStudentInvite(token: string, user: TAuthUser, contex
       alreadyJoined: false,
       courseId: course.id,
       courseName: course.title,
-      orgName: organization.name
+      orgName: organization.name,
+      orgSiteName: organization.siteName
     };
   });
 
@@ -1070,6 +1076,7 @@ export async function acceptStudentInvite(token: string, user: TAuthUser, contex
       courseId: result.courseId,
       courseName: result.courseName,
       orgName: result.orgName,
+      orgSiteName: result.orgSiteName,
       studentId: user.id,
       studentEmail: normalizedEmail
     });
diff --git a/apps/api/src/services/course/people.ts b/apps/api/src/services/course/people.ts
index ab848c74..c58aa7c4 100644
--- a/apps/api/src/services/course/people.ts
+++ b/apps/api/src/services/course/people.ts
@@ -62,6 +62,7 @@ export async function addMember(
         if (courseOrgData) {
           const courseName = courseOrgData.courseTitle || '';
           const orgName = courseOrgData.orgName || 'ClassroomIO';
+          const loginUrl = getDashboardBaseUrl(courseOrgData.orgSiteName ?? undefined);
 
           // Get student profile data
           let studentEmail: string | null = null;
@@ -86,7 +87,8 @@ export async function addMember(
                 to: studentEmail,
                 fields: {
                   orgName,
-                  courseName
+                  courseName,
+                  loginUrl
                 },
                 from: buildEmailFromName(`${orgName} (via ClassroomIO.com)`)
               });
diff --git a/apps/api/src/services/exercise/exercise.ts b/apps/api/src/services/exercise/exercise.ts
index eca41a49..424f90dc 100644
--- a/apps/api/src/services/exercise/exercise.ts
+++ b/apps/api/src/services/exercise/exercise.ts
@@ -1,4 +1,5 @@
 import { AppError, ErrorCodes } from '@api/utils/errors';
+import { sanitizeHtml, sanitizeOptionalHtml, sanitizeUnknownStrings } from '@api/utils/sanitize-html';
 import type { TExercise, TExerciseTemplate, TNewOption, TNewQuestion } from '@cio/db/types';
 import type { TExerciseCreate, TExerciseUpdate } from '@cio/utils/validation/exercise';
 import {
@@ -40,6 +41,29 @@ type ExerciseWithCompletion = TExercise & {
   isComplete: boolean;
 };
 
+function sanitizeExerciseQuestions(questions: TExerciseCreate['questions'] | TExerciseUpdate['questions']) {
+  return questions?.map((question) => ({
+    ...question,
+    question: sanitizeHtml(question.question),
+    settings: question.settings ? sanitizeUnknownStrings(question.settings) : question.settings,
+    options: question.options?.map((option) => ({
+      ...option,
+      label: sanitizeHtml(option.label),
+      settings: option.settings ? sanitizeUnknownStrings(option.settings) : option.settings
+    }))
+  }));
+}
+
+function sanitizeExercisePayload(data: TExerciseCreate): TExerciseCreate;
+function sanitizeExercisePayload(data: TExerciseUpdate): TExerciseUpdate;
+function sanitizeExercisePayload(data: TExerciseCreate | TExerciseUpdate): TExerciseCreate | TExerciseUpdate {
+  return {
+    ...data,
+    description: sanitizeOptionalHtml(data.description),
+    questions: sanitizeExerciseQuestions(data.questions)
+  };
+}
+
 /**
  * Creates a new exercise with optional questions and options
  * @param data Exercise creation data
@@ -47,14 +71,16 @@ type ExerciseWithCompletion = TExercise & {
  */
 export async function createExercise(data: TExerciseCreate): Promise<TExercise> {
   try {
+    const sanitizedData = sanitizeExercisePayload(data);
+
     const exerciseData = {
-      title: data.title,
-      description: data.description ?? null,
-      lessonId: data.lessonId || null,
-      courseId: data.courseId,
-      sectionId: data.sectionId || null,
-      order: data.order ?? null,
-      dueBy: data.dueBy || null
+      title: sanitizedData.title,
+      description: sanitizedData.description ?? null,
+      lessonId: sanitizedData.lessonId || null,
+      courseId: sanitizedData.courseId,
+      sectionId: sanitizedData.sectionId || null,
+      order: sanitizedData.order ?? null,
+      dueBy: sanitizedData.dueBy || null
     };
 
     const [exercise] = await createExercises([exerciseData]);
@@ -63,10 +89,10 @@ export async function createExercise(data: TExerciseCreate): Promise<TExercise>
     }
 
     // Create questions and options if provided
-    if (data.questions && data.questions.length > 0) {
+    if (sanitizedData.questions && sanitizedData.questions.length > 0) {
       await db.transaction(async (tx) => {
         const txClient = tx as DbOrTxClient;
-        const questionsData: TNewQuestion[] = data.questions!.map((q) => ({
+        const questionsData: TNewQuestion[] = sanitizedData.questions!.map((q) => ({
           exerciseId: exercise.id,
           title: q.question,
           questionTypeId: q.questionTypeId || 1,
@@ -78,7 +104,7 @@ export async function createExercise(data: TExerciseCreate): Promise<TExercise>
         const questions = await createQuestions(questionsData, txClient);
 
         // Create options for each question
-        const optionsPromises = data.questions!.map(async (q, index) => {
+        const optionsPromises = sanitizedData.questions!.map(async (q, index) => {
           const question = questions[index];
           if (!question) return;
 
@@ -165,11 +191,13 @@ export async function getExercise(
  */
 export async function updateExerciseService(exerciseId: string, data: TExerciseUpdate): Promise<TExercise> {
   try {
+    const sanitizedData = sanitizeExercisePayload(data);
+
     return await db.transaction(async (tx) => {
       const txClient = tx as DbOrTxClient;
 
       // Update exercise basic fields only if they changed
-      const exerciseUpdate = buildExerciseUpdateFields(data);
+      const exerciseUpdate = buildExerciseUpdateFields(sanitizedData);
       if (Object.keys(exerciseUpdate).length > 0) {
         const updated = await updateExercise(exerciseId, exerciseUpdate, txClient);
         if (!updated) {
@@ -178,7 +206,7 @@ export async function updateExerciseService(exerciseId: string, data: TExerciseU
       }
 
       // Process questions - only update what changed
-      if (data.questions && data.questions.length > 0) {
+      if (sanitizedData.questions && sanitizedData.questions.length > 0) {
         // Query current state from DB
         const { questions: currentQuestions, options: currentOptions } = await fetchQuestionsAndOptions(
           exerciseId,
@@ -192,7 +220,7 @@ export async function updateExerciseService(exerciseId: string, data: TExerciseU
         }));
 
         // Compute diff between current DB state and incoming data
-        const diff = computeExerciseDiff(currentQuestionsWithOptions, data.questions);
+        const diff = computeExerciseDiff(currentQuestionsWithOptions, sanitizedData.questions);
 
         // Sync option id sequence so next inserts get ids > max(id) (avoids option_pkey duplicate)
         if (
@@ -240,10 +268,12 @@ export async function updateExerciseService(exerciseId: string, data: TExerciseU
  */
 export async function replaceExerciseService(exerciseId: string, data: TExerciseUpdate): Promise<TExercise> {
   try {
+    const sanitizedData = sanitizeExercisePayload(data);
+
     return await db.transaction(async (tx) => {
       const txClient = tx as DbOrTxClient;
 
-      const exerciseUpdate = buildExerciseUpdateFields(data);
+      const exerciseUpdate = buildExerciseUpdateFields(sanitizedData);
       if (Object.keys(exerciseUpdate).length > 0) {
         const updated = await updateExercise(exerciseId, exerciseUpdate, txClient);
         if (!updated) {
@@ -260,7 +290,7 @@ export async function replaceExerciseService(exerciseId: string, data: TExercise
         await deleteQuestionsByIds(currentQuestionIds, txClient);
       }
 
-      const replacementQuestions = data.questions ?? [];
+      const replacementQuestions = sanitizedData.questions ?? [];
       const hasReplacementOptions = replacementQuestions.some((question) => (question.options?.length ?? 0) > 0);
 
       if (replacementQuestions.length > 0) {
@@ -389,14 +419,16 @@ export async function createExerciseFromTemplate(
         const txClient = tx as DbOrTxClient;
         for (const question of questions) {
           const { title, question_type, options, order, points } = question;
-          const questionSettings = (question as { settings?: Record<string, unknown> }).settings ?? {};
+          const questionSettings = sanitizeUnknownStrings(
+            (question as { settings?: Record<string, unknown> }).settings ?? {}
+          );
 
           // Create question
           const [newQuestion] = await createQuestions(
             [
               {
                 exerciseId: exercise.id,
-                title,
+                title: sanitizeHtml(title),
                 questionTypeId: question_type.id,
                 points: points || 0,
                 order: order || 0,
@@ -415,9 +447,9 @@ export async function createExerciseFromTemplate(
             // value column is UUID (default gen_random_uuid()); label is the display text only
             const optionsData: TNewOption[] = options.map((opt) => ({
               questionId: newQuestion.id,
-              label: opt.label || '',
+              label: sanitizeHtml(opt.label || ''),
               isCorrect: opt.is_correct || false,
-              settings: (opt as { settings?: Record<string, unknown> }).settings ?? {}
+              settings: sanitizeUnknownStrings((opt as { settings?: Record<string, unknown> }).settings ?? {})
             }));
 
             await createOptions(optionsData, txClient);
diff --git a/apps/api/src/services/exercise/utils.ts b/apps/api/src/services/exercise/utils.ts
index 36ef580b..7718de9f 100644
--- a/apps/api/src/services/exercise/utils.ts
+++ b/apps/api/src/services/exercise/utils.ts
@@ -79,6 +79,7 @@ export function buildExerciseUpdateFields(data: TExerciseUpdate): Partial<TExerc
   if (data.order !== undefined) exerciseUpdate.order = data.order;
   if (data.isUnlocked !== undefined) exerciseUpdate.isUnlocked = data.isUnlocked;
   if (data.dueBy !== undefined) exerciseUpdate.dueBy = data.dueBy || null;
+  if (data.allowMultipleAttempts !== undefined) exerciseUpdate.allowMultipleAttempts = data.allowMultipleAttempts;
   return exerciseUpdate;
 }
 
diff --git a/apps/api/src/services/lesson-language.ts b/apps/api/src/services/lesson-language.ts
index dd9f2076..6ff5b9d3 100644
--- a/apps/api/src/services/lesson-language.ts
+++ b/apps/api/src/services/lesson-language.ts
@@ -1,4 +1,5 @@
 import { AppError, ErrorCodes } from '@api/utils/errors';
+import { sanitizeOptionalHtml } from '@api/utils/sanitize-html';
 import type { TLessonLanguage, TLocale, TNewLessonLanguage } from '@db/types';
 import {
   getLessonLanguageByLessonIdAndLocale,
@@ -65,6 +66,7 @@ export async function upsertLessonLanguageService(
 
     const language = await upsertLessonLanguage({
       ...data,
+      content: sanitizeOptionalHtml(data.content),
       lessonId
     });
 
@@ -105,7 +107,10 @@ export async function updateLessonLanguageService(
       throw new AppError('Lesson language not found', ErrorCodes.LESSON_LANGUAGE_NOT_FOUND, 404);
     }
 
-    const language = await updateLessonLanguage(lessonId, locale, data);
+    const language = await updateLessonLanguage(lessonId, locale, {
+      ...data,
+      content: sanitizeOptionalHtml(data.content)
+    });
     return language;
   } catch (error) {
     if (error instanceof AppError) {
diff --git a/apps/api/src/services/lesson/lesson.ts b/apps/api/src/services/lesson/lesson.ts
index ad577a66..78099787 100644
--- a/apps/api/src/services/lesson/lesson.ts
+++ b/apps/api/src/services/lesson/lesson.ts
@@ -1,4 +1,5 @@
 import { AppError, ErrorCodes } from '@api/utils/errors';
+import { sanitizeHtml } from '@api/utils/sanitize-html';
 import type { TLesson, TNewLessonComment, TNewLessonCompletion } from '@cio/db/types';
 import type { TLessonCreate, TLessonReorder, TLessonUpdate } from '@cio/utils/validation/lesson';
 import {
@@ -230,7 +231,7 @@ export async function createLessonCommentService(lessonId: string, groupMemberId
     const commentData: TNewLessonComment = {
       lessonId,
       groupmemberId: groupMemberId,
-      comment
+      comment: sanitizeHtml(comment)
     };
 
     return await createLessonComment(commentData);
@@ -252,7 +253,7 @@ export async function createLessonCommentService(lessonId: string, groupMemberId
  */
 export async function updateLessonCommentService(commentId: number, comment: string) {
   try {
-    const updated = await updateLessonComment(commentId, comment);
+    const updated = await updateLessonComment(commentId, sanitizeHtml(comment));
     if (!updated) {
       throw new AppError('Comment not found', ErrorCodes.LESSON_COMMENT_UPDATE_FAILED, 404);
     }
diff --git a/apps/api/src/services/newsfeed/newsfeed.ts b/apps/api/src/services/newsfeed/newsfeed.ts
index 584a4b26..0763dc8e 100644
--- a/apps/api/src/services/newsfeed/newsfeed.ts
+++ b/apps/api/src/services/newsfeed/newsfeed.ts
@@ -1,4 +1,5 @@
 import { AppError, ErrorCodes } from '@api/utils/errors';
+import { sanitizeHtml } from '@api/utils/sanitize-html';
 import type { TCourseNewsfeed, TNewCourseNewsfeed, TNewCourseNewsfeedComment } from '@cio/db/types';
 import type { TNewsfeedCreate, TNewsfeedUpdate } from '@cio/utils/validation/newsfeed';
 import {
@@ -93,10 +94,12 @@ export async function createNewsfeedService(
   data: TNewsfeedCreate
 ): Promise<TCourseNewsfeed> {
   try {
+    const sanitizedContent = sanitizeHtml(data.content);
+
     const newsfeedData: TNewCourseNewsfeed = {
       courseId,
       authorId,
-      content: data.content,
+      content: sanitizedContent,
       isPinned: data.isPinned || false
     };
 
@@ -125,7 +128,10 @@ export async function createNewsfeedService(
  */
 export async function updateNewsfeedService(feedId: string, data: TNewsfeedUpdate): Promise<TCourseNewsfeed> {
   try {
-    const updated = await updateNewsfeed(feedId, data);
+    const updated = await updateNewsfeed(feedId, {
+      ...data,
+      content: data.content === undefined ? undefined : sanitizeHtml(data.content)
+    });
     if (!updated) {
       // If no row was updated, it usually means the feed doesn't exist.
       throw new AppError('Newsfeed item not found', ErrorCodes.INTERNAL_ERROR, 404);
@@ -256,16 +262,18 @@ export async function getNewsfeedCommentsService(feedId: string, options: { curs
  */
 export async function createNewsfeedCommentService(feedId: string, authorId: string, content: string) {
   try {
+    const sanitizedContent = sanitizeHtml(content);
+
     const commentData: TNewCourseNewsfeedComment = {
       courseNewsfeedId: feedId,
       authorId,
-      content
+      content: sanitizedContent
     };
 
     const comment = await createNewsfeedComment(commentData);
 
     // Send email notification to feed author (async, don't wait)
-    sendNewsfeedCommentEmail(feedId, content).catch((error) => {
+    sendNewsfeedCommentEmail(feedId, sanitizedContent).catch((error) => {
       console.error('Failed to send newsfeed comment email:', error);
     });
 
@@ -287,7 +295,7 @@ export async function createNewsfeedCommentService(feedId: string, authorId: str
  */
 export async function updateNewsfeedCommentService(commentId: number, content: string) {
   try {
-    const updated = await updateNewsfeedComment(commentId, content);
+    const updated = await updateNewsfeedComment(commentId, sanitizeHtml(content));
     if (!updated) {
       throw new AppError('Comment not found', ErrorCodes.NEWSFEED_COMMENT_UPDATE_FAILED, 404);
     }
diff --git a/apps/api/src/services/organization.ts b/apps/api/src/services/organization.ts
index 7fd37318..55131237 100644
--- a/apps/api/src/services/organization.ts
+++ b/apps/api/src/services/organization.ts
@@ -1,6 +1,7 @@
 import { AppError, ErrorCodes } from '@api/utils/errors';
 import type { TNewOrganizationPlan, TOrganization, TOrganizationPlan } from '@db/types';
 import {
+  deleteOrganizationAudienceMember,
   cancelOrganizationPlan,
   createOrganizationPlan,
   deleteOrganizationMember,
@@ -34,7 +35,8 @@ import { createOrganizationWithOwner } from '@api/services/onboarding';
 import { getProfileById } from '@cio/db/queries/auth';
 import { inviteTeamMembers as inviteTeamMembersSecure } from './organization/invite';
 import { deriveAudienceMemberStatus } from '@api/utils/audience-member-status';
-import type { OrgAudienceMember } from '@api/types/org';
+import type { OrgAudienceMember, OrgAudiencePagination, OrgAudienceQuery } from '@api/types/org';
+import type { TGetAudienceQuery } from '@cio/utils/validation/organization';
 
 /**
  * Creates a new organization with the current user as owner
@@ -121,24 +123,43 @@ export async function getOrgTeam(orgId: string) {
  * @param orgId - The organization ID
  * @returns Audience members with invite status for profile-less rows
  */
-export async function getOrgAudience(orgId: string): Promise<OrgAudienceMember[]> {
+export async function getOrgAudience(
+  orgId: string,
+  query: TGetAudienceQuery
+): Promise<{ items: OrgAudienceMember[]; pagination: OrgAudiencePagination; query: OrgAudienceQuery }> {
   try {
-    const audience = await getOrganizationAudience(orgId);
+    const audienceResult = await getOrganizationAudience(orgId, query);
+    const audience = audienceResult.items;
 
     const emailsWithoutProfile = audience.filter((m) => !m.profileId && m.email).map((m) => m.email.toLowerCase());
 
     const invites = await getLatestOrgInvitesByEmails(orgId, emailsWithoutProfile);
     const inviteByEmail = new Map(invites.map((i) => [i.email.toLowerCase(), i]));
 
-    return audience.map(
-      (member): OrgAudienceMember => ({
-        ...member,
-        status: deriveAudienceMemberStatus(
-          member.profileId,
-          member.email ? inviteByEmail.get(member.email.toLowerCase()) : undefined
-        )
-      })
-    );
+    return {
+      items: audience.map(
+        (member): OrgAudienceMember => ({
+          ...member,
+          status: deriveAudienceMemberStatus(
+            member.profileId,
+            member.email ? inviteByEmail.get(member.email.toLowerCase()) : undefined
+          )
+        })
+      ),
+      pagination: {
+        page: audienceResult.page,
+        limit: audienceResult.limit,
+        total: audienceResult.total,
+        totalPages: audienceResult.totalPages
+      },
+      query: {
+        page: audienceResult.page,
+        limit: audienceResult.limit,
+        search: query.search,
+        sortBy: query.sortBy,
+        sortOrder: query.sortOrder
+      }
+    };
   } catch (error) {
     throw new AppError(
       error instanceof Error ? error.message : 'Failed to fetch organization audience',
@@ -148,6 +169,37 @@ export async function getOrgAudience(orgId: string): Promise<OrgAudienceMember[]
   }
 }
 
+/**
+ * Removes a student audience member from an organization
+ * @param orgId - The organization ID
+ * @param memberId - The student member ID to remove
+ * @returns Deleted member
+ */
+export async function removeAudienceMember(orgId: string, memberId: number, removedByProfileId?: string) {
+  try {
+    const deleted = await deleteOrganizationAudienceMember(orgId, memberId);
+    if (!deleted) {
+      throw new AppError('Audience member not found', ErrorCodes.ORG_AUDIENCE_REMOVE_FAILED, 404);
+    }
+
+    if (deleted.email && removedByProfileId) {
+      await revokeActiveOrganizationInvitesByEmails(orgId, [deleted.email.toLowerCase()], removedByProfileId);
+    }
+
+    return deleted;
+  } catch (error) {
+    if (error instanceof AppError) {
+      throw error;
+    }
+
+    throw new AppError(
+      error instanceof Error ? error.message : 'Failed to remove audience member',
+      ErrorCodes.ORG_AUDIENCE_REMOVE_FAILED,
+      500
+    );
+  }
+}
+
 /**
  * Gets public courses for an organization (landing page)
  * @param siteName - The organization siteName
diff --git a/apps/api/src/services/organization/audience.ts b/apps/api/src/services/organization/audience.ts
index ed156bf6..8ed5bf1d 100644
--- a/apps/api/src/services/organization/audience.ts
+++ b/apps/api/src/services/organization/audience.ts
@@ -7,7 +7,6 @@ import type {
 import { addGroupMembers, enrollUsersInCourseGroups, getExistingGroupMembers } from '@cio/db/queries/group';
 import { buildEmailFromName, sendEmail } from '@cio/email';
 import {
-  checkEmailsExistInOrg,
   createOrganizationInvite,
   createOrganizationInviteAudits,
   createOrganizationInvites,
@@ -15,6 +14,7 @@ import {
   getLatestOrganizationInviteRowByOrgAndEmail,
   getOrgMembersByProfileIds,
   getOrganizationById,
+  getOrganizationMembersByNormalizedEmails,
   getStudentOrganizationMemberByOrgAndEmail,
   hasActiveOrganizationInviteForEmail,
   revokeActiveOrganizationInvitesByEmails
@@ -108,52 +108,9 @@ function getNormalizedRecipients(recipientCsv: string): {
   return { valid, invalid, duplicates };
 }
 
-export async function importAudienceMembers(orgId: string, data: TImportAudienceMembers, invitedByProfileId: string) {
-  const organization = await getOrganizationById(orgId);
-  if (!organization || !organization.siteName) {
-    throw new AppError('Organization not found', ErrorCodes.ORGANIZATION_NOT_FOUND, 404);
-  }
-
-  const recipients = getNormalizedRecipients(data.recipientCsv);
-
-  if (recipients.invalid.length > 0) {
-    throw new AppError(
-      `Invalid emails found: ${recipients.invalid.slice(0, 5).join(', ')}`,
-      ErrorCodes.VALIDATION_ERROR,
-      400,
-      'recipientCsv'
-    );
-  }
-
-  if (recipients.valid.length === 0) {
-    throw new AppError('No valid emails provided', ErrorCodes.VALIDATION_ERROR, 400, 'recipientCsv');
-  }
-
-  const existingEmails = await checkEmailsExistInOrg(orgId, recipients.valid);
-  const emailsToImport = recipients.valid.filter((email) => !existingEmails.includes(email));
-
-  if (emailsToImport.length === 0) {
-    return {
-      imported: 0,
-      skipped: existingEmails.length,
-      duplicates: recipients.duplicates.length,
-      emailsSent: 0,
-      emailsFailed: 0
-    };
-  }
-
-  await createOrganizationMembers(
-    emailsToImport.map((email) => ({
-      organizationId: orgId,
-      email,
-      roleId: ROLE.STUDENT,
-      verified: false
-    }))
-  );
-
+async function resolveCourseIdsAndNamesForImport(orgId: string, data: TImportAudienceMembers) {
   let courseIds: string[] = [];
   let courseNames: string[] = [];
-
   if (data.allCourses) {
     const courses = await getOrgCourses({ orgId });
     courseIds = courses.map((c) => c.id);
@@ -163,25 +120,108 @@ export async function importAudienceMembers(orgId: string, data: TImportAudience
     courseIds = courses.map((c) => c.id);
     courseNames = courses.map((c) => c.title).filter(Boolean);
   }
-  if (courseIds.length > 0) {
-    const courseGroupMappings = await getCourseGroupIds(courseIds);
-    const validGroupIds = courseGroupMappings.map((m) => m.groupId).filter(Boolean) as string[];
+  return { courseIds, courseNames };
+}
 
-    if (validGroupIds.length > 0) {
-      const profiles = await getProfilesByEmails(emailsToImport);
-      if (profiles.length > 0) {
-        const users = profiles.map((p) => ({ profileId: p.id, email: p.email ?? undefined }));
-        await enrollUsersInCourseGroups(validGroupIds, users, ROLE.STUDENT);
-      }
-    }
+async function enrollAudienceStudentProfilesInCourses(
+  orgId: string,
+  organization: NonNullable<Awaited<ReturnType<typeof getOrganizationById>>>,
+  profileIds: string[],
+  courseIds: string[],
+  shouldSendEmail: boolean
+): Promise<{ assigned: number; alreadyEnrolled: number; emailsSent: number }> {
+  if (courseIds.length === 0 || profileIds.length === 0) {
+    return { assigned: 0, alreadyEnrolled: 0, emailsSent: 0 };
   }
 
-  await revokeActiveOrganizationInvitesByEmails(orgId, emailsToImport, invitedByProfileId);
+  const uniqueProfileIds = [...new Set(profileIds)];
+  const orgMembers = await getOrgMembersByProfileIds(orgId, uniqueProfileIds);
+  const studentMembers = orgMembers.filter((m) => m.profileId && m.roleId === ROLE.STUDENT);
+  const validProfileIds = new Set(studentMembers.map((m) => m.profileId!));
+  const profileEmailMap = new Map(studentMembers.filter((m) => m.profileId).map((m) => [m.profileId!, m.email ?? '']));
+
+  const courseGroups = await getOrgCourseGroups(orgId, courseIds);
+
+  if (courseGroups.length === 0) {
+    return { assigned: 0, alreadyEnrolled: 0, emailsSent: 0 };
+  }
+
+  const validGroupIds = courseGroups.map((cg) => cg.groupId).filter(Boolean) as string[];
+  const courseTitleByGroupId = new Map(courseGroups.map((cg) => [cg.groupId, cg.courseTitle]));
+  const validProfiles = uniqueProfileIds.filter((id) => validProfileIds.has(id));
+
+  const pairs = validProfiles.flatMap((profileId) => validGroupIds.map((groupId) => ({ groupId, profileId })));
+
+  const existingSet = await getExistingGroupMembers(pairs);
+
+  const toInsert = pairs.filter((p) => !existingSet.has(`${p.groupId}:${p.profileId}`));
+  const alreadyEnrolled = pairs.length - toInsert.length;
+
+  if (toInsert.length > 0) {
+    await addGroupMembers(
+      toInsert.map((p) => ({
+        groupId: p.groupId,
+        roleId: ROLE.STUDENT,
+        profileId: p.profileId,
+        email: profileEmailMap.get(p.profileId) || undefined
+      }))
+    );
+  }
+
+  let emailsSent = 0;
+  const loginUrl = getDashboardBaseUrl(organization.siteName ?? undefined);
+
+  if (shouldSendEmail && toInsert.length > 0) {
+    const emailPromises = toInsert
+      .filter((p) => profileEmailMap.get(p.profileId))
+      .map(async (p) => {
+        const email = profileEmailMap.get(p.profileId)!;
+        try {
+          await sendEmail('studentCourseWelcome', {
+            to: email,
+            fields: {
+              orgName: organization.name,
+              courseName: courseTitleByGroupId.get(p.groupId) || 'Course',
+              loginUrl
+            },
+            from: buildEmailFromName(`${organization.name} (via ClassroomIO.com)`)
+          });
+          emailsSent++;
+        } catch (emailError) {
+          console.error(`enrollAudienceStudentProfilesInCourses email error for ${email}:`, emailError);
+        }
+      });
+
+    await Promise.all(emailPromises);
+  }
+
+  return {
+    assigned: toInsert.length,
+    alreadyEnrolled,
+    emailsSent
+  };
+}
+
+async function createStudentOrgInvitesAndSendEmails(input: {
+  orgId: string;
+  organization: NonNullable<Awaited<ReturnType<typeof getOrganizationById>>>;
+  emails: string[];
+  courseIds: string[];
+  courseNamesLabel: string | undefined;
+  invitedByProfileId: string;
+  shouldSendEmail: boolean;
+}): Promise<{ created: number; emailsSent: number; emailsFailed: number }> {
+  const { orgId, organization, emails, courseIds, courseNamesLabel, invitedByProfileId, shouldSendEmail } = input;
+
+  if (emails.length === 0) {
+    return { created: 0, emailsSent: 0, emailsFailed: 0 };
+  }
+
+  await revokeActiveOrganizationInvitesByEmails(orgId, emails, invitedByProfileId);
 
   const expiresAt = new Date(Date.now() + ORG_INVITE_EXPIRY_MS).toISOString();
-  const courseNamesLabel = courseNames.length > 0 ? courseNames.join(', ') : undefined;
 
-  const inviteInputs = emailsToImport.map((email) => {
+  const inviteInputs = emails.map((email) => {
     const token = generateToken();
     return {
       email,
@@ -207,7 +247,7 @@ export async function importAudienceMembers(orgId: string, data: TImportAudience
   const tokenByEmail = new Map(inviteInputs.map((i) => [i.email.toLowerCase(), i.token]));
 
   await createOrganizationInviteAudits(
-    emailsToImport.map((email) => {
+    emails.map((email) => {
       const invite = inviteByEmail.get(email)!;
       return {
         inviteId: invite.id,
@@ -230,8 +270,8 @@ export async function importAudienceMembers(orgId: string, data: TImportAudience
   let emailsSent = 0;
   let emailsFailed = 0;
 
-  if (data.sendEmail) {
-    const emailOutcomes = await mapWithConcurrency(emailsToImport, EMAIL_SEND_CONCURRENCY, async (email) => {
+  if (shouldSendEmail) {
+    const emailOutcomes = await mapWithConcurrency(emails, EMAIL_SEND_CONCURRENCY, async (email) => {
       const invite = inviteByEmail.get(email)!;
       const token = tokenByEmail.get(email)!;
       try {
@@ -289,12 +329,140 @@ export async function importAudienceMembers(orgId: string, data: TImportAudience
     );
   }
 
+  return { created: emails.length, emailsSent, emailsFailed };
+}
+
+export async function importAudienceMembers(orgId: string, data: TImportAudienceMembers, invitedByProfileId: string) {
+  const organization = await getOrganizationById(orgId);
+  if (!organization || !organization.siteName) {
+    throw new AppError('Organization not found', ErrorCodes.ORGANIZATION_NOT_FOUND, 404);
+  }
+
+  const recipients = getNormalizedRecipients(data.recipientCsv);
+
+  if (recipients.invalid.length > 0) {
+    throw new AppError(
+      `Invalid emails found: ${recipients.invalid.slice(0, 5).join(', ')}`,
+      ErrorCodes.VALIDATION_ERROR,
+      400,
+      'recipientCsv'
+    );
+  }
+
+  if (recipients.valid.length === 0) {
+    throw new AppError('No valid emails provided', ErrorCodes.VALIDATION_ERROR, 400, 'recipientCsv');
+  }
+
+  const memberRows = await getOrganizationMembersByNormalizedEmails(orgId, recipients.valid);
+  const memberByEmail = new Map(memberRows.map((m) => [m.normalizedEmail, m]));
+
+  const newEmails: string[] = [];
+  const existingStudentProfileIds: string[] = [];
+  const pendingStudentEmails: string[] = [];
+  const teamEmails: string[] = [];
+
+  for (const email of recipients.valid) {
+    const m = memberByEmail.get(email);
+    if (!m) {
+      newEmails.push(email);
+      continue;
+    }
+    if (m.roleId !== ROLE.STUDENT) {
+      teamEmails.push(email);
+      continue;
+    }
+    if (!m.profileId) {
+      pendingStudentEmails.push(email);
+      continue;
+    }
+    existingStudentProfileIds.push(m.profileId);
+  }
+
+  if (teamEmails.length > 0) {
+    throw new AppError(
+      `These emails belong to organization staff, not students: ${teamEmails.slice(0, 8).join(', ')}${teamEmails.length > 8 ? '…' : ''}`,
+      ErrorCodes.VALIDATION_ERROR,
+      400,
+      'recipientCsv'
+    );
+  }
+
+  const { courseIds, courseNames } = await resolveCourseIdsAndNamesForImport(orgId, data);
+  const courseNamesLabel = courseNames.length > 0 ? courseNames.join(', ') : undefined;
+
+  const assignResult = await enrollAudienceStudentProfilesInCourses(
+    orgId,
+    organization,
+    existingStudentProfileIds,
+    courseIds,
+    data.sendEmail
+  );
+
+  let imported = 0;
+  let importEmailsSent = 0;
+  let importEmailsFailed = 0;
+
+  if (newEmails.length > 0) {
+    await createOrganizationMembers(
+      newEmails.map((email) => ({
+        organizationId: orgId,
+        email,
+        roleId: ROLE.STUDENT,
+        verified: false
+      }))
+    );
+
+    if (courseIds.length > 0) {
+      const courseGroupMappings = await getCourseGroupIds(courseIds);
+      const validGroupIds = courseGroupMappings.map((m) => m.groupId).filter(Boolean) as string[];
+
+      if (validGroupIds.length > 0) {
+        const profiles = await getProfilesByEmails(newEmails);
+        if (profiles.length > 0) {
+          const users = profiles.map((p) => ({ profileId: p.id, email: p.email ?? undefined }));
+          await enrollUsersInCourseGroups(validGroupIds, users, ROLE.STUDENT);
+        }
+      }
+    }
+
+    const inviteOutcome = await createStudentOrgInvitesAndSendEmails({
+      orgId,
+      organization,
+      emails: newEmails,
+      courseIds,
+      courseNamesLabel,
+      invitedByProfileId,
+      shouldSendEmail: data.sendEmail
+    });
+    imported = newEmails.length;
+    importEmailsSent = inviteOutcome.emailsSent;
+    importEmailsFailed = inviteOutcome.emailsFailed;
+  }
+
+  let pendingEmailsSent = 0;
+  let pendingEmailsFailed = 0;
+  if (pendingStudentEmails.length > 0) {
+    const pendingOutcome = await createStudentOrgInvitesAndSendEmails({
+      orgId,
+      organization,
+      emails: pendingStudentEmails,
+      courseIds,
+      courseNamesLabel,
+      invitedByProfileId,
+      shouldSendEmail: data.sendEmail
+    });
+    pendingEmailsSent = pendingOutcome.emailsSent;
+    pendingEmailsFailed = pendingOutcome.emailsFailed;
+  }
+
   return {
-    imported: emailsToImport.length,
-    skipped: existingEmails.length,
+    imported,
+    assigned: assignResult.assigned,
+    alreadyEnrolledInCourses: assignResult.alreadyEnrolled,
+    pendingInvitesRenewed: pendingStudentEmails.length,
     duplicates: recipients.duplicates.length,
-    emailsSent,
-    emailsFailed
+    emailsSent: assignResult.emailsSent + importEmailsSent + pendingEmailsSent,
+    emailsFailed: importEmailsFailed + pendingEmailsFailed
   };
 }
 
@@ -465,67 +633,10 @@ export async function assignAudienceToCourses(orgId: string, data: TAssignAudien
     throw new AppError('Organization not found', ErrorCodes.ORGANIZATION_NOT_FOUND, 404);
   }
 
-  const orgMembers = await getOrgMembersByProfileIds(orgId, data.profileIds);
-
-  const validProfileIds = new Set(orgMembers.map((m) => m.profileId).filter(Boolean));
-  const profileEmailMap = new Map(orgMembers.filter((m) => m.profileId).map((m) => [m.profileId!, m.email ?? '']));
-
   const courseGroups = await getOrgCourseGroups(orgId, data.courseIds);
-
   if (courseGroups.length === 0) {
     throw new AppError('No valid courses found', ErrorCodes.VALIDATION_ERROR, 400, 'courseIds');
   }
 
-  const validGroupIds = courseGroups.map((cg) => cg.groupId).filter(Boolean) as string[];
-  const courseTitleByGroupId = new Map(courseGroups.map((cg) => [cg.groupId, cg.courseTitle]));
-  const validProfiles = data.profileIds.filter((id) => validProfileIds.has(id));
-
-  const pairs = validProfiles.flatMap((profileId) => validGroupIds.map((groupId) => ({ groupId, profileId })));
-
-  const existingSet = await getExistingGroupMembers(pairs);
-
-  const toInsert = pairs.filter((p) => !existingSet.has(`${p.groupId}:${p.profileId}`));
-  const alreadyEnrolled = pairs.length - toInsert.length;
-
-  if (toInsert.length > 0) {
-    await addGroupMembers(
-      toInsert.map((p) => ({
-        groupId: p.groupId,
-        roleId: ROLE.STUDENT,
-        profileId: p.profileId,
-        email: profileEmailMap.get(p.profileId) || undefined
-      }))
-    );
-  }
-
-  let emailsSent = 0;
-
-  if (data.sendEmail && toInsert.length > 0) {
-    const emailPromises = toInsert
-      .filter((p) => profileEmailMap.get(p.profileId))
-      .map(async (p) => {
-        const email = profileEmailMap.get(p.profileId)!;
-        try {
-          await sendEmail('studentCourseWelcome', {
-            to: email,
-            fields: {
-              orgName: organization.name,
-              courseName: courseTitleByGroupId.get(p.groupId) || 'Course'
-            },
-            from: buildEmailFromName(`${organization.name} (via ClassroomIO.com)`)
-          });
-          emailsSent++;
-        } catch (emailError) {
-          console.error(`assignAudienceToCourses email error for ${email}:`, emailError);
-        }
-      });
-
-    await Promise.all(emailPromises);
-  }
-
-  return {
-    assigned: toInsert.length,
-    alreadyEnrolled,
-    emailsSent
-  };
+  return enrollAudienceStudentProfilesInCourses(orgId, organization, data.profileIds, data.courseIds, data.sendEmail);
 }
diff --git a/apps/api/src/services/submission/submission.ts b/apps/api/src/services/submission/submission.ts
index e484c122..981f6177 100644
--- a/apps/api/src/services/submission/submission.ts
+++ b/apps/api/src/services/submission/submission.ts
@@ -1,7 +1,7 @@
 import type { AnswerData, FileUploadAnswerData } from '@cio/question-types';
 import { scoreSubmissionAnswers, type ScoreSubmissionResult, validateTextareaAnswer } from '@cio/question-types';
 import { AppError, ErrorCodes } from '@api/utils/errors';
-import type { TNewSubmission, TSubmission } from '@cio/db/types';
+import type { TNewQuestionAnswer, TNewSubmission, TSubmission } from '@cio/db/types';
 import type {
   TSubmissionAnswerUpdate,
   TSubmissionGradesUpdate,
@@ -15,10 +15,11 @@ import {
   getSubmissionById,
   getSubmissionsByCourseIdWithDetails,
   getSubmissionsForGrading,
+  hasSubmission,
+  insertQuestionAnswersBatch,
   updateQuestionAnswer,
   updateSubmission,
-  updateSubmissionGrades,
-  upsertQuestionAnswer
+  updateSubmissionGrades
 } from '@cio/db/queries/submission';
 import {
   fromApiPayload,
@@ -32,7 +33,7 @@ import { getExerciseById, getExerciseWithRelationsOptimized } from '@cio/db/quer
 import { getGroupMemberIdByCourseAndProfile, isCourseTeamMemberOrOrgAdmin } from '@cio/db/queries/group';
 
 import { QUESTION_TYPE_ID_TO_KEY } from '@cio/question-types';
-import { db } from '@cio/db/drizzle';
+
 import { getDashboardBaseUrl } from '@api/config/dashboard-url';
 import { generateDocumentDownloadPresignedUrls } from '@api/utils/s3';
 
@@ -355,27 +356,26 @@ export async function listSubmissionsForGrading(courseId: string) {
         timeStyle: 'medium'
       }).format(new Date(submission.createdAt!));
 
-      // Format answers
-      const questionByIdAndName: { [id: number]: string } = {};
+      const questionKeyById: { [id: number]: string } = {};
       const questionTypeById: { [id: number]: number } = {};
       for (const question of submission.exercise.questions || []) {
-        questionByIdAndName[question.id] = question.name ?? '';
+        questionKeyById[question.id] = question.name ? String(question.name) : String(question.id);
         questionTypeById[question.id] = question.questionTypeId;
       }
 
-      const formattedAnswers: { [questionName: string]: AnswerData } = {};
+      const formattedAnswers: { [questionKey: string]: AnswerData } = {};
       const questionAnswerByPoint: { [questionId: number]: number } = {};
 
       for (const answer of submission.answers || []) {
-        const questionName = questionByIdAndName[answer.questionId];
+        const questionKey = questionKeyById[answer.questionId];
         if (
-          questionName &&
+          questionKey &&
           answer.answerData &&
           typeof answer.answerData === 'object' &&
           answer.answerData !== null &&
           'type' in answer.answerData
         ) {
-          formattedAnswers[questionName] = answer.answerData as AnswerData;
+          formattedAnswers[questionKey] = answer.answerData as AnswerData;
         }
         questionAnswerByPoint[answer.questionId] = answer.point || 0;
       }
@@ -475,11 +475,15 @@ export async function createSubmissionService(
   answers: Array<{ questionId: number; optionId?: number; answer?: string }>
 ): Promise<TSubmission & { answers?: any[] }> {
   try {
-    const exerciseWithRelations = await getExerciseWithRelationsOptimized(exerciseId);
+    const [exerciseWithRelations, courseRows] = await Promise.all([
+      getExerciseWithRelationsOptimized(exerciseId),
+      getCourseById(courseId)
+    ]);
+    const course = courseRows[0];
 
     if (!exerciseWithRelations.exercise.allowMultipleAttempts) {
-      const existing = await getSubmissionsByCourseIdWithDetails(courseId, exerciseId, submittedBy);
-      if (existing.length > 0) {
+      const alreadySubmitted = await hasSubmission(exerciseId, submittedBy);
+      if (alreadySubmitted) {
         throw new AppError('This exercise allows only one submission', ErrorCodes.VALIDATION_ERROR, 400);
       }
     }
@@ -498,7 +502,7 @@ export async function createSubmissionService(
       statusId: projectLegacyStatusId(gradingState),
       gradingState,
       overallStatus,
-      total: 0 // Will be calculated during grading
+      total: 0
     };
 
     let submission = await createSubmission(submissionData);
@@ -529,51 +533,45 @@ export async function createSubmissionService(
     );
 
     const answerByQuestionId = new Map<number, AnswerData>();
+    const answerRows: TNewQuestionAnswer[] = [];
 
-    // Create question answers
-    if (answers.length > 0) {
-      await db.transaction(async () => {
-        for (const ans of answers) {
-          const question = questionById.get(ans.questionId);
-          if (!question) continue;
+    for (const ans of answers) {
+      const question = questionById.get(ans.questionId);
+      if (!question) continue;
 
-          const answerData = fromApiPayload(
-            question.questionType,
-            { questionId: ans.questionId, optionId: ans.optionId, answer: ans.answer },
-            question
+      const answerData = fromApiPayload(
+        question.questionType,
+        { questionId: ans.questionId, optionId: ans.optionId, answer: ans.answer },
+        question
+      );
+      if (!answerData) continue;
+
+      if (answerData.type === 'TEXTAREA') {
+        const validation = validateTextareaAnswer(answerData.text, question);
+
+        if (!validation.isValid) {
+          throw new AppError(
+            validation.minCharacters !== undefined && validation.maxCharacters !== undefined
+              ? `Paragraph answer must be between ${validation.minCharacters} and ${validation.maxCharacters} characters`
+              : validation.reason === 'below_min' && validation.minCharacters !== undefined
+                ? `Paragraph answer must be at least ${validation.minCharacters} characters`
+                : `Paragraph answer must be at most ${validation.maxCharacters} characters`,
+            ErrorCodes.VALIDATION_ERROR,
+            400
           );
-          if (!answerData) continue;
-
-          if (answerData.type === 'TEXTAREA') {
-            const validation = validateTextareaAnswer(answerData.text, question);
-
-            if (!validation.isValid) {
-              throw new AppError(
-                validation.minCharacters !== undefined && validation.maxCharacters !== undefined
-                  ? `Paragraph answer must be between ${validation.minCharacters} and ${validation.maxCharacters} characters`
-                  : validation.reason === 'below_min' && validation.minCharacters !== undefined
-                    ? `Paragraph answer must be at least ${validation.minCharacters} characters`
-                    : `Paragraph answer must be at most ${validation.maxCharacters} characters`,
-                ErrorCodes.VALIDATION_ERROR,
-                400
-              );
-            }
-          }
-
-          answerByQuestionId.set(ans.questionId, answerData);
-
-          await upsertQuestionAnswer({
-            submissionId: submission.id,
-            questionId: ans.questionId,
-            groupMemberId: submittedBy,
-            answerData
-          });
         }
+      }
+
+      answerByQuestionId.set(ans.questionId, answerData);
+
+      answerRows.push({
+        submissionId: submission.id,
+        questionId: ans.questionId,
+        groupMemberId: submittedBy,
+        answerData
       });
     }
 
-    const courseRows = await getCourseById(courseId);
-    const course = courseRows[0];
     const shouldAutoGrade =
       course?.type === 'SELF_PACED' && overallStatus === 'auto_graded' && exerciseWithRelations.questions.length > 0;
 
@@ -582,7 +580,7 @@ export async function createSubmissionService(
       for (const q of exerciseWithRelations.questions) {
         if (q.id == null) continue;
         if (!answeredIds.has(q.id)) {
-          await upsertQuestionAnswer({
+          answerRows.push({
             submissionId: submission.id,
             questionId: q.id,
             groupMemberId: submittedBy,
@@ -590,7 +588,11 @@ export async function createSubmissionService(
           });
         }
       }
+    }
 
+    const insertedAnswers = answerRows.length > 0 ? await insertQuestionAnswersBatch(answerRows) : [];
+
+    if (shouldAutoGrade) {
       const dbQuestions = exerciseWithRelations.questions
         .filter((q): q is typeof q & { id: number } => q.id != null)
         .map((q) => ({
@@ -616,20 +618,28 @@ export async function createSubmissionService(
 
       if (graded) {
         submission = graded;
+
+        const pointByQuestionId = new Map(
+          scores.map((s: ScoreSubmissionResult['scores'][number]) => [s.questionId, s.points])
+        );
+        const answersWithPoints = insertedAnswers.map((row) => ({
+          ...row,
+          point: pointByQuestionId.get(row.questionId) ?? row.point
+        }));
+
+        void sendExerciseSubmissionUpdateEmail(courseId, exerciseId, submittedBy).catch((emailError) => {
+          console.error('Failed to send exercise submission update email:', emailError);
+        });
+
+        const enrichedAnswers =
+          answersWithPoints.length > 0 ? await enrichFileUploadAnswersArray(answersWithPoints) : answersWithPoints;
+        return { ...submission, answers: enrichedAnswers };
       }
     }
 
-    // Send email notification to teachers
-    try {
-      await sendExerciseSubmissionUpdateEmail(courseId, exerciseId, submittedBy);
-    } catch (emailError) {
-      // Log but don't fail the request if email fails
+    void sendExerciseSubmissionUpdateEmail(courseId, exerciseId, submittedBy).catch((emailError) => {
       console.error('Failed to send exercise submission update email:', emailError);
-    }
-
-    if (submission.gradingState === 'completed') {
-      return await getSubmission(submission.id);
-    }
+    });
 
     return submission;
   } catch (error) {
@@ -679,14 +689,10 @@ export async function updateSubmissionService(submissionId: string, data: TSubmi
       throw new AppError('Failed to update submission', ErrorCodes.INTERNAL_ERROR, 500);
     }
 
-    // Send email notification if status changed
     if (statusChanged) {
-      try {
-        await sendSubmissionUpdateEmail(submissionId, nextLegacyStatusId);
-      } catch (emailError) {
-        // Log but don't fail the request if email fails
+      void sendSubmissionUpdateEmail(submissionId, nextLegacyStatusId).catch((emailError) => {
         console.error('Failed to send submission update email:', emailError);
-      }
+      });
     }
 
     return updated;
@@ -782,11 +788,9 @@ export async function updateSubmissionGradesBatch(
     }
 
     if (statusChanged) {
-      try {
-        await sendSubmissionUpdateEmail(submissionId, targetStatusId);
-      } catch (emailError) {
+      void sendSubmissionUpdateEmail(submissionId, targetStatusId).catch((emailError) => {
         console.error('Failed to send submission update email:', emailError);
-      }
+      });
     }
 
     return updated;
diff --git a/apps/api/src/types/org.ts b/apps/api/src/types/org.ts
index 5091f2c8..48158e7e 100644
--- a/apps/api/src/types/org.ts
+++ b/apps/api/src/types/org.ts
@@ -1,4 +1,5 @@
 import type { AudienceMemberStatus } from '@api/utils/audience-member-status';
+import type { TAudienceSortBy, TAudienceSortOrder } from '@cio/utils/validation/organization';
 
 export type OrgAudienceMember = {
   id: number;
@@ -9,3 +10,18 @@ export type OrgAudienceMember = {
   createdAt: string;
   status: AudienceMemberStatus;
 };
+
+export type OrgAudiencePagination = {
+  page: number;
+  limit: number;
+  total: number;
+  totalPages: number;
+};
+
+export type OrgAudienceQuery = {
+  page: number;
+  limit: number;
+  search?: string;
+  sortBy: TAudienceSortBy;
+  sortOrder: TAudienceSortOrder;
+};
diff --git a/apps/api/src/utils/course-completion.ts b/apps/api/src/utils/course-completion.ts
new file mode 100644
index 00000000..27114f59
--- /dev/null
+++ b/apps/api/src/utils/course-completion.ts
@@ -0,0 +1,89 @@
+import { getDashboardBaseUrl } from '@api/config/dashboard-url';
+import {
+  getCourseProgress as getCourseProgressQuery,
+  type TCourseCertificationRow
+} from '@cio/db/queries/course/course';
+import { setMemberCertificateEarned, setMemberCertificationEmailSent } from '@cio/db/queries/course/people';
+import { getProfileById } from '@cio/db/queries/auth';
+import { buildEmailFromName, sendEmail } from '@cio/email';
+
+export function calcCourseProgressPercent(params: {
+  lessonsCompleted: number;
+  totalLessons: number;
+  exercisesCompleted: number;
+  exercisesCount: number;
+}): number {
+  const totalItems = params.totalLessons + params.exercisesCount;
+
+  if (totalItems === 0) return 0;
+
+  const completedItems = params.lessonsCompleted + params.exercisesCompleted;
+
+  return Math.round((completedItems / totalItems) * 100);
+}
+
+export function isBeforeOrEqualDeadline(deadlineIso: string | null | undefined, now: Date): boolean {
+  if (!deadlineIso) return true;
+
+  const deadlineDate = new Date(deadlineIso);
+
+  if (Number.isNaN(deadlineDate.getTime())) return true;
+
+  return now.getTime() <= deadlineDate.getTime();
+}
+
+/**
+ * Persists certificate earned time, then sends the completion email and records
+ * {@link setMemberCertificationEmailSent}, without blocking the HTTP handler.
+ * Re-fetches progress so concurrent jobs can skip work already done.
+ */
+export function scheduleCertificationCompletionWork(params: {
+  courseId: string;
+  profileId: string;
+  groupMemberId: string;
+  courseRow: TCourseCertificationRow;
+  earnedAt: string;
+}): void {
+  const { courseId, profileId, groupMemberId, courseRow, earnedAt } = params;
+
+  void (async () => {
+    try {
+      let latest = await getCourseProgressQuery(courseId, profileId);
+
+      if (!latest.certificateEarnedAt) {
+        await setMemberCertificateEarned(groupMemberId, earnedAt);
+        latest = await getCourseProgressQuery(courseId, profileId);
+      }
+
+      if (latest.certificationEmailSentAt) {
+        return;
+      }
+
+      const profile = await getProfileById(profileId);
+      const studentEmail = profile?.email;
+
+      if (!studentEmail) {
+        return;
+      }
+
+      const base = getDashboardBaseUrl(courseRow.orgSiteName ?? undefined);
+      const certificateUrl = `${base}/courses/${courseId}/certificates`;
+
+      await sendEmail('studentCourseCompletion', {
+        to: studentEmail,
+        fields: {
+          orgName: courseRow.orgName,
+          courseName: courseRow.title,
+          studentName: profile?.fullname || studentEmail,
+          certificateUrl,
+          customMessage: courseRow.certificate?.emailMessage ?? null
+        },
+        from: buildEmailFromName(`${courseRow.orgName} (via ClassroomIO.com)`)
+      });
+
+      await setMemberCertificationEmailSent(groupMemberId, new Date().toISOString());
+    } catch (error) {
+      console.error('scheduleCertificationCompletionWork: failed:', error);
+    }
+  })();
+}
diff --git a/apps/api/src/utils/errors.ts b/apps/api/src/utils/errors.ts
index 79cc0bd3..736e1779 100644
--- a/apps/api/src/utils/errors.ts
+++ b/apps/api/src/utils/errors.ts
@@ -60,6 +60,7 @@ export const ErrorCodes = {
   ORG_PLAN_NOT_FOUND: 'ORG_PLAN_NOT_FOUND',
   ORG_TEAM_INVITE_FAILED: 'ORG_TEAM_INVITE_FAILED',
   ORG_TEAM_REMOVE_FAILED: 'ORG_TEAM_REMOVE_FAILED',
+  ORG_AUDIENCE_REMOVE_FAILED: 'ORG_AUDIENCE_REMOVE_FAILED',
   ORG_TEAM_EMAIL_EXISTS: 'ORG_TEAM_EMAIL_EXISTS',
   ORG_TEAM_NOT_AUTHORIZED: 'ORG_TEAM_NOT_AUTHORIZED',
   ORGANIZATION_API_KEY_NOT_FOUND: 'ORGANIZATION_API_KEY_NOT_FOUND',
diff --git a/apps/api/src/utils/redis/redis.ts b/apps/api/src/utils/redis/redis.ts
index 098b7d37..dd465624 100644
--- a/apps/api/src/utils/redis/redis.ts
+++ b/apps/api/src/utils/redis/redis.ts
@@ -6,25 +6,38 @@ const client: RedisClientType = createClient({
   url: env.REDIS_URL
 });
 
+let hasLoggedRedisUnavailable = false;
+
+export function logRedisUnavailableOnce(message: string, error?: unknown): void {
+  if (hasLoggedRedisUnavailable) {
+    return;
+  }
+
+  hasLoggedRedisUnavailable = true;
+
+  if (error) {
+    console.warn(message, error);
+    return;
+  }
+
+  console.warn(message);
+}
+
 // Handle connection events
 client.on('error', (err) => {
-  console.error('Redis Client Error:', err);
+  logRedisUnavailableOnce('Redis unavailable, Redis-backed features disabled', err);
 });
 
 client.on('connect', () => {
   console.log('Redis Client Connected');
 });
 
-client.on('reconnecting', () => {
-  console.log('Redis Client Reconnecting');
-});
-
 // Track connection state
 let isConnected = false;
 
 export async function connectRedis(): Promise<void> {
   if (!env.REDIS_URL) {
-    console.warn('REDIS_URL not set, Redis features disabled');
+    logRedisUnavailableOnce('REDIS_URL not set, Redis features disabled');
     return;
   }
   if (isConnected) return;
@@ -32,7 +45,7 @@ export async function connectRedis(): Promise<void> {
     await client.connect();
     isConnected = true;
   } catch (error) {
-    console.error('Redis connection failed, API will run without Redis:', error);
+    logRedisUnavailableOnce('Redis connection failed, API will run without Redis', error);
     // Don't throw - allow API to start; rate limiting and caching will degrade gracefully
   }
 }
diff --git a/apps/api/src/utils/s3.ts b/apps/api/src/utils/s3.ts
index df231815..172825d5 100644
--- a/apps/api/src/utils/s3.ts
+++ b/apps/api/src/utils/s3.ts
@@ -9,7 +9,7 @@ import {
 
 import { getSignedUrl } from '@aws-sdk/s3-request-presigner';
 import { getPresignS3Client, getS3Client, getStorageConfig } from '@api/config/storage';
-import { redis } from '@api/utils/redis/redis';
+import { logRedisUnavailableOnce, redis } from '@api/utils/redis/redis';
 
 export type GetSignedUrlParameters = Parameters<typeof getSignedUrl>;
 
@@ -70,7 +70,7 @@ export async function generateDownloadPresignedUrls(
   try {
     cachedValues = await redis.mGet(cacheKeys);
   } catch (error) {
-    console.error('Redis mGet failed for presigned URL cache, falling back to S3:', error);
+    logRedisUnavailableOnce('Redis cache unavailable for presigned URLs, falling back to S3', error);
   }
 
   const keysToGenerate: string[] = [];
@@ -121,7 +121,7 @@ export async function generateDownloadPresignedUrls(
     });
     await pipeline.exec();
   } catch (error) {
-    console.error('Redis setEx failed for presigned URL cache:', error);
+    logRedisUnavailableOnce('Redis cache write unavailable for presigned URLs, continuing without cache', error);
     // URLs are already in signedUrls; cache write failure is non-fatal
   }
 
diff --git a/apps/api/src/utils/sanitize-html.ts b/apps/api/src/utils/sanitize-html.ts
new file mode 100644
index 00000000..678d89d0
--- /dev/null
+++ b/apps/api/src/utils/sanitize-html.ts
@@ -0,0 +1,39 @@
+import { createSanitizeHtmlConfig, stripSvgDataUrls } from '@cio/utils/functions';
+import DOMPurify from 'isomorphic-dompurify';
+
+export function sanitizeHtml(html: string): string {
+  let sanitized = DOMPurify.sanitize(html, createSanitizeHtmlConfig());
+
+  sanitized = stripSvgDataUrls(sanitized);
+
+  return sanitized;
+}
+
+export function sanitizeOptionalHtml(html: string | undefined): string | undefined;
+export function sanitizeOptionalHtml(html: string | null | undefined): string | null | undefined;
+export function sanitizeOptionalHtml(html: string | null | undefined): string | null | undefined {
+  if (html == null) return html;
+
+  return sanitizeHtml(html);
+}
+
+export function sanitizeUnknownStrings<T>(value: T): T {
+  if (typeof value === 'string') {
+    return sanitizeHtml(value) as T;
+  }
+
+  if (Array.isArray(value)) {
+    return value.map((item) => sanitizeUnknownStrings(item)) as T;
+  }
+
+  if (value && typeof value === 'object') {
+    const sanitizedEntries = Object.entries(value).map(([key, entryValue]) => [
+      key,
+      sanitizeUnknownStrings(entryValue)
+    ]);
+
+    return Object.fromEntries(sanitizedEntries) as T;
+  }
+
+  return value;
+}
diff --git a/apps/dashboard/src/app.css b/apps/dashboard/src/app.css
index 1e6c35c1..3613a272 100644
--- a/apps/dashboard/src/app.css
+++ b/apps/dashboard/src/app.css
@@ -180,6 +180,31 @@ html .dark {
   @apply text-end;
 }
 
+.prose hr {
+  @apply my-6 border-t;
+  border-top-color: var(--border);
+}
+
+.prose pre {
+  @apply my-4 overflow-auto rounded-lg p-4;
+  background-color: var(--muted);
+}
+
+.dark .prose pre {
+  background-color: color-mix(in oklch, var(--muted) 30%, transparent);
+}
+
+.prose pre code {
+  @apply bg-transparent p-0 text-sm;
+  font-family: 'JetBrains Mono', monospace, Consolas, Monaco, 'Andale Mono', 'Ubuntu Mono';
+  color: inherit;
+}
+
+.prose code:not(pre code) {
+  @apply rounded px-1.5 py-0.5 text-sm font-semibold;
+  background-color: var(--muted);
+}
+
 /* .dark .prose h1,
 .dark .prose h2,
 .dark .prose h3,
diff --git a/apps/dashboard/src/lib/features/audience/components/audience-delete-confirmation.svelte b/apps/dashboard/src/lib/features/audience/components/audience-delete-confirmation.svelte
new file mode 100644
index 00000000..6bc630fe
--- /dev/null
+++ b/apps/dashboard/src/lib/features/audience/components/audience-delete-confirmation.svelte
@@ -0,0 +1,42 @@
+<script lang="ts">
+  import * as Dialog from '@cio/ui/base/dialog';
+  import { Button } from '@cio/ui/base/button';
+  import { t } from '$lib/utils/functions/translations';
+  import type { OrganizationAudienceMember } from '$features/org/utils/types';
+
+  interface Props {
+    open: boolean;
+    member: OrganizationAudienceMember | null;
+    isDeleting?: boolean;
+    onDelete: () => void | Promise<void>;
+  }
+
+  let { open = $bindable(false), member, isDeleting = false, onDelete }: Props = $props();
+</script>
+
+<Dialog.Root bind:open>
+  <Dialog.Content class="w-full max-w-md">
+    <Dialog.Header>
+      <Dialog.Title>{$t('audience.delete.title')}</Dialog.Title>
+      <Dialog.Description>{$t('audience.delete.description')}</Dialog.Description>
+    </Dialog.Header>
+
+    <div class="space-y-4">
+      <p class="text-sm">
+        {$t('audience.delete.confirmation', {
+          email: member?.email ?? '',
+          name: member?.name ?? member?.email ?? ''
+        })}
+      </p>
+
+      <div class="flex justify-end gap-2">
+        <Button variant="outline" onclick={() => (open = false)} disabled={isDeleting}>
+          {$t('audience.delete.cancel')}
+        </Button>
+        <Button variant="destructive" onclick={onDelete} loading={isDeleting} disabled={!member || isDeleting}>
+          {$t('audience.delete.confirm')}
+        </Button>
+      </div>
+    </div>
+  </Dialog.Content>
+</Dialog.Root>
diff --git a/apps/dashboard/src/lib/features/audience/components/audience-member-row.svelte b/apps/dashboard/src/lib/features/audience/components/audience-member-row.svelte
index d4563521..98a35b5e 100644
--- a/apps/dashboard/src/lib/features/audience/components/audience-member-row.svelte
+++ b/apps/dashboard/src/lib/features/audience/components/audience-member-row.svelte
@@ -20,16 +20,31 @@
     selected: boolean;
     onToggleSelect: () => void;
     inviteActionEmail: string | null;
+    deletingMemberId: string | null;
+    canDeleteMembers: boolean;
     onResendInvite: (email: string) => void;
     onRevokeInvite: (email: string) => void;
+    onDelete: () => void;
   }
 
-  let { row, memberDetailHref, selected, onToggleSelect, inviteActionEmail, onResendInvite, onRevokeInvite }: Props =
-    $props();
+  let {
+    row,
+    memberDetailHref,
+    selected,
+    onToggleSelect,
+    inviteActionEmail,
+    deletingMemberId,
+    canDeleteMembers,
+    onResendInvite,
+    onRevokeInvite,
+    onDelete
+  }: Props = $props();
 
   const showInviteActions = $derived(
     !row.profileId && (canResendAudienceInvite(row.status) || canRevokeAudienceInvite(row.status))
   );
+  const isActionDisabled = $derived(inviteActionEmail === row.email || deletingMemberId === String(row.id));
+  const showRowActions = $derived(showInviteActions || canDeleteMembers);
 </script>
 
 <Table.Row>
@@ -55,31 +70,40 @@
   </Table.Cell>
   <Table.Cell>{row.createdAt}</Table.Cell>
   <Table.Cell class="text-right">
-    {#if showInviteActions}
+    {#if showRowActions}
       <DropdownMenu.Root>
         <DropdownMenu.Trigger
           class="hover:ui:bg-muted inline-flex items-center justify-center rounded-md p-1.5"
           aria-label={$t('audience.invite.row_actions_aria')}
-          disabled={inviteActionEmail !== null}
+          disabled={isActionDisabled}
           onclick={(e) => e.stopPropagation()}
         >
           <EllipsisVerticalIcon class="ui:size-4 ui:text-muted-foreground" />
         </DropdownMenu.Trigger>
         <DropdownMenu.Content align="end">
           {#if canResendAudienceInvite(row.status)}
-            <DropdownMenu.Item disabled={inviteActionEmail === row.email} onclick={() => onResendInvite(row.email)}>
+            <DropdownMenu.Item disabled={isActionDisabled} onclick={() => onResendInvite(row.email)}>
               {$t('audience.invite.resend')}
             </DropdownMenu.Item>
           {/if}
           {#if canRevokeAudienceInvite(row.status)}
             <DropdownMenu.Item
               class="ui:text-destructive focus:ui:text-destructive"
-              disabled={inviteActionEmail === row.email}
+              disabled={isActionDisabled}
               onclick={() => onRevokeInvite(row.email)}
             >
               {$t('audience.invite.revoke')}
             </DropdownMenu.Item>
           {/if}
+          {#if canDeleteMembers}
+            <DropdownMenu.Item
+              class="ui:text-destructive focus:ui:text-destructive"
+              disabled={isActionDisabled}
+              onclick={onDelete}
+            >
+              {$t('audience.delete.action')}
+            </DropdownMenu.Item>
+          {/if}
         </DropdownMenu.Content>
       </DropdownMenu.Root>
     {/if}
diff --git a/apps/dashboard/src/lib/features/audience/components/audience-table-toolbar.svelte b/apps/dashboard/src/lib/features/audience/components/audience-table-toolbar.svelte
index acab7939..818c70e9 100644
--- a/apps/dashboard/src/lib/features/audience/components/audience-table-toolbar.svelte
+++ b/apps/dashboard/src/lib/features/audience/components/audience-table-toolbar.svelte
@@ -1,5 +1,6 @@
 <script lang="ts">
   import { Button } from '@cio/ui/base/button';
+  import * as Select from '@cio/ui/base/select';
   import { Search } from '@cio/ui/custom/search';
   import * as Page from '@cio/ui/base/page';
   import { t } from '$lib/utils/functions/translations';
@@ -8,10 +9,28 @@
     hasSelection: boolean;
     selectedCount: number;
     searchValue?: string;
+    sortValue: string;
+    onSortChange: (value: string) => void;
     onOpenAssign: () => void;
   }
 
-  let { hasSelection, selectedCount, searchValue = $bindable(''), onOpenAssign }: Props = $props();
+  let {
+    hasSelection,
+    selectedCount,
+    searchValue = $bindable(''),
+    sortValue,
+    onSortChange,
+    onOpenAssign
+  }: Props = $props();
+
+  const sortOptions = [
+    { label: t.get('audience.sort.newest'), value: 'createdAt:desc' },
+    { label: t.get('audience.sort.oldest'), value: 'createdAt:asc' },
+    { label: t.get('audience.sort.name_asc'), value: 'name:asc' },
+    { label: t.get('audience.sort.name_desc'), value: 'name:desc' },
+    { label: t.get('audience.sort.email_asc'), value: 'email:asc' },
+    { label: t.get('audience.sort.email_desc'), value: 'email:desc' }
+  ];
 </script>
 
 <Page.BodyHeader>
@@ -25,6 +44,22 @@
       </Button>
     </div>
   {:else}
-    <Search placeholder={$t('audience.search_placeholder')} bind:value={searchValue} class="" />
+    <div class="flex w-full flex-col gap-2 md:flex-row md:items-center md:justify-between">
+      <Search placeholder={$t('audience.search_placeholder')} bind:value={searchValue} class="w-full md:max-w-sm" />
+      <Select.Root type="single" value={sortValue} onValueChange={onSortChange} name="audience-sort">
+        <Select.Trigger class="w-full md:w-[220px]">
+          {sortOptions.find((option) => option.value === sortValue)?.label ?? $t('audience.sort.label')}
+        </Select.Trigger>
+        <Select.Content>
+          <Select.Group>
+            {#each sortOptions as option (option.value)}
+              <Select.Item value={option.value} label={option.label} disabled={option.value === sortValue}>
+                {option.label}
+              </Select.Item>
+            {/each}
+          </Select.Group>
+        </Select.Content>
+      </Select.Root>
+    </div>
   {/if}
 </Page.BodyHeader>
diff --git a/apps/dashboard/src/lib/features/audience/components/audience-table.svelte b/apps/dashboard/src/lib/features/audience/components/audience-table.svelte
index 13e0e5a3..30f18f42 100644
--- a/apps/dashboard/src/lib/features/audience/components/audience-table.svelte
+++ b/apps/dashboard/src/lib/features/audience/components/audience-table.svelte
@@ -20,8 +20,11 @@
     isRowSelected: (rowId: string) => boolean;
     onToggleRow: (rowId: string) => void;
     inviteActionEmail: string | null;
+    deletingMemberId: string | null;
+    canDeleteMembers: boolean;
     onResendInvite: (email: string) => void;
     onRevokeInvite: (email: string) => void;
+    onDeleteRow: (row: OrganizationAudienceMember) => void;
   }
 
   let {
@@ -33,8 +36,11 @@
     isRowSelected,
     onToggleRow,
     inviteActionEmail,
+    deletingMemberId,
+    canDeleteMembers,
     onResendInvite,
-    onRevokeInvite
+    onRevokeInvite,
+    onDeleteRow
   }: Props = $props();
 
   function memberHref(row: OrganizationAudienceMember): string | null {
@@ -71,8 +77,11 @@
           selected={isRowSelected(String(row.id))}
           onToggleSelect={() => onToggleRow(String(row.id))}
           {inviteActionEmail}
+          {deletingMemberId}
+          {canDeleteMembers}
           {onResendInvite}
           {onRevokeInvite}
+          onDelete={() => onDeleteRow(row)}
         />
       {/each}
     </Table.Body>
diff --git a/apps/dashboard/src/lib/features/audience/components/index.ts b/apps/dashboard/src/lib/features/audience/components/index.ts
index b9a6c99e..1d960bed 100644
--- a/apps/dashboard/src/lib/features/audience/components/index.ts
+++ b/apps/dashboard/src/lib/features/audience/components/index.ts
@@ -1,5 +1,6 @@
 export { default as AssignCoursesModal } from './assign-courses-modal.svelte';
 export { default as AudienceMemberRow } from './audience-member-row.svelte';
+export { default as AudienceDeleteConfirmation } from './audience-delete-confirmation.svelte';
 export { default as AudiencePagination } from './audience-pagination.svelte';
 export { default as AudienceTable } from './audience-table.svelte';
 export { default as AudienceTableSkeleton } from './audience-table-skeleton.svelte';
diff --git a/apps/dashboard/src/lib/features/audience/pages/audience.svelte b/apps/dashboard/src/lib/features/audience/pages/audience.svelte
index 5fae1f5c..39ef187a 100644
--- a/apps/dashboard/src/lib/features/audience/pages/audience.svelte
+++ b/apps/dashboard/src/lib/features/audience/pages/audience.svelte
@@ -1,17 +1,25 @@
 <script lang="ts">
+  import { goto } from '$app/navigation';
+  import { page } from '$app/state';
   import UsersIcon from '@lucide/svelte/icons/users';
   import { orgApi } from '$features/org/api/org.svelte';
   import { t } from '$lib/utils/functions/translations';
   import { Empty } from '@cio/ui/custom/empty';
   import { UpgradeBanner } from '$features/ui';
-  import { currentOrgMaxAudience } from '$lib/utils/store/org';
-  import type { OrganizationAudience } from '$features/org/utils/types';
+  import { currentOrgMaxAudience, isOrgAdmin } from '$lib/utils/store/org';
+  import type {
+    OrganizationAudience,
+    OrganizationAudienceMember,
+    OrganizationAudiencePagination,
+    OrganizationAudienceQuery
+  } from '$features/org/utils/types';
   import AssignCoursesModal from '$features/audience/components/assign-courses-modal.svelte';
+  import AudienceDeleteConfirmation from '$features/audience/components/audience-delete-confirmation.svelte';
   import AudienceTableToolbar from '$features/audience/components/audience-table-toolbar.svelte';
-  import AudienceTableSkeleton from '$features/audience/components/audience-table-skeleton.svelte';
   import AudienceTable from '$features/audience/components/audience-table.svelte';
   import AudiencePagination from '$features/audience/components/audience-pagination.svelte';
   import { SvelteSet } from 'svelte/reactivity';
+  import { DEFAULT_ORG_AUDIENCE_QUERY, getAudienceSearchParams } from '$features/org/utils/audience-query-utils';
 
   interface Course {
     id: string;
@@ -20,15 +28,17 @@
 
   interface Props {
     audience?: OrganizationAudience;
+    pagination?: OrganizationAudiencePagination | null;
+    query: OrganizationAudienceQuery;
     courses?: Course[];
   }
 
-  let { audience, courses = [] }: Props = $props();
+  let { audience, pagination = null, query, courses = [] }: Props = $props();
 
   $effect(() => {
-    if (audience) {
-      orgApi.audience = audience;
-    }
+    orgApi.audience = audience ?? [];
+    orgApi.audiencePagination = pagination;
+    selectedIds.clear();
   });
 
   const headers = $derived([
@@ -39,11 +49,19 @@
   ]);
 
   let inviteActionEmail = $state<string | null>(null);
+  let deletingMemberId = $state<string | null>(null);
+  let deleteCandidate = $state<OrganizationAudienceMember | null>(null);
+  let deleteDialogOpen = $state(false);
+  let searchValue = $state(query.search ?? '');
+  let sortValue = $state(`${query.sortBy}:${query.sortOrder}`);
 
   async function handleResendInvite(email: string) {
     inviteActionEmail = email;
     try {
-      await orgApi.resendAudienceInvite({ email });
+      const result = await orgApi.resendAudienceInvite({ email });
+      if (result) {
+        await refreshAudience();
+      }
     } finally {
       inviteActionEmail = null;
     }
@@ -52,32 +70,22 @@
   async function handleRevokeInvite(email: string) {
     inviteActionEmail = email;
     try {
-      await orgApi.revokeAudienceInvite({ email });
+      const result = await orgApi.revokeAudienceInvite({ email });
+      if (result) {
+        await refreshAudience();
+      }
     } finally {
       inviteActionEmail = null;
     }
   }
 
-  let pageSize = $state(20);
-  let currentPage = $state(1);
-  let searchValue = $state('');
   let selectedIds = new SvelteSet<string>();
   let assignModalOpen = $state(false);
 
-  const filteredRows = $derived(
-    searchValue
-      ? orgApi.audience.filter((row) =>
-          Object.values(row).some((val) => String(val).toLowerCase().includes(searchValue.toLowerCase()))
-        )
-      : orgApi.audience
-  );
-
-  const totalPages = $derived(Math.ceil(filteredRows.length / pageSize));
-  const startIndex = $derived((currentPage - 1) * pageSize);
-  const endIndex = $derived(startIndex + pageSize);
-  const paginatedRows = $derived(filteredRows.slice(startIndex, endIndex));
-
-  const selectablePageRows = $derived(paginatedRows.filter((row) => row.profileId));
+  const currentPage = $derived(pagination?.page ?? DEFAULT_ORG_AUDIENCE_QUERY.page);
+  const pageSize = $derived(pagination?.limit ?? DEFAULT_ORG_AUDIENCE_QUERY.limit);
+  const totalCount = $derived(pagination?.total ?? 0);
+  const selectablePageRows = $derived(orgApi.audience.filter((row) => row.profileId));
 
   const allPageSelected = $derived(
     selectablePageRows.length > 0 && selectablePageRows.every((row) => selectedIds.has(String(row.id)))
@@ -117,13 +125,110 @@
   }
 
   $effect(() => {
-    if (filteredRows.length > 0 && currentPage > totalPages) {
-      currentPage = 1;
-    }
+    searchValue = query.search ?? '';
+    sortValue = `${query.sortBy}:${query.sortOrder}`;
   });
+
+  $effect(() => {
+    const normalizedSearch = searchValue.trim() || undefined;
+    const currentSearch = query.search ?? undefined;
+
+    if (normalizedSearch === currentSearch) {
+      return;
+    }
+
+    const timeoutId = setTimeout(() => {
+      void navigateAudience({
+        ...query,
+        page: 1,
+        search: normalizedSearch
+      });
+    }, 300);
+
+    return () => clearTimeout(timeoutId);
+  });
+
+  async function refreshAudience(pageOverride = currentPage) {
+    await navigateAudience({
+      ...query,
+      page: pageOverride
+    });
+  }
+
+  async function navigateAudience(nextQuery: OrganizationAudienceQuery) {
+    const searchParams = getAudienceSearchParams(nextQuery);
+    const nextSearch = searchParams.toString();
+    const currentSearch = page.url.searchParams.toString();
+
+    await goto(`${page.url.pathname}?${nextSearch}`, {
+      replaceState: nextSearch === currentSearch,
+      keepFocus: true,
+      noScroll: true,
+      invalidateAll: true
+    });
+  }
+
+  function handlePageChange(nextPage: number) {
+    if (nextPage === currentPage) {
+      return;
+    }
+
+    void navigateAudience({
+      ...query,
+      page: nextPage
+    });
+  }
+
+  function handleSortChange(nextSortValue: string) {
+    if (nextSortValue === sortValue) {
+      return;
+    }
+
+    sortValue = nextSortValue;
+    const [sortBy, sortOrder] = nextSortValue.split(':') as [
+      OrganizationAudienceQuery['sortBy'],
+      OrganizationAudienceQuery['sortOrder']
+    ];
+
+    void navigateAudience({
+      ...query,
+      page: 1,
+      sortBy,
+      sortOrder
+    });
+  }
+
+  function openDeleteConfirmation(member: OrganizationAudienceMember) {
+    deleteCandidate = member;
+    deleteDialogOpen = true;
+  }
+
+  async function handleDeleteAudienceMember() {
+    if (!deleteCandidate) {
+      return;
+    }
+
+    deletingMemberId = String(deleteCandidate.id);
+
+    try {
+      const result = await orgApi.deleteAudienceMember(Number(deleteCandidate.id));
+      if (!result) {
+        return;
+      }
+
+      selectedIds.delete(String(deleteCandidate.id));
+
+      const nextPage = orgApi.audience.length === 1 && currentPage > 1 ? currentPage - 1 : currentPage;
+      await refreshAudience(nextPage);
+      deleteCandidate = null;
+      deleteDialogOpen = false;
+    } finally {
+      deletingMemberId = null;
+    }
+  }
 </script>
 
-{#if orgApi.audience.length >= $currentOrgMaxAudience}
+{#if totalCount >= $currentOrgMaxAudience}
   <UpgradeBanner>{$t('audience.upgrade')}</UpgradeBanner>
 {/if}
 
@@ -131,34 +236,30 @@
   {hasSelection}
   selectedCount={selectedIds.size}
   bind:searchValue
+  {sortValue}
+  onSortChange={handleSortChange}
   onOpenAssign={() => (assignModalOpen = true)}
 />
 
-{#if orgApi.audience.length || orgApi.isLoading}
+{#if totalCount > 0}
   <div class="w-full space-y-4">
-    {#if orgApi.isLoading}
-      <AudienceTableSkeleton rowCount={pageSize} />
-    {:else}
-      <AudienceTable
-        {headers}
-        rows={paginatedRows}
-        {allPageSelected}
-        {somePageSelected}
-        onToggleSelectAll={toggleSelectAll}
-        isRowSelected={(id) => selectedIds.has(id)}
-        onToggleRow={toggleRow}
-        {inviteActionEmail}
-        onResendInvite={handleResendInvite}
-        onRevokeInvite={handleRevokeInvite}
-      />
-    {/if}
-
-    <AudiencePagination
-      count={filteredRows.length}
-      perPage={pageSize}
-      page={currentPage}
-      onPageChange={(p) => (currentPage = p)}
+    <AudienceTable
+      {headers}
+      rows={orgApi.audience}
+      {allPageSelected}
+      {somePageSelected}
+      onToggleSelectAll={toggleSelectAll}
+      isRowSelected={(id) => selectedIds.has(id)}
+      onToggleRow={toggleRow}
+      {inviteActionEmail}
+      {deletingMemberId}
+      canDeleteMembers={$isOrgAdmin === true}
+      onResendInvite={handleResendInvite}
+      onRevokeInvite={handleRevokeInvite}
+      onDeleteRow={openDeleteConfirmation}
     />
+
+    <AudiencePagination count={totalCount} perPage={pageSize} page={currentPage} onPageChange={handlePageChange} />
   </div>
 {:else}
   <Empty title={$t('audience.no_audience')} description={$t('audience.manage')} icon={UsersIcon} variant="page" />
@@ -171,3 +272,10 @@
   onclose={() => (assignModalOpen = false)}
   onassigned={handleAssigned}
 />
+
+<AudienceDeleteConfirmation
+  bind:open={deleteDialogOpen}
+  member={deleteCandidate}
+  isDeleting={deletingMemberId !== null}
+  onDelete={handleDeleteAudienceMember}
+/>
diff --git a/apps/dashboard/src/lib/features/course/api/course.svelte.ts b/apps/dashboard/src/lib/features/course/api/course.svelte.ts
index b59a03fd..da3a70b8 100644
--- a/apps/dashboard/src/lib/features/course/api/course.svelte.ts
+++ b/apps/dashboard/src/lib/features/course/api/course.svelte.ts
@@ -9,6 +9,7 @@ import type {
   EnrollCourseRequest,
   GetCourseAnalyticsRequest,
   GetCourseBySlugRequest,
+  GetCertificationEvaluationRequest,
   GetCourseProgressRequest,
   GetCourseRequest,
   UpdateCourseData,
@@ -543,6 +544,27 @@ export class CourseApi extends BaseApiWithErrors {
     });
   }
 
+  async getCertificationEvaluation(courseId: string) {
+    return this.execute<GetCertificationEvaluationRequest>({
+      requestFn: () =>
+        classroomio.course[':courseId']['certification-evaluation'].$get({
+          param: { courseId }
+        }),
+      logContext: 'fetching certification evaluation',
+      onSuccess: (response) => {
+        if (response.data) {
+          this.success = true;
+          this.errors = {};
+        }
+      },
+      onError: (result) => {
+        if (typeof result === 'string') {
+          snackbar.error('Failed to load certification status');
+        }
+      }
+    });
+  }
+
   /**
    * Gets course analytics including student progress, completion rates, and grades
    * @param courseId Course ID
@@ -635,7 +657,7 @@ export class CourseApi extends BaseApiWithErrors {
     const lessonTabsOrder = metadata?.lessonTabsOrder;
     if (lessonTabsOrder) {
       const existingTabIds = lessonTabsOrder.map((tab) => tab.id);
-      const allTabs = [
+      const allTabs: Array<{ id: 1 | 2 | 3 | 4; name: string }> = [
         { id: 1, name: 'course.navItem.lessons.materials.tabs.note.title' },
         { id: 2, name: 'course.navItem.lessons.materials.tabs.slide.title' },
         { id: 3, name: 'course.navItem.lessons.materials.tabs.video.title' },
@@ -661,9 +683,15 @@ export class CourseApi extends BaseApiWithErrors {
       };
     }
 
-    // Ensure certificateTheme has default value
-    if (!data.certificateTheme) {
-      data.certificateTheme = 'professional';
+    if (!data.certificate) {
+      data.certificate = {
+        isDownloadable: false,
+        theme: 'professional'
+      };
+    }
+
+    if (!data.certificate.theme) {
+      data.certificate.theme = 'professional';
     }
 
     // Set the course data
diff --git a/apps/dashboard/src/lib/features/course/api/exercise.svelte.ts b/apps/dashboard/src/lib/features/course/api/exercise.svelte.ts
index 34d1a606..a6b0ef86 100644
--- a/apps/dashboard/src/lib/features/course/api/exercise.svelte.ts
+++ b/apps/dashboard/src/lib/features/course/api/exercise.svelte.ts
@@ -32,7 +32,7 @@ export class ExerciseApi extends BaseApiWithErrors {
       logContext: 'fetching exercise',
       onSuccess: (response) => {
         if (response.data) {
-          this.exercise = response.data;
+          this.exercise = response.data as Exercise;
           this.success = true;
           this.errors = {};
         }
@@ -64,7 +64,7 @@ export class ExerciseApi extends BaseApiWithErrors {
       logContext: 'creating exercise',
       onSuccess: (response) => {
         if (response.data) {
-          this.exercise = response.data;
+          this.exercise = response.data as Exercise;
           snackbar.success('Exercise created successfully');
           this.success = true;
           this.errors = {};
@@ -106,7 +106,7 @@ export class ExerciseApi extends BaseApiWithErrors {
       logContext: 'updating exercise',
       onSuccess: (response) => {
         if (response.data) {
-          this.exercise = response.data;
+          this.exercise = response.data as Exercise;
           this.success = true;
           this.errors = {};
         }
@@ -163,7 +163,7 @@ export class ExerciseApi extends BaseApiWithErrors {
       return;
     }
 
-    await this.execute<SubmitExerciseRequest>({
+    return await this.execute<SubmitExerciseRequest>({
       requestFn: () =>
         classroomio.course[':courseId'].exercise[':exerciseId'].submission.$post({
           param: { courseId, exerciseId },
@@ -220,7 +220,7 @@ export class ExerciseApi extends BaseApiWithErrors {
       logContext: 'creating exercise from template',
       onSuccess: (response) => {
         if (response.data) {
-          this.exercise = response.data;
+          this.exercise = response.data as Exercise;
           snackbar.success('Exercise created successfully');
           this.success = true;
           this.errors = {};
diff --git a/apps/dashboard/src/lib/features/course/api/lesson.svelte.ts b/apps/dashboard/src/lib/features/course/api/lesson.svelte.ts
index 4eb9ef33..639051c1 100644
--- a/apps/dashboard/src/lib/features/course/api/lesson.svelte.ts
+++ b/apps/dashboard/src/lib/features/course/api/lesson.svelte.ts
@@ -38,7 +38,6 @@ import {
 import {
   ZLessonCommentCreate,
   ZLessonCommentUpdate,
-  ZLessonCompletionUpdate,
   ZLessonCreate,
   ZLessonReorder,
   ZLessonUpdate
@@ -46,8 +45,8 @@ import {
 
 import type { TLocale } from '@cio/db/types';
 import { get } from 'svelte/store';
-import { mediaApi } from '$features/media/api';
 import { mapZodErrorsToTranslations } from '$lib/utils/validation';
+import { mediaApi } from '$features/media/api';
 import { profile } from '$lib/utils/store/user';
 import { snackbar } from '$features/ui/snackbar/store';
 
@@ -607,17 +606,11 @@ export class LessonApi extends BaseApiWithErrors {
    * Updates lesson completion
    */
   async updateCompletion(courseId: string, lessonId: string, isComplete: boolean) {
-    const result = ZLessonCompletionUpdate.safeParse({ isComplete });
-    if (!result.success) {
-      this.errors = mapZodErrorsToTranslations(result.error, 'lesson');
-      return;
-    }
-
-    await this.execute<UpdateLessonCompletionRequest>({
+    return this.execute<UpdateLessonCompletionRequest>({
       requestFn: () =>
         classroomio.course[':courseId'].lesson[':lessonId'].completion.$put({
           param: { courseId, lessonId },
-          json: result.data
+          json: { isComplete }
         }),
       logContext: 'updating lesson completion',
       onSuccess: (response) => {
diff --git a/apps/dashboard/src/lib/features/course/components/ceritficate/certificate-design.svelte b/apps/dashboard/src/lib/features/course/components/ceritficate/certificate-design.svelte
new file mode 100644
index 00000000..c7247458
--- /dev/null
+++ b/apps/dashboard/src/lib/features/course/components/ceritficate/certificate-design.svelte
@@ -0,0 +1,134 @@
+<script lang="ts">
+  import { goto } from '$app/navigation';
+  import { resolve } from '$app/paths';
+  import { Label } from '@cio/ui/base/label';
+  import * as RadioGroup from '@cio/ui/base/radio-group';
+  import { Button } from '@cio/ui/base/button';
+  import { Textarea } from '@cio/ui/base/textarea';
+  import * as Field from '@cio/ui/base/field';
+  import { t } from '$lib/utils/functions/translations';
+
+  import { courseApi } from '$features/course/api';
+  import { CERTIFICATE_THEME_IDS, type CertificateThemeId } from '$features/course/utils/constants';
+  import { parseCertificateThemeId } from '$features/course/utils/certificate-utils';
+  import { currentOrg, isFreePlan } from '$lib/utils/store/org';
+  import Plain from './templates/plain.svelte';
+  import Professional from './templates/professional.svelte';
+  import BlueBadgePattern from './templates/blue-badge-pattern.svelte';
+  import PurpleBadgePattern from './templates/purple-badge-pattern.svelte';
+  import BlueProfessionalBadge from './templates/blue-professional-badge.svelte';
+  import PurpleProfessionalBadge from './templates/purple-professional-badge.svelte';
+
+  type Props = {
+    errors: Record<string, string>;
+  };
+
+  let { errors }: Props = $props();
+
+  const studentNamePlaceholder = 'Name of student';
+
+  const certificateTheme = $derived(parseCertificateThemeId(courseApi.course?.certificate?.theme));
+
+  const helperText = $derived(
+    `${courseApi.course?.description?.length || 0}/200 ${$t('course.navItem.certificates.characters')}`
+  );
+
+  function onDescriptionInput(e: Event) {
+    if (!courseApi.course) return;
+    courseApi.course.description = (e.currentTarget as HTMLTextAreaElement).value;
+  }
+
+  function goToOrgSettings() {
+    goto(
+      resolve('/org/[slug]/settings', {
+        slug: $currentOrg.siteName || ''
+      })
+    );
+  }
+</script>
+
+<div class="mb-3 flex h-4/5 w-full flex-1 flex-col justify-between gap-3 lg:flex-row">
+  <section class="h-full w-full lg:w-2/5">
+    <Field.Group class="w-full max-w-md! px-2">
+      <Field.Set>
+        <Field.Legend>{$t('course.navItem.certificates.certificate_settings')}</Field.Legend>
+
+        <Field.Group>
+          <Field.Field>
+            <Field.Label>{$t('course.navItem.certificates.theme')}</Field.Label>
+            <RadioGroup.Root
+              value={certificateTheme}
+              onValueChange={(value) => {
+                if (!courseApi.course) return;
+
+                courseApi.course.certificate = {
+                  ...(courseApi.course.certificate ?? {}),
+                  theme: value as CertificateThemeId
+                };
+              }}
+              disabled={$isFreePlan}
+              class="mb-6"
+            >
+              <div class="flex flex-wrap justify-between gap-y-5">
+                {#each CERTIFICATE_THEME_IDS as theme (theme)}
+                  <div class="mr-3 flex items-start space-x-2">
+                    <RadioGroup.Item value={theme} id={theme} />
+                    <Label for={theme} class="cursor-pointer">
+                      <img src={`/images/certificate_theme_${theme}.png`} alt="" class="h-[82px] w-[110px]" />
+                    </Label>
+                  </div>
+                {/each}
+              </div>
+            </RadioGroup.Root>
+          </Field.Field>
+
+          <Field.Field>
+            <Field.Label>{$t('course.navItem.certificates.logo')}</Field.Label>
+            <Field.Description>
+              {$t('course.navItem.certificates.to_update')}
+              <strong class="font-semibold">{$t('course.navItem.certificates.settings')}</strong>
+              {$t('course.navItem.certificates.and_upload')}
+            </Field.Description>
+            <Button variant="outline" class="mt-3" onclick={goToOrgSettings}>
+              {$t('course.navItem.certificates.goto_settings')}
+            </Button>
+          </Field.Field>
+
+          <Field.Field>
+            <Field.Label for="cert-design-description">{$t('course.navItem.certificates.description')}</Field.Label>
+            <Textarea
+              id="cert-design-description"
+              rows={6}
+              class="w-full"
+              placeholder={$t('course.navItem.certificates.placeholder')}
+              value={courseApi.course?.description ?? ''}
+              oninput={onDescriptionInput}
+              disabled={$isFreePlan}
+            />
+            <Field.Description>{helperText}</Field.Description>
+            {#if errors.description}
+              <Field.Error>{errors.description}</Field.Error>
+            {/if}
+          </Field.Field>
+        </Field.Group>
+      </Field.Set>
+    </Field.Group>
+  </section>
+  <section class="flex w-full rounded-md lg:w-3/5">
+    <div class="w-[95%]">
+      {#if certificateTheme === 'professional'}
+        <Professional studentName={studentNamePlaceholder} />
+      {:else if certificateTheme === 'plain'}
+        <Plain studentName={studentNamePlaceholder} />
+      {:else if certificateTheme === 'purpleProfessionalBadge'}
+        <PurpleProfessionalBadge studentName={studentNamePlaceholder} />
+      {:else if certificateTheme === 'blueProfessionalBadge'}
+        <BlueProfessionalBadge studentName={studentNamePlaceholder} />
+      {:else if certificateTheme === 'purpleBadgePattern'}
+        <PurpleBadgePattern studentName={studentNamePlaceholder} />
+      {:else if certificateTheme === 'blueBadgePattern'}
+        <BlueBadgePattern studentName={studentNamePlaceholder} />
+      {/if}
+    </div>
+  </section>
+</div>
diff --git a/apps/dashboard/src/lib/features/course/components/ceritficate/certificate-edit.svelte b/apps/dashboard/src/lib/features/course/components/ceritficate/certificate-edit.svelte
new file mode 100644
index 00000000..c05a1ddd
--- /dev/null
+++ b/apps/dashboard/src/lib/features/course/components/ceritficate/certificate-edit.svelte
@@ -0,0 +1,38 @@
+<script lang="ts">
+  import * as UnderlineTabs from '@cio/ui/custom/underline-tabs';
+  import { t } from '$lib/utils/functions/translations';
+
+  import { UpgradeBanner } from '$features/ui';
+
+  import CertificateDesign from './certificate-design.svelte';
+  import CertificateSettings from './certificate-settings.svelte';
+
+  type Props = {
+    errors: Record<string, string>;
+  };
+
+  let { errors }: Props = $props();
+
+  let activeTab = $state('design');
+</script>
+
+<UpgradeBanner>{$t('upgrade.certificate')}</UpgradeBanner>
+
+<main class="px-2 md:-mr-3 md:-ml-3">
+  <UnderlineTabs.Root bind:value={activeTab} class="w-full">
+    <UnderlineTabs.List>
+      <UnderlineTabs.Trigger value="design">
+        {$t('course.navItem.certificates.tab_design')}
+      </UnderlineTabs.Trigger>
+      <UnderlineTabs.Trigger value="settings">
+        {$t('course.navItem.certificates.tab_settings')}
+      </UnderlineTabs.Trigger>
+    </UnderlineTabs.List>
+    <UnderlineTabs.Content value="design" class="mt-4">
+      <CertificateDesign {errors} />
+    </UnderlineTabs.Content>
+    <UnderlineTabs.Content value="settings" class="mt-4">
+      <CertificateSettings {errors} />
+    </UnderlineTabs.Content>
+  </UnderlineTabs.Root>
+</main>
diff --git a/apps/dashboard/src/lib/features/course/components/ceritficate/certificate-settings.svelte b/apps/dashboard/src/lib/features/course/components/ceritficate/certificate-settings.svelte
new file mode 100644
index 00000000..6ed92be7
--- /dev/null
+++ b/apps/dashboard/src/lib/features/course/components/ceritficate/certificate-settings.svelte
@@ -0,0 +1,186 @@
+<script lang="ts">
+  import { Switch } from '@cio/ui/base/switch';
+  import { Input } from '@cio/ui/base/input';
+  import { Textarea } from '@cio/ui/base/textarea';
+  import * as Field from '@cio/ui/base/field';
+  import { t } from '$lib/utils/functions/translations';
+  import { courseApi } from '$features/course/api';
+  import { isFreePlan } from '$lib/utils/store/org';
+  import { getOrderedNavigableContent } from '$features/course/utils/content';
+  import { ContentType } from '@cio/utils/constants/content';
+
+  type Props = {
+    errors: Record<string, string>;
+  };
+
+  let { errors }: Props = $props();
+
+  function isoToDatetimeLocal(iso: string | null | undefined): string {
+    if (!iso) return '';
+    const d = new Date(iso);
+    if (Number.isNaN(d.getTime())) return '';
+    const pad = (n: number) => String(n).padStart(2, '0');
+    return `${d.getFullYear()}-${pad(d.getMonth() + 1)}-${pad(d.getDate())}T${pad(d.getHours())}:${pad(d.getMinutes())}`;
+  }
+
+  function updateCertificate(patch: Partial<NonNullable<typeof courseApi.course>['certificate']>) {
+    if (!courseApi.course) return;
+
+    courseApi.course.certificate = {
+      ...(courseApi.course.certificate ?? {}),
+      ...patch
+    };
+  }
+
+  function onCertDeadlineChange(e: Event) {
+    const v = (e.currentTarget as HTMLInputElement).value;
+    updateCertificate({ deadline: v ? new Date(v).toISOString() : null });
+  }
+
+  const certExercises = $derived(
+    getOrderedNavigableContent(courseApi.course).filter((item) => item.type === ContentType.Exercise)
+  );
+
+  const finalExerciseSelectValue = $derived(courseApi.course?.certificate?.requiredExerciseId ?? 'none');
+
+  function onFinalExerciseChange(e: Event) {
+    const v = (e.currentTarget as HTMLSelectElement).value;
+    if (!v || v === 'none') {
+      updateCertificate({ requiredExerciseId: null, exerciseMinScorePercent: null });
+      return;
+    }
+
+    const currentMin = courseApi.course?.certificate?.exerciseMinScorePercent;
+    updateCertificate({
+      requiredExerciseId: v,
+      exerciseMinScorePercent: currentMin ?? 100
+    });
+  }
+
+  function onThresholdInput(e: Event) {
+    const n = Number((e.currentTarget as HTMLInputElement).value);
+    updateCertificate({ threshold: Number.isFinite(n) ? Math.min(100, Math.max(0, n)) : 100 });
+  }
+
+  function onMinExerciseScoreInput(e: Event) {
+    const n = Number((e.currentTarget as HTMLInputElement).value);
+    updateCertificate({ exerciseMinScorePercent: Number.isFinite(n) ? Math.min(100, Math.max(0, n)) : 100 });
+  }
+
+  function onEmailMessageInput(e: Event) {
+    updateCertificate({ emailMessage: (e.currentTarget as HTMLTextAreaElement).value || null });
+  }
+</script>
+
+<Field.Group class="w-full max-w-md! px-2">
+  <Field.Set>
+    <Field.Legend>{$t('course.certification.rules_heading')}</Field.Legend>
+
+    <Field.Field orientation="horizontal">
+      <Switch
+        id="certificate-downloadable"
+        checked={!!courseApi.course?.certificate?.isDownloadable}
+        onCheckedChange={(checked) => {
+          updateCertificate({ isDownloadable: checked });
+        }}
+        disabled={$isFreePlan}
+      />
+      <Field.Label for="certificate-downloadable" class="text-gray-600">
+        {$t('course.navItem.certificates.allow')}
+      </Field.Label>
+    </Field.Field>
+
+    <Field.Group>
+      <Field.Field>
+        <Field.Label for="cert-deadline">{$t('course.certification.deadline_label')}</Field.Label>
+        <Input
+          id="cert-deadline"
+          type="datetime-local"
+          class="w-full"
+          value={isoToDatetimeLocal(courseApi.course?.certificate?.deadline ?? null)}
+          onchange={onCertDeadlineChange}
+          disabled={$isFreePlan}
+        />
+        <Field.Description>{$t('course.certification.deadline_helper')}</Field.Description>
+        {#if errors['certificate.deadline']}
+          <Field.Error>{errors['certificate.deadline']}</Field.Error>
+        {/if}
+      </Field.Field>
+
+      <Field.Field>
+        <Field.Label for="cert-threshold">{$t('course.certification.threshold_label')}</Field.Label>
+        <Input
+          id="cert-threshold"
+          type="number"
+          min={0}
+          max={100}
+          class="w-full"
+          value={String(courseApi.course?.certificate?.threshold ?? 100)}
+          oninput={onThresholdInput}
+          disabled={$isFreePlan}
+        />
+        <Field.Description>{$t('course.certification.threshold_helper')}</Field.Description>
+        {#if errors['certificate.threshold']}
+          <Field.Error>{errors['certificate.threshold']}</Field.Error>
+        {/if}
+      </Field.Field>
+
+      <Field.Field>
+        <Field.Label for="cert-final-exercise">{$t('course.certification.final_exercise_label')}</Field.Label>
+        <select
+          id="cert-final-exercise"
+          class="ui:border-input ui:bg-background ui:text-foreground ui:ring-offset-background ui:shadow-xs ui:flex ui:h-9 ui:w-full ui:min-w-0 ui:rounded-md ui:border ui:px-3 ui:py-1 ui:text-base ui:outline-none ui:transition-[color,box-shadow] ui:disabled:cursor-not-allowed ui:disabled:opacity-50 ui:md:text-sm ui:focus-visible:border-ring ui:focus-visible:ring-ring/50 ui:focus-visible:ring-[3px]"
+          value={finalExerciseSelectValue}
+          onchange={onFinalExerciseChange}
+          disabled={$isFreePlan}
+        >
+          <option value="none">{$t('course.certification.final_exercise_none')}</option>
+          {#each certExercises as item (item.id)}
+            <option value={item.id}>{item.title}</option>
+          {/each}
+        </select>
+        <Field.Description>{$t('course.certification.final_exercise_helper')}</Field.Description>
+      </Field.Field>
+
+      {#if courseApi.course?.certificate?.requiredExerciseId}
+        <Field.Field>
+          <Field.Label for="cert-min-exercise-score">{$t('course.certification.min_exercise_score_label')}</Field.Label>
+          <Input
+            id="cert-min-exercise-score"
+            type="number"
+            min={0}
+            max={100}
+            class="w-full"
+            value={String(courseApi.course?.certificate?.exerciseMinScorePercent ?? 100)}
+            oninput={onMinExerciseScoreInput}
+            disabled={$isFreePlan}
+          />
+          <Field.Description>{$t('course.certification.min_exercise_score_helper')}</Field.Description>
+          {#if errors['certificate.exerciseMinScorePercent']}
+            <Field.Error>{errors['certificate.exerciseMinScorePercent']}</Field.Error>
+          {/if}
+        </Field.Field>
+      {/if}
+    </Field.Group>
+  </Field.Set>
+
+  <Field.Separator />
+
+  <Field.Set>
+    <Field.Legend>{$t('course.certification.email_message_label')}</Field.Legend>
+    <Field.Field>
+      <Textarea
+        id="cert-email-message"
+        class="w-full"
+        rows={4}
+        placeholder={$t('course.certification.email_message_placeholder')}
+        value={courseApi.course?.certificate?.emailMessage ?? ''}
+        oninput={onEmailMessageInput}
+        disabled={$isFreePlan}
+      />
+      {#if errors['certificate.emailMessage']}
+        <Field.Error>{errors['certificate.emailMessage']}</Field.Error>
+      {/if}
+    </Field.Field>
+  </Field.Set>
+</Field.Group>
diff --git a/apps/dashboard/src/lib/features/course/components/ceritficate/course-completion-modal.svelte b/apps/dashboard/src/lib/features/course/components/ceritficate/course-completion-modal.svelte
new file mode 100644
index 00000000..14f4e7bd
--- /dev/null
+++ b/apps/dashboard/src/lib/features/course/components/ceritficate/course-completion-modal.svelte
@@ -0,0 +1,57 @@
+<script lang="ts">
+  import { onMount } from 'svelte';
+  import { goto } from '$app/navigation';
+  import { resolve } from '$app/paths';
+  import * as Dialog from '@cio/ui/base/dialog';
+  import { Button } from '@cio/ui/base/button';
+  import { Confetti } from '$features/ui';
+  import { setConfetti } from '$features/ui/confetti/store';
+  import { courseCompletionModal, closeCourseCompletionModal } from '$features/course/store/course-completion-modal';
+  import { t } from '$lib/utils/functions/translations';
+
+  let open = $state(false);
+  let activeCourseId = $state('');
+
+  onMount(() => {
+    return courseCompletionModal.subscribe((v) => {
+      if (v?.open && v.courseId) {
+        activeCourseId = v.courseId;
+        open = true;
+        setConfetti(true);
+        setTimeout(() => setConfetti(false), 5500);
+      } else {
+        open = false;
+      }
+    });
+  });
+
+  function onOpenChange(next: boolean) {
+    open = next;
+    if (!next) {
+      closeCourseCompletionModal();
+    }
+  }
+
+  function goToCertificate() {
+    if (!activeCourseId) return;
+    onOpenChange(false);
+    goto(resolve(`/courses/${activeCourseId}/certificates`, {}));
+  }
+</script>
+
+<div class="pointer-events-none fixed inset-0 z-100">
+  <Confetti />
+</div>
+
+<Dialog.Root {open} {onOpenChange}>
+  <Dialog.Content class="ui:max-w-md">
+    <Dialog.Header>
+      <Dialog.Title>{$t('course.completion.modal.title')}</Dialog.Title>
+      <Dialog.Description>{$t('course.completion.modal.subtitle')}</Dialog.Description>
+    </Dialog.Header>
+    <Dialog.Footer class="ui:gap-2">
+      <Button variant="outline" onclick={() => onOpenChange(false)}>{$t('course.completion.modal.later')}</Button>
+      <Button onclick={goToCertificate}>{$t('course.completion.modal.view_certificate')}</Button>
+    </Dialog.Footer>
+  </Dialog.Content>
+</Dialog.Root>
diff --git a/apps/dashboard/src/lib/features/course/components/ceritficate/design.svelte b/apps/dashboard/src/lib/features/course/components/ceritficate/design.svelte
deleted file mode 100644
index 91ee15b3..00000000
--- a/apps/dashboard/src/lib/features/course/components/ceritficate/design.svelte
+++ /dev/null
@@ -1,196 +0,0 @@
-<script lang="ts">
-  import { goto } from '$app/navigation';
-  import { Label } from '@cio/ui/base/label';
-  import { Switch } from '@cio/ui/base/switch';
-  import ZapIcon from '@lucide/svelte/icons/zap';
-  import * as RadioGroup from '@cio/ui/base/radio-group';
-
-  import { courseApi } from '$features/course/api';
-  import { t } from '$lib/utils/functions/translations';
-  import { snackbar } from '$features/ui/snackbar/store';
-  import { currentOrg, isFreePlan } from '$lib/utils/store/org';
-  import { saveCertificateValidation } from '$lib/utils/functions/validator';
-  import { Button } from '@cio/ui/base/button';
-
-  import Plain from './templates/plain.svelte';
-  import Professional from './templates/professional.svelte';
-  import { TextareaField } from '@cio/ui/custom/textarea-field';
-  import { UpgradeBanner } from '$features/ui';
-  import BlueBadgePattern from './templates/blue-badge-pattern.svelte';
-  import PurpleBadgePattern from './templates/purple-badge-pattern.svelte';
-  import BlueProfessionalBadge from './templates/blue-professional-badge.svelte';
-  import PurpleProfessionalBadge from './templates/purple-professional-badge.svelte';
-
-  const studentNamePlaceholder = 'Name of student';
-  const themes = [
-    'professional',
-    'plain',
-    'purpleProfessionalBadge',
-    'blueProfessionalBadge',
-    'purpleBadgePattern',
-    'blueBadgePattern'
-  ];
-
-  let errors = $state({
-    description: ''
-  });
-
-  const helperText = $derived(
-    `${courseApi.course?.description?.length || 0}/200 ${$t('course.navItem.certificates.characters')}`
-  );
-
-  let certificateTheme = $derived<string | undefined>(courseApi.course?.certificateTheme ?? undefined);
-
-  const saveCertificate = async () => {
-    if (!courseApi.course) return;
-
-    // Prevent free plan users from bypassing UI restrictions
-    if ($isFreePlan) {
-      errors.description = 'Certificate customization is only available on paid plans';
-      return;
-    }
-
-    try {
-      const result = saveCertificateValidation({
-        description: courseApi.course?.description || '',
-        isCertificateDownloadable: courseApi.course?.isCertificateDownloadable || false,
-        certificateTheme: certificateTheme || ''
-      });
-
-      if (result && Object.keys(result).length > 0) {
-        errors.description = $t(result.description) || $t('course.navItem.certificates.description_error');
-        throw new Error(errors.description);
-      }
-
-      errors.description = '';
-
-      await courseApi.update(courseApi.course.id!, {
-        description: courseApi.course?.description || '',
-        isCertificateDownloadable: courseApi.course?.isCertificateDownloadable || false,
-        certificateTheme: certificateTheme || ''
-      });
-
-      snackbar.success('snackbar.course_settings.success.saved');
-    } catch (error) {
-      if (error instanceof Error) {
-        errors.description = error.message;
-      } else {
-        errors.description = $t('course.navItem.certificates.unexpected_error');
-      }
-    }
-  };
-</script>
-
-<svelte:head>
-  <link rel="preconnect" href="https://fonts.googleapis.com" />
-  <link rel="preconnect" href="https://fonts.gstatic.com" crossorigin="anonymous" />
-  <link
-    href="https://fonts.googleapis.com/css2?family=Qwitcher+Grypen&family=Roboto:wght@300;400;700&display=swap"
-    rel="stylesheet"
-  />
-</svelte:head>
-
-<UpgradeBanner>{$t('upgrade.certificate')}</UpgradeBanner>
-
-<main class="mt-2 px-2 md:-mr-3 md:-ml-3">
-  <div class="mb-3 flex h-4/5 w-full flex-1 flex-col justify-between gap-3 lg:flex-row">
-    <section class="h-full w-full lg:w-2/5">
-      <strong class="my-2 text-base font-semibold text-black dark:text-gray-100"
-        >{$t('course.navItem.certificates.certificate_settings')}</strong
-      >
-      <p class="my-4 text-xs font-normal dark:text-gray-100">
-        {$t('course.navItem.certificates.theme')}
-      </p>
-
-      <RadioGroup.Root bind:value={certificateTheme} disabled={$isFreePlan} class="mb-10">
-        <div class="flex flex-wrap justify-between gap-y-5">
-          {#each themes as theme}
-            <div class="mr-3 flex items-start space-x-2">
-              <RadioGroup.Item value={theme} id={theme} />
-              <Label for={theme} class="cursor-pointer">
-                <img src={`/images/certificate_theme_${theme}.png`} alt="themes" class="h-[82px] w-[110px]" />
-              </Label>
-            </div>
-          {/each}
-        </div>
-      </RadioGroup.Root>
-
-      <div>
-        <p class="my-2 text-xs font-normal text-black dark:text-gray-100">
-          {$t('course.navItem.certificates.logo')}
-        </p>
-        <div>
-          <p class="mt-1 text-base dark:text-gray-100">
-            {$t('course.navItem.certificates.to_update')}
-            <strong class="font-semibold">{$t('course.navItem.certificates.settings')}</strong>
-            {$t('course.navItem.certificates.and_upload')}
-          </p>
-
-          <Button variant="outline" class="mt-3" onclick={() => goto(`/org/${$currentOrg.siteName}/settings`)}>
-            {$t('course.navItem.certificates.goto_settings')}
-          </Button>
-        </div>
-        <span class="my-4">
-          <p class="mt-4 mb-2 text-xs font-normal dark:text-gray-100">
-            {$t('course.navItem.certificates.description')}
-          </p>
-          <TextareaField
-            rows={6}
-            placeholder={$t('course.navItem.certificates.placeholder')}
-            value={courseApi.course?.description}
-            onchange={(e) => (courseApi.course!.description = e.currentTarget.value)}
-            errorMessage={errors.description}
-            disabled={$isFreePlan}
-            helperMessage={helperText}
-          />
-        </span>
-        <div class="my-4 flex items-center space-x-2">
-          <Switch
-            id="certificate-downloadable"
-            checked={!!courseApi.course?.isCertificateDownloadable}
-            onCheckedChange={(checked) => (courseApi.course!.isCertificateDownloadable = checked)}
-            disabled={$isFreePlan}
-          />
-          <Label for="certificate-downloadable" class="text-sm font-medium dark:text-gray-100">
-            {$t('course.navItem.certificates.allow')}
-          </Label>
-        </div>
-      </div>
-    </section>
-    <section class="flex w-full items-center justify-center rounded-md bg-gray-100 lg:w-3/5 dark:bg-neutral-800">
-      <div class="certificate-container flex items-center justify-center">
-        {#if certificateTheme === 'professional'}
-          <Professional studentName={studentNamePlaceholder} />
-        {:else if certificateTheme === 'plain'}
-          <Plain studentName={studentNamePlaceholder} />
-        {:else if certificateTheme === 'purpleProfessionalBadge'}
-          <PurpleProfessionalBadge studentName={studentNamePlaceholder} />
-        {:else if certificateTheme === 'blueProfessionalBadge'}
-          <BlueProfessionalBadge studentName={studentNamePlaceholder} />
-        {:else if certificateTheme === 'purpleBadgePattern'}
-          <PurpleBadgePattern studentName={studentNamePlaceholder} />
-        {:else if certificateTheme === 'blueBadgePattern'}
-          <BlueBadgePattern studentName={studentNamePlaceholder} />
-        {/if}
-      </div>
-    </section>
-  </div>
-  <div class="h-1/5">
-    <Button variant="secondary" onclick={saveCertificate} loading={courseApi.isLoading} disabled={$isFreePlan}>
-      {#if $isFreePlan}
-        <ZapIcon size={16} class="filled" />
-      {/if}
-      {$t('course.navItem.certificates.save')}
-    </Button>
-  </div>
-</main>
-
-<style>
-  p {
-    color: #262626;
-  }
-  .certificate-container {
-    width: 95%;
-    max-width: 95%;
-  }
-</style>
diff --git a/apps/dashboard/src/lib/features/course/components/ceritficate/student-certificate/index.svelte b/apps/dashboard/src/lib/features/course/components/ceritficate/student-certificate/index.svelte
index f9736ed5..a96967bc 100644
--- a/apps/dashboard/src/lib/features/course/components/ceritficate/student-certificate/index.svelte
+++ b/apps/dashboard/src/lib/features/course/components/ceritficate/student-certificate/index.svelte
@@ -5,7 +5,7 @@
 </script>
 
 <div>
-  {#if courseApi.course?.isCertificateDownloadable === true}
+  {#if courseApi.course?.certificate?.isDownloadable === true}
     <UnlockedCertificate />
   {:else}
     <LockedCertificate />
diff --git a/apps/dashboard/src/lib/features/course/components/ceritficate/student-certificate/unlocked-certificate.svelte b/apps/dashboard/src/lib/features/course/components/ceritficate/student-certificate/unlocked-certificate.svelte
index e985f216..a143b990 100644
--- a/apps/dashboard/src/lib/features/course/components/ceritficate/student-certificate/unlocked-certificate.svelte
+++ b/apps/dashboard/src/lib/features/course/components/ceritficate/student-certificate/unlocked-certificate.svelte
@@ -5,17 +5,55 @@
   import { currentOrg, currentOrgDomain } from '$lib/utils/store/org';
   import { profile } from '$lib/utils/store/user';
   import { Button } from '@cio/ui/base/button';
-  import Empty from '@cio/ui/custom/empty/empty.svelte';
+  import { Empty } from '@cio/ui/custom/empty';
   import { t } from '$lib/utils/functions/translations';
   import { courseApi } from '$features/course/api';
   import { snackbar } from '$features/ui/snackbar/store';
   import { classroomio } from '$lib/utils/services/api';
+  import type { CertificationEvaluationData } from '$features/course/utils/types';
+  import { openCourseCompletionModal } from '$features/course/store/course-completion-modal';
 
   let isLoading = $state(false);
   let isCourseComplete = $state(false);
+  let evaluation = $state<CertificationEvaluationData | null>(null);
 
   let courseId = $derived(courseApi.course?.id ?? '');
 
+  function formatBlockerMessage(blocker: CertificationEvaluationData['blockers'][number]): string {
+    const p = blocker.params ?? {};
+    switch (blocker.code) {
+      case 'CERT_PROGRESS':
+        return t.get('course.certification.blocker_progress', {
+          current: Number(p.current ?? 0),
+          required: Number(p.required ?? 0)
+        });
+      case 'CERT_DEADLINE_PASSED':
+        return t.get('course.certification.blocker_deadline');
+      case 'CERT_NO_CONTENT':
+        return t.get('course.certification.blocker_no_content');
+      case 'CERT_FINAL_EXERCISE_NOT_SUBMITTED':
+        return t.get('course.certification.blocker_final_not_submitted', {
+          exerciseTitle: String(p.exerciseTitle ?? '')
+        });
+      case 'CERT_FINAL_EXERCISE_PENDING_GRADE':
+        return t.get('course.certification.blocker_final_pending', {
+          exerciseTitle: String(p.exerciseTitle ?? '')
+        });
+      case 'CERT_FINAL_EXERCISE_SCORE':
+        return t.get('course.certification.blocker_final_score', {
+          exerciseTitle: String(p.exerciseTitle ?? ''),
+          bestPercent: Number(p.bestPercent ?? 0),
+          requiredPercent: Number(p.requiredPercent ?? 0)
+        });
+      case 'CERT_FINAL_EXERCISE_MISCONFIGURED':
+        return t.get('course.certification.blocker_final_misconfigured', {
+          exerciseTitle: String(p.exerciseTitle ?? '')
+        });
+      default:
+        return blocker.code;
+    }
+  }
+
   const downLoadCertificate = async () => {
     if (!isCourseComplete || !courseId) return;
 
@@ -24,7 +62,7 @@
       const response = await classroomio.course[':courseId']['download']['certificate']['$post']({
         param: { courseId },
         json: {
-          theme: `${courseApi.course?.certificateTheme}`,
+          theme: `${courseApi.course?.certificate?.theme ?? 'professional'}`,
           studentName: `${$profile.fullname}`,
           courseName: `${courseApi.course?.title}`,
           courseDescription: `${courseApi.course?.description}`,
@@ -52,22 +90,24 @@
     isLoading = false;
   };
 
-  const hasUserCompletedCourse = async () => {
+  const loadEvaluation = async () => {
+    if (!courseId) return;
     isLoading = true;
+    const res = await courseApi.getCertificationEvaluation(courseId);
+    if (res?.data) {
+      evaluation = res.data;
+      const hasEarned = res.data.certificateEarnedAt != null;
+      isCourseComplete = hasEarned || !!res.data.eligibleForCertificate;
 
-    const response = await courseApi.getProgress(courseId, $profile.id);
-
-    if (courseApi.success && response?.data) {
-      const progress = response.data;
-      isCourseComplete =
-        progress.lessonsCount === progress.lessonsCompleted && progress.exercisesCount === progress.exercisesCompleted;
+      if (res.data.isNewCompletion && courseId) {
+        openCourseCompletionModal(courseId);
+      }
     }
-
     isLoading = false;
   };
 
   onMount(() => {
-    hasUserCompletedCourse();
+    loadEvaluation();
   });
 
   let title = $derived(
@@ -75,15 +115,40 @@
       ? 'course.navItem.certificates.unlocked_certificate'
       : 'course.navItem.certificates.complete_to_download_title'
   );
-  let subtitle = $derived(
-    isCourseComplete
-      ? 'course.navItem.certificates.unlocked_certificate_subtitle'
-      : 'course.navItem.certificates.complete_to_download_subtitle'
-  );
+
+  let progressLines = $derived.by(() => {
+    if (!evaluation) {
+      return [
+        t.get('course.certificates.progress_hint', {
+          current: 0,
+          required: courseApi.course?.certificate?.threshold ?? 100
+        })
+      ];
+    }
+    const blockers = evaluation.blockers ?? [];
+    if (blockers.length > 0) {
+      return blockers.map((b) => formatBlockerMessage(b));
+    }
+    return [
+      t.get('course.certificates.progress_hint', {
+        current: evaluation.progressPercent,
+        required: evaluation.certificationThreshold
+      })
+    ];
+  });
 </script>
 
 <div class="flex-1">
-  <Empty title={$t(title)} description={$t(subtitle)} icon={DownloadIcon} variant="page">
+  <Empty title={$t(title)} icon={DownloadIcon} variant="page">
+    <div class="ui:text-muted-foreground mx-auto mb-4 max-w-md space-y-2 text-center text-sm">
+      {#if isCourseComplete}
+        <p>{$t('course.navItem.certificates.unlocked_certificate_subtitle')}</p>
+      {:else}
+        {#each progressLines as line (line)}
+          <p>{line}</p>
+        {/each}
+      {/if}
+    </div>
     <Button onclick={downLoadCertificate} disabled={!isCourseComplete} loading={isLoading}>
       <DownloadIcon size={16} />
       {$t('course.navItem.certificates.download_certificate')}
diff --git a/apps/dashboard/src/lib/features/course/components/content/content-create-modal.svelte b/apps/dashboard/src/lib/features/course/components/content/content-create-modal.svelte
index 1513bd66..978648d1 100644
--- a/apps/dashboard/src/lib/features/course/components/content/content-create-modal.svelte
+++ b/apps/dashboard/src/lib/features/course/components/content/content-create-modal.svelte
@@ -155,7 +155,7 @@
 </script>
 
 <Dialog.Root bind:open={$contentCreateStore.open} onOpenChange={(isOpen) => !isOpen && closeModal()}>
-  <Dialog.Content class="flex max-h-[680px] w-fit! max-w-2xl! min-w-[400px] flex-col overflow-hidden">
+  <Dialog.Content class="flex max-h-[680px] w-full! max-w-xl! min-w-[400px] flex-col overflow-hidden">
     <Dialog.Header>
       <Dialog.Title>{$t('course.navItem.lessons.add_content')}</Dialog.Title>
     </Dialog.Header>
diff --git a/apps/dashboard/src/lib/features/course/components/content/exercise-create-stepper.svelte b/apps/dashboard/src/lib/features/course/components/content/exercise-create-stepper.svelte
index aa8f7fe7..45823bb6 100644
--- a/apps/dashboard/src/lib/features/course/components/content/exercise-create-stepper.svelte
+++ b/apps/dashboard/src/lib/features/course/components/content/exercise-create-stepper.svelte
@@ -252,7 +252,7 @@
         bind:value={title}
         autoFocus={true}
         placeholder={$t('course.navItem.lessons.exercises.new_exercise_modal.title_placeholder')}
-        className="my-4 w-2/4!"
+        className="my-4 w-full"
       />
     </div>
   {:else if type === EXERCISE_CREATE_TYPE.TEMPLATE}
diff --git a/apps/dashboard/src/lib/features/course/components/exercise/edit-mode.svelte b/apps/dashboard/src/lib/features/course/components/exercise/edit-mode.svelte
index 617bbbd1..b492a23f 100644
--- a/apps/dashboard/src/lib/features/course/components/exercise/edit-mode.svelte
+++ b/apps/dashboard/src/lib/features/course/components/exercise/edit-mode.svelte
@@ -15,6 +15,7 @@
   import { ContentType } from '@cio/utils/constants/content';
   import { PREMIUM_QUESTION_TYPE_KEYS, QUESTION_TYPES } from '$features/ui/question/constants';
   import { Button } from '@cio/ui/base/button';
+  import { Badge } from '@cio/ui/base/badge';
   import { ExerciseQuestion } from '@cio/ui';
 
   import OrderModal from './order-modal.svelte';
@@ -40,11 +41,20 @@
 
   interface Props {
     shouldDeleteExercise?: boolean;
-    exerciseId: any;
-    goBack?: any;
+    exerciseId: string;
+    goBack?: () => void;
+    /** Self-paced + all auto-gradable question types: enforce points &gt; 0 */
+    requiresPositivePointsForAutoGrade?: boolean;
+    selfPacedCourse?: boolean;
   }
 
-  let { shouldDeleteExercise = $bindable(false), exerciseId, goBack = () => {} }: Props = $props();
+  let {
+    shouldDeleteExercise = $bindable(false),
+    exerciseId,
+    goBack = () => {},
+    requiresPositivePointsForAutoGrade = false,
+    selfPacedCourse = false
+  }: Props = $props();
 
   let questionIdToDelete = $state(null);
   let isDeleting = $state(false);
@@ -173,9 +183,10 @@
   }
 
   async function handleDelete() {
+    if (!courseApi.course?.id) return;
     isDeleting = true;
 
-    await exerciseApi.delete(courseApi.course?.id!, exerciseId);
+    await exerciseApi.delete(courseApi.course.id, exerciseId);
 
     if (exerciseApi.success) {
       courseApi.removeContentItem(exerciseId, ContentType.Exercise);
@@ -234,6 +245,9 @@
           bind:points={question.points}
           hasError={!!errors[question.id]}
           errorMsg={getQuestionErrorMsg(errors, question, 'points')}
+          pointsHint={requiresPositivePointsForAutoGrade && Number(question.points) === 0
+            ? $t('course.navItem.lessons.exercises.all_exercises.points_required_auto_grade')
+            : null}
           onPointsChange={() => {
             question.isDirty = true;
           }}
@@ -272,7 +286,7 @@
                     {getQuestionTypeLabel(question?.questionType)}
                   </Select.Trigger>
                   <Select.Content>
-                    {#each QUESTION_TYPES as type, i (type.key)}
+                    {#each QUESTION_TYPES as type (type.key)}
                       {#if $isFreePlan && PREMIUM_QUESTION_TYPE_KEYS.has(type.key)}
                         <button
                           type="button"
@@ -288,7 +302,27 @@
                           <span>{getQuestionTypeLabel(type)}</span>
                         </button>
                       {:else}
-                        <Select.Item value={type.id.toString()} label={getQuestionTypeLabel(type)} />
+                        <Select.Item value={type.id.toString()} label={getQuestionTypeLabel(type)}>
+                          {#snippet children({ selected: _sel })}
+                            <span class="flex w-full min-w-0 items-center justify-between gap-2">
+                              <span class="truncate">{getQuestionTypeLabel(type)}</span>
+                              {#if selfPacedCourse}
+                                <Badge
+                                  variant={type.autoGradable ? 'success' : 'warning'}
+                                  class="ui:shrink-0 ui:text-[10px] ui:font-normal"
+                                >
+                                  {type.autoGradable
+                                    ? $t(
+                                        'course.navItem.lessons.exercises.all_exercises.edit_mode.question_type_auto_gradable'
+                                      )
+                                    : $t(
+                                        'course.navItem.lessons.exercises.all_exercises.edit_mode.question_type_manual_grading'
+                                      )}
+                                </Badge>
+                              {/if}
+                            </span>
+                          {/snippet}
+                        </Select.Item>
                       {/if}
                     {/each}
                   </Select.Content>
diff --git a/apps/dashboard/src/lib/features/course/components/exercise/exercise-settings-tab.svelte b/apps/dashboard/src/lib/features/course/components/exercise/exercise-settings-tab.svelte
new file mode 100644
index 00000000..f7e08e13
--- /dev/null
+++ b/apps/dashboard/src/lib/features/course/components/exercise/exercise-settings-tab.svelte
@@ -0,0 +1,56 @@
+<script lang="ts">
+  import { Switch } from '@cio/ui/base/switch';
+  import { Label } from '@cio/ui/base/label';
+  import { Button } from '@cio/ui/base/button';
+  import { questionnaire } from './store';
+  import { exerciseApi } from '$features/course/api';
+  import { courseApi } from '$features/course/api';
+  import { t } from '$lib/utils/functions/translations';
+  import { snackbar } from '$features/ui/snackbar/store';
+
+  type Props = {
+    exerciseId: string;
+  };
+
+  let { exerciseId }: Props = $props();
+
+  let saving = $state(false);
+
+  async function saveSettings() {
+    if (!courseApi.course?.id) return;
+    saving = true;
+
+    await exerciseApi.update(courseApi.course.id, exerciseId, {
+      allowMultipleAttempts: !!$questionnaire.allowMultipleAttempts
+    });
+    saving = false;
+
+    if (exerciseApi.success) {
+      snackbar.success('snackbar.exercise.success');
+    }
+  }
+</script>
+
+<div class="max-w-xl space-y-6">
+  <div class="flex items-center justify-between gap-4 rounded-lg border border-neutral-200 p-4 dark:border-neutral-700">
+    <div class="space-y-1">
+      <Label for="allow-multiple" class="text-sm font-medium dark:text-gray-100">
+        {$t('course.navItem.lessons.exercises.all_exercises.settings_allow_multiple')}
+      </Label>
+      <p class="ui:text-muted-foreground text-sm">
+        {$t('course.navItem.lessons.exercises.all_exercises.settings_allow_multiple_helper')}
+      </p>
+    </div>
+    <Switch
+      id="allow-multiple"
+      checked={!!$questionnaire.allowMultipleAttempts}
+      onCheckedChange={(checked) => {
+        questionnaire.update((q) => ({ ...q, allowMultipleAttempts: checked }));
+      }}
+    />
+  </div>
+
+  <Button onclick={saveSettings} loading={saving} disabled={!courseApi.course?.id}>
+    {$t('course.navItem.lessons.exercises.all_exercises.settings_save')}
+  </Button>
+</div>
diff --git a/apps/dashboard/src/lib/features/course/components/exercise/store.ts b/apps/dashboard/src/lib/features/course/components/exercise/store.ts
index 4c46fa6c..cc469da2 100644
--- a/apps/dashboard/src/lib/features/course/components/exercise/store.ts
+++ b/apps/dashboard/src/lib/features/course/components/exercise/store.ts
@@ -54,6 +54,7 @@ export const questionnaire: Writable<{
   isDescriptionDirty?: boolean;
   questions: Question[];
   totalSubmissions: number;
+  allowMultipleAttempts?: boolean;
 }> = writable({
   title: '',
   dueBy: '',
@@ -62,7 +63,8 @@ export const questionnaire: Writable<{
   description: '',
   isDescriptionDirty: false,
   questions: [],
-  totalSubmissions: 0
+  totalSubmissions: 0,
+  allowMultipleAttempts: false
 });
 
 export function clearQuestionnaireValidation() {
@@ -88,6 +90,15 @@ export function reset() {
   clearQuestionnaireValidation();
 }
 
+/** Clears take-exercise state so the student can start another attempt (when allowed). */
+export function resetStudentExerciseTake() {
+  questionnaireMetaData.set({
+    ...initAnswerState,
+    exerciseId: null
+  });
+  clearQuestionnaireValidation();
+}
+
 /**
  * Maps Zod validation errors to UI format: { questionId: { option: 'error message' } }
  * This is used to display errors in the edit-mode component
diff --git a/apps/dashboard/src/lib/features/course/components/exercise/view-mode.svelte b/apps/dashboard/src/lib/features/course/components/exercise/view-mode.svelte
index fa067808..9319ae19 100644
--- a/apps/dashboard/src/lib/features/course/components/exercise/view-mode.svelte
+++ b/apps/dashboard/src/lib/features/course/components/exercise/view-mode.svelte
@@ -29,9 +29,10 @@
   import { SafeHtmlContent } from '@cio/ui/custom/safe-html-content';
   import { t } from '$lib/utils/functions/translations';
   import { snackbar } from '$features/ui/snackbar/store';
+  import { ContentType } from '@cio/utils/constants/content';
+  import { getOrderedNavigableContent } from '$features/course/utils/content';
   import { globalStore } from '$lib/utils/store/app';
   import { openCourseCompletionModal } from '$features/course/store/course-completion-modal';
-  import { ContentType } from '@cio/utils/constants/content';
   import { toExerciseQuestionModel } from './question-type-utils';
   import { getExerciseQuestionLabels } from './question-labels';
   import axios from 'axios';
@@ -150,17 +151,13 @@
           }));
         }
         courseApi.updateContentItem(exerciseId, ContentType.Exercise, { isComplete: true });
-        if (
-          $globalStore.isStudent &&
-          courseApi.course?.id &&
-          submitResult?.data &&
-          'certification' in submitResult.data
-        ) {
-          const certification = (submitResult.data as { certification?: { isNewCompletion?: boolean } | null })
-            .certification;
-          if (certification?.isNewCompletion) {
-            openCourseCompletionModal(courseApi.course.id);
-          }
+
+        const allContentItems = getOrderedNavigableContent(courseApi.course);
+        const allComplete =
+          $globalStore.isStudent && allContentItems.length > 0 && allContentItems.every((item) => item.isComplete);
+
+        if (allComplete && courseApi.course?.id) {
+          openCourseCompletionModal(courseApi.course.id);
         }
       }
 
diff --git a/apps/dashboard/src/lib/features/course/components/lesson/content-navigation-actions.svelte b/apps/dashboard/src/lib/features/course/components/lesson/content-navigation-actions.svelte
index bd00e0ed..92e783bd 100644
--- a/apps/dashboard/src/lib/features/course/components/lesson/content-navigation-actions.svelte
+++ b/apps/dashboard/src/lib/features/course/components/lesson/content-navigation-actions.svelte
@@ -13,6 +13,7 @@
   import { ContentType } from '@cio/utils/constants/content';
   import { snackbar } from '$features/ui/snackbar/store';
   import type { CourseContentItem } from '$features/course/utils/types';
+  import { openCourseCompletionModal } from '$features/course/store/course-completion-modal';
 
   interface Props {
     lessonId?: string;
@@ -65,7 +66,7 @@
   const isLessonLocked = $derived(
     $globalStore.isStudent && currentLessonItem && !(currentLessonItem.isUnlocked ?? false)
   );
-  const isMarkCompleteDisabled = $derived(isMarkingComplete || isLessonLocked);
+  const isMarkCompleteDisabled = $derived(isMarkingComplete || isLessonLocked || isLessonComplete);
 
   async function markLessonComplete(currentLessonId: string) {
     isMarkingComplete = true;
@@ -78,8 +79,18 @@
     await lessonApi.updateCompletion(courseId, currentLessonId, isComplete);
 
     if (lessonApi.success) {
-      updateCourseContentCompletion(currentLessonId, isComplete);
       snackbar.success('snackbar.lessons.success.complete_marked');
+      updateCourseContentCompletion(currentLessonId, isComplete);
+
+      const allComplete =
+        $globalStore.isStudent &&
+        isComplete &&
+        navigableContentItems.length > 0 &&
+        navigableContentItems.every((item) => item.isComplete);
+
+      if (allComplete) {
+        openCourseCompletionModal(courseId);
+      }
     } else {
       snackbar.error('snackbar.lessons.error.try_later');
     }
diff --git a/apps/dashboard/src/lib/features/course/components/list.svelte b/apps/dashboard/src/lib/features/course/components/list.svelte
index 03a8a9b1..43d7d19f 100644
--- a/apps/dashboard/src/lib/features/course/components/list.svelte
+++ b/apps/dashboard/src/lib/features/course/components/list.svelte
@@ -12,12 +12,15 @@
 
   interface Props {
     id?: string;
+    slug?: string;
     title?: string;
     type?: string;
     description?: string;
     isPublished?: boolean;
     totalLessons?: number;
     totalStudents?: number;
+    isExplore?: boolean;
+    isLMS?: boolean;
     tags?: Array<{
       id: string;
       name: string;
@@ -28,15 +31,32 @@
 
   let {
     id = '',
+    slug = '',
     title = '',
     type = '',
     description = '',
     isPublished = false,
     totalLessons = 0,
     totalStudents = 0,
+    isExplore = false,
+    isLMS = false,
     tags = []
   }: Props = $props();
 
+  function handleRowClick() {
+    if (isExplore) {
+      goto(resolve(`/course/${slug}`, {}));
+      return;
+    }
+
+    if (isLMS) {
+      goto(resolve(`/courses/${id}/lessons?next=true`, {}));
+      return;
+    }
+
+    goto(resolve(`/courses/[id]`, { id }));
+  }
+
   function handleCloneCourse(e) {
     e.stopPropagation();
     // TODO: Clone course functionality
@@ -62,7 +82,7 @@
   }
 </script>
 
-<Table.Row class="cursor-pointer" onclick={() => goto(resolve(`/courses/[id]`, { id }))}>
+<Table.Row class="cursor-pointer" onclick={handleRowClick}>
   <Table.Cell class="truncate"><p class="font-semibold">{title}</p></Table.Cell>
   <Table.Cell class="truncate">
     <p>{description}</p>
@@ -77,34 +97,38 @@
       {/if}
     </Table.Cell>
     <Table.Cell>{totalLessons}</Table.Cell>
-    <Table.Cell>{totalStudents}</Table.Cell>
-    <Table.Cell>
-      <CoursePublishBadge {isPublished} />
+    {#if !isLMS}
+      <Table.Cell>{totalStudents}</Table.Cell>
+      <Table.Cell>
+        <CoursePublishBadge {isPublished} />
+      </Table.Cell>
+    {/if}
+  {/if}
+  {#if !isLMS}
+    <Table.Cell class="text-center">
+      <DropdownMenu.Root>
+        <DropdownMenu.Trigger
+          class="flex items-center justify-center rounded-md p-1 hover:bg-gray-100"
+          onclick={(e) => e.stopPropagation()}
+        >
+          <EllipsisVerticalIcon size={16} />
+        </DropdownMenu.Trigger>
+        <DropdownMenu.Content align="end">
+          <DropdownMenu.Item onclick={handleCloneCourse}>
+            {$t('courses.course_card.context_menu.clone')}
+          </DropdownMenu.Item>
+          <DropdownMenu.Item onclick={handleShareCourse}>
+            {$t('courses.course_card.context_menu.share')}
+          </DropdownMenu.Item>
+          <DropdownMenu.Item onclick={handleInvite}>
+            {$t('courses.course_card.context_menu.invite')}
+          </DropdownMenu.Item>
+          <DropdownMenu.Separator />
+          <DropdownMenu.Item class="text-red-600" onclick={handleDeleteCourse}>
+            {$t('courses.course_card.context_menu.delete')}
+          </DropdownMenu.Item>
+        </DropdownMenu.Content>
+      </DropdownMenu.Root>
     </Table.Cell>
   {/if}
-  <Table.Cell class="text-center">
-    <DropdownMenu.Root>
-      <DropdownMenu.Trigger
-        class="flex items-center justify-center rounded-md p-1 hover:bg-gray-100"
-        onclick={(e) => e.stopPropagation()}
-      >
-        <EllipsisVerticalIcon size={16} />
-      </DropdownMenu.Trigger>
-      <DropdownMenu.Content align="end">
-        <DropdownMenu.Item onclick={handleCloneCourse}>
-          {$t('courses.course_card.context_menu.clone')}
-        </DropdownMenu.Item>
-        <DropdownMenu.Item onclick={handleShareCourse}>
-          {$t('courses.course_card.context_menu.share')}
-        </DropdownMenu.Item>
-        <DropdownMenu.Item onclick={handleInvite}>
-          {$t('courses.course_card.context_menu.invite')}
-        </DropdownMenu.Item>
-        <DropdownMenu.Separator />
-        <DropdownMenu.Item class="text-red-600" onclick={handleDeleteCourse}>
-          {$t('courses.course_card.context_menu.delete')}
-        </DropdownMenu.Item>
-      </DropdownMenu.Content>
-    </DropdownMenu.Root>
-  </Table.Cell>
 </Table.Row>
diff --git a/apps/dashboard/src/lib/features/course/components/people/existing-students-section.svelte b/apps/dashboard/src/lib/features/course/components/people/existing-students-section.svelte
index 58b109ba..83037fe0 100644
--- a/apps/dashboard/src/lib/features/course/components/people/existing-students-section.svelte
+++ b/apps/dashboard/src/lib/features/course/components/people/existing-students-section.svelte
@@ -1,11 +1,14 @@
 <script lang="ts">
+  import { onDestroy } from 'svelte';
   import { SvelteSet } from 'svelte/reactivity';
   import { Button } from '@cio/ui/base/button';
   import { CheckboxField } from '@cio/ui/custom/checkbox-field';
-  import { Search } from '@cio/ui/custom/search';
+  import { MultiSelectList } from '@cio/ui/custom/multi-select-list';
   import { t } from '$lib/utils/functions/translations';
   import { snackbar } from '$features/ui/snackbar/store';
   import { orgApi } from '$features/org/api/org.svelte';
+  import { currentOrg } from '$lib/utils/store/org';
+  import { DEFAULT_ORG_AUDIENCE_QUERY } from '$features/org/utils/audience-query-utils';
   import { courseApi } from '$features/course/api';
   import { profile } from '$lib/utils/store/user';
   import type { OrgStudent } from './types';
@@ -20,29 +23,39 @@
   let { courseId, students, isLoading = false, onAssigned }: Props = $props();
 
   let searchValue = $state('');
+  let isSearching = $state(false);
+  let lastSearchValue = $state('');
+  let searchTimeout: ReturnType<typeof setTimeout> | null = null;
+  let activeSearchRequestId = $state(0);
   const selectedProfileIds = new SvelteSet<string>();
   let sendEmail = $state(true);
   let isSubmitting = $state(false);
+  const SEARCH_DEBOUNCE_MS = 350;
 
-  const filteredStudents = $derived.by(() => {
-    const query = searchValue.trim().toLowerCase();
-    const sortedStudents = [...students].sort((a, b) =>
+  const sortedStudents = $derived.by(() =>
+    [...students].sort((a, b) =>
       (a.name || a.email || '').localeCompare(b.name || b.email || '', undefined, { sensitivity: 'base' })
-    );
-
-    if (!query) {
-      return sortedStudents;
-    }
-
-    return sortedStudents.filter((student) => {
-      const name = student.name?.toLowerCase() || '';
-      const email = student.email?.toLowerCase() || '';
-      return name.includes(query) || email.includes(query);
-    });
-  });
+    )
+  );
+  const showLoadingState = $derived(isLoading || isSearching);
+  const emptyMessage = $derived(
+    searchValue.trim()
+      ? $t('course.navItem.people.invite_modal.no_matching_existing_students')
+      : $t('course.navItem.people.invite_modal.no_existing_students')
+  );
 
   const selectedCount = $derived(selectedProfileIds.size);
 
+  const multiSelectItems = $derived(
+    sortedStudents
+      .filter((s): s is OrgStudent & { profileId: string } => Boolean(s.profileId))
+      .map((s) => ({
+        id: s.profileId,
+        label: s.name || s.email,
+        description: s.email
+      }))
+  );
+
   function toggleStudent(profileId: string) {
     if (selectedProfileIds.has(profileId)) {
       selectedProfileIds.delete(profileId);
@@ -51,8 +64,70 @@
     }
   }
 
+  async function searchStudents(value: string) {
+    const normalizedValue = value.trim();
+    if (normalizedValue === lastSearchValue) {
+      return;
+    }
+
+    lastSearchValue = normalizedValue;
+    const orgId = $currentOrg.id;
+    if (!orgId) {
+      return;
+    }
+
+    const requestId = activeSearchRequestId + 1;
+    activeSearchRequestId = requestId;
+    isSearching = true;
+
+    try {
+      await orgApi.getOrgAudience(
+        orgId,
+        {
+          ...DEFAULT_ORG_AUDIENCE_QUERY,
+          search: normalizedValue || undefined
+        },
+        {
+          abortPrevious: true
+        }
+      );
+    } finally {
+      if (requestId === activeSearchRequestId) {
+        isSearching = false;
+      }
+    }
+  }
+
+  function handleSearchValueChange(value: string) {
+    searchValue = value;
+
+    if (searchTimeout) {
+      clearTimeout(searchTimeout);
+    }
+
+    if (!value.trim()) {
+      void searchStudents(value);
+      return;
+    }
+
+    searchTimeout = setTimeout(() => {
+      void searchStudents(value);
+    }, SEARCH_DEBOUNCE_MS);
+  }
+
+  onDestroy(() => {
+    orgApi.cancelAudienceRequest();
+
+    if (!searchTimeout) {
+      return;
+    }
+
+    clearTimeout(searchTimeout);
+  });
+
   async function assignStudents() {
     if (!courseId) return;
+
     if (selectedProfileIds.size === 0) {
       snackbar.error('course.navItem.people.invite_modal.select_at_least_one_student');
       return;
@@ -82,56 +157,33 @@
   }
 </script>
 
-<div class="rounded-md border p-4">
-  <div class="space-y-1">
-    <p class="text-base font-semibold">{$t('course.navItem.people.invite_modal.existing_students_title')}</p>
-    <p class="ui:text-muted-foreground text-sm">
-      {$t('course.navItem.people.invite_modal.existing_students_description')}
-    </p>
-  </div>
-
-  <div class="mt-4 space-y-4">
-    <Search placeholder={$t('course.navItem.people.invite_modal.existing_students_search')} bind:value={searchValue} />
-
-    {#if selectedCount > 0}
-      <p class="ui:text-muted-foreground text-sm">{$t('audience.selected_count', { count: selectedCount })}</p>
-    {/if}
-
-    <div class="max-h-72 space-y-2 overflow-y-auto rounded-md border p-3">
-      {#if isLoading}
-        <p class="ui:text-muted-foreground text-sm">
-          {$t('course.navItem.people.invite_modal.loading_existing_students')}
-        </p>
-      {:else if students.length === 0}
-        <p class="ui:text-muted-foreground text-sm">{$t('course.navItem.people.invite_modal.no_existing_students')}</p>
-      {:else if filteredStudents.length === 0}
-        <p class="ui:text-muted-foreground text-sm">
-          {$t('course.navItem.people.invite_modal.no_matching_existing_students')}
-        </p>
-      {:else}
-        {#each filteredStudents as student (student.profileId)}
-          <div
-            class="ui:hover:bg-muted/40 rounded-md px-2 py-1"
-            role="button"
-            tabindex="0"
-            onclick={() => student.profileId && toggleStudent(student.profileId)}
-            onkeydown={(event) => {
-              if (event.key === 'Enter' || event.key === ' ') {
-                event.preventDefault();
-                if (student.profileId) toggleStudent(student.profileId);
-              }
-            }}
-          >
-            <CheckboxField
-              name={`existing-student-${student.profileId}`}
-              label={student.name || student.email}
-              checked={student.profileId ? selectedProfileIds.has(student.profileId) : false}
-            >
-              <span class="ui:text-muted-foreground text-sm">{student.email}</span>
-            </CheckboxField>
-          </div>
-        {/each}
-      {/if}
+<div class="">
+  <div class="space-y-2">
+    <div class="max-h-72 overflow-y-auto">
+      <MultiSelectList
+        class="border-0"
+        {emptyMessage}
+        items={multiSelectItems}
+        isLoading={showLoadingState}
+        isSelected={(id) => selectedProfileIds.has(id)}
+        onSearchValueChange={handleSearchValueChange}
+        onToggle={(id) => toggleStudent(id)}
+        namePrefix="existing-student"
+        listClass="max-h-60"
+        searchPlaceholder={$t('course.navItem.people.invite_modal.existing_students_search')}
+        bind:searchValue
+      >
+        {#snippet headingSnippet()}
+          <p class="ui:text-sm ui:font-medium">
+            {$t('course.navItem.people.invite_modal.existing_students_title')} ({multiSelectItems.length})
+            {#if selectedCount > 0}
+              <span class="ui:text-muted-foreground text-xs"
+                >{$t('audience.selected_count', { count: selectedCount })}</span
+              >
+            {/if}
+          </p>
+        {/snippet}
+      </MultiSelectList>
     </div>
 
     <CheckboxField
diff --git a/apps/dashboard/src/lib/features/course/components/people/invitation-modal.svelte b/apps/dashboard/src/lib/features/course/components/people/invitation-modal.svelte
index 4bad8bc2..a9a0adf2 100644
--- a/apps/dashboard/src/lib/features/course/components/people/invitation-modal.svelte
+++ b/apps/dashboard/src/lib/features/course/components/people/invitation-modal.svelte
@@ -12,6 +12,7 @@
   import { currentOrg } from '$lib/utils/store/org';
   import { peopleApi } from '$features/course/api';
   import { orgApi } from '$features/org/api/org.svelte';
+  import { DEFAULT_ORG_AUDIENCE_QUERY } from '$features/org/utils/audience-query-utils';
   import type { OrgTeamMember } from '$lib/utils/types/org';
   import type { OrgStudent, Tutor } from './types';
 
@@ -75,10 +76,11 @@
 
   function loadStudents(orgId: string | undefined) {
     if (!orgId) return;
+
     untrack(async () => {
       isLoadingStudents = true;
       try {
-        await orgApi.getOrgAudience(orgId);
+        await orgApi.getOrgAudience(orgId, DEFAULT_ORG_AUDIENCE_QUERY, { abortPrevious: true });
       } finally {
         isLoadingStudents = false;
       }
@@ -125,7 +127,7 @@
     if (!open) closeModal();
   }}
 >
-  <Dialog.Content class="max-h-[80vh] w-[96vw] max-w-6xl overflow-y-auto">
+  <Dialog.Content class="max-h-[80vh] w-[96vw] max-w-3xl! overflow-y-auto">
     <Dialog.Header>
       <Dialog.Title>{$t('course.navItem.people.invite_modal.title')}</Dialog.Title>
     </Dialog.Header>
diff --git a/apps/dashboard/src/lib/features/course/components/question-container.svelte b/apps/dashboard/src/lib/features/course/components/question-container.svelte
index 50619ab1..9e7d5a59 100644
--- a/apps/dashboard/src/lib/features/course/components/question-container.svelte
+++ b/apps/dashboard/src/lib/features/course/components/question-container.svelte
@@ -11,6 +11,8 @@
     points?: any;
     hasError?: boolean;
     errorMsg?: string | null;
+    /** Extra hint under points row (e.g. auto-grade requires non-zero points) */
+    pointsHint?: string | null;
     onPointsChange?: any;
     key?: string;
     children?: import('svelte').Snippet;
@@ -23,6 +25,7 @@
     points = $bindable(undefined),
     hasError = false,
     errorMsg = null,
+    pointsHint = null,
     onPointsChange = () => {},
     children
   }: Props = $props();
@@ -67,6 +70,8 @@
 
       {#if errorMsg}
         <p class="text-xs text-red-500">{errorMsg}</p>
+      {:else if pointsHint}
+        <p class="ui:text-muted-foreground max-w-[min(100%,12rem)] text-xs">{pointsHint}</p>
       {/if}
 
       {#if onClose && !isTitle}
diff --git a/apps/dashboard/src/lib/features/course/components/sidebar/course-content-sidebar-navigation.svelte b/apps/dashboard/src/lib/features/course/components/sidebar/course-content-sidebar-navigation.svelte
index 14b2df14..c4753c4c 100644
--- a/apps/dashboard/src/lib/features/course/components/sidebar/course-content-sidebar-navigation.svelte
+++ b/apps/dashboard/src/lib/features/course/components/sidebar/course-content-sidebar-navigation.svelte
@@ -64,15 +64,17 @@
             <span>{$t('course.navItems.nav_content')}</span>
 
             <div class="ml-auto flex items-center gap-1">
-              <Plus
-                size={20}
-                class="rounded-full p-1"
-                onclick={(event) => {
-                  event.preventDefault();
-                  event.stopPropagation();
-                  openContentModal(id);
-                }}
-              />
+              {#if !isStudent}
+                <Plus
+                  size={20}
+                  class="rounded-full p-1"
+                  onclick={(event) => {
+                    event.preventDefault();
+                    event.stopPropagation();
+                    openContentModal(id);
+                  }}
+                />
+              {/if}
             </div>
           </a>
         {/snippet}
@@ -85,8 +87,8 @@
     {id}
     {isStudent}
     className="mt-1"
-    onOpenContentModal={(sectionId) => openContentModal(id, sectionId)}
-    onEditSection={(sectionId) => openSectionEditor(id, sectionId)}
+    onOpenContentModal={isStudent ? undefined : (sectionId) => openContentModal(id, sectionId)}
+    onEditSection={isStudent ? undefined : (sectionId) => openSectionEditor(id, sectionId)}
   />
 </Sidebar.Group>
 
diff --git a/apps/dashboard/src/lib/features/course/components/sidebar/course-content-tree.svelte b/apps/dashboard/src/lib/features/course/components/sidebar/course-content-tree.svelte
index 4d2eb4d1..a91a3f87 100644
--- a/apps/dashboard/src/lib/features/course/components/sidebar/course-content-tree.svelte
+++ b/apps/dashboard/src/lib/features/course/components/sidebar/course-content-tree.svelte
@@ -26,6 +26,7 @@
   let { path, id, isStudent = false, className = '', onOpenContentModal }: Props = $props();
 
   const contentData = $derived(getCourseContent(courseApi.course));
+  const canOpenContentModal = $derived(Boolean(onOpenContentModal) && !isStudent);
 </script>
 
 <Sidebar.MenuSub class={className}>
@@ -42,7 +43,7 @@
                   <span class="flex-1 truncate">{section.title}</span>
 
                   <div class="ml-auto flex items-center gap-1">
-                    {#if onOpenContentModal}
+                    {#if canOpenContentModal}
                       <IconButton
                         variant="ghost-outline"
                         size="icon-xs"
diff --git a/apps/dashboard/src/lib/features/course/components/sidebar/course-sidebar-navigation.svelte b/apps/dashboard/src/lib/features/course/components/sidebar/course-sidebar-navigation.svelte
index 114c4bad..ae63bd73 100644
--- a/apps/dashboard/src/lib/features/course/components/sidebar/course-sidebar-navigation.svelte
+++ b/apps/dashboard/src/lib/features/course/components/sidebar/course-sidebar-navigation.svelte
@@ -285,8 +285,8 @@
               {id}
               {isStudent}
               className="mt-1 ml-2"
-              onOpenContentModal={(sectionId) => openContentModal(id, sectionId)}
-              onEditSection={(sectionId) => openSectionEditor(id, sectionId)}
+              onOpenContentModal={isStudent ? undefined : (sectionId) => openContentModal(id, sectionId)}
+              onEditSection={isStudent ? undefined : (sectionId) => openSectionEditor(id, sectionId)}
             />
           {/if}
         </Sidebar.MenuItem>
diff --git a/apps/dashboard/src/lib/features/course/pages/certificates.svelte b/apps/dashboard/src/lib/features/course/pages/certificates.svelte
index 5f904856..2173d327 100644
--- a/apps/dashboard/src/lib/features/course/pages/certificates.svelte
+++ b/apps/dashboard/src/lib/features/course/pages/certificates.svelte
@@ -1,14 +1,20 @@
 <script lang="ts">
   import IssueCertificateModal from '$features/course/components/ceritficate/issue-certificate-modal.svelte';
   import { RoleBasedSecurity } from '$features/ui';
-  import Design from '$features/course/components/ceritficate/design.svelte';
+  import CertificateEdit from '$features/course/components/ceritficate/certificate-edit.svelte';
   import StudentCertificate from '$features/course/components/ceritficate/student-certificate/index.svelte';
+
+  type Props = {
+    errors: Record<string, string>;
+  };
+
+  let { errors }: Props = $props();
 </script>
 
 <IssueCertificateModal />
 
 <RoleBasedSecurity allowedRoles={[1, 2]}>
-  <Design />
+  <CertificateEdit {errors} />
 </RoleBasedSecurity>
 <RoleBasedSecurity onlyStudent allowedRoles={[3]}>
   <StudentCertificate />
diff --git a/apps/dashboard/src/lib/features/course/pages/courses.svelte b/apps/dashboard/src/lib/features/course/pages/courses.svelte
index 32ea2221..c664f5b8 100644
--- a/apps/dashboard/src/lib/features/course/pages/courses.svelte
+++ b/apps/dashboard/src/lib/features/course/pages/courses.svelte
@@ -110,20 +110,18 @@
   {/if}
   {@render filterControls?.()}
 
-  {#if !isLMS}
-    {#if $courseMetaDeta.view === 'list'}
-      <IconButton onclick={() => setViewPreference('grid')}>
-        <GridIcon size={16} />
-      </IconButton>
-    {:else}
-      <IconButton onclick={() => setViewPreference('list')}>
-        <ListIcon size={16} />
-      </IconButton>
-    {/if}
+  {#if $courseMetaDeta.view === 'list'}
+    <IconButton onclick={() => setViewPreference('grid')}>
+      <GridIcon size={16} />
+    </IconButton>
+  {:else}
+    <IconButton onclick={() => setViewPreference('list')}>
+      <ListIcon size={16} />
+    </IconButton>
   {/if}
 </Page.BodyHeader>
 
-<div class="mx-auto w-full flex-1">
+<div class="mx-auto mt-4 w-full flex-1">
   {#if isLoading}
     <section class={`${isLoading || courses ? 'cards-container' : ''} `}>
       <CourseCardLoader />
@@ -146,15 +144,18 @@
             <Table.Head class="w-[10%]">{$t('courses.course_card.list_view.type')}</Table.Head>
             <Table.Head class="w-3/12 min-w-0">{$t('courses.course_card.list_view.tags')}</Table.Head>
             <Table.Head class="w-[8%]">{$t('courses.course_card.list_view.lessons')}</Table.Head>
-            <Table.Head class="w-[8%]">{$t('courses.course_card.list_view.students')}</Table.Head>
-            <Table.Head class="w-[10%]">{$t('courses.course_card.list_view.published')}</Table.Head>
-            <Table.Head class="w-[6%]"></Table.Head>
+            {#if !isLMS}
+              <Table.Head class="w-[8%]">{$t('courses.course_card.list_view.students')}</Table.Head>
+              <Table.Head class="w-[10%]">{$t('courses.course_card.list_view.published')}</Table.Head>
+              <Table.Head class="w-[6%]"></Table.Head>
+            {/if}
           </Table.Row>
         </Table.Header>
         <Table.Body>
           {#each courses as courseData (courseData.id)}
             <CourseList
               id={courseData.id}
+              slug={courseData.slug ?? ''}
               title={courseData.title}
               type={$t(`course.navItem.settings.${courseData.type?.toLowerCase()}`)}
               description={courseData.description}
@@ -167,6 +168,8 @@
                 slug: string;
                 color?: string | null;
               }>}
+              {isExplore}
+              {isLMS}
             />
           {/each}
         </Table.Body>
diff --git a/apps/dashboard/src/lib/features/course/pages/exercise.svelte b/apps/dashboard/src/lib/features/course/pages/exercise.svelte
index 654279a9..3e5c9575 100644
--- a/apps/dashboard/src/lib/features/course/pages/exercise.svelte
+++ b/apps/dashboard/src/lib/features/course/pages/exercise.svelte
@@ -30,6 +30,7 @@
   import { exerciseApi } from '$features/course/api';
   import { courseApi } from '$features/course/api';
   import EditMode from '$features/course/components/exercise/edit-mode.svelte';
+  import ExerciseSettingsTab from '$features/course/components/exercise/exercise-settings-tab.svelte';
   import ViewMode from '$features/course/components/exercise/view-mode.svelte';
   import Submissions from '$features/course/components/exercise/submissions/submissions.svelte';
   import { IconButton } from '@cio/ui/custom/icon-button';
@@ -41,17 +42,19 @@
   import VideoIcon from '@lucide/svelte/icons/video';
   import {
     getQuestionTypeId,
+    getQuestionTypeKeyFromId,
     getQuestionTypeOptionById
   } from '$features/course/components/exercise/question-type-utils';
   import type { SubmissionListItem } from '$features/course/utils/types';
   import { Badge } from '@cio/ui/base/badge';
+  import { isAutoGradableQuestionType } from '@cio/question-types';
 
   interface Props {
     exerciseId?: string;
     goBack?: () => void;
     isFetching?: boolean;
     submissions: SubmissionListItem[];
-    mySubmission: SubmissionListItem | null;
+    mySubmissions?: SubmissionListItem[];
   }
 
   let {
@@ -59,15 +62,18 @@
     goBack = () => {},
     isFetching = false,
     submissions,
-    mySubmission
+    mySubmissions = []
   }: Props = $props();
 
-  type ExerciseTab = 'questions' | 'submissions';
+  type ExerciseTab = 'questions' | 'settings' | 'submissions';
 
   function normalizeExerciseTab(tabParam: string | null): ExerciseTab {
     if (tabParam === 'submissions' || tabParam === 'analytics') {
       return 'submissions';
     }
+    if (tabParam === 'settings') {
+      return 'settings';
+    }
 
     return 'questions';
   }
@@ -109,6 +115,26 @@
       return;
     }
 
+    if (requiresPositivePointsForAutoGrade) {
+      const zeroPointQuestions = ($questionnaire.questions ?? []).filter((q) => !q.deletedAt && Number(q.points) === 0);
+
+      if (zeroPointQuestions.length > 0) {
+        const pointErrors: Record<string, { option?: string; title?: string; points?: string }> = {};
+
+        for (const q of zeroPointQuestions) {
+          pointErrors[q.id] = {
+            points: t.get('course.navItem.lessons.exercises.all_exercises.points_required_auto_grade')
+          };
+        }
+
+        questionnaireValidation.set(pointErrors);
+
+        snackbar.error('snackbar.exercise.points_required_auto_grade');
+
+        return;
+      }
+    }
+
     isSaving = true;
 
     reset();
@@ -204,11 +230,41 @@
     )
   );
   const isExerciseUnlocked = $derived(exerciseContentItem?.isUnlocked ?? false);
+
+  const isSelfPacedCourse = $derived(courseApi.course?.type === 'SELF_PACED');
+  const activeQuestionTypeIds = $derived(
+    ($questionnaire.questions ?? []).filter((q) => !q.deletedAt).map((q) => getQuestionTypeId(q))
+  );
+  function isExerciseFullyAutoGradable(typeIds: number[]): boolean {
+    return typeIds.length > 0 && typeIds.every((id) => isAutoGradableQuestionType(getQuestionTypeKeyFromId(id)));
+  }
+
+  /** When true, every question must have points &gt; 0 before save */
+  const requiresPositivePointsForAutoGrade = $derived(
+    isSelfPacedCourse && isExerciseFullyAutoGradable(activeQuestionTypeIds)
+  );
+  const teacherAutoGradeBadge = $derived.by(() => {
+    if ($globalStore.isStudent || !isSelfPacedCourse || activeQuestionTypeIds.length === 0) return null;
+    return isExerciseFullyAutoGradable(activeQuestionTypeIds) ? ('auto' as const) : ('manual' as const);
+  });
 </script>
 
 <Page.Header isSticky={true} class="z-250! min-h-[36px]">
   <Page.HeaderContent>
-    <Page.Title>{$questionnaire.title || 'Exercise'}</Page.Title>
+    <Page.Title class="flex flex-wrap items-center gap-2">
+      <span>{$questionnaire.title || 'Exercise'}</span>
+      <RoleBasedSecurity allowedRoles={[1, 2]}>
+        {#if teacherAutoGradeBadge === 'auto'}
+          <Badge variant="success" class="font-normal">
+            {$t('course.navItem.lessons.exercises.all_exercises.auto_graded_badge')}
+          </Badge>
+        {:else if teacherAutoGradeBadge === 'manual'}
+          <Badge variant="warning" class="font-normal">
+            {$t('course.navItem.lessons.exercises.all_exercises.manual_grading_required_badge')}
+          </Badge>
+        {/if}
+      </RoleBasedSecurity>
+    </Page.Title>
   </Page.HeaderContent>
   <Page.Action>
     <div class="flex items-center gap-2">
@@ -278,7 +334,7 @@
     <div class="overflow-x-hidden">
       {#if $globalStore.isStudent}
         {#if isExerciseUnlocked}
-          <ViewMode {preview} {exerciseId} isFetchingExercise={isFetching} {mySubmission} />
+          <ViewMode {preview} {exerciseId} isFetchingExercise={isFetching} {mySubmissions} />
         {:else}
           <Empty
             title={$t('course.navItem.lessons.content_locked_title')}
@@ -290,10 +346,13 @@
         {/if}
       {:else}
         <UnderlineTabs.Root bind:value={selectedTab} class="mb-4">
-          <UnderlineTabs.List class="grid w-full max-w-xs grid-cols-2">
+          <UnderlineTabs.List class="grid w-full max-w-lg grid-cols-3">
             <UnderlineTabs.Trigger value="questions">
               {$t('course.navItem.lessons.exercises.all_exercises.questions')}
             </UnderlineTabs.Trigger>
+            <UnderlineTabs.Trigger value="settings">
+              {$t('course.navItem.lessons.exercises.all_exercises.settings')}
+            </UnderlineTabs.Trigger>
             <UnderlineTabs.Trigger value="submissions">
               {$t('course.navItem.lessons.exercises.all_exercises.analytics.submissions')}
 
@@ -303,11 +362,20 @@
           <UnderlineTabs.Content value="questions">
             <UpdateDescription {preview} />
             {#if !preview}
-              <EditMode bind:shouldDeleteExercise {exerciseId} {goBack} />
+              <EditMode
+                bind:shouldDeleteExercise
+                {exerciseId}
+                {goBack}
+                {requiresPositivePointsForAutoGrade}
+                selfPacedCourse={isSelfPacedCourse}
+              />
             {:else}
-              <ViewMode {preview} {exerciseId} isFetchingExercise={isFetching} {mySubmission} />
+              <ViewMode {preview} {exerciseId} isFetchingExercise={isFetching} {mySubmissions} />
             {/if}
           </UnderlineTabs.Content>
+          <UnderlineTabs.Content value="settings">
+            <ExerciseSettingsTab {exerciseId} />
+          </UnderlineTabs.Content>
           <UnderlineTabs.Content value="submissions">
             <Submissions bind:exerciseId {submissions} />
           </UnderlineTabs.Content>
diff --git a/apps/dashboard/src/lib/features/course/pages/settings.svelte b/apps/dashboard/src/lib/features/course/pages/settings.svelte
index e23d0f8f..c9a9f70f 100644
--- a/apps/dashboard/src/lib/features/course/pages/settings.svelte
+++ b/apps/dashboard/src/lib/features/course/pages/settings.svelte
@@ -35,6 +35,12 @@
   import { currentOrgDomain, currentOrgPath, isFreePlan } from '$lib/utils/store/org';
   import { page } from '$app/stores';
 
+  interface Props {
+    hasUnsavedChanges?: boolean;
+  }
+
+  let { hasUnsavedChanges = $bindable(false) }: Props = $props();
+
   let isLoading = $state(false);
   let isDeleting = $state(false);
   let errors: {
@@ -45,7 +51,6 @@
     description: undefined
   });
   let avatar: string | undefined;
-  let hasUnsavedChanges = $state(false);
   let openDeleteModal = $state(false);
   let selectedTagIds = $state<string[]>([]);
   let initialTagIds = $state<string[]>([]);
diff --git a/apps/dashboard/src/lib/features/course/store.ts b/apps/dashboard/src/lib/features/course/store.ts
index 61630346..8f33085f 100644
--- a/apps/dashboard/src/lib/features/course/store.ts
+++ b/apps/dashboard/src/lib/features/course/store.ts
@@ -3,7 +3,14 @@ import type { Course } from '$features/course/types';
 import type { CourseMembers, CourseSectionWithLessons, ListLessons } from '$features/course/utils/types';
 import { writable, type Writable } from 'svelte/store';
 
-export const defaultCourse = {
+const defaultLessonTabsOrder: NonNullable<NonNullable<Course['metadata']>['lessonTabsOrder']> = [
+  { id: 1, name: 'course.navItem.lessons.materials.tabs.note.title' },
+  { id: 2, name: 'course.navItem.lessons.materials.tabs.slide.title' },
+  { id: 3, name: 'course.navItem.lessons.materials.tabs.video.title' },
+  { id: 4, name: 'course.navItem.lessons.materials.tabs.document.title' }
+];
+
+export const defaultCourse: Course = {
   id: '',
   title: '',
   description: '',
@@ -12,8 +19,10 @@ export const defaultCourse = {
   cost: 0,
   currency: 'USD',
   status: 'ACTIVE',
-  isCertificateDownloadable: false,
-  certificateTheme: 'professional',
+  certificate: {
+    isDownloadable: false,
+    theme: 'professional'
+  },
   isPublished: false,
   createdAt: new Date().toISOString(),
   updatedAt: new Date().toISOString(),
@@ -24,10 +33,6 @@ export const defaultCourse = {
   bannerImage: null,
   attendance: [],
   group: null,
-  course_section: [],
-  sections: [],
-  lessons: [],
-  exercises: [],
   content: {
     grouped: false,
     sections: [],
@@ -52,12 +57,7 @@ export const defaultCourse = {
       description: '',
       imgUrl: ''
     },
-    lessonTabsOrder: [
-      { id: 1, name: 'course.navItem.lessons.materials.tabs.note.title' },
-      { id: 2, name: 'course.navItem.lessons.materials.tabs.slide.title' },
-      { id: 3, name: 'course.navItem.lessons.materials.tabs.video.title' },
-      { id: 4, name: 'course.navItem.lessons.materials.tabs.document.title' }
-    ],
+    lessonTabsOrder: defaultLessonTabsOrder,
     grading: false,
     lessonDownload: true,
     allowNewStudent: false,
diff --git a/apps/dashboard/src/lib/features/course/store/course-completion-modal.ts b/apps/dashboard/src/lib/features/course/store/course-completion-modal.ts
new file mode 100644
index 00000000..0354b012
--- /dev/null
+++ b/apps/dashboard/src/lib/features/course/store/course-completion-modal.ts
@@ -0,0 +1,16 @@
+import { writable } from 'svelte/store';
+
+export type CourseCompletionModalState = {
+  open: boolean;
+  courseId: string;
+};
+
+export const courseCompletionModal = writable<CourseCompletionModalState | null>(null);
+
+export function openCourseCompletionModal(courseId: string) {
+  courseCompletionModal.set({ open: true, courseId });
+}
+
+export function closeCourseCompletionModal() {
+  courseCompletionModal.set(null);
+}
diff --git a/apps/dashboard/src/lib/features/course/utils/certificate-utils.ts b/apps/dashboard/src/lib/features/course/utils/certificate-utils.ts
new file mode 100644
index 00000000..9ea60e32
--- /dev/null
+++ b/apps/dashboard/src/lib/features/course/utils/certificate-utils.ts
@@ -0,0 +1,10 @@
+import { CERTIFICATE_THEME_IDS, DEFAULT_CERTIFICATE_THEME_ID, type CertificateThemeId } from './constants';
+
+const CERTIFICATE_THEME_ID_SET = new Set<string>(CERTIFICATE_THEME_IDS);
+
+export function parseCertificateThemeId(raw: string | null | undefined): CertificateThemeId {
+  if (raw != null && raw !== '' && CERTIFICATE_THEME_ID_SET.has(raw)) {
+    return raw as CertificateThemeId;
+  }
+  return DEFAULT_CERTIFICATE_THEME_ID;
+}
diff --git a/apps/dashboard/src/lib/features/course/utils/constants.ts b/apps/dashboard/src/lib/features/course/utils/constants.ts
index 28210495..63c41f5d 100644
--- a/apps/dashboard/src/lib/features/course/utils/constants.ts
+++ b/apps/dashboard/src/lib/features/course/utils/constants.ts
@@ -37,6 +37,19 @@ export type CourseSortOrder = (typeof CourseSortOrder)[keyof typeof CourseSortOr
 
 export const DEFAULT_SORT_ORDER: CourseSortOrder = CourseSortOrder.Desc;
 
+export const CERTIFICATE_THEME_IDS = [
+  'professional',
+  'plain',
+  'purpleProfessionalBadge',
+  'blueProfessionalBadge',
+  'purpleBadgePattern',
+  'blueBadgePattern'
+] as const;
+
+export type CertificateThemeId = (typeof CERTIFICATE_THEME_IDS)[number];
+
+export const DEFAULT_CERTIFICATE_THEME_ID: CertificateThemeId = 'professional';
+
 const COURSE_SORT_ORDER_VALUES = new Set<string>(Object.values(CourseSortOrder));
 
 export function parseCourseSortOrder(value: string | null | undefined): CourseSortOrder {
diff --git a/apps/dashboard/src/lib/features/course/utils/functions.ts b/apps/dashboard/src/lib/features/course/utils/functions.ts
index e23cbb3f..e97aeb42 100644
--- a/apps/dashboard/src/lib/features/course/utils/functions.ts
+++ b/apps/dashboard/src/lib/features/course/utils/functions.ts
@@ -71,16 +71,17 @@ export function formatAnswers(data: {
   answers: SubmissionAnswer[];
 }): Record<string, AnswerData> {
   const answers: Record<string, AnswerData> = {};
-  const questionByIdAndName: Record<string, string> = {};
+  const questionKeyById: Record<string, string> = {};
 
   for (const question of data.questions) {
-    questionByIdAndName[String(question.id)] = question.name ?? '';
+    const key = question.name ? String(question.name) : String(question.id);
+    questionKeyById[String(question.id)] = key;
   }
 
   for (const answer of data.answers) {
-    const questionName = questionByIdAndName[String(answer.questionId)];
-    if (questionName && answer.answerData) {
-      answers[questionName] = answer.answerData;
+    const questionKey = questionKeyById[String(answer.questionId)];
+    if (questionKey && answer.answerData) {
+      answers[questionKey] = answer.answerData;
     }
   }
 
diff --git a/apps/dashboard/src/lib/features/course/utils/types.ts b/apps/dashboard/src/lib/features/course/utils/types.ts
index b46c5e8c..627ec267 100644
--- a/apps/dashboard/src/lib/features/course/utils/types.ts
+++ b/apps/dashboard/src/lib/features/course/utils/types.ts
@@ -266,6 +266,13 @@ export type DeleteCourseRequest = (typeof classroomio.course)[':courseId']['$del
 export type UpdateCourseContentRequest = (typeof classroomio.course)[':courseId']['content']['$put'];
 export type DeleteCourseContentRequest = (typeof classroomio.course)[':courseId']['content']['$delete'];
 export type GetCourseProgressRequest = (typeof classroomio.course)[':courseId']['progress']['$get'];
+export type GetCertificationEvaluationRequest =
+  (typeof classroomio.course)[':courseId']['certification-evaluation']['$get'];
+export type GetCertificationEvaluationSuccess = Extract<
+  InferResponseType<GetCertificationEvaluationRequest>,
+  { success: true }
+>;
+export type CertificationEvaluationData = GetCertificationEvaluationSuccess['data'];
 export type CloneCourseRequest = (typeof classroomio.course)[':courseId']['clone']['$post'];
 export type EnrollCourseRequest = (typeof classroomio.course)[':courseId']['enroll']['$post'];
 
@@ -280,12 +287,17 @@ export type CourseMetadata = (NonNullable<ApiCourse['metadata']> extends object
   : Record<string, unknown>) & {
   isContentGroupingEnabled?: boolean;
 };
+export type CourseCertificate =
+  NonNullable<ApiCourse['certificate']> extends object
+    ? NonNullable<ApiCourse['certificate']>
+    : Record<string, unknown>;
 export type CourseContent = NonNullable<ApiCourse['content']>;
 export type CourseContentSection = CourseContent['sections'][number];
 export type CourseContentItem = CourseContent['items'][number];
 
 export type Course = Omit<ApiCourse, 'metadata' | 'lessons' | 'sections' | 'exercises'> & {
   metadata?: CourseMetadata | null;
+  certificate?: CourseCertificate | null;
   content: CourseContent;
 };
 
diff --git a/apps/dashboard/src/lib/features/lms/pages/mylearning.svelte b/apps/dashboard/src/lib/features/lms/pages/mylearning.svelte
index f2f897f9..a8fb7c3b 100644
--- a/apps/dashboard/src/lib/features/lms/pages/mylearning.svelte
+++ b/apps/dashboard/src/lib/features/lms/pages/mylearning.svelte
@@ -44,7 +44,7 @@
 
 <UnderlineTabs.Root bind:value={currentTab}>
   <UnderlineTabs.List>
-    {#each tabs as tab}
+    {#each tabs as tab (tab.value)}
       <UnderlineTabs.Trigger value={tab.value}>
         {$t(tab.label)}
       </UnderlineTabs.Trigger>
diff --git a/apps/dashboard/src/lib/features/org/api/org.svelte.ts b/apps/dashboard/src/lib/features/org/api/org.svelte.ts
index 0427a3cc..7945b790 100644
--- a/apps/dashboard/src/lib/features/org/api/org.svelte.ts
+++ b/apps/dashboard/src/lib/features/org/api/org.svelte.ts
@@ -1,5 +1,6 @@
 import type {
   AssignAudienceCoursesRequest,
+  DeleteAudienceMemberRequest,
   DeleteTeamRequest,
   DomainRequestRequest,
   GetAudienceRequest,
@@ -8,6 +9,8 @@ import type {
   InviteTeamRequest,
   OrgPublicCourses,
   OrganizationAudience,
+  OrganizationAudiencePagination,
+  OrganizationAudienceQuery,
   OrganizationTeamMembers,
   ResendAudienceInviteRequest,
   RevokeAudienceInviteRequest
@@ -36,6 +39,7 @@ import { resolve } from '$app/paths';
 import { snackbar } from '$features/ui/snackbar/store';
 import { t } from '$lib/utils/functions/translations';
 import { uploadImage } from '$lib/utils/services/upload';
+import { DEFAULT_ORG_AUDIENCE_QUERY, toAudienceRequestQuery } from '../utils/audience-query-utils';
 
 export interface TOrgUpdateForm {
   name?: string;
@@ -59,9 +63,16 @@ export interface TOrgUpdateForm {
 class OrgApi extends BaseApiWithErrors {
   teamMembers = $state<OrganizationTeamMembers>([]);
   audience = $state<OrganizationAudience>([]);
+  audiencePagination = $state<OrganizationAudiencePagination | null>(null);
   publicCourses: OrgPublicCourses = $state([]);
 
   isFetchingOrgPublicCourses = $state(false);
+  private activeAudienceRequestController: AbortController | null = null;
+
+  cancelAudienceRequest() {
+    this.activeAudienceRequestController?.abort();
+    this.activeAudienceRequestController = null;
+  }
 
   /**
    * Gets organization team members (non-students)
@@ -91,16 +102,52 @@ class OrgApi extends BaseApiWithErrors {
    * @param orgId Organization ID
    * @returns Audience array
    */
-  async getOrgAudience(orgId?: string) {
+  async getOrgAudience(
+    orgId?: string,
+    query?: Partial<OrganizationAudienceQuery>,
+    options: { abortPrevious?: boolean; signal?: AbortSignal } = {}
+  ) {
     if (!orgId) return;
 
-    return this.execute<GetAudienceRequest>({
-      requestFn: () => classroomio.organization.audience.$get(),
+    const requestQuery = toAudienceRequestQuery({
+      ...DEFAULT_ORG_AUDIENCE_QUERY,
+      ...query
+    });
+
+    let requestSignal = options.signal;
+    let requestController: AbortController | null = null;
+
+    if (options.abortPrevious) {
+      this.cancelAudienceRequest();
+      requestController = new AbortController();
+      this.activeAudienceRequestController = requestController;
+      requestSignal = requestController.signal;
+    }
+
+    const response = await this.execute<GetAudienceRequest>({
+      requestFn: () =>
+        classroomio.organization.audience.$get(
+          {
+            query: requestQuery!
+          },
+          {
+            init: {
+              signal: requestSignal
+            }
+          }
+        ),
       logContext: 'fetching organization audience',
       onSuccess: (response) => {
         this.audience = response.data;
+        this.audiencePagination = response.pagination;
       }
     });
+
+    if (requestController && this.activeAudienceRequestController === requestController) {
+      this.activeAudienceRequestController = null;
+    }
+
+    return response;
   }
 
   /**
@@ -384,7 +431,6 @@ class OrgApi extends BaseApiWithErrors {
    * Imports users into the organization as students
    */
   async importAudienceMembers(data: TImportAudienceMembers) {
-    console.log('importAudienceMembers', data);
     return this.execute<ImportAudienceRequest>({
       requestFn: () =>
         classroomio.organization.audience.import.$post({
@@ -396,7 +442,8 @@ class OrgApi extends BaseApiWithErrors {
         snackbar.success(
           t.get('audience.import.snackbar_success', {
             imported: d.imported,
-            skipped: d.skipped,
+            assigned: d.assigned ?? 0,
+            pendingInvitesRenewed: d.pendingInvitesRenewed ?? 0,
             emailsSent: d.emailsSent
           })
         );
@@ -460,8 +507,6 @@ class OrgApi extends BaseApiWithErrors {
         } else {
           snackbar.error('audience.invite.resend_snackbar_email_failed');
         }
-        const orgId = get(currentOrg).id;
-        if (orgId) this.getOrgAudience(orgId);
       },
       onError: (result) => {
         if (typeof result === 'string') {
@@ -480,8 +525,6 @@ class OrgApi extends BaseApiWithErrors {
       logContext: 'revoking audience invite',
       onSuccess: () => {
         snackbar.success('audience.invite.revoke_snackbar_success');
-        const orgId = get(currentOrg).id;
-        if (orgId) this.getOrgAudience(orgId);
       },
       onError: (result) => {
         if (typeof result === 'string') {
@@ -490,6 +533,27 @@ class OrgApi extends BaseApiWithErrors {
       }
     });
   }
+
+  async deleteAudienceMember(memberId: number) {
+    return this.execute<DeleteAudienceMemberRequest>({
+      requestFn: () =>
+        classroomio.organization.audience[':memberId'].$delete({
+          param: { memberId: memberId.toString() }
+        }),
+      logContext: 'removing audience member',
+      onSuccess: () => {
+        snackbar.success('audience.delete.snackbar_success');
+      },
+      onError: (result) => {
+        if (typeof result === 'string') {
+          snackbar.error(result);
+          return;
+        }
+
+        snackbar.error('error' in result ? result.error : result.message);
+      }
+    });
+  }
 }
 
 export const orgApi = new OrgApi();
diff --git a/apps/dashboard/src/lib/features/org/utils/audience-query-utils.ts b/apps/dashboard/src/lib/features/org/utils/audience-query-utils.ts
new file mode 100644
index 00000000..9c5e5860
--- /dev/null
+++ b/apps/dashboard/src/lib/features/org/utils/audience-query-utils.ts
@@ -0,0 +1,58 @@
+import type { OrganizationAudienceQuery, OrganizationAudienceRequestQuery } from './types';
+
+export const DEFAULT_ORG_AUDIENCE_QUERY: OrganizationAudienceQuery = {
+  page: 1,
+  limit: 20,
+  sortBy: 'createdAt',
+  sortOrder: 'desc'
+};
+
+export function getAudienceQueryFromSearchParams(
+  searchParams: URLSearchParams,
+  defaults: OrganizationAudienceQuery = DEFAULT_ORG_AUDIENCE_QUERY
+): OrganizationAudienceQuery {
+  const page = Number(searchParams.get('page'));
+  const limit = Number(searchParams.get('limit'));
+  const sortBy = searchParams.get('sortBy');
+  const sortOrder = searchParams.get('sortOrder');
+  const search = searchParams.get('search')?.trim() || undefined;
+
+  return {
+    page: Number.isFinite(page) && page > 0 ? Math.floor(page) : defaults.page,
+    limit: Number.isFinite(limit) && limit > 0 ? Math.floor(limit) : defaults.limit,
+    sortBy: sortBy === 'name' || sortBy === 'email' || sortBy === 'createdAt' ? sortBy : defaults.sortBy,
+    sortOrder: sortOrder === 'asc' || sortOrder === 'desc' ? sortOrder : defaults.sortOrder,
+    search
+  };
+}
+
+export function getAudienceSearchParams(query: OrganizationAudienceQuery): URLSearchParams {
+  const searchParams = new URLSearchParams();
+
+  searchParams.set('page', String(query.page));
+  searchParams.set('limit', String(query.limit));
+  searchParams.set('sortBy', query.sortBy);
+  searchParams.set('sortOrder', query.sortOrder);
+
+  if (query.search) {
+    searchParams.set('search', query.search);
+  }
+
+  return searchParams;
+}
+
+export function toAudienceRequestQuery(
+  query?: Partial<OrganizationAudienceQuery>
+): OrganizationAudienceRequestQuery | undefined {
+  if (!query) {
+    return undefined;
+  }
+
+  return {
+    page: query.page != null ? String(query.page) : undefined,
+    limit: query.limit != null ? String(query.limit) : undefined,
+    search: query.search,
+    sortBy: query.sortBy,
+    sortOrder: query.sortOrder
+  };
+}
diff --git a/apps/dashboard/src/lib/features/org/utils/types.ts b/apps/dashboard/src/lib/features/org/utils/types.ts
index e73cf3c5..d26f2088 100644
--- a/apps/dashboard/src/lib/features/org/utils/types.ts
+++ b/apps/dashboard/src/lib/features/org/utils/types.ts
@@ -1,4 +1,4 @@
-import { classroomio, type InferResponseType } from '$lib/utils/services/api';
+import { classroomio, type InferRequestType, type InferResponseType } from '$lib/utils/services/api';
 
 // Team member types
 export type GetTeamRequest = (typeof classroomio.organization)['team']['$get'];
@@ -20,9 +20,19 @@ export type OrganizationTeamMembers = Array<
 export type GetAudienceRequest = (typeof classroomio.organization)['audience']['$get'];
 export type OrganizationAudienceResponse = InferResponseType<GetAudienceRequest> | null;
 export type OrganizationAudienceSuccess = Extract<InferResponseType<GetAudienceRequest>, { success: true }>;
+export type OrganizationAudienceRequestQuery = NonNullable<InferRequestType<GetAudienceRequest>['query']>;
+export type OrganizationAudienceSortBy = 'createdAt' | 'name' | 'email';
+export type OrganizationAudienceSortOrder = 'asc' | 'desc';
+export type OrganizationAudienceQuery = {
+  page: number;
+  limit: number;
+  search?: string;
+  sortBy: OrganizationAudienceSortBy;
+  sortOrder: OrganizationAudienceSortOrder;
+};
 
 export type OrganizationAudience = OrganizationAudienceSuccess['data'];
-
+export type OrganizationAudiencePagination = OrganizationAudienceSuccess['pagination'];
 export type OrganizationAudienceMember = OrganizationAudience[number];
 
 // Org Public Courses  types
@@ -43,6 +53,8 @@ export type InviteTeamData = InviteTeamSuccess['data'];
 
 export type DeleteTeamRequest = (typeof classroomio.organization)['team'][':memberId']['$delete'];
 export type DeleteTeamSuccess = Extract<InferResponseType<DeleteTeamRequest>, { success: true }>;
+export type DeleteAudienceMemberRequest = (typeof classroomio.organization)['audience'][':memberId']['$delete'];
+export type DeleteAudienceMemberSuccess = Extract<InferResponseType<DeleteAudienceMemberRequest>, { success: true }>;
 
 // update organization types
 export type UpdateOrganizationRequest = (typeof classroomio.organization)['$put'];
diff --git a/apps/dashboard/src/lib/features/settings/pages/domains.svelte b/apps/dashboard/src/lib/features/settings/pages/domains.svelte
index 5b156908..54907cd3 100644
--- a/apps/dashboard/src/lib/features/settings/pages/domains.svelte
+++ b/apps/dashboard/src/lib/features/settings/pages/domains.svelte
@@ -370,7 +370,7 @@
           </Field.Field>
         {:else if currentDomainStatus !== 'verified'}
           <Field.Field>
-            <div class="rounded-md border px-4 py-3 text-sm ui:text-muted-foreground">
+            <div class="ui:text-muted-foreground rounded-md border px-4 py-3 text-sm">
               {$t('components.settings.domains.reconnect_hint')}
             </div>
           </Field.Field>
diff --git a/apps/dashboard/src/lib/features/ui/confetti/store.ts b/apps/dashboard/src/lib/features/ui/confetti/store.ts
index 879839a4..cfcf973c 100644
--- a/apps/dashboard/src/lib/features/ui/confetti/store.ts
+++ b/apps/dashboard/src/lib/features/ui/confetti/store.ts
@@ -10,3 +10,10 @@ export function toggleConfetti() {
     show: !confetti.show
   }));
 }
+
+export function setConfetti(show: boolean) {
+  confettiStore.update((confetti) => ({
+    ...confetti,
+    show
+  }));
+}
diff --git a/apps/dashboard/src/lib/features/ui/course-landing-page/components/editor/editor.svelte b/apps/dashboard/src/lib/features/ui/course-landing-page/components/editor/editor.svelte
index edc842e8..35073da3 100644
--- a/apps/dashboard/src/lib/features/ui/course-landing-page/components/editor/editor.svelte
+++ b/apps/dashboard/src/lib/features/ui/course-landing-page/components/editor/editor.svelte
@@ -18,6 +18,7 @@
     HoverableItem,
     PreviewIcon
   } from '@cio/ui/custom/moving-icons';
+  import type { TCourseUpdate } from '@cio/utils/validation/course';
 
   import { IconButton } from '@cio/ui/custom/icon-button';
   import { CloseButton } from '$features/ui';
@@ -151,15 +152,22 @@
     course.slug = course.slug || generateSlug(course.title, { appendTimestamp: true });
 
     console.log('course', course);
-    await courseApi.update(courseId, {
+    const updatePayload = {
       ...course,
       type: course.type!,
       slug: course.slug!,
       isPublished: course.isPublished ?? undefined,
       overview: course.overview ?? undefined,
-      isCertificateDownloadable: course.isCertificateDownloadable ?? undefined,
-      certificateTheme: course.certificateTheme ?? undefined
-    });
+      certificate: course.certificate
+        ? {
+            ...course.certificate,
+            isDownloadable: course.certificate.isDownloadable ?? undefined,
+            theme: course.certificate.theme ?? undefined
+          }
+        : undefined
+    } as TCourseUpdate;
+
+    await courseApi.update(courseId, updatePayload);
 
     loading = false;
     syncCourseStore(course);
@@ -173,7 +181,7 @@
     });
   }
 
-  function setter(value: any, setterKey: string) {
+  function setter(value: unknown, setterKey: string) {
     if (typeof value === 'undefined') return;
 
     // Untrack the course change to avoid unnecessary re-renders
@@ -231,7 +239,7 @@
         </Sidebar.GroupLabel>
         <Sidebar.GroupContent>
           <Sidebar.Menu>
-            {#each sections as section}
+            {#each sections as section (section.key)}
               {@const SectionIcon = section.icon}
               <HoverableItem>
                 {#snippet children(isHovered)}
@@ -253,7 +261,7 @@
       </Sidebar.Group>
     {:else}
       <Sidebar.Menu>
-        {#each sections as section}
+        {#each sections as section (section.key)}
           {@const SectionIcon = section.icon}
           <HoverableItem>
             {#snippet children(isHovered)}
diff --git a/apps/dashboard/src/lib/features/ui/question/constants.ts b/apps/dashboard/src/lib/features/ui/question/constants.ts
index 84e076c8..4741018e 100644
--- a/apps/dashboard/src/lib/features/ui/question/constants.ts
+++ b/apps/dashboard/src/lib/features/ui/question/constants.ts
@@ -32,7 +32,8 @@ export const QUESTION_TYPES = QUESTION_TYPE_REGISTRY.filter((qt) => !HIDDEN_QUES
     id: questionType.id,
     key: questionType.key,
     label: questionType.label,
-    labelKey: QUESTION_TYPE_LABEL_KEYS[questionType.key]
+    labelKey: QUESTION_TYPE_LABEL_KEYS[questionType.key],
+    autoGradable: questionType.autoGradable
   })
 );
 
diff --git a/apps/dashboard/src/lib/utils/functions/validator.ts b/apps/dashboard/src/lib/utils/functions/validator.ts
index 05e1bd3f..c12c6eb4 100644
--- a/apps/dashboard/src/lib/utils/functions/validator.ts
+++ b/apps/dashboard/src/lib/utils/functions/validator.ts
@@ -21,17 +21,6 @@ function getSiteNameValidation() {
     });
 }
 
-export const saveCertificateValidation = (fields = {}) => {
-  const schema = z.object({
-    description: z.string().max(200, 'course.navItem.certificates.description_error'),
-    is_certificate_downloadable: z.boolean(),
-    certificate_theme: z.string()
-  });
-
-  const { error } = schema.safeParse(fields);
-  return processErrors(error);
-};
-
 export const getConfirmPasswordError = ({ password, confirmPassword }) => {
   return password > 6 && confirmPassword > 6 && password !== confirmPassword
     ? `${t.get('validations.confirm_password.not_match')}`
diff --git a/apps/dashboard/src/lib/utils/services/api/base.svelte.ts b/apps/dashboard/src/lib/utils/services/api/base.svelte.ts
index aef00b4a..154fec3f 100644
--- a/apps/dashboard/src/lib/utils/services/api/base.svelte.ts
+++ b/apps/dashboard/src/lib/utils/services/api/base.svelte.ts
@@ -67,6 +67,10 @@ export class BaseApi {
         return typedResult;
       }
     } catch (error) {
+      if (error instanceof Error && error.name === 'AbortError') {
+        return;
+      }
+
       console.error(`Error in ${logContext}:`, error);
       this.error = getErrMsg(error, `Error ${logContext}:`);
 
diff --git a/apps/dashboard/src/lib/utils/services/api/index.ts b/apps/dashboard/src/lib/utils/services/api/index.ts
index fffbaa7d..94577720 100644
--- a/apps/dashboard/src/lib/utils/services/api/index.ts
+++ b/apps/dashboard/src/lib/utils/services/api/index.ts
@@ -19,6 +19,39 @@ export const getRequestBaseUrl = () => {
   return env.PUBLIC_SERVER_URL;
 };
 
+function mergeAbortSignals(...signals: Array<AbortSignal | null | undefined>) {
+  const activeSignals = signals.filter((signal): signal is AbortSignal => Boolean(signal));
+
+  if (activeSignals.length === 0) {
+    return undefined;
+  }
+
+  if (activeSignals.length === 1) {
+    return activeSignals[0];
+  }
+
+  const controller = new AbortController();
+
+  const abortWithSignal = (signal: AbortSignal) => {
+    if (controller.signal.aborted) {
+      return;
+    }
+
+    controller.abort(signal.reason);
+  };
+
+  for (const signal of activeSignals) {
+    if (signal.aborted) {
+      abortWithSignal(signal);
+      break;
+    }
+
+    signal.addEventListener('abort', () => abortWithSignal(signal), { once: true });
+  }
+
+  return controller.signal;
+}
+
 class ApiClient {
   private config: Required<ApiClientConfig>;
 
@@ -70,14 +103,14 @@ class ApiClient {
     }
 
     // Create abort controller for timeout
-    const controller = new AbortController();
-    const timeoutId = setTimeout(() => controller.abort(), timeout);
+    const timeoutController = new AbortController();
+    const timeoutId = setTimeout(() => timeoutController.abort(), timeout);
 
     const requestInit: RequestInit = {
       ...fetchConfig,
       headers: isFormData ? undefined : headers,
       body: requestBody,
-      signal: controller.signal
+      signal: mergeAbortSignals(fetchConfig.signal, timeoutController.signal)
     };
 
     let lastError: Error | null = null;
@@ -124,6 +157,10 @@ class ApiClient {
 
         // Handle abort (timeout)
         if (error instanceof Error && error.name === 'AbortError') {
+          if (!timeoutController.signal.aborted) {
+            throw error;
+          }
+
           throw new ApiError('Request timeout', 408, 'Request Timeout');
         }
 
diff --git a/apps/dashboard/src/lib/utils/translations/da.json b/apps/dashboard/src/lib/utils/translations/da.json
index ed89d2fa..10c84112 100644
--- a/apps/dashboard/src/lib/utils/translations/da.json
+++ b/apps/dashboard/src/lib/utils/translations/da.json
@@ -1118,7 +1118,11 @@
               "answers_required": "Angiv venligst mindst ét ​​svar, før du sender.",
               "checking_submission": "Tjek din indsendelse...",
               "answer_required": "Besvar venligst dette spørgsmål, før du fortsætter.",
-              "instructor_feedback": "Instruktør feedback"
+              "instructor_feedback": "Instruktør feedback",
+              "attempt_counter": "Forsøg {current} af {total}",
+              "previous_try": "Tidligere forsøg",
+              "next_try": "Næste forsøg",
+              "try_again": "Prøv igen"
             },
             "edit_mode": {
               "delete_modal": "Slet øvelse",
@@ -1371,7 +1375,11 @@
                 "not_set": "Ikke indstillet",
                 "incorrect_badge": "Forkert"
               }
-            }
+            },
+            "settings": "Indstillinger",
+            "settings_allow_multiple": "Tillad flere forsøg",
+            "settings_allow_multiple_helper": "Studerende kan indsende mere end én gang og gennemgå tidligere forsøg på resultatskærmen.",
+            "settings_save": "Gem indstillinger"
           },
           "new_exercise_modal": {
             "heading": "Ny øvelse",
@@ -1632,18 +1640,29 @@
         "later": "Luk"
       }
     },
+    "certificates": {
+      "progress_hint": "{current} % gennemført ({required} % kræves for at downloade)"
+    },
     "certification": {
-      "rules_heading": "Certificeringsregler",
+      "rules_heading": "Regler",
       "deadline_label": "Certificeringsfrist",
       "deadline_helper": "Studerende skal opfylde fuldførelsesprocenten inden denne dato (lokal tid). Lad være tomt uden deadline.",
       "threshold_label": "Minimum fuldførelse (%)",
       "threshold_helper": "Kombineret fremskridt i lektion og træning kræves for at opnå certifikatet (0-100). Standard er 100 %.",
-      "email_message_label": "E-mail med certificering",
-      "email_message_helper": "Valgfri besked vist i e-mailen, når en elev opfylder kravene. Et link til certifikatsiden er altid inkluderet.",
+      "final_exercise_label": "Afsluttende øvelse (valgfrit)",
+      "final_exercise_none": "ingen",
+      "final_exercise_helper": "Når den er indstillet, skal eleverne mindst opnå minimumscore på denne øvelse (bedste forsøg tæller) ud over fuldførelsesprocenten ovenfor.",
+      "min_exercise_score_label": "Minimumsscore på sidste øvelse (%)",
+      "min_exercise_score_helper": "Score er en procentdel af det samlede antal point, der er mulige på den øvelse (0-100).",
+      "blocker_progress": "Dit kursus fremskridt er {current}%; {required} % er påkrævet.",
+      "blocker_deadline": "Certificeringsfristen er udløbet.",
+      "blocker_no_content": "Dette kursus har ingen lektioner eller øvelser at gennemføre.",
+      "blocker_final_not_submitted": "Indsend den nødvendige øvelse \"{exerciseTitle}\" for at kvalificere dig til certifikatet.",
+      "blocker_final_pending": "Dit forsøg på \"{exerciseTitle}\" bliver stadig bedømt.",
+      "blocker_final_score": "Din bedste score på \"{exerciseTitle}\" er {bestPercent}%; {requiredPercent} % er påkrævet.",
+      "blocker_final_misconfigured": "Certificeringsøvelsen \"{exerciseTitle}\" har ingen point konfigureret; bed din instruktør om at ordne det.",
+      "email_message_label": "E-mail besked",
       "email_message_placeholder": "f.eks. Vi er stolte af dine fremskridt - fortsæt med at lære!"
-    },
-    "certificates": {
-      "progress_hint": "{current} % gennemført ({required} % kræves for at downloade)"
     }
   },
   "courses": {
diff --git a/apps/dashboard/src/lib/utils/translations/de.json b/apps/dashboard/src/lib/utils/translations/de.json
index c4d2f552..a37c1a1e 100644
--- a/apps/dashboard/src/lib/utils/translations/de.json
+++ b/apps/dashboard/src/lib/utils/translations/de.json
@@ -1118,7 +1118,11 @@
               "answers_required": "Bitte geben Sie vor dem Absenden mindestens eine Antwort an.",
               "checking_submission": "Ich prüfe Ihre Einreichung...",
               "answer_required": "Bitte beantworten Sie diese Frage, bevor Sie fortfahren.",
-              "instructor_feedback": "Feedback des Dozenten"
+              "instructor_feedback": "Feedback des Dozenten",
+              "attempt_counter": "Versuch {current} von {total}",
+              "previous_try": "Vorheriger Versuch",
+              "next_try": "Nächster Versuch",
+              "try_again": "Versuchen Sie es erneut"
             },
             "edit_mode": {
               "delete_modal": "Übung löschen",
@@ -1371,7 +1375,11 @@
                 "not_set": "Nicht festgelegt",
                 "incorrect_badge": "Falsch"
               }
-            }
+            },
+            "settings": "Einstellungen",
+            "settings_allow_multiple": "Erlauben Sie mehrere Versuche",
+            "settings_allow_multiple_helper": "Studierende können mehr als einmal einreichen und frühere Versuche auf dem Ergebnisbildschirm überprüfen.",
+            "settings_save": "Einstellungen speichern"
           },
           "new_exercise_modal": {
             "heading": "Neue Übung",
@@ -1632,18 +1640,29 @@
         "later": "Schließen"
       }
     },
+    "certificates": {
+      "progress_hint": "{current} % abgeschlossen ({required} % zum Herunterladen erforderlich)"
+    },
     "certification": {
-      "rules_heading": "Zertifizierungsregeln",
+      "rules_heading": "Regeln",
       "deadline_label": "Zertifizierungsfrist",
       "deadline_helper": "Die Schüler müssen den Abschlussprozentsatz vor diesem Datum/Uhrzeit (Ortszeit) erreichen. Für keine Frist leer lassen.",
       "threshold_label": "Mindestabschluss (%)",
       "threshold_helper": "Kombinierter Unterrichts- und Übungsfortschritt, der zum Erwerb des Zertifikats erforderlich ist (0–100). Der Standardwert ist 100 %.",
-      "email_message_label": "E-Mail-Nachricht zur Zertifizierung",
-      "email_message_helper": "Optionale Nachricht, die in der E-Mail angezeigt wird, wenn ein Student die Anforderungen erfüllt. Ein Link zur Zertifikatsseite ist immer enthalten.",
+      "final_exercise_label": "Abschlussübung (optional)",
+      "final_exercise_none": "keine",
+      "final_exercise_helper": "Wenn festgelegt, müssen die Schüler zusätzlich zu der oben genannten Abschlussquote mindestens die Mindestpunktzahl für diese Übung erreichen (bester Versuch zählt).",
+      "min_exercise_score_label": "Mindestpunktzahl bei der Abschlussübung (%)",
+      "min_exercise_score_helper": "Die Punktzahl ist ein Prozentsatz der bei dieser Übung möglichen Gesamtpunktzahl (0–100).",
+      "blocker_progress": "Ihr Kursfortschritt beträgt {current}%; {required}% ist erforderlich.",
+      "blocker_deadline": "Die Zertifizierungsfrist ist abgelaufen.",
+      "blocker_no_content": "Für diesen Kurs sind keine Lektionen oder Übungen erforderlich.",
+      "blocker_final_not_submitted": "Reichen Sie die erforderliche Übung „{exerciseTitle}“ ein, um sich für das Zertifikat zu qualifizieren.",
+      "blocker_final_pending": "Ihr Versuch bei „{exerciseTitle}“ wird noch bewertet.",
+      "blocker_final_score": "Ihre beste Punktzahl bei „{exerciseTitle}“ beträgt {bestPercent} %; {requiredPercent}% ist erforderlich.",
+      "blocker_final_misconfigured": "Für die Zertifizierungsübung „{exerciseTitle}“ sind keine Punkte konfiguriert; Bitten Sie Ihren Lehrer, das Problem zu beheben.",
+      "email_message_label": "E-Mail-Nachricht",
       "email_message_placeholder": "z.B. Wir sind stolz auf Ihre Fortschritte – lernen Sie weiter!"
-    },
-    "certificates": {
-      "progress_hint": "{current} % abgeschlossen ({required} % zum Herunterladen erforderlich)"
     }
   },
   "courses": {
diff --git a/apps/dashboard/src/lib/utils/translations/en.json b/apps/dashboard/src/lib/utils/translations/en.json
index 197e0c7f..a660f7c0 100644
--- a/apps/dashboard/src/lib/utils/translations/en.json
+++ b/apps/dashboard/src/lib/utils/translations/en.json
@@ -978,13 +978,13 @@
       "progress_hint": "{current}% complete ({required}% required to download)"
     },
     "certification": {
-      "rules_heading": "Certification rules",
+      "rules_heading": "Rules",
       "deadline_label": "Certification deadline",
       "deadline_helper": "Students must meet the completion percentage before this datetime (local time). Leave empty for no deadline.",
       "threshold_label": "Minimum completion (%)",
       "threshold_helper": "Combined lesson and exercise progress required to earn the certificate (0–100). Default is 100%.",
       "final_exercise_label": "Final exercise (optional)",
-      "final_exercise_none": "None — no extra exercise score",
+      "final_exercise_none": "none",
       "final_exercise_helper": "When set, students must reach at least the minimum score on this exercise (best attempt counts) in addition to the completion percentage above.",
       "min_exercise_score_label": "Minimum score on final exercise (%)",
       "min_exercise_score_helper": "Score is a percentage of the total points possible on that exercise (0–100).",
@@ -995,8 +995,7 @@
       "blocker_final_pending": "Your attempt on \"{exerciseTitle}\" is still being graded.",
       "blocker_final_score": "Your best score on \"{exerciseTitle}\" is {bestPercent}%; {requiredPercent}% is required.",
       "blocker_final_misconfigured": "The certification exercise \"{exerciseTitle}\" has no points configured; ask your instructor to fix it.",
-      "email_message_label": "Certification email message",
-      "email_message_helper": "Optional message shown in the email when a student meets the requirements. A link to the certificate page is always included.",
+      "email_message_label": "Email Message",
       "email_message_placeholder": "e.g. We are proud of your progress — keep learning!"
     },
     "completion": {
diff --git a/apps/dashboard/src/lib/utils/translations/es.json b/apps/dashboard/src/lib/utils/translations/es.json
index 9362ce3b..1bbc80f4 100644
--- a/apps/dashboard/src/lib/utils/translations/es.json
+++ b/apps/dashboard/src/lib/utils/translations/es.json
@@ -1118,7 +1118,11 @@
               "answers_required": "Proporcione al menos una respuesta antes de enviar.",
               "checking_submission": "Comprobando tu envío...",
               "answer_required": "Por favor responda esta pregunta antes de continuar.",
-              "instructor_feedback": "Comentarios del instructor"
+              "instructor_feedback": "Comentarios del instructor",
+              "attempt_counter": "Intento {actual} de {total}",
+              "previous_try": "Intento anterior",
+              "next_try": "Próximo intento",
+              "try_again": "Inténtalo de nuevo"
             },
             "edit_mode": {
               "delete_modal": "Eliminar ejercicio",
@@ -1371,7 +1375,11 @@
                 "not_set": "No establecido",
                 "incorrect_badge": "Incorrecto"
               }
-            }
+            },
+            "settings": "Configuración",
+            "settings_allow_multiple": "Permitir múltiples intentos",
+            "settings_allow_multiple_helper": "Los estudiantes pueden enviar más de una vez y revisar intentos anteriores en la pantalla de resultados.",
+            "settings_save": "Guardar configuración"
           },
           "new_exercise_modal": {
             "heading": "Nuevo ejercicio",
@@ -1632,18 +1640,29 @@
         "later": "Cerrar"
       }
     },
+    "certificates": {
+      "progress_hint": "{current}% completado ({required}% requerido para descargar)"
+    },
     "certification": {
-      "rules_heading": "Reglas de certificación",
+      "rules_heading": "Reglas",
       "deadline_label": "Fecha límite de certificación",
       "deadline_helper": "Los estudiantes deben alcanzar el porcentaje de finalización antes de esta fecha (hora local). Déjelo vacío sin fecha límite.",
       "threshold_label": "Finalización mínima (%)",
       "threshold_helper": "Progreso combinado de lección y ejercicio requerido para obtener el certificado (0–100). El valor predeterminado es 100%.",
-      "email_message_label": "Mensaje de correo electrónico de certificación",
-      "email_message_helper": "Mensaje opcional que se muestra en el correo electrónico cuando un estudiante cumple con los requisitos. Siempre se incluye un enlace a la página del certificado.",
-      "email_message_placeholder": "p.ej. Estamos orgullosos de tu progreso: ¡sigue aprendiendo!"
-    },
-    "certificates": {
-      "progress_hint": "{current}% completado ({required}% requerido para descargar)"
+      "final_exercise_label": "Ejercicio final (opcional)",
+      "final_exercise_none": "ninguno",
+      "final_exercise_helper": "Cuando se establece, los estudiantes deben alcanzar al menos la puntuación mínima en este ejercicio (el mejor intento cuenta) además del porcentaje de finalización anterior.",
+      "min_exercise_score_label": "Puntuación mínima en el ejercicio final (%)",
+      "min_exercise_score_helper": "La puntuación es un porcentaje del total de puntos posibles en ese ejercicio (0-100).",
+      "blocker_progress": "El progreso de su curso es {current}%; {required}% es obligatorio.",
+      "blocker_deadline": "La fecha límite de certificación ha pasado.",
+      "blocker_no_content": "Este curso no tiene lecciones ni ejercicios para completar.",
+      "blocker_final_not_submitted": "Envíe el ejercicio requerido \"{exerciseTitle}\" para calificar para el certificado.",
+      "blocker_final_pending": "Su intento en \"{exerciseTitle}\" aún se está calificando.",
+      "blocker_final_score": "Su mejor puntuación en \"{exerciseTitle}\" es {bestPercent}%; {requiredPercent}% es obligatorio.",
+      "blocker_final_misconfigured": "El ejercicio de certificación \"{exerciseTitle}\" no tiene puntos configurados; Pídele a tu instructor que lo arregle.",
+      "email_message_label": "Mensaje de correo electrónico",
+      "email_message_placeholder": "por ej. Estamos orgullosos de tu progreso: ¡sigue aprendiendo!"
     }
   },
   "courses": {
diff --git a/apps/dashboard/src/lib/utils/translations/fr.json b/apps/dashboard/src/lib/utils/translations/fr.json
index bde79151..0dd631d6 100644
--- a/apps/dashboard/src/lib/utils/translations/fr.json
+++ b/apps/dashboard/src/lib/utils/translations/fr.json
@@ -1118,7 +1118,11 @@
               "answers_required": "Veuillez fournir au moins une réponse avant de soumettre.",
               "checking_submission": "Vérification de votre soumission...",
               "answer_required": "Veuillez répondre à cette question avant de continuer.",
-              "instructor_feedback": "Commentaires de l'instructeur"
+              "instructor_feedback": "Commentaires de l'instructeur",
+              "attempt_counter": "Tentative {actuelle} de {total}",
+              "previous_try": "Tentative précédente",
+              "next_try": "Prochaine tentative",
+              "try_again": "Réessayez"
             },
             "edit_mode": {
               "delete_modal": "Supprimer l'exercice",
@@ -1371,7 +1375,11 @@
                 "not_set": "Non défini",
                 "incorrect_badge": "Incorrect"
               }
-            }
+            },
+            "settings": "Paramètres",
+            "settings_allow_multiple": "Autoriser plusieurs tentatives",
+            "settings_allow_multiple_helper": "Les étudiants peuvent soumettre plus d'une fois et revoir leurs tentatives antérieures sur l'écran des résultats.",
+            "settings_save": "Enregistrer les paramètres"
           },
           "new_exercise_modal": {
             "heading": "Nouvel exercice",
@@ -1632,18 +1640,29 @@
         "later": "Fermer"
       }
     },
+    "certificates": {
+      "progress_hint": "{current} % terminé ({required} % requis pour le téléchargement)"
+    },
     "certification": {
-      "rules_heading": "Règles de certification",
+      "rules_heading": "Règles",
       "deadline_label": "Date limite de certification",
       "deadline_helper": "Les étudiants doivent atteindre le pourcentage d'achèvement avant cette date/heure (heure locale). Laisser vide sans date limite.",
       "threshold_label": "Achèvement minimum (%)",
       "threshold_helper": "Progrès combiné des leçons et des exercices requis pour obtenir le certificat (0-100). La valeur par défaut est 100 %.",
-      "email_message_label": "Courriel de certification",
-      "email_message_helper": "Message facultatif affiché dans l'e-mail lorsqu'un étudiant répond aux exigences. Un lien vers la page du certificat est toujours inclus.",
+      "final_exercise_label": "Exercice final (facultatif)",
+      "final_exercise_none": "aucun",
+      "final_exercise_helper": "Une fois défini, les élèves doivent atteindre au moins le score minimum pour cet exercice (la meilleure tentative compte) en plus du pourcentage d'achèvement ci-dessus.",
+      "min_exercise_score_label": "Note minimale à l'exercice final (%)",
+      "min_exercise_score_helper": "Le score est un pourcentage du total de points possibles sur cet exercice (0 à 100).",
+      "blocker_progress": "La progression de votre cours est de {current} % ; {obligatoire} % est requis.",
+      "blocker_deadline": "La date limite de certification est dépassée.",
+      "blocker_no_content": "Ce cours ne comporte aucune leçon ni exercice à réaliser.",
+      "blocker_final_not_submitted": "Soumettez l'exercice requis \"{exerciseTitle}\" pour être admissible au certificat.",
+      "blocker_final_pending": "Votre tentative sur \"{exerciseTitle}\" est toujours en cours d'évaluation.",
+      "blocker_final_score": "Votre meilleur score sur \"{exerciseTitle}\" est de {bestPercent} % ; {requiredPercent} % est requis.",
+      "blocker_final_misconfigured": "L'exercice de certification « {exerciseTitle} » n'a aucun point configuré ; demandez à votre instructeur de le réparer.",
+      "email_message_label": "Message électronique",
       "email_message_placeholder": "par ex. Nous sommes fiers de vos progrès – continuez à apprendre !"
-    },
-    "certificates": {
-      "progress_hint": "{current} % terminé ({required} % requis pour le téléchargement)"
     }
   },
   "courses": {
diff --git a/apps/dashboard/src/lib/utils/translations/hi.json b/apps/dashboard/src/lib/utils/translations/hi.json
index f8b607bc..25d901b9 100644
--- a/apps/dashboard/src/lib/utils/translations/hi.json
+++ b/apps/dashboard/src/lib/utils/translations/hi.json
@@ -1118,7 +1118,11 @@
               "answers_required": "कृपया सबमिट करने से पहले कम से कम एक उत्तर प्रदान करें।",
               "checking_submission": "आपके सबमिशन की जाँच की जा रही है...",
               "answer_required": "कृपया आगे बढ़ने से पहले इस प्रश्न का उत्तर दें।",
-              "instructor_feedback": "प्रशिक्षक प्रतिक्रिया"
+              "instructor_feedback": "प्रशिक्षक प्रतिक्रिया",
+              "attempt_counter": "{कुल} का {वर्तमान} प्रयास करें",
+              "previous_try": "पिछला प्रयास",
+              "next_try": "अगला प्रयास",
+              "try_again": "पुनः प्रयास करें"
             },
             "edit_mode": {
               "delete_modal": "व्यायाम हटाएँ",
@@ -1371,7 +1375,11 @@
                 "not_set": "सेट नहीं",
                 "incorrect_badge": "गलत"
               }
-            }
+            },
+            "settings": "सेटिंग्स",
+            "settings_allow_multiple": "एकाधिक प्रयासों की अनुमति दें",
+            "settings_allow_multiple_helper": "छात्र एक से अधिक बार सबमिट कर सकते हैं और परिणाम स्क्रीन पर पिछले प्रयासों की समीक्षा कर सकते हैं।",
+            "settings_save": "सेटिंग्स सहेजें"
           },
           "new_exercise_modal": {
             "heading": "नया व्यायाम",
@@ -1632,18 +1640,29 @@
         "later": "बंद करें"
       }
     },
+    "certificates": {
+      "progress_hint": "{वर्तमान}% पूर्ण (डाउनलोड करने के लिए {आवश्यक}% आवश्यक)"
+    },
     "certification": {
-      "rules_heading": "प्रमाणन नियम",
+      "rules_heading": "नियम",
       "deadline_label": "प्रमाणीकरण की समय सीमा",
       "deadline_helper": "छात्रों को इस दिनांक समय (स्थानीय समय) से पहले पूर्णता प्रतिशत पूरा करना होगा। बिना किसी समय सीमा के खाली छोड़ दें.",
       "threshold_label": "न्यूनतम पूर्णता (%)",
       "threshold_helper": "प्रमाणपत्र (0-100) अर्जित करने के लिए संयुक्त पाठ और अभ्यास प्रगति की आवश्यकता है। डिफ़ॉल्ट 100% है.",
-      "email_message_label": "प्रमाणीकरण ईमेल संदेश",
-      "email_message_helper": "जब कोई छात्र आवश्यकताओं को पूरा करता है तो ईमेल में वैकल्पिक संदेश दिखाया जाता है। प्रमाणपत्र पृष्ठ का एक लिंक हमेशा शामिल किया जाता है।",
+      "final_exercise_label": "अंतिम अभ्यास (वैकल्पिक)",
+      "final_exercise_none": "कोई नहीं",
+      "final_exercise_helper": "निर्धारित होने पर, छात्रों को उपरोक्त पूर्णता प्रतिशत के अलावा इस अभ्यास पर कम से कम न्यूनतम अंक (सर्वोत्तम प्रयास मायने रखता है) तक पहुंचना होगा।",
+      "min_exercise_score_label": "अंतिम अभ्यास पर न्यूनतम स्कोर (%)",
+      "min_exercise_score_helper": "स्कोर उस अभ्यास पर संभावित कुल अंकों का एक प्रतिशत है (0-100)।",
+      "blocker_progress": "आपके पाठ्यक्रम की प्रगति {वर्तमान}% है; {आवश्यक}% आवश्यक है.",
+      "blocker_deadline": "प्रमाणन की समय सीमा बीत चुकी है.",
+      "blocker_no_content": "इस पाठ्यक्रम में पूरा करने के लिए कोई पाठ या अभ्यास नहीं है।",
+      "blocker_final_not_submitted": "प्रमाणपत्र के लिए अर्हता प्राप्त करने के लिए आवश्यक अभ्यास \"{exerciseTitle}\" सबमिट करें।",
+      "blocker_final_pending": "\"{exerciseTitle}\" पर आपका प्रयास अभी भी वर्गीकृत किया जा रहा है।",
+      "blocker_final_score": "\"{exerciseTitle}\" पर आपका सर्वोत्तम स्कोर {bestPercent}% है; {requiredPercent}% आवश्यक है.",
+      "blocker_final_misconfigured": "प्रमाणन अभ्यास \"{exerciseTitle}\" में कोई बिंदु कॉन्फ़िगर नहीं किया गया है; अपने प्रशिक्षक से इसे ठीक करने के लिए कहें।",
+      "email_message_label": "ईमेल संदेश",
       "email_message_placeholder": "जैसे हमें आपकी प्रगति पर गर्व है - सीखते रहें!"
-    },
-    "certificates": {
-      "progress_hint": "{वर्तमान}% पूर्ण (डाउनलोड करने के लिए {आवश्यक}% आवश्यक)"
     }
   },
   "courses": {
diff --git a/apps/dashboard/src/lib/utils/translations/pl.json b/apps/dashboard/src/lib/utils/translations/pl.json
index acb57053..a5ead84f 100644
--- a/apps/dashboard/src/lib/utils/translations/pl.json
+++ b/apps/dashboard/src/lib/utils/translations/pl.json
@@ -1118,7 +1118,11 @@
               "answers_required": "Przed przesłaniem proszę podać co najmniej jedną odpowiedź.",
               "checking_submission": "Sprawdzam Twoje zgłoszenie...",
               "answer_required": "Zanim przejdziesz dalej, odpowiedz na to pytanie.",
-              "instructor_feedback": "Informacje zwrotne od instruktora"
+              "instructor_feedback": "Informacje zwrotne od instruktora",
+              "attempt_counter": "Próba {bieżąca} z {total}",
+              "previous_try": "Poprzednia próba",
+              "next_try": "Następna próba",
+              "try_again": "Spróbuj ponownie"
             },
             "edit_mode": {
               "delete_modal": "Usuń ćwiczenie",
@@ -1371,7 +1375,11 @@
                 "not_set": "Nie ustawiono",
                 "incorrect_badge": "Niepoprawne"
               }
-            }
+            },
+            "settings": "Ustawienia",
+            "settings_allow_multiple": "Zezwalaj na wiele prób",
+            "settings_allow_multiple_helper": "Uczniowie mogą przesłać więcej niż raz i przejrzeć wcześniejsze próby na ekranie wyników.",
+            "settings_save": "Zapisz ustawienia"
           },
           "new_exercise_modal": {
             "heading": "Nowe ćwiczenie",
@@ -1632,18 +1640,29 @@
         "later": "Zamknij"
       }
     },
+    "certificates": {
+      "progress_hint": "{bieżący}% ukończenia ({required}% wymagane do pobrania)"
+    },
     "certification": {
-      "rules_heading": "Zasady certyfikacji",
+      "rules_heading": "Zasady",
       "deadline_label": "Termin certyfikacji",
       "deadline_helper": "Studenci muszą osiągnąć procent ukończenia przed tą datą (czasu lokalnego). Pozostaw puste bez terminu.",
       "threshold_label": "Minimalne ukończenie (%)",
       "threshold_helper": "Do uzyskania certyfikatu wymagany jest łączny postęp w lekcjach i ćwiczeniach (0–100). Wartość domyślna to 100%.",
-      "email_message_label": "Wiadomość e-mail z certyfikatem",
-      "email_message_helper": "Opcjonalna wiadomość wyświetlana w wiadomości e-mail, gdy uczeń spełni wymagania. Zawsze dołączany jest link do strony z certyfikatem.",
+      "final_exercise_label": "Ćwiczenie końcowe (opcjonalnie)",
+      "final_exercise_none": "żaden",
+      "final_exercise_helper": "Jeśli ta opcja jest ustawiona, uczniowie muszą osiągnąć co najmniej minimalny wynik w tym ćwiczeniu (liczą się najlepsze próby) oprócz powyższego procentu ukończenia.",
+      "min_exercise_score_label": "Minimalny wynik w ćwiczeniu końcowym (%)",
+      "min_exercise_score_helper": "Wynik to procent wszystkich punktów możliwych do uzyskania w tym ćwiczeniu (0–100).",
+      "blocker_progress": "Twój postęp w kursie wynosi {current}%; Wymagany jest {required}%.",
+      "blocker_deadline": "Termin certyfikacji minął.",
+      "blocker_no_content": "Ten kurs nie zawiera żadnych lekcji ani ćwiczeń do ukończenia.",
+      "blocker_final_not_submitted": "Wykonaj wymagane ćwiczenie „{exerciseTitle}”, aby zakwalifikować się do certyfikatu.",
+      "blocker_final_pending": "Twoje podejście do zadania „{exerciseTitle}” jest nadal oceniane.",
+      "blocker_final_score": "Twój najlepszy wynik w „{exerciseTitle}” to {bestPercent}%; Wymagany jest {requiredPercent}%.",
+      "blocker_final_misconfigured": "W ćwiczeniu certyfikacyjnym „{exerciseTitle}” nie skonfigurowano żadnych punktów; poproś instruktora, żeby to naprawił.",
+      "email_message_label": "Wiadomość e-mail",
       "email_message_placeholder": "np. Jesteśmy dumni z Twoich postępów — ucz się dalej!"
-    },
-    "certificates": {
-      "progress_hint": "{bieżący}% ukończenia ({required}% wymagane do pobrania)"
     }
   },
   "courses": {
diff --git a/apps/dashboard/src/lib/utils/translations/pt.json b/apps/dashboard/src/lib/utils/translations/pt.json
index fd18f828..f951b2fe 100644
--- a/apps/dashboard/src/lib/utils/translations/pt.json
+++ b/apps/dashboard/src/lib/utils/translations/pt.json
@@ -1118,7 +1118,11 @@
               "answers_required": "Forneça pelo menos uma resposta antes de enviar.",
               "checking_submission": "Verificando seu envio...",
               "answer_required": "Por favor, responda a esta pergunta antes de prosseguir.",
-              "instructor_feedback": "Feedback do instrutor"
+              "instructor_feedback": "Feedback do instrutor",
+              "attempt_counter": "Tentativa {atual} de {total}",
+              "previous_try": "Tentativa anterior",
+              "next_try": "Próxima tentativa",
+              "try_again": "Tente novamente"
             },
             "edit_mode": {
               "delete_modal": "Excluir exercício",
@@ -1371,7 +1375,11 @@
                 "not_set": "Não definido",
                 "incorrect_badge": "Incorreto"
               }
-            }
+            },
+            "settings": "Configurações",
+            "settings_allow_multiple": "Permitir múltiplas tentativas",
+            "settings_allow_multiple_helper": "Os alunos podem enviar mais de uma vez e revisar as tentativas anteriores na tela de resultados.",
+            "settings_save": "Salvar configurações"
           },
           "new_exercise_modal": {
             "heading": "Novo exercício",
@@ -1632,18 +1640,29 @@
         "later": "Fechar"
       }
     },
+    "certificates": {
+      "progress_hint": "{current}% concluído ({required}% necessário para download)"
+    },
     "certification": {
-      "rules_heading": "Regras de certificação",
+      "rules_heading": "Regras",
       "deadline_label": "Prazo de certificação",
       "deadline_helper": "Os alunos devem atingir o percentual de conclusão antes desta data e hora (horário local). Deixe em branco para não ter prazo.",
       "threshold_label": "Conclusão mínima (%)",
       "threshold_helper": "Progresso combinado de aulas e exercícios necessário para obter o certificado (0–100). O padrão é 100%.",
-      "email_message_label": "Mensagem de e-mail de certificação",
-      "email_message_helper": "Mensagem opcional mostrada no e-mail quando um aluno atende aos requisitos. Um link para a página do certificado está sempre incluído.",
+      "final_exercise_label": "Exercício final (opcional)",
+      "final_exercise_none": "nenhum",
+      "final_exercise_helper": "Quando definido, os alunos devem atingir pelo menos a pontuação mínima neste exercício (melhores tentativas contam), além do percentual de conclusão acima.",
+      "min_exercise_score_label": "Nota mínima no exercício final (%)",
+      "min_exercise_score_helper": "A pontuação é uma porcentagem do total de pontos possíveis naquele exercício (0–100).",
+      "blocker_progress": "O progresso do seu curso é {current}%; {obrigatório}% é obrigatório.",
+      "blocker_deadline": "O prazo de certificação expirou.",
+      "blocker_no_content": "Este curso não possui lições ou exercícios para serem concluídos.",
+      "blocker_final_not_submitted": "Envie o exercício obrigatório \"{exerciseTitle}\" para se qualificar para o certificado.",
+      "blocker_final_pending": "Sua tentativa em \"{exerciseTitle}\" ainda está sendo avaliada.",
+      "blocker_final_score": "Sua melhor pontuação em \"{exerciseTitle}\" é {bestPercent}%; {requiredPercent}% é obrigatório.",
+      "blocker_final_misconfigured": "O exercício de certificação \"{exerciseTitle}\" não possui pontos configurados; peça ao seu instrutor para consertar.",
+      "email_message_label": "Mensagem de e-mail",
       "email_message_placeholder": "por exemplo Estamos orgulhosos do seu progresso – continue aprendendo!"
-    },
-    "certificates": {
-      "progress_hint": "{current}% concluído ({required}% necessário para download)"
     }
   },
   "courses": {
diff --git a/apps/dashboard/src/lib/utils/translations/ru.json b/apps/dashboard/src/lib/utils/translations/ru.json
index 85283b5d..bdf48fb8 100644
--- a/apps/dashboard/src/lib/utils/translations/ru.json
+++ b/apps/dashboard/src/lib/utils/translations/ru.json
@@ -1118,7 +1118,11 @@
               "answers_required": "Перед отправкой дайте хотя бы один ответ.",
               "checking_submission": "Проверка вашей заявки...",
               "answer_required": "Пожалуйста, ответьте на этот вопрос, прежде чем продолжить.",
-              "instructor_feedback": "Отзывы инструктора"
+              "instructor_feedback": "Отзывы инструктора",
+              "attempt_counter": "Попытка {текущая} из {total}",
+              "previous_try": "Предыдущая попытка",
+              "next_try": "Следующая попытка",
+              "try_again": "Попробуйте еще раз"
             },
             "edit_mode": {
               "delete_modal": "Удалить упражнение",
@@ -1371,7 +1375,11 @@
                 "not_set": "Не установлено",
                 "incorrect_badge": "Неправильный"
               }
-            }
+            },
+            "settings": "Настройки",
+            "settings_allow_multiple": "Разрешить несколько попыток",
+            "settings_allow_multiple_helper": "Учащиеся могут отправлять заявки несколько раз и просматривать предыдущие попытки на экране результатов.",
+            "settings_save": "Сохранить настройки"
           },
           "new_exercise_modal": {
             "heading": "Новое упражнение",
@@ -1632,18 +1640,29 @@
         "later": "Закрыть"
       }
     },
+    "certificates": {
+      "progress_hint": "Выполнено {current}% (для загрузки требуется {required}%)"
+    },
     "certification": {
-      "rules_heading": "Правила сертификации",
+      "rules_heading": "Правила",
       "deadline_label": "Срок сертификации",
       "deadline_helper": "Учащиеся должны достичь процента завершения до этой даты и времени (по местному времени). Оставьте пустым, если срок не установлен.",
       "threshold_label": "Минимальное завершение (%)",
       "threshold_helper": "Для получения сертификата необходим совмещенный прогресс урока и упражнений (0–100). По умолчанию — 100%.",
-      "email_message_label": "Сертификационное письмо по электронной почте",
-      "email_message_helper": "Дополнительное сообщение, отображаемое в электронном письме, когда учащийся соответствует требованиям. Ссылка на страницу сертификата всегда включена.",
+      "final_exercise_label": "Заключительное упражнение (по желанию)",
+      "final_exercise_none": "нет",
+      "final_exercise_helper": "Если этот параметр установлен, учащиеся должны набрать хотя бы минимальный балл за это упражнение (засчитывается лучшая попытка) в дополнение к указанному выше проценту выполнения.",
+      "min_exercise_score_label": "Минимальный балл за финальное упражнение (%)",
+      "min_exercise_score_helper": "Оценка представляет собой процент от общего количества баллов, возможных за это упражнение (0–100).",
+      "blocker_progress": "Ваш прогресс по курсу составляет {current}%; Требуется {required}%.",
+      "blocker_deadline": "Срок сертификации прошел.",
+      "blocker_no_content": "В этом курсе нет уроков или упражнений, которые необходимо выполнить.",
+      "blocker_final_not_submitted": "Чтобы получить сертификат, отправьте необходимое упражнение «{exercisionTitle}».",
+      "blocker_final_pending": "Ваша попытка выполнения \"{exercisionTitle}\" все еще оценивается.",
+      "blocker_final_score": "Ваш лучший результат в «{exercisionTitle}» — {bestPercent}%; Требуется {requiredPercent}%.",
+      "blocker_final_misconfigured": "Для сертификационного упражнения «{exercisionTitle}» не настроены баллы; попросите инструктора это исправить.",
+      "email_message_label": "Сообщение электронной почты",
       "email_message_placeholder": "например Мы гордимся вашим прогрессом — продолжайте учиться!"
-    },
-    "certificates": {
-      "progress_hint": "Выполнено {current}% (для загрузки требуется {required}%)"
     }
   },
   "courses": {
diff --git a/apps/dashboard/src/lib/utils/translations/vi.json b/apps/dashboard/src/lib/utils/translations/vi.json
index 3c5edbc9..30a46d53 100644
--- a/apps/dashboard/src/lib/utils/translations/vi.json
+++ b/apps/dashboard/src/lib/utils/translations/vi.json
@@ -1118,7 +1118,11 @@
               "answers_required": "Vui lòng cung cấp ít nhất một câu trả lời trước khi gửi.",
               "checking_submission": "Đang kiểm tra nội dung gửi của bạn...",
               "answer_required": "Vui lòng trả lời câu hỏi này trước khi tiếp tục.",
-              "instructor_feedback": "Phản hồi của giảng viên"
+              "instructor_feedback": "Phản hồi của giảng viên",
+              "attempt_counter": "Hãy thử {current} trong tổng số {total}",
+              "previous_try": "Lần thử trước",
+              "next_try": "Lần thử tiếp theo",
+              "try_again": "Thử lại"
             },
             "edit_mode": {
               "delete_modal": "Xóa bài tập",
@@ -1371,7 +1375,11 @@
                 "not_set": "Chưa đặt",
                 "incorrect_badge": "sai"
               }
-            }
+            },
+            "settings": "Cài đặt",
+            "settings_allow_multiple": "Cho phép thử nhiều lần",
+            "settings_allow_multiple_helper": "Học sinh có thể gửi nhiều lần và xem lại các lần thử trước đây trên màn hình kết quả.",
+            "settings_save": "Lưu cài đặt"
           },
           "new_exercise_modal": {
             "heading": "Bài tập mới",
@@ -1632,18 +1640,29 @@
         "later": "Đóng"
       }
     },
+    "certificates": {
+      "progress_hint": "Đã hoàn thành {current}% (cần có {required}% để tải xuống)"
+    },
     "certification": {
-      "rules_heading": "Quy tắc chứng nhận",
+      "rules_heading": "Quy tắc",
       "deadline_label": "Thời hạn chứng nhận",
       "deadline_helper": "Học sinh phải đáp ứng tỷ lệ hoàn thành trước ngày này (giờ địa phương). Để trống không có thời hạn.",
       "threshold_label": "Hoàn thành tối thiểu (%)",
       "threshold_helper": "Cần có tiến độ kết hợp của bài học và bài tập để đạt được chứng chỉ (0–100). Mặc định là 100%.",
-      "email_message_label": "Thông báo email chứng nhận",
-      "email_message_helper": "Thông báo tùy chọn hiển thị trong email khi học sinh đáp ứng yêu cầu. Một liên kết đến trang chứng chỉ luôn được bao gồm.",
-      "email_message_placeholder": "ví dụ. Chúng tôi tự hào về sự tiến bộ của bạn - hãy tiếp tục học hỏi!"
-    },
-    "certificates": {
-      "progress_hint": "Đã hoàn thành {current}% (cần có {required}% để tải xuống)"
+      "final_exercise_label": "Bài tập cuối cùng (tùy chọn)",
+      "final_exercise_none": "không có",
+      "final_exercise_helper": "Khi được đặt ra, học sinh phải đạt ít nhất số điểm tối thiểu trong bài tập này (tính số lần thử tốt nhất) bên cạnh tỷ lệ hoàn thành ở trên.",
+      "min_exercise_score_label": "Điểm tối thiểu trong bài tập cuối cùng (%)",
+      "min_exercise_score_helper": "Điểm là tỷ lệ phần trăm của tổng số điểm có thể đạt được trong bài tập đó (0–100).",
+      "blocker_progress": "Tiến độ khóa học của bạn là {current}%; {required}% là bắt buộc.",
+      "blocker_deadline": "Thời hạn chứng nhận đã qua.",
+      "blocker_no_content": "Khóa học này không có bài học hoặc bài tập nào để hoàn thành.",
+      "blocker_final_not_submitted": "Gửi bài tập bắt buộc \"{exerciseTitle}\" để đủ điều kiện nhận chứng chỉ.",
+      "blocker_final_pending": "Nỗ lực của bạn về \"{exerciseTitle}\" vẫn đang được chấm điểm.",
+      "blocker_final_score": "Điểm cao nhất của bạn trong \"{exerciseTitle}\" là {bestPercent}%; {requiredPercent}% là bắt buộc.",
+      "blocker_final_misconfigured": "Bài tập chứng nhận \"{exerciseTitle}\" không có cấu hình điểm nào; nhờ người hướng dẫn khắc phục.",
+      "email_message_label": "Tin nhắn email",
+      "email_message_placeholder": "ví dụ: Chúng tôi tự hào về sự tiến bộ của bạn - hãy tiếp tục học hỏi!"
     }
   },
   "courses": {
diff --git a/apps/dashboard/src/routes/+error.svelte b/apps/dashboard/src/routes/+error.svelte
index 05d51b44..1a312772 100644
--- a/apps/dashboard/src/routes/+error.svelte
+++ b/apps/dashboard/src/routes/+error.svelte
@@ -6,7 +6,8 @@
 
   const isNotFound = $derived(page.status === 404);
 
-  console.error('error message', page.error?.message);
+  console.error('Error message:', page.error?.message);
+  console.error('Error page:', page.url);
 
   function goHome() {
     window.location.href = '/';
diff --git a/apps/dashboard/src/routes/courses/[id]/+layout.svelte b/apps/dashboard/src/routes/courses/[id]/+layout.svelte
index c8f8931d..d699b919 100644
--- a/apps/dashboard/src/routes/courses/[id]/+layout.svelte
+++ b/apps/dashboard/src/routes/courses/[id]/+layout.svelte
@@ -11,6 +11,7 @@
   import { Confetti } from '$features/ui';
   import { courseApi } from '$features/course/api';
   import ContentCreateModal from '$features/course/components/content/content-create-modal.svelte';
+  import CourseCompletionModal from '$features/course/components/ceritficate/course-completion-modal.svelte';
   import { profile } from '$lib/utils/store/user';
   import { isOrgAdmin } from '$lib/utils/store/org';
   import { t } from '$lib/utils/functions/translations';
@@ -98,6 +99,7 @@
   >
     <CourseHeader />
     <ContentCreateModal />
+    <CourseCompletionModal />
 
     {#if !isCourseReady}
       <div class="mx-auto flex h-[calc(100vh-56px)] w-full items-center justify-center">
diff --git a/apps/dashboard/src/routes/courses/[id]/certificates/+page.svelte b/apps/dashboard/src/routes/courses/[id]/certificates/+page.svelte
index 36e5bce5..e7d3d03b 100644
--- a/apps/dashboard/src/routes/courses/[id]/certificates/+page.svelte
+++ b/apps/dashboard/src/routes/courses/[id]/certificates/+page.svelte
@@ -1,10 +1,140 @@
 <script lang="ts">
   import { CertificatesPage } from '$features/course/pages';
-  import { RefreshPageData } from '$features/ui';
   import * as Page from '@cio/ui/base/page';
   import { t } from '$lib/utils/functions/translations';
+  import { courseApi } from '$features/course/api';
+  import type { Course } from '$features/course/utils/types';
+  import { parseCertificateThemeId } from '$features/course/utils/certificate-utils';
+  import { isFreePlan, isOrgAdmin } from '$lib/utils/store/org';
+  import { profile } from '$lib/utils/store/user';
+  import { Button } from '@cio/ui/base/button';
+  import ZapIcon from '@lucide/svelte/icons/zap';
+  import { RefreshPageData, UnsavedChanges } from '$features/ui';
+  import { ZCourseUpdate } from '@cio/utils/validation/course/course';
+  import { validateWithTranslation } from '$lib/utils/validation';
+  import { snackbar } from '$features/ui/snackbar/store';
+  import { openUpgradeModal } from '$lib/utils/functions/org';
+
+  let errors = $state<Record<string, string>>({});
+  let hasUnsavedChanges = $state(false);
+  let savedCertificateState = $state<string | null>(null);
+  let savedCertificateStateCourseId = $state<string | null>(null);
+
+  const certificateTheme = $derived(courseApi.course?.certificate?.theme ?? '');
+
+  const currentCertificateState = $derived.by(() => getCertificateStateSnapshot(courseApi.course));
+
+  const userRole = $derived.by(() => {
+    const user = courseApi.group.people.find((person) => person.profileId === $profile.id);
+    return user ? Number(user.roleId) : null;
+  });
+
+  const canEditCertificates = $derived(!!$isOrgAdmin || (userRole !== null && [1, 2].includes(userRole)));
+
+  function getCertificateFormState(course: Course | null) {
+    if (!course) {
+      return null;
+    }
+
+    return {
+      description: course.description ?? '',
+      certificate: {
+        isDownloadable: course.certificate?.isDownloadable ?? false,
+        theme: parseCertificateThemeId(course.certificate?.theme) ?? 'professional',
+        deadline: course.certificate?.deadline ?? null,
+        threshold: typeof course.certificate?.threshold === 'number' ? course.certificate.threshold : 100,
+        requiredExerciseId: course.certificate?.requiredExerciseId ?? null,
+        exerciseMinScorePercent:
+          typeof course.certificate?.exerciseMinScorePercent === 'number'
+            ? course.certificate.exerciseMinScorePercent
+            : course.certificate?.requiredExerciseId
+              ? 100
+              : null,
+        emailMessage: course.certificate?.emailMessage ?? null
+      }
+    };
+  }
+
+  function getCertificateStateSnapshot(course: Course | null) {
+    const certificateFormState = getCertificateFormState(course);
+    return certificateFormState ? JSON.stringify(certificateFormState) : null;
+  }
+
+  $effect(() => {
+    const course = courseApi.course;
+    const currentSnapshot = getCertificateStateSnapshot(course);
+
+    if (!course?.id || !currentSnapshot) {
+      savedCertificateState = null;
+      savedCertificateStateCourseId = null;
+      hasUnsavedChanges = false;
+      return;
+    }
+
+    if (savedCertificateStateCourseId !== course.id || savedCertificateState === null) {
+      savedCertificateStateCourseId = course.id;
+      savedCertificateState = currentSnapshot;
+    }
+
+    hasUnsavedChanges = currentSnapshot !== savedCertificateState;
+  });
+
+  async function saveCertificate() {
+    if (!courseApi.course) return;
+
+    if ($isFreePlan) {
+      errors = {};
+      openUpgradeModal();
+      return;
+    }
+
+    const updatePayload = {
+      description: courseApi.course.description ?? '',
+      certificate: {
+        isDownloadable: courseApi.course.certificate?.isDownloadable ?? false,
+        theme: certificateTheme || 'professional',
+        deadline: courseApi.course.certificate?.deadline ?? null,
+        threshold:
+          typeof courseApi.course.certificate?.threshold === 'number' ? courseApi.course.certificate.threshold : 100,
+        requiredExerciseId: courseApi.course.certificate?.requiredExerciseId ?? null,
+        exerciseMinScorePercent:
+          typeof courseApi.course.certificate?.exerciseMinScorePercent === 'number'
+            ? courseApi.course.certificate.exerciseMinScorePercent
+            : courseApi.course.certificate?.requiredExerciseId
+              ? 100
+              : null,
+        emailMessage: courseApi.course.certificate?.emailMessage ?? null
+      }
+    };
+
+    const validated = validateWithTranslation(ZCourseUpdate, updatePayload, 'course');
+    if ('errors' in validated) {
+      errors = validated.errors;
+      return;
+    }
+
+    errors = {};
+
+    const updated = await courseApi.update(courseApi.course.id!, validated.data, { showSuccessToast: false });
+    if (updated) {
+      savedCertificateState = getCertificateStateSnapshot(courseApi.course);
+      hasUnsavedChanges = false;
+      snackbar.success('snackbar.course_settings.success.saved');
+    }
+  }
 </script>
 
+<svelte:head>
+  <link rel="preconnect" href="https://fonts.googleapis.com" />
+  <link rel="preconnect" href="https://fonts.gstatic.com" crossorigin="anonymous" />
+  <link
+    href="https://fonts.googleapis.com/css2?family=Qwitcher+Grypen&family=Roboto:wght@300;400;700&display=swap"
+    rel="stylesheet"
+  />
+</svelte:head>
+
+<UnsavedChanges bind:hasUnsavedChanges />
+
 <Page.Root class="mx-auto flex w-[calc(95vw-var(--sidebar-width))]!">
   <Page.Header>
     <Page.HeaderContent>
@@ -13,12 +143,26 @@
       </Page.Title>
     </Page.HeaderContent>
     <Page.Action>
-      <RefreshPageData />
+      <div class="flex w-full justify-end gap-2">
+        {#if canEditCertificates}
+          <Button
+            onclick={saveCertificate}
+            loading={courseApi.isLoading}
+            disabled={courseApi.isLoading || !hasUnsavedChanges}
+          >
+            {#if $isFreePlan}
+              <ZapIcon size={16} class="filled" />
+            {/if}
+            {$t('course.navItem.certificates.save')}
+          </Button>
+        {/if}
+        <RefreshPageData />
+      </div>
     </Page.Action>
   </Page.Header>
   <Page.Body>
     {#snippet child()}
-      <CertificatesPage />
+      <CertificatesPage {errors} />
     {/snippet}
   </Page.Body>
 </Page.Root>
diff --git a/apps/dashboard/src/routes/courses/[id]/exercises/[exerciseId]/+page.server.ts b/apps/dashboard/src/routes/courses/[id]/exercises/[exerciseId]/+page.server.ts
index 4d272dd2..d06b6238 100644
--- a/apps/dashboard/src/routes/courses/[id]/exercises/[exerciseId]/+page.server.ts
+++ b/apps/dashboard/src/routes/courses/[id]/exercises/[exerciseId]/+page.server.ts
@@ -5,7 +5,7 @@ export const load = async ({ params, cookies }) => {
   const exerciseId = params.exerciseId || '';
 
   if (!courseId || !exerciseId) {
-    return { courseId, exerciseId, exercise: null, submissions: [], mySubmission: null };
+    return { courseId, exerciseId, exercise: null, submissions: [], mySubmissions: [] };
   }
 
   const headers = getApiHeaders(cookies);
@@ -26,7 +26,7 @@ export const load = async ({ params, cookies }) => {
     overviewResult.success && overviewResult.data ? overviewResult.data : { mySubmission: [], allSubmissions: [] };
 
   const mySubmissionData = Array.isArray(overview.mySubmission) ? overview.mySubmission : [];
-  const mySubmission = mySubmissionData.length > 0 ? mySubmissionData[0] : null;
+  const mySubmissions = mySubmissionData;
 
   const submissions = Array.isArray(overview.allSubmissions) ? overview.allSubmissions : [];
 
@@ -35,6 +35,6 @@ export const load = async ({ params, cookies }) => {
     exerciseId,
     exercise,
     submissions,
-    mySubmission
+    mySubmissions
   };
 };
diff --git a/apps/dashboard/src/routes/courses/[id]/exercises/[exerciseId]/+page.svelte b/apps/dashboard/src/routes/courses/[id]/exercises/[exerciseId]/+page.svelte
index bcbf87ce..141d5e78 100644
--- a/apps/dashboard/src/routes/courses/[id]/exercises/[exerciseId]/+page.svelte
+++ b/apps/dashboard/src/routes/courses/[id]/exercises/[exerciseId]/+page.svelte
@@ -63,7 +63,8 @@
       isDescriptionDirty: false,
       isDueByDirty: false,
       questions: questions,
-      totalSubmissions: 0
+      totalSubmissions: 0,
+      allowMultipleAttempts: !!exercise.allowMultipleAttempts
     });
     questionnaireMetaData.update((m) => ({ ...m, exerciseId: data.exerciseId }));
   });
@@ -84,7 +85,7 @@
       goBack={() => goto(resolve(path, {}))}
       isFetching={false}
       submissions={data.submissions ?? []}
-      mySubmission={data.mySubmission ?? null}
+      mySubmissions={data.mySubmissions ?? []}
     />
   {/if}
 </Page.Root>
diff --git a/apps/dashboard/src/routes/courses/[id]/settings/+page.svelte b/apps/dashboard/src/routes/courses/[id]/settings/+page.svelte
index 12aeac1e..38d6688b 100644
--- a/apps/dashboard/src/routes/courses/[id]/settings/+page.svelte
+++ b/apps/dashboard/src/routes/courses/[id]/settings/+page.svelte
@@ -9,6 +9,7 @@
 
   let settingsComponent: CourseSettingsPage | null = $state(null);
   let isSaving = $state(false);
+  let hasUnsavedChanges = $state(false);
   let { data } = $props();
 
   async function handleSave() {
@@ -30,7 +31,7 @@
     </Page.HeaderContent>
     <Page.Action>
       <div class="flex items-center gap-2">
-        <Button variant="secondary" loading={isSaving} onclick={handleSave}>
+        <Button variant="secondary" loading={isSaving} disabled={isSaving || !hasUnsavedChanges} onclick={handleSave}>
           {$t('course.navItem.settings.save')}
         </Button>
         <RefreshPageData disabled={isSaving} onRefresh={() => courseApi.refreshCourse(data.courseId, $profile.id)} />
@@ -39,7 +40,7 @@
   </Page.Header>
   <Page.Body>
     {#snippet child()}
-      <CourseSettingsPage bind:this={settingsComponent} />
+      <CourseSettingsPage bind:this={settingsComponent} bind:hasUnsavedChanges />
     {/snippet}
   </Page.Body>
 </Page.Root>
diff --git a/apps/dashboard/src/routes/org/[slug]/audience/+page.server.ts b/apps/dashboard/src/routes/org/[slug]/audience/+page.server.ts
index 00972280..4220b719 100644
--- a/apps/dashboard/src/routes/org/[slug]/audience/+page.server.ts
+++ b/apps/dashboard/src/routes/org/[slug]/audience/+page.server.ts
@@ -1,30 +1,41 @@
 import { classroomio, getApiHeaders } from '$lib/utils/services/api';
+import {
+  DEFAULT_ORG_AUDIENCE_QUERY,
+  getAudienceQueryFromSearchParams,
+  toAudienceRequestQuery
+} from '$lib/features/org/utils/audience-query-utils';
 
-export const load = async ({ parent, cookies }) => {
+export const load = async ({ parent, cookies, url }) => {
   const { orgId } = await parent();
 
   if (!orgId) {
     return {
       audience: [],
+      pagination: null,
+      query: DEFAULT_ORG_AUDIENCE_QUERY,
       courses: []
     };
   }
 
   const headers = getApiHeaders(cookies, orgId);
+  const query = getAudienceQueryFromSearchParams(url.searchParams);
 
   const [audienceResponse, coursesResponse] = await Promise.all([
-    classroomio.organization.audience.$get({}, headers),
+    classroomio.organization.audience.$get({ query: toAudienceRequestQuery(query)! }, headers),
     classroomio.organization.courses.$get({ query: { tags: undefined } }, headers)
   ]);
 
   const audienceData = await audienceResponse.json();
   const audience = audienceData.success ? audienceData.data : [];
+  const pagination = audienceData.success ? audienceData.pagination : null;
 
   const coursesData = await coursesResponse.json();
   const courses = coursesData.success ? coursesData.data : [];
 
   return {
     audience,
+    pagination,
+    query,
     courses
   };
 };
diff --git a/apps/dashboard/src/routes/org/[slug]/audience/+page.svelte b/apps/dashboard/src/routes/org/[slug]/audience/+page.svelte
index 01d735af..54834807 100644
--- a/apps/dashboard/src/routes/org/[slug]/audience/+page.svelte
+++ b/apps/dashboard/src/routes/org/[slug]/audience/+page.svelte
@@ -17,7 +17,7 @@
     isLoading = false;
   }
 
-  const audienceLength = $derived(data.audience?.length || 0);
+  const audienceLength = $derived(data.pagination?.total || 0);
 </script>
 
 <svelte:head>
@@ -47,7 +47,7 @@
   </Page.Header>
   <Page.Body>
     {#snippet child()}
-      <AudiencePage audience={data.audience} courses={data.courses} />
+      <AudiencePage audience={data.audience} pagination={data.pagination} query={data.query} courses={data.courses} />
     {/snippet}
   </Page.Body>
 </Page.Root>
diff --git a/apps/dashboard/src/routes/org/[slug]/courses/+page.server.ts b/apps/dashboard/src/routes/org/[slug]/courses/+page.server.ts
index d159d66c..11cb3975 100644
--- a/apps/dashboard/src/routes/org/[slug]/courses/+page.server.ts
+++ b/apps/dashboard/src/routes/org/[slug]/courses/+page.server.ts
@@ -9,11 +9,6 @@ export const load = async ({ parent, locals, cookies, url }) => {
   const { orgId } = await parent();
 
   if (!orgId || !locals.user?.id) {
-    const loadMs = Math.round((performance.now() - loadStart) * 100) / 100;
-    console.log(
-      `[org/[slug]/courses +page.server] load: ${loadMs}ms (skipped: no orgId or user) | PUBLIC_IS_SELFHOSTED=${PUBLIC_IS_SELFHOSTED}`
-    );
-
     return {
       courses: []
     };
diff --git a/packages/db/src/queries/course/certification-exercise.ts b/packages/db/src/queries/course/certification-exercise.ts
new file mode 100644
index 00000000..3d414a54
--- /dev/null
+++ b/packages/db/src/queries/course/certification-exercise.ts
@@ -0,0 +1,80 @@
+import * as schema from '@db/schema';
+
+import { and, asc, eq, or, sql } from 'drizzle-orm';
+
+import { db } from '@db/drizzle';
+
+/**
+ * Whether an exercise is part of a course (direct course_id or via lesson).
+ */
+export async function exerciseBelongsToCourse(exerciseId: string, courseId: string): Promise<boolean> {
+  try {
+    const [row] = await db
+      .select({ id: schema.exercise.id })
+      .from(schema.exercise)
+      .leftJoin(schema.lesson, eq(schema.exercise.lessonId, schema.lesson.id))
+      .where(
+        and(
+          eq(schema.exercise.id, exerciseId),
+          or(eq(schema.exercise.courseId, courseId), eq(schema.lesson.courseId, courseId))
+        )
+      )
+      .limit(1);
+
+    return !!row;
+  } catch (error) {
+    console.error('exerciseBelongsToCourse error:', error);
+    throw new Error(
+      `Failed to check exercise belongs to course: ${error instanceof Error ? error.message : 'Unknown error'}`
+    );
+  }
+}
+
+export async function getExerciseTitleAndMaxPoints(exerciseId: string): Promise<{ title: string; maxPoints: number }> {
+  try {
+    const [ex] = await db
+      .select({ title: schema.exercise.title })
+      .from(schema.exercise)
+      .where(eq(schema.exercise.id, exerciseId))
+      .limit(1);
+
+    if (!ex) {
+      return { title: '', maxPoints: 0 };
+    }
+
+    const [sumRow] = await db
+      .select({
+        maxPoints: sql<number>`coalesce(sum(${schema.question.points}), 0)::float`
+      })
+      .from(schema.question)
+      .where(eq(schema.question.exerciseId, exerciseId));
+
+    return { title: ex.title ?? '', maxPoints: Number(sumRow?.maxPoints ?? 0) };
+  } catch (error) {
+    console.error('getExerciseTitleAndMaxPoints error:', error);
+    throw new Error(
+      `Failed to get exercise title and max points: ${error instanceof Error ? error.message : 'Unknown error'}`
+    );
+  }
+}
+
+export async function getStudentSubmissionsForExercise(
+  groupMemberId: string,
+  exerciseId: string
+): Promise<Array<{ total: number | null; gradingState: string | null }>> {
+  try {
+    return db
+      .select({
+        total: schema.submission.total,
+        gradingState: schema.submission.gradingState
+      })
+      .from(schema.submission)
+      .where(and(eq(schema.submission.exerciseId, exerciseId), eq(schema.submission.submittedBy, groupMemberId)))
+      .orderBy(asc(schema.submission.createdAt));
+  } catch (error) {
+    console.error('getStudentSubmissionsForExercise error:', error);
+    throw new Error(
+      `Failed to list submissions for exercise: ${error instanceof Error ? error.message : 'Unknown error'}`
+    );
+  }
+}
diff --git a/packages/db/src/queries/course/course.ts b/packages/db/src/queries/course/course.ts
index ab691e67..e0edfaca 100644
--- a/packages/db/src/queries/course/course.ts
+++ b/packages/db/src/queries/course/course.ts
@@ -426,11 +426,20 @@ export async function getCourseProgress(
   lessonsCompleted: number;
   exercisesCount: number;
   exercisesCompleted: number;
+  groupMemberId: string | null;
+  roleId: number | null;
+  certificateEarnedAt: string | null;
+  certificationEmailSentAt: string | null;
 }> {
   try {
     // Get the groupmember ID for this profile in the course
     const groupMemberResult = await db
-      .select({ id: schema.groupmember.id })
+      .select({
+        id: schema.groupmember.id,
+        roleId: schema.groupmember.roleId,
+        certificateEarnedAt: schema.groupmember.certificateEarnedAt,
+        certificationEmailSentAt: schema.groupmember.certificationEmailSentAt
+      })
       .from(schema.groupmember)
       .innerJoin(schema.course, eq(schema.course.groupId, schema.groupmember.groupId))
       .where(and(eq(schema.course.id, courseId), eq(schema.groupmember.profileId, profileId)))
@@ -442,64 +451,64 @@ export async function getCourseProgress(
         lessonsCount: 0,
         lessonsCompleted: 0,
         exercisesCount: 0,
-        exercisesCompleted: 0
+        exercisesCompleted: 0,
+        groupMemberId: null,
+        roleId: null,
+        certificateEarnedAt: null,
+        certificationEmailSentAt: null
       };
     }
 
     const groupMemberId = groupMemberResult[0].id;
+    const roleId = groupMemberResult[0].roleId;
+    const certificateEarnedAt = groupMemberResult[0].certificateEarnedAt ?? null;
+    const certificationEmailSentAt = groupMemberResult[0].certificationEmailSentAt ?? null;
 
-    // Get all lessons for the course
-    const lessons = await db
-      .select({ id: schema.lesson.id })
-      .from(schema.lesson)
-      .where(eq(schema.lesson.courseId, courseId));
+    const [lessons, completedLessons, exercises, [completedRow]] = await Promise.all([
+      db.select({ id: schema.lesson.id }).from(schema.lesson).where(eq(schema.lesson.courseId, courseId)),
 
-    const lessonsCount = lessons.length;
+      db
+        .select({ id: schema.lessonCompletion.id })
+        .from(schema.lessonCompletion)
+        .innerJoin(schema.lesson, eq(schema.lessonCompletion.lessonId, schema.lesson.id))
+        .where(
+          and(
+            eq(schema.lesson.courseId, courseId),
+            eq(schema.lessonCompletion.profileId, profileId),
+            eq(schema.lessonCompletion.isComplete, true)
+          )
+        ),
 
-    // Get completed lessons (lesson_completion where is_complete = true and profile_id matches)
-    const completedLessons = await db
-      .select({ id: schema.lessonCompletion.id })
-      .from(schema.lessonCompletion)
-      .innerJoin(schema.lesson, eq(schema.lessonCompletion.lessonId, schema.lesson.id))
-      .where(
-        and(
-          eq(schema.lesson.courseId, courseId),
-          eq(schema.lessonCompletion.profileId, profileId),
-          eq(schema.lessonCompletion.isComplete, true)
+      db
+        .select({ id: schema.exercise.id })
+        .from(schema.exercise)
+        .leftJoin(schema.lesson, eq(schema.exercise.lessonId, schema.lesson.id))
+        .where(or(eq(schema.exercise.courseId, courseId), eq(schema.lesson.courseId, courseId))),
+
+      db
+        .select({
+          exercisesCompleted: sql<number>`count(distinct ${schema.exercise.id})::int`
+        })
+        .from(schema.submission)
+        .innerJoin(schema.exercise, eq(schema.submission.exerciseId, schema.exercise.id))
+        .leftJoin(schema.lesson, eq(schema.exercise.lessonId, schema.lesson.id))
+        .where(
+          and(
+            or(eq(schema.exercise.courseId, courseId), eq(schema.lesson.courseId, courseId)),
+            eq(schema.submission.submittedBy, groupMemberId)
+          )
         )
-      );
-
-    const lessonsCompleted = completedLessons.length;
-
-    // Get all exercises for the course (legacy lesson_id support)
-    const exercises = await db
-      .select({ id: schema.exercise.id })
-      .from(schema.exercise)
-      .leftJoin(schema.lesson, eq(schema.exercise.lessonId, schema.lesson.id))
-      .where(or(eq(schema.exercise.courseId, courseId), eq(schema.lesson.courseId, courseId)));
-
-    const exercisesCount = exercises.length;
-
-    // Get completed exercises (submissions where submitted_by = groupmember.id)
-    const completedExercises = await db
-      .select({ id: schema.submission.id })
-      .from(schema.submission)
-      .innerJoin(schema.exercise, eq(schema.submission.exerciseId, schema.exercise.id))
-      .leftJoin(schema.lesson, eq(schema.exercise.lessonId, schema.lesson.id))
-      .where(
-        and(
-          or(eq(schema.exercise.courseId, courseId), eq(schema.lesson.courseId, courseId)),
-          eq(schema.submission.submittedBy, groupMemberId)
-        )
-      );
-
-    const exercisesCompleted = completedExercises.length;
+    ]);
 
     return {
-      lessonsCount,
-      lessonsCompleted,
-      exercisesCount,
-      exercisesCompleted
+      lessonsCount: lessons.length,
+      lessonsCompleted: completedLessons.length,
+      exercisesCount: exercises.length,
+      exercisesCompleted: completedRow?.exercisesCompleted ?? 0,
+      groupMemberId,
+      roleId,
+      certificateEarnedAt,
+      certificationEmailSentAt
     };
   } catch (error) {
     console.error('getCourseProgress error:', error);
@@ -507,6 +516,46 @@ export async function getCourseProgress(
   }
 }
 
+/** Course + org fields needed for certification email and threshold rules */
+export type TCourseCertificationRow = {
+  certificate: {
+    isDownloadable?: boolean;
+    theme?: string;
+    deadline?: string | null;
+    threshold?: number;
+    requiredExerciseId?: string | null;
+    exerciseMinScorePercent?: number | null;
+    emailMessage?: string | null;
+  } | null;
+  title: string;
+  orgSiteName: string | null;
+  orgName: string;
+};
+
+export async function getCourseCertificationRow(courseId: string): Promise<TCourseCertificationRow | null> {
+  try {
+    const [row] = await db
+      .select({
+        certificate: schema.course.certificate,
+        title: schema.course.title,
+        orgSiteName: schema.organization.siteName,
+        orgName: schema.organization.name
+      })
+      .from(schema.course)
+      .innerJoin(schema.group, eq(schema.course.groupId, schema.group.id))
+      .innerJoin(schema.organization, eq(schema.group.organizationId, schema.organization.id))
+      .where(eq(schema.course.id, courseId))
+      .limit(1);
+
+    return row ?? null;
+  } catch (error) {
+    console.error('getCourseCertificationRow error:', error);
+    throw new Error(
+      `Failed to get course certification row: ${error instanceof Error ? error.message : 'Unknown error'}`
+    );
+  }
+}
+
 interface GetOrgCoursesOptions {
   /** Organization ID (required) */
   orgId: string;
diff --git a/packages/db/src/queries/course/people.ts b/packages/db/src/queries/course/people.ts
index 7aeca7fc..39a6e789 100644
--- a/packages/db/src/queries/course/people.ts
+++ b/packages/db/src/queries/course/people.ts
@@ -307,3 +307,39 @@ export async function getProfileByGroupMemberId(groupMemberId: string): Promise<
     );
   }
 }
+
+/**
+ * Sets when the learner first met certification threshold for this course membership.
+ */
+export async function setMemberCertificateEarned(memberId: string, earnedAt: string): Promise<TGroupmember | null> {
+  try {
+    const [updated] = await db
+      .update(schema.groupmember)
+      .set({ certificateEarnedAt: earnedAt })
+      .where(eq(schema.groupmember.id, memberId))
+      .returning();
+    return updated ?? null;
+  } catch (error) {
+    console.error('setMemberCertificateEarned error:', error);
+    throw new Error(`Failed to set certificate earned: ${error instanceof Error ? error.message : 'Unknown error'}`);
+  }
+}
+
+/**
+ * Records that the certification congratulations email was sent.
+ */
+export async function setMemberCertificationEmailSent(memberId: string, sentAt: string): Promise<TGroupmember | null> {
+  try {
+    const [updated] = await db
+      .update(schema.groupmember)
+      .set({ certificationEmailSentAt: sentAt })
+      .where(eq(schema.groupmember.id, memberId))
+      .returning();
+    return updated ?? null;
+  } catch (error) {
+    console.error('setMemberCertificationEmailSent error:', error);
+    throw new Error(
+      `Failed to set certification email sent: ${error instanceof Error ? error.message : 'Unknown error'}`
+    );
+  }
+}
diff --git a/packages/db/src/queries/organization/organization.ts b/packages/db/src/queries/organization/organization.ts
index 0939b6b6..3fe7f11a 100644
--- a/packages/db/src/queries/organization/organization.ts
+++ b/packages/db/src/queries/organization/organization.ts
@@ -8,10 +8,11 @@ import type {
   TOrganization,
   TOrganizationPlan
 } from '@db/types';
-import { and, eq, inArray, or, sql } from 'drizzle-orm';
+import { and, asc, count, desc, eq, ilike, inArray, or, sql } from 'drizzle-orm';
 
 import { ROLE } from '@cio/utils/constants';
 import { db, type DbOrTxClient } from '@db/drizzle';
+import type { TAudienceSortBy, TAudienceSortOrder } from '@cio/utils/validation/organization';
 
 export function getOrgIdBySiteName(siteName: string) {
   return db.select().from(schema.organization).where(eq(schema.organization.siteName, siteName)).limit(1);
@@ -246,6 +247,27 @@ export const deleteOrganizationMember = async (orgId: string, memberId: number)
   return deleted || null;
 };
 
+/**
+ * Deletes a student organization member by ID
+ * @param orgId Organization ID
+ * @param memberId Member ID to delete
+ * @returns Deleted member or null if not found
+ */
+export const deleteOrganizationAudienceMember = async (orgId: string, memberId: number) => {
+  const [deleted] = await db
+    .delete(schema.organizationmember)
+    .where(
+      and(
+        eq(schema.organizationmember.organizationId, orgId),
+        eq(schema.organizationmember.id, memberId),
+        eq(schema.organizationmember.roleId, ROLE.STUDENT)
+      )
+    )
+    .returning();
+
+  return deleted || null;
+};
+
 /**
  * Checks if a user is an admin of an organization
  * @param orgId Organization ID
@@ -349,38 +371,93 @@ export const getOrganizationTeam = async (orgId: string) => {
  * Includes invited members without a profile (LEFT JOIN profile).
  * Row id is organizationmember.id; use profileId for profile-backed actions when present.
  */
-export const getOrganizationAudience = async (orgId: string) => {
+type GetOrganizationAudienceOptions = {
+  page?: number;
+  limit?: number;
+  search?: string;
+  sortBy?: TAudienceSortBy;
+  sortOrder?: TAudienceSortOrder;
+};
+
+export const getOrganizationAudience = async (orgId: string, options: GetOrganizationAudienceOptions = {}) => {
+  const page = options.page && options.page > 0 ? options.page : 1;
+  const limit = options.limit && options.limit > 0 ? Math.min(options.limit, 100) : 20;
+  const offset = (page - 1) * limit;
+  const search = options.search?.trim();
+  const sortBy = options.sortBy ?? 'createdAt';
+  const sortOrder = options.sortOrder ?? 'desc';
+
+  const audienceNameSql = sql<string>`COALESCE(NULLIF(${schema.profile.fullname}, ''), ${schema.profile.email}, ${schema.organizationmember.email})`;
+  const audienceEmailSql = sql<string>`COALESCE(${schema.profile.email}, ${schema.organizationmember.email})`;
+  const audienceCreatedAtSql = sql<string>`COALESCE(${schema.profile.createdAt}, ${schema.organizationmember.createdAt})`;
+
+  const conditions = [
+    eq(schema.organizationmember.organizationId, orgId),
+    eq(schema.organizationmember.roleId, ROLE.STUDENT)
+  ];
+
+  if (search) {
+    const searchValue = `%${search}%`;
+    conditions.push(
+      or(
+        ilike(schema.profile.fullname, searchValue),
+        ilike(schema.profile.email, searchValue),
+        ilike(schema.organizationmember.email, searchValue)
+      )!
+    );
+  }
+
+  const whereClause = and(...conditions);
+  const [totalRow] = await db
+    .select({ count: count(schema.organizationmember.id) })
+    .from(schema.organizationmember)
+    .leftJoin(schema.profile, eq(schema.organizationmember.profileId, schema.profile.id))
+    .where(whereClause);
+
+  const total = Number(totalRow?.count ?? 0);
+
+  const orderByExpression =
+    sortBy === 'name' ? audienceNameSql : sortBy === 'email' ? audienceEmailSql : audienceCreatedAtSql;
+  const orderedExpression = sortOrder === 'asc' ? asc(orderByExpression) : desc(orderByExpression);
+
   const result = await db
     .select({
       memberId: schema.organizationmember.id,
       profileId: schema.profile.id,
       fullname: schema.profile.fullname,
-      email: sql<string>`COALESCE(${schema.profile.email}, ${schema.organizationmember.email})`.as('email'),
+      email: audienceEmailSql.as('email'),
       avatarUrl: schema.profile.avatarUrl,
       profileCreatedAt: schema.profile.createdAt,
       memberCreatedAt: schema.organizationmember.createdAt
     })
     .from(schema.organizationmember)
     .leftJoin(schema.profile, eq(schema.organizationmember.profileId, schema.profile.id))
-    .where(
-      and(eq(schema.organizationmember.organizationId, orgId), eq(schema.organizationmember.roleId, ROLE.STUDENT))
-    );
+    .where(whereClause)
+    .orderBy(orderedExpression, desc(schema.organizationmember.id))
+    .limit(limit)
+    .offset(offset);
 
-  return result.map((row) => {
-    const email = row.email?.trim() ?? '';
-    const name = row.fullname?.trim() || (email.includes('@') ? email.split('@')[0] : email) || '';
-    const createdAtRaw = row.profileId ? row.profileCreatedAt : row.memberCreatedAt;
-    const createdAt = createdAtRaw ? new Date(createdAtRaw).toDateString() : '';
+  return {
+    items: result.map((row) => {
+      const email = row.email?.trim() ?? '';
+      const name = row.fullname?.trim() || (email.includes('@') ? email.split('@')[0] : email) || '';
+      const createdAtRaw = row.profileId ? row.profileCreatedAt : row.memberCreatedAt;
+      const createdAt = createdAtRaw ? new Date(createdAtRaw).toDateString() : '';
 
-    return {
-      id: row.memberId,
-      profileId: row.profileId ?? null,
-      name,
-      email,
-      avatarUrl: row.avatarUrl || '',
-      createdAt
-    };
-  });
+      return {
+        id: row.memberId,
+        profileId: row.profileId ?? null,
+        name,
+        email,
+        avatarUrl: row.avatarUrl || '',
+        createdAt
+      };
+    }),
+    page,
+    limit,
+    total,
+    totalPages: Math.max(1, Math.ceil(total / limit))
+  };
 };
 
 /**
@@ -760,7 +837,8 @@ export async function getOrgMembersByProfileIds(orgId: string, profileIds: strin
     return db
       .select({
         profileId: schema.organizationmember.profileId,
-        email: schema.organizationmember.email
+        email: schema.organizationmember.email,
+        roleId: schema.organizationmember.roleId
       })
       .from(schema.organizationmember)
       .where(
@@ -776,3 +854,51 @@ export async function getOrgMembersByProfileIds(orgId: string, profileIds: strin
     );
   }
 }
+
+export type TOrganizationMemberByEmail = {
+  normalizedEmail: string;
+  profileId: string | null;
+  roleId: number;
+};
+
+/**
+ * Resolves organization members matching normalized emails (profile email or organizationmember.email).
+ */
+export async function getOrganizationMembersByNormalizedEmails(
+  orgId: string,
+  emails: string[]
+): Promise<TOrganizationMemberByEmail[]> {
+  try {
+    if (emails.length === 0) return [];
+
+    const normalized = [...new Set(emails.map((e) => e.toLowerCase().trim()).filter(Boolean))];
+
+    const rows = await db
+      .select({
+        roleId: schema.organizationmember.roleId,
+        profileId: schema.organizationmember.profileId,
+        matchEmail: sql<string>`lower(trim(coalesce(${schema.profile.email}, ${schema.organizationmember.email})))`.as(
+          'matchEmail'
+        )
+      })
+      .from(schema.organizationmember)
+      .leftJoin(schema.profile, eq(schema.organizationmember.profileId, schema.profile.id))
+      .where(
+        and(
+          eq(schema.organizationmember.organizationId, orgId),
+          inArray(sql`lower(trim(coalesce(${schema.profile.email}, ${schema.organizationmember.email})))`, normalized)
+        )
+      );
+
+    return rows.map((row) => ({
+      normalizedEmail: row.matchEmail,
+      profileId: row.profileId,
+      roleId: row.roleId
+    }));
+  } catch (error) {
+    console.error('getOrganizationMembersByNormalizedEmails error:', error);
+    throw new Error(
+      `Failed to get organization members by emails: ${error instanceof Error ? error.message : 'Unknown error'}`
+    );
+  }
+}
diff --git a/packages/db/src/queries/submission/submission.ts b/packages/db/src/queries/submission/submission.ts
index cb4f7623..b8173fad 100644
--- a/packages/db/src/queries/submission/submission.ts
+++ b/packages/db/src/queries/submission/submission.ts
@@ -1,7 +1,7 @@
 import * as schema from '@db/schema';
 
 import type { TNewQuestionAnswer, TNewSubmission, TQuestionAnswer, TSubmission } from '@db/types';
-import { and, db, eq, inArray } from '@db/drizzle';
+import { and, count, db, eq, inArray, sql } from '@db/drizzle';
 
 /**
  * Gets a submission by ID
@@ -24,6 +24,23 @@ export async function getSubmissionById(submissionId: string): Promise<TSubmissi
   }
 }
 
+export async function hasSubmission(exerciseId: string, submittedBy: string): Promise<boolean> {
+  try {
+    const [result] = await db
+      .select({ total: count() })
+      .from(schema.submission)
+      .where(and(eq(schema.submission.exerciseId, exerciseId), eq(schema.submission.submittedBy, submittedBy)))
+      .limit(1);
+
+    return (result?.total ?? 0) > 0;
+  } catch (error) {
+    console.error('hasSubmission error:', error);
+    throw new Error(
+      `Failed to check submission existence: ${error instanceof Error ? error.message : 'Unknown error'}`
+    );
+  }
+}
+
 /**
  * Gets submissions by course ID with full related data (answers, profile, etc.)
  * @param courseId Course ID
@@ -266,6 +283,21 @@ export async function upsertQuestionAnswer(data: TNewQuestionAnswer): Promise<TQ
   }
 }
 
+export async function insertQuestionAnswersBatch(rows: TNewQuestionAnswer[]): Promise<TQuestionAnswer[]> {
+  if (rows.length === 0) {
+    return [];
+  }
+
+  try {
+    return db.insert(schema.questionAnswer).values(rows).returning();
+  } catch (error) {
+    console.error('insertQuestionAnswersBatch error:', error);
+    throw new Error(
+      `Failed to insert question answers batch: ${error instanceof Error ? error.message : 'Unknown error'}`
+    );
+  }
+}
+
 /**
  * Updates a question answer
  * @param submissionId Submission ID
@@ -311,13 +343,15 @@ export async function updateSubmissionGrades(
 ): Promise<TSubmission | null> {
   try {
     return await db.transaction(async (tx) => {
-      for (const { questionId, points } of data.answers) {
-        await tx
-          .update(schema.questionAnswer)
-          .set({ point: points })
-          .where(
-            and(eq(schema.questionAnswer.submissionId, submissionId), eq(schema.questionAnswer.questionId, questionId))
-          );
+      if (data.answers.length > 0) {
+        const valueRows = data.answers.map((a) => sql`(${a.questionId}::bigint, ${a.points}::bigint)`);
+        await tx.execute(sql`
+          UPDATE question_answer AS qa
+          SET point = v.point
+          FROM (VALUES ${sql.join(valueRows, sql`, `)}) AS v(question_id, point)
+          WHERE qa.submission_id = ${submissionId}
+            AND qa.question_id = v.question_id
+        `);
       }
 
       const submissionData: Partial<TSubmission> = {
diff --git a/packages/db/src/schema.ts b/packages/db/src/schema.ts
index 5eccab72..c196220b 100644
--- a/packages/db/src/schema.ts
+++ b/packages/db/src/schema.ts
@@ -587,13 +587,15 @@ export const course = pgTable(
     currency: varchar().default('USD').notNull(),
     bannerImage: text('banner_image'),
     isPublished: boolean('is_published').default(false),
-    isCertificateDownloadable: boolean('is_certificate_downloadable').default(false),
-    certificateTheme: text('certificate_theme'),
-    certificationDeadline: timestamp('certification_deadline', { withTimezone: true, mode: 'string' }),
-    certificationThreshold: integer('certification_threshold').default(100),
-    certificationRequiredExerciseId: uuid('certification_required_exercise_id'),
-    certificationExerciseMinScorePercent: integer('certification_exercise_min_score_percent'),
-    certificationEmailMessage: text('certification_email_message'),
+    certificate: jsonb().default({}).$type<{
+      isDownloadable?: boolean;
+      theme?: string;
+      deadline?: string | null;
+      threshold?: number;
+      requiredExerciseId?: string | null;
+      exerciseMinScorePercent?: number | null;
+      emailMessage?: string | null;
+    }>(),
     status: text().default('ACTIVE').notNull(),
     type: courseType().default('LIVE_CLASS')
   },
diff --git a/packages/db/src/scripts/seed.ts b/packages/db/src/scripts/seed.ts
index 20c3aff2..e4fa7dca 100644
--- a/packages/db/src/scripts/seed.ts
+++ b/packages/db/src/scripts/seed.ts
@@ -10,6 +10,7 @@ import { seedGroupmembers } from '@db/utils/seed/groupmember';
 import { type LessonTemplate, seedLessons } from '@db/utils/seed/lesson';
 import { seedOrganization } from '@db/utils/seed/organization';
 import { seedOrganizationMember } from '@db/utils/seed/organizationmember';
+import { seedEnterpriseOrganizationPlan } from '@db/utils/seed/organizationPlan';
 import { seedProfile } from '@db/utils/seed/profile';
 import { seedQuestionTypes } from '@db/utils/seed/questionType';
 import { seedQuestions } from '@db/utils/seed/question';
@@ -28,6 +29,9 @@ const MVC_COURSE_ID = '98e6e798-f0bd-4f9d-a6f5-ce0816a4f97e';
 const REACT_COURSE_ID = '16e3bc8d-5d1b-4708-988e-93abae288ccf';
 const PANDAS_COURSE_ID = 'f0a85d18-aff4-412f-b8e6-3b34ef098dce';
 const STUDENT_USER_ID = '0c256e75-aa40-4f62-8d30-0217ca1c60d9';
+const ENTERPRISE_ORG_ID = '2b8f4a1c-6d3e-4b2a-9f7e-1c4d8a6e9b0f';
+const ENTERPRISE_ADMIN_USER_ID = '3c9052de-7e4f-4c3a-8d8e-2d5e9b7f1a3c';
+const ENTERPRISE_STUDENT_USER_ID = '4da163ef-8050-4d4b-9c9f-3e6fac802b4d';
 
 // Parse command line arguments
 function parseFlags(): Set<string> {
@@ -62,6 +66,7 @@ Flags:
   --accounts                  Seed accounts
   --organizations             Seed organizations
   --organization-members      Seed organization members
+  --organization-plan         Seed enterprise plan for Coursera Test org
   --groups                    Seed groups
   --group-members             Seed group members
   --courses                  Seed courses
@@ -108,11 +113,22 @@ const seedFunctions = {
   },
   organizations: async () => {
     console.log('📝 Seeding organizations...');
-    await seedOrganization({ testOrgId: TEST_ORG_ID });
+    await seedOrganization({ testOrgId: TEST_ORG_ID, enterpriseOrgId: ENTERPRISE_ORG_ID });
   },
   'organization-members': async () => {
     console.log('📝 Seeding organization members...');
-    await seedOrganizationMember({ testOrgId: TEST_ORG_ID, adminUserId: ADMIN_USER_ID });
+    await seedOrganizationMember({
+      testOrgId: TEST_ORG_ID,
+      adminUserId: ADMIN_USER_ID,
+      studentUserId: STUDENT_USER_ID,
+      enterpriseOrgId: ENTERPRISE_ORG_ID,
+      enterpriseAdminUserId: ENTERPRISE_ADMIN_USER_ID,
+      enterpriseStudentUserId: ENTERPRISE_STUDENT_USER_ID
+    });
+  },
+  'organization-plan': async () => {
+    console.log('📝 Seeding enterprise organization plan...');
+    await seedEnterpriseOrganizationPlan({ enterpriseOrgId: ENTERPRISE_ORG_ID });
   },
   groups: async () => {
     console.log('📝 Seeding groups...');
@@ -205,6 +221,7 @@ async function seed() {
       await seedFunctions.accounts();
       await seedFunctions.organizations();
       await seedFunctions['organization-members']();
+      await seedFunctions['organization-plan']();
       await seedFunctions.groups();
       await seedFunctions['group-members']();
       await seedFunctions.courses();
@@ -225,6 +242,7 @@ async function seed() {
         'accounts',
         'organizations',
         'organization-members',
+        'organization-plan',
         'groups',
         'group-members',
         'courses',
diff --git a/packages/db/src/utils/seed/course.ts b/packages/db/src/utils/seed/course.ts
index f55f31ca..1add451c 100644
--- a/packages/db/src/utils/seed/course.ts
+++ b/packages/db/src/utils/seed/course.ts
@@ -39,7 +39,10 @@ export async function seedCourses({ mvcGroupId, reactGroupId, pandasGroupId }: S
       cost: 0,
       currency: 'NGN',
       isPublished: true,
-      isCertificateDownloadable: false,
+      certificate: {
+        isDownloadable: false,
+        theme: 'professional'
+      },
       status: 'ACTIVE'
     },
     {
@@ -63,7 +66,10 @@ export async function seedCourses({ mvcGroupId, reactGroupId, pandasGroupId }: S
       cost: 0,
       currency: 'NGN',
       isPublished: true,
-      isCertificateDownloadable: false,
+      certificate: {
+        isDownloadable: false,
+        theme: 'professional'
+      },
       status: 'ACTIVE'
     },
     {
@@ -87,7 +93,10 @@ export async function seedCourses({ mvcGroupId, reactGroupId, pandasGroupId }: S
       cost: 0,
       currency: 'NGN',
       isPublished: true,
-      isCertificateDownloadable: false,
+      certificate: {
+        isDownloadable: false,
+        theme: 'professional'
+      },
       status: 'ACTIVE'
     }
   ].filter((c) => !existingCourseIds.includes(c.id));
diff --git a/packages/db/src/utils/seed/organization.ts b/packages/db/src/utils/seed/organization.ts
index 6b1dc37e..243aefba 100644
--- a/packages/db/src/utils/seed/organization.ts
+++ b/packages/db/src/utils/seed/organization.ts
@@ -1,6 +1,6 @@
 import { db, organization } from '@db/drizzle';
 
-export async function seedOrganization({ testOrgId }: { testOrgId: string }) {
+export async function seedOrganization({ testOrgId, enterpriseOrgId }: { testOrgId: string; enterpriseOrgId: string }) {
   const existingOrgs = await db.select().from(organization);
   const existingOrgIds = existingOrgs.map((o) => o.id);
 
@@ -17,6 +17,19 @@ export async function seedOrganization({ testOrgId }: { testOrgId: string }) {
         course: { grading: true, newsfeed: true },
         dashboard: { exercise: true, community: true, bannerText: '', bannerImage: '' }
       }
+    },
+    {
+      id: enterpriseOrgId,
+      name: 'Coursera Test',
+      siteName: 'coursera-test',
+      settings: {},
+      landingpage: {},
+      theme: '',
+      customization: {
+        apps: { poll: true, comments: true },
+        course: { grading: true, newsfeed: true },
+        dashboard: { exercise: true, community: true, bannerText: '', bannerImage: '' }
+      }
     }
   ].filter((o) => !existingOrgIds.includes(o.id));
 
diff --git a/packages/db/src/utils/seed/organizationPlan.ts b/packages/db/src/utils/seed/organizationPlan.ts
new file mode 100644
index 00000000..0fef08fc
--- /dev/null
+++ b/packages/db/src/utils/seed/organizationPlan.ts
@@ -0,0 +1,28 @@
+import { and, db, eq, organizationPlan } from '@db/drizzle';
+
+export async function seedEnterpriseOrganizationPlan({ enterpriseOrgId }: { enterpriseOrgId: string }) {
+  const existing = await db
+    .select()
+    .from(organizationPlan)
+    .where(
+      and(
+        eq(organizationPlan.orgId, enterpriseOrgId),
+        eq(organizationPlan.planName, 'ENTERPRISE'),
+        eq(organizationPlan.isActive, true)
+      )
+    );
+
+  if (existing.length > 0) {
+    console.log('   ✓ Enterprise organization plan already exists, skipping');
+    return;
+  }
+
+  await db.insert(organizationPlan).values({
+    orgId: enterpriseOrgId,
+    planName: 'ENTERPRISE',
+    isActive: true,
+    subscriptionId: 'seed-coursera-test-enterprise',
+    provider: 'seed'
+  });
+  console.log('   ✓ Inserted enterprise organization plan');
+}
diff --git a/packages/db/src/utils/seed/organizationmember.ts b/packages/db/src/utils/seed/organizationmember.ts
index 320a8736..02c578f6 100644
--- a/packages/db/src/utils/seed/organizationmember.ts
+++ b/packages/db/src/utils/seed/organizationmember.ts
@@ -3,14 +3,23 @@ import { db, organizationmember } from '@db/drizzle';
 interface SeedOrganizationMember {
   testOrgId: string;
   adminUserId: string;
+  studentUserId: string;
+  enterpriseOrgId: string;
+  enterpriseAdminUserId: string;
+  enterpriseStudentUserId: string;
 }
 
-export async function seedOrganizationMember({ testOrgId, adminUserId }: SeedOrganizationMember) {
+export async function seedOrganizationMember({
+  testOrgId,
+  adminUserId,
+  studentUserId,
+  enterpriseOrgId,
+  enterpriseAdminUserId,
+  enterpriseStudentUserId
+}: SeedOrganizationMember) {
   const existingOrgMembers = await db.select().from(organizationmember);
   const existingOrgMemberKeys = existingOrgMembers.map((om) => `${om.organizationId}-${om.profileId}`);
 
-  const studentUserId = '0c256e75-aa40-4f62-8d30-0217ca1c60d9';
-
   const orgMembersToInsert = [
     {
       organizationId: testOrgId,
@@ -23,6 +32,18 @@ export async function seedOrganizationMember({ testOrgId, adminUserId }: SeedOrg
       roleId: 3, // STUDENT
       profileId: studentUserId,
       verified: false
+    },
+    {
+      organizationId: enterpriseOrgId,
+      roleId: 1, // ADMIN
+      profileId: enterpriseAdminUserId,
+      verified: false
+    },
+    {
+      organizationId: enterpriseOrgId,
+      roleId: 3, // STUDENT
+      profileId: enterpriseStudentUserId,
+      verified: false
     }
   ].filter((om) => !existingOrgMemberKeys.includes(`${om.organizationId}-${om.profileId}`));
 
diff --git a/packages/db/users.json b/packages/db/users.json
index 506a4f39..8dd30467 100644
--- a/packages/db/users.json
+++ b/packages/db/users.json
@@ -151,5 +151,107 @@
       }
     ],
     "profile_fullname": "Elon Gates"
+  },
+  {
+    "instance_id": "00000000-0000-0000-0000-000000000000",
+    "id": "3c9052de-7e4f-4c3a-8d8e-2d5e9b7f1a3c",
+    "aud": "authenticated",
+    "role": "authenticated",
+    "email": "enterprise@test.com",
+    "encrypted_password": "$2a$10$n8vBI6.pyE0W/RO9DcJDseLKF/CRwsU4X4Lc2MaQogt8pQgnJavTa",
+    "email_confirmed_at": "2025-03-23T12:00:00.000Z",
+    "invited_at": null,
+    "confirmation_token": "",
+    "confirmation_sent_at": null,
+    "recovery_token": "",
+    "recovery_sent_at": null,
+    "email_change_token_new": "",
+    "email_change": "",
+    "email_change_sent_at": null,
+    "last_sign_in_at": null,
+    "raw_app_meta_data": { "provider": "email", "providers": ["email"] },
+    "raw_user_meta_data": {},
+    "is_super_admin": null,
+    "created_at": "2025-03-23T12:00:00.000Z",
+    "updated_at": "2025-03-23T12:00:00.000Z",
+    "phone": null,
+    "phone_confirmed_at": null,
+    "phone_change": "",
+    "phone_change_token": "",
+    "phone_change_sent_at": null,
+    "confirmed_at": "2025-03-23T12:00:00.000Z",
+    "email_change_token_current": "",
+    "email_change_confirm_status": 0,
+    "banned_until": null,
+    "reauthentication_token": "",
+    "reauthentication_sent_at": null,
+    "is_sso_user": false,
+    "deleted_at": null,
+    "is_anonymous": false,
+    "identities": [
+      {
+        "provider_id": "3c9052de-7e4f-4c3a-8d8e-2d5e9b7f1a3c",
+        "user_id": "3c9052de-7e4f-4c3a-8d8e-2d5e9b7f1a3c",
+        "identity_data": { "sub": "3c9052de-7e4f-4c3a-8d8e-2d5e9b7f1a3c", "email": "enterprise@test.com" },
+        "provider": "email",
+        "last_sign_in_at": "2025-03-23T12:00:00.000Z",
+        "created_at": "2025-03-23T12:00:00.000Z",
+        "updated_at": "2025-03-23T12:00:00.000Z",
+        "email": "enterprise@test.com",
+        "id": "5eb27480-91aa-4bcc-8e2f-33ddac914761"
+      }
+    ],
+    "profile_fullname": "Enterprise Admin"
+  },
+  {
+    "instance_id": "00000000-0000-0000-0000-000000000000",
+    "id": "4da163ef-8050-4d4b-9c9f-3e6fac802b4d",
+    "aud": "authenticated",
+    "role": "authenticated",
+    "email": "enterprise-student@test.com",
+    "encrypted_password": "$2a$10$n8vBI6.pyE0W/RO9DcJDseLKF/CRwsU4X4Lc2MaQogt8pQgnJavTa",
+    "email_confirmed_at": "2025-03-23T12:00:00.000Z",
+    "invited_at": null,
+    "confirmation_token": "",
+    "confirmation_sent_at": null,
+    "recovery_token": "",
+    "recovery_sent_at": null,
+    "email_change_token_new": "",
+    "email_change": "",
+    "email_change_sent_at": null,
+    "last_sign_in_at": null,
+    "raw_app_meta_data": { "provider": "email", "providers": ["email"] },
+    "raw_user_meta_data": {},
+    "is_super_admin": null,
+    "created_at": "2025-03-23T12:00:00.000Z",
+    "updated_at": "2025-03-23T12:00:00.000Z",
+    "phone": null,
+    "phone_confirmed_at": null,
+    "phone_change": "",
+    "phone_change_token": "",
+    "phone_change_sent_at": null,
+    "confirmed_at": "2025-03-23T12:00:00.000Z",
+    "email_change_token_current": "",
+    "email_change_confirm_status": 0,
+    "banned_until": null,
+    "reauthentication_token": "",
+    "reauthentication_sent_at": null,
+    "is_sso_user": false,
+    "deleted_at": null,
+    "is_anonymous": false,
+    "identities": [
+      {
+        "provider_id": "4da163ef-8050-4d4b-9c9f-3e6fac802b4d",
+        "user_id": "4da163ef-8050-4d4b-9c9f-3e6fac802b4d",
+        "identity_data": { "sub": "4da163ef-8050-4d4b-9c9f-3e6fac802b4d", "email": "enterprise-student@test.com" },
+        "provider": "email",
+        "last_sign_in_at": "2025-03-23T12:00:00.000Z",
+        "created_at": "2025-03-23T12:00:00.000Z",
+        "updated_at": "2025-03-23T12:00:00.000Z",
+        "email": "enterprise-student@test.com",
+        "id": "6fc38591-a2bb-5ccd-9f3a-44eebda025872"
+      }
+    ],
+    "profile_fullname": "Enterprise Student"
   }
 ]
diff --git a/packages/email/src/emails/index.ts b/packages/email/src/emails/index.ts
index f0e17668..6339601a 100644
--- a/packages/email/src/emails/index.ts
+++ b/packages/email/src/emails/index.ts
@@ -13,6 +13,7 @@ export * from './on-password-reset';
 export * from './invite-teacher';
 export * from './newsfeed';
 export * from './student-course-welcome';
+export * from './student-course-completion';
 export * from './student-course-invite';
 export * from './teacher-student-joined';
 export * from './teacher-student-buy-request';
@@ -27,6 +28,7 @@ import type { forgotPasswordEmail } from './forgot-password';
 import type { inviteTeacherEmail } from './invite-teacher';
 import type { onPasswordResetEmail } from './on-password-reset';
 import type { studentCourseInviteEmail } from './student-course-invite';
+import type { studentCourseCompletionEmail } from './student-course-completion';
 import type { studentCourseWelcomeEmail } from './student-course-welcome';
 import type { studentProvePaymentEmail } from './student-prove-payment';
 import type { studentOrgInviteEmail } from './student-org-invite';
@@ -51,6 +53,7 @@ export type EmailSchemas = {
   newsfeedPost: typeof newsfeedPostEmail.template.schema;
   newsfeedComment: typeof newsfeedCommentEmail.template.schema;
   studentCourseWelcome: typeof studentCourseWelcomeEmail.template.schema;
+  studentCourseCompletion: typeof studentCourseCompletionEmail.template.schema;
   studentCourseInvite: typeof studentCourseInviteEmail.template.schema;
   teacherStudentJoined: typeof teacherStudentJoinedEmail.template.schema;
   teacherStudentBuyRequest: typeof teacherStudentBuyRequestEmail.template.schema;
diff --git a/packages/email/src/emails/student-course-completion.ts b/packages/email/src/emails/student-course-completion.ts
new file mode 100644
index 00000000..0844aa0e
--- /dev/null
+++ b/packages/email/src/emails/student-course-completion.ts
@@ -0,0 +1,33 @@
+import * as z from 'zod';
+
+import { defineEmail } from '../send';
+import { getDefaultTemplate } from '../templates';
+
+export const studentCourseCompletionEmail = defineEmail({
+  id: 'studentCourseCompletion',
+  subject: 'Congratulations — you completed the course requirements',
+  schema: z.object({
+    orgName: z.string().min(1),
+    courseName: z.string().min(1),
+    studentName: z.string().min(1),
+    certificateUrl: z.string().url(),
+    customMessage: z.string().nullable().optional()
+  }),
+  render: (fields) => {
+    const customBlock =
+      fields.customMessage && fields.customMessage.trim().length > 0
+        ? `<div style="margin:16px 0;padding:12px;border-left:3px solid #6366f1;background:#f8fafc;">${fields.customMessage}</div>`
+        : '';
+
+    const content = `
+      <p>Hi ${fields.studentName},</p>
+      <p>Congratulations! You have met the completion requirements for <strong>${fields.courseName}</strong>.</p>
+      ${customBlock}
+      <p><a href="${fields.certificateUrl}" style="display:inline-block;padding:10px 16px;background:#111827;color:#fff;text-decoration:none;border-radius:6px;">View your certificate</a></p>
+      <p>If the button does not work, copy and paste this link into your browser:<br/><span style="word-break:break-all;">${fields.certificateUrl}</span></p>
+      <p>Cheers,<br/>${fields.orgName}</p>
+    `;
+
+    return getDefaultTemplate(content);
+  }
+});
diff --git a/packages/email/src/emails/student-course-welcome.ts b/packages/email/src/emails/student-course-welcome.ts
index 3eedabef..cb8ebb27 100644
--- a/packages/email/src/emails/student-course-welcome.ts
+++ b/packages/email/src/emails/student-course-welcome.ts
@@ -5,17 +5,18 @@ import { getDefaultTemplate } from '../templates';
 
 export const studentCourseWelcomeEmail = defineEmail({
   id: 'studentCourseWelcome',
-  subject: 'Welcome to Class 🎉',
+  subject: 'You have access to a course — sign in to get started',
   schema: z.object({
     orgName: z.string().min(1),
-    courseName: z.string().min(1)
+    courseName: z.string().min(1),
+    loginUrl: z.string().min(1)
   }),
   render: (fields) => {
     const content = `
       <p>Hi there,</p>
-      <p>Congratulations 🎉, you've successfully joined: <strong>${fields.courseName}</strong></p>
-      <p>Everything has been set up for you to have an amazing learning experience.</p>
-      <p>If you run into any issues, don't fail to reach out to your instructor(s).</p>
+      <p>You now have access to <strong>${fields.courseName}</strong> in <strong>${fields.orgName}</strong>.</p>
+      <p><a href="${fields.loginUrl}">Sign in to ClassroomIO</a> to open the course and get started.</p>
+      <p>If you run into any issues, reach out to your instructor(s).</p>
       <p>Cheers,</p>
       <p>${fields.orgName}</p>
     `;
diff --git a/packages/email/src/utils/constants.ts b/packages/email/src/utils/constants.ts
index 8b53a82c..e8f62882 100644
--- a/packages/email/src/utils/constants.ts
+++ b/packages/email/src/utils/constants.ts
@@ -7,6 +7,7 @@ export const EMAIL_IDS = [
   'newsfeedPost',
   'onPasswordReset',
   'studentCourseInvite',
+  'studentCourseCompletion',
   'studentCourseWelcome',
   'studentOrgInvite',
   'studentProvePayment',
diff --git a/packages/question-types/src/question-scoring.ts b/packages/question-types/src/question-scoring.ts
new file mode 100644
index 00000000..4c7bbc26
--- /dev/null
+++ b/packages/question-types/src/question-scoring.ts
@@ -0,0 +1,349 @@
+import type { AnswerData } from './answer-data';
+import type { ExerciseQuestionModel, ExerciseQuestionOption } from './exercise-types';
+import { QUESTION_TYPE_KEY } from './question-type-keys';
+import { getQuestionTypeById } from './question-type-lookup';
+import { QUESTION_TYPE_ID_TO_KEY } from './question-type-registry';
+import { supportsPartialCredit } from './question-type-capabilities';
+
+export type DbQuestionForScoring = {
+  id: number;
+  title?: string | null;
+  questionTypeId: number;
+  points: number | null;
+  settings?: Record<string, unknown> | null;
+  options: Array<{
+    id?: number | null;
+    label?: string | null;
+    value?: string | null;
+    isCorrect?: boolean | null;
+  }>;
+};
+
+function normalizeText(value: unknown): string {
+  return String(value ?? '')
+    .trim()
+    .toLowerCase();
+}
+
+export function dbQuestionToExerciseQuestionModel(q: DbQuestionForScoring): ExerciseQuestionModel {
+  const key = QUESTION_TYPE_ID_TO_KEY[q.questionTypeId] ?? QUESTION_TYPE_KEY.RADIO;
+  const options: ExerciseQuestionOption[] = (q.options ?? [])
+    .filter((o) => o.id != null)
+    .map((o) => ({
+      id: o.id as number,
+      label: String(o.label ?? ''),
+      value: o.value ?? undefined,
+      isCorrect: o.isCorrect ?? false
+    }));
+
+  const rawSettings = q.settings;
+  const settings =
+    rawSettings && typeof rawSettings === 'object' && !Array.isArray(rawSettings) ? { ...rawSettings } : {};
+
+  return {
+    id: q.id,
+    title: q.title ?? '',
+    questionType: key,
+    points: Number(q.points ?? 0),
+    options,
+    settings
+  };
+}
+
+/** True when every question type id refers to an auto-gradable type (from registry). */
+export function isExerciseAutoGradable(questionTypeIds: number[]): boolean {
+  if (questionTypeIds.length === 0) return false;
+  return questionTypeIds.every((id) => {
+    const meta = getQuestionTypeById(id);
+    return meta?.autoGradable === true;
+  });
+}
+
+function clampPoints(raw: number, max: number): number {
+  if (!Number.isFinite(raw) || raw < 0) return 0;
+  return Math.min(Math.round(raw * 100) / 100, max);
+}
+
+function scoreRadio(
+  question: ExerciseQuestionModel,
+  answer: Extract<AnswerData, { type: 'RADIO' }>,
+  maxPoints: number
+): number {
+  const selected = question.options?.find((o) => Number(o.id) === Number(answer.optionId));
+  if (!selected?.isCorrect) return 0;
+  return maxPoints;
+}
+
+function scoreCheckbox(
+  question: ExerciseQuestionModel,
+  answer: Extract<AnswerData, { type: 'CHECKBOX' }>,
+  maxPoints: number,
+  partial: boolean
+): number {
+  const options = question.options ?? [];
+  const correctIds = new Set(
+    options
+      .filter((o) => o.isCorrect)
+      .map((o) => Number(o.id))
+      .filter((id) => Number.isFinite(id))
+  );
+  const selected = new Set(answer.optionIds.map((id) => Number(id)));
+  if (correctIds.size === 0) return 0;
+
+  let correctSelected = 0;
+  let wrongSelected = 0;
+  for (const id of selected) {
+    if (correctIds.has(id)) correctSelected++;
+    else wrongSelected++;
+  }
+
+  if (!partial) {
+    return correctSelected === correctIds.size && wrongSelected === 0 ? maxPoints : 0;
+  }
+
+  const incorrectPool = Math.max(1, options.length - correctIds.size);
+  const ratio = correctSelected / correctIds.size - wrongSelected / incorrectPool;
+  return clampPoints(Math.max(0, ratio) * maxPoints, maxPoints);
+}
+
+function scoreTrueFalse(
+  question: ExerciseQuestionModel,
+  answer: Extract<AnswerData, { type: 'TRUE_FALSE' }>,
+  maxPoints: number
+): number {
+  const opts = question.options ?? [];
+  const trueOpt = opts.find((o) => normalizeText(o.label) === 'true');
+  const falseOpt = opts.find((o) => normalizeText(o.label) === 'false');
+  const correctFromSettings = question.settings?.correctValue;
+  let correctIsTrue: boolean;
+  if (typeof correctFromSettings === 'boolean') {
+    correctIsTrue = correctFromSettings;
+  } else if (trueOpt?.isCorrect) {
+    correctIsTrue = true;
+  } else if (falseOpt?.isCorrect) {
+    correctIsTrue = false;
+  } else {
+    correctIsTrue = true;
+  }
+
+  return answer.value === correctIsTrue ? maxPoints : 0;
+}
+
+function scoreNumeric(
+  question: ExerciseQuestionModel,
+  answer: Extract<AnswerData, { type: 'NUMERIC' }>,
+  maxPoints: number
+): number {
+  const rawCorrect = question.settings?.correctValue;
+  const correct = typeof rawCorrect === 'number' ? rawCorrect : rawCorrect != null ? Number(rawCorrect) : NaN;
+  if (Number.isNaN(correct)) return 0;
+
+  const rawTol = question.settings?.tolerance;
+  const tol = typeof rawTol === 'number' && Number.isFinite(rawTol) ? rawTol : rawTol != null ? Number(rawTol) : 0;
+  const diff = Math.abs(answer.value - correct);
+  return diff <= tol ? maxPoints : 0;
+}
+
+function scoreFillBlank(
+  question: ExerciseQuestionModel,
+  answer: Extract<AnswerData, { type: 'FILL_BLANK' }>,
+  maxPoints: number,
+  partial: boolean
+): number {
+  const raw = String(question.settings?.acceptedAnswers ?? '');
+  const expected = raw
+    .split(',')
+    .map((s) => s.trim().toLowerCase())
+    .filter(Boolean);
+  const studentVals = answer.values.map((v) => String(v).trim().toLowerCase());
+  if (expected.length === 0) return 0;
+
+  let correct = 0;
+  for (let i = 0; i < expected.length; i++) {
+    if (studentVals[i] === expected[i]) correct++;
+  }
+
+  if (!partial) {
+    return correct === expected.length && studentVals.length === expected.length ? maxPoints : 0;
+  }
+  return (correct / expected.length) * maxPoints;
+}
+
+function pairKey(left: string, right: string): string {
+  return `${normalizeText(left)}::${normalizeText(right)}`;
+}
+
+function scoreMatching(
+  question: ExerciseQuestionModel,
+  answer: Extract<AnswerData, { type: 'MATCHING' }>,
+  maxPoints: number,
+  partial: boolean
+): number {
+  const rawPairs = question.settings?.pairs;
+  const correctPairs = Array.isArray(rawPairs) ? (rawPairs as Array<{ left: string; right: string }>) : [];
+  if (correctPairs.length === 0) return 0;
+
+  const correctSet = new Set(correctPairs.map((p) => pairKey(p.left, p.right)));
+  const studentPairs = answer.pairs ?? [];
+  let matches = 0;
+  for (const p of studentPairs) {
+    if (correctSet.has(pairKey(p.left, p.right))) matches++;
+  }
+
+  if (!partial) {
+    return matches === correctSet.size && studentPairs.length === correctSet.size ? maxPoints : 0;
+  }
+  return (matches / correctSet.size) * maxPoints;
+}
+
+type OrderingItem = { label: string; answerValue: string };
+
+function getOrderingItems(question: ExerciseQuestionModel): OrderingItem[] {
+  const opts = question.options ?? [];
+  if (opts.length > 0) {
+    return opts.map((o, index) => {
+      const label = String(o.label ?? o.value ?? '').trim() || String(index + 1);
+      const id = String(o.id ?? o.value ?? o.label ?? `ordering-${index + 1}`);
+      const answerValue = String(o.id ?? o.value ?? o.label ?? id);
+      return { label, answerValue };
+    });
+  }
+  const rawItems = Array.isArray(question.settings?.items) ? (question.settings.items as string[]) : [];
+  return rawItems.map((label, index) => ({
+    label: String(label).trim() || String(index + 1),
+    answerValue: String(label).trim()
+  }));
+}
+
+function getExpectedOrderingValues(question: ExerciseQuestionModel): string[] {
+  const items = getOrderingItems(question);
+  const settingsItems = Array.isArray(question.settings?.items) ? (question.settings!.items as string[]) : [];
+  if (settingsItems.length > 0) {
+    const byLabel = new Map(items.map((i) => [normalizeText(i.label), i.answerValue]));
+    return settingsItems.map((l) => byLabel.get(normalizeText(l)) ?? String(l));
+  }
+  return items.map((i) => i.answerValue);
+}
+
+function scoreOrdering(
+  question: ExerciseQuestionModel,
+  answer: Extract<AnswerData, { type: 'ORDERING' }>,
+  maxPoints: number,
+  partial: boolean
+): number {
+  const expected = getExpectedOrderingValues(question);
+  const student = (answer.orderedValues ?? []).map((v) => String(v).trim());
+  if (expected.length === 0) return 0;
+  if (student.length !== expected.length) {
+    return partial ? 0 : 0;
+  }
+
+  let correct = 0;
+  for (let i = 0; i < expected.length; i++) {
+    if (normalizeText(student[i]) === normalizeText(expected[i])) correct++;
+  }
+
+  if (!partial) {
+    return correct === expected.length ? maxPoints : 0;
+  }
+  return (correct / expected.length) * maxPoints;
+}
+
+function distance(a: { x: number; y: number }, b: { x: number; y: number }): number {
+  return Math.hypot(a.x - b.x, a.y - b.y);
+}
+
+const HOTSPOT_TOLERANCE = 12;
+
+function scoreHotspot(
+  question: ExerciseQuestionModel,
+  answer: Extract<AnswerData, { type: 'HOTSPOT' }>,
+  maxPoints: number,
+  partial: boolean
+): number {
+  const raw = question.settings?.hotspots;
+  const hotspots = Array.isArray(raw) ? (raw as Array<{ x: number; y: number }>) : [];
+  if (hotspots.length === 0) return 0;
+
+  const coords = answer.coordinates ?? [];
+  let hits = 0;
+  for (const h of hotspots) {
+    if (coords.some((c) => distance(c, h) <= HOTSPOT_TOLERANCE)) hits++;
+  }
+
+  if (!partial) {
+    return hits === hotspots.length && coords.length >= hotspots.length ? maxPoints : 0;
+  }
+  return (hits / hotspots.length) * maxPoints;
+}
+
+export function scoreAnswerForQuestion(question: ExerciseQuestionModel, answer: AnswerData | null | undefined): number {
+  const maxPoints = Number(question.points ?? 0);
+  if (maxPoints <= 0) return 0;
+  if (!answer || typeof answer !== 'object' || !('type' in answer)) return 0;
+
+  const key = question.questionType;
+  const partial = supportsPartialCredit(key);
+
+  switch (answer.type) {
+    case 'RADIO':
+      if (key !== QUESTION_TYPE_KEY.RADIO) return 0;
+      return scoreRadio(question, answer, maxPoints);
+    case 'CHECKBOX':
+      if (key !== QUESTION_TYPE_KEY.CHECKBOX) return 0;
+      return clampPoints(scoreCheckbox(question, answer, maxPoints, partial), maxPoints);
+    case 'TRUE_FALSE':
+      if (key !== QUESTION_TYPE_KEY.TRUE_FALSE) return 0;
+      return scoreTrueFalse(question, answer, maxPoints);
+    case 'NUMERIC':
+      if (key !== QUESTION_TYPE_KEY.NUMERIC) return 0;
+      return scoreNumeric(question, answer, maxPoints);
+    case 'FILL_BLANK':
+      if (key !== QUESTION_TYPE_KEY.FILL_BLANK) return 0;
+      return clampPoints(scoreFillBlank(question, answer, maxPoints, partial), maxPoints);
+    case 'MATCHING':
+      if (key !== QUESTION_TYPE_KEY.MATCHING) return 0;
+      return clampPoints(scoreMatching(question, answer, maxPoints, partial), maxPoints);
+    case 'ORDERING':
+      if (key !== QUESTION_TYPE_KEY.ORDERING) return 0;
+      return clampPoints(scoreOrdering(question, answer, maxPoints, partial), maxPoints);
+    case 'HOTSPOT':
+      if (key !== QUESTION_TYPE_KEY.HOTSPOT) return 0;
+      return clampPoints(scoreHotspot(question, answer, maxPoints, partial), maxPoints);
+    default:
+      return 0;
+  }
+}
+
+export type ScoreSubmissionResult = {
+  scores: Array<{ questionId: number; points: number }>;
+  total: number;
+};
+
+/**
+ * Computes per-question scores and total for auto-graded exercises.
+ * Missing answers score 0.
+ */
+export function scoreSubmissionAnswers(
+  questions: DbQuestionForScoring[],
+  answersByQuestionId: ReadonlyMap<number, AnswerData | null | undefined>
+): ScoreSubmissionResult {
+  const scores: Array<{ questionId: number; points: number }> = [];
+  let total = 0;
+
+  for (const q of questions) {
+    const model = dbQuestionToExerciseQuestionModel(q);
+    const meta = getQuestionTypeById(q.questionTypeId);
+    if (!meta?.autoGradable) {
+      scores.push({ questionId: q.id, points: 0 });
+      continue;
+    }
+
+    const answer = answersByQuestionId.get(q.id);
+    const pts = Math.round(scoreAnswerForQuestion(model, answer ?? null));
+    scores.push({ questionId: q.id, points: pts });
+    total += pts;
+  }
+
+  return { scores, total };
+}
diff --git a/packages/ui/package.json b/packages/ui/package.json
index e5c9cb85..79b28615 100644
--- a/packages/ui/package.json
+++ b/packages/ui/package.json
@@ -44,6 +44,7 @@
   },
   "dependencies": {
     "@cio/question-types": "workspace:*",
+    "@cio/utils": "workspace:*",
     "@floating-ui/dom": "^1.7.4",
     "@tiptap/core": "^3.10.7",
     "@tiptap/extension-bubble-menu": "^3.10.7",
diff --git a/packages/ui/src/custom/editor/ui/components/CodeBlock.svelte b/packages/ui/src/custom/editor/ui/components/CodeBlock.svelte
index a06b8c60..e36ae603 100644
--- a/packages/ui/src/custom/editor/ui/components/CodeBlock.svelte
+++ b/packages/ui/src/custom/editor/ui/components/CodeBlock.svelte
@@ -71,6 +71,6 @@
     </Button>
   </div>
   <pre bind:this={preRef} draggable={false}>
-		<NodeViewContent as="code" class={`language-${defaultLanguage}`} {...node.attrs} />
+		<NodeViewContent as="code" class={`language-${defaultLanguage} ui:pt-3!`} {...node.attrs} />
 	</pre>
 </NodeViewWrapper>
diff --git a/packages/ui/src/custom/exercise-question/renderers/shared/option-correctness-badges.svelte b/packages/ui/src/custom/exercise-question/renderers/shared/option-correctness-badges.svelte
index ff746e76..62b6c13c 100644
--- a/packages/ui/src/custom/exercise-question/renderers/shared/option-correctness-badges.svelte
+++ b/packages/ui/src/custom/exercise-question/renderers/shared/option-correctness-badges.svelte
@@ -1,4 +1,6 @@
 <script lang="ts">
+  import CheckIcon from '@lucide/svelte/icons/check';
+  import XIcon from '@lucide/svelte/icons/x';
   import { getExerciseQuestionLabel, type ExerciseQuestionLabels } from '@cio/question-types';
   import { Badge } from '../../../../base/badge';
 
@@ -10,13 +12,17 @@
 
   let { labels, showCorrect = false, showIncorrect = false }: Props = $props();
 
-  const label = (key: Parameters<typeof getExerciseQuestionLabel>[1], fallback = '') =>
-    getExerciseQuestionLabel(labels, key, fallback);
+  const ariaCorrectLabel = $derived(getExerciseQuestionLabel(labels, 'common.correct_badge', 'Correct'));
+  const ariaIncorrectLabel = $derived(getExerciseQuestionLabel(labels, 'common.incorrect_badge', 'Incorrect'));
 </script>
 
 {#if showCorrect}
-  <Badge variant="success" class="ui:ml-2">{label('common.correct_badge')}</Badge>
+  <Badge variant="success" class="ui:ml-2 ui:p-1" aria-label={ariaCorrectLabel} title={ariaCorrectLabel}>
+    <CheckIcon aria-hidden="true" class="custom" />
+  </Badge>
 {/if}
 {#if showIncorrect}
-  <Badge variant="destructive" class="ui:ml-2">{label('common.incorrect_badge')}</Badge>
+  <Badge variant="destructive" class="ui:ml-2 ui:p-1" aria-label={ariaIncorrectLabel} title={ariaIncorrectLabel}>
+    <XIcon aria-hidden="true" class="custom" />
+  </Badge>
 {/if}
diff --git a/packages/ui/src/custom/multi-select-list/multi-select-list.svelte b/packages/ui/src/custom/multi-select-list/multi-select-list.svelte
index 29a20a48..37e3ad0e 100644
--- a/packages/ui/src/custom/multi-select-list/multi-select-list.svelte
+++ b/packages/ui/src/custom/multi-select-list/multi-select-list.svelte
@@ -1,12 +1,18 @@
 <script lang="ts">
+  import { Spinner } from '../../base/spinner';
   import { CheckboxField } from '../checkbox-field';
+  import { Search } from '../search';
   import { cn } from '../../tools';
   import type { MultiSelectListItem } from './types';
+  import type { Snippet } from 'svelte';
 
   interface Props {
-    heading: string;
+    /** When omitted, the list renders without a heading row (e.g. when the parent supplies the title). */
+    heading?: string;
+    headingSnippet?: Snippet;
     emptyMessage: string;
     items: MultiSelectListItem[];
+    isLoading?: boolean;
     isSelected: (id: string) => boolean;
     onToggle: (id: string) => void;
     /** Prefix for each row's checkbox `name` (e.g. `assign-course` → `assign-course-<id>`). */
@@ -14,35 +20,78 @@
     class?: string;
     /** Extra classes for the scrollable list container (`data-slot="multi-select-list-items"`). */
     listClass?: string;
+    searchPlaceholder?: string;
+    searchValue?: string;
+    onSearchValueChange?: (value: string) => void;
   }
 
   let {
-    heading,
+    heading = '',
+    headingSnippet,
     emptyMessage,
     items,
+    isLoading = false,
     isSelected,
     onToggle,
     namePrefix = 'multi-select',
     class: className,
-    listClass
+    listClass,
+    searchPlaceholder = '',
+    searchValue = $bindable(''),
+    onSearchValueChange
   }: Props = $props();
+
+  const hasHeading = $derived(heading || headingSnippet);
 </script>
 
-<div data-slot="multi-select-list" class={cn('ui:border-border space-y-3 rounded-md border', className)}>
-  <p class="ui:border-border border-b px-2 py-2 text-sm font-medium">
-    {heading} ({items.length})
-  </p>
-  {#if items.length === 0}
-    <p class="ui:text-muted-foreground px-2 pb-2 text-sm">{emptyMessage}</p>
+<div data-slot="multi-select-list" class={cn('ui:border-border ui:space-y-3 ui:rounded-md ui:border', className)}>
+  {#if hasHeading || searchPlaceholder}
+    <div
+      class={cn(
+        'ui:border-border ui:flex ui:gap-3 ui:border-b ui:px-2 ui:py-2 ui:items-center ui:justify-between',
+        !hasHeading && 'ui:justify-end'
+      )}
+    >
+      {#if heading}
+        <p class="ui:text-sm ui:font-medium">
+          {heading} ({items.length})
+        </p>
+      {:else if headingSnippet}
+        {@render headingSnippet()}
+      {/if}
+
+      {#if searchPlaceholder}
+        <Search
+          placeholder={searchPlaceholder}
+          bind:value={searchValue}
+          onValueChange={onSearchValueChange}
+          class="ui:w-full ui:max-w-sm"
+        />
+      {/if}
+    </div>
+  {/if}
+  {#if isLoading}
+    <div class="ui:flex ui:min-h-40 ui:items-center ui:justify-center ui:px-2 ui:pb-2">
+      <Spinner class="ui:size-5 ui:text-muted-foreground" />
+    </div>
+  {:else if items.length === 0}
+    <p class="ui:text-muted-foreground ui:px-2 ui:pb-2 ui:text-sm">{emptyMessage}</p>
   {:else}
-    <div data-slot="multi-select-list-items" class={cn('max-h-60 space-y-2 overflow-y-auto px-2 pb-2', listClass)}>
+    <div
+      data-slot="multi-select-list-items"
+      class={cn('ui:max-h-60 ui:space-y-2 ui:overflow-y-auto ui:px-2 ui:pb-2', listClass)}
+    >
       {#each items as item (item.id)}
         <CheckboxField
           name={`${namePrefix}-${item.id}`}
           label={item.label || item.id}
           checked={isSelected(item.id)}
           onclick={() => onToggle(item.id)}
-        />
+        >
+          {#if item.description}
+            <p class="ui:ml-2 ui:text-muted-foreground ui:text-sm">{item.description}</p>
+          {/if}
+        </CheckboxField>
       {/each}
     </div>
   {/if}
diff --git a/packages/ui/src/custom/multi-select-list/types.ts b/packages/ui/src/custom/multi-select-list/types.ts
index 184f56fa..1c39f333 100644
--- a/packages/ui/src/custom/multi-select-list/types.ts
+++ b/packages/ui/src/custom/multi-select-list/types.ts
@@ -1 +1 @@
-export type MultiSelectListItem = { id: string; label: string };
+export type MultiSelectListItem = { id: string; label: string; description?: string };
diff --git a/packages/ui/src/custom/search/search.svelte b/packages/ui/src/custom/search/search.svelte
index 0cf24b28..f73bed35 100644
--- a/packages/ui/src/custom/search/search.svelte
+++ b/packages/ui/src/custom/search/search.svelte
@@ -1,6 +1,7 @@
 <script lang="ts">
   import * as InputGroup from '../../base/input-group';
   import SearchIcon from '@lucide/svelte/icons/search';
+  import XIcon from '@lucide/svelte/icons/x';
   import type { ComponentProps } from 'svelte';
   import { cn } from '../../tools';
 
@@ -8,12 +9,14 @@
     placeholder?: string;
     value?: string;
     class?: string;
+    onValueChange?: (value: string) => void;
   }
 
   let {
     placeholder = '',
     value = $bindable(''),
     class: className = '',
+    onValueChange,
     ...restProps
   }: Props & Omit<ComponentProps<typeof InputGroup.Root>, 'class' | 'children'> = $props();
 
@@ -22,10 +25,26 @@
     'data-slot': 'search',
     ...restProps
   });
+
+  function handleInput(event: Event) {
+    onValueChange?.((event.currentTarget as HTMLInputElement).value);
+  }
+
+  function clearValue() {
+    value = '';
+    onValueChange?.('');
+  }
 </script>
 
 <InputGroup.Root {...mergedProps}>
-  <InputGroup.Input {placeholder} bind:value />
+  <InputGroup.Input {placeholder} bind:value oninput={handleInput} />
+  {#if value}
+    <InputGroup.Addon align="inline-end">
+      <InputGroup.Button aria-label="Clear search" onclick={clearValue}>
+        <XIcon />
+      </InputGroup.Button>
+    </InputGroup.Addon>
+  {/if}
   <InputGroup.Addon>
     <SearchIcon />
   </InputGroup.Addon>
diff --git a/packages/ui/src/output.css b/packages/ui/src/output.css
index 496a7846..aaa6a0a0 100644
--- a/packages/ui/src/output.css
+++ b/packages/ui/src/output.css
@@ -1,2 +1,2 @@
 /*! tailwindcss v4.2.1 | MIT License | https://tailwindcss.com */
-@layer properties{@supports (((-webkit-hyphens:none)) and (not (margin-trim:inline))) or ((-moz-orient:inline) and (not (color:rgb(from red r g b)))){*,:before,:after,::backdrop{--tw-translate-x:0;--tw-translate-y:0;--tw-translate-z:0;--tw-scale-x:1;--tw-scale-y:1;--tw-scale-z:1;--tw-space-y-reverse:0;--tw-border-style:solid;--tw-gradient-position:initial;--tw-gradient-from:#0000;--tw-gradient-via:#0000;--tw-gradient-to:#0000;--tw-gradient-stops:initial;--tw-gradient-via-stops:initial;--tw-gradient-from-position:0%;--tw-gradient-via-position:50%;--tw-gradient-to-position:100%;--tw-leading:initial;--tw-font-weight:initial;--tw-tracking:initial;--tw-shadow:0 0 #0000;--tw-shadow-color:initial;--tw-shadow-alpha:100%;--tw-inset-shadow:0 0 #0000;--tw-inset-shadow-color:initial;--tw-inset-shadow-alpha:100%;--tw-ring-color:initial;--tw-ring-shadow:0 0 #0000;--tw-inset-ring-color:initial;--tw-inset-ring-shadow:0 0 #0000;--tw-ring-inset:initial;--tw-ring-offset-width:0px;--tw-ring-offset-color:#fff;--tw-ring-offset-shadow:0 0 #0000;--tw-backdrop-blur:initial;--tw-backdrop-brightness:initial;--tw-backdrop-contrast:initial;--tw-backdrop-grayscale:initial;--tw-backdrop-hue-rotate:initial;--tw-backdrop-invert:initial;--tw-backdrop-opacity:initial;--tw-backdrop-saturate:initial;--tw-backdrop-sepia:initial;--tw-duration:initial;--tw-ease:initial;--tw-content:"";--tw-outline-style:solid;--tw-animation-delay:0s;--tw-animation-direction:normal;--tw-animation-duration:initial;--tw-animation-fill-mode:none;--tw-animation-iteration-count:1;--tw-enter-blur:0;--tw-enter-opacity:1;--tw-enter-rotate:0;--tw-enter-scale:1;--tw-enter-translate-x:0;--tw-enter-translate-y:0;--tw-exit-blur:0;--tw-exit-opacity:1;--tw-exit-rotate:0;--tw-exit-scale:1;--tw-exit-translate-x:0;--tw-exit-translate-y:0;--border-angle:0deg}}}@layer theme{:root,:host{--ui-font-sans:ui-sans-serif, system-ui, sans-serif, "Apple Color Emoji", "Segoe UI Emoji", "Segoe UI Symbol", "Noto Color Emoji";--ui-font-mono:ui-monospace, SFMono-Regular, Menlo, Monaco, Consolas, "Liberation Mono", "Courier New", monospace;--ui-color-red-50:oklch(97.1% .013 17.38);--ui-color-red-500:oklch(63.7% .237 25.331);--ui-color-red-600:oklch(57.7% .245 27.325);--ui-color-red-700:oklch(50.5% .213 27.518);--ui-color-orange-500:oklch(70.5% .213 47.604);--ui-color-amber-50:oklch(98.7% .022 95.277);--ui-color-amber-200:oklch(92.4% .12 95.746);--ui-color-amber-400:oklch(82.8% .189 84.429);--ui-color-amber-500:oklch(76.9% .188 70.08);--ui-color-amber-600:oklch(66.6% .179 58.318);--ui-color-amber-900:oklch(41.4% .112 45.904);--ui-color-amber-950:oklch(27.9% .077 45.635);--ui-color-yellow-500:oklch(79.5% .184 86.047);--ui-color-green-500:oklch(72.3% .219 149.579);--ui-color-emerald-50:oklch(97.9% .021 166.113);--ui-color-emerald-300:oklch(84.5% .143 164.978);--ui-color-emerald-400:oklch(76.5% .177 163.223);--ui-color-emerald-500:oklch(69.6% .17 162.48);--ui-color-emerald-600:oklch(59.6% .145 163.225);--ui-color-emerald-950:oklch(26.2% .051 172.552);--ui-color-sky-50:oklch(97.7% .013 236.62);--ui-color-sky-200:oklch(90.1% .058 230.902);--ui-color-sky-900:oklch(39.1% .09 240.876);--ui-color-sky-950:oklch(29.3% .066 243.157);--ui-color-pink-500:oklch(65.6% .241 354.308);--ui-color-slate-800:oklch(27.9% .041 260.031);--ui-color-slate-950:oklch(12.9% .042 264.695);--ui-color-gray-200:oklch(92.8% .006 264.531);--ui-color-black:#000;--ui-color-white:#fff;--ui-spacing:.25rem;--ui-container-sm:24rem;--ui-container-lg:32rem;--ui-container-xl:36rem;--ui-container-3xl:48rem;--ui-text-xs:.75rem;--ui-text-xs--line-height:calc(1 / .75);--ui-text-sm:.875rem;--ui-text-sm--line-height:calc(1.25 / .875);--ui-text-base:1rem;--ui-text-base--line-height:calc(1.5 / 1);--ui-text-lg:1.125rem;--ui-text-lg--line-height:calc(1.75 / 1.125);--ui-text-xl:1.25rem;--ui-text-xl--line-height:calc(1.75 / 1.25);--ui-text-2xl:1.5rem;--ui-text-2xl--line-height:calc(2 / 1.5);--ui-font-weight-normal:400;--ui-font-weight-medium:500;--ui-font-weight-semibold:600;--ui-font-weight-bold:700;--ui-tracking-tight:-.025em;--ui-tracking-widest:.1em;--ui-leading-snug:1.375;--ui-leading-normal:1.5;--ui-leading-relaxed:1.625;--ui-radius-xs:.125rem;--ui-ease-in-out:cubic-bezier(.4, 0, .2, 1);--ui-animate-spin:spin 1s linear infinite;--ui-animate-pulse:pulse 2s cubic-bezier(.4, 0, .6, 1) infinite;--ui-blur-sm:8px;--ui-aspect-video:16 / 9;--ui-default-transition-duration:.15s;--ui-default-transition-timing-function:cubic-bezier(.4, 0, .2, 1);--ui-default-mono-font-family:var(--ui-font-mono)}}@layer base{*,:after,:before,::backdrop{box-sizing:border-box;border:0 solid;margin:0;padding:0}::file-selector-button{box-sizing:border-box;border:0 solid;margin:0;padding:0}html,:host{-webkit-text-size-adjust:100%;tab-size:4;line-height:1.5;font-family:var(--font-cio,ui-sans-serif, system-ui, sans-serif, "Apple Color Emoji", "Segoe UI Emoji", "Segoe UI Symbol", "Noto Color Emoji");font-feature-settings:var(--ui-default-font-feature-settings,normal);font-variation-settings:var(--ui-default-font-variation-settings,normal);-webkit-tap-highlight-color:transparent}hr{height:0;color:inherit;border-top-width:1px}abbr:where([title]){-webkit-text-decoration:underline dotted;text-decoration:underline dotted}h1,h2,h3,h4,h5,h6{font-size:inherit;font-weight:inherit}a{color:inherit;-webkit-text-decoration:inherit;-webkit-text-decoration:inherit;-webkit-text-decoration:inherit;text-decoration:inherit}b,strong{font-weight:bolder}code,kbd,samp,pre{font-family:var(--ui-default-mono-font-family,ui-monospace, SFMono-Regular, Menlo, Monaco, Consolas, "Liberation Mono", "Courier New", monospace);font-feature-settings:var(--ui-default-mono-font-feature-settings,normal);font-variation-settings:var(--ui-default-mono-font-variation-settings,normal);font-size:1em}small{font-size:80%}sub,sup{vertical-align:baseline;font-size:75%;line-height:0;position:relative}sub{bottom:-.25em}sup{top:-.5em}table{text-indent:0;border-color:inherit;border-collapse:collapse}:-moz-focusring{outline:auto}progress{vertical-align:baseline}summary{display:list-item}ol,ul,menu{list-style:none}img,svg,video,canvas,audio,iframe,embed,object{vertical-align:middle;display:block}img,video{max-width:100%;height:auto}button,input,select,optgroup,textarea{font:inherit;font-feature-settings:inherit;font-variation-settings:inherit;letter-spacing:inherit;color:inherit;opacity:1;background-color:#0000;border-radius:0}::file-selector-button{font:inherit;font-feature-settings:inherit;font-variation-settings:inherit;letter-spacing:inherit;color:inherit;opacity:1;background-color:#0000;border-radius:0}:where(select:is([multiple],[size])) optgroup{font-weight:bolder}:where(select:is([multiple],[size])) optgroup option{padding-inline-start:20px}::file-selector-button{margin-inline-end:4px}::placeholder{opacity:1}@supports (not ((-webkit-appearance:-apple-pay-button))) or (contain-intrinsic-size:1px){::placeholder{color:currentColor}@supports (color:color-mix(in lab, red, red)){::placeholder{color:color-mix(in oklab, currentcolor 50%, transparent)}}}textarea{resize:vertical}::-webkit-search-decoration{-webkit-appearance:none}::-webkit-date-and-time-value{min-height:1lh;text-align:inherit}::-webkit-datetime-edit{display:inline-flex}::-webkit-datetime-edit-fields-wrapper{padding:0}::-webkit-datetime-edit{padding-block:0}::-webkit-datetime-edit-year-field{padding-block:0}::-webkit-datetime-edit-month-field{padding-block:0}::-webkit-datetime-edit-day-field{padding-block:0}::-webkit-datetime-edit-hour-field{padding-block:0}::-webkit-datetime-edit-minute-field{padding-block:0}::-webkit-datetime-edit-second-field{padding-block:0}::-webkit-datetime-edit-millisecond-field{padding-block:0}::-webkit-datetime-edit-meridiem-field{padding-block:0}::-webkit-calendar-picker-indicator{line-height:1}:-moz-ui-invalid{box-shadow:none}button,input:where([type=button],[type=reset],[type=submit]){appearance:button}::file-selector-button{appearance:button}::-webkit-inner-spin-button{height:auto}::-webkit-outer-spin-button{height:auto}[hidden]:where(:not([hidden=until-found])){display:none!important}*{border-color:var(--border);outline-color:var(--ring)}@supports (color:color-mix(in lab, red, red)){*{outline-color:color-mix(in oklab, var(--ring) 50%, transparent)}}body{background-color:var(--background);font-family:var(--font-sans);color:var(--foreground)}button,input,select,optgroup,textarea{font-family:var(--font-sans)}::file-selector-button{font-family:var(--font-sans)}.toaster{--normal-bg:var(--color-popover);--normal-text:var(--color-popover-foreground);--normal-border:var(--color-border)}}@layer components;@layer utilities{.ui\:\@container\/field-group{container:field-group/inline-size}.ui\:pointer-events-none{pointer-events:none}.ui\:sr-only{clip-path:inset(50%);white-space:nowrap;border-width:0;width:1px;height:1px;margin:-1px;padding:0;position:absolute;overflow:hidden}.ui\:absolute{position:absolute}.ui\:fixed{position:fixed}.ui\:relative{position:relative}.ui\:sticky{position:sticky}.ui\:inset-0{inset:calc(var(--ui-spacing) * 0)}.ui\:inset-x-0{inset-inline:calc(var(--ui-spacing) * 0)}.ui\:inset-y-0{inset-block:calc(var(--ui-spacing) * 0)}.ui\:start-0{inset-inline-start:calc(var(--ui-spacing) * 0)}.ui\:end-4{inset-inline-end:calc(var(--ui-spacing) * 4)}.ui\:-top-2{top:calc(var(--ui-spacing) * -2)}.ui\:-top-3{top:calc(var(--ui-spacing) * -3)}.ui\:top-0{top:calc(var(--ui-spacing) * 0)}.ui\:top-1\.5{top:calc(var(--ui-spacing) * 1.5)}.ui\:top-1\/2{top:50%}.ui\:top-2{top:calc(var(--ui-spacing) * 2)}.ui\:top-3\.5{top:calc(var(--ui-spacing) * 3.5)}.ui\:top-4{top:calc(var(--ui-spacing) * 4)}.ui\:top-13{top:calc(var(--ui-spacing) * 13)}.ui\:top-\[-12px\]{top:-12px}.ui\:top-\[50\%\]{top:50%}.ui\:top-\[60\%\]{top:60%}.ui\:top-full{top:100%}.ui\:top-px{top:1px}.ui\:-right-4{right:calc(var(--ui-spacing) * -4)}.ui\:right-0{right:calc(var(--ui-spacing) * 0)}.ui\:right-1{right:calc(var(--ui-spacing) * 1)}.ui\:right-2{right:calc(var(--ui-spacing) * 2)}.ui\:right-3{right:calc(var(--ui-spacing) * 3)}.ui\:right-4{right:calc(var(--ui-spacing) * 4)}.ui\:right-9{right:calc(var(--ui-spacing) * 9)}.ui\:right-\[-12px\]{right:-12px}.ui\:-bottom-px{bottom:-1px}.ui\:bottom-0{bottom:calc(var(--ui-spacing) * 0)}.ui\:bottom-2{bottom:calc(var(--ui-spacing) * 2)}.ui\:left-0{left:calc(var(--ui-spacing) * 0)}.ui\:left-1\/2{left:50%}.ui\:left-2{left:calc(var(--ui-spacing) * 2)}.ui\:left-\[50\%\]{left:50%}.ui\:left-\[calc\(50\%-3rem\)\]{left:calc(50% - 3rem)}.ui\:isolate{isolation:isolate}.ui\:z-1{z-index:1}.ui\:z-10{z-index:10}.ui\:z-20{z-index:20}.ui\:z-50{z-index:50}.ui\:z-200{z-index:200}.ui\:z-999{z-index:999}.ui\:z-\[1\]{z-index:1}.ui\:order-first{order:-9999}.ui\:order-last{order:9999}.ui\:col-start-2{grid-column-start:2}.ui\:row-span-2{grid-row:span 2/span 2}.ui\:row-start-1{grid-row-start:1}.ui\:m-0{margin:calc(var(--ui-spacing) * 0)}.ui\:m-0\!{margin:calc(var(--ui-spacing) * 0)!important}.ui\:-mx-1{margin-inline:calc(var(--ui-spacing) * -1)}.ui\:mx-auto{margin-inline:auto}.ui\:my-0{margin-block:calc(var(--ui-spacing) * 0)}.ui\:my-0\.5{margin-block:calc(var(--ui-spacing) * .5)}.ui\:my-1{margin-block:calc(var(--ui-spacing) * 1)}.ui\:my-2{margin-block:calc(var(--ui-spacing) * 2)}.ui\:my-4{margin-block:calc(var(--ui-spacing) * 4)}.ui\:ms-1{margin-inline-start:calc(var(--ui-spacing) * 1)}.ui\:ms-4{margin-inline-start:calc(var(--ui-spacing) * 4)}.ui\:mt-0\.5{margin-top:calc(var(--ui-spacing) * .5)}.ui\:mt-1{margin-top:calc(var(--ui-spacing) * 1)}.ui\:mt-1\.5{margin-top:calc(var(--ui-spacing) * 1.5)}.ui\:mt-3{margin-top:calc(var(--ui-spacing) * 3)}.ui\:mt-4{margin-top:calc(var(--ui-spacing) * 4)}.ui\:mt-auto{margin-top:auto}.ui\:mr-1{margin-right:calc(var(--ui-spacing) * 1)}.ui\:mr-2{margin-right:calc(var(--ui-spacing) * 2)}.ui\:mb-1{margin-bottom:calc(var(--ui-spacing) * 1)}.ui\:mb-2{margin-bottom:calc(var(--ui-spacing) * 2)}.ui\:mb-3{margin-bottom:calc(var(--ui-spacing) * 3)}.ui\:mb-4{margin-bottom:calc(var(--ui-spacing) * 4)}.ui\:ml-1{margin-left:calc(var(--ui-spacing) * 1)}.ui\:ml-2{margin-left:calc(var(--ui-spacing) * 2)}.ui\:ml-2\.5{margin-left:calc(var(--ui-spacing) * 2.5)}.ui\:ml-auto{margin-left:auto}.ui\:line-clamp-1{-webkit-line-clamp:1;-webkit-box-orient:vertical;display:-webkit-box;overflow:hidden}.ui\:line-clamp-2{-webkit-line-clamp:2;-webkit-box-orient:vertical;display:-webkit-box;overflow:hidden}.ui\:line-clamp-3{-webkit-line-clamp:3;-webkit-box-orient:vertical;display:-webkit-box;overflow:hidden}.ui\:block{display:block}.ui\:flex{display:flex}.ui\:grid{display:grid}.ui\:hidden{display:none}.ui\:inline-block{display:inline-block}.ui\:inline-flex{display:inline-flex}.ui\:field-sizing-content{field-sizing:content}.ui\:aspect-video{aspect-ratio:var(--ui-aspect-video)}.ui\:size-2{width:calc(var(--ui-spacing) * 2);height:calc(var(--ui-spacing) * 2)}.ui\:size-2\.5{width:calc(var(--ui-spacing) * 2.5);height:calc(var(--ui-spacing) * 2.5)}.ui\:size-3{width:calc(var(--ui-spacing) * 3);height:calc(var(--ui-spacing) * 3)}.ui\:size-3\.5{width:calc(var(--ui-spacing) * 3.5);height:calc(var(--ui-spacing) * 3.5)}.ui\:size-4{width:calc(var(--ui-spacing) * 4);height:calc(var(--ui-spacing) * 4)}.ui\:size-5{width:calc(var(--ui-spacing) * 5);height:calc(var(--ui-spacing) * 5)}.ui\:size-6{width:calc(var(--ui-spacing) * 6);height:calc(var(--ui-spacing) * 6)}.ui\:size-7{width:calc(var(--ui-spacing) * 7);height:calc(var(--ui-spacing) * 7)}.ui\:size-8{width:calc(var(--ui-spacing) * 8);height:calc(var(--ui-spacing) * 8)}.ui\:size-9{width:calc(var(--ui-spacing) * 9);height:calc(var(--ui-spacing) * 9)}.ui\:size-10{width:calc(var(--ui-spacing) * 10);height:calc(var(--ui-spacing) * 10)}.ui\:size-14{width:calc(var(--ui-spacing) * 14);height:calc(var(--ui-spacing) * 14)}.ui\:size-14\!{width:calc(var(--ui-spacing) * 14)!important;height:calc(var(--ui-spacing) * 14)!important}.ui\:size-20{width:calc(var(--ui-spacing) * 20);height:calc(var(--ui-spacing) * 20)}.ui\:size-fit{width:fit-content;height:fit-content}.ui\:size-full{width:100%;height:100%}.ui\:h-\(--bits-navigation-menu-viewport-height\){height:var(--bits-navigation-menu-viewport-height)}.ui\:h-\(--bits-select-anchor-height\){height:var(--bits-select-anchor-height)}.ui\:h-0\.5{height:calc(var(--ui-spacing) * .5)}.ui\:h-1\.5{height:calc(var(--ui-spacing) * 1.5)}.ui\:h-2{height:calc(var(--ui-spacing) * 2)}.ui\:h-4{height:calc(var(--ui-spacing) * 4)}.ui\:h-5{height:calc(var(--ui-spacing) * 5)}.ui\:h-6{height:calc(var(--ui-spacing) * 6)}.ui\:h-7{height:calc(var(--ui-spacing) * 7)}.ui\:h-8{height:calc(var(--ui-spacing) * 8)}.ui\:h-9{height:calc(var(--ui-spacing) * 9)}.ui\:h-10{height:calc(var(--ui-spacing) * 10)}.ui\:h-12{height:calc(var(--ui-spacing) * 12)}.ui\:h-24{height:calc(var(--ui-spacing) * 24)}.ui\:h-28{height:calc(var(--ui-spacing) * 28)}.ui\:h-40{height:calc(var(--ui-spacing) * 40)}.ui\:h-48{height:calc(var(--ui-spacing) * 48)}.ui\:h-96{height:calc(var(--ui-spacing) * 96)}.ui\:h-128{height:calc(var(--ui-spacing) * 128)}.ui\:h-\[1\.2rem\]{height:1.2rem}.ui\:h-\[1\.15rem\]{height:1.15rem}.ui\:h-\[6px\]{height:6px}.ui\:h-\[70px\]{height:70px}.ui\:h-\[280px\]{height:280px}.ui\:h-\[calc\(100\%-1px\)\]{height:calc(100% - 1px)}.ui\:h-\[calc\(100\%-3px\)\]{height:calc(100% - 3px)}.ui\:h-auto{height:auto}.ui\:h-fit{height:fit-content}.ui\:h-fit\!{height:fit-content!important}.ui\:h-full{height:100%}.ui\:h-px{height:1px}.ui\:h-screen{height:100vh}.ui\:max-h-\(--bits-dropdown-menu-content-available-height\){max-height:var(--bits-dropdown-menu-content-available-height)}.ui\:max-h-\(--bits-select-content-available-height\){max-height:var(--bits-select-content-available-height)}.ui\:max-h-64{max-height:calc(var(--ui-spacing) * 64)}.ui\:max-h-72{max-height:calc(var(--ui-spacing) * 72)}.ui\:max-h-80{max-height:calc(var(--ui-spacing) * 80)}.ui\:max-h-90{max-height:calc(var(--ui-spacing) * 90)}.ui\:max-h-96{max-height:calc(var(--ui-spacing) * 96)}.ui\:max-h-\[300px\]{max-height:300px}.ui\:max-h-svh{max-height:100svh}.ui\:min-h-0{min-height:calc(var(--ui-spacing) * 0)}.ui\:min-h-4{min-height:calc(var(--ui-spacing) * 4)}.ui\:min-h-16{min-height:calc(var(--ui-spacing) * 16)}.ui\:min-h-96{min-height:calc(var(--ui-spacing) * 96)}.ui\:min-h-\[44px\]{min-height:44px}.ui\:min-h-\[calc\(100vh-48px\)\]{min-height:calc(100vh - 48px)}.ui\:w-\(--sidebar-width\){width:var(--sidebar-width)}.ui\:w-0{width:calc(var(--ui-spacing) * 0)}.ui\:w-1{width:calc(var(--ui-spacing) * 1)}.ui\:w-1\/4{width:25%}.ui\:w-2{width:calc(var(--ui-spacing) * 2)}.ui\:w-2\/4{width:50%}.ui\:w-3\/4{width:75%}.ui\:w-4{width:calc(var(--ui-spacing) * 4)}.ui\:w-5{width:calc(var(--ui-spacing) * 5)}.ui\:w-6{width:calc(var(--ui-spacing) * 6)}.ui\:w-7{width:calc(var(--ui-spacing) * 7)}.ui\:w-8{width:calc(var(--ui-spacing) * 8)}.ui\:w-24{width:calc(var(--ui-spacing) * 24)}.ui\:w-28{width:calc(var(--ui-spacing) * 28)}.ui\:w-40{width:calc(var(--ui-spacing) * 40)}.ui\:w-64{width:calc(var(--ui-spacing) * 64)}.ui\:w-72{width:calc(var(--ui-spacing) * 72)}.ui\:w-88{width:calc(var(--ui-spacing) * 88)}.ui\:w-\[1\.2rem\]{width:1.2rem}.ui\:w-\[25px\]{width:25px}.ui\:w-\[100px\]{width:100px}.ui\:w-fit{width:fit-content}.ui\:w-fit\!{width:fit-content!important}.ui\:w-full{width:100%}.ui\:w-full\!{width:100%!important}.ui\:w-max{width:max-content}.ui\:w-screen{width:100vw}.ui\:max-w-\(--skeleton-width\){max-width:var(--skeleton-width)}.ui\:max-w-3xl{max-width:var(--ui-container-3xl)}.ui\:max-w-6{max-width:calc(var(--ui-spacing) * 6)}.ui\:max-w-80{max-width:calc(var(--ui-spacing) * 80)}.ui\:max-w-\[60\%\]{max-width:60%}.ui\:max-w-\[200px\]{max-width:200px}.ui\:max-w-\[300px\]{max-width:300px}.ui\:max-w-\[calc\(100\%-2rem\)\]{max-width:calc(100% - 2rem)}.ui\:max-w-full{max-width:100%}.ui\:max-w-max{max-width:max-content}.ui\:max-w-sm{max-width:var(--ui-container-sm)}.ui\:max-w-xl{max-width:var(--ui-container-xl)}.ui\:min-w-\(--bits-select-anchor-width\){min-width:var(--bits-select-anchor-width)}.ui\:min-w-0{min-width:calc(var(--ui-spacing) * 0)}.ui\:min-w-5{min-width:calc(var(--ui-spacing) * 5)}.ui\:min-w-8{min-width:calc(var(--ui-spacing) * 8)}.ui\:min-w-9{min-width:calc(var(--ui-spacing) * 9)}.ui\:min-w-10{min-width:calc(var(--ui-spacing) * 10)}.ui\:min-w-32{min-width:calc(var(--ui-spacing) * 32)}.ui\:min-w-48{min-width:calc(var(--ui-spacing) * 48)}.ui\:min-w-\[9rem\]{min-width:9rem}.ui\:min-w-full{min-width:100%}.ui\:flex-1{flex:1}.ui\:shrink{flex-shrink:1}.ui\:shrink-0{flex-shrink:0}.ui\:basis-full{flex-basis:100%}.ui\:origin-\(--bits-dropdown-menu-content-transform-origin\){transform-origin:var(--bits-dropdown-menu-content-transform-origin)}.ui\:origin-\(--bits-menubar-content-transform-origin\){transform-origin:var(--bits-menubar-content-transform-origin)}.ui\:origin-\(--bits-popover-content-transform-origin\){transform-origin:var(--bits-popover-content-transform-origin)}.ui\:origin-\(--bits-select-content-transform-origin\){transform-origin:var(--bits-select-content-transform-origin)}.ui\:origin-\(--bits-tooltip-content-transform-origin\){transform-origin:var(--bits-tooltip-content-transform-origin)}.ui\:-translate-x-1\/2{--tw-translate-x:calc(calc(1 / 2 * 100%) * -1);translate:var(--tw-translate-x) var(--tw-translate-y)}.ui\:-translate-x-px{--tw-translate-x:-1px;translate:var(--tw-translate-x) var(--tw-translate-y)}.ui\:translate-x-\[-50\%\]{--tw-translate-x:-50%;translate:var(--tw-translate-x) var(--tw-translate-y)}.ui\:translate-x-px{--tw-translate-x:1px;translate:var(--tw-translate-x) var(--tw-translate-y)}.ui\:-translate-y-1\/2{--tw-translate-y:calc(calc(1 / 2 * 100%) * -1);translate:var(--tw-translate-x) var(--tw-translate-y)}.ui\:translate-y-0\.5{--tw-translate-y:calc(var(--ui-spacing) * .5);translate:var(--tw-translate-x) var(--tw-translate-y)}.ui\:translate-y-\[-50\%\]{--tw-translate-y:-50%;translate:var(--tw-translate-x) var(--tw-translate-y)}.ui\:scale-0{--tw-scale-x:0%;--tw-scale-y:0%;--tw-scale-z:0%;scale:var(--tw-scale-x) var(--tw-scale-y)}.ui\:scale-100{--tw-scale-x:100%;--tw-scale-y:100%;--tw-scale-z:100%;scale:var(--tw-scale-x) var(--tw-scale-y)}.ui\:rotate-0{rotate:none}.ui\:rotate-5{rotate:5deg}.ui\:rotate-45{rotate:45deg}.ui\:rotate-90{rotate:90deg}.ui\:animate-in{animation:enter var(--tw-animation-duration,var(--tw-duration,.15s))var(--tw-ease,ease)var(--tw-animation-delay,0s)var(--tw-animation-iteration-count,1)var(--tw-animation-direction,normal)var(--tw-animation-fill-mode,none)}.ui\:animate-pulse{animation:var(--ui-animate-pulse)}.ui\:animate-spin{animation:var(--ui-animate-spin)}.ui\:cursor-auto{cursor:auto}.ui\:cursor-col-resize{cursor:col-resize}.ui\:cursor-default{cursor:default}.ui\:cursor-default\!{cursor:default!important}.ui\:cursor-grab{cursor:grab}.ui\:cursor-not-allowed{cursor:not-allowed}.ui\:cursor-pointer{cursor:pointer}.ui\:cursor-text{cursor:text}.ui\:resize-none{resize:none}.ui\:scroll-my-1{scroll-margin-block:calc(var(--ui-spacing) * 1)}.ui\:scroll-py-1{scroll-padding-block:calc(var(--ui-spacing) * 1)}.ui\:list-disc{list-style-type:disc}.ui\:list-none{list-style-type:none}.ui\:auto-rows-min{grid-auto-rows:min-content}.ui\:grid-cols-2{grid-template-columns:repeat(2,minmax(0,1fr))}.ui\:grid-cols-\[0_1fr\]{grid-template-columns:0 1fr}.ui\:grid-rows-\[auto_auto\]{grid-template-rows:auto auto}.ui\:flex-col{flex-direction:column}.ui\:flex-col-reverse{flex-direction:column-reverse}.ui\:flex-row{flex-direction:row}.ui\:flex-wrap{flex-wrap:wrap}.ui\:place-items-center{place-items:center}.ui\:items-baseline{align-items:baseline}.ui\:items-center{align-items:center}.ui\:items-end{align-items:flex-end}.ui\:items-start{align-items:flex-start}.ui\:items-stretch{align-items:stretch}.ui\:justify-between{justify-content:space-between}.ui\:justify-center{justify-content:center}.ui\:justify-end{justify-content:flex-end}.ui\:justify-start{justify-content:flex-start}.ui\:justify-start\!{justify-content:flex-start!important}.ui\:justify-items-start{justify-items:start}.ui\:gap-0{gap:calc(var(--ui-spacing) * 0)}.ui\:gap-0\.5{gap:calc(var(--ui-spacing) * .5)}.ui\:gap-1{gap:calc(var(--ui-spacing) * 1)}.ui\:gap-1\.5{gap:calc(var(--ui-spacing) * 1.5)}.ui\:gap-2{gap:calc(var(--ui-spacing) * 2)}.ui\:gap-2\.5{gap:calc(var(--ui-spacing) * 2.5)}.ui\:gap-3{gap:calc(var(--ui-spacing) * 3)}.ui\:gap-4{gap:calc(var(--ui-spacing) * 4)}.ui\:gap-6{gap:calc(var(--ui-spacing) * 6)}.ui\:gap-7{gap:calc(var(--ui-spacing) * 7)}:where(.ui\:space-y-1>:not(:last-child)){--tw-space-y-reverse:0;margin-block-start:calc(calc(var(--ui-spacing) * 1) * var(--tw-space-y-reverse));margin-block-end:calc(calc(var(--ui-spacing) * 1) * calc(1 - var(--tw-space-y-reverse)))}:where(.ui\:space-y-2>:not(:last-child)){--tw-space-y-reverse:0;margin-block-start:calc(calc(var(--ui-spacing) * 2) * var(--tw-space-y-reverse));margin-block-end:calc(calc(var(--ui-spacing) * 2) * calc(1 - var(--tw-space-y-reverse)))}:where(.ui\:space-y-3>:not(:last-child)){--tw-space-y-reverse:0;margin-block-start:calc(calc(var(--ui-spacing) * 3) * var(--tw-space-y-reverse));margin-block-end:calc(calc(var(--ui-spacing) * 3) * calc(1 - var(--tw-space-y-reverse)))}:where(.ui\:space-y-4>:not(:last-child)){--tw-space-y-reverse:0;margin-block-start:calc(calc(var(--ui-spacing) * 4) * var(--tw-space-y-reverse));margin-block-end:calc(calc(var(--ui-spacing) * 4) * calc(1 - var(--tw-space-y-reverse)))}.ui\:gap-x-6{column-gap:calc(var(--ui-spacing) * 6)}.ui\:gap-y-0\.5{row-gap:calc(var(--ui-spacing) * .5)}.ui\:gap-y-2{row-gap:calc(var(--ui-spacing) * 2)}.ui\:self-start{align-self:flex-start}.ui\:self-stretch{align-self:stretch}.ui\:justify-self-end{justify-self:flex-end}.ui\:truncate{text-overflow:ellipsis;white-space:nowrap;overflow:hidden}.ui\:overflow-auto{overflow:auto}.ui\:overflow-hidden{overflow:hidden}.ui\:overflow-visible{overflow:visible}.ui\:overflow-x-auto{overflow-x:auto}.ui\:overflow-x-hidden{overflow-x:hidden}.ui\:overflow-y-auto{overflow-y:auto}.ui\:overflow-y-hidden{overflow-y:hidden}.ui\:scroll-smooth{scroll-behavior:smooth}.ui\:rounded{border-radius:.25rem}.ui\:rounded-\[2px\]{border-radius:2px}.ui\:rounded-\[4px\]{border-radius:4px}.ui\:rounded-\[calc\(var\(--radius\)-5px\)\]{border-radius:calc(var(--radius) - 5px)}.ui\:rounded-full{border-radius:3.40282e38px}.ui\:rounded-lg{border-radius:var(--radius)}.ui\:rounded-md{border-radius:calc(var(--radius) - 2px)}.ui\:rounded-none{border-radius:0}.ui\:rounded-sm{border-radius:calc(var(--radius) - 4px)}.ui\:rounded-xl{border-radius:calc(var(--radius) + 4px)}.ui\:rounded-xs{border-radius:var(--ui-radius-xs)}.ui\:border{border-style:var(--tw-border-style);border-width:1px}.ui\:border-0{border-style:var(--tw-border-style);border-width:0}.ui\:border-2{border-style:var(--tw-border-style);border-width:2px}.ui\:border-\[1\.5px\]{border-style:var(--tw-border-style);border-width:1.5px}.ui\:border-x-0{border-inline-style:var(--tw-border-style);border-inline-width:0}.ui\:border-t{border-top-style:var(--tw-border-style);border-top-width:1px}.ui\:border-r{border-right-style:var(--tw-border-style);border-right-width:1px}.ui\:border-b{border-bottom-style:var(--tw-border-style);border-bottom-width:1px}.ui\:border-l{border-left-style:var(--tw-border-style);border-left-width:1px}.ui\:border-dashed{--tw-border-style:dashed;border-style:dashed}.ui\:border-none{--tw-border-style:none;border-style:none}.ui\:border-\(--color-border\){border-color:var(--color-border)}.ui\:border-amber-200{border-color:var(--ui-color-amber-200)}.ui\:border-amber-400{border-color:var(--ui-color-amber-400)}.ui\:border-border,.ui\:border-border\/50{border-color:var(--border)}@supports (color:color-mix(in lab, red, red)){.ui\:border-border\/50{border-color:color-mix(in oklab, var(--border) 50%, transparent)}}.ui\:border-emerald-300{border-color:var(--ui-color-emerald-300)}.ui\:border-emerald-400{border-color:var(--ui-color-emerald-400)}.ui\:border-emerald-500{border-color:var(--ui-color-emerald-500)}.ui\:border-input{border-color:var(--input)}.ui\:border-muted{border-color:var(--muted)}.ui\:border-muted-foreground{border-color:var(--muted-foreground)}.ui\:border-primary\/30{border-color:var(--primary)}@supports (color:color-mix(in lab, red, red)){.ui\:border-primary\/30{border-color:color-mix(in oklab, var(--primary) 30%, transparent)}}.ui\:border-red-500{border-color:var(--ui-color-red-500)}.ui\:border-sidebar-border{border-color:var(--sidebar-border)}.ui\:border-sky-200{border-color:var(--ui-color-sky-200)}.ui\:border-transparent{border-color:#0000}.ui\:bg-\(--color-bg\){background-color:var(--color-bg)}.ui\:bg-accent{background-color:var(--accent)}.ui\:bg-amber-50,.ui\:bg-amber-50\/30{background-color:var(--ui-color-amber-50)}@supports (color:color-mix(in lab, red, red)){.ui\:bg-amber-50\/30{background-color:color-mix(in oklab, var(--ui-color-amber-50) 30%, transparent)}}.ui\:bg-amber-600{background-color:var(--ui-color-amber-600)}.ui\:bg-background,.ui\:bg-background\/50{background-color:var(--background)}@supports (color:color-mix(in lab, red, red)){.ui\:bg-background\/50{background-color:color-mix(in oklab, var(--background) 50%, transparent)}}.ui\:bg-black\/50{background-color:var(--ui-color-black)}@supports (color:color-mix(in lab, red, red)){.ui\:bg-black\/50{background-color:color-mix(in oklab, var(--ui-color-black) 50%, transparent)}}.ui\:bg-border{background-color:var(--border)}.ui\:bg-card{background-color:var(--card)}.ui\:bg-destructive{background-color:var(--destructive)}.ui\:bg-emerald-50\/20{background-color:var(--ui-color-emerald-50)}@supports (color:color-mix(in lab, red, red)){.ui\:bg-emerald-50\/20{background-color:color-mix(in oklab, var(--ui-color-emerald-50) 20%, transparent)}}.ui\:bg-emerald-50\/30{background-color:var(--ui-color-emerald-50)}@supports (color:color-mix(in lab, red, red)){.ui\:bg-emerald-50\/30{background-color:color-mix(in oklab, var(--ui-color-emerald-50) 30%, transparent)}}.ui\:bg-emerald-50\/40{background-color:var(--ui-color-emerald-50)}@supports (color:color-mix(in lab, red, red)){.ui\:bg-emerald-50\/40{background-color:color-mix(in oklab, var(--ui-color-emerald-50) 40%, transparent)}}.ui\:bg-emerald-600{background-color:var(--ui-color-emerald-600)}.ui\:bg-gray-200{background-color:var(--ui-color-gray-200)}.ui\:bg-green-500{background-color:var(--ui-color-green-500)}.ui\:bg-inherit{background-color:inherit}.ui\:bg-input{background-color:var(--input)}.ui\:bg-muted,.ui\:bg-muted\/50{background-color:var(--muted)}@supports (color:color-mix(in lab, red, red)){.ui\:bg-muted\/50{background-color:color-mix(in oklab, var(--muted) 50%, transparent)}}.ui\:bg-popover{background-color:var(--popover)}.ui\:bg-primary{background-color:var(--primary)}.ui\:bg-primary-foreground{background-color:var(--primary-foreground)}.ui\:bg-primary\/10{background-color:var(--primary)}@supports (color:color-mix(in lab, red, red)){.ui\:bg-primary\/10{background-color:color-mix(in oklab, var(--primary) 10%, transparent)}}.ui\:bg-primary\/20{background-color:var(--primary)}@supports (color:color-mix(in lab, red, red)){.ui\:bg-primary\/20{background-color:color-mix(in oklab, var(--primary) 20%, transparent)}}.ui\:bg-red-50\/40{background-color:var(--ui-color-red-50)}@supports (color:color-mix(in lab, red, red)){.ui\:bg-red-50\/40{background-color:color-mix(in oklab, var(--ui-color-red-50) 40%, transparent)}}.ui\:bg-red-500{background-color:var(--ui-color-red-500)}.ui\:bg-secondary,.ui\:bg-secondary\/50{background-color:var(--secondary)}@supports (color:color-mix(in lab, red, red)){.ui\:bg-secondary\/50{background-color:color-mix(in oklab, var(--secondary) 50%, transparent)}}.ui\:bg-sidebar{background-color:var(--sidebar)}.ui\:bg-sidebar-border{background-color:var(--sidebar-border)}.ui\:bg-sky-50{background-color:var(--ui-color-sky-50)}.ui\:bg-transparent{background-color:#0000}.ui\:bg-white{background-color:var(--ui-color-white)}.ui\:bg-yellow-500{background-color:var(--ui-color-yellow-500)}.ui\:bg-linear-to-r{--tw-gradient-position:to right}@supports (background-image:linear-gradient(in lab, red, red)){.ui\:bg-linear-to-r{--tw-gradient-position:to right in oklab}}.ui\:bg-linear-to-r{background-image:linear-gradient(var(--tw-gradient-stops))}.ui\:bg-linear-to-t{--tw-gradient-position:to top}@supports (background-image:linear-gradient(in lab, red, red)){.ui\:bg-linear-to-t{--tw-gradient-position:to top in oklab}}.ui\:bg-linear-to-t{background-image:linear-gradient(var(--tw-gradient-stops))}.ui\:from-background{--tw-gradient-from:var(--background);--tw-gradient-stops:var(--tw-gradient-via-stops,var(--tw-gradient-position), var(--tw-gradient-from) var(--tw-gradient-from-position), var(--tw-gradient-to) var(--tw-gradient-to-position))}.ui\:from-pink-500{--tw-gradient-from:var(--ui-color-pink-500);--tw-gradient-stops:var(--tw-gradient-via-stops,var(--tw-gradient-position), var(--tw-gradient-from) var(--tw-gradient-from-position), var(--tw-gradient-to) var(--tw-gradient-to-position))}.ui\:to-orange-500{--tw-gradient-to:var(--ui-color-orange-500);--tw-gradient-stops:var(--tw-gradient-via-stops,var(--tw-gradient-position), var(--tw-gradient-from) var(--tw-gradient-from-position), var(--tw-gradient-to) var(--tw-gradient-to-position))}.ui\:to-transparent{--tw-gradient-to:transparent;--tw-gradient-stops:var(--tw-gradient-via-stops,var(--tw-gradient-position), var(--tw-gradient-from) var(--tw-gradient-from-position), var(--tw-gradient-to) var(--tw-gradient-to-position))}.ui\:bg-clip-padding{background-clip:padding-box}.ui\:fill-current{fill:currentColor}.ui\:fill-primary{fill:var(--primary)}.ui\:object-cover{object-fit:cover}.ui\:p-0{padding:calc(var(--ui-spacing) * 0)}.ui\:p-0\.5{padding:calc(var(--ui-spacing) * .5)}.ui\:p-1{padding:calc(var(--ui-spacing) * 1)}.ui\:p-2{padding:calc(var(--ui-spacing) * 2)}.ui\:p-3{padding:calc(var(--ui-spacing) * 3)}.ui\:p-3\!{padding:calc(var(--ui-spacing) * 3)!important}.ui\:p-4{padding:calc(var(--ui-spacing) * 4)}.ui\:p-6{padding:calc(var(--ui-spacing) * 6)}.ui\:p-8{padding:calc(var(--ui-spacing) * 8)}.ui\:p-\[3px\]{padding:3px}.ui\:px-1{padding-inline:calc(var(--ui-spacing) * 1)}.ui\:px-1\.5{padding-inline:calc(var(--ui-spacing) * 1.5)}.ui\:px-2{padding-inline:calc(var(--ui-spacing) * 2)}.ui\:px-2\.5{padding-inline:calc(var(--ui-spacing) * 2.5)}.ui\:px-3{padding-inline:calc(var(--ui-spacing) * 3)}.ui\:px-4{padding-inline:calc(var(--ui-spacing) * 4)}.ui\:px-6{padding-inline:calc(var(--ui-spacing) * 6)}.ui\:py-0\.5{padding-block:calc(var(--ui-spacing) * .5)}.ui\:py-1{padding-block:calc(var(--ui-spacing) * 1)}.ui\:py-1\.5{padding-block:calc(var(--ui-spacing) * 1.5)}.ui\:py-2{padding-block:calc(var(--ui-spacing) * 2)}.ui\:py-3{padding-block:calc(var(--ui-spacing) * 3)}.ui\:py-4{padding-block:calc(var(--ui-spacing) * 4)}.ui\:py-6{padding-block:calc(var(--ui-spacing) * 6)}.ui\:ps-3{padding-inline-start:calc(var(--ui-spacing) * 3)}.ui\:pe-3{padding-inline-end:calc(var(--ui-spacing) * 3)}.ui\:pt-0{padding-top:calc(var(--ui-spacing) * 0)}.ui\:pt-1\.5{padding-top:calc(var(--ui-spacing) * 1.5)}.ui\:pt-3{padding-top:calc(var(--ui-spacing) * 3)}.ui\:pt-3\!{padding-top:calc(var(--ui-spacing) * 3)!important}.ui\:pr-1{padding-right:calc(var(--ui-spacing) * 1)}.ui\:pr-2{padding-right:calc(var(--ui-spacing) * 2)}.ui\:pr-8{padding-right:calc(var(--ui-spacing) * 8)}.ui\:pr-9{padding-right:calc(var(--ui-spacing) * 9)}.ui\:pr-18{padding-right:calc(var(--ui-spacing) * 18)}.ui\:pb-3{padding-bottom:calc(var(--ui-spacing) * 3)}.ui\:pb-4{padding-bottom:calc(var(--ui-spacing) * 4)}.ui\:pl-2{padding-left:calc(var(--ui-spacing) * 2)}.ui\:pl-3{padding-left:calc(var(--ui-spacing) * 3)}.ui\:pl-8{padding-left:calc(var(--ui-spacing) * 8)}.ui\:text-center{text-align:center}.ui\:text-left{text-align:left}.ui\:text-right{text-align:right}.ui\:font-mono{font-family:var(--ui-font-mono)}.ui\:font-sans{font-family:var(--ui-font-sans)}.ui\:text-2xl{font-size:var(--ui-text-2xl);line-height:var(--tw-leading,var(--ui-text-2xl--line-height))}.ui\:text-base{font-size:var(--ui-text-base);line-height:var(--tw-leading,var(--ui-text-base--line-height))}.ui\:text-base\!{font-size:var(--ui-text-base)!important;line-height:var(--tw-leading,var(--ui-text-base--line-height))!important}.ui\:text-lg{font-size:var(--ui-text-lg);line-height:var(--tw-leading,var(--ui-text-lg--line-height))}.ui\:text-sm{font-size:var(--ui-text-sm);line-height:var(--tw-leading,var(--ui-text-sm--line-height))}.ui\:text-sm\/relaxed{font-size:var(--ui-text-sm);line-height:var(--ui-leading-relaxed)}.ui\:text-xl{font-size:var(--ui-text-xl);line-height:var(--tw-leading,var(--ui-text-xl--line-height))}.ui\:text-xs{font-size:var(--ui-text-xs);line-height:var(--tw-leading,var(--ui-text-xs--line-height))}.ui\:text-\[10px\]{font-size:10px}.ui\:leading-none{--tw-leading:1;line-height:1}.ui\:leading-normal{--tw-leading:var(--ui-leading-normal);line-height:var(--ui-leading-normal)}.ui\:leading-relaxed{--tw-leading:var(--ui-leading-relaxed);line-height:var(--ui-leading-relaxed)}.ui\:leading-snug{--tw-leading:var(--ui-leading-snug);line-height:var(--ui-leading-snug)}.ui\:font-bold{--tw-font-weight:var(--ui-font-weight-bold);font-weight:var(--ui-font-weight-bold)}.ui\:font-medium{--tw-font-weight:var(--ui-font-weight-medium);font-weight:var(--ui-font-weight-medium)}.ui\:font-normal{--tw-font-weight:var(--ui-font-weight-normal);font-weight:var(--ui-font-weight-normal)}.ui\:font-semibold{--tw-font-weight:var(--ui-font-weight-semibold);font-weight:var(--ui-font-weight-semibold)}.ui\:tracking-tight{--tw-tracking:var(--ui-tracking-tight);letter-spacing:var(--ui-tracking-tight)}.ui\:tracking-widest{--tw-tracking:var(--ui-tracking-widest);letter-spacing:var(--ui-tracking-widest)}.ui\:text-balance{text-wrap:balance}.ui\:break-words{overflow-wrap:break-word}.ui\:break-all{word-break:break-all}.ui\:text-ellipsis{text-overflow:ellipsis}.ui\:whitespace-nowrap{white-space:nowrap}.ui\:text-amber-600{color:var(--ui-color-amber-600)}.ui\:text-amber-900{color:var(--ui-color-amber-900)}.ui\:text-card-foreground{color:var(--card-foreground)}.ui\:text-current{color:currentColor}.ui\:text-destructive{color:var(--destructive)}.ui\:text-emerald-600{color:var(--ui-color-emerald-600)}.ui\:text-foreground,.ui\:text-foreground\/70{color:var(--foreground)}@supports (color:color-mix(in lab, red, red)){.ui\:text-foreground\/70{color:color-mix(in oklab, var(--foreground) 70%, transparent)}}.ui\:text-green-500{color:var(--ui-color-green-500)}.ui\:text-muted-foreground,.ui\:text-muted-foreground\/75{color:var(--muted-foreground)}@supports (color:color-mix(in lab, red, red)){.ui\:text-muted-foreground\/75{color:color-mix(in oklab, var(--muted-foreground) 75%, transparent)}}.ui\:text-popover-foreground{color:var(--popover-foreground)}.ui\:text-primary{color:var(--primary)}.ui\:text-primary-foreground{color:var(--primary-foreground)}.ui\:text-red-600{color:var(--ui-color-red-600)}.ui\:text-red-700{color:var(--ui-color-red-700)}.ui\:text-secondary-foreground{color:var(--secondary-foreground)}.ui\:text-sidebar-foreground,.ui\:text-sidebar-foreground\/70{color:var(--sidebar-foreground)}@supports (color:color-mix(in lab, red, red)){.ui\:text-sidebar-foreground\/70{color:color-mix(in oklab, var(--sidebar-foreground) 70%, transparent)}}.ui\:text-sky-900{color:var(--ui-color-sky-900)}.ui\:text-white{color:var(--ui-color-white)}.ui\:text-white\!{color:var(--ui-color-white)!important}.ui\:capitalize{text-transform:capitalize}.ui\:underline{text-decoration-line:underline}.ui\:underline-offset-4{text-underline-offset:4px}.ui\:opacity-0{opacity:0}.ui\:opacity-50{opacity:.5}.ui\:opacity-70{opacity:.7}.ui\:opacity-100{opacity:1}.ui\:shadow{--tw-shadow:0 1px 3px 0 var(--tw-shadow-color,#0000001a), 0 1px 2px -1px var(--tw-shadow-color,#0000001a);box-shadow:var(--tw-inset-shadow), var(--tw-inset-ring-shadow), var(--tw-ring-offset-shadow), var(--tw-ring-shadow), var(--tw-shadow)}.ui\:shadow-2xl{--tw-shadow:0 25px 50px -12px var(--tw-shadow-color,#00000040);box-shadow:var(--tw-inset-shadow), var(--tw-inset-ring-shadow), var(--tw-ring-offset-shadow), var(--tw-ring-shadow), var(--tw-shadow)}.ui\:shadow-2xs{--tw-shadow:0 1px var(--tw-shadow-color,#0000000d);box-shadow:var(--tw-inset-shadow), var(--tw-inset-ring-shadow), var(--tw-ring-offset-shadow), var(--tw-ring-shadow), var(--tw-shadow)}.ui\:shadow-\[0_0_0_1px_var\(--sidebar-border\)\]{--tw-shadow:0 0 0 1px var(--tw-shadow-color,var(--sidebar-border));box-shadow:var(--tw-inset-shadow), var(--tw-inset-ring-shadow), var(--tw-ring-offset-shadow), var(--tw-ring-shadow), var(--tw-shadow)}.ui\:shadow-lg{--tw-shadow:0 10px 15px -3px var(--tw-shadow-color,#0000001a), 0 4px 6px -4px var(--tw-shadow-color,#0000001a);box-shadow:var(--tw-inset-shadow), var(--tw-inset-ring-shadow), var(--tw-ring-offset-shadow), var(--tw-ring-shadow), var(--tw-shadow)}.ui\:shadow-md{--tw-shadow:0 4px 6px -1px var(--tw-shadow-color,#0000001a), 0 2px 4px -2px var(--tw-shadow-color,#0000001a);box-shadow:var(--tw-inset-shadow), var(--tw-inset-ring-shadow), var(--tw-ring-offset-shadow), var(--tw-ring-shadow), var(--tw-shadow)}.ui\:shadow-none{--tw-shadow:0 0 #0000;box-shadow:var(--tw-inset-shadow), var(--tw-inset-ring-shadow), var(--tw-ring-offset-shadow), var(--tw-ring-shadow), var(--tw-shadow)}.ui\:shadow-sm{--tw-shadow:0 1px 3px 0 var(--tw-shadow-color,#0000001a), 0 1px 2px -1px var(--tw-shadow-color,#0000001a);box-shadow:var(--tw-inset-shadow), var(--tw-inset-ring-shadow), var(--tw-ring-offset-shadow), var(--tw-ring-shadow), var(--tw-shadow)}.ui\:shadow-xl{--tw-shadow:0 20px 25px -5px var(--tw-shadow-color,#0000001a), 0 8px 10px -6px var(--tw-shadow-color,#0000001a);box-shadow:var(--tw-inset-shadow), var(--tw-inset-ring-shadow), var(--tw-ring-offset-shadow), var(--tw-ring-shadow), var(--tw-shadow)}.ui\:shadow-xs{--tw-shadow:0 1px 2px 0 var(--tw-shadow-color,#0000000d);box-shadow:var(--tw-inset-shadow), var(--tw-inset-ring-shadow), var(--tw-ring-offset-shadow), var(--tw-ring-shadow), var(--tw-shadow)}.ui\:ring-0{--tw-ring-shadow:var(--tw-ring-inset,) 0 0 0 calc(0px + var(--tw-ring-offset-width)) var(--tw-ring-color,currentcolor);box-shadow:var(--tw-inset-shadow), var(--tw-inset-ring-shadow), var(--tw-ring-offset-shadow), var(--tw-ring-shadow), var(--tw-shadow)}.ui\:ring-1{--tw-ring-shadow:var(--tw-ring-inset,) 0 0 0 calc(1px + var(--tw-ring-offset-width)) var(--tw-ring-color,currentcolor);box-shadow:var(--tw-inset-shadow), var(--tw-inset-ring-shadow), var(--tw-ring-offset-shadow), var(--tw-ring-shadow), var(--tw-shadow)}.ui\:ring-2{--tw-ring-shadow:var(--tw-ring-inset,) 0 0 0 calc(2px + var(--tw-ring-offset-width)) var(--tw-ring-color,currentcolor);box-shadow:var(--tw-inset-shadow), var(--tw-inset-ring-shadow), var(--tw-ring-offset-shadow), var(--tw-ring-shadow), var(--tw-shadow)}.ui\:ring-3{--tw-ring-shadow:var(--tw-ring-inset,) 0 0 0 calc(3px + var(--tw-ring-offset-width)) var(--tw-ring-color,currentcolor);box-shadow:var(--tw-inset-shadow), var(--tw-inset-ring-shadow), var(--tw-ring-offset-shadow), var(--tw-ring-shadow), var(--tw-shadow)}.ui\:ring-accent{--tw-ring-color:var(--accent)}.ui\:ring-background{--tw-ring-color:var(--background)}.ui\:ring-border\/50{--tw-ring-color:var(--border)}@supports (color:color-mix(in lab, red, red)){.ui\:ring-border\/50{--tw-ring-color:color-mix(in oklab, var(--border) 50%, transparent)}}.ui\:ring-sidebar-ring{--tw-ring-color:var(--sidebar-ring)}.ui\:ring-offset-2{--tw-ring-offset-width:2px;--tw-ring-offset-shadow:var(--tw-ring-inset,) 0 0 0 var(--tw-ring-offset-width) var(--tw-ring-offset-color)}.ui\:ring-offset-background{--tw-ring-offset-color:var(--background)}.ui\:outline-hidden{--tw-outline-style:none;outline-style:none}@media (forced-colors:active){.ui\:outline-hidden{outline-offset:2px;outline:2px solid #0000}}.ui\:backdrop-blur-sm{--tw-backdrop-blur:blur(var(--ui-blur-sm));-webkit-backdrop-filter:var(--tw-backdrop-blur,) var(--tw-backdrop-brightness,) var(--tw-backdrop-contrast,) var(--tw-backdrop-grayscale,) var(--tw-backdrop-hue-rotate,) var(--tw-backdrop-invert,) var(--tw-backdrop-opacity,) var(--tw-backdrop-saturate,) var(--tw-backdrop-sepia,);backdrop-filter:var(--tw-backdrop-blur,) var(--tw-backdrop-brightness,) var(--tw-backdrop-contrast,) var(--tw-backdrop-grayscale,) var(--tw-backdrop-hue-rotate,) var(--tw-backdrop-invert,) var(--tw-backdrop-opacity,) var(--tw-backdrop-saturate,) var(--tw-backdrop-sepia,)}.ui\:transition{transition-property:color,background-color,border-color,outline-color,text-decoration-color,fill,stroke,--tw-gradient-from,--tw-gradient-via,--tw-gradient-to,opacity,box-shadow,transform,translate,scale,rotate,filter,-webkit-backdrop-filter,backdrop-filter,display,content-visibility,overlay,pointer-events;transition-timing-function:var(--tw-ease,var(--ui-default-transition-timing-function));transition-duration:var(--tw-duration,var(--ui-default-transition-duration))}.ui\:transition-\[color\,box-shadow\]{transition-property:color,box-shadow;transition-timing-function:var(--tw-ease,var(--ui-default-transition-timing-function));transition-duration:var(--tw-duration,var(--ui-default-transition-duration))}.ui\:transition-\[left\,right\,width\]{transition-property:left,right,width;transition-timing-function:var(--tw-ease,var(--ui-default-transition-timing-function));transition-duration:var(--tw-duration,var(--ui-default-transition-duration))}.ui\:transition-\[margin\,opacity\]{transition-property:margin,opacity;transition-timing-function:var(--tw-ease,var(--ui-default-transition-timing-function));transition-duration:var(--tw-duration,var(--ui-default-transition-duration))}.ui\:transition-\[width\,height\,padding\]{transition-property:width,height,padding;transition-timing-function:var(--tw-ease,var(--ui-default-transition-timing-function));transition-duration:var(--tw-duration,var(--ui-default-transition-duration))}.ui\:transition-\[width\]{transition-property:width;transition-timing-function:var(--tw-ease,var(--ui-default-transition-timing-function));transition-duration:var(--tw-duration,var(--ui-default-transition-duration))}.ui\:transition-all{transition-property:all;transition-timing-function:var(--tw-ease,var(--ui-default-transition-timing-function));transition-duration:var(--tw-duration,var(--ui-default-transition-duration))}.ui\:transition-colors{transition-property:color,background-color,border-color,outline-color,text-decoration-color,fill,stroke,--tw-gradient-from,--tw-gradient-via,--tw-gradient-to;transition-timing-function:var(--tw-ease,var(--ui-default-transition-timing-function));transition-duration:var(--tw-duration,var(--ui-default-transition-duration))}.ui\:transition-opacity{transition-property:opacity;transition-timing-function:var(--tw-ease,var(--ui-default-transition-timing-function));transition-duration:var(--tw-duration,var(--ui-default-transition-duration))}.ui\:transition-shadow{transition-property:box-shadow;transition-timing-function:var(--tw-ease,var(--ui-default-transition-timing-function));transition-duration:var(--tw-duration,var(--ui-default-transition-duration))}.ui\:transition-transform{transition-property:transform,translate,scale,rotate;transition-timing-function:var(--tw-ease,var(--ui-default-transition-timing-function));transition-duration:var(--tw-duration,var(--ui-default-transition-duration))}.ui\:transition-none{transition-property:none}.ui\:duration-100{--tw-duration:.1s;transition-duration:.1s}.ui\:duration-200{--tw-duration:.2s;transition-duration:.2s}.ui\:duration-300{--tw-duration:.3s;transition-duration:.3s}.ui\:duration-500{--tw-duration:.5s;transition-duration:.5s}.ui\:ease-in-out{--tw-ease:var(--ui-ease-in-out);transition-timing-function:var(--ui-ease-in-out)}.ui\:ease-linear{--tw-ease:linear;transition-timing-function:linear}.ui\:fade-in-0{--tw-enter-opacity:0}.ui\:outline-none{--tw-outline-style:none;outline-style:none}.ui\:select-none{-webkit-user-select:none;user-select:none}.ui\:zoom-in-95{--tw-enter-scale:.95}.ui\:ring-inset{--tw-ring-inset:inset}:is(.ui\:\*\:w-full>*){width:100%}.ui\:group-focus-within\/menu-item\:opacity-100:is(:where(.ui\:group\/menu-item):focus-within *){opacity:1}@media (hover:hover){.ui\:group-hover\:opacity-100:is(:where(.ui\:group):hover *),.ui\:group-hover\/menu-item\:opacity-100:is(:where(.ui\:group\/menu-item):hover *){opacity:1}}.ui\:group-has-data-\[orientation\=horizontal\]\/field\:text-balance:is(:where(.ui\:group\/field):has([data-orientation=horizontal]) *){text-wrap:balance}.ui\:group-has-data-\[sidebar\=menu-action\]\/menu-item\:pr-8:is(:where(.ui\:group\/menu-item):has([data-sidebar=menu-action]) *){padding-right:calc(var(--ui-spacing) * 8)}.ui\:group-has-\[\[data-slot\=item-description\]\]\/item\:translate-y-0\.5:is(:where(.ui\:group\/item):has([data-slot=item-description]) *){--tw-translate-y:calc(var(--ui-spacing) * .5);translate:var(--tw-translate-x) var(--tw-translate-y)}.ui\:group-has-\[\[data-slot\=item-description\]\]\/item\:self-start:is(:where(.ui\:group\/item):has([data-slot=item-description]) *){align-self:flex-start}.ui\:group-has-\[\>input\]\/input-group\:pt-2\.5:is(:where(.ui\:group\/input-group):has(>input) *){padding-top:calc(var(--ui-spacing) * 2.5)}.ui\:group-has-\[\>input\]\/input-group\:pb-2\.5:is(:where(.ui\:group\/input-group):has(>input) *){padding-bottom:calc(var(--ui-spacing) * 2.5)}.ui\:group-data-\[collapsible\=icon\]\:-mt-8:is(:where(.ui\:group)[data-collapsible=icon] *){margin-top:calc(var(--ui-spacing) * -8)}.ui\:group-data-\[collapsible\=icon\]\:hidden:is(:where(.ui\:group)[data-collapsible=icon] *){display:none}.ui\:group-data-\[collapsible\=icon\]\:size-8\!:is(:where(.ui\:group)[data-collapsible=icon] *){width:calc(var(--ui-spacing) * 8)!important;height:calc(var(--ui-spacing) * 8)!important}.ui\:group-data-\[collapsible\=icon\]\:w-\(--sidebar-width-icon\):is(:where(.ui\:group)[data-collapsible=icon] *){width:var(--sidebar-width-icon)}.ui\:group-data-\[collapsible\=icon\]\:w-\[calc\(var\(--sidebar-width-icon\)\+\(--spacing\(4\)\)\+2px\)\]:is(:where(.ui\:group)[data-collapsible=icon] *){width:calc(var(--sidebar-width-icon) + (calc(var(--ui-spacing) * 4)) + 2px)}.ui\:group-data-\[collapsible\=icon\]\:overflow-hidden:is(:where(.ui\:group)[data-collapsible=icon] *){overflow:hidden}.ui\:group-data-\[collapsible\=icon\]\:p-0\!:is(:where(.ui\:group)[data-collapsible=icon] *){padding:calc(var(--ui-spacing) * 0)!important}.ui\:group-data-\[collapsible\=icon\]\:p-2\!:is(:where(.ui\:group)[data-collapsible=icon] *){padding:calc(var(--ui-spacing) * 2)!important}.ui\:group-data-\[collapsible\=icon\]\:opacity-0:is(:where(.ui\:group)[data-collapsible=icon] *){opacity:0}.ui\:group-data-\[collapsible\=offcanvas\]\:right-\[calc\(var\(--sidebar-width\)\*-1\)\]:is(:where(.ui\:group)[data-collapsible=offcanvas] *){right:calc(var(--sidebar-width) * -1)}.ui\:group-data-\[collapsible\=offcanvas\]\:left-\[calc\(var\(--sidebar-width\)\*-1\)\]:is(:where(.ui\:group)[data-collapsible=offcanvas] *){left:calc(var(--sidebar-width) * -1)}.ui\:group-data-\[collapsible\=offcanvas\]\:w-0:is(:where(.ui\:group)[data-collapsible=offcanvas] *){width:calc(var(--ui-spacing) * 0)}.ui\:group-data-\[collapsible\=offcanvas\]\:translate-x-0:is(:where(.ui\:group)[data-collapsible=offcanvas] *){--tw-translate-x:calc(var(--ui-spacing) * 0);translate:var(--tw-translate-x) var(--tw-translate-y)}.ui\:group-data-\[disabled\=true\]\:pointer-events-none:is(:where(.ui\:group)[data-disabled=true] *){pointer-events:none}.ui\:group-data-\[disabled\=true\]\:opacity-50:is(:where(.ui\:group)[data-disabled=true] *),.ui\:group-data-\[disabled\=true\]\/field\:opacity-50:is(:where(.ui\:group\/field)[data-disabled=true] *),.ui\:group-data-\[disabled\=true\]\/input-group\:opacity-50:is(:where(.ui\:group\/input-group)[data-disabled=true] *){opacity:.5}.ui\:group-data-\[side\=left\]\:-right-4:is(:where(.ui\:group)[data-side=left] *){right:calc(var(--ui-spacing) * -4)}.ui\:group-data-\[side\=left\]\:border-r:is(:where(.ui\:group)[data-side=left] *){border-right-style:var(--tw-border-style);border-right-width:1px}.ui\:group-data-\[side\=right\]\:left-0:is(:where(.ui\:group)[data-side=right] *){left:calc(var(--ui-spacing) * 0)}.ui\:group-data-\[side\=right\]\:rotate-180:is(:where(.ui\:group)[data-side=right] *){rotate:180deg}.ui\:group-data-\[side\=right\]\:border-l:is(:where(.ui\:group)[data-side=right] *){border-left-style:var(--tw-border-style);border-left-width:1px}.ui\:group-data-\[variant\=floating\]\:rounded-lg:is(:where(.ui\:group)[data-variant=floating] *){border-radius:var(--radius)}.ui\:group-data-\[variant\=floating\]\:border:is(:where(.ui\:group)[data-variant=floating] *){border-style:var(--tw-border-style);border-width:1px}.ui\:group-data-\[variant\=floating\]\:border-sidebar-border:is(:where(.ui\:group)[data-variant=floating] *){border-color:var(--sidebar-border)}.ui\:group-data-\[variant\=floating\]\:shadow-sm:is(:where(.ui\:group)[data-variant=floating] *){--tw-shadow:0 1px 3px 0 var(--tw-shadow-color,#0000001a), 0 1px 2px -1px var(--tw-shadow-color,#0000001a);box-shadow:var(--tw-inset-shadow), var(--tw-inset-ring-shadow), var(--tw-ring-offset-shadow), var(--tw-ring-shadow), var(--tw-shadow)}.ui\:group-data-\[variant\=outline\]\/field-group\:-mb-2:is(:where(.ui\:group\/field-group)[data-variant=outline] *){margin-bottom:calc(var(--ui-spacing) * -2)}.ui\:group-data-\[vaul-drawer-direction\=bottom\]\/drawer-content\:block:is(:where(.ui\:group\/drawer-content)[data-vaul-drawer-direction=bottom] *){display:block}.ui\:group-data-\[viewport\=false\]\/navigation-menu\:top-full:is(:where(.ui\:group\/navigation-menu)[data-viewport=false] *){top:100%}.ui\:group-data-\[viewport\=false\]\/navigation-menu\:mt-1\.5:is(:where(.ui\:group\/navigation-menu)[data-viewport=false] *){margin-top:calc(var(--ui-spacing) * 1.5)}.ui\:group-data-\[viewport\=false\]\/navigation-menu\:overflow-hidden:is(:where(.ui\:group\/navigation-menu)[data-viewport=false] *){overflow:hidden}.ui\:group-data-\[viewport\=false\]\/navigation-menu\:rounded-md:is(:where(.ui\:group\/navigation-menu)[data-viewport=false] *){border-radius:calc(var(--radius) - 2px)}.ui\:group-data-\[viewport\=false\]\/navigation-menu\:border:is(:where(.ui\:group\/navigation-menu)[data-viewport=false] *){border-style:var(--tw-border-style);border-width:1px}.ui\:group-data-\[viewport\=false\]\/navigation-menu\:bg-popover:is(:where(.ui\:group\/navigation-menu)[data-viewport=false] *){background-color:var(--popover)}.ui\:group-data-\[viewport\=false\]\/navigation-menu\:text-popover-foreground:is(:where(.ui\:group\/navigation-menu)[data-viewport=false] *){color:var(--popover-foreground)}.ui\:group-data-\[viewport\=false\]\/navigation-menu\:shadow:is(:where(.ui\:group\/navigation-menu)[data-viewport=false] *){--tw-shadow:0 1px 3px 0 var(--tw-shadow-color,#0000001a), 0 1px 2px -1px var(--tw-shadow-color,#0000001a);box-shadow:var(--tw-inset-shadow), var(--tw-inset-ring-shadow), var(--tw-ring-offset-shadow), var(--tw-ring-shadow), var(--tw-shadow)}.ui\:group-data-\[viewport\=false\]\/navigation-menu\:duration-200:is(:where(.ui\:group\/navigation-menu)[data-viewport=false] *){--tw-duration:.2s;transition-duration:.2s}@media (hover:hover){.ui\:peer-hover\/menu-button\:text-sidebar-accent-foreground:is(:where(.ui\:peer\/menu-button):hover~*){color:var(--sidebar-accent-foreground)}}.ui\:peer-disabled\:cursor-not-allowed:is(:where(.ui\:peer):disabled~*){cursor:not-allowed}.ui\:peer-disabled\:opacity-50:is(:where(.ui\:peer):disabled~*){opacity:.5}.ui\:peer-data-\[active\=true\]\/menu-button\:text-sidebar-accent-foreground:is(:where(.ui\:peer\/menu-button)[data-active=true]~*){color:var(--sidebar-accent-foreground)}.ui\:peer-data-\[size\=default\]\/menu-button\:top-1\.5:is(:where(.ui\:peer\/menu-button)[data-size=default]~*){top:calc(var(--ui-spacing) * 1.5)}.ui\:peer-data-\[size\=lg\]\/menu-button\:top-2\.5:is(:where(.ui\:peer\/menu-button)[data-size=lg]~*){top:calc(var(--ui-spacing) * 2.5)}.ui\:peer-data-\[size\=sm\]\/menu-button\:top-1:is(:where(.ui\:peer\/menu-button)[data-size=sm]~*){top:calc(var(--ui-spacing) * 1)}.ui\:selection\:bg-primary ::selection{background-color:var(--primary)}.ui\:selection\:bg-primary::selection{background-color:var(--primary)}.ui\:selection\:text-primary-foreground ::selection{color:var(--primary-foreground)}.ui\:selection\:text-primary-foreground::selection{color:var(--primary-foreground)}.ui\:placeholder\:text-muted-foreground::placeholder{color:var(--muted-foreground)}.ui\:after\:absolute:after{content:var(--tw-content);position:absolute}.ui\:after\:-inset-2:after{content:var(--tw-content);inset:calc(var(--ui-spacing) * -2)}.ui\:after\:inset-y-0:after{content:var(--tw-content);inset-block:calc(var(--ui-spacing) * 0)}.ui\:after\:left-\[calc\(1\/2\*100\%-1px\)\]:after{content:var(--tw-content);left:calc(50% - 1px)}.ui\:after\:w-\[2px\]:after{content:var(--tw-content);width:2px}.ui\:group-data-\[collapsible\=offcanvas\]\:after\:left-full:is(:where(.ui\:group)[data-collapsible=offcanvas] *):after{content:var(--tw-content);left:100%}.ui\:last\:mt-0:last-child{margin-top:calc(var(--ui-spacing) * 0)}.ui\:last\:border-b-0:last-child{border-bottom-style:var(--tw-border-style);border-bottom-width:0}@media (hover:hover){.ui\:hover\:cursor-pointer:hover{cursor:pointer}.ui\:hover\:border:hover{border-style:var(--tw-border-style);border-width:1px}.ui\:hover\:bg-accent:hover,.ui\:hover\:bg-accent\/25:hover{background-color:var(--accent)}@supports (color:color-mix(in lab, red, red)){.ui\:hover\:bg-accent\/25:hover{background-color:color-mix(in oklab, var(--accent) 25%, transparent)}}.ui\:hover\:bg-muted:hover{background-color:var(--muted)}.ui\:hover\:bg-sidebar-accent:hover{background-color:var(--sidebar-accent)}.ui\:hover\:bg-transparent\!:hover{background-color:#0000!important}.ui\:hover\:text-accent-foreground:hover{color:var(--accent-foreground)}.ui\:hover\:text-foreground:hover{color:var(--foreground)}.ui\:hover\:text-muted-foreground:hover{color:var(--muted-foreground)}.ui\:hover\:text-sidebar-accent-foreground:hover{color:var(--sidebar-accent-foreground)}.ui\:hover\:underline:hover{text-decoration-line:underline}.ui\:hover\:opacity-100:hover{opacity:1}.ui\:hover\:shadow-2xs:hover{--tw-shadow:0 1px var(--tw-shadow-color,#0000000d);box-shadow:var(--tw-inset-shadow), var(--tw-inset-ring-shadow), var(--tw-ring-offset-shadow), var(--tw-ring-shadow), var(--tw-shadow)}.ui\:hover\:shadow-\[0_0_0_1px_var\(--sidebar-accent\)\]:hover{--tw-shadow:0 0 0 1px var(--tw-shadow-color,var(--sidebar-accent));box-shadow:var(--tw-inset-shadow), var(--tw-inset-ring-shadow), var(--tw-ring-offset-shadow), var(--tw-ring-shadow), var(--tw-shadow)}.ui\:hover\:shadow-md:hover{--tw-shadow:0 4px 6px -1px var(--tw-shadow-color,#0000001a), 0 2px 4px -2px var(--tw-shadow-color,#0000001a);box-shadow:var(--tw-inset-shadow), var(--tw-inset-ring-shadow), var(--tw-ring-offset-shadow), var(--tw-ring-shadow), var(--tw-shadow)}.ui\:hover\:group-data-\[collapsible\=offcanvas\]\:bg-sidebar:hover:is(:where(.ui\:group)[data-collapsible=offcanvas] *){background-color:var(--sidebar)}.ui\:hover\:after\:bg-sidebar-border:hover:after{content:var(--tw-content);background-color:var(--sidebar-border)}}.ui\:focus\:bg-accent:focus{background-color:var(--accent)}.ui\:focus\:text-accent-foreground:focus{color:var(--accent-foreground)}.ui\:focus\:ring-2:focus{--tw-ring-shadow:var(--tw-ring-inset,) 0 0 0 calc(2px + var(--tw-ring-offset-width)) var(--tw-ring-color,currentcolor);box-shadow:var(--tw-inset-shadow), var(--tw-inset-ring-shadow), var(--tw-ring-offset-shadow), var(--tw-ring-shadow), var(--tw-shadow)}.ui\:focus\:ring-ring:focus{--tw-ring-color:var(--ring)}.ui\:focus\:ring-offset-2:focus{--tw-ring-offset-width:2px;--tw-ring-offset-shadow:var(--tw-ring-inset,) 0 0 0 var(--tw-ring-offset-width) var(--tw-ring-offset-color)}.ui\:focus\:outline-hidden:focus{--tw-outline-style:none;outline-style:none}@media (forced-colors:active){.ui\:focus\:outline-hidden:focus{outline-offset:2px;outline:2px solid #0000}}.ui\:focus\:outline-none:focus{--tw-outline-style:none;outline-style:none}.ui\:focus-visible\:border-ring:focus-visible{border-color:var(--ring)}.ui\:focus-visible\:ring-0:focus-visible{--tw-ring-shadow:var(--tw-ring-inset,) 0 0 0 calc(0px + var(--tw-ring-offset-width)) var(--tw-ring-color,currentcolor);box-shadow:var(--tw-inset-shadow), var(--tw-inset-ring-shadow), var(--tw-ring-offset-shadow), var(--tw-ring-shadow), var(--tw-shadow)}.ui\:focus-visible\:ring-2:focus-visible{--tw-ring-shadow:var(--tw-ring-inset,) 0 0 0 calc(2px + var(--tw-ring-offset-width)) var(--tw-ring-color,currentcolor);box-shadow:var(--tw-inset-shadow), var(--tw-inset-ring-shadow), var(--tw-ring-offset-shadow), var(--tw-ring-shadow), var(--tw-shadow)}.ui\:focus-visible\:ring-\[3px\]:focus-visible{--tw-ring-shadow:var(--tw-ring-inset,) 0 0 0 calc(3px + var(--tw-ring-offset-width)) var(--tw-ring-color,currentcolor);box-shadow:var(--tw-inset-shadow), var(--tw-inset-ring-shadow), var(--tw-ring-offset-shadow), var(--tw-ring-shadow), var(--tw-shadow)}.ui\:focus-visible\:ring-destructive\/20:focus-visible{--tw-ring-color:var(--destructive)}@supports (color:color-mix(in lab, red, red)){.ui\:focus-visible\:ring-destructive\/20:focus-visible{--tw-ring-color:color-mix(in oklab, var(--destructive) 20%, transparent)}}.ui\:focus-visible\:ring-ring:focus-visible,.ui\:focus-visible\:ring-ring\/50:focus-visible{--tw-ring-color:var(--ring)}@supports (color:color-mix(in lab, red, red)){.ui\:focus-visible\:ring-ring\/50:focus-visible{--tw-ring-color:color-mix(in oklab, var(--ring) 50%, transparent)}}.ui\:focus-visible\:ring-offset-2:focus-visible{--tw-ring-offset-width:2px;--tw-ring-offset-shadow:var(--tw-ring-inset,) 0 0 0 var(--tw-ring-offset-width) var(--tw-ring-offset-color)}.ui\:focus-visible\:outline-hidden:focus-visible{--tw-outline-style:none;outline-style:none}@media (forced-colors:active){.ui\:focus-visible\:outline-hidden:focus-visible{outline-offset:2px;outline:2px solid #0000}}.ui\:focus-visible\:outline-1:focus-visible{outline-style:var(--tw-outline-style);outline-width:1px}.ui\:focus-visible\:outline-ring:focus-visible{outline-color:var(--ring)}.ui\:active\:bg-sidebar-accent:active{background-color:var(--sidebar-accent)}.ui\:active\:text-sidebar-accent-foreground:active{color:var(--sidebar-accent-foreground)}.ui\:disabled\:pointer-events-none:disabled{pointer-events:none}.ui\:disabled\:cursor-not-allowed:disabled{cursor:not-allowed}.ui\:disabled\:opacity-50:disabled{opacity:.5}:where([data-side=left]) .ui\:in-data-\[side\=left\]\:cursor-w-resize{cursor:w-resize}:where([data-side=right]) .ui\:in-data-\[side\=right\]\:cursor-e-resize{cursor:e-resize}:where([data-slot=tooltip-content]) .ui\:in-data-\[slot\=tooltip-content\]\:bg-background\/20{background-color:var(--background)}@supports (color:color-mix(in lab, red, red)){:where([data-slot=tooltip-content]) .ui\:in-data-\[slot\=tooltip-content\]\:bg-background\/20{background-color:color-mix(in oklab, var(--background) 20%, transparent)}}:where([data-slot=tooltip-content]) .ui\:in-data-\[slot\=tooltip-content\]\:text-background{color:var(--background)}.ui\:has-data-\[slot\=card-action\]\:grid-cols-\[1fr_auto\]:has([data-slot=card-action]){grid-template-columns:1fr auto}.ui\:has-data-\[state\=checked\]\:border-primary:has([data-state=checked]){border-color:var(--primary)}.ui\:has-data-\[state\=checked\]\:bg-primary\/5:has([data-state=checked]){background-color:var(--primary)}@supports (color:color-mix(in lab, red, red)){.ui\:has-data-\[state\=checked\]\:bg-primary\/5:has([data-state=checked]){background-color:color-mix(in oklab, var(--primary) 5%, transparent)}}.ui\:has-data-\[variant\=inset\]\:bg-sidebar:has([data-variant=inset]){background-color:var(--sidebar)}.ui\:has-\[\[data-slot\=input-group-control\]\:focus-visible\]\:border-ring:has([data-slot=input-group-control]:focus-visible){border-color:var(--ring)}.ui\:has-\[\[data-slot\=input-group-control\]\:focus-visible\]\:ring-\[3px\]:has([data-slot=input-group-control]:focus-visible){--tw-ring-shadow:var(--tw-ring-inset,) 0 0 0 calc(3px + var(--tw-ring-offset-width)) var(--tw-ring-color,currentcolor);box-shadow:var(--tw-inset-shadow), var(--tw-inset-ring-shadow), var(--tw-ring-offset-shadow), var(--tw-ring-shadow), var(--tw-shadow)}.ui\:has-\[\[data-slot\=input-group-control\]\:focus-visible\]\:ring-ring\/50:has([data-slot=input-group-control]:focus-visible){--tw-ring-color:var(--ring)}@supports (color:color-mix(in lab, red, red)){.ui\:has-\[\[data-slot\=input-group-control\]\:focus-visible\]\:ring-ring\/50:has([data-slot=input-group-control]:focus-visible){--tw-ring-color:color-mix(in oklab, var(--ring) 50%, transparent)}}.ui\:has-\[\[data-slot\]\[aria-invalid\=true\]\]\:border-destructive:has([data-slot][aria-invalid=true]){border-color:var(--destructive)}.ui\:has-\[\[data-slot\]\[aria-invalid\=true\]\]\:ring-destructive\/20:has([data-slot][aria-invalid=true]){--tw-ring-color:var(--destructive)}@supports (color:color-mix(in lab, red, red)){.ui\:has-\[\[data-slot\]\[aria-invalid\=true\]\]\:ring-destructive\/20:has([data-slot][aria-invalid=true]){--tw-ring-color:color-mix(in oklab, var(--destructive) 20%, transparent)}}.ui\:has-\[\>\[data-align\=block-end\]\]\:h-auto:has(>[data-align=block-end]){height:auto}.ui\:has-\[\>\[data-align\=block-end\]\]\:flex-col:has(>[data-align=block-end]){flex-direction:column}.ui\:has-\[\>\[data-align\=block-start\]\]\:h-auto:has(>[data-align=block-start]){height:auto}.ui\:has-\[\>\[data-align\=block-start\]\]\:flex-col:has(>[data-align=block-start]){flex-direction:column}.ui\:has-\[\>\[data-slot\=button-group\]\]\:gap-2:has(>[data-slot=button-group]){gap:calc(var(--ui-spacing) * 2)}.ui\:has-\[\>\[data-slot\=checkbox-group\]\]\:gap-3:has(>[data-slot=checkbox-group]){gap:calc(var(--ui-spacing) * 3)}.ui\:has-\[\>\[data-slot\=field-content\]\]\:items-start:has(>[data-slot=field-content]){align-items:flex-start}.ui\:has-\[\>\[data-slot\=field\]\]\:w-full:has(>[data-slot=field]){width:100%}.ui\:has-\[\>\[data-slot\=field\]\]\:flex-col:has(>[data-slot=field]){flex-direction:column}.ui\:has-\[\>\[data-slot\=field\]\]\:rounded-md:has(>[data-slot=field]){border-radius:calc(var(--radius) - 2px)}.ui\:has-\[\>\[data-slot\=field\]\]\:border:has(>[data-slot=field]){border-style:var(--tw-border-style);border-width:1px}.ui\:has-\[\>\[data-slot\=radio-group\]\]\:gap-3:has(>[data-slot=radio-group]){gap:calc(var(--ui-spacing) * 3)}.ui\:has-\[\>button\]\:ms-\[-0\.45rem\]:has(>button){margin-inline-start:-.45rem}.ui\:has-\[\>button\]\:me-\[-0\.45rem\]:has(>button){margin-inline-end:-.45rem}.ui\:has-\[\>kbd\]\:ms-\[-0\.35rem\]:has(>kbd){margin-inline-start:-.35rem}.ui\:has-\[\>kbd\]\:me-\[-0\.35rem\]:has(>kbd){margin-inline-end:-.35rem}.ui\:has-\[\>svg\]\:grid-cols-\[calc\(var\(--spacing\)\*4\)_1fr\]:has(>svg){grid-template-columns:calc(var(--spacing) * 4) 1fr}.ui\:has-\[\>svg\]\:gap-x-3:has(>svg){column-gap:calc(var(--ui-spacing) * 3)}.ui\:has-\[\>svg\]\:p-0:has(>svg){padding:calc(var(--ui-spacing) * 0)}.ui\:has-\[\>svg\]\:px-2:has(>svg){padding-inline:calc(var(--ui-spacing) * 2)}.ui\:has-\[\>svg\]\:px-2\.5:has(>svg){padding-inline:calc(var(--ui-spacing) * 2.5)}.ui\:has-\[\>svg\]\:px-3:has(>svg){padding-inline:calc(var(--ui-spacing) * 3)}.ui\:has-\[\>svg\]\:px-4:has(>svg){padding-inline:calc(var(--ui-spacing) * 4)}.ui\:has-\[\>textarea\]\:h-auto:has(>textarea){height:auto}.ui\:aria-disabled\:pointer-events-none[aria-disabled=true]{pointer-events:none}.ui\:aria-disabled\:opacity-50[aria-disabled=true]{opacity:.5}.ui\:aria-invalid\:border-destructive[aria-invalid=true]{border-color:var(--destructive)}.ui\:aria-invalid\:ring-destructive\/20[aria-invalid=true]{--tw-ring-color:var(--destructive)}@supports (color:color-mix(in lab, red, red)){.ui\:aria-invalid\:ring-destructive\/20[aria-invalid=true]{--tw-ring-color:color-mix(in oklab, var(--destructive) 20%, transparent)}}.ui\:aria-selected\:bg-accent[aria-selected=true]{background-color:var(--accent)}.ui\:aria-selected\:text-accent-foreground[aria-selected=true]{color:var(--accent-foreground)}:is(.ui\:\*\*\:data-command-group\:px-2 *)[data-command-group]{padding-inline:calc(var(--ui-spacing) * 2)}:is(.ui\:\*\*\:data-command-input\:h-12 *)[data-command-input]{height:calc(var(--ui-spacing) * 12)}:is(.ui\:\*\*\:data-command-item\:px-2 *)[data-command-item]{padding-inline:calc(var(--ui-spacing) * 2)}:is(.ui\:\*\*\:data-command-item\:py-3 *)[data-command-item]{padding-block:calc(var(--ui-spacing) * 3)}.ui\:data-disabled\:pointer-events-none[data-disabled]{pointer-events:none}.ui\:data-disabled\:cursor-not-allowed[data-disabled]{cursor:not-allowed}.ui\:data-disabled\:opacity-50[data-disabled]{opacity:.5}.ui\:data-highlighted\:bg-accent[data-highlighted]{background-color:var(--accent)}.ui\:data-highlighted\:text-accent-foreground[data-highlighted]{color:var(--accent-foreground)}.ui\:data-inset\:pl-8[data-inset]{padding-left:calc(var(--ui-spacing) * 8)}.ui\:data-placeholder\:text-muted-foreground[data-placeholder]{color:var(--muted-foreground)}.ui\:data-\[active\=true\]\:bg-accent\/50[data-active=true]{background-color:var(--accent)}@supports (color:color-mix(in lab, red, red)){.ui\:data-\[active\=true\]\:bg-accent\/50[data-active=true]{background-color:color-mix(in oklab, var(--accent) 50%, transparent)}}.ui\:data-\[active\=true\]\:bg-sidebar-accent[data-active=true]{background-color:var(--sidebar-accent)}.ui\:data-\[active\=true\]\:font-medium[data-active=true]{--tw-font-weight:var(--ui-font-weight-medium);font-weight:var(--ui-font-weight-medium)}.ui\:data-\[active\=true\]\:text-accent-foreground[data-active=true]{color:var(--accent-foreground)}.ui\:data-\[active\=true\]\:text-sidebar-accent-foreground[data-active=true]{color:var(--sidebar-accent-foreground)}@media (hover:hover){.ui\:data-\[active\=true\]\:hover\:bg-accent[data-active=true]:hover{background-color:var(--accent)}}.ui\:data-\[active\=true\]\:focus\:bg-accent[data-active=true]:focus{background-color:var(--accent)}.ui\:data-\[current\=true\]\:bg-muted[data-current=true]{background-color:var(--muted)}.ui\:data-\[disabled\=true\]\:pointer-events-none[data-disabled=true]{pointer-events:none}.ui\:data-\[disabled\=true\]\:opacity-50[data-disabled=true]{opacity:.5}.ui\:data-\[inset\]\:pl-8[data-inset]{padding-left:calc(var(--ui-spacing) * 8)}.ui\:data-\[invalid\=true\]\:text-destructive[data-invalid=true]{color:var(--destructive)}.ui\:data-\[motion\=from-end\]\:slide-in-from-end-52[data-motion=from-end]:where(:dir(ltr),[dir=ltr]){--tw-enter-translate-x:calc(52*var(--spacing))}.ui\:data-\[motion\=from-end\]\:slide-in-from-end-52[data-motion=from-end]:where(:dir(rtl),[dir=rtl]),.ui\:data-\[motion\=from-start\]\:slide-in-from-start-52[data-motion=from-start]:where(:dir(ltr),[dir=ltr]){--tw-enter-translate-x:calc(52*var(--spacing)*-1)}.ui\:data-\[motion\=from-start\]\:slide-in-from-start-52[data-motion=from-start]:where(:dir(rtl),[dir=rtl]){--tw-enter-translate-x:calc(52*var(--spacing))}.ui\:data-\[motion\=to-end\]\:slide-out-to-end-52[data-motion=to-end]:where(:dir(ltr),[dir=ltr]){--tw-exit-translate-x:calc(52*var(--spacing))}.ui\:data-\[motion\=to-end\]\:slide-out-to-end-52[data-motion=to-end]:where(:dir(rtl),[dir=rtl]),.ui\:data-\[motion\=to-start\]\:slide-out-to-start-52[data-motion=to-start]:where(:dir(ltr),[dir=ltr]){--tw-exit-translate-x:calc(52*var(--spacing)*-1)}.ui\:data-\[motion\=to-start\]\:slide-out-to-start-52[data-motion=to-start]:where(:dir(rtl),[dir=rtl]){--tw-exit-translate-x:calc(52*var(--spacing))}.ui\:data-\[motion\^\=from-\]\:animate-in[data-motion^=from-]{animation:enter var(--tw-animation-duration,var(--tw-duration,.15s))var(--tw-ease,ease)var(--tw-animation-delay,0s)var(--tw-animation-iteration-count,1)var(--tw-animation-direction,normal)var(--tw-animation-fill-mode,none)}.ui\:data-\[motion\^\=from-\]\:fade-in[data-motion^=from-]{--tw-enter-opacity:0}.ui\:data-\[motion\^\=to-\]\:animate-out[data-motion^=to-]{animation:exit var(--tw-animation-duration,var(--tw-duration,.15s))var(--tw-ease,ease)var(--tw-animation-delay,0s)var(--tw-animation-iteration-count,1)var(--tw-animation-direction,normal)var(--tw-animation-fill-mode,none)}.ui\:data-\[motion\^\=to-\]\:fade-out[data-motion^=to-]{--tw-exit-opacity:0}.ui\:data-\[orientation\=horizontal\]\:h-px[data-orientation=horizontal]{height:1px}.ui\:data-\[orientation\=horizontal\]\:w-full[data-orientation=horizontal]{width:100%}.ui\:data-\[orientation\=vertical\]\:h-auto[data-orientation=vertical]{height:auto}.ui\:data-\[orientation\=vertical\]\:h-full[data-orientation=vertical]{height:100%}.ui\:data-\[orientation\=vertical\]\:w-px[data-orientation=vertical]{width:1px}.ui\:data-\[side\=bottom\]\:-translate-x-1\/2[data-side=bottom]{--tw-translate-x:calc(calc(1 / 2 * 100%) * -1);translate:var(--tw-translate-x) var(--tw-translate-y)}.ui\:data-\[side\=bottom\]\:-translate-y-\[calc\(-50\%\+1px\)\][data-side=bottom]{--tw-translate-y:calc(calc(-50% + 1px) * -1);translate:var(--tw-translate-x) var(--tw-translate-y)}.ui\:data-\[side\=bottom\]\:translate-y-1[data-side=bottom]{--tw-translate-y:calc(var(--ui-spacing) * 1);translate:var(--tw-translate-x) var(--tw-translate-y)}.ui\:data-\[side\=bottom\]\:slide-in-from-top-2[data-side=bottom]{--tw-enter-translate-y:calc(2*var(--spacing)*-1)}.ui\:data-\[side\=left\]\:-translate-x-1[data-side=left]{--tw-translate-x:calc(var(--ui-spacing) * -1);translate:var(--tw-translate-x) var(--tw-translate-y)}.ui\:data-\[side\=left\]\:-translate-y-\[calc\(50\%-3px\)\][data-side=left]{--tw-translate-y:calc(calc(50% - 3px) * -1);translate:var(--tw-translate-x) var(--tw-translate-y)}.ui\:data-\[side\=left\]\:slide-in-from-end-2[data-side=left]:where(:dir(ltr),[dir=ltr]){--tw-enter-translate-x:calc(2*var(--spacing))}.ui\:data-\[side\=left\]\:slide-in-from-end-2[data-side=left]:where(:dir(rtl),[dir=rtl]){--tw-enter-translate-x:calc(2*var(--spacing)*-1)}.ui\:data-\[side\=left\]\:slide-in-from-right-2[data-side=left]{--tw-enter-translate-x:calc(2*var(--spacing))}.ui\:data-\[side\=right\]\:translate-x-1[data-side=right]{--tw-translate-x:calc(var(--ui-spacing) * 1);translate:var(--tw-translate-x) var(--tw-translate-y)}.ui\:data-\[side\=right\]\:translate-x-\[calc\(50\%\+2px\)\][data-side=right]{--tw-translate-x:calc(50% + 2px);translate:var(--tw-translate-x) var(--tw-translate-y)}.ui\:data-\[side\=right\]\:translate-y-1\/2[data-side=right]{--tw-translate-y:calc(1 / 2 * 100%);translate:var(--tw-translate-x) var(--tw-translate-y)}.ui\:data-\[side\=right\]\:slide-in-from-start-2[data-side=right]:where(:dir(ltr),[dir=ltr]){--tw-enter-translate-x:calc(2*var(--spacing)*-1)}.ui\:data-\[side\=right\]\:slide-in-from-start-2[data-side=right]:where(:dir(rtl),[dir=rtl]){--tw-enter-translate-x:calc(2*var(--spacing))}.ui\:data-\[side\=right\]\:slide-in-from-left-2[data-side=right]{--tw-enter-translate-x:calc(2*var(--spacing)*-1)}.ui\:data-\[side\=top\]\:translate-x-1\/2[data-side=top]{--tw-translate-x:calc(1 / 2 * 100%);translate:var(--tw-translate-x) var(--tw-translate-y)}.ui\:data-\[side\=top\]\:-translate-y-1[data-side=top]{--tw-translate-y:calc(var(--ui-spacing) * -1);translate:var(--tw-translate-x) var(--tw-translate-y)}.ui\:data-\[side\=top\]\:translate-y-\[calc\(-50\%\+2px\)\][data-side=top]{--tw-translate-y:calc(-50% + 2px);translate:var(--tw-translate-x) var(--tw-translate-y)}.ui\:data-\[side\=top\]\:slide-in-from-bottom-2[data-side=top]{--tw-enter-translate-y:calc(2*var(--spacing))}.ui\:data-\[size\=default\]\:h-9[data-size=default]{height:calc(var(--ui-spacing) * 9)}.ui\:data-\[size\=sm\]\:h-8[data-size=sm]{height:calc(var(--ui-spacing) * 8)}.ui\:data-\[slot\=checkbox-group\]\:gap-3[data-slot=checkbox-group]{gap:calc(var(--ui-spacing) * 3)}:is(.ui\:\*\:data-\[slot\=field\]\:p-4>*)[data-slot=field]{padding:calc(var(--ui-spacing) * 4)}:is(.ui\:\*\:data-\[slot\=field-group\]\:gap-4>*)[data-slot=field-group]{gap:calc(var(--ui-spacing) * 4)}:is(.ui\:\*\*\:data-\[slot\=navigation-menu-link\]\:focus\:ring-0 *)[data-slot=navigation-menu-link]:focus{--tw-ring-shadow:var(--tw-ring-inset,) 0 0 0 calc(0px + var(--tw-ring-offset-width)) var(--tw-ring-color,currentcolor);box-shadow:var(--tw-inset-shadow), var(--tw-inset-ring-shadow), var(--tw-ring-offset-shadow), var(--tw-ring-shadow), var(--tw-shadow)}:is(.ui\:\*\*\:data-\[slot\=navigation-menu-link\]\:focus\:outline-none *)[data-slot=navigation-menu-link]:focus{--tw-outline-style:none;outline-style:none}:is(.ui\:\*\*\:data-\[slot\=select-value\]\:line-clamp-1 *)[data-slot=select-value]{-webkit-line-clamp:1;-webkit-box-orient:vertical;display:-webkit-box;overflow:hidden}:is(.ui\:\*\*\:data-\[slot\=select-value\]\:flex *)[data-slot=select-value]{display:flex}:is(.ui\:\*\*\:data-\[slot\=select-value\]\:items-center *)[data-slot=select-value]{align-items:center}:is(.ui\:\*\*\:data-\[slot\=select-value\]\:gap-2 *)[data-slot=select-value]{gap:calc(var(--ui-spacing) * 2)}.ui\:data-\[state\=active\]\:bg-background[data-state=active]{background-color:var(--background)}.ui\:data-\[state\=active\]\:shadow-sm[data-state=active]{--tw-shadow:0 1px 3px 0 var(--tw-shadow-color,#0000001a), 0 1px 2px -1px var(--tw-shadow-color,#0000001a);box-shadow:var(--tw-inset-shadow), var(--tw-inset-ring-shadow), var(--tw-ring-offset-shadow), var(--tw-ring-shadow), var(--tw-shadow)}.ui\:data-\[state\=checked\]\:translate-x-\[calc\(100\%-2px\)\][data-state=checked]{--tw-translate-x:calc(100% - 2px);translate:var(--tw-translate-x) var(--tw-translate-y)}.ui\:data-\[state\=checked\]\:border-primary[data-state=checked]{border-color:var(--primary)}.ui\:data-\[state\=checked\]\:bg-primary[data-state=checked]{background-color:var(--primary)}.ui\:data-\[state\=checked\]\:text-primary-foreground[data-state=checked]{color:var(--primary-foreground)}.ui\:data-\[state\=closed\]\:animate-accordion-up[data-state=closed]{animation:accordion-up var(--tw-animation-duration,var(--tw-duration,.2s))var(--tw-ease,ease-out)var(--tw-animation-delay,0s)var(--tw-animation-iteration-count,1)var(--tw-animation-direction,normal)var(--tw-animation-fill-mode,none)}.ui\:data-\[state\=closed\]\:animate-out[data-state=closed]{animation:exit var(--tw-animation-duration,var(--tw-duration,.15s))var(--tw-ease,ease)var(--tw-animation-delay,0s)var(--tw-animation-iteration-count,1)var(--tw-animation-direction,normal)var(--tw-animation-fill-mode,none)}.ui\:data-\[state\=closed\]\:duration-300[data-state=closed]{--tw-duration:.3s;transition-duration:.3s}.ui\:data-\[state\=closed\]\:fade-out-0[data-state=closed]{--tw-exit-opacity:0}.ui\:data-\[state\=closed\]\:zoom-out-95[data-state=closed]{--tw-exit-scale:.95}.ui\:data-\[state\=closed\]\:slide-out-to-bottom[data-state=closed]{--tw-exit-translate-y:100%}.ui\:data-\[state\=closed\]\:slide-out-to-left[data-state=closed]{--tw-exit-translate-x:-100%}.ui\:data-\[state\=closed\]\:slide-out-to-right[data-state=closed]{--tw-exit-translate-x:100%}.ui\:data-\[state\=closed\]\:slide-out-to-top[data-state=closed]{--tw-exit-translate-y:-100%}.ui\:group-data-\[viewport\=false\]\/navigation-menu\:data-\[state\=closed\]\:animate-out:is(:where(.ui\:group\/navigation-menu)[data-viewport=false] *)[data-state=closed]{animation:exit var(--tw-animation-duration,var(--tw-duration,.15s))var(--tw-ease,ease)var(--tw-animation-delay,0s)var(--tw-animation-iteration-count,1)var(--tw-animation-direction,normal)var(--tw-animation-fill-mode,none)}.ui\:group-data-\[viewport\=false\]\/navigation-menu\:data-\[state\=closed\]\:fade-out-0:is(:where(.ui\:group\/navigation-menu)[data-viewport=false] *)[data-state=closed]{--tw-exit-opacity:0}.ui\:group-data-\[viewport\=false\]\/navigation-menu\:data-\[state\=closed\]\:zoom-out-95:is(:where(.ui\:group\/navigation-menu)[data-viewport=false] *)[data-state=closed]{--tw-exit-scale:.95}.ui\:data-\[state\=hidden\]\:animate-out[data-state=hidden]{animation:exit var(--tw-animation-duration,var(--tw-duration,.15s))var(--tw-ease,ease)var(--tw-animation-delay,0s)var(--tw-animation-iteration-count,1)var(--tw-animation-direction,normal)var(--tw-animation-fill-mode,none)}.ui\:data-\[state\=hidden\]\:fade-out[data-state=hidden]{--tw-exit-opacity:0}.ui\:data-\[state\=off\]\:text-muted-foreground[data-state=off]{color:var(--muted-foreground)}@media (hover:hover){.ui\:hover\:data-\[state\=off\]\:text-accent-foreground:hover[data-state=off]{color:var(--accent-foreground)}}.ui\:data-\[state\=on\]\:bg-accent[data-state=on]{background-color:var(--accent)}.ui\:data-\[state\=on\]\:bg-transparent[data-state=on]{background-color:#0000}.ui\:data-\[state\=on\]\:text-accent-foreground[data-state=on]{color:var(--accent-foreground)}.ui\:data-\[state\=on\]\:text-muted-foreground[data-state=on]{color:var(--muted-foreground)}@media (hover:hover){.ui\:hover\:data-\[state\=on\]\:text-accent-foreground:hover[data-state=on]{color:var(--accent-foreground)}}.ui\:data-\[state\=open\]\:animate-accordion-down[data-state=open]{animation:accordion-down var(--tw-animation-duration,var(--tw-duration,.2s))var(--tw-ease,ease-out)var(--tw-animation-delay,0s)var(--tw-animation-iteration-count,1)var(--tw-animation-direction,normal)var(--tw-animation-fill-mode,none)}.ui\:data-\[state\=open\]\:animate-in[data-state=open]{animation:enter var(--tw-animation-duration,var(--tw-duration,.15s))var(--tw-ease,ease)var(--tw-animation-delay,0s)var(--tw-animation-iteration-count,1)var(--tw-animation-direction,normal)var(--tw-animation-fill-mode,none)}.ui\:data-\[state\=open\]\:bg-accent[data-state=open]{background-color:var(--accent)}.ui\:data-\[state\=open\]\:text-accent-foreground[data-state=open]{color:var(--accent-foreground)}.ui\:data-\[state\=open\]\:opacity-100[data-state=open]{opacity:1}.ui\:data-\[state\=open\]\:duration-500[data-state=open]{--tw-duration:.5s;transition-duration:.5s}.ui\:data-\[state\=open\]\:fade-in-0[data-state=open]{--tw-enter-opacity:0}.ui\:data-\[state\=open\]\:zoom-in-90[data-state=open]{--tw-enter-scale:.9}.ui\:data-\[state\=open\]\:zoom-in-95[data-state=open]{--tw-enter-scale:.95}.ui\:data-\[state\=open\]\:slide-in-from-bottom[data-state=open]{--tw-enter-translate-y:100%}.ui\:data-\[state\=open\]\:slide-in-from-left[data-state=open]{--tw-enter-translate-x:-100%}.ui\:data-\[state\=open\]\:slide-in-from-right[data-state=open]{--tw-enter-translate-x:100%}.ui\:data-\[state\=open\]\:slide-in-from-top[data-state=open]{--tw-enter-translate-y:-100%}.ui\:group-data-\[viewport\=false\]\/navigation-menu\:data-\[state\=open\]\:animate-in:is(:where(.ui\:group\/navigation-menu)[data-viewport=false] *)[data-state=open]{animation:enter var(--tw-animation-duration,var(--tw-duration,.15s))var(--tw-ease,ease)var(--tw-animation-delay,0s)var(--tw-animation-iteration-count,1)var(--tw-animation-direction,normal)var(--tw-animation-fill-mode,none)}.ui\:group-data-\[viewport\=false\]\/navigation-menu\:data-\[state\=open\]\:fade-in-0:is(:where(.ui\:group\/navigation-menu)[data-viewport=false] *)[data-state=open]{--tw-enter-opacity:0}.ui\:group-data-\[viewport\=false\]\/navigation-menu\:data-\[state\=open\]\:zoom-in-95:is(:where(.ui\:group\/navigation-menu)[data-viewport=false] *)[data-state=open]{--tw-enter-scale:.95}@media (hover:hover){.ui\:data-\[state\=open\]\:hover\:bg-sidebar-accent[data-state=open]:hover{background-color:var(--sidebar-accent)}.ui\:data-\[state\=open\]\:hover\:text-sidebar-accent-foreground[data-state=open]:hover{color:var(--sidebar-accent-foreground)}}.ui\:data-\[state\=selected\]\:bg-muted[data-state=selected]{background-color:var(--muted)}.ui\:data-\[state\=unchecked\]\:translate-x-0[data-state=unchecked]{--tw-translate-x:calc(var(--ui-spacing) * 0);translate:var(--tw-translate-x) var(--tw-translate-y)}.ui\:data-\[state\=unchecked\]\:bg-input[data-state=unchecked]{background-color:var(--input)}.ui\:data-\[state\=visible\]\:animate-in[data-state=visible]{animation:enter var(--tw-animation-duration,var(--tw-duration,.15s))var(--tw-ease,ease)var(--tw-animation-delay,0s)var(--tw-animation-iteration-count,1)var(--tw-animation-direction,normal)var(--tw-animation-fill-mode,none)}.ui\:data-\[state\=visible\]\:fade-in[data-state=visible]{--tw-enter-opacity:0}.ui\:data-\[variant\=destructive\]\:text-destructive[data-variant=destructive]{color:var(--destructive)}.ui\:data-\[variant\=destructive\]\:focus\:bg-destructive\/10[data-variant=destructive]:focus{background-color:var(--destructive)}@supports (color:color-mix(in lab, red, red)){.ui\:data-\[variant\=destructive\]\:focus\:bg-destructive\/10[data-variant=destructive]:focus{background-color:color-mix(in oklab, var(--destructive) 10%, transparent)}}.ui\:data-\[variant\=destructive\]\:focus\:text-destructive[data-variant=destructive]:focus{color:var(--destructive)}.ui\:data-\[variant\=destructive\]\:data-highlighted\:bg-destructive\/10[data-variant=destructive][data-highlighted]{background-color:var(--destructive)}@supports (color:color-mix(in lab, red, red)){.ui\:data-\[variant\=destructive\]\:data-highlighted\:bg-destructive\/10[data-variant=destructive][data-highlighted]{background-color:color-mix(in oklab, var(--destructive) 10%, transparent)}}.ui\:data-\[variant\=destructive\]\:data-highlighted\:text-destructive[data-variant=destructive][data-highlighted]{color:var(--destructive)}.ui\:data-\[variant\=label\]\:text-sm[data-variant=label]{font-size:var(--ui-text-sm);line-height:var(--tw-leading,var(--ui-text-sm--line-height))}.ui\:data-\[variant\=legend\]\:text-base[data-variant=legend]{font-size:var(--ui-text-base);line-height:var(--tw-leading,var(--ui-text-base--line-height))}.ui\:data-\[vaul-drawer-direction\=bottom\]\:inset-x-0[data-vaul-drawer-direction=bottom]{inset-inline:calc(var(--ui-spacing) * 0)}.ui\:data-\[vaul-drawer-direction\=bottom\]\:bottom-0[data-vaul-drawer-direction=bottom]{bottom:calc(var(--ui-spacing) * 0)}.ui\:data-\[vaul-drawer-direction\=bottom\]\:mt-24[data-vaul-drawer-direction=bottom]{margin-top:calc(var(--ui-spacing) * 24)}.ui\:data-\[vaul-drawer-direction\=bottom\]\:max-h-\[80vh\][data-vaul-drawer-direction=bottom]{max-height:80vh}.ui\:data-\[vaul-drawer-direction\=bottom\]\:rounded-t-lg[data-vaul-drawer-direction=bottom]{border-top-left-radius:var(--radius);border-top-right-radius:var(--radius)}.ui\:data-\[vaul-drawer-direction\=bottom\]\:border-t[data-vaul-drawer-direction=bottom]{border-top-style:var(--tw-border-style);border-top-width:1px}.ui\:data-\[vaul-drawer-direction\=left\]\:inset-y-0[data-vaul-drawer-direction=left]{inset-block:calc(var(--ui-spacing) * 0)}.ui\:data-\[vaul-drawer-direction\=left\]\:start-0[data-vaul-drawer-direction=left]{inset-inline-start:calc(var(--ui-spacing) * 0)}.ui\:data-\[vaul-drawer-direction\=left\]\:w-3\/4[data-vaul-drawer-direction=left]{width:75%}.ui\:data-\[vaul-drawer-direction\=left\]\:border-e[data-vaul-drawer-direction=left]{border-inline-end-style:var(--tw-border-style);border-inline-end-width:1px}.ui\:data-\[vaul-drawer-direction\=right\]\:inset-y-0[data-vaul-drawer-direction=right]{inset-block:calc(var(--ui-spacing) * 0)}.ui\:data-\[vaul-drawer-direction\=right\]\:end-0[data-vaul-drawer-direction=right]{inset-inline-end:calc(var(--ui-spacing) * 0)}.ui\:data-\[vaul-drawer-direction\=right\]\:w-3\/4[data-vaul-drawer-direction=right]{width:75%}.ui\:data-\[vaul-drawer-direction\=right\]\:border-s[data-vaul-drawer-direction=right]{border-inline-start-style:var(--tw-border-style);border-inline-start-width:1px}.ui\:data-\[vaul-drawer-direction\=top\]\:inset-x-0[data-vaul-drawer-direction=top]{inset-inline:calc(var(--ui-spacing) * 0)}.ui\:data-\[vaul-drawer-direction\=top\]\:top-0[data-vaul-drawer-direction=top]{top:calc(var(--ui-spacing) * 0)}.ui\:data-\[vaul-drawer-direction\=top\]\:mb-24[data-vaul-drawer-direction=top]{margin-bottom:calc(var(--ui-spacing) * 24)}.ui\:data-\[vaul-drawer-direction\=top\]\:max-h-\[80vh\][data-vaul-drawer-direction=top]{max-height:80vh}.ui\:data-\[vaul-drawer-direction\=top\]\:rounded-b-lg[data-vaul-drawer-direction=top]{border-bottom-right-radius:var(--radius);border-bottom-left-radius:var(--radius)}.ui\:data-\[vaul-drawer-direction\=top\]\:border-b[data-vaul-drawer-direction=top]{border-bottom-style:var(--tw-border-style);border-bottom-width:1px}.ui\:nth-last-2\:-mt-1:nth-last-child(2){margin-top:calc(var(--ui-spacing) * -1)}@media (min-width:40rem){.ui\:sm\:flex{display:flex}.ui\:sm\:max-w-lg{max-width:var(--ui-container-lg)}.ui\:sm\:max-w-sm{max-width:var(--ui-container-sm)}.ui\:sm\:flex-row{flex-direction:row}.ui\:sm\:justify-end{justify-content:flex-end}.ui\:sm\:gap-2\.5{gap:calc(var(--ui-spacing) * 2.5)}.ui\:sm\:pr-2\.5{padding-right:calc(var(--ui-spacing) * 2.5)}.ui\:sm\:pl-2\.5{padding-left:calc(var(--ui-spacing) * 2.5)}.ui\:data-\[vaul-drawer-direction\=left\]\:sm\:max-w-sm[data-vaul-drawer-direction=left],.ui\:data-\[vaul-drawer-direction\=right\]\:sm\:max-w-sm[data-vaul-drawer-direction=right]{max-width:var(--ui-container-sm)}}@media (min-width:48rem){.ui\:md\:block{display:block}.ui\:md\:flex{display:flex}.ui\:md\:grid-cols-2{grid-template-columns:repeat(2,minmax(0,1fr))}.ui\:md\:flex-row{flex-direction:row}.ui\:md\:p-12{padding:calc(var(--ui-spacing) * 12)}.ui\:md\:text-sm{font-size:var(--ui-text-sm);line-height:var(--tw-leading,var(--ui-text-sm--line-height))}.ui\:md\:opacity-0{opacity:0}.ui\:md\:peer-data-\[variant\=inset\]\:m-2:is(:where(.ui\:peer)[data-variant=inset]~*){margin:calc(var(--ui-spacing) * 2)}.ui\:md\:peer-data-\[variant\=inset\]\:ml-0:is(:where(.ui\:peer)[data-variant=inset]~*){margin-left:calc(var(--ui-spacing) * 0)}.ui\:md\:peer-data-\[variant\=inset\]\:rounded-xl:is(:where(.ui\:peer)[data-variant=inset]~*){border-radius:calc(var(--radius) + 4px)}.ui\:md\:peer-data-\[variant\=inset\]\:shadow-sm:is(:where(.ui\:peer)[data-variant=inset]~*){--tw-shadow:0 1px 3px 0 var(--tw-shadow-color,#0000001a), 0 1px 2px -1px var(--tw-shadow-color,#0000001a);box-shadow:var(--tw-inset-shadow), var(--tw-inset-ring-shadow), var(--tw-ring-offset-shadow), var(--tw-ring-shadow), var(--tw-shadow)}.ui\:md\:peer-data-\[variant\=inset\]\:peer-data-\[state\=collapsed\]\:ml-2:is(:where(.ui\:peer)[data-variant=inset]~*):is(:where(.ui\:peer)[data-state=collapsed]~*){margin-left:calc(var(--ui-spacing) * 2)}.ui\:md\:after\:hidden:after{content:var(--tw-content);display:none}}.ui\:dark\:scale-0:where(.dark,.dark *){--tw-scale-x:0%;--tw-scale-y:0%;--tw-scale-z:0%;scale:var(--tw-scale-x) var(--tw-scale-y)}.ui\:dark\:scale-100:where(.dark,.dark *){--tw-scale-x:100%;--tw-scale-y:100%;--tw-scale-z:100%;scale:var(--tw-scale-x) var(--tw-scale-y)}.ui\:dark\:-rotate-90:where(.dark,.dark *){rotate:-90deg}.ui\:dark\:rotate-0:where(.dark,.dark *){rotate:none}.ui\:dark\:border-amber-900:where(.dark,.dark *){border-color:var(--ui-color-amber-900)}.ui\:dark\:border-input:where(.dark,.dark *){border-color:var(--input)}.ui\:dark\:border-sky-900:where(.dark,.dark *){border-color:var(--ui-color-sky-900)}.ui\:dark\:border-slate-800:where(.dark,.dark *){border-color:var(--ui-color-slate-800)}.ui\:dark\:bg-amber-500:where(.dark,.dark *){background-color:var(--ui-color-amber-500)}.ui\:dark\:bg-amber-950:where(.dark,.dark *){background-color:var(--ui-color-amber-950)}.ui\:dark\:bg-destructive\/60:where(.dark,.dark *){background-color:var(--destructive)}@supports (color:color-mix(in lab, red, red)){.ui\:dark\:bg-destructive\/60:where(.dark,.dark *){background-color:color-mix(in oklab, var(--destructive) 60%, transparent)}}.ui\:dark\:bg-destructive\/70:where(.dark,.dark *){background-color:var(--destructive)}@supports (color:color-mix(in lab, red, red)){.ui\:dark\:bg-destructive\/70:where(.dark,.dark *){background-color:color-mix(in oklab, var(--destructive) 70%, transparent)}}.ui\:dark\:bg-emerald-500:where(.dark,.dark *){background-color:var(--ui-color-emerald-500)}.ui\:dark\:bg-input\/30:where(.dark,.dark *){background-color:var(--input)}@supports (color:color-mix(in lab, red, red)){.ui\:dark\:bg-input\/30:where(.dark,.dark *){background-color:color-mix(in oklab, var(--input) 30%, transparent)}}.ui\:dark\:bg-sky-950:where(.dark,.dark *){background-color:var(--ui-color-sky-950)}.ui\:dark\:bg-slate-950:where(.dark,.dark *){background-color:var(--ui-color-slate-950)}.ui\:dark\:bg-transparent:where(.dark,.dark *){background-color:#0000}.ui\:dark\:text-amber-50:where(.dark,.dark *){color:var(--ui-color-amber-50)}.ui\:dark\:text-amber-950:where(.dark,.dark *){color:var(--ui-color-amber-950)}.ui\:dark\:text-emerald-950:where(.dark,.dark *){color:var(--ui-color-emerald-950)}.ui\:dark\:text-muted-foreground:where(.dark,.dark *){color:var(--muted-foreground)}.ui\:dark\:text-sky-50:where(.dark,.dark *){color:var(--ui-color-sky-50)}.ui\:dark\:text-white:where(.dark,.dark *){color:var(--ui-color-white)}@media (hover:hover){.ui\:dark\:hover\:border-input:where(.dark,.dark *):hover{border-color:var(--input)}.ui\:dark\:hover\:bg-input\/50:where(.dark,.dark *):hover{background-color:var(--input)}@supports (color:color-mix(in lab, red, red)){.ui\:dark\:hover\:bg-input\/50:where(.dark,.dark *):hover{background-color:color-mix(in oklab, var(--input) 50%, transparent)}}}.ui\:dark\:focus-visible\:ring-destructive\/40:where(.dark,.dark *):focus-visible{--tw-ring-color:var(--destructive)}@supports (color:color-mix(in lab, red, red)){.ui\:dark\:focus-visible\:ring-destructive\/40:where(.dark,.dark *):focus-visible{--tw-ring-color:color-mix(in oklab, var(--destructive) 40%, transparent)}}:where([data-slot=tooltip-content]) .ui\:dark\:in-data-\[slot\=tooltip-content\]\:bg-background\/10:where(.dark,.dark *){background-color:var(--background)}@supports (color:color-mix(in lab, red, red)){:where([data-slot=tooltip-content]) .ui\:dark\:in-data-\[slot\=tooltip-content\]\:bg-background\/10:where(.dark,.dark *){background-color:color-mix(in oklab, var(--background) 10%, transparent)}}.ui\:dark\:has-data-\[state\=checked\]\:bg-primary\/10:where(.dark,.dark *):has([data-state=checked]){background-color:var(--primary)}@supports (color:color-mix(in lab, red, red)){.ui\:dark\:has-data-\[state\=checked\]\:bg-primary\/10:where(.dark,.dark *):has([data-state=checked]){background-color:color-mix(in oklab, var(--primary) 10%, transparent)}}.ui\:dark\:has-\[\[data-slot\]\[aria-invalid\=true\]\]\:ring-destructive\/40:where(.dark,.dark *):has([data-slot][aria-invalid=true]){--tw-ring-color:var(--destructive)}@supports (color:color-mix(in lab, red, red)){.ui\:dark\:has-\[\[data-slot\]\[aria-invalid\=true\]\]\:ring-destructive\/40:where(.dark,.dark *):has([data-slot][aria-invalid=true]){--tw-ring-color:color-mix(in oklab, var(--destructive) 40%, transparent)}}.ui\:dark\:aria-invalid\:ring-destructive\/40:where(.dark,.dark *)[aria-invalid=true]{--tw-ring-color:var(--destructive)}@supports (color:color-mix(in lab, red, red)){.ui\:dark\:aria-invalid\:ring-destructive\/40:where(.dark,.dark *)[aria-invalid=true]{--tw-ring-color:color-mix(in oklab, var(--destructive) 40%, transparent)}}.ui\:dark\:data-\[state\=active\]\:border-input:where(.dark,.dark *)[data-state=active]{border-color:var(--input)}.ui\:dark\:data-\[state\=active\]\:bg-input\/30:where(.dark,.dark *)[data-state=active]{background-color:var(--input)}@supports (color:color-mix(in lab, red, red)){.ui\:dark\:data-\[state\=active\]\:bg-input\/30:where(.dark,.dark *)[data-state=active]{background-color:color-mix(in oklab, var(--input) 30%, transparent)}}.ui\:dark\:data-\[state\=active\]\:text-foreground:where(.dark,.dark *)[data-state=active]{color:var(--foreground)}.ui\:dark\:data-\[state\=checked\]\:bg-primary:where(.dark,.dark *)[data-state=checked]{background-color:var(--primary)}.ui\:dark\:data-\[state\=checked\]\:bg-primary-foreground:where(.dark,.dark *)[data-state=checked]{background-color:var(--primary-foreground)}.ui\:dark\:data-\[state\=unchecked\]\:bg-foreground:where(.dark,.dark *)[data-state=unchecked]{background-color:var(--foreground)}.ui\:dark\:data-\[state\=unchecked\]\:bg-input\/80:where(.dark,.dark *)[data-state=unchecked]{background-color:var(--input)}@supports (color:color-mix(in lab, red, red)){.ui\:dark\:data-\[state\=unchecked\]\:bg-input\/80:where(.dark,.dark *)[data-state=unchecked]{background-color:color-mix(in oklab, var(--input) 80%, transparent)}}.ui\:\[\&_\.lc-area-path\]\:opacity-100 .lc-area-path{opacity:1}.ui\:\[\&_\.lc-axis-tick\]\:stroke-0 .lc-axis-tick{stroke-width:0}.ui\:\[\&_\.lc-axis-tick-label\]\:fill-muted-foreground .lc-axis-tick-label{fill:var(--muted-foreground)}.ui\:\[\&_\.lc-axis-tick-label\]\:font-normal .lc-axis-tick-label{--tw-font-weight:var(--ui-font-weight-normal);font-weight:var(--ui-font-weight-normal)}.ui\:\[\&_\.lc-grid-x-radial-circle\]\:stroke-border .lc-grid-x-radial-circle,.ui\:\[\&_\.lc-grid-x-radial-line\]\:stroke-border .lc-grid-x-radial-line,.ui\:\[\&_\.lc-grid-y-radial-circle\]\:stroke-border .lc-grid-y-radial-circle,.ui\:\[\&_\.lc-grid-y-radial-line\]\:stroke-border .lc-grid-y-radial-line{stroke:var(--border)}.ui\:\[\&_\.lc-highlight-line\]\:stroke-0 .lc-highlight-line{stroke-width:0}.ui\:\[\&_\.lc-highlight-line\]\:opacity-100 .lc-highlight-line,.ui\:\[\&_\.lc-highlight-point\]\:opacity-100 .lc-highlight-point{opacity:1}.ui\:\[\&_\.lc-labels-text\:not\(\[fill\]\)\]\:fill-foreground .lc-labels-text:not([fill]){fill:var(--foreground)}.ui\:\[\&_\.lc-layout-svg-g\]\:fill-transparent .lc-layout-svg-g{fill:#0000}.ui\:\[\&_\.lc-legend-swatch\]\:size-2\.5 .lc-legend-swatch{width:calc(var(--ui-spacing) * 2.5);height:calc(var(--ui-spacing) * 2.5)}.ui\:\[\&_\.lc-legend-swatch\]\:rounded-\[2px\] .lc-legend-swatch{border-radius:2px}.ui\:\[\&_\.lc-legend-swatch-button\]\:items-center .lc-legend-swatch-button{align-items:center}.ui\:\[\&_\.lc-legend-swatch-button\]\:gap-1\.5 .lc-legend-swatch-button{gap:calc(var(--ui-spacing) * 1.5)}.ui\:\[\&_\.lc-legend-swatch-group\]\:items-center .lc-legend-swatch-group{align-items:center}.ui\:\[\&_\.lc-legend-swatch-group\]\:gap-4 .lc-legend-swatch-group{gap:calc(var(--ui-spacing) * 4)}.ui\:\[\&_\.lc-line\]\:stroke-border\/50 .lc-line{stroke:var(--border)}@supports (color:color-mix(in lab, red, red)){.ui\:\[\&_\.lc-line\]\:stroke-border\/50 .lc-line{stroke:color-mix(in oklab, var(--border) 50%, transparent)}}.ui\:\[\&_\.lc-root-container\]\:w-full .lc-root-container{width:100%}.ui\:\[\&_\.lc-rule-x-line\:not\(\.lc-grid-x-rule\)\]\:stroke-0 .lc-rule-x-line:not(.lc-grid-x-rule),.ui\:\[\&_\.lc-rule-y-line\:not\(\.lc-grid-y-rule\)\]\:stroke-0 .lc-rule-y-line:not(.lc-grid-y-rule){stroke-width:0}.ui\:\[\&_\.lc-spline-path\]\:opacity-100 .lc-spline-path{opacity:1}.ui\:\[\&_\.lc-text\]\:text-xs .lc-text{font-size:var(--ui-text-xs);line-height:var(--tw-leading,var(--ui-text-xs--line-height))}.ui\:\[\&_\.lc-text-svg\]\:overflow-visible .lc-text-svg{overflow:visible}.ui\:\[\&_\.lc-tooltip-rects-g\]\:fill-transparent .lc-tooltip-rects-g{fill:#0000}.ui\:\[\&_\.stroke-white\]\:stroke-transparent .stroke-white{stroke:#0000}.ui\:\[\&_\[data-command-group\]\:not\(\[hidden\]\)_\~\[data-command-group\]\]\:pt-0 [data-command-group]:not([hidden])~[data-command-group]{padding-top:calc(var(--ui-spacing) * 0)}.ui\:\[\&_\[data-command-input-wrapper\]_svg\]\:h-5 [data-command-input-wrapper] svg{height:calc(var(--ui-spacing) * 5)}.ui\:\[\&_\[data-command-input-wrapper\]_svg\]\:w-5 [data-command-input-wrapper] svg{width:calc(var(--ui-spacing) * 5)}.ui\:\[\&_\[data-command-item\]_svg\]\:h-5 [data-command-item] svg{height:calc(var(--ui-spacing) * 5)}.ui\:\[\&_\[data-command-item\]_svg\]\:w-5 [data-command-item] svg{width:calc(var(--ui-spacing) * 5)}.ui\:\[\&_img\]\:size-full img{width:100%;height:100%}.ui\:\[\&_img\]\:object-cover img{object-fit:cover}.ui\:\[\&_p\]\:leading-relaxed p{--tw-leading:var(--ui-leading-relaxed);line-height:var(--ui-leading-relaxed)}.ui\:\[\&_svg\]\:pointer-events-none svg{pointer-events:none}.ui\:\[\&_svg\]\:size-8\! svg{width:calc(var(--ui-spacing) * 8)!important;height:calc(var(--ui-spacing) * 8)!important}.ui\:\[\&_svg\]\:shrink-0 svg{flex-shrink:0}.ui\:\[\&_svg\:not\(\[class\*\=\'size-\'\]\)\]\:size-3 svg:not([class*=size-]){width:calc(var(--ui-spacing) * 3);height:calc(var(--ui-spacing) * 3)}.ui\:\[\&_svg\:not\(\[class\*\=\'size-\'\]\)\]\:size-4 svg:not([class*=size-]){width:calc(var(--ui-spacing) * 4);height:calc(var(--ui-spacing) * 4)}.ui\:\[\&_svg\:not\(\[class\*\=\'text-\'\]\)\]\:text-muted-foreground svg:not([class*=text-]){color:var(--muted-foreground)}.ui\:\[\&_svg\:not\(\[class\*\=\'ui\:size-\'\]\)\]\:size-4 svg:not([class*=ui\:size-]){width:calc(var(--ui-spacing) * 4);height:calc(var(--ui-spacing) * 4)}.ui\:\[\&_svg\:not\(\[class\*\=\'ui\:size-\'\]\)\]\:size-6 svg:not([class*=ui\:size-]){width:calc(var(--ui-spacing) * 6);height:calc(var(--ui-spacing) * 6)}.ui\:\[\&_text\]\:stroke-transparent text{stroke:#0000}.ui\:\[\&_tr\]\:border-b tr{border-bottom-style:var(--tw-border-style);border-bottom-width:1px}.ui\:\[\&_tr\:last-child\]\:border-0 tr:last-child{border-style:var(--tw-border-style);border-width:0}.ui\:\[\&\+\[data-slot\=item-content\]\]\:flex-none+[data-slot=item-content]{flex:none}.ui\:\[\&\:has\(\[role\=checkbox\]\)\]\:pr-0:has([role=checkbox]){padding-right:calc(var(--ui-spacing) * 0)}.ui\:\[\.border-b\]\:pb-3.border-b{padding-bottom:calc(var(--ui-spacing) * 3)}.ui\:\[\.border-b\]\:pb-6.border-b{padding-bottom:calc(var(--ui-spacing) * 6)}.ui\:\[\.border-t\]\:pt-3.border-t{padding-top:calc(var(--ui-spacing) * 3)}.ui\:\[\.border-t\]\:pt-6.border-t{padding-top:calc(var(--ui-spacing) * 6)}.ui\:\[a\]\:transition-colors:is(a){transition-property:color,background-color,border-color,outline-color,text-decoration-color,fill,stroke,--tw-gradient-from,--tw-gradient-via,--tw-gradient-to;transition-timing-function:var(--tw-ease,var(--ui-default-transition-timing-function));transition-duration:var(--tw-duration,var(--ui-default-transition-duration))}@media (hover:hover){.ui\:\[a\]\:hover\:bg-accent\/50:is(a):hover{background-color:var(--accent)}@supports (color:color-mix(in lab, red, red)){.ui\:\[a\]\:hover\:bg-accent\/50:is(a):hover{background-color:color-mix(in oklab, var(--accent) 50%, transparent)}}}:is(.ui\:\*\:\[span\]\:last\:flex>*):is(span):last-child{display:flex}:is(.ui\:\*\:\[span\]\:last\:items-center>*):is(span):last-child{align-items:center}:is(.ui\:\*\:\[span\]\:last\:gap-2>*):is(span):last-child{gap:calc(var(--ui-spacing) * 2)}:is(.ui\:data-\[variant\=destructive\]\:\*\:\[svg\]\:text-destructive\![data-variant=destructive]>*):is(svg){color:var(--destructive)!important}.ui\:\[\&\>\*\]\:focus-visible\:relative>:focus-visible{position:relative}.ui\:\[\&\>\*\]\:focus-visible\:z-10>:focus-visible{z-index:10}.ui\:\[\&\>\*\:not\(\:first-child\)\]\:rounded-s-none>:not(:first-child){border-start-start-radius:0;border-end-start-radius:0}.ui\:\[\&\>\*\:not\(\:first-child\)\]\:rounded-t-none>:not(:first-child){border-top-left-radius:0;border-top-right-radius:0}.ui\:\[\&\>\*\:not\(\:first-child\)\]\:border-s-0>:not(:first-child){border-inline-start-style:var(--tw-border-style);border-inline-start-width:0}.ui\:\[\&\>\*\:not\(\:first-child\)\]\:border-t-0>:not(:first-child){border-top-style:var(--tw-border-style);border-top-width:0}.ui\:\[\&\>\*\:not\(\:last-child\)\]\:rounded-e-none>:not(:last-child){border-start-end-radius:0;border-end-end-radius:0}.ui\:\[\&\>\*\:not\(\:last-child\)\]\:rounded-b-none>:not(:last-child){border-bottom-right-radius:0;border-bottom-left-radius:0}.ui\:\[\&\>\[data-slot\=field-label\]\]\:flex-auto>[data-slot=field-label]{flex:auto}.ui\:has-\[select\[aria-hidden\=true\]\:last-child\]\:\[\&\>\[data-slot\=select-trigger\]\:last-of-type\]\:rounded-e-md:has(:is(select[aria-hidden=true]:last-child))>[data-slot=select-trigger]:last-of-type{border-start-end-radius:calc(var(--radius) - 2px);border-end-end-radius:calc(var(--radius) - 2px)}.ui\:\[\&\>\[data-slot\=select-trigger\]\:not\(\[class\*\=\'ui\:w-\'\]\)\]\:w-fit>[data-slot=select-trigger]:not([class*=ui\:w-]){width:fit-content}.ui\:has-\[\>\[data-slot\=field-content\]\]\:\[\&\>\[role\=checkbox\]\,\[role\=radio\]\]\:mt-px:has(>[data-slot=field-content])>[role=checkbox],.ui\:has-\[\>\[data-slot\=field-content\]\]\:\[\&\>\[role\=checkbox\]\,\[role\=radio\]\]\:mt-px:has(>[data-slot=field-content]) [role=radio]{margin-top:1px}.ui\:\[\&\>a\]\:underline>a{text-decoration-line:underline}.ui\:\[\&\>a\]\:underline-offset-4>a{text-underline-offset:4px}.ui\:\[\&\>a\:hover\]\:text-primary>a:hover{color:var(--primary)}.ui\:\[\&\>button\]\:hidden>button{display:none}.ui\:\[\&\>input\]\:flex-1>input{flex:1}.ui\:has-\[\>\[data-align\=block-end\]\]\:\[\&\>input\]\:pt-3:has(>[data-align=block-end])>input{padding-top:calc(var(--ui-spacing) * 3)}.ui\:has-\[\>\[data-align\=block-start\]\]\:\[\&\>input\]\:pb-3:has(>[data-align=block-start])>input{padding-bottom:calc(var(--ui-spacing) * 3)}.ui\:has-\[\>\[data-align\=inline-end\]\]\:\[\&\>input\]\:pe-2:has(>[data-align=inline-end])>input{padding-inline-end:calc(var(--ui-spacing) * 2)}.ui\:has-\[\>\[data-align\=inline-start\]\]\:\[\&\>input\]\:ps-2:has(>[data-align=inline-start])>input{padding-inline-start:calc(var(--ui-spacing) * 2)}.ui\:\[\&\>kbd\]\:rounded-\[calc\(var\(--radius\)-5px\)\]>kbd{border-radius:calc(var(--radius) - 5px)}.ui\:\[\&\>span\:last-child\]\:truncate>span:last-child{text-overflow:ellipsis;white-space:nowrap;overflow:hidden}.ui\:\[\&\>svg\]\:pointer-events-none>svg{pointer-events:none}.ui\:\[\&\>svg\]\:size-2\.5>svg{width:calc(var(--ui-spacing) * 2.5);height:calc(var(--ui-spacing) * 2.5)}.ui\:\[\&\>svg\]\:size-3>svg{width:calc(var(--ui-spacing) * 3);height:calc(var(--ui-spacing) * 3)}.ui\:\[\&\>svg\]\:size-3\.5>svg{width:calc(var(--ui-spacing) * 3.5);height:calc(var(--ui-spacing) * 3.5)}.ui\:\[\&\>svg\]\:size-4>svg{width:calc(var(--ui-spacing) * 4);height:calc(var(--ui-spacing) * 4)}.ui\:\[\&\>svg\]\:shrink-0>svg{flex-shrink:0}.ui\:\[\&\>svg\]\:translate-y-0\.5>svg{--tw-translate-y:calc(var(--ui-spacing) * .5);translate:var(--tw-translate-x) var(--tw-translate-y)}.ui\:\[\&\>svg\]\:text-current>svg{color:currentColor}.ui\:\[\&\>svg\]\:text-muted-foreground>svg{color:var(--muted-foreground)}.ui\:\[\&\>svg\]\:text-sidebar-accent-foreground>svg{color:var(--sidebar-accent-foreground)}.ui\:\[\&\>svg\:not\(\[class\*\=\'ui\:size-\'\]\)\]\:size-3\.5>svg:not([class*=ui\:size-]){width:calc(var(--ui-spacing) * 3.5);height:calc(var(--ui-spacing) * 3.5)}.ui\:\[\&\>svg\:not\(\[class\*\=\'ui\:size-\'\]\)\]\:size-4>svg:not([class*=ui\:size-]){width:calc(var(--ui-spacing) * 4);height:calc(var(--ui-spacing) * 4)}@media (hover:hover){:is(.ui\:hover\:\[\&\,\&\>svelte-css-wrapper\]\:\[\&\>th\,td\]\:bg-muted\/50:hover,.ui\:hover\:\[\&\,\&\>svelte-css-wrapper\]\:\[\&\>th\,td\]\:bg-muted\/50:hover>svelte-css-wrapper)>th,:is(.ui\:hover\:\[\&\,\&\>svelte-css-wrapper\]\:\[\&\>th\,td\]\:bg-muted\/50:hover,.ui\:hover\:\[\&\,\&\>svelte-css-wrapper\]\:\[\&\>th\,td\]\:bg-muted\/50:hover>svelte-css-wrapper) td{background-color:var(--muted)}@supports (color:color-mix(in lab, red, red)){:is(.ui\:hover\:\[\&\,\&\>svelte-css-wrapper\]\:\[\&\>th\,td\]\:bg-muted\/50:hover,.ui\:hover\:\[\&\,\&\>svelte-css-wrapper\]\:\[\&\>th\,td\]\:bg-muted\/50:hover>svelte-css-wrapper)>th,:is(.ui\:hover\:\[\&\,\&\>svelte-css-wrapper\]\:\[\&\>th\,td\]\:bg-muted\/50:hover,.ui\:hover\:\[\&\,\&\>svelte-css-wrapper\]\:\[\&\>th\,td\]\:bg-muted\/50:hover>svelte-css-wrapper) td{background-color:color-mix(in oklab, var(--muted) 50%, transparent)}}}.ui\:\[\&\>tr\]\:last\:border-b-0>tr:last-child{border-bottom-style:var(--tw-border-style);border-bottom-width:0}.ui\:\[\&\[data-state\=open\]\>svg\]\:rotate-180[data-state=open]>svg{rotate:180deg}[data-side=left][data-collapsible=offcanvas] .ui\:\[\[data-side\=left\]\[data-collapsible\=offcanvas\]_\&\]\:-right-2{right:calc(var(--ui-spacing) * -2)}[data-side=left][data-state=collapsed] .ui\:\[\[data-side\=left\]\[data-state\=collapsed\]_\&\]\:cursor-e-resize{cursor:e-resize}[data-side=right][data-collapsible=offcanvas] .ui\:\[\[data-side\=right\]\[data-collapsible\=offcanvas\]_\&\]\:-left-2{left:calc(var(--ui-spacing) * -2)}[data-side=right][data-state=collapsed] .ui\:\[\[data-side\=right\]\[data-state\=collapsed\]_\&\]\:cursor-w-resize{cursor:w-resize}[data-variant=legend]+.ui\:\[\[data-variant\=legend\]\+\&\]\:-mt-1\.5{margin-top:calc(var(--ui-spacing) * -1.5)}@media (hover:hover){a.ui\:\[a\&\]\:hover\:bg-accent:hover{background-color:var(--accent)}a.ui\:\[a\&\]\:hover\:bg-amber-600\/90:hover{background-color:var(--ui-color-amber-600)}@supports (color:color-mix(in lab, red, red)){a.ui\:\[a\&\]\:hover\:bg-amber-600\/90:hover{background-color:color-mix(in oklab, var(--ui-color-amber-600) 90%, transparent)}}a.ui\:\[a\&\]\:hover\:bg-destructive\/90:hover{background-color:var(--destructive)}@supports (color:color-mix(in lab, red, red)){a.ui\:\[a\&\]\:hover\:bg-destructive\/90:hover{background-color:color-mix(in oklab, var(--destructive) 90%, transparent)}}a.ui\:\[a\&\]\:hover\:bg-emerald-600\/90:hover{background-color:var(--ui-color-emerald-600)}@supports (color:color-mix(in lab, red, red)){a.ui\:\[a\&\]\:hover\:bg-emerald-600\/90:hover{background-color:color-mix(in oklab, var(--ui-color-emerald-600) 90%, transparent)}}a.ui\:\[a\&\]\:hover\:bg-primary\/30:hover{background-color:var(--primary)}@supports (color:color-mix(in lab, red, red)){a.ui\:\[a\&\]\:hover\:bg-primary\/30:hover{background-color:color-mix(in oklab, var(--primary) 30%, transparent)}}a.ui\:\[a\&\]\:hover\:bg-primary\/90:hover{background-color:var(--primary)}@supports (color:color-mix(in lab, red, red)){a.ui\:\[a\&\]\:hover\:bg-primary\/90:hover{background-color:color-mix(in oklab, var(--primary) 90%, transparent)}}a.ui\:\[a\&\]\:hover\:bg-secondary\/80:hover{background-color:var(--secondary)}@supports (color:color-mix(in lab, red, red)){a.ui\:\[a\&\]\:hover\:bg-secondary\/80:hover{background-color:color-mix(in oklab, var(--secondary) 80%, transparent)}}a.ui\:\[a\&\]\:hover\:bg-secondary\/90:hover{background-color:var(--secondary)}@supports (color:color-mix(in lab, red, red)){a.ui\:\[a\&\]\:hover\:bg-secondary\/90:hover{background-color:color-mix(in oklab, var(--secondary) 90%, transparent)}}a.ui\:\[a\&\]\:hover\:text-accent-foreground:hover{color:var(--accent-foreground)}a.ui\:\[a\&\]\:hover\:text-primary:hover{color:var(--primary)}a.ui\:\[a\&\]\:hover\:underline:hover{text-decoration-line:underline}a.ui\:dark\:\[a\&\]\:hover\:bg-accent\/50:where(.dark,.dark *):hover{background-color:var(--accent)}@supports (color:color-mix(in lab, red, red)){a.ui\:dark\:\[a\&\]\:hover\:bg-accent\/50:where(.dark,.dark *):hover{background-color:color-mix(in oklab, var(--accent) 50%, transparent)}}}}@property --tw-animation-delay{syntax:"*";inherits:false;initial-value:0s}@property --tw-animation-direction{syntax:"*";inherits:false;initial-value:normal}@property --tw-animation-duration{syntax:"*";inherits:false}@property --tw-animation-fill-mode{syntax:"*";inherits:false;initial-value:none}@property --tw-animation-iteration-count{syntax:"*";inherits:false;initial-value:1}@property --tw-enter-blur{syntax:"*";inherits:false;initial-value:0}@property --tw-enter-opacity{syntax:"*";inherits:false;initial-value:1}@property --tw-enter-rotate{syntax:"*";inherits:false;initial-value:0}@property --tw-enter-scale{syntax:"*";inherits:false;initial-value:1}@property --tw-enter-translate-x{syntax:"*";inherits:false;initial-value:0}@property --tw-enter-translate-y{syntax:"*";inherits:false;initial-value:0}@property --tw-exit-blur{syntax:"*";inherits:false;initial-value:0}@property --tw-exit-opacity{syntax:"*";inherits:false;initial-value:1}@property --tw-exit-rotate{syntax:"*";inherits:false;initial-value:0}@property --tw-exit-scale{syntax:"*";inherits:false;initial-value:1}@property --tw-exit-translate-x{syntax:"*";inherits:false;initial-value:0}@property --tw-exit-translate-y{syntax:"*";inherits:false;initial-value:0}:root{--radius:.625rem;--background:oklch(100% 0 0);--foreground:oklch(14.7% .004 49.25);--card:oklch(100% 0 0);--card-foreground:oklch(14.7% .004 49.25);--popover:oklch(100% 0 0);--popover-foreground:oklch(14.7% .004 49.25);--primary:oklch(21.6% .006 56.043);--primary-foreground:oklch(98.5% .001 106.423);--secondary:oklch(97% .001 106.424);--secondary-foreground:oklch(21.6% .006 56.043);--muted:oklch(97% .001 106.424);--muted-foreground:oklch(55.3% .013 58.071);--accent:oklch(96.7% .001 286.375);--accent-foreground:oklch(21.6% .006 56.043);--destructive:oklch(57.7% .245 27.325);--border:oklch(92.3% .003 48.717);--input:oklch(92.3% .003 48.717);--ring:oklch(70.9% .01 56.259);--chart-1:oklch(64.6% .222 41.116);--chart-2:oklch(60% .118 184.704);--chart-3:oklch(39.8% .07 227.392);--chart-4:oklch(82.8% .189 84.429);--chart-5:oklch(76.9% .188 70.08);--sidebar:oklch(100% 0 0);--sidebar-foreground:oklch(14.7% .004 49.25);--sidebar-primary:oklch(21.6% .006 56.043);--sidebar-primary-foreground:oklch(98.5% .001 106.423);--sidebar-accent:oklch(97% .001 106.424);--sidebar-accent-foreground:oklch(21.6% .006 56.043);--sidebar-border:oklch(92.3% .003 48.717);--sidebar-ring:oklch(70.9% .01 56.259)}.dark{--background:oklch(14.7% .004 49.25);--foreground:oklch(98.5% .001 106.423);--card:oklch(21.6% .006 56.043);--card-foreground:oklch(98.5% .001 106.423);--popover:oklch(21.6% .006 56.043);--popover-foreground:oklch(98.5% .001 106.423);--primary:oklch(92.3% .003 48.717);--primary-foreground:oklch(21.6% .006 56.043);--secondary:oklch(26.8% .007 34.298);--secondary-foreground:oklch(98.5% .001 106.423);--muted:oklch(26.8% .007 34.298);--muted-foreground:oklch(70.9% .01 56.259);--accent:oklch(26.8% .007 34.298);--accent-foreground:oklch(98.5% .001 106.423);--destructive:oklch(70.4% .191 22.216);--border:oklch(100% 0 0/.1);--input:oklch(100% 0 0/.15);--ring:oklch(55.3% .013 58.071);--chart-1:oklch(48.8% .243 264.376);--chart-2:oklch(69.6% .17 162.48);--chart-3:oklch(76.9% .188 70.08);--chart-4:oklch(62.7% .265 303.9);--chart-5:oklch(64.5% .246 16.439);--sidebar:oklch(0% 0 0);--sidebar-foreground:oklch(98.5% .001 106.423);--sidebar-primary:oklch(48.8% .243 264.376);--sidebar-primary-foreground:oklch(98.5% .001 106.423);--sidebar-accent:oklch(26.8% .007 34.298);--sidebar-accent-foreground:oklch(98.5% .001 106.423);--sidebar-border:oklch(100% 0 0/.1);--sidebar-ring:oklch(55.3% .013 58.071)}@property --border-angle{syntax:"<angle>";inherits:false;initial-value:0deg}@keyframes border{to{--border-angle:360deg}}.animate-gradient-border{background:linear-gradient(45deg, white, white) padding-box, conic-gradient(from var(--border-angle), #94a3b84d 75%, var(--primary,#1d4ee2) 82%, var(--primary-foreground,white) 88%, var(--primary,#1d4ee2) 92%, #94a3b84d 100%) border-box;border:1px solid #0000;transition:--border-angle 3s ease-in-out}.animate-gradient-border:hover{animation:4s ease-in-out infinite border}.dark.animate-gradient-border{background:linear-gradient(45deg, #000, #000) padding-box, conic-gradient(from var(--border-angle), #4755697a 75%, var(--primary,#1d4ee2) 82%, var(--primary-foreground,black) 88%, var(--primary,#1d4ee2) 92%, #4755697a 100%) border-box}@property --tw-translate-x{syntax:"*";inherits:false;initial-value:0}@property --tw-translate-y{syntax:"*";inherits:false;initial-value:0}@property --tw-translate-z{syntax:"*";inherits:false;initial-value:0}@property --tw-scale-x{syntax:"*";inherits:false;initial-value:1}@property --tw-scale-y{syntax:"*";inherits:false;initial-value:1}@property --tw-scale-z{syntax:"*";inherits:false;initial-value:1}@property --tw-space-y-reverse{syntax:"*";inherits:false;initial-value:0}@property --tw-border-style{syntax:"*";inherits:false;initial-value:solid}@property --tw-gradient-position{syntax:"*";inherits:false}@property --tw-gradient-from{syntax:"<color>";inherits:false;initial-value:#0000}@property --tw-gradient-via{syntax:"<color>";inherits:false;initial-value:#0000}@property --tw-gradient-to{syntax:"<color>";inherits:false;initial-value:#0000}@property --tw-gradient-stops{syntax:"*";inherits:false}@property --tw-gradient-via-stops{syntax:"*";inherits:false}@property --tw-gradient-from-position{syntax:"<length-percentage>";inherits:false;initial-value:0%}@property --tw-gradient-via-position{syntax:"<length-percentage>";inherits:false;initial-value:50%}@property --tw-gradient-to-position{syntax:"<length-percentage>";inherits:false;initial-value:100%}@property --tw-leading{syntax:"*";inherits:false}@property --tw-font-weight{syntax:"*";inherits:false}@property --tw-tracking{syntax:"*";inherits:false}@property --tw-shadow{syntax:"*";inherits:false;initial-value:0 0 #0000}@property --tw-shadow-color{syntax:"*";inherits:false}@property --tw-shadow-alpha{syntax:"<percentage>";inherits:false;initial-value:100%}@property --tw-inset-shadow{syntax:"*";inherits:false;initial-value:0 0 #0000}@property --tw-inset-shadow-color{syntax:"*";inherits:false}@property --tw-inset-shadow-alpha{syntax:"<percentage>";inherits:false;initial-value:100%}@property --tw-ring-color{syntax:"*";inherits:false}@property --tw-ring-shadow{syntax:"*";inherits:false;initial-value:0 0 #0000}@property --tw-inset-ring-color{syntax:"*";inherits:false}@property --tw-inset-ring-shadow{syntax:"*";inherits:false;initial-value:0 0 #0000}@property --tw-ring-inset{syntax:"*";inherits:false}@property --tw-ring-offset-width{syntax:"<length>";inherits:false;initial-value:0}@property --tw-ring-offset-color{syntax:"*";inherits:false;initial-value:#fff}@property --tw-ring-offset-shadow{syntax:"*";inherits:false;initial-value:0 0 #0000}@property --tw-backdrop-blur{syntax:"*";inherits:false}@property --tw-backdrop-brightness{syntax:"*";inherits:false}@property --tw-backdrop-contrast{syntax:"*";inherits:false}@property --tw-backdrop-grayscale{syntax:"*";inherits:false}@property --tw-backdrop-hue-rotate{syntax:"*";inherits:false}@property --tw-backdrop-invert{syntax:"*";inherits:false}@property --tw-backdrop-opacity{syntax:"*";inherits:false}@property --tw-backdrop-saturate{syntax:"*";inherits:false}@property --tw-backdrop-sepia{syntax:"*";inherits:false}@property --tw-duration{syntax:"*";inherits:false}@property --tw-ease{syntax:"*";inherits:false}@property --tw-content{syntax:"*";inherits:false;initial-value:""}@property --tw-outline-style{syntax:"*";inherits:false;initial-value:solid}@keyframes spin{to{transform:rotate(360deg)}}@keyframes pulse{50%{opacity:.5}}@keyframes enter{0%{opacity:var(--tw-enter-opacity,1);transform:translate3d(var(--tw-enter-translate-x,0),var(--tw-enter-translate-y,0),0)scale3d(var(--tw-enter-scale,1),var(--tw-enter-scale,1),var(--tw-enter-scale,1))rotate(var(--tw-enter-rotate,0));filter:blur(var(--tw-enter-blur,0))}}@keyframes exit{to{opacity:var(--tw-exit-opacity,1);transform:translate3d(var(--tw-exit-translate-x,0),var(--tw-exit-translate-y,0),0)scale3d(var(--tw-exit-scale,1),var(--tw-exit-scale,1),var(--tw-exit-scale,1))rotate(var(--tw-exit-rotate,0));filter:blur(var(--tw-exit-blur,0))}}@keyframes accordion-down{0%{height:0}to{height:var(--radix-accordion-content-height,var(--bits-accordion-content-height,var(--reka-accordion-content-height,var(--kb-accordion-content-height,var(--ngp-accordion-content-height,auto)))))}}@keyframes accordion-up{0%{height:var(--radix-accordion-content-height,var(--bits-accordion-content-height,var(--reka-accordion-content-height,var(--kb-accordion-content-height,var(--ngp-accordion-content-height,auto)))))}to{height:0}}
\ No newline at end of file
+@layer properties{@supports (((-webkit-hyphens:none)) and (not (margin-trim:inline))) or ((-moz-orient:inline) and (not (color:rgb(from red r g b)))){*,:before,:after,::backdrop{--tw-translate-x:0;--tw-translate-y:0;--tw-translate-z:0;--tw-scale-x:1;--tw-scale-y:1;--tw-scale-z:1;--tw-space-y-reverse:0;--tw-border-style:solid;--tw-gradient-position:initial;--tw-gradient-from:#0000;--tw-gradient-via:#0000;--tw-gradient-to:#0000;--tw-gradient-stops:initial;--tw-gradient-via-stops:initial;--tw-gradient-from-position:0%;--tw-gradient-via-position:50%;--tw-gradient-to-position:100%;--tw-leading:initial;--tw-font-weight:initial;--tw-tracking:initial;--tw-shadow:0 0 #0000;--tw-shadow-color:initial;--tw-shadow-alpha:100%;--tw-inset-shadow:0 0 #0000;--tw-inset-shadow-color:initial;--tw-inset-shadow-alpha:100%;--tw-ring-color:initial;--tw-ring-shadow:0 0 #0000;--tw-inset-ring-color:initial;--tw-inset-ring-shadow:0 0 #0000;--tw-ring-inset:initial;--tw-ring-offset-width:0px;--tw-ring-offset-color:#fff;--tw-ring-offset-shadow:0 0 #0000;--tw-backdrop-blur:initial;--tw-backdrop-brightness:initial;--tw-backdrop-contrast:initial;--tw-backdrop-grayscale:initial;--tw-backdrop-hue-rotate:initial;--tw-backdrop-invert:initial;--tw-backdrop-opacity:initial;--tw-backdrop-saturate:initial;--tw-backdrop-sepia:initial;--tw-duration:initial;--tw-ease:initial;--tw-content:"";--tw-outline-style:solid;--tw-animation-delay:0s;--tw-animation-direction:normal;--tw-animation-duration:initial;--tw-animation-fill-mode:none;--tw-animation-iteration-count:1;--tw-enter-blur:0;--tw-enter-opacity:1;--tw-enter-rotate:0;--tw-enter-scale:1;--tw-enter-translate-x:0;--tw-enter-translate-y:0;--tw-exit-blur:0;--tw-exit-opacity:1;--tw-exit-rotate:0;--tw-exit-scale:1;--tw-exit-translate-x:0;--tw-exit-translate-y:0;--border-angle:0deg}}}@layer theme{:root,:host{--ui-font-sans:ui-sans-serif, system-ui, sans-serif, "Apple Color Emoji", "Segoe UI Emoji", "Segoe UI Symbol", "Noto Color Emoji";--ui-font-mono:ui-monospace, SFMono-Regular, Menlo, Monaco, Consolas, "Liberation Mono", "Courier New", monospace;--ui-color-red-50:oklch(97.1% .013 17.38);--ui-color-red-500:oklch(63.7% .237 25.331);--ui-color-red-600:oklch(57.7% .245 27.325);--ui-color-red-700:oklch(50.5% .213 27.518);--ui-color-orange-500:oklch(70.5% .213 47.604);--ui-color-amber-50:oklch(98.7% .022 95.277);--ui-color-amber-200:oklch(92.4% .12 95.746);--ui-color-amber-400:oklch(82.8% .189 84.429);--ui-color-amber-500:oklch(76.9% .188 70.08);--ui-color-amber-600:oklch(66.6% .179 58.318);--ui-color-amber-900:oklch(41.4% .112 45.904);--ui-color-amber-950:oklch(27.9% .077 45.635);--ui-color-yellow-500:oklch(79.5% .184 86.047);--ui-color-green-500:oklch(72.3% .219 149.579);--ui-color-emerald-50:oklch(97.9% .021 166.113);--ui-color-emerald-300:oklch(84.5% .143 164.978);--ui-color-emerald-400:oklch(76.5% .177 163.223);--ui-color-emerald-500:oklch(69.6% .17 162.48);--ui-color-emerald-600:oklch(59.6% .145 163.225);--ui-color-emerald-950:oklch(26.2% .051 172.552);--ui-color-sky-50:oklch(97.7% .013 236.62);--ui-color-sky-200:oklch(90.1% .058 230.902);--ui-color-sky-900:oklch(39.1% .09 240.876);--ui-color-sky-950:oklch(29.3% .066 243.157);--ui-color-pink-500:oklch(65.6% .241 354.308);--ui-color-slate-800:oklch(27.9% .041 260.031);--ui-color-slate-950:oklch(12.9% .042 264.695);--ui-color-gray-200:oklch(92.8% .006 264.531);--ui-color-black:#000;--ui-color-white:#fff;--ui-spacing:.25rem;--ui-container-sm:24rem;--ui-container-lg:32rem;--ui-container-xl:36rem;--ui-container-3xl:48rem;--ui-text-xs:.75rem;--ui-text-xs--line-height:calc(1 / .75);--ui-text-sm:.875rem;--ui-text-sm--line-height:calc(1.25 / .875);--ui-text-base:1rem;--ui-text-base--line-height:calc(1.5 / 1);--ui-text-lg:1.125rem;--ui-text-lg--line-height:calc(1.75 / 1.125);--ui-text-xl:1.25rem;--ui-text-xl--line-height:calc(1.75 / 1.25);--ui-text-2xl:1.5rem;--ui-text-2xl--line-height:calc(2 / 1.5);--ui-font-weight-normal:400;--ui-font-weight-medium:500;--ui-font-weight-semibold:600;--ui-font-weight-bold:700;--ui-tracking-tight:-.025em;--ui-tracking-widest:.1em;--ui-leading-snug:1.375;--ui-leading-normal:1.5;--ui-leading-relaxed:1.625;--ui-radius-xs:.125rem;--ui-ease-in-out:cubic-bezier(.4, 0, .2, 1);--ui-animate-spin:spin 1s linear infinite;--ui-animate-pulse:pulse 2s cubic-bezier(.4, 0, .6, 1) infinite;--ui-blur-sm:8px;--ui-aspect-video:16 / 9;--ui-default-transition-duration:.15s;--ui-default-transition-timing-function:cubic-bezier(.4, 0, .2, 1);--ui-default-mono-font-family:var(--ui-font-mono)}}@layer base{*,:after,:before,::backdrop{box-sizing:border-box;border:0 solid;margin:0;padding:0}::file-selector-button{box-sizing:border-box;border:0 solid;margin:0;padding:0}html,:host{-webkit-text-size-adjust:100%;tab-size:4;line-height:1.5;font-family:var(--font-cio,ui-sans-serif, system-ui, sans-serif, "Apple Color Emoji", "Segoe UI Emoji", "Segoe UI Symbol", "Noto Color Emoji");font-feature-settings:var(--ui-default-font-feature-settings,normal);font-variation-settings:var(--ui-default-font-variation-settings,normal);-webkit-tap-highlight-color:transparent}hr{height:0;color:inherit;border-top-width:1px}abbr:where([title]){-webkit-text-decoration:underline dotted;text-decoration:underline dotted}h1,h2,h3,h4,h5,h6{font-size:inherit;font-weight:inherit}a{color:inherit;-webkit-text-decoration:inherit;-webkit-text-decoration:inherit;-webkit-text-decoration:inherit;text-decoration:inherit}b,strong{font-weight:bolder}code,kbd,samp,pre{font-family:var(--ui-default-mono-font-family,ui-monospace, SFMono-Regular, Menlo, Monaco, Consolas, "Liberation Mono", "Courier New", monospace);font-feature-settings:var(--ui-default-mono-font-feature-settings,normal);font-variation-settings:var(--ui-default-mono-font-variation-settings,normal);font-size:1em}small{font-size:80%}sub,sup{vertical-align:baseline;font-size:75%;line-height:0;position:relative}sub{bottom:-.25em}sup{top:-.5em}table{text-indent:0;border-color:inherit;border-collapse:collapse}:-moz-focusring{outline:auto}progress{vertical-align:baseline}summary{display:list-item}ol,ul,menu{list-style:none}img,svg,video,canvas,audio,iframe,embed,object{vertical-align:middle;display:block}img,video{max-width:100%;height:auto}button,input,select,optgroup,textarea{font:inherit;font-feature-settings:inherit;font-variation-settings:inherit;letter-spacing:inherit;color:inherit;opacity:1;background-color:#0000;border-radius:0}::file-selector-button{font:inherit;font-feature-settings:inherit;font-variation-settings:inherit;letter-spacing:inherit;color:inherit;opacity:1;background-color:#0000;border-radius:0}:where(select:is([multiple],[size])) optgroup{font-weight:bolder}:where(select:is([multiple],[size])) optgroup option{padding-inline-start:20px}::file-selector-button{margin-inline-end:4px}::placeholder{opacity:1}@supports (not ((-webkit-appearance:-apple-pay-button))) or (contain-intrinsic-size:1px){::placeholder{color:currentColor}@supports (color:color-mix(in lab, red, red)){::placeholder{color:color-mix(in oklab, currentcolor 50%, transparent)}}}textarea{resize:vertical}::-webkit-search-decoration{-webkit-appearance:none}::-webkit-date-and-time-value{min-height:1lh;text-align:inherit}::-webkit-datetime-edit{display:inline-flex}::-webkit-datetime-edit-fields-wrapper{padding:0}::-webkit-datetime-edit{padding-block:0}::-webkit-datetime-edit-year-field{padding-block:0}::-webkit-datetime-edit-month-field{padding-block:0}::-webkit-datetime-edit-day-field{padding-block:0}::-webkit-datetime-edit-hour-field{padding-block:0}::-webkit-datetime-edit-minute-field{padding-block:0}::-webkit-datetime-edit-second-field{padding-block:0}::-webkit-datetime-edit-millisecond-field{padding-block:0}::-webkit-datetime-edit-meridiem-field{padding-block:0}::-webkit-calendar-picker-indicator{line-height:1}:-moz-ui-invalid{box-shadow:none}button,input:where([type=button],[type=reset],[type=submit]){appearance:button}::file-selector-button{appearance:button}::-webkit-inner-spin-button{height:auto}::-webkit-outer-spin-button{height:auto}[hidden]:where(:not([hidden=until-found])){display:none!important}*{border-color:var(--border);outline-color:var(--ring)}@supports (color:color-mix(in lab, red, red)){*{outline-color:color-mix(in oklab, var(--ring) 50%, transparent)}}body{background-color:var(--background);font-family:var(--font-sans);color:var(--foreground)}button,input,select,optgroup,textarea{font-family:var(--font-sans)}::file-selector-button{font-family:var(--font-sans)}.toaster{--normal-bg:var(--color-popover);--normal-text:var(--color-popover-foreground);--normal-border:var(--color-border)}}@layer components;@layer utilities{.ui\:\@container\/field-group{container:field-group/inline-size}.ui\:pointer-events-none{pointer-events:none}.ui\:sr-only{clip-path:inset(50%);white-space:nowrap;border-width:0;width:1px;height:1px;margin:-1px;padding:0;position:absolute;overflow:hidden}.ui\:absolute{position:absolute}.ui\:fixed{position:fixed}.ui\:relative{position:relative}.ui\:sticky{position:sticky}.ui\:inset-0{inset:calc(var(--ui-spacing) * 0)}.ui\:inset-x-0{inset-inline:calc(var(--ui-spacing) * 0)}.ui\:inset-y-0{inset-block:calc(var(--ui-spacing) * 0)}.ui\:start-0{inset-inline-start:calc(var(--ui-spacing) * 0)}.ui\:end-4{inset-inline-end:calc(var(--ui-spacing) * 4)}.ui\:-top-2{top:calc(var(--ui-spacing) * -2)}.ui\:-top-3{top:calc(var(--ui-spacing) * -3)}.ui\:top-0{top:calc(var(--ui-spacing) * 0)}.ui\:top-1\.5{top:calc(var(--ui-spacing) * 1.5)}.ui\:top-1\/2{top:50%}.ui\:top-2{top:calc(var(--ui-spacing) * 2)}.ui\:top-3\.5{top:calc(var(--ui-spacing) * 3.5)}.ui\:top-4{top:calc(var(--ui-spacing) * 4)}.ui\:top-13{top:calc(var(--ui-spacing) * 13)}.ui\:top-\[-12px\]{top:-12px}.ui\:top-\[50\%\]{top:50%}.ui\:top-\[60\%\]{top:60%}.ui\:top-full{top:100%}.ui\:top-px{top:1px}.ui\:-right-4{right:calc(var(--ui-spacing) * -4)}.ui\:right-0{right:calc(var(--ui-spacing) * 0)}.ui\:right-1{right:calc(var(--ui-spacing) * 1)}.ui\:right-2{right:calc(var(--ui-spacing) * 2)}.ui\:right-3{right:calc(var(--ui-spacing) * 3)}.ui\:right-4{right:calc(var(--ui-spacing) * 4)}.ui\:right-9{right:calc(var(--ui-spacing) * 9)}.ui\:right-\[-12px\]{right:-12px}.ui\:-bottom-px{bottom:-1px}.ui\:bottom-0{bottom:calc(var(--ui-spacing) * 0)}.ui\:bottom-2{bottom:calc(var(--ui-spacing) * 2)}.ui\:left-0{left:calc(var(--ui-spacing) * 0)}.ui\:left-1\/2{left:50%}.ui\:left-2{left:calc(var(--ui-spacing) * 2)}.ui\:left-\[50\%\]{left:50%}.ui\:left-\[calc\(50\%-3rem\)\]{left:calc(50% - 3rem)}.ui\:isolate{isolation:isolate}.ui\:z-1{z-index:1}.ui\:z-10{z-index:10}.ui\:z-20{z-index:20}.ui\:z-50{z-index:50}.ui\:z-200{z-index:200}.ui\:z-999{z-index:999}.ui\:z-\[1\]{z-index:1}.ui\:order-first{order:-9999}.ui\:order-last{order:9999}.ui\:col-start-2{grid-column-start:2}.ui\:row-span-2{grid-row:span 2/span 2}.ui\:row-start-1{grid-row-start:1}.ui\:m-0{margin:calc(var(--ui-spacing) * 0)}.ui\:m-0\!{margin:calc(var(--ui-spacing) * 0)!important}.ui\:-mx-1{margin-inline:calc(var(--ui-spacing) * -1)}.ui\:mx-auto{margin-inline:auto}.ui\:my-0{margin-block:calc(var(--ui-spacing) * 0)}.ui\:my-0\.5{margin-block:calc(var(--ui-spacing) * .5)}.ui\:my-1{margin-block:calc(var(--ui-spacing) * 1)}.ui\:my-2{margin-block:calc(var(--ui-spacing) * 2)}.ui\:my-4{margin-block:calc(var(--ui-spacing) * 4)}.ui\:ms-1{margin-inline-start:calc(var(--ui-spacing) * 1)}.ui\:ms-4{margin-inline-start:calc(var(--ui-spacing) * 4)}.ui\:mt-0\.5{margin-top:calc(var(--ui-spacing) * .5)}.ui\:mt-1{margin-top:calc(var(--ui-spacing) * 1)}.ui\:mt-1\.5{margin-top:calc(var(--ui-spacing) * 1.5)}.ui\:mt-3{margin-top:calc(var(--ui-spacing) * 3)}.ui\:mt-4{margin-top:calc(var(--ui-spacing) * 4)}.ui\:mt-auto{margin-top:auto}.ui\:mr-1{margin-right:calc(var(--ui-spacing) * 1)}.ui\:mr-2{margin-right:calc(var(--ui-spacing) * 2)}.ui\:mb-1{margin-bottom:calc(var(--ui-spacing) * 1)}.ui\:mb-2{margin-bottom:calc(var(--ui-spacing) * 2)}.ui\:mb-3{margin-bottom:calc(var(--ui-spacing) * 3)}.ui\:mb-4{margin-bottom:calc(var(--ui-spacing) * 4)}.ui\:ml-1{margin-left:calc(var(--ui-spacing) * 1)}.ui\:ml-2{margin-left:calc(var(--ui-spacing) * 2)}.ui\:ml-2\.5{margin-left:calc(var(--ui-spacing) * 2.5)}.ui\:ml-auto{margin-left:auto}.ui\:line-clamp-1{-webkit-line-clamp:1;-webkit-box-orient:vertical;display:-webkit-box;overflow:hidden}.ui\:line-clamp-2{-webkit-line-clamp:2;-webkit-box-orient:vertical;display:-webkit-box;overflow:hidden}.ui\:line-clamp-3{-webkit-line-clamp:3;-webkit-box-orient:vertical;display:-webkit-box;overflow:hidden}.ui\:block{display:block}.ui\:flex{display:flex}.ui\:grid{display:grid}.ui\:hidden{display:none}.ui\:inline-block{display:inline-block}.ui\:inline-flex{display:inline-flex}.ui\:field-sizing-content{field-sizing:content}.ui\:aspect-video{aspect-ratio:var(--ui-aspect-video)}.ui\:size-2{width:calc(var(--ui-spacing) * 2);height:calc(var(--ui-spacing) * 2)}.ui\:size-2\.5{width:calc(var(--ui-spacing) * 2.5);height:calc(var(--ui-spacing) * 2.5)}.ui\:size-3{width:calc(var(--ui-spacing) * 3);height:calc(var(--ui-spacing) * 3)}.ui\:size-3\.5{width:calc(var(--ui-spacing) * 3.5);height:calc(var(--ui-spacing) * 3.5)}.ui\:size-4{width:calc(var(--ui-spacing) * 4);height:calc(var(--ui-spacing) * 4)}.ui\:size-5{width:calc(var(--ui-spacing) * 5);height:calc(var(--ui-spacing) * 5)}.ui\:size-6{width:calc(var(--ui-spacing) * 6);height:calc(var(--ui-spacing) * 6)}.ui\:size-7{width:calc(var(--ui-spacing) * 7);height:calc(var(--ui-spacing) * 7)}.ui\:size-8{width:calc(var(--ui-spacing) * 8);height:calc(var(--ui-spacing) * 8)}.ui\:size-9{width:calc(var(--ui-spacing) * 9);height:calc(var(--ui-spacing) * 9)}.ui\:size-10{width:calc(var(--ui-spacing) * 10);height:calc(var(--ui-spacing) * 10)}.ui\:size-14{width:calc(var(--ui-spacing) * 14);height:calc(var(--ui-spacing) * 14)}.ui\:size-14\!{width:calc(var(--ui-spacing) * 14)!important;height:calc(var(--ui-spacing) * 14)!important}.ui\:size-20{width:calc(var(--ui-spacing) * 20);height:calc(var(--ui-spacing) * 20)}.ui\:size-fit{width:fit-content;height:fit-content}.ui\:size-full{width:100%;height:100%}.ui\:h-\(--bits-navigation-menu-viewport-height\){height:var(--bits-navigation-menu-viewport-height)}.ui\:h-\(--bits-select-anchor-height\){height:var(--bits-select-anchor-height)}.ui\:h-0\.5{height:calc(var(--ui-spacing) * .5)}.ui\:h-1\.5{height:calc(var(--ui-spacing) * 1.5)}.ui\:h-2{height:calc(var(--ui-spacing) * 2)}.ui\:h-4{height:calc(var(--ui-spacing) * 4)}.ui\:h-5{height:calc(var(--ui-spacing) * 5)}.ui\:h-6{height:calc(var(--ui-spacing) * 6)}.ui\:h-7{height:calc(var(--ui-spacing) * 7)}.ui\:h-8{height:calc(var(--ui-spacing) * 8)}.ui\:h-9{height:calc(var(--ui-spacing) * 9)}.ui\:h-10{height:calc(var(--ui-spacing) * 10)}.ui\:h-12{height:calc(var(--ui-spacing) * 12)}.ui\:h-24{height:calc(var(--ui-spacing) * 24)}.ui\:h-28{height:calc(var(--ui-spacing) * 28)}.ui\:h-40{height:calc(var(--ui-spacing) * 40)}.ui\:h-48{height:calc(var(--ui-spacing) * 48)}.ui\:h-96{height:calc(var(--ui-spacing) * 96)}.ui\:h-128{height:calc(var(--ui-spacing) * 128)}.ui\:h-\[1\.2rem\]{height:1.2rem}.ui\:h-\[1\.15rem\]{height:1.15rem}.ui\:h-\[6px\]{height:6px}.ui\:h-\[70px\]{height:70px}.ui\:h-\[280px\]{height:280px}.ui\:h-\[calc\(100\%-1px\)\]{height:calc(100% - 1px)}.ui\:h-\[calc\(100\%-3px\)\]{height:calc(100% - 3px)}.ui\:h-auto{height:auto}.ui\:h-fit{height:fit-content}.ui\:h-fit\!{height:fit-content!important}.ui\:h-full{height:100%}.ui\:h-px{height:1px}.ui\:h-screen{height:100vh}.ui\:max-h-\(--bits-dropdown-menu-content-available-height\){max-height:var(--bits-dropdown-menu-content-available-height)}.ui\:max-h-\(--bits-select-content-available-height\){max-height:var(--bits-select-content-available-height)}.ui\:max-h-60{max-height:calc(var(--ui-spacing) * 60)}.ui\:max-h-64{max-height:calc(var(--ui-spacing) * 64)}.ui\:max-h-72{max-height:calc(var(--ui-spacing) * 72)}.ui\:max-h-80{max-height:calc(var(--ui-spacing) * 80)}.ui\:max-h-90{max-height:calc(var(--ui-spacing) * 90)}.ui\:max-h-96{max-height:calc(var(--ui-spacing) * 96)}.ui\:max-h-\[300px\]{max-height:300px}.ui\:max-h-svh{max-height:100svh}.ui\:min-h-0{min-height:calc(var(--ui-spacing) * 0)}.ui\:min-h-4{min-height:calc(var(--ui-spacing) * 4)}.ui\:min-h-16{min-height:calc(var(--ui-spacing) * 16)}.ui\:min-h-40{min-height:calc(var(--ui-spacing) * 40)}.ui\:min-h-96{min-height:calc(var(--ui-spacing) * 96)}.ui\:min-h-\[44px\]{min-height:44px}.ui\:min-h-\[calc\(100vh-48px\)\]{min-height:calc(100vh - 48px)}.ui\:w-\(--sidebar-width\){width:var(--sidebar-width)}.ui\:w-0{width:calc(var(--ui-spacing) * 0)}.ui\:w-1{width:calc(var(--ui-spacing) * 1)}.ui\:w-1\/4{width:25%}.ui\:w-2{width:calc(var(--ui-spacing) * 2)}.ui\:w-2\/4{width:50%}.ui\:w-3\/4{width:75%}.ui\:w-4{width:calc(var(--ui-spacing) * 4)}.ui\:w-5{width:calc(var(--ui-spacing) * 5)}.ui\:w-6{width:calc(var(--ui-spacing) * 6)}.ui\:w-7{width:calc(var(--ui-spacing) * 7)}.ui\:w-8{width:calc(var(--ui-spacing) * 8)}.ui\:w-24{width:calc(var(--ui-spacing) * 24)}.ui\:w-28{width:calc(var(--ui-spacing) * 28)}.ui\:w-40{width:calc(var(--ui-spacing) * 40)}.ui\:w-64{width:calc(var(--ui-spacing) * 64)}.ui\:w-72{width:calc(var(--ui-spacing) * 72)}.ui\:w-88{width:calc(var(--ui-spacing) * 88)}.ui\:w-\[1\.2rem\]{width:1.2rem}.ui\:w-\[25px\]{width:25px}.ui\:w-\[100px\]{width:100px}.ui\:w-fit{width:fit-content}.ui\:w-fit\!{width:fit-content!important}.ui\:w-full{width:100%}.ui\:w-full\!{width:100%!important}.ui\:w-max{width:max-content}.ui\:w-screen{width:100vw}.ui\:max-w-\(--skeleton-width\){max-width:var(--skeleton-width)}.ui\:max-w-3xl{max-width:var(--ui-container-3xl)}.ui\:max-w-6{max-width:calc(var(--ui-spacing) * 6)}.ui\:max-w-80{max-width:calc(var(--ui-spacing) * 80)}.ui\:max-w-\[60\%\]{max-width:60%}.ui\:max-w-\[200px\]{max-width:200px}.ui\:max-w-\[300px\]{max-width:300px}.ui\:max-w-\[calc\(100\%-2rem\)\]{max-width:calc(100% - 2rem)}.ui\:max-w-full{max-width:100%}.ui\:max-w-max{max-width:max-content}.ui\:max-w-sm{max-width:var(--ui-container-sm)}.ui\:max-w-xl{max-width:var(--ui-container-xl)}.ui\:min-w-\(--bits-select-anchor-width\){min-width:var(--bits-select-anchor-width)}.ui\:min-w-0{min-width:calc(var(--ui-spacing) * 0)}.ui\:min-w-5{min-width:calc(var(--ui-spacing) * 5)}.ui\:min-w-8{min-width:calc(var(--ui-spacing) * 8)}.ui\:min-w-9{min-width:calc(var(--ui-spacing) * 9)}.ui\:min-w-10{min-width:calc(var(--ui-spacing) * 10)}.ui\:min-w-32{min-width:calc(var(--ui-spacing) * 32)}.ui\:min-w-48{min-width:calc(var(--ui-spacing) * 48)}.ui\:min-w-\[9rem\]{min-width:9rem}.ui\:min-w-full{min-width:100%}.ui\:flex-1{flex:1}.ui\:shrink{flex-shrink:1}.ui\:shrink-0{flex-shrink:0}.ui\:basis-full{flex-basis:100%}.ui\:origin-\(--bits-dropdown-menu-content-transform-origin\){transform-origin:var(--bits-dropdown-menu-content-transform-origin)}.ui\:origin-\(--bits-menubar-content-transform-origin\){transform-origin:var(--bits-menubar-content-transform-origin)}.ui\:origin-\(--bits-popover-content-transform-origin\){transform-origin:var(--bits-popover-content-transform-origin)}.ui\:origin-\(--bits-select-content-transform-origin\){transform-origin:var(--bits-select-content-transform-origin)}.ui\:origin-\(--bits-tooltip-content-transform-origin\){transform-origin:var(--bits-tooltip-content-transform-origin)}.ui\:-translate-x-1\/2{--tw-translate-x:calc(calc(1 / 2 * 100%) * -1);translate:var(--tw-translate-x) var(--tw-translate-y)}.ui\:-translate-x-px{--tw-translate-x:-1px;translate:var(--tw-translate-x) var(--tw-translate-y)}.ui\:translate-x-\[-50\%\]{--tw-translate-x:-50%;translate:var(--tw-translate-x) var(--tw-translate-y)}.ui\:translate-x-px{--tw-translate-x:1px;translate:var(--tw-translate-x) var(--tw-translate-y)}.ui\:-translate-y-1\/2{--tw-translate-y:calc(calc(1 / 2 * 100%) * -1);translate:var(--tw-translate-x) var(--tw-translate-y)}.ui\:translate-y-0\.5{--tw-translate-y:calc(var(--ui-spacing) * .5);translate:var(--tw-translate-x) var(--tw-translate-y)}.ui\:translate-y-\[-50\%\]{--tw-translate-y:-50%;translate:var(--tw-translate-x) var(--tw-translate-y)}.ui\:scale-0{--tw-scale-x:0%;--tw-scale-y:0%;--tw-scale-z:0%;scale:var(--tw-scale-x) var(--tw-scale-y)}.ui\:scale-100{--tw-scale-x:100%;--tw-scale-y:100%;--tw-scale-z:100%;scale:var(--tw-scale-x) var(--tw-scale-y)}.ui\:rotate-0{rotate:none}.ui\:rotate-5{rotate:5deg}.ui\:rotate-45{rotate:45deg}.ui\:rotate-90{rotate:90deg}.ui\:animate-in{animation:enter var(--tw-animation-duration,var(--tw-duration,.15s))var(--tw-ease,ease)var(--tw-animation-delay,0s)var(--tw-animation-iteration-count,1)var(--tw-animation-direction,normal)var(--tw-animation-fill-mode,none)}.ui\:animate-pulse{animation:var(--ui-animate-pulse)}.ui\:animate-spin{animation:var(--ui-animate-spin)}.ui\:cursor-auto{cursor:auto}.ui\:cursor-col-resize{cursor:col-resize}.ui\:cursor-default{cursor:default}.ui\:cursor-default\!{cursor:default!important}.ui\:cursor-grab{cursor:grab}.ui\:cursor-not-allowed{cursor:not-allowed}.ui\:cursor-pointer{cursor:pointer}.ui\:cursor-text{cursor:text}.ui\:resize-none{resize:none}.ui\:scroll-my-1{scroll-margin-block:calc(var(--ui-spacing) * 1)}.ui\:scroll-py-1{scroll-padding-block:calc(var(--ui-spacing) * 1)}.ui\:list-disc{list-style-type:disc}.ui\:list-none{list-style-type:none}.ui\:auto-rows-min{grid-auto-rows:min-content}.ui\:grid-cols-2{grid-template-columns:repeat(2,minmax(0,1fr))}.ui\:grid-cols-\[0_1fr\]{grid-template-columns:0 1fr}.ui\:grid-rows-\[auto_auto\]{grid-template-rows:auto auto}.ui\:flex-col{flex-direction:column}.ui\:flex-col-reverse{flex-direction:column-reverse}.ui\:flex-row{flex-direction:row}.ui\:flex-wrap{flex-wrap:wrap}.ui\:place-items-center{place-items:center}.ui\:items-baseline{align-items:baseline}.ui\:items-center{align-items:center}.ui\:items-end{align-items:flex-end}.ui\:items-start{align-items:flex-start}.ui\:items-stretch{align-items:stretch}.ui\:justify-between{justify-content:space-between}.ui\:justify-center{justify-content:center}.ui\:justify-end{justify-content:flex-end}.ui\:justify-start{justify-content:flex-start}.ui\:justify-start\!{justify-content:flex-start!important}.ui\:justify-items-start{justify-items:start}.ui\:gap-0{gap:calc(var(--ui-spacing) * 0)}.ui\:gap-0\.5{gap:calc(var(--ui-spacing) * .5)}.ui\:gap-1{gap:calc(var(--ui-spacing) * 1)}.ui\:gap-1\.5{gap:calc(var(--ui-spacing) * 1.5)}.ui\:gap-2{gap:calc(var(--ui-spacing) * 2)}.ui\:gap-2\.5{gap:calc(var(--ui-spacing) * 2.5)}.ui\:gap-3{gap:calc(var(--ui-spacing) * 3)}.ui\:gap-4{gap:calc(var(--ui-spacing) * 4)}.ui\:gap-6{gap:calc(var(--ui-spacing) * 6)}.ui\:gap-7{gap:calc(var(--ui-spacing) * 7)}:where(.ui\:space-y-1>:not(:last-child)){--tw-space-y-reverse:0;margin-block-start:calc(calc(var(--ui-spacing) * 1) * var(--tw-space-y-reverse));margin-block-end:calc(calc(var(--ui-spacing) * 1) * calc(1 - var(--tw-space-y-reverse)))}:where(.ui\:space-y-2>:not(:last-child)){--tw-space-y-reverse:0;margin-block-start:calc(calc(var(--ui-spacing) * 2) * var(--tw-space-y-reverse));margin-block-end:calc(calc(var(--ui-spacing) * 2) * calc(1 - var(--tw-space-y-reverse)))}:where(.ui\:space-y-3>:not(:last-child)){--tw-space-y-reverse:0;margin-block-start:calc(calc(var(--ui-spacing) * 3) * var(--tw-space-y-reverse));margin-block-end:calc(calc(var(--ui-spacing) * 3) * calc(1 - var(--tw-space-y-reverse)))}:where(.ui\:space-y-4>:not(:last-child)){--tw-space-y-reverse:0;margin-block-start:calc(calc(var(--ui-spacing) * 4) * var(--tw-space-y-reverse));margin-block-end:calc(calc(var(--ui-spacing) * 4) * calc(1 - var(--tw-space-y-reverse)))}.ui\:gap-x-6{column-gap:calc(var(--ui-spacing) * 6)}.ui\:gap-y-0\.5{row-gap:calc(var(--ui-spacing) * .5)}.ui\:gap-y-2{row-gap:calc(var(--ui-spacing) * 2)}.ui\:self-start{align-self:flex-start}.ui\:self-stretch{align-self:stretch}.ui\:justify-self-end{justify-self:flex-end}.ui\:truncate{text-overflow:ellipsis;white-space:nowrap;overflow:hidden}.ui\:overflow-auto{overflow:auto}.ui\:overflow-hidden{overflow:hidden}.ui\:overflow-visible{overflow:visible}.ui\:overflow-x-auto{overflow-x:auto}.ui\:overflow-x-hidden{overflow-x:hidden}.ui\:overflow-y-auto{overflow-y:auto}.ui\:overflow-y-hidden{overflow-y:hidden}.ui\:scroll-smooth{scroll-behavior:smooth}.ui\:rounded{border-radius:.25rem}.ui\:rounded-\[2px\]{border-radius:2px}.ui\:rounded-\[4px\]{border-radius:4px}.ui\:rounded-\[calc\(var\(--radius\)-5px\)\]{border-radius:calc(var(--radius) - 5px)}.ui\:rounded-full{border-radius:3.40282e38px}.ui\:rounded-lg{border-radius:var(--radius)}.ui\:rounded-md{border-radius:calc(var(--radius) - 2px)}.ui\:rounded-none{border-radius:0}.ui\:rounded-sm{border-radius:calc(var(--radius) - 4px)}.ui\:rounded-xl{border-radius:calc(var(--radius) + 4px)}.ui\:rounded-xs{border-radius:var(--ui-radius-xs)}.ui\:border{border-style:var(--tw-border-style);border-width:1px}.ui\:border-0{border-style:var(--tw-border-style);border-width:0}.ui\:border-2{border-style:var(--tw-border-style);border-width:2px}.ui\:border-\[1\.5px\]{border-style:var(--tw-border-style);border-width:1.5px}.ui\:border-x-0{border-inline-style:var(--tw-border-style);border-inline-width:0}.ui\:border-t{border-top-style:var(--tw-border-style);border-top-width:1px}.ui\:border-r{border-right-style:var(--tw-border-style);border-right-width:1px}.ui\:border-b{border-bottom-style:var(--tw-border-style);border-bottom-width:1px}.ui\:border-l{border-left-style:var(--tw-border-style);border-left-width:1px}.ui\:border-dashed{--tw-border-style:dashed;border-style:dashed}.ui\:border-none{--tw-border-style:none;border-style:none}.ui\:border-\(--color-border\){border-color:var(--color-border)}.ui\:border-amber-200{border-color:var(--ui-color-amber-200)}.ui\:border-amber-400{border-color:var(--ui-color-amber-400)}.ui\:border-border,.ui\:border-border\/50{border-color:var(--border)}@supports (color:color-mix(in lab, red, red)){.ui\:border-border\/50{border-color:color-mix(in oklab, var(--border) 50%, transparent)}}.ui\:border-emerald-300{border-color:var(--ui-color-emerald-300)}.ui\:border-emerald-400{border-color:var(--ui-color-emerald-400)}.ui\:border-emerald-500{border-color:var(--ui-color-emerald-500)}.ui\:border-input{border-color:var(--input)}.ui\:border-muted{border-color:var(--muted)}.ui\:border-muted-foreground{border-color:var(--muted-foreground)}.ui\:border-primary\/30{border-color:var(--primary)}@supports (color:color-mix(in lab, red, red)){.ui\:border-primary\/30{border-color:color-mix(in oklab, var(--primary) 30%, transparent)}}.ui\:border-red-500{border-color:var(--ui-color-red-500)}.ui\:border-sidebar-border{border-color:var(--sidebar-border)}.ui\:border-sky-200{border-color:var(--ui-color-sky-200)}.ui\:border-transparent{border-color:#0000}.ui\:bg-\(--color-bg\){background-color:var(--color-bg)}.ui\:bg-accent{background-color:var(--accent)}.ui\:bg-amber-50,.ui\:bg-amber-50\/30{background-color:var(--ui-color-amber-50)}@supports (color:color-mix(in lab, red, red)){.ui\:bg-amber-50\/30{background-color:color-mix(in oklab, var(--ui-color-amber-50) 30%, transparent)}}.ui\:bg-amber-600{background-color:var(--ui-color-amber-600)}.ui\:bg-background,.ui\:bg-background\/50{background-color:var(--background)}@supports (color:color-mix(in lab, red, red)){.ui\:bg-background\/50{background-color:color-mix(in oklab, var(--background) 50%, transparent)}}.ui\:bg-black\/50{background-color:var(--ui-color-black)}@supports (color:color-mix(in lab, red, red)){.ui\:bg-black\/50{background-color:color-mix(in oklab, var(--ui-color-black) 50%, transparent)}}.ui\:bg-border{background-color:var(--border)}.ui\:bg-card{background-color:var(--card)}.ui\:bg-destructive{background-color:var(--destructive)}.ui\:bg-emerald-50\/20{background-color:var(--ui-color-emerald-50)}@supports (color:color-mix(in lab, red, red)){.ui\:bg-emerald-50\/20{background-color:color-mix(in oklab, var(--ui-color-emerald-50) 20%, transparent)}}.ui\:bg-emerald-50\/30{background-color:var(--ui-color-emerald-50)}@supports (color:color-mix(in lab, red, red)){.ui\:bg-emerald-50\/30{background-color:color-mix(in oklab, var(--ui-color-emerald-50) 30%, transparent)}}.ui\:bg-emerald-50\/40{background-color:var(--ui-color-emerald-50)}@supports (color:color-mix(in lab, red, red)){.ui\:bg-emerald-50\/40{background-color:color-mix(in oklab, var(--ui-color-emerald-50) 40%, transparent)}}.ui\:bg-emerald-600{background-color:var(--ui-color-emerald-600)}.ui\:bg-gray-200{background-color:var(--ui-color-gray-200)}.ui\:bg-green-500{background-color:var(--ui-color-green-500)}.ui\:bg-inherit{background-color:inherit}.ui\:bg-input{background-color:var(--input)}.ui\:bg-muted,.ui\:bg-muted\/50{background-color:var(--muted)}@supports (color:color-mix(in lab, red, red)){.ui\:bg-muted\/50{background-color:color-mix(in oklab, var(--muted) 50%, transparent)}}.ui\:bg-popover{background-color:var(--popover)}.ui\:bg-primary{background-color:var(--primary)}.ui\:bg-primary-foreground{background-color:var(--primary-foreground)}.ui\:bg-primary\/10{background-color:var(--primary)}@supports (color:color-mix(in lab, red, red)){.ui\:bg-primary\/10{background-color:color-mix(in oklab, var(--primary) 10%, transparent)}}.ui\:bg-primary\/20{background-color:var(--primary)}@supports (color:color-mix(in lab, red, red)){.ui\:bg-primary\/20{background-color:color-mix(in oklab, var(--primary) 20%, transparent)}}.ui\:bg-red-50\/40{background-color:var(--ui-color-red-50)}@supports (color:color-mix(in lab, red, red)){.ui\:bg-red-50\/40{background-color:color-mix(in oklab, var(--ui-color-red-50) 40%, transparent)}}.ui\:bg-red-500{background-color:var(--ui-color-red-500)}.ui\:bg-secondary,.ui\:bg-secondary\/50{background-color:var(--secondary)}@supports (color:color-mix(in lab, red, red)){.ui\:bg-secondary\/50{background-color:color-mix(in oklab, var(--secondary) 50%, transparent)}}.ui\:bg-sidebar{background-color:var(--sidebar)}.ui\:bg-sidebar-border{background-color:var(--sidebar-border)}.ui\:bg-sky-50{background-color:var(--ui-color-sky-50)}.ui\:bg-transparent{background-color:#0000}.ui\:bg-white{background-color:var(--ui-color-white)}.ui\:bg-yellow-500{background-color:var(--ui-color-yellow-500)}.ui\:bg-linear-to-r{--tw-gradient-position:to right}@supports (background-image:linear-gradient(in lab, red, red)){.ui\:bg-linear-to-r{--tw-gradient-position:to right in oklab}}.ui\:bg-linear-to-r{background-image:linear-gradient(var(--tw-gradient-stops))}.ui\:bg-linear-to-t{--tw-gradient-position:to top}@supports (background-image:linear-gradient(in lab, red, red)){.ui\:bg-linear-to-t{--tw-gradient-position:to top in oklab}}.ui\:bg-linear-to-t{background-image:linear-gradient(var(--tw-gradient-stops))}.ui\:from-background{--tw-gradient-from:var(--background);--tw-gradient-stops:var(--tw-gradient-via-stops,var(--tw-gradient-position), var(--tw-gradient-from) var(--tw-gradient-from-position), var(--tw-gradient-to) var(--tw-gradient-to-position))}.ui\:from-pink-500{--tw-gradient-from:var(--ui-color-pink-500);--tw-gradient-stops:var(--tw-gradient-via-stops,var(--tw-gradient-position), var(--tw-gradient-from) var(--tw-gradient-from-position), var(--tw-gradient-to) var(--tw-gradient-to-position))}.ui\:to-orange-500{--tw-gradient-to:var(--ui-color-orange-500);--tw-gradient-stops:var(--tw-gradient-via-stops,var(--tw-gradient-position), var(--tw-gradient-from) var(--tw-gradient-from-position), var(--tw-gradient-to) var(--tw-gradient-to-position))}.ui\:to-transparent{--tw-gradient-to:transparent;--tw-gradient-stops:var(--tw-gradient-via-stops,var(--tw-gradient-position), var(--tw-gradient-from) var(--tw-gradient-from-position), var(--tw-gradient-to) var(--tw-gradient-to-position))}.ui\:bg-clip-padding{background-clip:padding-box}.ui\:fill-current{fill:currentColor}.ui\:fill-primary{fill:var(--primary)}.ui\:object-cover{object-fit:cover}.ui\:p-0{padding:calc(var(--ui-spacing) * 0)}.ui\:p-0\.5{padding:calc(var(--ui-spacing) * .5)}.ui\:p-1{padding:calc(var(--ui-spacing) * 1)}.ui\:p-2{padding:calc(var(--ui-spacing) * 2)}.ui\:p-3{padding:calc(var(--ui-spacing) * 3)}.ui\:p-3\!{padding:calc(var(--ui-spacing) * 3)!important}.ui\:p-4{padding:calc(var(--ui-spacing) * 4)}.ui\:p-6{padding:calc(var(--ui-spacing) * 6)}.ui\:p-8{padding:calc(var(--ui-spacing) * 8)}.ui\:p-\[3px\]{padding:3px}.ui\:px-1{padding-inline:calc(var(--ui-spacing) * 1)}.ui\:px-1\.5{padding-inline:calc(var(--ui-spacing) * 1.5)}.ui\:px-2{padding-inline:calc(var(--ui-spacing) * 2)}.ui\:px-2\.5{padding-inline:calc(var(--ui-spacing) * 2.5)}.ui\:px-3{padding-inline:calc(var(--ui-spacing) * 3)}.ui\:px-4{padding-inline:calc(var(--ui-spacing) * 4)}.ui\:px-6{padding-inline:calc(var(--ui-spacing) * 6)}.ui\:py-0\.5{padding-block:calc(var(--ui-spacing) * .5)}.ui\:py-1{padding-block:calc(var(--ui-spacing) * 1)}.ui\:py-1\.5{padding-block:calc(var(--ui-spacing) * 1.5)}.ui\:py-2{padding-block:calc(var(--ui-spacing) * 2)}.ui\:py-3{padding-block:calc(var(--ui-spacing) * 3)}.ui\:py-4{padding-block:calc(var(--ui-spacing) * 4)}.ui\:py-6{padding-block:calc(var(--ui-spacing) * 6)}.ui\:ps-3{padding-inline-start:calc(var(--ui-spacing) * 3)}.ui\:pe-3{padding-inline-end:calc(var(--ui-spacing) * 3)}.ui\:pt-0{padding-top:calc(var(--ui-spacing) * 0)}.ui\:pt-1\.5{padding-top:calc(var(--ui-spacing) * 1.5)}.ui\:pt-3{padding-top:calc(var(--ui-spacing) * 3)}.ui\:pt-3\!{padding-top:calc(var(--ui-spacing) * 3)!important}.ui\:pr-1{padding-right:calc(var(--ui-spacing) * 1)}.ui\:pr-2{padding-right:calc(var(--ui-spacing) * 2)}.ui\:pr-8{padding-right:calc(var(--ui-spacing) * 8)}.ui\:pr-9{padding-right:calc(var(--ui-spacing) * 9)}.ui\:pr-18{padding-right:calc(var(--ui-spacing) * 18)}.ui\:pb-2{padding-bottom:calc(var(--ui-spacing) * 2)}.ui\:pb-3{padding-bottom:calc(var(--ui-spacing) * 3)}.ui\:pb-4{padding-bottom:calc(var(--ui-spacing) * 4)}.ui\:pl-2{padding-left:calc(var(--ui-spacing) * 2)}.ui\:pl-3{padding-left:calc(var(--ui-spacing) * 3)}.ui\:pl-8{padding-left:calc(var(--ui-spacing) * 8)}.ui\:text-center{text-align:center}.ui\:text-left{text-align:left}.ui\:text-right{text-align:right}.ui\:font-mono{font-family:var(--ui-font-mono)}.ui\:font-sans{font-family:var(--ui-font-sans)}.ui\:text-2xl{font-size:var(--ui-text-2xl);line-height:var(--tw-leading,var(--ui-text-2xl--line-height))}.ui\:text-base{font-size:var(--ui-text-base);line-height:var(--tw-leading,var(--ui-text-base--line-height))}.ui\:text-base\!{font-size:var(--ui-text-base)!important;line-height:var(--tw-leading,var(--ui-text-base--line-height))!important}.ui\:text-lg{font-size:var(--ui-text-lg);line-height:var(--tw-leading,var(--ui-text-lg--line-height))}.ui\:text-sm{font-size:var(--ui-text-sm);line-height:var(--tw-leading,var(--ui-text-sm--line-height))}.ui\:text-sm\/relaxed{font-size:var(--ui-text-sm);line-height:var(--ui-leading-relaxed)}.ui\:text-xl{font-size:var(--ui-text-xl);line-height:var(--tw-leading,var(--ui-text-xl--line-height))}.ui\:text-xs{font-size:var(--ui-text-xs);line-height:var(--tw-leading,var(--ui-text-xs--line-height))}.ui\:text-\[10px\]{font-size:10px}.ui\:leading-none{--tw-leading:1;line-height:1}.ui\:leading-normal{--tw-leading:var(--ui-leading-normal);line-height:var(--ui-leading-normal)}.ui\:leading-relaxed{--tw-leading:var(--ui-leading-relaxed);line-height:var(--ui-leading-relaxed)}.ui\:leading-snug{--tw-leading:var(--ui-leading-snug);line-height:var(--ui-leading-snug)}.ui\:font-bold{--tw-font-weight:var(--ui-font-weight-bold);font-weight:var(--ui-font-weight-bold)}.ui\:font-medium{--tw-font-weight:var(--ui-font-weight-medium);font-weight:var(--ui-font-weight-medium)}.ui\:font-normal{--tw-font-weight:var(--ui-font-weight-normal);font-weight:var(--ui-font-weight-normal)}.ui\:font-semibold{--tw-font-weight:var(--ui-font-weight-semibold);font-weight:var(--ui-font-weight-semibold)}.ui\:tracking-tight{--tw-tracking:var(--ui-tracking-tight);letter-spacing:var(--ui-tracking-tight)}.ui\:tracking-widest{--tw-tracking:var(--ui-tracking-widest);letter-spacing:var(--ui-tracking-widest)}.ui\:text-balance{text-wrap:balance}.ui\:break-words{overflow-wrap:break-word}.ui\:break-all{word-break:break-all}.ui\:text-ellipsis{text-overflow:ellipsis}.ui\:whitespace-nowrap{white-space:nowrap}.ui\:text-amber-600{color:var(--ui-color-amber-600)}.ui\:text-amber-900{color:var(--ui-color-amber-900)}.ui\:text-card-foreground{color:var(--card-foreground)}.ui\:text-current{color:currentColor}.ui\:text-destructive{color:var(--destructive)}.ui\:text-emerald-600{color:var(--ui-color-emerald-600)}.ui\:text-foreground,.ui\:text-foreground\/70{color:var(--foreground)}@supports (color:color-mix(in lab, red, red)){.ui\:text-foreground\/70{color:color-mix(in oklab, var(--foreground) 70%, transparent)}}.ui\:text-green-500{color:var(--ui-color-green-500)}.ui\:text-muted-foreground,.ui\:text-muted-foreground\/75{color:var(--muted-foreground)}@supports (color:color-mix(in lab, red, red)){.ui\:text-muted-foreground\/75{color:color-mix(in oklab, var(--muted-foreground) 75%, transparent)}}.ui\:text-popover-foreground{color:var(--popover-foreground)}.ui\:text-primary{color:var(--primary)}.ui\:text-primary-foreground{color:var(--primary-foreground)}.ui\:text-red-600{color:var(--ui-color-red-600)}.ui\:text-red-700{color:var(--ui-color-red-700)}.ui\:text-secondary-foreground{color:var(--secondary-foreground)}.ui\:text-sidebar-foreground,.ui\:text-sidebar-foreground\/70{color:var(--sidebar-foreground)}@supports (color:color-mix(in lab, red, red)){.ui\:text-sidebar-foreground\/70{color:color-mix(in oklab, var(--sidebar-foreground) 70%, transparent)}}.ui\:text-sky-900{color:var(--ui-color-sky-900)}.ui\:text-white{color:var(--ui-color-white)}.ui\:text-white\!{color:var(--ui-color-white)!important}.ui\:capitalize{text-transform:capitalize}.ui\:underline{text-decoration-line:underline}.ui\:underline-offset-4{text-underline-offset:4px}.ui\:opacity-0{opacity:0}.ui\:opacity-50{opacity:.5}.ui\:opacity-70{opacity:.7}.ui\:opacity-100{opacity:1}.ui\:shadow{--tw-shadow:0 1px 3px 0 var(--tw-shadow-color,#0000001a), 0 1px 2px -1px var(--tw-shadow-color,#0000001a);box-shadow:var(--tw-inset-shadow), var(--tw-inset-ring-shadow), var(--tw-ring-offset-shadow), var(--tw-ring-shadow), var(--tw-shadow)}.ui\:shadow-2xl{--tw-shadow:0 25px 50px -12px var(--tw-shadow-color,#00000040);box-shadow:var(--tw-inset-shadow), var(--tw-inset-ring-shadow), var(--tw-ring-offset-shadow), var(--tw-ring-shadow), var(--tw-shadow)}.ui\:shadow-2xs{--tw-shadow:0 1px var(--tw-shadow-color,#0000000d);box-shadow:var(--tw-inset-shadow), var(--tw-inset-ring-shadow), var(--tw-ring-offset-shadow), var(--tw-ring-shadow), var(--tw-shadow)}.ui\:shadow-\[0_0_0_1px_var\(--sidebar-border\)\]{--tw-shadow:0 0 0 1px var(--tw-shadow-color,var(--sidebar-border));box-shadow:var(--tw-inset-shadow), var(--tw-inset-ring-shadow), var(--tw-ring-offset-shadow), var(--tw-ring-shadow), var(--tw-shadow)}.ui\:shadow-lg{--tw-shadow:0 10px 15px -3px var(--tw-shadow-color,#0000001a), 0 4px 6px -4px var(--tw-shadow-color,#0000001a);box-shadow:var(--tw-inset-shadow), var(--tw-inset-ring-shadow), var(--tw-ring-offset-shadow), var(--tw-ring-shadow), var(--tw-shadow)}.ui\:shadow-md{--tw-shadow:0 4px 6px -1px var(--tw-shadow-color,#0000001a), 0 2px 4px -2px var(--tw-shadow-color,#0000001a);box-shadow:var(--tw-inset-shadow), var(--tw-inset-ring-shadow), var(--tw-ring-offset-shadow), var(--tw-ring-shadow), var(--tw-shadow)}.ui\:shadow-none{--tw-shadow:0 0 #0000;box-shadow:var(--tw-inset-shadow), var(--tw-inset-ring-shadow), var(--tw-ring-offset-shadow), var(--tw-ring-shadow), var(--tw-shadow)}.ui\:shadow-sm{--tw-shadow:0 1px 3px 0 var(--tw-shadow-color,#0000001a), 0 1px 2px -1px var(--tw-shadow-color,#0000001a);box-shadow:var(--tw-inset-shadow), var(--tw-inset-ring-shadow), var(--tw-ring-offset-shadow), var(--tw-ring-shadow), var(--tw-shadow)}.ui\:shadow-xl{--tw-shadow:0 20px 25px -5px var(--tw-shadow-color,#0000001a), 0 8px 10px -6px var(--tw-shadow-color,#0000001a);box-shadow:var(--tw-inset-shadow), var(--tw-inset-ring-shadow), var(--tw-ring-offset-shadow), var(--tw-ring-shadow), var(--tw-shadow)}.ui\:shadow-xs{--tw-shadow:0 1px 2px 0 var(--tw-shadow-color,#0000000d);box-shadow:var(--tw-inset-shadow), var(--tw-inset-ring-shadow), var(--tw-ring-offset-shadow), var(--tw-ring-shadow), var(--tw-shadow)}.ui\:ring-0{--tw-ring-shadow:var(--tw-ring-inset,) 0 0 0 calc(0px + var(--tw-ring-offset-width)) var(--tw-ring-color,currentcolor);box-shadow:var(--tw-inset-shadow), var(--tw-inset-ring-shadow), var(--tw-ring-offset-shadow), var(--tw-ring-shadow), var(--tw-shadow)}.ui\:ring-1{--tw-ring-shadow:var(--tw-ring-inset,) 0 0 0 calc(1px + var(--tw-ring-offset-width)) var(--tw-ring-color,currentcolor);box-shadow:var(--tw-inset-shadow), var(--tw-inset-ring-shadow), var(--tw-ring-offset-shadow), var(--tw-ring-shadow), var(--tw-shadow)}.ui\:ring-2{--tw-ring-shadow:var(--tw-ring-inset,) 0 0 0 calc(2px + var(--tw-ring-offset-width)) var(--tw-ring-color,currentcolor);box-shadow:var(--tw-inset-shadow), var(--tw-inset-ring-shadow), var(--tw-ring-offset-shadow), var(--tw-ring-shadow), var(--tw-shadow)}.ui\:ring-3{--tw-ring-shadow:var(--tw-ring-inset,) 0 0 0 calc(3px + var(--tw-ring-offset-width)) var(--tw-ring-color,currentcolor);box-shadow:var(--tw-inset-shadow), var(--tw-inset-ring-shadow), var(--tw-ring-offset-shadow), var(--tw-ring-shadow), var(--tw-shadow)}.ui\:ring-accent{--tw-ring-color:var(--accent)}.ui\:ring-background{--tw-ring-color:var(--background)}.ui\:ring-border\/50{--tw-ring-color:var(--border)}@supports (color:color-mix(in lab, red, red)){.ui\:ring-border\/50{--tw-ring-color:color-mix(in oklab, var(--border) 50%, transparent)}}.ui\:ring-sidebar-ring{--tw-ring-color:var(--sidebar-ring)}.ui\:ring-offset-2{--tw-ring-offset-width:2px;--tw-ring-offset-shadow:var(--tw-ring-inset,) 0 0 0 var(--tw-ring-offset-width) var(--tw-ring-offset-color)}.ui\:ring-offset-background{--tw-ring-offset-color:var(--background)}.ui\:outline-hidden{--tw-outline-style:none;outline-style:none}@media (forced-colors:active){.ui\:outline-hidden{outline-offset:2px;outline:2px solid #0000}}.ui\:backdrop-blur-sm{--tw-backdrop-blur:blur(var(--ui-blur-sm));-webkit-backdrop-filter:var(--tw-backdrop-blur,) var(--tw-backdrop-brightness,) var(--tw-backdrop-contrast,) var(--tw-backdrop-grayscale,) var(--tw-backdrop-hue-rotate,) var(--tw-backdrop-invert,) var(--tw-backdrop-opacity,) var(--tw-backdrop-saturate,) var(--tw-backdrop-sepia,);backdrop-filter:var(--tw-backdrop-blur,) var(--tw-backdrop-brightness,) var(--tw-backdrop-contrast,) var(--tw-backdrop-grayscale,) var(--tw-backdrop-hue-rotate,) var(--tw-backdrop-invert,) var(--tw-backdrop-opacity,) var(--tw-backdrop-saturate,) var(--tw-backdrop-sepia,)}.ui\:transition{transition-property:color,background-color,border-color,outline-color,text-decoration-color,fill,stroke,--tw-gradient-from,--tw-gradient-via,--tw-gradient-to,opacity,box-shadow,transform,translate,scale,rotate,filter,-webkit-backdrop-filter,backdrop-filter,display,content-visibility,overlay,pointer-events;transition-timing-function:var(--tw-ease,var(--ui-default-transition-timing-function));transition-duration:var(--tw-duration,var(--ui-default-transition-duration))}.ui\:transition-\[color\,box-shadow\]{transition-property:color,box-shadow;transition-timing-function:var(--tw-ease,var(--ui-default-transition-timing-function));transition-duration:var(--tw-duration,var(--ui-default-transition-duration))}.ui\:transition-\[left\,right\,width\]{transition-property:left,right,width;transition-timing-function:var(--tw-ease,var(--ui-default-transition-timing-function));transition-duration:var(--tw-duration,var(--ui-default-transition-duration))}.ui\:transition-\[margin\,opacity\]{transition-property:margin,opacity;transition-timing-function:var(--tw-ease,var(--ui-default-transition-timing-function));transition-duration:var(--tw-duration,var(--ui-default-transition-duration))}.ui\:transition-\[width\,height\,padding\]{transition-property:width,height,padding;transition-timing-function:var(--tw-ease,var(--ui-default-transition-timing-function));transition-duration:var(--tw-duration,var(--ui-default-transition-duration))}.ui\:transition-\[width\]{transition-property:width;transition-timing-function:var(--tw-ease,var(--ui-default-transition-timing-function));transition-duration:var(--tw-duration,var(--ui-default-transition-duration))}.ui\:transition-all{transition-property:all;transition-timing-function:var(--tw-ease,var(--ui-default-transition-timing-function));transition-duration:var(--tw-duration,var(--ui-default-transition-duration))}.ui\:transition-colors{transition-property:color,background-color,border-color,outline-color,text-decoration-color,fill,stroke,--tw-gradient-from,--tw-gradient-via,--tw-gradient-to;transition-timing-function:var(--tw-ease,var(--ui-default-transition-timing-function));transition-duration:var(--tw-duration,var(--ui-default-transition-duration))}.ui\:transition-opacity{transition-property:opacity;transition-timing-function:var(--tw-ease,var(--ui-default-transition-timing-function));transition-duration:var(--tw-duration,var(--ui-default-transition-duration))}.ui\:transition-shadow{transition-property:box-shadow;transition-timing-function:var(--tw-ease,var(--ui-default-transition-timing-function));transition-duration:var(--tw-duration,var(--ui-default-transition-duration))}.ui\:transition-transform{transition-property:transform,translate,scale,rotate;transition-timing-function:var(--tw-ease,var(--ui-default-transition-timing-function));transition-duration:var(--tw-duration,var(--ui-default-transition-duration))}.ui\:transition-none{transition-property:none}.ui\:duration-100{--tw-duration:.1s;transition-duration:.1s}.ui\:duration-200{--tw-duration:.2s;transition-duration:.2s}.ui\:duration-300{--tw-duration:.3s;transition-duration:.3s}.ui\:duration-500{--tw-duration:.5s;transition-duration:.5s}.ui\:ease-in-out{--tw-ease:var(--ui-ease-in-out);transition-timing-function:var(--ui-ease-in-out)}.ui\:ease-linear{--tw-ease:linear;transition-timing-function:linear}.ui\:fade-in-0{--tw-enter-opacity:0}.ui\:outline-none{--tw-outline-style:none;outline-style:none}.ui\:select-none{-webkit-user-select:none;user-select:none}.ui\:zoom-in-95{--tw-enter-scale:.95}.ui\:ring-inset{--tw-ring-inset:inset}:is(.ui\:\*\:w-full>*){width:100%}.ui\:group-focus-within\/menu-item\:opacity-100:is(:where(.ui\:group\/menu-item):focus-within *){opacity:1}@media (hover:hover){.ui\:group-hover\:opacity-100:is(:where(.ui\:group):hover *),.ui\:group-hover\/menu-item\:opacity-100:is(:where(.ui\:group\/menu-item):hover *){opacity:1}}.ui\:group-has-data-\[orientation\=horizontal\]\/field\:text-balance:is(:where(.ui\:group\/field):has([data-orientation=horizontal]) *){text-wrap:balance}.ui\:group-has-data-\[sidebar\=menu-action\]\/menu-item\:pr-8:is(:where(.ui\:group\/menu-item):has([data-sidebar=menu-action]) *){padding-right:calc(var(--ui-spacing) * 8)}.ui\:group-has-\[\[data-slot\=item-description\]\]\/item\:translate-y-0\.5:is(:where(.ui\:group\/item):has([data-slot=item-description]) *){--tw-translate-y:calc(var(--ui-spacing) * .5);translate:var(--tw-translate-x) var(--tw-translate-y)}.ui\:group-has-\[\[data-slot\=item-description\]\]\/item\:self-start:is(:where(.ui\:group\/item):has([data-slot=item-description]) *){align-self:flex-start}.ui\:group-has-\[\>input\]\/input-group\:pt-2\.5:is(:where(.ui\:group\/input-group):has(>input) *){padding-top:calc(var(--ui-spacing) * 2.5)}.ui\:group-has-\[\>input\]\/input-group\:pb-2\.5:is(:where(.ui\:group\/input-group):has(>input) *){padding-bottom:calc(var(--ui-spacing) * 2.5)}.ui\:group-data-\[collapsible\=icon\]\:-mt-8:is(:where(.ui\:group)[data-collapsible=icon] *){margin-top:calc(var(--ui-spacing) * -8)}.ui\:group-data-\[collapsible\=icon\]\:hidden:is(:where(.ui\:group)[data-collapsible=icon] *){display:none}.ui\:group-data-\[collapsible\=icon\]\:size-8\!:is(:where(.ui\:group)[data-collapsible=icon] *){width:calc(var(--ui-spacing) * 8)!important;height:calc(var(--ui-spacing) * 8)!important}.ui\:group-data-\[collapsible\=icon\]\:w-\(--sidebar-width-icon\):is(:where(.ui\:group)[data-collapsible=icon] *){width:var(--sidebar-width-icon)}.ui\:group-data-\[collapsible\=icon\]\:w-\[calc\(var\(--sidebar-width-icon\)\+\(--spacing\(4\)\)\+2px\)\]:is(:where(.ui\:group)[data-collapsible=icon] *){width:calc(var(--sidebar-width-icon) + (calc(var(--ui-spacing) * 4)) + 2px)}.ui\:group-data-\[collapsible\=icon\]\:overflow-hidden:is(:where(.ui\:group)[data-collapsible=icon] *){overflow:hidden}.ui\:group-data-\[collapsible\=icon\]\:p-0\!:is(:where(.ui\:group)[data-collapsible=icon] *){padding:calc(var(--ui-spacing) * 0)!important}.ui\:group-data-\[collapsible\=icon\]\:p-2\!:is(:where(.ui\:group)[data-collapsible=icon] *){padding:calc(var(--ui-spacing) * 2)!important}.ui\:group-data-\[collapsible\=icon\]\:opacity-0:is(:where(.ui\:group)[data-collapsible=icon] *){opacity:0}.ui\:group-data-\[collapsible\=offcanvas\]\:right-\[calc\(var\(--sidebar-width\)\*-1\)\]:is(:where(.ui\:group)[data-collapsible=offcanvas] *){right:calc(var(--sidebar-width) * -1)}.ui\:group-data-\[collapsible\=offcanvas\]\:left-\[calc\(var\(--sidebar-width\)\*-1\)\]:is(:where(.ui\:group)[data-collapsible=offcanvas] *){left:calc(var(--sidebar-width) * -1)}.ui\:group-data-\[collapsible\=offcanvas\]\:w-0:is(:where(.ui\:group)[data-collapsible=offcanvas] *){width:calc(var(--ui-spacing) * 0)}.ui\:group-data-\[collapsible\=offcanvas\]\:translate-x-0:is(:where(.ui\:group)[data-collapsible=offcanvas] *){--tw-translate-x:calc(var(--ui-spacing) * 0);translate:var(--tw-translate-x) var(--tw-translate-y)}.ui\:group-data-\[disabled\=true\]\:pointer-events-none:is(:where(.ui\:group)[data-disabled=true] *){pointer-events:none}.ui\:group-data-\[disabled\=true\]\:opacity-50:is(:where(.ui\:group)[data-disabled=true] *),.ui\:group-data-\[disabled\=true\]\/field\:opacity-50:is(:where(.ui\:group\/field)[data-disabled=true] *),.ui\:group-data-\[disabled\=true\]\/input-group\:opacity-50:is(:where(.ui\:group\/input-group)[data-disabled=true] *){opacity:.5}.ui\:group-data-\[side\=left\]\:-right-4:is(:where(.ui\:group)[data-side=left] *){right:calc(var(--ui-spacing) * -4)}.ui\:group-data-\[side\=left\]\:border-r:is(:where(.ui\:group)[data-side=left] *){border-right-style:var(--tw-border-style);border-right-width:1px}.ui\:group-data-\[side\=right\]\:left-0:is(:where(.ui\:group)[data-side=right] *){left:calc(var(--ui-spacing) * 0)}.ui\:group-data-\[side\=right\]\:rotate-180:is(:where(.ui\:group)[data-side=right] *){rotate:180deg}.ui\:group-data-\[side\=right\]\:border-l:is(:where(.ui\:group)[data-side=right] *){border-left-style:var(--tw-border-style);border-left-width:1px}.ui\:group-data-\[variant\=floating\]\:rounded-lg:is(:where(.ui\:group)[data-variant=floating] *){border-radius:var(--radius)}.ui\:group-data-\[variant\=floating\]\:border:is(:where(.ui\:group)[data-variant=floating] *){border-style:var(--tw-border-style);border-width:1px}.ui\:group-data-\[variant\=floating\]\:border-sidebar-border:is(:where(.ui\:group)[data-variant=floating] *){border-color:var(--sidebar-border)}.ui\:group-data-\[variant\=floating\]\:shadow-sm:is(:where(.ui\:group)[data-variant=floating] *){--tw-shadow:0 1px 3px 0 var(--tw-shadow-color,#0000001a), 0 1px 2px -1px var(--tw-shadow-color,#0000001a);box-shadow:var(--tw-inset-shadow), var(--tw-inset-ring-shadow), var(--tw-ring-offset-shadow), var(--tw-ring-shadow), var(--tw-shadow)}.ui\:group-data-\[variant\=outline\]\/field-group\:-mb-2:is(:where(.ui\:group\/field-group)[data-variant=outline] *){margin-bottom:calc(var(--ui-spacing) * -2)}.ui\:group-data-\[vaul-drawer-direction\=bottom\]\/drawer-content\:block:is(:where(.ui\:group\/drawer-content)[data-vaul-drawer-direction=bottom] *){display:block}.ui\:group-data-\[viewport\=false\]\/navigation-menu\:top-full:is(:where(.ui\:group\/navigation-menu)[data-viewport=false] *){top:100%}.ui\:group-data-\[viewport\=false\]\/navigation-menu\:mt-1\.5:is(:where(.ui\:group\/navigation-menu)[data-viewport=false] *){margin-top:calc(var(--ui-spacing) * 1.5)}.ui\:group-data-\[viewport\=false\]\/navigation-menu\:overflow-hidden:is(:where(.ui\:group\/navigation-menu)[data-viewport=false] *){overflow:hidden}.ui\:group-data-\[viewport\=false\]\/navigation-menu\:rounded-md:is(:where(.ui\:group\/navigation-menu)[data-viewport=false] *){border-radius:calc(var(--radius) - 2px)}.ui\:group-data-\[viewport\=false\]\/navigation-menu\:border:is(:where(.ui\:group\/navigation-menu)[data-viewport=false] *){border-style:var(--tw-border-style);border-width:1px}.ui\:group-data-\[viewport\=false\]\/navigation-menu\:bg-popover:is(:where(.ui\:group\/navigation-menu)[data-viewport=false] *){background-color:var(--popover)}.ui\:group-data-\[viewport\=false\]\/navigation-menu\:text-popover-foreground:is(:where(.ui\:group\/navigation-menu)[data-viewport=false] *){color:var(--popover-foreground)}.ui\:group-data-\[viewport\=false\]\/navigation-menu\:shadow:is(:where(.ui\:group\/navigation-menu)[data-viewport=false] *){--tw-shadow:0 1px 3px 0 var(--tw-shadow-color,#0000001a), 0 1px 2px -1px var(--tw-shadow-color,#0000001a);box-shadow:var(--tw-inset-shadow), var(--tw-inset-ring-shadow), var(--tw-ring-offset-shadow), var(--tw-ring-shadow), var(--tw-shadow)}.ui\:group-data-\[viewport\=false\]\/navigation-menu\:duration-200:is(:where(.ui\:group\/navigation-menu)[data-viewport=false] *){--tw-duration:.2s;transition-duration:.2s}@media (hover:hover){.ui\:peer-hover\/menu-button\:text-sidebar-accent-foreground:is(:where(.ui\:peer\/menu-button):hover~*){color:var(--sidebar-accent-foreground)}}.ui\:peer-disabled\:cursor-not-allowed:is(:where(.ui\:peer):disabled~*){cursor:not-allowed}.ui\:peer-disabled\:opacity-50:is(:where(.ui\:peer):disabled~*){opacity:.5}.ui\:peer-data-\[active\=true\]\/menu-button\:text-sidebar-accent-foreground:is(:where(.ui\:peer\/menu-button)[data-active=true]~*){color:var(--sidebar-accent-foreground)}.ui\:peer-data-\[size\=default\]\/menu-button\:top-1\.5:is(:where(.ui\:peer\/menu-button)[data-size=default]~*){top:calc(var(--ui-spacing) * 1.5)}.ui\:peer-data-\[size\=lg\]\/menu-button\:top-2\.5:is(:where(.ui\:peer\/menu-button)[data-size=lg]~*){top:calc(var(--ui-spacing) * 2.5)}.ui\:peer-data-\[size\=sm\]\/menu-button\:top-1:is(:where(.ui\:peer\/menu-button)[data-size=sm]~*){top:calc(var(--ui-spacing) * 1)}.ui\:selection\:bg-primary ::selection{background-color:var(--primary)}.ui\:selection\:bg-primary::selection{background-color:var(--primary)}.ui\:selection\:text-primary-foreground ::selection{color:var(--primary-foreground)}.ui\:selection\:text-primary-foreground::selection{color:var(--primary-foreground)}.ui\:placeholder\:text-muted-foreground::placeholder{color:var(--muted-foreground)}.ui\:after\:absolute:after{content:var(--tw-content);position:absolute}.ui\:after\:-inset-2:after{content:var(--tw-content);inset:calc(var(--ui-spacing) * -2)}.ui\:after\:inset-y-0:after{content:var(--tw-content);inset-block:calc(var(--ui-spacing) * 0)}.ui\:after\:left-\[calc\(1\/2\*100\%-1px\)\]:after{content:var(--tw-content);left:calc(50% - 1px)}.ui\:after\:w-\[2px\]:after{content:var(--tw-content);width:2px}.ui\:group-data-\[collapsible\=offcanvas\]\:after\:left-full:is(:where(.ui\:group)[data-collapsible=offcanvas] *):after{content:var(--tw-content);left:100%}.ui\:last\:mt-0:last-child{margin-top:calc(var(--ui-spacing) * 0)}.ui\:last\:border-b-0:last-child{border-bottom-style:var(--tw-border-style);border-bottom-width:0}@media (hover:hover){.ui\:hover\:cursor-pointer:hover{cursor:pointer}.ui\:hover\:border:hover{border-style:var(--tw-border-style);border-width:1px}.ui\:hover\:bg-accent:hover,.ui\:hover\:bg-accent\/25:hover{background-color:var(--accent)}@supports (color:color-mix(in lab, red, red)){.ui\:hover\:bg-accent\/25:hover{background-color:color-mix(in oklab, var(--accent) 25%, transparent)}}.ui\:hover\:bg-muted:hover{background-color:var(--muted)}.ui\:hover\:bg-sidebar-accent:hover{background-color:var(--sidebar-accent)}.ui\:hover\:bg-transparent\!:hover{background-color:#0000!important}.ui\:hover\:text-accent-foreground:hover{color:var(--accent-foreground)}.ui\:hover\:text-foreground:hover{color:var(--foreground)}.ui\:hover\:text-muted-foreground:hover{color:var(--muted-foreground)}.ui\:hover\:text-sidebar-accent-foreground:hover{color:var(--sidebar-accent-foreground)}.ui\:hover\:underline:hover{text-decoration-line:underline}.ui\:hover\:opacity-100:hover{opacity:1}.ui\:hover\:shadow-2xs:hover{--tw-shadow:0 1px var(--tw-shadow-color,#0000000d);box-shadow:var(--tw-inset-shadow), var(--tw-inset-ring-shadow), var(--tw-ring-offset-shadow), var(--tw-ring-shadow), var(--tw-shadow)}.ui\:hover\:shadow-\[0_0_0_1px_var\(--sidebar-accent\)\]:hover{--tw-shadow:0 0 0 1px var(--tw-shadow-color,var(--sidebar-accent));box-shadow:var(--tw-inset-shadow), var(--tw-inset-ring-shadow), var(--tw-ring-offset-shadow), var(--tw-ring-shadow), var(--tw-shadow)}.ui\:hover\:shadow-md:hover{--tw-shadow:0 4px 6px -1px var(--tw-shadow-color,#0000001a), 0 2px 4px -2px var(--tw-shadow-color,#0000001a);box-shadow:var(--tw-inset-shadow), var(--tw-inset-ring-shadow), var(--tw-ring-offset-shadow), var(--tw-ring-shadow), var(--tw-shadow)}.ui\:hover\:group-data-\[collapsible\=offcanvas\]\:bg-sidebar:hover:is(:where(.ui\:group)[data-collapsible=offcanvas] *){background-color:var(--sidebar)}.ui\:hover\:after\:bg-sidebar-border:hover:after{content:var(--tw-content);background-color:var(--sidebar-border)}}.ui\:focus\:bg-accent:focus{background-color:var(--accent)}.ui\:focus\:text-accent-foreground:focus{color:var(--accent-foreground)}.ui\:focus\:ring-2:focus{--tw-ring-shadow:var(--tw-ring-inset,) 0 0 0 calc(2px + var(--tw-ring-offset-width)) var(--tw-ring-color,currentcolor);box-shadow:var(--tw-inset-shadow), var(--tw-inset-ring-shadow), var(--tw-ring-offset-shadow), var(--tw-ring-shadow), var(--tw-shadow)}.ui\:focus\:ring-ring:focus{--tw-ring-color:var(--ring)}.ui\:focus\:ring-offset-2:focus{--tw-ring-offset-width:2px;--tw-ring-offset-shadow:var(--tw-ring-inset,) 0 0 0 var(--tw-ring-offset-width) var(--tw-ring-offset-color)}.ui\:focus\:outline-hidden:focus{--tw-outline-style:none;outline-style:none}@media (forced-colors:active){.ui\:focus\:outline-hidden:focus{outline-offset:2px;outline:2px solid #0000}}.ui\:focus\:outline-none:focus{--tw-outline-style:none;outline-style:none}.ui\:focus-visible\:border-ring:focus-visible{border-color:var(--ring)}.ui\:focus-visible\:ring-0:focus-visible{--tw-ring-shadow:var(--tw-ring-inset,) 0 0 0 calc(0px + var(--tw-ring-offset-width)) var(--tw-ring-color,currentcolor);box-shadow:var(--tw-inset-shadow), var(--tw-inset-ring-shadow), var(--tw-ring-offset-shadow), var(--tw-ring-shadow), var(--tw-shadow)}.ui\:focus-visible\:ring-2:focus-visible{--tw-ring-shadow:var(--tw-ring-inset,) 0 0 0 calc(2px + var(--tw-ring-offset-width)) var(--tw-ring-color,currentcolor);box-shadow:var(--tw-inset-shadow), var(--tw-inset-ring-shadow), var(--tw-ring-offset-shadow), var(--tw-ring-shadow), var(--tw-shadow)}.ui\:focus-visible\:ring-\[3px\]:focus-visible{--tw-ring-shadow:var(--tw-ring-inset,) 0 0 0 calc(3px + var(--tw-ring-offset-width)) var(--tw-ring-color,currentcolor);box-shadow:var(--tw-inset-shadow), var(--tw-inset-ring-shadow), var(--tw-ring-offset-shadow), var(--tw-ring-shadow), var(--tw-shadow)}.ui\:focus-visible\:ring-destructive\/20:focus-visible{--tw-ring-color:var(--destructive)}@supports (color:color-mix(in lab, red, red)){.ui\:focus-visible\:ring-destructive\/20:focus-visible{--tw-ring-color:color-mix(in oklab, var(--destructive) 20%, transparent)}}.ui\:focus-visible\:ring-ring:focus-visible,.ui\:focus-visible\:ring-ring\/50:focus-visible{--tw-ring-color:var(--ring)}@supports (color:color-mix(in lab, red, red)){.ui\:focus-visible\:ring-ring\/50:focus-visible{--tw-ring-color:color-mix(in oklab, var(--ring) 50%, transparent)}}.ui\:focus-visible\:ring-offset-2:focus-visible{--tw-ring-offset-width:2px;--tw-ring-offset-shadow:var(--tw-ring-inset,) 0 0 0 var(--tw-ring-offset-width) var(--tw-ring-offset-color)}.ui\:focus-visible\:outline-hidden:focus-visible{--tw-outline-style:none;outline-style:none}@media (forced-colors:active){.ui\:focus-visible\:outline-hidden:focus-visible{outline-offset:2px;outline:2px solid #0000}}.ui\:focus-visible\:outline-1:focus-visible{outline-style:var(--tw-outline-style);outline-width:1px}.ui\:focus-visible\:outline-ring:focus-visible{outline-color:var(--ring)}.ui\:active\:bg-sidebar-accent:active{background-color:var(--sidebar-accent)}.ui\:active\:text-sidebar-accent-foreground:active{color:var(--sidebar-accent-foreground)}.ui\:disabled\:pointer-events-none:disabled{pointer-events:none}.ui\:disabled\:cursor-not-allowed:disabled{cursor:not-allowed}.ui\:disabled\:opacity-50:disabled{opacity:.5}:where([data-side=left]) .ui\:in-data-\[side\=left\]\:cursor-w-resize{cursor:w-resize}:where([data-side=right]) .ui\:in-data-\[side\=right\]\:cursor-e-resize{cursor:e-resize}:where([data-slot=tooltip-content]) .ui\:in-data-\[slot\=tooltip-content\]\:bg-background\/20{background-color:var(--background)}@supports (color:color-mix(in lab, red, red)){:where([data-slot=tooltip-content]) .ui\:in-data-\[slot\=tooltip-content\]\:bg-background\/20{background-color:color-mix(in oklab, var(--background) 20%, transparent)}}:where([data-slot=tooltip-content]) .ui\:in-data-\[slot\=tooltip-content\]\:text-background{color:var(--background)}.ui\:has-data-\[slot\=card-action\]\:grid-cols-\[1fr_auto\]:has([data-slot=card-action]){grid-template-columns:1fr auto}.ui\:has-data-\[state\=checked\]\:border-primary:has([data-state=checked]){border-color:var(--primary)}.ui\:has-data-\[state\=checked\]\:bg-primary\/5:has([data-state=checked]){background-color:var(--primary)}@supports (color:color-mix(in lab, red, red)){.ui\:has-data-\[state\=checked\]\:bg-primary\/5:has([data-state=checked]){background-color:color-mix(in oklab, var(--primary) 5%, transparent)}}.ui\:has-data-\[variant\=inset\]\:bg-sidebar:has([data-variant=inset]){background-color:var(--sidebar)}.ui\:has-\[\[data-slot\=input-group-control\]\:focus-visible\]\:border-ring:has([data-slot=input-group-control]:focus-visible){border-color:var(--ring)}.ui\:has-\[\[data-slot\=input-group-control\]\:focus-visible\]\:ring-\[3px\]:has([data-slot=input-group-control]:focus-visible){--tw-ring-shadow:var(--tw-ring-inset,) 0 0 0 calc(3px + var(--tw-ring-offset-width)) var(--tw-ring-color,currentcolor);box-shadow:var(--tw-inset-shadow), var(--tw-inset-ring-shadow), var(--tw-ring-offset-shadow), var(--tw-ring-shadow), var(--tw-shadow)}.ui\:has-\[\[data-slot\=input-group-control\]\:focus-visible\]\:ring-ring\/50:has([data-slot=input-group-control]:focus-visible){--tw-ring-color:var(--ring)}@supports (color:color-mix(in lab, red, red)){.ui\:has-\[\[data-slot\=input-group-control\]\:focus-visible\]\:ring-ring\/50:has([data-slot=input-group-control]:focus-visible){--tw-ring-color:color-mix(in oklab, var(--ring) 50%, transparent)}}.ui\:has-\[\[data-slot\]\[aria-invalid\=true\]\]\:border-destructive:has([data-slot][aria-invalid=true]){border-color:var(--destructive)}.ui\:has-\[\[data-slot\]\[aria-invalid\=true\]\]\:ring-destructive\/20:has([data-slot][aria-invalid=true]){--tw-ring-color:var(--destructive)}@supports (color:color-mix(in lab, red, red)){.ui\:has-\[\[data-slot\]\[aria-invalid\=true\]\]\:ring-destructive\/20:has([data-slot][aria-invalid=true]){--tw-ring-color:color-mix(in oklab, var(--destructive) 20%, transparent)}}.ui\:has-\[\>\[data-align\=block-end\]\]\:h-auto:has(>[data-align=block-end]){height:auto}.ui\:has-\[\>\[data-align\=block-end\]\]\:flex-col:has(>[data-align=block-end]){flex-direction:column}.ui\:has-\[\>\[data-align\=block-start\]\]\:h-auto:has(>[data-align=block-start]){height:auto}.ui\:has-\[\>\[data-align\=block-start\]\]\:flex-col:has(>[data-align=block-start]){flex-direction:column}.ui\:has-\[\>\[data-slot\=button-group\]\]\:gap-2:has(>[data-slot=button-group]){gap:calc(var(--ui-spacing) * 2)}.ui\:has-\[\>\[data-slot\=checkbox-group\]\]\:gap-3:has(>[data-slot=checkbox-group]){gap:calc(var(--ui-spacing) * 3)}.ui\:has-\[\>\[data-slot\=field-content\]\]\:items-start:has(>[data-slot=field-content]){align-items:flex-start}.ui\:has-\[\>\[data-slot\=field\]\]\:w-full:has(>[data-slot=field]){width:100%}.ui\:has-\[\>\[data-slot\=field\]\]\:flex-col:has(>[data-slot=field]){flex-direction:column}.ui\:has-\[\>\[data-slot\=field\]\]\:rounded-md:has(>[data-slot=field]){border-radius:calc(var(--radius) - 2px)}.ui\:has-\[\>\[data-slot\=field\]\]\:border:has(>[data-slot=field]){border-style:var(--tw-border-style);border-width:1px}.ui\:has-\[\>\[data-slot\=radio-group\]\]\:gap-3:has(>[data-slot=radio-group]){gap:calc(var(--ui-spacing) * 3)}.ui\:has-\[\>button\]\:ms-\[-0\.45rem\]:has(>button){margin-inline-start:-.45rem}.ui\:has-\[\>button\]\:me-\[-0\.45rem\]:has(>button){margin-inline-end:-.45rem}.ui\:has-\[\>kbd\]\:ms-\[-0\.35rem\]:has(>kbd){margin-inline-start:-.35rem}.ui\:has-\[\>kbd\]\:me-\[-0\.35rem\]:has(>kbd){margin-inline-end:-.35rem}.ui\:has-\[\>svg\]\:grid-cols-\[calc\(var\(--spacing\)\*4\)_1fr\]:has(>svg){grid-template-columns:calc(var(--spacing) * 4) 1fr}.ui\:has-\[\>svg\]\:gap-x-3:has(>svg){column-gap:calc(var(--ui-spacing) * 3)}.ui\:has-\[\>svg\]\:p-0:has(>svg){padding:calc(var(--ui-spacing) * 0)}.ui\:has-\[\>svg\]\:px-2:has(>svg){padding-inline:calc(var(--ui-spacing) * 2)}.ui\:has-\[\>svg\]\:px-2\.5:has(>svg){padding-inline:calc(var(--ui-spacing) * 2.5)}.ui\:has-\[\>svg\]\:px-3:has(>svg){padding-inline:calc(var(--ui-spacing) * 3)}.ui\:has-\[\>svg\]\:px-4:has(>svg){padding-inline:calc(var(--ui-spacing) * 4)}.ui\:has-\[\>textarea\]\:h-auto:has(>textarea){height:auto}.ui\:aria-disabled\:pointer-events-none[aria-disabled=true]{pointer-events:none}.ui\:aria-disabled\:opacity-50[aria-disabled=true]{opacity:.5}.ui\:aria-invalid\:border-destructive[aria-invalid=true]{border-color:var(--destructive)}.ui\:aria-invalid\:ring-destructive\/20[aria-invalid=true]{--tw-ring-color:var(--destructive)}@supports (color:color-mix(in lab, red, red)){.ui\:aria-invalid\:ring-destructive\/20[aria-invalid=true]{--tw-ring-color:color-mix(in oklab, var(--destructive) 20%, transparent)}}.ui\:aria-selected\:bg-accent[aria-selected=true]{background-color:var(--accent)}.ui\:aria-selected\:text-accent-foreground[aria-selected=true]{color:var(--accent-foreground)}:is(.ui\:\*\*\:data-command-group\:px-2 *)[data-command-group]{padding-inline:calc(var(--ui-spacing) * 2)}:is(.ui\:\*\*\:data-command-input\:h-12 *)[data-command-input]{height:calc(var(--ui-spacing) * 12)}:is(.ui\:\*\*\:data-command-item\:px-2 *)[data-command-item]{padding-inline:calc(var(--ui-spacing) * 2)}:is(.ui\:\*\*\:data-command-item\:py-3 *)[data-command-item]{padding-block:calc(var(--ui-spacing) * 3)}.ui\:data-disabled\:pointer-events-none[data-disabled]{pointer-events:none}.ui\:data-disabled\:cursor-not-allowed[data-disabled]{cursor:not-allowed}.ui\:data-disabled\:opacity-50[data-disabled]{opacity:.5}.ui\:data-highlighted\:bg-accent[data-highlighted]{background-color:var(--accent)}.ui\:data-highlighted\:text-accent-foreground[data-highlighted]{color:var(--accent-foreground)}.ui\:data-inset\:pl-8[data-inset]{padding-left:calc(var(--ui-spacing) * 8)}.ui\:data-placeholder\:text-muted-foreground[data-placeholder]{color:var(--muted-foreground)}.ui\:data-\[active\=true\]\:bg-accent\/50[data-active=true]{background-color:var(--accent)}@supports (color:color-mix(in lab, red, red)){.ui\:data-\[active\=true\]\:bg-accent\/50[data-active=true]{background-color:color-mix(in oklab, var(--accent) 50%, transparent)}}.ui\:data-\[active\=true\]\:bg-sidebar-accent[data-active=true]{background-color:var(--sidebar-accent)}.ui\:data-\[active\=true\]\:font-medium[data-active=true]{--tw-font-weight:var(--ui-font-weight-medium);font-weight:var(--ui-font-weight-medium)}.ui\:data-\[active\=true\]\:text-accent-foreground[data-active=true]{color:var(--accent-foreground)}.ui\:data-\[active\=true\]\:text-sidebar-accent-foreground[data-active=true]{color:var(--sidebar-accent-foreground)}@media (hover:hover){.ui\:data-\[active\=true\]\:hover\:bg-accent[data-active=true]:hover{background-color:var(--accent)}}.ui\:data-\[active\=true\]\:focus\:bg-accent[data-active=true]:focus{background-color:var(--accent)}.ui\:data-\[current\=true\]\:bg-muted[data-current=true]{background-color:var(--muted)}.ui\:data-\[disabled\=true\]\:pointer-events-none[data-disabled=true]{pointer-events:none}.ui\:data-\[disabled\=true\]\:opacity-50[data-disabled=true]{opacity:.5}.ui\:data-\[inset\]\:pl-8[data-inset]{padding-left:calc(var(--ui-spacing) * 8)}.ui\:data-\[invalid\=true\]\:text-destructive[data-invalid=true]{color:var(--destructive)}.ui\:data-\[motion\=from-end\]\:slide-in-from-end-52[data-motion=from-end]:where(:dir(ltr),[dir=ltr]){--tw-enter-translate-x:calc(52*var(--spacing))}.ui\:data-\[motion\=from-end\]\:slide-in-from-end-52[data-motion=from-end]:where(:dir(rtl),[dir=rtl]),.ui\:data-\[motion\=from-start\]\:slide-in-from-start-52[data-motion=from-start]:where(:dir(ltr),[dir=ltr]){--tw-enter-translate-x:calc(52*var(--spacing)*-1)}.ui\:data-\[motion\=from-start\]\:slide-in-from-start-52[data-motion=from-start]:where(:dir(rtl),[dir=rtl]){--tw-enter-translate-x:calc(52*var(--spacing))}.ui\:data-\[motion\=to-end\]\:slide-out-to-end-52[data-motion=to-end]:where(:dir(ltr),[dir=ltr]){--tw-exit-translate-x:calc(52*var(--spacing))}.ui\:data-\[motion\=to-end\]\:slide-out-to-end-52[data-motion=to-end]:where(:dir(rtl),[dir=rtl]),.ui\:data-\[motion\=to-start\]\:slide-out-to-start-52[data-motion=to-start]:where(:dir(ltr),[dir=ltr]){--tw-exit-translate-x:calc(52*var(--spacing)*-1)}.ui\:data-\[motion\=to-start\]\:slide-out-to-start-52[data-motion=to-start]:where(:dir(rtl),[dir=rtl]){--tw-exit-translate-x:calc(52*var(--spacing))}.ui\:data-\[motion\^\=from-\]\:animate-in[data-motion^=from-]{animation:enter var(--tw-animation-duration,var(--tw-duration,.15s))var(--tw-ease,ease)var(--tw-animation-delay,0s)var(--tw-animation-iteration-count,1)var(--tw-animation-direction,normal)var(--tw-animation-fill-mode,none)}.ui\:data-\[motion\^\=from-\]\:fade-in[data-motion^=from-]{--tw-enter-opacity:0}.ui\:data-\[motion\^\=to-\]\:animate-out[data-motion^=to-]{animation:exit var(--tw-animation-duration,var(--tw-duration,.15s))var(--tw-ease,ease)var(--tw-animation-delay,0s)var(--tw-animation-iteration-count,1)var(--tw-animation-direction,normal)var(--tw-animation-fill-mode,none)}.ui\:data-\[motion\^\=to-\]\:fade-out[data-motion^=to-]{--tw-exit-opacity:0}.ui\:data-\[orientation\=horizontal\]\:h-px[data-orientation=horizontal]{height:1px}.ui\:data-\[orientation\=horizontal\]\:w-full[data-orientation=horizontal]{width:100%}.ui\:data-\[orientation\=vertical\]\:h-auto[data-orientation=vertical]{height:auto}.ui\:data-\[orientation\=vertical\]\:h-full[data-orientation=vertical]{height:100%}.ui\:data-\[orientation\=vertical\]\:w-px[data-orientation=vertical]{width:1px}.ui\:data-\[side\=bottom\]\:-translate-x-1\/2[data-side=bottom]{--tw-translate-x:calc(calc(1 / 2 * 100%) * -1);translate:var(--tw-translate-x) var(--tw-translate-y)}.ui\:data-\[side\=bottom\]\:-translate-y-\[calc\(-50\%\+1px\)\][data-side=bottom]{--tw-translate-y:calc(calc(-50% + 1px) * -1);translate:var(--tw-translate-x) var(--tw-translate-y)}.ui\:data-\[side\=bottom\]\:translate-y-1[data-side=bottom]{--tw-translate-y:calc(var(--ui-spacing) * 1);translate:var(--tw-translate-x) var(--tw-translate-y)}.ui\:data-\[side\=bottom\]\:slide-in-from-top-2[data-side=bottom]{--tw-enter-translate-y:calc(2*var(--spacing)*-1)}.ui\:data-\[side\=left\]\:-translate-x-1[data-side=left]{--tw-translate-x:calc(var(--ui-spacing) * -1);translate:var(--tw-translate-x) var(--tw-translate-y)}.ui\:data-\[side\=left\]\:-translate-y-\[calc\(50\%-3px\)\][data-side=left]{--tw-translate-y:calc(calc(50% - 3px) * -1);translate:var(--tw-translate-x) var(--tw-translate-y)}.ui\:data-\[side\=left\]\:slide-in-from-end-2[data-side=left]:where(:dir(ltr),[dir=ltr]){--tw-enter-translate-x:calc(2*var(--spacing))}.ui\:data-\[side\=left\]\:slide-in-from-end-2[data-side=left]:where(:dir(rtl),[dir=rtl]){--tw-enter-translate-x:calc(2*var(--spacing)*-1)}.ui\:data-\[side\=left\]\:slide-in-from-right-2[data-side=left]{--tw-enter-translate-x:calc(2*var(--spacing))}.ui\:data-\[side\=right\]\:translate-x-1[data-side=right]{--tw-translate-x:calc(var(--ui-spacing) * 1);translate:var(--tw-translate-x) var(--tw-translate-y)}.ui\:data-\[side\=right\]\:translate-x-\[calc\(50\%\+2px\)\][data-side=right]{--tw-translate-x:calc(50% + 2px);translate:var(--tw-translate-x) var(--tw-translate-y)}.ui\:data-\[side\=right\]\:translate-y-1\/2[data-side=right]{--tw-translate-y:calc(1 / 2 * 100%);translate:var(--tw-translate-x) var(--tw-translate-y)}.ui\:data-\[side\=right\]\:slide-in-from-start-2[data-side=right]:where(:dir(ltr),[dir=ltr]){--tw-enter-translate-x:calc(2*var(--spacing)*-1)}.ui\:data-\[side\=right\]\:slide-in-from-start-2[data-side=right]:where(:dir(rtl),[dir=rtl]){--tw-enter-translate-x:calc(2*var(--spacing))}.ui\:data-\[side\=right\]\:slide-in-from-left-2[data-side=right]{--tw-enter-translate-x:calc(2*var(--spacing)*-1)}.ui\:data-\[side\=top\]\:translate-x-1\/2[data-side=top]{--tw-translate-x:calc(1 / 2 * 100%);translate:var(--tw-translate-x) var(--tw-translate-y)}.ui\:data-\[side\=top\]\:-translate-y-1[data-side=top]{--tw-translate-y:calc(var(--ui-spacing) * -1);translate:var(--tw-translate-x) var(--tw-translate-y)}.ui\:data-\[side\=top\]\:translate-y-\[calc\(-50\%\+2px\)\][data-side=top]{--tw-translate-y:calc(-50% + 2px);translate:var(--tw-translate-x) var(--tw-translate-y)}.ui\:data-\[side\=top\]\:slide-in-from-bottom-2[data-side=top]{--tw-enter-translate-y:calc(2*var(--spacing))}.ui\:data-\[size\=default\]\:h-9[data-size=default]{height:calc(var(--ui-spacing) * 9)}.ui\:data-\[size\=sm\]\:h-8[data-size=sm]{height:calc(var(--ui-spacing) * 8)}.ui\:data-\[slot\=checkbox-group\]\:gap-3[data-slot=checkbox-group]{gap:calc(var(--ui-spacing) * 3)}:is(.ui\:\*\:data-\[slot\=field\]\:p-4>*)[data-slot=field]{padding:calc(var(--ui-spacing) * 4)}:is(.ui\:\*\:data-\[slot\=field-group\]\:gap-4>*)[data-slot=field-group]{gap:calc(var(--ui-spacing) * 4)}:is(.ui\:\*\*\:data-\[slot\=navigation-menu-link\]\:focus\:ring-0 *)[data-slot=navigation-menu-link]:focus{--tw-ring-shadow:var(--tw-ring-inset,) 0 0 0 calc(0px + var(--tw-ring-offset-width)) var(--tw-ring-color,currentcolor);box-shadow:var(--tw-inset-shadow), var(--tw-inset-ring-shadow), var(--tw-ring-offset-shadow), var(--tw-ring-shadow), var(--tw-shadow)}:is(.ui\:\*\*\:data-\[slot\=navigation-menu-link\]\:focus\:outline-none *)[data-slot=navigation-menu-link]:focus{--tw-outline-style:none;outline-style:none}:is(.ui\:\*\*\:data-\[slot\=select-value\]\:line-clamp-1 *)[data-slot=select-value]{-webkit-line-clamp:1;-webkit-box-orient:vertical;display:-webkit-box;overflow:hidden}:is(.ui\:\*\*\:data-\[slot\=select-value\]\:flex *)[data-slot=select-value]{display:flex}:is(.ui\:\*\*\:data-\[slot\=select-value\]\:items-center *)[data-slot=select-value]{align-items:center}:is(.ui\:\*\*\:data-\[slot\=select-value\]\:gap-2 *)[data-slot=select-value]{gap:calc(var(--ui-spacing) * 2)}.ui\:data-\[state\=active\]\:bg-background[data-state=active]{background-color:var(--background)}.ui\:data-\[state\=active\]\:shadow-sm[data-state=active]{--tw-shadow:0 1px 3px 0 var(--tw-shadow-color,#0000001a), 0 1px 2px -1px var(--tw-shadow-color,#0000001a);box-shadow:var(--tw-inset-shadow), var(--tw-inset-ring-shadow), var(--tw-ring-offset-shadow), var(--tw-ring-shadow), var(--tw-shadow)}.ui\:data-\[state\=checked\]\:translate-x-\[calc\(100\%-2px\)\][data-state=checked]{--tw-translate-x:calc(100% - 2px);translate:var(--tw-translate-x) var(--tw-translate-y)}.ui\:data-\[state\=checked\]\:border-primary[data-state=checked]{border-color:var(--primary)}.ui\:data-\[state\=checked\]\:bg-primary[data-state=checked]{background-color:var(--primary)}.ui\:data-\[state\=checked\]\:text-primary-foreground[data-state=checked]{color:var(--primary-foreground)}.ui\:data-\[state\=closed\]\:animate-accordion-up[data-state=closed]{animation:accordion-up var(--tw-animation-duration,var(--tw-duration,.2s))var(--tw-ease,ease-out)var(--tw-animation-delay,0s)var(--tw-animation-iteration-count,1)var(--tw-animation-direction,normal)var(--tw-animation-fill-mode,none)}.ui\:data-\[state\=closed\]\:animate-out[data-state=closed]{animation:exit var(--tw-animation-duration,var(--tw-duration,.15s))var(--tw-ease,ease)var(--tw-animation-delay,0s)var(--tw-animation-iteration-count,1)var(--tw-animation-direction,normal)var(--tw-animation-fill-mode,none)}.ui\:data-\[state\=closed\]\:duration-300[data-state=closed]{--tw-duration:.3s;transition-duration:.3s}.ui\:data-\[state\=closed\]\:fade-out-0[data-state=closed]{--tw-exit-opacity:0}.ui\:data-\[state\=closed\]\:zoom-out-95[data-state=closed]{--tw-exit-scale:.95}.ui\:data-\[state\=closed\]\:slide-out-to-bottom[data-state=closed]{--tw-exit-translate-y:100%}.ui\:data-\[state\=closed\]\:slide-out-to-left[data-state=closed]{--tw-exit-translate-x:-100%}.ui\:data-\[state\=closed\]\:slide-out-to-right[data-state=closed]{--tw-exit-translate-x:100%}.ui\:data-\[state\=closed\]\:slide-out-to-top[data-state=closed]{--tw-exit-translate-y:-100%}.ui\:group-data-\[viewport\=false\]\/navigation-menu\:data-\[state\=closed\]\:animate-out:is(:where(.ui\:group\/navigation-menu)[data-viewport=false] *)[data-state=closed]{animation:exit var(--tw-animation-duration,var(--tw-duration,.15s))var(--tw-ease,ease)var(--tw-animation-delay,0s)var(--tw-animation-iteration-count,1)var(--tw-animation-direction,normal)var(--tw-animation-fill-mode,none)}.ui\:group-data-\[viewport\=false\]\/navigation-menu\:data-\[state\=closed\]\:fade-out-0:is(:where(.ui\:group\/navigation-menu)[data-viewport=false] *)[data-state=closed]{--tw-exit-opacity:0}.ui\:group-data-\[viewport\=false\]\/navigation-menu\:data-\[state\=closed\]\:zoom-out-95:is(:where(.ui\:group\/navigation-menu)[data-viewport=false] *)[data-state=closed]{--tw-exit-scale:.95}.ui\:data-\[state\=hidden\]\:animate-out[data-state=hidden]{animation:exit var(--tw-animation-duration,var(--tw-duration,.15s))var(--tw-ease,ease)var(--tw-animation-delay,0s)var(--tw-animation-iteration-count,1)var(--tw-animation-direction,normal)var(--tw-animation-fill-mode,none)}.ui\:data-\[state\=hidden\]\:fade-out[data-state=hidden]{--tw-exit-opacity:0}.ui\:data-\[state\=off\]\:text-muted-foreground[data-state=off]{color:var(--muted-foreground)}@media (hover:hover){.ui\:hover\:data-\[state\=off\]\:text-accent-foreground:hover[data-state=off]{color:var(--accent-foreground)}}.ui\:data-\[state\=on\]\:bg-accent[data-state=on]{background-color:var(--accent)}.ui\:data-\[state\=on\]\:bg-transparent[data-state=on]{background-color:#0000}.ui\:data-\[state\=on\]\:text-accent-foreground[data-state=on]{color:var(--accent-foreground)}.ui\:data-\[state\=on\]\:text-muted-foreground[data-state=on]{color:var(--muted-foreground)}@media (hover:hover){.ui\:hover\:data-\[state\=on\]\:text-accent-foreground:hover[data-state=on]{color:var(--accent-foreground)}}.ui\:data-\[state\=open\]\:animate-accordion-down[data-state=open]{animation:accordion-down var(--tw-animation-duration,var(--tw-duration,.2s))var(--tw-ease,ease-out)var(--tw-animation-delay,0s)var(--tw-animation-iteration-count,1)var(--tw-animation-direction,normal)var(--tw-animation-fill-mode,none)}.ui\:data-\[state\=open\]\:animate-in[data-state=open]{animation:enter var(--tw-animation-duration,var(--tw-duration,.15s))var(--tw-ease,ease)var(--tw-animation-delay,0s)var(--tw-animation-iteration-count,1)var(--tw-animation-direction,normal)var(--tw-animation-fill-mode,none)}.ui\:data-\[state\=open\]\:bg-accent[data-state=open]{background-color:var(--accent)}.ui\:data-\[state\=open\]\:text-accent-foreground[data-state=open]{color:var(--accent-foreground)}.ui\:data-\[state\=open\]\:opacity-100[data-state=open]{opacity:1}.ui\:data-\[state\=open\]\:duration-500[data-state=open]{--tw-duration:.5s;transition-duration:.5s}.ui\:data-\[state\=open\]\:fade-in-0[data-state=open]{--tw-enter-opacity:0}.ui\:data-\[state\=open\]\:zoom-in-90[data-state=open]{--tw-enter-scale:.9}.ui\:data-\[state\=open\]\:zoom-in-95[data-state=open]{--tw-enter-scale:.95}.ui\:data-\[state\=open\]\:slide-in-from-bottom[data-state=open]{--tw-enter-translate-y:100%}.ui\:data-\[state\=open\]\:slide-in-from-left[data-state=open]{--tw-enter-translate-x:-100%}.ui\:data-\[state\=open\]\:slide-in-from-right[data-state=open]{--tw-enter-translate-x:100%}.ui\:data-\[state\=open\]\:slide-in-from-top[data-state=open]{--tw-enter-translate-y:-100%}.ui\:group-data-\[viewport\=false\]\/navigation-menu\:data-\[state\=open\]\:animate-in:is(:where(.ui\:group\/navigation-menu)[data-viewport=false] *)[data-state=open]{animation:enter var(--tw-animation-duration,var(--tw-duration,.15s))var(--tw-ease,ease)var(--tw-animation-delay,0s)var(--tw-animation-iteration-count,1)var(--tw-animation-direction,normal)var(--tw-animation-fill-mode,none)}.ui\:group-data-\[viewport\=false\]\/navigation-menu\:data-\[state\=open\]\:fade-in-0:is(:where(.ui\:group\/navigation-menu)[data-viewport=false] *)[data-state=open]{--tw-enter-opacity:0}.ui\:group-data-\[viewport\=false\]\/navigation-menu\:data-\[state\=open\]\:zoom-in-95:is(:where(.ui\:group\/navigation-menu)[data-viewport=false] *)[data-state=open]{--tw-enter-scale:.95}@media (hover:hover){.ui\:data-\[state\=open\]\:hover\:bg-sidebar-accent[data-state=open]:hover{background-color:var(--sidebar-accent)}.ui\:data-\[state\=open\]\:hover\:text-sidebar-accent-foreground[data-state=open]:hover{color:var(--sidebar-accent-foreground)}}.ui\:data-\[state\=selected\]\:bg-muted[data-state=selected]{background-color:var(--muted)}.ui\:data-\[state\=unchecked\]\:translate-x-0[data-state=unchecked]{--tw-translate-x:calc(var(--ui-spacing) * 0);translate:var(--tw-translate-x) var(--tw-translate-y)}.ui\:data-\[state\=unchecked\]\:bg-input[data-state=unchecked]{background-color:var(--input)}.ui\:data-\[state\=visible\]\:animate-in[data-state=visible]{animation:enter var(--tw-animation-duration,var(--tw-duration,.15s))var(--tw-ease,ease)var(--tw-animation-delay,0s)var(--tw-animation-iteration-count,1)var(--tw-animation-direction,normal)var(--tw-animation-fill-mode,none)}.ui\:data-\[state\=visible\]\:fade-in[data-state=visible]{--tw-enter-opacity:0}.ui\:data-\[variant\=destructive\]\:text-destructive[data-variant=destructive]{color:var(--destructive)}.ui\:data-\[variant\=destructive\]\:focus\:bg-destructive\/10[data-variant=destructive]:focus{background-color:var(--destructive)}@supports (color:color-mix(in lab, red, red)){.ui\:data-\[variant\=destructive\]\:focus\:bg-destructive\/10[data-variant=destructive]:focus{background-color:color-mix(in oklab, var(--destructive) 10%, transparent)}}.ui\:data-\[variant\=destructive\]\:focus\:text-destructive[data-variant=destructive]:focus{color:var(--destructive)}.ui\:data-\[variant\=destructive\]\:data-highlighted\:bg-destructive\/10[data-variant=destructive][data-highlighted]{background-color:var(--destructive)}@supports (color:color-mix(in lab, red, red)){.ui\:data-\[variant\=destructive\]\:data-highlighted\:bg-destructive\/10[data-variant=destructive][data-highlighted]{background-color:color-mix(in oklab, var(--destructive) 10%, transparent)}}.ui\:data-\[variant\=destructive\]\:data-highlighted\:text-destructive[data-variant=destructive][data-highlighted]{color:var(--destructive)}.ui\:data-\[variant\=label\]\:text-sm[data-variant=label]{font-size:var(--ui-text-sm);line-height:var(--tw-leading,var(--ui-text-sm--line-height))}.ui\:data-\[variant\=legend\]\:text-base[data-variant=legend]{font-size:var(--ui-text-base);line-height:var(--tw-leading,var(--ui-text-base--line-height))}.ui\:data-\[vaul-drawer-direction\=bottom\]\:inset-x-0[data-vaul-drawer-direction=bottom]{inset-inline:calc(var(--ui-spacing) * 0)}.ui\:data-\[vaul-drawer-direction\=bottom\]\:bottom-0[data-vaul-drawer-direction=bottom]{bottom:calc(var(--ui-spacing) * 0)}.ui\:data-\[vaul-drawer-direction\=bottom\]\:mt-24[data-vaul-drawer-direction=bottom]{margin-top:calc(var(--ui-spacing) * 24)}.ui\:data-\[vaul-drawer-direction\=bottom\]\:max-h-\[80vh\][data-vaul-drawer-direction=bottom]{max-height:80vh}.ui\:data-\[vaul-drawer-direction\=bottom\]\:rounded-t-lg[data-vaul-drawer-direction=bottom]{border-top-left-radius:var(--radius);border-top-right-radius:var(--radius)}.ui\:data-\[vaul-drawer-direction\=bottom\]\:border-t[data-vaul-drawer-direction=bottom]{border-top-style:var(--tw-border-style);border-top-width:1px}.ui\:data-\[vaul-drawer-direction\=left\]\:inset-y-0[data-vaul-drawer-direction=left]{inset-block:calc(var(--ui-spacing) * 0)}.ui\:data-\[vaul-drawer-direction\=left\]\:start-0[data-vaul-drawer-direction=left]{inset-inline-start:calc(var(--ui-spacing) * 0)}.ui\:data-\[vaul-drawer-direction\=left\]\:w-3\/4[data-vaul-drawer-direction=left]{width:75%}.ui\:data-\[vaul-drawer-direction\=left\]\:border-e[data-vaul-drawer-direction=left]{border-inline-end-style:var(--tw-border-style);border-inline-end-width:1px}.ui\:data-\[vaul-drawer-direction\=right\]\:inset-y-0[data-vaul-drawer-direction=right]{inset-block:calc(var(--ui-spacing) * 0)}.ui\:data-\[vaul-drawer-direction\=right\]\:end-0[data-vaul-drawer-direction=right]{inset-inline-end:calc(var(--ui-spacing) * 0)}.ui\:data-\[vaul-drawer-direction\=right\]\:w-3\/4[data-vaul-drawer-direction=right]{width:75%}.ui\:data-\[vaul-drawer-direction\=right\]\:border-s[data-vaul-drawer-direction=right]{border-inline-start-style:var(--tw-border-style);border-inline-start-width:1px}.ui\:data-\[vaul-drawer-direction\=top\]\:inset-x-0[data-vaul-drawer-direction=top]{inset-inline:calc(var(--ui-spacing) * 0)}.ui\:data-\[vaul-drawer-direction\=top\]\:top-0[data-vaul-drawer-direction=top]{top:calc(var(--ui-spacing) * 0)}.ui\:data-\[vaul-drawer-direction\=top\]\:mb-24[data-vaul-drawer-direction=top]{margin-bottom:calc(var(--ui-spacing) * 24)}.ui\:data-\[vaul-drawer-direction\=top\]\:max-h-\[80vh\][data-vaul-drawer-direction=top]{max-height:80vh}.ui\:data-\[vaul-drawer-direction\=top\]\:rounded-b-lg[data-vaul-drawer-direction=top]{border-bottom-right-radius:var(--radius);border-bottom-left-radius:var(--radius)}.ui\:data-\[vaul-drawer-direction\=top\]\:border-b[data-vaul-drawer-direction=top]{border-bottom-style:var(--tw-border-style);border-bottom-width:1px}.ui\:nth-last-2\:-mt-1:nth-last-child(2){margin-top:calc(var(--ui-spacing) * -1)}@media (min-width:40rem){.ui\:sm\:flex{display:flex}.ui\:sm\:max-w-lg{max-width:var(--ui-container-lg)}.ui\:sm\:max-w-sm{max-width:var(--ui-container-sm)}.ui\:sm\:flex-row{flex-direction:row}.ui\:sm\:justify-end{justify-content:flex-end}.ui\:sm\:gap-2\.5{gap:calc(var(--ui-spacing) * 2.5)}.ui\:sm\:pr-2\.5{padding-right:calc(var(--ui-spacing) * 2.5)}.ui\:sm\:pl-2\.5{padding-left:calc(var(--ui-spacing) * 2.5)}.ui\:data-\[vaul-drawer-direction\=left\]\:sm\:max-w-sm[data-vaul-drawer-direction=left],.ui\:data-\[vaul-drawer-direction\=right\]\:sm\:max-w-sm[data-vaul-drawer-direction=right]{max-width:var(--ui-container-sm)}}@media (min-width:48rem){.ui\:md\:block{display:block}.ui\:md\:flex{display:flex}.ui\:md\:grid-cols-2{grid-template-columns:repeat(2,minmax(0,1fr))}.ui\:md\:flex-row{flex-direction:row}.ui\:md\:p-12{padding:calc(var(--ui-spacing) * 12)}.ui\:md\:text-sm{font-size:var(--ui-text-sm);line-height:var(--tw-leading,var(--ui-text-sm--line-height))}.ui\:md\:opacity-0{opacity:0}.ui\:md\:peer-data-\[variant\=inset\]\:m-2:is(:where(.ui\:peer)[data-variant=inset]~*){margin:calc(var(--ui-spacing) * 2)}.ui\:md\:peer-data-\[variant\=inset\]\:ml-0:is(:where(.ui\:peer)[data-variant=inset]~*){margin-left:calc(var(--ui-spacing) * 0)}.ui\:md\:peer-data-\[variant\=inset\]\:rounded-xl:is(:where(.ui\:peer)[data-variant=inset]~*){border-radius:calc(var(--radius) + 4px)}.ui\:md\:peer-data-\[variant\=inset\]\:shadow-sm:is(:where(.ui\:peer)[data-variant=inset]~*){--tw-shadow:0 1px 3px 0 var(--tw-shadow-color,#0000001a), 0 1px 2px -1px var(--tw-shadow-color,#0000001a);box-shadow:var(--tw-inset-shadow), var(--tw-inset-ring-shadow), var(--tw-ring-offset-shadow), var(--tw-ring-shadow), var(--tw-shadow)}.ui\:md\:peer-data-\[variant\=inset\]\:peer-data-\[state\=collapsed\]\:ml-2:is(:where(.ui\:peer)[data-variant=inset]~*):is(:where(.ui\:peer)[data-state=collapsed]~*){margin-left:calc(var(--ui-spacing) * 2)}.ui\:md\:after\:hidden:after{content:var(--tw-content);display:none}}.ui\:dark\:scale-0:where(.dark,.dark *){--tw-scale-x:0%;--tw-scale-y:0%;--tw-scale-z:0%;scale:var(--tw-scale-x) var(--tw-scale-y)}.ui\:dark\:scale-100:where(.dark,.dark *){--tw-scale-x:100%;--tw-scale-y:100%;--tw-scale-z:100%;scale:var(--tw-scale-x) var(--tw-scale-y)}.ui\:dark\:-rotate-90:where(.dark,.dark *){rotate:-90deg}.ui\:dark\:rotate-0:where(.dark,.dark *){rotate:none}.ui\:dark\:border-amber-900:where(.dark,.dark *){border-color:var(--ui-color-amber-900)}.ui\:dark\:border-input:where(.dark,.dark *){border-color:var(--input)}.ui\:dark\:border-sky-900:where(.dark,.dark *){border-color:var(--ui-color-sky-900)}.ui\:dark\:border-slate-800:where(.dark,.dark *){border-color:var(--ui-color-slate-800)}.ui\:dark\:bg-amber-500:where(.dark,.dark *){background-color:var(--ui-color-amber-500)}.ui\:dark\:bg-amber-950:where(.dark,.dark *){background-color:var(--ui-color-amber-950)}.ui\:dark\:bg-destructive\/60:where(.dark,.dark *){background-color:var(--destructive)}@supports (color:color-mix(in lab, red, red)){.ui\:dark\:bg-destructive\/60:where(.dark,.dark *){background-color:color-mix(in oklab, var(--destructive) 60%, transparent)}}.ui\:dark\:bg-destructive\/70:where(.dark,.dark *){background-color:var(--destructive)}@supports (color:color-mix(in lab, red, red)){.ui\:dark\:bg-destructive\/70:where(.dark,.dark *){background-color:color-mix(in oklab, var(--destructive) 70%, transparent)}}.ui\:dark\:bg-emerald-500:where(.dark,.dark *){background-color:var(--ui-color-emerald-500)}.ui\:dark\:bg-input\/30:where(.dark,.dark *){background-color:var(--input)}@supports (color:color-mix(in lab, red, red)){.ui\:dark\:bg-input\/30:where(.dark,.dark *){background-color:color-mix(in oklab, var(--input) 30%, transparent)}}.ui\:dark\:bg-sky-950:where(.dark,.dark *){background-color:var(--ui-color-sky-950)}.ui\:dark\:bg-slate-950:where(.dark,.dark *){background-color:var(--ui-color-slate-950)}.ui\:dark\:bg-transparent:where(.dark,.dark *){background-color:#0000}.ui\:dark\:text-amber-50:where(.dark,.dark *){color:var(--ui-color-amber-50)}.ui\:dark\:text-amber-950:where(.dark,.dark *){color:var(--ui-color-amber-950)}.ui\:dark\:text-emerald-950:where(.dark,.dark *){color:var(--ui-color-emerald-950)}.ui\:dark\:text-muted-foreground:where(.dark,.dark *){color:var(--muted-foreground)}.ui\:dark\:text-sky-50:where(.dark,.dark *){color:var(--ui-color-sky-50)}.ui\:dark\:text-white:where(.dark,.dark *){color:var(--ui-color-white)}@media (hover:hover){.ui\:dark\:hover\:border-input:where(.dark,.dark *):hover{border-color:var(--input)}.ui\:dark\:hover\:bg-input\/50:where(.dark,.dark *):hover{background-color:var(--input)}@supports (color:color-mix(in lab, red, red)){.ui\:dark\:hover\:bg-input\/50:where(.dark,.dark *):hover{background-color:color-mix(in oklab, var(--input) 50%, transparent)}}}.ui\:dark\:focus-visible\:ring-destructive\/40:where(.dark,.dark *):focus-visible{--tw-ring-color:var(--destructive)}@supports (color:color-mix(in lab, red, red)){.ui\:dark\:focus-visible\:ring-destructive\/40:where(.dark,.dark *):focus-visible{--tw-ring-color:color-mix(in oklab, var(--destructive) 40%, transparent)}}:where([data-slot=tooltip-content]) .ui\:dark\:in-data-\[slot\=tooltip-content\]\:bg-background\/10:where(.dark,.dark *){background-color:var(--background)}@supports (color:color-mix(in lab, red, red)){:where([data-slot=tooltip-content]) .ui\:dark\:in-data-\[slot\=tooltip-content\]\:bg-background\/10:where(.dark,.dark *){background-color:color-mix(in oklab, var(--background) 10%, transparent)}}.ui\:dark\:has-data-\[state\=checked\]\:bg-primary\/10:where(.dark,.dark *):has([data-state=checked]){background-color:var(--primary)}@supports (color:color-mix(in lab, red, red)){.ui\:dark\:has-data-\[state\=checked\]\:bg-primary\/10:where(.dark,.dark *):has([data-state=checked]){background-color:color-mix(in oklab, var(--primary) 10%, transparent)}}.ui\:dark\:has-\[\[data-slot\]\[aria-invalid\=true\]\]\:ring-destructive\/40:where(.dark,.dark *):has([data-slot][aria-invalid=true]){--tw-ring-color:var(--destructive)}@supports (color:color-mix(in lab, red, red)){.ui\:dark\:has-\[\[data-slot\]\[aria-invalid\=true\]\]\:ring-destructive\/40:where(.dark,.dark *):has([data-slot][aria-invalid=true]){--tw-ring-color:color-mix(in oklab, var(--destructive) 40%, transparent)}}.ui\:dark\:aria-invalid\:ring-destructive\/40:where(.dark,.dark *)[aria-invalid=true]{--tw-ring-color:var(--destructive)}@supports (color:color-mix(in lab, red, red)){.ui\:dark\:aria-invalid\:ring-destructive\/40:where(.dark,.dark *)[aria-invalid=true]{--tw-ring-color:color-mix(in oklab, var(--destructive) 40%, transparent)}}.ui\:dark\:data-\[state\=active\]\:border-input:where(.dark,.dark *)[data-state=active]{border-color:var(--input)}.ui\:dark\:data-\[state\=active\]\:bg-input\/30:where(.dark,.dark *)[data-state=active]{background-color:var(--input)}@supports (color:color-mix(in lab, red, red)){.ui\:dark\:data-\[state\=active\]\:bg-input\/30:where(.dark,.dark *)[data-state=active]{background-color:color-mix(in oklab, var(--input) 30%, transparent)}}.ui\:dark\:data-\[state\=active\]\:text-foreground:where(.dark,.dark *)[data-state=active]{color:var(--foreground)}.ui\:dark\:data-\[state\=checked\]\:bg-primary:where(.dark,.dark *)[data-state=checked]{background-color:var(--primary)}.ui\:dark\:data-\[state\=checked\]\:bg-primary-foreground:where(.dark,.dark *)[data-state=checked]{background-color:var(--primary-foreground)}.ui\:dark\:data-\[state\=unchecked\]\:bg-foreground:where(.dark,.dark *)[data-state=unchecked]{background-color:var(--foreground)}.ui\:dark\:data-\[state\=unchecked\]\:bg-input\/80:where(.dark,.dark *)[data-state=unchecked]{background-color:var(--input)}@supports (color:color-mix(in lab, red, red)){.ui\:dark\:data-\[state\=unchecked\]\:bg-input\/80:where(.dark,.dark *)[data-state=unchecked]{background-color:color-mix(in oklab, var(--input) 80%, transparent)}}.ui\:\[\&_\.lc-area-path\]\:opacity-100 .lc-area-path{opacity:1}.ui\:\[\&_\.lc-axis-tick\]\:stroke-0 .lc-axis-tick{stroke-width:0}.ui\:\[\&_\.lc-axis-tick-label\]\:fill-muted-foreground .lc-axis-tick-label{fill:var(--muted-foreground)}.ui\:\[\&_\.lc-axis-tick-label\]\:font-normal .lc-axis-tick-label{--tw-font-weight:var(--ui-font-weight-normal);font-weight:var(--ui-font-weight-normal)}.ui\:\[\&_\.lc-grid-x-radial-circle\]\:stroke-border .lc-grid-x-radial-circle,.ui\:\[\&_\.lc-grid-x-radial-line\]\:stroke-border .lc-grid-x-radial-line,.ui\:\[\&_\.lc-grid-y-radial-circle\]\:stroke-border .lc-grid-y-radial-circle,.ui\:\[\&_\.lc-grid-y-radial-line\]\:stroke-border .lc-grid-y-radial-line{stroke:var(--border)}.ui\:\[\&_\.lc-highlight-line\]\:stroke-0 .lc-highlight-line{stroke-width:0}.ui\:\[\&_\.lc-highlight-line\]\:opacity-100 .lc-highlight-line,.ui\:\[\&_\.lc-highlight-point\]\:opacity-100 .lc-highlight-point{opacity:1}.ui\:\[\&_\.lc-labels-text\:not\(\[fill\]\)\]\:fill-foreground .lc-labels-text:not([fill]){fill:var(--foreground)}.ui\:\[\&_\.lc-layout-svg-g\]\:fill-transparent .lc-layout-svg-g{fill:#0000}.ui\:\[\&_\.lc-legend-swatch\]\:size-2\.5 .lc-legend-swatch{width:calc(var(--ui-spacing) * 2.5);height:calc(var(--ui-spacing) * 2.5)}.ui\:\[\&_\.lc-legend-swatch\]\:rounded-\[2px\] .lc-legend-swatch{border-radius:2px}.ui\:\[\&_\.lc-legend-swatch-button\]\:items-center .lc-legend-swatch-button{align-items:center}.ui\:\[\&_\.lc-legend-swatch-button\]\:gap-1\.5 .lc-legend-swatch-button{gap:calc(var(--ui-spacing) * 1.5)}.ui\:\[\&_\.lc-legend-swatch-group\]\:items-center .lc-legend-swatch-group{align-items:center}.ui\:\[\&_\.lc-legend-swatch-group\]\:gap-4 .lc-legend-swatch-group{gap:calc(var(--ui-spacing) * 4)}.ui\:\[\&_\.lc-line\]\:stroke-border\/50 .lc-line{stroke:var(--border)}@supports (color:color-mix(in lab, red, red)){.ui\:\[\&_\.lc-line\]\:stroke-border\/50 .lc-line{stroke:color-mix(in oklab, var(--border) 50%, transparent)}}.ui\:\[\&_\.lc-root-container\]\:w-full .lc-root-container{width:100%}.ui\:\[\&_\.lc-rule-x-line\:not\(\.lc-grid-x-rule\)\]\:stroke-0 .lc-rule-x-line:not(.lc-grid-x-rule),.ui\:\[\&_\.lc-rule-y-line\:not\(\.lc-grid-y-rule\)\]\:stroke-0 .lc-rule-y-line:not(.lc-grid-y-rule){stroke-width:0}.ui\:\[\&_\.lc-spline-path\]\:opacity-100 .lc-spline-path{opacity:1}.ui\:\[\&_\.lc-text\]\:text-xs .lc-text{font-size:var(--ui-text-xs);line-height:var(--tw-leading,var(--ui-text-xs--line-height))}.ui\:\[\&_\.lc-text-svg\]\:overflow-visible .lc-text-svg{overflow:visible}.ui\:\[\&_\.lc-tooltip-rects-g\]\:fill-transparent .lc-tooltip-rects-g{fill:#0000}.ui\:\[\&_\.stroke-white\]\:stroke-transparent .stroke-white{stroke:#0000}.ui\:\[\&_\[data-command-group\]\:not\(\[hidden\]\)_\~\[data-command-group\]\]\:pt-0 [data-command-group]:not([hidden])~[data-command-group]{padding-top:calc(var(--ui-spacing) * 0)}.ui\:\[\&_\[data-command-input-wrapper\]_svg\]\:h-5 [data-command-input-wrapper] svg{height:calc(var(--ui-spacing) * 5)}.ui\:\[\&_\[data-command-input-wrapper\]_svg\]\:w-5 [data-command-input-wrapper] svg{width:calc(var(--ui-spacing) * 5)}.ui\:\[\&_\[data-command-item\]_svg\]\:h-5 [data-command-item] svg{height:calc(var(--ui-spacing) * 5)}.ui\:\[\&_\[data-command-item\]_svg\]\:w-5 [data-command-item] svg{width:calc(var(--ui-spacing) * 5)}.ui\:\[\&_img\]\:size-full img{width:100%;height:100%}.ui\:\[\&_img\]\:object-cover img{object-fit:cover}.ui\:\[\&_p\]\:leading-relaxed p{--tw-leading:var(--ui-leading-relaxed);line-height:var(--ui-leading-relaxed)}.ui\:\[\&_svg\]\:pointer-events-none svg{pointer-events:none}.ui\:\[\&_svg\]\:size-8\! svg{width:calc(var(--ui-spacing) * 8)!important;height:calc(var(--ui-spacing) * 8)!important}.ui\:\[\&_svg\]\:shrink-0 svg{flex-shrink:0}.ui\:\[\&_svg\:not\(\[class\*\=\'size-\'\]\)\]\:size-3 svg:not([class*=size-]){width:calc(var(--ui-spacing) * 3);height:calc(var(--ui-spacing) * 3)}.ui\:\[\&_svg\:not\(\[class\*\=\'size-\'\]\)\]\:size-4 svg:not([class*=size-]){width:calc(var(--ui-spacing) * 4);height:calc(var(--ui-spacing) * 4)}.ui\:\[\&_svg\:not\(\[class\*\=\'text-\'\]\)\]\:text-muted-foreground svg:not([class*=text-]){color:var(--muted-foreground)}.ui\:\[\&_svg\:not\(\[class\*\=\'ui\:size-\'\]\)\]\:size-4 svg:not([class*=ui\:size-]){width:calc(var(--ui-spacing) * 4);height:calc(var(--ui-spacing) * 4)}.ui\:\[\&_svg\:not\(\[class\*\=\'ui\:size-\'\]\)\]\:size-6 svg:not([class*=ui\:size-]){width:calc(var(--ui-spacing) * 6);height:calc(var(--ui-spacing) * 6)}.ui\:\[\&_text\]\:stroke-transparent text{stroke:#0000}.ui\:\[\&_tr\]\:border-b tr{border-bottom-style:var(--tw-border-style);border-bottom-width:1px}.ui\:\[\&_tr\:last-child\]\:border-0 tr:last-child{border-style:var(--tw-border-style);border-width:0}.ui\:\[\&\+\[data-slot\=item-content\]\]\:flex-none+[data-slot=item-content]{flex:none}.ui\:\[\&\:has\(\[role\=checkbox\]\)\]\:pr-0:has([role=checkbox]){padding-right:calc(var(--ui-spacing) * 0)}.ui\:\[\.border-b\]\:pb-3.border-b{padding-bottom:calc(var(--ui-spacing) * 3)}.ui\:\[\.border-b\]\:pb-6.border-b{padding-bottom:calc(var(--ui-spacing) * 6)}.ui\:\[\.border-t\]\:pt-3.border-t{padding-top:calc(var(--ui-spacing) * 3)}.ui\:\[\.border-t\]\:pt-6.border-t{padding-top:calc(var(--ui-spacing) * 6)}.ui\:\[a\]\:transition-colors:is(a){transition-property:color,background-color,border-color,outline-color,text-decoration-color,fill,stroke,--tw-gradient-from,--tw-gradient-via,--tw-gradient-to;transition-timing-function:var(--tw-ease,var(--ui-default-transition-timing-function));transition-duration:var(--tw-duration,var(--ui-default-transition-duration))}@media (hover:hover){.ui\:\[a\]\:hover\:bg-accent\/50:is(a):hover{background-color:var(--accent)}@supports (color:color-mix(in lab, red, red)){.ui\:\[a\]\:hover\:bg-accent\/50:is(a):hover{background-color:color-mix(in oklab, var(--accent) 50%, transparent)}}}:is(.ui\:\*\:\[span\]\:last\:flex>*):is(span):last-child{display:flex}:is(.ui\:\*\:\[span\]\:last\:items-center>*):is(span):last-child{align-items:center}:is(.ui\:\*\:\[span\]\:last\:gap-2>*):is(span):last-child{gap:calc(var(--ui-spacing) * 2)}:is(.ui\:data-\[variant\=destructive\]\:\*\:\[svg\]\:text-destructive\![data-variant=destructive]>*):is(svg){color:var(--destructive)!important}.ui\:\[\&\>\*\]\:focus-visible\:relative>:focus-visible{position:relative}.ui\:\[\&\>\*\]\:focus-visible\:z-10>:focus-visible{z-index:10}.ui\:\[\&\>\*\:not\(\:first-child\)\]\:rounded-s-none>:not(:first-child){border-start-start-radius:0;border-end-start-radius:0}.ui\:\[\&\>\*\:not\(\:first-child\)\]\:rounded-t-none>:not(:first-child){border-top-left-radius:0;border-top-right-radius:0}.ui\:\[\&\>\*\:not\(\:first-child\)\]\:border-s-0>:not(:first-child){border-inline-start-style:var(--tw-border-style);border-inline-start-width:0}.ui\:\[\&\>\*\:not\(\:first-child\)\]\:border-t-0>:not(:first-child){border-top-style:var(--tw-border-style);border-top-width:0}.ui\:\[\&\>\*\:not\(\:last-child\)\]\:rounded-e-none>:not(:last-child){border-start-end-radius:0;border-end-end-radius:0}.ui\:\[\&\>\*\:not\(\:last-child\)\]\:rounded-b-none>:not(:last-child){border-bottom-right-radius:0;border-bottom-left-radius:0}.ui\:\[\&\>\[data-slot\=field-label\]\]\:flex-auto>[data-slot=field-label]{flex:auto}.ui\:has-\[select\[aria-hidden\=true\]\:last-child\]\:\[\&\>\[data-slot\=select-trigger\]\:last-of-type\]\:rounded-e-md:has(:is(select[aria-hidden=true]:last-child))>[data-slot=select-trigger]:last-of-type{border-start-end-radius:calc(var(--radius) - 2px);border-end-end-radius:calc(var(--radius) - 2px)}.ui\:\[\&\>\[data-slot\=select-trigger\]\:not\(\[class\*\=\'ui\:w-\'\]\)\]\:w-fit>[data-slot=select-trigger]:not([class*=ui\:w-]){width:fit-content}.ui\:has-\[\>\[data-slot\=field-content\]\]\:\[\&\>\[role\=checkbox\]\,\[role\=radio\]\]\:mt-px:has(>[data-slot=field-content])>[role=checkbox],.ui\:has-\[\>\[data-slot\=field-content\]\]\:\[\&\>\[role\=checkbox\]\,\[role\=radio\]\]\:mt-px:has(>[data-slot=field-content]) [role=radio]{margin-top:1px}.ui\:\[\&\>a\]\:underline>a{text-decoration-line:underline}.ui\:\[\&\>a\]\:underline-offset-4>a{text-underline-offset:4px}.ui\:\[\&\>a\:hover\]\:text-primary>a:hover{color:var(--primary)}.ui\:\[\&\>button\]\:hidden>button{display:none}.ui\:\[\&\>input\]\:flex-1>input{flex:1}.ui\:has-\[\>\[data-align\=block-end\]\]\:\[\&\>input\]\:pt-3:has(>[data-align=block-end])>input{padding-top:calc(var(--ui-spacing) * 3)}.ui\:has-\[\>\[data-align\=block-start\]\]\:\[\&\>input\]\:pb-3:has(>[data-align=block-start])>input{padding-bottom:calc(var(--ui-spacing) * 3)}.ui\:has-\[\>\[data-align\=inline-end\]\]\:\[\&\>input\]\:pe-2:has(>[data-align=inline-end])>input{padding-inline-end:calc(var(--ui-spacing) * 2)}.ui\:has-\[\>\[data-align\=inline-start\]\]\:\[\&\>input\]\:ps-2:has(>[data-align=inline-start])>input{padding-inline-start:calc(var(--ui-spacing) * 2)}.ui\:\[\&\>kbd\]\:rounded-\[calc\(var\(--radius\)-5px\)\]>kbd{border-radius:calc(var(--radius) - 5px)}.ui\:\[\&\>span\:last-child\]\:truncate>span:last-child{text-overflow:ellipsis;white-space:nowrap;overflow:hidden}.ui\:\[\&\>svg\]\:pointer-events-none>svg{pointer-events:none}.ui\:\[\&\>svg\]\:size-2\.5>svg{width:calc(var(--ui-spacing) * 2.5);height:calc(var(--ui-spacing) * 2.5)}.ui\:\[\&\>svg\]\:size-3>svg{width:calc(var(--ui-spacing) * 3);height:calc(var(--ui-spacing) * 3)}.ui\:\[\&\>svg\]\:size-3\.5>svg{width:calc(var(--ui-spacing) * 3.5);height:calc(var(--ui-spacing) * 3.5)}.ui\:\[\&\>svg\]\:size-4>svg{width:calc(var(--ui-spacing) * 4);height:calc(var(--ui-spacing) * 4)}.ui\:\[\&\>svg\]\:shrink-0>svg{flex-shrink:0}.ui\:\[\&\>svg\]\:translate-y-0\.5>svg{--tw-translate-y:calc(var(--ui-spacing) * .5);translate:var(--tw-translate-x) var(--tw-translate-y)}.ui\:\[\&\>svg\]\:text-current>svg{color:currentColor}.ui\:\[\&\>svg\]\:text-muted-foreground>svg{color:var(--muted-foreground)}.ui\:\[\&\>svg\]\:text-sidebar-accent-foreground>svg{color:var(--sidebar-accent-foreground)}.ui\:\[\&\>svg\:not\(\[class\*\=\'ui\:size-\'\]\)\]\:size-3\.5>svg:not([class*=ui\:size-]){width:calc(var(--ui-spacing) * 3.5);height:calc(var(--ui-spacing) * 3.5)}.ui\:\[\&\>svg\:not\(\[class\*\=\'ui\:size-\'\]\)\]\:size-4>svg:not([class*=ui\:size-]){width:calc(var(--ui-spacing) * 4);height:calc(var(--ui-spacing) * 4)}@media (hover:hover){:is(.ui\:hover\:\[\&\,\&\>svelte-css-wrapper\]\:\[\&\>th\,td\]\:bg-muted\/50:hover,.ui\:hover\:\[\&\,\&\>svelte-css-wrapper\]\:\[\&\>th\,td\]\:bg-muted\/50:hover>svelte-css-wrapper)>th,:is(.ui\:hover\:\[\&\,\&\>svelte-css-wrapper\]\:\[\&\>th\,td\]\:bg-muted\/50:hover,.ui\:hover\:\[\&\,\&\>svelte-css-wrapper\]\:\[\&\>th\,td\]\:bg-muted\/50:hover>svelte-css-wrapper) td{background-color:var(--muted)}@supports (color:color-mix(in lab, red, red)){:is(.ui\:hover\:\[\&\,\&\>svelte-css-wrapper\]\:\[\&\>th\,td\]\:bg-muted\/50:hover,.ui\:hover\:\[\&\,\&\>svelte-css-wrapper\]\:\[\&\>th\,td\]\:bg-muted\/50:hover>svelte-css-wrapper)>th,:is(.ui\:hover\:\[\&\,\&\>svelte-css-wrapper\]\:\[\&\>th\,td\]\:bg-muted\/50:hover,.ui\:hover\:\[\&\,\&\>svelte-css-wrapper\]\:\[\&\>th\,td\]\:bg-muted\/50:hover>svelte-css-wrapper) td{background-color:color-mix(in oklab, var(--muted) 50%, transparent)}}}.ui\:\[\&\>tr\]\:last\:border-b-0>tr:last-child{border-bottom-style:var(--tw-border-style);border-bottom-width:0}.ui\:\[\&\[data-state\=open\]\>svg\]\:rotate-180[data-state=open]>svg{rotate:180deg}[data-side=left][data-collapsible=offcanvas] .ui\:\[\[data-side\=left\]\[data-collapsible\=offcanvas\]_\&\]\:-right-2{right:calc(var(--ui-spacing) * -2)}[data-side=left][data-state=collapsed] .ui\:\[\[data-side\=left\]\[data-state\=collapsed\]_\&\]\:cursor-e-resize{cursor:e-resize}[data-side=right][data-collapsible=offcanvas] .ui\:\[\[data-side\=right\]\[data-collapsible\=offcanvas\]_\&\]\:-left-2{left:calc(var(--ui-spacing) * -2)}[data-side=right][data-state=collapsed] .ui\:\[\[data-side\=right\]\[data-state\=collapsed\]_\&\]\:cursor-w-resize{cursor:w-resize}[data-variant=legend]+.ui\:\[\[data-variant\=legend\]\+\&\]\:-mt-1\.5{margin-top:calc(var(--ui-spacing) * -1.5)}@media (hover:hover){a.ui\:\[a\&\]\:hover\:bg-accent:hover{background-color:var(--accent)}a.ui\:\[a\&\]\:hover\:bg-amber-600\/90:hover{background-color:var(--ui-color-amber-600)}@supports (color:color-mix(in lab, red, red)){a.ui\:\[a\&\]\:hover\:bg-amber-600\/90:hover{background-color:color-mix(in oklab, var(--ui-color-amber-600) 90%, transparent)}}a.ui\:\[a\&\]\:hover\:bg-destructive\/90:hover{background-color:var(--destructive)}@supports (color:color-mix(in lab, red, red)){a.ui\:\[a\&\]\:hover\:bg-destructive\/90:hover{background-color:color-mix(in oklab, var(--destructive) 90%, transparent)}}a.ui\:\[a\&\]\:hover\:bg-emerald-600\/90:hover{background-color:var(--ui-color-emerald-600)}@supports (color:color-mix(in lab, red, red)){a.ui\:\[a\&\]\:hover\:bg-emerald-600\/90:hover{background-color:color-mix(in oklab, var(--ui-color-emerald-600) 90%, transparent)}}a.ui\:\[a\&\]\:hover\:bg-primary\/30:hover{background-color:var(--primary)}@supports (color:color-mix(in lab, red, red)){a.ui\:\[a\&\]\:hover\:bg-primary\/30:hover{background-color:color-mix(in oklab, var(--primary) 30%, transparent)}}a.ui\:\[a\&\]\:hover\:bg-primary\/90:hover{background-color:var(--primary)}@supports (color:color-mix(in lab, red, red)){a.ui\:\[a\&\]\:hover\:bg-primary\/90:hover{background-color:color-mix(in oklab, var(--primary) 90%, transparent)}}a.ui\:\[a\&\]\:hover\:bg-secondary\/80:hover{background-color:var(--secondary)}@supports (color:color-mix(in lab, red, red)){a.ui\:\[a\&\]\:hover\:bg-secondary\/80:hover{background-color:color-mix(in oklab, var(--secondary) 80%, transparent)}}a.ui\:\[a\&\]\:hover\:bg-secondary\/90:hover{background-color:var(--secondary)}@supports (color:color-mix(in lab, red, red)){a.ui\:\[a\&\]\:hover\:bg-secondary\/90:hover{background-color:color-mix(in oklab, var(--secondary) 90%, transparent)}}a.ui\:\[a\&\]\:hover\:text-accent-foreground:hover{color:var(--accent-foreground)}a.ui\:\[a\&\]\:hover\:text-primary:hover{color:var(--primary)}a.ui\:\[a\&\]\:hover\:underline:hover{text-decoration-line:underline}a.ui\:dark\:\[a\&\]\:hover\:bg-accent\/50:where(.dark,.dark *):hover{background-color:var(--accent)}@supports (color:color-mix(in lab, red, red)){a.ui\:dark\:\[a\&\]\:hover\:bg-accent\/50:where(.dark,.dark *):hover{background-color:color-mix(in oklab, var(--accent) 50%, transparent)}}}}@property --tw-animation-delay{syntax:"*";inherits:false;initial-value:0s}@property --tw-animation-direction{syntax:"*";inherits:false;initial-value:normal}@property --tw-animation-duration{syntax:"*";inherits:false}@property --tw-animation-fill-mode{syntax:"*";inherits:false;initial-value:none}@property --tw-animation-iteration-count{syntax:"*";inherits:false;initial-value:1}@property --tw-enter-blur{syntax:"*";inherits:false;initial-value:0}@property --tw-enter-opacity{syntax:"*";inherits:false;initial-value:1}@property --tw-enter-rotate{syntax:"*";inherits:false;initial-value:0}@property --tw-enter-scale{syntax:"*";inherits:false;initial-value:1}@property --tw-enter-translate-x{syntax:"*";inherits:false;initial-value:0}@property --tw-enter-translate-y{syntax:"*";inherits:false;initial-value:0}@property --tw-exit-blur{syntax:"*";inherits:false;initial-value:0}@property --tw-exit-opacity{syntax:"*";inherits:false;initial-value:1}@property --tw-exit-rotate{syntax:"*";inherits:false;initial-value:0}@property --tw-exit-scale{syntax:"*";inherits:false;initial-value:1}@property --tw-exit-translate-x{syntax:"*";inherits:false;initial-value:0}@property --tw-exit-translate-y{syntax:"*";inherits:false;initial-value:0}:root{--radius:.625rem;--background:oklch(100% 0 0);--foreground:oklch(14.7% .004 49.25);--card:oklch(100% 0 0);--card-foreground:oklch(14.7% .004 49.25);--popover:oklch(100% 0 0);--popover-foreground:oklch(14.7% .004 49.25);--primary:oklch(21.6% .006 56.043);--primary-foreground:oklch(98.5% .001 106.423);--secondary:oklch(97% .001 106.424);--secondary-foreground:oklch(21.6% .006 56.043);--muted:oklch(97% .001 106.424);--muted-foreground:oklch(55.3% .013 58.071);--accent:oklch(96.7% .001 286.375);--accent-foreground:oklch(21.6% .006 56.043);--destructive:oklch(57.7% .245 27.325);--border:oklch(92.3% .003 48.717);--input:oklch(92.3% .003 48.717);--ring:oklch(70.9% .01 56.259);--chart-1:oklch(64.6% .222 41.116);--chart-2:oklch(60% .118 184.704);--chart-3:oklch(39.8% .07 227.392);--chart-4:oklch(82.8% .189 84.429);--chart-5:oklch(76.9% .188 70.08);--sidebar:oklch(100% 0 0);--sidebar-foreground:oklch(14.7% .004 49.25);--sidebar-primary:oklch(21.6% .006 56.043);--sidebar-primary-foreground:oklch(98.5% .001 106.423);--sidebar-accent:oklch(97% .001 106.424);--sidebar-accent-foreground:oklch(21.6% .006 56.043);--sidebar-border:oklch(92.3% .003 48.717);--sidebar-ring:oklch(70.9% .01 56.259)}.dark{--background:oklch(14.7% .004 49.25);--foreground:oklch(98.5% .001 106.423);--card:oklch(21.6% .006 56.043);--card-foreground:oklch(98.5% .001 106.423);--popover:oklch(21.6% .006 56.043);--popover-foreground:oklch(98.5% .001 106.423);--primary:oklch(92.3% .003 48.717);--primary-foreground:oklch(21.6% .006 56.043);--secondary:oklch(26.8% .007 34.298);--secondary-foreground:oklch(98.5% .001 106.423);--muted:oklch(26.8% .007 34.298);--muted-foreground:oklch(70.9% .01 56.259);--accent:oklch(26.8% .007 34.298);--accent-foreground:oklch(98.5% .001 106.423);--destructive:oklch(70.4% .191 22.216);--border:oklch(100% 0 0/.1);--input:oklch(100% 0 0/.15);--ring:oklch(55.3% .013 58.071);--chart-1:oklch(48.8% .243 264.376);--chart-2:oklch(69.6% .17 162.48);--chart-3:oklch(76.9% .188 70.08);--chart-4:oklch(62.7% .265 303.9);--chart-5:oklch(64.5% .246 16.439);--sidebar:oklch(0% 0 0);--sidebar-foreground:oklch(98.5% .001 106.423);--sidebar-primary:oklch(48.8% .243 264.376);--sidebar-primary-foreground:oklch(98.5% .001 106.423);--sidebar-accent:oklch(26.8% .007 34.298);--sidebar-accent-foreground:oklch(98.5% .001 106.423);--sidebar-border:oklch(100% 0 0/.1);--sidebar-ring:oklch(55.3% .013 58.071)}@property --border-angle{syntax:"<angle>";inherits:false;initial-value:0deg}@keyframes border{to{--border-angle:360deg}}.animate-gradient-border{background:linear-gradient(45deg, white, white) padding-box, conic-gradient(from var(--border-angle), #94a3b84d 75%, var(--primary,#1d4ee2) 82%, var(--primary-foreground,white) 88%, var(--primary,#1d4ee2) 92%, #94a3b84d 100%) border-box;border:1px solid #0000;transition:--border-angle 3s ease-in-out}.animate-gradient-border:hover{animation:4s ease-in-out infinite border}.dark.animate-gradient-border{background:linear-gradient(45deg, #000, #000) padding-box, conic-gradient(from var(--border-angle), #4755697a 75%, var(--primary,#1d4ee2) 82%, var(--primary-foreground,black) 88%, var(--primary,#1d4ee2) 92%, #4755697a 100%) border-box}@property --tw-translate-x{syntax:"*";inherits:false;initial-value:0}@property --tw-translate-y{syntax:"*";inherits:false;initial-value:0}@property --tw-translate-z{syntax:"*";inherits:false;initial-value:0}@property --tw-scale-x{syntax:"*";inherits:false;initial-value:1}@property --tw-scale-y{syntax:"*";inherits:false;initial-value:1}@property --tw-scale-z{syntax:"*";inherits:false;initial-value:1}@property --tw-space-y-reverse{syntax:"*";inherits:false;initial-value:0}@property --tw-border-style{syntax:"*";inherits:false;initial-value:solid}@property --tw-gradient-position{syntax:"*";inherits:false}@property --tw-gradient-from{syntax:"<color>";inherits:false;initial-value:#0000}@property --tw-gradient-via{syntax:"<color>";inherits:false;initial-value:#0000}@property --tw-gradient-to{syntax:"<color>";inherits:false;initial-value:#0000}@property --tw-gradient-stops{syntax:"*";inherits:false}@property --tw-gradient-via-stops{syntax:"*";inherits:false}@property --tw-gradient-from-position{syntax:"<length-percentage>";inherits:false;initial-value:0%}@property --tw-gradient-via-position{syntax:"<length-percentage>";inherits:false;initial-value:50%}@property --tw-gradient-to-position{syntax:"<length-percentage>";inherits:false;initial-value:100%}@property --tw-leading{syntax:"*";inherits:false}@property --tw-font-weight{syntax:"*";inherits:false}@property --tw-tracking{syntax:"*";inherits:false}@property --tw-shadow{syntax:"*";inherits:false;initial-value:0 0 #0000}@property --tw-shadow-color{syntax:"*";inherits:false}@property --tw-shadow-alpha{syntax:"<percentage>";inherits:false;initial-value:100%}@property --tw-inset-shadow{syntax:"*";inherits:false;initial-value:0 0 #0000}@property --tw-inset-shadow-color{syntax:"*";inherits:false}@property --tw-inset-shadow-alpha{syntax:"<percentage>";inherits:false;initial-value:100%}@property --tw-ring-color{syntax:"*";inherits:false}@property --tw-ring-shadow{syntax:"*";inherits:false;initial-value:0 0 #0000}@property --tw-inset-ring-color{syntax:"*";inherits:false}@property --tw-inset-ring-shadow{syntax:"*";inherits:false;initial-value:0 0 #0000}@property --tw-ring-inset{syntax:"*";inherits:false}@property --tw-ring-offset-width{syntax:"<length>";inherits:false;initial-value:0}@property --tw-ring-offset-color{syntax:"*";inherits:false;initial-value:#fff}@property --tw-ring-offset-shadow{syntax:"*";inherits:false;initial-value:0 0 #0000}@property --tw-backdrop-blur{syntax:"*";inherits:false}@property --tw-backdrop-brightness{syntax:"*";inherits:false}@property --tw-backdrop-contrast{syntax:"*";inherits:false}@property --tw-backdrop-grayscale{syntax:"*";inherits:false}@property --tw-backdrop-hue-rotate{syntax:"*";inherits:false}@property --tw-backdrop-invert{syntax:"*";inherits:false}@property --tw-backdrop-opacity{syntax:"*";inherits:false}@property --tw-backdrop-saturate{syntax:"*";inherits:false}@property --tw-backdrop-sepia{syntax:"*";inherits:false}@property --tw-duration{syntax:"*";inherits:false}@property --tw-ease{syntax:"*";inherits:false}@property --tw-content{syntax:"*";inherits:false;initial-value:""}@property --tw-outline-style{syntax:"*";inherits:false;initial-value:solid}@keyframes spin{to{transform:rotate(360deg)}}@keyframes pulse{50%{opacity:.5}}@keyframes enter{0%{opacity:var(--tw-enter-opacity,1);transform:translate3d(var(--tw-enter-translate-x,0),var(--tw-enter-translate-y,0),0)scale3d(var(--tw-enter-scale,1),var(--tw-enter-scale,1),var(--tw-enter-scale,1))rotate(var(--tw-enter-rotate,0));filter:blur(var(--tw-enter-blur,0))}}@keyframes exit{to{opacity:var(--tw-exit-opacity,1);transform:translate3d(var(--tw-exit-translate-x,0),var(--tw-exit-translate-y,0),0)scale3d(var(--tw-exit-scale,1),var(--tw-exit-scale,1),var(--tw-exit-scale,1))rotate(var(--tw-exit-rotate,0));filter:blur(var(--tw-exit-blur,0))}}@keyframes accordion-down{0%{height:0}to{height:var(--radix-accordion-content-height,var(--bits-accordion-content-height,var(--reka-accordion-content-height,var(--kb-accordion-content-height,var(--ngp-accordion-content-height,auto)))))}}@keyframes accordion-up{0%{height:var(--radix-accordion-content-height,var(--bits-accordion-content-height,var(--reka-accordion-content-height,var(--kb-accordion-content-height,var(--ngp-accordion-content-height,auto)))))}to{height:0}}
\ No newline at end of file
diff --git a/packages/ui/src/tools/sanitize.ts b/packages/ui/src/tools/sanitize.ts
index d29a374e..071514f1 100644
--- a/packages/ui/src/tools/sanitize.ts
+++ b/packages/ui/src/tools/sanitize.ts
@@ -1,6 +1,7 @@
 /**
  * HTML Sanitization utilities to prevent XSS attacks
  */
+import { createSanitizeHtmlConfig, FORBID_TAGS, stripSvgDataUrls } from '@cio/utils/functions';
 import DOMPurify from 'dompurify';
 
 const browser = typeof window !== 'undefined' && typeof window.document !== 'undefined';
@@ -17,77 +18,10 @@ export function sanitizeHtml(html: string): string {
     return fallbackSanitize(html);
   }
 
-  let sanitized = DOMPurify.sanitize(html, {
-    // Allow safe HTML tags
-    ALLOWED_TAGS: [
-      'p',
-      'br',
-      'strong',
-      'b',
-      'em',
-      'i',
-      'u',
-      'span',
-      'div',
-      'h1',
-      'h2',
-      'h3',
-      'h4',
-      'h5',
-      'h6',
-      'ul',
-      'ol',
-      'li',
-      'blockquote',
-      'pre',
-      'code',
-      'a',
-      'img'
-    ],
-    // Allow safe attributes
-    ALLOWED_ATTR: ['href', 'src', 'alt', 'title', 'class', 'style', 'data-type', 'data-latex'],
-    // Forbid dangerous attributes
-    FORBID_ATTR: [
-      'onerror',
-      'onload',
-      'onclick',
-      'onmouseover',
-      'onfocus',
-      'onblur',
-      'onchange',
-      'onsubmit',
-      'onreset',
-      'onselect',
-      'onunload'
-    ],
-    // Forbid dangerous tags (including svg)
-    FORBID_TAGS: [
-      'script',
-      'iframe',
-      'object',
-      'embed',
-      'form',
-      'input',
-      'textarea',
-      'select',
-      'button',
-      'meta',
-      'link',
-      'svg',
-      'math'
-    ],
-    // Keep content of forbidden tags
-    KEEP_CONTENT: true,
-    // Sanitize attributes
-    SANITIZE_DOM: true,
-    // Allow data attributes
-    ALLOW_DATA_ATTR: false,
-    // Transform URLs and filter dangerous protocols
-    ALLOWED_URI_REGEXP: /^(?:(?:(?:f|ht)tps?|mailto|tel|callto|sms|cid|xmpp):|[^a-z]|[a-z+.\-]+(?:[^a-z+.\-:]|$))/i
-  });
+  let sanitized = String(DOMPurify.sanitize(html, createSanitizeHtmlConfig()));
 
   // Additional post-processing to remove any SVG data URLs that might have slipped through
-  sanitized = sanitized.replace(/src\s*=\s*["']data:image\/svg[^"']*["']/gi, 'src=""');
+  sanitized = stripSvgDataUrls(sanitized);
 
   return sanitized;
 }
@@ -125,20 +59,7 @@ function fallbackSanitize(html: string): string {
   html = html.replace(/expression\s*\(/gi, '');
 
   // Remove dangerous tags
-  const dangerousTags = [
-    'script',
-    'iframe',
-    'object',
-    'embed',
-    'form',
-    'input',
-    'textarea',
-    'select',
-    'button',
-    'svg',
-    'math'
-  ];
-  dangerousTags.forEach((tag) => {
+  FORBID_TAGS.forEach((tag: string) => {
     const regex = new RegExp(`<${tag}\\b[^>]*>.*?<\\/${tag}>`, 'gi');
     html = html.replace(regex, '');
     const selfClosing = new RegExp(`<${tag}\\b[^>]*\\/>`, 'gi');
diff --git a/packages/ui/tsconfig.json b/packages/ui/tsconfig.json
index bd3189a1..617c779d 100644
--- a/packages/ui/tsconfig.json
+++ b/packages/ui/tsconfig.json
@@ -5,7 +5,9 @@
     "baseUrl": ".",
     "paths": {
       "$src": ["./src"],
-      "$src/*": ["./src/*"]
+      "$src/*": ["./src/*"],
+      "@cio/utils": ["./node_modules/@cio/utils/dist/index.ts"],
+      "@cio/utils/*": ["./node_modules/@cio/utils/dist/*"]
     },
     "allowJs": true,
     "checkJs": true,
diff --git a/packages/utils/src/functions/index.ts b/packages/utils/src/functions/index.ts
index da9cd59d..10654eee 100644
--- a/packages/utils/src/functions/index.ts
+++ b/packages/utils/src/functions/index.ts
@@ -1,3 +1,4 @@
 export * from './array';
 export * from './fileValidation';
+export * from './sanitize';
 export * from './slug';
diff --git a/packages/utils/src/functions/sanitize.ts b/packages/utils/src/functions/sanitize.ts
new file mode 100644
index 00000000..405e5c05
--- /dev/null
+++ b/packages/utils/src/functions/sanitize.ts
@@ -0,0 +1,50 @@
+export const FORBID_TAGS = [
+  'script',
+  'iframe',
+  'object',
+  'embed',
+  'form',
+  'input',
+  'textarea',
+  'select',
+  'button',
+  'meta',
+  'link',
+  'svg',
+  'math'
+] as const;
+
+export const FORBID_ATTR = [
+  'onerror',
+  'onload',
+  'onclick',
+  'onmouseover',
+  'onfocus',
+  'onblur',
+  'onchange',
+  'onsubmit',
+  'onreset',
+  'onselect',
+  'onunload'
+] as const;
+
+export const ADD_ATTR = ['data-type', 'data-latex', 'colwidth'] as const;
+
+export const ALLOWED_URI_REGEXP =
+  /^(?:(?:(?:f|ht)tps?|mailto|tel|callto|sms|cid|xmpp):|[^a-z]|[a-z+.\-]+(?:[^a-z+.\-:]|$))/i;
+
+export function createSanitizeHtmlConfig() {
+  return {
+    FORBID_TAGS: [...FORBID_TAGS],
+    FORBID_ATTR: [...FORBID_ATTR],
+    ADD_ATTR: [...ADD_ATTR],
+    KEEP_CONTENT: true,
+    SANITIZE_DOM: true,
+    ALLOW_DATA_ATTR: false,
+    ALLOWED_URI_REGEXP
+  };
+}
+
+export function stripSvgDataUrls(html: string): string {
+  return html.replace(/src\s*=\s*["']data:image\/svg[^"']*["']/gi, 'src=""');
+}
diff --git a/packages/utils/src/validation/course/course.ts b/packages/utils/src/validation/course/course.ts
index fe956b0a..2c5dce0c 100644
--- a/packages/utils/src/validation/course/course.ts
+++ b/packages/utils/src/validation/course/course.ts
@@ -279,6 +279,18 @@ export const ZCourseLandingPageMetadataUpdate = z.object({
 });
 export type TCourseLandingPageMetadataUpdate = z.infer<typeof ZCourseLandingPageMetadataUpdate>;
 
+export const ZCertificationSettings = z.object({
+  isDownloadable: z.boolean().optional(),
+  theme: z.string().optional(),
+  /** ISO 8601 datetime string or null to clear */
+  deadline: z.union([z.string().min(1), z.null()]).optional(),
+  threshold: z.number().int().min(0).max(100).optional(),
+  requiredExerciseId: z.union([z.string().uuid(), z.null()]).optional(),
+  exerciseMinScorePercent: z.number().int().min(0).max(100).nullable().optional(),
+  emailMessage: z.string().max(5000).nullable().optional()
+});
+export type TCertificationSettings = z.infer<typeof ZCertificationSettings>;
+
 export const ZCourseUpdate = z.object({
   title: z.string().min(1).optional(),
   description: z.string().min(1).optional(),
@@ -290,8 +302,7 @@ export const ZCourseUpdate = z.object({
   metadata: ZCourseMetadata.optional(),
   cost: z.number().int().min(0).optional(),
   currency: z.enum(['NGN', 'USD']).optional(),
-  isCertificateDownloadable: z.boolean().optional(),
-  certificateTheme: z.string().optional(),
+  certificate: ZCertificationSettings.optional(),
   tagIds: z.array(z.uuid()).max(100).optional()
 });
 export type TCourseUpdate = z.infer<typeof ZCourseUpdate>;
diff --git a/packages/utils/src/validation/exercise/exercise.ts b/packages/utils/src/validation/exercise/exercise.ts
index 85a34349..db8f460c 100644
--- a/packages/utils/src/validation/exercise/exercise.ts
+++ b/packages/utils/src/validation/exercise/exercise.ts
@@ -155,6 +155,7 @@ export const ZExerciseUpdate = z.object({
   order: z.number().int().optional(),
   isUnlocked: z.boolean().optional(),
   dueBy: z.string().optional(), // Changed from iso.datetime() to string to match frontend format
+  allowMultipleAttempts: z.boolean().optional(),
   questions: z.array(ZExerciseUpdateQuestion).optional()
 });
 export type TExerciseUpdate = z.infer<typeof ZExerciseUpdate>;
diff --git a/packages/utils/src/validation/organization/audience.ts b/packages/utils/src/validation/organization/audience.ts
index afc3bc0b..925a3d50 100644
--- a/packages/utils/src/validation/organization/audience.ts
+++ b/packages/utils/src/validation/organization/audience.ts
@@ -1,5 +1,20 @@
 import * as z from 'zod';
 
+export const AudienceSortBy = z.enum(['createdAt', 'name', 'email']);
+export const AudienceSortOrder = z.enum(['asc', 'desc']);
+
+export const ZGetAudienceQuery = z.object({
+  page: z.coerce.number().int().min(1).default(1),
+  limit: z.coerce.number().int().min(1).max(100).default(20),
+  search: z.string().trim().optional(),
+  sortBy: AudienceSortBy.default('createdAt'),
+  sortOrder: AudienceSortOrder.default('desc')
+});
+
+export type TAudienceSortBy = z.infer<typeof AudienceSortBy>;
+export type TAudienceSortOrder = z.infer<typeof AudienceSortOrder>;
+export type TGetAudienceQuery = z.infer<typeof ZGetAudienceQuery>;
+
 export const ZImportAudienceMembers = z.object({
   recipientCsv: z.string().max(25000),
   courseIds: z.array(z.string().uuid()).optional(),
diff --git a/pnpm-lock.yaml b/pnpm-lock.yaml
index 515ead28..de9a8806 100644
--- a/pnpm-lock.yaml
+++ b/pnpm-lock.yaml
@@ -98,6 +98,9 @@ importers:
       hono-rate-limiter:
         specifier: ^0.4.2
         version: 0.4.2(hono@4.11.3)
+      isomorphic-dompurify:
+        specifier: ^3.7.1
+        version: 3.7.1(@noble/hashes@2.0.1)
       katex:
         specifier: ^0.16.10
         version: 0.16.27
@@ -131,7 +134,7 @@ importers:
         version: 7.0.1(eslint@9.39.2(jiti@2.6.1))(typescript@5.9.3)
       '@vitest/coverage-v8':
         specifier: ^1.2.2
-        version: 1.6.1(vitest@1.6.1(@types/node@20.19.27)(jsdom@26.1.0(bufferutil@4.1.0)(utf-8-validate@6.0.6))(lightningcss@1.31.1)(sass@1.97.1))
+        version: 1.6.1(vitest@1.6.1(@types/node@20.19.27)(jsdom@29.0.1(@noble/hashes@2.0.1))(lightningcss@1.31.1)(sass@1.97.1))
       eslint:
         specifier: ^9.31.0
         version: 9.39.2(jiti@2.6.1)
@@ -152,7 +155,7 @@ importers:
         version: 5.9.3
       vitest:
         specifier: ^1.2.2
-        version: 1.6.1(@types/node@20.19.27)(jsdom@26.1.0(bufferutil@4.1.0)(utf-8-validate@6.0.6))(lightningcss@1.31.1)(sass@1.97.1)
+        version: 1.6.1(@types/node@20.19.27)(jsdom@29.0.1(@noble/hashes@2.0.1))(lightningcss@1.31.1)(sass@1.97.1)
       wrangler:
         specifier: 4.21.x
         version: 4.21.2(@cloudflare/workers-types@4.20260313.1)(bufferutil@4.1.0)(utf-8-validate@6.0.6)
@@ -240,13 +243,13 @@ importers:
         version: 6.4.1(@types/node@24.10.4)(jiti@2.6.1)(lightningcss@1.31.1)(sass@1.97.1)(tsx@4.21.0)(yaml@2.8.2)
       vitest:
         specifier: ^2.0.4
-        version: 2.1.9(@types/node@24.10.4)(jsdom@26.1.0(bufferutil@4.1.0)(utf-8-validate@6.0.6))(lightningcss@1.31.1)(sass@1.97.1)
+        version: 2.1.9(@types/node@24.10.4)(jsdom@29.0.1(@noble/hashes@2.0.1))(lightningcss@1.31.1)(sass@1.97.1)
 
   apps/dashboard:
     dependencies:
       '@better-auth/sso':
         specifier: 1.4.18
-        version: 1.4.18(@better-auth/utils@0.3.0)(better-auth@1.4.18(@sveltejs/kit@2.49.2(@sveltejs/vite-plugin-svelte@4.0.4(svelte@5.46.0)(vite@5.4.21(@types/node@20.19.27)(lightningcss@1.31.1)(sass@1.97.1)))(svelte@5.46.0)(vite@5.4.21(@types/node@20.19.27)(lightningcss@1.31.1)(sass@1.97.1)))(@tanstack/react-start@1.143.4(crossws@0.4.1(srvx@0.9.8))(react-dom@19.2.3(react@19.2.3))(react@19.2.3)(vite@5.4.21(@types/node@20.19.27)(lightningcss@1.31.1)(sass@1.97.1)))(drizzle-kit@0.31.8)(drizzle-orm@0.44.7(@cloudflare/workers-types@4.20260313.1)(@types/pg@8.16.0)(kysely@0.28.9)(pg@8.18.0)(postgres@3.4.7))(pg@8.18.0)(react-dom@19.2.3(react@19.2.3))(react@19.2.3)(solid-js@1.9.10)(svelte@5.46.0)(vitest@2.1.9(@types/node@20.19.27)(jsdom@26.1.0(bufferutil@4.1.0)(utf-8-validate@6.0.6))(lightningcss@1.31.1)(sass@1.97.1))(vue@3.5.26(typescript@5.9.3)))
+        version: 1.4.18(@better-auth/utils@0.3.0)(better-auth@1.4.18(@sveltejs/kit@2.49.2(@sveltejs/vite-plugin-svelte@4.0.4(svelte@5.46.0)(vite@5.4.21(@types/node@20.19.27)(lightningcss@1.31.1)(sass@1.97.1)))(svelte@5.46.0)(vite@5.4.21(@types/node@20.19.27)(lightningcss@1.31.1)(sass@1.97.1)))(@tanstack/react-start@1.143.4(crossws@0.4.1(srvx@0.9.8))(react-dom@19.2.3(react@19.2.3))(react@19.2.3)(vite@5.4.21(@types/node@20.19.27)(lightningcss@1.31.1)(sass@1.97.1)))(drizzle-kit@0.31.8)(drizzle-orm@0.44.7(@cloudflare/workers-types@4.20260313.1)(@types/pg@8.16.0)(kysely@0.28.9)(pg@8.18.0)(postgres@3.4.7))(pg@8.18.0)(react-dom@19.2.3(react@19.2.3))(react@19.2.3)(solid-js@1.9.10)(svelte@5.46.0)(vitest@2.1.9(@types/node@20.19.27)(jsdom@29.0.1(@noble/hashes@2.0.1))(lightningcss@1.31.1)(sass@1.97.1))(vue@3.5.26(typescript@5.9.3)))
       '@cio/api':
         specifier: workspace:*
         version: link:../api
@@ -300,7 +303,7 @@ importers:
         version: 1.13.2
       better-auth:
         specifier: ^1.4.18
-        version: 1.4.18(@sveltejs/kit@2.49.2(@sveltejs/vite-plugin-svelte@4.0.4(svelte@5.46.0)(vite@5.4.21(@types/node@20.19.27)(lightningcss@1.31.1)(sass@1.97.1)))(svelte@5.46.0)(vite@5.4.21(@types/node@20.19.27)(lightningcss@1.31.1)(sass@1.97.1)))(@tanstack/react-start@1.143.4(crossws@0.4.1(srvx@0.9.8))(react-dom@19.2.3(react@19.2.3))(react@19.2.3)(vite@5.4.21(@types/node@20.19.27)(lightningcss@1.31.1)(sass@1.97.1)))(drizzle-kit@0.31.8)(drizzle-orm@0.44.7(@cloudflare/workers-types@4.20260313.1)(@types/pg@8.16.0)(kysely@0.28.9)(pg@8.18.0)(postgres@3.4.7))(pg@8.18.0)(react-dom@19.2.3(react@19.2.3))(react@19.2.3)(solid-js@1.9.10)(svelte@5.46.0)(vitest@2.1.9(@types/node@20.19.27)(jsdom@26.1.0(bufferutil@4.1.0)(utf-8-validate@6.0.6))(lightningcss@1.31.1)(sass@1.97.1))(vue@3.5.26(typescript@5.9.3))
+        version: 1.4.18(@sveltejs/kit@2.49.2(@sveltejs/vite-plugin-svelte@4.0.4(svelte@5.46.0)(vite@5.4.21(@types/node@20.19.27)(lightningcss@1.31.1)(sass@1.97.1)))(svelte@5.46.0)(vite@5.4.21(@types/node@20.19.27)(lightningcss@1.31.1)(sass@1.97.1)))(@tanstack/react-start@1.143.4(crossws@0.4.1(srvx@0.9.8))(react-dom@19.2.3(react@19.2.3))(react@19.2.3)(vite@5.4.21(@types/node@20.19.27)(lightningcss@1.31.1)(sass@1.97.1)))(drizzle-kit@0.31.8)(drizzle-orm@0.44.7(@cloudflare/workers-types@4.20260313.1)(@types/pg@8.16.0)(kysely@0.28.9)(pg@8.18.0)(postgres@3.4.7))(pg@8.18.0)(react-dom@19.2.3(react@19.2.3))(react@19.2.3)(solid-js@1.9.10)(svelte@5.46.0)(vitest@2.1.9(@types/node@20.19.27)(jsdom@29.0.1(@noble/hashes@2.0.1))(lightningcss@1.31.1)(sass@1.97.1))(vue@3.5.26(typescript@5.9.3))
       bits-ui:
         specifier: ^2.14.4
         version: 2.14.4(@internationalized/date@3.10.1)(@sveltejs/kit@2.49.2(@sveltejs/vite-plugin-svelte@4.0.4(svelte@5.46.0)(vite@5.4.21(@types/node@20.19.27)(lightningcss@1.31.1)(sass@1.97.1)))(svelte@5.46.0)(vite@5.4.21(@types/node@20.19.27)(lightningcss@1.31.1)(sass@1.97.1)))(svelte@5.46.0)
@@ -602,7 +605,7 @@ importers:
         version: 5.1.2(vite@7.3.0(@types/node@24.10.4)(jiti@2.6.1)(lightningcss@1.31.1)(sass@1.97.1)(tsx@4.21.0)(yaml@2.8.2))
       nitro:
         specifier: 3.0.1-alpha.1
-        version: 3.0.1-alpha.1(chokidar@4.0.3)(drizzle-orm@0.44.7(@cloudflare/workers-types@4.20260313.1)(@types/pg@8.16.0)(kysely@0.28.9)(pg@8.18.0)(postgres@3.4.7))(ioredis@5.8.2)(lru-cache@11.2.4)(rollup@4.54.0)(vite@7.3.0(@types/node@24.10.4)(jiti@2.6.1)(lightningcss@1.31.1)(sass@1.97.1)(tsx@4.21.0)(yaml@2.8.2))
+        version: 3.0.1-alpha.1(chokidar@4.0.3)(drizzle-orm@0.44.7(@cloudflare/workers-types@4.20260313.1)(@types/pg@8.16.0)(kysely@0.28.9)(pg@8.18.0)(postgres@3.4.7))(ioredis@5.8.2)(lru-cache@11.2.7)(rollup@4.54.0)(vite@7.3.0(@types/node@24.10.4)(jiti@2.6.1)(lightningcss@1.31.1)(sass@1.97.1)(tsx@4.21.0)(yaml@2.8.2))
       tailwindcss:
         specifier: ^4.1.16
         version: 4.1.18
@@ -821,7 +824,7 @@ importers:
     dependencies:
       '@better-auth/sso':
         specifier: ^1.4.18
-        version: 1.4.18(@better-auth/utils@0.3.0)(better-auth@1.4.18(@sveltejs/kit@2.49.2(@sveltejs/vite-plugin-svelte@6.2.1(svelte@5.46.0)(vite@7.3.0(@types/node@24.10.4)(jiti@2.6.1)(lightningcss@1.31.1)(sass@1.97.1)(tsx@4.21.0)(yaml@2.8.2)))(svelte@5.46.0)(vite@7.3.0(@types/node@24.10.4)(jiti@2.6.1)(lightningcss@1.31.1)(sass@1.97.1)(tsx@4.21.0)(yaml@2.8.2)))(@tanstack/react-start@1.143.4(crossws@0.4.1(srvx@0.9.8))(react-dom@19.2.3(react@19.2.3))(react@19.2.3)(vite@7.3.0(@types/node@24.10.4)(jiti@2.6.1)(lightningcss@1.31.1)(sass@1.97.1)(tsx@4.21.0)(yaml@2.8.2)))(drizzle-kit@0.31.8)(drizzle-orm@0.44.7(@cloudflare/workers-types@4.20260313.1)(@types/pg@8.16.0)(kysely@0.28.9)(pg@8.18.0)(postgres@3.4.7))(pg@8.18.0)(react-dom@19.2.3(react@19.2.3))(react@19.2.3)(solid-js@1.9.10)(svelte@5.46.0)(vitest@2.1.9(@types/node@24.10.4)(jsdom@26.1.0(bufferutil@4.1.0)(utf-8-validate@6.0.6))(lightningcss@1.31.1)(sass@1.97.1))(vue@3.5.26(typescript@5.9.3)))
+        version: 1.4.18(@better-auth/utils@0.3.0)(better-auth@1.4.18(@sveltejs/kit@2.49.2(@sveltejs/vite-plugin-svelte@6.2.1(svelte@5.46.0)(vite@7.3.0(@types/node@24.10.4)(jiti@2.6.1)(lightningcss@1.31.1)(sass@1.97.1)(tsx@4.21.0)(yaml@2.8.2)))(svelte@5.46.0)(vite@7.3.0(@types/node@24.10.4)(jiti@2.6.1)(lightningcss@1.31.1)(sass@1.97.1)(tsx@4.21.0)(yaml@2.8.2)))(@tanstack/react-start@1.143.4(crossws@0.4.1(srvx@0.9.8))(react-dom@19.2.3(react@19.2.3))(react@19.2.3)(vite@7.3.0(@types/node@24.10.4)(jiti@2.6.1)(lightningcss@1.31.1)(sass@1.97.1)(tsx@4.21.0)(yaml@2.8.2)))(drizzle-kit@0.31.8)(drizzle-orm@0.44.7(@cloudflare/workers-types@4.20260313.1)(@types/pg@8.16.0)(kysely@0.28.9)(pg@8.18.0)(postgres@3.4.7))(pg@8.18.0)(react-dom@19.2.3(react@19.2.3))(react@19.2.3)(solid-js@1.9.10)(svelte@5.46.0)(vitest@2.1.9(@types/node@24.10.4)(jsdom@29.0.1(@noble/hashes@2.0.1))(lightningcss@1.31.1)(sass@1.97.1))(vue@3.5.26(typescript@5.9.3)))
       '@cio/email':
         specifier: workspace:*
         version: link:../email
@@ -839,7 +842,7 @@ importers:
         version: 6.0.0
       better-auth:
         specifier: ^1.4.18
-        version: 1.4.18(@sveltejs/kit@2.49.2(@sveltejs/vite-plugin-svelte@6.2.1(svelte@5.46.0)(vite@7.3.0(@types/node@24.10.4)(jiti@2.6.1)(lightningcss@1.31.1)(sass@1.97.1)(tsx@4.21.0)(yaml@2.8.2)))(svelte@5.46.0)(vite@7.3.0(@types/node@24.10.4)(jiti@2.6.1)(lightningcss@1.31.1)(sass@1.97.1)(tsx@4.21.0)(yaml@2.8.2)))(@tanstack/react-start@1.143.4(crossws@0.4.1(srvx@0.9.8))(react-dom@19.2.3(react@19.2.3))(react@19.2.3)(vite@7.3.0(@types/node@24.10.4)(jiti@2.6.1)(lightningcss@1.31.1)(sass@1.97.1)(tsx@4.21.0)(yaml@2.8.2)))(drizzle-kit@0.31.8)(drizzle-orm@0.44.7(@cloudflare/workers-types@4.20260313.1)(@types/pg@8.16.0)(kysely@0.28.9)(pg@8.18.0)(postgres@3.4.7))(pg@8.18.0)(react-dom@19.2.3(react@19.2.3))(react@19.2.3)(solid-js@1.9.10)(svelte@5.46.0)(vitest@2.1.9(@types/node@24.10.4)(jsdom@26.1.0(bufferutil@4.1.0)(utf-8-validate@6.0.6))(lightningcss@1.31.1)(sass@1.97.1))(vue@3.5.26(typescript@5.9.3))
+        version: 1.4.18(@sveltejs/kit@2.49.2(@sveltejs/vite-plugin-svelte@6.2.1(svelte@5.46.0)(vite@7.3.0(@types/node@24.10.4)(jiti@2.6.1)(lightningcss@1.31.1)(sass@1.97.1)(tsx@4.21.0)(yaml@2.8.2)))(svelte@5.46.0)(vite@7.3.0(@types/node@24.10.4)(jiti@2.6.1)(lightningcss@1.31.1)(sass@1.97.1)(tsx@4.21.0)(yaml@2.8.2)))(@tanstack/react-start@1.143.4(crossws@0.4.1(srvx@0.9.8))(react-dom@19.2.3(react@19.2.3))(react@19.2.3)(vite@7.3.0(@types/node@24.10.4)(jiti@2.6.1)(lightningcss@1.31.1)(sass@1.97.1)(tsx@4.21.0)(yaml@2.8.2)))(drizzle-kit@0.31.8)(drizzle-orm@0.44.7(@cloudflare/workers-types@4.20260313.1)(@types/pg@8.16.0)(kysely@0.28.9)(pg@8.18.0)(postgres@3.4.7))(pg@8.18.0)(react-dom@19.2.3(react@19.2.3))(react@19.2.3)(solid-js@1.9.10)(svelte@5.46.0)(vitest@2.1.9(@types/node@24.10.4)(jsdom@29.0.1(@noble/hashes@2.0.1))(lightningcss@1.31.1)(sass@1.97.1))(vue@3.5.26(typescript@5.9.3))
       drizzle-kit:
         specifier: ^0.31.8
         version: 0.31.8
@@ -957,7 +960,7 @@ importers:
         version: 5.9.3
       vitest:
         specifier: ^1.2.2
-        version: 1.6.1(@types/node@24.10.4)(jsdom@26.1.0(bufferutil@4.1.0)(utf-8-validate@6.0.6))(lightningcss@1.31.1)(sass@1.97.1)
+        version: 1.6.1(@types/node@24.10.4)(jsdom@29.0.1(@noble/hashes@2.0.1))(lightningcss@1.31.1)(sass@1.97.1)
 
   packages/storybook:
     dependencies:
@@ -1045,6 +1048,9 @@ importers:
       '@cio/question-types':
         specifier: workspace:*
         version: link:../question-types
+      '@cio/utils':
+        specifier: workspace:*
+        version: link:../utils
       '@floating-ui/dom':
         specifier: ^1.7.4
         version: 1.7.4
@@ -1268,6 +1274,17 @@ packages:
   '@asamuzakjp/css-color@3.2.0':
     resolution: {integrity: sha512-K1A6z8tS3XsmCMM86xoWdn7Fkdn9m6RSVtocUrJYIwZnFVkng/PvkEoWtOWmP+Scc6saYWHWZYbndEEXxl24jw==}
 
+  '@asamuzakjp/css-color@5.0.1':
+    resolution: {integrity: sha512-2SZFvqMyvboVV1d15lMf7XiI3m7SDqXUuKaTymJYLN6dSGadqp+fVojqJlVoMlbZnlTmu3S0TLwLTJpvBMO1Aw==}
+    engines: {node: ^20.19.0 || ^22.12.0 || >=24.0.0}
+
+  '@asamuzakjp/dom-selector@7.0.4':
+    resolution: {integrity: sha512-jXR6x4AcT3eIrS2fSNAwJpwirOkGcd+E7F7CP3zjdTqz9B/2huHOL8YJZBgekKwLML+u7qB/6P1LXQuMScsx0w==}
+    engines: {node: ^20.19.0 || ^22.12.0 || >=24.0.0}
+
+  '@asamuzakjp/nwsapi@2.3.9':
+    resolution: {integrity: sha512-n8GuYSrI9bF7FFZ/SjhwevlHc8xaVlb/7HmHelnc/PZXBD2ZR49NnN9sMMuDdEGPeeRQ5d0hqlSlEpgCX3Wl0Q==}
+
   '@authenio/xml-encryption@2.0.2':
     resolution: {integrity: sha512-cTlrKttbrRHEw3W+0/I609A2Matj5JQaRvfLtEIGZvlN0RaPi+3ANsMeqAyCAVlH/lUIW2tmtBlSMni74lcXeg==}
     engines: {node: '>=12'}
@@ -2096,6 +2113,10 @@ packages:
   '@better-fetch/fetch@1.1.21':
     resolution: {integrity: sha512-/ImESw0sskqlVR94jB+5+Pxjf+xBwDZF/N5+y2/q4EqD7IARUTSpPfIo8uf39SYpCxyOCtbyYpUrZ3F/k0zT4A==}
 
+  '@bramus/specificity@2.4.2':
+    resolution: {integrity: sha512-ctxtJ/eA+t+6q2++vj5j7FYX3nRu311q1wfYH3xjlLOsczhlhxAg2FWNUXhpGvAw3BWo1xBcvOV6/YLc2r5FJw==}
+    hasBin: true
+
   '@cloudflare/kv-asset-handler@0.4.0':
     resolution: {integrity: sha512-+tv3z+SPp+gqTIcImN9o0hqE9xyfQjI1XD9pL6NuKjua9B1y7mNYv0S9cP+QEbA4ppVgGZEmKOvHX5G5Ei1CVA==}
     engines: {node: '>=18.0.0'}
@@ -2150,6 +2171,10 @@ packages:
     resolution: {integrity: sha512-S11EXWJyy0Mz5SYvRmY8nJYTFFd1LCNV+7cXyAgQtOOuzb4EsgfqDufL+9esx72/eLhsRdGZwaldu/h+E4t4BA==}
     engines: {node: '>=18'}
 
+  '@csstools/color-helpers@6.0.2':
+    resolution: {integrity: sha512-LMGQLS9EuADloEFkcTBR3BwV/CGHV7zyDxVRtVDTwdI2Ca4it0CCVTT9wCkxSgokjE5Ho41hEPgb8OEUwoXr6Q==}
+    engines: {node: '>=20.19.0'}
+
   '@csstools/css-calc@2.1.4':
     resolution: {integrity: sha512-3N8oaj+0juUw/1H3YwmDDJXCgTB1gKU6Hc/bB502u9zR0q2vd786XJH9QfrKIEgFlZmhZiq6epXl4rHqhzsIgQ==}
     engines: {node: '>=18'}
@@ -2157,6 +2182,13 @@ packages:
       '@csstools/css-parser-algorithms': ^3.0.5
       '@csstools/css-tokenizer': ^3.0.4
 
+  '@csstools/css-calc@3.1.1':
+    resolution: {integrity: sha512-HJ26Z/vmsZQqs/o3a6bgKslXGFAungXGbinULZO3eMsOyNJHeBBZfup5FiZInOghgoM4Hwnmw+OgbJCNg1wwUQ==}
+    engines: {node: '>=20.19.0'}
+    peerDependencies:
+      '@csstools/css-parser-algorithms': ^4.0.0
+      '@csstools/css-tokenizer': ^4.0.0
+
   '@csstools/css-color-parser@3.1.0':
     resolution: {integrity: sha512-nbtKwh3a6xNVIp/VRuXV64yTKnb1IjTAEEh3irzS+HkKjAOYLTGNb9pmVNntZ8iVBHcWDA2Dof0QtPgFI1BaTA==}
     engines: {node: '>=18'}
@@ -2164,16 +2196,41 @@ packages:
       '@csstools/css-parser-algorithms': ^3.0.5
       '@csstools/css-tokenizer': ^3.0.4
 
+  '@csstools/css-color-parser@4.0.2':
+    resolution: {integrity: sha512-0GEfbBLmTFf0dJlpsNU7zwxRIH0/BGEMuXLTCvFYxuL1tNhqzTbtnFICyJLTNK4a+RechKP75e7w42ClXSnJQw==}
+    engines: {node: '>=20.19.0'}
+    peerDependencies:
+      '@csstools/css-parser-algorithms': ^4.0.0
+      '@csstools/css-tokenizer': ^4.0.0
+
   '@csstools/css-parser-algorithms@3.0.5':
     resolution: {integrity: sha512-DaDeUkXZKjdGhgYaHNJTV9pV7Y9B3b644jCLs9Upc3VeNGg6LWARAT6O+Q+/COo+2gg/bM5rhpMAtf70WqfBdQ==}
     engines: {node: '>=18'}
     peerDependencies:
       '@csstools/css-tokenizer': ^3.0.4
 
+  '@csstools/css-parser-algorithms@4.0.0':
+    resolution: {integrity: sha512-+B87qS7fIG3L5h3qwJ/IFbjoVoOe/bpOdh9hAjXbvx0o8ImEmUsGXN0inFOnk2ChCFgqkkGFQ+TpM5rbhkKe4w==}
+    engines: {node: '>=20.19.0'}
+    peerDependencies:
+      '@csstools/css-tokenizer': ^4.0.0
+
+  '@csstools/css-syntax-patches-for-csstree@1.1.2':
+    resolution: {integrity: sha512-5GkLzz4prTIpoyeUiIu3iV6CSG3Plo7xRVOFPKI7FVEJ3mZ0A8SwK0XU3Gl7xAkiQ+mDyam+NNp875/C5y+jSA==}
+    peerDependencies:
+      css-tree: ^3.2.1
+    peerDependenciesMeta:
+      css-tree:
+        optional: true
+
   '@csstools/css-tokenizer@3.0.4':
     resolution: {integrity: sha512-Vd/9EVDiu6PPJt9yAh6roZP6El1xHrdvIVGjyBsHR0RYwNHgL7FJPyIIW4fANJNG6FtyZfvlRPpFI4ZM/lubvw==}
     engines: {node: '>=18'}
 
+  '@csstools/css-tokenizer@4.0.0':
+    resolution: {integrity: sha512-QxULHAm7cNu72w97JUNCBFODFaXpbDg+dP8b/oWFAZ2MTRppA3U00Y2L1HqaS4J6yBqxwa/Y3nMBaxVKbB/NsA==}
+    engines: {node: '>=20.19.0'}
+
   '@dagrejs/dagre@1.1.8':
     resolution: {integrity: sha512-5SEDlndt4W/LaVzPYJW+bSmSEZc9EzTf8rJ20WCKvjS5EAZAN0b+x0Yww7VMT4R3Wootkg+X9bUfUxazYw6Blw==}
 
@@ -3128,6 +3185,15 @@ packages:
     os: [darwin, linux, win32]
     hasBin: true
 
+  '@exodus/bytes@1.15.0':
+    resolution: {integrity: sha512-UY0nlA+feH81UGSHv92sLEPLCeZFjXOuHhrIo0HQydScuQc8s0A7kL/UdgwgDq8g8ilksmuoF35YVTNphV2aBQ==}
+    engines: {node: ^20.19.0 || ^22.12.0 || >=24.0.0}
+    peerDependencies:
+      '@noble/hashes': ^1.8.0 || ^2.0.0
+    peerDependenciesMeta:
+      '@noble/hashes':
+        optional: true
+
   '@fastify/busboy@2.1.1':
     resolution: {integrity: sha512-vBZP4NlzfOlerQTnba4aqZoMhE/a9HY7HRqoOPaETQcSQuWEIyZMHGfVu6w9wGtGK5fED5qRs2DteVCjOH60sA==}
     engines: {node: '>=14'}
@@ -6658,6 +6724,9 @@ packages:
     resolution: {integrity: sha512-aVNobHnJqLiUelTaHat9DZ1qM2w0C0Eym4LPI/3JxOnSokGVdsl1T1kN7TFvsEAD8G47A6VKQ0TVHqbBnYMJlQ==}
     engines: {node: '>=12.0.0'}
 
+  bidi-js@1.0.3:
+    resolution: {integrity: sha512-RKshQI1R3YQ+n9YJz2QQ147P66ELpa1FQEg20Dk8oW9t2KgLbpDLLp9aGZ7y8WHSshDknG0bknqGw5/tyCs5tw==}
+
   binary-extensions@2.3.0:
     resolution: {integrity: sha512-Ceh+7ox5qe7LJuLHoY0feh3pHuUDHAcRUeyL2VYghZwfpkNIy/+8Ocg0a3UuSoYzavmylwuLWQOf3hl0jjMMIw==}
     engines: {node: '>=8'}
@@ -7165,6 +7234,10 @@ packages:
   css-select@5.2.2:
     resolution: {integrity: sha512-TizTzUddG/xYLA3NXodFM0fSbNizXjOKhqiQQwvhlspadZokn1KDy0NZFS0wuEubIYAV5/c1/lAr0TaaFXEXzw==}
 
+  css-tree@3.2.1:
+    resolution: {integrity: sha512-X7sjQzceUhu1u7Y/ylrRZFU2FS6LRiFVp6rKLPg23y3x3c3DOKAwuXGDp+PAGjh6CSnCjYeAul8pcT8bAl+lSA==}
+    engines: {node: ^10 || ^12.20.0 || ^14.13.0 || >=15.0.0}
+
   css-what@6.2.2:
     resolution: {integrity: sha512-u/O3vwbptzhMs3L1fQE82ZSLHQQfto5gyZzwteVIEyeaY5Fc7R4dapF/BvRoSYFeqfBk4m0V1Vafq5Pjv25wvA==}
     engines: {node: '>= 6'}
@@ -7357,6 +7430,10 @@ packages:
     resolution: {integrity: sha512-ZYP5VBHshaDAiVZxjbRVcFJpc+4xGgT0bK3vzy1HLN8jTO975HEbuYzZJcHoQEY5K1a0z8YayJkyVETa08eNTg==}
     engines: {node: '>=18'}
 
+  data-urls@7.0.0:
+    resolution: {integrity: sha512-23XHcCF+coGYevirZceTVD7NdJOqVn+49IHyxgszm+JIiHLoB2TkmPtsYkNWT1pvRSGkc35L6NHs0yHkN2SumA==}
+    engines: {node: ^20.19.0 || ^22.12.0 || >=24.0.0}
+
   date-fns@2.30.0:
     resolution: {integrity: sha512-fnULvOpxnC5/Vg3NCiWelDsLiUc9bRwAPs/+LfTLNvetFCtCTN+yQz15C/fs4AwX1R9K5GLtLfn8QW+dWisaAw==}
     engines: {node: '>=0.11'}
@@ -7584,6 +7661,9 @@ packages:
   dompurify@3.3.1:
     resolution: {integrity: sha512-qkdCKzLNtrgPFP1Vo+98FRzJnBRGe4ffyCea9IwHB1fyxPOeNTHpLKYGd4Uk9xvNoH0ZoOjwZxNptyMwqrId1Q==}
 
+  dompurify@3.3.3:
+    resolution: {integrity: sha512-Oj6pzI2+RqBfFG+qOaOLbFXLQ90ARpcGG6UePL82bJLtdsa6CYJD7nmiU8MW9nQNOtCHV3lZ/Bzq1X0QYbBZCA==}
+
   domutils@2.8.0:
     resolution: {integrity: sha512-w96Cjofp72M5IIhpjgobBimYEfoPjx1Vx0BSX9P30WBdZW2WIKU0T1Bd0kz2eNZ9ikjKgHbEyKx8BB6H1L3h3A==}
 
@@ -8557,6 +8637,10 @@ packages:
     resolution: {integrity: sha512-Y22oTqIU4uuPgEemfz7NDJz6OeKf12Lsu+QC+s3BVpda64lTiMYCyGwg5ki4vFxkMwQdeZDl2adZoqUgdFuTgQ==}
     engines: {node: '>=18'}
 
+  html-encoding-sniffer@6.0.0:
+    resolution: {integrity: sha512-CV9TW3Y3f8/wT0BRFc1/KAVQ3TUHiXmaAb6VW9vtiMFf7SLoMd1PdAc4W3KFOFETBJUb90KatHqlsZMWV+R9Gg==}
+    engines: {node: ^20.19.0 || ^22.12.0 || >=24.0.0}
+
   html-escaper@2.0.2:
     resolution: {integrity: sha512-H2iMtd0I4Mt5eYiapRdIDjp+XzelXQ0tFE4JS7YFwFevXXMmOp9myNrUvCg0D6ws8iqkRPBfKHgbwig1SmlLfg==}
 
@@ -8889,6 +8973,10 @@ packages:
   isexe@2.0.0:
     resolution: {integrity: sha512-RHxMLp9lnKHGHRng9QFhRCMbYAcVpn69smSGcq3f36xjgVVWThj4qqLbTLlq7Ssj8B+fIQ1EuCEGI2lKsyQeIw==}
 
+  isomorphic-dompurify@3.7.1:
+    resolution: {integrity: sha512-ChhzwwCm7k8h8ANiq1Vc7geCWeHGaAPusgXU5N4mu7Y2wChgn2JHvbUe6aH/XQOUG3+KV+GmqSq95MntW/V1ng==}
+    engines: {node: ^20.19.0 || ^22.13.0 || >=24.0.0}
+
   istanbul-lib-coverage@3.2.2:
     resolution: {integrity: sha512-O8dpsF+r0WV/8MNRKfnmrtCWhuKjxrq2w+jpzBL5UZKTi2LeVWnWOmWRxFlesJONmc+wLAGvKQZEOanko0LFTg==}
     engines: {node: '>=8'}
@@ -9091,9 +9179,9 @@ packages:
       canvas:
         optional: true
 
-  jsdom@26.1.0:
-    resolution: {integrity: sha512-Cvc9WUhxSMEo4McES3P7oK3QaXldCfNWp7pl2NNeiIFlCoLr3kfq9kb1fxftiwk1FLV7CvpvDfonxtzUDeSOPg==}
-    engines: {node: '>=18'}
+  jsdom@29.0.1:
+    resolution: {integrity: sha512-z6JOK5gRO7aMybVq/y/MlIpKh8JIi68FBKMUtKkK2KH/wMSRlCxQ682d08LB9fYXplyY/UXG8P4XXTScmdjApg==}
+    engines: {node: ^20.19.0 || ^22.13.0 || >=24.0.0}
     peerDependencies:
       canvas: ^3.0.0
     peerDependenciesMeta:
@@ -9444,6 +9532,10 @@ packages:
     resolution: {integrity: sha512-B5Y16Jr9LB9dHVkh6ZevG+vAbOsNOYCX+sXvFWFu7B3Iz5mijW3zdbMyhsh8ANd2mSWBYdJgnqi+mL7/LrOPYg==}
     engines: {node: 20 || >=22}
 
+  lru-cache@11.2.7:
+    resolution: {integrity: sha512-aY/R+aEsRelme17KGQa/1ZSIpLpNYYrhcrepKTZgE+W3WM16YMCaPwOHLHsmopZHELU0Ojin1lPVxKR0MihncA==}
+    engines: {node: 20 || >=22}
+
   lru-cache@5.1.1:
     resolution: {integrity: sha512-KpNARQA3Iwv+jTA0utUVVbrh+Jlrr1Fv0e56GGzAFOXN7dk/FviaDW8LHmK52DlcH4WP2n6gI8vN1aesBFgo9w==}
 
@@ -9575,6 +9667,9 @@ packages:
   mdast-util-toc@7.1.0:
     resolution: {integrity: sha512-2TVKotOQzqdY7THOdn2gGzS9d1Sdd66bvxUyw3aNpWfcPXCLYSJCCgfPy30sEtuzkDraJgqF35dzgmz6xlvH/w==}
 
+  mdn-data@2.27.1:
+    resolution: {integrity: sha512-9Yubnt3e8A0OKwxYSXyhLymGW4sCufcLG6VdiDdUGVkPhpqLxlvP5vl1983gQjJl3tqbrM731mjaZaP68AgosQ==}
+
   mdsvex@0.11.2:
     resolution: {integrity: sha512-Y4ab+vLvTJS88196Scb/RFNaHMHVSWw6CwfsgWIQP8f42D57iDII0/qABSu530V4pkv8s6T2nx3ds0MC1VwFLA==}
     peerDependencies:
@@ -10163,6 +10258,9 @@ packages:
   parse5@7.3.0:
     resolution: {integrity: sha512-IInvU7fabl34qmi9gY8XOVxhYyMyuH2xUNpb2q8/Y+7552KlejkRvqvD19nMoUW/uQGGbqNpA6Tufu5FL5BZgw==}
 
+  parse5@8.0.0:
+    resolution: {integrity: sha512-9m4m5GSgXjL4AjumKzq1Fgfp3Z8rsvjRNbnkVwfu2ImRqE5D0LnY2QfDen18FSY9C573YU5XxSapdHZTZ2WolA==}
+
   parseurl@1.3.3:
     resolution: {integrity: sha512-CiyeOxFT/JZyN5m0z9PfXw4SCBJ6Sygz1Dpl0wqjlhDEGGBP1GnsUVEL0p63hoG1fcj3fHynXi9NYO4nWOL+qQ==}
     engines: {node: '>= 0.8'}
@@ -11841,10 +11939,17 @@ packages:
   tldts-core@6.1.86:
     resolution: {integrity: sha512-Je6p7pkk+KMzMv2XXKmAE3McmolOQFdxkKw0R8EYNr7sELW46JqnNeTX8ybPiQgvg1ymCoF8LXs5fzFaZvJPTA==}
 
+  tldts-core@7.0.27:
+    resolution: {integrity: sha512-YQ7uPjgWUibIK6DW5lrKujGwUKhLevU4hcGbP5O6TcIUb+oTjJYJVWPS4nZsIHrEEEG6myk/oqAJUEQmpZrHsg==}
+
   tldts@6.1.86:
     resolution: {integrity: sha512-WMi/OQ2axVTf/ykqCQgXiIct+mSQDFdH2fkwhPwgEwvJ1kSzZRiinb0zF2Xb8u4+OqPChmyI6MEu4EezNJz+FQ==}
     hasBin: true
 
+  tldts@7.0.27:
+    resolution: {integrity: sha512-I4FZcVFcqCRuT0ph6dCDpPuO4Xgzvh+spkcTr1gK7peIvxWauoloVO0vuy1FQnijT63ss6AsHB6+OIM4aXHbPg==}
+    hasBin: true
+
   tmp@0.0.33:
     resolution: {integrity: sha512-jRCJlojKnZ3addtTOjdIqoRuPEKBvNXcGYqzO6zWZX8KfKEpnGY5jfggJQ3EjKuu8D4bJRr0y+cYJFmYbImXGw==}
     engines: {node: '>=0.6.0'}
@@ -11871,6 +11976,10 @@ packages:
     resolution: {integrity: sha512-FVDYdxtnj0G6Qm/DhNPSb8Ju59ULcup3tuJxkFb5K8Bv2pUXILbf0xZWU8PX8Ov19OXljbUyveOFwRMwkXzO+A==}
     engines: {node: '>=16'}
 
+  tough-cookie@6.0.1:
+    resolution: {integrity: sha512-LktZQb3IeoUWB9lqR5EWTHgW/VTITCXg4D21M+lvybRVdylLrRMnqaIONLVb5mav8vM19m44HIcGq4qASeu2Qw==}
+    engines: {node: '>=16'}
+
   tr46@0.0.3:
     resolution: {integrity: sha512-N3WMsuqV66lT30CrXNbEjx4GEwlow3v6rr4mCcv6prnfwhS01rkgyFdjPNBYd9br7LpXV1+Emh01fHnq2Gdgrw==}
 
@@ -11878,6 +11987,10 @@ packages:
     resolution: {integrity: sha512-hdF5ZgjTqgAntKkklYw0R03MG2x/bSzTtkxmIRw/sTNV8YXsCJ1tfLAX23lhxhHJlEf3CRCOCGGWw3vI3GaSPw==}
     engines: {node: '>=18'}
 
+  tr46@6.0.0:
+    resolution: {integrity: sha512-bLVMLPtstlZ4iMQHpFHTR7GAGj2jxi8Dg0s2h2MafAE4uSWF98FC/3MomU51iQAMf8/qDUbKWf5GxuvvVcXEhw==}
+    engines: {node: '>=20'}
+
   tree-kill@1.2.2:
     resolution: {integrity: sha512-L0Orpi8qGpRG//Nd+H90vFB+3iHnue1zSSGmNOOCh1GLJ7rUKVwV2HvijphGQS2UmhUZewS9VgvxYIdgr+fG1A==}
     hasBin: true
@@ -12120,6 +12233,10 @@ packages:
     resolution: {integrity: sha512-QEg3HPMll0o3t2ourKwOeUAZ159Kn9mx5pnzHRQO8+Wixmh88YdZRiIwat0iNzNNXn0yoEtXJqFpyW7eM8BV7g==}
     engines: {node: '>=20.18.1'}
 
+  undici@7.24.6:
+    resolution: {integrity: sha512-Xi4agocCbRzt0yYMZGMA6ApD7gvtUFaxm4ZmeacWI4cZxaF6C+8I8QfofC20NAePiB/IcvZmzkJ7XPa471AEtA==}
+    engines: {node: '>=20.18.1'}
+
   unenv@2.0.0-rc.17:
     resolution: {integrity: sha512-B06u0wXkEd+o5gOCMl/ZHl5cfpYbDZKAT+HWTL+Hws6jWu7dCiqBBXXXzMFcFVJb8D4ytAnYmxJA83uwOQRSsg==}
 
@@ -12579,6 +12696,10 @@ packages:
     resolution: {integrity: sha512-VwddBukDzu71offAQR975unBIGqfKZpM+8ZX6ySk8nYhVoo5CYaZyzt3YBvYtRtO+aoGlqxPg/B87NGVZ/fu6g==}
     engines: {node: '>=12'}
 
+  webidl-conversions@8.0.1:
+    resolution: {integrity: sha512-BMhLD/Sw+GbJC21C/UgyaZX41nPt8bUTg+jWyDeg7e7YN4xOM05YPSIXceACnXVtqyEw/LMClUQMtMZ+PGGpqQ==}
+    engines: {node: '>=20'}
+
   webpack-virtual-modules@0.6.2:
     resolution: {integrity: sha512-66/V2i5hQanC51vBQKPH4aI8NMAcBW59FVBs+rC7eGHupMyfn34q7rZIE+ETlJ+XTevqfUhVVBgSUNSW2flEUQ==}
 
@@ -12591,10 +12712,18 @@ packages:
     resolution: {integrity: sha512-QaKxh0eNIi2mE9p2vEdzfagOKHCcj1pJ56EEHGQOVxp8r9/iszLUUV7v89x9O1p/T+NlTM5W7jW6+cz4Fq1YVg==}
     engines: {node: '>=18'}
 
+  whatwg-mimetype@5.0.0:
+    resolution: {integrity: sha512-sXcNcHOC51uPGF0P/D4NVtrkjSU2fNsm9iog4ZvZJsL3rjoDAzXZhkm2MWt1y+PUdggKAYVoMAIYcs78wJ51Cw==}
+    engines: {node: '>=20'}
+
   whatwg-url@14.2.0:
     resolution: {integrity: sha512-De72GdQZzNTUBBChsXueQUnPKDkg/5A5zp7pFDuQAj5UFoENpiACU0wlCvzpAGnTkj++ihpKwKyYewn/XNUbKw==}
     engines: {node: '>=18'}
 
+  whatwg-url@16.0.1:
+    resolution: {integrity: sha512-1to4zXBxmXHV3IiSSEInrreIlu02vUOvrhxJJH5vcxYTBDAx51cqZiKdyTxlecdKNSjj8EcxGBxNf6Vg+945gw==}
+    engines: {node: ^20.19.0 || ^22.12.0 || >=24.0.0}
+
   whatwg-url@5.0.0:
     resolution: {integrity: sha512-saE57nupxk6v3HY35+jzBwYa0rKSy0XR8JSxZPwgLr7ys0IBzhGviA1/TUGJLmSVqs8pb9AnvICXEuOHLprYTw==}
 
@@ -12843,6 +12972,24 @@ snapshots:
       '@csstools/css-tokenizer': 3.0.4
       lru-cache: 10.4.3
 
+  '@asamuzakjp/css-color@5.0.1':
+    dependencies:
+      '@csstools/css-calc': 3.1.1(@csstools/css-parser-algorithms@4.0.0(@csstools/css-tokenizer@4.0.0))(@csstools/css-tokenizer@4.0.0)
+      '@csstools/css-color-parser': 4.0.2(@csstools/css-parser-algorithms@4.0.0(@csstools/css-tokenizer@4.0.0))(@csstools/css-tokenizer@4.0.0)
+      '@csstools/css-parser-algorithms': 4.0.0(@csstools/css-tokenizer@4.0.0)
+      '@csstools/css-tokenizer': 4.0.0
+      lru-cache: 11.2.7
+
+  '@asamuzakjp/dom-selector@7.0.4':
+    dependencies:
+      '@asamuzakjp/nwsapi': 2.3.9
+      bidi-js: 1.0.3
+      css-tree: 3.2.1
+      is-potential-custom-element-name: 1.0.1
+      lru-cache: 11.2.7
+
+  '@asamuzakjp/nwsapi@2.3.9': {}
+
   '@authenio/xml-encryption@2.0.2':
     dependencies:
       '@xmldom/xmldom': 0.8.11
@@ -14199,21 +14346,21 @@ snapshots:
       nanostores: 1.1.0
       zod: 4.3.6
 
-  '@better-auth/sso@1.4.18(@better-auth/utils@0.3.0)(better-auth@1.4.18(@sveltejs/kit@2.49.2(@sveltejs/vite-plugin-svelte@4.0.4(svelte@5.46.0)(vite@5.4.21(@types/node@20.19.27)(lightningcss@1.31.1)(sass@1.97.1)))(svelte@5.46.0)(vite@5.4.21(@types/node@20.19.27)(lightningcss@1.31.1)(sass@1.97.1)))(@tanstack/react-start@1.143.4(crossws@0.4.1(srvx@0.9.8))(react-dom@19.2.3(react@19.2.3))(react@19.2.3)(vite@5.4.21(@types/node@20.19.27)(lightningcss@1.31.1)(sass@1.97.1)))(drizzle-kit@0.31.8)(drizzle-orm@0.44.7(@cloudflare/workers-types@4.20260313.1)(@types/pg@8.16.0)(kysely@0.28.9)(pg@8.18.0)(postgres@3.4.7))(pg@8.18.0)(react-dom@19.2.3(react@19.2.3))(react@19.2.3)(solid-js@1.9.10)(svelte@5.46.0)(vitest@2.1.9(@types/node@20.19.27)(jsdom@26.1.0(bufferutil@4.1.0)(utf-8-validate@6.0.6))(lightningcss@1.31.1)(sass@1.97.1))(vue@3.5.26(typescript@5.9.3)))':
+  '@better-auth/sso@1.4.18(@better-auth/utils@0.3.0)(better-auth@1.4.18(@sveltejs/kit@2.49.2(@sveltejs/vite-plugin-svelte@4.0.4(svelte@5.46.0)(vite@5.4.21(@types/node@20.19.27)(lightningcss@1.31.1)(sass@1.97.1)))(svelte@5.46.0)(vite@5.4.21(@types/node@20.19.27)(lightningcss@1.31.1)(sass@1.97.1)))(@tanstack/react-start@1.143.4(crossws@0.4.1(srvx@0.9.8))(react-dom@19.2.3(react@19.2.3))(react@19.2.3)(vite@5.4.21(@types/node@20.19.27)(lightningcss@1.31.1)(sass@1.97.1)))(drizzle-kit@0.31.8)(drizzle-orm@0.44.7(@cloudflare/workers-types@4.20260313.1)(@types/pg@8.16.0)(kysely@0.28.9)(pg@8.18.0)(postgres@3.4.7))(pg@8.18.0)(react-dom@19.2.3(react@19.2.3))(react@19.2.3)(solid-js@1.9.10)(svelte@5.46.0)(vitest@2.1.9(@types/node@20.19.27)(jsdom@29.0.1(@noble/hashes@2.0.1))(lightningcss@1.31.1)(sass@1.97.1))(vue@3.5.26(typescript@5.9.3)))':
     dependencies:
       '@better-auth/utils': 0.3.0
       '@better-fetch/fetch': 1.1.21
-      better-auth: 1.4.18(@sveltejs/kit@2.49.2(@sveltejs/vite-plugin-svelte@4.0.4(svelte@5.46.0)(vite@5.4.21(@types/node@20.19.27)(lightningcss@1.31.1)(sass@1.97.1)))(svelte@5.46.0)(vite@5.4.21(@types/node@20.19.27)(lightningcss@1.31.1)(sass@1.97.1)))(@tanstack/react-start@1.143.4(crossws@0.4.1(srvx@0.9.8))(react-dom@19.2.3(react@19.2.3))(react@19.2.3)(vite@5.4.21(@types/node@20.19.27)(lightningcss@1.31.1)(sass@1.97.1)))(drizzle-kit@0.31.8)(drizzle-orm@0.44.7(@cloudflare/workers-types@4.20260313.1)(@types/pg@8.16.0)(kysely@0.28.9)(pg@8.18.0)(postgres@3.4.7))(pg@8.18.0)(react-dom@19.2.3(react@19.2.3))(react@19.2.3)(solid-js@1.9.10)(svelte@5.46.0)(vitest@2.1.9(@types/node@20.19.27)(jsdom@26.1.0(bufferutil@4.1.0)(utf-8-validate@6.0.6))(lightningcss@1.31.1)(sass@1.97.1))(vue@3.5.26(typescript@5.9.3))
+      better-auth: 1.4.18(@sveltejs/kit@2.49.2(@sveltejs/vite-plugin-svelte@4.0.4(svelte@5.46.0)(vite@5.4.21(@types/node@20.19.27)(lightningcss@1.31.1)(sass@1.97.1)))(svelte@5.46.0)(vite@5.4.21(@types/node@20.19.27)(lightningcss@1.31.1)(sass@1.97.1)))(@tanstack/react-start@1.143.4(crossws@0.4.1(srvx@0.9.8))(react-dom@19.2.3(react@19.2.3))(react@19.2.3)(vite@5.4.21(@types/node@20.19.27)(lightningcss@1.31.1)(sass@1.97.1)))(drizzle-kit@0.31.8)(drizzle-orm@0.44.7(@cloudflare/workers-types@4.20260313.1)(@types/pg@8.16.0)(kysely@0.28.9)(pg@8.18.0)(postgres@3.4.7))(pg@8.18.0)(react-dom@19.2.3(react@19.2.3))(react@19.2.3)(solid-js@1.9.10)(svelte@5.46.0)(vitest@2.1.9(@types/node@20.19.27)(jsdom@29.0.1(@noble/hashes@2.0.1))(lightningcss@1.31.1)(sass@1.97.1))(vue@3.5.26(typescript@5.9.3))
       fast-xml-parser: 5.2.5
       jose: 6.1.3
       samlify: 2.10.2
       zod: 4.3.6
 
-  '@better-auth/sso@1.4.18(@better-auth/utils@0.3.0)(better-auth@1.4.18(@sveltejs/kit@2.49.2(@sveltejs/vite-plugin-svelte@6.2.1(svelte@5.46.0)(vite@7.3.0(@types/node@24.10.4)(jiti@2.6.1)(lightningcss@1.31.1)(sass@1.97.1)(tsx@4.21.0)(yaml@2.8.2)))(svelte@5.46.0)(vite@7.3.0(@types/node@24.10.4)(jiti@2.6.1)(lightningcss@1.31.1)(sass@1.97.1)(tsx@4.21.0)(yaml@2.8.2)))(@tanstack/react-start@1.143.4(crossws@0.4.1(srvx@0.9.8))(react-dom@19.2.3(react@19.2.3))(react@19.2.3)(vite@7.3.0(@types/node@24.10.4)(jiti@2.6.1)(lightningcss@1.31.1)(sass@1.97.1)(tsx@4.21.0)(yaml@2.8.2)))(drizzle-kit@0.31.8)(drizzle-orm@0.44.7(@cloudflare/workers-types@4.20260313.1)(@types/pg@8.16.0)(kysely@0.28.9)(pg@8.18.0)(postgres@3.4.7))(pg@8.18.0)(react-dom@19.2.3(react@19.2.3))(react@19.2.3)(solid-js@1.9.10)(svelte@5.46.0)(vitest@2.1.9(@types/node@24.10.4)(jsdom@26.1.0(bufferutil@4.1.0)(utf-8-validate@6.0.6))(lightningcss@1.31.1)(sass@1.97.1))(vue@3.5.26(typescript@5.9.3)))':
+  '@better-auth/sso@1.4.18(@better-auth/utils@0.3.0)(better-auth@1.4.18(@sveltejs/kit@2.49.2(@sveltejs/vite-plugin-svelte@6.2.1(svelte@5.46.0)(vite@7.3.0(@types/node@24.10.4)(jiti@2.6.1)(lightningcss@1.31.1)(sass@1.97.1)(tsx@4.21.0)(yaml@2.8.2)))(svelte@5.46.0)(vite@7.3.0(@types/node@24.10.4)(jiti@2.6.1)(lightningcss@1.31.1)(sass@1.97.1)(tsx@4.21.0)(yaml@2.8.2)))(@tanstack/react-start@1.143.4(crossws@0.4.1(srvx@0.9.8))(react-dom@19.2.3(react@19.2.3))(react@19.2.3)(vite@7.3.0(@types/node@24.10.4)(jiti@2.6.1)(lightningcss@1.31.1)(sass@1.97.1)(tsx@4.21.0)(yaml@2.8.2)))(drizzle-kit@0.31.8)(drizzle-orm@0.44.7(@cloudflare/workers-types@4.20260313.1)(@types/pg@8.16.0)(kysely@0.28.9)(pg@8.18.0)(postgres@3.4.7))(pg@8.18.0)(react-dom@19.2.3(react@19.2.3))(react@19.2.3)(solid-js@1.9.10)(svelte@5.46.0)(vitest@2.1.9(@types/node@24.10.4)(jsdom@29.0.1(@noble/hashes@2.0.1))(lightningcss@1.31.1)(sass@1.97.1))(vue@3.5.26(typescript@5.9.3)))':
     dependencies:
       '@better-auth/utils': 0.3.0
       '@better-fetch/fetch': 1.1.21
-      better-auth: 1.4.18(@sveltejs/kit@2.49.2(@sveltejs/vite-plugin-svelte@6.2.1(svelte@5.46.0)(vite@7.3.0(@types/node@24.10.4)(jiti@2.6.1)(lightningcss@1.31.1)(sass@1.97.1)(tsx@4.21.0)(yaml@2.8.2)))(svelte@5.46.0)(vite@7.3.0(@types/node@24.10.4)(jiti@2.6.1)(lightningcss@1.31.1)(sass@1.97.1)(tsx@4.21.0)(yaml@2.8.2)))(@tanstack/react-start@1.143.4(crossws@0.4.1(srvx@0.9.8))(react-dom@19.2.3(react@19.2.3))(react@19.2.3)(vite@7.3.0(@types/node@24.10.4)(jiti@2.6.1)(lightningcss@1.31.1)(sass@1.97.1)(tsx@4.21.0)(yaml@2.8.2)))(drizzle-kit@0.31.8)(drizzle-orm@0.44.7(@cloudflare/workers-types@4.20260313.1)(@types/pg@8.16.0)(kysely@0.28.9)(pg@8.18.0)(postgres@3.4.7))(pg@8.18.0)(react-dom@19.2.3(react@19.2.3))(react@19.2.3)(solid-js@1.9.10)(svelte@5.46.0)(vitest@2.1.9(@types/node@24.10.4)(jsdom@26.1.0(bufferutil@4.1.0)(utf-8-validate@6.0.6))(lightningcss@1.31.1)(sass@1.97.1))(vue@3.5.26(typescript@5.9.3))
+      better-auth: 1.4.18(@sveltejs/kit@2.49.2(@sveltejs/vite-plugin-svelte@6.2.1(svelte@5.46.0)(vite@7.3.0(@types/node@24.10.4)(jiti@2.6.1)(lightningcss@1.31.1)(sass@1.97.1)(tsx@4.21.0)(yaml@2.8.2)))(svelte@5.46.0)(vite@7.3.0(@types/node@24.10.4)(jiti@2.6.1)(lightningcss@1.31.1)(sass@1.97.1)(tsx@4.21.0)(yaml@2.8.2)))(@tanstack/react-start@1.143.4(crossws@0.4.1(srvx@0.9.8))(react-dom@19.2.3(react@19.2.3))(react@19.2.3)(vite@7.3.0(@types/node@24.10.4)(jiti@2.6.1)(lightningcss@1.31.1)(sass@1.97.1)(tsx@4.21.0)(yaml@2.8.2)))(drizzle-kit@0.31.8)(drizzle-orm@0.44.7(@cloudflare/workers-types@4.20260313.1)(@types/pg@8.16.0)(kysely@0.28.9)(pg@8.18.0)(postgres@3.4.7))(pg@8.18.0)(react-dom@19.2.3(react@19.2.3))(react@19.2.3)(solid-js@1.9.10)(svelte@5.46.0)(vitest@2.1.9(@types/node@24.10.4)(jsdom@29.0.1(@noble/hashes@2.0.1))(lightningcss@1.31.1)(sass@1.97.1))(vue@3.5.26(typescript@5.9.3))
       fast-xml-parser: 5.2.5
       jose: 6.1.3
       samlify: 2.10.2
@@ -14229,6 +14376,10 @@ snapshots:
 
   '@better-fetch/fetch@1.1.21': {}
 
+  '@bramus/specificity@2.4.2':
+    dependencies:
+      css-tree: 3.2.1
+
   '@cloudflare/kv-asset-handler@0.4.0':
     dependencies:
       mime: 3.0.0
@@ -14262,11 +14413,18 @@ snapshots:
 
   '@csstools/color-helpers@5.1.0': {}
 
+  '@csstools/color-helpers@6.0.2': {}
+
   '@csstools/css-calc@2.1.4(@csstools/css-parser-algorithms@3.0.5(@csstools/css-tokenizer@3.0.4))(@csstools/css-tokenizer@3.0.4)':
     dependencies:
       '@csstools/css-parser-algorithms': 3.0.5(@csstools/css-tokenizer@3.0.4)
       '@csstools/css-tokenizer': 3.0.4
 
+  '@csstools/css-calc@3.1.1(@csstools/css-parser-algorithms@4.0.0(@csstools/css-tokenizer@4.0.0))(@csstools/css-tokenizer@4.0.0)':
+    dependencies:
+      '@csstools/css-parser-algorithms': 4.0.0(@csstools/css-tokenizer@4.0.0)
+      '@csstools/css-tokenizer': 4.0.0
+
   '@csstools/css-color-parser@3.1.0(@csstools/css-parser-algorithms@3.0.5(@csstools/css-tokenizer@3.0.4))(@csstools/css-tokenizer@3.0.4)':
     dependencies:
       '@csstools/color-helpers': 5.1.0
@@ -14274,12 +14432,29 @@ snapshots:
       '@csstools/css-parser-algorithms': 3.0.5(@csstools/css-tokenizer@3.0.4)
       '@csstools/css-tokenizer': 3.0.4
 
+  '@csstools/css-color-parser@4.0.2(@csstools/css-parser-algorithms@4.0.0(@csstools/css-tokenizer@4.0.0))(@csstools/css-tokenizer@4.0.0)':
+    dependencies:
+      '@csstools/color-helpers': 6.0.2
+      '@csstools/css-calc': 3.1.1(@csstools/css-parser-algorithms@4.0.0(@csstools/css-tokenizer@4.0.0))(@csstools/css-tokenizer@4.0.0)
+      '@csstools/css-parser-algorithms': 4.0.0(@csstools/css-tokenizer@4.0.0)
+      '@csstools/css-tokenizer': 4.0.0
+
   '@csstools/css-parser-algorithms@3.0.5(@csstools/css-tokenizer@3.0.4)':
     dependencies:
       '@csstools/css-tokenizer': 3.0.4
 
+  '@csstools/css-parser-algorithms@4.0.0(@csstools/css-tokenizer@4.0.0)':
+    dependencies:
+      '@csstools/css-tokenizer': 4.0.0
+
+  '@csstools/css-syntax-patches-for-csstree@1.1.2(css-tree@3.2.1)':
+    optionalDependencies:
+      css-tree: 3.2.1
+
   '@csstools/css-tokenizer@3.0.4': {}
 
+  '@csstools/css-tokenizer@4.0.0': {}
+
   '@dagrejs/dagre@1.1.8':
     dependencies:
       '@dagrejs/graphlib': 2.2.4
@@ -14817,6 +14992,10 @@ snapshots:
 
   '@evilmartians/lefthook@1.13.6': {}
 
+  '@exodus/bytes@1.15.0(@noble/hashes@2.0.1)':
+    optionalDependencies:
+      '@noble/hashes': 2.0.1
+
   '@fastify/busboy@2.1.1': {}
 
   '@floating-ui/core@1.7.3':
@@ -18528,7 +18707,7 @@ snapshots:
     transitivePeerDependencies:
       - supports-color
 
-  '@vitest/coverage-v8@1.6.1(vitest@1.6.1(@types/node@20.19.27)(jsdom@26.1.0(bufferutil@4.1.0)(utf-8-validate@6.0.6))(lightningcss@1.31.1)(sass@1.97.1))':
+  '@vitest/coverage-v8@1.6.1(vitest@1.6.1(@types/node@20.19.27)(jsdom@29.0.1(@noble/hashes@2.0.1))(lightningcss@1.31.1)(sass@1.97.1))':
     dependencies:
       '@ampproject/remapping': 2.3.0
       '@bcoe/v8-coverage': 0.2.3
@@ -18543,7 +18722,7 @@ snapshots:
       std-env: 3.10.0
       strip-literal: 2.1.1
       test-exclude: 6.0.0
-      vitest: 1.6.1(@types/node@20.19.27)(jsdom@26.1.0(bufferutil@4.1.0)(utf-8-validate@6.0.6))(lightningcss@1.31.1)(sass@1.97.1)
+      vitest: 1.6.1(@types/node@20.19.27)(jsdom@29.0.1(@noble/hashes@2.0.1))(lightningcss@1.31.1)(sass@1.97.1)
     transitivePeerDependencies:
       - supports-color
 
@@ -19032,7 +19211,7 @@ snapshots:
       node-addon-api: 8.5.0
       node-gyp-build: 4.8.4
 
-  better-auth@1.4.18(@sveltejs/kit@2.49.2(@sveltejs/vite-plugin-svelte@4.0.4(svelte@5.46.0)(vite@5.4.21(@types/node@20.19.27)(lightningcss@1.31.1)(sass@1.97.1)))(svelte@5.46.0)(vite@5.4.21(@types/node@20.19.27)(lightningcss@1.31.1)(sass@1.97.1)))(@tanstack/react-start@1.143.4(crossws@0.4.1(srvx@0.9.8))(react-dom@19.2.3(react@19.2.3))(react@19.2.3)(vite@5.4.21(@types/node@20.19.27)(lightningcss@1.31.1)(sass@1.97.1)))(drizzle-kit@0.31.8)(drizzle-orm@0.44.7(@cloudflare/workers-types@4.20260313.1)(@types/pg@8.16.0)(kysely@0.28.9)(pg@8.18.0)(postgres@3.4.7))(pg@8.18.0)(react-dom@19.2.3(react@19.2.3))(react@19.2.3)(solid-js@1.9.10)(svelte@5.46.0)(vitest@2.1.9(@types/node@20.19.27)(jsdom@26.1.0(bufferutil@4.1.0)(utf-8-validate@6.0.6))(lightningcss@1.31.1)(sass@1.97.1))(vue@3.5.26(typescript@5.9.3)):
+  better-auth@1.4.18(@sveltejs/kit@2.49.2(@sveltejs/vite-plugin-svelte@4.0.4(svelte@5.46.0)(vite@5.4.21(@types/node@20.19.27)(lightningcss@1.31.1)(sass@1.97.1)))(svelte@5.46.0)(vite@5.4.21(@types/node@20.19.27)(lightningcss@1.31.1)(sass@1.97.1)))(@tanstack/react-start@1.143.4(crossws@0.4.1(srvx@0.9.8))(react-dom@19.2.3(react@19.2.3))(react@19.2.3)(vite@5.4.21(@types/node@20.19.27)(lightningcss@1.31.1)(sass@1.97.1)))(drizzle-kit@0.31.8)(drizzle-orm@0.44.7(@cloudflare/workers-types@4.20260313.1)(@types/pg@8.16.0)(kysely@0.28.9)(pg@8.18.0)(postgres@3.4.7))(pg@8.18.0)(react-dom@19.2.3(react@19.2.3))(react@19.2.3)(solid-js@1.9.10)(svelte@5.46.0)(vitest@2.1.9(@types/node@20.19.27)(jsdom@29.0.1(@noble/hashes@2.0.1))(lightningcss@1.31.1)(sass@1.97.1))(vue@3.5.26(typescript@5.9.3)):
     dependencies:
       '@better-auth/core': 1.4.18(@better-auth/utils@0.3.0)(@better-fetch/fetch@1.1.21)(better-call@1.1.8(zod@4.3.6))(jose@6.1.3)(kysely@0.28.9)(nanostores@1.1.0)
       '@better-auth/telemetry': 1.4.18(@better-auth/core@1.4.18(@better-auth/utils@0.3.0)(@better-fetch/fetch@1.1.21)(better-call@1.1.8(zod@4.3.6))(jose@6.1.3)(kysely@0.28.9)(nanostores@1.1.0))
@@ -19056,10 +19235,10 @@ snapshots:
       react-dom: 19.2.3(react@19.2.3)
       solid-js: 1.9.10
       svelte: 5.46.0
-      vitest: 2.1.9(@types/node@20.19.27)(jsdom@26.1.0(bufferutil@4.1.0)(utf-8-validate@6.0.6))(lightningcss@1.31.1)(sass@1.97.1)
+      vitest: 2.1.9(@types/node@20.19.27)(jsdom@29.0.1(@noble/hashes@2.0.1))(lightningcss@1.31.1)(sass@1.97.1)
       vue: 3.5.26(typescript@5.9.3)
 
-  better-auth@1.4.18(@sveltejs/kit@2.49.2(@sveltejs/vite-plugin-svelte@6.2.1(svelte@5.46.0)(vite@7.3.0(@types/node@24.10.4)(jiti@2.6.1)(lightningcss@1.31.1)(sass@1.97.1)(tsx@4.21.0)(yaml@2.8.2)))(svelte@5.46.0)(vite@7.3.0(@types/node@24.10.4)(jiti@2.6.1)(lightningcss@1.31.1)(sass@1.97.1)(tsx@4.21.0)(yaml@2.8.2)))(@tanstack/react-start@1.143.4(crossws@0.4.1(srvx@0.9.8))(react-dom@19.2.3(react@19.2.3))(react@19.2.3)(vite@7.3.0(@types/node@24.10.4)(jiti@2.6.1)(lightningcss@1.31.1)(sass@1.97.1)(tsx@4.21.0)(yaml@2.8.2)))(drizzle-kit@0.31.8)(drizzle-orm@0.44.7(@cloudflare/workers-types@4.20260313.1)(@types/pg@8.16.0)(kysely@0.28.9)(pg@8.18.0)(postgres@3.4.7))(pg@8.18.0)(react-dom@19.2.3(react@19.2.3))(react@19.2.3)(solid-js@1.9.10)(svelte@5.46.0)(vitest@2.1.9(@types/node@24.10.4)(jsdom@26.1.0(bufferutil@4.1.0)(utf-8-validate@6.0.6))(lightningcss@1.31.1)(sass@1.97.1))(vue@3.5.26(typescript@5.9.3)):
+  better-auth@1.4.18(@sveltejs/kit@2.49.2(@sveltejs/vite-plugin-svelte@6.2.1(svelte@5.46.0)(vite@7.3.0(@types/node@24.10.4)(jiti@2.6.1)(lightningcss@1.31.1)(sass@1.97.1)(tsx@4.21.0)(yaml@2.8.2)))(svelte@5.46.0)(vite@7.3.0(@types/node@24.10.4)(jiti@2.6.1)(lightningcss@1.31.1)(sass@1.97.1)(tsx@4.21.0)(yaml@2.8.2)))(@tanstack/react-start@1.143.4(crossws@0.4.1(srvx@0.9.8))(react-dom@19.2.3(react@19.2.3))(react@19.2.3)(vite@7.3.0(@types/node@24.10.4)(jiti@2.6.1)(lightningcss@1.31.1)(sass@1.97.1)(tsx@4.21.0)(yaml@2.8.2)))(drizzle-kit@0.31.8)(drizzle-orm@0.44.7(@cloudflare/workers-types@4.20260313.1)(@types/pg@8.16.0)(kysely@0.28.9)(pg@8.18.0)(postgres@3.4.7))(pg@8.18.0)(react-dom@19.2.3(react@19.2.3))(react@19.2.3)(solid-js@1.9.10)(svelte@5.46.0)(vitest@2.1.9(@types/node@24.10.4)(jsdom@29.0.1(@noble/hashes@2.0.1))(lightningcss@1.31.1)(sass@1.97.1))(vue@3.5.26(typescript@5.9.3)):
     dependencies:
       '@better-auth/core': 1.4.18(@better-auth/utils@0.3.0)(@better-fetch/fetch@1.1.21)(better-call@1.1.8(zod@4.3.6))(jose@6.1.3)(kysely@0.28.9)(nanostores@1.1.0)
       '@better-auth/telemetry': 1.4.18(@better-auth/core@1.4.18(@better-auth/utils@0.3.0)(@better-fetch/fetch@1.1.21)(better-call@1.1.8(zod@4.3.6))(jose@6.1.3)(kysely@0.28.9)(nanostores@1.1.0))
@@ -19083,7 +19262,7 @@ snapshots:
       react-dom: 19.2.3(react@19.2.3)
       solid-js: 1.9.10
       svelte: 5.46.0
-      vitest: 2.1.9(@types/node@24.10.4)(jsdom@26.1.0(bufferutil@4.1.0)(utf-8-validate@6.0.6))(lightningcss@1.31.1)(sass@1.97.1)
+      vitest: 2.1.9(@types/node@24.10.4)(jsdom@29.0.1(@noble/hashes@2.0.1))(lightningcss@1.31.1)(sass@1.97.1)
       vue: 3.5.26(typescript@5.9.3)
 
   better-call@1.1.8(zod@4.3.6):
@@ -19099,6 +19278,10 @@ snapshots:
     dependencies:
       open: 8.4.2
 
+  bidi-js@1.0.3:
+    dependencies:
+      require-from-string: 2.0.2
+
   binary-extensions@2.3.0: {}
 
   bindings@1.5.0:
@@ -19690,6 +19873,11 @@ snapshots:
       domutils: 3.2.2
       nth-check: 2.1.1
 
+  css-tree@3.2.1:
+    dependencies:
+      mdn-data: 2.27.1
+      source-map-js: 1.2.1
+
   css-what@6.2.2: {}
 
   css.escape@1.5.1: {}
@@ -19903,6 +20091,13 @@ snapshots:
       whatwg-mimetype: 4.0.0
       whatwg-url: 14.2.0
 
+  data-urls@7.0.0(@noble/hashes@2.0.1):
+    dependencies:
+      whatwg-mimetype: 5.0.0
+      whatwg-url: 16.0.1(@noble/hashes@2.0.1)
+    transitivePeerDependencies:
+      - '@noble/hashes'
+
   date-fns@2.30.0:
     dependencies:
       '@babel/runtime': 7.28.4
@@ -20079,6 +20274,10 @@ snapshots:
     optionalDependencies:
       '@types/trusted-types': 2.0.7
 
+  dompurify@3.3.3:
+    optionalDependencies:
+      '@types/trusted-types': 2.0.7
+
   domutils@2.8.0:
     dependencies:
       dom-serializer: 1.4.1
@@ -21268,6 +21467,12 @@ snapshots:
     dependencies:
       whatwg-encoding: 3.1.1
 
+  html-encoding-sniffer@6.0.0(@noble/hashes@2.0.1):
+    dependencies:
+      '@exodus/bytes': 1.15.0(@noble/hashes@2.0.1)
+    transitivePeerDependencies:
+      - '@noble/hashes'
+
   html-escaper@2.0.2: {}
 
   html-to-image@1.11.13: {}
@@ -21589,6 +21794,14 @@ snapshots:
 
   isexe@2.0.0: {}
 
+  isomorphic-dompurify@3.7.1(@noble/hashes@2.0.1):
+    dependencies:
+      dompurify: 3.3.3
+      jsdom: 29.0.1(@noble/hashes@2.0.1)
+    transitivePeerDependencies:
+      - '@noble/hashes'
+      - canvas
+
   istanbul-lib-coverage@3.2.2: {}
 
   istanbul-lib-instrument@5.2.1:
@@ -22037,33 +22250,31 @@ snapshots:
       - supports-color
       - utf-8-validate
 
-  jsdom@26.1.0(bufferutil@4.1.0)(utf-8-validate@6.0.6):
+  jsdom@29.0.1(@noble/hashes@2.0.1):
     dependencies:
-      cssstyle: 4.6.0
-      data-urls: 5.0.0
+      '@asamuzakjp/css-color': 5.0.1
+      '@asamuzakjp/dom-selector': 7.0.4
+      '@bramus/specificity': 2.4.2
+      '@csstools/css-syntax-patches-for-csstree': 1.1.2(css-tree@3.2.1)
+      '@exodus/bytes': 1.15.0(@noble/hashes@2.0.1)
+      css-tree: 3.2.1
+      data-urls: 7.0.0(@noble/hashes@2.0.1)
       decimal.js: 10.6.0
-      html-encoding-sniffer: 4.0.0
-      http-proxy-agent: 7.0.2
-      https-proxy-agent: 7.0.6
+      html-encoding-sniffer: 6.0.0(@noble/hashes@2.0.1)
       is-potential-custom-element-name: 1.0.1
-      nwsapi: 2.2.23
-      parse5: 7.3.0
-      rrweb-cssom: 0.8.0
+      lru-cache: 11.2.7
+      parse5: 8.0.0
       saxes: 6.0.0
       symbol-tree: 3.2.4
-      tough-cookie: 5.1.2
+      tough-cookie: 6.0.1
+      undici: 7.24.6
       w3c-xmlserializer: 5.0.0
-      webidl-conversions: 7.0.0
-      whatwg-encoding: 3.1.1
-      whatwg-mimetype: 4.0.0
-      whatwg-url: 14.2.0
-      ws: 8.18.3(bufferutil@4.1.0)(utf-8-validate@6.0.6)
+      webidl-conversions: 8.0.1
+      whatwg-mimetype: 5.0.0
+      whatwg-url: 16.0.1(@noble/hashes@2.0.1)
       xml-name-validator: 5.0.0
     transitivePeerDependencies:
-      - bufferutil
-      - supports-color
-      - utf-8-validate
-    optional: true
+      - '@noble/hashes'
 
   jsesc@3.1.0: {}
 
@@ -22365,6 +22576,8 @@ snapshots:
 
   lru-cache@11.2.4: {}
 
+  lru-cache@11.2.7: {}
+
   lru-cache@5.1.1:
     dependencies:
       yallist: 3.1.1
@@ -22607,6 +22820,8 @@ snapshots:
       unist-util-is: 6.0.1
       unist-util-visit: 5.0.0
 
+  mdn-data@2.27.1: {}
+
   mdsvex@0.11.2(svelte@5.46.0):
     dependencies:
       '@types/unist': 2.0.11
@@ -23059,7 +23274,7 @@ snapshots:
 
   nf3@0.1.12: {}
 
-  nitro@3.0.1-alpha.1(chokidar@4.0.3)(drizzle-orm@0.44.7(@cloudflare/workers-types@4.20260313.1)(@types/pg@8.16.0)(kysely@0.28.9)(pg@8.18.0)(postgres@3.4.7))(ioredis@5.8.2)(lru-cache@11.2.4)(rollup@4.54.0)(vite@7.3.0(@types/node@24.10.4)(jiti@2.6.1)(lightningcss@1.31.1)(sass@1.97.1)(tsx@4.21.0)(yaml@2.8.2)):
+  nitro@3.0.1-alpha.1(chokidar@4.0.3)(drizzle-orm@0.44.7(@cloudflare/workers-types@4.20260313.1)(@types/pg@8.16.0)(kysely@0.28.9)(pg@8.18.0)(postgres@3.4.7))(ioredis@5.8.2)(lru-cache@11.2.7)(rollup@4.54.0)(vite@7.3.0(@types/node@24.10.4)(jiti@2.6.1)(lightningcss@1.31.1)(sass@1.97.1)(tsx@4.21.0)(yaml@2.8.2)):
     dependencies:
       consola: 3.4.2
       crossws: 0.4.1(srvx@0.9.8)
@@ -23074,7 +23289,7 @@ snapshots:
       srvx: 0.9.8
       undici: 7.16.0
       unenv: 2.0.0-rc.24
-      unstorage: 2.0.0-alpha.4(chokidar@4.0.3)(db0@0.3.4(drizzle-orm@0.44.7(@cloudflare/workers-types@4.20260313.1)(@types/pg@8.16.0)(kysely@0.28.9)(pg@8.18.0)(postgres@3.4.7)))(ioredis@5.8.2)(lru-cache@11.2.4)(ofetch@2.0.0-alpha.3)
+      unstorage: 2.0.0-alpha.4(chokidar@4.0.3)(db0@0.3.4(drizzle-orm@0.44.7(@cloudflare/workers-types@4.20260313.1)(@types/pg@8.16.0)(kysely@0.28.9)(pg@8.18.0)(postgres@3.4.7)))(ioredis@5.8.2)(lru-cache@11.2.7)(ofetch@2.0.0-alpha.3)
     optionalDependencies:
       rollup: 4.54.0
       vite: 7.3.0(@types/node@24.10.4)(jiti@2.6.1)(lightningcss@1.31.1)(sass@1.97.1)(tsx@4.21.0)(yaml@2.8.2)
@@ -23415,6 +23630,10 @@ snapshots:
     dependencies:
       entities: 6.0.1
 
+  parse5@8.0.0:
+    dependencies:
+      entities: 6.0.1
+
   parseurl@1.3.3: {}
 
   path-exists@3.0.0: {}
@@ -25191,10 +25410,16 @@ snapshots:
 
   tldts-core@6.1.86: {}
 
+  tldts-core@7.0.27: {}
+
   tldts@6.1.86:
     dependencies:
       tldts-core: 6.1.86
 
+  tldts@7.0.27:
+    dependencies:
+      tldts-core: 7.0.27
+
   tmp@0.0.33:
     dependencies:
       os-tmpdir: 1.0.2
@@ -25215,12 +25440,20 @@ snapshots:
     dependencies:
       tldts: 6.1.86
 
+  tough-cookie@6.0.1:
+    dependencies:
+      tldts: 7.0.27
+
   tr46@0.0.3: {}
 
   tr46@5.1.1:
     dependencies:
       punycode: 2.3.1
 
+  tr46@6.0.0:
+    dependencies:
+      punycode: 2.3.1
+
   tree-kill@1.2.2: {}
 
   trim-lines@3.0.1: {}
@@ -25463,6 +25696,8 @@ snapshots:
 
   undici@7.16.0: {}
 
+  undici@7.24.6: {}
+
   unenv@2.0.0-rc.17:
     dependencies:
       defu: 6.1.4
@@ -25550,12 +25785,12 @@ snapshots:
 
   unsplash-js@7.0.20: {}
 
-  unstorage@2.0.0-alpha.4(chokidar@4.0.3)(db0@0.3.4(drizzle-orm@0.44.7(@cloudflare/workers-types@4.20260313.1)(@types/pg@8.16.0)(kysely@0.28.9)(pg@8.18.0)(postgres@3.4.7)))(ioredis@5.8.2)(lru-cache@11.2.4)(ofetch@2.0.0-alpha.3):
+  unstorage@2.0.0-alpha.4(chokidar@4.0.3)(db0@0.3.4(drizzle-orm@0.44.7(@cloudflare/workers-types@4.20260313.1)(@types/pg@8.16.0)(kysely@0.28.9)(pg@8.18.0)(postgres@3.4.7)))(ioredis@5.8.2)(lru-cache@11.2.7)(ofetch@2.0.0-alpha.3):
     optionalDependencies:
       chokidar: 4.0.3
       db0: 0.3.4(drizzle-orm@0.44.7(@cloudflare/workers-types@4.20260313.1)(@types/pg@8.16.0)(kysely@0.28.9)(pg@8.18.0)(postgres@3.4.7))
       ioredis: 5.8.2
-      lru-cache: 11.2.4
+      lru-cache: 11.2.7
       ofetch: 2.0.0-alpha.3
 
   update-browserslist-db@1.2.3(browserslist@4.28.1):
@@ -25839,7 +26074,7 @@ snapshots:
     optionalDependencies:
       vite: 7.3.0(@types/node@24.10.4)(jiti@2.6.1)(lightningcss@1.31.1)(sass@1.97.1)(tsx@4.21.0)(yaml@2.8.2)
 
-  vitest@1.6.1(@types/node@20.19.27)(jsdom@26.1.0(bufferutil@4.1.0)(utf-8-validate@6.0.6))(lightningcss@1.31.1)(sass@1.97.1):
+  vitest@1.6.1(@types/node@20.19.27)(jsdom@29.0.1(@noble/hashes@2.0.1))(lightningcss@1.31.1)(sass@1.97.1):
     dependencies:
       '@vitest/expect': 1.6.1
       '@vitest/runner': 1.6.1
@@ -25863,7 +26098,7 @@ snapshots:
       why-is-node-running: 2.3.0
     optionalDependencies:
       '@types/node': 20.19.27
-      jsdom: 26.1.0(bufferutil@4.1.0)(utf-8-validate@6.0.6)
+      jsdom: 29.0.1(@noble/hashes@2.0.1)
     transitivePeerDependencies:
       - less
       - lightningcss
@@ -25874,7 +26109,7 @@ snapshots:
       - supports-color
       - terser
 
-  vitest@1.6.1(@types/node@24.10.4)(jsdom@26.1.0(bufferutil@4.1.0)(utf-8-validate@6.0.6))(lightningcss@1.31.1)(sass@1.97.1):
+  vitest@1.6.1(@types/node@24.10.4)(jsdom@29.0.1(@noble/hashes@2.0.1))(lightningcss@1.31.1)(sass@1.97.1):
     dependencies:
       '@vitest/expect': 1.6.1
       '@vitest/runner': 1.6.1
@@ -25898,7 +26133,7 @@ snapshots:
       why-is-node-running: 2.3.0
     optionalDependencies:
       '@types/node': 24.10.4
-      jsdom: 26.1.0(bufferutil@4.1.0)(utf-8-validate@6.0.6)
+      jsdom: 29.0.1(@noble/hashes@2.0.1)
     transitivePeerDependencies:
       - less
       - lightningcss
@@ -25909,7 +26144,7 @@ snapshots:
       - supports-color
       - terser
 
-  vitest@2.1.9(@types/node@20.19.27)(jsdom@26.1.0(bufferutil@4.1.0)(utf-8-validate@6.0.6))(lightningcss@1.31.1)(sass@1.97.1):
+  vitest@2.1.9(@types/node@20.19.27)(jsdom@29.0.1(@noble/hashes@2.0.1))(lightningcss@1.31.1)(sass@1.97.1):
     dependencies:
       '@vitest/expect': 2.1.9
       '@vitest/mocker': 2.1.9(vite@5.4.21(@types/node@20.19.27)(lightningcss@1.31.1)(sass@1.97.1))
@@ -25933,7 +26168,7 @@ snapshots:
       why-is-node-running: 2.3.0
     optionalDependencies:
       '@types/node': 20.19.27
-      jsdom: 26.1.0(bufferutil@4.1.0)(utf-8-validate@6.0.6)
+      jsdom: 29.0.1(@noble/hashes@2.0.1)
     transitivePeerDependencies:
       - less
       - lightningcss
@@ -25982,7 +26217,7 @@ snapshots:
       - supports-color
       - terser
 
-  vitest@2.1.9(@types/node@24.10.4)(jsdom@26.1.0(bufferutil@4.1.0)(utf-8-validate@6.0.6))(lightningcss@1.31.1)(sass@1.97.1):
+  vitest@2.1.9(@types/node@24.10.4)(jsdom@29.0.1(@noble/hashes@2.0.1))(lightningcss@1.31.1)(sass@1.97.1):
     dependencies:
       '@vitest/expect': 2.1.9
       '@vitest/mocker': 2.1.9(vite@5.4.21(@types/node@24.10.4)(lightningcss@1.31.1)(sass@1.97.1))
@@ -26006,7 +26241,7 @@ snapshots:
       why-is-node-running: 2.3.0
     optionalDependencies:
       '@types/node': 24.10.4
-      jsdom: 26.1.0(bufferutil@4.1.0)(utf-8-validate@6.0.6)
+      jsdom: 29.0.1(@noble/hashes@2.0.1)
     transitivePeerDependencies:
       - less
       - lightningcss
@@ -26058,6 +26293,8 @@ snapshots:
 
   webidl-conversions@7.0.0: {}
 
+  webidl-conversions@8.0.1: {}
+
   webpack-virtual-modules@0.6.2: {}
 
   whatwg-encoding@3.1.1:
@@ -26066,11 +26303,21 @@ snapshots:
 
   whatwg-mimetype@4.0.0: {}
 
+  whatwg-mimetype@5.0.0: {}
+
   whatwg-url@14.2.0:
     dependencies:
       tr46: 5.1.1
       webidl-conversions: 7.0.0
 
+  whatwg-url@16.0.1(@noble/hashes@2.0.1):
+    dependencies:
+      '@exodus/bytes': 1.15.0(@noble/hashes@2.0.1)
+      tr46: 6.0.0
+      webidl-conversions: 8.0.1
+    transitivePeerDependencies:
+      - '@noble/hashes'
+
   whatwg-url@5.0.0:
     dependencies:
       tr46: 0.0.3
diff --git a/prd/classes/README.md b/prd/classes/README.md
deleted file mode 100644
index 979e9a7c..00000000
--- a/prd/classes/README.md
+++ /dev/null
@@ -1,993 +0,0 @@
-# Classes PRD
-
-## Purpose
-
-Enable instructors and org admins to group multiple courses — along with shared announcements, files, and community discussions — into a single **class**. Enrolling a student in a class auto-enrolls them in every course inside it, eliminating the need to manage per-course enrollment manually when delivering a structured program.
-
-## Problem Statement
-
-Currently, ClassroomIO has no entity above the individual course. Every course has its own independent enrollment roster. This creates several pain points:
-
-- An instructor running a program (e.g., a bootcamp, onboarding track, or certification pathway) must enroll students in each constituent course one by one.
-- There is no shared space for class-wide announcements, files, or discussions that span multiple courses.
-- Students cannot see a unified "program" view in the LMS — they only see a flat list of individual courses.
-- Org admins have no way to bundle courses for a specific cohort of learners (e.g., "Q1 2026 New Hire Onboarding") without creating separate organizations or duplicating content.
-
-## Confirmed Decisions
-
-1. **Terminology**: "Class" in both the instructor-facing admin UI and the student-facing LMS.
-2. **Auto-enrollment**: Joining a class automatically creates `groupmember` records for every course inside the class. Removing a student from a class does not remove them from individual course groups, preserving their submission and progress data.
-3. **Shared materials**: Each class has three shared material surfaces: announcements (instructor-authored posts), a file library, and a community Q&A board.
-4. **Many-to-many courses**: A course can belong to multiple classes. Courses and classes are independent entities linked by a join table.
-5. **LMS visibility**: Classes are visible to students in the LMS under a dedicated "Classes" section. Students see enrolled classes and can navigate courses from within a class hub page.
-6. **Roles**: Class roles mirror the existing system (`ADMIN`/roleId 1, `TUTOR`/roleId 2, `STUDENT`/roleId 3). Class admins and tutors can manage the class; class students get read access to materials.
-7. **Class status**: Classes can be `ACTIVE`, `INACTIVE`, or `ARCHIVED`. `INACTIVE` classes are hidden from students in the LMS but preserved for instructors. `ARCHIVED` classes are soft-deleted and hidden everywhere.
-8. **Course independence**: Courses in a class remain fully independent. A student enrolled in a class is a regular `groupmember` in each course — existing course pages, progress tracking, submissions, and grading are unchanged.
-9. **Community reuse**: The existing `community_question` table gains a nullable `classId` FK. Class-level Q&A behaves identically to course-level community Q&A but scoped to the class.
-
-## Current-State Audit
-
-| Capability | Current State | Notes |
-| --- | --- | --- |
-| Organization structure | `organization` → `group` (1:1 with `course`) → `course` | No intermediate grouping layer above course |
-| Course enrollment | `groupmember` rows per course's `group` | Per-course, no bulk enrollment mechanism |
-| Student LMS view | Flat list of enrolled courses under `/lms/mylearning` | No program/class concept |
-| Community Q&A | `community_question.courseId` scoped | Reusable with additional `classId` FK |
-| Shared file library | Per-course via `assets` table; no org-wide shared files | New `class_file` table needed |
-| Announcements | Per-course `course_newsfeed` | New `class_announcement` table needed |
-| Org admin navigation | "Courses" section listing all courses | "Classes" nav item needed |
-| LMS navigation | Home, My Learning, Exercises, Community, Explore, Settings | "Classes" nav item needed |
-| Enrollment service | `enrollInCourse()` in `apps/api/src/services/course/invite.ts` | Must be called per-course when adding class member |
-
-**Key insight**: Because enrollment = `groupmember` rows per course, adding a student to a class is purely a matter of calling the existing enrollment logic for each course in the class within a single transaction. No course-level schema changes are needed.
-
-## Product Goals
-
-1. Org admins and instructors can create a class, add courses to it, and manage class membership from the admin dashboard.
-2. Adding a student to a class auto-enrolls them in all courses currently in the class.
-3. Adding a new course to an existing class auto-enrolls all current class students in that course.
-4. Each class has a shared announcements feed, file library, and community board visible to all class members.
-5. Students can see their enrolled classes in the LMS with a unified hub view showing all courses, announcements, and files.
-6. Classes without students, and courses outside any class, continue to work exactly as they do today (zero regression).
-
-## Non-Goals (v1)
-
-- Class-level invite links (v1 enrollment is admin-managed; students cannot self-enroll in a class via a token).
-- Class-specific exercise deadlines or content overrides (courses are shared as-is).
-- Class progress analytics aggregated across all courses (available per-course; cross-course aggregation is a future improvement).
-- Removing a student from a class also unenrolling them from individual courses (data preservation is the default).
-- Class templates or class cloning.
-- Public/discoverable class landing pages (classes are private to org members).
-- Billing or pricing at the class level.
-- Class-level attendance tracking separate from per-course attendance.
-
-## Data Sources Checked
-
-- `packages/db/src/schema.ts` — all table definitions and constraint patterns
-- `apps/api/src/services/course/course.ts` — course creation flow
-- `apps/api/src/services/course/invite.ts` — enrollment flow (`enrollInCourse`)
-- `apps/api/src/routes/course/course.ts` — course router and sub-router mounting
-- `apps/api/src/app.ts` — top-level router registration
-- `packages/db/src/queries/course/people.ts` — group member management
-- `packages/db/src/queries/group/group.ts` — group/member queries
-- `packages/db/src/queries/community/community.ts` — community Q&A pattern
-- `apps/dashboard/src/lib/features/lms/` — LMS navigation and pages
-- `apps/dashboard/src/lib/features/org/` — org admin navigation
-- `apps/dashboard/src/routes/lms/` — LMS SvelteKit routes
-- `apps/dashboard/src/routes/courses/` — course admin SvelteKit routes
-
-## Functional Requirements
-
-### 1. Class CRUD (Admin)
-
-- Org admins can create a class with: name (required), description (optional), cover image (optional).
-- Classes can be updated (name, description, cover image, status).
-- Archiving a class sets `status = 'ARCHIVED'` and hides it from all views. Archived classes can be restored.
-- A class belongs to exactly one organization.
-- Class names do not need to be unique within an org (unlike course slugs), but should be descriptive.
-
-### 2. Course Management in a Class (Admin)
-
-- Org admins and class tutors can add existing org courses to a class.
-- A course can belong to multiple classes simultaneously.
-- Adding a course to a class triggers auto-enrollment: all existing `STUDENT` class members are enrolled in the new course (a `groupmember` row is created in the course's `group` for each student not already enrolled).
-- Removing a course from a class does not unenroll any students from that course. Their progress and submissions are preserved.
-- Courses within a class are ordered (integer `order` field) so instructors can sequence them.
-
-### 3. Class Membership (Admin)
-
-- Org admins can add members to a class by profile ID or email, assigning them a role (ADMIN, TUTOR, or STUDENT).
-- Adding a STUDENT member triggers auto-enrollment: a `groupmember` row is created in every course currently in the class (skipping courses the student is already enrolled in; idempotent).
-- Adding an ADMIN or TUTOR member does not auto-enroll them in courses (their course-level permissions are managed separately via course membership).
-- Removing a member from a class removes the `class_member` row only. Individual `groupmember` rows in courses are left intact, preserving submissions, grades, and progress.
-- Batch add: admins can add multiple members at once (array of `{ email, roleId }` pairs).
-
-### 4. Class Announcements (Admin + LMS)
-
-- Class admins and tutors can post announcements to the class feed.
-- Announcements have a title and a rich-text body.
-- Announcements are visible to all class members (students, tutors, and admins) in both the admin class view and the LMS class hub.
-- Students cannot post announcements (read-only for students).
-- Announcements are ordered by `createdAt` descending (newest first).
-
-### 5. Class File Library (Admin + LMS)
-
-- Class admins and tutors can upload files to the class file library.
-- Each file record stores: name, URL (stored via the existing presigned upload flow), MIME type, size, uploader profile ID.
-- All class members can view and download files.
-- Only class admins and tutors can delete files.
-
-### 6. Class Community (Admin + LMS)
-
-- Class-level community Q&A reuses the existing `community_question` / `community_answer` infrastructure.
-- A nullable `classId` FK is added to `community_question`. Questions with `classId` set are class-scoped (not visible on the course-level community board).
-- All class members can post questions and answers in the class community.
-- The existing voting, commenting, and answer-acceptance behavior is unchanged.
-
-### 7. LMS — My Classes (Student)
-
-- A "Classes" nav item appears in the LMS sidebar when the student is enrolled in at least one class.
-- The `/lms/classes` page lists all classes the student is enrolled in.
-- Each class card shows: class name, cover image, number of courses, brief description.
-- Clicking a class opens the class hub page.
-
-### 8. LMS — Class Hub (Student)
-
-- The class hub at `/lms/classes/[classId]` is the student's central page for a class.
-- It is divided into three tabs or sections:
-  - **Courses**: All courses in the class, each with the student's individual progress bar and a direct link to the course. Courses are shown in the instructor-defined order.
-  - **Announcements**: Class announcements in reverse-chronological order (read-only for students).
-  - **Resources**: The class file library (download only) and a link to the class community board.
-- The class community board lives at `/lms/classes/[classId]/community` and behaves identically to the existing course community pages.
-
-### 9. Admin — Classes Section
-
-- "Classes" is added as a top-level nav item in the org admin sidebar, alongside "Courses".
-- The `/courses/classes` page lists all org classes with name, course count, student count, and status badge.
-- A "Create Class" button opens a creation form.
-- Each class links to a class detail view with sub-pages: Overview, Courses, People, Announcements, Files.
-
-### 10. Access Control
-
-- Only `ADMIN` and `TUTOR` role members of a class (or org admins) can manage class content and membership.
-- Students can read announcements and files, participate in the community, and view the course list.
-- A student who is removed from the org loses access to all class content.
-- An `INACTIVE` class is hidden from students in the LMS but all data is preserved.
-
----
-
-## Technical Design
-
-### Data Model
-
-#### New Enum: `CLASS_STATUS`
-
-```typescript
-// packages/db/src/schema.ts
-export const classStatus = pgEnum('CLASS_STATUS', ['ACTIVE', 'INACTIVE', 'ARCHIVED']);
-```
-
-#### New Table: `class`
-
-```typescript
-// packages/db/src/schema.ts
-export const lmsClass = pgTable(
-  'class',
-  {
-    id: uuid()
-      .default(sql`gen_random_uuid()`)
-      .primaryKey()
-      .notNull(),
-    createdAt: timestamp('created_at', { withTimezone: true, mode: 'string' }).defaultNow().notNull(),
-    updatedAt: timestamp('updated_at', { withTimezone: true, mode: 'string' }).defaultNow(),
-    organizationId: uuid('organization_id').notNull(),
-    name: varchar().notNull(),
-    description: text(),
-    coverImage: text('cover_image'),
-    status: classStatus().default('ACTIVE').notNull(),
-    createdByProfileId: uuid('created_by_profile_id')
-  },
-  (table) => [
-    foreignKey({
-      columns: [table.organizationId],
-      foreignColumns: [organization.id],
-      name: 'class_organization_id_fkey'
-    }).onDelete('cascade'),
-    foreignKey({
-      columns: [table.createdByProfileId],
-      foreignColumns: [profile.id],
-      name: 'class_created_by_profile_id_fkey'
-    }),
-    index('idx_class_organization_id').on(table.organizationId)
-  ]
-);
-```
-
-#### New Table: `class_course`
-
-Many-to-many join between class and course, with an instructor-controlled display order.
-
-```typescript
-// packages/db/src/schema.ts
-export const classCourse = pgTable(
-  'class_course',
-  {
-    id: uuid()
-      .default(sql`gen_random_uuid()`)
-      .primaryKey()
-      .notNull(),
-    classId: uuid('class_id').notNull(),
-    courseId: uuid('course_id').notNull(),
-    order: integer().default(0).notNull(),
-    addedAt: timestamp('added_at', { withTimezone: true, mode: 'string' }).defaultNow().notNull()
-  },
-  (table) => [
-    foreignKey({
-      columns: [table.classId],
-      foreignColumns: [lmsClass.id],
-      name: 'class_course_class_id_fkey'
-    }).onDelete('cascade'),
-    foreignKey({
-      columns: [table.courseId],
-      foreignColumns: [course.id],
-      name: 'class_course_course_id_fkey'
-    }).onDelete('cascade'),
-    unique('class_course_class_id_course_id_unique').on(table.classId, table.courseId),
-    index('idx_class_course_class_id').on(table.classId)
-  ]
-);
-```
-
-#### New Table: `class_member`
-
-Membership roster for a class. Does not replace `groupmember` — it is a separate layer.
-
-```typescript
-// packages/db/src/schema.ts
-export const classMember = pgTable(
-  'class_member',
-  {
-    id: uuid()
-      .default(sql`gen_random_uuid()`)
-      .primaryKey()
-      .notNull(),
-    classId: uuid('class_id').notNull(),
-    profileId: uuid('profile_id'),
-    roleId: integer('role_id').notNull(),
-    email: text(),
-    createdAt: timestamp('created_at', { withTimezone: true, mode: 'string' }).defaultNow().notNull()
-  },
-  (table) => [
-    foreignKey({
-      columns: [table.classId],
-      foreignColumns: [lmsClass.id],
-      name: 'class_member_class_id_fkey'
-    }).onDelete('cascade'),
-    foreignKey({
-      columns: [table.profileId],
-      foreignColumns: [profile.id],
-      name: 'class_member_profile_id_fkey'
-    }),
-    foreignKey({
-      columns: [table.roleId],
-      foreignColumns: [role.id],
-      name: 'class_member_role_id_fkey'
-    }),
-    unique('class_member_class_id_profile_id_unique').on(table.classId, table.profileId),
-    index('idx_class_member_class_id').on(table.classId),
-    index('idx_class_member_profile_id').on(table.profileId)
-  ]
-);
-```
-
-#### New Table: `class_announcement`
-
-```typescript
-// packages/db/src/schema.ts
-export const classAnnouncement = pgTable(
-  'class_announcement',
-  {
-    id: uuid()
-      .default(sql`gen_random_uuid()`)
-      .primaryKey()
-      .notNull(),
-    classId: uuid('class_id').notNull(),
-    authorProfileId: uuid('author_profile_id'),
-    title: varchar().notNull(),
-    body: text(),
-    createdAt: timestamp('created_at', { withTimezone: true, mode: 'string' }).defaultNow().notNull(),
-    updatedAt: timestamp('updated_at', { withTimezone: true, mode: 'string' }).defaultNow()
-  },
-  (table) => [
-    foreignKey({
-      columns: [table.classId],
-      foreignColumns: [lmsClass.id],
-      name: 'class_announcement_class_id_fkey'
-    }).onDelete('cascade'),
-    foreignKey({
-      columns: [table.authorProfileId],
-      foreignColumns: [profile.id],
-      name: 'class_announcement_author_profile_id_fkey'
-    }),
-    index('idx_class_announcement_class_id').on(table.classId)
-  ]
-);
-```
-
-#### New Table: `class_file`
-
-```typescript
-// packages/db/src/schema.ts
-export const classFile = pgTable(
-  'class_file',
-  {
-    id: uuid()
-      .default(sql`gen_random_uuid()`)
-      .primaryKey()
-      .notNull(),
-    classId: uuid('class_id').notNull(),
-    uploadedByProfileId: uuid('uploaded_by_profile_id'),
-    name: varchar().notNull(),
-    url: text().notNull(),
-    mimeType: varchar('mime_type'),
-    size: integer(),
-    createdAt: timestamp('created_at', { withTimezone: true, mode: 'string' }).defaultNow().notNull()
-  },
-  (table) => [
-    foreignKey({
-      columns: [table.classId],
-      foreignColumns: [lmsClass.id],
-      name: 'class_file_class_id_fkey'
-    }).onDelete('cascade'),
-    foreignKey({
-      columns: [table.uploadedByProfileId],
-      foreignColumns: [profile.id],
-      name: 'class_file_uploaded_by_profile_id_fkey'
-    }),
-    index('idx_class_file_class_id').on(table.classId)
-  ]
-);
-```
-
-#### Modified Table: `community_question`
-
-Add a nullable `classId` FK so community questions can be scoped to a class:
-
-```typescript
-// Add to community_question table columns:
-classId: uuid('class_id')
-
-// Add to community_question table constraints:
-foreignKey({
-  columns: [table.classId],
-  foreignColumns: [lmsClass.id],
-  name: 'community_question_class_id_fkey'
-}).onDelete('cascade')
-```
-
-When `classId` is set, the question is class-scoped. When `courseId` is set, it is course-scoped. The two are mutually exclusive in practice (enforced at the service layer).
-
-#### Relationship Diagram
-
-```
-organization
-  └── class
-        ├── class_course  ──────────────────────→  course
-        │     (order, addedAt)                        └── group → groupmember ← (auto-created)
-        ├── class_member  ──────────────────────→  profile
-        │     (roleId: ADMIN/TUTOR/STUDENT)
-        ├── class_announcement
-        │     (title, body, authorProfileId)
-        ├── class_file
-        │     (name, url, mimeType, size)
-        └── community_question (classId set)
-              └── community_answer
-```
-
-### Migration
-
-File: `packages/db/src/migrations/XXXX_add_classes.sql`
-
-```sql
--- 1. Create CLASS_STATUS enum
-CREATE TYPE "CLASS_STATUS" AS ENUM ('ACTIVE', 'INACTIVE', 'ARCHIVED');
-
--- 2. Create class table
-CREATE TABLE class (
-  id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
-  created_at TIMESTAMPTZ NOT NULL DEFAULT NOW(),
-  updated_at TIMESTAMPTZ DEFAULT NOW(),
-  organization_id UUID NOT NULL REFERENCES organization(id) ON DELETE CASCADE,
-  name VARCHAR NOT NULL,
-  description TEXT,
-  cover_image TEXT,
-  status "CLASS_STATUS" NOT NULL DEFAULT 'ACTIVE',
-  created_by_profile_id UUID REFERENCES profile(id)
-);
-
-CREATE INDEX idx_class_organization_id ON class(organization_id);
-
--- 3. Create class_course join table
-CREATE TABLE class_course (
-  id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
-  class_id UUID NOT NULL REFERENCES class(id) ON DELETE CASCADE,
-  course_id UUID NOT NULL REFERENCES course(id) ON DELETE CASCADE,
-  "order" INTEGER NOT NULL DEFAULT 0,
-  added_at TIMESTAMPTZ NOT NULL DEFAULT NOW(),
-  UNIQUE(class_id, course_id)
-);
-
-CREATE INDEX idx_class_course_class_id ON class_course(class_id);
-
--- 4. Create class_member table
-CREATE TABLE class_member (
-  id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
-  class_id UUID NOT NULL REFERENCES class(id) ON DELETE CASCADE,
-  profile_id UUID REFERENCES profile(id),
-  role_id INTEGER NOT NULL REFERENCES role(id),
-  email TEXT,
-  created_at TIMESTAMPTZ NOT NULL DEFAULT NOW(),
-  UNIQUE(class_id, profile_id)
-);
-
-CREATE INDEX idx_class_member_class_id ON class_member(class_id);
-CREATE INDEX idx_class_member_profile_id ON class_member(profile_id);
-
--- 5. Create class_announcement table
-CREATE TABLE class_announcement (
-  id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
-  class_id UUID NOT NULL REFERENCES class(id) ON DELETE CASCADE,
-  author_profile_id UUID REFERENCES profile(id),
-  title VARCHAR NOT NULL,
-  body TEXT,
-  created_at TIMESTAMPTZ NOT NULL DEFAULT NOW(),
-  updated_at TIMESTAMPTZ DEFAULT NOW()
-);
-
-CREATE INDEX idx_class_announcement_class_id ON class_announcement(class_id);
-
--- 6. Create class_file table
-CREATE TABLE class_file (
-  id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
-  class_id UUID NOT NULL REFERENCES class(id) ON DELETE CASCADE,
-  uploaded_by_profile_id UUID REFERENCES profile(id),
-  name VARCHAR NOT NULL,
-  url TEXT NOT NULL,
-  mime_type VARCHAR,
-  size INTEGER,
-  created_at TIMESTAMPTZ NOT NULL DEFAULT NOW()
-);
-
-CREATE INDEX idx_class_file_class_id ON class_file(class_id);
-
--- 7. Add classId to community_question
-ALTER TABLE community_question ADD COLUMN class_id UUID REFERENCES class(id) ON DELETE CASCADE;
-```
-
----
-
-## Access Control Logic
-
-Two middleware functions are needed in `apps/api/src/middleware/`:
-
-### `classAccessMiddleware` (read access)
-
-Verifies the caller is either an org admin or a `class_member` for the given `:classId`. Used on all `GET /class/:classId/*` routes.
-
-```typescript
-// apps/api/src/middleware/class-access.ts
-export async function classAccessMiddleware(c, next) {
-  const { classId } = c.req.param();
-  const user = c.get('user')!;
-  const isMember = await isClassMember(classId, user.profileId);
-  const isOrgAdmin = await isOrgAdminByClassId(classId, user.profileId);
-  if (!isMember && !isOrgAdmin) throw new AppError('Forbidden', ErrorCodes.FORBIDDEN, 403);
-  await next();
-}
-```
-
-### `classAdminMiddleware` (write access)
-
-Verifies the caller has `roleId` 1 (ADMIN) or 2 (TUTOR) within the class, or is an org admin. Used on all mutating routes.
-
-```typescript
-// apps/api/src/middleware/class-admin.ts
-export async function classAdminMiddleware(c, next) {
-  const { classId } = c.req.param();
-  const user = c.get('user')!;
-  const role = await getClassMemberRole(classId, user.profileId);
-  const isOrgAdmin = await isOrgAdminByClassId(classId, user.profileId);
-  if (!isOrgAdmin && (!role || role > 2)) throw new AppError('Forbidden', ErrorCodes.FORBIDDEN, 403);
-  await next();
-}
-```
-
----
-
-## API and Route Plan
-
-### Validation Layer
-
-File: `packages/utils/src/validation/class/class.ts`
-
-```typescript
-import { z } from 'zod';
-
-export const ZCreateClass = z.object({
-  name: z.string().min(1).max(255),
-  description: z.string().max(2000).optional(),
-  coverImage: z.string().url().optional()
-});
-export type TCreateClass = z.infer<typeof ZCreateClass>;
-
-export const ZUpdateClass = z.object({
-  name: z.string().min(1).max(255).optional(),
-  description: z.string().max(2000).nullable().optional(),
-  coverImage: z.string().url().nullable().optional(),
-  status: z.enum(['ACTIVE', 'INACTIVE', 'ARCHIVED']).optional()
-});
-export type TUpdateClass = z.infer<typeof ZUpdateClass>;
-
-export const ZAddCourseToClass = z.object({
-  courseId: z.string().uuid(),
-  order: z.number().int().min(0).optional()
-});
-export type TAddCourseToClass = z.infer<typeof ZAddCourseToClass>;
-
-export const ZAddClassMembers = z.object({
-  members: z.array(
-    z.object({
-      email: z.string().email(),
-      roleId: z.number().int().min(1).max(3)
-    })
-  ).min(1)
-});
-export type TAddClassMembers = z.infer<typeof ZAddClassMembers>;
-
-export const ZUpdateClassMember = z.object({
-  roleId: z.number().int().min(1).max(3)
-});
-export type TUpdateClassMember = z.infer<typeof ZUpdateClassMember>;
-
-export const ZCreateClassAnnouncement = z.object({
-  title: z.string().min(1).max(500),
-  body: z.string().max(10000).optional()
-});
-export type TCreateClassAnnouncement = z.infer<typeof ZCreateClassAnnouncement>;
-
-export const ZUpdateClassAnnouncement = z.object({
-  title: z.string().min(1).max(500).optional(),
-  body: z.string().max(10000).nullable().optional()
-});
-export type TUpdateClassAnnouncement = z.infer<typeof ZUpdateClassAnnouncement>;
-
-export const ZAddClassFile = z.object({
-  name: z.string().min(1).max(255),
-  url: z.string().url(),
-  mimeType: z.string().optional(),
-  size: z.number().int().positive().optional()
-});
-export type TAddClassFile = z.infer<typeof ZAddClassFile>;
-```
-
-Export from: `packages/utils/src/validation/class/index.ts` and re-export from `packages/utils/src/validation/index.ts`.
-
-### Query Layer
-
-File: `packages/db/src/queries/class/class.ts`
-
-| Function | Description |
-| --- | --- |
-| `createClass(data)` | Insert into `class`, return created row |
-| `getClassById(classId)` | Single class with member count and course count |
-| `getClassesByOrg(orgId)` | All non-archived classes for org, ordered by `createdAt` desc |
-| `updateClass(classId, data)` | Update name, description, coverImage, status |
-| `getClassMemberRole(classId, profileId)` | Return `roleId` for the given profile in the class, or null |
-| `isClassMember(classId, profileId)` | Boolean check |
-| `isOrgAdminByClassId(classId, profileId)` | Joins `class → organization → organizationmember` to check admin role |
-| `addClassMember(classId, profileId, roleId, email)` | Insert `class_member` row (upsert on conflict) |
-| `removeClassMember(classId, memberId)` | Delete `class_member` by `id` |
-| `getClassMembers(classId)` | All members joined to `profile` for display |
-| `getEnrolledClassesByProfile(orgId, profileId)` | All `ACTIVE` classes where profile is a class member, for LMS |
-| `addCourseToClass(classId, courseId, order)` | Insert `class_course` row |
-| `removeCourseFromClass(classId, courseId)` | Delete `class_course` row |
-| `getCoursesByClass(classId)` | All courses in class ordered by `order`, joined to `course` |
-| `getStudentMemberIdsByClass(classId)` | All `profileId` values with `roleId = 3` in class (for auto-enrollment) |
-| `createClassAnnouncement(data)` | Insert `class_announcement` |
-| `getClassAnnouncements(classId)` | All announcements ordered by `createdAt` desc, joined to `profile` |
-| `updateClassAnnouncement(announcementId, data)` | Update title/body |
-| `deleteClassAnnouncement(announcementId)` | Delete row |
-| `addClassFile(data)` | Insert `class_file` |
-| `getClassFiles(classId)` | All files ordered by `createdAt` desc |
-| `deleteClassFile(fileId)` | Delete `class_file` by `id` |
-
-Export from: `packages/db/src/queries/class/index.ts`
-
-### Service Layer
-
-File: `apps/api/src/services/class/class.ts`
-
-#### `createClass(orgId, profileId, data: TCreateClass)`
-
-- Insert `class` row.
-- Add creator as `class_member` with `roleId = 1` (ADMIN).
-- Return the new class.
-
-#### `addCourseToClass(classId, courseId)`
-
-- Verify class exists and course belongs to the same org.
-- Insert `class_course` row (error if already linked).
-- Fetch all current STUDENT class members (`getStudentMemberIdsByClass`).
-- For each student profile, look up their `groupmember` status in the course's group; if not already enrolled, call `enrollInCourse` (or insert `groupmember` directly if the course is free and no invite is needed).
-- All writes in a single transaction.
-- Return updated course list for the class.
-
-#### `removeCourseFromClass(classId, courseId)`
-
-- Delete `class_course` row.
-- No changes to `groupmember` records.
-- Return updated course list.
-
-#### `addMembersToClass(classId, members: TAddClassMembers['members'])`
-
-Transaction:
-1. For each member in the batch, resolve `profileId` from `email` (look up `profile` by email, create if none exists as an invited-but-unregistered user following the same pattern as `addGroupMember`).
-2. Insert `class_member` row (skip if already a member of the class).
-3. If `roleId = 3` (STUDENT), fetch all courses in the class (`getCoursesByClass`). For each course, check if the student is already a `groupmember`; if not, insert a `groupmember` row with `roleId = 3`.
-
-#### `removeMemberFromClass(classId, memberId)`
-
-- Delete `class_member` row by `id`.
-- Leave all `groupmember` rows in individual courses intact.
-
-#### `createAnnouncement(classId, profileId, data: TCreateClassAnnouncement)`
-
-- Verify caller is class admin or tutor.
-- Insert `class_announcement` row.
-- Return new announcement.
-
-#### `addFile(classId, profileId, data: TAddClassFile)`
-
-- Insert `class_file` row.
-- Return new file record.
-
-#### `deleteFile(fileId, profileId)`
-
-- Verify caller is class admin or tutor.
-- Delete `class_file` row.
-
-### Route Layer
-
-File: `apps/api/src/routes/class/class.ts`
-
-All routes require `authMiddleware`. Routes scoped to a `:classId` also apply `classAccessMiddleware` (read) or `classAdminMiddleware` (write) as noted.
-
-| Method | Path | Middleware | Description |
-| --- | --- | --- | --- |
-| `GET` | `/class` | `authMiddleware` | List org's classes (org admin sees all; tutors/students see their own) |
-| `POST` | `/class` | `authMiddleware` + orgAdmin | Create class |
-| `GET` | `/class/:classId` | `classAccessMiddleware` | Get class with member/course counts |
-| `PUT` | `/class/:classId` | `classAdminMiddleware` | Update class name, description, cover, status |
-| `DELETE` | `/class/:classId` | orgAdmin | Archive class (`status = 'ARCHIVED'`) |
-| `GET` | `/class/:classId/courses` | `classAccessMiddleware` | List courses in class (ordered) |
-| `POST` | `/class/:classId/courses` | `classAdminMiddleware` | Add course to class + auto-enroll students |
-| `DELETE` | `/class/:classId/courses/:courseId` | `classAdminMiddleware` | Remove course from class |
-| `GET` | `/class/:classId/members` | `classAdminMiddleware` | List class members with profile info |
-| `POST` | `/class/:classId/members` | `classAdminMiddleware` | Batch-add members + auto-enroll students |
-| `PUT` | `/class/:classId/members/:memberId` | `classAdminMiddleware` | Update member role |
-| `DELETE` | `/class/:classId/members/:memberId` | `classAdminMiddleware` | Remove member from class |
-| `GET` | `/class/:classId/announcements` | `classAccessMiddleware` | List announcements |
-| `POST` | `/class/:classId/announcements` | `classAdminMiddleware` | Create announcement |
-| `PUT` | `/class/:classId/announcements/:announcementId` | `classAdminMiddleware` | Update announcement |
-| `DELETE` | `/class/:classId/announcements/:announcementId` | `classAdminMiddleware` | Delete announcement |
-| `GET` | `/class/:classId/files` | `classAccessMiddleware` | List files |
-| `POST` | `/class/:classId/files` | `classAdminMiddleware` | Add file record |
-| `DELETE` | `/class/:classId/files/:fileId` | `classAdminMiddleware` | Delete file |
-
-#### Route Registration
-
-```typescript
-// apps/api/src/routes/class/index.ts
-export * from './class';
-
-// apps/api/src/app.ts
-import { classRouter } from '@api/routes/class';
-export const app = new Hono()
-  // ... existing routes ...
-  .route('/class', classRouter);
-```
-
-#### LMS Enrolled Classes Route
-
-Add to `apps/api/src/routes/organization/organization.ts`:
-
-```
-GET /organization/classes/enrolled
-```
-
-Returns all `ACTIVE` classes where the current user is a STUDENT `class_member`, including the course list with per-course progress. Used by the LMS "My Classes" and "Class Hub" pages.
-
-#### Build Verification
-
-```bash
-pnpm --filter @cio/utils build
-pnpm --filter @cio/db build
-pnpm --filter @cio/api build
-```
-
----
-
-## Frontend Plan (Dashboard)
-
-### Request Types
-
-File: `apps/dashboard/src/lib/features/class/utils/types.ts`
-
-```typescript
-import { classroomio, type InferResponseType } from '$lib/utils/services/api';
-
-export type ListClassesRequest = typeof classroomio.class.$get;
-export type CreateClassRequest = typeof classroomio.class.$post;
-export type GetClassRequest = typeof classroomio.class[':classId']['$get'];
-export type UpdateClassRequest = typeof classroomio.class[':classId']['$put'];
-export type ListClassCoursesRequest = typeof classroomio.class[':classId']['courses']['$get'];
-export type AddCourseToClassRequest = typeof classroomio.class[':classId']['courses']['$post'];
-export type ListClassMembersRequest = typeof classroomio.class[':classId']['members']['$get'];
-export type AddClassMembersRequest = typeof classroomio.class[':classId']['members']['$post'];
-export type ListAnnouncementsRequest = typeof classroomio.class[':classId']['announcements']['$get'];
-export type CreateAnnouncementRequest = typeof classroomio.class[':classId']['announcements']['$post'];
-export type ListClassFilesRequest = typeof classroomio.class[':classId']['files']['$get'];
-
-export type ListClassesSuccess = Extract<InferResponseType<ListClassesRequest>, { success: true }>;
-export type ClassItem = ListClassesSuccess['data'][number];
-
-export type GetClassSuccess = Extract<InferResponseType<GetClassRequest>, { success: true }>;
-export type ClassDetail = GetClassSuccess['data'];
-
-export type ListClassCoursesSuccess = Extract<InferResponseType<ListClassCoursesRequest>, { success: true }>;
-export type ClassCourse = ListClassCoursesSuccess['data'][number];
-
-export type ListClassMembersSuccess = Extract<InferResponseType<ListClassMembersRequest>, { success: true }>;
-export type ClassMember = ListClassMembersSuccess['data'][number];
-
-export type ListAnnouncementsSuccess = Extract<InferResponseType<ListAnnouncementsRequest>, { success: true }>;
-export type ClassAnnouncement = ListAnnouncementsSuccess['data'][number];
-
-export type ListClassFilesSuccess = Extract<InferResponseType<ListClassFilesRequest>, { success: true }>;
-export type ClassFile = ListClassFilesSuccess['data'][number];
-
-// LMS enrolled classes
-export type EnrolledClassesRequest = typeof classroomio.organization.classes.enrolled['$get'];
-export type EnrolledClassesSuccess = Extract<InferResponseType<EnrolledClassesRequest>, { success: true }>;
-export type EnrolledClass = EnrolledClassesSuccess['data'][number];
-```
-
-### API Class
-
-File: `apps/dashboard/src/lib/features/class/api/class.svelte.ts`
-
-```typescript
-class ClassApi extends BaseApiWithErrors {
-  classes = $state<ClassItem[]>([]);
-  currentClass = $state<ClassDetail | null>(null);
-  courses = $state<ClassCourse[]>([]);
-  members = $state<ClassMember[]>([]);
-  announcements = $state<ClassAnnouncement[]>([]);
-  files = $state<ClassFile[]>([]);
-  loading = $state(false);
-
-  async list() { /* GET /class */ }
-  async get(classId: string) { /* GET /class/:classId */ }
-  async create(data: TCreateClass) { /* POST /class */ }
-  async update(classId: string, data: TUpdateClass) { /* PUT /class/:classId */ }
-  async archive(classId: string) { /* DELETE /class/:classId */ }
-
-  async listCourses(classId: string) { /* GET /class/:classId/courses */ }
-  async addCourse(classId: string, data: TAddCourseToClass) { /* POST /class/:classId/courses */ }
-  async removeCourse(classId: string, courseId: string) { /* DELETE /class/:classId/courses/:courseId */ }
-
-  async listMembers(classId: string) { /* GET /class/:classId/members */ }
-  async addMembers(classId: string, data: TAddClassMembers) { /* POST /class/:classId/members */ }
-  async removeMember(classId: string, memberId: string) { /* DELETE /class/:classId/members/:memberId */ }
-
-  async listAnnouncements(classId: string) { /* GET /class/:classId/announcements */ }
-  async createAnnouncement(classId: string, data: TCreateClassAnnouncement) { /* POST */ }
-  async deleteAnnouncement(classId: string, announcementId: string) { /* DELETE */ }
-
-  async listFiles(classId: string) { /* GET /class/:classId/files */ }
-  async addFile(classId: string, data: TAddClassFile) { /* POST /class/:classId/files */ }
-  async deleteFile(classId: string, fileId: string) { /* DELETE /class/:classId/files/:fileId */ }
-}
-
-export const classApi = new ClassApi();
-```
-
-### LMS API Class
-
-File: `apps/dashboard/src/lib/features/lms/api/class.svelte.ts`
-
-```typescript
-class LmsClassApi extends BaseApiWithErrors {
-  enrolledClasses = $state<EnrolledClass[]>([]);
-  loading = $state(false);
-
-  async listEnrolled() { /* GET /organization/classes/enrolled */ }
-}
-
-export const lmsClassApi = new LmsClassApi();
-```
-
-### Admin Pages
-
-| Route | File | Purpose |
-| --- | --- | --- |
-| `/courses/classes` | `apps/dashboard/src/routes/courses/classes/+page.svelte` | List all org classes |
-| `/courses/classes/new` | `apps/dashboard/src/routes/courses/classes/new/+page.svelte` | Create class form |
-| `/courses/classes/[classId]` | `apps/dashboard/src/routes/courses/classes/[classId]/+page.svelte` | Class overview |
-| `/courses/classes/[classId]/courses` | `.../courses/+page.svelte` | Manage courses |
-| `/courses/classes/[classId]/people` | `.../people/+page.svelte` | Manage members |
-| `/courses/classes/[classId]/announcements` | `.../announcements/+page.svelte` | Manage announcements |
-| `/courses/classes/[classId]/files` | `.../files/+page.svelte` | File library management |
-
-Feature pages live in: `apps/dashboard/src/lib/features/class/pages/`
-
-### LMS Pages
-
-| Route | File | Purpose |
-| --- | --- | --- |
-| `/lms/classes` | `apps/dashboard/src/routes/lms/classes/+page.svelte` | My enrolled classes |
-| `/lms/classes/[classId]` | `apps/dashboard/src/routes/lms/classes/[classId]/+page.svelte` | Class hub (courses + announcements + files) |
-| `/lms/classes/[classId]/community` | `.../community/+page.svelte` | Class community Q&A |
-
-Feature pages live in: `apps/dashboard/src/lib/features/lms/pages/class/`
-
-### Navigation Updates
-
-**Org admin sidebar** (`apps/dashboard/src/lib/features/org/`):
-- Add "Classes" nav item at the same level as "Courses", linking to `/courses/classes`.
-- Use a suitable icon (e.g., a group/layers icon).
-
-**LMS sidebar** (`apps/dashboard/src/lib/features/lms/`):
-- Add "Classes" nav item (shown conditionally: only when `enrolledClasses.length > 0`).
-- Position between "My Learning" and "Exercises".
-
-### Translations
-
-File: `apps/dashboard/src/lib/utils/translations/en.json`
-
-Add keys under `class`:
-
-```json
-{
-  "class": {
-    "title": "Classes",
-    "my_classes": "My Classes",
-    "create": "Create Class",
-    "create_description": "Group multiple courses and materials under one class for your students.",
-    "name": "Class Name",
-    "description": "Description",
-    "cover_image": "Cover Image",
-    "status": "Status",
-    "active": "Active",
-    "inactive": "Inactive",
-    "archived": "Archived",
-    "courses": "Courses",
-    "people": "People",
-    "announcements": "Announcements",
-    "files": "Files",
-    "community": "Community",
-    "add_course": "Add Course",
-    "remove_course": "Remove Course",
-    "add_members": "Add Members",
-    "remove_member": "Remove Member",
-    "course_count": "{count} courses",
-    "student_count": "{count} students",
-    "new_announcement": "New Announcement",
-    "announcement_title": "Announcement Title",
-    "announcement_body": "Write your announcement...",
-    "upload_file": "Upload File",
-    "no_classes": "No classes yet. Create one to get started.",
-    "no_courses": "No courses in this class yet.",
-    "no_members": "No members yet. Add students or tutors.",
-    "no_announcements": "No announcements yet.",
-    "no_files": "No files uploaded yet.",
-    "archive_confirm": "Archiving this class will hide it from all views. Are you sure?",
-    "auto_enroll_note": "Adding this course will enroll all current class students in it.",
-    "remove_course_note": "Removing this course will not unenroll any students.",
-    "remove_member_note": "Removing this member will not unenroll them from individual courses."
-  }
-}
-```
-
-### Frontend Build Verification
-
-```bash
-pnpm --filter @cio/dashboard build
-```
-
----
-
-## Implementation Order
-
-### Phase 1: Database + Schema
-
-1. Add `classStatus` enum to `packages/db/src/schema.ts`.
-2. Add `lmsClass`, `classCourse`, `classMember`, `classAnnouncement`, `classFile` tables to schema.
-3. Add `classId` FK column to `communityQuestion` table in schema.
-4. Write and apply migration SQL: `packages/db/src/migrations/XXXX_add_classes.sql`.
-5. Run `pnpm --filter @cio/db build`.
-
-### Phase 2: Validation + Queries
-
-1. Create `packages/utils/src/validation/class/class.ts` with all Zod schemas.
-2. Export from `packages/utils/src/validation/class/index.ts` and re-export from `packages/utils/src/validation/index.ts`.
-3. Run `pnpm --filter @cio/utils build`.
-4. Create `packages/db/src/queries/class/class.ts` with all query functions.
-5. Create `packages/db/src/queries/class/index.ts` and export.
-6. Run `pnpm --filter @cio/db build`.
-
-### Phase 3: Service + Routes
-
-1. Create `apps/api/src/services/class/class.ts` with all service functions (auto-enrollment transactions are the most complex part).
-2. Create access control utilities: `apps/api/src/middleware/class-access.ts` and `apps/api/src/middleware/class-admin.ts`.
-3. Add new error codes to `apps/api/src/utils/errors.ts`: `CLASS_NOT_FOUND`, `CLASS_FORBIDDEN`, `COURSE_ALREADY_IN_CLASS`, `MEMBER_ALREADY_IN_CLASS`.
-4. Create `apps/api/src/routes/class/class.ts` with all route handlers.
-5. Create `apps/api/src/routes/class/index.ts` and register in `apps/api/src/app.ts`.
-6. Add `GET /organization/classes/enrolled` to the organization router.
-7. Run `pnpm --filter @cio/api build`.
-
-### Phase 4: Admin Frontend
-
-1. Add request/response types to `apps/dashboard/src/lib/features/class/utils/types.ts`.
-2. Create `apps/dashboard/src/lib/features/class/api/class.svelte.ts` API class.
-3. Add translation keys to `en.json`.
-4. Create admin feature pages under `apps/dashboard/src/lib/features/class/pages/`.
-5. Create SvelteKit route files under `apps/dashboard/src/routes/courses/classes/`.
-6. Add "Classes" nav item to the org admin sidebar.
-7. Run `pnpm --filter @cio/dashboard build`.
-
-### Phase 5: LMS Frontend
-
-1. Create `apps/dashboard/src/lib/features/lms/api/class.svelte.ts`.
-2. Create LMS feature pages under `apps/dashboard/src/lib/features/lms/pages/class/`.
-3. Create SvelteKit route files under `apps/dashboard/src/routes/lms/classes/`.
-4. Add "Classes" nav item to the LMS sidebar (conditional on having enrolled classes).
-5. Run `pnpm --filter @cio/dashboard build`.
-
----
-
-## Acceptance Criteria
-
-1. Org admin can create a class, add courses to it, and add students — all from the admin dashboard.
-2. When a student is added to a class, `groupmember` rows are automatically created for every course in the class.
-3. When a course is added to an existing class that already has students, all those students are enrolled in the new course.
-4. Removing a student from a class does not remove their `groupmember` records in individual courses.
-5. Removing a course from a class does not unenroll any students.
-6. Students see a "Classes" section in the LMS sidebar (only when enrolled in at least one class).
-7. The class hub page shows all courses with per-course progress bars, the announcements feed, and the file library.
-8. Class admins and tutors can post announcements and upload files; students can only view them.
-9. Class community Q&A is scoped to the class and does not appear on course community boards.
-10. `INACTIVE` classes are hidden from the student LMS but remain fully accessible to admins and tutors.
-11. `ARCHIVED` classes are hidden from all views.
-12. Courses that are not in any class, and courses whose students were enrolled independently, continue to work exactly as they do today (zero regression on existing `groupmember` and course data).
-13. All user-facing strings use translation keys (no hardcoded English).
-14. `pnpm --filter @cio/api build` and `pnpm --filter @cio/dashboard build` pass after implementation.
-
----
-
-## Risks and Mitigations
-
-- **Risk**: Auto-enrollment transaction for large classes (hundreds of students, tens of courses) times out or partially fails.
-  - **Mitigation**: Process auto-enrollment in the service layer using a single transaction with batch inserts (insert multiple `groupmember` rows in one query using Drizzle's batch insert). For very large classes (> 500 students), offload to a background job via the existing email job queue or a new async task runner, and return a `202 Accepted` with a polling endpoint.
-
-- **Risk**: A student is already enrolled in a course independently before being added to a class. Duplicate `groupmember` rows violate the `(groupId, profileId)` unique constraint.
-  - **Mitigation**: The enrollment logic in `addMembersToClass` must check for existing membership before inserting. Use `INSERT ... ON CONFLICT DO NOTHING` or check with `isUserCourseMember` before inserting. This is already idempotent in the existing enrollment service.
-
-- **Risk**: The `community_question.classId` column causes existing community queries to break if they don't filter by `classId IS NULL` for course-scoped questions.
-  - **Mitigation**: Add `classId IS NULL` to all existing community query filters where `courseId` is used. The column is nullable so existing rows default to NULL and behavior is unchanged. Update `packages/db/src/queries/community/community.ts` alongside the schema migration.
-
-- **Risk**: Removing a course from a class causes confusion: students are still enrolled in the course but it no longer appears in the class hub.
-  - **Mitigation**: Show a confirmation dialog in the admin UI with the note: "Removing this course will not unenroll any students. They will still have access to it via My Learning." Use the `class.remove_course_note` translation key already specified.
-
-- **Risk**: Org nav gets crowded with a new "Classes" top-level item.
-  - **Mitigation**: Place "Classes" directly below "Courses" in the sidebar. Consider grouping them under a "Learning" section header if more items are added in future.
diff --git a/prd/programs/README.md b/prd/programs/README.md
new file mode 100644
index 00000000..3803f45b
--- /dev/null
+++ b/prd/programs/README.md
@@ -0,0 +1,993 @@
+# Programs PRD
+
+## Purpose
+
+Enable instructors and org admins to group multiple courses — along with shared announcements, files, and community discussions — into a single **program**. Enrolling a student in a program auto-enrolls them in every course inside it, eliminating the need to manage per-course enrollment manually when delivering a structured program.
+
+## Problem Statement
+
+Currently, ClassroomIO has no entity above the individual course. Every course has its own independent enrollment roster. This creates several pain points:
+
+- An instructor running a program (e.g., a bootcamp, onboarding track, or certification pathway) must enroll students in each constituent course one by one.
+- There is no shared space for program-wide announcements, files, or discussions that span multiple courses.
+- Students cannot see a unified "program" view in the LMS — they only see a flat list of individual courses.
+- Org admins have no way to bundle courses for a specific cohort of learners (e.g., "Q1 2026 New Hire Onboarding") without creating separate organizations or duplicating content.
+
+## Confirmed Decisions
+
+1. **Terminology**: "Program" in both the instructor-facing admin UI and the student-facing LMS.
+2. **Auto-enrollment**: Joining a program automatically creates `groupmember` records for every course inside the program. Removing a student from a program does not remove them from individual course groups, preserving their submission and progress data.
+3. **Shared materials**: Each program has three shared material surfaces: announcements (instructor-authored posts), a file library, and a community Q&A board.
+4. **Many-to-many courses**: A course can belong to multiple programs. Courses and programs are independent entities linked by a join table.
+5. **LMS visibility**: Programs are visible to students in the LMS under a dedicated "Programs" section. Students see enrolled programs and can navigate courses from within a program hub page.
+6. **Roles**: Program roles mirror the existing system (`ADMIN`/roleId 1, `TUTOR`/roleId 2, `STUDENT`/roleId 3). Program admins and tutors can manage the program; program students get read access to materials.
+7. **Program status**: Programs can be `ACTIVE`, `INACTIVE`, or `ARCHIVED`. `INACTIVE` programs are hidden from students in the LMS but preserved for instructors. `ARCHIVED` programs are soft-deleted and hidden everywhere.
+8. **Course independence**: Courses in a program remain fully independent. A student enrolled in a program is a regular `groupmember` in each course — existing course pages, progress tracking, submissions, and grading are unchanged.
+9. **Community reuse**: The existing `community_question` table gains a nullable `programId` FK. Program-level Q&A behaves identically to course-level community Q&A but scoped to the program.
+
+## Current-State Audit
+
+| Capability | Current State | Notes |
+| --- | --- | --- |
+| Organization structure | `organization` → `group` (1:1 with `course`) → `course` | No intermediate grouping layer above course |
+| Course enrollment | `groupmember` rows per course's `group` | Per-course, no bulk enrollment mechanism |
+| Student LMS view | Flat list of enrolled courses under `/lms/mylearning` | No program/program concept |
+| Community Q&A | `community_question.courseId` scoped | Reusable with additional `programId` FK |
+| Shared file library | Per-course via `assets` table; no org-wide shared files | New `program_file` table needed |
+| Announcements | Per-course `course_newsfeed` | New `program_announcement` table needed |
+| Org admin navigation | "Courses" section listing all courses | "Programs" nav item needed |
+| LMS navigation | Home, My Learning, Exercises, Community, Explore, Settings | "Programs" nav item needed |
+| Enrollment service | `enrollInCourse()` in `apps/api/src/services/course/invite.ts` | Must be called per-course when adding program member |
+
+**Key insight**: Because enrollment = `groupmember` rows per course, adding a student to a program is purely a matter of calling the existing enrollment logic for each course in the program within a single transaction. No course-level schema changes are needed.
+
+## Product Goals
+
+1. Org admins and instructors can create a program, add courses to it, and manage program membership from the admin dashboard.
+2. Adding a student to a program auto-enrolls them in all courses currently in the program.
+3. Adding a new course to an existing program auto-enrolls all current program students in that course.
+4. Each program has a shared announcements feed, file library, and community board visible to all program members.
+5. Students can see their enrolled programs in the LMS with a unified hub view showing all courses, announcements, and files.
+6. Programs without students, and courses outside any program, continue to work exactly as they do today (zero regression).
+
+## Non-Goals (v1)
+
+- Program-level invite links (v1 enrollment is admin-managed; students cannot self-enroll in a program via a token).
+- Program-specific exercise deadlines or content overrides (courses are shared as-is).
+- Program progress analytics aggregated across all courses (available per-course; cross-course aggregation is a future improvement).
+- Removing a student from a program also unenrolling them from individual courses (data preservation is the default).
+- Program templates or program cloning.
+- Public/discoverable program landing pages (programs are private to org members).
+- Billing or pricing at the program level.
+- Program-level attendance tracking separate from per-course attendance.
+
+## Data Sources Checked
+
+- `packages/db/src/schema.ts` — all table definitions and constraint patterns
+- `apps/api/src/services/course/course.ts` — course creation flow
+- `apps/api/src/services/course/invite.ts` — enrollment flow (`enrollInCourse`)
+- `apps/api/src/routes/course/course.ts` — course router and sub-router mounting
+- `apps/api/src/app.ts` — top-level router registration
+- `packages/db/src/queries/course/people.ts` — group member management
+- `packages/db/src/queries/group/group.ts` — group/member queries
+- `packages/db/src/queries/community/community.ts` — community Q&A pattern
+- `apps/dashboard/src/lib/features/lms/` — LMS navigation and pages
+- `apps/dashboard/src/lib/features/org/` — org admin navigation
+- `apps/dashboard/src/routes/lms/` — LMS SvelteKit routes
+- `apps/dashboard/src/routes/courses/` — course admin SvelteKit routes
+
+## Functional Requirements
+
+### 1. Program CRUD (Admin)
+
+- Org admins can create a program with: name (required), description (optional), cover image (optional).
+- Programs can be updated (name, description, cover image, status).
+- Archiving a program sets `status = 'ARCHIVED'` and hides it from all views. Archived programs can be restored.
+- A program belongs to exactly one organization.
+- Program names do not need to be unique within an org (unlike course slugs), but should be descriptive.
+
+### 2. Course Management in a Program (Admin)
+
+- Org admins and program tutors can add existing org courses to a program.
+- A course can belong to multiple programs simultaneously.
+- Adding a course to a program triggers auto-enrollment: all existing `STUDENT` program members are enrolled in the new course (a `groupmember` row is created in the course's `group` for each student not already enrolled).
+- Removing a course from a program does not unenroll any students from that course. Their progress and submissions are preserved.
+- Courses within a program are ordered (integer `order` field) so instructors can sequence them.
+
+### 3. Program Membership (Admin)
+
+- Org admins can add members to a program by profile ID or email, assigning them a role (ADMIN, TUTOR, or STUDENT).
+- Adding a STUDENT member triggers auto-enrollment: a `groupmember` row is created in every course currently in the program (skipping courses the student is already enrolled in; idempotent).
+- Adding an ADMIN or TUTOR member does not auto-enroll them in courses (their course-level permissions are managed separately via course membership).
+- Removing a member from a program removes the `program_member` row only. Individual `groupmember` rows in courses are left intact, preserving submissions, grades, and progress.
+- Batch add: admins can add multiple members at once (array of `{ email, roleId }` pairs).
+
+### 4. Program Announcements (Admin + LMS)
+
+- Program admins and tutors can post announcements to the program feed.
+- Announcements have a title and a rich-text body.
+- Announcements are visible to all program members (students, tutors, and admins) in both the admin program view and the LMS program hub.
+- Students cannot post announcements (read-only for students).
+- Announcements are ordered by `createdAt` descending (newest first).
+
+### 5. Program File Library (Admin + LMS)
+
+- Program admins and tutors can upload files to the program file library.
+- Each file record stores: name, URL (stored via the existing presigned upload flow), MIME type, size, uploader profile ID.
+- All program members can view and download files.
+- Only program admins and tutors can delete files.
+
+### 6. Program Community (Admin + LMS)
+
+- Program-level community Q&A reuses the existing `community_question` / `community_answer` infrastructure.
+- A nullable `programId` FK is added to `community_question`. Questions with `programId` set are program-scoped (not visible on the course-level community board).
+- All program members can post questions and answers in the program community.
+- The existing voting, commenting, and answer-acceptance behavior is unchanged.
+
+### 7. LMS — My Programs (Student)
+
+- A "Programs" nav item appears in the LMS sidebar when the student is enrolled in at least one program.
+- The `/lms/programs` page lists all programs the student is enrolled in.
+- Each program card shows: program name, cover image, number of courses, brief description.
+- Clicking a program opens the program hub page.
+
+### 8. LMS — Program Hub (Student)
+
+- The program hub at `/lms/programs/[programId]` is the student's central page for a program.
+- It is divided into three tabs or sections:
+  - **Courses**: All courses in the program, each with the student's individual progress bar and a direct link to the course. Courses are shown in the instructor-defined order.
+  - **Announcements**: Program announcements in reverse-chronological order (read-only for students).
+  - **Resources**: The program file library (download only) and a link to the program community board.
+- The program community board lives at `/lms/programs/[programId]/community` and behaves identically to the existing course community pages.
+
+### 9. Admin — Programs Section
+
+- "Programs" is added as a top-level nav item in the org admin sidebar, alongside "Courses".
+- The `/courses/programs` page lists all org programs with name, course count, student count, and status badge.
+- A "Create Program" button opens a creation form.
+- Each program links to a program detail view with sub-pages: Overview, Courses, People, Announcements, Files.
+
+### 10. Access Control
+
+- Only `ADMIN` and `TUTOR` role members of a program (or org admins) can manage program content and membership.
+- Students can read announcements and files, participate in the community, and view the course list.
+- A student who is removed from the org loses access to all program content.
+- An `INACTIVE` program is hidden from students in the LMS but all data is preserved.
+
+---
+
+## Technical Design
+
+### Data Model
+
+#### New Enum: `PROGRAM_STATUS`
+
+```typescript
+// packages/db/src/schema.ts
+export const programStatus = pgEnum('PROGRAM_STATUS', ['ACTIVE', 'INACTIVE', 'ARCHIVED']);
+```
+
+#### New Table: `program`
+
+```typescript
+// packages/db/src/schema.ts
+export const lmsProgram = pgTable(
+  'program',
+  {
+    id: uuid()
+      .default(sql`gen_random_uuid()`)
+      .primaryKey()
+      .notNull(),
+    createdAt: timestamp('created_at', { withTimezone: true, mode: 'string' }).defaultNow().notNull(),
+    updatedAt: timestamp('updated_at', { withTimezone: true, mode: 'string' }).defaultNow(),
+    organizationId: uuid('organization_id').notNull(),
+    name: varchar().notNull(),
+    description: text(),
+    coverImage: text('cover_image'),
+    status: programStatus().default('ACTIVE').notNull(),
+    createdByProfileId: uuid('created_by_profile_id')
+  },
+  (table) => [
+    foreignKey({
+      columns: [table.organizationId],
+      foreignColumns: [organization.id],
+      name: 'class_organization_id_fkey'
+    }).onDelete('cascade'),
+    foreignKey({
+      columns: [table.createdByProfileId],
+      foreignColumns: [profile.id],
+      name: 'class_created_by_profile_id_fkey'
+    }),
+    index('idx_program_organization_id').on(table.organizationId)
+  ]
+);
+```
+
+#### New Table: `program_course`
+
+Many-to-many join between program and course, with an instructor-controlled display order.
+
+```typescript
+// packages/db/src/schema.ts
+export const programCourse = pgTable(
+  'program_course',
+  {
+    id: uuid()
+      .default(sql`gen_random_uuid()`)
+      .primaryKey()
+      .notNull(),
+    programId: uuid('program_id').notNull(),
+    courseId: uuid('course_id').notNull(),
+    order: integer().default(0).notNull(),
+    addedAt: timestamp('added_at', { withTimezone: true, mode: 'string' }).defaultNow().notNull()
+  },
+  (table) => [
+    foreignKey({
+      columns: [table.programId],
+      foreignColumns: [lmsProgram.id],
+      name: 'program_course_class_id_fkey'
+    }).onDelete('cascade'),
+    foreignKey({
+      columns: [table.courseId],
+      foreignColumns: [course.id],
+      name: 'program_course_course_id_fkey'
+    }).onDelete('cascade'),
+    unique('program_course_class_id_course_id_unique').on(table.programId, table.courseId),
+    index('idx_program_course_class_id').on(table.programId)
+  ]
+);
+```
+
+#### New Table: `program_member`
+
+Membership roster for a program. Does not replace `groupmember` — it is a separate layer.
+
+```typescript
+// packages/db/src/schema.ts
+export const programMember = pgTable(
+  'program_member',
+  {
+    id: uuid()
+      .default(sql`gen_random_uuid()`)
+      .primaryKey()
+      .notNull(),
+    programId: uuid('program_id').notNull(),
+    profileId: uuid('profile_id'),
+    roleId: integer('role_id').notNull(),
+    email: text(),
+    createdAt: timestamp('created_at', { withTimezone: true, mode: 'string' }).defaultNow().notNull()
+  },
+  (table) => [
+    foreignKey({
+      columns: [table.programId],
+      foreignColumns: [lmsProgram.id],
+      name: 'program_member_class_id_fkey'
+    }).onDelete('cascade'),
+    foreignKey({
+      columns: [table.profileId],
+      foreignColumns: [profile.id],
+      name: 'program_member_profile_id_fkey'
+    }),
+    foreignKey({
+      columns: [table.roleId],
+      foreignColumns: [role.id],
+      name: 'program_member_role_id_fkey'
+    }),
+    unique('program_member_class_id_profile_id_unique').on(table.programId, table.profileId),
+    index('idx_program_member_class_id').on(table.programId),
+    index('idx_program_member_profile_id').on(table.profileId)
+  ]
+);
+```
+
+#### New Table: `program_announcement`
+
+```typescript
+// packages/db/src/schema.ts
+export const programAnnouncement = pgTable(
+  'program_announcement',
+  {
+    id: uuid()
+      .default(sql`gen_random_uuid()`)
+      .primaryKey()
+      .notNull(),
+    programId: uuid('program_id').notNull(),
+    authorProfileId: uuid('author_profile_id'),
+    title: varchar().notNull(),
+    body: text(),
+    createdAt: timestamp('created_at', { withTimezone: true, mode: 'string' }).defaultNow().notNull(),
+    updatedAt: timestamp('updated_at', { withTimezone: true, mode: 'string' }).defaultNow()
+  },
+  (table) => [
+    foreignKey({
+      columns: [table.programId],
+      foreignColumns: [lmsProgram.id],
+      name: 'program_announcement_class_id_fkey'
+    }).onDelete('cascade'),
+    foreignKey({
+      columns: [table.authorProfileId],
+      foreignColumns: [profile.id],
+      name: 'program_announcement_author_profile_id_fkey'
+    }),
+    index('idx_program_announcement_class_id').on(table.programId)
+  ]
+);
+```
+
+#### New Table: `program_file`
+
+```typescript
+// packages/db/src/schema.ts
+export const programFile = pgTable(
+  'program_file',
+  {
+    id: uuid()
+      .default(sql`gen_random_uuid()`)
+      .primaryKey()
+      .notNull(),
+    programId: uuid('program_id').notNull(),
+    uploadedByProfileId: uuid('uploaded_by_profile_id'),
+    name: varchar().notNull(),
+    url: text().notNull(),
+    mimeType: varchar('mime_type'),
+    size: integer(),
+    createdAt: timestamp('created_at', { withTimezone: true, mode: 'string' }).defaultNow().notNull()
+  },
+  (table) => [
+    foreignKey({
+      columns: [table.programId],
+      foreignColumns: [lmsProgram.id],
+      name: 'program_file_class_id_fkey'
+    }).onDelete('cascade'),
+    foreignKey({
+      columns: [table.uploadedByProfileId],
+      foreignColumns: [profile.id],
+      name: 'program_file_uploaded_by_profile_id_fkey'
+    }),
+    index('idx_program_file_class_id').on(table.programId)
+  ]
+);
+```
+
+#### Modified Table: `community_question`
+
+Add a nullable `programId` FK so community questions can be scoped to a program:
+
+```typescript
+// Add to community_question table columns:
+programId: uuid('program_id')
+
+// Add to community_question table constraints:
+foreignKey({
+  columns: [table.programId],
+  foreignColumns: [lmsProgram.id],
+  name: 'community_question_class_id_fkey'
+}).onDelete('cascade')
+```
+
+When `programId` is set, the question is program-scoped. When `courseId` is set, it is course-scoped. The two are mutually exclusive in practice (enforced at the service layer).
+
+#### Relationship Diagram
+
+```
+organization
+  └── program
+        ├── program_course  ──────────────────────→  course
+        │     (order, addedAt)                        └── group → groupmember ← (auto-created)
+        ├── program_member  ──────────────────────→  profile
+        │     (roleId: ADMIN/TUTOR/STUDENT)
+        ├── program_announcement
+        │     (title, body, authorProfileId)
+        ├── program_file
+        │     (name, url, mimeType, size)
+        └── community_question (programId set)
+              └── community_answer
+```
+
+### Migration
+
+File: `packages/db/src/migrations/XXXX_add_programs.sql`
+
+```sql
+-- 1. Create PROGRAM_STATUS enum
+CREATE TYPE "PROGRAM_STATUS" AS ENUM ('ACTIVE', 'INACTIVE', 'ARCHIVED');
+
+-- 2. Create program table
+CREATE TABLE program (
+  id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
+  created_at TIMESTAMPTZ NOT NULL DEFAULT NOW(),
+  updated_at TIMESTAMPTZ DEFAULT NOW(),
+  organization_id UUID NOT NULL REFERENCES organization(id) ON DELETE CASCADE,
+  name VARCHAR NOT NULL,
+  description TEXT,
+  cover_image TEXT,
+  status "PROGRAM_STATUS" NOT NULL DEFAULT 'ACTIVE',
+  created_by_profile_id UUID REFERENCES profile(id)
+);
+
+CREATE INDEX idx_program_organization_id ON program(organization_id);
+
+-- 3. Create program_course join table
+CREATE TABLE program_course (
+  id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
+  program_id UUID NOT NULL REFERENCES program(id) ON DELETE CASCADE,
+  course_id UUID NOT NULL REFERENCES course(id) ON DELETE CASCADE,
+  "order" INTEGER NOT NULL DEFAULT 0,
+  added_at TIMESTAMPTZ NOT NULL DEFAULT NOW(),
+  UNIQUE(program_id, course_id)
+);
+
+CREATE INDEX idx_program_course_class_id ON program_course(program_id);
+
+-- 4. Create program_member table
+CREATE TABLE program_member (
+  id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
+  program_id UUID NOT NULL REFERENCES program(id) ON DELETE CASCADE,
+  profile_id UUID REFERENCES profile(id),
+  role_id INTEGER NOT NULL REFERENCES role(id),
+  email TEXT,
+  created_at TIMESTAMPTZ NOT NULL DEFAULT NOW(),
+  UNIQUE(program_id, profile_id)
+);
+
+CREATE INDEX idx_program_member_class_id ON program_member(program_id);
+CREATE INDEX idx_program_member_profile_id ON program_member(profile_id);
+
+-- 5. Create program_announcement table
+CREATE TABLE program_announcement (
+  id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
+  program_id UUID NOT NULL REFERENCES program(id) ON DELETE CASCADE,
+  author_profile_id UUID REFERENCES profile(id),
+  title VARCHAR NOT NULL,
+  body TEXT,
+  created_at TIMESTAMPTZ NOT NULL DEFAULT NOW(),
+  updated_at TIMESTAMPTZ DEFAULT NOW()
+);
+
+CREATE INDEX idx_program_announcement_class_id ON program_announcement(program_id);
+
+-- 6. Create program_file table
+CREATE TABLE program_file (
+  id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
+  program_id UUID NOT NULL REFERENCES program(id) ON DELETE CASCADE,
+  uploaded_by_profile_id UUID REFERENCES profile(id),
+  name VARCHAR NOT NULL,
+  url TEXT NOT NULL,
+  mime_type VARCHAR,
+  size INTEGER,
+  created_at TIMESTAMPTZ NOT NULL DEFAULT NOW()
+);
+
+CREATE INDEX idx_program_file_class_id ON program_file(program_id);
+
+-- 7. Add programId to community_question
+ALTER TABLE community_question ADD COLUMN program_id UUID REFERENCES program(id) ON DELETE CASCADE;
+```
+
+---
+
+## Access Control Logic
+
+Two middleware functions are needed in `apps/api/src/middleware/`:
+
+### `programAccessMiddleware` (read access)
+
+Verifies the caller is either an org admin or a `program_member` for the given `:programId`. Used on all `GET /program/:programId/*` routes.
+
+```typescript
+// apps/api/src/middleware/program-access.ts
+export async function programAccessMiddleware(c, next) {
+  const { programId } = c.req.param();
+  const user = c.get('user')!;
+  const isMember = await isProgramMember(programId, user.profileId);
+  const isOrgAdmin = await isOrgAdminByProgramId(programId, user.profileId);
+  if (!isMember && !isOrgAdmin) throw new AppError('Forbidden', ErrorCodes.FORBIDDEN, 403);
+  await next();
+}
+```
+
+### `programAdminMiddleware` (write access)
+
+Verifies the caller has `roleId` 1 (ADMIN) or 2 (TUTOR) within the program, or is an org admin. Used on all mutating routes.
+
+```typescript
+// apps/api/src/middleware/program-admin.ts
+export async function programAdminMiddleware(c, next) {
+  const { programId } = c.req.param();
+  const user = c.get('user')!;
+  const role = await getProgramMemberRole(programId, user.profileId);
+  const isOrgAdmin = await isOrgAdminByProgramId(programId, user.profileId);
+  if (!isOrgAdmin && (!role || role > 2)) throw new AppError('Forbidden', ErrorCodes.FORBIDDEN, 403);
+  await next();
+}
+```
+
+---
+
+## API and Route Plan
+
+### Validation Layer
+
+File: `packages/utils/src/validation/program/program.ts`
+
+```typescript
+import { z } from 'zod';
+
+export const ZCreateProgram = z.object({
+  name: z.string().min(1).max(255),
+  description: z.string().max(2000).optional(),
+  coverImage: z.string().url().optional()
+});
+export type TCreateProgram = z.infer<typeof ZCreateProgram>;
+
+export const ZUpdateProgram = z.object({
+  name: z.string().min(1).max(255).optional(),
+  description: z.string().max(2000).nullable().optional(),
+  coverImage: z.string().url().nullable().optional(),
+  status: z.enum(['ACTIVE', 'INACTIVE', 'ARCHIVED']).optional()
+});
+export type TUpdateProgram = z.infer<typeof ZUpdateProgram>;
+
+export const ZAddCourseToProgram = z.object({
+  courseId: z.string().uuid(),
+  order: z.number().int().min(0).optional()
+});
+export type TAddCourseToProgram = z.infer<typeof ZAddCourseToProgram>;
+
+export const ZAddProgramMembers = z.object({
+  members: z.array(
+    z.object({
+      email: z.string().email(),
+      roleId: z.number().int().min(1).max(3)
+    })
+  ).min(1)
+});
+export type TAddProgramMembers = z.infer<typeof ZAddProgramMembers>;
+
+export const ZUpdateProgramMember = z.object({
+  roleId: z.number().int().min(1).max(3)
+});
+export type TUpdateProgramMember = z.infer<typeof ZUpdateProgramMember>;
+
+export const ZCreateProgramAnnouncement = z.object({
+  title: z.string().min(1).max(500),
+  body: z.string().max(10000).optional()
+});
+export type TCreateProgramAnnouncement = z.infer<typeof ZCreateProgramAnnouncement>;
+
+export const ZUpdateProgramAnnouncement = z.object({
+  title: z.string().min(1).max(500).optional(),
+  body: z.string().max(10000).nullable().optional()
+});
+export type TUpdateProgramAnnouncement = z.infer<typeof ZUpdateProgramAnnouncement>;
+
+export const ZAddProgramFile = z.object({
+  name: z.string().min(1).max(255),
+  url: z.string().url(),
+  mimeType: z.string().optional(),
+  size: z.number().int().positive().optional()
+});
+export type TAddProgramFile = z.infer<typeof ZAddProgramFile>;
+```
+
+Export from: `packages/utils/src/validation/program/index.ts` and re-export from `packages/utils/src/validation/index.ts`.
+
+### Query Layer
+
+File: `packages/db/src/queries/program/program.ts`
+
+| Function | Description |
+| --- | --- |
+| `createProgram(data)` | Insert into `program`, return created row |
+| `getProgramById(programId)` | Single program with member count and course count |
+| `getProgramsByOrg(orgId)` | All non-archived programs for org, ordered by `createdAt` desc |
+| `updateProgram(programId, data)` | Update name, description, coverImage, status |
+| `getProgramMemberRole(programId, profileId)` | Return `roleId` for the given profile in the program, or null |
+| `isProgramMember(programId, profileId)` | Boolean check |
+| `isOrgAdminByProgramId(programId, profileId)` | Joins `program → organization → organizationmember` to check admin role |
+| `addProgramMember(programId, profileId, roleId, email)` | Insert `program_member` row (upsert on conflict) |
+| `removeProgramMember(programId, memberId)` | Delete `program_member` by `id` |
+| `getProgramMembers(programId)` | All members joined to `profile` for display |
+| `getEnrolledProgramsByProfile(orgId, profileId)` | All `ACTIVE` programs where profile is a program member, for LMS |
+| `addCourseToProgram(programId, courseId, order)` | Insert `program_course` row |
+| `removeCourseFromProgram(programId, courseId)` | Delete `program_course` row |
+| `getCoursesByProgram(programId)` | All courses in program ordered by `order`, joined to `course` |
+| `getStudentMemberIdsByProgram(programId)` | All `profileId` values with `roleId = 3` in program (for auto-enrollment) |
+| `createProgramAnnouncement(data)` | Insert `program_announcement` |
+| `getProgramAnnouncements(programId)` | All announcements ordered by `createdAt` desc, joined to `profile` |
+| `updateProgramAnnouncement(announcementId, data)` | Update title/body |
+| `deleteProgramAnnouncement(announcementId)` | Delete row |
+| `addProgramFile(data)` | Insert `program_file` |
+| `getProgramFiles(programId)` | All files ordered by `createdAt` desc |
+| `deleteProgramFile(fileId)` | Delete `program_file` by `id` |
+
+Export from: `packages/db/src/queries/program/index.ts`
+
+### Service Layer
+
+File: `apps/api/src/services/program/program.ts`
+
+#### `createProgram(orgId, profileId, data: TCreateProgram)`
+
+- Insert `program` row.
+- Add creator as `program_member` with `roleId = 1` (ADMIN).
+- Return the new program.
+
+#### `addCourseToProgram(programId, courseId)`
+
+- Verify program exists and course belongs to the same org.
+- Insert `program_course` row (error if already linked).
+- Fetch all current STUDENT program members (`getStudentMemberIdsByProgram`).
+- For each student profile, look up their `groupmember` status in the course's group; if not already enrolled, call `enrollInCourse` (or insert `groupmember` directly if the course is free and no invite is needed).
+- All writes in a single transaction.
+- Return updated course list for the program.
+
+#### `removeCourseFromProgram(programId, courseId)`
+
+- Delete `program_course` row.
+- No changes to `groupmember` records.
+- Return updated course list.
+
+#### `addMembersToProgram(programId, members: TAddProgramMembers['members'])`
+
+Transaction:
+1. For each member in the batch, resolve `profileId` from `email` (look up `profile` by email, create if none exists as an invited-but-unregistered user following the same pattern as `addGroupMember`).
+2. Insert `program_member` row (skip if already a member of the program).
+3. If `roleId = 3` (STUDENT), fetch all courses in the program (`getCoursesByProgram`). For each course, check if the student is already a `groupmember`; if not, insert a `groupmember` row with `roleId = 3`.
+
+#### `removeMemberFromProgram(programId, memberId)`
+
+- Delete `program_member` row by `id`.
+- Leave all `groupmember` rows in individual courses intact.
+
+#### `createAnnouncement(programId, profileId, data: TCreateProgramAnnouncement)`
+
+- Verify caller is program admin or tutor.
+- Insert `program_announcement` row.
+- Return new announcement.
+
+#### `addFile(programId, profileId, data: TAddProgramFile)`
+
+- Insert `program_file` row.
+- Return new file record.
+
+#### `deleteFile(fileId, profileId)`
+
+- Verify caller is program admin or tutor.
+- Delete `program_file` row.
+
+### Route Layer
+
+File: `apps/api/src/routes/program/program.ts`
+
+All routes require `authMiddleware`. Routes scoped to a `:programId` also apply `programAccessMiddleware` (read) or `programAdminMiddleware` (write) as noted.
+
+| Method | Path | Middleware | Description |
+| --- | --- | --- | --- |
+| `GET` | `/program` | `authMiddleware` | List org's programs (org admin sees all; tutors/students see their own) |
+| `POST` | `/program` | `authMiddleware` + orgAdmin | Create program |
+| `GET` | `/program/:programId` | `programAccessMiddleware` | Get program with member/course counts |
+| `PUT` | `/program/:programId` | `programAdminMiddleware` | Update program name, description, cover, status |
+| `DELETE` | `/program/:programId` | orgAdmin | Archive program (`status = 'ARCHIVED'`) |
+| `GET` | `/program/:programId/courses` | `programAccessMiddleware` | List courses in program (ordered) |
+| `POST` | `/program/:programId/courses` | `programAdminMiddleware` | Add course to program + auto-enroll students |
+| `DELETE` | `/program/:programId/courses/:courseId` | `programAdminMiddleware` | Remove course from program |
+| `GET` | `/program/:programId/members` | `programAdminMiddleware` | List program members with profile info |
+| `POST` | `/program/:programId/members` | `programAdminMiddleware` | Batch-add members + auto-enroll students |
+| `PUT` | `/program/:programId/members/:memberId` | `programAdminMiddleware` | Update member role |
+| `DELETE` | `/program/:programId/members/:memberId` | `programAdminMiddleware` | Remove member from program |
+| `GET` | `/program/:programId/announcements` | `programAccessMiddleware` | List announcements |
+| `POST` | `/program/:programId/announcements` | `programAdminMiddleware` | Create announcement |
+| `PUT` | `/program/:programId/announcements/:announcementId` | `programAdminMiddleware` | Update announcement |
+| `DELETE` | `/program/:programId/announcements/:announcementId` | `programAdminMiddleware` | Delete announcement |
+| `GET` | `/program/:programId/files` | `programAccessMiddleware` | List files |
+| `POST` | `/program/:programId/files` | `programAdminMiddleware` | Add file record |
+| `DELETE` | `/program/:programId/files/:fileId` | `programAdminMiddleware` | Delete file |
+
+#### Route Registration
+
+```typescript
+// apps/api/src/routes/program/index.ts
+export * from './program';
+
+// apps/api/src/app.ts
+import { classRouter } from '@api/routes/program';
+export const app = new Hono()
+  // ... existing routes ...
+  .route('/program', classRouter);
+```
+
+#### LMS Enrolled Programs Route
+
+Add to `apps/api/src/routes/organization/organization.ts`:
+
+```
+GET /organization/programs/enrolled
+```
+
+Returns all `ACTIVE` programs where the current user is a STUDENT `program_member`, including the course list with per-course progress. Used by the LMS "My Programs" and "Program Hub" pages.
+
+#### Build Verification
+
+```bash
+pnpm --filter @cio/utils build
+pnpm --filter @cio/db build
+pnpm --filter @cio/api build
+```
+
+---
+
+## Frontend Plan (Dashboard)
+
+### Request Types
+
+File: `apps/dashboard/src/lib/features/program/utils/types.ts`
+
+```typescript
+import { classroomio, type InferResponseType } from '$lib/utils/services/api';
+
+export type ListClassesRequest = typeof classroomio.program.$get;
+export type CreateClassRequest = typeof classroomio.program.$post;
+export type GetClassRequest = typeof classroomio.program[':programId']['$get'];
+export type UpdateClassRequest = typeof classroomio.program[':programId']['$put'];
+export type ListProgramCoursesRequest = typeof classroomio.program[':programId']['courses']['$get'];
+export type AddCourseToClassRequest = typeof classroomio.program[':programId']['courses']['$post'];
+export type ListProgramMembersRequest = typeof classroomio.program[':programId']['members']['$get'];
+export type AddProgramMembersRequest = typeof classroomio.program[':programId']['members']['$post'];
+export type ListAnnouncementsRequest = typeof classroomio.program[':programId']['announcements']['$get'];
+export type CreateAnnouncementRequest = typeof classroomio.program[':programId']['announcements']['$post'];
+export type ListProgramFilesRequest = typeof classroomio.program[':programId']['files']['$get'];
+
+export type ListClassesSuccess = Extract<InferResponseType<ListClassesRequest>, { success: true }>;
+export type ProgramItem = ListClassesSuccess['data'][number];
+
+export type GetClassSuccess = Extract<InferResponseType<GetClassRequest>, { success: true }>;
+export type ProgramDetail = GetClassSuccess['data'];
+
+export type ListProgramCoursesSuccess = Extract<InferResponseType<ListProgramCoursesRequest>, { success: true }>;
+export type ProgramCourse = ListProgramCoursesSuccess['data'][number];
+
+export type ListProgramMembersSuccess = Extract<InferResponseType<ListProgramMembersRequest>, { success: true }>;
+export type ProgramMember = ListProgramMembersSuccess['data'][number];
+
+export type ListAnnouncementsSuccess = Extract<InferResponseType<ListAnnouncementsRequest>, { success: true }>;
+export type ProgramAnnouncement = ListAnnouncementsSuccess['data'][number];
+
+export type ListProgramFilesSuccess = Extract<InferResponseType<ListProgramFilesRequest>, { success: true }>;
+export type ProgramFile = ListProgramFilesSuccess['data'][number];
+
+// LMS enrolled programs
+export type EnrolledClassesRequest = typeof classroomio.organization.programs.enrolled['$get'];
+export type EnrolledClassesSuccess = Extract<InferResponseType<EnrolledClassesRequest>, { success: true }>;
+export type EnrolledClass = EnrolledClassesSuccess['data'][number];
+```
+
+### API Program
+
+File: `apps/dashboard/src/lib/features/program/api/program.svelte.ts`
+
+```typescript
+program ProgramApi extends BaseApiWithErrors {
+  programs = $state<ProgramItem[]>([]);
+  currentClass = $state<ProgramDetail | null>(null);
+  courses = $state<ProgramCourse[]>([]);
+  members = $state<ProgramMember[]>([]);
+  announcements = $state<ProgramAnnouncement[]>([]);
+  files = $state<ProgramFile[]>([]);
+  loading = $state(false);
+
+  async list() { /* GET /program */ }
+  async get(programId: string) { /* GET /program/:programId */ }
+  async create(data: TCreateProgram) { /* POST /program */ }
+  async update(programId: string, data: TUpdateProgram) { /* PUT /program/:programId */ }
+  async archive(programId: string) { /* DELETE /program/:programId */ }
+
+  async listCourses(programId: string) { /* GET /program/:programId/courses */ }
+  async addCourse(programId: string, data: TAddCourseToProgram) { /* POST /program/:programId/courses */ }
+  async removeCourse(programId: string, courseId: string) { /* DELETE /program/:programId/courses/:courseId */ }
+
+  async listMembers(programId: string) { /* GET /program/:programId/members */ }
+  async addMembers(programId: string, data: TAddProgramMembers) { /* POST /program/:programId/members */ }
+  async removeMember(programId: string, memberId: string) { /* DELETE /program/:programId/members/:memberId */ }
+
+  async listAnnouncements(programId: string) { /* GET /program/:programId/announcements */ }
+  async createAnnouncement(programId: string, data: TCreateProgramAnnouncement) { /* POST */ }
+  async deleteAnnouncement(programId: string, announcementId: string) { /* DELETE */ }
+
+  async listFiles(programId: string) { /* GET /program/:programId/files */ }
+  async addFile(programId: string, data: TAddProgramFile) { /* POST /program/:programId/files */ }
+  async deleteFile(programId: string, fileId: string) { /* DELETE /program/:programId/files/:fileId */ }
+}
+
+export const programApi = new ProgramApi();
+```
+
+### LMS API Program
+
+File: `apps/dashboard/src/lib/features/lms/api/program.svelte.ts`
+
+```typescript
+program LmsProgramApi extends BaseApiWithErrors {
+  enrolledClasses = $state<EnrolledClass[]>([]);
+  loading = $state(false);
+
+  async listEnrolled() { /* GET /organization/programs/enrolled */ }
+}
+
+export const lmsProgramApi = new LmsProgramApi();
+```
+
+### Admin Pages
+
+| Route | File | Purpose |
+| --- | --- | --- |
+| `/courses/programs` | `apps/dashboard/src/routes/courses/programs/+page.svelte` | List all org programs |
+| `/courses/programs/new` | `apps/dashboard/src/routes/courses/programs/new/+page.svelte` | Create program form |
+| `/courses/programs/[programId]` | `apps/dashboard/src/routes/courses/programs/[programId]/+page.svelte` | Program overview |
+| `/courses/programs/[programId]/courses` | `.../courses/+page.svelte` | Manage courses |
+| `/courses/programs/[programId]/people` | `.../people/+page.svelte` | Manage members |
+| `/courses/programs/[programId]/announcements` | `.../announcements/+page.svelte` | Manage announcements |
+| `/courses/programs/[programId]/files` | `.../files/+page.svelte` | File library management |
+
+Feature pages live in: `apps/dashboard/src/lib/features/program/pages/`
+
+### LMS Pages
+
+| Route | File | Purpose |
+| --- | --- | --- |
+| `/lms/programs` | `apps/dashboard/src/routes/lms/programs/+page.svelte` | My enrolled programs |
+| `/lms/programs/[programId]` | `apps/dashboard/src/routes/lms/programs/[programId]/+page.svelte` | Program hub (courses + announcements + files) |
+| `/lms/programs/[programId]/community` | `.../community/+page.svelte` | Program community Q&A |
+
+Feature pages live in: `apps/dashboard/src/lib/features/lms/pages/program/`
+
+### Navigation Updates
+
+**Org admin sidebar** (`apps/dashboard/src/lib/features/org/`):
+- Add "Programs" nav item at the same level as "Courses", linking to `/courses/programs`.
+- Use a suitable icon (e.g., a group/layers icon).
+
+**LMS sidebar** (`apps/dashboard/src/lib/features/lms/`):
+- Add "Programs" nav item (shown conditionally: only when `enrolledClasses.length > 0`).
+- Position between "My Learning" and "Exercises".
+
+### Translations
+
+File: `apps/dashboard/src/lib/utils/translations/en.json`
+
+Add keys under `program`:
+
+```json
+{
+  "program": {
+    "title": "Programs",
+    "my_classes": "My Programs",
+    "create": "Create Program",
+    "create_description": "Group multiple courses and materials under one program for your students.",
+    "name": "Program Name",
+    "description": "Description",
+    "cover_image": "Cover Image",
+    "status": "Status",
+    "active": "Active",
+    "inactive": "Inactive",
+    "archived": "Archived",
+    "courses": "Courses",
+    "people": "People",
+    "announcements": "Announcements",
+    "files": "Files",
+    "community": "Community",
+    "add_course": "Add Course",
+    "remove_course": "Remove Course",
+    "add_members": "Add Members",
+    "remove_member": "Remove Member",
+    "course_count": "{count} courses",
+    "student_count": "{count} students",
+    "new_announcement": "New Announcement",
+    "announcement_title": "Announcement Title",
+    "announcement_body": "Write your announcement...",
+    "upload_file": "Upload File",
+    "no_classes": "No programs yet. Create one to get started.",
+    "no_courses": "No courses in this program yet.",
+    "no_members": "No members yet. Add students or tutors.",
+    "no_announcements": "No announcements yet.",
+    "no_files": "No files uploaded yet.",
+    "archive_confirm": "Archiving this program will hide it from all views. Are you sure?",
+    "auto_enroll_note": "Adding this course will enroll all current program students in it.",
+    "remove_course_note": "Removing this course will not unenroll any students.",
+    "remove_member_note": "Removing this member will not unenroll them from individual courses."
+  }
+}
+```
+
+### Frontend Build Verification
+
+```bash
+pnpm --filter @cio/dashboard build
+```
+
+---
+
+## Implementation Order
+
+### Phase 1: Database + Schema
+
+1. Add `programStatus` enum to `packages/db/src/schema.ts`.
+2. Add `lmsProgram`, `programCourse`, `programMember`, `programAnnouncement`, `programFile` tables to schema.
+3. Add `programId` FK column to `communityQuestion` table in schema.
+4. Write and apply migration SQL: `packages/db/src/migrations/XXXX_add_programs.sql`.
+5. Run `pnpm --filter @cio/db build`.
+
+### Phase 2: Validation + Queries
+
+1. Create `packages/utils/src/validation/program/program.ts` with all Zod schemas.
+2. Export from `packages/utils/src/validation/program/index.ts` and re-export from `packages/utils/src/validation/index.ts`.
+3. Run `pnpm --filter @cio/utils build`.
+4. Create `packages/db/src/queries/program/program.ts` with all query functions.
+5. Create `packages/db/src/queries/program/index.ts` and export.
+6. Run `pnpm --filter @cio/db build`.
+
+### Phase 3: Service + Routes
+
+1. Create `apps/api/src/services/program/program.ts` with all service functions (auto-enrollment transactions are the most complex part).
+2. Create access control utilities: `apps/api/src/middleware/program-access.ts` and `apps/api/src/middleware/program-admin.ts`.
+3. Add new error codes to `apps/api/src/utils/errors.ts`: `PROGRAM_NOT_FOUND`, `PROGRAM_FORBIDDEN`, `COURSE_ALREADY_IN_PROGRAM`, `MEMBER_ALREADY_IN_PROGRAM`.
+4. Create `apps/api/src/routes/program/program.ts` with all route handlers.
+5. Create `apps/api/src/routes/program/index.ts` and register in `apps/api/src/app.ts`.
+6. Add `GET /organization/programs/enrolled` to the organization router.
+7. Run `pnpm --filter @cio/api build`.
+
+### Phase 4: Admin Frontend
+
+1. Add request/response types to `apps/dashboard/src/lib/features/program/utils/types.ts`.
+2. Create `apps/dashboard/src/lib/features/program/api/program.svelte.ts` API program.
+3. Add translation keys to `en.json`.
+4. Create admin feature pages under `apps/dashboard/src/lib/features/program/pages/`.
+5. Create SvelteKit route files under `apps/dashboard/src/routes/courses/programs/`.
+6. Add "Programs" nav item to the org admin sidebar.
+7. Run `pnpm --filter @cio/dashboard build`.
+
+### Phase 5: LMS Frontend
+
+1. Create `apps/dashboard/src/lib/features/lms/api/program.svelte.ts`.
+2. Create LMS feature pages under `apps/dashboard/src/lib/features/lms/pages/program/`.
+3. Create SvelteKit route files under `apps/dashboard/src/routes/lms/programs/`.
+4. Add "Programs" nav item to the LMS sidebar (conditional on having enrolled programs).
+5. Run `pnpm --filter @cio/dashboard build`.
+
+---
+
+## Acceptance Criteria
+
+1. Org admin can create a program, add courses to it, and add students — all from the admin dashboard.
+2. When a student is added to a program, `groupmember` rows are automatically created for every course in the program.
+3. When a course is added to an existing program that already has students, all those students are enrolled in the new course.
+4. Removing a student from a program does not remove their `groupmember` records in individual courses.
+5. Removing a course from a program does not unenroll any students.
+6. Students see a "Programs" section in the LMS sidebar (only when enrolled in at least one program).
+7. The program hub page shows all courses with per-course progress bars, the announcements feed, and the file library.
+8. Program admins and tutors can post announcements and upload files; students can only view them.
+9. Program community Q&A is scoped to the program and does not appear on course community boards.
+10. `INACTIVE` programs are hidden from the student LMS but remain fully accessible to admins and tutors.
+11. `ARCHIVED` programs are hidden from all views.
+12. Courses that are not in any program, and courses whose students were enrolled independently, continue to work exactly as they do today (zero regression on existing `groupmember` and course data).
+13. All user-facing strings use translation keys (no hardcoded English).
+14. `pnpm --filter @cio/api build` and `pnpm --filter @cio/dashboard build` pass after implementation.
+
+---
+
+## Risks and Mitigations
+
+- **Risk**: Auto-enrollment transaction for large programs (hundreds of students, tens of courses) times out or partially fails.
+  - **Mitigation**: Process auto-enrollment in the service layer using a single transaction with batch inserts (insert multiple `groupmember` rows in one query using Drizzle's batch insert). For very large programs (> 500 students), offload to a background job via the existing email job queue or a new async task runner, and return a `202 Accepted` with a polling endpoint.
+
+- **Risk**: A student is already enrolled in a course independently before being added to a program. Duplicate `groupmember` rows violate the `(groupId, profileId)` unique constraint.
+  - **Mitigation**: The enrollment logic in `addMembersToProgram` must check for existing membership before inserting. Use `INSERT ... ON CONFLICT DO NOTHING` or check with `isUserCourseMember` before inserting. This is already idempotent in the existing enrollment service.
+
+- **Risk**: The `community_question.programId` column causes existing community queries to break if they don't filter by `programId IS NULL` for course-scoped questions.
+  - **Mitigation**: Add `programId IS NULL` to all existing community query filters where `courseId` is used. The column is nullable so existing rows default to NULL and behavior is unchanged. Update `packages/db/src/queries/community/community.ts` alongside the schema migration.
+
+- **Risk**: Removing a course from a program causes confusion: students are still enrolled in the course but it no longer appears in the program hub.
+  - **Mitigation**: Show a confirmation dialog in the admin UI with the note: "Removing this course will not unenroll any students. They will still have access to it via My Learning." Use the `program.remove_course_note` translation key already specified.
+
+- **Risk**: Org nav gets crowded with a new "Programs" top-level item.
+  - **Mitigation**: Place "Programs" directly below "Courses" in the sidebar. Consider grouping them under a "Learning" section header if more items are added in future.