@edpire/sdk 0.7.0 → 0.8.1

package/dist/core.d.mts

@@ -1,4 +1,5 @@
 import { RuntimeAnswer } from '@youssefalmia/edpire-runtime';
+import { RichContent } from '@youssefalmia/edpire-schema/authoring';
 
 /** Flat per-question answer collected during a custom player session. */
 interface StoredAnswer {
@@ -44,6 +45,195 @@ declare function buildSubmitPayload(stored: StoredAnswer[]): {
     }>;
 };
 
+/**
+ * Public types for the polished Assessment Shell.
+ *
+ * The shell renders the same UI used at edpire.com's hosted player.
+ * Consumers using the EdpireAssessment.mount() API get these types
+ * indirectly via MountOptions; consumers rendering <AssessmentShell>
+ * directly import them from "@edpire/sdk/react".
+ */
+
+/** Branding payload accepted by AssessmentShell. Mirrors what edpire.com sends. */
+interface TakeBranding {
+    /** Org display name — shown as the alt text on the logo. */
+    name: string;
+    /** Logo URL (any https URL). When absent, the Edpire logo is shown. */
+    logoUrl: string | null;
+    branding: {
+        /** CSS color for the primary action buttons (Submit, View Report, etc.). */
+        primaryColor?: string;
+        /** CSS color used as the background of the top bar and per-exercise headers. */
+        accentColor?: string;
+        /** font-family applied to the shell. Pair with `fontUrl` for non-system fonts. */
+        fontFamily?: string;
+        /** A Google Fonts stylesheet URL; the shell injects a <link> tag at mount. */
+        fontUrl?: string;
+        /** When false, the "Powered by Edpire" watermark is hidden. Default true. */
+        showPoweredBy?: boolean;
+    } | null;
+}
+
+/**
+ * Public types for the Edpire Embeddable JS SDK.
+ */
+
+type NodeFeedbackStatus = "correct" | "partial" | "incorrect" | "awaiting_review";
+interface EmbedResult {
+    submission_id: string;
+    score: number;
+    max_score: number;
+    percentage: number;
+    passed: boolean;
+    passing_score_percent: number;
+    attempt_number: number;
+    /** True when the submission contains open-response nodes still pending teacher review. */
+    awaiting_manual_grading?: boolean;
+    /** True when an AI-marked answer has no mark yet: it is being marked, not scored 0. */
+    ai_pending?: boolean;
+    exercise_results: Array<{
+        exercise_id: string;
+        total_score: number;
+        max_score: number;
+        question_results: Array<{
+            question_id: string;
+            score: number;
+            correct: boolean;
+            points: number;
+        }>;
+    }>;
+    exercise_feedback: Array<{
+        exercise_id: string;
+        questions: Array<{
+            question_id: string;
+            node_results: Array<{
+                node_id: string;
+                status: NodeFeedbackStatus;
+                score: number;
+                max_score: number;
+                feedback?: string;
+                display_answer?: string;
+                detail?: {
+                    type: "choiceSet";
+                    correctChoiceIds: string[];
+                } | {
+                    type: "matchingSet";
+                    pairFeedback: Array<{
+                        leftId: string;
+                        rightId: string;
+                        correct: boolean;
+                    }>;
+                    correctPairings: Array<{
+                        leftId: string;
+                        rightId: string;
+                    }>;
+                };
+                /**
+                 * The teacher's written feedback on an open response. Only ever present
+                 * in a review (`GET /submissions/{id}/review`), since at submit time no
+                 * teacher has graded anything yet.
+                 */
+                teacher_feedback?: RichContent[];
+            }>;
+        }>;
+    }>;
+}
+/**
+ * Response of `GET /api/v1/submissions/{id}/review`: one finished attempt, with
+ * everything needed to draw it as the corrected paper. Fetch it on your server
+ * (it needs an API key with `read:results`), send it to the browser, and pass it
+ * to `EdpireAssessment.review()` unchanged.
+ */
+interface SubmissionReview {
+    submission: {
+        id: string;
+        assessment_id: string;
+        learner_ref: string | null;
+        status: string;
+        attempt_number: number;
+        /** How many attempts this learner has made at this assessment, this one included. */
+        total_attempts: number;
+        score: number;
+        max_score: number;
+        percentage: number;
+        passed: boolean;
+        passing_score_percent: number;
+        is_fully_graded: boolean;
+        /**
+         * True while a teacher still has open responses to grade. `score`,
+         * `percentage` and `passed` are provisional until it turns false, and the
+         * player hides them.
+         */
+        awaiting_manual_grading: boolean;
+        /** True while an AI-marked answer has no mark yet. Optional: older servers did not send it. */
+        ai_pending?: boolean;
+        submitted_at: string | null;
+    };
+    assessment: AssessmentLoaderResponse["assessment"];
+    meta: Omit<AssessmentLoaderResponse["meta"], "type">;
+    branding?: TakeBranding | null;
+    /** The learner's answers, in the shape the player collected them. */
+    answers: {
+        exerciseAnswers: Array<{
+            exerciseId: string;
+            questionAnswers: Array<{
+                questionId: string;
+                answers: RuntimeAnswer[];
+            }>;
+        }>;
+    };
+    exercise_feedback: EmbedResult["exercise_feedback"];
+}
+interface AssessmentLoaderResponse {
+    assessment: {
+        /**
+         * Assessment-level annex — reading texts, figures, formula sheets. The
+         * player shows it as a side panel on wide screens and a drawer on narrow
+         * ones. Null when the assessment has none.
+         */
+        annex?: unknown | null;
+        exercises: Array<{
+            id: string;
+            sharedContext: unknown | null;
+            questions: Array<{
+                id: string;
+                version: "1.0";
+                content: unknown;
+                /** Sent by the content loader, not by a review. Nothing in the player reads either. */
+                points?: number;
+                sequenceNumber?: number;
+                answerKeys: never[];
+            }>;
+        }>;
+    };
+    meta: {
+        id: string;
+        title: string;
+        type: string;
+        category?: string | null;
+        /**
+         * The assessment's learner-facing language, which also decides text
+         * direction. The player uses this unless the host passes `locale`
+         * explicitly, so a French assessment reads left-to-right even when embedded
+         * in a right-to-left product.
+         */
+        language?: "en" | "fr" | "ar";
+        settings: {
+            time_limit_minutes: number | null;
+            passing_score_percent: number;
+            allowed_attempts: number;
+            show_solutions: string;
+        };
+    };
+    attempt_info: {
+        attempt_number: number;
+        can_retry: boolean;
+        attempts_remaining: number | null;
+    };
+    /** Org branding loaded server-side. May be overridden by MountOptions.branding. */
+    branding?: TakeBranding | null;
+}
+
 /**
  * @edpire/sdk/client — Server-side API client for Edpire.
  *
@@ -146,6 +336,71 @@ interface FlatStep {
  */
 declare function flattenAssessment(assessment: Assessment): FlatStep[];
 
+/**
+ * flattenReview: a finished attempt as a linear sequence of steps, one per
+ * question, each ready to hand to `renderQuestion()` read-only.
+ *
+ * The review counterpart of `flattenAssessment()`. Where the full paper
+ * (`EdpireAssessment.review()`) draws the whole attempt at once, this is for
+ * flows that show one question per screen, Arcade-style, and want the learner
+ * to page back through a past attempt the same way they took it.
+ *
+ * @example
+ * const review = await fetch(`/api/attempts/${id}/review`).then((r) => r.json())
+ * const steps = flattenReview(review)
+ *
+ * const q = renderQuestion({
+ *   container: "#question",
+ *   content: steps[i].content,
+ *   initialAnswers: steps[i].answers,
+ *   feedback: steps[i].feedback,
+ *   readOnly: true,
+ * })
+ * // steps[i].status, steps[i].score / steps[i].maxScore for your own chrome
+ *
+ * Pure: no React, no DOM. Also exported from `@edpire/sdk/core`.
+ */
+
+interface ReviewStep {
+    exerciseId: string;
+    questionId: string;
+    /** ContentAST. Pass to renderQuestion's `content`. */
+    content: unknown;
+    /**
+     * The exercise's shared context (reading passage, figure, worked example),
+     * or null. Unlike `flattenAssessment()`, carried on every step: a
+     * comprehension question reviewed without its passage makes no sense.
+     * Render it with renderQuestion too; it is plain content.
+     */
+    sharedContext: unknown | null;
+    /** What the learner answered. Pass to renderQuestion's `initialAnswers`. */
+    answers: RuntimeAnswer[];
+    /**
+     * The marking, in the same shape POST /check returns, so it goes straight
+     * into renderQuestion's `feedback`. Includes the expected answer on anything
+     * missed and the teacher's comment on an open response.
+     */
+    feedback: Record<string, unknown>;
+    score: number;
+    maxScore: number;
+    /**
+     * The question as a whole. `awaiting_review` while a teacher has yet to mark
+     * any part of it; its score is then provisional. `unscored` when it is worth
+     * nothing (no answerable input, or 0 points): there was nothing to get
+     * wrong, so do not show it as wrong.
+     */
+    status: "correct" | "partial" | "incorrect" | "awaiting_review" | "unscored";
+    /** 0-based position, in the order the assessment presents questions. */
+    index: number;
+}
+/**
+ * The order is the assessment's (exercises, then questions within each), not
+ * the order a shuffled Arcade attempt happened to show. Edpire does not record
+ * the order an attempt was presented in; store it yourself if you need to
+ * replay it exactly.
+ */
+declare function flattenReview(review: SubmissionReview): ReviewStep[];
+
 /**
  * "Did the learner actually answer this?"
  *
@@ -180,4 +435,4 @@ declare function isAnswered(answer: RuntimeAnswer): boolean;
  */
 declare function countAnswerableNodes(content: unknown): number;
 
-export { type FlatStep, type StoredAnswer, buildSubmitPayload, countAnswerableNodes, flattenAssessment, isAnswered };
+export { type FlatStep, type ReviewStep, type StoredAnswer, type SubmissionReview, buildSubmitPayload, countAnswerableNodes, flattenAssessment, flattenReview, isAnswered };

package/dist/core.mjs

@@ -1 +1 @@
-function c(e){let n=[],t=0;for(let s of e.exercises)for(let r of s.questions)n.push({exerciseId:s.id,questionId:r.id,content:r.content_ast,points:r.points,sequenceNumber:r.sequence_number,index:t++});return n}function u(e){let n=new Map;for(let t of e)n.has(t.exerciseId)||n.set(t.exerciseId,[]),n.get(t.exerciseId).push({questionId:t.questionId,answers:t.answers});return{exerciseAnswers:Array.from(n.entries()).map(([t,s])=>({exerciseId:t,questionAnswers:s}))}}var a=new Set(["choiceSet","inlineChoiceSet","blank","aiAnswerInput","matchingSet","openResponseNode","mathResponse","codingResponse"]),f=new Set(["blankPool","inlinePool"]);function d(e){switch(e.type){case"choiceSet":case"inlineChoiceSet":return e.answer.selectedIds.length>0;case"blank":return e.answer.mode==="choice"?e.answer.choiceId.length>0:e.answer.text.trim().length>0;case"matchingSet":return e.answer.connections.length>0;case"aiAnswer":return e.answer.text.trim().length>0;case"openResponse":{let n=e.answer;return n.recording||n.files&&n.files.length>0?!0:(n.text?.wordCount??0)>0}case"mathResponse":return e.answer.latex.trim().length>0;case"codingResponse":return e.answer.source.trim().length>0;default:{let n=e;return!0}}}function m(e){let n=0,t=s=>{if(Array.isArray(s)){for(let i of s)t(i);return}if(!s||typeof s!="object")return;let{type:r,content:o}=s;if(typeof r=="string"){if(a.has(r)){n+=1;return}if(f.has(r))return}o!==void 0&&t(o)};return t(e),n}export{u as buildSubmitPayload,m as countAnswerableNodes,c as flattenAssessment,d as isAnswered};
+function x(t){let n=[],s=0;for(let e of t.exercises)for(let i of e.questions)n.push({exerciseId:e.id,questionId:i.id,content:i.content_ast,points:i.points,sequenceNumber:i.sequence_number,index:s++});return n}function l(t){let n=new Map;for(let s of t){let e=new Map;for(let i of s.questions){let o=new Map;for(let r of i.nodeResults){let a={state:r.status,showFeedback:!0,score:r.score,...r.feedback!==void 0?{message:r.feedback}:{},...r.displayAnswer!==void 0?{displayAnswer:r.displayAnswer}:{},...r.teacherFeedback!==void 0?{teacherFeedback:r.teacherFeedback}:{}};r.detail?.type==="choiceSet"?a.correctChoiceIds=r.detail.correctChoiceIds:r.detail?.type==="matchingSet"&&(a.pairFeedback=r.detail.pairFeedback,a.correctPairings=r.detail.correctPairings),o.set(r.nodeId,a)}e.set(i.questionId,o)}n.set(s.exerciseId,e)}return n}function m(t){return(t??[]).map(n=>({exerciseId:n.exercise_id,questions:n.questions.map(s=>({questionId:s.question_id,nodeResults:s.node_results.map(e=>({nodeId:e.node_id,status:e.status,score:e.score,maxScore:e.max_score,...e.feedback!==void 0?{feedback:e.feedback}:{},...e.display_answer!==void 0?{displayAnswer:e.display_answer}:{},...e.detail!==void 0?{detail:e.detail}:{},...e.teacher_feedback!==void 0?{teacherFeedback:e.teacher_feedback}:{}}))}))}))}function b(t){let n=l(m(t.exercise_feedback)),s=new Map;for(let o of t.answers.exerciseAnswers)for(let r of o.questionAnswers)s.set(r.questionId,r.answers);let e=[],i=0;for(let o of t.assessment.exercises){let r=n.get(o.id);for(let a of o.questions){let p=r?.get(a.id),w=t.exercise_feedback.find(c=>c.exercise_id===o.id)?.questions.find(c=>c.question_id===a.id)?.node_results??[],d=0,u=0,f=!1;for(let c of w)d+=c.score,u+=c.max_score,c.status==="awaiting_review"&&(f=!0);e.push({exerciseId:o.id,questionId:a.id,content:a.content,sharedContext:o.sharedContext??null,answers:s.get(a.id)??[],feedback:p?Object.fromEntries(p):{},score:d,maxScore:u,status:f?"awaiting_review":u===0?"unscored":d>=u?"correct":d>0?"partial":"incorrect",index:i++})}}return e}function g(t){let n=new Map;for(let s of t)n.has(s.exerciseId)||n.set(s.exerciseId,[]),n.get(s.exerciseId).push({questionId:s.questionId,answers:s.answers});return{exerciseAnswers:Array.from(n.entries()).map(([s,e])=>({exerciseId:s,questionAnswers:e}))}}var h=new Set(["choiceSet","inlineChoiceSet","blank","aiAnswerInput","matchingSet","openResponseNode","mathResponse","codingResponse"]),k=new Set(["blankPool","inlinePool"]);function y(t){switch(t.type){case"choiceSet":case"inlineChoiceSet":return t.answer.selectedIds.length>0;case"blank":return t.answer.mode==="choice"?t.answer.choiceId.length>0:t.answer.text.trim().length>0;case"matchingSet":return t.answer.connections.length>0;case"aiAnswer":return t.answer.text.trim().length>0;case"openResponse":{let n=t.answer;return n.recording||n.files&&n.files.length>0?!0:(n.text?.wordCount??0)>0}case"mathResponse":return t.answer.latex.trim().length>0;case"codingResponse":return t.answer.source.trim().length>0;default:{let n=t;return!0}}}function A(t){let n=0,s=e=>{if(Array.isArray(e)){for(let r of e)s(r);return}if(!e||typeof e!="object")return;let{type:i,content:o}=e;if(typeof i=="string"){if(h.has(i)){n+=1;return}if(k.has(i))return}o!==void 0&&s(o)};return s(t),n}export{g as buildSubmitPayload,A as countAnswerableNodes,x as flattenAssessment,b as flattenReview,y as isAnswered};

package/dist/index.d.mts

@@ -96,6 +96,12 @@ interface SubmitResult {
     exerciseFeedback: ExerciseFeedbackData[];
     /** When true, score banners hide the score (still being reviewed). */
     awaitingManualGrading?: boolean;
+    /**
+     * When true, an AI-marked answer has no mark yet (it did not come back in
+     * time). The banner then says the answers are still being marked, rather
+     * than that a teacher is reviewing open responses.
+     */
+    aiPending?: boolean;
 }
 
 type SpinnerTheme = "default" | "dots" | "pulse" | "bars";
@@ -139,6 +145,8 @@ interface EmbedResult {
     attempt_number: number;
     /** True when the submission contains open-response nodes still pending teacher review. */
     awaiting_manual_grading?: boolean;
+    /** True when an AI-marked answer has no mark yet: it is being marked, not scored 0. */
+    ai_pending?: boolean;
     exercise_results: Array<{
         exercise_id: string;
         total_score: number;
@@ -176,6 +184,12 @@ interface EmbedResult {
                         rightId: string;
                     }>;
                 };
+                /**
+                 * The teacher's written feedback on an open response. Only ever present
+                 * in a review (`GET /submissions/{id}/review`), since at submit time no
+                 * teacher has graded anything yet.
+                 */
+                teacher_feedback?: RichContent[];
             }>;
         }>;
     }>;
@@ -252,6 +266,68 @@ interface EmbedInstance {
     /** Unmounts the assessment player and cleans up event listeners. */
     unmount: () => void;
 }
+/**
+ * Response of `GET /api/v1/submissions/{id}/review`: one finished attempt, with
+ * everything needed to draw it as the corrected paper. Fetch it on your server
+ * (it needs an API key with `read:results`), send it to the browser, and pass it
+ * to `EdpireAssessment.review()` unchanged.
+ */
+interface SubmissionReview {
+    submission: {
+        id: string;
+        assessment_id: string;
+        learner_ref: string | null;
+        status: string;
+        attempt_number: number;
+        /** How many attempts this learner has made at this assessment, this one included. */
+        total_attempts: number;
+        score: number;
+        max_score: number;
+        percentage: number;
+        passed: boolean;
+        passing_score_percent: number;
+        is_fully_graded: boolean;
+        /**
+         * True while a teacher still has open responses to grade. `score`,
+         * `percentage` and `passed` are provisional until it turns false, and the
+         * player hides them.
+         */
+        awaiting_manual_grading: boolean;
+        /** True while an AI-marked answer has no mark yet. Optional: older servers did not send it. */
+        ai_pending?: boolean;
+        submitted_at: string | null;
+    };
+    assessment: AssessmentLoaderResponse["assessment"];
+    meta: Omit<AssessmentLoaderResponse["meta"], "type">;
+    branding?: TakeBranding | null;
+    /** The learner's answers, in the shape the player collected them. */
+    answers: {
+        exerciseAnswers: Array<{
+            exerciseId: string;
+            questionAnswers: Array<{
+                questionId: string;
+                answers: RuntimeAnswer[];
+            }>;
+        }>;
+    };
+    exercise_feedback: EmbedResult["exercise_feedback"];
+}
+interface ReviewOptions {
+    /** The response of `GET /api/v1/submissions/{id}/review`, passed through untouched. */
+    review: SubmissionReview;
+    /** Where to mount the corrected paper. CSS selector string or DOM element. */
+    container: string | HTMLElement;
+    /** Player UI language. Defaults to the assessment's own language. */
+    locale?: ShellLocale;
+    /** Branding overrides. Defaults to the org branding carried in the review. */
+    branding?: TakeBranding;
+    /** Geometry of the question column. Same as `MountOptions.layout`. */
+    layout?: ShellLayout;
+    /** Shows a back button in the top bar and calls this when it is clicked. */
+    onBack?: () => void;
+    /** Custom label for the back button. */
+    backLabel?: string;
+}
 interface RenderQuestionOptions {
     /**
      * DOM element or CSS selector string to mount into.
@@ -273,6 +349,11 @@ interface RenderQuestionOptions {
      * Pre-fill answers.
      */
     initialAnswers?: RuntimeAnswer[];
+    /**
+     * Lock the question: answers show but cannot be changed. Since 0.8.0. For
+     * reviewing a past attempt one question at a time; see `flattenReview()`.
+     */
+    readOnly?: boolean;
     /**
      * Text direction for the question container.
      */
@@ -298,6 +379,55 @@ interface QuestionInstance {
      */
     unmount(): void;
 }
+interface AssessmentLoaderResponse {
+    assessment: {
+        /**
+         * Assessment-level annex — reading texts, figures, formula sheets. The
+         * player shows it as a side panel on wide screens and a drawer on narrow
+         * ones. Null when the assessment has none.
+         */
+        annex?: unknown | null;
+        exercises: Array<{
+            id: string;
+            sharedContext: unknown | null;
+            questions: Array<{
+                id: string;
+                version: "1.0";
+                content: unknown;
+                /** Sent by the content loader, not by a review. Nothing in the player reads either. */
+                points?: number;
+                sequenceNumber?: number;
+                answerKeys: never[];
+            }>;
+        }>;
+    };
+    meta: {
+        id: string;
+        title: string;
+        type: string;
+        category?: string | null;
+        /**
+         * The assessment's learner-facing language, which also decides text
+         * direction. The player uses this unless the host passes `locale`
+         * explicitly, so a French assessment reads left-to-right even when embedded
+         * in a right-to-left product.
+         */
+        language?: "en" | "fr" | "ar";
+        settings: {
+            time_limit_minutes: number | null;
+            passing_score_percent: number;
+            allowed_attempts: number;
+            show_solutions: string;
+        };
+    };
+    attempt_info: {
+        attempt_number: number;
+        can_retry: boolean;
+        attempts_remaining: number | null;
+    };
+    /** Org branding loaded server-side. May be overridden by MountOptions.branding. */
+    branding?: TakeBranding | null;
+}
 
 /** Flat per-question answer collected during a custom player session. */
 interface StoredAnswer {
@@ -447,6 +577,71 @@ declare function flattenAssessment(assessment: Assessment): FlatStep[];
 
 declare function renderQuestion(options: RenderQuestionOptions): QuestionInstance;
 
+/**
+ * flattenReview: a finished attempt as a linear sequence of steps, one per
+ * question, each ready to hand to `renderQuestion()` read-only.
+ *
+ * The review counterpart of `flattenAssessment()`. Where the full paper
+ * (`EdpireAssessment.review()`) draws the whole attempt at once, this is for
+ * flows that show one question per screen, Arcade-style, and want the learner
+ * to page back through a past attempt the same way they took it.
+ *
+ * @example
+ * const review = await fetch(`/api/attempts/${id}/review`).then((r) => r.json())
+ * const steps = flattenReview(review)
+ *
+ * const q = renderQuestion({
+ *   container: "#question",
+ *   content: steps[i].content,
+ *   initialAnswers: steps[i].answers,
+ *   feedback: steps[i].feedback,
+ *   readOnly: true,
+ * })
+ * // steps[i].status, steps[i].score / steps[i].maxScore for your own chrome
+ *
+ * Pure: no React, no DOM. Also exported from `@edpire/sdk/core`.
+ */
+
+interface ReviewStep {
+    exerciseId: string;
+    questionId: string;
+    /** ContentAST. Pass to renderQuestion's `content`. */
+    content: unknown;
+    /**
+     * The exercise's shared context (reading passage, figure, worked example),
+     * or null. Unlike `flattenAssessment()`, carried on every step: a
+     * comprehension question reviewed without its passage makes no sense.
+     * Render it with renderQuestion too; it is plain content.
+     */
+    sharedContext: unknown | null;
+    /** What the learner answered. Pass to renderQuestion's `initialAnswers`. */
+    answers: RuntimeAnswer[];
+    /**
+     * The marking, in the same shape POST /check returns, so it goes straight
+     * into renderQuestion's `feedback`. Includes the expected answer on anything
+     * missed and the teacher's comment on an open response.
+     */
+    feedback: Record<string, unknown>;
+    score: number;
+    maxScore: number;
+    /**
+     * The question as a whole. `awaiting_review` while a teacher has yet to mark
+     * any part of it; its score is then provisional. `unscored` when it is worth
+     * nothing (no answerable input, or 0 points): there was nothing to get
+     * wrong, so do not show it as wrong.
+     */
+    status: "correct" | "partial" | "incorrect" | "awaiting_review" | "unscored";
+    /** 0-based position, in the order the assessment presents questions. */
+    index: number;
+}
+/**
+ * The order is the assessment's (exercises, then questions within each), not
+ * the order a shuffled Arcade attempt happened to show. Edpire does not record
+ * the order an attempt was presented in; store it yourself if you need to
+ * replay it exactly.
+ */
+declare function flattenReview(review: SubmissionReview): ReviewStep[];
+
 declare const EdpireAssessment: {
     /**
      * Mount an Edpire assessment into the given container.
@@ -463,6 +658,21 @@ declare const EdpireAssessment: {
      * })
      */
     mount(options: MountOptions): EmbedInstance;
+    /**
+     * Render a finished attempt as the corrected paper: the learner's answers,
+     * locked, with every mark, expected answer and teacher comment.
+     *
+     * Pass the response of `GET /api/v1/submissions/{id}/review` unchanged. Your
+     * server fetches it with an API key, after checking the attempt belongs to
+     * the signed-in learner. No token, and no request from the browser to Edpire,
+     * so the origin allow-list does not apply.
+     *
+     * @example
+     * const review = await fetch(`/api/attempts/${submissionId}/review`).then((r) => r.json())
+     * const view = EdpireAssessment.review({ review, container: "#paper" })
+     * view.unmount()
+     */
+    review(options: ReviewOptions): EmbedInstance;
 };
 
-export { EdpireAssessment, type EmbedError, type EmbedInstance, type EmbedResult, type ExerciseFeedbackData, type FlatStep, type MountOptions, type OverlayConfig, type QuestionInstance, type RenderQuestionOptions, type ShellLayout, type ShellLocale, type SpinnerTheme, type StoredAnswer, type SubmitResult, type TakeBranding, buildSubmitPayload, flattenAssessment, renderQuestion };
+export { EdpireAssessment, type EmbedError, type EmbedInstance, type EmbedResult, type ExerciseFeedbackData, type FlatStep, type MountOptions, type OverlayConfig, type QuestionInstance, type RenderQuestionOptions, type ReviewOptions, type ReviewStep, type ShellLayout, type ShellLocale, type SpinnerTheme, type StoredAnswer, type SubmissionReview, type SubmitResult, type TakeBranding, buildSubmitPayload, flattenAssessment, flattenReview, renderQuestion };