@anantagnanam/lms 0.1.0 → 0.3.0

package/dist/runtime.js

@@ -1,7 +1,7 @@
-import { a as adminPages, i as PLUGIN_VERSION, n as MAX_DOCUMENT_BYTES, o as storage, r as PLUGIN_ID } from "./constants-C0kT94tc.js";
+import { a as adminPages, i as PLUGIN_VERSION, n as MAX_DOCUMENT_BYTES, o as storage, r as PLUGIN_ID } from "./constants-DyQbwNbP.js";
 import { t as normalizeLmsOptions } from "./config-BX3beTpM.js";
-import { assignmentSubmitSchema, catalogSchema, certificateActionSchema, certificateRevokeSchema, cohortSaveSchema, courseIdSchema, courseSaveSchema, discussionSchema, enrollmentAdminSchema, enrollmentRequestSchema, gradeSchema, idSchema, keySchema, lessonIdSchema, moderateSchema, noteSchema, pageSchema, quizSubmitSchema, reviewSchema, settingsSchema } from "./schemas.js";
-import { n as invariant, t as LmsError } from "./errors-ChzJS9al.js";
+import { assignmentDraftSchema, 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, studyNoteSchema } from "./schemas.js";
+import { a as invariant, i as LmsError, n as assignmentGrade, r as emptyAssignmentDraft, t as assignmentBlock } from "./assignments-CsuAjxGO.js";
 import { n as enrollmentCsvLines, t as enrollmentCsvHeader } from "./csv-DKq_4OWU.js";
 import { definePlugin, definePluginRoute, pluginResponse } from "emdash";
 import { z } from "zod";
@@ -37,6 +37,212 @@ async function putOnce(store, id, 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) {
@@ -103,6 +309,8 @@ 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,
@@ -116,7 +324,10 @@ function publicLesson(lesson) {
 }
 function publicAttempt(attempt) {
 	const { quiz: _quiz, ...safe } = attempt;
-	return safe;
+	return {
+		...safe,
+		draftRevision: attempt.draftRevision ?? 0
+	};
 }
 function effectiveAccess(enrollment, now = /* @__PURE__ */ new Date()) {
 	if (enrollment.status === "suspended" || enrollment.accessStatus === "suspended") return "suspended";
@@ -142,16 +353,68 @@ function publicEnrollment(enrollment, now = /* @__PURE__ */ new Date()) {
 		}]))
 	};
 }
-function progressSummary(course, enrollment) {
+/** 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);
+	delete view.studyNotes;
+	for (const progress of Object.values(view.progress)) {
+		progress.note = "";
+		delete progress.noteRevision;
+		delete progress.playback;
+		delete progress.assignmentDraft;
+	}
+	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: lessons(course).find((lesson) => !enrollment?.progress[lesson.id]?.completedAt)?.id ?? null
+		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);
@@ -173,8 +436,7 @@ function assertLessonAccess(course, lessonId, enrollment, now, allowPreview = fa
 	].includes(lesson.kind)) return lesson;
 	assertEnrollmentAccess(enrollment, now);
 	invariant(course.status !== "draft", "NOT_FOUND", "Course not found.", 404);
-	const module = course.modules.find((item) => item.lessons.some((entry) => entry.id === lessonId));
-	const releaseAt = Math.max(module.unlockAt ? Date.parse(module.unlockAt) : 0, Date.parse(enrollment.approvedAt ?? enrollment.enrolledAt) + module.releaseDays * 864e5);
+	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);
@@ -233,16 +495,18 @@ function parse(schema, 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(actor) {
+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();
@@ -251,7 +515,7 @@ var LmsService = class {
 		return settingsSchema.parse(await this.ctx.settings.get("configuration") ?? {});
 	}
 	async saveSettings(actor, input) {
-		invariant(user(actor).role >= 50, "FORBIDDEN", "Only administrators can change LMS settings.", 403);
+		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);
@@ -295,51 +559,182 @@ var LmsService = class {
 	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(course, lessonId, await this.accessEnrollment(enrollment), this.now());
+		return assertLessonAccess(await this.editions.learning(course, enrollment), lessonId, await this.accessEnrollment(enrollment), this.now());
 	}
 	instructor(course, actor) {
-		const current = user(actor);
-		invariant(current.role >= 50 || course.createdBy === current.id || course.instructorIds.includes(current.id), "FORBIDDEN", "You are not an instructor for this course.", 403);
+		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(actor);
+		const currentActor = user$1(actor);
 		const parsed = parse(courseSaveSchema, input);
 		const id = parsed.id ?? crypto.randomUUID();
-		const current = await this.stores.courses.getVersioned(id);
+		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 (parsed.data.status === "published") invariant(currentActor.role >= 50 || currentActor.role >= 30, "FORBIDDEN", "Publishing requires an author account or higher.", 403);
-		invariant(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);
+		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 && await this.stores.enrollments.count({ courseId: id })) {
-			const nextIds = new Set(parsed.data.modules.flatMap((module) => module.lessons.map((lesson) => lesson.id)));
-			invariant(lessons(current.value).every((lesson) => nextIds.has(lesson.id)), "CURRICULUM_IN_USE", "Enrolled courses must keep existing lesson IDs. Archive the course or create a new edition to remove lessons.", 409);
-		}
-		const course = {
+		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: 1
+			schemaVersion: 2
 		};
-		assertSize(course);
-		const saved = await this.stores.courses.compareAndSet(id, current?.revision ?? null, course);
-		invariant(saved.applied, "CONFLICT", "The course changed while saving. Reload before saving.", 409);
-		await this.audit(currentActor, "course.save", id, { status: course.status });
+		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,
+			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) => {
@@ -357,12 +752,12 @@ var LmsService = class {
 		invariant(current, "NOT_FOUND", "Course not found.", 404);
 		this.instructor(current.value, actor);
 		return {
-			course: current.value,
+			course: await this.editions.draft(current.value),
 			revision: current.revision
 		};
 	}
 	async adminCourses(actor, options = {}) {
-		const current = user(actor);
+		const current = user$1(actor);
 		const page = await queryPage(this.stores.courses, {
 			where: options.status ? { status: options.status } : {},
 			orderBy: { updatedAt: "desc" },
@@ -371,7 +766,7 @@ var LmsService = class {
 		});
 		return {
 			...page,
-			items: page.items.filter((course) => current.role >= 50 || course.createdBy === current.id || course.instructorIds.includes(current.id))
+			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) {
@@ -449,6 +844,13 @@ var LmsService = class {
 			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);
 	}
@@ -458,6 +860,7 @@ var LmsService = class {
 		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,
@@ -501,10 +904,12 @@ var LmsService = class {
 		};
 	}
 	async enroll(actor, courseId, options = {}) {
-		const current = user(actor);
-		const course = await this.course(courseId);
+		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);
@@ -554,10 +959,11 @@ var LmsService = class {
 	}
 	async adminEnrollment(actor, input) {
 		const parsed = parse(enrollmentAdminSchema, input);
-		const course = await this.course(parsed.courseId);
+		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.");
@@ -576,6 +982,7 @@ var LmsService = class {
 		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;
@@ -604,7 +1011,7 @@ var LmsService = class {
 			}
 			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(course, next, settings);
+			if (parsed.status === "active") this.finish(await this.editions.learning(course, next), next, settings);
 			return {
 				value: next,
 				result: next
@@ -613,22 +1020,21 @@ var LmsService = class {
 		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 this.enrollmentView(enrollment);
+		return staffEnrollment(await this.accessEnrollment(enrollment), this.now());
 	}
 	async learnerCourse(actor, courseId) {
-		const current = user(actor);
+		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(course),
-			enrollment: enrollment ? await this.enrollmentView(enrollment) : null,
-			progress: progressSummary(course, enrollment)
+			course: await this.detail(await this.editions.learning(course, enrollment)),
+			...await this.learningState(course, enrollment)
 		};
 	}
 	async learnerCourseBySlug(actor, slug) {
-		user(actor);
+		user$1(actor);
 		const page = await this.stores.courses.query({
 			where: { slug },
 			limit: 1
@@ -637,7 +1043,7 @@ var LmsService = class {
 		return this.learnerCourse(actor, page.items[0].id);
 	}
 	async dashboard(actor, options = {}) {
-		const current = user(actor);
+		const current = user$1(actor);
 		const page = await queryPage(this.stores.enrollments, {
 			where: { userId: current.id },
 			orderBy: { enrolledAt: "desc" },
@@ -649,9 +1055,8 @@ var LmsService = class {
 			if (enrollment.completedAt) await this.projectCompletion(enrollment);
 			const course = courses.get(enrollment.courseId);
 			return course ? {
-				course: courseCard(course),
-				enrollment: await this.enrollmentView(enrollment),
-				progress: progressSummary(course, enrollment)
+				course: courseCard(await this.editions.learning(course, enrollment)),
+				...await this.learningState(course, enrollment)
 			} : null;
 		}))).filter((row) => row !== null);
 		return {
@@ -660,19 +1065,18 @@ var LmsService = class {
 		};
 	}
 	async learnerLesson(actor, courseId, lessonId) {
-		const current = user(actor);
+		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(course),
+			course: courseDetail(await this.editions.learning(course, enrollment)),
 			lesson: publicLesson(await this.resolveContent(lesson)),
-			enrollment: await this.enrollmentView(enrollment),
-			progress: progressSummary(course, enrollment)
+			...await this.learningState(course, enrollment)
 		};
 	}
 	async startLesson(actor, courseId, lessonId) {
-		const current = user(actor);
+		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);
@@ -689,7 +1093,7 @@ var LmsService = class {
 		return await this.enrollmentView(enrollment);
 	}
 	async completeLesson(actor, courseId, lessonId) {
-		const current = user(actor);
+		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) => {
@@ -702,17 +1106,14 @@ var LmsService = class {
 			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(course, next, settings);
+			this.finish(await this.editions.learning(course, next), next, settings);
 			return {
 				value: next,
 				result: next
 			};
 		});
 		await this.projectCompletion(enrollment);
-		return {
-			enrollment: await this.enrollmentView(enrollment),
-			progress: progressSummary(course, enrollment)
-		};
+		return { ...await this.learningState(course, enrollment) };
 	}
 	finish(course, enrollment, settings) {
 		enrollment.lastActivityAt = this.time();
@@ -743,7 +1144,7 @@ var LmsService = class {
 		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(actor);
+		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);
@@ -790,7 +1191,8 @@ var LmsService = class {
 				percent: null,
 				passed: false,
 				feedback: [],
-				answers: {}
+				answers: {},
+				draftRevision: 0
 			};
 			progress.quizAttempts.push(attempt);
 			next.lastActivityAt = this.time();
@@ -806,7 +1208,7 @@ var LmsService = class {
 		return publicAttempt(result.attempt);
 	}
 	async submitQuiz(actor, input) {
-		const current = user(actor);
+		const current = user$1(actor);
 		const parsed = parse(quizSubmitSchema, input);
 		const course = await this.course(parsed.courseId);
 		const settings = await this.settings();
@@ -838,6 +1240,7 @@ var LmsService = class {
 				};
 			}
 			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 : [];
@@ -849,7 +1252,7 @@ var LmsService = class {
 			attempt.submittedAt = this.time();
 			attempt.quiz = null;
 			if (attempt.passed) progress.completedAt ??= this.time();
-			this.finish(course, next, settings);
+			this.finish(await this.editions.learning(course, next), next, settings);
 			return {
 				value: next,
 				result: {
@@ -863,46 +1266,110 @@ var LmsService = class {
 		await this.projectCompletion(result.enrollment);
 		return {
 			attempt: publicAttempt(result.attempt),
-			enrollment: await this.enrollmentView(result.enrollment),
-			progress: progressSummary(course, result.enrollment)
+			...await this.learningState(course, result.enrollment)
 		};
 	}
 	async saveQuizDraft(actor, input) {
-		const current = user(actor);
-		const parsed = parse(quizSubmitSchema, input);
+		const current = user$1(actor);
+		const parsed = parse(quizDraftSchema, input);
 		const course = await this.course(parsed.courseId);
-		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);
-			attempt.answers = parsed.answers;
-			return {
-				value: next,
-				result: true
-			};
-		});
-		return { saved: true };
+		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 assignmentState(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);
+		invariant(lesson.kind === "assignment" && lesson.assignment, "NOT_AN_ASSIGNMENT", "This lesson has no assignment.");
+		const progress = enrollment.progress[lessonId] ?? emptyProgress();
+		const blocked = assignmentBlock(lesson.assignment, progress, this.now());
+		return {
+			draft: progress.assignmentDraft ?? emptyAssignmentDraft(),
+			submission: progress.assignments.at(-1) ?? null,
+			canSubmit: !blocked,
+			closedReason: blocked?.message ?? null
+		};
+	}
+	async saveAssignmentDraft(actor, input) {
+		const current = user$1(actor);
+		const parsed = parse(assignmentDraftSchema, input);
+		const course = await this.course(parsed.courseId);
+		return {
+			saved: true,
+			draftRevision: 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.");
+				const next = structuredClone(stored);
+				const progress = next.progress[parsed.lessonId] ?? emptyProgress();
+				const draft = progress.assignmentDraft ?? emptyAssignmentDraft();
+				const blocked = assignmentBlock(lesson.assignment, progress, this.now());
+				if (blocked) throw new LmsError(blocked.code, blocked.message, blocked.status);
+				if (draft.revision === parsed.expectedDraftRevision + 1 && draft.body === parsed.body && draft.attachmentUrl === parsed.attachmentUrl) return {
+					value: next,
+					result: draft.revision
+				};
+				invariant(draft.revision === parsed.expectedDraftRevision, "DRAFT_CONFLICT", "Your assignment draft changed in another request. Review it before saving.", 409);
+				progress.assignmentDraft = {
+					body: parsed.body,
+					attachmentUrl: parsed.attachmentUrl,
+					revision: draft.revision + 1,
+					updatedAt: this.time()
+				};
+				next.progress[parsed.lessonId] = progress;
+				return {
+					value: next,
+					result: progress.assignmentDraft.revision
+				};
+			})
+		};
 	}
 	async submitAssignment(actor, input) {
-		const current = user(actor);
+		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);
+			const previous = parsed.submissionId && progress.assignments.find((item) => item.id === parsed.submissionId);
+			if (previous) {
+				invariant(previous.body === parsed.body && previous.attachmentUrl === parsed.attachmentUrl, "SUBMISSION_CONFLICT", "This submission ID already belongs to different work.", 409);
+				return {
+					value: next,
+					result: next
+				};
+			}
+			const blocked = assignmentBlock(lesson.assignment, progress, this.now());
+			if (blocked) throw new LmsError(blocked.code, blocked.message, blocked.status);
+			const draft = progress.assignmentDraft ?? emptyAssignmentDraft();
+			invariant(parsed.expectedDraftRevision === void 0 ? !draft.body && !draft.attachmentUrl : draft.revision === parsed.expectedDraftRevision, "DRAFT_CONFLICT", "Your assignment draft changed. Review it before submitting.", 409);
 			progress.startedAt ??= this.time();
 			progress.assignments.push({
-				id: crypto.randomUUID(),
+				id: parsed.submissionId ?? crypto.randomUUID(),
 				body: parsed.body,
 				attachmentUrl: parsed.attachmentUrl,
 				submittedAt: this.time(),
@@ -912,8 +1379,16 @@ var LmsService = class {
 				points: null,
 				feedback: "",
 				gradedAt: null,
-				gradedBy: null
+				gradedBy: null,
+				rubric: structuredClone(lesson.assignment.rubric ?? []),
+				rubricScores: []
 			});
+			progress.assignmentDraft = {
+				body: "",
+				attachmentUrl: null,
+				revision: draft.revision + 1,
+				updatedAt: this.time()
+			};
 			next.progress[parsed.lessonId] = progress;
 			next.lastActivityAt = this.time();
 			return {
@@ -935,19 +1410,20 @@ var LmsService = class {
 			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;
+			const grade = assignmentGrade(submission, parsed.points, parsed.rubricScores);
+			submission.points = grade.points;
+			submission.rubricScores = grade.rubricScores;
 			submission.feedback = parsed.feedback;
 			submission.status = "graded";
 			submission.gradedAt = this.time();
 			submission.gradedBy = current.id;
-			if (parsed.points >= submission.passingPoints) progress.completedAt ??= this.time();
+			if (grade.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(course, next, settings);
+			].includes(access)) this.finish(await this.editions.learning(course, next), next, settings);
 			return {
 				value: next,
 				result: next
@@ -957,35 +1433,47 @@ var LmsService = class {
 		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
+			submissionId: parsed.submissionId,
+			points: enrollment.progress[parsed.lessonId].assignments.find((item) => item.id === parsed.submissionId).points
 		});
-		return await this.enrollmentView(enrollment);
+		return staffEnrollment(await this.accessEnrollment(enrollment), this.now());
 	}
 	async saveNote(actor, input) {
-		const current = user(actor);
+		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) => {
+		const enrollment = 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();
+			const revision = progress.noteRevision ?? 0;
+			if (revision === parsed.expectedRevision + 1 && progress.note === parsed.note) return {
+				value: next,
+				result: next
+			};
+			invariant(revision === parsed.expectedRevision, "NOTE_CONFLICT", "Your lesson notes changed in another tab. Copy your work before reloading to compare it with the saved notes.", 409);
 			progress.note = parsed.note;
+			progress.noteRevision = revision + 1;
 			next.progress[parsed.lessonId] = progress;
 			return {
 				value: next,
 				result: next
 			};
-		})).progress[parsed.lessonId].note };
+		});
+		return {
+			note: enrollment.progress[parsed.lessonId].note,
+			revision: enrollment.progress[parsed.lessonId].noteRevision ?? 0
+		};
 	}
 	async certificate(actor, courseId) {
-		const current = user(actor);
+		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(actor);
+		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);
@@ -1008,7 +1496,7 @@ var LmsService = class {
 		};
 	}
 	async shareCertificate(actor, courseId, shared) {
-		const current = user(actor);
+		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);
@@ -1036,7 +1524,7 @@ var LmsService = class {
 		return certificate;
 	}
 	async cancelEnrollment(actor, courseId) {
-		const current = user(actor);
+		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 = {
@@ -1052,7 +1540,7 @@ var LmsService = class {
 		return await this.enrollmentView(enrollment);
 	}
 	async discussions(actor, courseId, lessonId, cursor) {
-		const current = user(actor);
+		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);
@@ -1081,7 +1569,7 @@ var LmsService = class {
 		};
 	}
 	async postDiscussion(actor, input) {
-		const current = user(actor);
+		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));
@@ -1117,7 +1605,7 @@ var LmsService = class {
 		});
 	}
 	async postReview(actor, input) {
-		const current = user(actor);
+		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)));
@@ -1159,7 +1647,7 @@ var LmsService = class {
 		return next;
 	}
 	async communityQueue(actor, collection, options = {}) {
-		const current = user(actor);
+		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];
@@ -1182,7 +1670,7 @@ var LmsService = class {
 		};
 	}
 	async enrollments(actor, options = {}) {
-		const current = user(actor);
+		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, {
@@ -1197,17 +1685,23 @@ var LmsService = class {
 		const courses = await this.stores.courses.getMany(page.items.map((item) => item.courseId));
 		return {
 			...page,
-			items: await Promise.all(page.items.map(async (enrollment) => ({
-				...await this.enrollmentView(enrollment),
-				learnerEmail: enrollment.learnerEmail,
-				courseTitle: courses.get(enrollment.courseId)?.title ?? "Archived course",
-				lessonTitles: Object.fromEntries((courses.has(enrollment.courseId) ? lessons(courses.get(enrollment.courseId)) : []).map((lesson) => [lesson.id, lesson.title])),
-				progressSummary: courses.has(enrollment.courseId) ? progressSummary(courses.get(enrollment.courseId), enrollment) : null
-			})))
+			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(actor);
+		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 } : {};
@@ -1279,7 +1773,7 @@ var LmsService = class {
 		return "" + lines.join("\r\n");
 	}
 	async cohortList(actor, cursor) {
-		invariant(user(actor).role >= 50, "FORBIDDEN", "Only administrators can manage cohorts.", 403);
+		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,
@@ -1307,7 +1801,7 @@ var LmsService = class {
 		};
 	}
 	async requestCohort(actor, cohortId) {
-		const current = user(actor);
+		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);
@@ -1337,7 +1831,7 @@ var LmsService = class {
 		});
 	}
 	async cohortMemberships(actor, options = {}) {
-		invariant(user(actor).role >= 50, "FORBIDDEN", "Only administrators can review cohort membership.", 403);
+		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 } : {},
@@ -1349,7 +1843,7 @@ var LmsService = class {
 		});
 	}
 	async decideCohort(actor, cohortId, userId, status, reason = "") {
-		const current = user(actor);
+		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);
@@ -1421,7 +1915,7 @@ var LmsService = class {
 		};
 	}
 	async saveCohort(actor, input) {
-		const current = user(actor);
+		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);
@@ -1445,7 +1939,7 @@ var LmsService = class {
 		};
 	}
 	async applyCohort(actor, id, expectedRevision, offset) {
-		const current = user(actor);
+		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);
@@ -1476,6 +1970,7 @@ var LmsService = class {
 	}
 	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,
@@ -1486,14 +1981,14 @@ var LmsService = class {
 			courseId: enrollment.courseId,
 			read: false,
 			createdAt: this.time(),
-			emailStatus: settings.emailNotifications ? "pending" : "disabled",
+			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(actor);
+		const current = user$1(actor);
 		const page = await queryPage(this.stores.notifications, {
 			where: { userId: current.id },
 			orderBy: { createdAt: "desc" },
@@ -1506,7 +2001,7 @@ var LmsService = class {
 		};
 	}
 	async readNotification(actor, id) {
-		const current = user(actor);
+		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 {
@@ -1561,6 +2056,17 @@ var LmsService = class {
 				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,
@@ -1611,11 +2117,13 @@ var LmsService = class {
 	}
 	async exportCourse(actor, id) {
 		const { course } = await this.editableCourse(actor, id);
-		const { id: _id, searchTitle: _search, createdBy: _creator, createdAt: _created, updatedAt: _updated, schemaVersion: _version, ...data } = course;
 		return {
 			format: "anantagnanam-lms-course",
 			version: 1,
-			course: data
+			course: courseDataSchema.parse({
+				...course,
+				status: "draft"
+			})
 		};
 	}
 	async importCourse(actor, input) {
@@ -1642,7 +2150,7 @@ var LmsService = class {
 		return { deleted: true };
 	}
 	async retryNotification(actor, id) {
-		invariant(user(actor).role >= 50, "FORBIDDEN", "Only administrators can retry email delivery.", 403);
+		invariant(user$1(actor).role >= 50, "FORBIDDEN", "Only administrators can retry email delivery.", 403);
 		invariant((await this.stores.notifications.updateIf(id, {
 			where: {
 				emailStatus: "failed",
@@ -1657,7 +2165,7 @@ var LmsService = class {
 		return { queued: true };
 	}
 	async notificationQueue(actor, options = {}) {
-		invariant(user(actor).role >= 50, "FORBIDDEN", "Administrator access required.", 403);
+		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" },
@@ -1666,7 +2174,7 @@ var LmsService = class {
 		});
 	}
 	async auditList(actor, options = {}) {
-		invariant(user(actor).role >= 50, "FORBIDDEN", "Administrator access required.", 403);
+		invariant(user$1(actor).role >= 50, "FORBIDDEN", "Administrator access required.", 403);
 		return queryPage(this.stores.audit, {
 			orderBy: { createdAt: "desc" },
 			limit: options.limit ?? 30,
@@ -1696,6 +2204,477 @@ var LmsService = class {
 	}
 };
 
+//#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/study.ts
+function owner(actor) {
+	invariant(actor, "UNAUTHORIZED", "Sign in to continue.", 401);
+	return actor;
+}
+/** Personal study data is retained separately from access and completion decisions. */
+var StudyTools = class {
+	constructor(service) {
+		this.service = service;
+	}
+	async courses(actor, input) {
+		const current = owner(actor);
+		const page = await queryPage(this.service.stores.enrollments, {
+			...parse(pageSchema, input),
+			where: { userId: current.id },
+			orderBy: { enrolledAt: "desc" }
+		});
+		return {
+			...page,
+			items: await Promise.all(page.items.map(async (enrollment) => {
+				const source = await this.service.stores.courses.get(enrollment.courseId);
+				const course = source ? await this.service.editions.learning(source, enrollment) : null;
+				return {
+					courseId: enrollment.courseId,
+					title: course?.title ?? "Unavailable course",
+					slug: course?.slug ?? null
+				};
+			}))
+		};
+	}
+	async notebook(actor, input) {
+		const current = owner(actor);
+		const { courseId } = parse(courseIdSchema, input);
+		const stored = await this.service.stores.enrollments.get(enrollmentKey(courseId, current.id));
+		invariant(stored, "NOT_FOUND", "Your course notebook was not found.", 404);
+		const source = await this.service.stores.courses.get(courseId);
+		const course = source ? await this.service.editions.learning(source, stored) : null;
+		const resolved = await this.service.accessEnrollment(stored);
+		const all = course ? lessons(course) : [];
+		return {
+			course: {
+				id: courseId,
+				title: course?.title ?? "Unavailable course",
+				slug: course?.slug ?? ""
+			},
+			notes: stored.studyNotes ?? [],
+			summaries: Object.entries(stored.progress).flatMap(([lessonId, progress]) => progress.note ? [{
+				lessonId,
+				lessonTitle: all.find((lesson) => lesson.id === lessonId)?.title ?? "Lesson",
+				body: progress.note
+			}] : []),
+			availableLessonIds: course ? all.filter((lesson) => lessonAvailability(course, lesson.id, resolved, this.service.now()).available).map((lesson) => lesson.id) : []
+		};
+	}
+	async saveNote(actor, input) {
+		const current = owner(actor);
+		const parsed = parse(studyNoteSchema, input);
+		const course = await this.service.course(parsed.courseId);
+		return change(this.service.stores.enrollments, enrollmentKey(course.id, current.id), async (stored) => {
+			const lesson = await this.service.lessonAccess(course, parsed.lessonId, stored);
+			invariant(parsed.positionSeconds === null || ["video", "audio"].includes(lesson.kind), "INVALID_TIMESTAMP", "Timestamps belong to audio or video lessons.");
+			const next = structuredClone(stored);
+			const notes = next.studyNotes ??= [];
+			const existing = notes.find((note) => note.id === parsed.id);
+			invariant(!existing || existing.lessonId === lesson.id, "NOTE_CONFLICT", "This note belongs to another lesson.", 409);
+			const same = existing && existing.body === parsed.body && existing.positionSeconds === parsed.positionSeconds && existing.starred === parsed.starred && existing.archived === parsed.archived;
+			if (existing && same && existing.revision === parsed.expectedRevision + 1) return {
+				value: next,
+				result: existing
+			};
+			invariant((existing?.revision ?? 0) === parsed.expectedRevision, "NOTE_CONFLICT", "This note changed in another tab. Your edits are still here; reload the saved note to compare.", 409);
+			invariant(existing || notes.length < 100, "NOTE_LIMIT", "This course notebook has reached its limit of 100 notes, including archived notes. Edit an existing note instead.", 409);
+			const note = {
+				id: parsed.id,
+				lessonId: lesson.id,
+				lessonTitle: existing?.lessonTitle ?? lesson.title,
+				body: parsed.body,
+				positionSeconds: parsed.positionSeconds,
+				starred: parsed.starred,
+				archived: parsed.archived,
+				revision: (existing?.revision ?? 0) + 1,
+				createdAt: existing?.createdAt ?? this.service.time(),
+				updatedAt: this.service.time()
+			};
+			if (existing) notes[notes.indexOf(existing)] = note;
+			else notes.push(note);
+			invariant(new TextEncoder().encode(JSON.stringify(notes)).byteLength <= 15e4, "NOTE_LIMIT", "This course notebook has reached its storage limit. Shorten an existing note to make room; archived notes still count.", 409);
+			return {
+				value: next,
+				result: note
+			};
+		});
+	}
+	async agenda(actor, input) {
+		const current = owner(actor);
+		const { courseId } = parse(courseIdSchema, input);
+		const source = await this.service.course(courseId);
+		const stored = await this.service.stores.enrollments.get(enrollmentKey(courseId, current.id));
+		const enrollment = await this.service.accessEnrollment(stored);
+		assertEnrollmentAccess(enrollment, this.service.now());
+		const course = await this.service.editions.learning(source, enrollment);
+		const now = this.service.now();
+		const events = [];
+		for (const lesson of lessons(course)) {
+			const access = lessonAvailability(course, lesson.id, enrollment, now);
+			const progress = enrollment.progress[lesson.id];
+			const append = (kind, startsAt, endsAt) => {
+				const past = Date.parse(startsAt) < now.getTime();
+				events.push({
+					id: `${course.id}-${lesson.id}-${kind}`,
+					kind,
+					lessonId: lesson.id,
+					title: lesson.title,
+					startsAt,
+					endsAt,
+					available: access.available,
+					reason: access.reason,
+					status: progress?.completedAt ? "completed" : kind === "assignment" && progress?.assignments.at(-1)?.status === "submitted" ? "submitted" : past ? kind === "assignment" ? "overdue" : "past" : "upcoming"
+				});
+			};
+			if (lesson.assignment?.dueAt) append("assignment", lesson.assignment.dueAt, null);
+			if (lesson.kind === "live" && lesson.liveStartsAt) append("live", lesson.liveStartsAt, new Date(Date.parse(lesson.liveStartsAt) + Math.max(1, lesson.durationMinutes) * 6e4).toISOString());
+			if (access.code === "LESSON_LOCKED" && access.releaseAt) append("release", access.releaseAt, null);
+		}
+		events.sort((a, b) => Date.parse(a.startsAt) - Date.parse(b.startsAt) || a.id.localeCompare(b.id));
+		return {
+			course: {
+				id: course.id,
+				title: course.title,
+				slug: course.slug
+			},
+			generatedAt: now.toISOString(),
+			events
+		};
+	}
+};
+
+//#endregion
+//#region src/calendar.ts
+const text = (value) => value.replace(/\r\n|\r/g, "\n").replace(/[\u0000-\u0008\u000b\u000c\u000e-\u001f\u007f]/g, "").replace(/\\/g, "\\\\").replace(/\n/g, "\\n").replace(/;/g, "\\;").replace(/,/g, "\\,");
+const date = (value) => new Date(value).toISOString().replace(/[-:]/g, "").replace(/\.\d{3}Z$/, "Z");
+/** RFC 5545 folding counts UTF-8 octets, including the continuation space. */
+function foldCalendarLine(value) {
+	const encoder = new TextEncoder();
+	let line = "";
+	let bytes = 0;
+	const lines = [];
+	for (const char of value) {
+		const size = encoder.encode(char).byteLength;
+		if (bytes + size > 75) {
+			lines.push(line);
+			line = " ";
+			bytes = 1;
+		}
+		line += char;
+		bytes += size;
+	}
+	lines.push(line);
+	return lines.join("\r\n");
+}
+/** A private downloadable snapshot: no subscription token, meeting URL or alarm. */
+function courseCalendar(agenda, origin, basePath) {
+	const lines = [
+		"BEGIN:VCALENDAR",
+		"VERSION:2.0",
+		"PRODID:-//Ananta Gnanam//LMS//EN",
+		"CALSCALE:GREGORIAN",
+		"METHOD:PUBLISH"
+	];
+	for (const event of agenda.events.filter((item) => item.status === "upcoming")) {
+		const kind = {
+			assignment: "Assignment due",
+			live: "Live session",
+			release: "Lesson release"
+		}[event.kind];
+		const url = new URL(`${basePath}/courses/${encodeURIComponent(agenda.course.slug)}/lessons/${encodeURIComponent(event.lessonId)}`, origin).href;
+		lines.push("BEGIN:VEVENT", `UID:${event.id}@anantagnanam-lms`, `DTSTAMP:${date(agenda.generatedAt)}`, `DTSTART:${date(event.startsAt)}`);
+		if (event.endsAt) lines.push(`DTEND:${date(event.endsAt)}`);
+		lines.push(`SUMMARY:${text(`${kind}: ${event.title}`)}`, `DESCRIPTION:${text(`${agenda.course.title}. Check the course for current access and requirements. This downloaded calendar does not update automatically.`)}`, `URL:${url}`, "CLASS:PRIVATE", `STATUS:${event.available ? "CONFIRMED" : "TENTATIVE"}`, "END:VEVENT");
+	}
+	lines.push("END:VCALENDAR");
+	return lines.map(foldCalendarLine).join("\r\n") + "\r\n";
+}
+
 //#endregion
 //#region src/runtime.ts
 const listSchema = pageSchema.extend({
@@ -1719,6 +2698,10 @@ const communityListSchema = pageSchema.extend({
 });
 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"],
@@ -1762,7 +2745,7 @@ function createPlugin(_options = {}) {
 		},
 		hooks: {
 			"plugin:install": async (_event, ctx) => {
-				await ctx.kv.set("schemaVersion", 1);
+				await ctx.kv.compareAndSet("schemaVersion", null, 1);
 			},
 			"plugin:activate": async (_event, ctx) => {
 				await ctx.cron?.schedule("maintenance", { schedule: "*/15 * * * *" });
@@ -1773,12 +2756,61 @@ function createPlugin(_options = {}) {
 			cron: async (event, ctx) => {
 				if (event.name === "maintenance") {
 					const service = new LmsService(ctx);
-					await service.reminders();
-					await service.deliverNotifications();
+					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: {
+			"learner/study/courses": get((ctx, service) => new StudyTools(service).courses(ctx.user, ctx.input)),
+			"learner/notebook": get((ctx, service) => new StudyTools(service).notebook(ctx.user, ctx.input)),
+			"learner/notebook/save": post((ctx, service) => new StudyTools(service).saveNote(ctx.user, ctx.input)),
+			"learner/agenda": get((ctx, service) => new StudyTools(service).agenda(ctx.user, ctx.input)),
+			"learner/agenda/calendar": definePluginRoute({
+				methods: ["GET"],
+				permission: "content:read",
+				request: { body: "none" },
+				response: "raw",
+				handler: async (ctx) => {
+					return pluginResponse({
+						body: {
+							kind: "text",
+							value: courseCalendar(await new StudyTools(new LmsService(ctx)).agenda(ctx.user, ctx.input), new URL(ctx.request.url).origin, options.basePath)
+						},
+						headers: {
+							"Content-Type": "text/calendar; charset=utf-8",
+							"Content-Disposition": "attachment; filename=\"lms-course-agenda.ics\""
+						}
+					});
+				}
+			}),
+			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 {
@@ -1827,6 +2859,11 @@ function createPlugin(_options = {}) {
 			"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/assignment/state": get(async (ctx, service) => {
+				const input = parse(lessonIdSchema, ctx.input);
+				return service.assignmentState(ctx.user, input.courseId, input.lessonId);
+			}),
+			"learner/assignment/draft": post(async (ctx, service) => service.saveAssignmentDraft(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);
@@ -1854,6 +2891,34 @@ function createPlugin(_options = {}) {
 			]).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,
@@ -2035,10 +3100,16 @@ function createPlugin(_options = {}) {
 			},
 			save_course: {
 				route: "admin/course/save",
-				description: "Create or update a course using its current storage revision. Can publish course content.",
+				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.",