@anantagnanam/lms 0.0.0-stage → 0.2.0

package/dist/runtime.js

@@ -0,0 +1,2840 @@
+import { a as adminPages, i as PLUGIN_VERSION, n as MAX_DOCUMENT_BYTES, o as storage, r as PLUGIN_ID } from "./constants-Cnx7k82Z.js";
+import { t as normalizeLmsOptions } from "./config-BX3beTpM.js";
+import { assignmentSubmitSchema, catalogSchema, certificateActionSchema, certificateRevokeSchema, cohortSaveSchema, courseDataSchema, courseIdSchema, courseSaveSchema, discussionSchema, enrollmentAdminSchema, enrollmentRequestSchema, gradeSchema, idSchema, keySchema, lessonIdSchema, moderateSchema, noteSchema, pageSchema, pathSaveSchema, playbackSchema, preferencesSchema, quizDraftSchema, quizSubmitSchema, reviewSchema, settingsSchema } from "./schemas.js";
+import { n as invariant, t as LmsError } from "./errors-ChzJS9al.js";
+import { n as enrollmentCsvLines, t as enrollmentCsvHeader } from "./csv-DKq_4OWU.js";
+import { definePlugin, definePluginRoute, pluginResponse } from "emdash";
+import { z } from "zod";
+
+//#region src/store.ts
+function collections(ctx) {
+	return ctx.storage;
+}
+function enrollmentKey(courseId, userId) {
+	return `${courseId}:${userId}`;
+}
+function assertSize(data) {
+	invariant(new TextEncoder().encode(JSON.stringify(data)).byteLength <= MAX_DOCUMENT_BYTES, "DOCUMENT_TOO_LARGE", "This record exceeds the LMS storage limit. Split the course into smaller courses.", 413);
+}
+async function change(store, id, update) {
+	for (let attempt = 0; attempt < 8; attempt++) {
+		const current = await store.getVersioned(id);
+		const { value, result } = await update(current?.value ?? null);
+		assertSize(value);
+		if ((await store.compareAndSet(id, current?.revision ?? null, value)).applied) return result;
+	}
+	throw new LmsError("CONFLICT", "Another request changed this record. Please try again.", 409);
+}
+async function queryPage(store, options = {}) {
+	const page = await store.query(options);
+	return {
+		...page,
+		items: page.items.map((item) => item.data)
+	};
+}
+async function putOnce(store, id, value) {
+	assertSize(value);
+	await store.compareAndSet(id, null, value);
+}
+
+//#endregion
+//#region src/editions.ts
+/** Child snapshots are immutable. Only the root CAS makes a revision visible. */
+var CourseEditions = class {
+	constructor(stores, time, resolveContent) {
+		this.stores = stores;
+		this.time = time;
+		this.resolveContent = resolveContent;
+	}
+	async snapshot(courseId, data) {
+		const frozen = structuredClone(data);
+		for (const module of frozen.modules) for (let i = 0; i < module.lessons.length; i++) module.lessons[i] = {
+			...await this.resolveContent(module.lessons[i]),
+			contentSource: null
+		};
+		const id = crypto.randomUUID();
+		await putOnce(this.stores.course_editions, id, {
+			id,
+			courseId,
+			data: frozen,
+			createdAt: this.time()
+		});
+		return id;
+	}
+	async revision(course, data, actorId, kind, extra = {}) {
+		const revision = {
+			id: crypto.randomUUID(),
+			courseId: course.id,
+			parentId: course.draftRevisionId ?? null,
+			data: courseDataSchema.parse({
+				...data,
+				status: "draft"
+			}),
+			kind,
+			createdBy: actorId,
+			createdAt: this.time(),
+			...extra
+		};
+		await putOnce(this.stores.course_revisions, revision.id, revision);
+		return revision;
+	}
+	async commit(current, course) {
+		assertSize(course);
+		const saved = await this.stores.courses.compareAndSet(course.id, current?.revision ?? null, course);
+		invariant(saved.applied, "CONFLICT", "The course changed. Reload before continuing.", 409);
+		return {
+			value: course,
+			revision: saved.revision
+		};
+	}
+	async ensure(id, expectedRevision) {
+		for (let attempt = 0; attempt < 8; attempt++) {
+			const current = await this.stores.courses.getVersioned(id);
+			invariant(current, "NOT_FOUND", "Course not found.", 404);
+			invariant(expectedRevision === void 0 || current.revision === expectedRevision, "CONFLICT", "The course changed. Reload before continuing.", 409);
+			if (current.value.schemaVersion === 2) return current;
+			const course = current.value;
+			invariant(course.schemaVersion === 1, "UNSUPPORTED_SCHEMA", "This course needs a different LMS version. No migration was applied.", 409);
+			const data = courseDataSchema.parse(course);
+			const editionId = await this.snapshot(id, data);
+			const revision = await this.revision(course, data, course.createdBy, "migration", { editionId });
+			const edition = await this.stores.course_editions.get(editionId);
+			const next = {
+				...course,
+				...edition.data,
+				schemaVersion: 2,
+				draftRevisionId: revision.id,
+				legacyEditionId: editionId,
+				...course.status !== "draft" ? {
+					publishedEditionId: editionId,
+					publishedDraftRevisionId: revision.id
+				} : {}
+			};
+			try {
+				return await this.commit(current, next);
+			} catch (error) {
+				if (!(error instanceof LmsError) || error.code !== "CONFLICT" || expectedRevision !== void 0) throw error;
+			}
+		}
+		throw new LmsError("CONFLICT", "Course migration conflicted. Please retry.", 409);
+	}
+	async draft(course) {
+		if (!course.draftRevisionId) return course;
+		const revision = await this.stores.course_revisions.get(course.draftRevisionId);
+		invariant(revision?.courseId === course.id, "EDITION_UNAVAILABLE", "The saved course draft is unavailable.", 503);
+		return {
+			...course,
+			...revision.data,
+			status: course.status
+		};
+	}
+	async learning(course, enrollment) {
+		if (!enrollment) return course;
+		const id = enrollment.courseEditionId ?? course.legacyEditionId ?? course.publishedEditionId;
+		if (!id) return course;
+		const edition = await this.stores.course_editions.get(id);
+		invariant(edition?.courseId === course.id, "EDITION_UNAVAILABLE", "The enrolled course edition is unavailable.", 503);
+		return {
+			...course,
+			...edition.data,
+			status: course.status,
+			slug: course.slug,
+			instructorIds: course.instructorIds
+		};
+	}
+	async history(course, cursor) {
+		let id = course.draftRevisionId;
+		let found = !cursor;
+		const items = [];
+		for (let i = 0; id && i < 1e3; i++) {
+			const revision = await this.stores.course_revisions.get(id);
+			invariant(revision?.courseId === course.id, "EDITION_UNAVAILABLE", "Course history is unavailable.", 503);
+			if (id === cursor) found = true;
+			if (found) {
+				const { data, ...summary } = revision;
+				items.push({
+					...summary,
+					title: data.title
+				});
+			}
+			id = revision.parentId ?? void 0;
+			if (items.length === 20) return {
+				items,
+				cursor: id,
+				hasMore: !!id
+			};
+		}
+		invariant(found && !id, "INVALID_CURSOR", "History cursor is invalid or exceeds the 1,000-revision browsing limit.", 400);
+		return {
+			items,
+			hasMore: false
+		};
+	}
+	async migrationStatus() {
+		return await this.stores.migrations.get("course-editions-v2") ?? {
+			phase: "courses",
+			coursesProcessed: 0,
+			enrollmentsProcessed: 0,
+			updatedAt: this.time(),
+			lastError: null
+		};
+	}
+	async migrateBatch(limit) {
+		const id = "course-editions-v2";
+		const current = await this.stores.migrations.getVersioned(id);
+		const state = current?.value ?? await this.migrationStatus();
+		if (state.phase === "complete") return state;
+		const next = {
+			...state,
+			lastError: null,
+			updatedAt: this.time()
+		};
+		try {
+			if (state.phase === "courses") {
+				const page = await this.stores.courses.query({
+					orderBy: { createdAt: "asc" },
+					cursor: state.cursor,
+					limit
+				});
+				for (const item of page.items) await this.ensure(item.id);
+				next.coursesProcessed += page.items.length;
+				next.cursor = page.cursor;
+				if (!page.hasMore) {
+					next.phase = "enrollments";
+					next.cursor = void 0;
+				}
+			} else {
+				const page = await this.stores.enrollments.query({
+					orderBy: { enrolledAt: "asc" },
+					cursor: state.cursor,
+					limit
+				});
+				for (const item of page.items) {
+					if (item.data.courseEditionId) continue;
+					const course = (await this.ensure(item.data.courseId)).value;
+					await change(this.stores.enrollments, item.id, async (enrollment) => {
+						invariant(enrollment, "NOT_FOUND", "Enrollment disappeared during migration.", 409);
+						return {
+							value: {
+								...enrollment,
+								courseEditionId: enrollment.courseEditionId ?? course.legacyEditionId ?? course.publishedEditionId
+							},
+							result: null
+						};
+					});
+				}
+				next.enrollmentsProcessed += page.items.length;
+				next.cursor = page.cursor;
+				if (!page.hasMore) {
+					next.phase = "complete";
+					next.cursor = void 0;
+				}
+			}
+		} catch (error) {
+			await this.stores.migrations.compareAndSet(id, current?.revision ?? null, {
+				...state,
+				updatedAt: this.time(),
+				lastError: error instanceof LmsError ? error.message : "Migration failed. Retry the batch after checking storage availability."
+			});
+			throw error;
+		}
+		invariant((await this.stores.migrations.compareAndSet(id, current?.revision ?? null, next)).applied, "CONFLICT", "Another migration batch advanced the checkpoint. Refresh and continue.", 409);
+		return next;
+	}
+};
+
+//#endregion
+//#region src/curriculum.ts
+function lessons(course) {
+	return course.modules.flatMap((module) => module.lessons);
+}
+function emptyProgress() {
+	return {
+		startedAt: null,
+		completedAt: null,
+		note: "",
+		quizAttempts: [],
+		assignments: []
+	};
+}
+function courseCard(course) {
+	const all = lessons(course);
+	return {
+		id: course.id,
+		slug: course.slug,
+		title: course.title,
+		summary: course.summary,
+		category: course.category,
+		tags: course.tags,
+		level: course.level,
+		language: course.language,
+		featuredImage: course.featuredImage,
+		instructorName: course.instructorName,
+		enrollmentMode: course.enrollmentMode,
+		lessonCount: all.length,
+		durationMinutes: all.reduce((sum, lesson) => sum + lesson.durationMinutes, 0)
+	};
+}
+function courseDetail(course) {
+	return {
+		prerequisites: [],
+		...courseCard(course),
+		description: course.description,
+		outcomes: course.outcomes,
+		requirements: course.requirements,
+		sequential: course.sequential,
+		prerequisiteCourseIds: course.prerequisiteCourseIds,
+		enrollmentClosesAt: course.enrollmentClosesAt,
+		accessDays: course.accessDays,
+		certificateEnabled: course.certificateEnabled,
+		modules: course.modules.map((module) => ({
+			id: module.id,
+			title: module.title,
+			description: module.description,
+			releaseDays: module.releaseDays,
+			unlockAt: module.unlockAt,
+			lessons: module.lessons.map((lesson) => ({
+				id: lesson.id,
+				title: lesson.title,
+				summary: lesson.summary,
+				kind: lesson.kind,
+				durationMinutes: lesson.durationMinutes,
+				preview: lesson.preview,
+				required: lesson.required
+			}))
+		}))
+	};
+}
+function publicLesson(lesson) {
+	const { quiz, contentSource: _source, ...safe } = lesson;
+	return {
+		...safe,
+		transcript: lesson.transcript ?? "",
+		captions: lesson.captions ?? [],
+		quiz: quiz ? {
+			passingPercent: quiz.passingPercent,
+			maxAttempts: quiz.maxAttempts,
+			timeLimitMinutes: quiz.timeLimitMinutes,
+			randomizeQuestions: quiz.randomizeQuestions,
+			randomizeOptions: quiz.randomizeOptions,
+			showFeedback: quiz.showFeedback,
+			questionCount: quiz.questions.length
+		} : null
+	};
+}
+function publicAttempt(attempt) {
+	const { quiz: _quiz, ...safe } = attempt;
+	return {
+		...safe,
+		draftRevision: attempt.draftRevision ?? 0
+	};
+}
+function effectiveAccess(enrollment, now = /* @__PURE__ */ new Date()) {
+	if (enrollment.status === "suspended" || enrollment.accessStatus === "suspended") return "suspended";
+	if (["rejected", "cancelled"].includes(enrollment.status) || enrollment.accessStatus === "revoked") return "revoked";
+	if (enrollment.status === "pending" || enrollment.accessStatus === "pending") return "pending";
+	if (enrollment.accessExpiresAt && now.getTime() >= Date.parse(enrollment.accessExpiresAt)) return "expired";
+	if (enrollment.accessStartsAt && now.getTime() < Date.parse(enrollment.accessStartsAt)) return "scheduled";
+	const grants = Object.values(enrollment.grants);
+	if (grants.some((grant) => grant.status === "granted" && (!grant.startsAt || now.getTime() >= Date.parse(grant.startsAt)) && (!grant.expiresAt || now.getTime() < Date.parse(grant.expiresAt)))) return "granted";
+	if (grants.some((grant) => grant.status === "granted" && grant.startsAt && now.getTime() < Date.parse(grant.startsAt) && (!grant.expiresAt || now.getTime() < Date.parse(grant.expiresAt)))) return "scheduled";
+	if (grants.some((grant) => grant.status === "suspended")) return "suspended";
+	if (grants.some((grant) => grant.status === "granted" && grant.expiresAt && now.getTime() >= Date.parse(grant.expiresAt))) return "expired";
+	return "revoked";
+}
+function publicEnrollment(enrollment, now = /* @__PURE__ */ new Date()) {
+	const { learnerEmail: _email, progress, ...safe } = enrollment;
+	return {
+		...safe,
+		effectiveAccess: effectiveAccess(enrollment, now),
+		progress: Object.fromEntries(Object.entries(progress).map(([id, item]) => [id, {
+			...item,
+			quizAttempts: item.quizAttempts.map(publicAttempt)
+		}]))
+	};
+}
+/** Staff need assessment and completion records, not a learner's private study notes. */
+function staffEnrollment(enrollment, now = /* @__PURE__ */ new Date()) {
+	const view = publicEnrollment(enrollment, now);
+	for (const progress of Object.values(view.progress)) {
+		progress.note = "";
+		delete progress.playback;
+	}
+	return view;
+}
+function progressSummary(course, enrollment, now = /* @__PURE__ */ new Date()) {
+	const required = enrollment?.completedAt ? enrollment.completionLessonIds : lessons(course).filter((lesson) => lesson.required).map((lesson) => lesson.id);
+	const completed = required.filter((id) => enrollment?.progress[id]?.completedAt).length;
+	const all = lessons(course);
+	const availability = Object.fromEntries(all.map((lesson) => [lesson.id, lessonAvailability(course, lesson.id, enrollment, now)]));
+	const incomplete = all.filter((lesson) => !enrollment?.progress[lesson.id]?.completedAt);
+	const nextLessonId = incomplete.find((lesson) => availability[lesson.id].available)?.id ?? null;
+	return {
+		completed,
+		total: required.length,
+		percent: required.length ? Math.floor(completed / required.length * 100) : 0,
+		nextLessonId,
+		blockedLessonId: nextLessonId ? null : incomplete[0]?.id ?? null,
+		availability
+	};
+}
+/** Use the same access boundary for navigation and private lesson reads. Enrollment
+* must already have its cohort grants resolved against authoritative membership. */
+function lessonAvailability(course, lessonId, enrollment, now) {
+	try {
+		assertLessonAccess(course, lessonId, enrollment, now);
+		return {
+			available: true,
+			code: null,
+			reason: null,
+			releaseAt: null
+		};
+	} catch (error) {
+		if (!(error instanceof LmsError)) throw error;
+		let releaseAt = null;
+		if (enrollment && error.code === "LESSON_LOCKED") releaseAt = new Date(moduleReleaseAt(course, lessonId, enrollment)).toISOString();
+		else if (enrollment && effectiveAccess(enrollment, now) === "scheduled") {
+			const starts = Object.values(enrollment.grants).filter((grant) => grant.status === "granted" && (!grant.expiresAt || Date.parse(grant.expiresAt) > now.getTime())).flatMap((grant) => {
+				const date = Math.max(grant.startsAt ? Date.parse(grant.startsAt) : 0, enrollment.accessStartsAt ? Date.parse(enrollment.accessStartsAt) : 0);
+				return date > now.getTime() && (!grant.expiresAt || date < Date.parse(grant.expiresAt)) && (!enrollment.accessExpiresAt || date < Date.parse(enrollment.accessExpiresAt)) ? [date] : [];
+			});
+			if (starts.length) releaseAt = new Date(Math.min(...starts)).toISOString();
+		}
+		return {
+			available: false,
+			code: error.code,
+			reason: error.message,
+			releaseAt
+		};
+	}
+}
+function moduleReleaseAt(course, lessonId, enrollment) {
+	const module = course.modules.find((item) => item.lessons.some((entry) => entry.id === lessonId));
+	return Math.max(module.unlockAt ? Date.parse(module.unlockAt) : 0, Date.parse(enrollment.approvedAt ?? enrollment.enrolledAt) + module.releaseDays * 864e5);
+}
+function assertEnrollmentAccess(enrollment, now) {
+	invariant(enrollment && (enrollment.status === "active" || enrollment.status === "completed"), "ENROLLMENT_REQUIRED", "An active enrollment is required for this lesson.", 403);
+	invariant(enrollment.accessStatus === "granted", "ACCESS_RESTRICTED", "Your course access is not currently granted.", 403);
+	invariant(Object.values(enrollment.grants).some((grant) => grant.status === "granted" && (!grant.startsAt || now.getTime() >= Date.parse(grant.startsAt)) && (!grant.expiresAt || now.getTime() < Date.parse(grant.expiresAt))), "GRANT_REQUIRED", "Your course access grant has not started, expired, or been revoked.", 403);
+	invariant(!enrollment.accessStartsAt || now.getTime() >= Date.parse(enrollment.accessStartsAt), "COURSE_NOT_STARTED", "Your course access has not started yet.", 403);
+	invariant(!enrollment.accessExpiresAt || now.getTime() < Date.parse(enrollment.accessExpiresAt), "ACCESS_EXPIRED", "Your course access has expired.", 403);
+}
+function findLesson(course, lessonId) {
+	const lesson = lessons(course).find((item) => item.id === lessonId);
+	invariant(lesson, "NOT_FOUND", "Lesson not found.", 404);
+	return lesson;
+}
+function assertLessonAccess(course, lessonId, enrollment, now, allowPreview = false) {
+	const lesson = findLesson(course, lessonId);
+	if (allowPreview && lesson.preview && ![
+		"quiz",
+		"assignment",
+		"live"
+	].includes(lesson.kind)) return lesson;
+	assertEnrollmentAccess(enrollment, now);
+	invariant(course.status !== "draft", "NOT_FOUND", "Course not found.", 404);
+	const releaseAt = moduleReleaseAt(course, lessonId, enrollment);
+	invariant(now.getTime() >= releaseAt, "LESSON_LOCKED", "This module has not been released yet.", 403);
+	if (course.sequential) {
+		const all = lessons(course);
+		const index = all.findIndex((item) => item.id === lessonId);
+		invariant(all.slice(0, index).filter((item) => item.required).every((item) => enrollment.progress[item.id]?.completedAt), "PREREQUISITE_REQUIRED", "Complete the earlier required lessons first.", 403);
+	}
+	return lesson;
+}
+function shuffle(items, random = () => {
+	const value = new Uint32Array(1);
+	crypto.getRandomValues(value);
+	return value[0] / 4294967296;
+}) {
+	const output = [...items];
+	for (let index = output.length - 1; index > 0; index--) {
+		const pick = Math.floor(random() * (index + 1));
+		[output[index], output[pick]] = [output[pick], output[index]];
+	}
+	return output;
+}
+function normalized(value) {
+	return value.normalize("NFKC").trim().toLocaleLowerCase("en").replace(/\s+/g, " ");
+}
+function gradeAnswers(questions, answers) {
+	const ids = new Set(questions.map((question) => question.id));
+	invariant(Object.keys(answers).every((id) => ids.has(id)), "INVALID_ANSWERS", "Answers contain an unknown question.");
+	const feedback = questions.map((question) => {
+		const response = answers[question.id];
+		const selected = Array.isArray(response) ? response : response === void 0 ? [] : [response];
+		invariant(new Set(selected).size === selected.length, "INVALID_ANSWERS", "Duplicate answer choices are not accepted.");
+		if (question.type !== "multiple") invariant(selected.length <= 1, "INVALID_ANSWERS", "This question accepts one answer.");
+		if (question.type !== "short") invariant(selected.every((answer) => question.options.some((option) => option.id === answer)), "INVALID_ANSWERS", "An answer contains an invalid option.");
+		const correct = question.type === "short" ? selected.length === 1 && question.correctAnswers.some((answer) => normalized(answer) === normalized(selected[0])) : selected.length === question.correctAnswers.length && selected.every((answer) => question.correctAnswers.includes(answer));
+		return {
+			questionId: question.id,
+			correct,
+			points: correct ? question.points : 0,
+			maxPoints: question.points,
+			explanation: question.explanation
+		};
+	});
+	const score = feedback.reduce((sum, item) => sum + item.points, 0);
+	const maxScore = questions.reduce((sum, question) => sum + question.points, 0);
+	return {
+		score,
+		maxScore,
+		percent: Math.round(score / maxScore * 1e4) / 100,
+		feedback
+	};
+}
+
+//#endregion
+//#region src/service.ts
+function parse(schema, input) {
+	const result = schema.safeParse(input);
+	if (!result.success) throw new LmsError("VALIDATION_ERROR", result.error.issues.map((issue) => `${issue.path.join(".") || "Input"}: ${issue.message}`).slice(0, 5).join(" "), 400);
+	return result.data;
+}
+function user$1(actor) {
+	invariant(actor, "UNAUTHORIZED", "Sign in to continue.", 401);
+	return actor;
+}
+var LmsService = class {
+	stores;
+	editions;
+	constructor(ctx, now = () => /* @__PURE__ */ new Date()) {
+		this.ctx = ctx;
+		this.now = now;
+		this.stores = collections(ctx);
+		this.editions = new CourseEditions(this.stores, () => this.time(), (lesson) => this.resolveContent(lesson));
+	}
+	time() {
+		return this.now().toISOString();
+	}
+	async settings() {
+		return settingsSchema.parse(await this.ctx.settings.get("configuration") ?? {});
+	}
+	async saveSettings(actor, input) {
+		invariant(user$1(actor).role >= 50, "FORBIDDEN", "Only administrators can change LMS settings.", 403);
+		const settings = parse(settingsSchema, input);
+		invariant(!settings.emailNotifications || this.ctx.email, "EMAIL_UNAVAILABLE", "Configure an email transport in EmDash before enabling LMS emails.");
+		await this.ctx.settings.set("configuration", settings);
+		await this.audit(actor, "settings.save", "configuration");
+		return settings;
+	}
+	async audit(actor, action, resourceId, details = {}) {
+		const id = crypto.randomUUID();
+		await this.stores.audit.put(id, {
+			id,
+			actorId: actor.id,
+			action,
+			resourceId,
+			createdAt: this.time(),
+			details
+		});
+	}
+	async course(id) {
+		const course = await this.stores.courses.get(id);
+		invariant(course, "NOT_FOUND", "Course not found.", 404);
+		return course;
+	}
+	async accessEnrollment(enrollment) {
+		if (!enrollment) return null;
+		const grants = Object.values(enrollment.grants).filter((grant) => grant.source === "cohort");
+		if (!grants.length) return enrollment;
+		const [memberships, cohorts] = await Promise.all([this.stores.cohort_enrollments.getMany(grants.map((grant) => enrollmentKey(grant.referenceId ?? "", enrollment.userId))), this.stores.cohorts.getMany(grants.map((grant) => grant.referenceId ?? ""))]);
+		const resolved = structuredClone(enrollment);
+		for (const grant of grants) {
+			const membership = memberships.get(enrollmentKey(grant.referenceId ?? "", enrollment.userId));
+			const cohort = cohorts.get(grant.referenceId ?? "");
+			if (membership?.status !== "active" || !cohort?.courseIds.includes(enrollment.courseId)) resolved.grants[grant.id].status = membership?.status === "suspended" ? "suspended" : "revoked";
+			else {
+				resolved.grants[grant.id].status = "granted";
+				resolved.grants[grant.id].startsAt = cohort.startsAt;
+				resolved.grants[grant.id].expiresAt = cohort.endsAt;
+			}
+		}
+		return resolved;
+	}
+	async enrollmentView(enrollment) {
+		return publicEnrollment(await this.accessEnrollment(enrollment), this.now());
+	}
+	async learningState(course, enrollment) {
+		course = await this.editions.learning(course, enrollment);
+		const resolved = await this.accessEnrollment(enrollment);
+		const now = this.now();
+		return {
+			enrollment: resolved ? publicEnrollment(resolved, now) : null,
+			progress: progressSummary(course, resolved, now)
+		};
+	}
+	async lessonAccess(course, lessonId, enrollment) {
+		return assertLessonAccess(await this.editions.learning(course, enrollment), lessonId, await this.accessEnrollment(enrollment), this.now());
+	}
+	instructor(course, actor) {
+		const current = user$1(actor);
+		invariant(current.role >= 20 && (current.role >= 50 || course.createdBy === current.id || course.instructorIds.includes(current.id)), "FORBIDDEN", "You are not an instructor for this course.", 403);
+		return current;
+	}
+	async saveCourse(actor, input) {
+		const currentActor = user$1(actor);
+		const parsed = parse(courseSaveSchema, input);
+		const id = parsed.id ?? crypto.randomUUID();
+		let current = await this.stores.courses.getVersioned(id);
+		if (current) this.instructor(current.value, currentActor);
+		else invariant(currentActor.role >= 20, "FORBIDDEN", "Course authoring requires a contributor account or higher.", 403);
+		invariant((current?.revision ?? null) === parsed.expectedRevision, "CONFLICT", "The course changed since you opened it. Reload before saving.", 409);
+		if (!current && parsed.data.status === "published") invariant(currentActor.role >= 50 || currentActor.role >= 30, "FORBIDDEN", "Publishing requires an author account or higher.", 403);
+		invariant(current || parsed.data.status !== "published" || parsed.data.commerce.accessModel === "free", "PAID_COURSES_DISABLED", "Payment processing is not enabled in this release. Publish free courses only.", 409);
+		invariant(!(await this.stores.courses.query({
+			where: { slug: parsed.data.slug },
+			limit: 1
+		})).items.some((item) => item.id !== id), "SLUG_TAKEN", "A course already uses this URL.", 409);
+		await this.assertPrerequisiteGraph(id, parsed.data.prerequisiteCourseIds);
+		if (current) current = await this.editions.ensure(id, current.revision);
+		let course = {
+			...parsed.data,
+			id,
+			searchTitle: parsed.data.title.toLocaleLowerCase("en"),
+			createdBy: current?.value.createdBy ?? currentActor.id,
+			createdAt: current?.value.createdAt ?? this.time(),
+			updatedAt: this.time(),
+			schemaVersion: 2
+		};
+		const draft = await this.editions.revision(current?.value ?? course, parsed.data, currentActor.id, "draft");
+		if (current) {
+			course = {
+				...current.value,
+				...current.value.publishedEditionId ? {} : parsed.data,
+				status: current.value.status,
+				draftRevisionId: draft.id,
+				updatedAt: this.time()
+			};
+			course.instructorIds = parsed.data.instructorIds;
+		} else {
+			course.draftRevisionId = draft.id;
+			if (course.status === "published") {
+				const editionId = await this.editions.snapshot(id, parsed.data);
+				const edition = await this.stores.course_editions.get(editionId);
+				course = {
+					...course,
+					...edition.data,
+					publishedEditionId: editionId,
+					publishedDraftRevisionId: draft.id
+				};
+			}
+		}
+		course.searchTitle = course.title.toLocaleLowerCase("en");
+		const saved = await this.editions.commit(current, course);
+		await this.audit(currentActor, "course.save", id, { draftRevisionId: draft.id });
+		return {
+			course: await this.editions.draft(course),
+			revision: saved.revision
+		};
+	}
+	async publishCourse(actor, id, expectedRevision) {
+		const owner = this.instructor(await this.course(id), actor);
+		invariant(owner.role >= 30, "FORBIDDEN", "Publishing requires an author account or higher.", 403);
+		const current = await this.editions.ensure(id, expectedRevision);
+		const data = parse(courseDataSchema, {
+			...await this.editions.draft(current.value),
+			status: "published"
+		});
+		invariant(data.commerce.accessModel === "free", "PAID_COURSES_DISABLED", "Publish free courses only.", 409);
+		await this.assertPrerequisiteGraph(id, data.prerequisiteCourseIds);
+		invariant(!(await this.stores.courses.query({
+			where: { slug: data.slug },
+			limit: 1
+		})).items.some((row) => row.id !== id), "SLUG_TAKEN", "A course already uses this URL.", 409);
+		const editionId = await this.editions.snapshot(id, data);
+		const revision = await this.editions.revision(current.value, data, owner.id, "publish", { editionId });
+		const edition = await this.stores.course_editions.get(editionId);
+		const next = {
+			...current.value,
+			...edition.data,
+			searchTitle: data.title.toLocaleLowerCase("en"),
+			draftRevisionId: revision.id,
+			publishedDraftRevisionId: revision.id,
+			publishedEditionId: editionId,
+			updatedAt: this.time()
+		};
+		const saved = await this.editions.commit(current, next);
+		await this.audit(owner, "course.publish", id, { editionId });
+		return {
+			course: await this.editions.draft(next),
+			revision: saved.revision
+		};
+	}
+	async courseHistory(actor, id, cursor) {
+		const course = await this.course(id);
+		this.instructor(course, actor);
+		return this.editions.history(course, cursor);
+	}
+	async restoreCourse(actor, id, expectedRevision, revisionId) {
+		const owner = this.instructor(await this.course(id), actor);
+		const current = await this.editions.ensure(id, expectedRevision);
+		invariant((await this.editions.history(current.value, revisionId)).items[0]?.id === revisionId, "NOT_FOUND", "Saved revision not found.", 404);
+		const data = {
+			...(await this.stores.course_revisions.get(revisionId)).data,
+			instructorIds: current.value.instructorIds
+		};
+		const revision = await this.editions.revision(current.value, data, owner.id, "restore", { restoredFrom: revisionId });
+		const next = {
+			...current.value,
+			draftRevisionId: revision.id,
+			updatedAt: this.time()
+		};
+		const saved = await this.editions.commit(current, next);
+		await this.audit(owner, "course.restore", id, { revisionId });
+		return {
+			course: await this.editions.draft(next),
+			revision: saved.revision
+		};
+	}
+	async archiveCourse(actor, id, expectedRevision) {
+		const owner = this.instructor(await this.course(id), actor);
+		invariant(owner.role >= 30, "FORBIDDEN", "Archiving requires an author account or higher.", 403);
+		const legacy = await this.stores.courses.getVersioned(id);
+		if (legacy?.value.schemaVersion === 1) {
+			invariant(legacy.revision === expectedRevision, "CONFLICT", "The course changed. Reload before continuing.", 409);
+			const next = {
+				...legacy.value,
+				status: "archived",
+				updatedAt: this.time()
+			};
+			const saved = await this.editions.commit(legacy, next);
+			await this.audit(owner, "course.archive", id);
+			return {
+				course: next,
+				revision: saved.revision
+			};
+		}
+		const current = await this.editions.ensure(id, expectedRevision);
+		const draft = await this.editions.draft(current.value);
+		const revision = await this.editions.revision(current.value, draft, owner.id, "archive");
+		const next = {
+			...current.value,
+			status: "archived",
+			draftRevisionId: revision.id,
+			updatedAt: this.time()
+		};
+		const saved = await this.editions.commit(current, next);
+		await this.audit(owner, "course.archive", id);
+		return {
+			course: await this.editions.draft(next),
+			revision: saved.revision
+		};
+	}
+	async migrationStatus(actor) {
+		invariant(user$1(actor).role >= 50, "FORBIDDEN", "Only administrators can manage migrations.", 403);
+		return this.editions.migrationStatus();
+	}
+	async migrateBatch(actor, limit) {
+		await this.migrationStatus(actor);
+		const state = await this.editions.migrateBatch(limit);
+		if (state.phase === "complete") await this.ctx.kv.set("schemaVersion", 2);
+		return state;
+	}
+	async assertPrerequisiteGraph(courseId, prerequisites) {
+		const visited = /* @__PURE__ */ new Set();
+		const visit = async (id) => {
+			invariant(id !== courseId, "PREREQUISITE_CYCLE", "Course prerequisites cannot form a cycle.");
+			if (visited.has(id)) return;
+			invariant(visited.size < 100, "PREREQUISITE_GRAPH_TOO_LARGE", "The prerequisite chain is too long.");
+			visited.add(id);
+			const course = await this.course(id);
+			for (const next of course.prerequisiteCourseIds) await visit(next);
+		};
+		for (const id of prerequisites) await visit(id);
+	}
+	async editableCourse(actor, id) {
+		const current = await this.stores.courses.getVersioned(id);
+		invariant(current, "NOT_FOUND", "Course not found.", 404);
+		this.instructor(current.value, actor);
+		return {
+			course: await this.editions.draft(current.value),
+			revision: current.revision
+		};
+	}
+	async adminCourses(actor, options = {}) {
+		const current = user$1(actor);
+		const page = await queryPage(this.stores.courses, {
+			where: options.status ? { status: options.status } : {},
+			orderBy: { updatedAt: "desc" },
+			limit: options.limit ?? 24,
+			cursor: options.cursor
+		});
+		return {
+			...page,
+			items: await Promise.all(page.items.filter((course) => current.role >= 20 && (current.role >= 50 || course.createdBy === current.id || course.instructorIds.includes(current.id))).map((course) => this.editions.draft(course)))
+		};
+	}
+	async catalog(input) {
+		const options = parse(catalogSchema, input);
+		const where = { status: "published" };
+		if (options.q.trim()) where.searchTitle = { startsWith: options.q.trim().toLocaleLowerCase("en") };
+		if (options.category) where.category = options.category;
+		if (options.language) where.language = options.language;
+		if (options.level && options.level !== "all") where.level = { in: [options.level, "all"] };
+		const page = await queryPage(this.stores.courses, {
+			where,
+			orderBy: { title: "asc" },
+			limit: options.limit,
+			cursor: options.cursor
+		});
+		return {
+			...page,
+			items: page.items.map(courseCard)
+		};
+	}
+	async publicCourse(slug) {
+		const page = await this.stores.courses.query({
+			where: {
+				slug,
+				status: "published"
+			},
+			limit: 1
+		});
+		invariant(page.items[0], "NOT_FOUND", "Course not found.", 404);
+		return this.detail(page.items[0].data);
+	}
+	async detail(course) {
+		const prerequisites = await this.stores.courses.getMany(course.prerequisiteCourseIds);
+		return {
+			...courseDetail(course),
+			prerequisites: course.prerequisiteCourseIds.map((id) => {
+				const value = prerequisites.get(id);
+				return {
+					id,
+					title: value?.title ?? "Prerequisite course",
+					slug: value?.status === "published" ? value.slug : null
+				};
+			})
+		};
+	}
+	async preview(courseId, lessonId) {
+		const course = await this.course(courseId);
+		invariant(course.status === "published", "NOT_FOUND", "Course not found.", 404);
+		const lesson = findLesson(course, lessonId);
+		invariant(lesson.preview && ![
+			"quiz",
+			"assignment",
+			"live"
+		].includes(lesson.kind), "PREVIEW_UNAVAILABLE", "This lesson is available to enrolled learners.", 403);
+		return {
+			course: courseDetail(course),
+			lesson: publicLesson(await this.resolveContent(lesson))
+		};
+	}
+	async resolveContent(lesson) {
+		if (!lesson.contentSource) return lesson;
+		invariant(this.ctx.content, "CONTENT_UNAVAILABLE", "Content integration is unavailable.", 503);
+		const entry = await this.ctx.content.get(lesson.contentSource.collection, lesson.contentSource.id);
+		invariant(entry?.status === "published", "CONTENT_UNAVAILABLE", "The linked lesson content is not published.", 404);
+		const body = entry.data[lesson.contentSource.field];
+		invariant(Array.isArray(body) || typeof body === "string", "CONTENT_UNAVAILABLE", "The linked lesson field is unavailable.", 404);
+		if (Array.isArray(body)) return {
+			...lesson,
+			body: "",
+			portableText: body
+		};
+		return {
+			...lesson,
+			body,
+			portableText: []
+		};
+	}
+	async authorLessonPreview(actor, courseId, lessonId) {
+		const { course } = await this.editableCourse(actor, courseId);
+		return {
+			course: courseDetail(course),
+			lesson: publicLesson(await this.resolveContent(findLesson(course, lessonId)))
+		};
+	}
+	async assertPrerequisites(course, actorId) {
+		for (const id of course.prerequisiteCourseIds) invariant((await this.stores.enrollments.get(enrollmentKey(id, actorId)))?.completedAt, "COURSE_PREREQUISITE_REQUIRED", "Complete the prerequisite courses before enrolling.", 403);
+	}
+	newEnrollment(course, actor, status) {
+		const now = this.time();
+		const active = status === "active";
+		return {
+			id: enrollmentKey(course.id, actor.id),
+			courseId: course.id,
+			courseEditionId: course.publishedEditionId ?? course.legacyEditionId,
+			userId: actor.id,
+			learnerName: actor.name || actor.email.split("@")[0] || "Learner",
+			learnerEmail: actor.email,
+			status,
+			accessStatus: active ? "granted" : "pending",
+			accessSource: "free",
+			grants: { free: {
+				id: "free",
+				source: "free",
+				referenceId: null,
+				status: active ? "granted" : "pending",
+				startsAt: null,
+				expiresAt: active && course.accessDays ? new Date(this.now().getTime() + course.accessDays * 864e5).toISOString() : null,
+				grantedAt: active ? now : null,
+				grantedBy: null
+			} },
+			cohortIds: [],
+			acquisition: {
+				orderId: null,
+				offerId: course.commerce.offerId,
+				paymentStatus: "not_required",
+				amountMinor: null,
+				currency: null,
+				providerId: null,
+				providerPaymentId: null
+			},
+			approvedBy: null,
+			decisionAt: active ? now : null,
+			decisionReason: null,
+			enrolledAt: now,
+			approvedAt: active ? now : null,
+			completedAt: null,
+			accessStartsAt: null,
+			accessExpiresAt: null,
+			cohortId: null,
+			progress: {},
+			certificate: null,
+			completionLessonIds: [],
+			lastActivityAt: now,
+			schemaVersion: 1
+		};
+	}
+	async enroll(actor, courseId, options = {}) {
+		const current = user$1(actor);
+		let course = await this.course(courseId);
+		invariant(course.status === "published", "NOT_FOUND", "Course not found.", 404);
+		invariant(course.commerce.accessModel === "free", "PAID_COURSES_DISABLED", "Payment processing is not enabled for this course.", 403);
+		course = (await this.editions.ensure(courseId)).value;
+		invariant(course.status === "published", "NOT_FOUND", "Course not found.", 404);
+		const cohort = options.cohortId ? await this.stores.cohorts.get(options.cohortId) : null;
+		if (options.cohortId) invariant(cohort && cohort.courseIds.includes(courseId), "NOT_FOUND", "This course is not part of that cohort.", 404);
+		if (cohort) invariant((await this.stores.cohort_enrollments.get(enrollmentKey(cohort.id, current.id)))?.status === "active", "COHORT_APPROVAL_REQUIRED", "Request cohort membership and wait for administrator approval.", 403);
+		const id = enrollmentKey(courseId, current.id);
+		const existing = await this.stores.enrollments.get(id);
+		if (!cohort && existing && [
+			"active",
+			"completed",
+			"pending"
+		].includes(existing.status)) return await this.enrollmentView(existing);
+		invariant(course.enrollmentMode !== "invite" || cohort, "INVITATION_REQUIRED", "An administrator must enroll you in this course.", 403);
+		invariant(!course.enrollmentClosesAt || this.now().getTime() < Date.parse(course.enrollmentClosesAt), "ENROLLMENT_CLOSED", "Enrollment for this course is closed.", 403);
+		await this.assertPrerequisites(course, current.id);
+		const enrollment = await change(this.stores.enrollments, id, async (stored) => {
+			invariant(!stored || ![
+				"suspended",
+				"cancelled",
+				"rejected"
+			].includes(stored.status), "ENROLLMENT_RESTRICTED", "Contact an administrator to restore your enrollment.", 403);
+			const next = structuredClone(stored ?? this.newEnrollment(course, current, !cohort && course.enrollmentMode === "approval" ? "pending" : "active"));
+			if (cohort) {
+				next.cohortId = cohort.id;
+				next.cohortIds = [...new Set([...next.cohortIds, cohort.id])];
+				if (!stored || stored.accessStatus !== "granted") next.accessSource = "cohort";
+				if (!stored) delete next.grants.free;
+				next.status = next.completedAt ? "completed" : "active";
+				next.accessStatus = "granted";
+				next.approvedAt ??= this.time();
+				next.grants[`cohort:${cohort.id}`] = {
+					id: `cohort:${cohort.id}`,
+					source: "cohort",
+					referenceId: cohort.id,
+					status: "granted",
+					startsAt: cohort.startsAt,
+					expiresAt: cohort.endsAt,
+					grantedAt: this.time(),
+					grantedBy: null
+				};
+			}
+			return {
+				value: next,
+				result: next
+			};
+		});
+		await this.notify(enrollment, "enrolled", enrollment.status === "pending" ? "Enrollment requested" : "You are enrolled", `${course.title}: ${enrollment.status === "pending" ? "an administrator will review your request." : "your learning journey is ready."}`);
+		return await this.enrollmentView(enrollment);
+	}
+	async adminEnrollment(actor, input) {
+		const parsed = parse(enrollmentAdminSchema, input);
+		let course = await this.course(parsed.courseId);
+		const currentActor = this.instructor(course, actor);
+		invariant(currentActor.role >= 50, "FORBIDDEN", "Only administrators can make enrollment decisions.", 403);
+		invariant(this.ctx.users, "USERS_UNAVAILABLE", "The user directory is unavailable.", 503);
+		if (parsed.status === "active" && !await this.stores.enrollments.get(enrollmentKey(course.id, parsed.userId))) course = (await this.editions.ensure(parsed.courseId)).value;
+		const target = await this.ctx.users.get(parsed.userId);
+		invariant(target, "NOT_FOUND", "Learner account not found.", 404);
+		invariant(!parsed.accessStartsAt || !parsed.accessExpiresAt || Date.parse(parsed.accessExpiresAt) > Date.parse(parsed.accessStartsAt), "INVALID_ACCESS_WINDOW", "Access expiry must follow its start.");
+		if (parsed.cohortId) {
+			const cohort = await this.stores.cohorts.get(parsed.cohortId);
+			invariant(cohort && cohort.courseIds.includes(course.id), "INVALID_COHORT", "This course must belong to the selected cohort.");
+		}
+		if (parsed.status === "active") {
+			invariant(course.status !== "draft", "COURSE_NOT_PUBLISHED", "Publish the course before enrolling learners.", 409);
+			invariant(course.commerce.accessModel === "free", "PAID_COURSES_DISABLED", "Paid access is not enabled in this release.", 403);
+			await this.assertPrerequisites(course, target.id);
+		}
+		const cohort = parsed.cohortId ? await this.stores.cohorts.get(parsed.cohortId) : null;
+		if (cohort && parsed.status === "active") invariant((await this.stores.cohort_enrollments.get(enrollmentKey(cohort.id, target.id)))?.status === "active", "COHORT_APPROVAL_REQUIRED", "Approve cohort membership before granting cohort access.", 403);
+		const settings = await this.settings();
+		const enrollment = await change(this.stores.enrollments, enrollmentKey(course.id, target.id), async (stored) => {
+			const next = structuredClone(stored ?? this.newEnrollment(course, target, parsed.status));
+			const firstApproval = parsed.status === "active" && !next.approvedAt;
+			next.courseEditionId ??= course.legacyEditionId ?? course.publishedEditionId;
+			next.status = parsed.status === "active" && next.completedAt ? "completed" : parsed.status;
+			next.accessStatus = parsed.status === "active" ? "granted" : parsed.status === "suspended" ? "suspended" : "revoked";
+			next.approvedBy = parsed.status === "active" ? currentActor.id : next.approvedBy;
+			next.decisionAt = this.time();
+			next.decisionReason = parsed.reason || null;
+			next.accessSource = stored?.approvedAt ? stored.accessSource : cohort ? "cohort" : "manual";
+			if (firstApproval) next.approvedAt = this.time();
+			if (parsed.cohortId !== void 0) next.cohortId = parsed.cohortId;
+			if (!cohort && parsed.accessStartsAt !== void 0) next.accessStartsAt = parsed.accessStartsAt;
+			if (!cohort && parsed.accessExpiresAt !== void 0) next.accessExpiresAt = parsed.accessExpiresAt;
+			if (parsed.status === "active") {
+				if (!stored) delete next.grants.free;
+				const grantId = cohort ? `cohort:${cohort.id}` : "manual";
+				const previous = next.grants[grantId];
+				next.grants[grantId] = {
+					id: grantId,
+					source: cohort ? "cohort" : "manual",
+					referenceId: cohort?.id ?? null,
+					status: "granted",
+					startsAt: cohort?.startsAt ?? null,
+					expiresAt: cohort ? cohort.endsAt : parsed.accessExpiresAt !== void 0 ? parsed.accessExpiresAt : previous && (!previous.expiresAt || Date.parse(previous.expiresAt) > this.now().getTime()) ? previous.expiresAt : course.accessDays ? new Date(this.now().getTime() + course.accessDays * 864e5).toISOString() : null,
+					grantedAt: previous?.grantedAt ?? this.time(),
+					grantedBy: currentActor.id
+				};
+				if (cohort) next.cohortIds = [...new Set([...next.cohortIds, cohort.id])];
+			}
+			invariant(!next.accessStartsAt || !next.accessExpiresAt || Date.parse(next.accessExpiresAt) > Date.parse(next.accessStartsAt), "INVALID_ACCESS_WINDOW", "Access expiry must follow its start.");
+			next.lastActivityAt = this.time();
+			if (parsed.status === "active") this.finish(await this.editions.learning(course, next), next, settings);
+			return {
+				value: next,
+				result: next
+			};
+		});
+		await this.audit(currentActor, "enrollment.update", enrollment.id, { status: enrollment.status });
+		await this.notify(enrollment, `enrollment-${enrollment.status}-${enrollment.decisionAt}`, "Enrollment updated", `${course.title}: your enrollment is ${enrollment.status}.`);
+		await this.projectCompletion(enrollment);
+		return staffEnrollment(await this.accessEnrollment(enrollment), this.now());
+	}
+	async learnerCourse(actor, courseId) {
+		const current = user$1(actor);
+		const course = await this.course(courseId);
+		const enrollment = await this.stores.enrollments.get(enrollmentKey(courseId, current.id));
+		invariant(course.status === "published" || course.status === "archived" && enrollment, "NOT_FOUND", "Course not found.", 404);
+		if (enrollment?.completedAt) await this.projectCompletion(enrollment);
+		return {
+			course: await this.detail(await this.editions.learning(course, enrollment)),
+			...await this.learningState(course, enrollment)
+		};
+	}
+	async learnerCourseBySlug(actor, slug) {
+		user$1(actor);
+		const page = await this.stores.courses.query({
+			where: { slug },
+			limit: 1
+		});
+		invariant(page.items[0], "NOT_FOUND", "Course not found.", 404);
+		return this.learnerCourse(actor, page.items[0].id);
+	}
+	async dashboard(actor, options = {}) {
+		const current = user$1(actor);
+		const page = await queryPage(this.stores.enrollments, {
+			where: { userId: current.id },
+			orderBy: { enrolledAt: "desc" },
+			limit: options.limit ?? 24,
+			cursor: options.cursor
+		});
+		const courses = await this.stores.courses.getMany(page.items.map((entry) => entry.courseId));
+		const items = (await Promise.all(page.items.map(async (enrollment) => {
+			if (enrollment.completedAt) await this.projectCompletion(enrollment);
+			const course = courses.get(enrollment.courseId);
+			return course ? {
+				course: courseCard(await this.editions.learning(course, enrollment)),
+				...await this.learningState(course, enrollment)
+			} : null;
+		}))).filter((row) => row !== null);
+		return {
+			...page,
+			items
+		};
+	}
+	async learnerLesson(actor, courseId, lessonId) {
+		const current = user$1(actor);
+		const course = await this.course(courseId);
+		const enrollment = await this.stores.enrollments.get(enrollmentKey(courseId, current.id));
+		const lesson = await this.lessonAccess(course, lessonId, enrollment);
+		return {
+			course: courseDetail(await this.editions.learning(course, enrollment)),
+			lesson: publicLesson(await this.resolveContent(lesson)),
+			...await this.learningState(course, enrollment)
+		};
+	}
+	async startLesson(actor, courseId, lessonId) {
+		const current = user$1(actor);
+		const course = await this.course(courseId);
+		const enrollment = await change(this.stores.enrollments, enrollmentKey(courseId, current.id), async (stored) => {
+			await this.lessonAccess(course, lessonId, stored);
+			const next = structuredClone(stored);
+			const progress = next.progress[lessonId] ?? emptyProgress();
+			progress.startedAt ??= this.time();
+			next.progress[lessonId] = progress;
+			next.lastActivityAt = this.time();
+			return {
+				value: next,
+				result: next
+			};
+		});
+		return await this.enrollmentView(enrollment);
+	}
+	async completeLesson(actor, courseId, lessonId) {
+		const current = user$1(actor);
+		const course = await this.course(courseId);
+		const settings = await this.settings();
+		const enrollment = await change(this.stores.enrollments, enrollmentKey(courseId, current.id), async (stored) => {
+			const lesson = await this.lessonAccess(course, lessonId, stored);
+			invariant(!["quiz", "assignment"].includes(lesson.kind), "ASSESSMENT_REQUIRED", "Pass the quiz or assignment to complete this lesson.", 403);
+			const next = structuredClone(stored);
+			const progress = next.progress[lessonId] ?? emptyProgress();
+			invariant(progress.startedAt, "LESSON_NOT_STARTED", "Start the lesson before marking it complete.");
+			if (lesson.kind === "live") invariant(lesson.liveStartsAt && this.now().getTime() >= Date.parse(lesson.liveStartsAt), "LIVE_NOT_STARTED", "The live session has not started yet.", 403);
+			invariant(this.now().getTime() - Date.parse(progress.startedAt) >= lesson.minStudySeconds * 1e3, "STUDY_TIME_REQUIRED", "Spend the minimum study time on this lesson before completing it.", 403);
+			progress.completedAt ??= this.time();
+			next.progress[lessonId] = progress;
+			this.finish(await this.editions.learning(course, next), next, settings);
+			return {
+				value: next,
+				result: next
+			};
+		});
+		await this.projectCompletion(enrollment);
+		return { ...await this.learningState(course, enrollment) };
+	}
+	finish(course, enrollment, settings) {
+		enrollment.lastActivityAt = this.time();
+		const required = lessons(course).filter((lesson) => lesson.required);
+		if (enrollment.completedAt || !required.length || !required.every((lesson) => enrollment.progress[lesson.id]?.completedAt)) return;
+		enrollment.status = "completed";
+		enrollment.completedAt = this.time();
+		enrollment.completionLessonIds = required.map((lesson) => lesson.id);
+		if (course.certificateEnabled) enrollment.certificate = {
+			id: crypto.randomUUID(),
+			courseId: course.id,
+			courseTitle: course.title,
+			userId: enrollment.userId,
+			learnerName: enrollment.learnerName,
+			issuerName: settings.issuerName,
+			issuedAt: this.time(),
+			shared: false,
+			revokedAt: null,
+			revocationReason: null
+		};
+	}
+	async projectCompletion(enrollment) {
+		if (enrollment.certificate) await putOnce(this.stores.certificates, enrollment.certificate.id, {
+			enrollmentId: enrollment.id,
+			courseId: enrollment.courseId,
+			userId: enrollment.userId
+		});
+		if (enrollment.completedAt) await this.notify(enrollment, "completed", "Course complete", "You have completed your course. Your achievement is saved in My Learning.");
+	}
+	async startQuiz(actor, courseId, lessonId) {
+		const current = user$1(actor);
+		const course = await this.course(courseId);
+		const result = await change(this.stores.enrollments, enrollmentKey(courseId, current.id), async (stored) => {
+			const lesson = await this.lessonAccess(course, lessonId, stored);
+			invariant(lesson.kind === "quiz" && lesson.quiz, "NOT_A_QUIZ", "This lesson has no quiz.");
+			const next = structuredClone(stored);
+			const progress = next.progress[lessonId] ?? emptyProgress();
+			progress.startedAt ??= this.time();
+			const existing = progress.quizAttempts.find((attempt) => attempt.status === "in_progress");
+			if (existing && (!existing.expiresAt || this.now().getTime() < Date.parse(existing.expiresAt))) return {
+				value: next,
+				result: {
+					attempt: existing,
+					blocked: false
+				}
+			};
+			if (existing) {
+				existing.status = "expired";
+				existing.quiz = null;
+				existing.submittedAt = this.time();
+			}
+			next.progress[lessonId] = progress;
+			if (progress.quizAttempts.length >= lesson.quiz.maxAttempts || progress.completedAt) return {
+				value: next,
+				result: {
+					attempt: null,
+					blocked: true
+				}
+			};
+			const quiz = structuredClone(lesson.quiz);
+			const questions = (quiz.randomizeQuestions ? shuffle(quiz.questions) : quiz.questions).map(({ correctAnswers: _correct, explanation: _explanation, ...question }) => ({
+				...question,
+				options: quiz.randomizeOptions ? shuffle(question.options) : question.options
+			}));
+			const attempt = {
+				id: crypto.randomUUID(),
+				startedAt: this.time(),
+				expiresAt: quiz.timeLimitMinutes ? new Date(this.now().getTime() + quiz.timeLimitMinutes * 6e4).toISOString() : null,
+				status: "in_progress",
+				quiz,
+				questions,
+				submittedAt: null,
+				score: null,
+				maxScore: null,
+				percent: null,
+				passed: false,
+				feedback: [],
+				answers: {},
+				draftRevision: 0
+			};
+			progress.quizAttempts.push(attempt);
+			next.lastActivityAt = this.time();
+			return {
+				value: next,
+				result: {
+					attempt,
+					blocked: false
+				}
+			};
+		});
+		invariant(result.attempt && !result.blocked, "ATTEMPT_LIMIT", "No further quiz attempts are available. Contact an instructor.", 403);
+		return publicAttempt(result.attempt);
+	}
+	async submitQuiz(actor, input) {
+		const current = user$1(actor);
+		const parsed = parse(quizSubmitSchema, input);
+		const course = await this.course(parsed.courseId);
+		const settings = await this.settings();
+		const result = await change(this.stores.enrollments, enrollmentKey(course.id, current.id), async (stored) => {
+			await this.lessonAccess(course, parsed.lessonId, stored);
+			const next = structuredClone(stored);
+			const progress = next.progress[parsed.lessonId];
+			const attempt = progress?.quizAttempts.find((item) => item.id === parsed.attemptId);
+			invariant(attempt && progress, "NOT_FOUND", "Quiz attempt not found.", 404);
+			if (attempt.status !== "in_progress") return {
+				value: next,
+				result: {
+					enrollment: next,
+					attempt,
+					expired: attempt.status === "expired"
+				}
+			};
+			if (attempt.expiresAt && this.now().getTime() >= Date.parse(attempt.expiresAt)) {
+				attempt.status = "expired";
+				attempt.quiz = null;
+				attempt.submittedAt = this.time();
+				return {
+					value: next,
+					result: {
+						enrollment: next,
+						attempt,
+						expired: true
+					}
+				};
+			}
+			invariant(attempt.quiz, "INVALID_ATTEMPT", "This attempt cannot be graded.", 409);
+			invariant(parsed.expectedDraftRevision === void 0 || parsed.expectedDraftRevision === (attempt.draftRevision ?? 0), "DRAFT_CONFLICT", "Saved answers changed in another request. Review them before submitting.", 409);
+			const graded = gradeAnswers(attempt.quiz.questions, parsed.answers);
+			attempt.passed = graded.score * 100 >= graded.maxScore * attempt.quiz.passingPercent;
+			attempt.feedback = attempt.quiz.showFeedback === "after_submit" || attempt.quiz.showFeedback === "after_pass" && attempt.passed ? graded.feedback : [];
+			attempt.score = graded.score;
+			attempt.maxScore = graded.maxScore;
+			attempt.percent = graded.percent;
+			attempt.answers = parsed.answers;
+			attempt.status = "submitted";
+			attempt.submittedAt = this.time();
+			attempt.quiz = null;
+			if (attempt.passed) progress.completedAt ??= this.time();
+			this.finish(await this.editions.learning(course, next), next, settings);
+			return {
+				value: next,
+				result: {
+					enrollment: next,
+					attempt,
+					expired: false
+				}
+			};
+		});
+		invariant(!result.expired, "QUIZ_EXPIRED", "The quiz time limit expired. Start a new attempt if one is available.", 409);
+		await this.projectCompletion(result.enrollment);
+		return {
+			attempt: publicAttempt(result.attempt),
+			...await this.learningState(course, result.enrollment)
+		};
+	}
+	async saveQuizDraft(actor, input) {
+		const current = user$1(actor);
+		const parsed = parse(quizDraftSchema, input);
+		const course = await this.course(parsed.courseId);
+		return {
+			saved: true,
+			draftRevision: await change(this.stores.enrollments, enrollmentKey(course.id, current.id), async (stored) => {
+				await this.lessonAccess(course, parsed.lessonId, stored);
+				const next = structuredClone(stored);
+				const attempt = next.progress[parsed.lessonId]?.quizAttempts.find((item) => item.id === parsed.attemptId);
+				invariant(attempt?.status === "in_progress" && attempt.quiz, "ATTEMPT_CLOSED", "This quiz attempt is closed.", 409);
+				invariant(!attempt.expiresAt || this.now().getTime() < Date.parse(attempt.expiresAt), "QUIZ_EXPIRED", "This quiz attempt has expired.", 409);
+				gradeAnswers(attempt.quiz.questions, parsed.answers);
+				const revision = attempt.draftRevision ?? 0;
+				const canonical = (answers) => JSON.stringify(Object.entries(answers).sort(([a], [b]) => a.localeCompare(b)));
+				if (revision === parsed.expectedDraftRevision + 1 && canonical(attempt.answers) === canonical(parsed.answers)) return {
+					value: next,
+					result: revision
+				};
+				invariant(revision === parsed.expectedDraftRevision, "DRAFT_CONFLICT", "Saved answers changed in another request. Review them before saving.", 409);
+				attempt.answers = parsed.answers;
+				attempt.draftRevision = revision + 1;
+				return {
+					value: next,
+					result: attempt.draftRevision
+				};
+			})
+		};
+	}
+	async submitAssignment(actor, input) {
+		const current = user$1(actor);
+		const parsed = parse(assignmentSubmitSchema, input);
+		const course = await this.course(parsed.courseId);
+		const enrollment = await change(this.stores.enrollments, enrollmentKey(course.id, current.id), async (stored) => {
+			const lesson = await this.lessonAccess(course, parsed.lessonId, stored);
+			invariant(lesson.kind === "assignment" && lesson.assignment, "NOT_AN_ASSIGNMENT", "This lesson has no assignment.");
+			invariant(!lesson.assignment.dueAt || this.now().getTime() <= Date.parse(lesson.assignment.dueAt), "ASSIGNMENT_CLOSED", "The assignment deadline has passed.", 403);
+			const next = structuredClone(stored);
+			const progress = next.progress[parsed.lessonId] ?? emptyProgress();
+			const last = progress.assignments.at(-1);
+			invariant(!progress.completedAt, "ASSIGNMENT_PASSED", "This assignment has already been passed.", 409);
+			invariant(!last || last.status === "graded" && lesson.assignment.allowResubmission, "SUBMISSION_PENDING", "Wait for grading before submitting again.", 409);
+			invariant(progress.assignments.length < 10, "SUBMISSION_LIMIT", "The assignment submission limit has been reached.", 403);
+			progress.startedAt ??= this.time();
+			progress.assignments.push({
+				id: crypto.randomUUID(),
+				body: parsed.body,
+				attachmentUrl: parsed.attachmentUrl,
+				submittedAt: this.time(),
+				status: "submitted",
+				maxPoints: lesson.assignment.maxPoints,
+				passingPoints: lesson.assignment.passingPoints,
+				points: null,
+				feedback: "",
+				gradedAt: null,
+				gradedBy: null
+			});
+			next.progress[parsed.lessonId] = progress;
+			next.lastActivityAt = this.time();
+			return {
+				value: next,
+				result: next
+			};
+		});
+		return await this.enrollmentView(enrollment);
+	}
+	async gradeAssignment(actor, input) {
+		const parsed = parse(gradeSchema, input);
+		const course = await this.course(parsed.courseId);
+		const current = this.instructor(course, actor);
+		const settings = await this.settings();
+		const enrollment = await change(this.stores.enrollments, enrollmentKey(course.id, parsed.userId), async (stored) => {
+			invariant(stored, "NOT_FOUND", "Enrollment not found.", 404);
+			const next = structuredClone(stored);
+			const progress = next.progress[parsed.lessonId];
+			const submission = progress?.assignments.find((item) => item.id === parsed.submissionId);
+			invariant(submission && progress, "NOT_FOUND", "Assignment submission not found.", 404);
+			invariant(submission.status === "submitted", "ALREADY_GRADED", "This submission has already been graded.", 409);
+			invariant(parsed.points <= submission.maxPoints, "INVALID_GRADE", "The grade cannot exceed the assignment's maximum points.");
+			submission.points = parsed.points;
+			submission.feedback = parsed.feedback;
+			submission.status = "graded";
+			submission.gradedAt = this.time();
+			submission.gradedBy = current.id;
+			if (parsed.points >= submission.passingPoints) progress.completedAt ??= this.time();
+			const access = effectiveAccess(await this.accessEnrollment(next), this.now());
+			if (["active", "completed"].includes(next.status) && ![
+				"suspended",
+				"revoked",
+				"pending"
+			].includes(access)) this.finish(await this.editions.learning(course, next), next, settings);
+			return {
+				value: next,
+				result: next
+			};
+		});
+		await this.projectCompletion(enrollment);
+		await this.notify(enrollment, `graded-${parsed.submissionId}`, "Assignment graded", "Your assignment feedback is ready in My Learning.");
+		await this.audit(current, "assignment.grade", enrollment.id, {
+			lessonId: parsed.lessonId,
+			points: parsed.points
+		});
+		return staffEnrollment(await this.accessEnrollment(enrollment), this.now());
+	}
+	async saveNote(actor, input) {
+		const current = user$1(actor);
+		const parsed = parse(noteSchema, input);
+		const course = await this.course(parsed.courseId);
+		return { note: (await change(this.stores.enrollments, enrollmentKey(course.id, current.id), async (stored) => {
+			await this.lessonAccess(course, parsed.lessonId, stored);
+			const next = structuredClone(stored);
+			const progress = next.progress[parsed.lessonId] ?? emptyProgress();
+			progress.note = parsed.note;
+			next.progress[parsed.lessonId] = progress;
+			return {
+				value: next,
+				result: next
+			};
+		})).progress[parsed.lessonId].note };
+	}
+	async certificate(actor, courseId) {
+		const current = user$1(actor);
+		const enrollment = await this.stores.enrollments.get(enrollmentKey(courseId, current.id));
+		invariant(enrollment?.certificate, "NOT_FOUND", "Certificate not found.", 404);
+		await this.projectCompletion(enrollment);
+		return enrollment.certificate;
+	}
+	async ownedCertificate(actor, id) {
+		const current = user$1(actor);
+		const index = await this.stores.certificates.get(id);
+		invariant(index?.userId === current.id, "NOT_FOUND", "Certificate not found.", 404);
+		const enrollment = await this.stores.enrollments.get(index.enrollmentId);
+		invariant(enrollment?.certificate?.id === id, "NOT_FOUND", "Certificate not found.", 404);
+		return enrollment.certificate;
+	}
+	async verifyCertificate(id) {
+		const index = await this.stores.certificates.get(id);
+		invariant(index, "NOT_FOUND", "Certificate not found.", 404);
+		const certificate = (await this.stores.enrollments.get(index.enrollmentId))?.certificate;
+		invariant(certificate?.id === id, "NOT_FOUND", "Certificate not found.", 404);
+		return {
+			id,
+			courseTitle: certificate.courseTitle,
+			issuerName: certificate.issuerName,
+			issuedAt: certificate.issuedAt,
+			valid: !certificate.revokedAt,
+			shared: certificate.shared,
+			learnerName: certificate.shared ? certificate.learnerName : null
+		};
+	}
+	async shareCertificate(actor, courseId, shared) {
+		const current = user$1(actor);
+		return await change(this.stores.enrollments, enrollmentKey(courseId, current.id), async (stored) => {
+			invariant(stored?.certificate, "NOT_FOUND", "Certificate not found.", 404);
+			const next = structuredClone(stored);
+			next.certificate.shared = shared;
+			return {
+				value: next,
+				result: next.certificate
+			};
+		});
+	}
+	async revokeCertificate(actor, courseId, userId, reason) {
+		const course = await this.course(courseId);
+		const current = this.instructor(course, actor);
+		const certificate = await change(this.stores.enrollments, enrollmentKey(courseId, userId), async (stored) => {
+			invariant(stored?.certificate, "NOT_FOUND", "Certificate not found.", 404);
+			const next = structuredClone(stored);
+			next.certificate.revokedAt = this.time();
+			next.certificate.revocationReason = reason;
+			return {
+				value: next,
+				result: next.certificate
+			};
+		});
+		await this.audit(current, "certificate.revoke", certificate.id);
+		return certificate;
+	}
+	async cancelEnrollment(actor, courseId) {
+		const current = user$1(actor);
+		const enrollment = await change(this.stores.enrollments, enrollmentKey(courseId, current.id), async (stored) => {
+			invariant(stored, "NOT_FOUND", "Enrollment not found.", 404);
+			const next = {
+				...stored,
+				status: "cancelled",
+				accessStatus: "revoked"
+			};
+			return {
+				value: next,
+				result: next
+			};
+		});
+		return await this.enrollmentView(enrollment);
+	}
+	async discussions(actor, courseId, lessonId, cursor) {
+		const current = user$1(actor);
+		const course = await this.course(courseId);
+		const enrollment = await this.stores.enrollments.get(enrollmentKey(courseId, current.id));
+		await this.lessonAccess(course, lessonId, enrollment);
+		const page = await queryPage(this.stores.discussions, {
+			where: {
+				courseId,
+				lessonId,
+				status: "published"
+			},
+			orderBy: { createdAt: "asc" },
+			cursor,
+			limit: 30
+		});
+		const own = await queryPage(this.stores.discussions, {
+			where: {
+				courseId,
+				lessonId,
+				authorId: current.id,
+				status: "pending"
+			},
+			limit: 30
+		});
+		return {
+			...page,
+			pending: own.items
+		};
+	}
+	async postDiscussion(actor, input) {
+		const current = user$1(actor);
+		const parsed = parse(discussionSchema, input);
+		const course = await this.course(parsed.courseId);
+		const enrollment = await this.stores.enrollments.get(enrollmentKey(course.id, current.id));
+		await this.lessonAccess(course, parsed.lessonId, enrollment);
+		if (parsed.parentId) {
+			const parent = await this.stores.discussions.get(parsed.parentId);
+			invariant(parent && parent.courseId === course.id && parent.lessonId === parsed.lessonId && parent.status === "published" && !parent.parentId, "INVALID_PARENT", "Reply to a published discussion in this lesson.");
+		}
+		const settings = await this.settings();
+		const id = crypto.randomUUID();
+		const discussion = {
+			...parsed,
+			id,
+			authorId: current.id,
+			authorName: current.name || "Learner",
+			status: settings.moderateDiscussions ? "pending" : "published",
+			createdAt: this.time(),
+			updatedAt: this.time()
+		};
+		await this.stores.discussions.put(id, discussion);
+		return discussion;
+	}
+	async publicReviews(courseId, cursor) {
+		invariant((await this.course(courseId)).status === "published", "NOT_FOUND", "Course not found.", 404);
+		return queryPage(this.stores.reviews, {
+			where: {
+				courseId,
+				status: "published"
+			},
+			orderBy: { createdAt: "desc" },
+			limit: 24,
+			cursor
+		});
+	}
+	async postReview(actor, input) {
+		const current = user$1(actor);
+		const parsed = parse(reviewSchema, input);
+		const course = await this.course(parsed.courseId);
+		const enrollment = await this.accessEnrollment(await this.stores.enrollments.get(enrollmentKey(course.id, current.id)));
+		assertEnrollmentAccess(enrollment, this.now());
+		invariant(Object.values(enrollment.progress).some((progress) => progress.completedAt), "REVIEW_TOO_EARLY", "Complete at least one lesson before reviewing this course.", 403);
+		const settings = await this.settings();
+		const id = enrollmentKey(course.id, current.id);
+		return await change(this.stores.reviews, id, async (stored) => {
+			const next = {
+				...parsed,
+				id,
+				userId: current.id,
+				authorName: current.name || "Learner",
+				status: settings.moderateReviews ? "pending" : "published",
+				createdAt: stored?.createdAt ?? this.time(),
+				updatedAt: this.time()
+			};
+			return {
+				value: next,
+				result: next
+			};
+		});
+	}
+	async moderate(actor, collection, input) {
+		const parsed = parse(moderateSchema, input);
+		const store = this.stores[collection];
+		const stored = await store.getVersioned(parsed.id);
+		invariant(stored, "NOT_FOUND", "Community item not found.", 404);
+		const course = await this.course(stored.value.courseId);
+		const current = this.instructor(course, actor);
+		invariant(stored.revision === parsed.expectedRevision, "CONFLICT", "This item changed. Reload before moderating.", 409);
+		const next = {
+			...stored.value,
+			status: parsed.status,
+			updatedAt: this.time()
+		};
+		invariant((await store.compareAndSet(parsed.id, stored.revision, next)).applied, "CONFLICT", "This item changed while moderating.", 409);
+		await this.audit(current, `${collection}.moderate`, parsed.id, { status: parsed.status });
+		return next;
+	}
+	async communityQueue(actor, collection, options = {}) {
+		const current = user$1(actor);
+		if (options.courseId) this.instructor(await this.course(options.courseId), current);
+		else invariant(current.role >= 50, "FORBIDDEN", "Select a course you teach.", 403);
+		const store = this.stores[collection];
+		const page = await store.query({
+			where: {
+				...options.courseId ? { courseId: options.courseId } : {},
+				...options.status ? { status: options.status } : {}
+			},
+			orderBy: { createdAt: "desc" },
+			limit: 30,
+			cursor: options.cursor
+		});
+		const items = (await Promise.all(page.items.map((item) => store.getVersioned(item.id)))).flatMap((item) => item ? [{
+			...item.value,
+			revision: item.revision
+		}] : []);
+		return {
+			...page,
+			items
+		};
+	}
+	async enrollments(actor, options = {}) {
+		const current = user$1(actor);
+		if (options.courseId) this.instructor(await this.course(options.courseId), current);
+		else invariant(current.role >= 50, "FORBIDDEN", "Select a course you teach.", 403);
+		const page = await queryPage(this.stores.enrollments, {
+			where: {
+				...options.courseId ? { courseId: options.courseId } : {},
+				...options.status ? { status: options.status } : {}
+			},
+			orderBy: { enrolledAt: "desc" },
+			limit: options.limit ?? 30,
+			cursor: options.cursor
+		});
+		const courses = await this.stores.courses.getMany(page.items.map((item) => item.courseId));
+		return {
+			...page,
+			items: await Promise.all(page.items.map(async (enrollment) => {
+				const resolved = await this.accessEnrollment(enrollment);
+				const root = courses.get(enrollment.courseId);
+				const course = root ? await this.editions.learning(root, enrollment) : null;
+				const now = this.now();
+				return {
+					...staffEnrollment(resolved, now),
+					learnerEmail: enrollment.learnerEmail,
+					courseTitle: course?.title ?? "Archived course",
+					lessonTitles: Object.fromEntries((course ? lessons(course) : []).map((lesson) => [lesson.id, lesson.title])),
+					progressSummary: course ? progressSummary(course, resolved, now) : null
+				};
+			}))
+		};
+	}
+	async report(actor, courseId) {
+		const current = user$1(actor);
+		if (courseId) this.instructor(await this.course(courseId), current);
+		else invariant(current.role >= 50, "FORBIDDEN", "Select a course you teach.", 403);
+		const filter = courseId ? { courseId } : {};
+		const statuses = [
+			"pending",
+			"active",
+			"completed",
+			"rejected",
+			"suspended",
+			"cancelled"
+		];
+		const counts = await Promise.all(statuses.map((status) => this.stores.enrollments.count({
+			...filter,
+			status
+		})));
+		const statusCounts = Object.fromEntries(statuses.map((status, index) => [status, counts[index]]));
+		const total = counts.reduce((sum, count) => sum + count, 0);
+		const completedEver = await this.stores.enrollments.count({
+			...filter,
+			completedAt: { gte: "0000-01-01T00:00:00.000Z" }
+		});
+		const sourceCounts = Object.fromEntries(await Promise.all([
+			"free",
+			"manual",
+			"cohort",
+			"purchase"
+		].map(async (accessSource) => [accessSource, await this.stores.enrollments.count({
+			...filter,
+			accessSource
+		})])));
+		const accessDecisions = Object.fromEntries(await Promise.all([
+			"pending",
+			"granted",
+			"suspended",
+			"revoked"
+		].map(async (accessStatus) => [accessStatus, await this.stores.enrollments.count({
+			...filter,
+			accessStatus
+		})])));
+		return {
+			total,
+			completedEver,
+			...statusCounts,
+			accessSources: sourceCounts,
+			accessDecisions,
+			completionRate: total ? Math.round(completedEver / total * 100) : 0,
+			courseCount: courseId ? 1 : await this.stores.courses.count(),
+			generatedAt: this.time()
+		};
+	}
+	async enrollmentCsv(actor, options = {}) {
+		const lines = [enrollmentCsvHeader];
+		let cursor;
+		let rows = 0;
+		let bytes = new TextEncoder().encode(enrollmentCsvHeader).byteLength + 3;
+		do {
+			const page = await this.enrollments(actor, {
+				...options,
+				cursor,
+				limit: 100
+			});
+			const next = enrollmentCsvLines(page.items);
+			rows += next.length;
+			bytes += new TextEncoder().encode(next.join("\r\n")).byteLength + next.length * 2;
+			invariant(rows <= 1e4 && bytes <= 6e6, "EXPORT_TOO_LARGE", "Filter by course or enrollment status to export fewer records.", 413);
+			lines.push(...next);
+			cursor = page.hasMore ? page.cursor : void 0;
+		} while (cursor);
+		return "" + lines.join("\r\n");
+	}
+	async cohortList(actor, cursor) {
+		invariant(user$1(actor).role >= 50, "FORBIDDEN", "Only administrators can manage cohorts.", 403);
+		const page = await this.stores.cohorts.query({
+			orderBy: { createdAt: "desc" },
+			limit: 24,
+			cursor
+		});
+		const items = (await Promise.all(page.items.map((item) => this.stores.cohorts.getVersioned(item.id)))).flatMap((item) => item ? [{
+			...item.value,
+			revision: item.revision
+		}] : []);
+		return {
+			...page,
+			items
+		};
+	}
+	async publicCohort(id) {
+		const cohort = await this.stores.cohorts.get(id);
+		invariant(cohort, "NOT_FOUND", "Cohort not found.", 404);
+		const courses = await this.stores.courses.getMany(cohort.courseIds);
+		return {
+			id: cohort.id,
+			title: cohort.title,
+			startsAt: cohort.startsAt,
+			endsAt: cohort.endsAt,
+			courses: [...courses.values()].filter((course) => course.status === "published" && course.commerce.accessModel === "free").map(courseCard)
+		};
+	}
+	async requestCohort(actor, cohortId) {
+		const current = user$1(actor);
+		const cohort = await this.stores.cohorts.get(cohortId);
+		invariant(cohort, "NOT_FOUND", "Cohort not found.", 404);
+		invariant(!cohort.endsAt || this.now().getTime() < Date.parse(cohort.endsAt), "COHORT_CLOSED", "This cohort has ended.", 403);
+		const id = enrollmentKey(cohortId, current.id);
+		return change(this.stores.cohort_enrollments, id, async (stored) => {
+			invariant(!stored || ![
+				"rejected",
+				"suspended",
+				"cancelled"
+			].includes(stored.status), "COHORT_RESTRICTED", "Contact an administrator to restore your cohort membership.", 403);
+			const next = stored ?? {
+				id,
+				cohortId,
+				userId: current.id,
+				learnerName: current.name || "Learner",
+				learnerEmail: current.email,
+				status: "pending",
+				requestedAt: this.time(),
+				decidedAt: null,
+				decidedBy: null,
+				reason: null
+			};
+			return {
+				value: next,
+				result: next
+			};
+		});
+	}
+	async cohortMemberships(actor, options = {}) {
+		invariant(user$1(actor).role >= 50, "FORBIDDEN", "Only administrators can review cohort membership.", 403);
+		return queryPage(this.stores.cohort_enrollments, {
+			where: {
+				...options.cohortId ? { cohortId: options.cohortId } : {},
+				...options.status ? { status: options.status } : {}
+			},
+			orderBy: { requestedAt: "desc" },
+			limit: 30,
+			cursor: options.cursor
+		});
+	}
+	async decideCohort(actor, cohortId, userId, status, reason = "") {
+		const current = user$1(actor);
+		invariant(current.role >= 50, "FORBIDDEN", "Only administrators can make cohort decisions.", 403);
+		const cohort = await this.stores.cohorts.get(cohortId);
+		invariant(cohort && this.ctx.users, "NOT_FOUND", "Cohort not found.", 404);
+		const target = await this.ctx.users.get(userId);
+		invariant(target, "NOT_FOUND", "Learner account not found.", 404);
+		const membership = await change(this.stores.cohort_enrollments, enrollmentKey(cohortId, userId), async (stored) => {
+			const next = {
+				...stored ?? {
+					id: enrollmentKey(cohortId, userId),
+					cohortId,
+					userId,
+					learnerName: target.name || "Learner",
+					learnerEmail: target.email,
+					requestedAt: this.time()
+				},
+				status,
+				decidedAt: this.time(),
+				decidedBy: current.id,
+				reason: reason || null
+			};
+			return {
+				value: next,
+				result: next
+			};
+		});
+		const results = [];
+		for (const courseId of cohort.courseIds) try {
+			if (status === "active") {
+				const existing = await this.stores.enrollments.get(enrollmentKey(courseId, userId));
+				invariant(!existing || ![
+					"suspended",
+					"cancelled",
+					"rejected"
+				].includes(existing.status), "ENROLLMENT_RESTRICTED", "Restore this course enrollment separately before granting cohort access.", 403);
+				await this.adminEnrollment(current, {
+					courseId,
+					userId,
+					cohortId,
+					status: "active"
+				});
+			} else {
+				const id = enrollmentKey(courseId, userId);
+				if (await this.stores.enrollments.exists(id)) await change(this.stores.enrollments, id, async (stored) => {
+					invariant(stored, "NOT_FOUND", "Enrollment not found.", 404);
+					const next = structuredClone(stored);
+					const grant = next.grants[`cohort:${cohortId}`];
+					if (grant) grant.status = status === "suspended" ? "suspended" : "revoked";
+					return {
+						value: next,
+						result: true
+					};
+				});
+			}
+			results.push({
+				courseId,
+				success: true
+			});
+		} catch (error) {
+			results.push({
+				courseId,
+				success: false,
+				error: error instanceof LmsError ? error.message : "Access update failed."
+			});
+		}
+		await this.audit(current, "cohort.decision", membership.id, { status });
+		return {
+			membership,
+			results
+		};
+	}
+	async saveCohort(actor, input) {
+		const current = user$1(actor);
+		invariant(current.role >= 50, "FORBIDDEN", "Only administrators can manage cohorts.", 403);
+		const parsed = parse(cohortSaveSchema, input);
+		for (const id of parsed.data.courseIds) await this.course(id);
+		const id = parsed.id ?? crypto.randomUUID();
+		const existing = await this.stores.cohorts.getVersioned(id);
+		invariant((existing?.revision ?? null) === parsed.expectedRevision, "CONFLICT", "The cohort changed. Reload before saving.", 409);
+		if (existing && await this.stores.cohort_enrollments.count({ cohortId: id })) invariant(existing.value.courseIds.every((courseId) => parsed.data.courseIds.includes(courseId)), "COHORT_IN_USE", "Cohorts with membership records must retain existing courses. Create a new cohort to remove courses.", 409);
+		const cohort = {
+			...parsed.data,
+			id,
+			createdBy: existing?.value.createdBy ?? current.id,
+			createdAt: existing?.value.createdAt ?? this.time(),
+			updatedAt: this.time()
+		};
+		const saved = await this.stores.cohorts.compareAndSet(id, existing?.revision ?? null, cohort);
+		invariant(saved.applied, "CONFLICT", "The cohort changed while saving.", 409);
+		await this.audit(current, "cohort.save", id);
+		return {
+			cohort,
+			revision: saved.revision
+		};
+	}
+	async applyCohort(actor, id, expectedRevision, offset) {
+		const current = user$1(actor);
+		invariant(current.role >= 50, "FORBIDDEN", "Only administrators can enroll cohorts.", 403);
+		const stored = await this.stores.cohorts.getVersioned(id);
+		invariant(stored, "NOT_FOUND", "Cohort not found.", 404);
+		invariant(stored.revision === expectedRevision, "CONFLICT", "The cohort changed. Reload before continuing.", 409);
+		const cohort = stored.value;
+		const members = cohort.memberIds.slice(offset, offset + Math.max(1, Math.floor(10 / cohort.courseIds.length)));
+		const results = [];
+		for (const userId of members) try {
+			const decided = await this.decideCohort(current, id, userId, "active");
+			results.push(...decided.results.map((result) => ({
+				userId,
+				...result
+			})));
+		} catch (error) {
+			results.push({
+				userId,
+				courseId: "",
+				success: false,
+				error: error instanceof LmsError ? error.message : "Enrollment failed."
+			});
+		}
+		const nextOffset = offset + members.length;
+		return {
+			results,
+			nextOffset,
+			hasMore: nextOffset < cohort.memberIds.length
+		};
+	}
+	async notify(enrollment, key, title, message) {
+		const settings = await this.settings();
+		const preferences = await this.stores.preferences.get(enrollment.userId);
+		const id = `${enrollment.id}:${key}`;
+		const notification = {
+			id,
+			userId: enrollment.userId,
+			email: enrollment.learnerEmail,
+			title,
+			message,
+			courseId: enrollment.courseId,
+			read: false,
+			createdAt: this.time(),
+			emailStatus: settings.emailNotifications && preferences?.emailNotifications !== false ? "pending" : "disabled",
+			emailAttempts: 0,
+			claimedAt: null
+		};
+		await putOnce(this.stores.notifications, id, notification);
+	}
+	async notifications(actor, cursor) {
+		const current = user$1(actor);
+		const page = await queryPage(this.stores.notifications, {
+			where: { userId: current.id },
+			orderBy: { createdAt: "desc" },
+			limit: 30,
+			cursor
+		});
+		return {
+			...page,
+			items: page.items.map(({ email: _email, emailStatus: _status, emailAttempts: _attempts, claimedAt: _claimed, ...item }) => item)
+		};
+	}
+	async readNotification(actor, id) {
+		const current = user$1(actor);
+		await change(this.stores.notifications, id, async (stored) => {
+			invariant(stored && stored.userId === current.id, "NOT_FOUND", "Notification not found.", 404);
+			return {
+				value: {
+					...stored,
+					read: true
+				},
+				result: true
+			};
+		});
+		return { read: true };
+	}
+	async deliverNotifications() {
+		if (!(await this.settings()).emailNotifications || !this.ctx.email) return {
+			sent: 0,
+			failed: 0
+		};
+		const cutoff = (/* @__PURE__ */ new Date(this.now().getTime() - 15 * 6e4)).toISOString();
+		const abandoned = await this.stores.notifications.query({
+			where: {
+				emailStatus: "sending",
+				claimedAt: { lte: cutoff }
+			},
+			limit: 20
+		});
+		let failed = 0;
+		for (const item of abandoned.items) if ((await this.stores.notifications.updateIf(item.id, {
+			where: {
+				emailStatus: "sending",
+				claimedAt: { lte: cutoff }
+			},
+			set: { emailStatus: "failed" }
+		})).applied) failed++;
+		const page = await this.stores.notifications.query({
+			where: { emailStatus: "pending" },
+			limit: 20
+		});
+		let sent = 0;
+		for (const item of page.items) {
+			if (item.data.emailAttempts >= 3) continue;
+			const claimedAt = this.time();
+			const emailAttempts = item.data.emailAttempts + 1;
+			if (!(await this.stores.notifications.updateIf(item.id, {
+				where: {
+					emailStatus: "pending",
+					emailAttempts: item.data.emailAttempts
+				},
+				set: {
+					emailStatus: "sending",
+					claimedAt
+				},
+				delta: { emailAttempts: { inc: 1 } }
+			})).applied) continue;
+			try {
+				if ((await this.stores.preferences.get(item.data.userId))?.emailNotifications === false) {
+					await this.stores.notifications.updateIf(item.id, {
+						where: {
+							emailStatus: "sending",
+							emailAttempts,
+							claimedAt
+						},
+						set: { emailStatus: "disabled" }
+					});
+					continue;
+				}
+				await this.ctx.email.send({
+					to: item.data.email,
+					subject: item.data.title,
+					text: item.data.message
+				});
+				await this.stores.notifications.updateIf(item.id, {
+					where: {
+						emailStatus: "sending",
+						emailAttempts,
+						claimedAt
+					},
+					set: { emailStatus: "sent" }
+				});
+				sent++;
+			} catch {
+				await this.stores.notifications.updateIf(item.id, {
+					where: {
+						emailStatus: "sending",
+						emailAttempts,
+						claimedAt
+					},
+					set: { emailStatus: "failed" }
+				});
+				failed++;
+			}
+		}
+		return {
+			sent,
+			failed
+		};
+	}
+	async assignments(actor, courseId, cursor) {
+		const page = await this.enrollments(actor, {
+			courseId,
+			cursor,
+			limit: 30
+		});
+		return {
+			...page,
+			items: page.items.flatMap((enrollment) => Object.entries(enrollment.progress).flatMap(([lessonId, progress]) => progress.assignments.map((submission) => ({
+				...submission,
+				userId: enrollment.userId,
+				learnerName: enrollment.learnerName,
+				courseId,
+				lessonId
+			}))))
+		};
+	}
+	async exportCourse(actor, id) {
+		const { course } = await this.editableCourse(actor, id);
+		return {
+			format: "anantagnanam-lms-course",
+			version: 1,
+			course: courseDataSchema.parse({
+				...course,
+				status: "draft"
+			})
+		};
+	}
+	async importCourse(actor, input) {
+		const parsed = parse(z.object({
+			format: z.literal("anantagnanam-lms-course"),
+			version: z.literal(1),
+			course: courseSaveSchema.shape.data
+		}), input);
+		return this.saveCourse(actor, {
+			data: {
+				...parsed.course,
+				status: "draft"
+			},
+			expectedRevision: null
+		});
+	}
+	async deleteCourse(actor, id, expectedRevision) {
+		const stored = await this.stores.courses.getVersioned(id);
+		invariant(stored, "NOT_FOUND", "Course not found.", 404);
+		const current = this.instructor(stored.value, actor);
+		invariant(stored.value.status === "draft" && await this.stores.enrollments.count({ courseId: id }) === 0, "COURSE_IN_USE", "Only drafts without enrollments can be deleted. Archive other courses.", 409);
+		invariant((await this.stores.courses.compareAndDelete(id, expectedRevision)).applied, "CONFLICT", "The course changed. Reload before deleting.", 409);
+		await this.audit(current, "course.delete", id);
+		return { deleted: true };
+	}
+	async retryNotification(actor, id) {
+		invariant(user$1(actor).role >= 50, "FORBIDDEN", "Only administrators can retry email delivery.", 403);
+		invariant((await this.stores.notifications.updateIf(id, {
+			where: {
+				emailStatus: "failed",
+				emailAttempts: { lt: 3 }
+			},
+			set: {
+				emailStatus: "pending",
+				claimedAt: null
+			}
+		})).applied, "RETRY_UNAVAILABLE", "This notification cannot be retried.", 409);
+		await this.audit(actor, "notification.retry", id);
+		return { queued: true };
+	}
+	async notificationQueue(actor, options = {}) {
+		invariant(user$1(actor).role >= 50, "FORBIDDEN", "Administrator access required.", 403);
+		return queryPage(this.stores.notifications, {
+			where: options.status ? { emailStatus: options.status } : {},
+			orderBy: { createdAt: "desc" },
+			limit: options.limit ?? 30,
+			cursor: options.cursor
+		});
+	}
+	async auditList(actor, options = {}) {
+		invariant(user$1(actor).role >= 50, "FORBIDDEN", "Administrator access required.", 403);
+		return queryPage(this.stores.audit, {
+			orderBy: { createdAt: "desc" },
+			limit: options.limit ?? 30,
+			cursor: options.cursor
+		});
+	}
+	async reminders() {
+		const settings = await this.settings();
+		if (!settings.reminderDays) return 0;
+		const cutoff = (/* @__PURE__ */ new Date(this.now().getTime() - settings.reminderDays * 864e5)).toISOString();
+		const cursor = await this.ctx.kv.get("reminders:cursor");
+		const page = await this.stores.enrollments.query({
+			where: { status: "active" },
+			limit: 30,
+			cursor: cursor ?? void 0
+		});
+		const week = Math.floor(this.now().getTime() / (7 * 864e5));
+		let queued = 0;
+		for (const item of page.items) {
+			if (item.data.lastActivityAt > cutoff || effectiveAccess(await this.accessEnrollment(item.data), this.now()) !== "granted") continue;
+			await this.notify(item.data, `reminder-${week}`, "Continue your learning", "Your next lesson is waiting in My Learning.");
+			queued++;
+		}
+		if (page.hasMore && page.cursor) await this.ctx.kv.set("reminders:cursor", page.cursor);
+		else await this.ctx.kv.delete("reminders:cursor");
+		return queued;
+	}
+};
+
+//#endregion
+//#region src/learning.ts
+const exportSchema = pageSchema.extend({ section: z.enum([
+	"enrollments",
+	"discussions",
+	"reviews",
+	"notifications",
+	"saved_courses",
+	"path_enrollments",
+	"cohort_enrollments"
+]) });
+function user(actor) {
+	invariant(actor, "UNAUTHORIZED", "Sign in to continue.", 401);
+	return actor;
+}
+function admin(actor) {
+	const current = user(actor);
+	invariant(current.role >= 50, "FORBIDDEN", "Administrator access required.", 403);
+	return current;
+}
+function pathPage(input) {
+	const options = parse(pageSchema, input);
+	return {
+		...options,
+		limit: Math.min(options.limit, 8)
+	};
+}
+/** Optional learning features share the existing access and immutable-edition service. */
+var LearningFeatures = class {
+	constructor(service) {
+		this.service = service;
+	}
+	get stores() {
+		return this.service.stores;
+	}
+	async preferences(actor) {
+		const stored = await this.stores.preferences.getVersioned(user(actor).id);
+		return {
+			value: preferencesSchema.parse(stored?.value ?? {}),
+			revision: stored?.revision ?? null
+		};
+	}
+	async savePreferences(actor, input) {
+		const current = user(actor);
+		const parsed = parse(z.object({
+			data: preferencesSchema,
+			expectedRevision: z.string().max(128).nullable()
+		}), input);
+		const saved = await this.stores.preferences.compareAndSet(current.id, parsed.expectedRevision, parsed.data);
+		invariant(saved.applied, "CONFLICT", "Preferences changed in another tab. Reload before saving.", 409);
+		return {
+			value: parsed.data,
+			revision: saved.revision
+		};
+	}
+	async saveCourse(actor, input) {
+		const current = user(actor);
+		const parsed = parse(courseIdSchema.extend({ saved: z.boolean() }), input);
+		if (parsed.saved) invariant((await this.service.course(parsed.courseId)).status === "published", "NOT_FOUND", "Course not found.", 404);
+		await change(this.stores.saved_courses, enrollmentKey(parsed.courseId, current.id), () => ({
+			value: {
+				userId: current.id,
+				courseId: parsed.courseId,
+				saved: parsed.saved,
+				updatedAt: this.service.time()
+			},
+			result: true
+		}));
+		return { saved: parsed.saved };
+	}
+	async savedCourses(actor, input) {
+		const current = user(actor);
+		const options = parse(pageSchema, input);
+		const page = await queryPage(this.stores.saved_courses, {
+			...options,
+			where: {
+				userId: current.id,
+				saved: true
+			},
+			orderBy: { updatedAt: "desc" }
+		});
+		return {
+			...page,
+			items: await Promise.all(page.items.map(async (item) => ({
+				courseId: item.courseId,
+				course: await this.card(item.courseId)
+			})))
+		};
+	}
+	async card(courseId) {
+		const course = await this.stores.courses.get(courseId);
+		return course?.status === "published" ? courseCard(course) : null;
+	}
+	async savePath(actor, input) {
+		const current = admin(actor);
+		const parsed = parse(pathSaveSchema, input);
+		const id = parsed.id ?? crypto.randomUUID();
+		const existing = await this.stores.learning_paths.getVersioned(id);
+		invariant(!parsed.id || existing, "NOT_FOUND", "Learning path not found.", 404);
+		invariant((existing?.revision ?? null) === parsed.expectedRevision, "CONFLICT", "This path changed. Reload before saving.", 409);
+		for (const courseId of parsed.data.courseIds) {
+			const course = await this.service.course(courseId);
+			invariant(parsed.data.status !== "published" || course.status === "published", "VALIDATION_ERROR", "Publish all courses before publishing the path.");
+		}
+		const path = {
+			...parsed.data,
+			id,
+			createdAt: existing?.value.createdAt ?? this.service.time(),
+			updatedAt: this.service.time()
+		};
+		assertSize(path);
+		const saved = await this.stores.learning_paths.compareAndSet(id, parsed.expectedRevision, path);
+		invariant(saved.applied, "CONFLICT", "This path changed. Reload before saving.", 409);
+		await this.service.audit(current, "path.save", id);
+		return {
+			path,
+			revision: saved.revision
+		};
+	}
+	async adminPaths(actor, input) {
+		admin(actor);
+		const page = await this.stores.learning_paths.query({
+			...parse(pageSchema, input),
+			orderBy: { updatedAt: "desc" }
+		});
+		const versions = await Promise.all(page.items.map((item) => this.stores.learning_paths.getVersioned(item.id)));
+		return {
+			...page,
+			items: versions.flatMap((item) => item ? [{
+				...item.value,
+				revision: item.revision
+			}] : [])
+		};
+	}
+	async paths(input) {
+		const page = await queryPage(this.stores.learning_paths, {
+			...pathPage(input),
+			where: { status: "published" },
+			orderBy: { updatedAt: "desc" }
+		});
+		const items = await Promise.all(page.items.map(async (path) => ({
+			id: path.id,
+			title: path.title,
+			description: path.description,
+			courses: await Promise.all(path.courseIds.map((id) => this.card(id)))
+		})));
+		return {
+			...page,
+			items
+		};
+	}
+	async joinPath(actor, input) {
+		const current = user(actor);
+		const { pathId } = parse(z.object({ pathId: idSchema }), input);
+		const id = enrollmentKey(pathId, current.id);
+		if (await this.stores.path_enrollments.get(id)) return { joined: true };
+		const path = await this.stores.learning_paths.get(pathId);
+		invariant(path?.status === "published", "NOT_FOUND", "Learning path not found.", 404);
+		await putOnce(this.stores.path_enrollments, id, {
+			pathId,
+			userId: current.id,
+			title: path.title,
+			courseIds: path.courseIds,
+			joinedAt: this.service.time()
+		});
+		return { joined: true };
+	}
+	async learnerPaths(actor, input) {
+		const current = user(actor);
+		const page = await queryPage(this.stores.path_enrollments, {
+			...pathPage(input),
+			where: { userId: current.id },
+			orderBy: { joinedAt: "desc" }
+		});
+		const items = await Promise.all(page.items.map(async (path) => {
+			const courses = await Promise.all(path.courseIds.map(async (courseId) => {
+				const enrollment = await this.stores.enrollments.get(enrollmentKey(courseId, current.id));
+				const course = await this.stores.courses.get(courseId);
+				return {
+					course: course && enrollment ? courseCard(await this.service.editions.learning(course, enrollment)) : await this.card(courseId),
+					completed: Boolean(enrollment?.completedAt)
+				};
+			}));
+			return {
+				pathId: path.pathId,
+				title: path.title,
+				joinedAt: path.joinedAt,
+				total: courses.length,
+				completed: courses.filter((c) => c.completed).length,
+				courses
+			};
+		}));
+		return {
+			...page,
+			items
+		};
+	}
+	async playback(actor, input) {
+		const current = user(actor);
+		const parsed = parse(playbackSchema, input);
+		const course = await this.service.course(parsed.courseId);
+		return change(this.stores.enrollments, enrollmentKey(course.id, current.id), async (stored) => {
+			const lesson = await this.service.lessonAccess(course, parsed.lessonId, stored);
+			invariant(["audio", "video"].includes(lesson.kind), "VALIDATION_ERROR", "Only audio and video lessons store playback positions.");
+			const next = structuredClone(stored);
+			const progress = next.progress[lesson.id] ?? emptyProgress();
+			invariant((progress.playback?.revision ?? 0) === parsed.expectedRevision, "CONFLICT", "Playback changed in another tab. Reload to resume saving.", 409);
+			const playback = {
+				positionSeconds: parsed.positionSeconds,
+				playbackRate: parsed.playbackRate,
+				revision: parsed.expectedRevision + 1,
+				updatedAt: this.service.time()
+			};
+			progress.playback = playback;
+			next.progress[lesson.id] = progress;
+			next.lastActivityAt = this.service.time();
+			return {
+				value: next,
+				result: playback
+			};
+		});
+	}
+	async exportData(actor, input) {
+		const current = user(actor);
+		const parsed = parse(exportSchema, input);
+		const { section, cursor } = parsed;
+		const options = {
+			where: section === "discussions" ? { authorId: current.id } : { userId: current.id },
+			cursor,
+			limit: Math.min(parsed.limit, 5)
+		};
+		let page;
+		if (section === "enrollments") {
+			const raw = await queryPage(this.stores.enrollments, options);
+			page = {
+				...raw,
+				items: await Promise.all(raw.items.map((enrollment) => this.service.enrollmentView(enrollment)))
+			};
+		} else {
+			const raw = await this.stores[section].query(options);
+			page = {
+				...raw,
+				items: raw.items.map((item) => item.data)
+			};
+		}
+		return {
+			format: "anantagnanam-lms-learner",
+			version: 1,
+			exportedAt: this.service.time(),
+			section,
+			profile: {
+				id: current.id,
+				name: current.name,
+				email: current.email
+			},
+			preferences: (await this.preferences(current)).value,
+			...page
+		};
+	}
+	async health(actor) {
+		admin(actor);
+		const [maintenance, pendingEmails, failedEmails, pending, settings, migration] = await Promise.all([
+			this.service.ctx.kv.get("maintenanceHealth"),
+			this.stores.notifications.count({ emailStatus: "pending" }),
+			this.stores.notifications.count({ emailStatus: "failed" }),
+			this.stores.notifications.query({
+				where: { emailStatus: "pending" },
+				orderBy: { createdAt: "asc" },
+				limit: 1
+			}),
+			this.service.settings(),
+			this.service.migrationStatus(actor)
+		]);
+		return {
+			version: PLUGIN_VERSION,
+			maintenance,
+			maintenanceStale: !maintenance?.completedAt || this.service.now().getTime() - Date.parse(maintenance.completedAt) > 45 * 6e4,
+			pendingEmails,
+			failedEmails,
+			oldestPendingAt: pending.items[0]?.data.createdAt ?? null,
+			emailEnabled: settings.emailNotifications,
+			migration
+		};
+	}
+};
+
+//#endregion
+//#region src/runtime.ts
+const listSchema = pageSchema.extend({
+	courseId: idSchema.optional(),
+	status: z.enum([
+		"pending",
+		"active",
+		"completed",
+		"rejected",
+		"suspended",
+		"cancelled"
+	]).optional()
+});
+const communityListSchema = pageSchema.extend({
+	courseId: idSchema.optional(),
+	status: z.enum([
+		"pending",
+		"published",
+		"hidden"
+	]).optional()
+});
+const slugSchema = z.object({ slug: z.string().min(1).max(100) });
+const keyInput = z.object({ id: keySchema });
+const courseRevisionInput = z.object({
+	id: idSchema,
+	expectedRevision: z.string().min(1).max(128)
+});
+function get(handler, publicRoute = false, permission = "content:read") {
+	return definePluginRoute({
+		methods: ["GET"],
+		public: publicRoute,
+		permission,
+		request: { body: "none" },
+		handler: async (ctx) => handler(ctx, new LmsService(ctx))
+	});
+}
+function post(handler, permission = "content:read") {
+	return definePluginRoute({
+		methods: ["POST"],
+		permission,
+		request: {
+			body: "json",
+			maxBytes: 1e6
+		},
+		handler: async (ctx) => handler(ctx, new LmsService(ctx))
+	});
+}
+function createPlugin(_options = {}) {
+	const options = normalizeLmsOptions(_options);
+	return definePlugin({
+		id: PLUGIN_ID,
+		version: PLUGIN_VERSION,
+		capabilities: [
+			"schema:read",
+			"content:read",
+			"users:read",
+			"email:send"
+		],
+		storage,
+		admin: {
+			entry: "@anantagnanam/lms/admin",
+			pages: adminPages,
+			widgets: [{
+				id: "learning",
+				title: "Learning",
+				size: "half"
+			}]
+		},
+		hooks: {
+			"plugin:install": async (_event, ctx) => {
+				await ctx.kv.compareAndSet("schemaVersion", null, 1);
+			},
+			"plugin:activate": async (_event, ctx) => {
+				await ctx.cron?.schedule("maintenance", { schedule: "*/15 * * * *" });
+			},
+			"plugin:deactivate": async (_event, ctx) => {
+				await ctx.cron?.cancel("maintenance");
+			},
+			cron: async (event, ctx) => {
+				if (event.name === "maintenance") {
+					const service = new LmsService(ctx);
+					const startedAt = service.time();
+					try {
+						await service.reminders();
+						await service.deliverNotifications();
+						await ctx.kv.set("maintenanceHealth", {
+							startedAt,
+							completedAt: service.time(),
+							failed: false
+						});
+					} catch (error) {
+						await ctx.kv.set("maintenanceHealth", {
+							startedAt,
+							completedAt: null,
+							failed: true
+						});
+						throw error;
+					}
+				}
+			}
+		},
+		routes: {
+			paths: get(async (ctx, service) => new LearningFeatures(service).paths(ctx.input), true),
+			"learner/paths": get(async (ctx, service) => new LearningFeatures(service).learnerPaths(ctx.user, ctx.input)),
+			"learner/path/join": post(async (ctx, service) => new LearningFeatures(service).joinPath(ctx.user, ctx.input)),
+			"learner/saved": get(async (ctx, service) => new LearningFeatures(service).savedCourses(ctx.user, ctx.input)),
+			"learner/saved/save": post(async (ctx, service) => new LearningFeatures(service).saveCourse(ctx.user, ctx.input)),
+			"learner/preferences": get(async (ctx, service) => new LearningFeatures(service).preferences(ctx.user)),
+			"learner/preferences/save": post(async (ctx, service) => new LearningFeatures(service).savePreferences(ctx.user, ctx.input)),
+			"learner/playback": post(async (ctx, service) => new LearningFeatures(service).playback(ctx.user, ctx.input)),
+			"learner/export": get(async (ctx, service) => new LearningFeatures(service).exportData(ctx.user, ctx.input)),
+			"admin/paths": get(async (ctx, service) => new LearningFeatures(service).adminPaths(ctx.user, ctx.input), false, "plugins:manage"),
+			"admin/path/save": post(async (ctx, service) => new LearningFeatures(service).savePath(ctx.user, ctx.input), "plugins:manage"),
+			"admin/health": get(async (ctx, service) => new LearningFeatures(service).health(ctx.user), false, "plugins:manage"),
+			academy: get(async (_ctx, service) => {
+				const settings = await service.settings();
+				return {
+					title: settings.academyTitle,
+					description: settings.academyDescription,
+					basePath: options.basePath
+				};
+			}, true),
+			catalog: get(async (ctx, service) => service.catalog(ctx.input), true),
+			course: get(async (ctx, service) => service.publicCourse(parse(slugSchema, ctx.input).slug), true),
+			cohort: get(async (ctx, service) => service.publicCohort(parse(z.object({ id: idSchema }), ctx.input).id), true),
+			preview: get(async (ctx, service) => {
+				const input = parse(lessonIdSchema, ctx.input);
+				return service.preview(input.courseId, input.lessonId);
+			}, true),
+			reviews: get(async (ctx, service) => {
+				const input = parse(courseIdSchema.extend({ cursor: z.string().optional() }), ctx.input);
+				return service.publicReviews(input.courseId, input.cursor);
+			}, true),
+			"certificates/verify": get(async (ctx, service) => service.verifyCertificate(parse(z.object({ id: idSchema }), ctx.input).id), true),
+			"learner/dashboard": get(async (ctx, service) => service.dashboard(ctx.user, parse(pageSchema, ctx.input))),
+			"learner/course": get(async (ctx, service) => service.learnerCourse(ctx.user, parse(courseIdSchema, ctx.input).courseId)),
+			"learner/course-by-slug": get(async (ctx, service) => service.learnerCourseBySlug(ctx.user, parse(slugSchema, ctx.input).slug)),
+			"learner/lesson": get(async (ctx, service) => {
+				const input = parse(lessonIdSchema, ctx.input);
+				return service.learnerLesson(ctx.user, input.courseId, input.lessonId);
+			}),
+			"learner/enroll": post(async (ctx, service) => {
+				const input = parse(enrollmentRequestSchema, ctx.input);
+				return service.enroll(ctx.user, input.courseId, { cohortId: input.cohortId });
+			}),
+			"learner/cohort/request": post(async (ctx, service) => service.requestCohort(ctx.user, parse(z.object({ cohortId: idSchema }), ctx.input).cohortId)),
+			"learner/cancel": post(async (ctx, service) => service.cancelEnrollment(ctx.user, parse(courseIdSchema, ctx.input).courseId)),
+			"learner/start": post(async (ctx, service) => {
+				const input = parse(lessonIdSchema, ctx.input);
+				return service.startLesson(ctx.user, input.courseId, input.lessonId);
+			}),
+			"learner/complete": post(async (ctx, service) => {
+				const input = parse(lessonIdSchema, ctx.input);
+				return service.completeLesson(ctx.user, input.courseId, input.lessonId);
+			}),
+			"learner/quiz/start": post(async (ctx, service) => {
+				const input = parse(lessonIdSchema, ctx.input);
+				return service.startQuiz(ctx.user, input.courseId, input.lessonId);
+			}),
+			"learner/quiz/submit": post(async (ctx, service) => service.submitQuiz(ctx.user, ctx.input)),
+			"learner/quiz/draft": post(async (ctx, service) => service.saveQuizDraft(ctx.user, ctx.input)),
+			"learner/assignment": post(async (ctx, service) => service.submitAssignment(ctx.user, ctx.input)),
+			"learner/note": post(async (ctx, service) => service.saveNote(ctx.user, ctx.input)),
+			"learner/discussions": get(async (ctx, service) => {
+				const input = parse(lessonIdSchema.extend({ cursor: z.string().optional() }), ctx.input);
+				return service.discussions(ctx.user, input.courseId, input.lessonId, input.cursor);
+			}),
+			"learner/discussion": post(async (ctx, service) => service.postDiscussion(ctx.user, ctx.input)),
+			"learner/review": post(async (ctx, service) => service.postReview(ctx.user, ctx.input)),
+			"learner/certificate": get(async (ctx, service) => service.certificate(ctx.user, parse(courseIdSchema, ctx.input).courseId)),
+			"learner/certificate-by-id": get(async (ctx, service) => service.ownedCertificate(ctx.user, parse(z.object({ id: idSchema }), ctx.input).id)),
+			"learner/cohort": get(async (ctx, service) => {
+				const input = parse(z.object({ cohortId: idSchema }), ctx.input);
+				invariant(ctx.user, "UNAUTHORIZED", "Sign in to continue.", 401);
+				return service.stores.cohort_enrollments.get(`${input.cohortId}:${ctx.user.id}`);
+			}),
+			"learner/certificate/share": post(async (ctx, service) => {
+				const input = parse(certificateActionSchema, ctx.input);
+				return service.shareCertificate(ctx.user, input.courseId, input.shared);
+			}),
+			"learner/notifications": get(async (ctx, service) => service.notifications(ctx.user, parse(pageSchema, ctx.input).cursor)),
+			"learner/notification/read": post(async (ctx, service) => service.readNotification(ctx.user, parse(keyInput, ctx.input).id)),
+			"admin/courses": get(async (ctx, service) => service.adminCourses(ctx.user, parse(pageSchema.extend({ status: z.enum([
+				"draft",
+				"published",
+				"archived"
+			]).optional() }), ctx.input))),
+			"admin/course": get(async (ctx, service) => service.editableCourse(ctx.user, parse(z.object({ id: idSchema }), ctx.input).id)),
+			"admin/course/save": post(async (ctx, service) => service.saveCourse(ctx.user, ctx.input)),
+			"admin/course/publish": post(async (ctx, service) => {
+				const input = parse(courseRevisionInput, ctx.input);
+				return service.publishCourse(ctx.user, input.id, input.expectedRevision);
+			}),
+			"admin/course/archive": post(async (ctx, service) => {
+				const input = parse(courseRevisionInput, ctx.input);
+				return service.archiveCourse(ctx.user, input.id, input.expectedRevision);
+			}),
+			"admin/course/history": get(async (ctx, service) => {
+				const input = parse(z.object({
+					id: idSchema,
+					cursor: idSchema.optional()
+				}), ctx.input);
+				return service.courseHistory(ctx.user, input.id, input.cursor);
+			}),
+			"admin/course/restore": post(async (ctx, service) => {
+				const input = parse(courseRevisionInput.extend({ revisionId: idSchema }), ctx.input);
+				return service.restoreCourse(ctx.user, input.id, input.expectedRevision, input.revisionId);
+			}),
+			"admin/migrations": get(async (ctx, service) => service.migrationStatus(ctx.user), false, "plugins:manage"),
+			"admin/migrations/run": post(async (ctx, service) => {
+				const input = parse(z.object({ limit: z.number().int().min(1).max(20).default(20) }), ctx.input);
+				return service.migrateBatch(ctx.user, input.limit);
+			}, "plugins:manage"),
+			"admin/lesson/preview": get(async (ctx, service) => {
+				const input = parse(lessonIdSchema, ctx.input);
+				return service.authorLessonPreview(ctx.user, input.courseId, input.lessonId);
+			}),
+			"admin/course/delete": post(async (ctx, service) => {
+				const input = parse(z.object({
+					id: idSchema,
+					expectedRevision: z.string().min(1).max(128)
+				}), ctx.input);
+				return service.deleteCourse(ctx.user, input.id, input.expectedRevision);
+			}),
+			"admin/course/export": get(async (ctx, service) => service.exportCourse(ctx.user, parse(z.object({ id: idSchema }), ctx.input).id)),
+			"admin/course/import": post(async (ctx, service) => service.importCourse(ctx.user, ctx.input)),
+			"admin/enrollments": get(async (ctx, service) => service.enrollments(ctx.user, parse(listSchema, ctx.input))),
+			"admin/enrollment/save": post(async (ctx, service) => service.adminEnrollment(ctx.user, ctx.input), "plugins:manage"),
+			"admin/assignments": get(async (ctx, service) => {
+				const input = parse(courseIdSchema.extend({ cursor: z.string().optional() }), ctx.input);
+				return service.assignments(ctx.user, input.courseId, input.cursor);
+			}),
+			"admin/assignment/grade": post(async (ctx, service) => service.gradeAssignment(ctx.user, ctx.input)),
+			"admin/discussions": get(async (ctx, service) => service.communityQueue(ctx.user, "discussions", parse(communityListSchema, ctx.input))),
+			"admin/reviews": get(async (ctx, service) => service.communityQueue(ctx.user, "reviews", parse(communityListSchema, ctx.input))),
+			"admin/discussion/moderate": post(async (ctx, service) => service.moderate(ctx.user, "discussions", ctx.input)),
+			"admin/review/moderate": post(async (ctx, service) => service.moderate(ctx.user, "reviews", ctx.input)),
+			"admin/certificate/revoke": post(async (ctx, service) => {
+				const input = parse(certificateRevokeSchema, ctx.input);
+				return service.revokeCertificate(ctx.user, input.courseId, input.userId, input.reason);
+			}),
+			"admin/report": get(async (ctx, service) => service.report(ctx.user, parse(z.object({ courseId: idSchema.optional() }), ctx.input).courseId)),
+			"admin/cohorts": get(async (ctx, service) => service.cohortList(ctx.user, parse(pageSchema, ctx.input).cursor), false, "plugins:manage"),
+			"admin/cohort/save": post(async (ctx, service) => service.saveCohort(ctx.user, ctx.input), "plugins:manage"),
+			"admin/cohort/enroll": post(async (ctx, service) => {
+				const input = parse(z.object({
+					id: idSchema,
+					expectedRevision: z.string().min(1).max(128),
+					offset: z.number().int().min(0).max(1e3).default(0)
+				}), ctx.input);
+				return service.applyCohort(ctx.user, input.id, input.expectedRevision, input.offset);
+			}, "plugins:manage"),
+			"admin/cohort/memberships": get(async (ctx, service) => service.cohortMemberships(ctx.user, parse(pageSchema.extend({
+				cohortId: idSchema.optional(),
+				status: z.enum([
+					"pending",
+					"active",
+					"rejected",
+					"suspended",
+					"cancelled"
+				]).optional()
+			}), ctx.input)), false, "plugins:manage"),
+			"admin/cohort/decision": post(async (ctx, service) => {
+				const input = parse(z.object({
+					cohortId: idSchema,
+					userId: idSchema,
+					status: z.enum([
+						"active",
+						"rejected",
+						"suspended",
+						"cancelled"
+					]),
+					reason: z.string().max(1e3).default("")
+				}), ctx.input);
+				return service.decideCohort(ctx.user, input.cohortId, input.userId, input.status, input.reason);
+			}, "plugins:manage"),
+			"admin/settings": get(async (_ctx, service) => service.settings(), false, "plugins:manage"),
+			"admin/settings/save": post(async (ctx, service) => service.saveSettings(ctx.user, ctx.input), "plugins:manage"),
+			"admin/notification/retry": post(async (ctx, service) => service.retryNotification(ctx.user, parse(keyInput, ctx.input).id), "plugins:manage"),
+			"admin/notifications": get(async (ctx, service) => service.notificationQueue(ctx.user, parse(pageSchema.extend({ status: z.enum([
+				"pending",
+				"sending",
+				"sent",
+				"disabled",
+				"failed"
+			]).optional() }), ctx.input)), false, "plugins:manage"),
+			"admin/audit": get(async (ctx, service) => service.auditList(ctx.user, parse(pageSchema, ctx.input)), false, "plugins:manage"),
+			"admin/users": get(async (ctx) => {
+				invariant(ctx.users, "USERS_UNAVAILABLE", "The user directory is unavailable.", 503);
+				const input = parse(pageSchema, ctx.input);
+				const page = await ctx.users.list({
+					limit: input.limit,
+					cursor: input.cursor
+				});
+				return {
+					...page,
+					items: page.items.map((entry) => ({
+						id: entry.id,
+						name: entry.name,
+						email: entry.email,
+						role: entry.role
+					}))
+				};
+			}, false, "users:read"),
+			"admin/instructors": get(async (ctx) => {
+				invariant(ctx.user && ctx.user.role >= 20, "FORBIDDEN", "Course authoring access required.", 403);
+				invariant(ctx.users, "USERS_UNAVAILABLE", "The user directory is unavailable.", 503);
+				const input = parse(pageSchema, ctx.input);
+				const page = await ctx.users.list({
+					limit: input.limit,
+					cursor: input.cursor
+				});
+				return {
+					...page,
+					items: page.items.filter((entry) => entry.role >= 20).map((entry) => ({
+						id: entry.id,
+						name: entry.name,
+						email: entry.email
+					}))
+				};
+			}),
+			"admin/content/collections": get(async (ctx) => {
+				invariant(ctx.user && ctx.user.role >= 20, "FORBIDDEN", "Course authoring access required.", 403);
+				invariant(ctx.schema, "SCHEMA_UNAVAILABLE", "The content schema is unavailable.", 503);
+				return (await ctx.schema.listCollections()).map((collection) => ({
+					slug: collection.slug,
+					label: collection.label,
+					fields: collection.fields.filter((field) => [
+						"portableText",
+						"text",
+						"string"
+					].includes(field.type)).map((field) => ({
+						slug: field.slug,
+						label: field.label,
+						type: field.type
+					}))
+				})).filter((collection) => collection.fields.length);
+			}),
+			"admin/content/entries": get(async (ctx) => {
+				invariant(ctx.user && ctx.user.role >= 20, "FORBIDDEN", "Course authoring access required.", 403);
+				invariant(ctx.schema && ctx.content, "CONTENT_UNAVAILABLE", "Content integration is unavailable.", 503);
+				const input = parse(pageSchema.extend({ collection: idSchema }), ctx.input);
+				const collection = await ctx.schema.getCollection(input.collection);
+				invariant(collection, "NOT_FOUND", "Content collection not found.", 404);
+				const page = await ctx.content.list(input.collection, {
+					limit: input.limit,
+					cursor: input.cursor,
+					where: { status: "published" }
+				});
+				return {
+					...page,
+					items: page.items.map((entry) => ({
+						id: entry.id,
+						title: String(entry.data[collection.titleField ?? "title"] ?? entry.slug ?? "Published entry")
+					}))
+				};
+			}),
+			"admin/learner/find": post(async (ctx, service) => {
+				const input = parse(courseIdSchema.extend({ email: z.email().max(254) }), ctx.input);
+				service.instructor(await service.course(input.courseId), ctx.user);
+				invariant(ctx.users, "USERS_UNAVAILABLE", "The user directory is unavailable.", 503);
+				const target = await ctx.users.getByEmail(input.email);
+				invariant(target, "NOT_FOUND", "No account uses this email address. Invite the learner through EmDash first.", 404);
+				return {
+					id: target.id,
+					name: target.name,
+					email: target.email
+				};
+			}, "plugins:manage"),
+			"admin/report/csv": definePluginRoute({
+				methods: ["GET"],
+				permission: "content:read",
+				request: { body: "none" },
+				response: "raw",
+				handler: async (ctx) => {
+					const input = parse(listSchema, ctx.input);
+					return pluginResponse({
+						body: {
+							kind: "text",
+							value: await new LmsService(ctx).enrollmentCsv(ctx.user, input)
+						},
+						headers: {
+							"Content-Type": "text/csv; charset=utf-8",
+							"Content-Disposition": "attachment; filename=\"lms-enrollments.csv\""
+						}
+					});
+				}
+			}),
+			"mcp/courses": post(async (ctx, service) => service.adminCourses(ctx.user, parse(pageSchema, ctx.input)))
+		},
+		mcp: { tools: {
+			list_courses: {
+				route: "mcp/courses",
+				description: "List courses available to this instructor or administrator.",
+				input: pageSchema
+			},
+			save_course: {
+				route: "admin/course/save",
+				description: "Create a course or save a working draft using its current storage revision. Existing courses require publish_course to publish edits; initial creation with published status publishes immediately.",
+				input: courseSaveSchema,
+				destructive: true
+			},
+			publish_course: {
+				route: "admin/course/publish",
+				description: "Publish the saved draft as a new course edition using its current storage revision. Existing learners retain their enrolled edition.",
+				input: courseRevisionInput,
+				destructive: true
+			},
+			enroll_learner: {
+				route: "admin/enrollment/save",
+				description: "Approve, reject, suspend, or manually enroll a learner. Requires an administrator account.",
+				input: enrollmentAdminSchema,
+				destructive: true
+			},
+			grade_assignment: {
+				route: "admin/assignment/grade",
+				description: "Grade a pending assignment submission in a course you teach.",
+				input: gradeSchema,
+				destructive: true
+			}
+		} }
+	});
+}
+
+//#endregion
+export { LmsService, createPlugin };
+//# sourceMappingURL=runtime.js.map