@studious-lms/server 1.4.1 → 1.4.2

package/dist/services/section.d.ts

@@ -7,10 +7,10 @@ export declare function createSectionRecord(userId: string, input: {
     name: string;
     color?: string;
 }): Promise<{
-    id: string;
-    classId: string;
     name: string;
+    id: string;
     color: string | null;
+    classId: string;
     order: number | null;
 }>;
 export declare function reorderSection(userId: string, input: {
@@ -19,10 +19,10 @@ export declare function reorderSection(userId: string, input: {
     position: "start" | "end" | "before" | "after";
     targetId?: string;
 }): Promise<{
-    id: string;
-    classId: string;
     name: string;
+    id: string;
     color: string | null;
+    classId: string;
     order: number | null;
 } | null>;
 export declare function updateSectionRecord(userId: string, input: {
@@ -31,10 +31,10 @@ export declare function updateSectionRecord(userId: string, input: {
     name: string;
     color?: string;
 }): Promise<{
-    id: string;
-    classId: string;
     name: string;
+    id: string;
     color: string | null;
+    classId: string;
     order: number | null;
 }>;
 export declare function reOrderSection(userId: string, input: {

package/dist/services/studentProgress.d.ts

@@ -2,6 +2,7 @@ type ProgressChatMessage = {
     role: "user" | "assistant";
     content: string;
 };
+type RecommendationType = "missing" | "low_score" | "awaiting_feedback";
 export declare function getStudentProgressRecommendations(viewerId: string, classId: string, studentId: string): Promise<{
     student: {
         id: string;
@@ -21,6 +22,7 @@ export declare function getStudentProgressRecommendations(viewerId: string, clas
         submissionId: string;
         title: string;
         type: import(".prisma/client").$Enums.AssignmentType;
+        sectionId: string | null;
         sectionName: string | null;
         dueDate: Date;
         gradeReceived: number | null;
@@ -28,10 +30,83 @@ export declare function getStudentProgressRecommendations(viewerId: string, clas
         percentage: number | null;
         submitted: boolean;
         returned: boolean;
+        recommendationType: RecommendationType;
         reasons: string[];
+        suggestedAssignment: {
+            title: string;
+            instructions: string;
+            type: import(".prisma/client").$Enums.AssignmentType;
+            maxGrade: number;
+            weight: number;
+            graded: boolean;
+            sectionId: string | null;
+            sourceAssignmentId: string;
+        };
     }[];
     nextSteps: string[];
 }>;
+export declare function getClassProgressRecommendations(viewerId: string, classId: string): Promise<{
+    class: {
+        id: string;
+        name: string;
+        subject: string;
+    };
+    summary: {
+        studentsWithConcerns: number;
+        totalRecommendations: number;
+        totalMissingAssignments: number;
+        totalLowScoreAssignments: number;
+    };
+    students: {
+        student: {
+            id: string;
+            username: string;
+            displayName: string;
+        };
+        summary: {
+            overallGrade: number | null;
+            trend: number;
+            completedAssignments: number;
+            totalAssignments: number;
+            missingCount: number;
+            lowScoreCount: number;
+        };
+        recommendations: {
+            assignmentId: string;
+            submissionId: string;
+            title: string;
+            type: import(".prisma/client").$Enums.AssignmentType;
+            sectionId: string | null;
+            sectionName: string | null;
+            dueDate: Date;
+            gradeReceived: number | null;
+            maxGrade: number | null;
+            percentage: number | null;
+            submitted: boolean;
+            returned: boolean;
+            recommendationType: RecommendationType;
+            reasons: string[];
+            suggestedAssignment: {
+                title: string;
+                instructions: string;
+                type: import(".prisma/client").$Enums.AssignmentType;
+                maxGrade: number;
+                weight: number;
+                graded: boolean;
+                sectionId: string | null;
+                sourceAssignmentId: string;
+            };
+        }[];
+        nextSteps: string[];
+    }[];
+}>;
+export declare function dismissStudentRecommendation(viewerId: string, input: {
+    classId: string;
+    studentId: string;
+    submissionId: string;
+}): Promise<{
+    success: boolean;
+}>;
 export declare function chatAboutStudentProgress(viewerId: string, input: {
     classId: string;
     studentId: string;

package/dist/services/studentProgress.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"studentProgress.d.ts","sourceRoot":"/","sources":["services/studentProgress.ts"],"names":[],"mappings":"AAUA,KAAK,mBAAmB,GAAG;IACzB,IAAI,EAAE,MAAM,GAAG,WAAW,CAAC;IAC3B,OAAO,EAAE,MAAM,CAAC;CACjB,CAAC;AA2IF,wBAAsB,iCAAiC,CACrD,QAAQ,EAAE,MAAM,EAChB,OAAO,EAAE,MAAM,EACf,SAAS,EAAE,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAoHlB;AAgBD,wBAAsB,wBAAwB,CAC5C,QAAQ,EAAE,MAAM,EAChB,KAAK,EAAE;IACL,OAAO,EAAE,MAAM,CAAC;IAChB,SAAS,EAAE,MAAM,CAAC;IAClB,OAAO,EAAE,MAAM,CAAC;IAChB,OAAO,CAAC,EAAE,mBAAmB,EAAE,CAAC;CACjC;;;GA+FF"}
+{"version":3,"file":"studentProgress.d.ts","sourceRoot":"/","sources":["services/studentProgress.ts"],"names":[],"mappings":"AAUA,KAAK,mBAAmB,GAAG;IACzB,IAAI,EAAE,MAAM,GAAG,WAAW,CAAC;IAC3B,OAAO,EAAE,MAAM,CAAC;CACjB,CAAC;AA2BF,KAAK,kBAAkB,GACnB,SAAS,GACT,WAAW,GACX,mBAAmB,CAAC;AAyXxB,wBAAsB,iCAAiC,CACrD,QAAQ,EAAE,MAAM,EAChB,OAAO,EAAE,MAAM,EACf,SAAS,EAAE,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiBlB;AAED,wBAAsB,+BAA+B,CACnD,QAAQ,EAAE,MAAM,EAChB,OAAO,EAAE,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAwFhB;AAED,wBAAsB,4BAA4B,CAChD,QAAQ,EAAE,MAAM,EAChB,KAAK,EAAE;IACL,OAAO,EAAE,MAAM,CAAC;IAChB,SAAS,EAAE,MAAM,CAAC;IAClB,YAAY,EAAE,MAAM,CAAC;CACtB;;GAqCF;AAgBD,wBAAsB,wBAAwB,CAC5C,QAAQ,EAAE,MAAM,EAChB,KAAK,EAAE;IACL,OAAO,EAAE,MAAM,CAAC;IAChB,SAAS,EAAE,MAAM,CAAC;IAClB,OAAO,EAAE,MAAM,CAAC;IAChB,OAAO,CAAC,EAAE,mBAAmB,EAAE,CAAC;CACjC;;;GA0FF"}

package/dist/services/studentProgress.js

@@ -2,15 +2,16 @@
  * Student progress service - assignment recommendations and progress chat.
  */
 
-!function(){try{var e="undefined"!=typeof window?window:"undefined"!=typeof global?global:"undefined"!=typeof globalThis?globalThis:"undefined"!=typeof self?self:{},n=(new e.Error).stack;n&&(e._sentryDebugIds=e._sentryDebugIds||{},e._sentryDebugIds[n]="e4b426af-1ccd-5152-a996-9a03a09b6503")}catch(e){}}();
+!function(){try{var e="undefined"!=typeof window?window:"undefined"!=typeof global?global:"undefined"!=typeof globalThis?globalThis:"undefined"!=typeof self?self:{},n=(new e.Error).stack;n&&(e._sentryDebugIds=e._sentryDebugIds||{},e._sentryDebugIds[n]="a4f18375-dd27-5f8f-befa-f7b494a8bb88")}catch(e){}}();
 import { TRPCError } from "@trpc/server";
 import { prisma } from "../lib/prisma.js";
+import { isTeacherInClass } from "../models/class.js";
 import { inference } from "../utils/inference.js";
 import { logger } from "../utils/logger.js";
-import { isTeacherInClass } from "../models/class.js";
 function calculatePercentage(submission) {
-    if (submission.gradeReceived == null || !submission.assignment.maxGrade)
+    if (submission.gradeReceived == null || !submission.assignment.maxGrade) {
         return null;
+    }
     return (Math.round((submission.gradeReceived / submission.assignment.maxGrade) * 1000) / 10);
 }
 function calculateTrend(submissions) {
@@ -48,6 +49,183 @@ function getOverallGrade(submissions) {
         ? Math.round((totalWeighted / totalWeight) * 1000) / 10
         : null;
 }
+function normalizeAssignmentType(assignmentType) {
+    if (assignmentType === "TEST" || assignmentType === "QUIZ") {
+        return "HOMEWORK";
+    }
+    return assignmentType;
+}
+function buildSuggestedAssignment(recommendationType, submission, displayName, percentage) {
+    const sourceTitle = submission.assignment.title;
+    const section = submission.assignment.section?.name;
+    const titleByType = {
+        missing: `Make-up: ${sourceTitle}`,
+        low_score: `Targeted practice: ${sourceTitle}`,
+        awaiting_feedback: `Revision follow-up: ${sourceTitle}`,
+    };
+    const leadByType = {
+        missing: `${displayName} missed the original assignment and needs a focused make-up task on the same material.`,
+        low_score: percentage != null
+            ? `${displayName} scored ${percentage}% and needs targeted reinforcement on the underlying concepts.`
+            : `${displayName} needs targeted reinforcement on the underlying concepts.`,
+        awaiting_feedback: `${displayName} has work in progress here, so a short follow-up can keep momentum once feedback lands.`,
+    };
+    return {
+        title: titleByType[recommendationType],
+        instructions: [
+            leadByType[recommendationType],
+            `Source assignment: ${sourceTitle}.`,
+            section ? `Section: ${section}.` : null,
+            "Keep the work concise and focused on the specific area of concern.",
+        ]
+            .filter((line) => Boolean(line))
+            .join("\n\n"),
+        type: normalizeAssignmentType(submission.assignment.type),
+        maxGrade: submission.assignment.maxGrade ?? 100,
+        weight: submission.assignment.weight || 1,
+        graded: true,
+        sectionId: submission.assignment.section?.id ?? null,
+        sourceAssignmentId: submission.assignment.id,
+    };
+}
+function buildRecommendationCandidate(submission, displayName, now) {
+    if (submission.recommendationState === "ASSIGNED" ||
+        submission.recommendationState === "DISMISSED") {
+        return null;
+    }
+    const percentage = calculatePercentage(submission);
+    const isMissing = !submission.submitted &&
+        submission.assignment.dueDate.getTime() < now.getTime();
+    const isLowScore = percentage != null && percentage < 70;
+    const isUnreturned = Boolean(submission.submitted) &&
+        submission.gradeReceived == null &&
+        !submission.returned;
+    const reasons = [];
+    let priorityScore = 0;
+    let recommendationType = null;
+    if (isMissing) {
+        reasons.push("Missing past-due work");
+        priorityScore += 100;
+        recommendationType = "missing";
+    }
+    if (isLowScore) {
+        reasons.push(`Scored ${percentage}%`);
+        priorityScore += 85 - (percentage ?? 0);
+        recommendationType ?? (recommendationType = "low_score");
+    }
+    if (isUnreturned) {
+        reasons.push("Awaiting grade or feedback");
+        priorityScore += 15;
+        recommendationType ?? (recommendationType = "awaiting_feedback");
+    }
+    if (priorityScore <= 0 || !recommendationType) {
+        return null;
+    }
+    return {
+        assignmentId: submission.assignment.id,
+        submissionId: submission.id,
+        title: submission.assignment.title,
+        type: submission.assignment.type,
+        sectionId: submission.assignment.section?.id ?? null,
+        sectionName: submission.assignment.section?.name ?? null,
+        dueDate: submission.assignment.dueDate,
+        gradeReceived: submission.gradeReceived,
+        maxGrade: submission.assignment.maxGrade,
+        percentage,
+        submitted: Boolean(submission.submitted),
+        returned: Boolean(submission.returned),
+        recommendationType,
+        reasons,
+        priorityScore,
+        suggestedAssignment: buildSuggestedAssignment(recommendationType, submission, displayName, percentage),
+    };
+}
+function summarizeStudentRecommendations(student, submissions) {
+    const now = new Date();
+    const displayName = student.profile?.displayName ?? student.username;
+    const recommendationCandidates = submissions
+        .map((submission) => buildRecommendationCandidate(submission, displayName, now))
+        .filter((candidate) => candidate != null)
+        .sort((a, b) => b.priorityScore - a.priorityScore);
+    const recommendations = recommendationCandidates
+        .slice(0, 5)
+        .map(({ priorityScore, ...candidate }) => candidate);
+    const gradedPercentages = submissions
+        .map(calculatePercentage)
+        .filter((value) => value != null);
+    const lowScoreCount = gradedPercentages.filter((percentage) => percentage < 70).length;
+    const missingCount = submissions.filter((submission) => !submission.submitted &&
+        submission.assignment.dueDate.getTime() < now.getTime()).length;
+    const trend = calculateTrend(submissions);
+    const overallGrade = getOverallGrade(submissions);
+    const nextSteps = [
+        missingCount > 0
+            ? `Prioritize ${missingCount} missing assignment${missingCount === 1 ? "" : "s"}.`
+            : null,
+        lowScoreCount > 0
+            ? `Review ${lowScoreCount} low-scoring assignment${lowScoreCount === 1 ? "" : "s"} before introducing new material.`
+            : null,
+        trend < -5
+            ? "Schedule a check-in because recent performance is trending down."
+            : null,
+        recommendationCandidates.length === 0
+            ? "No urgent assignment issues detected from the available grades."
+            : null,
+    ].filter((step) => Boolean(step));
+    return {
+        student: {
+            id: student.id,
+            username: student.username,
+            displayName,
+        },
+        summary: {
+            overallGrade,
+            trend,
+            completedAssignments: submissions.filter((submission) => Boolean(submission.submitted)).length,
+            totalAssignments: submissions.length,
+            missingCount,
+            lowScoreCount,
+        },
+        recommendations,
+        recommendationCandidates,
+        nextSteps,
+        priorityScore: recommendationCandidates[0]?.priorityScore ?? 0,
+    };
+}
+async function syncRecommendationStates(submissions, recommendationCandidates) {
+    const candidateSubmissionIds = new Set(recommendationCandidates.map((candidate) => candidate.submissionId));
+    const updates = [];
+    for (const submission of submissions) {
+        const shouldBeOpen = candidateSubmissionIds.has(submission.id);
+        if (shouldBeOpen && submission.recommendationState === "NONE") {
+            updates.push(prisma.submission.update({
+                where: { id: submission.id },
+                data: {
+                    recommendationState: "OPEN",
+                    recommendationUpdatedAt: new Date(),
+                },
+            }));
+            continue;
+        }
+        if (!shouldBeOpen && submission.recommendationState === "OPEN") {
+            updates.push(prisma.submission.update({
+                where: { id: submission.id },
+                data: {
+                    recommendationState: "NONE",
+                    recommendationUpdatedAt: new Date(),
+                },
+            }));
+        }
+    }
+    if (updates.length) {
+        await Promise.all(updates);
+    }
+}
+async function summarizeStudentRecommendationsWithCases(student, submissions) {
+    const summary = summarizeStudentRecommendations(student, submissions);
+    await syncRecommendationStates(submissions, summary.recommendationCandidates);
+    return summary;
+}
 async function loadStudentProgressContext(viewerId, classId, studentId) {
     const isTeacher = await isTeacherInClass(classId, viewerId);
     if (viewerId !== studentId && !isTeacher) {
@@ -106,98 +284,116 @@ async function loadStudentProgressContext(viewerId, classId, studentId) {
 }
 export async function getStudentProgressRecommendations(viewerId, classId, studentId) {
     const { student, submissions } = await loadStudentProgressContext(viewerId, classId, studentId);
-    const now = new Date();
-    const recommendationCandidates = submissions
-        .map((submission) => {
-        const percentage = calculatePercentage(submission);
-        const isMissing = !submission.submitted &&
-            submission.assignment.dueDate.getTime() < now.getTime();
-        const isLowScore = percentage != null && percentage < 70;
-        const isUnreturned = Boolean(submission.submitted) &&
-            submission.gradeReceived == null &&
-            !submission.returned;
-        const isUpcoming = !Boolean(submission.submitted) &&
-            !submission.submittedAt &&
-            !submission.returned &&
-            submission.gradeReceived == null &&
-            submission.assignment.dueDate.getTime() >= now.getTime();
-        const reasons = [];
-        let priorityScore = 0;
-        if (isMissing) {
-            reasons.push("Missing past-due work");
-            priorityScore += 100;
-        }
-        if (isLowScore) {
-            reasons.push(`Scored ${percentage}%`);
-            priorityScore += 85 - (percentage ?? 0);
-        }
-        if (isUnreturned) {
-            reasons.push("Awaiting grade or feedback");
-            priorityScore += 15;
-        }
-        if (isUpcoming) {
-            reasons.push("Upcoming graded assignment");
-            priorityScore += 5;
-        }
-        return {
-            assignmentId: submission.assignment.id,
-            submissionId: submission.id,
-            title: submission.assignment.title,
-            type: submission.assignment.type,
-            sectionName: submission.assignment.section?.name ?? null,
-            dueDate: submission.assignment.dueDate,
-            gradeReceived: submission.gradeReceived,
-            maxGrade: submission.assignment.maxGrade,
-            percentage,
-            submitted: Boolean(submission.submitted),
-            returned: Boolean(submission.returned),
-            reasons,
-            priorityScore,
-        };
-    })
-        .filter((candidate) => candidate.priorityScore > 0)
-        .sort((a, b) => b.priorityScore - a.priorityScore)
-        .slice(0, 5);
-    const gradedPercentages = submissions
-        .map(calculatePercentage)
-        .filter((value) => value != null);
-    const lowScoreCount = gradedPercentages.filter((percentage) => percentage < 70).length;
-    const missingCount = submissions.filter((submission) => !submission.submitted &&
-        submission.assignment.dueDate.getTime() < now.getTime()).length;
-    const trend = calculateTrend(submissions);
-    const overallGrade = getOverallGrade(submissions);
-    const nextSteps = [
-        missingCount > 0
-            ? `Prioritize ${missingCount} missing assignment${missingCount === 1 ? "" : "s"}.`
-            : null,
-        lowScoreCount > 0
-            ? `Review ${lowScoreCount} low-scoring assignment${lowScoreCount === 1 ? "" : "s"} before introducing new material.`
-            : null,
-        trend < -5
-            ? "Schedule a check-in because recent performance is trending down."
-            : null,
-        recommendationCandidates.length === 0
-            ? "No urgent assignment issues detected from the available grades."
-            : null,
-    ].filter((step) => Boolean(step));
+    const summary = await summarizeStudentRecommendationsWithCases(student, submissions);
+    const { recommendationCandidates: _recommendationCandidates, ...summaryResponse } = summary;
     return {
-        student: {
-            id: student.id,
-            username: student.username,
-            displayName: student.profile?.displayName ?? student.username,
+        student: summaryResponse.student,
+        summary: summaryResponse.summary,
+        recommendations: summaryResponse.recommendations,
+        nextSteps: summaryResponse.nextSteps,
+    };
+}
+export async function getClassProgressRecommendations(viewerId, classId) {
+    const teacherInClass = await isTeacherInClass(classId, viewerId);
+    if (!teacherInClass) {
+        throw new TRPCError({
+            code: "UNAUTHORIZED",
+            message: "Only teachers can view class-wide recommendations",
+        });
+    }
+    const classData = await prisma.class.findUnique({
+        where: { id: classId },
+        select: {
+            id: true,
+            name: true,
+            subject: true,
+            students: {
+                select: {
+                    id: true,
+                    username: true,
+                    profile: { select: { displayName: true } },
+                    submissions: {
+                        where: {
+                            assignment: { classId, graded: true },
+                        },
+                        include: {
+                            assignment: {
+                                select: {
+                                    id: true,
+                                    title: true,
+                                    dueDate: true,
+                                    maxGrade: true,
+                                    weight: true,
+                                    type: true,
+                                    section: { select: { id: true, name: true } },
+                                },
+                            },
+                        },
+                        orderBy: { assignment: { dueDate: "asc" } },
+                    },
+                },
+            },
+        },
+    });
+    if (!classData) {
+        throw new TRPCError({ code: "NOT_FOUND", message: "Class not found" });
+    }
+    const students = (await Promise.all(classData.students.map((student) => summarizeStudentRecommendationsWithCases(student, student.submissions))))
+        .map(({ recommendationCandidates: _recommendationCandidates, ...student }) => student)
+        .filter((student) => student.recommendations.length > 0)
+        .sort((a, b) => b.priorityScore - a.priorityScore);
+    const totalRecommendations = students.reduce((sum, student) => sum + student.recommendations.length, 0);
+    const studentsWithConcerns = students.length;
+    const totalMissingAssignments = students.reduce((sum, student) => sum + student.summary.missingCount, 0);
+    const totalLowScoreAssignments = students.reduce((sum, student) => sum + student.summary.lowScoreCount, 0);
+    return {
+        class: {
+            id: classData.id,
+            name: classData.name,
+            subject: classData.subject,
         },
         summary: {
-            overallGrade,
-            trend,
-            completedAssignments: submissions.filter((submission) => Boolean(submission.submitted)).length,
-            totalAssignments: submissions.length,
-            missingCount,
-            lowScoreCount,
+            studentsWithConcerns,
+            totalRecommendations,
+            totalMissingAssignments,
+            totalLowScoreAssignments,
         },
-        recommendations: recommendationCandidates.map(({ priorityScore, ...candidate }) => candidate),
-        nextSteps,
+        students: students.map(({ priorityScore, ...student }) => student),
     };
 }
+export async function dismissStudentRecommendation(viewerId, input) {
+    const teacherInClass = await isTeacherInClass(input.classId, viewerId);
+    if (!teacherInClass) {
+        throw new TRPCError({
+            code: "UNAUTHORIZED",
+            message: "Only teachers can dismiss recommendations",
+        });
+    }
+    const submission = await prisma.submission.findFirst({
+        where: {
+            id: input.submissionId,
+            studentId: input.studentId,
+            assignment: {
+                classId: input.classId,
+            },
+        },
+        select: { id: true },
+    });
+    if (!submission) {
+        throw new TRPCError({
+            code: "NOT_FOUND",
+            message: "Submission not found for this student in this class",
+        });
+    }
+    await prisma.submission.update({
+        where: { id: input.submissionId },
+        data: {
+            recommendationState: "DISMISSED",
+            recommendationUpdatedAt: new Date(),
+        },
+    });
+    return { success: true };
+}
 function buildProgressSummary(submissions) {
     return submissions.map((submission) => ({
         title: submission.assignment.title,
@@ -260,32 +456,26 @@ export async function chatAboutStudentProgress(viewerId, input) {
         const awaitingFeedback = summary.assignments.filter((assignment) => assignment.submitted &&
             assignment.gradeReceived == null &&
             !assignment.returned).length;
-        const trendLabel = summary.overallGrade == null
-            ? "not enough graded work to determine a recent trend"
-            : summary.trend > 5
-                ? "improving"
-                : summary.trend < -5
-                    ? "declining"
-                    : "stable";
-        const advice = [
+        const fallbackParts = [
+            `${displayName}'s current overall grade is ${overall}.`,
             missingItems > 0
-                ? `Review ${missingItems} missing assignment${missingItems === 1 ? "" : "s"}.`
+                ? `${missingItems} assignment${missingItems === 1 ? "" : "s"} ${missingItems === 1 ? "appears" : "appear"} overdue.`
                 : null,
             lowScores > 0
-                ? `Use targeted practice for ${lowScores} low-scoring assignment${lowScores === 1 ? "" : "s"}.`
+                ? `${lowScores} graded assignment${lowScores === 1 ? " is" : "s are"} below 70%.`
                 : null,
             awaitingFeedback > 0
-                ? `Check back after feedback is returned for ${awaitingFeedback} submitted assignment${awaitingFeedback === 1 ? "" : "s"}.`
-                : null,
-            missingItems === 0 && lowScores === 0 && awaitingFeedback === 0
-                ? "Check upcoming work and ask for feedback as new grades are returned."
+                ? `${awaitingFeedback} assignment${awaitingFeedback === 1 ? " is" : "s are"} still awaiting feedback.`
                 : null,
-        ].filter((item) => Boolean(item));
+            summary.trend < -5
+                ? "Recent performance is trending down, so a check-in would be reasonable."
+                : "Performance looks relatively steady from the available data.",
+        ].filter((part) => Boolean(part));
         return {
-            message: `${displayName}'s current overall progress is ${overall}, with ${trendLabel}. ${advice.join(" ")}`,
+            message: fallbackParts.join(" "),
             isFallback: true,
         };
     }
 }
 //# sourceMappingURL=studentProgress.js.map
-//# debugId=e4b426af-1ccd-5152-a996-9a03a09b6503
+//# debugId=a4f18375-dd27-5f8f-befa-f7b494a8bb88