@studious-lms/server 1.9.0 → 1.12.0

package/src/seedDatabase.ts

@@ -1,83 +1,160 @@
 import { prisma } from "./lib/prisma.js";
 import { hash } from "bcryptjs";
 import { logger } from "./utils/logger.js";
+import { ensureAIUserExists, getAIUserId } from "./utils/aiUser.js";
+import {
+    AssignmentType,
+    ConversationRole,
+    ConversationType,
+    DiscussionType,
+    FolderScope,
+    JobStatus,
+    PermissionLevel,
+    PermissionPrincipalType,
+    ReactionType,
+    SchoolMembershipRole,
+    SchoolMembershipStatus,
+    UploadStatus,
+    WorksheetQuestionType,
+} from "@prisma/client";
+
+// -----------------------------------------------------------------------------
+// Clear
+// -----------------------------------------------------------------------------
 
 export async function clearDatabase() {
-    // Delete in order to respect foreign key constraints
-    // Delete notifications first (they reference users)
-    logger.info('Clearing database');
+    logger.info("Clearing database");
+
+    // Top-of-the-graph children first.
+    await prisma.aiUsageLog.deleteMany();
     await prisma.notification.deleteMany();
-    
-    // Delete worksheet-related records
+
+    // Worksheet + question progress (referenced by submissions).
     await prisma.studentQuestionProgress.deleteMany();
     await prisma.studentWorksheetResponse.deleteMany();
     await prisma.worksheetQuestion.deleteMany();
     await prisma.worksheet.deleteMany();
-    
-    // Delete reactions (they reference announcements and comments)
+
+    // Reactions and reads (reference announcements/comments/discussions).
     await prisma.reaction.deleteMany();
-    
-    // Delete comments (they reference announcements and users)
+    await prisma.discussionRead.deleteMany();
+
+    // Discussion tree.
+    await prisma.discussionReply.deleteMany();
+    await prisma.discussion.deleteMany();
+    await prisma.discussionTag.deleteMany();
+
+    // Comments after their reactions are gone.
     await prisma.comment.deleteMany();
-    
-    // Delete NewtonChat (they reference submissions and conversations)
+
+    // Newton + Lab chats sit on conversations + submissions.
     await prisma.newtonChat.deleteMany();
-    
-    // Delete chat-related records
+    await prisma.labChat.deleteMany();
+
+    // Conversation graph.
     await prisma.mention.deleteMany();
     await prisma.message.deleteMany();
     await prisma.conversationMember.deleteMany();
-    await prisma.labChat.deleteMany();
     await prisma.conversation.deleteMany();
-    
-    // Delete other records that reference users
+
+    // Submissions / assignments / announcements / events.
     await prisma.submission.deleteMany();
     await prisma.assignment.deleteMany();
     await prisma.announcement.deleteMany();
-    await prisma.event.deleteMany();
     await prisma.attendance.deleteMany();
-    
-    // Delete class-related records
+    await prisma.event.deleteMany();
+
+    // RunJob is referenced by worksheets / messages / progress, all cleared above.
+    await prisma.runJob.deleteMany();
+
+    // Class scaffolding.
     await prisma.section.deleteMany();
     await prisma.markScheme.deleteMany();
     await prisma.gradingBoundary.deleteMany();
+
+    // Permissions live on folders; clear before folders.
+    await prisma.permission.deleteMany();
+
+    // Folders + files. Files reference folders/assignments/etc. so flush both.
+    await prisma.file.deleteMany();
     await prisma.folder.deleteMany();
+
+    // Classes (need to be gone before departments + tags they reference).
     await prisma.class.deleteMany();
-    
-    // Delete user-related records
+
+    // School scaffolding.
+    await prisma.tag.deleteMany();
+    await prisma.department.deleteMany();
+    await prisma.schoolInvite.deleteMany();
+    await prisma.schoolMembership.deleteMany();
+
+    // Sessions + profiles.
     await prisma.session.deleteMany();
     await prisma.userProfile.deleteMany();
-    
-    // Delete users first
+
+    // Users.
     await prisma.user.deleteMany();
-    
-    // Delete schools (which reference files for logos) - this will cascade delete the file references
+
+    // Schools (cascades remaining school-scoped rows).
     await prisma.school.deleteMany();
-    
-    // Delete marketing-related records
+
+    // Marketing forms.
     await prisma.schoolDevelopementProgram.deleteMany();
     await prisma.earlyAccessRequest.deleteMany();
-    
-    // Finally delete all files
-    await prisma.file.deleteMany();
 }
 
-// Helper function to generate DiceBear avatar URL
+// -----------------------------------------------------------------------------
+// Tiny helpers
+// -----------------------------------------------------------------------------
+
 function getDiceBearAvatar(seed: string): string {
     return `https://api.dicebear.com/7.x/avataaars/svg?seed=${encodeURIComponent(seed)}`;
 }
 
-export async function createUser(email: string, password: string, username: string) {
-    logger.debug("Creating user", { email, username, password });
+function pick<T>(arr: T[]): T {
+    return arr[Math.floor(Math.random() * arr.length)];
+}
+
+/**
+ * Run async work in capped batches. Supabase session-mode poolers cap clients
+ * very low (often ≤15), so unbounded `Promise.all` over a list will trip
+ * `MaxClientsInSessionMode`. Keep this small.
+ */
+async function runInBatches<T, R>(
+    items: T[],
+    fn: (item: T, index: number) => Promise<R>,
+    batchSize = 4,
+    delayMs = 50
+): Promise<R[]> {
+    const results: R[] = [];
+    for (let i = 0; i < items.length; i += batchSize) {
+        const slice = items.slice(i, i + batchSize);
+        const slot = await Promise.all(slice.map((item, j) => fn(item, i + j)));
+        results.push(...slot);
+        if (i + batchSize < items.length && delayMs > 0) {
+            await new Promise((resolve) => setTimeout(resolve, delayMs));
+        }
+    }
+    return results;
+}
 
+function daysFromNow(days: number, base: Date = new Date()): Date {
+    return new Date(base.getTime() + days * 24 * 60 * 60 * 1000);
+}
+
+function hoursFromNow(hours: number, base: Date = new Date()): Date {
+    return new Date(base.getTime() + hours * 60 * 60 * 1000);
+}
+
+export async function createUser(email: string, password: string, username: string) {
     const hashedPassword = await hash(password, 10);
-    return await prisma.user.create({
+    return prisma.user.create({
         data: { email, password: hashedPassword, username, verified: true },
     });
 }
 
 export async function addNotification(userId: string, title: string, content: string) {
-    return await prisma.notification.create({
+    return prisma.notification.create({
         data: {
             receiverId: userId,
             title,
@@ -86,1534 +163,1809 @@ export async function addNotification(userId: string, title: string, content: st
     });
 }
 
+/**
+ * Create a fake "uploaded" file record. We don't actually push bytes anywhere —
+ * this is just enough to make attachments render in the UI.
+ */
+async function createFakeFile(opts: {
+    name: string;
+    type?: string;
+    size?: number;
+    userId?: string;
+    folderId?: string;
+    assignmentId?: string;
+    submissionId?: string;
+    annotationId?: string;
+    messageId?: string;
+    announcementId?: string;
+    discussionId?: string;
+    discussionReplyId?: string;
+    classDraftId?: string;
+}) {
+    const type = opts.type ?? guessMime(opts.name);
+    const size = opts.size ?? Math.floor(50_000 + Math.random() * 950_000);
+    return prisma.file.create({
+        data: {
+            name: opts.name,
+            path: `seed/${crypto.randomUUID()}-${opts.name}`,
+            type,
+            size,
+            uploadStatus: UploadStatus.COMPLETED,
+            uploadedAt: new Date(),
+            ...(opts.userId && { user: { connect: { id: opts.userId } } }),
+            ...(opts.folderId && { folder: { connect: { id: opts.folderId } } }),
+            ...(opts.assignmentId && { assignment: { connect: { id: opts.assignmentId } } }),
+            ...(opts.submissionId && { submission: { connect: { id: opts.submissionId } } }),
+            ...(opts.annotationId && { annotations: { connect: { id: opts.annotationId } } }),
+            ...(opts.messageId && { message: { connect: { id: opts.messageId } } }),
+            ...(opts.announcementId && { announcement: { connect: { id: opts.announcementId } } }),
+            ...(opts.discussionId && { discussion: { connect: { id: opts.discussionId } } }),
+            ...(opts.discussionReplyId && {
+                discussionReply: { connect: { id: opts.discussionReplyId } },
+            }),
+            ...(opts.classDraftId && { classDraft: { connect: { id: opts.classDraftId } } }),
+        },
+    });
+}
+
+function guessMime(name: string): string {
+    const ext = name.split(".").pop()?.toLowerCase();
+    switch (ext) {
+        case "pdf":
+            return "application/pdf";
+        case "png":
+            return "image/png";
+        case "jpg":
+        case "jpeg":
+            return "image/jpeg";
+        case "gif":
+            return "image/gif";
+        case "webp":
+            return "image/webp";
+        case "docx":
+            return "application/vnd.openxmlformats-officedocument.wordprocessingml.document";
+        case "xlsx":
+            return "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet";
+        case "pptx":
+            return "application/vnd.openxmlformats-officedocument.presentationml.presentation";
+        case "md":
+            return "text/markdown";
+        case "txt":
+            return "text/plain";
+        case "csv":
+            return "text/csv";
+        case "mp4":
+            return "video/mp4";
+        case "mov":
+            return "video/quicktime";
+        default:
+            return "application/octet-stream";
+    }
+}
+
+// -----------------------------------------------------------------------------
+// Rubric + boundary structures (kept as JSON strings to match `structured`)
+// -----------------------------------------------------------------------------
+
+const fourLevelRubricLevels = [
+    { id: "excellent", name: "Excellent", points: 4, color: "#10B981" },
+    { id: "proficient", name: "Proficient", points: 3, color: "#3B82F6" },
+    { id: "developing", name: "Developing", points: 2, color: "#F59E0B" },
+    { id: "beginning", name: "Beginning", points: 1, color: "#EF4444" },
+] as const;
+
+function buildRubric(name: string, criteria: { id: string; title: string; description: string }[]) {
+    return JSON.stringify({
+        name,
+        criteria: criteria.map((c) => ({
+            ...c,
+            levels: fourLevelRubricLevels.map((l) => ({
+                ...l,
+                description: `${l.name} performance on ${c.title.toLowerCase()}.`,
+            })),
+        })),
+    });
+}
+
+const apGradingScale = JSON.stringify({
+    name: "AP Grading Scale",
+    boundaries: [
+        { id: "a-plus", grade: "A+", minPercentage: 97, maxPercentage: 100, color: "#059669" },
+        { id: "a", grade: "A", minPercentage: 93, maxPercentage: 96, color: "#10B981" },
+        { id: "a-minus", grade: "A-", minPercentage: 90, maxPercentage: 92, color: "#34D399" },
+        { id: "b-plus", grade: "B+", minPercentage: 87, maxPercentage: 89, color: "#1D4ED8" },
+        { id: "b", grade: "B", minPercentage: 83, maxPercentage: 86, color: "#3B82F6" },
+        { id: "b-minus", grade: "B-", minPercentage: 80, maxPercentage: 82, color: "#60A5FA" },
+        { id: "c-plus", grade: "C+", minPercentage: 77, maxPercentage: 79, color: "#D97706" },
+        { id: "c", grade: "C", minPercentage: 73, maxPercentage: 76, color: "#F59E0B" },
+        { id: "c-minus", grade: "C-", minPercentage: 70, maxPercentage: 72, color: "#FBBF24" },
+        { id: "d", grade: "D", minPercentage: 60, maxPercentage: 69, color: "#F87171" },
+        { id: "f", grade: "F", minPercentage: 0, maxPercentage: 59, color: "#EF4444" },
+    ],
+});
+
+// -----------------------------------------------------------------------------
+// Seed
+// -----------------------------------------------------------------------------
+
 export const seedDatabase = async () => {
     await clearDatabase();
-    logger.info('Cleared database');
+    logger.info("Cleared database");
 
-    // Create comprehensive demo data for teacher demo video
-    
-    // 1. Create School
-    const demoFile = await prisma.file.create({
+    // The AI assistant uses a fixed user id (`AI_ASSISTANT`) and is the sender
+    // on every AI-generated message. clearDatabase wipes it along with everyone
+    // else, so recreate it before we start producing AI-authored content.
+    await ensureAIUserExists();
+    const aiUserId = getAIUserId();
+
+    const now = new Date();
+
+    // ---------------------------------------------------------------------
+    // 1. School + logo
+    // ---------------------------------------------------------------------
+    const schoolLogo = await prisma.file.create({
         data: {
-            name: 'school_logo.png',
-            path: 'logos/demo_school.png',
-            type: 'image/png',
-            size: 15000,
-        }
+            name: "school_logo.png",
+            path: "logos/riverside.png",
+            type: "image/png",
+            size: 18_240,
+            uploadStatus: UploadStatus.COMPLETED,
+        },
     });
 
     const school = await prisma.school.create({
         data: {
-            name: 'Riverside High School',
-            logoId: demoFile.id,
-            subdomain: 'riverside',
-        }
+            name: "Riverside High School",
+            description: "A demo school used to showcase Studious end-to-end.",
+            subdomain: "riverside",
+            logoId: schoolLogo.id,
+        },
     });
 
-    // 2. Create Teachers
-    const teachers = await Promise.all([
-        createUser('sarah.johnson@riverside.edu', 'demo123', 'sarah.johnson'),
-        createUser('michael.chen@riverside.edu', 'demo123', 'michael.chen'),
-        createUser('emma.davis@riverside.edu', 'demo123', 'emma.davis'),
+    // ---------------------------------------------------------------------
+    // 2. Departments
+    // ---------------------------------------------------------------------
+    const [scienceDept, mathDept, englishDept] = await Promise.all([
+        prisma.department.create({
+            data: {
+                schoolId: school.id,
+                name: "Science",
+                description: "Biology, Chemistry, Physics, Environmental Science.",
+                color: "#10B981",
+            },
+        }),
+        prisma.department.create({
+            data: {
+                schoolId: school.id,
+                name: "Mathematics",
+                description: "Algebra, Geometry, Calculus, Statistics.",
+                color: "#3B82F6",
+            },
+        }),
+        prisma.department.create({
+            data: {
+                schoolId: school.id,
+                name: "English",
+                description: "Literature, Composition, Creative Writing.",
+                color: "#8B5CF6",
+            },
+        }),
     ]);
 
-    // 3. Create Students (realistic names)
-    const students = await Promise.all([
-        createUser('alex.martinez@student.rverside.eidu', 'student123', 'alex.martinez'),
-        createUser('sophia.williams@student.riverside.edu', 'student123', 'sophia.williams'),
-        createUser('james.brown@student.riverside.edu', 'student123', 'james.brown'),
-        createUser('olivia.taylor@student.riverside.edu', 'student123', 'olivia.taylor'),
-        createUser('ethan.anderson@student.riverside.edu', 'student123', 'ethan.anderson'),
-        createUser('ava.thomas@student.riverside.edu', 'student123', 'ava.thomas'),
-        createUser('noah.jackson@student.riverside.edu', 'student123', 'noah.jackson'),
-        createUser('isabella.white@student.riverside.edu', 'student123', 'isabella.white'),
-        createUser('liam.harris@student.riverside.edu', 'student123', 'liam.harris'),
-        createUser('mia.clark@student.riverside.edu', 'student123', 'mia.clark'),
-        createUser('lucas.lewis@student.riverside.edu', 'student123', 'lucas.lewis'),
-        createUser('charlotte.walker@student.riverside.edu', 'student123', 'charlotte.walker'),
+    // ---------------------------------------------------------------------
+    // 3. Tags (school-wide + department-scoped)
+    // ---------------------------------------------------------------------
+    const [tagAP, tagHonors, tagNeedsSupport, tagGifted, tagSeniorClass] = await Promise.all([
+        prisma.tag.create({
+            data: { schoolId: school.id, name: "AP", color: "#DC2626" },
+        }),
+        prisma.tag.create({
+            data: { schoolId: school.id, name: "Honors", color: "#7C3AED" },
+        }),
+        prisma.tag.create({
+            data: { schoolId: school.id, name: "Needs Support", color: "#F59E0B" },
+        }),
+        prisma.tag.create({
+            data: { schoolId: school.id, name: "Gifted & Talented", color: "#0EA5E9" },
+        }),
+        prisma.tag.create({
+            data: { schoolId: school.id, name: "Class of 2026", color: "#10B981" },
+        }),
     ]);
 
-    // 4. Create User Profiles with DiceBear avatars
+    // ---------------------------------------------------------------------
+    // 4. Users — teachers + admin + students
+    // ---------------------------------------------------------------------
+    const admin = await createUser("admin@riverside.edu", "admin123", "principal.rivera");
+
+    const teachers = await runInBatches(
+        [
+            { email: "sarah.johnson@riverside.edu", username: "sarah.johnson" },
+            { email: "michael.chen@riverside.edu", username: "michael.chen" },
+            { email: "emma.davis@riverside.edu", username: "emma.davis" },
+        ],
+        (t) => createUser(t.email, "demo123", t.username)
+    );
+
+    const studentSeeds: { email: string; username: string; name: string }[] = [
+        { email: "alex.martinez@student.riverside.edu", username: "alex.martinez", name: "Alex Martinez" },
+        { email: "sophia.williams@student.riverside.edu", username: "sophia.williams", name: "Sophia Williams" },
+        { email: "james.brown@student.riverside.edu", username: "james.brown", name: "James Brown" },
+        { email: "olivia.taylor@student.riverside.edu", username: "olivia.taylor", name: "Olivia Taylor" },
+        { email: "ethan.anderson@student.riverside.edu", username: "ethan.anderson", name: "Ethan Anderson" },
+        { email: "ava.thomas@student.riverside.edu", username: "ava.thomas", name: "Ava Thomas" },
+        { email: "noah.jackson@student.riverside.edu", username: "noah.jackson", name: "Noah Jackson" },
+        { email: "isabella.white@student.riverside.edu", username: "isabella.white", name: "Isabella White" },
+        { email: "liam.harris@student.riverside.edu", username: "liam.harris", name: "Liam Harris" },
+        { email: "mia.clark@student.riverside.edu", username: "mia.clark", name: "Mia Clark" },
+        { email: "lucas.lewis@student.riverside.edu", username: "lucas.lewis", name: "Lucas Lewis" },
+        { email: "charlotte.walker@student.riverside.edu", username: "charlotte.walker", name: "Charlotte Walker" },
+    ];
+
+    const students = await runInBatches(studentSeeds, (s) =>
+        createUser(s.email, "student123", s.username)
+    );
+
+    // Attach everyone to the school via the canonical schoolId pointer.
+    await prisma.user.updateMany({
+        where: { id: { in: [admin.id, ...teachers.map((t) => t.id), ...students.map((s) => s.id)] } },
+        data: { schoolId: school.id },
+    });
+
+    // ---------------------------------------------------------------------
+    // 5. SchoolMemberships
+    // ---------------------------------------------------------------------
+    await prisma.schoolMembership.createMany({
+        data: [
+            {
+                schoolId: school.id,
+                userId: admin.id,
+                role: SchoolMembershipRole.ADMIN,
+                status: SchoolMembershipStatus.ACTIVE,
+            },
+            ...teachers.map((t) => ({
+                schoolId: school.id,
+                userId: t.id,
+                role: SchoolMembershipRole.TEACHER,
+                status: SchoolMembershipStatus.ACTIVE,
+            })),
+            ...students.map((s) => ({
+                schoolId: school.id,
+                userId: s.id,
+                role: SchoolMembershipRole.STUDENT,
+                status: SchoolMembershipStatus.ACTIVE,
+            })),
+        ],
+    });
+
+    // A couple of pending invites for the demo.
     await Promise.all([
-        prisma.userProfile.create({
+        prisma.schoolInvite.create({
             data: {
-                userId: teachers[0].id,
-                displayName: 'Dr. Sarah Johnson',
-                bio: 'Biology teacher with 15 years of experience. Passionate about making science accessible to all students.',
-                location: 'Riverside, CA',
-                website: 'https://sarahjohnson-bio.com',
-                profilePicture: getDiceBearAvatar(teachers[0].username),
-            }
+                schoolId: school.id,
+                invitedById: admin.id,
+                email: "new.teacher@riverside.edu",
+                role: SchoolMembershipRole.TEACHER,
+                token: `invite-${crypto.randomUUID()}`,
+                expiresAt: daysFromNow(7, now),
+            },
         }),
-        prisma.userProfile.create({
+        prisma.schoolInvite.create({
             data: {
-                userId: teachers[1].id,
-                displayName: 'Mr. Michael Chen',
-                bio: 'Mathematics teacher and department head. Specializes in AP Calculus and Statistics.',
-                location: 'Riverside, CA',
-                profilePicture: getDiceBearAvatar(teachers[1].username),
-            }
+                schoolId: school.id,
+                invitedById: admin.id,
+                email: "transfer.student@riverside.edu",
+                role: SchoolMembershipRole.STUDENT,
+                token: `invite-${crypto.randomUUID()}`,
+                expiresAt: daysFromNow(14, now),
+            },
+        }),
+    ]);
+
+    // Hook teachers into their departments + add a few student tags.
+    await prisma.user.update({
+        where: { id: teachers[0].id },
+        data: { departments: { connect: { id: scienceDept.id } } },
+    });
+    await prisma.user.update({
+        where: { id: teachers[1].id },
+        data: { departments: { connect: { id: mathDept.id } } },
+    });
+    await prisma.user.update({
+        where: { id: teachers[2].id },
+        data: { departments: { connect: { id: englishDept.id } } },
+    });
+
+    // Tag a slice of students for the demo.
+    await Promise.all([
+        prisma.user.update({
+            where: { id: students[0].id },
+            data: { tags: { connect: [{ id: tagAP.id }, { id: tagSeniorClass.id }] } },
         }),
-        prisma.userProfile.create({
+        prisma.user.update({
+            where: { id: students[1].id },
             data: {
-                userId: teachers[2].id,
-                displayName: 'Ms. Emma Davis',
-                bio: 'English Literature teacher. Loves fostering creative writing and critical thinking.',
-                location: 'Riverside, CA',
-                profilePicture: getDiceBearAvatar(teachers[2].username),
-            }
+                tags: { connect: [{ id: tagAP.id }, { id: tagGifted.id }, { id: tagSeniorClass.id }] },
+            },
+        }),
+        prisma.user.update({
+            where: { id: students[4].id },
+            data: { tags: { connect: [{ id: tagNeedsSupport.id }] } },
+        }),
+        prisma.user.update({
+            where: { id: students[6].id },
+            data: { tags: { connect: [{ id: tagHonors.id }] } },
         }),
     ]);
 
-    // Add profiles for all students with DiceBear avatars
-    await Promise.all(students.map((student, index) => {
-        const names = [
-            'Alex Martinez', 'Sophia Williams', 'James Brown', 'Olivia Taylor', 
-            'Ethan Anderson', 'Ava Thomas', 'Noah Jackson', 'Isabella White',
-            'Liam Harris', 'Mia Clark', 'Lucas Lewis', 'Charlotte Walker'
-        ];
-        return prisma.userProfile.create({
-            data: {
+    // ---------------------------------------------------------------------
+    // 6. Profiles. createMany is cheap and avoids 16 parallel inserts.
+    // ---------------------------------------------------------------------
+    await prisma.userProfile.createMany({
+        data: [
+            {
+                userId: admin.id,
+                displayName: "Principal Rivera",
+                bio: "School administrator, oversees academic operations at Riverside High.",
+                location: "Riverside, CA",
+                profilePicture: getDiceBearAvatar(admin.username),
+            },
+            {
+                userId: teachers[0].id,
+                displayName: "Dr. Sarah Johnson",
+                bio: "Biology teacher with 15 years of experience.",
+                location: "Riverside, CA",
+                website: "https://sarahjohnson-bio.example",
+                profilePicture: getDiceBearAvatar(teachers[0].username),
+            },
+            {
+                userId: teachers[1].id,
+                displayName: "Mr. Michael Chen",
+                bio: "Math department head. AP Calculus + Statistics.",
+                location: "Riverside, CA",
+                profilePicture: getDiceBearAvatar(teachers[1].username),
+            },
+            {
+                userId: teachers[2].id,
+                displayName: "Ms. Emma Davis",
+                bio: "English Literature. Loves creative writing.",
+                location: "Riverside, CA",
+                profilePicture: getDiceBearAvatar(teachers[2].username),
+            },
+            ...students.map((student, i) => ({
                 userId: student.id,
-                displayName: names[index] || student.username,
-                bio: index < 6 ? `Grade 11 student at Riverside High School.` : undefined,
+                displayName: studentSeeds[i].name,
+                bio: i < 6 ? "Grade 11 student at Riverside High." : undefined,
                 profilePicture: getDiceBearAvatar(student.username),
-            }
-        });
-    }));
+            })),
+        ],
+    });
+
+    // ---------------------------------------------------------------------
+    // 7. Storage roots (school + personal). Class roots get created with classes.
+    // ---------------------------------------------------------------------
+    const schoolStorageRoot = await prisma.folder.create({
+        data: {
+            name: "Cloud Storage",
+            scope: FolderScope.SCHOOL_STORAGE,
+            color: "#3B82F6",
+            schoolStorage: { connect: { id: school.id } },
+        },
+    });
+
+    // Personal storage for each teacher.
+    const personalRoots = await Promise.all(
+        [admin, ...teachers].map((u) =>
+            prisma.folder.create({
+                data: {
+                    name: "My Files",
+                    scope: FolderScope.PERSONAL,
+                    color: "#6366F1",
+                    personalOwner: { connect: { id: u.id } },
+                },
+            })
+        )
+    );
+
+    // Some files in the school-wide storage.
+    await createFakeFile({
+        name: "Faculty Handbook 2026.pdf",
+        userId: admin.id,
+        folderId: schoolStorageRoot.id,
+        size: 1_240_000,
+    });
+    await createFakeFile({
+        name: "Emergency Procedures.pdf",
+        userId: admin.id,
+        folderId: schoolStorageRoot.id,
+        size: 520_000,
+    });
+    await createFakeFile({
+        name: "Bell Schedule (2026-2027).pdf",
+        userId: admin.id,
+        folderId: schoolStorageRoot.id,
+        size: 84_000,
+    });
+
+    // A personal subfolder + files for Sarah.
+    const sarahLessonPlans = await prisma.folder.create({
+        data: {
+            name: "Lesson Plans",
+            scope: FolderScope.PERSONAL,
+            color: "#10B981",
+            parentFolder: { connect: { id: personalRoots[1].id } },
+        },
+    });
+    await Promise.all([
+        createFakeFile({
+            name: "Cell Membrane Lecture.pptx",
+            userId: teachers[0].id,
+            folderId: sarahLessonPlans.id,
+        }),
+        createFakeFile({
+            name: "Mitosis vs Meiosis.md",
+            userId: teachers[0].id,
+            folderId: sarahLessonPlans.id,
+        }),
+        createFakeFile({
+            name: "Photosynthesis Diagram.png",
+            userId: teachers[0].id,
+            folderId: sarahLessonPlans.id,
+        }),
+    ]);
+
+    // Sharing the faculty handbook with all teachers via a permission grant.
+    await prisma.permission.create({
+        data: {
+            folderId: schoolStorageRoot.id,
+            principalType: PermissionPrincipalType.SCHOOL,
+            schoolId: school.id,
+            level: PermissionLevel.READ,
+            grantedById: admin.id,
+        },
+    });
 
-    // 5. Create Classes with realistic subjects
+    // ---------------------------------------------------------------------
+    // 8. Classes + their class-storage roots
+    // ---------------------------------------------------------------------
     const biologyClass = await prisma.class.create({
         data: {
-            name: 'AP Biology',
-            subject: 'Biology',
-            section: 'Period 3',
-            color: '#10B981',
-            syllabus: 'Advanced Placement Biology covering molecular biology, genetics, evolution, ecology, and more.',
+            name: "AP Biology",
+            subject: "Biology",
+            section: "Period 3",
+            color: "#10B981",
+            syllabus: "Molecular biology, genetics, evolution, ecology.",
             schoolId: school.id,
+            departmentId: scienceDept.id,
+            tags: { connect: [{ id: tagAP.id }] },
             teachers: { connect: { id: teachers[0].id } },
-            students: { connect: students.slice(0, 8).map(s => ({ id: s.id })) },
+            students: { connect: students.slice(0, 8).map((s) => ({ id: s.id })) },
         },
     });
 
     const mathClass = await prisma.class.create({
         data: {
-            name: 'AP Calculus BC',
-            subject: 'Mathematics',
-            section: 'Period 2',
-            color: '#3B82F6',
-            syllabus: 'Advanced calculus including limits, derivatives, integrals, and series.',
+            name: "AP Calculus BC",
+            subject: "Mathematics",
+            section: "Period 2",
+            color: "#3B82F6",
+            syllabus: "Limits, derivatives, integrals, series, parametric and polar.",
             schoolId: school.id,
+            departmentId: mathDept.id,
+            tags: { connect: [{ id: tagAP.id }, { id: tagHonors.id }] },
             teachers: { connect: { id: teachers[1].id } },
-            students: { connect: students.slice(4, 12).map(s => ({ id: s.id })) },
+            students: { connect: students.slice(4, 12).map((s) => ({ id: s.id })) },
         },
     });
 
     const englishClass = await prisma.class.create({
         data: {
-            name: 'English Literature',
-            subject: 'English',
-            section: 'Period 1',
-            color: '#8B5CF6',
-            syllabus: 'Study of classic and contemporary literature with focus on analysis and writing.',
+            name: "English Literature",
+            subject: "English",
+            section: "Period 1",
+            color: "#8B5CF6",
+            syllabus: "Close reading, rhetorical analysis, and academic writing.",
             schoolId: school.id,
+            departmentId: englishDept.id,
+            tags: { connect: [{ id: tagHonors.id }] },
             teachers: { connect: { id: teachers[2].id } },
-            students: { connect: students.slice(0, 10).map(s => ({ id: s.id })) },
+            students: { connect: students.slice(0, 10).map((s) => ({ id: s.id })) },
         },
     });
 
-    // 6. Create Sections for organization
-    const bioSections = await Promise.all([
-        prisma.section.create({
-            data: { name: 'Unit 1: Chemistry of Life', classId: biologyClass.id, color: '#EF4444', order: 1 }
+    const classes = [biologyClass, mathClass, englishClass];
+
+    // Per-class storage root + a few subfolders + draft attachments.
+    const classFolders = await Promise.all(
+        classes.map((c) =>
+            prisma.folder.create({
+                data: {
+                    name: "Class Files",
+                    scope: FolderScope.CLASS,
+                    color: c.color ?? "#3B82F6",
+                    class: { connect: { id: c.id } },
+                },
+            })
+        )
+    );
+
+    // Biology subfolders + files.
+    const bioHandouts = await prisma.folder.create({
+        data: {
+            name: "Handouts",
+            scope: FolderScope.CLASS,
+            color: "#10B981",
+            parentFolder: { connect: { id: classFolders[0].id } },
+        },
+    });
+    const bioLabs = await prisma.folder.create({
+        data: {
+            name: "Labs",
+            scope: FolderScope.CLASS,
+            color: "#0EA5E9",
+            parentFolder: { connect: { id: classFolders[0].id } },
+        },
+    });
+    await Promise.all([
+        createFakeFile({
+            name: "Cell Structure Reading.pdf",
+            userId: teachers[0].id,
+            folderId: bioHandouts.id,
+            size: 740_000,
         }),
-        prisma.section.create({
-            data: { name: 'Unit 2: Cell Structure', classId: biologyClass.id, color: '#F97316', order: 2 }
+        createFakeFile({
+            name: "Microscope Setup.pdf",
+            userId: teachers[0].id,
+            folderId: bioLabs.id,
         }),
-        prisma.section.create({
-            data: { name: 'Unit 3: Cellular Processes', classId: biologyClass.id, color: '#EAB308', order: 3 }
+        createFakeFile({
+            name: "Onion Cell Slides.jpg",
+            userId: teachers[0].id,
+            folderId: bioLabs.id,
         }),
-        prisma.section.create({
-            data: { name: 'Unit 4: Genetics', classId: biologyClass.id, color: '#22C55E', order: 4 }
+        createFakeFile({
+            name: "Syllabus AP Bio 2026.pdf",
+            userId: teachers[0].id,
+            folderId: classFolders[0].id,
         }),
     ]);
 
-    const mathSections = await Promise.all([
-        prisma.section.create({
-            data: { name: 'Limits and Continuity', classId: mathClass.id, color: '#3B82F6', order: 1 }
+    // Math subfolders + files.
+    const mathPracticeFolder = await prisma.folder.create({
+        data: {
+            name: "Practice Problems",
+            scope: FolderScope.CLASS,
+            color: "#6366F1",
+            parentFolder: { connect: { id: classFolders[1].id } },
+        },
+    });
+    await Promise.all([
+        createFakeFile({
+            name: "AP Calc BC Syllabus.pdf",
+            userId: teachers[1].id,
+            folderId: classFolders[1].id,
         }),
-        prisma.section.create({
-            data: { name: 'Derivatives', classId: mathClass.id, color: '#6366F1', order: 2 }
+        createFakeFile({
+            name: "Integration Cheatsheet.pdf",
+            userId: teachers[1].id,
+            folderId: mathPracticeFolder.id,
         }),
-        prisma.section.create({
-            data: { name: 'Integrals', classId: mathClass.id, color: '#8B5CF6', order: 3 }
+        createFakeFile({
+            name: "Past AP Exam 2024.pdf",
+            userId: teachers[1].id,
+            folderId: mathPracticeFolder.id,
+            size: 2_100_000,
         }),
     ]);
 
-    // 7. Create mark schemes first
-    const bioMarkScheme = await prisma.markScheme.create({
-        data: {
-            classId: biologyClass.id,
-            structured: JSON.stringify({
-                name: 'Biology Assessment Rubric',
-                criteria: [
-                    {
-                        id: 'scientific-accuracy',
-                        title: 'Scientific Accuracy',
-                        description: 'Correct use of scientific terminology and concepts',
-                        levels: [
-                            {
-                                id: 'excellent',
-                                name: 'Excellent',
-                                description: 'All scientific terms and concepts used correctly with precision',
-                                points: 4,
-                                color: '#10B981'
-                            },
-                            {
-                                id: 'proficient',
-                                name: 'Proficient',
-                                description: 'Most scientific terms and concepts used correctly',
-                                points: 3,
-                                color: '#3B82F6'
-                            },
-                            {
-                                id: 'developing',
-                                name: 'Developing',
-                                description: 'Some scientific terms used correctly, minor errors present',
-                                points: 2,
-                                color: '#F59E0B'
-                            },
-                            {
-                                id: 'beginning',
-                                name: 'Beginning',
-                                description: 'Limited use of scientific terminology, significant errors',
-                                points: 1,
-                                color: '#EF4444'
-                            }
-                        ]
-                    },
-                    {
-                        id: 'analysis-reasoning',
-                        title: 'Analysis & Reasoning',
-                        description: 'Quality of analysis and logical reasoning',
-                        levels: [
-                            {
-                                id: 'excellent',
-                                name: 'Excellent',
-                                description: 'Clear, sophisticated analysis with logical connections',
-                                points: 4,
-                                color: '#10B981'
-                            },
-                            {
-                                id: 'proficient',
-                                name: 'Proficient',
-                                description: 'Good analysis with mostly logical reasoning',
-                                points: 3,
-                                color: '#3B82F6'
-                            },
-                            {
-                                id: 'developing',
-                                name: 'Developing',
-                                description: 'Basic analysis with some logical gaps',
-                                points: 2,
-                                color: '#F59E0B'
-                            },
-                            {
-                                id: 'beginning',
-                                name: 'Beginning',
-                                description: 'Limited analysis, unclear reasoning',
-                                points: 1,
-                                color: '#EF4444'
-                            }
-                        ]
-                    },
-                    {
-                        id: 'communication',
-                        title: 'Communication',
-                        description: 'Clear writing and proper formatting',
-                        levels: [
-                            {
-                                id: 'excellent',
-                                name: 'Excellent',
-                                description: 'Clear, well-organized writing with proper format',
-                                points: 4,
-                                color: '#10B981'
-                            },
-                            {
-                                id: 'proficient',
-                                name: 'Proficient',
-                                description: 'Generally clear writing with good organization',
-                                points: 3,
-                                color: '#3B82F6'
-                            },
-                            {
-                                id: 'developing',
-                                name: 'Developing',
-                                description: 'Adequate writing with some organizational issues',
-                                points: 2,
-                                color: '#F59E0B'
-                            },
-                            {
-                                id: 'beginning',
-                                name: 'Beginning',
-                                description: 'Unclear writing, poor organization',
-                                points: 1,
-                                color: '#EF4444'
-                            }
-                        ]
-                    },
-                    {
-                        id: 'evidence-examples',
-                        title: 'Evidence & Examples',
-                        description: 'Use of relevant examples and evidence',
-                        levels: [
-                            {
-                                id: 'excellent',
-                                name: 'Excellent',
-                                description: 'Strong, relevant examples that enhance understanding',
-                                points: 4,
-                                color: '#10B981'
-                            },
-                            {
-                                id: 'proficient',
-                                name: 'Proficient',
-                                description: 'Good examples that support main points',
-                                points: 3,
-                                color: '#3B82F6'
-                            },
-                            {
-                                id: 'developing',
-                                name: 'Developing',
-                                description: 'Some examples provided, may lack relevance',
-                                points: 2,
-                                color: '#F59E0B'
-                            },
-                            {
-                                id: 'beginning',
-                                name: 'Beginning',
-                                description: 'Few or no relevant examples provided',
-                                points: 1,
-                                color: '#EF4444'
-                            }
-                        ]
-                    }
-                ]
-            })
-        }
+    // English class folder file.
+    await createFakeFile({
+        name: "Reading List Q1.pdf",
+        userId: teachers[2].id,
+        folderId: classFolders[2].id,
     });
 
-    const mathMarkScheme = await prisma.markScheme.create({
-        data: {
-            classId: mathClass.id,
-            structured: JSON.stringify({
-                name: 'Mathematics Assessment Rubric',
-                criteria: [
-                    {
-                        id: 'mathematical-accuracy',
-                        title: 'Mathematical Accuracy',
-                        description: 'Correct calculations and mathematical procedures',
-                        levels: [
-                            {
-                                id: 'excellent',
-                                name: 'Excellent',
-                                description: 'All calculations correct, proper mathematical procedures',
-                                points: 4,
-                                color: '#10B981'
-                            },
-                            {
-                                id: 'proficient',
-                                name: 'Proficient',
-                                description: 'Most calculations correct, minor computational errors',
-                                points: 3,
-                                color: '#3B82F6'
-                            },
-                            {
-                                id: 'developing',
-                                name: 'Developing',
-                                description: 'Some calculations correct, several errors present',
-                                points: 2,
-                                color: '#F59E0B'
-                            },
-                            {
-                                id: 'beginning',
-                                name: 'Beginning',
-                                description: 'Many calculation errors, incorrect procedures',
-                                points: 1,
-                                color: '#EF4444'
-                            }
-                        ]
-                    },
-                    {
-                        id: 'problem-solving',
-                        title: 'Problem-Solving Strategy',
-                        description: 'Appropriate method selection and setup',
-                        levels: [
-                            {
-                                id: 'excellent',
-                                name: 'Excellent',
-                                description: 'Optimal strategy chosen, excellent problem setup',
-                                points: 4,
-                                color: '#10B981'
-                            },
-                            {
-                                id: 'proficient',
-                                name: 'Proficient',
-                                description: 'Good strategy, appropriate problem approach',
-                                points: 3,
-                                color: '#3B82F6'
-                            },
-                            {
-                                id: 'developing',
-                                name: 'Developing',
-                                description: 'Adequate strategy, some setup issues',
-                                points: 2,
-                                color: '#F59E0B'
-                            },
-                            {
-                                id: 'beginning',
-                                name: 'Beginning',
-                                description: 'Poor strategy choice, unclear setup',
-                                points: 1,
-                                color: '#EF4444'
-                            }
-                        ]
-                    },
-                    {
-                        id: 'work-shown',
-                        title: 'Work Shown',
-                        description: 'Clear step-by-step work and explanations',
-                        levels: [
-                            {
-                                id: 'excellent',
-                                name: 'Excellent',
-                                description: 'All work clearly shown with detailed explanations',
-                                points: 4,
-                                color: '#10B981'
-                            },
-                            {
-                                id: 'proficient',
-                                name: 'Proficient',
-                                description: 'Most work shown, good explanations',
-                                points: 3,
-                                color: '#3B82F6'
-                            },
-                            {
-                                id: 'developing',
-                                name: 'Developing',
-                                description: 'Some work shown, limited explanations',
-                                points: 2,
-                                color: '#F59E0B'
-                            },
-                            {
-                                id: 'beginning',
-                                name: 'Beginning',
-                                description: 'Little work shown, unclear process',
-                                points: 1,
-                                color: '#EF4444'
-                            }
-                        ]
-                    },
-                    {
-                        id: 'final-answer',
-                        title: 'Final Answer',
-                        description: 'Correct final answer with proper units/notation',
-                        levels: [
-                            {
-                                id: 'excellent',
-                                name: 'Excellent',
-                                description: 'Correct answer with proper units and notation',
-                                points: 4,
-                                color: '#10B981'
-                            },
-                            {
-                                id: 'proficient',
-                                name: 'Proficient',
-                                description: 'Correct answer, minor notation issues',
-                                points: 3,
-                                color: '#3B82F6'
-                            },
-                            {
-                                id: 'developing',
-                                name: 'Developing',
-                                description: 'Answer close to correct, some notation errors',
-                                points: 2,
-                                color: '#F59E0B'
-                            },
-                            {
-                                id: 'beginning',
-                                name: 'Beginning',
-                                description: 'Incorrect answer or missing units',
-                                points: 1,
-                                color: '#EF4444'
-                            }
-                        ]
-                    }
-                ]
-            })
-        }
+    // A class draft file (attached to class drafts list, not yet on an assignment).
+    await createFakeFile({
+        name: "Draft - Genetics Worksheet.docx",
+        userId: teachers[0].id,
+        classDraftId: biologyClass.id,
     });
 
-    // 8. Create grading boundaries
-    const mathGradingBoundary = await prisma.gradingBoundary.create({
+    // Grant the science department READ on Bio class folder.
+    await prisma.permission.create({
         data: {
-            classId: mathClass.id,
-            structured: JSON.stringify({
-                name: 'AP Calculus BC Grading Scale',
-                boundaries: [
-                    {
-                        id: 'a-plus',
-                        grade: 'A+',
-                        minPercentage: 97,
-                        maxPercentage: 100,
-                        description: 'Exceptional mastery of all concepts',
-                        color: '#059669'
-                    },
-                    {
-                        id: 'a',
-                        grade: 'A',
-                        minPercentage: 93,
-                        maxPercentage: 96,
-                        description: 'Strong mastery of concepts',
-                        color: '#10B981'
-                    },
-                    {
-                        id: 'a-minus',
-                        grade: 'A-',
-                        minPercentage: 90,
-                        maxPercentage: 92,
-                        description: 'Good mastery with minor gaps',
-                        color: '#34D399'
-                    },
-                    {
-                        id: 'b-plus',
-                        grade: 'B+',
-                        minPercentage: 87,
-                        maxPercentage: 89,
-                        description: 'Above average understanding',
-                        color: '#1D4ED8'
-                    },
-                    {
-                        id: 'b',
-                        grade: 'B',
-                        minPercentage: 83,
-                        maxPercentage: 86,
-                        description: 'Solid understanding of most concepts',
-                        color: '#3B82F6'
-                    },
-                    {
-                        id: 'b-minus',
-                        grade: 'B-',
-                        minPercentage: 80,
-                        maxPercentage: 82,
-                        description: 'Adequate understanding with some gaps',
-                        color: '#60A5FA'
-                    },
-                    {
-                        id: 'c-plus',
-                        grade: 'C+',
-                        minPercentage: 77,
-                        maxPercentage: 79,
-                        description: 'Basic understanding, needs improvement',
-                        color: '#D97706'
-                    },
-                    {
-                        id: 'c',
-                        grade: 'C',
-                        minPercentage: 73,
-                        maxPercentage: 76,
-                        description: 'Minimal acceptable understanding',
-                        color: '#F59E0B'
-                    },
-                    {
-                        id: 'c-minus',
-                        grade: 'C-',
-                        minPercentage: 70,
-                        maxPercentage: 72,
-                        description: 'Below average, significant gaps',
-                        color: '#FBBF24'
-                    },
-                    {
-                        id: 'd',
-                        grade: 'D',
-                        minPercentage: 60,
-                        maxPercentage: 69,
-                        description: 'Poor understanding, major deficiencies',
-                        color: '#F87171'
-                    },
-                    {
-                        id: 'f',
-                        grade: 'F',
-                        minPercentage: 0,
-                        maxPercentage: 59,
-                        description: 'Inadequate understanding, does not meet standards',
-                        color: '#EF4444'
-                    }
-                ]
-            })
-        }
+            folderId: classFolders[0].id,
+            principalType: PermissionPrincipalType.DEPARTMENT,
+            departmentId: scienceDept.id,
+            level: PermissionLevel.READ,
+            grantedById: teachers[0].id,
+        },
     });
 
-    // 9. Create realistic assignments (more for Calc BC)
-    const now = new Date();
-    const yesterday = new Date(now.getTime() - 24 * 60 * 60 * 1000);
-    const tomorrow = new Date(now.getTime() + 24 * 60 * 60 * 1000);
-    const nextWeek = new Date(now.getTime() + 7 * 24 * 60 * 60 * 1000);
-    const nextMonth = new Date(now.getTime() + 30 * 24 * 60 * 60 * 1000);
-    const lastWeek = new Date(now.getTime() - 7 * 24 * 60 * 60 * 1000);
-
-    const assignments = await Promise.all([
-        // Biology assignments
-        prisma.assignment.create({
-            data: {
-                title: 'Cell Structure Lab Report',
-                instructions: 'Complete the microscopy lab and write a detailed report on your observations of plant and animal cells. Include labeled diagrams and compare/contrast the structures you observed.',
-                dueDate: nextWeek,
-                teacherId: teachers[0].id,
-                classId: biologyClass.id,
-                sectionId: bioSections[1].id,
-                type: 'LAB',
-                maxGrade: 100,
-                weight: 1.5,
-                markSchemeId: bioMarkScheme.id,
-            }
-        }),
-        prisma.assignment.create({
-            data: {
-                title: 'Genetics Problem Set',
-                instructions: 'Solve the genetics problems on pages 234-237. Show all work including Punnett squares and probability calculations.',
-                dueDate: tomorrow,
-                teacherId: teachers[0].id,
-                classId: biologyClass.id,
-                sectionId: bioSections[3].id,
-                type: 'HOMEWORK',
-                maxGrade: 50,
-                weight: 1.0,
-                markSchemeId: bioMarkScheme.id,
-            }
-        }),
-        prisma.assignment.create({
-            data: {
-                title: 'Evolution Essay',
-                instructions: 'Write a 5-page essay on the evidence for evolution. Use at least 5 scientific sources and cite them properly.',
-                dueDate: nextMonth,
-                teacherId: teachers[0].id,
-                classId: biologyClass.id,
-                type: 'ESSAY',
-                maxGrade: 100,
-                weight: 2.0,
-                markSchemeId: bioMarkScheme.id,
-            }
-        }),
-        
-        // Math assignments (expanded for demo)
-        prisma.assignment.create({
-            data: {
-                title: 'Limits and Continuity Test',
-                instructions: 'Comprehensive test covering limits, continuity, and the Intermediate Value Theorem. Calculators allowed for Section B only.',
-                dueDate: lastWeek, // Already completed
-                teacherId: teachers[1].id,
-                classId: mathClass.id,
-                sectionId: mathSections[0].id,
-                type: 'TEST',
-                maxGrade: 100,
-                weight: 2.5,
-                markSchemeId: mathMarkScheme.id,
-                gradingBoundaryId: mathGradingBoundary.id,
-                graded: true,
-            }
-        }),
-        prisma.assignment.create({
-            data: {
-                title: 'Limits Practice Problems',
-                instructions: 'Complete problems 1-25 on page 89. Focus on algebraic manipulation and graphical analysis.',
-                dueDate: yesterday, // Just submitted
-                teacherId: teachers[1].id,
-                classId: mathClass.id,
-                sectionId: mathSections[0].id,
-                type: 'HOMEWORK',
-                maxGrade: 25,
-                weight: 1.0,
-                markSchemeId: mathMarkScheme.id,
-                gradingBoundaryId: mathGradingBoundary.id,
-            }
-        }),
-        prisma.assignment.create({
-            data: {
-                title: 'Derivative Applications Quiz',
-                instructions: 'Quiz covering related rates, optimization, and curve sketching.',
-                dueDate: new Date(now.getTime() + 5 * 24 * 60 * 60 * 1000),
-                teacherId: teachers[1].id,
-                classId: mathClass.id,
-                sectionId: mathSections[1].id,
-                type: 'QUIZ',
-                maxGrade: 75,
-                weight: 1.5,
-                markSchemeId: mathMarkScheme.id,
-                gradingBoundaryId: mathGradingBoundary.id,
-            }
-        }),
-        prisma.assignment.create({
-            data: {
-                title: 'Integration Techniques Homework',
-                instructions: 'Complete problems 1-30 on pages 156-158. Practice integration by parts, substitution, and partial fractions.',
-                dueDate: new Date(now.getTime() + 3 * 24 * 60 * 60 * 1000),
-                teacherId: teachers[1].id,
-                classId: mathClass.id,
-                sectionId: mathSections[2].id,
-                type: 'HOMEWORK',
-                maxGrade: 30,
-                weight: 1.0,
-                markSchemeId: mathMarkScheme.id,
-                gradingBoundaryId: mathGradingBoundary.id,
-            }
-        }),
-        prisma.assignment.create({
-            data: {
-                title: 'AP Practice Test - Derivatives',
-                instructions: 'Complete this practice AP exam focusing on derivatives and their applications. Time limit: 90 minutes.',
-                dueDate: new Date(now.getTime() + 10 * 24 * 60 * 60 * 1000),
-                teacherId: teachers[1].id,
-                classId: mathClass.id,
-                sectionId: mathSections[1].id,
-                type: 'TEST',
-                maxGrade: 108, // AP style scoring
-                weight: 2.5,
-                markSchemeId: mathMarkScheme.id,
-                gradingBoundaryId: mathGradingBoundary.id,
-            }
-        }),
-        prisma.assignment.create({
-            data: {
-                title: 'Calculus Project: Real-World Applications',
-                instructions: 'Choose a real-world scenario and create a presentation showing how calculus is used. Include derivatives, integrals, and optimization. 10-minute presentation required.',
-                dueDate: new Date(now.getTime() + 21 * 24 * 60 * 60 * 1000),
-                teacherId: teachers[1].id,
-                classId: mathClass.id,
-                type: 'PROJECT',
-                maxGrade: 150,
-                weight: 3.0,
-                markSchemeId: mathMarkScheme.id,
-                gradingBoundaryId: mathGradingBoundary.id,
-            }
-        }),
-    ]);
-
-    // 10. Create comprehensive submissions for all students and assignments
-    const submissionsToCreate: any[] = [];
-    
-    // Helper function to generate realistic grades based on assignment type and student performance
-    const generateGrade = (maxGrade: number, studentIndex: number, assignmentType: string) => {
-        // Create some variation in student performance
-        const basePerformance = [0.92, 0.88, 0.85, 0.90, 0.82, 0.87, 0.91, 0.84, 0.89, 0.86, 0.83, 0.88]; // Different performance levels
-        const performance = basePerformance[studentIndex % basePerformance.length];
-        
-        // Adjust based on assignment type
-        let multiplier = performance;
-        if (assignmentType === 'TEST') multiplier -= 0.05; // Tests are harder
-        if (assignmentType === 'QUIZ') multiplier -= 0.02; // Quizzes slightly harder
-        if (assignmentType === 'HOMEWORK') multiplier += 0.03; // Homework gets better grades
-        
-        // Add some randomness
-        const randomFactor = (Math.random() - 0.5) * 0.1; // ±5%
-        const finalGrade = Math.round(maxGrade * (multiplier + randomFactor));
-        
-        return Math.max(0, Math.min(maxGrade, finalGrade)); // Clamp between 0 and maxGrade
-    };
-
-    // Generate teacher comments based on grade
-    const generateComment = (grade: number, maxGrade: number, assignmentType: string) => {
-        const percentage = (grade / maxGrade) * 100;
-        const comments = {
-            excellent: [
-                'Excellent work! Your understanding of the concepts is clear.',
-                'Outstanding performance. Keep up the great work!',
-                'Impressive analysis and problem-solving approach.',
-                'Perfect execution. Your work demonstrates mastery of the material.'
-            ],
-            good: [
-                'Good work overall. Minor areas for improvement noted.',
-                'Solid understanding demonstrated. Watch calculation accuracy.',
-                'Well done! A few small errors but good conceptual grasp.',
-                'Nice job. Consider reviewing the highlighted sections.'
-            ],
-            average: [
-                'Adequate work. Please review the concepts we discussed in class.',
-                'Shows basic understanding but needs more practice.',
-                'Fair attempt. Come see me during office hours for extra help.',
-                'Meets expectations. Focus on showing more detailed work.'
-            ],
-            needs_improvement: [
-                'Needs significant improvement. Please schedule a meeting to discuss.',
-                'Below expectations. Additional practice and review required.',
-                'Struggling with key concepts. Let\'s work together to improve.',
-                'Requires more effort and attention to detail.'
-            ]
-        };
-
-        let category: keyof typeof comments;
-        if (percentage >= 90) category = 'excellent';
-        else if (percentage >= 80) category = 'good';
-        else if (percentage >= 70) category = 'average';
-        else category = 'needs_improvement';
-
-        return comments[category][Math.floor(Math.random() * comments[category].length)];
-    };
+    // ---------------------------------------------------------------------
+    // 9. Sections inside each class
+    // ---------------------------------------------------------------------
+    const bioSections = await Promise.all(
+        [
+            { name: "Unit 1: Chemistry of Life", color: "#EF4444" },
+            { name: "Unit 2: Cell Structure", color: "#F97316" },
+            { name: "Unit 3: Cellular Processes", color: "#EAB308" },
+            { name: "Unit 4: Genetics", color: "#22C55E" },
+        ].map((s, i) =>
+            prisma.section.create({
+                data: { name: s.name, color: s.color, order: i + 1, classId: biologyClass.id },
+            })
+        )
+    );
 
-    // Create submissions for Biology assignments (students 0-7)
-    for (let i = 0; i < 3; i++) { // First 3 assignments are Biology
-        const assignment = assignments[i];
-        const maxGrade = assignment.maxGrade || 100; // Default to 100 if null
-        for (let j = 0; j < 8; j++) { // 8 students in Biology
-            const student = students[j];
-            const grade = generateGrade(maxGrade, j, assignment.type);
-            const isSubmitted = Math.random() > 0.1; // 90% submission rate
-            const isGraded = i < 2; // First 2 assignments are graded
-            
-            submissionsToCreate.push({
-                assignmentId: assignment.id,
-                studentId: student.id,
-                submitted: isSubmitted,
-                submittedAt: isSubmitted ? new Date(assignment.dueDate.getTime() - Math.random() * 24 * 60 * 60 * 1000) : null,
-                gradeReceived: isGraded && isSubmitted ? grade : null,
-                teacherComments: isGraded && isSubmitted ? generateComment(grade, maxGrade, assignment.type) : null,
-                returned: isGraded && isSubmitted,
-            });
-        }
-    }
+    const mathSections = await Promise.all(
+        [
+            { name: "Limits and Continuity", color: "#3B82F6" },
+            { name: "Derivatives", color: "#6366F1" },
+            { name: "Integrals", color: "#8B5CF6" },
+            { name: "Series", color: "#A855F7" },
+        ].map((s, i) =>
+            prisma.section.create({
+                data: { name: s.name, color: s.color, order: i + 1, classId: mathClass.id },
+            })
+        )
+    );
 
-    // Create submissions for Math assignments (students 4-11) - 8 students
-    for (let i = 3; i < assignments.length; i++) { // Math assignments start at index 3
-        const assignment = assignments[i];
-        const maxGrade = assignment.maxGrade || 100; // Default to 100 if null
-        for (let j = 4; j < 12; j++) { // Students 4-11 are in Math class
-            const student = students[j];
-            const grade = generateGrade(maxGrade, j, assignment.type);
-            
-            // Determine submission and grading status based on due date
-            const isOverdue = assignment.dueDate < now;
-            const isDueSoon = assignment.dueDate < tomorrow;
-            const isSubmitted = isOverdue || (isDueSoon && Math.random() > 0.2) || Math.random() > 0.15; // Higher submission rate for math
-            const isGraded = isOverdue && assignment.graded; // Only grade overdue assignments
-            
-            submissionsToCreate.push({
-                assignmentId: assignment.id,
-                studentId: student.id,
-                submitted: isSubmitted,
-                submittedAt: isSubmitted ? new Date(assignment.dueDate.getTime() - Math.random() * 48 * 60 * 60 * 1000) : null,
-                gradeReceived: isGraded && isSubmitted ? grade : null,
-                teacherComments: isGraded && isSubmitted ? generateComment(grade, maxGrade, assignment.type) : null,
-                returned: isGraded && isSubmitted,
-                rubricState: isGraded && isSubmitted ? JSON.stringify({
-                    criteria: [
-                        { name: 'Mathematical Accuracy', score: Math.round(grade * 0.5), maxScore: Math.round(maxGrade * 0.5) },
-                        { name: 'Problem-Solving Strategy', score: Math.round(grade * 0.25), maxScore: Math.round(maxGrade * 0.25) },
-                        { name: 'Work Shown', score: Math.round(grade * 0.15), maxScore: Math.round(maxGrade * 0.15) },
-                        { name: 'Final Answer', score: Math.round(grade * 0.1), maxScore: Math.round(maxGrade * 0.1) }
-                    ]
-                }) : null,
-            });
-        }
-    }
+    await Promise.all(
+        [
+            { name: "Short Stories", color: "#8B5CF6" },
+            { name: "Poetry", color: "#EC4899" },
+            { name: "Novels", color: "#A855F7" },
+        ].map((s, i) =>
+            prisma.section.create({
+                data: { name: s.name, color: s.color, order: i + 1, classId: englishClass.id },
+            })
+        )
+    );
 
-    // Create all submissions in batches to avoid connection pool exhaustion
-    const BATCH_SIZE = 15; // Create 15 at a time to avoid overwhelming Supabase connection pool
-    
-    logger.info(`Creating ${submissionsToCreate.length} submissions in batches of ${BATCH_SIZE}`);
-    
-    for (let i = 0; i < submissionsToCreate.length; i += BATCH_SIZE) {
-        const batch = submissionsToCreate.slice(i, i + BATCH_SIZE);
-        await Promise.all(batch.map(submission => 
-            prisma.submission.create({ data: submission })
-        ));
-        
-        // Small delay between batches to avoid overwhelming the connection pool
-        if (i + BATCH_SIZE < submissionsToCreate.length) {
-            await new Promise(resolve => setTimeout(resolve, 100)); // 100ms delay
-        }
-        
-        // Log progress every 30 submissions or at the end
-        if ((i + BATCH_SIZE) % 30 === 0 || i + BATCH_SIZE >= submissionsToCreate.length) {
-            logger.info(`Created ${Math.min(i + BATCH_SIZE, submissionsToCreate.length)}/${submissionsToCreate.length} submissions`);
-        }
-    }
-    
-    logger.info(`Successfully created all ${submissionsToCreate.length} submissions`);
+    // ---------------------------------------------------------------------
+    // 10. MarkSchemes + GradingBoundaries
+    //     Mix of class-bound (legacy) and department-level (template) rows.
+    // ---------------------------------------------------------------------
+    const bioRubricStructured = buildRubric("Biology Assessment Rubric", [
+        { id: "scientific-accuracy", title: "Scientific Accuracy", description: "Correct use of scientific terminology and concepts" },
+        { id: "analysis", title: "Analysis & Reasoning", description: "Quality of analysis and logical reasoning" },
+        { id: "communication", title: "Communication", description: "Clear writing and proper formatting" },
+        { id: "evidence", title: "Evidence & Examples", description: "Use of relevant examples and evidence" },
+    ]);
+    const mathRubricStructured = buildRubric("Mathematics Assessment Rubric", [
+        { id: "accuracy", title: "Mathematical Accuracy", description: "Correct calculations and procedures" },
+        { id: "strategy", title: "Problem-Solving Strategy", description: "Appropriate method selection and setup" },
+        { id: "work-shown", title: "Work Shown", description: "Clear step-by-step work and explanations" },
+        { id: "final-answer", title: "Final Answer", description: "Correct final answer with proper units/notation" },
+    ]);
 
-    // 11. Create announcements
-    await Promise.all([
-        prisma.announcement.create({
+    const [bioMarkScheme, mathMarkScheme] = await Promise.all([
+        prisma.markScheme.create({
             data: {
-                remarks: 'Reminder: Lab safety quiz next Tuesday. Please review the safety protocols we discussed in class.',
-                teacherId: teachers[0].id,
                 classId: biologyClass.id,
-                createdAt: new Date(now.getTime() - 24 * 60 * 60 * 1000),
-            }
+                name: "Biology Assessment Rubric",
+                structured: bioRubricStructured,
+                tags: { connect: [{ id: tagAP.id }] },
+            },
         }),
-        prisma.announcement.create({
+        prisma.markScheme.create({
             data: {
-                remarks: 'Great job on the recent quiz, everyone! The class average was 87%. Keep up the excellent work!',
-                teacherId: teachers[1].id,
                 classId: mathClass.id,
-                createdAt: new Date(now.getTime() - 6 * 60 * 60 * 1000),
-            }
+                name: "Mathematics Assessment Rubric",
+                structured: mathRubricStructured,
+                tags: { connect: [{ id: tagAP.id }] },
+            },
+        }),
+        // Department-level templates so the rubric library has content too.
+        prisma.markScheme.create({
+            data: {
+                departmentId: mathDept.id,
+                name: "Math Department Standard Rubric",
+                structured: mathRubricStructured,
+            },
         }),
-        prisma.announcement.create({
+        prisma.gradingBoundary.create({
             data: {
-                remarks: 'Don\'t forget: Parent-teacher conferences are next week. Sign-up sheets are available in the main office.',
-                teacherId: teachers[2].id,
-                classId: englishClass.id,
-                createdAt: new Date(now.getTime() - 12 * 60 * 60 * 1000),
-            }
+                departmentId: mathDept.id,
+                name: "AP Grading Scale (Template)",
+                structured: apGradingScale,
+            },
         }),
     ]);
 
-    // 12. Create events/calendar items (lots for Michael Chen's week of Oct 7)
-    const oct7 = new Date('2025-10-07T08:00:00');
-    const oct8 = new Date('2025-10-08T08:00:00');
-    const oct9 = new Date('2025-10-09T08:00:00');
-    const oct10 = new Date('2025-10-10T08:00:00');
-    const oct11 = new Date('2025-10-11T08:00:00');
-    
-    // Build events array first, then batch create them
-    const eventsToCreate = [
-        // Monday Oct 7 - Michael Chen's busy day
-        {
-            name: 'AP Calculus BC - Period 2',
-            startTime: new Date('2025-10-07T09:15:00'),
-            endTime: new Date('2025-10-07T10:05:00'),
-            location: 'Room 156',
-            remarks: 'Derivatives unit test review',
-            userId: teachers[1].id,
+    const mathGradingBoundary = await prisma.gradingBoundary.create({
+        data: {
             classId: mathClass.id,
-            color: '#3B82F6',
-        },
-        {
-            name: 'Department Head Meeting',
-            startTime: new Date('2025-10-07T10:30:00'),
-            endTime: new Date('2025-10-07T11:30:00'),
-            location: 'Conference Room A',
-            remarks: 'Monthly math department meeting - curriculum planning',
-            userId: teachers[1].id,
-            color: '#8B5CF6',
+            name: "AP Calculus BC Grading Scale",
+            structured: apGradingScale,
         },
+    });
+
+    // ---------------------------------------------------------------------
+    // 11. Assignments + attachments
+    // ---------------------------------------------------------------------
+    const assignmentSpecs: {
+        title: string;
+        instructions: string;
+        dueDate: Date;
+        teacherId: string;
+        classId: string;
+        sectionId?: string;
+        type: AssignmentType;
+        maxGrade: number;
+        weight: number;
+        markSchemeId?: string;
+        gradingBoundaryId?: string;
+        graded?: boolean;
+        acceptFiles?: boolean;
+        acceptExtendedResponse?: boolean;
+        acceptWorksheet?: boolean;
+        gradeWithAI?: boolean;
+        attachments?: string[];
+    }[] = [
         {
-            name: 'AP Statistics - Period 5',
-            startTime: new Date('2025-10-07T13:45:00'),
-            endTime: new Date('2025-10-07T14:35:00'),
-            location: 'Room 156',
-            remarks: 'Hypothesis testing introduction',
-            userId: teachers[1].id,
-            color: '#3B82F6',
+            title: "Cell Structure Lab Report",
+            instructions:
+                "Complete the microscopy lab and write a detailed report on your observations of plant and animal cells. Include labeled diagrams.",
+            dueDate: daysFromNow(7, now),
+            teacherId: teachers[0].id,
+            classId: biologyClass.id,
+            sectionId: bioSections[1].id,
+            type: AssignmentType.LAB,
+            maxGrade: 100,
+            weight: 1.5,
+            markSchemeId: bioMarkScheme.id,
+            acceptFiles: true,
+            acceptExtendedResponse: true,
+            attachments: ["Lab Report Template.docx", "Rubric.pdf"],
         },
         {
-            name: 'Parent Conference - Williams Family',
-            startTime: new Date('2025-10-07T15:00:00'),
-            endTime: new Date('2025-10-07T15:30:00'),
-            location: 'Room 156',
-            remarks: 'Discuss Sophia\'s progress in AP Calculus',
-            userId: teachers[1].id,
-            color: '#F59E0B',
+            title: "Genetics Problem Set",
+            instructions:
+                "Solve problems on pages 234-237. Show all work including Punnett squares and probability.",
+            dueDate: daysFromNow(1, now),
+            teacherId: teachers[0].id,
+            classId: biologyClass.id,
+            sectionId: bioSections[3].id,
+            type: AssignmentType.HOMEWORK,
+            maxGrade: 50,
+            weight: 1.0,
+            markSchemeId: bioMarkScheme.id,
+            acceptFiles: true,
+            acceptWorksheet: true,
+            attachments: ["Genetics Worksheet.pdf"],
         },
         {
-            name: 'Math Tutoring Session',
-            startTime: new Date('2025-10-07T15:45:00'),
-            endTime: new Date('2025-10-07T16:45:00'),
-            location: 'Room 156',
-            remarks: 'Extra help for struggling students',
-            userId: teachers[1].id,
-            color: '#10B981',
+            title: "Evolution Essay",
+            instructions:
+                "Write a 5-page essay on the evidence for evolution. Use at least 5 scientific sources and cite properly.",
+            dueDate: daysFromNow(30, now),
+            teacherId: teachers[0].id,
+            classId: biologyClass.id,
+            type: AssignmentType.ESSAY,
+            maxGrade: 100,
+            weight: 2.0,
+            markSchemeId: bioMarkScheme.id,
+            acceptFiles: true,
+            acceptExtendedResponse: true,
+            gradeWithAI: true,
+            attachments: ["Essay Guidelines.pdf"],
         },
-
-        // Tuesday Oct 8
         {
-            name: 'AP Calculus BC - Period 2',
-            startTime: new Date('2025-10-08T09:15:00'),
-            endTime: new Date('2025-10-08T10:05:00'),
-            location: 'Room 156',
-            remarks: 'Derivatives unit test',
-            userId: teachers[1].id,
+            title: "Limits and Continuity Test",
+            instructions: "Comprehensive test covering limits, continuity, and the Intermediate Value Theorem.",
+            dueDate: daysFromNow(-7, now),
+            teacherId: teachers[1].id,
             classId: mathClass.id,
-            color: '#3B82F6',
+            sectionId: mathSections[0].id,
+            type: AssignmentType.TEST,
+            maxGrade: 100,
+            weight: 2.5,
+            markSchemeId: mathMarkScheme.id,
+            gradingBoundaryId: mathGradingBoundary.id,
+            graded: true,
+            acceptFiles: true,
+            attachments: ["Practice Test.pdf", "Formula Sheet.pdf"],
         },
         {
-            name: 'Faculty Meeting',
-            startTime: new Date('2025-10-08T12:00:00'),
-            endTime: new Date('2025-10-08T13:00:00'),
-            location: 'Main Auditorium',
-            remarks: 'All-school faculty meeting',
-            userId: teachers[1].id,
-            color: '#6B7280',
+            title: "Limits Practice Problems",
+            instructions: "Complete problems 1-25 on page 89.",
+            dueDate: daysFromNow(-1, now),
+            teacherId: teachers[1].id,
+            classId: mathClass.id,
+            sectionId: mathSections[0].id,
+            type: AssignmentType.HOMEWORK,
+            maxGrade: 25,
+            weight: 1.0,
+            markSchemeId: mathMarkScheme.id,
+            gradingBoundaryId: mathGradingBoundary.id,
+            acceptWorksheet: true,
         },
         {
-            name: 'AP Statistics - Period 5',
-            startTime: new Date('2025-10-08T13:45:00'),
-            endTime: new Date('2025-10-08T14:35:00'),
-            location: 'Room 156',
-            remarks: 'Hypothesis testing practice problems',
-            userId: teachers[1].id,
-            color: '#3B82F6',
+            title: "Derivative Applications Quiz",
+            instructions: "Quiz covering related rates, optimization, and curve sketching.",
+            dueDate: daysFromNow(5, now),
+            teacherId: teachers[1].id,
+            classId: mathClass.id,
+            sectionId: mathSections[1].id,
+            type: AssignmentType.QUIZ,
+            maxGrade: 75,
+            weight: 1.5,
+            markSchemeId: mathMarkScheme.id,
+            gradingBoundaryId: mathGradingBoundary.id,
+            acceptWorksheet: true,
+            gradeWithAI: true,
         },
         {
-            name: 'Grade Level Team Meeting',
-            startTime: new Date('2025-10-08T15:00:00'),
-            endTime: new Date('2025-10-08T16:00:00'),
-            location: 'Room 201',
-            remarks: '11th grade team coordination',
-            userId: teachers[1].id,
-            color: '#8B5CF6',
+            title: "Integration Techniques Homework",
+            instructions: "Complete problems 1-30 on pages 156-158.",
+            dueDate: daysFromNow(3, now),
+            teacherId: teachers[1].id,
+            classId: mathClass.id,
+            sectionId: mathSections[2].id,
+            type: AssignmentType.HOMEWORK,
+            maxGrade: 30,
+            weight: 1.0,
+            markSchemeId: mathMarkScheme.id,
+            gradingBoundaryId: mathGradingBoundary.id,
+            acceptFiles: true,
         },
-
-        // Wednesday Oct 9
         {
-            name: 'AP Calculus BC - Period 2',
-            startTime: new Date('2025-10-09T09:15:00'),
-            endTime: new Date('2025-10-09T10:05:00'),
-            location: 'Room 156',
-            remarks: 'Integration introduction',
-            userId: teachers[1].id,
+            title: "Calculus Project: Real-World Applications",
+            instructions: "Choose a real-world scenario and create a presentation showing how calculus is used.",
+            dueDate: daysFromNow(21, now),
+            teacherId: teachers[1].id,
             classId: mathClass.id,
-            color: '#3B82F6',
+            type: AssignmentType.PROJECT,
+            maxGrade: 150,
+            weight: 3.0,
+            markSchemeId: mathMarkScheme.id,
+            gradingBoundaryId: mathGradingBoundary.id,
+            acceptFiles: true,
+            acceptExtendedResponse: true,
+            attachments: ["Project Rubric.pdf", "Past Examples.pdf"],
         },
         {
-            name: 'Professional Development',
-            startTime: new Date('2025-10-09T11:00:00'),
-            endTime: new Date('2025-10-09T12:30:00'),
-            location: 'Library Conference Room',
-            remarks: 'Technology in Mathematics Education workshop',
-            userId: teachers[1].id,
-            color: '#059669',
+            title: "Macbeth — Themes Essay",
+            instructions: "Choose a theme and trace its development across the play. 4-6 pages, MLA format.",
+            dueDate: daysFromNow(10, now),
+            teacherId: teachers[2].id,
+            classId: englishClass.id,
+            type: AssignmentType.ESSAY,
+            maxGrade: 100,
+            weight: 2.0,
+            acceptFiles: true,
+            acceptExtendedResponse: true,
+            gradeWithAI: true,
+            attachments: ["Macbeth Annotation Guide.pdf"],
         },
-        {
-            name: 'AP Statistics - Period 5',
-            startTime: new Date('2025-10-09T13:45:00'),
-            endTime: new Date('2025-10-09T14:35:00'),
-            location: 'Room 156',
-            remarks: 'Chi-square tests',
-            userId: teachers[1].id,
-            color: '#3B82F6',
+    ];
+
+    const assignments = await runInBatches(assignmentSpecs, (spec) =>
+        prisma.assignment.create({
+            data: {
+                title: spec.title,
+                instructions: spec.instructions,
+                dueDate: spec.dueDate,
+                teacherId: spec.teacherId,
+                classId: spec.classId,
+                sectionId: spec.sectionId,
+                type: spec.type,
+                maxGrade: spec.maxGrade,
+                weight: spec.weight,
+                markSchemeId: spec.markSchemeId,
+                gradingBoundaryId: spec.gradingBoundaryId,
+                graded: spec.graded ?? false,
+                acceptFiles: spec.acceptFiles ?? false,
+                acceptExtendedResponse: spec.acceptExtendedResponse ?? false,
+                acceptWorksheet: spec.acceptWorksheet ?? false,
+                gradeWithAI: spec.gradeWithAI ?? false,
+                aiPolicyLevel: spec.gradeWithAI ? 2 : 0,
+            },
+        })
+    );
+
+    // Now attach files to assignments (after the assignment IDs exist).
+    for (let i = 0; i < assignments.length; i++) {
+        const spec = assignmentSpecs[i];
+        if (!spec.attachments?.length) continue;
+        await Promise.all(
+            spec.attachments.map((name) =>
+                createFakeFile({
+                    name,
+                    userId: spec.teacherId,
+                    assignmentId: assignments[i].id,
+                })
+            )
+        );
+    }
+
+    // ---------------------------------------------------------------------
+    // 12. Worksheets — attach the worksheet-style assignments to a worksheet
+    // ---------------------------------------------------------------------
+    const geneticsAssignment = assignments[1];
+    const geneticsWorksheet = await prisma.worksheet.create({
+        data: {
+            classId: biologyClass.id,
+            name: "Genetics Problem Set",
+            status: JobStatus.COMPLETED,
+            assignments: { connect: { id: geneticsAssignment.id } },
         },
-        {
-            name: 'Student Council Advisory',
-            startTime: new Date('2025-10-09T15:00:00'),
-            endTime: new Date('2025-10-09T16:00:00'),
-            location: 'Room 105',
-            remarks: 'Advisor meeting for student council',
-            userId: teachers[1].id,
-            color: '#DC2626',
+    });
+
+    const geneticsQuestions = await runInBatches(
+        [
+            {
+                type: WorksheetQuestionType.MULTIPLE_CHOICE,
+                question: "A heterozygous tall pea plant (Tt) is crossed with a homozygous short pea plant (tt). What percentage of offspring will be tall?",
+                answer: "50%",
+                options: { choices: ["0%", "25%", "50%", "75%", "100%"] },
+                points: 5,
+                order: 1,
+            },
+            {
+                type: WorksheetQuestionType.SHORT_ANSWER,
+                question: "Define genotype and phenotype, and give an example of each.",
+                answer: "Genotype is the genetic makeup (e.g. Tt). Phenotype is the observable trait (e.g. tall).",
+                points: 10,
+                order: 2,
+            },
+            {
+                type: WorksheetQuestionType.TRUE_FALSE,
+                question: "A Punnett square predicts the probability of genotypes in offspring.",
+                answer: "true",
+                options: { choices: ["true", "false"] },
+                points: 5,
+                order: 3,
+            },
+            {
+                type: WorksheetQuestionType.LONG_ANSWER,
+                question: "Explain how independent assortment contributes to genetic variation.",
+                answer:
+                    "During meiosis, homologous chromosome pairs sort independently into gametes, producing many different combinations of alleles.",
+                points: 15,
+                order: 4,
+            },
+            {
+                type: WorksheetQuestionType.MATH_EXPRESSION,
+                question: "If two heterozygous parents (Aa x Aa) produce 100 offspring, how many are expected to be homozygous recessive?",
+                answer: "25",
+                points: 5,
+                order: 5,
+            },
+        ],
+        (q) =>
+            prisma.worksheetQuestion.create({
+                data: { worksheetId: geneticsWorksheet.id, ...q },
+            })
+    );
+
+    // A separate worksheet for the limits homework.
+    const limitsAssignment = assignments[4];
+    const limitsWorksheet = await prisma.worksheet.create({
+        data: {
+            classId: mathClass.id,
+            name: "Limits Practice",
+            status: JobStatus.COMPLETED,
+            assignments: { connect: { id: limitsAssignment.id } },
         },
+    });
 
-        // Thursday Oct 10
-        {
-            name: 'AP Calculus BC - Period 2',
-            startTime: new Date('2025-10-10T09:15:00'),
-            endTime: new Date('2025-10-10T10:05:00'),
-            location: 'Room 156',
-            remarks: 'Integration by substitution',
-            userId: teachers[1].id,
+    await runInBatches(
+        [
+            {
+                type: WorksheetQuestionType.MATH_EXPRESSION,
+                question: "Evaluate lim_{x→2} (x^2 - 4) / (x - 2).",
+                answer: "4",
+                points: 10,
+                order: 1,
+            },
+            {
+                type: WorksheetQuestionType.MATH_EXPRESSION,
+                question: "Evaluate lim_{x→0} sin(x) / x.",
+                answer: "1",
+                points: 10,
+                order: 2,
+            },
+            {
+                type: WorksheetQuestionType.SHORT_ANSWER,
+                question: "State the Intermediate Value Theorem.",
+                answer:
+                    "If f is continuous on [a, b] and N lies between f(a) and f(b), then there exists c in (a, b) with f(c) = N.",
+                points: 5,
+                order: 3,
+            },
+        ],
+        (q) =>
+            prisma.worksheetQuestion.create({
+                data: { worksheetId: limitsWorksheet.id, ...q },
+            })
+    );
+
+    // ---------------------------------------------------------------------
+    // 13. Submissions (+ attachments, worksheet responses, annotations)
+    // ---------------------------------------------------------------------
+    const generateGrade = (maxGrade: number, studentIndex: number, type: AssignmentType): number => {
+        const base = [0.92, 0.88, 0.85, 0.9, 0.82, 0.87, 0.91, 0.84, 0.89, 0.86, 0.83, 0.88];
+        let multiplier = base[studentIndex % base.length];
+        if (type === AssignmentType.TEST) multiplier -= 0.05;
+        if (type === AssignmentType.QUIZ) multiplier -= 0.02;
+        if (type === AssignmentType.HOMEWORK) multiplier += 0.03;
+        const variance = (Math.random() - 0.5) * 0.1;
+        return Math.max(0, Math.min(maxGrade, Math.round(maxGrade * (multiplier + variance))));
+    };
+
+    const teacherFeedback = (pct: number): string => {
+        if (pct >= 90) return pick([
+            "Excellent work! Your understanding of the concepts is clear.",
+            "Outstanding performance. Keep it up.",
+            "Impressive analysis and reasoning throughout.",
+        ]);
+        if (pct >= 80) return pick([
+            "Good work overall. A few small slips but nothing structural.",
+            "Solid understanding — watch calculation accuracy on tricky cases.",
+            "Nice job. Review the highlighted sections.",
+        ]);
+        if (pct >= 70) return pick([
+            "Adequate work — please revisit the concepts we covered in class.",
+            "Shows basic understanding but needs more practice.",
+            "Fair attempt. Come to office hours and we'll work through it.",
+        ]);
+        return pick([
+            "Below expectations. Let's schedule a meeting to talk through it.",
+            "Struggling with the key concepts — we'll get you there.",
+            "Needs significant improvement. Try the supplementary set.",
+        ]);
+    };
+
+    const studentsInBio = students.slice(0, 8);
+    const studentsInMath = students.slice(4, 12);
+    const studentsInEnglish = students.slice(0, 10);
+
+    const studentsForClass = (classId: string) => {
+        if (classId === biologyClass.id) return studentsInBio;
+        if (classId === mathClass.id) return studentsInMath;
+        return studentsInEnglish;
+    };
+
+    // Submissions: small batches + a tiny delay between them.
+    const submissionRecords: { id: string; assignmentId: string; studentId: string; submitted: boolean; isGraded: boolean }[] = [];
+
+    for (const assignment of assignments) {
+        const enrolled = studentsForClass(assignment.classId);
+        const max = assignment.maxGrade ?? 100;
+        const overdue = assignment.dueDate < now;
+
+        const created = await runInBatches(enrolled, (student) => {
+            const studentIndex = students.findIndex((s) => s.id === student.id);
+            const isSubmitted = overdue ? Math.random() > 0.05 : Math.random() > 0.4;
+            const isGraded = overdue && isSubmitted && (assignment.graded || Math.random() > 0.4);
+            const grade = generateGrade(max, studentIndex, assignment.type);
+            const submittedAt = isSubmitted
+                ? new Date(assignment.dueDate.getTime() - Math.random() * 48 * 60 * 60 * 1000)
+                : null;
+
+            return prisma.submission.create({
+                data: {
+                    assignmentId: assignment.id,
+                    studentId: student.id,
+                    submitted: isSubmitted,
+                    submittedAt,
+                    gradeReceived: isGraded ? grade : null,
+                    teacherComments: isGraded ? teacherFeedback((grade / max) * 100) : null,
+                    returned: isGraded,
+                    extendedResponse:
+                        assignment.acceptExtendedResponse && isSubmitted
+                            ? sampleExtendedResponse(assignment.title)
+                            : null,
+                    rubricState: isGraded
+                        ? JSON.stringify({
+                              criteria: [
+                                  { name: "Accuracy", score: Math.round(grade * 0.4), maxScore: Math.round(max * 0.4) },
+                                  { name: "Reasoning", score: Math.round(grade * 0.3), maxScore: Math.round(max * 0.3) },
+                                  { name: "Communication", score: Math.round(grade * 0.2), maxScore: Math.round(max * 0.2) },
+                                  { name: "Evidence", score: Math.round(grade * 0.1), maxScore: Math.round(max * 0.1) },
+                              ],
+                          })
+                        : null,
+                },
+            });
+        });
+
+        for (const sub of created) {
+            submissionRecords.push({
+                id: sub.id,
+                assignmentId: assignment.id,
+                studentId: sub.studentId,
+                submitted: sub.submitted ?? false,
+                isGraded: Boolean(sub.returned),
+            });
+        }
+    }
+    logger.info(`Created ${submissionRecords.length} submissions`);
+
+    // Attach a fake "submitted document" to submitted submissions, and a
+    // teacher "annotations" PDF on graded ones.
+    const submittedOnes = submissionRecords.filter((s) => s.submitted);
+    await runInBatches(submittedOnes, async (sub) => {
+        await createFakeFile({
+            name: pick(["Submission.pdf", "Final Draft.docx", "Worked Solutions.pdf", "Notes.png"]),
+            userId: sub.studentId,
+            submissionId: sub.id,
+        });
+        if (sub.isGraded && Math.random() > 0.4) {
+            await createFakeFile({
+                name: "Teacher Annotations.pdf",
+                userId: assignmentTeacherFor(sub.assignmentId, assignments),
+                annotationId: sub.id,
+            });
+        }
+    });
+
+    // Worksheet responses for the genetics worksheet (one per Bio student that
+    // submitted). Sequential to keep the pool happy.
+    for (const student of studentsInBio) {
+        const submission = submissionRecords.find(
+            (s) => s.assignmentId === geneticsAssignment.id && s.studentId === student.id
+        );
+        if (!submission?.submitted) continue;
+        const response = await prisma.studentWorksheetResponse.create({
+            data: {
+                studentId: student.id,
+                worksheetId: geneticsWorksheet.id,
+                submissionId: submission.id,
+                submitted: true,
+                submittedAt: new Date(now.getTime() - Math.random() * 24 * 60 * 60 * 1000),
+            },
+        });
+        await runInBatches(geneticsQuestions, (q) => {
+            const isCorrect = Math.random() > 0.25;
+            return prisma.studentQuestionProgress.create({
+                data: {
+                    studentId: student.id,
+                    questionId: q.id,
+                    studentWorksheetResponseId: response.id,
+                    response: isCorrect ? q.answer : "I'm not sure — guessing here.",
+                    isCorrect,
+                    points: isCorrect ? q.points : Math.floor(q.points / 2),
+                    feedback: isCorrect
+                        ? "Nice — correct reasoning."
+                        : "Re-read the section on Punnett squares and try again.",
+                    status: JobStatus.COMPLETED,
+                },
+            });
+        });
+    }
+
+    // ---------------------------------------------------------------------
+    // 14. Announcements + attachments + reactions + comments
+    // ---------------------------------------------------------------------
+    const bioAnnouncement = await prisma.announcement.create({
+        data: {
+            remarks:
+                "Reminder: lab safety quiz next Tuesday. Please review the protocols from Unit 2 — there'll be a short review at the start of class.",
+            teacherId: teachers[0].id,
+            classId: biologyClass.id,
+            createdAt: hoursFromNow(-24, now),
+        },
+    });
+    await createFakeFile({
+        name: "Lab Safety Protocols.pdf",
+        userId: teachers[0].id,
+        announcementId: bioAnnouncement.id,
+    });
+
+    const mathAnnouncement = await prisma.announcement.create({
+        data: {
+            remarks:
+                "Great job on the recent quiz, everyone! Class average was 87%. Solutions are attached. Office hours are Wednesday after school.",
+            teacherId: teachers[1].id,
             classId: mathClass.id,
-            color: '#3B82F6',
+            createdAt: hoursFromNow(-6, now),
         },
-        {
-            name: 'Curriculum Committee',
-            startTime: new Date('2025-10-10T11:00:00'),
-            endTime: new Date('2025-10-10T12:00:00'),
-            location: 'Principal\'s Office',
-            remarks: 'Review new AP curriculum standards',
-            userId: teachers[1].id,
-            color: '#8B5CF6',
+    });
+    await createFakeFile({
+        name: "Quiz Solutions.pdf",
+        userId: teachers[1].id,
+        announcementId: mathAnnouncement.id,
+    });
+
+    const englishAnnouncement = await prisma.announcement.create({
+        data: {
+            remarks:
+                "Parent-teacher conferences are next week. Sign-ups are in the main office. Bring questions about your Macbeth essay drafts.",
+            teacherId: teachers[2].id,
+            classId: englishClass.id,
+            createdAt: hoursFromNow(-12, now),
         },
-        {
-            name: 'AP Statistics - Period 5',
-            startTime: new Date('2025-10-10T13:45:00'),
-            endTime: new Date('2025-10-10T14:35:00'),
-            location: 'Room 156',
-            remarks: 'ANOVA introduction',
-            userId: teachers[1].id,
-            color: '#3B82F6',
+    });
+
+    // Reactions to announcements.
+    await prisma.reaction.createMany({
+        data: [
+            { type: ReactionType.THUMBSUP, userId: students[0].id, announcementId: bioAnnouncement.id },
+            { type: ReactionType.HEART, userId: students[1].id, announcementId: bioAnnouncement.id },
+            { type: ReactionType.CELEBRATE, userId: students[4].id, announcementId: mathAnnouncement.id },
+            { type: ReactionType.CELEBRATE, userId: students[5].id, announcementId: mathAnnouncement.id },
+            { type: ReactionType.HAPPY, userId: students[6].id, announcementId: mathAnnouncement.id },
+        ],
+    });
+
+    // A comment thread on the math announcement.
+    const topComment = await prisma.comment.create({
+        data: {
+            content: "Will the quiz solutions help with the upcoming test as well?",
+            authorId: students[4].id,
+            announcementId: mathAnnouncement.id,
         },
-        {
-            name: 'Parent Conference - Anderson Family',
-            startTime: new Date('2025-10-10T15:00:00'),
-            endTime: new Date('2025-10-10T15:30:00'),
-            location: 'Room 156',
-            remarks: 'Discuss Ethan\'s improvement strategies',
-            userId: teachers[1].id,
-            color: '#F59E0B',
+    });
+    const replyComment = await prisma.comment.create({
+        data: {
+            content: "Yes — the test reuses the same concepts. Use these to self-check first.",
+            authorId: teachers[1].id,
+            announcementId: mathAnnouncement.id,
+            parentCommentId: topComment.id,
         },
-        {
-            name: 'Math Club Meeting',
-            startTime: new Date('2025-10-10T15:45:00'),
-            endTime: new Date('2025-10-10T16:45:00'),
-            location: 'Room 156',
-            remarks: 'Preparing for state math competition',
-            userId: teachers[1].id,
-            color: '#10B981',
+    });
+    await prisma.reaction.create({
+        data: { type: ReactionType.THUMBSUP, userId: students[4].id, commentId: replyComment.id },
+    });
+
+    // A comment directly on an assignment (asking for clarification).
+    await prisma.comment.create({
+        data: {
+            content: "For question 4, are we expected to include a diagram or is text sufficient?",
+            authorId: students[1].id,
+            assignmentId: assignments[1].id, // Genetics Problem Set
         },
+    });
 
-        // Friday Oct 11
-        {
-            name: 'AP Calculus BC - Period 2',
-            startTime: new Date('2025-10-11T09:15:00'),
-            endTime: new Date('2025-10-11T10:05:00'),
-            location: 'Room 156',
-            remarks: 'Integration by parts',
-            userId: teachers[1].id,
+    // ---------------------------------------------------------------------
+    // 15. Discussions (with replies, tags, reads, reactions)
+    // ---------------------------------------------------------------------
+    const bioTag = await prisma.discussionTag.create({
+        data: { classId: biologyClass.id, name: "Lab", color: "#10B981" },
+    });
+    const bioTagHomework = await prisma.discussionTag.create({
+        data: { classId: biologyClass.id, name: "Homework Help", color: "#F59E0B" },
+    });
+    const mathTagAP = await prisma.discussionTag.create({
+        data: { classId: mathClass.id, name: "AP Prep", color: "#DC2626" },
+    });
+
+    const labQuestion = await prisma.discussion.create({
+        data: {
+            classId: biologyClass.id,
+            authorId: students[2].id,
+            title: "What stain works best for onion cells?",
+            body: "I tried iodine but the nuclei were hard to see. Anyone have better luck with methylene blue?",
+            type: DiscussionType.QUESTION,
+            tags: { connect: [{ id: bioTag.id }, { id: bioTagHomework.id }] },
+            lastActivityAt: hoursFromNow(-2, now),
+        },
+    });
+    await createFakeFile({
+        name: "onion-cells-iodine.jpg",
+        userId: students[2].id,
+        discussionId: labQuestion.id,
+    });
+
+    const reply1 = await prisma.discussionReply.create({
+        data: {
+            discussionId: labQuestion.id,
+            authorId: students[5].id,
+            body: "Methylene blue is way clearer for nuclei. We used it last week.",
+        },
+    });
+    const reply2 = await prisma.discussionReply.create({
+        data: {
+            discussionId: labQuestion.id,
+            authorId: teachers[0].id,
+            body: "Either works — focus on getting a thin sample. I'll bring more methylene blue tomorrow.",
+            isAcceptedAnswer: true,
+        },
+    });
+    await prisma.reaction.createMany({
+        data: [
+            { type: ReactionType.THUMBSUP, userId: students[2].id, discussionReplyId: reply2.id },
+            { type: ReactionType.IDEA, userId: students[1].id, discussionReplyId: reply1.id },
+        ],
+    });
+
+    const announcementDiscussion = await prisma.discussion.create({
+        data: {
             classId: mathClass.id,
-            color: '#3B82F6',
+            authorId: teachers[1].id,
+            title: "AP Calculus BC Mock Exam — Saturday 10am",
+            body: "Reminder: full-length mock exam this Saturday at 10am in Room 156. Bring two pencils and a calculator.",
+            type: DiscussionType.ANNOUNCEMENT,
+            isPinned: true,
+            tags: { connect: [{ id: mathTagAP.id }] },
+            lastActivityAt: hoursFromNow(-4, now),
         },
-        {
-            name: 'IEP Meeting - Student Support',
-            startTime: new Date('2025-10-11T10:30:00'),
-            endTime: new Date('2025-10-11T11:30:00'),
-            location: 'Special Services Office',
-            remarks: 'Individualized Education Plan review',
-            userId: teachers[1].id,
-            color: '#F59E0B',
+    });
+
+    const generalDiscussion = await prisma.discussion.create({
+        data: {
+            classId: mathClass.id,
+            authorId: students[8].id,
+            title: "Any tips for memorizing integration formulas?",
+            body: "Flashcards aren't sticking. Curious what's worked for everyone.",
+            type: DiscussionType.DISCUSSION,
+            lastActivityAt: hoursFromNow(-1, now),
         },
-        {
-            name: 'AP Statistics - Period 5',
-            startTime: new Date('2025-10-11T13:45:00'),
-            endTime: new Date('2025-10-11T14:35:00'),
-            location: 'Room 156',
-            remarks: 'ANOVA practice and review',
-            userId: teachers[1].id,
-            color: '#3B82F6',
+    });
+    const genReply = await prisma.discussionReply.create({
+        data: {
+            discussionId: generalDiscussion.id,
+            authorId: students[1].id,
+            body: "I rewrite the formulas every morning for a week. Sounds annoying but it works.",
         },
-        {
-            name: 'Weekend Prep Session',
-            startTime: new Date('2025-10-11T15:00:00'),
-            endTime: new Date('2025-10-11T17:00:00'),
-            location: 'Room 156',
-            remarks: 'Voluntary AP exam prep session',
-            userId: teachers[1].id,
-            color: '#059669',
+    });
+    await prisma.discussionReply.create({
+        data: {
+            discussionId: generalDiscussion.id,
+            authorId: students[10].id,
+            parentId: genReply.id,
+            body: "Going to try this — thanks!",
         },
+    });
 
-        // Some events for other teachers too
+    // A few discussion reads so unread counts look realistic.
+    await prisma.discussionRead.createMany({
+        data: [
+            { userId: students[0].id, discussionId: labQuestion.id, lastReadAt: hoursFromNow(-1, now) },
+            { userId: students[1].id, discussionId: labQuestion.id, lastReadAt: hoursFromNow(-3, now) },
+            { userId: teachers[0].id, discussionId: labQuestion.id, lastReadAt: now },
+            {
+                userId: students[4].id,
+                discussionId: announcementDiscussion.id,
+                lastReadAt: hoursFromNow(-2, now),
+            },
+        ],
+    });
+
+    // ---------------------------------------------------------------------
+    // 16. Events + attendance
+    // ---------------------------------------------------------------------
+    const teachingWeekStart = new Date("2026-10-12T08:00:00");
+    const eventsToCreate = buildWeeklyTeacherEvents(teachingWeekStart, teachers[1].id, mathClass.id);
+    eventsToCreate.push(
         {
-            name: 'Cell Biology Lab',
-            startTime: new Date(now.getTime() + 2 * 24 * 60 * 60 * 1000),
-            endTime: new Date(now.getTime() + 2 * 24 * 60 * 60 * 1000 + 90 * 60 * 1000), // 90 minutes
-            location: 'Science Lab Room 204',
-            remarks: 'Bring lab notebooks and safety goggles',
+            name: "Cell Biology Lab",
+            startTime: daysFromNow(2, now),
+            endTime: hoursFromNow(2 * 24 + 1.5, now),
+            location: "Science Lab Room 204",
+            remarks: "Bring lab notebooks and safety goggles",
             userId: teachers[0].id,
             classId: biologyClass.id,
-            color: '#10B981',
+            color: "#10B981",
         },
         {
-            name: 'Poetry Reading',
-            startTime: new Date(now.getTime() + 7 * 24 * 60 * 60 * 1000),
-            endTime: new Date(now.getTime() + 7 * 24 * 60 * 60 * 1000 + 60 * 60 * 1000),
-            location: 'Library',
-            remarks: 'Students will present their original poetry',
+            name: "Poetry Reading",
+            startTime: daysFromNow(7, now),
+            endTime: hoursFromNow(7 * 24 + 1, now),
+            location: "Library",
+            remarks: "Students will present their original poetry",
             userId: teachers[2].id,
             classId: englishClass.id,
-            color: '#8B5CF6',
-        },
-    ];
-
-    // Create events in batches to avoid connection pool exhaustion
-    const EVENT_BATCH_SIZE = 10;
-    
-    logger.info(`Creating ${eventsToCreate.length} events in batches of ${EVENT_BATCH_SIZE}`);
-    
-    for (let i = 0; i < eventsToCreate.length; i += EVENT_BATCH_SIZE) {
-        const batch = eventsToCreate.slice(i, i + EVENT_BATCH_SIZE);
-        await Promise.all(batch.map(event => 
-            prisma.event.create({ data: event })
-        ));
-        
-        // Small delay between batches
-        if (i + EVENT_BATCH_SIZE < eventsToCreate.length) {
-            await new Promise(resolve => setTimeout(resolve, 100));
+            color: "#8B5CF6",
         }
-    }
-    
-    logger.info(`Successfully created all ${eventsToCreate.length} events`);
+    );
 
-    // 13. Create attendance records
-    const attendanceDate = new Date(now.getTime() - 24 * 60 * 60 * 1000);
-    await Promise.all([
-        prisma.attendance.create({
-            data: {
-                date: attendanceDate,
-                classId: biologyClass.id,
-                present: { connect: students.slice(0, 6).map(s => ({ id: s.id })) },
-                late: { connect: [{ id: students[6].id }] },
-                absent: { connect: [{ id: students[7].id }] },
-            }
-        }),
-        prisma.attendance.create({
-            data: {
-                date: attendanceDate,
-                classId: mathClass.id,
-                present: { connect: students.slice(4, 11).map(s => ({ id: s.id })) },
-                late: { connect: [{ id: students[11].id }] },
-            }
-        }),
-    ]);
+    await runInBatches(eventsToCreate, (event) => prisma.event.create({ data: event }));
+    logger.info(`Created ${eventsToCreate.length} events`);
 
-    // 14. Create notifications for realistic teacher experience
-    await Promise.all([
-        // For main teacher (Sarah Johnson)
-        addNotification(teachers[0].id, 'New Submission', 'Alex Martinez submitted Genetics Problem Set'),
-        addNotification(teachers[0].id, 'Grade Reminder', 'You have 3 assignments pending grading'),
-        addNotification(teachers[0].id, 'Lab Equipment', 'Microscopes for tomorrow\'s lab are ready in Room 204'),
-        addNotification(teachers[0].id, 'Parent Contact', 'Mrs. Williams requested a meeting about Sophia\'s progress'),
-        
-        // For students
-        addNotification(students[0].id, 'Assignment Graded', 'Your Genetics Problem Set has been graded: 45/50'),
-        addNotification(students[1].id, 'Assignment Graded', 'Your Genetics Problem Set has been graded: 48/50'),
-        addNotification(students[2].id, 'Assignment Due', 'Cell Structure Lab Report is due in 3 days'),
-        addNotification(students[3].id, 'Class Announcement', 'New announcement in AP Biology'),
-    ]);
+    const attendanceDate = hoursFromNow(-24, now);
+    await prisma.attendance.create({
+        data: {
+            date: attendanceDate,
+            classId: biologyClass.id,
+            present: { connect: students.slice(0, 6).map((s) => ({ id: s.id })) },
+            late: { connect: [{ id: students[6].id }] },
+            absent: { connect: [{ id: students[7].id }] },
+        },
+    });
+    await prisma.attendance.create({
+        data: {
+            date: attendanceDate,
+            classId: mathClass.id,
+            present: { connect: students.slice(4, 11).map((s) => ({ id: s.id })) },
+            late: { connect: [{ id: students[11].id }] },
+        },
+    });
+    await prisma.attendance.create({
+        data: {
+            date: attendanceDate,
+            classId: englishClass.id,
+            present: { connect: students.slice(0, 9).map((s) => ({ id: s.id })) },
+            absent: { connect: [{ id: students[9].id }] },
+        },
+    });
 
-    // 15. Create some lab chats for AI demo
-    const labChatContext = JSON.stringify({
-        subject: 'Biology',
-        topic: 'Cell Structure and Function',
-        gradeLevel: '11th Grade AP',
-        difficulty: 'Advanced',
-        objectives: [
-            'Understand prokaryotic vs eukaryotic cell structures',
-            'Identify organelles and their functions',
-            'Compare plant and animal cells'
+    // ---------------------------------------------------------------------
+    // 17. Notifications
+    // ---------------------------------------------------------------------
+    await prisma.notification.createMany({
+        data: [
+            { receiverId: teachers[0].id, title: "New Submission", content: "Alex Martinez submitted Genetics Problem Set" },
+            { receiverId: teachers[0].id, title: "Grade Reminder", content: "You have 3 assignments pending grading" },
+            { receiverId: teachers[0].id, title: "Parent Contact", content: "Mrs. Williams requested a meeting about Sophia's progress" },
+            { receiverId: teachers[1].id, title: "AI Grading Ready", content: "Derivative Applications Quiz AI feedback is ready to review" },
+            { receiverId: teachers[1].id, title: "New Discussion Reply", content: "A student replied to 'Integration tips' in AP Calculus BC" },
+            { receiverId: students[0].id, title: "Assignment Graded", content: "Your Genetics Problem Set has been graded: 45/50" },
+            { receiverId: students[1].id, title: "Assignment Graded", content: "Your Genetics Problem Set has been graded: 48/50" },
+            { receiverId: students[2].id, title: "Assignment Due", content: "Cell Structure Lab Report is due in 3 days" },
+            { receiverId: students[3].id, title: "Class Announcement", content: "New announcement in AP Biology" },
+            { receiverId: students[4].id, title: "Worksheet Returned", content: "Mr. Chen returned your Limits Practice Worksheet" },
         ],
-        standards: ['NGSS HS-LS1-1', 'NGSS HS-LS1-2'],
-        duration: '2 weeks',
-        assessmentType: 'Lab report and quiz'
     });
 
-    // Create conversation for lab chat
+    // ---------------------------------------------------------------------
+    // 18. Conversations / Messages / Mentions / LabChat / NewtonChat
+    // ---------------------------------------------------------------------
     const labConversation = await prisma.conversation.create({
         data: {
-            type: 'GROUP',
-            name: 'Lab: Cell Structure Materials',
+            type: ConversationType.GROUP,
+            name: "Lab: Cell Structure Materials",
             displayInChat: false,
-        }
-    });
-
-    // Add teacher to conversation
-    await prisma.conversationMember.create({
-        data: {
-            userId: teachers[0].id,
-            conversationId: labConversation.id,
-            role: 'ADMIN',
-        }
+            members: {
+                create: [
+                    { userId: teachers[0].id, role: ConversationRole.ADMIN },
+                    { userId: aiUserId, role: ConversationRole.MEMBER },
+                ],
+            },
+        },
     });
 
-    // Create lab chat
     await prisma.labChat.create({
         data: {
-            title: 'Cell Structure Teaching Materials',
-            context: labChatContext,
+            title: "Cell Structure Teaching Materials",
             classId: biologyClass.id,
             conversationId: labConversation.id,
             createdById: teachers[0].id,
-        }
+            context: JSON.stringify({
+                subject: "Biology",
+                topic: "Cell Structure and Function",
+                gradeLevel: "11th Grade AP",
+                difficulty: "Advanced",
+                objectives: [
+                    "Understand prokaryotic vs eukaryotic cell structures",
+                    "Identify organelles and their functions",
+                    "Compare plant and animal cells",
+                ],
+                standards: ["NGSS HS-LS1-1", "NGSS HS-LS1-2"],
+                duration: "2 weeks",
+                assessmentType: "Lab report and quiz",
+            }),
+        },
     });
 
-    // 16. Create chat conversations and messages
-    // Teacher-to-teacher conversations
-    const teacherConversation1 = await prisma.conversation.create({
+    // A short Lab Chat exchange so the AI surface has content.
+    await prisma.message.create({
         data: {
-            type: 'GROUP',
-            name: 'Math Department Chat',
-            displayInChat: true,
-        }
+            content:
+                "Can you draft a 10-question multiple choice quiz on organelle functions for my AP Bio students?",
+            senderId: teachers[0].id,
+            conversationId: labConversation.id,
+            createdAt: hoursFromNow(-3, now),
+        },
+    });
+    await prisma.message.create({
+        data: {
+            content:
+                "Sure! Here are 10 AP-level MCQs on organelle functions, with explanations on each. Want me to also generate a 4-criterion rubric for grading short-answer follow-ups?",
+            senderId: aiUserId,
+            conversationId: labConversation.id,
+            createdAt: hoursFromNow(-2.95, now),
+            status: JobStatus.COMPLETED,
+        },
     });
 
-    // Add all teachers to department chat
-    await Promise.all([
-        prisma.conversationMember.create({
-            data: {
-                userId: teachers[0].id, // Sarah (Biology)
-                conversationId: teacherConversation1.id,
-                role: 'MEMBER',
-            }
-        }),
-        prisma.conversationMember.create({
-            data: {
-                userId: teachers[1].id, // Michael (Math)
-                conversationId: teacherConversation1.id,
-                role: 'ADMIN',
-            }
-        }),
-        prisma.conversationMember.create({
-            data: {
-                userId: teachers[2].id, // Emma (English)
-                conversationId: teacherConversation1.id,
-                role: 'MEMBER',
-            }
-        }),
-    ]);
-
-    // Teacher-student conversations
-    const studentConversation1 = await prisma.conversation.create({
+    // A teacher-to-teacher group chat.
+    const deptChat = await prisma.conversation.create({
         data: {
-            type: 'DM',
-            name: null,
+            type: ConversationType.GROUP,
+            name: "Faculty Lounge",
             displayInChat: true,
-        }
+            members: {
+                create: [
+                    { userId: teachers[0].id, role: ConversationRole.MEMBER },
+                    { userId: teachers[1].id, role: ConversationRole.ADMIN },
+                    { userId: teachers[2].id, role: ConversationRole.MEMBER },
+                    { userId: admin.id, role: ConversationRole.MEMBER },
+                ],
+            },
+        },
     });
 
-    await Promise.all([
-        prisma.conversationMember.create({
-            data: {
-                userId: teachers[1].id, // Michael Chen
-                conversationId: studentConversation1.id,
-                role: 'MEMBER',
-            }
-        }),
-        prisma.conversationMember.create({
-            data: {
-                userId: students[4].id, // Ethan Anderson
-                conversationId: studentConversation1.id,
-                role: 'MEMBER',
-            }
-        }),
-    ]);
+    // DMs.
+    const dmChenEthan = await prisma.conversation.create({
+        data: {
+            type: ConversationType.DM,
+            members: {
+                create: [
+                    { userId: teachers[1].id },
+                    { userId: students[4].id },
+                ],
+            },
+        },
+    });
 
-    const studentConversation2 = await prisma.conversation.create({
+    const dmChenSophia = await prisma.conversation.create({
         data: {
-            type: 'DM',
-            name: null,
-            displayInChat: true,
-        }
+            type: ConversationType.DM,
+            members: {
+                create: [
+                    { userId: teachers[1].id },
+                    { userId: students[1].id },
+                ],
+            },
+        },
     });
 
-    await Promise.all([
-        prisma.conversationMember.create({
-            data: {
-                userId: teachers[1].id, // Michael Chen
-                conversationId: studentConversation2.id,
-                role: 'MEMBER',
-            }
-        }),
-        prisma.conversationMember.create({
-            data: {
-                userId: students[1].id, // Sophia Williams
-                conversationId: studentConversation2.id,
-                role: 'MEMBER',
-            }
-        }),
-    ]);
+    type SeedMessage = {
+        content: string;
+        senderId: string;
+        conversationId: string;
+        createdAt: Date;
+        mentions?: string[];
+        attachmentNames?: string[];
+    };
 
-    // Create messages in conversations
-    const chatMessages = [
-        // Teacher department chat messages
+    const messages: SeedMessage[] = [
         {
-            content: 'Hey everyone! Hope you all had a great weekend. Quick reminder about the faculty meeting tomorrow at noon.',
+            content: "Quick reminder about the faculty meeting tomorrow at noon.",
             senderId: teachers[1].id,
-            conversationId: teacherConversation1.id,
-            createdAt: new Date('2024-10-07T07:30:00'),
+            conversationId: deptChat.id,
+            createdAt: new Date("2026-10-12T07:30:00"),
         },
         {
-            content: 'Thanks for the reminder, Michael! I\'ll be there. Are we discussing the new curriculum standards?',
+            content: "Thanks for the heads up. Are we discussing the new curriculum standards?",
             senderId: teachers[0].id,
-            conversationId: teacherConversation1.id,
-            createdAt: new Date('2024-10-07T07:45:00'),
+            conversationId: deptChat.id,
+            createdAt: new Date("2026-10-12T07:45:00"),
         },
         {
-            content: 'Yes, among other things. Also wanted to coordinate on the parent-teacher conferences next week.',
+            content:
+                "Yes, plus coordination for parent-teacher conferences. I'll bring the draft agenda.",
             senderId: teachers[1].id,
-            conversationId: teacherConversation1.id,
-            createdAt: new Date('2024-10-07T08:00:00'),
-        },
-        {
-            content: 'Perfect timing! I have several parents asking about their kids\' progress in my English classes.',
-            senderId: teachers[2].id,
-            conversationId: teacherConversation1.id,
-            createdAt: new Date('2024-10-07T08:15:00'),
-        },
-        {
-            content: 'The integration unit is going well in AP Calc. Students seem to be grasping the concepts better this year.',
-            senderId: teachers[1].id,
-            conversationId: teacherConversation1.id,
-            createdAt: new Date('2024-10-08T16:30:00'),
-        },
-        {
-            content: 'That\'s great to hear! I\'ve been incorporating more hands-on labs in biology and seeing similar improvements.',
-            senderId: teachers[0].id,
-            conversationId: teacherConversation1.id,
-            createdAt: new Date('2024-10-08T16:45:00'),
+            conversationId: deptChat.id,
+            createdAt: new Date("2026-10-12T08:00:00"),
+            attachmentNames: ["Draft Agenda.pdf"],
         },
         {
-            content: 'Anyone free for coffee after school tomorrow? Would love to chat about cross-curricular projects.',
+            content: "Perfect — several parents are already asking about progress in my classes.",
             senderId: teachers[2].id,
-            conversationId: teacherConversation1.id,
-            createdAt: new Date('2024-10-09T14:00:00'),
+            conversationId: deptChat.id,
+            createdAt: new Date("2026-10-12T08:15:00"),
         },
         {
-            content: 'I\'m in! Math Club ends at 4:45, so anytime after 5 works for me.',
+            content: "@sarah.johnson can you bring the Bio progress reports too?",
             senderId: teachers[1].id,
-            conversationId: teacherConversation1.id,
-            createdAt: new Date('2024-10-09T14:15:00'),
+            conversationId: deptChat.id,
+            createdAt: new Date("2026-10-12T08:20:00"),
+            mentions: [teachers[0].id],
         },
 
-        // Michael Chen with Ethan Anderson (struggling student)
+        // Ethan struggling student DM
         {
-            content: 'Hi Mr. Chen, I\'m really struggling with the integration problems from today\'s class. Could you help explain substitution method again?',
+            content:
+                "Hi Mr. Chen, I'm really struggling with the integration problems. Could you explain substitution again?",
             senderId: students[4].id,
-            conversationId: studentConversation1.id,
-            createdAt: new Date('2024-10-09T15:30:00'),
+            conversationId: dmChenEthan.id,
+            createdAt: new Date("2026-10-13T15:30:00"),
         },
         {
-            content: 'Of course, Ethan! I\'m glad you reached out. The key is identifying what to substitute. Can you tell me which problem you\'re stuck on specifically?',
+            content:
+                "Of course Ethan — glad you reached out. Which problem are you stuck on?",
             senderId: teachers[1].id,
-            conversationId: studentConversation1.id,
-            createdAt: new Date('2024-10-09T15:45:00'),
+            conversationId: dmChenEthan.id,
+            createdAt: new Date("2026-10-13T15:45:00"),
         },
         {
-            content: 'Problem #7 from the homework. I don\'t know how to choose what u should equal.',
+            content: "Problem #7 from the homework.",
             senderId: students[4].id,
-            conversationId: studentConversation1.id,
-            createdAt: new Date('2024-10-09T16:00:00'),
+            conversationId: dmChenEthan.id,
+            createdAt: new Date("2026-10-13T16:00:00"),
+            attachmentNames: ["IMG_4421.jpg"],
         },
         {
-            content: 'Great question! For u-substitution, look for a function whose derivative also appears in the integral. In #7, try setting u equal to the expression inside the parentheses. What do you get when you differentiate that?',
+            content:
+                "For u-sub, look for a function whose derivative also appears. Try u = the inside of the parentheses.",
             senderId: teachers[1].id,
-            conversationId: studentConversation1.id,
-            createdAt: new Date('2024-10-09T16:15:00'),
-        },
-        {
-            content: 'Oh! So u = 2x + 1, and du = 2dx? That means I need to adjust for the 2...',
-            senderId: students[4].id,
-            conversationId: studentConversation1.id,
-            createdAt: new Date('2024-10-09T17:00:00'),
-        },
-        {
-            content: 'Exactly! You\'ve got it. Remember to substitute back at the end. Feel free to come to tutoring tomorrow if you need more practice.',
-            senderId: teachers[1].id,
-            conversationId: studentConversation1.id,
-            createdAt: new Date('2024-10-09T17:15:00'),
-        },
-        {
-            content: 'Thank you so much! This makes way more sense now. I\'ll definitely come to tutoring.',
-            senderId: students[4].id,
-            conversationId: studentConversation1.id,
-            createdAt: new Date('2024-10-09T17:30:00'),
+            conversationId: dmChenEthan.id,
+            createdAt: new Date("2026-10-13T16:15:00"),
         },
 
-        // Michael Chen with Sophia Williams (high-achieving student)
-        {
-            content: 'Hi Mr. Chen! I finished the integration homework early. Are there any extra challenge problems I could work on?',
-            senderId: students[1].id,
-            conversationId: studentConversation2.id,
-            createdAt: new Date('2024-10-10T19:00:00'),
-        },
+        // Sophia gifted student DM
         {
-            content: 'Sophia, I love your enthusiasm! Try problems 45-50 from chapter 6. They involve integration by parts, which we\'ll cover next week.',
-            senderId: teachers[1].id,
-            conversationId: studentConversation2.id,
-            createdAt: new Date('2024-10-10T19:30:00'),
-        },
-        {
-            content: 'Perfect! I looked ahead in the textbook and the integration by parts formula looks interesting. Is it similar to the product rule for derivatives?',
+            content:
+                "Mr. Chen! I finished the integration homework — are there any extra challenge problems I could try?",
             senderId: students[1].id,
-            conversationId: studentConversation2.id,
-            createdAt: new Date('2024-10-10T20:00:00'),
+            conversationId: dmChenSophia.id,
+            createdAt: new Date("2026-10-13T19:00:00"),
         },
         {
-            content: 'You\'re absolutely right! Integration by parts is essentially the reverse of the product rule. You have a great mathematical intuition.',
+            content: "Try problems 45-50 from chapter 6 — they cover integration by parts.",
             senderId: teachers[1].id,
-            conversationId: studentConversation2.id,
-            createdAt: new Date('2024-10-10T20:15:00'),
+            conversationId: dmChenSophia.id,
+            createdAt: new Date("2026-10-13T19:30:00"),
+            attachmentNames: ["Chapter 6 Challenge.pdf"],
         },
         {
-            content: 'Also, I wanted to ask about the Math Club competition. What topics should I focus on for preparation?',
+            content: "Perfect, thanks! Integration by parts looks similar to the product rule for derivatives.",
             senderId: students[1].id,
-            conversationId: studentConversation2.id,
-            createdAt: new Date('2024-10-11T12:00:00'),
-        },
-        {
-            content: 'Great question! Focus on algebra, geometry, and basic calculus. I\'ll have practice problems ready for tomorrow\'s Math Club meeting.',
-            senderId: teachers[1].id,
-            conversationId: studentConversation2.id,
-            createdAt: new Date('2024-10-11T12:30:00'),
+            conversationId: dmChenSophia.id,
+            createdAt: new Date("2026-10-13T20:00:00"),
         },
     ];
 
-    // Create all messages in batches to avoid connection pool exhaustion
-    const MESSAGE_BATCH_SIZE = 10;
-    
-    logger.info(`Creating ${chatMessages.length} chat messages in batches of ${MESSAGE_BATCH_SIZE}`);
-    
-    for (let i = 0; i < chatMessages.length; i += MESSAGE_BATCH_SIZE) {
-        const batch = chatMessages.slice(i, i + MESSAGE_BATCH_SIZE);
-        await Promise.all(batch.map(message => 
-            prisma.message.create({ data: message })
-        ));
+    for (const msg of messages) {
+        const created = await prisma.message.create({
+            data: {
+                content: msg.content,
+                senderId: msg.senderId,
+                conversationId: msg.conversationId,
+                createdAt: msg.createdAt,
+            },
+        });
+        if (msg.mentions?.length) {
+            await prisma.mention.createMany({
+                data: msg.mentions.map((userId) => ({ messageId: created.id, userId })),
+            });
+        }
+        if (msg.attachmentNames?.length) {
+            await Promise.all(
+                msg.attachmentNames.map((name) =>
+                    createFakeFile({ name, userId: msg.senderId, messageId: created.id })
+                )
+            );
+        }
     }
-    
-    logger.info(`Successfully created all ${chatMessages.length} chat messages`);
 
-    // 16. Create file structure for classes
-    await Promise.all([
-        prisma.folder.create({
+    // Newton tutor chat tied to a submission.
+    const newtonSubmission = submissionRecords.find(
+        (s) => s.assignmentId === limitsAssignment.id && s.submitted
+    );
+    if (newtonSubmission) {
+        const newtonConv = await prisma.conversation.create({
             data: {
-                name: 'Class Files',
-                classId: biologyClass.id,
-                color: '#10B981',
-            }
-        }),
-        prisma.folder.create({
+                type: ConversationType.GROUP,
+                name: "Session with Newton Tutor",
+                displayInChat: true,
+                members: {
+                    create: [
+                        { userId: newtonSubmission.studentId, role: ConversationRole.MEMBER },
+                        { userId: aiUserId, role: ConversationRole.MEMBER },
+                    ],
+                },
+            },
+        });
+        await prisma.newtonChat.create({
             data: {
-                name: 'Class Files',
-                classId: mathClass.id,
-                color: '#3B82F6',
-            }
-        }),
-        prisma.folder.create({
+                submissionId: newtonSubmission.id,
+                conversationId: newtonConv.id,
+                title: "Limits Practice — Newton Tutor",
+            },
+        });
+        await prisma.message.create({
             data: {
-                name: 'Class Files',
-                classId: englishClass.id,
-                color: '#8B5CF6',
-            }
-        }),
-    ]);
+                content:
+                    "Hi! I'm Newton, your study buddy. I can see you're working on the Limits Practice worksheet. Want to go over Question 1?",
+                senderId: aiUserId,
+                conversationId: newtonConv.id,
+                createdAt: now,
+                status: JobStatus.COMPLETED,
+            },
+        });
+        await prisma.message.create({
+            data: {
+                content: "Yes please — I got stuck on the sin(x)/x limit.",
+                senderId: newtonSubmission.studentId,
+                conversationId: newtonConv.id,
+                createdAt: hoursFromNow(0.05, now),
+            },
+        });
+        await prisma.message.create({
+            data: {
+                content:
+                    "Great pick. Try thinking about what sin(x) looks like near 0 — what does its slope look like there? That's the key intuition behind lim_{x→0} sin(x)/x = 1.",
+                senderId: aiUserId,
+                conversationId: newtonConv.id,
+                createdAt: hoursFromNow(0.1, now),
+                status: JobStatus.COMPLETED,
+            },
+        });
+    }
 
-    logger.info('✅ Comprehensive demo database seeded successfully!');
-    logger.info('📚 Created:');
-    logger.info('  - 1 School (Riverside High School)');
-    logger.info('  - 3 Teachers with detailed profiles');
-    logger.info('  - 12 Students with profiles');
-    logger.info('  - 3 Classes (AP Biology, AP Calculus BC, English Literature)');
-    logger.info('  - 7 Course sections with color coding');
-    logger.info('  - 2 Mark schemes with detailed rubrics');
-    logger.info('  - 1 Grading boundary with weighted categories');
-    logger.info('  - 9 Assignments (6 for Calc BC demo class)');
-    logger.info('  - 64+ Student submissions with realistic grades & comments');
-    logger.info('  - 3 Announcements from different teachers');
-    logger.info('  - 3 Calendar events');
-    logger.info('  - Attendance records with present/late/absent tracking');
-    logger.info('  - 1 Lab chat for AI demo');
-    logger.info('  - Multiple realistic notifications');
-    logger.info('  - File organization structure');
-    logger.info('');
-    logger.info('🎯 AP Calculus BC Class (Demo Focus):');
-    logger.info('  - 6 assignments with varied due dates');
-    logger.info('  - Complete mark scheme & grading boundaries');
-    logger.info('  - All 8 students have submissions to all assignments');
-    logger.info('  - Realistic grade distribution & teacher feedback');
-    logger.info('  - Rubric-based grading with detailed breakdowns');
-    logger.info('');
-    logger.info('🎬 Demo accounts:');
-    logger.info('  Main Teacher: sarah.johnson@riverside.edu / demo123');
-    logger.info('  Math Teacher: michael.chen@riverside.edu / demo123');
-    logger.info('  English Teacher: emma.davis@riverside.edu / demo123');
-    logger.info('  Student: alex.martinez@student.riverside.edu / student123');
+    // ---------------------------------------------------------------------
+    // 19. Summary
+    // ---------------------------------------------------------------------
+    logger.info("Demo database seeded.");
+    logger.info(
+        `Created: 1 school, ${[admin, ...teachers].length} staff, ${students.length} students, ${classes.length} classes, ${assignments.length} assignments, ${submissionRecords.length} submissions.`
+    );
+    logger.info("Demo accounts:");
+    logger.info("  Admin:      admin@riverside.edu / admin123");
+    logger.info("  Bio:        sarah.johnson@riverside.edu / demo123");
+    logger.info("  Math:       michael.chen@riverside.edu / demo123");
+    logger.info("  English:    emma.davis@riverside.edu / demo123");
+    logger.info("  Student:    alex.martinez@student.riverside.edu / student123");
 };
 
-// Only run seedDatabase when executed directly (npm run seed)
-// Not when imported by other modules
-const isSeedScript = process.argv[1]?.includes('seedDatabase') || 
-                     process.argv.includes('seed');
+// -----------------------------------------------------------------------------
+// Local helpers (small enough to keep at the bottom)
+// -----------------------------------------------------------------------------
+
+function assignmentTeacherFor(assignmentId: string, assignments: { id: string; teacherId: string }[]): string {
+    return assignments.find((a) => a.id === assignmentId)?.teacherId ?? assignments[0].teacherId;
+}
+
+function sampleExtendedResponse(assignmentTitle: string): string {
+    return `Response for "${assignmentTitle}".\n\nThis essay addresses the prompt by walking through the key points covered in class, supported with examples and a short reflection on what surprised me. (Demo seed text — would be student-written in production.)`;
+}
+
+function buildWeeklyTeacherEvents(
+    weekStart: Date,
+    teacherId: string,
+    classId: string
+): {
+    name: string;
+    startTime: Date;
+    endTime: Date;
+    location: string;
+    remarks?: string;
+    userId: string;
+    classId?: string;
+    color: string;
+}[] {
+    const dayOffset = (n: number) => daysFromNow(n, weekStart);
+    const at = (offset: number, h: number, m: number) => {
+        const d = dayOffset(offset);
+        d.setHours(h, m, 0, 0);
+        return d;
+    };
+    return [
+        // Monday
+        { name: "AP Calculus BC", startTime: at(0, 9, 15), endTime: at(0, 10, 5), location: "Room 156", remarks: "Derivatives unit test review", userId: teacherId, classId, color: "#3B82F6" },
+        { name: "Department Head Meeting", startTime: at(0, 10, 30), endTime: at(0, 11, 30), location: "Conference Room A", remarks: "Curriculum planning", userId: teacherId, color: "#8B5CF6" },
+        { name: "AP Statistics", startTime: at(0, 13, 45), endTime: at(0, 14, 35), location: "Room 156", remarks: "Hypothesis testing introduction", userId: teacherId, color: "#3B82F6" },
+        { name: "Parent Conference — Williams Family", startTime: at(0, 15, 0), endTime: at(0, 15, 30), location: "Room 156", remarks: "Discuss Sophia's progress", userId: teacherId, color: "#F59E0B" },
+        { name: "Math Tutoring", startTime: at(0, 15, 45), endTime: at(0, 16, 45), location: "Room 156", remarks: "Extra help for struggling students", userId: teacherId, color: "#10B981" },
+        // Tuesday
+        { name: "AP Calculus BC", startTime: at(1, 9, 15), endTime: at(1, 10, 5), location: "Room 156", remarks: "Derivatives unit test", userId: teacherId, classId, color: "#3B82F6" },
+        { name: "Faculty Meeting", startTime: at(1, 12, 0), endTime: at(1, 13, 0), location: "Main Auditorium", userId: teacherId, color: "#6B7280" },
+        { name: "AP Statistics", startTime: at(1, 13, 45), endTime: at(1, 14, 35), location: "Room 156", remarks: "Hypothesis testing practice", userId: teacherId, color: "#3B82F6" },
+        // Wednesday
+        { name: "AP Calculus BC", startTime: at(2, 9, 15), endTime: at(2, 10, 5), location: "Room 156", remarks: "Integration introduction", userId: teacherId, classId, color: "#3B82F6" },
+        { name: "Professional Development", startTime: at(2, 11, 0), endTime: at(2, 12, 30), location: "Library Conference Room", remarks: "Tech in Math Education", userId: teacherId, color: "#059669" },
+        { name: "AP Statistics", startTime: at(2, 13, 45), endTime: at(2, 14, 35), location: "Room 156", remarks: "Chi-square tests", userId: teacherId, color: "#3B82F6" },
+        // Thursday
+        { name: "AP Calculus BC", startTime: at(3, 9, 15), endTime: at(3, 10, 5), location: "Room 156", remarks: "Integration by substitution", userId: teacherId, classId, color: "#3B82F6" },
+        { name: "Curriculum Committee", startTime: at(3, 11, 0), endTime: at(3, 12, 0), location: "Principal's Office", userId: teacherId, color: "#8B5CF6" },
+        { name: "AP Statistics", startTime: at(3, 13, 45), endTime: at(3, 14, 35), location: "Room 156", remarks: "ANOVA introduction", userId: teacherId, color: "#3B82F6" },
+        { name: "Math Club", startTime: at(3, 15, 45), endTime: at(3, 16, 45), location: "Room 156", remarks: "Prepping for state competition", userId: teacherId, color: "#10B981" },
+        // Friday
+        { name: "AP Calculus BC", startTime: at(4, 9, 15), endTime: at(4, 10, 5), location: "Room 156", remarks: "Integration by parts", userId: teacherId, classId, color: "#3B82F6" },
+        { name: "AP Statistics", startTime: at(4, 13, 45), endTime: at(4, 14, 35), location: "Room 156", remarks: "ANOVA practice", userId: teacherId, color: "#3B82F6" },
+        { name: "Weekend Prep Session", startTime: at(4, 15, 0), endTime: at(4, 17, 0), location: "Room 156", remarks: "Voluntary AP exam prep", userId: teacherId, color: "#059669" },
+    ];
+}
+
+// -----------------------------------------------------------------------------
+// Entry point
+// -----------------------------------------------------------------------------
+
+const isSeedScript =
+    process.argv[1]?.includes("seedDatabase") || process.argv.includes("seed");
 
 if (isSeedScript) {
-  (async () => {
-    logger.info('Seeding database');
-    await seedDatabase();
-    logger.info('Database seeded');
-  })();
-}
+    (async () => {
+        logger.info("Seeding database");
+        await seedDatabase();
+        logger.info("Database seeded");
+    })();
+}